Merge branch 'master' into careminster

Conflicts:
	bin/HttpServer_OpenSim.dll

12 files changed, 4280 insertions, 2945 deletions

diff --git a/OpenSim/Framework/Servers/HttpServer/BaseHttpServer.cs b/OpenSim/Framework/Servers/HttpServer/BaseHttpServer.cs
index e3f2e7a..27af009 100644
--- a/OpenSim/Framework/Servers/HttpServer/BaseHttpServer.cs
+++ b/OpenSim/Framework/Servers/HttpServer/BaseHttpServer.cs
@@ -54,6 +54,16 @@ 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 
+        /// start the connection and optionally provide an origin authentication method.
+        /// </summary>
+        /// <param name="servicepath"></param>
+        /// <param name="handler"></param>
+        public delegate void WebSocketRequestDelegate(string servicepath, WebSocketHttpServerHandler handler);
+
         /// <summary>
         /// Gets or sets the debug level.
         /// </summary>
@@ -87,6 +97,9 @@ namespace OpenSim.Framework.Servers.HttpServer
         protected Dictionary<string, PollServiceEventArgs> m_pollHandlers =
             new Dictionary<string, PollServiceEventArgs>();
 
+        protected Dictionary<string, WebSocketRequestDelegate> m_WebSocketHandlers =
+            new Dictionary<string, WebSocketRequestDelegate>(); 
+
         protected uint m_port;
         protected uint m_sslport;
         protected bool m_ssl;
@@ -170,6 +183,22 @@ namespace OpenSim.Framework.Servers.HttpServer
             }
         }
 
+        public void AddWebSocketHandler(string servicepath, WebSocketRequestDelegate handler)
+        {
+            lock (m_WebSocketHandlers)
+            {
+                if (!m_WebSocketHandlers.ContainsKey(servicepath))
+                    m_WebSocketHandlers.Add(servicepath, handler);
+            }
+        }
+
+        public void RemoveWebSocketHandler(string servicepath)
+        {
+            lock (m_WebSocketHandlers)
+                if (m_WebSocketHandlers.ContainsKey(servicepath))
+                    m_WebSocketHandlers.Remove(servicepath);
+        }
+
         public List<string> GetStreamHandlerKeys()
         {
             lock (m_streamHandlers)
@@ -410,9 +439,24 @@ namespace OpenSim.Framework.Servers.HttpServer
 
         public void OnHandleRequestIOThread(IHttpClientContext context, IHttpRequest request)
         {
+
             OSHttpRequest req = new OSHttpRequest(context, request);
+            WebSocketRequestDelegate dWebSocketRequestDelegate = null;
+            lock (m_WebSocketHandlers)
+            {
+                if (m_WebSocketHandlers.ContainsKey(req.RawUrl))
+                    dWebSocketRequestDelegate = m_WebSocketHandlers[req.RawUrl];
+            }
+            if (dWebSocketRequestDelegate != null)
+            {
+                dWebSocketRequestDelegate(req.Url.AbsolutePath, new WebSocketHttpServerHandler(req, context, 8192));
+                return;
+            }
+            
             OSHttpResponse resp = new OSHttpResponse(new HttpResponse(context, request),context);
+            
             HandleRequest(req, resp);
+           
 
             // !!!HACK ALERT!!!
             // There seems to be a bug in the underlying http code that makes subsequent requests
@@ -501,7 +545,7 @@ namespace OpenSim.Framework.Servers.HttpServer
                         LogIncomingToStreamHandler(request, requestHandler);
 
                     response.ContentType = requestHandler.ContentType; // Lets do this defaulting before in case handler has varying content type.
-
+                    
                     if (requestHandler is IStreamedRequestHandler)
                     {
                         IStreamedRequestHandler streamedRequestHandler = requestHandler as IStreamedRequestHandler;
diff --git a/OpenSim/Framework/Servers/HttpServer/Interfaces/IHttpServer.cs b/OpenSim/Framework/Servers/HttpServer/Interfaces/IHttpServer.cs
index 13b5dd3..71ca3ff 100644
--- a/OpenSim/Framework/Servers/HttpServer/Interfaces/IHttpServer.cs
+++ b/OpenSim/Framework/Servers/HttpServer/Interfaces/IHttpServer.cs
@@ -98,7 +98,17 @@ namespace OpenSim.Framework.Servers.HttpServer
         bool AddXmlRPCHandler(string method, XmlRpcMethod handler, bool keepAlive);
 
         bool AddJsonRPCHandler(string method, JsonRPCMethod handler);
+        
+        /// <summary>
+        /// Websocket HTTP server handlers.
+        /// </summary>
+        /// <param name="servicepath"></param>
+        /// <param name="handler"></param>
+        void AddWebSocketHandler(string servicepath, BaseHttpServer.WebSocketRequestDelegate handler);
+
 
+        void RemoveWebSocketHandler(string servicepath);
+       
         /// <summary>
         /// Gets the XML RPC handler for given method name
         /// </summary>
diff --git a/OpenSim/Framework/Servers/HttpServer/WebsocketServerHandler.cs b/OpenSim/Framework/Servers/HttpServer/WebsocketServerHandler.cs
new file mode 100644
index 0000000..cfb1605
--- /dev/null
+++ b/OpenSim/Framework/Servers/HttpServer/WebsocketServerHandler.cs
@@ -0,0 +1,1085 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Security.Cryptography;
+using System.Text;
+using HttpServer;
+
+namespace OpenSim.Framework.Servers.HttpServer
+{
+    // Sealed class.  If you're going to unseal it, implement IDisposable.
+    /// <summary>
+    /// This class implements websockets.    It grabs the network context from C#Webserver and utilizes it directly as a tcp streaming service
+    /// </summary>
+    public sealed class WebSocketHttpServerHandler : BaseRequestHandler
+    {
+
+        private class WebSocketState
+        {
+            public List<byte> ReceivedBytes;
+            public int ExpectedBytes;
+            public WebsocketFrameHeader Header;
+            public bool FrameComplete;
+            public WebSocketFrame ContinuationFrame;
+        }
+
+        /// <summary>
+        /// Binary Data will trigger this event
+        /// </summary>
+        public event DataDelegate OnData;
+
+        /// <summary>
+        /// Textual Data will trigger this event
+        /// </summary>
+        public event TextDelegate OnText;
+
+        /// <summary>
+        /// A ping request form the other side will trigger this event.
+        /// This class responds to the ping automatically.  You shouldn't send a pong.
+        /// it's informational.
+        /// </summary>
+        public event PingDelegate OnPing;
+
+        /// <summary>
+        /// This is a response to a ping you sent.
+        /// </summary>
+        public event PongDelegate OnPong;
+
+        /// <summary>
+        /// This is a regular HTTP Request...    This may be removed in the future.   
+        /// </summary>
+        public event RegularHttpRequestDelegate OnRegularHttpRequest;
+
+        /// <summary>
+        /// When the upgrade from a HTTP request to a Websocket is completed, this will be fired
+        /// </summary>
+        public event UpgradeCompletedDelegate OnUpgradeCompleted;
+
+        /// <summary>
+        /// If the upgrade failed, this will be fired
+        /// </summary>
+        public event UpgradeFailedDelegate OnUpgradeFailed;
+
+        /// <summary>
+        /// When the websocket is closed, this will be fired.
+        /// </summary>
+        public event CloseDelegate OnClose;
+        
+        /// <summary>
+        /// Set this delegate to allow your module to validate the origin of the 
+        /// Websocket request.  Primary line of defense against cross site scripting
+        /// </summary>
+        public ValidateHandshake HandshakeValidateMethodOverride = null;
+
+        private OSHttpRequest _request;
+        private HTTPNetworkContext _networkContext;
+        private IHttpClientContext _clientContext;
+
+        private int _pingtime = 0;
+        private byte[] _buffer;
+        private int _bufferPosition;
+        private int _bufferLength;
+        private bool _closing;
+        private bool _upgraded;
+
+        private const string HandshakeAcceptText =
+            "HTTP/1.1 101 Switching Protocols\r\n" +
+            "upgrade: websocket\r\n" +
+            "Connection: Upgrade\r\n" +
+            "sec-websocket-accept: {0}\r\n\r\n";// +
+           //"{1}";
+
+        private const string HandshakeDeclineText =
+            "HTTP/1.1 {0} {1}\r\n" +
+            "Connection: close\r\n\r\n";
+
+        /// <summary>
+        /// Mysterious constant defined in RFC6455 to append to the client provided security key
+        /// </summary>
+        private const string WebsocketHandshakeAcceptHashConstant = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
+
+        public WebSocketHttpServerHandler(OSHttpRequest preq, IHttpClientContext pContext, int bufferlen)
+            : base(preq.HttpMethod, preq.Url.OriginalString)
+        {
+            _request = preq;
+            _networkContext = pContext.GiveMeTheNetworkStreamIKnowWhatImDoing();
+            _clientContext = pContext;
+            _bufferLength = bufferlen;
+            _buffer = new byte[_bufferLength];
+        }
+
+        // Sealed class implments destructor and an internal dispose method. complies with C# unmanaged resource best practices.
+        ~WebSocketHttpServerHandler()
+        {
+            Dispose();
+
+        }
+
+        /// <summary>
+        /// Sets the length of the stream buffer
+        /// </summary>
+        /// <param name="pChunk">Byte length.</param>
+        public void SetChunksize(int pChunk)
+        {
+            if (!_upgraded)
+            {
+                _buffer = new byte[pChunk];
+            }
+            else
+            {
+                throw new InvalidOperationException("You must set the chunksize before the connection is upgraded");
+            }
+        }
+
+        /// <summary>
+        /// This is the famous nagle.
+        /// </summary>
+        public bool NoDelay_TCP_Nagle
+        {
+            get
+            {
+                if (_networkContext != null && _networkContext.Socket != null)
+                {
+                    return _networkContext.Socket.NoDelay;
+                }
+                else
+                {
+                    throw new InvalidOperationException("The socket has been shutdown");
+                }
+            } 
+            set
+            {
+                if (_networkContext != null && _networkContext.Socket != null)
+                    _networkContext.Socket.NoDelay = value;
+                else
+                {
+                    throw new InvalidOperationException("The socket has been shutdown");
+                }
+            }
+        }
+
+        /// <summary>
+        /// This triggers the websocket to start the upgrade process...  
+        /// This is a Generalized Networking 'common sense' helper method.  Some people expect to call Start() instead 
+        /// of the more context appropriate HandshakeAndUpgrade()
+        /// </summary>
+        public void Start()
+        {
+            HandshakeAndUpgrade();
+        }
+
+        /// <summary>
+        /// This triggers the websocket start the upgrade process
+        /// </summary>
+        public void HandshakeAndUpgrade()
+        {
+            string webOrigin = string.Empty;
+            string websocketKey = string.Empty;
+            string acceptKey = string.Empty;
+            string accepthost = string.Empty;
+            if (!string.IsNullOrEmpty(_request.Headers["origin"]))
+                webOrigin = _request.Headers["origin"];
+
+            if (!string.IsNullOrEmpty(_request.Headers["sec-websocket-key"]))
+                websocketKey = _request.Headers["sec-websocket-key"];
+
+            if (!string.IsNullOrEmpty(_request.Headers["host"]))
+                accepthost = _request.Headers["host"];
+
+            if (string.IsNullOrEmpty(_request.Headers["upgrade"]))
+            {
+                FailUpgrade(OSHttpStatusCode.ClientErrorBadRequest, "no upgrade request submitted");
+            }
+
+            string connectionheader = _request.Headers["upgrade"];
+            if (connectionheader.ToLower() != "websocket")
+            {
+                FailUpgrade(OSHttpStatusCode.ClientErrorBadRequest, "no connection upgrade request submitted");
+            }
+
+            // If the object consumer provided a method to validate the origin, we should call it and give the client a success or fail.
+            // If not..  we should accept any.   The assumption here is that there would be no Websocket handlers registered in baseHTTPServer unless
+            // Something asked for it...
+            if (HandshakeValidateMethodOverride != null)
+            {
+                if (HandshakeValidateMethodOverride(webOrigin, websocketKey, accepthost))
+                {
+                    acceptKey = GenerateAcceptKey(websocketKey);
+                    string rawaccept = string.Format(HandshakeAcceptText, acceptKey);
+                    SendUpgradeSuccess(rawaccept);
+                    
+                }
+                else
+                {
+                    FailUpgrade(OSHttpStatusCode.ClientErrorForbidden, "Origin Validation Failed");
+                }
+            }
+            else
+            {
+                acceptKey = GenerateAcceptKey(websocketKey);
+                string rawaccept = string.Format(HandshakeAcceptText, acceptKey);
+                SendUpgradeSuccess(rawaccept);
+            }
+        }
+
+        /// <summary>
+        /// Generates a handshake response key string based on the client's 
+        /// provided key to prove to the client that we're allowing the Websocket
+        /// upgrade of our own free will and we were not coerced into doing it.
+        /// </summary>
+        /// <param name="key">Client provided security key</param>
+        /// <returns></returns>
+        private static string GenerateAcceptKey(string key)
+        {
+            if (string.IsNullOrEmpty(key))
+                return string.Empty;
+
+            string acceptkey = key + WebsocketHandshakeAcceptHashConstant;
+
+            SHA1 hashobj = SHA1.Create();
+            string ret = Convert.ToBase64String(hashobj.ComputeHash(Encoding.UTF8.GetBytes(acceptkey)));
+            hashobj.Clear();
+            
+            return ret;
+        }
+
+        /// <summary>
+        /// Informs the otherside that we accepted their upgrade request
+        /// </summary>
+        /// <param name="pHandshakeResponse">The HTTP 1.1 101 response that says Yay \o/ </param>
+        private void SendUpgradeSuccess(string pHandshakeResponse)
+        {
+            // Create a new websocket state so we can keep track of data in between network reads.
+            WebSocketState socketState = new WebSocketState() { ReceivedBytes = new List<byte>(), Header = WebsocketFrameHeader.HeaderDefault(), FrameComplete = true};
+            
+            byte[] bhandshakeResponse = Encoding.UTF8.GetBytes(pHandshakeResponse);
+            try
+            {
+                
+                // 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);
+                
+                // Write the upgrade handshake success message
+                _networkContext.Stream.Write(bhandshakeResponse, 0, bhandshakeResponse.Length);
+                _networkContext.Stream.Flush();
+                _upgraded = true;
+                UpgradeCompletedDelegate d = OnUpgradeCompleted;
+                if (d != null)
+                    d(this, new UpgradeCompletedEventArgs());
+            }
+            catch (IOException fail)
+            {
+                Close(string.Empty);
+            }
+            catch (ObjectDisposedException fail)
+            {
+                Close(string.Empty);
+            }
+            
+        }
+
+        /// <summary>
+        /// The server has decided not to allow the upgrade to a websocket for some reason.  The Http 1.1 response that says Nay >:(
+        /// </summary>
+        /// <param name="pCode">HTTP Status reflecting the reason why</param>
+        /// <param name="pMessage">Textual reason for the upgrade fail</param>
+        private void FailUpgrade(OSHttpStatusCode pCode, string pMessage )
+        {
+            string handshakeResponse = string.Format(HandshakeDeclineText, (int)pCode, pMessage.Replace("\n", string.Empty).Replace("\r", string.Empty));
+            byte[] bhandshakeResponse = Encoding.UTF8.GetBytes(handshakeResponse);
+            _networkContext.Stream.Write(bhandshakeResponse, 0, bhandshakeResponse.Length);
+            _networkContext.Stream.Flush();
+            _networkContext.Stream.Dispose();
+
+            UpgradeFailedDelegate d = OnUpgradeFailed;
+            if (d != null)
+                d(this,new UpgradeFailedEventArgs());
+        }
+
+
+        /// <summary>
+        /// This is our ugly Async OnReceive event handler.
+        /// This chunks the input stream based on the length of the provided buffer and processes out 
+        /// as many frames as it can.   It then moves the unprocessed data to the beginning of the buffer.
+        /// </summary>
+        /// <param name="ar">Our Async State from beginread</param>
+        private void OnReceive(IAsyncResult ar)
+        {
+            WebSocketState _socketState = ar.AsyncState as WebSocketState;
+            try
+            {
+                int bytesRead = _networkContext.Stream.EndRead(ar);
+                if (bytesRead == 0)
+                {
+                    // Do Disconnect
+                    _networkContext.Stream.Dispose();
+                    _networkContext = null;
+                    return;
+                }
+                _bufferPosition += bytesRead;
+
+                if (_bufferPosition > _bufferLength)
+                {
+                    // Message too big for chunksize..   not sure how this happened...  
+                    //Close(string.Empty);
+                }
+
+                int offset = 0;
+                bool headerread = true;
+                int headerforwardposition = 0;
+                while (headerread && offset < bytesRead)
+                {
+                    if (_socketState.FrameComplete)
+                    {
+                        WebsocketFrameHeader pheader = WebsocketFrameHeader.ZeroHeader;
+
+                        headerread = WebSocketReader.TryReadHeader(_buffer, offset, _bufferPosition - offset, out pheader,
+                                                                   out headerforwardposition);
+                        offset += headerforwardposition;
+
+                        if (headerread)
+                        {
+                            _socketState.FrameComplete = false;
+
+                            if (pheader.PayloadLen > 0)
+                            {
+                                if ((int) pheader.PayloadLen > _bufferPosition - offset)
+                                {
+                                    byte[] writebytes = new byte[_bufferPosition - offset];
+
+                                    Buffer.BlockCopy(_buffer, offset, writebytes, 0, (int) _bufferPosition - offset);
+                                    _socketState.ExpectedBytes = (int) pheader.PayloadLen;
+                                    _socketState.ReceivedBytes.AddRange(writebytes);
+                                    _socketState.Header = pheader; // We need to add the header so that we can unmask it
+                                    offset += (int) _bufferPosition - offset;
+                                }
+                                else
+                                {
+                                    byte[] writebytes = new byte[pheader.PayloadLen];
+                                    Buffer.BlockCopy(_buffer, offset, writebytes, 0, (int) pheader.PayloadLen);
+                                    WebSocketReader.Mask(pheader.Mask, writebytes);
+                                    pheader.IsMasked = false;
+                                    _socketState.FrameComplete = true;
+                                    _socketState.ReceivedBytes.AddRange(writebytes);
+                                    _socketState.Header = pheader;
+                                    offset += (int) pheader.PayloadLen;
+                                }
+                            }
+                            else
+                            {
+                                pheader.Mask = 0;
+                                _socketState.FrameComplete = true;
+                                _socketState.Header = pheader;
+                            }
+
+
+
+                            if (_socketState.FrameComplete)
+                            {
+                                ProcessFrame(_socketState);
+                                _socketState.Header.SetDefault();
+                                _socketState.ReceivedBytes.Clear();
+                                _socketState.ExpectedBytes = 0;
+
+                            }
+
+                        }
+                    }
+                    else
+                    {
+                        WebsocketFrameHeader frameHeader = _socketState.Header;
+                        int bytesleft = _socketState.ExpectedBytes - _socketState.ReceivedBytes.Count;
+
+                        if (bytesleft > _bufferPosition)
+                        {
+                            byte[] writebytes = new byte[_bufferPosition];
+
+                            Buffer.BlockCopy(_buffer, offset, writebytes, 0, (int) _bufferPosition);
+                            _socketState.ReceivedBytes.AddRange(writebytes);
+                            _socketState.Header = frameHeader; // We need to add the header so that we can unmask it
+                            offset += (int) _bufferPosition;
+                        }
+                        else
+                        {
+                            byte[] writebytes = new byte[_bufferPosition];
+                            Buffer.BlockCopy(_buffer, offset, writebytes, 0, (int) _bufferPosition);
+                            _socketState.FrameComplete = true;
+                            _socketState.ReceivedBytes.AddRange(writebytes);
+                            _socketState.Header = frameHeader;
+                            offset += (int) _bufferPosition;
+                        }
+                        if (_socketState.FrameComplete)
+                        {
+                            ProcessFrame(_socketState);
+                            _socketState.Header.SetDefault();
+                            _socketState.ReceivedBytes.Clear();
+                            _socketState.ExpectedBytes = 0;
+                            // do some processing
+                        }
+
+                    }
+                }
+                if (offset > 0)
+                {
+                    // If the buffer is maxed out..  we can just move the cursor.   Nothing to move to the beginning.
+                    if (offset <_buffer.Length)
+                        Buffer.BlockCopy(_buffer, offset, _buffer, 0, _bufferPosition - offset);
+                    _bufferPosition -= offset;
+                }
+                if (_networkContext.Stream != null && _networkContext.Stream.CanRead && !_closing)
+                {
+                    _networkContext.Stream.BeginRead(_buffer, _bufferPosition, _bufferLength - _bufferPosition, OnReceive,
+                                                    _socketState);
+                }
+                else
+                {
+                    // We can't read the stream anymore...  
+                }
+
+            }
+            catch (IOException fail)
+            {
+                Close(string.Empty);
+            }
+            catch (ObjectDisposedException fail)
+            {
+                Close(string.Empty);
+            }
+        }
+
+        /// <summary>
+        /// Sends a string to the other side
+        /// </summary>
+        /// <param name="message">the string message that is to be sent</param>
+        public void SendMessage(string message)
+        {
+            byte[] messagedata = Encoding.UTF8.GetBytes(message);
+            WebSocketFrame textMessageFrame = new WebSocketFrame() { Header = WebsocketFrameHeader.HeaderDefault(), WebSocketPayload = messagedata };
+            textMessageFrame.Header.Opcode = WebSocketReader.OpCode.Text;
+            textMessageFrame.Header.IsEnd = true;
+            SendSocket(textMessageFrame.ToBytes());
+            
+        }
+
+        public void SendData(byte[] data)
+        {
+            WebSocketFrame dataMessageFrame = new WebSocketFrame() { Header = WebsocketFrameHeader.HeaderDefault(), WebSocketPayload = data};
+            dataMessageFrame.Header.IsEnd = true;
+            dataMessageFrame.Header.Opcode = WebSocketReader.OpCode.Binary;
+            SendSocket(dataMessageFrame.ToBytes());
+
+        }
+
+        /// <summary>
+        /// Writes raw bytes to the websocket.   Unframed data will cause disconnection
+        /// </summary>
+        /// <param name="data"></param>
+        private void SendSocket(byte[] data)
+        {
+            if (!_closing)
+            {
+                try
+                {
+
+                    _networkContext.Stream.Write(data, 0, data.Length);
+                }
+                catch (IOException)
+                {
+
+                }
+            }
+        }
+
+        /// <summary>
+        /// Sends a Ping check to the other side.  The other side SHOULD respond as soon as possible with a pong frame.   This interleaves with incoming fragmented frames.
+        /// </summary>
+        public void SendPingCheck()
+        {
+            WebSocketFrame pingFrame = new WebSocketFrame() { Header = WebsocketFrameHeader.HeaderDefault(), WebSocketPayload = new byte[0] };
+            pingFrame.Header.Opcode = WebSocketReader.OpCode.Ping;
+            pingFrame.Header.IsEnd = true;
+            _pingtime = Util.EnvironmentTickCount();
+            SendSocket(pingFrame.ToBytes());
+        }
+
+        /// <summary>
+        /// Closes the websocket connection.   Sends a close message to the other side if it hasn't already done so.
+        /// </summary>
+        /// <param name="message"></param>
+        public void Close(string message)
+        {
+            if (_networkContext.Stream != null)
+            {
+                if (_networkContext.Stream.CanWrite)
+            {
+                byte[] messagedata = Encoding.UTF8.GetBytes(message);
+                WebSocketFrame closeResponseFrame = new WebSocketFrame()
+                                                        {
+                                                            Header = WebsocketFrameHeader.HeaderDefault(),
+                                                            WebSocketPayload = messagedata
+                                                        };
+                closeResponseFrame.Header.Opcode = WebSocketReader.OpCode.Close;
+                closeResponseFrame.Header.PayloadLen = (ulong) messagedata.Length;
+                closeResponseFrame.Header.IsEnd = true;
+                SendSocket(closeResponseFrame.ToBytes());
+            }
+                }
+            CloseDelegate closeD = OnClose;
+            if (closeD != null)
+            {
+                closeD(this, new CloseEventArgs());
+            }
+
+            _closing = true;
+        }
+
+        /// <summary>
+        /// Processes a websocket frame and triggers consumer events
+        /// </summary>
+        /// <param name="psocketState">We need to modify the websocket state here depending on the frame</param>
+        private void ProcessFrame(WebSocketState psocketState)
+        {
+            if (psocketState.Header.IsMasked)
+            {
+                byte[] unmask = psocketState.ReceivedBytes.ToArray();
+                WebSocketReader.Mask(psocketState.Header.Mask, unmask);
+                psocketState.ReceivedBytes = new List<byte>(unmask);
+            }
+            
+            switch (psocketState.Header.Opcode)
+            {
+                case WebSocketReader.OpCode.Ping:
+                    PingDelegate pingD = OnPing;
+                    if (pingD != null)
+                    {
+                        pingD(this, new PingEventArgs());
+                    }
+
+                    WebSocketFrame pongFrame = new WebSocketFrame(){Header = WebsocketFrameHeader.HeaderDefault(),WebSocketPayload = new byte[0]};
+                    pongFrame.Header.Opcode = WebSocketReader.OpCode.Pong;
+                    pongFrame.Header.IsEnd = true;
+                    SendSocket(pongFrame.ToBytes());
+                    break;
+                case WebSocketReader.OpCode.Pong:
+                 
+                    PongDelegate pongD = OnPong;
+                    if (pongD != null)
+                    {
+                        pongD(this, new PongEventArgs(){PingResponseMS = Util.EnvironmentTickCountSubtract(Util.EnvironmentTickCount(),_pingtime)});
+                    }
+                    break;
+                case WebSocketReader.OpCode.Binary:
+                    if (!psocketState.Header.IsEnd) // Not done, so we need to store this and wait for the end frame.
+                    {
+                        psocketState.ContinuationFrame = new WebSocketFrame
+                                                             {
+                                                                 Header = psocketState.Header,
+                                                                 WebSocketPayload =
+                                                                     psocketState.ReceivedBytes.ToArray()
+                                                             };
+                    }
+                    else
+                    {
+                        // Send Done Event!
+                        DataDelegate dataD = OnData;
+                        if (dataD != null)
+                        {
+                            dataD(this,new WebsocketDataEventArgs(){Data = psocketState.ReceivedBytes.ToArray()});
+                        }
+                    }
+                    break;
+                case WebSocketReader.OpCode.Text:
+                    if (!psocketState.Header.IsEnd) // Not done, so we need to store this and wait for the end frame.
+                    {
+                        psocketState.ContinuationFrame = new WebSocketFrame
+                                                             {
+                                                                 Header = psocketState.Header,
+                                                                 WebSocketPayload =
+                                                                     psocketState.ReceivedBytes.ToArray()
+                                                             };
+                    }
+                    else
+                    {
+                        TextDelegate textD = OnText;
+                        if (textD != null)
+                        {
+                            textD(this, new WebsocketTextEventArgs() { Data = Encoding.UTF8.GetString(psocketState.ReceivedBytes.ToArray()) });
+                        }
+                        
+                        // Send Done Event!
+                    }
+                    break;
+                case WebSocketReader.OpCode.Continue:  // Continuation.  Multiple frames worth of data for one message.   Only valid when not using Control Opcodes
+                    //Console.WriteLine("currhead " + psocketState.Header.IsEnd);
+                    //Console.WriteLine("Continuation! " + psocketState.ContinuationFrame.Header.IsEnd);
+                    byte[] combineddata = new byte[psocketState.ReceivedBytes.Count+psocketState.ContinuationFrame.WebSocketPayload.Length];
+                    byte[] newdata = psocketState.ReceivedBytes.ToArray();
+                    Buffer.BlockCopy(psocketState.ContinuationFrame.WebSocketPayload, 0, combineddata, 0, psocketState.ContinuationFrame.WebSocketPayload.Length);
+                    Buffer.BlockCopy(newdata, 0, combineddata,
+                                        psocketState.ContinuationFrame.WebSocketPayload.Length, newdata.Length);
+                    psocketState.ContinuationFrame.WebSocketPayload = combineddata;
+                    psocketState.Header.PayloadLen = (ulong)combineddata.Length;
+                    if (psocketState.Header.IsEnd)
+                    {
+                        if (psocketState.ContinuationFrame.Header.Opcode == WebSocketReader.OpCode.Text)
+                        {
+                            // Send Done event    
+                            TextDelegate textD = OnText;
+                            if (textD != null)
+                            {
+                                textD(this, new WebsocketTextEventArgs() { Data = Encoding.UTF8.GetString(combineddata) });
+                            }
+                        }
+                        else if (psocketState.ContinuationFrame.Header.Opcode == WebSocketReader.OpCode.Binary)
+                        {
+                            // Send Done event
+                            DataDelegate dataD = OnData;
+                            if (dataD != null)
+                            {
+                                dataD(this, new WebsocketDataEventArgs() { Data = combineddata });
+                            }
+                        }
+                        else
+                        {
+                            // protocol violation
+                        }
+                        psocketState.ContinuationFrame = null;
+                    }
+                    break;
+                case WebSocketReader.OpCode.Close:
+                    Close(string.Empty);
+                    
+                    break;
+               
+            }
+            psocketState.Header.SetDefault();
+            psocketState.ReceivedBytes.Clear();
+            psocketState.ExpectedBytes = 0;
+        }
+        public void Dispose()
+        {
+            if (_networkContext != null && _networkContext.Stream != null)
+            {
+                if (_networkContext.Stream.CanWrite)
+                    _networkContext.Stream.Flush();
+                _networkContext.Stream.Close();
+                _networkContext.Stream.Dispose();
+                _networkContext.Stream = null;
+            }
+
+            if (_request != null && _request.InputStream != null)
+            {
+                _request.InputStream.Close();
+                _request.InputStream.Dispose();
+                _request = null;
+            }
+
+            if (_clientContext != null)
+            {
+                _clientContext.Close();
+                _clientContext = null;
+            }
+        }
+    }
+
+    /// <summary>
+    /// Reads a byte stream and returns Websocket frames.
+    /// </summary>
+    public class WebSocketReader
+    {
+        /// <summary>
+        /// Bit to determine if the frame read on the stream is the last frame in a sequence of fragmented frames
+        /// </summary>
+        private const byte EndBit = 0x80;
+
+        /// <summary>
+        /// These are the Frame Opcodes
+        /// </summary>
+        public enum OpCode
+        {
+            // Data Opcodes
+            Continue = 0x0,
+            Text = 0x1,
+            Binary = 0x2,
+
+            // Control flow Opcodes
+            Close = 0x8,
+            Ping = 0x9,
+            Pong = 0xA
+        }
+
+        /// <summary>
+        /// Masks and Unmasks data using the frame mask.  Mask is applied per octal
+        /// Note: Frames from clients MUST be masked
+        /// Note: Frames from servers MUST NOT be masked
+        /// </summary>
+        /// <param name="pMask">Int representing 32 bytes of mask data.  Mask is applied per octal</param>
+        /// <param name="pBuffer"></param>
+        public static void Mask(int pMask, byte[] pBuffer)
+        {
+            byte[] maskKey = BitConverter.GetBytes(pMask);
+            int currentMaskIndex = 0;
+            for (int i = 0; i < pBuffer.Length; i++)
+            {
+                pBuffer[i] = (byte)(pBuffer[i] ^ maskKey[currentMaskIndex]);
+                if (currentMaskIndex == 3)
+                {
+                    currentMaskIndex = 0;
+                }
+                else
+                {
+                    currentMaskIndex++;
+
+                }
+
+            }
+        }
+
+        /// <summary>
+        /// Attempts to read a header off the provided buffer.  Returns true, exports a WebSocketFrameheader, 
+        /// and an int to move the buffer forward when it reads a header.  False when it can't read a header
+        /// </summary>
+        /// <param name="pBuffer">Bytes read from the stream</param>
+        /// <param name="pOffset">Starting place in the stream to begin trying to read from</param>
+        /// <param name="length">Lenth in the stream to try and read from.  Provided for cases where the 
+        /// buffer's length is larger then the data in it</param>
+        /// <param name="oHeader">Outputs the read WebSocket frame header</param>
+        /// <param name="moveBuffer">Informs the calling stream to move the buffer forward</param>
+        /// <returns>True if it got a header, False if it didn't get a header</returns>
+        public static bool TryReadHeader(byte[] pBuffer, int pOffset, int length, out WebsocketFrameHeader oHeader,
+                                         out int moveBuffer)
+        {
+            oHeader = WebsocketFrameHeader.ZeroHeader;
+            int minumheadersize = 2;
+            if (length > pBuffer.Length - pOffset)
+                throw new ArgumentOutOfRangeException("The Length specified was larger the byte array supplied");
+            if (length < minumheadersize)
+            {
+                moveBuffer = 0;
+                return false;
+            }
+
+            byte nibble1 = (byte)(pBuffer[pOffset] & 0xF0);  //FIN/RSV1/RSV2/RSV3
+            byte nibble2 = (byte)(pBuffer[pOffset] & 0x0F); // Opcode block
+
+            oHeader = new WebsocketFrameHeader();
+            oHeader.SetDefault();
+
+            if ((nibble1 & WebSocketReader.EndBit) == WebSocketReader.EndBit)
+            {
+                oHeader.IsEnd = true;
+            }
+            else
+            {
+                oHeader.IsEnd = false;
+            }
+            //Opcode
+            oHeader.Opcode = (WebSocketReader.OpCode)nibble2;
+            //Mask
+            oHeader.IsMasked = Convert.ToBoolean((pBuffer[pOffset + 1] & 0x80) >> 7);
+
+            // Payload length
+            oHeader.PayloadLen = (byte)(pBuffer[pOffset + 1] & 0x7F);
+
+            int index = 2; // LargerPayload length starts at byte 3
+
+            switch (oHeader.PayloadLen)
+            {
+                case 126:
+                    minumheadersize += 2;
+                    if (length < minumheadersize)
+                    {
+                        moveBuffer = 0;
+                        return false;
+                    }
+                    Array.Reverse(pBuffer, pOffset + index, 2);  // two bytes
+                    oHeader.PayloadLen = BitConverter.ToUInt16(pBuffer, pOffset + index);
+                    index += 2;
+                    break;
+                case 127:   // we got more this is a bigger frame  
+                    // 8 bytes - uint64 - most significant bit 0  network byte order
+                    minumheadersize += 8;
+                    if (length < minumheadersize)
+                    {
+                        moveBuffer = 0;
+                        return false;
+                    }
+                    Array.Reverse(pBuffer, pOffset + index, 8);
+                    oHeader.PayloadLen = BitConverter.ToUInt64(pBuffer, pOffset + index);
+                    index += 8;
+                    break;
+                
+            }
+            //oHeader.PayloadLeft = oHeader.PayloadLen; // Start the count in case it's chunked over the network.  This is different then frame fragmentation
+            if (oHeader.IsMasked)
+            {
+                minumheadersize += 4;
+                if (length < minumheadersize)
+                {
+                    moveBuffer = 0;
+                    return false;
+                }
+                oHeader.Mask = BitConverter.ToInt32(pBuffer, pOffset + index);
+                index += 4;
+            }
+            moveBuffer = index;
+            return true;
+
+        }
+    }
+
+    /// <summary>
+    /// RFC6455 Websocket Frame
+    /// </summary>
+    public class WebSocketFrame
+    {
+        /*
+         * RFC6455
+nib   0       1       2       3       4       5       6       7
+byt   0               1               2               3               
+dec   0                   1                   2                   3   
+      0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 
+     +-+-+-+-+-------+-+-------------+-------------------------------+
+     |F|R|R|R| opcode|M| Payload len |    Extended payload length    |
+     |I|S|S|S|  (4)  |A|     (7)     |             (16/64)           +
+     |N|V|V|V|       |S|             |   (if payload len==126/127)   |
+     | |1|2|3|       |K|             |                               +
+     +-+-+-+-+-------+-+-------------+ - - - - - - - - - - - - - - - +
+     |     Extended payload length continued, if payload len == 127  |
+     + - - - - - - - - - - - - - - - +-------------------------------+
+     |                               |Masking-key, if MASK set to 1  |
+     +-------------------------------+-------------------------------+
+     | Masking-key (continued)       |          Payload Data         |
+     +-------------------------------- - - - - - - - - - - - - - - - +
+     :                     Payload Data continued ...                :
+     + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +
+     |                     Payload Data continued ...                |
+     +---------------------------------------------------------------+
+
+         *   When reading these, the frames are possibly fragmented and interleaved with control frames
+         *   the fragmented frames are not interleaved with data frames.  Just control frames
+         */
+        public static readonly WebSocketFrame DefaultFrame = new WebSocketFrame(){Header = new WebsocketFrameHeader(),WebSocketPayload = new byte[0]};
+        public WebsocketFrameHeader Header;
+        public byte[] WebSocketPayload;
+        
+        public byte[] ToBytes()
+        {
+            Header.PayloadLen = (ulong)WebSocketPayload.Length;
+            return Header.ToBytes(WebSocketPayload);
+        }
+
+    }
+
+    public struct WebsocketFrameHeader
+    {
+        //public byte CurrentMaskIndex;
+        /// <summary>
+        /// The last frame in a sequence of fragmented frames or the one and only frame for this message.
+        /// </summary>
+        public bool IsEnd;
+
+        /// <summary>
+        /// Returns whether the payload data is masked or not.  Data from Clients MUST be masked, Data from Servers MUST NOT be masked
+        /// </summary>
+        public bool IsMasked;
+
+        /// <summary>
+        /// A set of cryptologically sound random bytes XoR-ed against the payload octally.  Looped
+        /// </summary>
+        public int Mask;
+        /*
+byt   0               1               2               3
+      0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 
+     +---------------+---------------+---------------+---------------+
+     |    Octal 1    |    Octal 2    |    Octal 3    |    Octal 4    |
+     +---------------+---------------+---------------+---------------+
+*/
+
+
+        public WebSocketReader.OpCode Opcode;
+
+        public UInt64 PayloadLen;
+        //public UInt64 PayloadLeft;
+        // Payload is X + Y   
+        //public UInt64 ExtensionDataLength;
+        //public UInt64 ApplicationDataLength;
+        public static readonly WebsocketFrameHeader ZeroHeader = WebsocketFrameHeader.HeaderDefault();
+       
+        public void SetDefault()
+        {
+
+            //CurrentMaskIndex = 0;
+            IsEnd = true;
+            IsMasked = true;
+            Mask = 0;
+            Opcode = WebSocketReader.OpCode.Close;
+  //        PayloadLeft = 0;
+            PayloadLen = 0;
+  //        ExtensionDataLength = 0;
+  //        ApplicationDataLength = 0;
+
+        }
+
+        /// <summary>
+        /// Returns a byte array representing the Frame header
+        /// </summary>
+        /// <param name="payload">This is the frame data payload.  The header describes the size of the payload. 
+        /// If payload is null, a Zero sized payload is assumed</param>
+        /// <returns>Returns a byte array representing the frame header</returns>
+        public byte[] ToBytes(byte[] payload)
+        {
+            List<byte> result = new List<byte>();
+           
+            // Squeeze in our opcode and our ending bit.
+            result.Add((byte)((byte)Opcode | (IsEnd?0x80:0x00) ));
+           
+            // Again with the three different byte interpretations of size..
+
+            //bytesize
+            if (PayloadLen <= 125)
+            {
+                result.Add((byte) PayloadLen);
+            } //Uint16
+            else if (PayloadLen <= ushort.MaxValue)
+            {
+                result.Add(126);
+                byte[] payloadLengthByte = BitConverter.GetBytes(Convert.ToUInt16(PayloadLen));
+                Array.Reverse(payloadLengthByte);
+                result.AddRange(payloadLengthByte);
+            } //UInt64
+            else
+            {
+                result.Add(127);
+                byte[] payloadLengthByte = BitConverter.GetBytes(PayloadLen);
+                Array.Reverse(payloadLengthByte);
+                result.AddRange(payloadLengthByte);
+            }
+            
+            // Only add a payload if it's not null
+            if (payload != null)
+            {
+                result.AddRange(payload);
+            }
+            return result.ToArray();
+        }
+
+        /// <summary>
+        /// A Helper method to define the defaults
+        /// </summary>
+        /// <returns></returns>
+
+        public static WebsocketFrameHeader HeaderDefault()
+        {
+            return new WebsocketFrameHeader
+                       {
+                           //CurrentMaskIndex = 0,
+                           IsEnd = false,
+                           IsMasked = true,
+                           Mask = 0,
+                           Opcode = WebSocketReader.OpCode.Close,
+                           //PayloadLeft = 0,
+                           PayloadLen = 0,
+ //                          ExtensionDataLength = 0,
+ //                          ApplicationDataLength = 0
+                       };
+        }
+    }
+
+    public delegate void DataDelegate(object sender, WebsocketDataEventArgs data);
+
+    public delegate void TextDelegate(object sender, WebsocketTextEventArgs text);
+
+    public delegate void PingDelegate(object sender, PingEventArgs pingdata);
+
+    public delegate void PongDelegate(object sender, PongEventArgs pongdata);
+
+    public delegate void RegularHttpRequestDelegate(object sender, RegularHttpRequestEvnetArgs request);
+
+    public delegate void UpgradeCompletedDelegate(object sender, UpgradeCompletedEventArgs completeddata);
+
+    public delegate void UpgradeFailedDelegate(object sender, UpgradeFailedEventArgs faileddata);
+
+    public delegate void CloseDelegate(object sender, CloseEventArgs closedata);
+
+    public delegate bool ValidateHandshake(string pWebOrigin, string pWebSocketKey, string pHost);
+
+
+    public class WebsocketDataEventArgs : EventArgs
+    {
+        public byte[] Data;
+    }
+
+    public class WebsocketTextEventArgs : EventArgs
+    {
+        public string Data;
+    }
+
+    public class PingEventArgs : EventArgs
+    {
+        /// <summary>
+        /// The ping event can arbitrarily contain data
+        /// </summary>
+        public byte[] Data;
+    }
+
+    public class PongEventArgs : EventArgs
+    {
+        /// <summary>
+        /// The pong event can arbitrarily contain data
+        /// </summary>
+        public byte[] Data;
+
+        public int PingResponseMS;
+
+    }
+
+    public class RegularHttpRequestEvnetArgs : EventArgs
+    {
+
+    }
+
+    public class UpgradeCompletedEventArgs : EventArgs
+    {
+
+    }
+
+    public class UpgradeFailedEventArgs : EventArgs
+    {
+
+    }
+
+    public class CloseEventArgs : EventArgs
+    {
+
+    }
+
+   
+}
diff --git a/OpenSim/Framework/Servers/Tests/OSHttpTests.cs b/OpenSim/Framework/Servers/Tests/OSHttpTests.cs
index 50f306e..deae45c 100644
--- a/OpenSim/Framework/Servers/Tests/OSHttpTests.cs
+++ b/OpenSim/Framework/Servers/Tests/OSHttpTests.cs
@@ -70,6 +70,11 @@ namespace OpenSim.Framework.Servers.Tests
             public void Close() { }
             public bool EndWhenDone { get { return false;} set { return;}}
 
+            public HTTPNetworkContext GiveMeTheNetworkStreamIKnowWhatImDoing()
+            {
+                return new HTTPNetworkContext();
+            }
+
             public event EventHandler<DisconnectedEventArgs> Disconnected = delegate { };
             /// <summary>
             /// A request have been received in the context.
diff --git a/OpenSim/Region/OptionalModules/Example/WebSocketEchoTest/WebSocketEchoModule.cs b/OpenSim/Region/OptionalModules/Example/WebSocketEchoTest/WebSocketEchoModule.cs
new file mode 100644
index 0000000..112ba4e
--- /dev/null
+++ b/OpenSim/Region/OptionalModules/Example/WebSocketEchoTest/WebSocketEchoModule.cs
@@ -0,0 +1,174 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using OpenSim.Framework.Servers;
+using Mono.Addins;
+using log4net;
+using Nini.Config;
+using OpenSim.Region.Framework.Interfaces;
+using OpenSim.Region.Framework.Scenes;
+
+using OpenSim.Framework.Servers.HttpServer;
+
+
+namespace OpenSim.Region.OptionalModules.WebSocketEchoModule
+{
+    
+    [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule", Id = "WebSocketEchoModule")]
+    public class WebSocketEchoModule : ISharedRegionModule
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        private bool enabled;
+        public string Name { get { return "WebSocketEchoModule"; } }
+
+        public Type ReplaceableInterface { get { return null; } }
+
+
+        private HashSet<WebSocketHttpServerHandler> _activeHandlers = new HashSet<WebSocketHttpServerHandler>();
+
+        public void Initialise(IConfigSource pConfig)
+        {
+            enabled =(pConfig.Configs["WebSocketEcho"] != null);
+            if (enabled)
+                m_log.DebugFormat("[WebSocketEchoModule]: INITIALIZED MODULE");
+        }
+
+        /// <summary>
+        /// This method sets up the callback to WebSocketHandlerCallback below when a HTTPRequest comes in for /echo
+        /// </summary>
+        public void PostInitialise()
+        {
+            if (enabled)
+                MainServer.Instance.AddWebSocketHandler("/echo", WebSocketHandlerCallback);
+        }
+
+        // This gets called by BaseHttpServer and gives us an opportunity to set things on the WebSocket handler before we turn it on
+        public void WebSocketHandlerCallback(string path, WebSocketHttpServerHandler handler)
+        {
+            SubscribeToEvents(handler);
+            handler.SetChunksize(8192);
+            handler.NoDelay_TCP_Nagle = true;
+            handler.HandshakeAndUpgrade();
+        }
+
+        //These are our normal events
+        public void SubscribeToEvents(WebSocketHttpServerHandler handler)
+        {
+            handler.OnClose += HandlerOnOnClose;
+            handler.OnText += HandlerOnOnText;
+            handler.OnUpgradeCompleted += HandlerOnOnUpgradeCompleted;
+            handler.OnData += HandlerOnOnData;
+            handler.OnPong += HandlerOnOnPong;
+        }
+
+        public void UnSubscribeToEvents(WebSocketHttpServerHandler handler)
+        {
+            handler.OnClose -= HandlerOnOnClose;
+            handler.OnText -= HandlerOnOnText;
+            handler.OnUpgradeCompleted -= HandlerOnOnUpgradeCompleted;
+            handler.OnData -= HandlerOnOnData;
+            handler.OnPong -= HandlerOnOnPong;
+        }
+
+        private void HandlerOnOnPong(object sender, PongEventArgs pongdata)
+        {
+            m_log.Info("[WebSocketEchoModule]: Got a pong..  ping time: " + pongdata.PingResponseMS);
+        }
+
+        private void HandlerOnOnData(object sender, WebsocketDataEventArgs data)
+        {
+            WebSocketHttpServerHandler obj = sender as WebSocketHttpServerHandler;
+            obj.SendData(data.Data);
+            m_log.Info("[WebSocketEchoModule]: We received a bunch of ugly non-printable bytes");
+            obj.SendPingCheck();
+        }
+
+        
+        private void HandlerOnOnUpgradeCompleted(object sender, UpgradeCompletedEventArgs completeddata)
+        {
+            WebSocketHttpServerHandler obj = sender as WebSocketHttpServerHandler;
+            _activeHandlers.Add(obj);
+        }
+
+        private void HandlerOnOnText(object sender, WebsocketTextEventArgs text)
+        {
+            WebSocketHttpServerHandler obj = sender as WebSocketHttpServerHandler;
+            obj.SendMessage(text.Data);
+            m_log.Info("[WebSocketEchoModule]: We received this: " + text.Data);
+        }
+
+        // Remove the references to our handler
+        private void HandlerOnOnClose(object sender, CloseEventArgs closedata)
+        {
+            WebSocketHttpServerHandler obj = sender as WebSocketHttpServerHandler;
+            UnSubscribeToEvents(obj);
+
+            lock (_activeHandlers)
+                _activeHandlers.Remove(obj);
+            obj.Dispose();
+        }
+
+        // Shutting down..  so shut down all sockets.   
+        // Note..    this should be done outside of an ienumerable if you're also hook to the close event.
+        public void Close()
+        {
+            if (!enabled)
+                return;
+        
+            // We convert this to a for loop so we're not in in an IEnumerable when the close 
+            //call triggers an event which then removes item from _activeHandlers that we're enumerating
+            WebSocketHttpServerHandler[] items = new WebSocketHttpServerHandler[_activeHandlers.Count];
+            _activeHandlers.CopyTo(items);
+
+            for (int i = 0; i < items.Length; i++)
+            {
+                items[i].Close(string.Empty);
+                items[i].Dispose();
+            }
+            _activeHandlers.Clear();
+            MainServer.Instance.RemoveWebSocketHandler("/echo");
+        }
+
+        public void AddRegion(Scene scene)
+        {
+            m_log.DebugFormat("[WebSocketEchoModule]: REGION {0} ADDED", scene.RegionInfo.RegionName);
+        }
+
+        public void RemoveRegion(Scene scene)
+        {
+            m_log.DebugFormat("[WebSocketEchoModule]: REGION {0} REMOVED", scene.RegionInfo.RegionName);
+        }
+
+        public void RegionLoaded(Scene scene)
+        {
+            m_log.DebugFormat("[WebSocketEchoModule]: REGION {0} LOADED", scene.RegionInfo.RegionName);
+        }
+    }
+}
\ No newline at end of file
diff --git a/OpenSim/Region/OptionalModules/PhysicsParameters/PhysicsParameters.cs b/OpenSim/Region/OptionalModules/PhysicsParameters/PhysicsParameters.cs
index 40f7fbc..3083a33 100755
--- a/OpenSim/Region/OptionalModules/PhysicsParameters/PhysicsParameters.cs
+++ b/OpenSim/Region/OptionalModules/PhysicsParameters/PhysicsParameters.cs
@@ -146,7 +146,7 @@ namespace OpenSim.Region.OptionalModules.PhysicsParameters
                 {
                     foreach (PhysParameterEntry ppe in physScene.GetParameterList())
                     {
-                        float val = 0.0f;
+                        string val = string.Empty;
                         if (physScene.GetPhysicsParameter(ppe.name, out val))
                         {
                             WriteOut("  {0}/{1} = {2}", scene.RegionInfo.RegionName, ppe.name, val);
@@ -159,7 +159,7 @@ namespace OpenSim.Region.OptionalModules.PhysicsParameters
                 }
                 else
                 {
-                    float val = 0.0f;
+                    string val = string.Empty;
                     if (physScene.GetPhysicsParameter(parm, out val))
                     {
                         WriteOut("  {0}/{1} = {2}", scene.RegionInfo.RegionName, parm, val);
@@ -185,21 +185,12 @@ namespace OpenSim.Region.OptionalModules.PhysicsParameters
                 return;
             }
             string parm = "xxx";
-            float val = 0f;
+            string valparm = String.Empty;
             uint localID = (uint)PhysParameterEntry.APPLY_TO_NONE;  // set default value
             try
             {
                 parm = cmdparms[2];
-                string valparm = cmdparms[3].ToLower();
-                if (valparm == "true")
-                    val = PhysParameterEntry.NUMERIC_TRUE;
-                else
-                {
-                    if (valparm == "false")
-                        val = PhysParameterEntry.NUMERIC_FALSE;
-                    else
-                        val = float.Parse(valparm, Culture.NumberFormatInfo);
-                }
+                valparm = cmdparms[3].ToLower();
                 if (cmdparms.Length > 4)
                 {
                     if (cmdparms[4].ToLower() == "all")
@@ -224,7 +215,7 @@ namespace OpenSim.Region.OptionalModules.PhysicsParameters
             IPhysicsParameters physScene = scene.PhysicsScene as IPhysicsParameters;
             if (physScene != null)
             {
-                if (!physScene.SetPhysicsParameter(parm, val, localID))
+                if (!physScene.SetPhysicsParameter(parm, valparm, localID))
                 {
                     WriteError("Failed set of parameter '{0}' for region '{1}'", parm, scene.RegionInfo.RegionName);
                 }
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSParam.cs b/OpenSim/Region/Physics/BulletSPlugin/BSParam.cs
index 965c382..601c78c 100755
--- a/OpenSim/Region/Physics/BulletSPlugin/BSParam.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSParam.cs
@@ -641,24 +641,6 @@ public static class BSParam
         return (b == ConfigurationParameters.numericTrue ? true : false);
     }
 
-    private static void ResetBroadphasePoolTainted(BSScene pPhysScene, float v)
-    {
-        BSScene physScene = pPhysScene;
-        physScene.TaintedObject("BSParam.ResetBroadphasePoolTainted", delegate()
-        {
-            physScene.PE.ResetBroadphasePool(physScene.World);
-        });
-    }
-
-    private static void ResetConstraintSolverTainted(BSScene pPhysScene, float v)
-    {
-        BSScene physScene = pPhysScene;
-        physScene.TaintedObject("BSParam.ResetConstraintSolver", delegate()
-        {
-            physScene.PE.ResetConstraintSolver(physScene.World);
-        });
-    }
-
     // Search through the parameter definitions and return the matching
     //    ParameterDefn structure.
     // Case does not matter as names are compared after converting to lower case.
@@ -722,6 +704,22 @@ public static class BSParam
         }
     }
 
+    private static void ResetBroadphasePoolTainted(BSScene pPhysScene, float v)
+    {
+        BSScene physScene = pPhysScene;
+        physScene.TaintedObject("BSParam.ResetBroadphasePoolTainted", delegate()
+        {
+            physScene.PE.ResetBroadphasePool(physScene.World);
+        });
+    }
 
+    private static void ResetConstraintSolverTainted(BSScene pPhysScene, float v)
+    {
+        BSScene physScene = pPhysScene;
+        physScene.TaintedObject("BSParam.ResetConstraintSolver", delegate()
+        {
+            physScene.PE.ResetConstraintSolver(physScene.World);
+        });
+    }
 }
 }
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSScene.cs b/OpenSim/Region/Physics/BulletSPlugin/BSScene.cs
index 6cd72f2..f8a0c1e 100644
--- a/OpenSim/Region/Physics/BulletSPlugin/BSScene.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSScene.cs
@@ -876,14 +876,39 @@ public sealed class BSScene : PhysicsScene, IPhysicsParameters
     //   will use the next time since it's pinned and shared memory.
     // Some of the values require calling into the physics engine to get the new
     //   value activated ('terrainFriction' for instance).
-    public bool SetPhysicsParameter(string parm, float val, uint localID)
+    public bool SetPhysicsParameter(string parm, string val, uint localID)
     {
         bool ret = false;
+
+        float valf = 0f;
+        if (val.ToLower() == "true")
+        {
+            valf = PhysParameterEntry.NUMERIC_TRUE;
+        }
+        else
+        {
+            if (val.ToLower() == "false")
+            {
+                valf = PhysParameterEntry.NUMERIC_FALSE;
+            }
+            else
+            {
+                try
+                {
+                    valf = float.Parse(val);
+                }
+                catch
+                {
+                    valf = 0f;
+                }
+            }
+        }
+
         BSParam.ParameterDefn theParam;
         if (BSParam.TryGetParameter(parm, out theParam))
         {
             // Set the value in the C# code
-            theParam.setter(this, parm, localID, val);
+            theParam.setter(this, parm, localID, valf);
 
             // Optionally set the parameter in the unmanaged code
             if (theParam.onObject != null)
@@ -898,16 +923,16 @@ public sealed class BSScene : PhysicsScene, IPhysicsParameters
                     case PhysParameterEntry.APPLY_TO_NONE:
                         // This will cause a call into the physical world if some operation is specified (SetOnObject).
                         objectIDs.Add(TERRAIN_ID);
-                        TaintedUpdateParameter(parm, objectIDs, val);
+                        TaintedUpdateParameter(parm, objectIDs, valf);
                         break;
                     case PhysParameterEntry.APPLY_TO_ALL:
                         lock (PhysObjects) objectIDs = new List<uint>(PhysObjects.Keys);
-                        TaintedUpdateParameter(parm, objectIDs, val);
+                        TaintedUpdateParameter(parm, objectIDs, valf);
                         break;
                     default:
                         // setting only one localID
                         objectIDs.Add(localID);
-                        TaintedUpdateParameter(parm, objectIDs, val);
+                        TaintedUpdateParameter(parm, objectIDs, valf);
                         break;
                 }
             }
@@ -942,14 +967,14 @@ public sealed class BSScene : PhysicsScene, IPhysicsParameters
 
     // Get parameter.
     // Return 'false' if not able to get the parameter.
-    public bool GetPhysicsParameter(string parm, out float value)
+    public bool GetPhysicsParameter(string parm, out string value)
     {
-        float val = 0f;
+        string val = String.Empty;
         bool ret = false;
         BSParam.ParameterDefn theParam;
         if (BSParam.TryGetParameter(parm, out theParam))
         {
-            val = theParam.getter(this);
+            val = theParam.getter(this).ToString();
             ret = true;
         }
         value = val;
diff --git a/OpenSim/Region/Physics/Manager/IPhysicsParameters.cs b/OpenSim/Region/Physics/Manager/IPhysicsParameters.cs
index b8676ba..31a397c 100755
--- a/OpenSim/Region/Physics/Manager/IPhysicsParameters.cs
+++ b/OpenSim/Region/Physics/Manager/IPhysicsParameters.cs
@@ -60,14 +60,14 @@ namespace OpenSim.Region.Physics.Manager
 
         // Set parameter on a specific or all instances.
         // Return 'false' if not able to set the parameter.
-        bool SetPhysicsParameter(string parm, float value, uint localID);
+        bool SetPhysicsParameter(string parm, string value, uint localID);
 
         // Get parameter.
         // Return 'false' if not able to get the parameter.
-        bool GetPhysicsParameter(string parm, out float value);
+        bool GetPhysicsParameter(string parm, out string value);
 
         // Get parameter from a particular object
         // TODO:
-        // bool GetPhysicsParameter(string parm, out float value, uint localID);
+        // bool GetPhysicsParameter(string parm, out string value, uint localID);
     }
 }
diff --git a/bin/HttpServer_OpenSim.pdb b/bin/HttpServer_OpenSim.pdb
index b9161e1..f56e891 100644
--- a/bin/HttpServer_OpenSim.pdb
+++ b/bin/HttpServer_OpenSim.pdb
diff --git a/bin/HttpServer_OpenSim.xml b/bin/HttpServer_OpenSim.xml
index d31bcca..fa88fc7 100644
--- a/bin/HttpServer_OpenSim.xml
+++ b/bin/HttpServer_OpenSim.xml
@@ -4,922 +4,421 @@
         <name>HttpServer_OpenSim</name>

     </assembly>

     <members>

-        <member name="T:HttpServer.Sessions.IHttpSessionStore">

-            <summary>

-            A session store is used to store and load sessions on a media.

-            The default implementation (<see cref="T:HttpServer.Sessions.MemorySessionStore"/>) saves/retrieves sessions from memory.

-            </summary>

-        </member>

-        <member name="M:HttpServer.Sessions.IHttpSessionStore.Create">

-            <summary>

-            Creates a new http session with a generated id.

-            </summary>

-            <returns>A <see cref="T:HttpServer.Sessions.IHttpSession"/> object</returns>

-        </member>

-        <member name="M:HttpServer.Sessions.IHttpSessionStore.Create(System.String)">

+        <member name="T:HttpServer.RealmHandler">

             <summary>

-            Creates a new http session with a specific id

+            Delegate used to find a realm/domain.

             </summary>

-            <param name="id">Id used to identify the new cookie..</param>

-            <returns>A <see cref="T:HttpServer.Sessions.IHttpSession"/> object.</returns>

+            <param name="domain"></param>

+            <returns></returns>

             <remarks>

-            Id should be generated by the store implementation if it's null or <see cref="F:System.String.Empty"/>.

+            Realms are used during HTTP Authentication

             </remarks>

+            <seealso cref="T:HttpServer.Authentication.AuthenticationModule"/>

+            <seealso cref="T:HttpServer.Authentication.AuthenticationHandler"/>

         </member>

-        <member name="M:HttpServer.Sessions.IHttpSessionStore.Load(System.String)">

-            <summary>

-            Load an existing session.

-            </summary>

-            <param name="sessionId">Session id (usually retrieved from a client side cookie).</param>

-            <returns>A session if found; otherwise null.</returns>

-        </member>

-        <member name="M:HttpServer.Sessions.IHttpSessionStore.Save(HttpServer.Sessions.IHttpSession)">

-            <summary>

-            Save an updated session to the store.

-            </summary>

-            <param name="session">Session id (usually retrieved from a client side cookie).</param>

-            <exception cref="T:System.ArgumentException">If Id property have not been specified.</exception>

-        </member>

-        <member name="M:HttpServer.Sessions.IHttpSessionStore.AddUnused(HttpServer.Sessions.IHttpSession)">

-            <summary>

-            We use the flyweight pattern which reuses small objects

-            instead of creating new each time.

-            </summary>

-            <param name="session">Unused session that should be reused next time Create is called.</param>

-        </member>

-        <member name="M:HttpServer.Sessions.IHttpSessionStore.Cleanup">

-            <summary>

-            Remove expired sessions

-            </summary>

-        </member>

-        <member name="M:HttpServer.Sessions.IHttpSessionStore.Remove(System.String)">

-            <summary>

-            Remove a session

-            </summary>

-            <param name="sessionId">id of the session.</param>

-        </member>

-        <member name="P:HttpServer.Sessions.IHttpSessionStore.Item(System.String)">

-            <summary>

-            Load a session from the store

-            </summary>

-            <param name="sessionId"></param>

-            <returns>null if session is not found.</returns>

-        </member>

-        <member name="P:HttpServer.Sessions.IHttpSessionStore.ExpireTime">

-            <summary>

-            Number of minutes before a session expires.

-            </summary>

-            <value>Default time is 20 minutes.</value>

-        </member>

-        <member name="T:HttpServer.IHttpRequest">

-            <summary>

-            Contains server side HTTP request information.

-            </summary>

-        </member>

-        <member name="M:HttpServer.IHttpRequest.AddHeader(System.String,System.String)">

-            <summary>

-            Called during parsing of a <see cref="T:HttpServer.IHttpRequest"/>.

-            </summary>

-            <param name="name">Name of the header, should not be URL encoded</param>

-            <param name="value">Value of the header, should not be URL encoded</param>

-            <exception cref="T:HttpServer.Exceptions.BadRequestException">If a header is incorrect.</exception>

-        </member>

-        <member name="M:HttpServer.IHttpRequest.AddToBody(System.Byte[],System.Int32,System.Int32)">

+        <member name="T:HttpServer.HttpServer">

             <summary>

-            Add bytes to the body

+            A complete HTTP server, you need to add a module to it to be able to handle incoming requests.

             </summary>

-            <param name="bytes">buffer to read bytes from</param>

-            <param name="offset">where to start read</param>

-            <param name="length">number of bytes to read</param>

-            <returns>Number of bytes actually read (same as length unless we got all body bytes).</returns>

-            <exception cref="T:System.InvalidOperationException">If body is not writable</exception>

-            <exception cref="T:System.ArgumentNullException"><c>bytes</c> is null.</exception>

-            <exception cref="T:System.ArgumentOutOfRangeException"><c>offset</c> is out of range.</exception>

+            <example>

+            <code>

+            // this small example will add two web site modules, thus handling

+            // two different sites. In reality you should add Controller modules or something

+            // two the website modules to be able to handle different requests.

+            HttpServer server = new HttpServer();

+            server.Add(new WebSiteModule("www.gauffin.com", "Gauffin Telecom AB"));

+            server.Add(new WebSiteModule("www.vapadi.se", "Remote PBX"));

+            

+            // start regular http

+            server.Start(IPAddress.Any, 80);

+            

+            // start https

+            server.Start(IPAddress.Any, 443, myCertificate);

+            </code>

+            </example>

+            <seealso cref="T:HttpServer.HttpModules.HttpModule"/>

+            <seealso cref="T:HttpServer.HttpModules.FileModule"/>

+            <seealso cref="T:HttpServer.HttpListener"/>

         </member>

-        <member name="M:HttpServer.IHttpRequest.Clear">

+        <member name="M:HttpServer.HttpServer.#ctor(HttpServer.IComponentProvider)">

             <summary>

-            Clear everything in the request

+            Initializes a new instance of the <see cref="T:HttpServer.HttpServer"/> class.

             </summary>

+            <param name="provider">Used to get all components used in the server..</param>

         </member>

-        <member name="M:HttpServer.IHttpRequest.DecodeBody(HttpServer.FormDecoders.FormDecoderProvider)">

+        <member name="M:HttpServer.HttpServer.#ctor">

             <summary>

-            Decode body into a form.

+            Initializes a new instance of the <see cref="T:HttpServer.HttpServer"/> class.

             </summary>

-            <param name="providers">A list with form decoders.</param>

-            <exception cref="T:System.IO.InvalidDataException">If body contents is not valid for the chosen decoder.</exception>

-            <exception cref="T:System.InvalidOperationException">If body is still being transferred.</exception>

         </member>

-        <member name="M:HttpServer.IHttpRequest.SetCookies(HttpServer.RequestCookies)">

+        <member name="M:HttpServer.HttpServer.#ctor(HttpServer.FormDecoders.FormDecoderProvider)">

             <summary>

-            Sets the cookies.

+            Initializes a new instance of the <see cref="T:HttpServer.HttpServer"/> class.

             </summary>

-            <param name="cookies">The cookies.</param>

+            <param name="decoderProvider">Form decoders are used to convert different types of posted data to the <see cref="T:HttpServer.HttpInput"/> object types.</param>

+            <seealso cref="T:HttpServer.FormDecoders.IFormDecoder"/>

+            <seealso cref="P:HttpServer.HttpServer.FormDecoderProviders"/>

         </member>

-        <member name="M:HttpServer.IHttpRequest.CreateResponse(HttpServer.IHttpClientContext)">

+        <member name="M:HttpServer.HttpServer.#ctor(HttpServer.Sessions.IHttpSessionStore)">

             <summary>

-            Create a response object.

+            Initializes a new instance of the <see cref="T:HttpServer.HttpServer"/> class.

             </summary>

-            <param name="context">Context for the connected client.</param>

-            <returns>A new <see cref="T:HttpServer.IHttpResponse"/>.</returns>

+            <param name="sessionStore">A session store is used to save and retrieve sessions</param>

+            <seealso cref="T:HttpServer.Sessions.IHttpSessionStore"/>

         </member>

-        <member name="P:HttpServer.IHttpRequest.AcceptTypes">

+        <member name="M:HttpServer.HttpServer.#ctor(HttpServer.ILogWriter)">

             <summary>

-            Gets kind of types accepted by the client.

+            Initializes a new instance of the <see cref="T:HttpServer.HttpServer"/> class.

             </summary>

+            <param name="logWriter">The log writer.</param>

+            <seealso cref="P:HttpServer.HttpServer.LogWriter"/>

         </member>

-        <member name="P:HttpServer.IHttpRequest.Body">

+        <member name="M:HttpServer.HttpServer.#ctor(HttpServer.FormDecoders.FormDecoderProvider,HttpServer.ILogWriter)">

             <summary>

-            Gets or sets body stream.

+            Initializes a new instance of the <see cref="T:HttpServer.HttpServer"/> class.

             </summary>

+            <param name="decoderProvider">Form decoders are used to convert different types of posted data to the <see cref="T:HttpServer.HttpInput"/> object types.</param>

+            <param name="logWriter">The log writer.</param>

+            <seealso cref="T:HttpServer.FormDecoders.IFormDecoder"/>

+            <seealso cref="P:HttpServer.HttpServer.FormDecoderProviders"/>

+            <seealso cref="P:HttpServer.HttpServer.LogWriter"/>

         </member>

-        <member name="P:HttpServer.IHttpRequest.BodyIsComplete">

+        <member name="M:HttpServer.HttpServer.#ctor(HttpServer.FormDecoders.FormDecoderProvider,HttpServer.Sessions.IHttpSessionStore,HttpServer.ILogWriter)">

             <summary>

-            Gets whether the body is complete.

+            Initializes a new instance of the <see cref="T:HttpServer.HttpServer"/> class.

             </summary>

+            <param name="decoderProvider">Form decoders are used to convert different types of posted data to the <see cref="T:HttpServer.HttpInput"/> object types.</param>

+            <param name="sessionStore">A session store is used to save and retrieve sessions</param>

+            <param name="logWriter">The log writer.</param>

+            <seealso cref="T:HttpServer.FormDecoders.IFormDecoder"/>

+            <seealso cref="P:HttpServer.HttpServer.FormDecoderProviders"/>

+            <seealso cref="P:HttpServer.HttpServer.LogWriter"/>

+            <seealso cref="T:HttpServer.Sessions.IHttpSessionStore"/>

         </member>

-        <member name="P:HttpServer.IHttpRequest.Connection">

+        <member name="M:HttpServer.HttpServer.Add(HttpServer.Rules.IRule)">

             <summary>

-            Gets or sets kind of connection used for the session.

+            Adds the specified rule.

             </summary>

+            <param name="rule">The rule.</param>

         </member>

-        <member name="P:HttpServer.IHttpRequest.ContentLength">

+        <member name="M:HttpServer.HttpServer.Add(HttpServer.HttpModules.HttpModule)">

             <summary>

-            Gets or sets number of bytes in the body.

+            Add a <see cref="T:HttpServer.HttpModules.HttpModule"/> to the server.

             </summary>

+            <param name="module">mode to add</param>

         </member>

-        <member name="P:HttpServer.IHttpRequest.Cookies">

+        <member name="M:HttpServer.HttpServer.DecodeBody(HttpServer.IHttpRequest)">

             <summary>

-            Gets cookies that was sent with the request.

+            Decodes the request body.

             </summary>

+            <param name="request">The request.</param>

+            <exception cref="T:HttpServer.Exceptions.InternalServerException">Failed to decode form data.</exception>

         </member>

-        <member name="P:HttpServer.IHttpRequest.Form">

+        <member name="M:HttpServer.HttpServer.ErrorPage(HttpServer.IHttpResponse,System.Net.HttpStatusCode,System.String)">

             <summary>

-            Gets form parameters.

+            Generate a HTTP error page (that will be added to the response body).

+            response status code is also set.

             </summary>

+            <param name="response">Response that the page will be generated in.</param>

+            <param name="error"><see cref="T:System.Net.HttpStatusCode"/>.</param>

+            <param name="body">response body contents.</param>

         </member>

-        <member name="P:HttpServer.IHttpRequest.Headers">

+        <member name="M:HttpServer.HttpServer.ErrorPage(HttpServer.IHttpResponse,HttpServer.Exceptions.HttpException)">

             <summary>

-            Gets headers sent by the client.

+            Generate a HTTP error page (that will be added to the response body).

+            response status code is also set.

             </summary>

+            <param name="response">Response that the page will be generated in.</param>

+            <param name="err">exception.</param>

         </member>

-        <member name="P:HttpServer.IHttpRequest.HttpVersion">

+        <member name="M:HttpServer.HttpServer.GetRealm(HttpServer.IHttpRequest)">

             <summary>

-            Gets or sets version of HTTP protocol that's used. 

+            Realms are used by the <see cref="T:HttpServer.Authentication.AuthenticationModule"/>s.

             </summary>

-            <remarks>

-            Probably <see cref="F:HttpServer.HttpHelper.HTTP10"/> or <see cref="F:HttpServer.HttpHelper.HTTP11"/>.

-            </remarks>

-            <seealso cref="T:HttpServer.HttpHelper"/>

+            <param name="request">HTTP request</param>

+            <returns>domain/realm.</returns>

         </member>

-        <member name="P:HttpServer.IHttpRequest.IsAjax">

+        <member name="M:HttpServer.HttpServer.HandleRequest(HttpServer.IHttpClientContext,HttpServer.IHttpRequest,HttpServer.IHttpResponse,HttpServer.Sessions.IHttpSession)">

             <summary>

-            Gets whether the request was made by Ajax (Asynchronous JavaScript)

+            Process an incoming request.

             </summary>

+            <param name="context">connection to client</param>

+            <param name="request">request information</param>

+            <param name="response">response that should be filled</param>

+            <param name="session">session information</param>

         </member>

-        <member name="P:HttpServer.IHttpRequest.Method">

+        <member name="M:HttpServer.HttpServer.OnClientDisconnected(HttpServer.IHttpClientContext,System.Net.Sockets.SocketError)">

             <summary>

-            Gets or sets requested method.

+            Can be overloaded to implement stuff when a client have been connected.

             </summary>

             <remarks>

-            Will always be in upper case.

+            Default implementation does nothing.

             </remarks>

-            <see cref="P:HttpServer.IHttpRequest.Method"/>

-        </member>

-        <member name="P:HttpServer.IHttpRequest.Param">

-            <summary>

-            Gets parameter from <see cref="P:HttpServer.IHttpRequest.QueryString"/> or <see cref="P:HttpServer.IHttpRequest.Form"/>.

-            </summary>

-        </member>

-        <member name="P:HttpServer.IHttpRequest.QueryString">

-            <summary>

-            Gets variables sent in the query string

-            </summary>

-        </member>

-        <member name="P:HttpServer.IHttpRequest.Uri">

-            <summary>

-            Gets or sets requested URI.

-            </summary>

+            <param name="client">client that disconnected</param>

+            <param name="error">disconnect reason</param>

         </member>

-        <member name="P:HttpServer.IHttpRequest.UriParts">

+        <member name="M:HttpServer.HttpServer.ProcessAuthentication(HttpServer.IHttpRequest,HttpServer.IHttpResponse,HttpServer.Sessions.IHttpSession)">

             <summary>

-            Gets URI absolute path divided into parts.

+            Handle authentication

             </summary>

-            <example>

-            // URI is: http://gauffin.com/code/tiny/

-            Console.WriteLine(request.UriParts[0]); // result: code

-            Console.WriteLine(request.UriParts[1]); // result: tiny

-            </example>

-            <remarks>

-            If you're using controllers than the first part is controller name,

-            the second part is method name and the third part is Id property.

-            </remarks>

-            <seealso cref="P:HttpServer.IHttpRequest.Uri"/>

+            <param name="request"></param>

+            <param name="response"></param>

+            <param name="session"></param>

+            <returns>true if request can be handled; false if not.</returns>

+            <exception cref="T:HttpServer.Exceptions.BadRequestException">Invalid authorization header</exception>

         </member>

-        <member name="P:HttpServer.IHttpRequest.UriPath">

+        <member name="M:HttpServer.HttpServer.RequestAuthentication(HttpServer.Authentication.AuthenticationModule,HttpServer.IHttpRequest,HttpServer.IHttpResponse)">

             <summary>

-            Gets or sets path and query.

+            Will request authentication.

             </summary>

-            <see cref="P:HttpServer.IHttpRequest.Uri"/>

             <remarks>

-            Are only used during request parsing. Cannot be set after "Host" header have been

-            added.

+            Sends respond to client, nothing else can be done with the response after this.

             </remarks>

+            <param name="mod"></param>

+            <param name="request"></param>

+            <param name="response"></param>

         </member>

-        <member name="T:HttpServer.IHttpContextHandler">

-            <summary>

-            Class that receives Requests from a <see cref="T:HttpServer.IHttpClientContext"/>.

-            </summary>

-        </member>

-        <member name="M:HttpServer.IHttpContextHandler.ClientDisconnected(HttpServer.IHttpClientContext,System.Net.Sockets.SocketError)">

-            <summary>

-            Client have been disconnected.

-            </summary>

-            <param name="client">Client that was disconnected.</param>

-            <param name="error">Reason</param>

-            <see cref="T:HttpServer.IHttpClientContext"/>

-        </member>

-        <member name="M:HttpServer.IHttpContextHandler.RequestReceived(HttpServer.IHttpClientContext,HttpServer.IHttpRequest)">

-            <summary>

-            Invoked when a client context have received a new HTTP request

-            </summary>

-            <param name="client">Client that received the request.</param>

-            <param name="request">Request that was received.</param>

-            <see cref="T:HttpServer.IHttpClientContext"/>

-        </member>

-        <member name="T:HttpServer.Helpers.GetIdTitle">

-            <summary>

-            Delegate used by <see cref="M:HttpServer.Helpers.FormHelper.Select(System.String,System.Collections.IEnumerable,HttpServer.Helpers.GetIdTitle,System.Object,System.Boolean)"/> to populate select options.

-            </summary>

-            <param name="obj">current object (for instance a User).</param>

-            <param name="id">Text that should be displayed in the value part of a &lt;optiongt;-tag.</param>

-            <param name="title">Text shown in the select list.</param>

-            <example>

-            // Class that is going to be used in a SELECT-tag.

-            public class User

-            {

-                private readonly string _realName;

-                private readonly int _id;

-                public User(int id, string realName)

-                {

-                    _id = id;

-                    _realName = realName;

-                }

-                public string RealName

-                {

-                    get { return _realName; }

-                }

-            

-                public int Id

-                {

-                    get { return _id; }

-                }

-            }

-            

-            // Using an inline delegate to generate the select list

-            public void UserInlineDelegate()

-            {

-                List&lt;User&gt; items = new List&lt;User&gt;();

-                items.Add(new User(1, "adam"));

-                items.Add(new User(2, "bertial"));

-                items.Add(new User(3, "david"));

-                string htmlSelect = Select("users", "users", items, delegate(object o, out object id, out object value)

-                                                                    {

-                                                                        User user = (User)o;

-                                                                        id = user.Id;

-                                                                        value = user.RealName;

-                                                                    }, 2, true);

-            }

-            

-            // Using an method as delegate to generate the select list.

-            public void UseExternalDelegate()

-            {

-                List&lt;User&gt; items = new List&lt;User&gt;();

-                items.Add(new User(1, "adam"));

-                items.Add(new User(2, "bertial"));

-                items.Add(new User(3, "david"));

-                string htmlSelect = Select("users", "users", items, UserOptions, 1, true);

-            }

-            

-            // delegate returning id and title

-            public static void UserOptions(object o, out object id, out object title)

-            {

-                User user = (User)o;

-                id = user.Id;

-                value = user.RealName;

-            }    /// </example>

-        </member>

-        <member name="T:HttpServer.Exceptions.ForbiddenException">

-            <summary>

-            The server understood the request, but is refusing to fulfill it. 

-            Authorization will not help and the request SHOULD NOT be repeated. 

-            If the request method was not HEAD and the server wishes to make public why the request has not been fulfilled, 

-            it SHOULD describe the reason for the refusal in the entity. If the server does not wish to make this information 

-            available to the client, the status code 404 (Not Found) can be used instead.

-            

-            Text taken from: http://www.submissionchamber.com/help-guides/error-codes.php

-            </summary>

-        </member>

-        <member name="T:HttpServer.Exceptions.HttpException">

-            <summary>

-            All HTTP based exceptions will derive this class.

-            </summary>

-        </member>

-        <member name="M:HttpServer.Exceptions.HttpException.#ctor(System.Net.HttpStatusCode,System.String)">

-            <summary>

-            Create a new HttpException

-            </summary>

-            <param name="code">http status code (sent in the response)</param>

-            <param name="message">error description</param>

-        </member>

-        <member name="M:HttpServer.Exceptions.HttpException.#ctor(System.Net.HttpStatusCode,System.String,System.Exception)">

-            <summary>

-            Create a new HttpException

-            </summary>

-            <param name="code">http status code (sent in the response)</param>

-            <param name="message">error description</param>

-            <param name="inner">inner exception</param>

-        </member>

-        <member name="P:HttpServer.Exceptions.HttpException.HttpStatusCode">

-            <summary>

-            status code to use in the response.

-            </summary>

-        </member>

-        <member name="M:HttpServer.Exceptions.ForbiddenException.#ctor(System.String)">

-            <summary>

-            Initializes a new instance of the <see cref="T:HttpServer.Exceptions.ForbiddenException"/> class.

-            </summary>

-            <param name="errorMsg">error message</param>

-        </member>

-        <member name="T:HttpServer.Sessions.MemorySession">

-            <summary>

-            A session stored in memory.

-            </summary>

-        </member>

-        <member name="T:HttpServer.Sessions.IHttpSession">

-            <summary>

-            Interface for sessions

-            </summary>

-        </member>

-        <member name="M:HttpServer.Sessions.IHttpSession.Clear">

-            <summary>

-            Remove everything from the session

-            </summary>

-        </member>

-        <member name="M:HttpServer.Sessions.IHttpSession.Clear(System.Boolean)">

-            <summary>

-            Remove everything from the session

-            </summary>

-            <param name="expires">True if the session is cleared due to expiration</param>

-        </member>

-        <member name="P:HttpServer.Sessions.IHttpSession.Id">

-            <summary>

-            Session id

-            </summary>

-        </member>

-        <member name="P:HttpServer.Sessions.IHttpSession.Item(System.String)">

-            <summary>

-            Should 

-            </summary>

-            <param name="name">Name of the session variable</param>

-            <returns>null if it's not set</returns>

-            <exception cref="T:System.Runtime.Serialization.SerializationException">If the object cant be serialized.</exception>

-        </member>

-        <member name="P:HttpServer.Sessions.IHttpSession.Accessed">

-            <summary>

-            When the session was last accessed.

-            This property is touched by the http server each time the

-            session is requested.

-            </summary>

-        </member>

-        <member name="P:HttpServer.Sessions.IHttpSession.Count">

-            <summary>

-            Number of session variables.

-            </summary>

-        </member>

-        <member name="E:HttpServer.Sessions.IHttpSession.BeforeClear">

-            <summary>

-            Event triggered upon clearing the session

-            </summary>

-        </member>

-        <member name="M:HttpServer.Sessions.MemorySession.#ctor(System.String)">

+        <member name="M:HttpServer.HttpServer.OnRequest(System.Object,HttpServer.RequestEventArgs)">

             <summary>

-            

+            Received from a <see cref="T:HttpServer.IHttpClientContext"/> when a request have been parsed successfully.

             </summary>

-            <param name="id">A unique id used by the sessions store to identify the session</param>

+            <param name="source"><see cref="T:HttpServer.IHttpClientContext"/> that received the request.</param>

+            <param name="args">The request.</param>

         </member>

-        <member name="M:HttpServer.Sessions.MemorySession.SetId(System.String)">

+        <member name="M:HttpServer.HttpServer.ProcessRequestWrapper(HttpServer.IHttpClientContext,HttpServer.IHttpRequest)">

             <summary>

-            Id

+            To be able to track request count.

             </summary>

-            <param name="id"></param>

+            <param name="context"></param>

+            <param name="request"></param>

         </member>

-        <member name="M:HttpServer.Sessions.MemorySession.Clear">

+        <member name="M:HttpServer.HttpServer.Start(System.Net.IPAddress,System.Int32)">

             <summary>

-            Remove everything from the session

+            Start the web server using regular HTTP.

             </summary>

+            <param name="address">IP Address to listen on, use <c>IpAddress.Any </c>to accept connections on all IP addresses/network cards.</param>

+            <param name="port">Port to listen on. 80 can be a good idea =)</param>

+            <exception cref="T:System.ArgumentNullException"><c>address</c> is null.</exception>

+            <exception cref="T:System.ArgumentException">Port must be a positive number.</exception>

         </member>

-        <member name="M:HttpServer.Sessions.MemorySession.Clear(System.Boolean)">

+        <member name="M:HttpServer.HttpServer.Start(System.Net.IPAddress,System.Int32,System.Security.Cryptography.X509Certificates.X509Certificate)">

             <summary>

-            Clears the specified expire.

+            Accept secure connections.

             </summary>

-            <param name="expires">True if the session is cleared due to expiration</param>

+            <param name="address">IP Address to listen on, use <see cref="F:System.Net.IPAddress.Any"/> to accept connections on all IP Addresses / network cards.</param>

+            <param name="port">Port to listen on. 80 can be a good idea =)</param>

+            <param name="certificate">Certificate to use</param>

+            <exception cref="T:System.ArgumentNullException"><c>address</c> is null.</exception>

+            <exception cref="T:System.ArgumentException">Port must be a positive number.</exception>

         </member>

-        <member name="M:HttpServer.Sessions.MemorySession.Dispose">

+        <member name="M:HttpServer.HttpServer.Stop">

             <summary>

-            Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.

+            shut down the server and listeners

             </summary>

-            <filterpriority>2</filterpriority>

         </member>

-        <member name="P:HttpServer.Sessions.MemorySession.Id">

+        <member name="M:HttpServer.HttpServer.WriteLog(HttpServer.LogPrio,System.String)">

             <summary>

-            Session id

+            write an entry to the log file

             </summary>

+            <param name="prio">importance of the message</param>

+            <param name="message">log message</param>

         </member>

-        <member name="P:HttpServer.Sessions.MemorySession.Item(System.String)">

+        <member name="M:HttpServer.HttpServer.WriteLog(System.Object,HttpServer.LogPrio,System.String)">

             <summary>

-            Should 

+            write an entry to the log file

             </summary>

-            <param name="name">Name of the session variable</param>

-            <returns>null if it's not set</returns>

+            <param name="source">object that wrote the message</param>

+            <param name="prio">importance of the message</param>

+            <param name="message">log message</param>

         </member>

-        <member name="P:HttpServer.Sessions.MemorySession.Accessed">

+        <member name="P:HttpServer.HttpServer.Current">

             <summary>

-            when the session was last accessed.

+            Server that is handling the current request.

             </summary>

             <remarks>

-            Used to determine when the session should be removed.

+            Will be set as soon as a request arrives to the <see cref="T:HttpServer.HttpServer"/> object.

             </remarks>

         </member>

-        <member name="P:HttpServer.Sessions.MemorySession.Count">

-            <summary>

-            Number of values in the session

-            </summary>

-        </member>

-        <member name="P:HttpServer.Sessions.MemorySession.Changed">

-            <summary>

-            Flag to indicate that the session have been changed

-            and should be saved into the session store.

-            </summary>

-        </member>

-        <member name="E:HttpServer.Sessions.MemorySession.BeforeClear">

-            <summary>

-            Event triggered upon clearing the session

-            </summary>

-        </member>

-        <member name="T:HttpServer.ResponseCookie">

-            <summary>

-            cookie being sent back to the browser.

-            </summary>

-            <seealso cref="T:HttpServer.ResponseCookie"/>

-        </member>

-        <member name="T:HttpServer.RequestCookie">

-            <summary>

-            cookie sent by the client/browser

-            </summary>

-            <seealso cref="T:HttpServer.ResponseCookie"/>

-        </member>

-        <member name="M:HttpServer.RequestCookie.#ctor(System.String,System.String)">

-            <summary>

-            Constructor.

-            </summary>

-            <param name="id">cookie identifier</param>

-            <param name="content">cookie content</param>

-            <exception cref="T:System.ArgumentNullException">id or content is null</exception>

-            <exception cref="T:System.ArgumentException">id is empty</exception>

-        </member>

-        <member name="M:HttpServer.RequestCookie.ToString">

-            <summary>

-            Gets the cookie HTML representation.

-            </summary>

-            <returns>cookie string</returns>

-        </member>

-        <member name="P:HttpServer.RequestCookie.Name">

-            <summary>

-            Gets the cookie identifier.

-            </summary>

-        </member>

-        <member name="P:HttpServer.RequestCookie.Value">

-            <summary>

-            Cookie value. Set to null to remove cookie.

-            </summary>

-        </member>

-        <member name="M:HttpServer.ResponseCookie.#ctor(System.String,System.String,System.DateTime)">

-            <summary>

-            Constructor.

-            </summary>

-            <param name="id">cookie identifier</param>

-            <param name="content">cookie content</param>

-            <param name="expiresAt">cookie expiration date. Use DateTime.MinValue for session cookie.</param>

-            <exception cref="T:System.ArgumentNullException">id or content is null</exception>

-            <exception cref="T:System.ArgumentException">id is empty</exception>

-        </member>

-        <member name="M:HttpServer.ResponseCookie.#ctor(System.String,System.String,System.DateTime,System.String,System.String)">

-            <summary>

-            Create a new cookie

-            </summary>

-            <param name="name">name identifying the cookie</param>

-            <param name="value">cookie value</param>

-            <param name="expires">when the cookie expires. Setting DateTime.MinValue will delete the cookie when the session is closed.</param>

-            <param name="path">Path to where the cookie is valid</param>

-            <param name="domain">Domain that the cookie is valid for.</param>

-        </member>

-        <member name="M:HttpServer.ResponseCookie.#ctor(HttpServer.RequestCookie,System.DateTime)">

-            <summary>

-            Create a new cookie

-            </summary>

-            <param name="cookie">Name and value will be used</param>

-            <param name="expires">when the cookie expires.</param>

-        </member>

-        <member name="M:HttpServer.ResponseCookie.ToString">

-            <summary>

-            Gets the cookie HTML representation.

-            </summary>

-            <returns>cookie string</returns>

-        </member>

-        <member name="P:HttpServer.ResponseCookie.Expires">

-            <summary>

-            When the cookie expires.

-            DateTime.MinValue means that the cookie expires when the session do so.

-            </summary>

-        </member>

-        <member name="P:HttpServer.ResponseCookie.Path">

-            <summary>

-            Cookie is only valid under this path.

-            </summary>

-        </member>

-        <member name="T:HttpServer.IHttpClientContext">

-            <summary>

-            Contains a connection to a browser/client.

-            </summary>

-        </member>

-        <member name="M:HttpServer.IHttpClientContext.Disconnect(System.Net.Sockets.SocketError)">

-            <summary>

-            Disconnect from client

-            </summary>

-            <param name="error">error to report in the <see cref="E:HttpServer.IHttpClientContext.Disconnected"/> event.</param>

-        </member>

-        <member name="M:HttpServer.IHttpClientContext.Respond(System.String,System.Net.HttpStatusCode,System.String,System.String,System.String)">

-            <summary>

-            Send a response.

-            </summary>

-            <param name="httpVersion">Either <see cref="F:HttpServer.HttpHelper.HTTP10"/> or <see cref="F:HttpServer.HttpHelper.HTTP11"/></param>

-            <param name="statusCode">HTTP status code</param>

-            <param name="reason">reason for the status code.</param>

-            <param name="body">HTML body contents, can be null or empty.</param>

-            <param name="contentType">A content type to return the body as, i.e. 'text/html' or 'text/plain', defaults to 'text/html' if null or empty</param>

-            <exception cref="T:System.ArgumentException">If <paramref name="httpVersion"/> is invalid.</exception>

-        </member>

-        <member name="M:HttpServer.IHttpClientContext.Respond(System.String,System.Net.HttpStatusCode,System.String)">

-            <summary>

-            Send a response.

-            </summary>

-            <param name="httpVersion">Either <see cref="F:HttpServer.HttpHelper.HTTP10"/> or <see cref="F:HttpServer.HttpHelper.HTTP11"/></param>

-            <param name="statusCode">HTTP status code</param>

-            <param name="reason">reason for the status code.</param>

-        </member>

-        <member name="M:HttpServer.IHttpClientContext.Respond(System.String)">

-            <summary>

-            Send a response.

-            </summary>

-            <exception cref="T:System.ArgumentNullException"></exception>

-        </member>

-        <member name="M:HttpServer.IHttpClientContext.Send(System.Byte[])">

-            <summary>

-            send a whole buffer

-            </summary>

-            <param name="buffer">buffer to send</param>

-            <exception cref="T:System.ArgumentNullException"></exception>

-        </member>

-        <member name="M:HttpServer.IHttpClientContext.Send(System.Byte[],System.Int32,System.Int32)">

-            <summary>

-            Send data using the stream

-            </summary>

-            <param name="buffer">Contains data to send</param>

-            <param name="offset">Start position in buffer</param>

-            <param name="size">number of bytes to send</param>

-            <exception cref="T:System.ArgumentNullException"></exception>

-            <exception cref="T:System.ArgumentOutOfRangeException"></exception>

-        </member>

-        <member name="M:HttpServer.IHttpClientContext.Close">

-            <summary>

-            Closes the streams and disposes of the unmanaged resources

-            </summary>

-        </member>

-        <member name="P:HttpServer.IHttpClientContext.Secured">

+        <member name="P:HttpServer.HttpServer.AuthenticationModules">

             <summary>

-            Using SSL or other encryption method.

+            Modules used for authentication. The module that is is added first is used as 

+            the default authentication module.

             </summary>

+            <remarks>Use the corresponding property

+            in the <see cref="T:HttpServer.HttpModules.WebSiteModule"/> if you are using multiple websites.</remarks>

         </member>

-        <member name="P:HttpServer.IHttpClientContext.IsSecured">

+        <member name="P:HttpServer.HttpServer.FormDecoderProviders">

             <summary>

-            Using SSL or other encryption method.

+            Form decoder providers are used to decode request body (which normally contains form data).

             </summary>

         </member>

-        <member name="E:HttpServer.IHttpClientContext.Disconnected">

+        <member name="P:HttpServer.HttpServer.ServerName">

             <summary>

-            The context have been disconnected.

+            Server name sent in HTTP responses.

             </summary>

             <remarks>

-            Event can be used to clean up a context, or to reuse it.

+            Do NOT include version in name, since it makes it 

+            easier for hackers.

             </remarks>

         </member>

-        <member name="E:HttpServer.IHttpClientContext.RequestReceived">

-            <summary>

-            A request have been received in the context.

-            </summary>

-        </member>

-        <member name="T:HttpServer.DisconnectedEventArgs">

-            <summary>

-            A <see cref="T:HttpServer.IHttpClientContext"/> have been disconnected.

-            </summary>

-        </member>

-        <member name="M:HttpServer.DisconnectedEventArgs.#ctor(System.Net.Sockets.SocketError)">

-            <summary>

-            Initializes a new instance of the <see cref="T:HttpServer.DisconnectedEventArgs"/> class.

-            </summary>

-            <param name="error">Reason to disconnection.</param>

-        </member>

-        <member name="P:HttpServer.DisconnectedEventArgs.Error">

-            <summary>

-            Gets reason to why client disconnected.

-            </summary>

-        </member>

-        <member name="T:HttpServer.RequestEventArgs">

-            <summary>

-            

-            </summary>

-        </member>

-        <member name="M:HttpServer.RequestEventArgs.#ctor(HttpServer.IHttpRequest)">

-            <summary>

-            Initializes a new instance of the <see cref="T:HttpServer.RequestEventArgs"/> class.

-            </summary>

-            <param name="request">The request.</param>

-        </member>

-        <member name="P:HttpServer.RequestEventArgs.Request">

-            <summary>

-            Gets received request.

-            </summary>

-        </member>

-        <member name="T:HttpServer.HttpListenerBase">

-            <summary>

-            Contains a listener that doesn't do anything with the connections.

-            </summary>

-        </member>

-        <member name="M:HttpServer.HttpListenerBase.#ctor(System.Net.IPAddress,System.Int32,HttpServer.IHttpContextFactory)">

-            <summary>

-            Listen for regular HTTP connections

-            </summary>

-            <param name="address">IP Address to accept connections on</param>

-            <param name="port">TCP Port to listen on, default HTTP port is 80.</param>

-            <param name="factory">Factory used to create <see cref="T:HttpServer.IHttpClientContext"/>es.</param>

-            <exception cref="T:System.ArgumentNullException"><c>address</c> is null.</exception>

-            <exception cref="T:System.ArgumentException">Port must be a positive number.</exception>

-        </member>

-        <member name="M:HttpServer.HttpListenerBase.#ctor(System.Net.IPAddress,System.Int32,HttpServer.IHttpContextFactory,System.Security.Cryptography.X509Certificates.X509Certificate)">

-            <summary>

-            Initializes a new instance of the <see cref="T:HttpServer.HttpListenerBase"/> class.

-            </summary>

-            <param name="address">IP Address to accept connections on</param>

-            <param name="port">TCP Port to listen on, default HTTPS port is 443</param>

-            <param name="factory">Factory used to create <see cref="T:HttpServer.IHttpClientContext"/>es.</param>

-            <param name="certificate">Certificate to use</param>

-        </member>

-        <member name="M:HttpServer.HttpListenerBase.#ctor(System.Net.IPAddress,System.Int32,HttpServer.IHttpContextFactory,System.Security.Cryptography.X509Certificates.X509Certificate,System.Security.Authentication.SslProtocols)">

-            <summary>

-            Initializes a new instance of the <see cref="T:HttpServer.HttpListenerBase"/> class.

-            </summary>

-            <param name="address">IP Address to accept connections on</param>

-            <param name="port">TCP Port to listen on, default HTTPS port is 443</param>

-            <param name="factory">Factory used to create <see cref="T:HttpServer.IHttpClientContext"/>es.</param>

-            <param name="certificate">Certificate to use</param>

-            <param name="protocol">which HTTPS protocol to use, default is TLS.</param>

-        </member>

-        <member name="M:HttpServer.HttpListenerBase.OnAccept(System.IAsyncResult)">

-            <exception cref="T:System.Exception"><c>Exception</c>.</exception>

-        </member>

-        <member name="M:HttpServer.HttpListenerBase.RetryBeginAccept">

+        <member name="P:HttpServer.HttpServer.SessionCookieName">

             <summary>

-            Will try to accept connections one more time.

+            Name of cookie where session id is stored.

             </summary>

-            <exception cref="T:System.Exception">If any exceptions is thrown.</exception>

         </member>

-        <member name="M:HttpServer.HttpListenerBase.OnAcceptingSocket(System.Net.Sockets.Socket)">

+        <member name="P:HttpServer.HttpServer.LogWriter">

             <summary>

-            Can be used to create filtering of new connections.

+            Specified where logging should go.

             </summary>

-            <param name="socket">Accepted socket</param>

-            <returns>true if connection can be accepted; otherwise false.</returns>

+            <seealso cref="T:HttpServer.NullLogWriter"/>

+            <seealso cref="T:HttpServer.ConsoleLogWriter"/>

+            <seealso cref="P:HttpServer.HttpServer.LogWriter"/>

         </member>

-        <member name="M:HttpServer.HttpListenerBase.Start(System.Int32)">

+        <member name="P:HttpServer.HttpServer.BackLog">

             <summary>

-            Start listen for new connections

+            Number of connections that can wait to be accepted by the server.

             </summary>

-            <param name="backlog">Number of connections that can stand in a queue to be accepted.</param>

-            <exception cref="T:System.InvalidOperationException">Listener have already been started.</exception>

+            <remarks>Default is 10.</remarks>

         </member>

-        <member name="M:HttpServer.HttpListenerBase.Stop">

+        <member name="P:HttpServer.HttpServer.MaxRequestCount">

             <summary>

-            Stop the listener

+            Gets or sets maximum number of allowed simultaneous requests.

             </summary>

-            <exception cref="T:System.Net.Sockets.SocketException"></exception>

+            <remarks>

+            <para>

+            This property is useful in busy systems. The HTTP server

+            will start queuing new requests if this limit is hit, instead

+            of trying to process all incoming requests directly.

+            </para>

+            <para>

+            The default number if allowed simultaneous requests are 10.

+            </para>

+            </remarks>

         </member>

-        <member name="P:HttpServer.HttpListenerBase.LogWriter">

+        <member name="P:HttpServer.HttpServer.MaxQueueSize">

             <summary>

-            Gives you a change to receive log entries for all internals of the HTTP library.

+            Gets or sets maximum number of requests queuing to be handled.

             </summary>

             <remarks>

-            You may not switch log writer after starting the listener.

+            <para>

+            The WebServer will start turning requests away if response code

+            <see cref="F:System.Net.HttpStatusCode.ServiceUnavailable"/> to indicate that the server

+            is too busy to be able to handle the request.

+            </para>

             </remarks>

         </member>

-        <member name="P:HttpServer.HttpListenerBase.UseTraceLogs">

+        <member name="E:HttpServer.HttpServer.RealmWanted">

             <summary>

-            True if we should turn on trace logs.

+            Realms are used during HTTP authentication.

+            Default realm is same as server name.

             </summary>

         </member>

-        <member name="E:HttpServer.HttpListenerBase.ExceptionThrown">

+        <member name="E:HttpServer.HttpServer.ExceptionThrown">

             <summary>

-            Catch exceptions not handled by the listener.

+            Let's to receive unhandled exceptions from the threads.

             </summary>

             <remarks>

             Exceptions will be thrown during debug mode if this event is not used,

             exceptions will be printed to console and suppressed during release mode.

             </remarks>

         </member>

-        <member name="E:HttpServer.HttpListenerBase.RequestReceived">

+        <member name="T:HttpServer.HttpModules.ResourceFileModule">

             <summary>

-            A request have been received from a <see cref="T:HttpServer.IHttpClientContext"/>.

+            Serves files that are stored in embedded resources.

             </summary>

         </member>

-        <member name="T:HttpServer.FormDecoders.MultipartDecoder">

+        <member name="T:HttpServer.HttpModules.HttpModule">

             <summary>

-            

+            A HttpModule can be used to serve Uri's. The module itself

+            decides if it should serve a Uri or not. In this way, you can

+            get a very flexible http application since you can let multiple modules

+            serve almost similar urls.

             </summary>

             <remarks>

-            http://www.faqs.org/rfcs/rfc1867.html

+            Throw <see cref="T:HttpServer.Exceptions.UnauthorizedException"/> if you are using a <see cref="T:HttpServer.Authentication.AuthenticationModule"/> and want to prompt for user name/password.

             </remarks>

         </member>

-        <member name="T:HttpServer.FormDecoders.IFormDecoder">

-            <summary>

-            Interface for form content decoders.

-            </summary>

-        </member>

-        <member name="M:HttpServer.FormDecoders.IFormDecoder.Decode(System.IO.Stream,System.String,System.Text.Encoding)">

-            <summary>

-            

-            </summary>

-            <param name="stream">Stream containing the content</param>

-            <param name="contentType">Content type (with any additional info like boundry). Content type is always supplied in lower case</param>

-            <param name="encoding">Stream enconding</param>

-            <returns>A http form, or null if content could not be parsed.</returns>

-            <exception cref="T:System.IO.InvalidDataException">If contents in the stream is not valid input data.</exception>

-        </member>

-        <member name="M:HttpServer.FormDecoders.IFormDecoder.CanParse(System.String)">

-            <summary>

-            Checks if the decoder can handle the mime type

-            </summary>

-            <param name="contentType">Content type (with any additional info like boundry). Content type is always supplied in lower case.</param>

-            <returns>True if the decoder can parse the specified content type</returns>

-        </member>

-        <member name="F:HttpServer.FormDecoders.MultipartDecoder.MimeType">

-            <summary>

-            multipart/form-data

-            </summary>

-        </member>

-        <member name="F:HttpServer.FormDecoders.MultipartDecoder.FormData">

-            <summary>

-            form-data

-            </summary>

-        </member>

-        <member name="M:HttpServer.FormDecoders.MultipartDecoder.Decode(System.IO.Stream,System.String,System.Text.Encoding)">

-            <summary>

-            

-            </summary>

-            <param name="stream">Stream containing the content</param>

-            <param name="contentType">Content type (with any additional info like boundry). Content type is always supplied in lower case</param>

-            <param name="encoding">Stream enconding</param>

-            <returns>A http form, or null if content could not be parsed.</returns>

-            <exception cref="T:System.IO.InvalidDataException">If contents in the stream is not valid input data.</exception>

-            <exception cref="T:System.ArgumentNullException">If any parameter is null</exception>

-        </member>

-        <member name="M:HttpServer.FormDecoders.MultipartDecoder.CanParse(System.String)">

-            <summary>

-            Checks if the decoder can handle the mime type

-            </summary>

-            <param name="contentType">Content type (with any additional info like boundry). Content type is always supplied in lower case.</param>

-            <returns>True if the decoder can parse the specified content type</returns>

-        </member>

-        <member name="T:HttpServer.Exceptions.NotFoundException">

-            <summary>

-            The requested resource was not found in the web server.

-            </summary>

-        </member>

-        <member name="M:HttpServer.Exceptions.NotFoundException.#ctor(System.String,System.Exception)">

-            <summary>

-            Create a new exception

-            </summary>

-            <param name="message">message describing the error</param>

-            <param name="inner">inner exception</param>

-        </member>

-        <member name="M:HttpServer.Exceptions.NotFoundException.#ctor(System.String)">

-            <summary>

-            Create a new exception

-            </summary>

-            <param name="message">message describing the error</param>

-        </member>

-        <member name="T:HttpServer.Authentication.AuthenticationHandler">

+        <member name="M:HttpServer.HttpModules.HttpModule.Process(HttpServer.IHttpRequest,HttpServer.IHttpResponse,HttpServer.Sessions.IHttpSession)">

             <summary>

-            Delegate used to let authentication modules authenticate the user name and password.

+            Method that process the url

             </summary>

-            <param name="realm">Realm that the user want to authenticate in</param>

-            <param name="userName">User name specified by client</param>

-            <param name="token">Can either be user password or implementation specific token.</param>

-            <param name="login">object that will be stored in a session variable called <see cref="F:HttpServer.Authentication.AuthenticationModule.AuthenticationTag"/> if authentication was successful.</param>

-            <exception cref="T:HttpServer.Exceptions.ForbiddenException">throw forbidden exception if too many attempts have been made.</exception>

-            <remarks>

-            <para>

-            Use <see cref="P:HttpServer.Authentication.DigestAuthentication.TokenIsHA1"/> to specify that the token is a HA1 token. (MD5 generated

-            string from realm, user name and password); Md5String(userName + ":" + realm + ":" + password);

-            </para>

-            </remarks>

+            <param name="request">Information sent by the browser about the request</param>

+            <param name="response">Information that is being sent back to the client.</param>

+            <param name="session">Session used to </param>

+            <returns>true if this module handled the request.</returns>

         </member>

-        <member name="T:HttpServer.Authentication.AuthenticationRequiredHandler">

+        <member name="M:HttpServer.HttpModules.HttpModule.SetLogWriter(HttpServer.ILogWriter)">

             <summary>

-            Let's you decide on a system level if authentication is required.

+            Set the log writer to use.

             </summary>

-            <param name="request">HTTP request from client</param>

-            <returns>true if user should be authenticated.</returns>

-            <remarks>throw <see cref="T:HttpServer.Exceptions.ForbiddenException"/> if no more attempts are allowed.</remarks>

-            <exception cref="T:HttpServer.Exceptions.ForbiddenException">If no more attempts are allowed</exception>

+            <param name="writer">logwriter to use.</param>

         </member>

-        <member name="T:HttpServer.Authentication.AuthenticationModule">

+        <member name="M:HttpServer.HttpModules.HttpModule.Write(HttpServer.LogPrio,System.String)">

             <summary>

-            Authentication modules are used to implement different

-            kind of HTTP authentication.

+            Log something.

             </summary>

+            <param name="prio">importance of log message</param>

+            <param name="message">message</param>

         </member>

-        <member name="F:HttpServer.Authentication.AuthenticationModule.AuthenticationTag">

+        <member name="P:HttpServer.HttpModules.HttpModule.AllowSecondaryProcessing">

             <summary>

-            Tag used for authentication.

+            If true specifies that the module doesn't consume the processing of a request so that subsequent modules

+            can continue processing afterwards. Default is false.

             </summary>

         </member>

-        <member name="M:HttpServer.Authentication.AuthenticationModule.#ctor(HttpServer.Authentication.AuthenticationHandler,HttpServer.Authentication.AuthenticationRequiredHandler)">

+        <member name="M:HttpServer.HttpModules.ResourceFileModule.#ctor">

             <summary>

-            Initializes a new instance of the <see cref="T:HttpServer.Authentication.AuthenticationModule"/> class.

+            Initializes a new instance of the <see cref="T:HttpServer.HttpModules.ResourceFileModule"/> class.

+            Runs <see cref="M:HttpServer.HttpModules.ResourceFileModule.AddDefaultMimeTypes"/> to make sure the basic mime types are available, they can be cleared later

+            through the use of <see cref="P:HttpServer.HttpModules.ResourceFileModule.MimeTypes"/> if desired.

             </summary>

-            <param name="authenticator">Delegate used to provide information used during authentication.</param>

-            <param name="authenticationRequiredHandler">Delegate used to determine if authentication is required (may be null).</param>

         </member>

-        <member name="M:HttpServer.Authentication.AuthenticationModule.#ctor(HttpServer.Authentication.AuthenticationHandler)">

+        <member name="M:HttpServer.HttpModules.ResourceFileModule.#ctor(HttpServer.ILogWriter)">

             <summary>

-            Initializes a new instance of the <see cref="T:HttpServer.Authentication.AuthenticationModule"/> class.

+            Initializes a new instance of the <see cref="T:HttpServer.HttpModules.ResourceFileModule"/> class.

+            Runs <see cref="M:HttpServer.HttpModules.ResourceFileModule.AddDefaultMimeTypes"/> to make sure the basic mime types are available, they can be cleared later

+            through the use of <see cref="P:HttpServer.HttpModules.ResourceFileModule.MimeTypes"/> if desired.

             </summary>

-            <param name="authenticator">Delegate used to provide information used during authentication.</param>

+            <param name="logWriter">The log writer to use when logging events</param>

         </member>

-        <member name="M:HttpServer.Authentication.AuthenticationModule.CreateResponse(System.String,System.Object[])">

+        <member name="M:HttpServer.HttpModules.ResourceFileModule.AddDefaultMimeTypes">

             <summary>

-            Create a response that can be sent in the WWW-Authenticate header.

+            Mimtypes that this class can handle per default

             </summary>

-            <param name="realm">Realm that the user should authenticate in</param>

-            <param name="options">Array with optional options.</param>

-            <returns>A correct authentication request.</returns>

-            <exception cref="T:System.ArgumentNullException">If realm is empty or null.</exception>

         </member>

-        <member name="M:HttpServer.Authentication.AuthenticationModule.Authenticate(System.String,System.String,System.String,System.Object[])">

+        <member name="M:HttpServer.HttpModules.ResourceFileModule.AddResources(System.String,System.Reflection.Assembly,System.String)">

             <summary>

-            An authentication response have been received from the web browser.

-            Check if it's correct

+            Loads resources from a namespace in the given assembly to an uri

             </summary>

-            <param name="authenticationHeader">Contents from the Authorization header</param>

-            <param name="realm">Realm that should be authenticated</param>

-            <param name="httpVerb">GET/POST/PUT/DELETE etc.</param>

-            <param name="options">options to specific implementations</param>

-            <returns>Authentication object that is stored for the request. A user class or something like that.</returns>

-            <exception cref="T:System.ArgumentException">if <paramref name="authenticationHeader"/> is invalid</exception>

-            <exception cref="T:System.ArgumentNullException">If any of the parameters is empty or null.</exception>

+            <param name="toUri">The uri to map the resources to</param>

+            <param name="fromAssembly">The assembly in which the resources reside</param>

+            <param name="fromNamespace">The namespace from which to load the resources</param>

+            <usage>

+            resourceLoader.LoadResources("/user/", typeof(User).Assembly, "MyLib.Models.User.Views");

+            

+            will make ie the resource MyLib.Models.User.Views.stylesheet.css accessible via /user/stylesheet.css

+            </usage>

+            <returns>The amount of loaded files, giving you the possibility of making sure the resources needed gets loaded</returns>

         </member>

-        <member name="M:HttpServer.Authentication.AuthenticationModule.CheckAuthentication(System.String,System.String,System.String@,System.Object@)">

+        <member name="M:HttpServer.HttpModules.ResourceFileModule.CanHandle(HttpServer.IHttpRequest)">

             <summary>

-            Used to invoke the authentication delegate that is used to lookup the user name/realm.

+            Returns true if the module can handle the request

             </summary>

-            <param name="realm">Realm (domain) that user want to authenticate in</param>

-            <param name="userName">User name</param>

-            <param name="password">Password used for validation. Some implementations got password in clear text, they are then sent to client.</param>

-            <param name="login">object that will be stored in the request to help you identify the user if authentication was successful.</param>

-            <returns>true if authentication was successful</returns>

         </member>

-        <member name="M:HttpServer.Authentication.AuthenticationModule.AuthenticationRequired(HttpServer.IHttpRequest)">

+        <member name="M:HttpServer.HttpModules.ResourceFileModule.Process(HttpServer.IHttpRequest,HttpServer.IHttpResponse,HttpServer.Sessions.IHttpSession)">

             <summary>

-            Determines if authentication is required.

+            Method that process the url

             </summary>

-            <param name="request">HTTP request from browser</param>

-            <returns>true if user should be authenticated.</returns>

-            <remarks>throw <see cref="T:HttpServer.Exceptions.ForbiddenException"/> from your delegate if no more attempts are allowed.</remarks>

-            <exception cref="T:HttpServer.Exceptions.ForbiddenException">If no more attempts are allowed</exception>

+            <param name="request">Information sent by the browser about the request</param>

+            <param name="response">Information that is being sent back to the client.</param>

+            <param name="session">Session used to </param>

+            <returns>true if this module handled the request.</returns>

         </member>

-        <member name="P:HttpServer.Authentication.AuthenticationModule.Name">

+        <member name="P:HttpServer.HttpModules.ResourceFileModule.MimeTypes">

             <summary>

-            name used in HTTP request.

+            List with all mime-type that are allowed. 

             </summary>

+            <remarks>All other mime types will result in a Forbidden http status code.</remarks>

         </member>

         <member name="T:HttpServer.HttpInput">

             <summary>

@@ -1062,444 +561,216 @@
             <param name="name"></param>

             <returns>Returns <see cref="F:HttpServer.HttpInputItem.Empty"/> if item was not found.</returns>

         </member>

-        <member name="T:HttpServer.Check">

-            <summary>

-            Small design by contract implementation.

-            </summary>

-        </member>

-        <member name="M:HttpServer.Check.NotEmpty(System.String,System.String)">

-            <summary>

-            Check whether a parameter is empty.

-            </summary>

-            <param name="value">Parameter value</param>

-            <param name="parameterOrErrorMessage">Parameter name, or error description.</param>

-            <exception cref="T:System.ArgumentException">value is empty.</exception>

-        </member>

-        <member name="M:HttpServer.Check.Require(System.Object,System.String)">

-            <summary>

-            Checks whether a parameter is null.

-            </summary>

-            <param name="value">Parameter value</param>

-            <param name="parameterOrErrorMessage">Parameter name, or error description.</param>

-            <exception cref="T:System.ArgumentNullException">value is null.</exception>

-        </member>

-        <member name="M:HttpServer.Check.Min(System.Int32,System.Object,System.String)">

-            <summary>

-            Checks whether a parameter is null.

-            </summary>

-            <param name="minValue"></param>

-            <param name="value">Parameter value</param>

-            <param name="parameterOrErrorMessage">Parameter name, or error description.</param>

-            <exception cref="T:System.ArgumentException">value is null.</exception>

-        </member>

-        <member name="T:HttpServer.Method">

-            <summary>

-            Contains all HTTP Methods (according to the HTTP 1.1 specification)

-            <para>

-            See: http://www.w3.org/Protocols/rfc2616/rfc2616-sec9.html

-            </para>

-            </summary>

-        </member>

-        <member name="F:HttpServer.Method.Delete">

-            <summary>

-            The DELETE method requests that the origin server delete the resource identified by the Request-URI.

-            </summary>

-            <remarks>

-            <para>

-            This method MAY be overridden by human intervention (or other means) on the origin server. 

-            The client cannot be guaranteed that the operation has been carried out, even if the status code 

-            returned from the origin server indicates that the action has been completed successfully. 

-            </para>

-            <para>

-            However, the server SHOULD NOT indicate success unless, at the time the response is given, 

-            it intends to delete the resource or move it to an inaccessible location.

-            </para>

-            <para>

-            A successful response SHOULD be 200 (OK) if the response includes an entity describing the status, 

-            202 (Accepted) if the action has not yet been enacted, 

-            or 204 (No Content) if the action has been enacted but the response does not include an entity.

-            </para>

-            <para>

-            If the request passes through a cache and the Request-URI identifies one or more currently cached entities, 

-            those entries SHOULD be treated as stale. Responses to this method are not cacheable. 

-            </para>

-            </remarks>

-        </member>

-        <member name="F:HttpServer.Method.Get">

-            <summary>

-            The GET method means retrieve whatever information (in the form of an entity) is identified by the Request-URI.

-            </summary>

-            <remarks>

-            <para>

-            If the Request-URI refers to a data-producing process, it is the produced data which shall be returned as the 

-            entity in the response and not the source text of the process, unless that text happens to be the output of the process.

-            </para>

-            <para>

-            The semantics of the GET method change to a "conditional GET" if the request message includes an 

-            If-Modified-Since, If-Unmodified-Since, If-Match, If-None-Match, or If-Range header field. 

-            A conditional GET method requests that the entity be transferred only under the circumstances described 

-            by the conditional header field(s). The conditional GET method is intended to reduce unnecessary network 

-            usage by allowing cached entities to be refreshed without requiring multiple requests or transferring 

-            data already held by the client.

-            </para>

-            </remarks>

-        </member>

-        <member name="F:HttpServer.Method.Header">

+        <member name="T:HttpServer.Exceptions.ForbiddenException">

             <summary>

-            The HEAD method is identical to GET except that the server MUST NOT return a message-body in the response. 

-            </summary>

-            <remarks>

-            The meta information contained in the HTTP headers in response to a HEAD request SHOULD be identical to the

-             information sent in response to a GET request. This method can be used for obtaining meta information about 

-            the entity implied by the request without transferring the entity-body itself. 

+            The server understood the request, but is refusing to fulfill it. 

+            Authorization will not help and the request SHOULD NOT be repeated. 

+            If the request method was not HEAD and the server wishes to make public why the request has not been fulfilled, 

+            it SHOULD describe the reason for the refusal in the entity. If the server does not wish to make this information 

+            available to the client, the status code 404 (Not Found) can be used instead.

             

-            This method is often used for testing hypertext links for validity, accessibility, and recent modification.

-            </remarks>

-        </member>

-        <member name="F:HttpServer.Method.Options">

-            <summary>

-            <para>The OPTIONS method represents a request for information about the communication options available on the request/response chain identified by the Request-URI.</para>

+            Text taken from: http://www.submissionchamber.com/help-guides/error-codes.php

             </summary>

-            <remarks>

-            <para>This method allows the client to determine the options and/or requirements associated with a resource, or the capabilities of a server, without implying a resource action or initiating a resource retrieval.</para>

-            </remarks>

         </member>

-        <member name="F:HttpServer.Method.Post">

+        <member name="T:HttpServer.Exceptions.HttpException">

             <summary>

-            The POST method is used to request that the origin server accept the entity enclosed 

-            in the request as a new subordinate of the resource identified by the Request-URI in the Request-Line.

+            All HTTP based exceptions will derive this class.

             </summary>

-            <remarks>

-            POST is designed to allow a uniform method to cover the following functions:

-            <list type="bullet">

-            <item>

-            Annotation of existing resources;

-            </item><item>

-            Posting a message to a bulletin board, newsgroup, mailing list, or similar group of articles;

-            </item><item>

-            Providing a block of data, such as the result of submitting a form, to a data-handling process;

-            </item><item>

-            Extending a database through an append operation.

-            </item>

-            </list>

-            <para>

-            If a resource has been created on the origin server, the response SHOULD be 201 (Created) and 

-            contain an entity which describes the status of the request and refers to the new resource, and a 

-            Location header (see section 14.30).

-            </para>

-            <para>

-             The action performed by the POST method might not result in a resource that can be identified by a URI. 

-            In this case, either 200 (OK) or 204 (No Content) is the appropriate response status, depending on 

-            whether or not the response includes an entity that describes the result.

-            </para><para>

-            Responses to this method are not cacheable, unless the response includes appropriate Cache-Control 

-            or Expires header fields. However, the 303 (See Other) response can be used to direct the user agent 

-            to retrieve a cacheable resource. 

-            </para>

-            </remarks>

         </member>

-        <member name="F:HttpServer.Method.Put">

+        <member name="M:HttpServer.Exceptions.HttpException.#ctor(System.Net.HttpStatusCode,System.String)">

             <summary>

-            The PUT method requests that the enclosed entity be stored under the supplied Request-URI.

+            Create a new HttpException

             </summary>

-            <remarks>

-            <list type="bullet">

-            <item>

-            If the Request-URI refers to an already existing resource, the enclosed entity SHOULD be considered as a 

-            modified version of the one residing on the origin server. 

-            </item><item>

-            If the Request-URI does not point to an existing resource, and that URI is capable of being defined as a new 

-            resource by the requesting user agent, the origin server can create the resource with that URI. 

-            </item><item>

-            If a new resource is created, the origin server MUST inform the user agent via the 201 (Created) response. 

-            </item><item>

-            If an existing resource is modified, either the 200 (OK) or 204 (No Content) response codes SHOULD be sent to 

-            indicate successful completion of the request. 

-            </item><item>

-            If the resource could not be created or modified with the Request-URI, an appropriate error response SHOULD be 

-            given that reflects the nature of the problem. 

-            </item>

-            </list>

-            <para>

-            The recipient of the entity MUST NOT ignore any Content-* (e.g. Content-Range) headers that it does not 

-            understand or implement and MUST return a 501 (Not Implemented) response in such cases.

-            </para>

-            </remarks>

+            <param name="code">http status code (sent in the response)</param>

+            <param name="message">error description</param>

         </member>

-        <member name="F:HttpServer.Method.Trace">

+        <member name="M:HttpServer.Exceptions.HttpException.#ctor(System.Net.HttpStatusCode,System.String,System.Exception)">

             <summary>

-            The TRACE method is used to invoke a remote, application-layer loop- back of the request message.

+            Create a new HttpException

             </summary>

+            <param name="code">http status code (sent in the response)</param>

+            <param name="message">error description</param>

+            <param name="inner">inner exception</param>

         </member>

-        <member name="T:HttpServer.Methods">

+        <member name="P:HttpServer.Exceptions.HttpException.HttpStatusCode">

             <summary>

-            Contains all HTTP Methods (according to the HTTP 1.1 specification)

-            <para>

-            See: http://www.w3.org/Protocols/rfc2616/rfc2616-sec9.html

-            </para>

+            status code to use in the response.

             </summary>

         </member>

-        <member name="F:HttpServer.Methods.Delete">

+        <member name="M:HttpServer.Exceptions.ForbiddenException.#ctor(System.String)">

             <summary>

-            The DELETE method requests that the origin server delete the resource identified by the Request-URI.

+            Initializes a new instance of the <see cref="T:HttpServer.Exceptions.ForbiddenException"/> class.

             </summary>

-            <remarks>

-            <para>

-            This method MAY be overridden by human intervention (or other means) on the origin server. 

-            The client cannot be guaranteed that the operation has been carried out, even if the status code 

-            returned from the origin server indicates that the action has been completed successfully. 

-            </para>

-            <para>

-            However, the server SHOULD NOT indicate success unless, at the time the response is given, 

-            it intends to delete the resource or move it to an inaccessible location.

-            </para>

-            <para>

-            A successful response SHOULD be 200 (OK) if the response includes an entity describing the status, 

-            202 (Accepted) if the action has not yet been enacted, 

-            or 204 (No Content) if the action has been enacted but the response does not include an entity.

-            </para>

-            <para>

-            If the request passes through a cache and the Request-URI identifies one or more currently cached entities, 

-            those entries SHOULD be treated as stale. Responses to this method are not cacheable. 

-            </para>

-            </remarks>

+            <param name="errorMsg">error message</param>

         </member>

-        <member name="F:HttpServer.Methods.Get">

+        <member name="T:HttpServer.RequestCookies">

             <summary>

-            The GET method means retrieve whatever information (in the form of an entity) is identified by the Request-URI.

+            This class is created as a wrapper, since there are two different cookie types in .Net (Cookie and HttpCookie).

+            The framework might switch class in the future and we dont want to have to replace all instances

             </summary>

-            <remarks>

-            <para>

-            If the Request-URI refers to a data-producing process, it is the produced data which shall be returned as the 

-            entity in the response and not the source text of the process, unless that text happens to be the output of the process.

-            </para>

-            <para>

-            The semantics of the GET method change to a "conditional GET" if the request message includes an 

-            If-Modified-Since, If-Unmodified-Since, If-Match, If-None-Match, or If-Range header field. 

-            A conditional GET method requests that the entity be transferred only under the circumstances described 

-            by the conditional header field(s). The conditional GET method is intended to reduce unnecessary network 

-            usage by allowing cached entities to be refreshed without requiring multiple requests or transferring 

-            data already held by the client.

-            </para>

-            </remarks>

         </member>

-        <member name="F:HttpServer.Methods.Header">

+        <member name="M:HttpServer.RequestCookies.#ctor(System.String)">

             <summary>

-            The HEAD method is identical to GET except that the server MUST NOT return a message-body in the response. 

+            Let's copy all the cookies.

             </summary>

-            <remarks>

-            The meta information contained in the HTTP headers in response to a HEAD request SHOULD be identical to the

-             information sent in response to a GET request. This method can be used for obtaining meta information about 

-            the entity implied by the request without transferring the entity-body itself. 

-            

-            This method is often used for testing hypertext links for validity, accessibility, and recent modification.

-            </remarks>

+            <param name="cookies">value from cookie header.</param>

         </member>

-        <member name="F:HttpServer.Methods.Options">

+        <member name="M:HttpServer.RequestCookies.Add(HttpServer.RequestCookie)">

             <summary>

-            <para>The OPTIONS method represents a request for information about the communication options available on the request/response chain identified by the Request-URI.</para>

+            Adds a cookie in the collection.

             </summary>

-            <remarks>

-            <para>This method allows the client to determine the options and/or requirements associated with a resource, or the capabilities of a server, without implying a resource action or initiating a resource retrieval.</para>

-            </remarks>

+            <param name="cookie">cookie to add</param>

+            <exception cref="T:System.ArgumentNullException">cookie is null</exception>

         </member>

-        <member name="F:HttpServer.Methods.Post">

+        <member name="M:HttpServer.RequestCookies.GetEnumerator">

             <summary>

-            The POST method is used to request that the origin server accept the entity enclosed 

-            in the request as a new subordinate of the resource identified by the Request-URI in the Request-Line.

+            Gets a collection enumerator on the cookie list.

             </summary>

-            <remarks>

-            POST is designed to allow a uniform method to cover the following functions:

-            <list type="bullet">

-            <item>

-            Annotation of existing resources;

-            </item><item>

-            Posting a message to a bulletin board, newsgroup, mailing list, or similar group of articles;

-            </item><item>

-            Providing a block of data, such as the result of submitting a form, to a data-handling process;

-            </item><item>

-            Extending a database through an append operation.

-            </item>

-            </list>

-            <para>

-            If a resource has been created on the origin server, the response SHOULD be 201 (Created) and 

-            contain an entity which describes the status of the request and refers to the new resource, and a 

-            Location header (see section 14.30).

-            </para>

-            <para>

-             The action performed by the POST method might not result in a resource that can be identified by a URI. 

-            In this case, either 200 (OK) or 204 (No Content) is the appropriate response status, depending on 

-            whether or not the response includes an entity that describes the result.

-            </para><para>

-            Responses to this method are not cacheable, unless the response includes appropriate Cache-Control 

-            or Expires header fields. However, the 303 (See Other) response can be used to direct the user agent 

-            to retrieve a cacheable resource. 

-            </para>

-            </remarks>

+            <returns>collection enumerator</returns>

         </member>

-        <member name="F:HttpServer.Methods.Put">

+        <member name="M:HttpServer.RequestCookies.Clear">

             <summary>

-            The PUT method requests that the enclosed entity be stored under the supplied Request-URI.

+            Remove all cookies.

             </summary>

-            <remarks>

-            <list type="bullet">

-            <item>

-            If the Request-URI refers to an already existing resource, the enclosed entity SHOULD be considered as a 

-            modified version of the one residing on the origin server. 

-            </item><item>

-            If the Request-URI does not point to an existing resource, and that URI is capable of being defined as a new 

-            resource by the requesting user agent, the origin server can create the resource with that URI. 

-            </item><item>

-            If a new resource is created, the origin server MUST inform the user agent via the 201 (Created) response. 

-            </item><item>

-            If an existing resource is modified, either the 200 (OK) or 204 (No Content) response codes SHOULD be sent to 

-            indicate successful completion of the request. 

-            </item><item>

-            If the resource could not be created or modified with the Request-URI, an appropriate error response SHOULD be 

-            given that reflects the nature of the problem. 

-            </item>

-            </list>

-            <para>

-            The recipient of the entity MUST NOT ignore any Content-* (e.g. Content-Range) headers that it does not 

-            understand or implement and MUST return a 501 (Not Implemented) response in such cases.

-            </para>

-            </remarks>

         </member>

-        <member name="F:HttpServer.Methods.Trace">

+        <member name="M:HttpServer.RequestCookies.System#Collections#Generic#IEnumerable{HttpServer#RequestCookie}#GetEnumerator">

             <summary>

-            The TRACE method is used to invoke a remote, application-layer loop- back of the request message.

+            Returns an enumerator that iterates through the collection.

             </summary>

+            

+            <returns>

+            A <see cref="T:System.Collections.Generic.IEnumerator`1"></see> that can be used to iterate through the collection.

+            </returns>

+            <filterpriority>1</filterpriority>

         </member>

-        <member name="T:HttpServer.LogPrio">

+        <member name="M:HttpServer.RequestCookies.Remove(System.String)">

             <summary>

-            Priority for log entries

+            Remove a cookie from the collection.

             </summary>

-            <seealso cref="T:HttpServer.ILogWriter"/>

+            <param name="cookieName">Name of cookie.</param>

         </member>

-        <member name="F:HttpServer.LogPrio.Trace">

+        <member name="P:HttpServer.RequestCookies.Count">

             <summary>

-            Very detailed logs to be able to follow the flow of the program.

+            Gets the count of cookies in the collection.

             </summary>

         </member>

-        <member name="F:HttpServer.LogPrio.Debug">

+        <member name="P:HttpServer.RequestCookies.Item(System.String)">

             <summary>

-            Logs to help debug errors in the application

+            Gets the cookie of a given identifier (null if not existing).

             </summary>

         </member>

-        <member name="F:HttpServer.LogPrio.Info">

+        <member name="T:HttpServer.IHttpClientContext">

             <summary>

-            Information to be able to keep track of state changes etc.

+            Contains a connection to a browser/client.

             </summary>

         </member>

-        <member name="F:HttpServer.LogPrio.Warning">

+        <member name="M:HttpServer.IHttpClientContext.Disconnect(System.Net.Sockets.SocketError)">

             <summary>

-            Something did not go as we expected, but it's no problem.

+            Disconnect from client

             </summary>

+            <param name="error">error to report in the <see cref="E:HttpServer.IHttpClientContext.Disconnected"/> event.</param>

         </member>

-        <member name="F:HttpServer.LogPrio.Error">

+        <member name="M:HttpServer.IHttpClientContext.Respond(System.String,System.Net.HttpStatusCode,System.String,System.String,System.String)">

             <summary>

-            Something that should not fail failed, but we can still keep

-            on going.

+            Send a response.

             </summary>

+            <param name="httpVersion">Either <see cref="F:HttpServer.HttpHelper.HTTP10"/> or <see cref="F:HttpServer.HttpHelper.HTTP11"/></param>

+            <param name="statusCode">HTTP status code</param>

+            <param name="reason">reason for the status code.</param>

+            <param name="body">HTML body contents, can be null or empty.</param>

+            <param name="contentType">A content type to return the body as, i.e. 'text/html' or 'text/plain', defaults to 'text/html' if null or empty</param>

+            <exception cref="T:System.ArgumentException">If <paramref name="httpVersion"/> is invalid.</exception>

         </member>

-        <member name="F:HttpServer.LogPrio.Fatal">

+        <member name="M:HttpServer.IHttpClientContext.Respond(System.String,System.Net.HttpStatusCode,System.String)">

             <summary>

-            Something failed, and we cannot handle it properly.

+            Send a response.

             </summary>

+            <param name="httpVersion">Either <see cref="F:HttpServer.HttpHelper.HTTP10"/> or <see cref="F:HttpServer.HttpHelper.HTTP11"/></param>

+            <param name="statusCode">HTTP status code</param>

+            <param name="reason">reason for the status code.</param>

         </member>

-        <member name="T:HttpServer.ILogWriter">

+        <member name="M:HttpServer.IHttpClientContext.Respond(System.String)">

             <summary>

-            Interface used to write to log files.

+            Send a response.

             </summary>

+            <exception cref="T:System.ArgumentNullException"></exception>

         </member>

-        <member name="M:HttpServer.ILogWriter.Write(System.Object,HttpServer.LogPrio,System.String)">

+        <member name="M:HttpServer.IHttpClientContext.Send(System.Byte[])">

             <summary>

-            Write an entry to the log file.

+            send a whole buffer

             </summary>

-            <param name="source">object that is writing to the log</param>

-            <param name="priority">importance of the log message</param>

-            <param name="message">the message</param>

+            <param name="buffer">buffer to send</param>

+            <exception cref="T:System.ArgumentNullException"></exception>

         </member>

-        <member name="T:HttpServer.ConsoleLogWriter">

+        <member name="M:HttpServer.IHttpClientContext.Send(System.Byte[],System.Int32,System.Int32)">

             <summary>

-            This class writes to the console. It colors the output depending on the logprio and includes a 3-level stacktrace (in debug mode)

+            Send data using the stream

             </summary>

-            <seealso cref="T:HttpServer.ILogWriter"/>

+            <param name="buffer">Contains data to send</param>

+            <param name="offset">Start position in buffer</param>

+            <param name="size">number of bytes to send</param>

+            <exception cref="T:System.ArgumentNullException"></exception>

+            <exception cref="T:System.ArgumentOutOfRangeException"></exception>

         </member>

-        <member name="F:HttpServer.ConsoleLogWriter.Instance">

+        <member name="M:HttpServer.IHttpClientContext.Close">

             <summary>

-            The actual instance of this class.

+            Closes the streams and disposes of the unmanaged resources

             </summary>

         </member>

-        <member name="M:HttpServer.ConsoleLogWriter.Write(System.Object,HttpServer.LogPrio,System.String)">

+        <member name="P:HttpServer.IHttpClientContext.Secured">

             <summary>

-            Logwriters the specified source.

+            Using SSL or other encryption method.

             </summary>

-            <param name="source">object that wrote the logentry.</param>

-            <param name="prio">Importance of the log message</param>

-            <param name="message">The message.</param>

         </member>

-        <member name="M:HttpServer.ConsoleLogWriter.GetColor(HttpServer.LogPrio)">

+        <member name="P:HttpServer.IHttpClientContext.IsSecured">

             <summary>

-            Get color for the specified logprio

+            Using SSL or other encryption method.

             </summary>

-            <param name="prio">prio for the log entry</param>

-            <returns>A <see cref="T:System.ConsoleColor"/> for the prio</returns>

         </member>

-        <member name="T:HttpServer.NullLogWriter">

+        <member name="E:HttpServer.IHttpClientContext.Disconnected">

             <summary>

-            Default log writer, writes everything to null (nowhere).

+            The context have been disconnected.

             </summary>

-            <seealso cref="T:HttpServer.ILogWriter"/>

+            <remarks>

+            Event can be used to clean up a context, or to reuse it.

+            </remarks>

         </member>

-        <member name="F:HttpServer.NullLogWriter.Instance">

+        <member name="E:HttpServer.IHttpClientContext.RequestReceived">

             <summary>

-            The logging instance.

+            A request have been received in the context.

             </summary>

         </member>

-        <member name="M:HttpServer.NullLogWriter.Write(System.Object,HttpServer.LogPrio,System.String)">

+        <member name="T:HttpServer.DisconnectedEventArgs">

             <summary>

-            Writes everything to null

+            A <see cref="T:HttpServer.IHttpClientContext"/> have been disconnected.

             </summary>

-            <param name="source">object that wrote the log entry.</param>

-            <param name="prio">Importance of the log message</param>

-            <param name="message">The message.</param>

         </member>

-        <member name="T:HttpServer.IComponentProvider">

+        <member name="M:HttpServer.DisconnectedEventArgs.#ctor(System.Net.Sockets.SocketError)">

             <summary>

-            Inversion of control interface.

+            Initializes a new instance of the <see cref="T:HttpServer.DisconnectedEventArgs"/> class.

             </summary>

+            <param name="error">Reason to disconnection.</param>

         </member>

-        <member name="M:HttpServer.IComponentProvider.AddInstance``1(System.Object)">

+        <member name="P:HttpServer.DisconnectedEventArgs.Error">

             <summary>

-            Add a component instance

+            Gets reason to why client disconnected.

             </summary>

-            <typeparam name="T">Interface type</typeparam>

-            <param name="instance">Instance to add</param>

         </member>

-        <member name="M:HttpServer.IComponentProvider.Get``1">

+        <member name="T:HttpServer.RequestEventArgs">

             <summary>

-            Get a component.

+            

             </summary>

-            <typeparam name="T">Interface type</typeparam>

-            <returns>Component if registered, otherwise null.</returns>

-            <remarks>

-            Component will get created if needed.

-            </remarks>

         </member>

-        <member name="M:HttpServer.IComponentProvider.Contains(System.Type)">

+        <member name="M:HttpServer.RequestEventArgs.#ctor(HttpServer.IHttpRequest)">

             <summary>

-            Checks if the specified component interface have been added.

+            Initializes a new instance of the <see cref="T:HttpServer.RequestEventArgs"/> class.

             </summary>

-            <param name="interfaceType"></param>

-            <returns>true if found; otherwise false.</returns>

+            <param name="request">The request.</param>

         </member>

-        <member name="M:HttpServer.IComponentProvider.Add``2">

+        <member name="P:HttpServer.RequestEventArgs.Request">

             <summary>

-            Add a component.

+            Gets received request.

             </summary>

-            <typeparam name="InterfaceType">Type being requested.</typeparam>

-            <typeparam name="InstanceType">Type being created.</typeparam>

         </member>

         <member name="T:HttpServer.HttpParam">

             <summary>

@@ -1555,55 +826,125 @@
             <param name="name"></param>

             <returns>Item if found; otherwise HttpInputItem.EmptyLanguageNode</returns>

         </member>

-        <member name="T:HttpServer.HttpForm">

-            <summary>Container for posted form data</summary>

+        <member name="T:HttpServer.HttpFile">

+            <summary>

+            Container class for posted files

+            </summary>

         </member>

-        <member name="F:HttpServer.HttpForm.EmptyForm">

-            <summary>Instance to help mark a non-initialized form</summary>

+        <member name="M:HttpServer.HttpFile.#ctor(System.String,System.String,System.String,System.String)">

+            <summary>

+            Creates a container for a posted file

+            </summary>

+            <param name="name">The identifier of the post field</param>

+            <param name="filename">The file path</param>

+            <param name="contentType">The content type of the file</param>

+            <param name="uploadFilename">The name of the file uploaded</param>

+            <exception cref="T:System.ArgumentNullException">If any parameter is null or empty</exception>

         </member>

-        <member name="M:HttpServer.HttpForm.#ctor">

-            <summary>Initializes a form container with the specified name</summary>

+        <member name="M:HttpServer.HttpFile.#ctor(System.String,System.String,System.String)">

+            <summary>

+            Creates a container for a posted file <see cref="M:HttpServer.HttpFile.#ctor(System.String,System.String,System.String,System.String)"/>

+            </summary>

+            <exception cref="T:System.ArgumentNullException">If any parameter is null or empty</exception>

         </member>

-        <member name="M:HttpServer.HttpForm.#ctor(HttpServer.HttpInput)">

+        <member name="M:HttpServer.HttpFile.Finalize">

+            <summary>Destructor disposing the file</summary>

+        </member>

+        <member name="M:HttpServer.HttpFile.Dispose(System.Boolean)">

             <summary>

-            Makes a deep copy of the input

+            Deletes the temporary file

             </summary>

-            <param name="input">The input to copy</param>

+            <param name="disposing">True if manual dispose</param>

         </member>

-        <member name="M:HttpServer.HttpForm.AddFile(HttpServer.HttpFile)">

+        <member name="M:HttpServer.HttpFile.Dispose">

             <summary>

-            Adds a file to the collection of posted files

+            Disposing interface, cleans up managed resources (the temporary file) and suppresses finalization

             </summary>

-            <param name="file">The file to add</param>

-            <exception cref="T:System.ArgumentException">If the file is already added</exception>

-            <exception cref="T:System.ArgumentNullException">If file is null</exception>

-            <exception cref="T:System.InvalidOperationException">If the instance is HttpForm.EmptyForm which cannot be modified</exception>

         </member>

-        <member name="M:HttpServer.HttpForm.ContainsFile(System.String)">

+        <member name="P:HttpServer.HttpFile.Name">

             <summary>

-            Checks if the form contains a specified file

+            The name/id of the file

             </summary>

-            <param name="name">Field name of the file parameter</param>

-            <returns>True if the file exists</returns>

-            <exception cref="T:System.InvalidOperationException">If the instance is HttpForm.EmptyForm which cannot be modified</exception>

         </member>

-        <member name="M:HttpServer.HttpForm.GetFile(System.String)">

+        <member name="P:HttpServer.HttpFile.Filename">

             <summary>

-            Retrieves a file held by by the form

+            The full file path

             </summary>

-            <param name="name">The identifier of the file</param>

-            <returns>The requested file or null if the file was not found</returns>

-            <exception cref="T:System.ArgumentNullException">If name is null or empty</exception>

-            <exception cref="T:System.InvalidOperationException">If the instance is HttpForm.EmptyForm which cannot be modified</exception>

         </member>

-        <member name="M:HttpServer.HttpForm.Clear">

-            <summary>Disposes all held HttpFile's and resets values</summary>

+        <member name="P:HttpServer.HttpFile.UploadFilename">

+            <summary>

+            The name of the uploaded file

+            </summary>

         </member>

-        <member name="P:HttpServer.HttpForm.Files">

+        <member name="P:HttpServer.HttpFile.ContentType">

             <summary>

-            Retrieves the number of files added to the <see cref="T:HttpServer.HttpForm"/>

+            The type of file

             </summary>

-            <returns>0 if no files are added</returns>

+        </member>

+        <member name="T:HttpServer.FormDecoders.XmlDecoder">

+            <summary>

+            This decoder converts XML documents to form items.

+            Each element becomes a subitem in the form, and each attribute becomes an item.

+            </summary>

+            <example>

+            // xml: <hello id="1">something<world id="2">data</world></hello>

+            // result: 

+            // form["hello"].Value = "something"

+            // form["hello"]["id"].Value = 1

+            // form["hello"]["world]["id"].Value = 1

+            // form["hello"]["world"].Value = "data"

+            </example>

+            <remarks>

+            The original xml document is stored in form["__xml__"].Value.

+            </remarks>

+        </member>

+        <member name="T:HttpServer.FormDecoders.IFormDecoder">

+            <summary>

+            Interface for form content decoders.

+            </summary>

+        </member>

+        <member name="M:HttpServer.FormDecoders.IFormDecoder.Decode(System.IO.Stream,System.String,System.Text.Encoding)">

+            <summary>

+            

+            </summary>

+            <param name="stream">Stream containing the content</param>

+            <param name="contentType">Content type (with any additional info like boundry). Content type is always supplied in lower case</param>

+            <param name="encoding">Stream enconding</param>

+            <returns>A http form, or null if content could not be parsed.</returns>

+            <exception cref="T:System.IO.InvalidDataException">If contents in the stream is not valid input data.</exception>

+        </member>

+        <member name="M:HttpServer.FormDecoders.IFormDecoder.CanParse(System.String)">

+            <summary>

+            Checks if the decoder can handle the mime type

+            </summary>

+            <param name="contentType">Content type (with any additional info like boundry). Content type is always supplied in lower case.</param>

+            <returns>True if the decoder can parse the specified content type</returns>

+        </member>

+        <member name="M:HttpServer.FormDecoders.XmlDecoder.Decode(System.IO.Stream,System.String,System.Text.Encoding)">

+            <summary>

+            

+            </summary>

+            <param name="stream">Stream containing the content</param>

+            <param name="contentType">Content type (with any additional info like boundry). Content type is always supplied in lower case</param>

+            <param name="encoding">Stream encoding</param>

+            Note: contentType and encoding are not used?

+            <returns>A http form, or null if content could not be parsed.</returns>

+            <exception cref="T:System.IO.InvalidDataException"></exception>

+        </member>

+        <member name="M:HttpServer.FormDecoders.XmlDecoder.TraverseNode(HttpServer.IHttpInput,System.Xml.XmlNode)">

+            <summary>

+            Recursive function that will go through an xml element and store it's content 

+            to the form item.

+            </summary>

+            <param name="item">(parent) Item in form that content should be added to.</param>

+            <param name="node">Node that should be parsed.</param>

+        </member>

+        <member name="M:HttpServer.FormDecoders.XmlDecoder.CanParse(System.String)">

+            <summary>

+            Checks if the decoder can handle the mime type

+            </summary>

+            <param name="contentType">Content type (with any additional info like boundry). Content type is always supplied in lower case.</param>

+            <returns>True if the decoder can parse the specified content type</returns>

         </member>

         <member name="T:HttpServer.Helpers.ObjectForm">

             <summary>

@@ -1722,405 +1063,397 @@
             </summary>

             <returns>html</returns>

         </member>

-        <member name="T:HttpServer.FormDecoders.FormDecoderProvider">

-            <summary>

-            This provider is used to let us implement any type of form decoding we want without

-            having to rewrite anything else in the server.

-            </summary>

-        </member>

-        <member name="M:HttpServer.FormDecoders.FormDecoderProvider.Decode(System.String,System.IO.Stream,System.Text.Encoding)">

+        <member name="T:HttpServer.FormDecoders.MultipartDecoder">

             <summary>

             

             </summary>

-            <param name="contentType">Should contain boundary and type, as in: multipart/form-data; boundary=---------------------------230051238959</param>

-            <param name="stream">Stream containing form data.</param>

-            <param name="encoding">Encoding used when decoding the stream</param>

-            <returns><see cref="F:HttpServer.HttpInput.Empty"/> if no parser was found.</returns>

-            <exception cref="T:System.ArgumentException">If stream is null or not readable.</exception>

-            <exception cref="T:System.IO.InvalidDataException">If stream contents cannot be decoded properly.</exception>

+            <remarks>

+            http://www.faqs.org/rfcs/rfc1867.html

+            </remarks>

         </member>

-        <member name="M:HttpServer.FormDecoders.FormDecoderProvider.Add(HttpServer.FormDecoders.IFormDecoder)">

+        <member name="F:HttpServer.FormDecoders.MultipartDecoder.MimeType">

             <summary>

-            Add a decoder.

+            multipart/form-data

             </summary>

-            <param name="decoder"></param>

-            <exception cref="T:System.ArgumentNullException"></exception>

         </member>

-        <member name="P:HttpServer.FormDecoders.FormDecoderProvider.Count">

+        <member name="F:HttpServer.FormDecoders.MultipartDecoder.FormData">

             <summary>

-            Number of added decoders.

+            form-data

             </summary>

         </member>

-        <member name="P:HttpServer.FormDecoders.FormDecoderProvider.Decoders">

+        <member name="M:HttpServer.FormDecoders.MultipartDecoder.Decode(System.IO.Stream,System.String,System.Text.Encoding)">

             <summary>

-            Use with care.

+            

             </summary>

+            <param name="stream">Stream containing the content</param>

+            <param name="contentType">Content type (with any additional info like boundry). Content type is always supplied in lower case</param>

+            <param name="encoding">Stream enconding</param>

+            <returns>A http form, or null if content could not be parsed.</returns>

+            <exception cref="T:System.IO.InvalidDataException">If contents in the stream is not valid input data.</exception>

+            <exception cref="T:System.ArgumentNullException">If any parameter is null</exception>

         </member>

-        <member name="P:HttpServer.FormDecoders.FormDecoderProvider.DefaultDecoder">

+        <member name="M:HttpServer.FormDecoders.MultipartDecoder.CanParse(System.String)">

             <summary>

-            Decoder used for unknown content types.

+            Checks if the decoder can handle the mime type

             </summary>

+            <param name="contentType">Content type (with any additional info like boundry). Content type is always supplied in lower case.</param>

+            <returns>True if the decoder can parse the specified content type</returns>

         </member>

-        <member name="T:HttpServer.ExceptionHandler">

+        <member name="T:HttpServer.Exceptions.BadRequestException">

             <summary>

-            We dont want to let the server to die due to exceptions thrown in worker threads.

-            therefore we use this delegate to give you a change to handle uncaught exceptions.

+            The request could not be understood by the server due to malformed syntax. 

+            The client SHOULD NOT repeat the request without modifications.

+            

+            Text taken from: http://www.submissionchamber.com/help-guides/error-codes.php

             </summary>

-            <param name="source">Class that the exception was thrown in.</param>

-            <param name="exception">Exception</param>

-            <remarks>

-            Server will throw a InternalServerException in release version if you dont

-            handle this delegate.

-            </remarks>

         </member>

-        <member name="T:HttpServer.HttpClientContext">

+        <member name="M:HttpServer.Exceptions.BadRequestException.#ctor(System.String)">

             <summary>

-            Contains a connection to a browser/client.

+            Create a new bad request exception.

             </summary>

-            <remarks>

-            Remember to <see cref="M:HttpServer.HttpClientContext.Start"/> after you have hooked the <see cref="E:HttpServer.HttpClientContext.RequestReceived"/> event.

-            </remarks>

-            TODO: Maybe this class should be broken up into HttpClientChannel and HttpClientContext?

+            <param name="errMsg">reason to why the request was bad.</param>

         </member>

-        <member name="M:HttpServer.HttpClientContext.#ctor(System.Boolean,System.Net.IPEndPoint,System.IO.Stream,HttpServer.IRequestParserFactory,System.Int32,System.Net.Sockets.Socket)">

+        <member name="M:HttpServer.Exceptions.BadRequestException.#ctor(System.String,System.Exception)">

             <summary>

-            Initializes a new instance of the <see cref="T:HttpServer.HttpClientContext"/> class.

+            Create a new bad request exception.

             </summary>

-            <param name="secured">true if the connection is secured (SSL/TLS)</param>

-            <param name="remoteEndPoint">client that connected.</param>

-            <param name="stream">Stream used for communication</param>

-            <param name="parserFactory">Used to create a <see cref="T:HttpServer.IHttpRequestParser"/>.</param>

-            <param name="bufferSize">Size of buffer to use when reading data. Must be at least 4096 bytes.</param>

-            <exception cref="T:System.Net.Sockets.SocketException">If <see cref="M:System.Net.Sockets.Socket.BeginReceive(System.Byte[],System.Int32,System.Int32,System.Net.Sockets.SocketFlags,System.AsyncCallback,System.Object)"/> fails</exception>

-            <exception cref="T:System.ArgumentException">Stream must be writable and readable.</exception>

+            <param name="errMsg">reason to why the request was bad.</param>

+            <param name="inner">inner exception</param>

         </member>

-        <member name="M:HttpServer.HttpClientContext.OnBodyBytesReceived(System.Object,HttpServer.Parser.BodyEventArgs)">

+        <member name="T:HttpServer.ResponseCookies">

             <summary>

-            Process incoming body bytes.

+            Cookies that should be set.

             </summary>

-            <param name="sender"><see cref="T:HttpServer.IHttpRequestParser"/></param>

-            <param name="e">Bytes</param>

         </member>

-        <member name="M:HttpServer.HttpClientContext.OnHeaderReceived(System.Object,HttpServer.Parser.HeaderEventArgs)">

+        <member name="M:HttpServer.ResponseCookies.Add(HttpServer.ResponseCookie)">

             <summary>

-            

+            Adds a cookie in the collection.

             </summary>

-            <param name="sender"></param>

-            <param name="e"></param>

+            <param name="cookie">cookie to add</param>

+            <exception cref="T:System.ArgumentNullException">cookie is null</exception>

         </member>

-        <member name="M:HttpServer.HttpClientContext.Start">

+        <member name="M:HttpServer.ResponseCookies.Add(HttpServer.RequestCookie,System.DateTime)">

             <summary>

-            Start reading content.

+            Copy a request cookie

             </summary>

-            <remarks>

-            Make sure to call base.Start() if you override this method.

-            </remarks>

+            <param name="cookie"></param>

+            <param name="expires">When the cookie should expire</param>

         </member>

-        <member name="M:HttpServer.HttpClientContext.Cleanup">

+        <member name="M:HttpServer.ResponseCookies.GetEnumerator">

             <summary>

-            Clean up context.

+            Gets a collection enumerator on the cookie list.

             </summary>

-            <remarks>

-            Make sure to call base.Cleanup() if you override the method.

-            </remarks>

+            <returns>collection enumerator</returns>

         </member>

-        <member name="M:HttpServer.HttpClientContext.Disconnect(System.Net.Sockets.SocketError)">

+        <member name="M:HttpServer.ResponseCookies.Clear">

             <summary>

-            Disconnect from client

+            Remove all cookies

             </summary>

-            <param name="error">error to report in the <see cref="E:HttpServer.HttpClientContext.Disconnected"/> event.</param>

         </member>

-        <member name="M:HttpServer.HttpClientContext.Respond(System.String,System.Net.HttpStatusCode,System.String,System.String,System.String)">

+        <member name="M:HttpServer.ResponseCookies.System#Collections#Generic#IEnumerable{HttpServer#ResponseCookie}#GetEnumerator">

             <summary>

-            Send a response.

+            Returns an enumerator that iterates through the collection.

             </summary>

-            <param name="httpVersion">Either <see cref="F:HttpServer.HttpHelper.HTTP10"/> or <see cref="F:HttpServer.HttpHelper.HTTP11"/></param>

-            <param name="statusCode">HTTP status code</param>

-            <param name="reason">reason for the status code.</param>

-            <param name="body">HTML body contents, can be null or empty.</param>

-            <param name="contentType">A content type to return the body as, i.e. 'text/html' or 'text/plain', defaults to 'text/html' if null or empty</param>

-            <exception cref="T:System.ArgumentException">If <paramref name="httpVersion"/> is invalid.</exception>

+            

+            <returns>

+            A <see cref="T:System.Collections.Generic.IEnumerator`1"></see> that can be used to iterate through the collection.

+            </returns>

+            <filterpriority>1</filterpriority>

         </member>

-        <member name="M:HttpServer.HttpClientContext.Respond(System.String,System.Net.HttpStatusCode,System.String)">

+        <member name="P:HttpServer.ResponseCookies.Count">

             <summary>

-            Send a response.

+            Gets the count of cookies in the collection.

             </summary>

-            <param name="httpVersion">Either <see cref="F:HttpServer.HttpHelper.HTTP10"/> or <see cref="F:HttpServer.HttpHelper.HTTP11"/></param>

-            <param name="statusCode">HTTP status code</param>

-            <param name="reason">reason for the status code.</param>

         </member>

-        <member name="M:HttpServer.HttpClientContext.Respond(System.String)">

+        <member name="P:HttpServer.ResponseCookies.Item(System.String)">

             <summary>

-            Send a response.

+            Gets the cookie of a given identifier (null if not existing).

             </summary>

-            <exception cref="T:System.ArgumentNullException"></exception>

         </member>

-        <member name="M:HttpServer.HttpClientContext.Send(System.Byte[])">

+        <member name="T:HttpServer.ResponseCookie">

             <summary>

-            send a whole buffer

+            cookie being sent back to the browser.

             </summary>

-            <param name="buffer">buffer to send</param>

-            <exception cref="T:System.ArgumentNullException"></exception>

+            <seealso cref="T:HttpServer.ResponseCookie"/>

         </member>

-        <member name="M:HttpServer.HttpClientContext.Send(System.Byte[],System.Int32,System.Int32)">

+        <member name="T:HttpServer.RequestCookie">

             <summary>

-            Send data using the stream

+            cookie sent by the client/browser

             </summary>

-            <param name="buffer">Contains data to send</param>

-            <param name="offset">Start position in buffer</param>

-            <param name="size">number of bytes to send</param>

-            <exception cref="T:System.ArgumentNullException"></exception>

-            <exception cref="T:System.ArgumentOutOfRangeException"></exception>

+            <seealso cref="T:HttpServer.ResponseCookie"/>

         </member>

-        <member name="E:HttpServer.HttpClientContext.Cleaned">

+        <member name="M:HttpServer.RequestCookie.#ctor(System.String,System.String)">

             <summary>

-            This context have been cleaned, which means that it can be reused.

+            Constructor.

             </summary>

+            <param name="id">cookie identifier</param>

+            <param name="content">cookie content</param>

+            <exception cref="T:System.ArgumentNullException">id or content is null</exception>

+            <exception cref="T:System.ArgumentException">id is empty</exception>

         </member>

-        <member name="E:HttpServer.HttpClientContext.Started">

+        <member name="M:HttpServer.RequestCookie.ToString">

             <summary>

-            Context have been started (a new client have connected)

+            Gets the cookie HTML representation.

             </summary>

+            <returns>cookie string</returns>

         </member>

-        <member name="P:HttpServer.HttpClientContext.CurrentRequest">

+        <member name="P:HttpServer.RequestCookie.Name">

             <summary>

-            Overload to specify own type.

+            Gets the cookie identifier.

             </summary>

-            <remarks>

-            Must be specified before the context is being used.

-            </remarks>

         </member>

-        <member name="P:HttpServer.HttpClientContext.Secured">

+        <member name="P:HttpServer.RequestCookie.Value">

             <summary>

-            Using SSL or other encryption method.

+            Cookie value. Set to null to remove cookie.

             </summary>

         </member>

-        <member name="P:HttpServer.HttpClientContext.IsSecured">

+        <member name="M:HttpServer.ResponseCookie.#ctor(System.String,System.String,System.DateTime)">

             <summary>

-            Using SSL or other encryption method.

+            Constructor.

             </summary>

+            <param name="id">cookie identifier</param>

+            <param name="content">cookie content</param>

+            <param name="expiresAt">cookie expiration date. Use DateTime.MinValue for session cookie.</param>

+            <exception cref="T:System.ArgumentNullException">id or content is null</exception>

+            <exception cref="T:System.ArgumentException">id is empty</exception>

         </member>

-        <member name="P:HttpServer.HttpClientContext.LogWriter">

+        <member name="M:HttpServer.ResponseCookie.#ctor(System.String,System.String,System.DateTime,System.String,System.String)">

             <summary>

-            Specify which logger to use.

+            Create a new cookie

             </summary>

+            <param name="name">name identifying the cookie</param>

+            <param name="value">cookie value</param>

+            <param name="expires">when the cookie expires. Setting DateTime.MinValue will delete the cookie when the session is closed.</param>

+            <param name="path">Path to where the cookie is valid</param>

+            <param name="domain">Domain that the cookie is valid for.</param>

         </member>

-        <member name="P:HttpServer.HttpClientContext.Stream">

+        <member name="M:HttpServer.ResponseCookie.#ctor(HttpServer.RequestCookie,System.DateTime)">

             <summary>

-            Gets or sets the network stream.

+            Create a new cookie

             </summary>

+            <param name="cookie">Name and value will be used</param>

+            <param name="expires">when the cookie expires.</param>

         </member>

-        <member name="P:HttpServer.HttpClientContext.RemoteAddress">

+        <member name="M:HttpServer.ResponseCookie.ToString">

             <summary>

-            Gets or sets IP address that the client connected from.

+            Gets the cookie HTML representation.

             </summary>

+            <returns>cookie string</returns>

         </member>

-        <member name="P:HttpServer.HttpClientContext.RemotePort">

+        <member name="P:HttpServer.ResponseCookie.Expires">

             <summary>

-            Gets or sets port that the client connected from.

+            When the cookie expires.

+            DateTime.MinValue means that the cookie expires when the session do so.

             </summary>

         </member>

-        <member name="E:HttpServer.HttpClientContext.Disconnected">

+        <member name="P:HttpServer.ResponseCookie.Path">

             <summary>

-            The context have been disconnected.

+            Cookie is only valid under this path.

             </summary>

-            <remarks>

-            Event can be used to clean up a context, or to reuse it.

-            </remarks>

         </member>

-        <member name="E:HttpServer.HttpClientContext.RequestReceived">

+        <member name="T:HttpServer.IComponentProvider">

             <summary>

-            A request have been received in the context.

+            Inversion of control interface.

             </summary>

         </member>

-        <member name="T:HttpServer.Helpers.XmlHelper">

+        <member name="M:HttpServer.IComponentProvider.AddInstance``1(System.Object)">

             <summary>

-            Helpers to make XML handling easier

+            Add a component instance

             </summary>

+            <typeparam name="T">Interface type</typeparam>

+            <param name="instance">Instance to add</param>

         </member>

-        <member name="M:HttpServer.Helpers.XmlHelper.Serialize(System.Object)">

+        <member name="M:HttpServer.IComponentProvider.Get``1">

             <summary>

-            Serializes object to XML.

+            Get a component.

             </summary>

-            <param name="value">object to serialize.</param>

-            <returns>XML</returns>

+            <typeparam name="T">Interface type</typeparam>

+            <returns>Component if registered, otherwise null.</returns>

             <remarks>

-            Removes name spaces and adds indentation

+            Component will get created if needed.

             </remarks>

         </member>

-        <member name="M:HttpServer.Helpers.XmlHelper.Deserialize``1(System.String)">

-            <summary>

-            Create an object from a XML string

-            </summary>

-            <typeparam name="T">Type of object</typeparam>

-            <param name="xml">XML string</param>

-            <returns>object</returns>

-        </member>

-        <member name="T:HttpServer.FormDecoders.UrlDecoder">

+        <member name="M:HttpServer.IComponentProvider.Contains(System.Type)">

             <summary>

-            Can handle application/x-www-form-urlencoded

+            Checks if the specified component interface have been added.

             </summary>

+            <param name="interfaceType"></param>

+            <returns>true if found; otherwise false.</returns>

         </member>

-        <member name="M:HttpServer.FormDecoders.UrlDecoder.Decode(System.IO.Stream,System.String,System.Text.Encoding)">

+        <member name="M:HttpServer.IComponentProvider.Add``2">

             <summary>

+            Add a component.

             </summary>

-            <param name="stream">Stream containing the content</param>

-            <param name="contentType">Content type (with any additional info like boundry). Content type is always supplied in lower case</param>

-            <param name="encoding">Stream encoding</param>

-            <returns>

-            A HTTP form, or null if content could not be parsed.

-            </returns>

-            <exception cref="T:System.IO.InvalidDataException">If contents in the stream is not valid input data.</exception>

+            <typeparam name="InterfaceType">Type being requested.</typeparam>

+            <typeparam name="InstanceType">Type being created.</typeparam>

         </member>

-        <member name="M:HttpServer.FormDecoders.UrlDecoder.CanParse(System.String)">

+        <member name="T:HttpServer.HttpListenerBase">

             <summary>

-            Checks if the decoder can handle the mime type

+            Contains a listener that doesn't do anything with the connections.

             </summary>

-            <param name="contentType">Content type (with any additional info like boundry). Content type is always supplied in lower case.</param>

-            <returns>True if the decoder can parse the specified content type</returns>

         </member>

-        <member name="T:HttpServer.ClientAcceptedEventArgs">

+        <member name="M:HttpServer.HttpListenerBase.#ctor(System.Net.IPAddress,System.Int32,HttpServer.IHttpContextFactory)">

             <summary>

-            Invoked when a client have been accepted by the <see cref="T:HttpServer.HttpListener"/>

+            Listen for regular HTTP connections

             </summary>

-            <remarks>

-            Can be used to revoke incoming connections

-            </remarks>

+            <param name="address">IP Address to accept connections on</param>

+            <param name="port">TCP Port to listen on, default HTTP port is 80.</param>

+            <param name="factory">Factory used to create <see cref="T:HttpServer.IHttpClientContext"/>es.</param>

+            <exception cref="T:System.ArgumentNullException"><c>address</c> is null.</exception>

+            <exception cref="T:System.ArgumentException">Port must be a positive number.</exception>

         </member>

-        <member name="M:HttpServer.ClientAcceptedEventArgs.#ctor(System.Net.Sockets.Socket)">

+        <member name="M:HttpServer.HttpListenerBase.#ctor(System.Net.IPAddress,System.Int32,HttpServer.IHttpContextFactory,System.Security.Cryptography.X509Certificates.X509Certificate)">

             <summary>

-            Initializes a new instance of the <see cref="T:HttpServer.ClientAcceptedEventArgs"/> class.

+            Initializes a new instance of the <see cref="T:HttpServer.HttpListenerBase"/> class.

             </summary>

-            <param name="socket">The socket.</param>

+            <param name="address">IP Address to accept connections on</param>

+            <param name="port">TCP Port to listen on, default HTTPS port is 443</param>

+            <param name="factory">Factory used to create <see cref="T:HttpServer.IHttpClientContext"/>es.</param>

+            <param name="certificate">Certificate to use</param>

         </member>

-        <member name="M:HttpServer.ClientAcceptedEventArgs.Revoke">

+        <member name="M:HttpServer.HttpListenerBase.#ctor(System.Net.IPAddress,System.Int32,HttpServer.IHttpContextFactory,System.Security.Cryptography.X509Certificates.X509Certificate,System.Security.Authentication.SslProtocols)">

             <summary>

-            Client may not be handled.

+            Initializes a new instance of the <see cref="T:HttpServer.HttpListenerBase"/> class.

             </summary>

+            <param name="address">IP Address to accept connections on</param>

+            <param name="port">TCP Port to listen on, default HTTPS port is 443</param>

+            <param name="factory">Factory used to create <see cref="T:HttpServer.IHttpClientContext"/>es.</param>

+            <param name="certificate">Certificate to use</param>

+            <param name="protocol">which HTTPS protocol to use, default is TLS.</param>

         </member>

-        <member name="P:HttpServer.ClientAcceptedEventArgs.Socket">

-            <summary>

-            Accepted socket.

-            </summary>

+        <member name="M:HttpServer.HttpListenerBase.OnAccept(System.IAsyncResult)">

+            <exception cref="T:System.Exception"><c>Exception</c>.</exception>

         </member>

-        <member name="P:HttpServer.ClientAcceptedEventArgs.Revoked">

+        <member name="M:HttpServer.HttpListenerBase.RetryBeginAccept">

             <summary>

-            Client should be revoked.

+            Will try to accept connections one more time.

             </summary>

+            <exception cref="T:System.Exception">If any exceptions is thrown.</exception>

         </member>

-        <member name="T:HttpServer.Sessions.HttpSessionClearedArgs">

+        <member name="M:HttpServer.HttpListenerBase.OnAcceptingSocket(System.Net.Sockets.Socket)">

             <summary>

-            Arguments sent when a <see cref="T:HttpServer.Sessions.IHttpSession"/> is cleared

+            Can be used to create filtering of new connections.

             </summary>

+            <param name="socket">Accepted socket</param>

+            <returns>true if connection can be accepted; otherwise false.</returns>

         </member>

-        <member name="M:HttpServer.Sessions.HttpSessionClearedArgs.#ctor(System.Boolean)">

+        <member name="M:HttpServer.HttpListenerBase.Start(System.Int32)">

             <summary>

-            Instantiates the arguments for the event

+            Start listen for new connections

             </summary>

-            <param name="expired">True if the session is cleared due to expiration</param>

+            <param name="backlog">Number of connections that can stand in a queue to be accepted.</param>

+            <exception cref="T:System.InvalidOperationException">Listener have already been started.</exception>

         </member>

-        <member name="P:HttpServer.Sessions.HttpSessionClearedArgs.Expired">

+        <member name="M:HttpServer.HttpListenerBase.Stop">

             <summary>

-            Returns true if the session is cleared due to expiration

+            Stop the listener

             </summary>

+            <exception cref="T:System.Net.Sockets.SocketException"></exception>

         </member>

-        <member name="T:HttpServer.Sessions.HttpSessionClearedHandler">

+        <member name="P:HttpServer.HttpListenerBase.LogWriter">

             <summary>

-            Delegate for when a IHttpSession is cleared

+            Gives you a change to receive log entries for all internals of the HTTP library.

             </summary>

-            <param name="session"><see cref="T:HttpServer.Sessions.IHttpSession"/> this is being cleared.</param>

-            <param name="args">Arguments for the clearing</param>

+            <remarks>

+            You may not switch log writer after starting the listener.

+            </remarks>

         </member>

-        <member name="T:HttpServer.Parser.HeaderEventArgs">

+        <member name="P:HttpServer.HttpListenerBase.UseTraceLogs">

             <summary>

-            Event arguments used when a new header have been parsed.

+            True if we should turn on trace logs.

             </summary>

         </member>

-        <member name="M:HttpServer.Parser.HeaderEventArgs.#ctor(System.String,System.String)">

+        <member name="E:HttpServer.HttpListenerBase.ExceptionThrown">

             <summary>

-            Initializes a new instance of the <see cref="T:HttpServer.Parser.HeaderEventArgs"/> class.

+            Catch exceptions not handled by the listener.

             </summary>

-            <param name="name">Name of header.</param>

-            <param name="value">Header value.</param>

+            <remarks>

+            Exceptions will be thrown during debug mode if this event is not used,

+            exceptions will be printed to console and suppressed during release mode.

+            </remarks>

         </member>

-        <member name="M:HttpServer.Parser.HeaderEventArgs.#ctor">

+        <member name="E:HttpServer.HttpListenerBase.RequestReceived">

             <summary>

-            Initializes a new instance of the <see cref="T:HttpServer.Parser.HeaderEventArgs"/> class.

+            A request have been received from a <see cref="T:HttpServer.IHttpClientContext"/>.

             </summary>

         </member>

-        <member name="P:HttpServer.Parser.HeaderEventArgs.Name">

+        <member name="T:HttpServer.HttpListener">

             <summary>

-            Gets or sets header name.

+            New implementation of the HTTP listener.

             </summary>

+            <remarks>

+            Use the <c>Create</c> methods to create a default listener.

+            </remarks>

         </member>

-        <member name="P:HttpServer.Parser.HeaderEventArgs.Value">

+        <member name="M:HttpServer.HttpListener.#ctor(System.Net.IPAddress,System.Int32,HttpServer.IHttpContextFactory)">

             <summary>

-            Gets or sets header value.

+            Initializes a new instance of the <see cref="T:HttpServer.HttpListener"/> class.

             </summary>

+            <param name="address">IP Address to accept connections on</param>

+            <param name="port">TCP Port to listen on, default HTTP port is 80.</param>

+            <param name="factory">Factory used to create <see cref="T:HttpServer.IHttpClientContext"/>es.</param>

+            <exception cref="T:System.ArgumentNullException"><c>address</c> is null.</exception>

+            <exception cref="T:System.ArgumentException">Port must be a positive number.</exception>

         </member>

-        <member name="T:HttpServer.Helpers.ResourceManager">

-            <summary>Class to handle loading of resource files</summary>

-        </member>

-        <member name="M:HttpServer.Helpers.ResourceManager.#ctor">

+        <member name="M:HttpServer.HttpListener.#ctor(System.Net.IPAddress,System.Int32,HttpServer.IHttpContextFactory,System.Security.Cryptography.X509Certificates.X509Certificate)">

             <summary>

-            Initializes a new instance of the <see cref="T:HttpServer.Helpers.ResourceManager"/> class.

+            Initializes a new instance of the <see cref="T:HttpServer.HttpListener"/> class.

             </summary>

+            <param name="address">The address.</param>

+            <param name="port">The port.</param>

+            <param name="factory">The factory.</param>

+            <param name="certificate">The certificate.</param>

         </member>

-        <member name="M:HttpServer.Helpers.ResourceManager.#ctor(HttpServer.ILogWriter)">

+        <member name="M:HttpServer.HttpListener.#ctor(System.Net.IPAddress,System.Int32,HttpServer.IHttpContextFactory,System.Security.Cryptography.X509Certificates.X509Certificate,System.Security.Authentication.SslProtocols)">

             <summary>

-            Initializes a new instance of the <see cref="T:HttpServer.Helpers.ResourceManager"/> class.

+            Initializes a new instance of the <see cref="T:HttpServer.HttpListener"/> class.

             </summary>

-            <param name="writer">logger.</param>

+            <param name="address">The address.</param>

+            <param name="port">The port.</param>

+            <param name="factory">The factory.</param>

+            <param name="certificate">The certificate.</param>

+            <param name="protocol">The protocol.</param>

         </member>

-        <member name="M:HttpServer.Helpers.ResourceManager.LoadResources(System.String,System.Reflection.Assembly,System.String)">

+        <member name="M:HttpServer.HttpListener.Create(System.Net.IPAddress,System.Int32)">

             <summary>

-            Loads resources from a namespace in the given assembly to an URI

+            Creates a new <see cref="T:HttpServer.HttpListener"/> instance with default factories.

             </summary>

-            <param name="toUri">The URI to map the resources to</param>

-            <param name="fromAssembly">The assembly in which the resources reside</param>

-            <param name="fromNamespace">The namespace from which to load the resources</param>

-            <usage>

-            <code>

-            resourceLoader.LoadResources("/user/", typeof(User).Assembly, "MyLib.Models.User.Views");

-            </code>

-            Will make the resource MyLib.Models.User.Views.list.Haml accessible via /user/list.haml or /user/list/

-            </usage>

-            <returns>The amount of loaded files, giving you the possibility of making sure the resources needed gets loaded</returns>

-            <exception cref="T:System.InvalidOperationException">If a resource has already been mapped to an uri</exception>

+            <param name="address">Address that the listener should accept connections on.</param>

+            <param name="port">Port that listener should accept connections on.</param>

+            <returns>Created HTTP listener.</returns>

         </member>

-        <member name="M:HttpServer.Helpers.ResourceManager.GetResourceStream(System.String)">

+        <member name="M:HttpServer.HttpListener.Create(System.Net.IPAddress,System.Int32,System.Security.Cryptography.X509Certificates.X509Certificate)">

             <summary>

-            Retrieves a stream for the specified resource path if loaded otherwise null

+            Creates a new <see cref="T:HttpServer.HttpListener"/> instance with default factories.

             </summary>

-            <param name="path">Path to the resource to retrieve a stream for</param>

-            <returns>A stream or null if the resource couldn't be found</returns>

+            <param name="address">Address that the listener should accept connections on.</param>

+            <param name="port">Port that listener should accept connections on.</param>

+            <param name="certificate">Certificate to use</param>

+            <returns>Created HTTP listener.</returns>

         </member>

-        <member name="M:HttpServer.Helpers.ResourceManager.GetFiles(System.String)">

+        <member name="M:HttpServer.HttpListener.Create(System.Net.IPAddress,System.Int32,System.Security.Cryptography.X509Certificates.X509Certificate,System.Security.Authentication.SslProtocols)">

             <summary>

-            Fetch all files from the resource that matches the specified arguments.

+            Creates a new <see cref="T:HttpServer.HttpListener"/> instance with default factories.

             </summary>

-            <param name="path">The path to the resource to extract</param>

-            <returns>

-            a list of files if found; or an empty array if no files are found.

-            </returns>

-            <exception cref="T:System.ArgumentException">Search path must end with an asterisk for finding arbitrary files</exception>

+            <param name="address">Address that the listener should accept connections on.</param>

+            <param name="port">Port that listener should accept connections on.</param>

+            <param name="certificate">Certificate to use</param>

+            <param name="protocol">which HTTPS protocol to use, default is TLS.</param>

+            <returns>Created HTTP listener.</returns>

         </member>

-        <member name="M:HttpServer.Helpers.ResourceManager.GetFiles(System.String,System.String)">

+        <member name="M:HttpServer.HttpListener.OnAcceptingSocket(System.Net.Sockets.Socket)">

             <summary>

-            Fetch all files from the resource that matches the specified arguments.

+            Can be used to create filtering of new connections.

             </summary>

-            <param name="path">Where the file should reside.</param>

-            <param name="filename">Files to check</param>

+            <param name="socket">Accepted socket</param>

             <returns>

-            a list of files if found; or an empty array if no files are found.

+            true if connection can be accepted; otherwise false.

             </returns>

         </member>

-        <member name="M:HttpServer.Helpers.ResourceManager.ContainsResource(System.String)">

+        <member name="E:HttpServer.HttpListener.Accepted">

             <summary>

-            Returns whether or not the loader has an instance of the file requested

+            A client have been accepted, but not handled, by the listener.

             </summary>

-            <param name="filename">The name of the template/file</param>

-            <returns>True if the loader can provide the file</returns>

         </member>

         <member name="T:HttpServer.Rules.RedirectRule">

             <summary>

@@ -2200,50 +1533,6 @@
             <c>true</c> means that a redirect response is sent to the client.

             </remarks>

         </member>

-        <member name="T:HttpServer.RequestQueue">

-            <summary>

-            Used to queue incoming requests.

-            </summary>

-        </member>

-        <member name="M:HttpServer.RequestQueue.#ctor(HttpServer.ProcessRequestHandler)">

-            <summary>

-            Initializes a new instance of the <see cref="T:HttpServer.RequestQueue"/> class.

-            </summary>

-            <param name="handler">Called when a request should be processed.</param>

-        </member>

-        <member name="M:HttpServer.RequestQueue.QueueThread">

-            <summary>

-            Used to process queued requests.

-            </summary>

-        </member>

-        <member name="P:HttpServer.RequestQueue.MaxRequestCount">

-            <summary>

-            Gets or sets maximum number of allowed simultaneous requests.

-            </summary>

-        </member>

-        <member name="P:HttpServer.RequestQueue.MaxQueueSize">

-            <summary>

-            Gets or sets maximum number of requests queuing to be handled.

-            </summary>

-        </member>

-        <member name="P:HttpServer.RequestQueue.CurrentRequestCount">

-            <summary>

-            Specifies how many requests the HTTP server is currently processing.

-            </summary>

-        </member>

-        <member name="T:HttpServer.RequestQueue.QueueItem">

-            <summary>

-            Used two queue incoming requests to avoid

-            thread starvation.

-            </summary>

-        </member>

-        <member name="T:HttpServer.ProcessRequestHandler">

-            <summary>

-            Method used to process a queued request

-            </summary>

-            <param name="context">Context that the request was received from.</param>

-            <param name="request">Request to process.</param>

-        </member>

         <member name="T:HttpServer.Parser.HttpRequestParser">

             <summary>

             Parses a HTTP request directly from a stream

@@ -2380,516 +1669,349 @@
             A header have been received.

             </summary>

         </member>

-        <member name="T:HttpServer.IHttpResponse">

-            <summary>

-            Response that is sent back to the web browser / client.

-            

-            A response can be sent if different ways. The easiest one is

-            to just fill the Body stream with content, everything else

-            will then be taken care of by the framework. The default content-type

-            is text/html, you should change it if you send anything else.

-            

-            The second and slighty more complex way is to send the response

-            as parts. Start with sending the header using the SendHeaders method and 

-            then you can send the body using SendBody method, but do not forget

-            to set ContentType and ContentLength before doing so.

-            </summary>

-            <example>

-            public void MyHandler(IHttpRequest request, IHttpResponse response)

-            {

-              

-            }

-            </example>

-        </member>

-        <member name="M:HttpServer.IHttpResponse.AddHeader(System.String,System.String)">

-            <summary>

-            Add another header to the document.

-            </summary>

-            <param name="name">Name of the header, case sensitive, use lower cases.</param>

-            <param name="value">Header values can span over multiple lines as long as each line starts with a white space. New line chars should be \r\n</param>

-            <exception cref="T:System.InvalidOperationException">If headers already been sent.</exception>

-            <exception cref="T:System.ArgumentException">If value conditions have not been met.</exception>

-            <remarks>Adding any header will override the default ones and those specified by properties.</remarks>

-        </member>

-        <member name="M:HttpServer.IHttpResponse.Send">

-            <summary>

-            Send headers and body to the browser.

-            </summary>

-            <exception cref="T:System.InvalidOperationException">If content have already been sent.</exception>

-        </member>

-        <member name="M:HttpServer.IHttpResponse.SendBody(System.Byte[],System.Int32,System.Int32)">

-            <summary>

-            Make sure that you have specified ContentLength and sent the headers first.

-            </summary>

-            <param name="buffer"></param>

-            <exception cref="T:System.InvalidOperationException">If headers have not been sent.</exception>

-            <see cref="M:HttpServer.IHttpResponse.SendHeaders"/>

-            <param name="offset">offest of first byte to send</param>

-            <param name="count">number of bytes to send.</param>

-            <seealso cref="M:HttpServer.IHttpResponse.Send"/>

-            <seealso cref="M:HttpServer.IHttpResponse.SendHeaders"/>

-            <remarks>This method can be used if you want to send body contents without caching them first. This

-            is recommended for larger files to keep the memory usage low.</remarks>

-        </member>

-        <member name="M:HttpServer.IHttpResponse.SendBody(System.Byte[])">

-            <summary>

-            Make sure that you have specified ContentLength and sent the headers first.

-            </summary>

-            <param name="buffer"></param>

-            <exception cref="T:System.InvalidOperationException">If headers have not been sent.</exception>

-            <see cref="M:HttpServer.IHttpResponse.SendHeaders"/>

-            <seealso cref="M:HttpServer.IHttpResponse.Send"/>

-            <seealso cref="M:HttpServer.IHttpResponse.SendHeaders"/>

-            <remarks>This method can be used if you want to send body contents without caching them first. This

-            is recommended for larger files to keep the memory usage low.</remarks>

-        </member>

-        <member name="M:HttpServer.IHttpResponse.SendHeaders">

-            <summary>

-            Send headers to the client.

-            </summary>

-            <exception cref="T:System.InvalidOperationException">If headers already been sent.</exception>

-            <seealso cref="M:HttpServer.IHttpResponse.AddHeader(System.String,System.String)"/>

-            <seealso cref="M:HttpServer.IHttpResponse.Send"/>

-            <seealso cref="M:HttpServer.IHttpResponse.SendBody(System.Byte[])"/>

-        </member>

-        <member name="M:HttpServer.IHttpResponse.Redirect(System.Uri)">

-            <summary>

-            Redirect client to somewhere else using the 302 status code.

-            </summary>

-            <param name="uri">Destination of the redirect</param>

-            <exception cref="T:System.InvalidOperationException">If headers already been sent.</exception>

-            <remarks>You can not do anything more with the request when a redirect have been done. This should be your last

-            action.</remarks>

-        </member>

-        <member name="M:HttpServer.IHttpResponse.Redirect(System.String)">

-            <summary>

-            redirect to somewhere

-            </summary>

-            <param name="url">where the redirect should go</param>

-            <remarks>

-            No body are allowed when doing redirects.

-            </remarks>

-        </member>

-        <member name="P:HttpServer.IHttpResponse.Body">

-            <summary>

-            The body stream is used to cache the body contents

-            before sending everything to the client. It's the simplest

-            way to serve documents.

-            </summary>

-        </member>

-        <member name="P:HttpServer.IHttpResponse.ProtocolVersion">

+        <member name="T:HttpServer.IHttpRequest">

             <summary>

-            Defines the version of the HTTP Response for applications where it's required

-            for this to be forced.

+            Contains server side HTTP request information.

             </summary>

         </member>

-        <member name="P:HttpServer.IHttpResponse.Chunked">

+        <member name="M:HttpServer.IHttpRequest.AddHeader(System.String,System.String)">

             <summary>

-            The chunked encoding modifies the body of a message in order to

-            transfer it as a series of chunks, each with its own size indicator,

-            followed by an OPTIONAL trailer containing entity-header fields. This

-            allows dynamically produced content to be transferred along with the

-            information necessary for the recipient to verify that it has

-            received the full message.

+            Called during parsing of a <see cref="T:HttpServer.IHttpRequest"/>.

             </summary>

+            <param name="name">Name of the header, should not be URL encoded</param>

+            <param name="value">Value of the header, should not be URL encoded</param>

+            <exception cref="T:HttpServer.Exceptions.BadRequestException">If a header is incorrect.</exception>

         </member>

-        <member name="P:HttpServer.IHttpResponse.Connection">

+        <member name="M:HttpServer.IHttpRequest.AddToBody(System.Byte[],System.Int32,System.Int32)">

             <summary>

-            Kind of connection

+            Add bytes to the body

             </summary>

+            <param name="bytes">buffer to read bytes from</param>

+            <param name="offset">where to start read</param>

+            <param name="length">number of bytes to read</param>

+            <returns>Number of bytes actually read (same as length unless we got all body bytes).</returns>

+            <exception cref="T:System.InvalidOperationException">If body is not writable</exception>

+            <exception cref="T:System.ArgumentNullException"><c>bytes</c> is null.</exception>

+            <exception cref="T:System.ArgumentOutOfRangeException"><c>offset</c> is out of range.</exception>

         </member>

-        <member name="P:HttpServer.IHttpResponse.Encoding">

+        <member name="M:HttpServer.IHttpRequest.Clear">

             <summary>

-            Encoding to use when sending stuff to the client.

+            Clear everything in the request

             </summary>

-            <remarks>Default is UTF8</remarks>

         </member>

-        <member name="P:HttpServer.IHttpResponse.KeepAlive">

+        <member name="M:HttpServer.IHttpRequest.DecodeBody(HttpServer.FormDecoders.FormDecoderProvider)">

             <summary>

-            Number of seconds to keep connection alive

+            Decode body into a form.

             </summary>

-            <remarks>Only used if Connection property is set to ConnectionType.KeepAlive</remarks>

+            <param name="providers">A list with form decoders.</param>

+            <exception cref="T:System.IO.InvalidDataException">If body contents is not valid for the chosen decoder.</exception>

+            <exception cref="T:System.InvalidOperationException">If body is still being transferred.</exception>

         </member>

-        <member name="P:HttpServer.IHttpResponse.Status">

+        <member name="M:HttpServer.IHttpRequest.SetCookies(HttpServer.RequestCookies)">

             <summary>

-            Status code that is sent to the client.

+            Sets the cookies.

             </summary>

-            <remarks>Default is HttpStatusCode.Ok</remarks>

+            <param name="cookies">The cookies.</param>

         </member>

-        <member name="P:HttpServer.IHttpResponse.Reason">

+        <member name="M:HttpServer.IHttpRequest.CreateResponse(HttpServer.IHttpClientContext)">

             <summary>

-            Information about why a specific status code was used.

+            Create a response object.

             </summary>

+            <param name="context">Context for the connected client.</param>

+            <returns>A new <see cref="T:HttpServer.IHttpResponse"/>.</returns>

         </member>

-        <member name="P:HttpServer.IHttpResponse.ContentLength">

+        <member name="P:HttpServer.IHttpRequest.AcceptTypes">

             <summary>

-            Size of the body. MUST be specified before sending the header,

-            unless property Chunked is set to true.

+            Gets kind of types accepted by the client.

             </summary>

         </member>

-        <member name="P:HttpServer.IHttpResponse.ContentType">

+        <member name="P:HttpServer.IHttpRequest.Body">

             <summary>

-            Kind of content in the body

+            Gets or sets body stream.

             </summary>

-            <remarks>Default is text/html</remarks>

         </member>

-        <member name="P:HttpServer.IHttpResponse.HeadersSent">

+        <member name="P:HttpServer.IHttpRequest.BodyIsComplete">

             <summary>

-            Headers have been sent to the client-

+            Gets whether the body is complete.

             </summary>

-            <remarks>You can not send any additional headers if they have already been sent.</remarks>

         </member>

-        <member name="P:HttpServer.IHttpResponse.Sent">

+        <member name="P:HttpServer.IHttpRequest.Connection">

             <summary>

-            The whole response have been sent.

+            Gets or sets kind of connection used for the session.

             </summary>

         </member>

-        <member name="P:HttpServer.IHttpResponse.Cookies">

+        <member name="P:HttpServer.IHttpRequest.ContentLength">

             <summary>

-            Cookies that should be created/changed.

+            Gets or sets number of bytes in the body.

             </summary>

         </member>

-        <member name="T:HttpServer.ConnectionType">

+        <member name="P:HttpServer.IHttpRequest.Cookies">

             <summary>

-            Type of HTTP connection

+            Gets cookies that was sent with the request.

             </summary>

         </member>

-        <member name="F:HttpServer.ConnectionType.Close">

+        <member name="P:HttpServer.IHttpRequest.Form">

             <summary>

-            Connection is closed after each request-response

+            Gets form parameters.

             </summary>

         </member>

-        <member name="F:HttpServer.ConnectionType.KeepAlive">

+        <member name="P:HttpServer.IHttpRequest.Headers">

             <summary>

-            Connection is kept alive for X seconds (unless another request have been made)

+            Gets headers sent by the client.

             </summary>

         </member>

-        <member name="T:HttpServer.HttpResponse">

+        <member name="P:HttpServer.IHttpRequest.HttpVersion">

             <summary>

-            Response that is sent back to the web browser / client.

+            Gets or sets version of HTTP protocol that's used. 

             </summary>

             <remarks>

-            <para>

-            A response can be sent if different ways. The easiest one is

-            to just fill the Body stream with content, everything else

-            will then be taken care of by the framework. The default content-type

-            is text/html, you should change it if you send anything else.

-            </para><para>

-            The second and slightly more complex way is to send the response

-            as parts. Start with sending the header using the SendHeaders method and 

-            then you can send the body using SendBody method, but do not forget

-            to set <see cref="P:HttpServer.HttpResponse.ContentType"/> and <see cref="P:HttpServer.HttpResponse.ContentLength"/> before doing so.

-            </para>

+            Probably <see cref="F:HttpServer.HttpHelper.HTTP10"/> or <see cref="F:HttpServer.HttpHelper.HTTP11"/>.

             </remarks>

-            <example>

-            <code>

-            // Example using response body.

-            class MyModule : HttpModule

-            {

-                        public override bool Process(IHttpRequest request, IHttpResponse response, IHttpSession session)

-                        {

-                                StreamWriter writer = new StreamWriter(response.Body);

-                                writer.WriteLine("Hello dear World!");

-                                writer.Flush();

-            

-                                // return true to tell webserver that we've handled the url

-                                return true;

-                        }

-            }

-            </code>

-            </example>

-            todo: add two examples, using SendHeaders/SendBody and just the Body stream.

-        </member>

-        <member name="M:HttpServer.HttpResponse.#ctor(HttpServer.IHttpClientContext,HttpServer.IHttpRequest)">

-            <summary>

-            Initializes a new instance of the <see cref="T:HttpServer.IHttpResponse"/> class.

-            </summary>

-            <param name="context">Client that send the <see cref="T:HttpServer.IHttpRequest"/>.</param>

-            <param name="request">Contains information of what the client want to receive.</param>

-            <exception cref="T:System.ArgumentException"><see cref="P:HttpServer.IHttpRequest.HttpVersion"/> cannot be empty.</exception>

-        </member>

-        <member name="M:HttpServer.HttpResponse.#ctor(HttpServer.IHttpClientContext,System.String,HttpServer.ConnectionType)">

-            <summary>

-            Initializes a new instance of the <see cref="T:HttpServer.IHttpResponse"/> class.

-            </summary>

-            <param name="context">Client that send the <see cref="T:HttpServer.IHttpRequest"/>.</param>

-            <param name="httpVersion">Version of HTTP protocol that the client uses.</param>

-            <param name="connectionType">Type of HTTP connection used.</param>

-        </member>

-        <member name="M:HttpServer.HttpResponse.AddHeader(System.String,System.String)">

-            <summary>

-            Add another header to the document.

-            </summary>

-            <param name="name">Name of the header, case sensitive, use lower cases.</param>

-            <param name="value">Header values can span over multiple lines as long as each line starts with a white space. New line chars should be \r\n</param>

-            <exception cref="T:System.InvalidOperationException">If headers already been sent.</exception>

-            <exception cref="T:System.ArgumentException">If value conditions have not been met.</exception>

-            <remarks>Adding any header will override the default ones and those specified by properties.</remarks>

-        </member>

-        <member name="M:HttpServer.HttpResponse.Send">

-            <summary>

-            Send headers and body to the browser.

-            </summary>

-            <exception cref="T:System.InvalidOperationException">If content have already been sent.</exception>

-        </member>

-        <member name="M:HttpServer.HttpResponse.SendBody(System.Byte[],System.Int32,System.Int32)">

-            <summary>

-            Make sure that you have specified <see cref="P:HttpServer.HttpResponse.ContentLength"/> and sent the headers first.

-            </summary>

-            <param name="buffer"></param>

-            <exception cref="T:System.InvalidOperationException">If headers have not been sent.</exception>

-            <see cref="M:HttpServer.HttpResponse.SendHeaders"/>

-            <param name="offset">offset of first byte to send</param>

-            <param name="count">number of bytes to send.</param>

-            <seealso cref="M:HttpServer.HttpResponse.Send"/>

-            <seealso cref="M:HttpServer.HttpResponse.SendHeaders"/>

-            <remarks>This method can be used if you want to send body contents without caching them first. This

-            is recommended for larger files to keep the memory usage low.</remarks>

-        </member>

-        <member name="M:HttpServer.HttpResponse.SendBody(System.Byte[])">

-            <summary>

-            Make sure that you have specified <see cref="P:HttpServer.HttpResponse.ContentLength"/> and sent the headers first.

-            </summary>

-            <param name="buffer"></param>

-            <exception cref="T:System.InvalidOperationException">If headers have not been sent.</exception>

-            <see cref="M:HttpServer.HttpResponse.SendHeaders"/>

-            <seealso cref="M:HttpServer.HttpResponse.Send"/>

-            <seealso cref="M:HttpServer.HttpResponse.SendHeaders"/>

-            <remarks>This method can be used if you want to send body contents without caching them first. This

-            is recommended for larger files to keep the memory usage low.</remarks>

-        </member>

-        <member name="M:HttpServer.HttpResponse.SendHeaders">

-            <summary>

-            Send headers to the client.

-            </summary>

-            <exception cref="T:System.InvalidOperationException">If headers already been sent.</exception>

-            <seealso cref="M:HttpServer.HttpResponse.AddHeader(System.String,System.String)"/>

-            <seealso cref="M:HttpServer.HttpResponse.Send"/>

-            <seealso cref="M:HttpServer.HttpResponse.SendBody(System.Byte[])"/>

+            <seealso cref="T:HttpServer.HttpHelper"/>

         </member>

-        <member name="M:HttpServer.HttpResponse.Redirect(System.Uri)">

+        <member name="P:HttpServer.IHttpRequest.IsAjax">

             <summary>

-            Redirect client to somewhere else using the 302 status code.

+            Gets whether the request was made by Ajax (Asynchronous JavaScript)

             </summary>

-            <param name="uri">Destination of the redirect</param>

-            <exception cref="T:System.InvalidOperationException">If headers already been sent.</exception>

-            <remarks>You can not do anything more with the request when a redirect have been done. This should be your last

-            action.</remarks>

         </member>

-        <member name="M:HttpServer.HttpResponse.Redirect(System.String)">

+        <member name="P:HttpServer.IHttpRequest.Method">

             <summary>

-            redirect to somewhere

+            Gets or sets requested method.

             </summary>

-            <param name="url">where the redirect should go</param>

             <remarks>

-            No body are allowed when doing redirects.

+            Will always be in upper case.

             </remarks>

+            <see cref="P:HttpServer.IHttpRequest.Method"/>

         </member>

-        <member name="P:HttpServer.HttpResponse.Body">

-            <summary>

-            The body stream is used to cache the body contents

-            before sending everything to the client. It's the simplest

-            way to serve documents.

-            </summary>

-        </member>

-        <member name="P:HttpServer.HttpResponse.Chunked">

-            <summary>

-            The chunked encoding modifies the body of a message in order to

-            transfer it as a series of chunks, each with its own size indicator,

-            followed by an OPTIONAL trailer containing entity-header fields. This

-            allows dynamically produced content to be transferred along with the

-            information necessary for the recipient to verify that it has

-            received the full message.

-            </summary>

-        </member>

-        <member name="P:HttpServer.HttpResponse.ProtocolVersion">

+        <member name="P:HttpServer.IHttpRequest.Param">

             <summary>

-            Defines the version of the HTTP Response for applications where it's required

-            for this to be forced.

+            Gets parameter from <see cref="P:HttpServer.IHttpRequest.QueryString"/> or <see cref="P:HttpServer.IHttpRequest.Form"/>.

             </summary>

         </member>

-        <member name="P:HttpServer.HttpResponse.Connection">

+        <member name="P:HttpServer.IHttpRequest.QueryString">

             <summary>

-            Kind of connection

+            Gets variables sent in the query string

             </summary>

         </member>

-        <member name="P:HttpServer.HttpResponse.Encoding">

+        <member name="P:HttpServer.IHttpRequest.Uri">

             <summary>

-            Encoding to use when sending stuff to the client.

+            Gets or sets requested URI.

             </summary>

-            <remarks>Default is UTF8</remarks>

         </member>

-        <member name="P:HttpServer.HttpResponse.KeepAlive">

+        <member name="P:HttpServer.IHttpRequest.UriParts">

             <summary>

-            Number of seconds to keep connection alive

+            Gets URI absolute path divided into parts.

             </summary>

-            <remarks>Only used if Connection property is set to <see cref="F:HttpServer.ConnectionType.KeepAlive"/>.</remarks>

+            <example>

+            // URI is: http://gauffin.com/code/tiny/

+            Console.WriteLine(request.UriParts[0]); // result: code

+            Console.WriteLine(request.UriParts[1]); // result: tiny

+            </example>

+            <remarks>

+            If you're using controllers than the first part is controller name,

+            the second part is method name and the third part is Id property.

+            </remarks>

+            <seealso cref="P:HttpServer.IHttpRequest.Uri"/>

         </member>

-        <member name="P:HttpServer.HttpResponse.Status">

+        <member name="P:HttpServer.IHttpRequest.UriPath">

             <summary>

-            Status code that is sent to the client.

+            Gets or sets path and query.

             </summary>

-            <remarks>Default is <see cref="F:System.Net.HttpStatusCode.OK"/></remarks>

+            <see cref="P:HttpServer.IHttpRequest.Uri"/>

+            <remarks>

+            Are only used during request parsing. Cannot be set after "Host" header have been

+            added.

+            </remarks>

         </member>

-        <member name="P:HttpServer.HttpResponse.Reason">

+        <member name="T:HttpServer.Helpers.Implementations.PrototypeImp">

             <summary>

-            Information about why a specific status code was used.

+            PrototypeJS implementation of the javascript functions.

             </summary>

         </member>

-        <member name="P:HttpServer.HttpResponse.ContentLength">

+        <member name="T:HttpServer.Helpers.JavascriptHelperImplementation">

             <summary>

-            Size of the body. MUST be specified before sending the header,

-            unless property Chunked is set to true.

+            Purpose of this class is to create a javascript toolkit independent javascript helper.

             </summary>

         </member>

-        <member name="P:HttpServer.HttpResponse.ContentType">

+        <member name="M:HttpServer.Helpers.JavascriptHelperImplementation.GenerateOptions(System.Text.StringBuilder,System.String[],System.Boolean)">

             <summary>

-            Kind of content in the body

+            Generates a list with JS options.

             </summary>

-            <remarks>Default type is "text/html"</remarks>

+            <param name="sb">StringBuilder that the options should be added to.</param>

+            <param name="options">the javascript options. name, value pairs. each string value should be escaped by YOU!</param>

+            <param name="startWithComma">true if we should start with a comma.</param>

         </member>

-        <member name="P:HttpServer.HttpResponse.HeadersSent">

+        <member name="M:HttpServer.Helpers.JavascriptHelperImplementation.RemoveJavascriptOptions(System.String[])">

             <summary>

-            Headers have been sent to the client-

+            Removes any javascript parameters from an array of parameters

             </summary>

-            <remarks>You can not send any additional headers if they have already been sent.</remarks>

+            <param name="options">The array of parameters to remove javascript params from</param>

+            <returns>An array of html parameters</returns>

         </member>

-        <member name="P:HttpServer.HttpResponse.Sent">

+        <member name="M:HttpServer.Helpers.JavascriptHelperImplementation.AjaxFormOnSubmit(System.String[])">

             <summary>

-            The whole response have been sent.

+            javascript action that should be added to the "onsubmit" event in the form tag.

             </summary>

+            <returns></returns>

+            <remarks>All javascript option names should end with colon.</remarks>

+            <example>

+            <code>

+            JSHelper.AjaxRequest("/user/show/1", "onsuccess:", "$('userInfo').update(result);");

+            </code>

+            </example>

         </member>

-        <member name="P:HttpServer.HttpResponse.Cookies">

+        <member name="M:HttpServer.Helpers.JavascriptHelperImplementation.AjaxRequest(System.String,System.String[])">

             <summary>

-            Cookies that should be created/changed.

+            Requests a url through ajax

             </summary>

+            <param name="url">url to fetch</param>

+            <param name="options">optional options in format "key, value, key, value", used in JS request object.</param>

+            <returns>a link tag</returns>

+            <remarks>All javascript option names should end with colon.</remarks>

+            <example>

+            <code>

+            JSHelper.AjaxRequest("/user/show/1", "onsuccess:", "$('userInfo').update(result);");

+            </code>

+            </example>

         </member>

-        <member name="T:HttpServer.HttpInputItem">

+        <member name="M:HttpServer.Helpers.JavascriptHelperImplementation.AjaxUpdater(System.String,System.String,System.String[])">

             <summary>

-            represents a HTTP input item. Each item can have multiple sub items, a sub item

-            is made in a HTML form by using square brackets

+            Ajax requests that updates an element with

+            the fetched content

             </summary>

+            <param name="url">Url to fetch content from</param>

+            <param name="targetId">element to update</param>

+            <param name="options">optional options in format "key, value, key, value", used in JS updater object.</param>

+            <returns>A link tag.</returns>

+            <remarks>All javascript option names should end with colon.</remarks>

             <example>

-              // <input type="text" name="user[FirstName]" value="jonas" /> becomes:

-              Console.WriteLine("Value: {0}", form["user"]["FirstName"].Value);

+            <code>

+            JSHelper.AjaxUpdater("/user/show/1", "userInfo", "onsuccess:", "alert('Successful!');");

+            </code>

             </example>

-            <remarks>

-            All names in a form SHOULD be in lowercase.

-            </remarks>

         </member>

-        <member name="F:HttpServer.HttpInputItem.Empty">

-            <summary> Representation of a non-initialized <see cref="T:HttpServer.HttpInputItem"/>.</summary>

-        </member>

-        <member name="M:HttpServer.HttpInputItem.#ctor(System.String,System.String)">

+        <member name="M:HttpServer.Helpers.JavascriptHelperImplementation.DialogLink(System.String,System.String,System.String[])">

             <summary>

-            Initializes an input item setting its name/identifier and value

+            A link that pop ups a Dialog (overlay div)

             </summary>

-            <param name="name">Parameter name/id</param>

-            <param name="value">Parameter value</param>

-        </member>

-        <member name="M:HttpServer.HttpInputItem.#ctor(HttpServer.HttpInputItem)">

-            <summary>Creates a deep copy of the item specified</summary>

-            <param name="item">The item to copy</param>

-            <remarks>The function makes a deep copy of quite a lot which can be slow</remarks>

+            <param name="url">url to contents of dialog</param>

+            <param name="title">link title</param>

+            <returns>A "a"-tag that popups a dialog when clicked</returns>

+            <param name="htmlAttributes">name/value of html attributes</param>

+            <example>

+            WebHelper.DialogLink("/user/show/1", "show user", "onmouseover", "alert('booh!');");

+            </example>

         </member>

-        <member name="M:HttpServer.HttpInputItem.Add(System.String)">

+        <member name="M:HttpServer.Helpers.JavascriptHelperImplementation.CloseDialog">

             <summary>

-            Add another value to this item

+            Close a javascript dialog window/div.

             </summary>

-            <param name="value">Value to add.</param>

-            <exception cref="T:System.InvalidOperationException">Cannot add stuff to <see cref="F:HttpServer.HttpInput.Empty"/>.</exception>

+            <returns>javascript for closing a dialog.</returns>

+            <see cref="M:HttpServer.Helpers.JavascriptHelperImplementation.DialogLink(System.String,System.String,System.String[])"/>

         </member>

-        <member name="M:HttpServer.HttpInputItem.Contains(System.String)">

+        <member name="M:HttpServer.Helpers.JavascriptHelperImplementation.CreateDialog(System.String,System.String,System.String[])">

             <summary>

-            checks if a sub-item exists (and has a value).

+            Creates a new modal dialog window

             </summary>

-            <param name="name">name in lower case</param>

-            <returns>true if the sub-item exists and has a value; otherwise false.</returns>

-        </member>

-        <member name="M:HttpServer.HttpInputItem.ToString">

-            <summary> Returns a formatted representation of the instance with the values of all contained parameters </summary>

+            <param name="url">url to open in window.</param>

+            <param name="title">window title (may not be supported by all js implementations)</param>

+            <param name="options"></param>

+            <returns></returns>

         </member>

-        <member name="M:HttpServer.HttpInputItem.ToString(System.String,System.Boolean)">

+        <member name="M:HttpServer.Helpers.Implementations.PrototypeImp.AjaxRequest(System.String,System.String[])">

             <summary>

-            Outputs the string in a formatted manner

+            Requests a url through ajax

             </summary>

-            <param name="prefix">A prefix to append, used internally</param>

-            <param name="asQuerySting">produce a query string</param>

+            <param name="url">url to fetch. Url is NOT enclosed in quotes by the implementation. You need to do that yourself.</param>

+            <param name="options">optional options in format "key, value, key, value", used in JS request object. All keys should end with colon.</param>

+            <returns>a link tag</returns>

+            <remarks>onclick attribute is used by this method.</remarks>

+            <example>

+            <code>

+            // plain text

+            JSHelper.AjaxRequest("'/user/show/1'");

+            

+            // ajax request using this.href

+            string link = "&lt;a href=\"/user/call/1\" onclick=\"" + JSHelper.AjaxRequest("this.href") + "/&lt;call user&lt;/a&gt;";

+            </code>

+            </example>

         </member>

-        <member name="M:HttpServer.HttpInputItem.Add(System.String,System.String)">

+        <member name="M:HttpServer.Helpers.Implementations.PrototypeImp.Contains(System.Collections.Generic.IEnumerable{System.String},System.String)">

             <summary>

-            Add a sub item.

+            Determins if a list of strings contains a specific value

             </summary>

-            <param name="name">Can contain array formatting, the item is then parsed and added in multiple levels</param>

-            <param name="value">Value to add.</param>

-            <exception cref="T:System.ArgumentNullException">Argument is null.</exception>

-            <exception cref="T:System.InvalidOperationException">Cannot add stuff to <see cref="F:HttpServer.HttpInput.Empty"/>.</exception>

+            <param name="options">options to check in</param>

+            <param name="value">value to find</param>

+            <returns>true if value was found</returns>

+            <remarks>case insensitive</remarks>

         </member>

-        <member name="M:HttpServer.HttpInputItem.System#Collections#Generic#IEnumerable{HttpServer#HttpInputItem}#GetEnumerator">

+        <member name="M:HttpServer.Helpers.Implementations.PrototypeImp.AjaxUpdater(System.String,System.String,System.String[])">

             <summary>

-            Returns an enumerator that iterates through the collection.

+            Ajax requests that updates an element with

+            the fetched content

             </summary>

-            

-            <returns>

-            A <see cref="T:System.Collections.Generic.IEnumerator`1"></see> that can be used to iterate through the collection.

-            </returns>

-            <filterpriority>1</filterpriority>

+            <param name="url">URL to fetch. URL is NOT enclosed in quotes by the implementation. You need to do that yourself.</param>

+            <param name="targetId">element to update</param>

+            <param name="options">options in format "key, value, key, value". All keys should end with colon.</param>

+            <returns>A link tag.</returns>

+            <example>

+            <code>

+            JSHelper.AjaxUpdater("'/user/show/1'", "user", "onsuccess:", "alert('hello');", "asynchronous:", "true");

+            </code>

+            </example>

         </member>

-        <member name="M:HttpServer.HttpInputItem.GetEnumerator">

+        <member name="M:HttpServer.Helpers.Implementations.PrototypeImp.DialogLink(System.String,System.String,System.String[])">

             <summary>

-            Returns an enumerator that iterates through a collection.

+            A link that pop ups a Dialog (overlay div)

             </summary>

-            

+            <param name="url">URL to contents of dialog</param>

+            <param name="title">link title</param>

+            <param name="htmlAttributes">name, value, name, value</param>

             <returns>

-            An <see cref="T:System.Collections.IEnumerator"></see> object that can be used to iterate through the collection.

+            A "a"-tag that popups a dialog when clicked

             </returns>

-            <filterpriority>2</filterpriority>

+            <remarks><para>Requires Control.Modal found here: http://livepipe.net/projects/control_modal/</para>

+            And the following JavaScript (load it in application.js):

+            <code>

+            Event.observe(window, 'load',

+              function() {

+                document.getElementsByClassName('modal').each(function(link){  new Control.Modal(link);  });

+              }

+            );

+            </code>

+            </remarks>

+            <example>

+            WebHelper.DialogLink("/user/show/1", "show user", "onmouseover", "alert('booh!');");

+            </example>

         </member>

-        <member name="M:HttpServer.HttpInputItem.ToString(System.String)">

+        <member name="M:HttpServer.Helpers.Implementations.PrototypeImp.CreateDialog(System.String,System.String,System.String[])">

             <summary>

-            Outputs the string in a formatted manner

+            create a modal dialog (usually using DIVs)

             </summary>

-            <param name="prefix">A prefix to append, used internally</param>

+            <param name="url">url to fetch</param>

+            <param name="title">dialog title</param>

+            <param name="options">javascript/html attributes. javascript options ends with colon ':'.</param>

             <returns></returns>

         </member>

-        <member name="P:HttpServer.HttpInputItem.Count">

-            <summary>

-            Number of values

-            </summary>

-        </member>

-        <member name="P:HttpServer.HttpInputItem.Item(System.String)">

-            <summary>

-            Get a sub item

-            </summary>

-            <param name="name">name in lower case.</param>

-            <returns><see cref="F:HttpServer.HttpInputItem.Empty"/> if no item was found.</returns>

-        </member>

-        <member name="P:HttpServer.HttpInputItem.Name">

-            <summary>

-            Name of item (in lower case).

-            </summary>

-        </member>

-        <member name="P:HttpServer.HttpInputItem.Value">

-            <summary>

-            Returns the first value, or null if no value exist.

-            </summary>

-        </member>

-        <member name="P:HttpServer.HttpInputItem.LastValue">

-            <summary>

-            Returns the last value, or null if no value exist.

-            </summary>

-        </member>

-        <member name="P:HttpServer.HttpInputItem.Values">

+        <member name="M:HttpServer.Helpers.Implementations.PrototypeImp.CloseDialog">

             <summary>

-            Returns the list with values.

+            Close a javascript dialog window/div.

             </summary>

+            <returns>javascript for closing a dialog.</returns>

+            <see cref="M:HttpServer.Helpers.Implementations.PrototypeImp.DialogLink(System.String,System.String,System.String[])"/>

         </member>

-        <member name="P:HttpServer.HttpInputItem.HttpServer#IHttpInput#Item(System.String)">

+        <member name="M:HttpServer.Helpers.Implementations.PrototypeImp.AjaxFormOnSubmit(System.String[])">

             <summary>

-            

+            javascript action that should be added to the "onsubmit" event in the form tag.

             </summary>

-            <param name="name">name in lower case</param>

+            <param name="options">remember to encapsulate strings in ''</param>

             <returns></returns>

+            <remarks>All javascript option names should end with colon.</remarks>

+            <example>

+                <code>

+            JSHelper.AjaxRequest("/user/show/1", "onsuccess:", "$('userInfo').update(result);");

+            </code>

+            </example>

         </member>

         <member name="T:HttpServer.Helpers.FormHelper">

             <summary>

@@ -3109,40 +2231,262 @@
             </summary>

             <returns></returns>

         </member>

-        <member name="M:HttpServer.ComponentProvider.AddInstance``1(System.Object)">

+        <member name="T:HttpServer.ExceptionHandler">

             <summary>

-            Add a component instance

+            We dont want to let the server to die due to exceptions thrown in worker threads.

+            therefore we use this delegate to give you a change to handle uncaught exceptions.

             </summary>

-            <typeparam name="T">Interface type</typeparam>

-            <param name="instance">Instance to add</param>

+            <param name="source">Class that the exception was thrown in.</param>

+            <param name="exception">Exception</param>

+            <remarks>

+            Server will throw a InternalServerException in release version if you dont

+            handle this delegate.

+            </remarks>

         </member>

-        <member name="M:HttpServer.ComponentProvider.Get``1">

+        <member name="T:HttpServer.Authentication.DigestAuthentication">

             <summary>

-            Get a component.

+            Implements HTTP Digest authentication. It's more secure than Basic auth since password is 

+            encrypted with a "key" from the server. 

             </summary>

-            <typeparam name="T">Interface type</typeparam>

-            <returns>Component if registered, otherwise null.</returns>

             <remarks>

-            Component will get created if needed.

+            Keep in mind that the password is encrypted with MD5. Use a combination of SSL and digest auth to be secure.

             </remarks>

         </member>

-        <member name="M:HttpServer.ComponentProvider.Create(HttpServer.ComponentProvider.TypeInformation)">

-            <exception cref="T:System.InvalidOperationException">If instance cannot be created.</exception>

+        <member name="T:HttpServer.Authentication.AuthenticationModule">

+            <summary>

+            Authentication modules are used to implement different

+            kind of HTTP authentication.

+            </summary>

         </member>

-        <member name="M:HttpServer.ComponentProvider.Contains(System.Type)">

+        <member name="F:HttpServer.Authentication.AuthenticationModule.AuthenticationTag">

             <summary>

-            Checks if the specified component interface have been added.

+            Tag used for authentication.

             </summary>

-            <param name="interfaceType"></param>

-            <returns>true if found; otherwise false.</returns>

         </member>

-        <member name="M:HttpServer.ComponentProvider.Add``2">

+        <member name="M:HttpServer.Authentication.AuthenticationModule.#ctor(HttpServer.Authentication.AuthenticationHandler,HttpServer.Authentication.AuthenticationRequiredHandler)">

             <summary>

-            Add a component.

+            Initializes a new instance of the <see cref="T:HttpServer.Authentication.AuthenticationModule"/> class.

             </summary>

-            <typeparam name="InterfaceType">Type being requested.</typeparam>

-            <typeparam name="InstanceType">Type being created.</typeparam>

-            <exception cref="T:System.InvalidOperationException">Type have already been mapped.</exception>

+            <param name="authenticator">Delegate used to provide information used during authentication.</param>

+            <param name="authenticationRequiredHandler">Delegate used to determine if authentication is required (may be null).</param>

+        </member>

+        <member name="M:HttpServer.Authentication.AuthenticationModule.#ctor(HttpServer.Authentication.AuthenticationHandler)">

+            <summary>

+            Initializes a new instance of the <see cref="T:HttpServer.Authentication.AuthenticationModule"/> class.

+            </summary>

+            <param name="authenticator">Delegate used to provide information used during authentication.</param>

+        </member>

+        <member name="M:HttpServer.Authentication.AuthenticationModule.CreateResponse(System.String,System.Object[])">

+            <summary>

+            Create a response that can be sent in the WWW-Authenticate header.

+            </summary>

+            <param name="realm">Realm that the user should authenticate in</param>

+            <param name="options">Array with optional options.</param>

+            <returns>A correct authentication request.</returns>

+            <exception cref="T:System.ArgumentNullException">If realm is empty or null.</exception>

+        </member>

+        <member name="M:HttpServer.Authentication.AuthenticationModule.Authenticate(System.String,System.String,System.String,System.Object[])">

+            <summary>

+            An authentication response have been received from the web browser.

+            Check if it's correct

+            </summary>

+            <param name="authenticationHeader">Contents from the Authorization header</param>

+            <param name="realm">Realm that should be authenticated</param>

+            <param name="httpVerb">GET/POST/PUT/DELETE etc.</param>

+            <param name="options">options to specific implementations</param>

+            <returns>Authentication object that is stored for the request. A user class or something like that.</returns>

+            <exception cref="T:System.ArgumentException">if <paramref name="authenticationHeader"/> is invalid</exception>

+            <exception cref="T:System.ArgumentNullException">If any of the parameters is empty or null.</exception>

+        </member>

+        <member name="M:HttpServer.Authentication.AuthenticationModule.CheckAuthentication(System.String,System.String,System.String@,System.Object@)">

+            <summary>

+            Used to invoke the authentication delegate that is used to lookup the user name/realm.

+            </summary>

+            <param name="realm">Realm (domain) that user want to authenticate in</param>

+            <param name="userName">User name</param>

+            <param name="password">Password used for validation. Some implementations got password in clear text, they are then sent to client.</param>

+            <param name="login">object that will be stored in the request to help you identify the user if authentication was successful.</param>

+            <returns>true if authentication was successful</returns>

+        </member>

+        <member name="M:HttpServer.Authentication.AuthenticationModule.AuthenticationRequired(HttpServer.IHttpRequest)">

+            <summary>

+            Determines if authentication is required.

+            </summary>

+            <param name="request">HTTP request from browser</param>

+            <returns>true if user should be authenticated.</returns>

+            <remarks>throw <see cref="T:HttpServer.Exceptions.ForbiddenException"/> from your delegate if no more attempts are allowed.</remarks>

+            <exception cref="T:HttpServer.Exceptions.ForbiddenException">If no more attempts are allowed</exception>

+        </member>

+        <member name="P:HttpServer.Authentication.AuthenticationModule.Name">

+            <summary>

+            name used in HTTP request.

+            </summary>

+        </member>

+        <member name="M:HttpServer.Authentication.DigestAuthentication.#ctor(HttpServer.Authentication.AuthenticationHandler,HttpServer.Authentication.AuthenticationRequiredHandler)">

+            <summary>

+            Initializes a new instance of the <see cref="T:HttpServer.Authentication.DigestAuthentication"/> class.

+            </summary>

+            <param name="authenticator">Delegate used to provide information used during authentication.</param>

+            <param name="authenticationRequiredHandler">Delegate used to determine if authentication is required (may be null).</param>

+        </member>

+        <member name="M:HttpServer.Authentication.DigestAuthentication.#ctor(HttpServer.Authentication.AuthenticationHandler)">

+            <summary>

+            Initializes a new instance of the <see cref="T:HttpServer.Authentication.DigestAuthentication"/> class.

+            </summary>

+            <param name="authenticator">Delegate used to provide information used during authentication.</param>

+        </member>

+        <member name="F:HttpServer.Authentication.DigestAuthentication.DisableNonceCheck">

+            <summary>

+            Used by test classes to be able to use hardcoded values

+            </summary>

+        </member>

+        <member name="M:HttpServer.Authentication.DigestAuthentication.Authenticate(System.String,System.String,System.String,System.Object[])">

+            <summary>

+            An authentication response have been received from the web browser.

+            Check if it's correct

+            </summary>

+            <param name="authenticationHeader">Contents from the Authorization header</param>

+            <param name="realm">Realm that should be authenticated</param>

+            <param name="httpVerb">GET/POST/PUT/DELETE etc.</param>

+            <param name="options">First option: true if username/password is correct but not cnonce</param>

+            <returns>

+            Authentication object that is stored for the request. A user class or something like that.

+            </returns>

+            <exception cref="T:System.ArgumentException">if authenticationHeader is invalid</exception>

+            <exception cref="T:System.ArgumentNullException">If any of the paramters is empty or null.</exception>

+        </member>

+        <member name="M:HttpServer.Authentication.DigestAuthentication.Encrypt(System.String,System.String,System.String,System.String,System.String,System.String,System.String,System.String,System.String)">

+            <summary>

+            Encrypts parameters into a Digest string

+            </summary>

+            <param name="realm">Realm that the user want to log into.</param>

+            <param name="userName">User logging in</param>

+            <param name="password">Users password.</param>

+            <param name="method">HTTP method.</param>

+            <param name="uri">Uri/domain that generated the login prompt.</param>

+            <param name="qop">Quality of Protection.</param>

+            <param name="nonce">"Number used ONCE"</param>

+            <param name="nc">Hexadecimal request counter.</param>

+            <param name="cnonce">"Client Number used ONCE"</param>

+            <returns>Digest encrypted string</returns>

+        </member>

+        <member name="M:HttpServer.Authentication.DigestAuthentication.Encrypt(System.String,System.String,System.String,System.String,System.String,System.String)">

+            <summary>

+            

+            </summary>

+            <param name="ha1">Md5 hex encoded "userName:realm:password", without the quotes.</param>

+            <param name="ha2">Md5 hex encoded "method:uri", without the quotes</param>

+            <param name="qop">Quality of Protection</param>

+            <param name="nonce">"Number used ONCE"</param>

+            <param name="nc">Hexadecimal request counter.</param>

+            <param name="cnonce">Client number used once</param>

+            <returns></returns>

+        </member>

+        <member name="M:HttpServer.Authentication.DigestAuthentication.CreateResponse(System.String,System.Object[])">

+            <summary>

+            Create a response that can be sent in the WWW-Authenticate header.

+            </summary>

+            <param name="realm">Realm that the user should authenticate in</param>

+            <param name="options">First options specifies if true if username/password is correct but not cnonce.</param>

+            <returns>A correct auth request.</returns>

+            <exception cref="T:System.ArgumentNullException">If realm is empty or null.</exception>

+        </member>

+        <member name="M:HttpServer.Authentication.DigestAuthentication.Decode(System.String,System.Text.Encoding)">

+            <summary>

+            Decodes authorization header value

+            </summary>

+            <param name="buffer">header value</param>

+            <param name="encoding">Encoding that the buffer is in</param>

+            <returns>All headers and their values if successful; otherwise null</returns>

+            <example>

+            NameValueCollection header = DigestAuthentication.Decode("response=\"6629fae49393a05397450978507c4ef1\",\r\nc=00001", Encoding.ASCII);

+            </example>

+            <remarks>Can handle lots of whitespaces and new lines without failing.</remarks>

+        </member>

+        <member name="M:HttpServer.Authentication.DigestAuthentication.GetCurrentNonce">

+            <summary>

+            Gets the current nonce.

+            </summary>

+            <returns></returns>

+        </member>

+        <member name="M:HttpServer.Authentication.DigestAuthentication.GetMD5HashBinHex2(System.String)">

+            <summary>

+            Gets the Md5 hash bin hex2.

+            </summary>

+            <param name="toBeHashed">To be hashed.</param>

+            <returns></returns>

+        </member>

+        <member name="M:HttpServer.Authentication.DigestAuthentication.IsValidNonce(System.String)">

+            <summary>

+            determines if the nonce is valid or has expired.

+            </summary>

+            <param name="nonce">nonce value (check wikipedia for info)</param>

+            <returns>true if the nonce has not expired.</returns>

+        </member>

+        <member name="P:HttpServer.Authentication.DigestAuthentication.Name">

+            <summary>

+            name used in http request.

+            </summary>

+        </member>

+        <member name="P:HttpServer.Authentication.DigestAuthentication.TokenIsHA1">

+            <summary>

+            Gets or sets whether the token supplied in <see cref="T:HttpServer.Authentication.AuthenticationHandler"/> is a

+            HA1 generated string.

+            </summary>

+        </member>

+        <member name="T:HttpServer.HttpHelper">

+            <summary>

+            Generic helper functions for HTTP

+            </summary>

+        </member>

+        <member name="F:HttpServer.HttpHelper.HTTP10">

+            <summary>

+            Version string for HTTP v1.0

+            </summary>

+        </member>

+        <member name="F:HttpServer.HttpHelper.HTTP11">

+            <summary>

+            Version string for HTTP v1.1

+            </summary>

+        </member>

+        <member name="F:HttpServer.HttpHelper.EmptyUri">

+            <summary>

+            An empty URI

+            </summary>

+        </member>

+        <member name="M:HttpServer.HttpHelper.ParseQueryString(System.String)">

+            <summary>

+            Parses a query string.

+            </summary>

+            <param name="queryString">Query string (URI encoded)</param>

+            <returns>A <see cref="T:HttpServer.HttpInput"/> object if successful; otherwise <see cref="F:HttpServer.HttpInput.Empty"/></returns>

+            <exception cref="T:System.ArgumentNullException"><c>queryString</c> is null.</exception>

+            <exception cref="T:System.FormatException">If string cannot be parsed.</exception>

+        </member>

+        <member name="T:HttpServer.Authentication.AuthenticationHandler">

+            <summary>

+            Delegate used to let authentication modules authenticate the user name and password.

+            </summary>

+            <param name="realm">Realm that the user want to authenticate in</param>

+            <param name="userName">User name specified by client</param>

+            <param name="token">Can either be user password or implementation specific token.</param>

+            <param name="login">object that will be stored in a session variable called <see cref="F:HttpServer.Authentication.AuthenticationModule.AuthenticationTag"/> if authentication was successful.</param>

+            <exception cref="T:HttpServer.Exceptions.ForbiddenException">throw forbidden exception if too many attempts have been made.</exception>

+            <remarks>

+            <para>

+            Use <see cref="P:HttpServer.Authentication.DigestAuthentication.TokenIsHA1"/> to specify that the token is a HA1 token. (MD5 generated

+            string from realm, user name and password); Md5String(userName + ":" + realm + ":" + password);

+            </para>

+            </remarks>

+        </member>

+        <member name="T:HttpServer.Authentication.AuthenticationRequiredHandler">

+            <summary>

+            Let's you decide on a system level if authentication is required.

+            </summary>

+            <param name="request">HTTP request from client</param>

+            <returns>true if user should be authenticated.</returns>

+            <remarks>throw <see cref="T:HttpServer.Exceptions.ForbiddenException"/> if no more attempts are allowed.</remarks>

+            <exception cref="T:HttpServer.Exceptions.ForbiddenException">If no more attempts are allowed</exception>

         </member>

         <member name="T:HttpServer.Parser.BodyEventArgs">

             <summary>

@@ -3177,6 +2521,284 @@
             Gets or sets offset in buffer where to start processing.

             </summary>

         </member>

+        <member name="T:HttpServer.Method">

+            <summary>

+            Contains all HTTP Methods (according to the HTTP 1.1 specification)

+            <para>

+            See: http://www.w3.org/Protocols/rfc2616/rfc2616-sec9.html

+            </para>

+            </summary>

+        </member>

+        <member name="F:HttpServer.Method.Delete">

+            <summary>

+            The DELETE method requests that the origin server delete the resource identified by the Request-URI.

+            </summary>

+            <remarks>

+            <para>

+            This method MAY be overridden by human intervention (or other means) on the origin server. 

+            The client cannot be guaranteed that the operation has been carried out, even if the status code 

+            returned from the origin server indicates that the action has been completed successfully. 

+            </para>

+            <para>

+            However, the server SHOULD NOT indicate success unless, at the time the response is given, 

+            it intends to delete the resource or move it to an inaccessible location.

+            </para>

+            <para>

+            A successful response SHOULD be 200 (OK) if the response includes an entity describing the status, 

+            202 (Accepted) if the action has not yet been enacted, 

+            or 204 (No Content) if the action has been enacted but the response does not include an entity.

+            </para>

+            <para>

+            If the request passes through a cache and the Request-URI identifies one or more currently cached entities, 

+            those entries SHOULD be treated as stale. Responses to this method are not cacheable. 

+            </para>

+            </remarks>

+        </member>

+        <member name="F:HttpServer.Method.Get">

+            <summary>

+            The GET method means retrieve whatever information (in the form of an entity) is identified by the Request-URI.

+            </summary>

+            <remarks>

+            <para>

+            If the Request-URI refers to a data-producing process, it is the produced data which shall be returned as the 

+            entity in the response and not the source text of the process, unless that text happens to be the output of the process.

+            </para>

+            <para>

+            The semantics of the GET method change to a "conditional GET" if the request message includes an 

+            If-Modified-Since, If-Unmodified-Since, If-Match, If-None-Match, or If-Range header field. 

+            A conditional GET method requests that the entity be transferred only under the circumstances described 

+            by the conditional header field(s). The conditional GET method is intended to reduce unnecessary network 

+            usage by allowing cached entities to be refreshed without requiring multiple requests or transferring 

+            data already held by the client.

+            </para>

+            </remarks>

+        </member>

+        <member name="F:HttpServer.Method.Header">

+            <summary>

+            The HEAD method is identical to GET except that the server MUST NOT return a message-body in the response. 

+            </summary>

+            <remarks>

+            The meta information contained in the HTTP headers in response to a HEAD request SHOULD be identical to the

+             information sent in response to a GET request. This method can be used for obtaining meta information about 

+            the entity implied by the request without transferring the entity-body itself. 

+            

+            This method is often used for testing hypertext links for validity, accessibility, and recent modification.

+            </remarks>

+        </member>

+        <member name="F:HttpServer.Method.Options">

+            <summary>

+            <para>The OPTIONS method represents a request for information about the communication options available on the request/response chain identified by the Request-URI.</para>

+            </summary>

+            <remarks>

+            <para>This method allows the client to determine the options and/or requirements associated with a resource, or the capabilities of a server, without implying a resource action or initiating a resource retrieval.</para>

+            </remarks>

+        </member>

+        <member name="F:HttpServer.Method.Post">

+            <summary>

+            The POST method is used to request that the origin server accept the entity enclosed 

+            in the request as a new subordinate of the resource identified by the Request-URI in the Request-Line.

+            </summary>

+            <remarks>

+            POST is designed to allow a uniform method to cover the following functions:

+            <list type="bullet">

+            <item>

+            Annotation of existing resources;

+            </item><item>

+            Posting a message to a bulletin board, newsgroup, mailing list, or similar group of articles;

+            </item><item>

+            Providing a block of data, such as the result of submitting a form, to a data-handling process;

+            </item><item>

+            Extending a database through an append operation.

+            </item>

+            </list>

+            <para>

+            If a resource has been created on the origin server, the response SHOULD be 201 (Created) and 

+            contain an entity which describes the status of the request and refers to the new resource, and a 

+            Location header (see section 14.30).

+            </para>

+            <para>

+             The action performed by the POST method might not result in a resource that can be identified by a URI. 

+            In this case, either 200 (OK) or 204 (No Content) is the appropriate response status, depending on 

+            whether or not the response includes an entity that describes the result.

+            </para><para>

+            Responses to this method are not cacheable, unless the response includes appropriate Cache-Control 

+            or Expires header fields. However, the 303 (See Other) response can be used to direct the user agent 

+            to retrieve a cacheable resource. 

+            </para>

+            </remarks>

+        </member>

+        <member name="F:HttpServer.Method.Put">

+            <summary>

+            The PUT method requests that the enclosed entity be stored under the supplied Request-URI.

+            </summary>

+            <remarks>

+            <list type="bullet">

+            <item>

+            If the Request-URI refers to an already existing resource, the enclosed entity SHOULD be considered as a 

+            modified version of the one residing on the origin server. 

+            </item><item>

+            If the Request-URI does not point to an existing resource, and that URI is capable of being defined as a new 

+            resource by the requesting user agent, the origin server can create the resource with that URI. 

+            </item><item>

+            If a new resource is created, the origin server MUST inform the user agent via the 201 (Created) response. 

+            </item><item>

+            If an existing resource is modified, either the 200 (OK) or 204 (No Content) response codes SHOULD be sent to 

+            indicate successful completion of the request. 

+            </item><item>

+            If the resource could not be created or modified with the Request-URI, an appropriate error response SHOULD be 

+            given that reflects the nature of the problem. 

+            </item>

+            </list>

+            <para>

+            The recipient of the entity MUST NOT ignore any Content-* (e.g. Content-Range) headers that it does not 

+            understand or implement and MUST return a 501 (Not Implemented) response in such cases.

+            </para>

+            </remarks>

+        </member>

+        <member name="F:HttpServer.Method.Trace">

+            <summary>

+            The TRACE method is used to invoke a remote, application-layer loop- back of the request message.

+            </summary>

+        </member>

+        <member name="T:HttpServer.Methods">

+            <summary>

+            Contains all HTTP Methods (according to the HTTP 1.1 specification)

+            <para>

+            See: http://www.w3.org/Protocols/rfc2616/rfc2616-sec9.html

+            </para>

+            </summary>

+        </member>

+        <member name="F:HttpServer.Methods.Delete">

+            <summary>

+            The DELETE method requests that the origin server delete the resource identified by the Request-URI.

+            </summary>

+            <remarks>

+            <para>

+            This method MAY be overridden by human intervention (or other means) on the origin server. 

+            The client cannot be guaranteed that the operation has been carried out, even if the status code 

+            returned from the origin server indicates that the action has been completed successfully. 

+            </para>

+            <para>

+            However, the server SHOULD NOT indicate success unless, at the time the response is given, 

+            it intends to delete the resource or move it to an inaccessible location.

+            </para>

+            <para>

+            A successful response SHOULD be 200 (OK) if the response includes an entity describing the status, 

+            202 (Accepted) if the action has not yet been enacted, 

+            or 204 (No Content) if the action has been enacted but the response does not include an entity.

+            </para>

+            <para>

+            If the request passes through a cache and the Request-URI identifies one or more currently cached entities, 

+            those entries SHOULD be treated as stale. Responses to this method are not cacheable. 

+            </para>

+            </remarks>

+        </member>

+        <member name="F:HttpServer.Methods.Get">

+            <summary>

+            The GET method means retrieve whatever information (in the form of an entity) is identified by the Request-URI.

+            </summary>

+            <remarks>

+            <para>

+            If the Request-URI refers to a data-producing process, it is the produced data which shall be returned as the 

+            entity in the response and not the source text of the process, unless that text happens to be the output of the process.

+            </para>

+            <para>

+            The semantics of the GET method change to a "conditional GET" if the request message includes an 

+            If-Modified-Since, If-Unmodified-Since, If-Match, If-None-Match, or If-Range header field. 

+            A conditional GET method requests that the entity be transferred only under the circumstances described 

+            by the conditional header field(s). The conditional GET method is intended to reduce unnecessary network 

+            usage by allowing cached entities to be refreshed without requiring multiple requests or transferring 

+            data already held by the client.

+            </para>

+            </remarks>

+        </member>

+        <member name="F:HttpServer.Methods.Header">

+            <summary>

+            The HEAD method is identical to GET except that the server MUST NOT return a message-body in the response. 

+            </summary>

+            <remarks>

+            The meta information contained in the HTTP headers in response to a HEAD request SHOULD be identical to the

+             information sent in response to a GET request. This method can be used for obtaining meta information about 

+            the entity implied by the request without transferring the entity-body itself. 

+            

+            This method is often used for testing hypertext links for validity, accessibility, and recent modification.

+            </remarks>

+        </member>

+        <member name="F:HttpServer.Methods.Options">

+            <summary>

+            <para>The OPTIONS method represents a request for information about the communication options available on the request/response chain identified by the Request-URI.</para>

+            </summary>

+            <remarks>

+            <para>This method allows the client to determine the options and/or requirements associated with a resource, or the capabilities of a server, without implying a resource action or initiating a resource retrieval.</para>

+            </remarks>

+        </member>

+        <member name="F:HttpServer.Methods.Post">

+            <summary>

+            The POST method is used to request that the origin server accept the entity enclosed 

+            in the request as a new subordinate of the resource identified by the Request-URI in the Request-Line.

+            </summary>

+            <remarks>

+            POST is designed to allow a uniform method to cover the following functions:

+            <list type="bullet">

+            <item>

+            Annotation of existing resources;

+            </item><item>

+            Posting a message to a bulletin board, newsgroup, mailing list, or similar group of articles;

+            </item><item>

+            Providing a block of data, such as the result of submitting a form, to a data-handling process;

+            </item><item>

+            Extending a database through an append operation.

+            </item>

+            </list>

+            <para>

+            If a resource has been created on the origin server, the response SHOULD be 201 (Created) and 

+            contain an entity which describes the status of the request and refers to the new resource, and a 

+            Location header (see section 14.30).

+            </para>

+            <para>

+             The action performed by the POST method might not result in a resource that can be identified by a URI. 

+            In this case, either 200 (OK) or 204 (No Content) is the appropriate response status, depending on 

+            whether or not the response includes an entity that describes the result.

+            </para><para>

+            Responses to this method are not cacheable, unless the response includes appropriate Cache-Control 

+            or Expires header fields. However, the 303 (See Other) response can be used to direct the user agent 

+            to retrieve a cacheable resource. 

+            </para>

+            </remarks>

+        </member>

+        <member name="F:HttpServer.Methods.Put">

+            <summary>

+            The PUT method requests that the enclosed entity be stored under the supplied Request-URI.

+            </summary>

+            <remarks>

+            <list type="bullet">

+            <item>

+            If the Request-URI refers to an already existing resource, the enclosed entity SHOULD be considered as a 

+            modified version of the one residing on the origin server. 

+            </item><item>

+            If the Request-URI does not point to an existing resource, and that URI is capable of being defined as a new 

+            resource by the requesting user agent, the origin server can create the resource with that URI. 

+            </item><item>

+            If a new resource is created, the origin server MUST inform the user agent via the 201 (Created) response. 

+            </item><item>

+            If an existing resource is modified, either the 200 (OK) or 204 (No Content) response codes SHOULD be sent to 

+            indicate successful completion of the request. 

+            </item><item>

+            If the resource could not be created or modified with the Request-URI, an appropriate error response SHOULD be 

+            given that reflects the nature of the problem. 

+            </item>

+            </list>

+            <para>

+            The recipient of the entity MUST NOT ignore any Content-* (e.g. Content-Range) headers that it does not 

+            understand or implement and MUST return a 501 (Not Implemented) response in such cases.

+            </para>

+            </remarks>

+        </member>

+        <member name="F:HttpServer.Methods.Trace">

+            <summary>

+            The TRACE method is used to invoke a remote, application-layer loop- back of the request message.

+            </summary>

+        </member>

         <member name="T:HttpServer.HttpContextFactory">

             <summary>

             Used to create and reuse contexts.

@@ -3364,178 +2986,247 @@
             </summary>

             <param name="disposing">true to release both managed and unmanaged resources; false to release only unmanaged resources.</param>

         </member>

-        <member name="T:HttpServer.HttpModules.ResourceFileModule">

+        <member name="T:HttpServer.ClientAcceptedEventArgs">

             <summary>

-            Serves files that are stored in embedded resources.

+            Invoked when a client have been accepted by the <see cref="T:HttpServer.HttpListener"/>

             </summary>

+            <remarks>

+            Can be used to revoke incoming connections

+            </remarks>

         </member>

-        <member name="T:HttpServer.HttpModules.HttpModule">

+        <member name="M:HttpServer.ClientAcceptedEventArgs.#ctor(System.Net.Sockets.Socket)">

             <summary>

-            A HttpModule can be used to serve Uri's. The module itself

-            decides if it should serve a Uri or not. In this way, you can

-            get a very flexible http application since you can let multiple modules

-            serve almost similar urls.

+            Initializes a new instance of the <see cref="T:HttpServer.ClientAcceptedEventArgs"/> class.

             </summary>

-            <remarks>

-            Throw <see cref="T:HttpServer.Exceptions.UnauthorizedException"/> if you are using a <see cref="T:HttpServer.Authentication.AuthenticationModule"/> and want to prompt for user name/password.

-            </remarks>

+            <param name="socket">The socket.</param>

         </member>

-        <member name="M:HttpServer.HttpModules.HttpModule.Process(HttpServer.IHttpRequest,HttpServer.IHttpResponse,HttpServer.Sessions.IHttpSession)">

+        <member name="M:HttpServer.ClientAcceptedEventArgs.Revoke">

             <summary>

-            Method that process the url

+            Client may not be handled.

             </summary>

-            <param name="request">Information sent by the browser about the request</param>

-            <param name="response">Information that is being sent back to the client.</param>

-            <param name="session">Session used to </param>

-            <returns>true if this module handled the request.</returns>

         </member>

-        <member name="M:HttpServer.HttpModules.HttpModule.SetLogWriter(HttpServer.ILogWriter)">

+        <member name="P:HttpServer.ClientAcceptedEventArgs.Socket">

             <summary>

-            Set the log writer to use.

+            Accepted socket.

             </summary>

-            <param name="writer">logwriter to use.</param>

         </member>

-        <member name="M:HttpServer.HttpModules.HttpModule.Write(HttpServer.LogPrio,System.String)">

+        <member name="P:HttpServer.ClientAcceptedEventArgs.Revoked">

             <summary>

-            Log something.

+            Client should be revoked.

             </summary>

-            <param name="prio">importance of log message</param>

-            <param name="message">message</param>

         </member>

-        <member name="P:HttpServer.HttpModules.HttpModule.AllowSecondaryProcessing">

+        <member name="T:HttpServer.Sessions.MemorySession">

             <summary>

-            If true specifies that the module doesn't consume the processing of a request so that subsequent modules

-            can continue processing afterwards. Default is false.

+            A session stored in memory.

             </summary>

         </member>

-        <member name="M:HttpServer.HttpModules.ResourceFileModule.#ctor">

+        <member name="T:HttpServer.Sessions.IHttpSession">

             <summary>

-            Initializes a new instance of the <see cref="T:HttpServer.HttpModules.ResourceFileModule"/> class.

-            Runs <see cref="M:HttpServer.HttpModules.ResourceFileModule.AddDefaultMimeTypes"/> to make sure the basic mime types are available, they can be cleared later

-            through the use of <see cref="P:HttpServer.HttpModules.ResourceFileModule.MimeTypes"/> if desired.

+            Interface for sessions

             </summary>

         </member>

-        <member name="M:HttpServer.HttpModules.ResourceFileModule.#ctor(HttpServer.ILogWriter)">

+        <member name="M:HttpServer.Sessions.IHttpSession.Clear">

             <summary>

-            Initializes a new instance of the <see cref="T:HttpServer.HttpModules.ResourceFileModule"/> class.

-            Runs <see cref="M:HttpServer.HttpModules.ResourceFileModule.AddDefaultMimeTypes"/> to make sure the basic mime types are available, they can be cleared later

-            through the use of <see cref="P:HttpServer.HttpModules.ResourceFileModule.MimeTypes"/> if desired.

+            Remove everything from the session

             </summary>

-            <param name="logWriter">The log writer to use when logging events</param>

         </member>

-        <member name="M:HttpServer.HttpModules.ResourceFileModule.AddDefaultMimeTypes">

+        <member name="M:HttpServer.Sessions.IHttpSession.Clear(System.Boolean)">

             <summary>

-            Mimtypes that this class can handle per default

+            Remove everything from the session

             </summary>

+            <param name="expires">True if the session is cleared due to expiration</param>

         </member>

-        <member name="M:HttpServer.HttpModules.ResourceFileModule.AddResources(System.String,System.Reflection.Assembly,System.String)">

+        <member name="P:HttpServer.Sessions.IHttpSession.Id">

             <summary>

-            Loads resources from a namespace in the given assembly to an uri

+            Session id

             </summary>

-            <param name="toUri">The uri to map the resources to</param>

-            <param name="fromAssembly">The assembly in which the resources reside</param>

-            <param name="fromNamespace">The namespace from which to load the resources</param>

-            <usage>

-            resourceLoader.LoadResources("/user/", typeof(User).Assembly, "MyLib.Models.User.Views");

+        </member>

+        <member name="P:HttpServer.Sessions.IHttpSession.Item(System.String)">

+            <summary>

+            Should 

+            </summary>

+            <param name="name">Name of the session variable</param>

+            <returns>null if it's not set</returns>

+            <exception cref="T:System.Runtime.Serialization.SerializationException">If the object cant be serialized.</exception>

+        </member>

+        <member name="P:HttpServer.Sessions.IHttpSession.Accessed">

+            <summary>

+            When the session was last accessed.

+            This property is touched by the http server each time the

+            session is requested.

+            </summary>

+        </member>

+        <member name="P:HttpServer.Sessions.IHttpSession.Count">

+            <summary>

+            Number of session variables.

+            </summary>

+        </member>

+        <member name="E:HttpServer.Sessions.IHttpSession.BeforeClear">

+            <summary>

+            Event triggered upon clearing the session

+            </summary>

+        </member>

+        <member name="M:HttpServer.Sessions.MemorySession.#ctor(System.String)">

+            <summary>

             

-            will make ie the resource MyLib.Models.User.Views.stylesheet.css accessible via /user/stylesheet.css

-            </usage>

-            <returns>The amount of loaded files, giving you the possibility of making sure the resources needed gets loaded</returns>

+            </summary>

+            <param name="id">A unique id used by the sessions store to identify the session</param>

         </member>

-        <member name="M:HttpServer.HttpModules.ResourceFileModule.CanHandle(HttpServer.IHttpRequest)">

+        <member name="M:HttpServer.Sessions.MemorySession.SetId(System.String)">

             <summary>

-            Returns true if the module can handle the request

+            Id

             </summary>

+            <param name="id"></param>

         </member>

-        <member name="M:HttpServer.HttpModules.ResourceFileModule.Process(HttpServer.IHttpRequest,HttpServer.IHttpResponse,HttpServer.Sessions.IHttpSession)">

+        <member name="M:HttpServer.Sessions.MemorySession.Clear">

             <summary>

-            Method that process the url

+            Remove everything from the session

             </summary>

-            <param name="request">Information sent by the browser about the request</param>

-            <param name="response">Information that is being sent back to the client.</param>

-            <param name="session">Session used to </param>

-            <returns>true if this module handled the request.</returns>

         </member>

-        <member name="P:HttpServer.HttpModules.ResourceFileModule.MimeTypes">

+        <member name="M:HttpServer.Sessions.MemorySession.Clear(System.Boolean)">

             <summary>

-            List with all mime-type that are allowed. 

+            Clears the specified expire.

             </summary>

-            <remarks>All other mime types will result in a Forbidden http status code.</remarks>

+            <param name="expires">True if the session is cleared due to expiration</param>

         </member>

-        <member name="T:HttpServer.HttpModules.FileModule">

+        <member name="M:HttpServer.Sessions.MemorySession.Dispose">

             <summary>

-            The purpose of this module is to serve files.

+            Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.

             </summary>

+            <filterpriority>2</filterpriority>

         </member>

-        <member name="M:HttpServer.HttpModules.FileModule.#ctor(System.String,System.String,System.Boolean)">

+        <member name="P:HttpServer.Sessions.MemorySession.Id">

             <summary>

-            Initializes a new instance of the <see cref="T:HttpServer.HttpModules.FileModule"/> class.

+            Session id

             </summary>

-            <param name="baseUri">Uri to serve, for instance "/files/"</param>

-            <param name="basePath">Path on hard drive where we should start looking for files</param>

-            <param name="useLastModifiedHeader">If true a Last-Modifed header will be sent upon requests urging web browser to cache files</param>

         </member>

-        <member name="M:HttpServer.HttpModules.FileModule.#ctor(System.String,System.String)">

+        <member name="P:HttpServer.Sessions.MemorySession.Item(System.String)">

             <summary>

-            Initializes a new instance of the <see cref="T:HttpServer.HttpModules.FileModule"/> class.

+            Should 

             </summary>

-            <param name="baseUri">Uri to serve, for instance "/files/"</param>

-            <param name="basePath">Path on hard drive where we should start looking for files</param>

+            <param name="name">Name of the session variable</param>

+            <returns>null if it's not set</returns>

         </member>

-        <member name="M:HttpServer.HttpModules.FileModule.AddDefaultMimeTypes">

+        <member name="P:HttpServer.Sessions.MemorySession.Accessed">

             <summary>

-            Mimtypes that this class can handle per default

+            when the session was last accessed.

             </summary>

+            <remarks>

+            Used to determine when the session should be removed.

+            </remarks>

         </member>

-        <member name="M:HttpServer.HttpModules.FileModule.CanHandle(System.Uri)">

+        <member name="P:HttpServer.Sessions.MemorySession.Count">

             <summary>

-            Determines if the request should be handled by this module.

-            Invoked by the <see cref="T:HttpServer.HttpServer"/>

+            Number of values in the session

             </summary>

-            <param name="uri"></param>

-            <returns>true if this module should handle it.</returns>

         </member>

-        <member name="M:HttpServer.HttpModules.FileModule.GetPath(System.Uri)">

-            <exception cref="T:HttpServer.Exceptions.BadRequestException">Illegal path</exception>

+        <member name="P:HttpServer.Sessions.MemorySession.Changed">

+            <summary>

+            Flag to indicate that the session have been changed

+            and should be saved into the session store.

+            </summary>

         </member>

-        <member name="M:HttpServer.HttpModules.FileModule.Contains(System.String,System.Collections.Generic.IEnumerable{System.String})">

+        <member name="E:HttpServer.Sessions.MemorySession.BeforeClear">

             <summary>

-            check if source contains any of the chars.

+            Event triggered upon clearing the session

             </summary>

-            <param name="source"></param>

-            <param name="chars"></param>

-            <returns></returns>

         </member>

-        <member name="M:HttpServer.HttpModules.FileModule.Process(HttpServer.IHttpRequest,HttpServer.IHttpResponse,HttpServer.Sessions.IHttpSession)">

+        <member name="T:HttpServer.HttpModules.ReverseProxyModule">

             <summary>

-            Method that process the Uri.

+            A reverse proxy are used to act as a bridge between local (protected/hidden) websites

+            and public clients.

+            

+            A typical usage is to allow web servers on non standard ports to still be available

+            to the public clients, or allow web servers on private ips to be available.

+            </summary>

+        </member>

+        <member name="M:HttpServer.HttpModules.ReverseProxyModule.#ctor(System.String,System.String)">

+            <summary>

+            

+            </summary>

+            <param name="source">Base url requested from browser</param>

+            <param name="destination">Base url on private web server</param>

+            <example>

+            // this will return contents from http://192.168.1.128/view/jonas when client requests http://www.gauffin.com/user/view/jonas

+            _server.Add(new ReverseProxyModule("http://www.gauffin.com/user/", "http://192.168.1.128/");

+            </example>

+        </member>

+        <member name="M:HttpServer.HttpModules.ReverseProxyModule.CanHandle(System.Uri)">

+            <summary>

+            Method that determines if an url should be handled or not by the module

+            </summary>

+            <param name="uri">Url requested by the client.</param>

+            <returns>true if module should handle the url.</returns>

+        </member>

+        <member name="M:HttpServer.HttpModules.ReverseProxyModule.Process(HttpServer.IHttpRequest,HttpServer.IHttpResponse,HttpServer.Sessions.IHttpSession)">

+            <summary>

+            Method that process the url

             </summary>

             <param name="request">Information sent by the browser about the request</param>

             <param name="response">Information that is being sent back to the client.</param>

             <param name="session">Session used to </param>

-            <exception cref="T:HttpServer.Exceptions.InternalServerException">Failed to find file extension</exception>

-            <exception cref="T:HttpServer.Exceptions.ForbiddenException">File type is forbidden.</exception>

         </member>

-        <member name="M:HttpServer.HttpModules.FileModule.GetFileExtension(System.String)">

+        <member name="T:HttpServer.FormDecoders.UrlDecoder">

             <summary>

-            return a file extension from an absolute Uri path (or plain filename)

+            Can handle application/x-www-form-urlencoded

             </summary>

-            <param name="uri"></param>

-            <returns></returns>

         </member>

-        <member name="P:HttpServer.HttpModules.FileModule.MimeTypes">

+        <member name="M:HttpServer.FormDecoders.UrlDecoder.Decode(System.IO.Stream,System.String,System.Text.Encoding)">

             <summary>

-            List with all mime-type that are allowed. 

             </summary>

-            <remarks>All other mime types will result in a Forbidden http status code.</remarks>

+            <param name="stream">Stream containing the content</param>

+            <param name="contentType">Content type (with any additional info like boundry). Content type is always supplied in lower case</param>

+            <param name="encoding">Stream encoding</param>

+            <returns>

+            A HTTP form, or null if content could not be parsed.

+            </returns>

+            <exception cref="T:System.IO.InvalidDataException">If contents in the stream is not valid input data.</exception>

         </member>

-        <member name="P:HttpServer.HttpModules.FileModule.ForbiddenChars">

+        <member name="M:HttpServer.FormDecoders.UrlDecoder.CanParse(System.String)">

             <summary>

-            characters that may not  exist in a path.

+            Checks if the decoder can handle the mime type

+            </summary>

+            <param name="contentType">Content type (with any additional info like boundry). Content type is always supplied in lower case.</param>

+            <returns>True if the decoder can parse the specified content type</returns>

+        </member>

+        <member name="T:HttpServer.FormDecoders.FormDecoderProvider">

+            <summary>

+            This provider is used to let us implement any type of form decoding we want without

+            having to rewrite anything else in the server.

+            </summary>

+        </member>

+        <member name="M:HttpServer.FormDecoders.FormDecoderProvider.Decode(System.String,System.IO.Stream,System.Text.Encoding)">

+            <summary>

+            

+            </summary>

+            <param name="contentType">Should contain boundary and type, as in: multipart/form-data; boundary=---------------------------230051238959</param>

+            <param name="stream">Stream containing form data.</param>

+            <param name="encoding">Encoding used when decoding the stream</param>

+            <returns><see cref="F:HttpServer.HttpInput.Empty"/> if no parser was found.</returns>

+            <exception cref="T:System.ArgumentException">If stream is null or not readable.</exception>

+            <exception cref="T:System.IO.InvalidDataException">If stream contents cannot be decoded properly.</exception>

+        </member>

+        <member name="M:HttpServer.FormDecoders.FormDecoderProvider.Add(HttpServer.FormDecoders.IFormDecoder)">

+            <summary>

+            Add a decoder.

+            </summary>

+            <param name="decoder"></param>

+            <exception cref="T:System.ArgumentNullException"></exception>

+        </member>

+        <member name="P:HttpServer.FormDecoders.FormDecoderProvider.Count">

+            <summary>

+            Number of added decoders.

+            </summary>

+        </member>

+        <member name="P:HttpServer.FormDecoders.FormDecoderProvider.Decoders">

+            <summary>

+            Use with care.

+            </summary>

+        </member>

+        <member name="P:HttpServer.FormDecoders.FormDecoderProvider.DefaultDecoder">

+            <summary>

+            Decoder used for unknown content types.

             </summary>

-            <example>

-            fileMod.ForbiddenChars = new string[]{ "\\", "..", ":" };

-            </example>

         </member>

         <member name="T:HttpServer.Exceptions.InternalServerException">

             <summary>

@@ -3560,73 +3251,425 @@
             <param name="message">error message.</param>

             <param name="inner">inner exception.</param>

         </member>

-        <member name="T:HttpServer.Rules.RegexRedirectRule">

+        <member name="T:HttpServer.IHttpResponse">

             <summary>

-            Class to make dynamic binding of redirects. Instead of having to specify a number of similar redirect rules

-            a regular expression can be used to identify redirect URLs and their targets.

+            Response that is sent back to the web browser / client.

+            

+            A response can be sent if different ways. The easiest one is

+            to just fill the Body stream with content, everything else

+            will then be taken care of by the framework. The default content-type

+            is text/html, you should change it if you send anything else.

+            

+            The second and slighty more complex way is to send the response

+            as parts. Start with sending the header using the SendHeaders method and 

+            then you can send the body using SendBody method, but do not forget

+            to set ContentType and ContentLength before doing so.

             </summary>

             <example>

-            <![CDATA[

-            new RegexRedirectRule("/(?<target>[a-z0-9]+)", "/users/${target}?find=true", RegexOptions.IgnoreCase)

-            ]]>

+            public void MyHandler(IHttpRequest request, IHttpResponse response)

+            {

+              

+            }

             </example>

         </member>

-        <member name="M:HttpServer.Rules.RegexRedirectRule.#ctor(System.String,System.String)">

+        <member name="M:HttpServer.IHttpResponse.AddHeader(System.String,System.String)">

             <summary>

-            Initializes a new instance of the <see cref="T:HttpServer.Rules.RegexRedirectRule"/> class.

+            Add another header to the document.

             </summary>

-            <param name="fromUrlExpression">Expression to match URL</param>

-            <param name="toUrlExpression">Expression to generate URL</param>

-            <example>

-            <![CDATA[

-            server.Add(new RegexRedirectRule("/(?<first>[a-zA-Z0-9]+)", "/user/${first}"));

-            Result of ie. /employee1 will then be /user/employee1

-            ]]>

-            </example>

+            <param name="name">Name of the header, case sensitive, use lower cases.</param>

+            <param name="value">Header values can span over multiple lines as long as each line starts with a white space. New line chars should be \r\n</param>

+            <exception cref="T:System.InvalidOperationException">If headers already been sent.</exception>

+            <exception cref="T:System.ArgumentException">If value conditions have not been met.</exception>

+            <remarks>Adding any header will override the default ones and those specified by properties.</remarks>

         </member>

-        <member name="M:HttpServer.Rules.RegexRedirectRule.#ctor(System.String,System.String,System.Text.RegularExpressions.RegexOptions)">

+        <member name="M:HttpServer.IHttpResponse.Send">

             <summary>

-            Initializes a new instance of the <see cref="T:HttpServer.Rules.RegexRedirectRule"/> class.

+            Send headers and body to the browser.

             </summary>

-            <param name="fromUrlExpression">Expression to match URL</param>

-            <param name="toUrlExpression">Expression to generate URL</param>

-            <param name="options">Regular expression options to use, can be null</param>

-            <example>

-            <![CDATA[

-            server.Add(new RegexRedirectRule("/(?<first>[a-zA-Z0-9]+)", "/user/{first}", RegexOptions.IgnoreCase));

-            Result of ie. /employee1 will then be /user/employee1

-            ]]>

-            </example>

+            <exception cref="T:System.InvalidOperationException">If content have already been sent.</exception>

         </member>

-        <member name="M:HttpServer.Rules.RegexRedirectRule.#ctor(System.String,System.String,System.Text.RegularExpressions.RegexOptions,System.Boolean)">

+        <member name="M:HttpServer.IHttpResponse.SendBody(System.Byte[],System.Int32,System.Int32)">

             <summary>

-            Initializes a new instance of the <see cref="T:HttpServer.Rules.RegexRedirectRule"/> class.

+            Make sure that you have specified ContentLength and sent the headers first.

+            </summary>

+            <param name="buffer"></param>

+            <exception cref="T:System.InvalidOperationException">If headers have not been sent.</exception>

+            <see cref="M:HttpServer.IHttpResponse.SendHeaders"/>

+            <param name="offset">offest of first byte to send</param>

+            <param name="count">number of bytes to send.</param>

+            <seealso cref="M:HttpServer.IHttpResponse.Send"/>

+            <seealso cref="M:HttpServer.IHttpResponse.SendHeaders"/>

+            <remarks>This method can be used if you want to send body contents without caching them first. This

+            is recommended for larger files to keep the memory usage low.</remarks>

+        </member>

+        <member name="M:HttpServer.IHttpResponse.SendBody(System.Byte[])">

+            <summary>

+            Make sure that you have specified ContentLength and sent the headers first.

+            </summary>

+            <param name="buffer"></param>

+            <exception cref="T:System.InvalidOperationException">If headers have not been sent.</exception>

+            <see cref="M:HttpServer.IHttpResponse.SendHeaders"/>

+            <seealso cref="M:HttpServer.IHttpResponse.Send"/>

+            <seealso cref="M:HttpServer.IHttpResponse.SendHeaders"/>

+            <remarks>This method can be used if you want to send body contents without caching them first. This

+            is recommended for larger files to keep the memory usage low.</remarks>

+        </member>

+        <member name="M:HttpServer.IHttpResponse.SendHeaders">

+            <summary>

+            Send headers to the client.

+            </summary>

+            <exception cref="T:System.InvalidOperationException">If headers already been sent.</exception>

+            <seealso cref="M:HttpServer.IHttpResponse.AddHeader(System.String,System.String)"/>

+            <seealso cref="M:HttpServer.IHttpResponse.Send"/>

+            <seealso cref="M:HttpServer.IHttpResponse.SendBody(System.Byte[])"/>

+        </member>

+        <member name="M:HttpServer.IHttpResponse.Redirect(System.Uri)">

+            <summary>

+            Redirect client to somewhere else using the 302 status code.

+            </summary>

+            <param name="uri">Destination of the redirect</param>

+            <exception cref="T:System.InvalidOperationException">If headers already been sent.</exception>

+            <remarks>You can not do anything more with the request when a redirect have been done. This should be your last

+            action.</remarks>

+        </member>

+        <member name="M:HttpServer.IHttpResponse.Redirect(System.String)">

+            <summary>

+            redirect to somewhere

+            </summary>

+            <param name="url">where the redirect should go</param>

+            <remarks>

+            No body are allowed when doing redirects.

+            </remarks>

+        </member>

+        <member name="P:HttpServer.IHttpResponse.Body">

+            <summary>

+            The body stream is used to cache the body contents

+            before sending everything to the client. It's the simplest

+            way to serve documents.

+            </summary>

+        </member>

+        <member name="P:HttpServer.IHttpResponse.ProtocolVersion">

+            <summary>

+            Defines the version of the HTTP Response for applications where it's required

+            for this to be forced.

+            </summary>

+        </member>

+        <member name="P:HttpServer.IHttpResponse.Chunked">

+            <summary>

+            The chunked encoding modifies the body of a message in order to

+            transfer it as a series of chunks, each with its own size indicator,

+            followed by an OPTIONAL trailer containing entity-header fields. This

+            allows dynamically produced content to be transferred along with the

+            information necessary for the recipient to verify that it has

+            received the full message.

+            </summary>

+        </member>

+        <member name="P:HttpServer.IHttpResponse.Connection">

+            <summary>

+            Kind of connection

+            </summary>

+        </member>

+        <member name="P:HttpServer.IHttpResponse.Encoding">

+            <summary>

+            Encoding to use when sending stuff to the client.

+            </summary>

+            <remarks>Default is UTF8</remarks>

+        </member>

+        <member name="P:HttpServer.IHttpResponse.KeepAlive">

+            <summary>

+            Number of seconds to keep connection alive

+            </summary>

+            <remarks>Only used if Connection property is set to ConnectionType.KeepAlive</remarks>

+        </member>

+        <member name="P:HttpServer.IHttpResponse.Status">

+            <summary>

+            Status code that is sent to the client.

+            </summary>

+            <remarks>Default is HttpStatusCode.Ok</remarks>

+        </member>

+        <member name="P:HttpServer.IHttpResponse.Reason">

+            <summary>

+            Information about why a specific status code was used.

+            </summary>

+        </member>

+        <member name="P:HttpServer.IHttpResponse.ContentLength">

+            <summary>

+            Size of the body. MUST be specified before sending the header,

+            unless property Chunked is set to true.

+            </summary>

+        </member>

+        <member name="P:HttpServer.IHttpResponse.ContentType">

+            <summary>

+            Kind of content in the body

+            </summary>

+            <remarks>Default is text/html</remarks>

+        </member>

+        <member name="P:HttpServer.IHttpResponse.HeadersSent">

+            <summary>

+            Headers have been sent to the client-

+            </summary>

+            <remarks>You can not send any additional headers if they have already been sent.</remarks>

+        </member>

+        <member name="P:HttpServer.IHttpResponse.Sent">

+            <summary>

+            The whole response have been sent.

+            </summary>

+        </member>

+        <member name="P:HttpServer.IHttpResponse.Cookies">

+            <summary>

+            Cookies that should be created/changed.

+            </summary>

+        </member>

+        <member name="T:HttpServer.ConnectionType">

+            <summary>

+            Type of HTTP connection

+            </summary>

+        </member>

+        <member name="F:HttpServer.ConnectionType.Close">

+            <summary>

+            Connection is closed after each request-response

+            </summary>

+        </member>

+        <member name="F:HttpServer.ConnectionType.KeepAlive">

+            <summary>

+            Connection is kept alive for X seconds (unless another request have been made)

+            </summary>

+        </member>

+        <member name="T:HttpServer.HttpModules.WebSiteModule">

+            <summary>

+            The website module let's you handle multiple websites in the same server.

+            It uses the "Host" header to check which site you want.

+            </summary>

+            <remarks>It's recommended that you do not

+            add any other modules to HttpServer if you are using the website module. Instead,

+            add all wanted modules to each website.</remarks>

+        </member>

+        <member name="M:HttpServer.HttpModules.WebSiteModule.#ctor(System.String,System.String)">

+            <summary>

+            

+            </summary>

+            <param name="host">domain name that should be handled.</param>

+            <param name="name"></param>

+        </member>

+        <member name="M:HttpServer.HttpModules.WebSiteModule.Process(HttpServer.IHttpRequest,HttpServer.IHttpResponse,HttpServer.Sessions.IHttpSession)">

+            <summary>

+            Method that process the url

+            </summary>

+            <param name="request">Information sent by the browser about the request</param>

+            <param name="response">Information that is being sent back to the client.</param>

+            <param name="session">Session used to </param>

+        </member>

+        <member name="P:HttpServer.HttpModules.WebSiteModule.SiteName">

+            <summary>

+            Name of site.

+            </summary>

+        </member>

+        <member name="T:HttpServer.HttpModules.HttpModuleExceptionEventArgs">

+            <summary>

+            Used to inform http server that 

+            </summary>

+        </member>

+        <member name="M:HttpServer.HttpModules.HttpModuleExceptionEventArgs.#ctor(System.Exception)">

+            <summary>

+            Eventarguments used when an exception is thrown by a module

+            </summary>

+            <param name="e">the exception</param>

+        </member>

+        <member name="P:HttpServer.HttpModules.HttpModuleExceptionEventArgs.Exception">

+            <summary>

+            Exception thrown in a module

+            </summary>

+        </member>

+        <member name="T:HttpServer.HttpInputItem">

+            <summary>

+            represents a HTTP input item. Each item can have multiple sub items, a sub item

+            is made in a HTML form by using square brackets

             </summary>

-            <param name="fromUrlExpression">Expression to match URL</param>

-            <param name="toUrlExpression">Expression to generate URL</param>

-            <param name="options">Regular expression options to apply</param>

-            <param name="shouldRedirect"><c>true</c> if request should be redirected, <c>false</c> if the request URI should be replaced.</param>

             <example>

-            <![CDATA[

-            server.Add(new RegexRedirectRule("/(?<first>[a-zA-Z0-9]+)", "/user/${first}", RegexOptions.None));

-            Result of ie. /employee1 will then be /user/employee1

-            ]]>

+              // <input type="text" name="user[FirstName]" value="jonas" /> becomes:

+              Console.WriteLine("Value: {0}", form["user"]["FirstName"].Value);

             </example>

+            <remarks>

+            All names in a form SHOULD be in lowercase.

+            </remarks>

+        </member>

+        <member name="F:HttpServer.HttpInputItem.Empty">

+            <summary> Representation of a non-initialized <see cref="T:HttpServer.HttpInputItem"/>.</summary>

+        </member>

+        <member name="M:HttpServer.HttpInputItem.#ctor(System.String,System.String)">

+            <summary>

+            Initializes an input item setting its name/identifier and value

+            </summary>

+            <param name="name">Parameter name/id</param>

+            <param name="value">Parameter value</param>

+        </member>

+        <member name="M:HttpServer.HttpInputItem.#ctor(HttpServer.HttpInputItem)">

+            <summary>Creates a deep copy of the item specified</summary>

+            <param name="item">The item to copy</param>

+            <remarks>The function makes a deep copy of quite a lot which can be slow</remarks>

+        </member>

+        <member name="M:HttpServer.HttpInputItem.Add(System.String)">

+            <summary>

+            Add another value to this item

+            </summary>

+            <param name="value">Value to add.</param>

+            <exception cref="T:System.InvalidOperationException">Cannot add stuff to <see cref="F:HttpServer.HttpInput.Empty"/>.</exception>

+        </member>

+        <member name="M:HttpServer.HttpInputItem.Contains(System.String)">

+            <summary>

+            checks if a sub-item exists (and has a value).

+            </summary>

+            <param name="name">name in lower case</param>

+            <returns>true if the sub-item exists and has a value; otherwise false.</returns>

+        </member>

+        <member name="M:HttpServer.HttpInputItem.ToString">

+            <summary> Returns a formatted representation of the instance with the values of all contained parameters </summary>

+        </member>

+        <member name="M:HttpServer.HttpInputItem.ToString(System.String,System.Boolean)">

+            <summary>

+            Outputs the string in a formatted manner

+            </summary>

+            <param name="prefix">A prefix to append, used internally</param>

+            <param name="asQuerySting">produce a query string</param>

+        </member>

+        <member name="M:HttpServer.HttpInputItem.Add(System.String,System.String)">

+            <summary>

+            Add a sub item.

+            </summary>

+            <param name="name">Can contain array formatting, the item is then parsed and added in multiple levels</param>

+            <param name="value">Value to add.</param>

             <exception cref="T:System.ArgumentNullException">Argument is null.</exception>

-            <seealso cref="P:HttpServer.Rules.RedirectRule.ShouldRedirect"/>

+            <exception cref="T:System.InvalidOperationException">Cannot add stuff to <see cref="F:HttpServer.HttpInput.Empty"/>.</exception>

         </member>

-        <member name="M:HttpServer.Rules.RegexRedirectRule.Process(HttpServer.IHttpRequest,HttpServer.IHttpResponse)">

+        <member name="M:HttpServer.HttpInputItem.System#Collections#Generic#IEnumerable{HttpServer#HttpInputItem}#GetEnumerator">

             <summary>

-            Process the incoming request.

+            Returns an enumerator that iterates through the collection.

             </summary>

-            <param name="request">incoming HTTP request</param>

-            <param name="response">outgoing HTTP response</param>

-            <returns>true if response should be sent to the browser directly (no other rules or modules will be processed).</returns>

-            <remarks>

-            returning true means that no modules will get the request. Returning true is typically being done

-            for redirects.

-            </remarks>

-            <exception cref="T:System.ArgumentNullException">If request or response is null</exception>

+            

+            <returns>

+            A <see cref="T:System.Collections.Generic.IEnumerator`1"></see> that can be used to iterate through the collection.

+            </returns>

+            <filterpriority>1</filterpriority>

+        </member>

+        <member name="M:HttpServer.HttpInputItem.GetEnumerator">

+            <summary>

+            Returns an enumerator that iterates through a collection.

+            </summary>

+            

+            <returns>

+            An <see cref="T:System.Collections.IEnumerator"></see> object that can be used to iterate through the collection.

+            </returns>

+            <filterpriority>2</filterpriority>

+        </member>

+        <member name="M:HttpServer.HttpInputItem.ToString(System.String)">

+            <summary>

+            Outputs the string in a formatted manner

+            </summary>

+            <param name="prefix">A prefix to append, used internally</param>

+            <returns></returns>

+        </member>

+        <member name="P:HttpServer.HttpInputItem.Count">

+            <summary>

+            Number of values

+            </summary>

+        </member>

+        <member name="P:HttpServer.HttpInputItem.Item(System.String)">

+            <summary>

+            Get a sub item

+            </summary>

+            <param name="name">name in lower case.</param>

+            <returns><see cref="F:HttpServer.HttpInputItem.Empty"/> if no item was found.</returns>

+        </member>

+        <member name="P:HttpServer.HttpInputItem.Name">

+            <summary>

+            Name of item (in lower case).

+            </summary>

+        </member>

+        <member name="P:HttpServer.HttpInputItem.Value">

+            <summary>

+            Returns the first value, or null if no value exist.

+            </summary>

+        </member>

+        <member name="P:HttpServer.HttpInputItem.LastValue">

+            <summary>

+            Returns the last value, or null if no value exist.

+            </summary>

+        </member>

+        <member name="P:HttpServer.HttpInputItem.Values">

+            <summary>

+            Returns the list with values.

+            </summary>

+        </member>

+        <member name="P:HttpServer.HttpInputItem.HttpServer#IHttpInput#Item(System.String)">

+            <summary>

+            

+            </summary>

+            <param name="name">name in lower case</param>

+            <returns></returns>

+        </member>

+        <member name="T:HttpServer.Helpers.ResourceManager">

+            <summary>Class to handle loading of resource files</summary>

+        </member>

+        <member name="M:HttpServer.Helpers.ResourceManager.#ctor">

+            <summary>

+            Initializes a new instance of the <see cref="T:HttpServer.Helpers.ResourceManager"/> class.

+            </summary>

+        </member>

+        <member name="M:HttpServer.Helpers.ResourceManager.#ctor(HttpServer.ILogWriter)">

+            <summary>

+            Initializes a new instance of the <see cref="T:HttpServer.Helpers.ResourceManager"/> class.

+            </summary>

+            <param name="writer">logger.</param>

+        </member>

+        <member name="M:HttpServer.Helpers.ResourceManager.LoadResources(System.String,System.Reflection.Assembly,System.String)">

+            <summary>

+            Loads resources from a namespace in the given assembly to an URI

+            </summary>

+            <param name="toUri">The URI to map the resources to</param>

+            <param name="fromAssembly">The assembly in which the resources reside</param>

+            <param name="fromNamespace">The namespace from which to load the resources</param>

+            <usage>

+            <code>

+            resourceLoader.LoadResources("/user/", typeof(User).Assembly, "MyLib.Models.User.Views");

+            </code>

+            Will make the resource MyLib.Models.User.Views.list.Haml accessible via /user/list.haml or /user/list/

+            </usage>

+            <returns>The amount of loaded files, giving you the possibility of making sure the resources needed gets loaded</returns>

+            <exception cref="T:System.InvalidOperationException">If a resource has already been mapped to an uri</exception>

+        </member>

+        <member name="M:HttpServer.Helpers.ResourceManager.GetResourceStream(System.String)">

+            <summary>

+            Retrieves a stream for the specified resource path if loaded otherwise null

+            </summary>

+            <param name="path">Path to the resource to retrieve a stream for</param>

+            <returns>A stream or null if the resource couldn't be found</returns>

+        </member>

+        <member name="M:HttpServer.Helpers.ResourceManager.GetFiles(System.String)">

+            <summary>

+            Fetch all files from the resource that matches the specified arguments.

+            </summary>

+            <param name="path">The path to the resource to extract</param>

+            <returns>

+            a list of files if found; or an empty array if no files are found.

+            </returns>

+            <exception cref="T:System.ArgumentException">Search path must end with an asterisk for finding arbitrary files</exception>

+        </member>

+        <member name="M:HttpServer.Helpers.ResourceManager.GetFiles(System.String,System.String)">

+            <summary>

+            Fetch all files from the resource that matches the specified arguments.

+            </summary>

+            <param name="path">Where the file should reside.</param>

+            <param name="filename">Files to check</param>

+            <returns>

+            a list of files if found; or an empty array if no files are found.

+            </returns>

+        </member>

+        <member name="M:HttpServer.Helpers.ResourceManager.ContainsResource(System.String)">

+            <summary>

+            Returns whether or not the loader has an instance of the file requested

+            </summary>

+            <param name="filename">The name of the template/file</param>

+            <returns>True if the loader can provide the file</returns>

         </member>

         <member name="T:HttpServer.Parser.RequestLineEventArgs">

             <summary>

@@ -3664,908 +3707,849 @@
             Gets or sets requested URI path.

             </summary>

         </member>

-        <member name="T:HttpServer.RealmHandler">

+        <member name="T:HttpServer.IHttpContextHandler">

             <summary>

-            Delegate used to find a realm/domain.

+            Class that receives Requests from a <see cref="T:HttpServer.IHttpClientContext"/>.

+            </summary>

+        </member>

+        <member name="M:HttpServer.IHttpContextHandler.ClientDisconnected(HttpServer.IHttpClientContext,System.Net.Sockets.SocketError)">

+            <summary>

+            Client have been disconnected.

+            </summary>

+            <param name="client">Client that was disconnected.</param>

+            <param name="error">Reason</param>

+            <see cref="T:HttpServer.IHttpClientContext"/>

+        </member>

+        <member name="M:HttpServer.IHttpContextHandler.RequestReceived(HttpServer.IHttpClientContext,HttpServer.IHttpRequest)">

+            <summary>

+            Invoked when a client context have received a new HTTP request

+            </summary>

+            <param name="client">Client that received the request.</param>

+            <param name="request">Request that was received.</param>

+            <see cref="T:HttpServer.IHttpClientContext"/>

+        </member>

+        <member name="T:HttpServer.HttpForm">

+            <summary>Container for posted form data</summary>

+        </member>

+        <member name="F:HttpServer.HttpForm.EmptyForm">

+            <summary>Instance to help mark a non-initialized form</summary>

+        </member>

+        <member name="M:HttpServer.HttpForm.#ctor">

+            <summary>Initializes a form container with the specified name</summary>

+        </member>

+        <member name="M:HttpServer.HttpForm.#ctor(HttpServer.HttpInput)">

+            <summary>

+            Makes a deep copy of the input

+            </summary>

+            <param name="input">The input to copy</param>

+        </member>

+        <member name="M:HttpServer.HttpForm.AddFile(HttpServer.HttpFile)">

+            <summary>

+            Adds a file to the collection of posted files

+            </summary>

+            <param name="file">The file to add</param>

+            <exception cref="T:System.ArgumentException">If the file is already added</exception>

+            <exception cref="T:System.ArgumentNullException">If file is null</exception>

+            <exception cref="T:System.InvalidOperationException">If the instance is HttpForm.EmptyForm which cannot be modified</exception>

+        </member>

+        <member name="M:HttpServer.HttpForm.ContainsFile(System.String)">

+            <summary>

+            Checks if the form contains a specified file

+            </summary>

+            <param name="name">Field name of the file parameter</param>

+            <returns>True if the file exists</returns>

+            <exception cref="T:System.InvalidOperationException">If the instance is HttpForm.EmptyForm which cannot be modified</exception>

+        </member>

+        <member name="M:HttpServer.HttpForm.GetFile(System.String)">

+            <summary>

+            Retrieves a file held by by the form

+            </summary>

+            <param name="name">The identifier of the file</param>

+            <returns>The requested file or null if the file was not found</returns>

+            <exception cref="T:System.ArgumentNullException">If name is null or empty</exception>

+            <exception cref="T:System.InvalidOperationException">If the instance is HttpForm.EmptyForm which cannot be modified</exception>

+        </member>

+        <member name="M:HttpServer.HttpForm.Clear">

+            <summary>Disposes all held HttpFile's and resets values</summary>

+        </member>

+        <member name="P:HttpServer.HttpForm.Files">

+            <summary>

+            Retrieves the number of files added to the <see cref="T:HttpServer.HttpForm"/>

+            </summary>

+            <returns>0 if no files are added</returns>

+        </member>

+        <member name="T:HttpServer.HttpClientContext">

+            <summary>

+            Contains a connection to a browser/client.

             </summary>

-            <param name="domain"></param>

-            <returns></returns>

             <remarks>

-            Realms are used during HTTP Authentication

+            Remember to <see cref="M:HttpServer.HttpClientContext.Start"/> after you have hooked the <see cref="E:HttpServer.HttpClientContext.RequestReceived"/> event.

             </remarks>

-            <seealso cref="T:HttpServer.Authentication.AuthenticationModule"/>

-            <seealso cref="T:HttpServer.Authentication.AuthenticationHandler"/>

+            TODO: Maybe this class should be broken up into HttpClientChannel and HttpClientContext?

         </member>

-        <member name="T:HttpServer.HttpServer">

+        <member name="M:HttpServer.HttpClientContext.#ctor(System.Boolean,System.Net.IPEndPoint,System.IO.Stream,HttpServer.IRequestParserFactory,System.Int32,System.Net.Sockets.Socket)">

             <summary>

-            A complete HTTP server, you need to add a module to it to be able to handle incoming requests.

+            Initializes a new instance of the <see cref="T:HttpServer.HttpClientContext"/> class.

             </summary>

-            <example>

-            <code>

-            // this small example will add two web site modules, thus handling

-            // two different sites. In reality you should add Controller modules or something

-            // two the website modules to be able to handle different requests.

-            HttpServer server = new HttpServer();

-            server.Add(new WebSiteModule("www.gauffin.com", "Gauffin Telecom AB"));

-            server.Add(new WebSiteModule("www.vapadi.se", "Remote PBX"));

-            

-            // start regular http

-            server.Start(IPAddress.Any, 80);

+            <param name="secured">true if the connection is secured (SSL/TLS)</param>

+            <param name="remoteEndPoint">client that connected.</param>

+            <param name="stream">Stream used for communication</param>

+            <param name="parserFactory">Used to create a <see cref="T:HttpServer.IHttpRequestParser"/>.</param>

+            <param name="bufferSize">Size of buffer to use when reading data. Must be at least 4096 bytes.</param>

+            <exception cref="T:System.Net.Sockets.SocketException">If <see cref="M:System.Net.Sockets.Socket.BeginReceive(System.Byte[],System.Int32,System.Int32,System.Net.Sockets.SocketFlags,System.AsyncCallback,System.Object)"/> fails</exception>

+            <exception cref="T:System.ArgumentException">Stream must be writable and readable.</exception>

+        </member>

+        <member name="M:HttpServer.HttpClientContext.OnBodyBytesReceived(System.Object,HttpServer.Parser.BodyEventArgs)">

+            <summary>

+            Process incoming body bytes.

+            </summary>

+            <param name="sender"><see cref="T:HttpServer.IHttpRequestParser"/></param>

+            <param name="e">Bytes</param>

+        </member>

+        <member name="M:HttpServer.HttpClientContext.OnHeaderReceived(System.Object,HttpServer.Parser.HeaderEventArgs)">

+            <summary>

             

-            // start https

-            server.Start(IPAddress.Any, 443, myCertificate);

-            </code>

-            </example>

-            <seealso cref="T:HttpServer.HttpModules.HttpModule"/>

-            <seealso cref="T:HttpServer.HttpModules.FileModule"/>

-            <seealso cref="T:HttpServer.HttpListener"/>

+            </summary>

+            <param name="sender"></param>

+            <param name="e"></param>

         </member>

-        <member name="M:HttpServer.HttpServer.#ctor(HttpServer.IComponentProvider)">

+        <member name="M:HttpServer.HttpClientContext.Start">

             <summary>

-            Initializes a new instance of the <see cref="T:HttpServer.HttpServer"/> class.

+            Start reading content.

             </summary>

-            <param name="provider">Used to get all components used in the server..</param>

+            <remarks>

+            Make sure to call base.Start() if you override this method.

+            </remarks>

         </member>

-        <member name="M:HttpServer.HttpServer.#ctor">

+        <member name="M:HttpServer.HttpClientContext.Cleanup">

             <summary>

-            Initializes a new instance of the <see cref="T:HttpServer.HttpServer"/> class.

+            Clean up context.

             </summary>

+            <remarks>

+            Make sure to call base.Cleanup() if you override the method.

+            </remarks>

         </member>

-        <member name="M:HttpServer.HttpServer.#ctor(HttpServer.FormDecoders.FormDecoderProvider)">

+        <member name="M:HttpServer.HttpClientContext.Disconnect(System.Net.Sockets.SocketError)">

             <summary>

-            Initializes a new instance of the <see cref="T:HttpServer.HttpServer"/> class.

+            Disconnect from client

             </summary>

-            <param name="decoderProvider">Form decoders are used to convert different types of posted data to the <see cref="T:HttpServer.HttpInput"/> object types.</param>

-            <seealso cref="T:HttpServer.FormDecoders.IFormDecoder"/>

-            <seealso cref="P:HttpServer.HttpServer.FormDecoderProviders"/>

+            <param name="error">error to report in the <see cref="E:HttpServer.HttpClientContext.Disconnected"/> event.</param>

         </member>

-        <member name="M:HttpServer.HttpServer.#ctor(HttpServer.Sessions.IHttpSessionStore)">

+        <member name="M:HttpServer.HttpClientContext.Respond(System.String,System.Net.HttpStatusCode,System.String,System.String,System.String)">

             <summary>

-            Initializes a new instance of the <see cref="T:HttpServer.HttpServer"/> class.

+            Send a response.

             </summary>

-            <param name="sessionStore">A session store is used to save and retrieve sessions</param>

-            <seealso cref="T:HttpServer.Sessions.IHttpSessionStore"/>

+            <param name="httpVersion">Either <see cref="F:HttpServer.HttpHelper.HTTP10"/> or <see cref="F:HttpServer.HttpHelper.HTTP11"/></param>

+            <param name="statusCode">HTTP status code</param>

+            <param name="reason">reason for the status code.</param>

+            <param name="body">HTML body contents, can be null or empty.</param>

+            <param name="contentType">A content type to return the body as, i.e. 'text/html' or 'text/plain', defaults to 'text/html' if null or empty</param>

+            <exception cref="T:System.ArgumentException">If <paramref name="httpVersion"/> is invalid.</exception>

         </member>

-        <member name="M:HttpServer.HttpServer.#ctor(HttpServer.ILogWriter)">

+        <member name="M:HttpServer.HttpClientContext.Respond(System.String,System.Net.HttpStatusCode,System.String)">

             <summary>

-            Initializes a new instance of the <see cref="T:HttpServer.HttpServer"/> class.

+            Send a response.

             </summary>

-            <param name="logWriter">The log writer.</param>

-            <seealso cref="P:HttpServer.HttpServer.LogWriter"/>

+            <param name="httpVersion">Either <see cref="F:HttpServer.HttpHelper.HTTP10"/> or <see cref="F:HttpServer.HttpHelper.HTTP11"/></param>

+            <param name="statusCode">HTTP status code</param>

+            <param name="reason">reason for the status code.</param>

         </member>

-        <member name="M:HttpServer.HttpServer.#ctor(HttpServer.FormDecoders.FormDecoderProvider,HttpServer.ILogWriter)">

+        <member name="M:HttpServer.HttpClientContext.Respond(System.String)">

             <summary>

-            Initializes a new instance of the <see cref="T:HttpServer.HttpServer"/> class.

+            Send a response.

             </summary>

-            <param name="decoderProvider">Form decoders are used to convert different types of posted data to the <see cref="T:HttpServer.HttpInput"/> object types.</param>

-            <param name="logWriter">The log writer.</param>

-            <seealso cref="T:HttpServer.FormDecoders.IFormDecoder"/>

-            <seealso cref="P:HttpServer.HttpServer.FormDecoderProviders"/>

-            <seealso cref="P:HttpServer.HttpServer.LogWriter"/>

+            <exception cref="T:System.ArgumentNullException"></exception>

         </member>

-        <member name="M:HttpServer.HttpServer.#ctor(HttpServer.FormDecoders.FormDecoderProvider,HttpServer.Sessions.IHttpSessionStore,HttpServer.ILogWriter)">

+        <member name="M:HttpServer.HttpClientContext.Send(System.Byte[])">

             <summary>

-            Initializes a new instance of the <see cref="T:HttpServer.HttpServer"/> class.

+            send a whole buffer

             </summary>

-            <param name="decoderProvider">Form decoders are used to convert different types of posted data to the <see cref="T:HttpServer.HttpInput"/> object types.</param>

-            <param name="sessionStore">A session store is used to save and retrieve sessions</param>

-            <param name="logWriter">The log writer.</param>

-            <seealso cref="T:HttpServer.FormDecoders.IFormDecoder"/>

-            <seealso cref="P:HttpServer.HttpServer.FormDecoderProviders"/>

-            <seealso cref="P:HttpServer.HttpServer.LogWriter"/>

-            <seealso cref="T:HttpServer.Sessions.IHttpSessionStore"/>

+            <param name="buffer">buffer to send</param>

+            <exception cref="T:System.ArgumentNullException"></exception>

         </member>

-        <member name="M:HttpServer.HttpServer.Add(HttpServer.Rules.IRule)">

+        <member name="M:HttpServer.HttpClientContext.Send(System.Byte[],System.Int32,System.Int32)">

             <summary>

-            Adds the specified rule.

+            Send data using the stream

             </summary>

-            <param name="rule">The rule.</param>

+            <param name="buffer">Contains data to send</param>

+            <param name="offset">Start position in buffer</param>

+            <param name="size">number of bytes to send</param>

+            <exception cref="T:System.ArgumentNullException"></exception>

+            <exception cref="T:System.ArgumentOutOfRangeException"></exception>

         </member>

-        <member name="M:HttpServer.HttpServer.Add(HttpServer.HttpModules.HttpModule)">

+        <member name="E:HttpServer.HttpClientContext.Cleaned">

             <summary>

-            Add a <see cref="T:HttpServer.HttpModules.HttpModule"/> to the server.

+            This context have been cleaned, which means that it can be reused.

             </summary>

-            <param name="module">mode to add</param>

         </member>

-        <member name="M:HttpServer.HttpServer.DecodeBody(HttpServer.IHttpRequest)">

+        <member name="E:HttpServer.HttpClientContext.Started">

             <summary>

-            Decodes the request body.

+            Context have been started (a new client have connected)

             </summary>

-            <param name="request">The request.</param>

-            <exception cref="T:HttpServer.Exceptions.InternalServerException">Failed to decode form data.</exception>

         </member>

-        <member name="M:HttpServer.HttpServer.ErrorPage(HttpServer.IHttpResponse,System.Net.HttpStatusCode,System.String)">

+        <member name="P:HttpServer.HttpClientContext.CurrentRequest">

             <summary>

-            Generate a HTTP error page (that will be added to the response body).

-            response status code is also set.

+            Overload to specify own type.

             </summary>

-            <param name="response">Response that the page will be generated in.</param>

-            <param name="error"><see cref="T:System.Net.HttpStatusCode"/>.</param>

-            <param name="body">response body contents.</param>

+            <remarks>

+            Must be specified before the context is being used.

+            </remarks>

         </member>

-        <member name="M:HttpServer.HttpServer.ErrorPage(HttpServer.IHttpResponse,HttpServer.Exceptions.HttpException)">

+        <member name="P:HttpServer.HttpClientContext.Secured">

             <summary>

-            Generate a HTTP error page (that will be added to the response body).

-            response status code is also set.

+            Using SSL or other encryption method.

             </summary>

-            <param name="response">Response that the page will be generated in.</param>

-            <param name="err">exception.</param>

         </member>

-        <member name="M:HttpServer.HttpServer.GetRealm(HttpServer.IHttpRequest)">

+        <member name="P:HttpServer.HttpClientContext.IsSecured">

             <summary>

-            Realms are used by the <see cref="T:HttpServer.Authentication.AuthenticationModule"/>s.

+            Using SSL or other encryption method.

             </summary>

-            <param name="request">HTTP request</param>

-            <returns>domain/realm.</returns>

         </member>

-        <member name="M:HttpServer.HttpServer.HandleRequest(HttpServer.IHttpClientContext,HttpServer.IHttpRequest,HttpServer.IHttpResponse,HttpServer.Sessions.IHttpSession)">

+        <member name="P:HttpServer.HttpClientContext.LogWriter">

             <summary>

-            Process an incoming request.

+            Specify which logger to use.

             </summary>

-            <param name="context">connection to client</param>

-            <param name="request">request information</param>

-            <param name="response">response that should be filled</param>

-            <param name="session">session information</param>

         </member>

-        <member name="M:HttpServer.HttpServer.OnClientDisconnected(HttpServer.IHttpClientContext,System.Net.Sockets.SocketError)">

+        <member name="P:HttpServer.HttpClientContext.Stream">

             <summary>

-            Can be overloaded to implement stuff when a client have been connected.

+            Gets or sets the network stream.

             </summary>

-            <remarks>

-            Default implementation does nothing.

-            </remarks>

-            <param name="client">client that disconnected</param>

-            <param name="error">disconnect reason</param>

         </member>

-        <member name="M:HttpServer.HttpServer.ProcessAuthentication(HttpServer.IHttpRequest,HttpServer.IHttpResponse,HttpServer.Sessions.IHttpSession)">

+        <member name="P:HttpServer.HttpClientContext.RemoteAddress">

             <summary>

-            Handle authentication

+            Gets or sets IP address that the client connected from.

             </summary>

-            <param name="request"></param>

-            <param name="response"></param>

-            <param name="session"></param>

-            <returns>true if request can be handled; false if not.</returns>

-            <exception cref="T:HttpServer.Exceptions.BadRequestException">Invalid authorization header</exception>

         </member>

-        <member name="M:HttpServer.HttpServer.RequestAuthentication(HttpServer.Authentication.AuthenticationModule,HttpServer.IHttpRequest,HttpServer.IHttpResponse)">

+        <member name="P:HttpServer.HttpClientContext.RemotePort">

             <summary>

-            Will request authentication.

+            Gets or sets port that the client connected from.

+            </summary>

+        </member>

+        <member name="E:HttpServer.HttpClientContext.Disconnected">

+            <summary>

+            The context have been disconnected.

             </summary>

             <remarks>

-            Sends respond to client, nothing else can be done with the response after this.

+            Event can be used to clean up a context, or to reuse it.

             </remarks>

-            <param name="mod"></param>

-            <param name="request"></param>

-            <param name="response"></param>

         </member>

-        <member name="M:HttpServer.HttpServer.OnRequest(System.Object,HttpServer.RequestEventArgs)">

+        <member name="E:HttpServer.HttpClientContext.RequestReceived">

             <summary>

-            Received from a <see cref="T:HttpServer.IHttpClientContext"/> when a request have been parsed successfully.

+            A request have been received in the context.

             </summary>

-            <param name="source"><see cref="T:HttpServer.IHttpClientContext"/> that received the request.</param>

-            <param name="args">The request.</param>

         </member>

-        <member name="M:HttpServer.HttpServer.ProcessRequestWrapper(HttpServer.IHttpClientContext,HttpServer.IHttpRequest)">

+        <member name="T:HttpServer.Helpers.XmlHelper">

             <summary>

-            To be able to track request count.

+            Helpers to make XML handling easier

             </summary>

-            <param name="context"></param>

-            <param name="request"></param>

         </member>

-        <member name="M:HttpServer.HttpServer.Start(System.Net.IPAddress,System.Int32)">

+        <member name="M:HttpServer.Helpers.XmlHelper.Serialize(System.Object)">

             <summary>

-            Start the web server using regular HTTP.

+            Serializes object to XML.

             </summary>

-            <param name="address">IP Address to listen on, use <c>IpAddress.Any </c>to accept connections on all IP addresses/network cards.</param>

-            <param name="port">Port to listen on. 80 can be a good idea =)</param>

-            <exception cref="T:System.ArgumentNullException"><c>address</c> is null.</exception>

-            <exception cref="T:System.ArgumentException">Port must be a positive number.</exception>

+            <param name="value">object to serialize.</param>

+            <returns>XML</returns>

+            <remarks>

+            Removes name spaces and adds indentation

+            </remarks>

         </member>

-        <member name="M:HttpServer.HttpServer.Start(System.Net.IPAddress,System.Int32,System.Security.Cryptography.X509Certificates.X509Certificate)">

+        <member name="M:HttpServer.Helpers.XmlHelper.Deserialize``1(System.String)">

             <summary>

-            Accept secure connections.

+            Create an object from a XML string

             </summary>

-            <param name="address">IP Address to listen on, use <see cref="F:System.Net.IPAddress.Any"/> to accept connections on all IP Addresses / network cards.</param>

-            <param name="port">Port to listen on. 80 can be a good idea =)</param>

-            <param name="certificate">Certificate to use</param>

-            <exception cref="T:System.ArgumentNullException"><c>address</c> is null.</exception>

-            <exception cref="T:System.ArgumentException">Port must be a positive number.</exception>

+            <typeparam name="T">Type of object</typeparam>

+            <param name="xml">XML string</param>

+            <returns>object</returns>

         </member>

-        <member name="M:HttpServer.HttpServer.Stop">

+        <member name="M:HttpServer.FormDecoders.HttpMultipart.ReadLine">

             <summary>

-            shut down the server and listeners

+            

             </summary>

+            <returns></returns>

+            <exception cref="T:System.ArgumentOutOfRangeException"></exception>

+            <exception cref="T:System.ObjectDisposedException"></exception>

         </member>

-        <member name="M:HttpServer.HttpServer.WriteLog(HttpServer.LogPrio,System.String)">

+        <member name="T:HttpServer.FormDecoders.HttpMultipart.Element">

+            <summary>Represents a field in a multipart form</summary>

+        </member>

+        <member name="T:HttpServer.Check">

             <summary>

-            write an entry to the log file

+            Small design by contract implementation.

             </summary>

-            <param name="prio">importance of the message</param>

-            <param name="message">log message</param>

         </member>

-        <member name="M:HttpServer.HttpServer.WriteLog(System.Object,HttpServer.LogPrio,System.String)">

+        <member name="M:HttpServer.Check.NotEmpty(System.String,System.String)">

             <summary>

-            write an entry to the log file

+            Check whether a parameter is empty.

             </summary>

-            <param name="source">object that wrote the message</param>

-            <param name="prio">importance of the message</param>

-            <param name="message">log message</param>

+            <param name="value">Parameter value</param>

+            <param name="parameterOrErrorMessage">Parameter name, or error description.</param>

+            <exception cref="T:System.ArgumentException">value is empty.</exception>

         </member>

-        <member name="P:HttpServer.HttpServer.Current">

+        <member name="M:HttpServer.Check.Require(System.Object,System.String)">

             <summary>

-            Server that is handling the current request.

+            Checks whether a parameter is null.

             </summary>

-            <remarks>

-            Will be set as soon as a request arrives to the <see cref="T:HttpServer.HttpServer"/> object.

-            </remarks>

+            <param name="value">Parameter value</param>

+            <param name="parameterOrErrorMessage">Parameter name, or error description.</param>

+            <exception cref="T:System.ArgumentNullException">value is null.</exception>

         </member>

-        <member name="P:HttpServer.HttpServer.AuthenticationModules">

+        <member name="M:HttpServer.Check.Min(System.Int32,System.Object,System.String)">

             <summary>

-            Modules used for authentication. The module that is is added first is used as 

-            the default authentication module.

+            Checks whether a parameter is null.

             </summary>

-            <remarks>Use the corresponding property

-            in the <see cref="T:HttpServer.HttpModules.WebSiteModule"/> if you are using multiple websites.</remarks>

+            <param name="minValue"></param>

+            <param name="value">Parameter value</param>

+            <param name="parameterOrErrorMessage">Parameter name, or error description.</param>

+            <exception cref="T:System.ArgumentException">value is null.</exception>

         </member>

-        <member name="P:HttpServer.HttpServer.FormDecoderProviders">

+        <member name="T:HttpServer.LogPrio">

             <summary>

-            Form decoder providers are used to decode request body (which normally contains form data).

+            Priority for log entries

             </summary>

+            <seealso cref="T:HttpServer.ILogWriter"/>

         </member>

-        <member name="P:HttpServer.HttpServer.ServerName">

+        <member name="F:HttpServer.LogPrio.Trace">

             <summary>

-            Server name sent in HTTP responses.

+            Very detailed logs to be able to follow the flow of the program.

             </summary>

-            <remarks>

-            Do NOT include version in name, since it makes it 

-            easier for hackers.

-            </remarks>

         </member>

-        <member name="P:HttpServer.HttpServer.SessionCookieName">

+        <member name="F:HttpServer.LogPrio.Debug">

             <summary>

-            Name of cookie where session id is stored.

+            Logs to help debug errors in the application

             </summary>

         </member>

-        <member name="P:HttpServer.HttpServer.LogWriter">

+        <member name="F:HttpServer.LogPrio.Info">

             <summary>

-            Specified where logging should go.

+            Information to be able to keep track of state changes etc.

             </summary>

-            <seealso cref="T:HttpServer.NullLogWriter"/>

-            <seealso cref="T:HttpServer.ConsoleLogWriter"/>

-            <seealso cref="P:HttpServer.HttpServer.LogWriter"/>

         </member>

-        <member name="P:HttpServer.HttpServer.BackLog">

+        <member name="F:HttpServer.LogPrio.Warning">

             <summary>

-            Number of connections that can wait to be accepted by the server.

+            Something did not go as we expected, but it's no problem.

             </summary>

-            <remarks>Default is 10.</remarks>

         </member>

-        <member name="P:HttpServer.HttpServer.MaxRequestCount">

+        <member name="F:HttpServer.LogPrio.Error">

             <summary>

-            Gets or sets maximum number of allowed simultaneous requests.

+            Something that should not fail failed, but we can still keep

+            on going.

             </summary>

-            <remarks>

-            <para>

-            This property is useful in busy systems. The HTTP server

-            will start queuing new requests if this limit is hit, instead

-            of trying to process all incoming requests directly.

-            </para>

-            <para>

-            The default number if allowed simultaneous requests are 10.

-            </para>

-            </remarks>

         </member>

-        <member name="P:HttpServer.HttpServer.MaxQueueSize">

+        <member name="F:HttpServer.LogPrio.Fatal">

             <summary>

-            Gets or sets maximum number of requests queuing to be handled.

+            Something failed, and we cannot handle it properly.

             </summary>

-            <remarks>

-            <para>

-            The WebServer will start turning requests away if response code

-            <see cref="F:System.Net.HttpStatusCode.ServiceUnavailable"/> to indicate that the server

-            is too busy to be able to handle the request.

-            </para>

-            </remarks>

         </member>

-        <member name="E:HttpServer.HttpServer.RealmWanted">

+        <member name="T:HttpServer.ILogWriter">

             <summary>

-            Realms are used during HTTP authentication.

-            Default realm is same as server name.

+            Interface used to write to log files.

             </summary>

         </member>

-        <member name="E:HttpServer.HttpServer.ExceptionThrown">

+        <member name="M:HttpServer.ILogWriter.Write(System.Object,HttpServer.LogPrio,System.String)">

             <summary>

-            Let's to receive unhandled exceptions from the threads.

+            Write an entry to the log file.

             </summary>

-            <remarks>

-            Exceptions will be thrown during debug mode if this event is not used,

-            exceptions will be printed to console and suppressed during release mode.

-            </remarks>

+            <param name="source">object that is writing to the log</param>

+            <param name="priority">importance of the log message</param>

+            <param name="message">the message</param>

         </member>

-        <member name="T:HttpServer.Exceptions.UnauthorizedException">

+        <member name="T:HttpServer.ConsoleLogWriter">

             <summary>

-            The request requires user authentication. The response MUST include a 

-            WWW-Authenticate header field (section 14.47) containing a challenge 

-            applicable to the requested resource. 

-            

-            The client MAY repeat the request with a suitable Authorization header 

-            field (section 14.8). If the request already included Authorization 

-            credentials, then the 401 response indicates that authorization has been 

-            refused for those credentials. If the 401 response contains the same challenge 

-            as the prior response, and the user agent has already attempted authentication 

-            at least once, then the user SHOULD be presented the entity that was given in the response, 

-            since that entity might include relevant diagnostic information. 

-            

-            HTTP access authentication is explained in rfc2617:

-            http://www.ietf.org/rfc/rfc2617.txt

-            

-            (description is taken from 

-            http://www.submissionchamber.com/help-guides/error-codes.php#sec10.4.2)

+            This class writes to the console. It colors the output depending on the logprio and includes a 3-level stacktrace (in debug mode)

             </summary>

+            <seealso cref="T:HttpServer.ILogWriter"/>

         </member>

-        <member name="M:HttpServer.Exceptions.UnauthorizedException.#ctor">

+        <member name="F:HttpServer.ConsoleLogWriter.Instance">

             <summary>

-            Create a new unauhtorized exception.

+            The actual instance of this class.

             </summary>

-            <seealso cref="T:HttpServer.Exceptions.UnauthorizedException"/>

         </member>

-        <member name="M:HttpServer.Exceptions.UnauthorizedException.#ctor(System.String,System.Exception)">

+        <member name="M:HttpServer.ConsoleLogWriter.Write(System.Object,HttpServer.LogPrio,System.String)">

             <summary>

-            Create a new unauhtorized exception.

+            Logwriters the specified source.

             </summary>

-            <param name="message">reason to why the request was unauthorized.</param>

-            <param name="inner">inner exception</param>

+            <param name="source">object that wrote the logentry.</param>

+            <param name="prio">Importance of the log message</param>

+            <param name="message">The message.</param>

         </member>

-        <member name="M:HttpServer.Exceptions.UnauthorizedException.#ctor(System.String)">

+        <member name="M:HttpServer.ConsoleLogWriter.GetColor(HttpServer.LogPrio)">

             <summary>

-            Create a new unauhtorized exception.

+            Get color for the specified logprio

             </summary>

-            <param name="message">reason to why the request was unauthorized.</param>

+            <param name="prio">prio for the log entry</param>

+            <returns>A <see cref="T:System.ConsoleColor"/> for the prio</returns>

         </member>

-        <member name="T:HttpServer.ContentType">

+        <member name="T:HttpServer.NullLogWriter">

             <summary>

-            Lists content type mime types.

+            Default log writer, writes everything to null (nowhere).

             </summary>

+            <seealso cref="T:HttpServer.ILogWriter"/>

         </member>

-        <member name="F:HttpServer.ContentType.Text">

+        <member name="F:HttpServer.NullLogWriter.Instance">

             <summary>

-            text/plain

+            The logging instance.

             </summary>

         </member>

-        <member name="F:HttpServer.ContentType.Html">

+        <member name="M:HttpServer.NullLogWriter.Write(System.Object,HttpServer.LogPrio,System.String)">

             <summary>

-            text/haml

+            Writes everything to null

             </summary>

+            <param name="source">object that wrote the log entry.</param>

+            <param name="prio">Importance of the log message</param>

+            <param name="message">The message.</param>

         </member>

-        <member name="F:HttpServer.ContentType.Javascript">

+        <member name="T:HttpServer.HttpResponse">

             <summary>

-            content type for javascript documents = application/javascript

+            Response that is sent back to the web browser / client.

             </summary>

             <remarks>

             <para>

-            RFC 4329 states that text/javascript have been superseeded by

-            application/javascript. You might still want to check browser versions

-            since older ones do not support application/javascript.

+            A response can be sent if different ways. The easiest one is

+            to just fill the Body stream with content, everything else

+            will then be taken care of by the framework. The default content-type

+            is text/html, you should change it if you send anything else.

+            </para><para>

+            The second and slightly more complex way is to send the response

+            as parts. Start with sending the header using the SendHeaders method and 

+            then you can send the body using SendBody method, but do not forget

+            to set <see cref="P:HttpServer.HttpResponse.ContentType"/> and <see cref="P:HttpServer.HttpResponse.ContentLength"/> before doing so.

             </para>

-            <para>Browser support: http://krijnhoetmer.nl/stuff/javascript/mime-types/</para>

             </remarks>

+            <example>

+            <code>

+            // Example using response body.

+            class MyModule : HttpModule

+            {

+                        public override bool Process(IHttpRequest request, IHttpResponse response, IHttpSession session)

+                        {

+                                StreamWriter writer = new StreamWriter(response.Body);

+                                writer.WriteLine("Hello dear World!");

+                                writer.Flush();

+            

+                                // return true to tell webserver that we've handled the url

+                                return true;

+                        }

+            }

+            </code>

+            </example>

+            todo: add two examples, using SendHeaders/SendBody and just the Body stream.

         </member>

-        <member name="F:HttpServer.ContentType.Xml">

+        <member name="M:HttpServer.HttpResponse.#ctor(HttpServer.IHttpClientContext,HttpServer.IHttpRequest)">

             <summary>

-            text/xml

+            Initializes a new instance of the <see cref="T:HttpServer.IHttpResponse"/> class.

             </summary>

+            <param name="context">Client that send the <see cref="T:HttpServer.IHttpRequest"/>.</param>

+            <param name="request">Contains information of what the client want to receive.</param>

+            <exception cref="T:System.ArgumentException"><see cref="P:HttpServer.IHttpRequest.HttpVersion"/> cannot be empty.</exception>

         </member>

-        <member name="T:HttpServer.ContentTypes">

+        <member name="M:HttpServer.HttpResponse.#ctor(HttpServer.IHttpClientContext,System.String,HttpServer.ConnectionType)">

             <summary>

-            A list of content types

+            Initializes a new instance of the <see cref="T:HttpServer.IHttpResponse"/> class.

             </summary>

+            <param name="context">Client that send the <see cref="T:HttpServer.IHttpRequest"/>.</param>

+            <param name="httpVersion">Version of HTTP protocol that the client uses.</param>

+            <param name="connectionType">Type of HTTP connection used.</param>

         </member>

-        <member name="M:HttpServer.ContentTypes.#ctor(System.String)">

+        <member name="M:HttpServer.HttpResponse.AddHeader(System.String,System.String)">

             <summary>

-            

+            Add another header to the document.

             </summary>

-            <param name="types">Semicolon separated content types.</param>

+            <param name="name">Name of the header, case sensitive, use lower cases.</param>

+            <param name="value">Header values can span over multiple lines as long as each line starts with a white space. New line chars should be \r\n</param>

+            <exception cref="T:System.InvalidOperationException">If headers already been sent.</exception>

+            <exception cref="T:System.ArgumentException">If value conditions have not been met.</exception>

+            <remarks>Adding any header will override the default ones and those specified by properties.</remarks>

         </member>

-        <member name="M:HttpServer.ContentTypes.GetEnumerator">

+        <member name="M:HttpServer.HttpResponse.Send">

             <summary>

-            Returns an enumerator that iterates through a collection.

+            Send headers and body to the browser.

             </summary>

-            <returns>

-            An <see cref="T:System.Collections.IEnumerator"/> object that can be used to iterate through the collection.

-            </returns>

+            <exception cref="T:System.InvalidOperationException">If content have already been sent.</exception>

         </member>

-        <member name="M:HttpServer.ContentTypes.Contains(System.String)">

+        <member name="M:HttpServer.HttpResponse.SendBody(System.Byte[],System.Int32,System.Int32)">

             <summary>

-            Searches for the specified type

+            Make sure that you have specified <see cref="P:HttpServer.HttpResponse.ContentLength"/> and sent the headers first.

             </summary>

-            <param name="type">Can also be a part of a type (searching for "xml" would return true for "application/xml").</param>

-            <returns>true if type was found.</returns>

+            <param name="buffer"></param>

+            <exception cref="T:System.InvalidOperationException">If headers have not been sent.</exception>

+            <see cref="M:HttpServer.HttpResponse.SendHeaders"/>

+            <param name="offset">offset of first byte to send</param>

+            <param name="count">number of bytes to send.</param>

+            <seealso cref="M:HttpServer.HttpResponse.Send"/>

+            <seealso cref="M:HttpServer.HttpResponse.SendHeaders"/>

+            <remarks>This method can be used if you want to send body contents without caching them first. This

+            is recommended for larger files to keep the memory usage low.</remarks>

         </member>

-        <member name="P:HttpServer.ContentTypes.First">

+        <member name="M:HttpServer.HttpResponse.SendBody(System.Byte[])">

             <summary>

-            Get this first content type.

+            Make sure that you have specified <see cref="P:HttpServer.HttpResponse.ContentLength"/> and sent the headers first.

             </summary>

+            <param name="buffer"></param>

+            <exception cref="T:System.InvalidOperationException">If headers have not been sent.</exception>

+            <see cref="M:HttpServer.HttpResponse.SendHeaders"/>

+            <seealso cref="M:HttpServer.HttpResponse.Send"/>

+            <seealso cref="M:HttpServer.HttpResponse.SendHeaders"/>

+            <remarks>This method can be used if you want to send body contents without caching them first. This

+            is recommended for larger files to keep the memory usage low.</remarks>

         </member>

-        <member name="P:HttpServer.ContentTypes.Item(System.String)">

+        <member name="M:HttpServer.HttpResponse.SendHeaders">

             <summary>

-            Fetch a content type

+            Send headers to the client.

             </summary>

-            <param name="type">Part of type ("xml" would return "application/xml")</param>

-            <returns></returns>

-            <remarks>All content types are in lower case.</remarks>

+            <exception cref="T:System.InvalidOperationException">If headers already been sent.</exception>

+            <seealso cref="M:HttpServer.HttpResponse.AddHeader(System.String,System.String)"/>

+            <seealso cref="M:HttpServer.HttpResponse.Send"/>

+            <seealso cref="M:HttpServer.HttpResponse.SendBody(System.Byte[])"/>

         </member>

-        <member name="T:HttpServer.Sessions.MemorySessionStore">

+        <member name="M:HttpServer.HttpResponse.Redirect(System.Uri)">

             <summary>

-            Session store using memory for each session.

+            Redirect client to somewhere else using the 302 status code.

             </summary>

+            <param name="uri">Destination of the redirect</param>

+            <exception cref="T:System.InvalidOperationException">If headers already been sent.</exception>

+            <remarks>You can not do anything more with the request when a redirect have been done. This should be your last

+            action.</remarks>

         </member>

-        <member name="M:HttpServer.Sessions.MemorySessionStore.#ctor">

+        <member name="M:HttpServer.HttpResponse.Redirect(System.String)">

             <summary>

-            Initializes the class setting the expirationtimer to clean the session every minute

+            redirect to somewhere

             </summary>

+            <param name="url">where the redirect should go</param>

+            <remarks>

+            No body are allowed when doing redirects.

+            </remarks>

         </member>

-        <member name="M:HttpServer.Sessions.MemorySessionStore.Cleanup(System.Object)">

+        <member name="P:HttpServer.HttpResponse.Body">

             <summary>

-            Delegate for the cleanup timer

+            The body stream is used to cache the body contents

+            before sending everything to the client. It's the simplest

+            way to serve documents.

             </summary>

         </member>

-        <member name="M:HttpServer.Sessions.MemorySessionStore.Create">

+        <member name="P:HttpServer.HttpResponse.Chunked">

             <summary>

-            Creates a new http session

+            The chunked encoding modifies the body of a message in order to

+            transfer it as a series of chunks, each with its own size indicator,

+            followed by an OPTIONAL trailer containing entity-header fields. This

+            allows dynamically produced content to be transferred along with the

+            information necessary for the recipient to verify that it has

+            received the full message.

             </summary>

-            <returns></returns>

         </member>

-        <member name="M:HttpServer.Sessions.MemorySessionStore.Create(System.String)">

+        <member name="P:HttpServer.HttpResponse.ProtocolVersion">

             <summary>

-            Creates a new http session with a specific id

+            Defines the version of the HTTP Response for applications where it's required

+            for this to be forced.

             </summary>

-            <param name="id">Id used to identify the new cookie..</param>

-            <returns>A <see cref="T:HttpServer.Sessions.IHttpSession"/> object.</returns>

-            <remarks>

-            Id should be generated by the store implementation if it's null or <see cref="F:System.String.Empty"/>.

-            </remarks>

         </member>

-        <member name="M:HttpServer.Sessions.MemorySessionStore.Load(System.String)">

+        <member name="P:HttpServer.HttpResponse.Connection">

             <summary>

-            Load an existing session.

+            Kind of connection

             </summary>

-            <param name="sessionId"></param>

-            <returns></returns>

         </member>

-        <member name="M:HttpServer.Sessions.MemorySessionStore.Save(HttpServer.Sessions.IHttpSession)">

+        <member name="P:HttpServer.HttpResponse.Encoding">

             <summary>

-            Save an updated session to the store.

+            Encoding to use when sending stuff to the client.

             </summary>

-            <param name="session"></param>

+            <remarks>Default is UTF8</remarks>

         </member>

-        <member name="M:HttpServer.Sessions.MemorySessionStore.AddUnused(HttpServer.Sessions.IHttpSession)">

+        <member name="P:HttpServer.HttpResponse.KeepAlive">

             <summary>

-            We use the flyweight pattern which reuses small objects

-            instead of creating new each time.

+            Number of seconds to keep connection alive

             </summary>

-            <param name="session">EmptyLanguageNode (unused) session that should be reused next time Create is called.</param>

+            <remarks>Only used if Connection property is set to <see cref="F:HttpServer.ConnectionType.KeepAlive"/>.</remarks>

         </member>

-        <member name="M:HttpServer.Sessions.MemorySessionStore.Cleanup">

+        <member name="P:HttpServer.HttpResponse.Status">

             <summary>

-            Remove expired sessions

+            Status code that is sent to the client.

             </summary>

+            <remarks>Default is <see cref="F:System.Net.HttpStatusCode.OK"/></remarks>

         </member>

-        <member name="M:HttpServer.Sessions.MemorySessionStore.Remove(System.String)">

+        <member name="P:HttpServer.HttpResponse.Reason">

             <summary>

-            Remove a session

+            Information about why a specific status code was used.

             </summary>

-            <param name="sessionId">id of the session.</param>

         </member>

-        <member name="P:HttpServer.Sessions.MemorySessionStore.Item(System.String)">

+        <member name="P:HttpServer.HttpResponse.ContentLength">

             <summary>

-            Load a session from the store

+            Size of the body. MUST be specified before sending the header,

+            unless property Chunked is set to true.

             </summary>

-            <param name="sessionId"></param>

-            <returns>null if session is not found.</returns>

         </member>

-        <member name="P:HttpServer.Sessions.MemorySessionStore.ExpireTime">

+        <member name="P:HttpServer.HttpResponse.ContentType">

             <summary>

-            Number of minutes before a session expires.

-            Default is 20 minutes.

+            Kind of content in the body

             </summary>

+            <remarks>Default type is "text/html"</remarks>

         </member>

-        <member name="T:HttpServer.Helpers.WebHelper">

+        <member name="P:HttpServer.HttpResponse.HeadersSent">

             <summary>

-            Webhelper provides helpers for common tasks in HTML.

+            Headers have been sent to the client-

             </summary>

+            <remarks>You can not send any additional headers if they have already been sent.</remarks>

         </member>

-        <member name="F:HttpServer.Helpers.WebHelper.JSImplementation">

+        <member name="P:HttpServer.HttpResponse.Sent">

             <summary>

-            Used to let the website use different javascript libraries.

-            Default is <see cref="T:HttpServer.Helpers.Implementations.PrototypeImp"/>

+            The whole response have been sent.

             </summary>

         </member>

-        <member name="M:HttpServer.Helpers.WebHelper.AjaxRequest(System.String,System.String,System.String[])">

+        <member name="P:HttpServer.HttpResponse.Cookies">

             <summary>

-            Creates a link that invokes through ajax.

+            Cookies that should be created/changed.

             </summary>

-            <param name="url">url to fetch</param>

-            <param name="title">link title</param>

-            <param name="options">

-            optional options in format "key, value, key, value". 

-            Javascript options starts with ':'.

-            </param>

-            <returns>a link tag</returns>

-            <example>

-            WebHelper.AjaxRequest("/users/add/", "Add user", "method:", "post", "onclick", "validate('this');");

-            </example>

         </member>

-        <member name="M:HttpServer.Helpers.WebHelper.AjaxUpdater(System.String,System.String,System.String,System.String[])">

+        <member name="T:HttpServer.Exceptions.NotFoundException">

             <summary>

-            Builds a link that updates an element with the fetched ajax content.

+            The requested resource was not found in the web server.

             </summary>

-            <param name="url">Url to fetch content from</param>

-            <param name="title">link title</param>

-            <param name="targetId">html element to update with the results of the ajax request.</param>

-            <param name="options">optional options in format "key, value, key, value"</param>

-            <returns>A link tag.</returns>

         </member>

-        <member name="M:HttpServer.Helpers.WebHelper.DialogLink(System.String,System.String,System.String[])">

+        <member name="M:HttpServer.Exceptions.NotFoundException.#ctor(System.String,System.Exception)">

             <summary>

-            A link that pop ups a Dialog (overlay div)

+            Create a new exception

             </summary>

-            <param name="url">url to contents of dialog</param>

-            <param name="title">link title</param>

-            <param name="htmlAttributes">name/value of html attributes.</param>

-            <returns>A "a"-tag that popups a dialog when clicked</returns>

-            <example>

-            WebHelper.DialogLink("/user/show/1", "show user", "onmouseover", "alert('booh!');");

-            </example>

+            <param name="message">message describing the error</param>

+            <param name="inner">inner exception</param>

         </member>

-        <member name="M:HttpServer.Helpers.WebHelper.CreateDialog(System.String,System.String,System.String[])">

+        <member name="M:HttpServer.Exceptions.NotFoundException.#ctor(System.String)">

             <summary>

-            Create/Open a dialog box using ajax

+            Create a new exception

             </summary>

-            <param name="url"></param>

-            <param name="title"></param>

-            <param name="parameters"></param>

-            <returns></returns>

+            <param name="message">message describing the error</param>

         </member>

-        <member name="M:HttpServer.Helpers.WebHelper.CloseDialog">

+        <member name="T:HttpServer.Sessions.MemorySessionStore">

             <summary>

-            Close a javascript dialog window/div.

+            Session store using memory for each session.

             </summary>

-            <returns>javascript for closing a dialog.</returns>

-            <see cref="M:HttpServer.Helpers.WebHelper.DialogLink(System.String,System.String,System.String[])"/>

         </member>

-        <member name="M:HttpServer.Helpers.WebHelper.FormStart(System.String,System.String,System.Boolean)">

+        <member name="T:HttpServer.Sessions.IHttpSessionStore">

             <summary>

-            Create a &lt;form&gt; tag.

+            A session store is used to store and load sessions on a media.

+            The default implementation (<see cref="T:HttpServer.Sessions.MemorySessionStore"/>) saves/retrieves sessions from memory.

             </summary>

-            <param name="name">name of form</param>

-            <param name="action">action to invoke on submit</param>

-            <param name="isAjax">form should be posted as ajax</param>

-            <returns>html code</returns>

-            <example>

-            WebHelper.FormStart("frmLogin", "/user/login", Request.IsAjax);

-            </example>

         </member>

-        <member name="M:HttpServer.Helpers.WebHelper.Link(System.String,System.String,System.String[])">

+        <member name="M:HttpServer.Sessions.IHttpSessionStore.Create">

             <summary>

-            Create a link tag.

+            Creates a new http session with a generated id.

             </summary>

-            <param name="url">url to go to</param>

-            <param name="title">link title (text that is displayed)</param>

-            <param name="htmlAttributes">html attributes, name, value, name, value</param>

-            <returns>html code</returns>

-            <example>

-            WebHelper.Link("/user/show/1", "Show user", "id", "showUser", "onclick", "return confirm('Are you shure?');");

-            </example>

+            <returns>A <see cref="T:HttpServer.Sessions.IHttpSession"/> object</returns>

         </member>

-        <member name="M:HttpServer.Helpers.WebHelper.BuildLink(System.String,System.String,System.String[])">

+        <member name="M:HttpServer.Sessions.IHttpSessionStore.Create(System.String)">

             <summary>

-            Build a link

+            Creates a new http session with a specific id

             </summary>

-            <param name="url">url to go to.</param>

-            <param name="title">title of link (displayed text)</param>

-            <param name="htmlAttributes">extra html attributes.</param>

-            <returns>a complete link</returns>

+            <param name="id">Id used to identify the new cookie..</param>

+            <returns>A <see cref="T:HttpServer.Sessions.IHttpSession"/> object.</returns>

+            <remarks>

+            Id should be generated by the store implementation if it's null or <see cref="F:System.String.Empty"/>.

+            </remarks>

         </member>

-        <member name="M:HttpServer.Helpers.WebHelper.BuildLink(System.String,System.String,System.String[],System.String[])">

+        <member name="M:HttpServer.Sessions.IHttpSessionStore.Load(System.String)">

             <summary>

-            Build a link

+            Load an existing session.

             </summary>

-            <param name="url">url to go to.</param>

-            <param name="title">title of link (displayed text)</param>

-            <param name="htmlAttributes">extra html attributes.</param>

-            <returns>a complete link</returns>

-            <param name="options">more options</param>

+            <param name="sessionId">Session id (usually retrieved from a client side cookie).</param>

+            <returns>A session if found; otherwise null.</returns>

         </member>

-        <member name="M:HttpServer.Helpers.WebHelper.Select(System.String,System.Collections.ICollection,HttpServer.Helpers.GetIdTitle,System.Object,System.Boolean)">

+        <member name="M:HttpServer.Sessions.IHttpSessionStore.Save(HttpServer.Sessions.IHttpSession)">

             <summary>

-            Obsolete

+            Save an updated session to the store.

             </summary>

-            <param name="name">Obsolete</param>

-            <param name="collection">Obsolete</param>

-            <param name="getIdTitle">Obsolete</param>

-            <param name="selectedValue">Obsolete</param>

-            <param name="firstEmpty">Obsolete</param>

-            <returns>Obsolete</returns>

+            <param name="session">Session id (usually retrieved from a client side cookie).</param>

+            <exception cref="T:System.ArgumentException">If Id property have not been specified.</exception>

         </member>

-        <member name="M:HttpServer.Helpers.WebHelper.Select(System.String,System.String,System.Collections.ICollection,HttpServer.Helpers.GetIdTitle,System.Object,System.Boolean)">

+        <member name="M:HttpServer.Sessions.IHttpSessionStore.AddUnused(HttpServer.Sessions.IHttpSession)">

             <summary>

-            Obsolete

+            We use the flyweight pattern which reuses small objects

+            instead of creating new each time.

             </summary>

-            <param name="name">Obsolete</param>

-            <param name="id">Obsolete</param>

-            <param name="collection">Obsolete</param>

-            <param name="getIdTitle">Obsolete</param>

-            <param name="selectedValue">Obsolete</param>

-            <param name="firstEmpty">Obsolete</param>

-            <returns>Obsolete</returns>

+            <param name="session">Unused session that should be reused next time Create is called.</param>

         </member>

-        <member name="M:HttpServer.Helpers.WebHelper.List(System.Collections.Generic.IEnumerable{System.Object},System.String)">

+        <member name="M:HttpServer.Sessions.IHttpSessionStore.Cleanup">

             <summary>

-            Render errors into a UL with class "errors"

+            Remove expired sessions

             </summary>

-            <param name="className">class used by UL-tag.</param>

-            <param name="theList">items to list</param>

-            <returns>an unordered html list.</returns>

         </member>

-        <member name="M:HttpServer.Helpers.WebHelper.List(System.Collections.Specialized.NameValueCollection,System.String)">

+        <member name="M:HttpServer.Sessions.IHttpSessionStore.Remove(System.String)">

             <summary>

-            Render errors into a UL with class "errors"

+            Remove a session

             </summary>

-            <param name="className">class used by UL-tag.</param>

-            <param name="theList">items to list</param>

-            <returns>an unordered html list.</returns>

+            <param name="sessionId">id of the session.</param>

         </member>

-        <member name="M:HttpServer.Helpers.WebHelper.Errors(System.Collections.Specialized.NameValueCollection)">

+        <member name="P:HttpServer.Sessions.IHttpSessionStore.Item(System.String)">

             <summary>

-            Render errors into a UL with class "errors"

+            Load a session from the store

             </summary>

-            <param name="errors"></param>

-            <returns></returns>

+            <param name="sessionId"></param>

+            <returns>null if session is not found.</returns>

         </member>

-        <member name="M:HttpServer.Helpers.WebHelper.GenerateHtmlAttributes(System.Text.StringBuilder,System.String[],System.String[])">

+        <member name="P:HttpServer.Sessions.IHttpSessionStore.ExpireTime">

             <summary>

-            Generates a list with html attributes.

+            Number of minutes before a session expires.

             </summary>

-            <param name="sb">StringBuilder that the options should be added to.</param>

-            <param name="firstOptions">attributes set by user.</param>

-            <param name="secondOptions">attributes set by any of the helper classes.</param>

+            <value>Default time is 20 minutes.</value>

         </member>

-        <member name="M:HttpServer.Helpers.WebHelper.GenerateHtmlAttributes(System.Text.StringBuilder,System.String[])">

+        <member name="M:HttpServer.Sessions.MemorySessionStore.#ctor">

             <summary>

-            Generates a list with html attributes.

+            Initializes the class setting the expirationtimer to clean the session every minute

             </summary>

-            <param name="sb">StringBuilder that the options should be added to.</param>

-            <param name="options"></param>

         </member>

-        <member name="T:HttpServer.Helpers.JavascriptHelperImplementation">

+        <member name="M:HttpServer.Sessions.MemorySessionStore.Cleanup(System.Object)">

             <summary>

-            Purpose of this class is to create a javascript toolkit independent javascript helper.

+            Delegate for the cleanup timer

             </summary>

         </member>

-        <member name="M:HttpServer.Helpers.JavascriptHelperImplementation.GenerateOptions(System.Text.StringBuilder,System.String[],System.Boolean)">

+        <member name="M:HttpServer.Sessions.MemorySessionStore.Create">

             <summary>

-            Generates a list with JS options.

+            Creates a new http session

             </summary>

-            <param name="sb">StringBuilder that the options should be added to.</param>

-            <param name="options">the javascript options. name, value pairs. each string value should be escaped by YOU!</param>

-            <param name="startWithComma">true if we should start with a comma.</param>

+            <returns></returns>

         </member>

-        <member name="M:HttpServer.Helpers.JavascriptHelperImplementation.RemoveJavascriptOptions(System.String[])">

+        <member name="M:HttpServer.Sessions.MemorySessionStore.Create(System.String)">

             <summary>

-            Removes any javascript parameters from an array of parameters

+            Creates a new http session with a specific id

             </summary>

-            <param name="options">The array of parameters to remove javascript params from</param>

-            <returns>An array of html parameters</returns>

+            <param name="id">Id used to identify the new cookie..</param>

+            <returns>A <see cref="T:HttpServer.Sessions.IHttpSession"/> object.</returns>

+            <remarks>

+            Id should be generated by the store implementation if it's null or <see cref="F:System.String.Empty"/>.

+            </remarks>

         </member>

-        <member name="M:HttpServer.Helpers.JavascriptHelperImplementation.AjaxFormOnSubmit(System.String[])">

+        <member name="M:HttpServer.Sessions.MemorySessionStore.Load(System.String)">

             <summary>

-            javascript action that should be added to the "onsubmit" event in the form tag.

+            Load an existing session.

             </summary>

+            <param name="sessionId"></param>

             <returns></returns>

-            <remarks>All javascript option names should end with colon.</remarks>

-            <example>

-            <code>

-            JSHelper.AjaxRequest("/user/show/1", "onsuccess:", "$('userInfo').update(result);");

-            </code>

-            </example>

         </member>

-        <member name="M:HttpServer.Helpers.JavascriptHelperImplementation.AjaxRequest(System.String,System.String[])">

+        <member name="M:HttpServer.Sessions.MemorySessionStore.Save(HttpServer.Sessions.IHttpSession)">

             <summary>

-            Requests a url through ajax

+            Save an updated session to the store.

             </summary>

-            <param name="url">url to fetch</param>

-            <param name="options">optional options in format "key, value, key, value", used in JS request object.</param>

-            <returns>a link tag</returns>

-            <remarks>All javascript option names should end with colon.</remarks>

-            <example>

-            <code>

-            JSHelper.AjaxRequest("/user/show/1", "onsuccess:", "$('userInfo').update(result);");

-            </code>

-            </example>

+            <param name="session"></param>

         </member>

-        <member name="M:HttpServer.Helpers.JavascriptHelperImplementation.AjaxUpdater(System.String,System.String,System.String[])">

+        <member name="M:HttpServer.Sessions.MemorySessionStore.AddUnused(HttpServer.Sessions.IHttpSession)">

             <summary>

-            Ajax requests that updates an element with

-            the fetched content

+            We use the flyweight pattern which reuses small objects

+            instead of creating new each time.

             </summary>

-            <param name="url">Url to fetch content from</param>

-            <param name="targetId">element to update</param>

-            <param name="options">optional options in format "key, value, key, value", used in JS updater object.</param>

-            <returns>A link tag.</returns>

-            <remarks>All javascript option names should end with colon.</remarks>

-            <example>

-            <code>

-            JSHelper.AjaxUpdater("/user/show/1", "userInfo", "onsuccess:", "alert('Successful!');");

-            </code>

-            </example>

+            <param name="session">EmptyLanguageNode (unused) session that should be reused next time Create is called.</param>

         </member>

-        <member name="M:HttpServer.Helpers.JavascriptHelperImplementation.DialogLink(System.String,System.String,System.String[])">

+        <member name="M:HttpServer.Sessions.MemorySessionStore.Cleanup">

             <summary>

-            A link that pop ups a Dialog (overlay div)

+            Remove expired sessions

             </summary>

-            <param name="url">url to contents of dialog</param>

-            <param name="title">link title</param>

-            <returns>A "a"-tag that popups a dialog when clicked</returns>

-            <param name="htmlAttributes">name/value of html attributes</param>

-            <example>

-            WebHelper.DialogLink("/user/show/1", "show user", "onmouseover", "alert('booh!');");

-            </example>

         </member>

-        <member name="M:HttpServer.Helpers.JavascriptHelperImplementation.CloseDialog">

+        <member name="M:HttpServer.Sessions.MemorySessionStore.Remove(System.String)">

             <summary>

-            Close a javascript dialog window/div.

+            Remove a session

             </summary>

-            <returns>javascript for closing a dialog.</returns>

-            <see cref="M:HttpServer.Helpers.JavascriptHelperImplementation.DialogLink(System.String,System.String,System.String[])"/>

+            <param name="sessionId">id of the session.</param>

         </member>

-        <member name="M:HttpServer.Helpers.JavascriptHelperImplementation.CreateDialog(System.String,System.String,System.String[])">

+        <member name="P:HttpServer.Sessions.MemorySessionStore.Item(System.String)">

             <summary>

-            Creates a new modal dialog window

+            Load a session from the store

             </summary>

-            <param name="url">url to open in window.</param>

-            <param name="title">window title (may not be supported by all js implementations)</param>

-            <param name="options"></param>

-            <returns></returns>

+            <param name="sessionId"></param>

+            <returns>null if session is not found.</returns>

         </member>

-        <member name="M:HttpServer.FormDecoders.HttpMultipart.ReadLine">

+        <member name="P:HttpServer.Sessions.MemorySessionStore.ExpireTime">

             <summary>

-            

+            Number of minutes before a session expires.

+            Default is 20 minutes.

             </summary>

-            <returns></returns>

-            <exception cref="T:System.ArgumentOutOfRangeException"></exception>

-            <exception cref="T:System.ObjectDisposedException"></exception>

         </member>

-        <member name="T:HttpServer.FormDecoders.HttpMultipart.Element">

-            <summary>Represents a field in a multipart form</summary>

-        </member>

-        <member name="T:HttpServer.Exceptions.BadRequestException">

+        <member name="T:HttpServer.Sessions.HttpSessionClearedArgs">

             <summary>

-            The request could not be understood by the server due to malformed syntax. 

-            The client SHOULD NOT repeat the request without modifications.

-            

-            Text taken from: http://www.submissionchamber.com/help-guides/error-codes.php

+            Arguments sent when a <see cref="T:HttpServer.Sessions.IHttpSession"/> is cleared

             </summary>

         </member>

-        <member name="M:HttpServer.Exceptions.BadRequestException.#ctor(System.String)">

+        <member name="M:HttpServer.Sessions.HttpSessionClearedArgs.#ctor(System.Boolean)">

             <summary>

-            Create a new bad request exception.

+            Instantiates the arguments for the event

             </summary>

-            <param name="errMsg">reason to why the request was bad.</param>

+            <param name="expired">True if the session is cleared due to expiration</param>

         </member>

-        <member name="M:HttpServer.Exceptions.BadRequestException.#ctor(System.String,System.Exception)">

+        <member name="P:HttpServer.Sessions.HttpSessionClearedArgs.Expired">

             <summary>

-            Create a new bad request exception.

+            Returns true if the session is cleared due to expiration

             </summary>

-            <param name="errMsg">reason to why the request was bad.</param>

-            <param name="inner">inner exception</param>

         </member>

-        <member name="T:HttpServer.HttpFile">

+        <member name="T:HttpServer.Sessions.HttpSessionClearedHandler">

             <summary>

-            Container class for posted files

+            Delegate for when a IHttpSession is cleared

             </summary>

+            <param name="session"><see cref="T:HttpServer.Sessions.IHttpSession"/> this is being cleared.</param>

+            <param name="args">Arguments for the clearing</param>

         </member>

-        <member name="M:HttpServer.HttpFile.#ctor(System.String,System.String,System.String,System.String)">

+        <member name="T:HttpServer.RequestQueue">

             <summary>

-            Creates a container for a posted file

+            Used to queue incoming requests.

             </summary>

-            <param name="name">The identifier of the post field</param>

-            <param name="filename">The file path</param>

-            <param name="contentType">The content type of the file</param>

-            <param name="uploadFilename">The name of the file uploaded</param>

-            <exception cref="T:System.ArgumentNullException">If any parameter is null or empty</exception>

         </member>

-        <member name="M:HttpServer.HttpFile.#ctor(System.String,System.String,System.String)">

+        <member name="M:HttpServer.RequestQueue.#ctor(HttpServer.ProcessRequestHandler)">

             <summary>

-            Creates a container for a posted file <see cref="M:HttpServer.HttpFile.#ctor(System.String,System.String,System.String,System.String)"/>

+            Initializes a new instance of the <see cref="T:HttpServer.RequestQueue"/> class.

             </summary>

-            <exception cref="T:System.ArgumentNullException">If any parameter is null or empty</exception>

-        </member>

-        <member name="M:HttpServer.HttpFile.Finalize">

-            <summary>Destructor disposing the file</summary>

+            <param name="handler">Called when a request should be processed.</param>

         </member>

-        <member name="M:HttpServer.HttpFile.Dispose(System.Boolean)">

+        <member name="M:HttpServer.RequestQueue.QueueThread">

             <summary>

-            Deletes the temporary file

+            Used to process queued requests.

             </summary>

-            <param name="disposing">True if manual dispose</param>

         </member>

-        <member name="M:HttpServer.HttpFile.Dispose">

+        <member name="P:HttpServer.RequestQueue.MaxRequestCount">

             <summary>

-            Disposing interface, cleans up managed resources (the temporary file) and suppresses finalization

+            Gets or sets maximum number of allowed simultaneous requests.

             </summary>

         </member>

-        <member name="P:HttpServer.HttpFile.Name">

+        <member name="P:HttpServer.RequestQueue.MaxQueueSize">

             <summary>

-            The name/id of the file

+            Gets or sets maximum number of requests queuing to be handled.

             </summary>

         </member>

-        <member name="P:HttpServer.HttpFile.Filename">

+        <member name="P:HttpServer.RequestQueue.CurrentRequestCount">

             <summary>

-            The full file path

+            Specifies how many requests the HTTP server is currently processing.

             </summary>

         </member>

-        <member name="P:HttpServer.HttpFile.UploadFilename">

+        <member name="T:HttpServer.RequestQueue.QueueItem">

             <summary>

-            The name of the uploaded file

+            Used two queue incoming requests to avoid

+            thread starvation.

             </summary>

         </member>

-        <member name="P:HttpServer.HttpFile.ContentType">

+        <member name="T:HttpServer.ProcessRequestHandler">

             <summary>

-            The type of file

+            Method used to process a queued request

             </summary>

+            <param name="context">Context that the request was received from.</param>

+            <param name="request">Request to process.</param>

         </member>

-        <member name="T:HttpServer.Helpers.JSHelper">

+        <member name="T:HttpServer.Parser.HeaderEventArgs">

             <summary>

-            Will contain helper functions for javascript.

+            Event arguments used when a new header have been parsed.

             </summary>

         </member>

-        <member name="M:HttpServer.Helpers.JSHelper.AjaxRequest(System.String,System.String[])">

+        <member name="M:HttpServer.Parser.HeaderEventArgs.#ctor(System.String,System.String)">

             <summary>

-            Requests a url through ajax

+            Initializes a new instance of the <see cref="T:HttpServer.Parser.HeaderEventArgs"/> class.

             </summary>

-            <param name="url">url to fetch. Url is NOT enclosed in quotes by the implementation. You need to do that yourself.</param>

-            <param name="options">optional options in format "key, value, key, value", used in JS request object. All keys should end with colon.</param>

-            <returns>a link tag</returns>

-            <remarks>onclick attribute is used by this method.</remarks>

-            <example>

-            <code>

-            // plain text

-            JSHelper.AjaxRequest("'/user/show/1'");

-            

-            // ajax request using this.href

-            string link = "&lt;a href=\"/user/call/1\" onclick=\"" + JSHelper.AjaxRequest("this.href") + "/&lt;call user&lt;/a&gt;";

-            </code>

-            </example>

+            <param name="name">Name of header.</param>

+            <param name="value">Header value.</param>

         </member>

-        <member name="M:HttpServer.Helpers.JSHelper.AjaxUpdater(System.String,System.String,System.String[])">

+        <member name="M:HttpServer.Parser.HeaderEventArgs.#ctor">

             <summary>

-            Ajax requests that updates an element with

-            the fetched content

+            Initializes a new instance of the <see cref="T:HttpServer.Parser.HeaderEventArgs"/> class.

             </summary>

-            <param name="url">url to fetch. Url is NOT enclosed in quotes by the implementation. You need to do that yourself.</param>

-            <param name="targetId">element to update</param>

-            <param name="options">options in format "key, value, key, value". All keys should end with colon.</param>

-            <returns>A link tag.</returns>

-            <example>

-            <code>

-            JSHelper.AjaxUpdater("'/user/show/1'", "user", "onsuccess:", "alert('hello');", "asynchronous:", "true");

-            </code>

-            </example>

         </member>

-        <member name="M:HttpServer.Helpers.JSHelper.CreateDialog(System.String,System.String,System.String[])">

+        <member name="P:HttpServer.Parser.HeaderEventArgs.Name">

             <summary>

-            Opens contents in a dialog window.

+            Gets or sets header name.

             </summary>

-            <param name="url">url to contents of dialog</param>

-            <param name="title">link title</param>

-            <param name="options">name, value, name, value, all parameter names should end with colon.</param>

         </member>

-        <member name="M:HttpServer.Helpers.JSHelper.CloseDialog">

+        <member name="P:HttpServer.Parser.HeaderEventArgs.Value">

             <summary>

-            Close a javascript dialog window/div.

+            Gets or sets header value.

             </summary>

-            <returns>javascript for closing a dialog.</returns>

-            <see cref="M:HttpServer.Helpers.JSHelper.CreateDialog(System.String,System.String,System.String[])"/>

         </member>

         <member name="T:HttpServer.HttpRequest">

             <summary>

@@ -4743,34 +4727,108 @@
             Gets cookies that was sent with the request.

             </summary>

         </member>

-        <member name="T:HttpServer.HttpModules.WebSiteModule">

+        <member name="M:HttpServer.ComponentProvider.AddInstance``1(System.Object)">

             <summary>

-            The website module let's you handle multiple websites in the same server.

-            It uses the "Host" header to check which site you want.

+            Add a component instance

             </summary>

-            <remarks>It's recommended that you do not

-            add any other modules to HttpServer if you are using the website module. Instead,

-            add all wanted modules to each website.</remarks>

+            <typeparam name="T">Interface type</typeparam>

+            <param name="instance">Instance to add</param>

         </member>

-        <member name="M:HttpServer.HttpModules.WebSiteModule.#ctor(System.String,System.String)">

+        <member name="M:HttpServer.ComponentProvider.Get``1">

             <summary>

-            

+            Get a component.

             </summary>

-            <param name="host">domain name that should be handled.</param>

-            <param name="name"></param>

+            <typeparam name="T">Interface type</typeparam>

+            <returns>Component if registered, otherwise null.</returns>

+            <remarks>

+            Component will get created if needed.

+            </remarks>

         </member>

-        <member name="M:HttpServer.HttpModules.WebSiteModule.Process(HttpServer.IHttpRequest,HttpServer.IHttpResponse,HttpServer.Sessions.IHttpSession)">

+        <member name="M:HttpServer.ComponentProvider.Create(HttpServer.ComponentProvider.TypeInformation)">

+            <exception cref="T:System.InvalidOperationException">If instance cannot be created.</exception>

+        </member>

+        <member name="M:HttpServer.ComponentProvider.Contains(System.Type)">

             <summary>

-            Method that process the url

+            Checks if the specified component interface have been added.

             </summary>

-            <param name="request">Information sent by the browser about the request</param>

-            <param name="response">Information that is being sent back to the client.</param>

-            <param name="session">Session used to </param>

+            <param name="interfaceType"></param>

+            <returns>true if found; otherwise false.</returns>

         </member>

-        <member name="P:HttpServer.HttpModules.WebSiteModule.SiteName">

+        <member name="M:HttpServer.ComponentProvider.Add``2">

             <summary>

-            Name of site.

+            Add a component.

+            </summary>

+            <typeparam name="InterfaceType">Type being requested.</typeparam>

+            <typeparam name="InstanceType">Type being created.</typeparam>

+            <exception cref="T:System.InvalidOperationException">Type have already been mapped.</exception>

+        </member>

+        <member name="T:HttpServer.Rules.RegexRedirectRule">

+            <summary>

+            Class to make dynamic binding of redirects. Instead of having to specify a number of similar redirect rules

+            a regular expression can be used to identify redirect URLs and their targets.

+            </summary>

+            <example>

+            <![CDATA[

+            new RegexRedirectRule("/(?<target>[a-z0-9]+)", "/users/${target}?find=true", RegexOptions.IgnoreCase)

+            ]]>

+            </example>

+        </member>

+        <member name="M:HttpServer.Rules.RegexRedirectRule.#ctor(System.String,System.String)">

+            <summary>

+            Initializes a new instance of the <see cref="T:HttpServer.Rules.RegexRedirectRule"/> class.

+            </summary>

+            <param name="fromUrlExpression">Expression to match URL</param>

+            <param name="toUrlExpression">Expression to generate URL</param>

+            <example>

+            <![CDATA[

+            server.Add(new RegexRedirectRule("/(?<first>[a-zA-Z0-9]+)", "/user/${first}"));

+            Result of ie. /employee1 will then be /user/employee1

+            ]]>

+            </example>

+        </member>

+        <member name="M:HttpServer.Rules.RegexRedirectRule.#ctor(System.String,System.String,System.Text.RegularExpressions.RegexOptions)">

+            <summary>

+            Initializes a new instance of the <see cref="T:HttpServer.Rules.RegexRedirectRule"/> class.

+            </summary>

+            <param name="fromUrlExpression">Expression to match URL</param>

+            <param name="toUrlExpression">Expression to generate URL</param>

+            <param name="options">Regular expression options to use, can be null</param>

+            <example>

+            <![CDATA[

+            server.Add(new RegexRedirectRule("/(?<first>[a-zA-Z0-9]+)", "/user/{first}", RegexOptions.IgnoreCase));

+            Result of ie. /employee1 will then be /user/employee1

+            ]]>

+            </example>

+        </member>

+        <member name="M:HttpServer.Rules.RegexRedirectRule.#ctor(System.String,System.String,System.Text.RegularExpressions.RegexOptions,System.Boolean)">

+            <summary>

+            Initializes a new instance of the <see cref="T:HttpServer.Rules.RegexRedirectRule"/> class.

+            </summary>

+            <param name="fromUrlExpression">Expression to match URL</param>

+            <param name="toUrlExpression">Expression to generate URL</param>

+            <param name="options">Regular expression options to apply</param>

+            <param name="shouldRedirect"><c>true</c> if request should be redirected, <c>false</c> if the request URI should be replaced.</param>

+            <example>

+            <![CDATA[

+            server.Add(new RegexRedirectRule("/(?<first>[a-zA-Z0-9]+)", "/user/${first}", RegexOptions.None));

+            Result of ie. /employee1 will then be /user/employee1

+            ]]>

+            </example>

+            <exception cref="T:System.ArgumentNullException">Argument is null.</exception>

+            <seealso cref="P:HttpServer.Rules.RedirectRule.ShouldRedirect"/>

+        </member>

+        <member name="M:HttpServer.Rules.RegexRedirectRule.Process(HttpServer.IHttpRequest,HttpServer.IHttpResponse)">

+            <summary>

+            Process the incoming request.

             </summary>

+            <param name="request">incoming HTTP request</param>

+            <param name="response">outgoing HTTP response</param>

+            <returns>true if response should be sent to the browser directly (no other rules or modules will be processed).</returns>

+            <remarks>

+            returning true means that no modules will get the request. Returning true is typically being done

+            for redirects.

+            </remarks>

+            <exception cref="T:System.ArgumentNullException">If request or response is null</exception>

         </member>

         <member name="T:HttpServer.Helpers.ResourceInfo">

             <summary>

@@ -4812,30 +4870,6 @@
         <member name="P:HttpServer.Helpers.ResourceInfo.ResourceName">

             <summary>Retrieves the full path name to the resource file</summary>

         </member>

-        <member name="T:HttpServer.RequestParserFactory">

-            <summary>

-            Creates request parsers when needed.

-            </summary>

-        </member>

-        <member name="T:HttpServer.IRequestParserFactory">

-            <summary>

-            Creates request parsers when needed.

-            </summary>

-        </member>

-        <member name="M:HttpServer.IRequestParserFactory.CreateParser(HttpServer.ILogWriter)">

-            <summary>

-            Create a new request parser.

-            </summary>

-            <param name="logWriter">Used when logging should be enabled.</param>

-            <returns>A new request parser.</returns>

-        </member>

-        <member name="M:HttpServer.RequestParserFactory.CreateParser(HttpServer.ILogWriter)">

-            <summary>

-            Create a new request parser.

-            </summary>

-            <param name="logWriter">Used when logging should be enabled.</param>

-            <returns>A new request parser.</returns>

-        </member>

         <member name="T:HttpServer.Authentication.BasicAuthentication">

             <summary>

             The "basic" authentication scheme is based on the model that the

@@ -4921,533 +4955,499 @@
             Adding bytes to body

             </summary>

         </member>

-        <member name="T:HttpServer.FormDecoders.XmlDecoder">

-            <summary>

-            This decoder converts XML documents to form items.

-            Each element becomes a subitem in the form, and each attribute becomes an item.

-            </summary>

-            <example>

-            // xml: <hello id="1">something<world id="2">data</world></hello>

-            // result: 

-            // form["hello"].Value = "something"

-            // form["hello"]["id"].Value = 1

-            // form["hello"]["world]["id"].Value = 1

-            // form["hello"]["world"].Value = "data"

-            </example>

-            <remarks>

-            The original xml document is stored in form["__xml__"].Value.

-            </remarks>

-        </member>

-        <member name="M:HttpServer.FormDecoders.XmlDecoder.Decode(System.IO.Stream,System.String,System.Text.Encoding)">

-            <summary>

-            

-            </summary>

-            <param name="stream">Stream containing the content</param>

-            <param name="contentType">Content type (with any additional info like boundry). Content type is always supplied in lower case</param>

-            <param name="encoding">Stream encoding</param>

-            Note: contentType and encoding are not used?

-            <returns>A http form, or null if content could not be parsed.</returns>

-            <exception cref="T:System.IO.InvalidDataException"></exception>

-        </member>

-        <member name="M:HttpServer.FormDecoders.XmlDecoder.TraverseNode(HttpServer.IHttpInput,System.Xml.XmlNode)">

-            <summary>

-            Recursive function that will go through an xml element and store it's content 

-            to the form item.

-            </summary>

-            <param name="item">(parent) Item in form that content should be added to.</param>

-            <param name="node">Node that should be parsed.</param>

-        </member>

-        <member name="M:HttpServer.FormDecoders.XmlDecoder.CanParse(System.String)">

-            <summary>

-            Checks if the decoder can handle the mime type

-            </summary>

-            <param name="contentType">Content type (with any additional info like boundry). Content type is always supplied in lower case.</param>

-            <returns>True if the decoder can parse the specified content type</returns>

-        </member>

-        <member name="T:HttpServer.ResponseCookies">

-            <summary>

-            Cookies that should be set.

-            </summary>

-        </member>

-        <member name="M:HttpServer.ResponseCookies.Add(HttpServer.ResponseCookie)">

+        <member name="T:HttpServer.Helpers.JSHelper">

             <summary>

-            Adds a cookie in the collection.

+            Will contain helper functions for javascript.

             </summary>

-            <param name="cookie">cookie to add</param>

-            <exception cref="T:System.ArgumentNullException">cookie is null</exception>

         </member>

-        <member name="M:HttpServer.ResponseCookies.Add(HttpServer.RequestCookie,System.DateTime)">

+        <member name="M:HttpServer.Helpers.JSHelper.AjaxRequest(System.String,System.String[])">

             <summary>

-            Copy a request cookie

+            Requests a url through ajax

             </summary>

-            <param name="cookie"></param>

-            <param name="expires">When the cookie should expire</param>

+            <param name="url">url to fetch. Url is NOT enclosed in quotes by the implementation. You need to do that yourself.</param>

+            <param name="options">optional options in format "key, value, key, value", used in JS request object. All keys should end with colon.</param>

+            <returns>a link tag</returns>

+            <remarks>onclick attribute is used by this method.</remarks>

+            <example>

+            <code>

+            // plain text

+            JSHelper.AjaxRequest("'/user/show/1'");

+            

+            // ajax request using this.href

+            string link = "&lt;a href=\"/user/call/1\" onclick=\"" + JSHelper.AjaxRequest("this.href") + "/&lt;call user&lt;/a&gt;";

+            </code>

+            </example>

         </member>

-        <member name="M:HttpServer.ResponseCookies.GetEnumerator">

+        <member name="M:HttpServer.Helpers.JSHelper.AjaxUpdater(System.String,System.String,System.String[])">

             <summary>

-            Gets a collection enumerator on the cookie list.

+            Ajax requests that updates an element with

+            the fetched content

             </summary>

-            <returns>collection enumerator</returns>

+            <param name="url">url to fetch. Url is NOT enclosed in quotes by the implementation. You need to do that yourself.</param>

+            <param name="targetId">element to update</param>

+            <param name="options">options in format "key, value, key, value". All keys should end with colon.</param>

+            <returns>A link tag.</returns>

+            <example>

+            <code>

+            JSHelper.AjaxUpdater("'/user/show/1'", "user", "onsuccess:", "alert('hello');", "asynchronous:", "true");

+            </code>

+            </example>

         </member>

-        <member name="M:HttpServer.ResponseCookies.Clear">

+        <member name="M:HttpServer.Helpers.JSHelper.CreateDialog(System.String,System.String,System.String[])">

             <summary>

-            Remove all cookies

+            Opens contents in a dialog window.

             </summary>

+            <param name="url">url to contents of dialog</param>

+            <param name="title">link title</param>

+            <param name="options">name, value, name, value, all parameter names should end with colon.</param>

         </member>

-        <member name="M:HttpServer.ResponseCookies.System#Collections#Generic#IEnumerable{HttpServer#ResponseCookie}#GetEnumerator">

+        <member name="M:HttpServer.Helpers.JSHelper.CloseDialog">

             <summary>

-            Returns an enumerator that iterates through the collection.

+            Close a javascript dialog window/div.

             </summary>

-            

-            <returns>

-            A <see cref="T:System.Collections.Generic.IEnumerator`1"></see> that can be used to iterate through the collection.

-            </returns>

-            <filterpriority>1</filterpriority>

+            <returns>javascript for closing a dialog.</returns>

+            <see cref="M:HttpServer.Helpers.JSHelper.CreateDialog(System.String,System.String,System.String[])"/>

         </member>

-        <member name="P:HttpServer.ResponseCookies.Count">

+        <member name="T:HttpServer.ContentType">

             <summary>

-            Gets the count of cookies in the collection.

+            Lists content type mime types.

             </summary>

         </member>

-        <member name="P:HttpServer.ResponseCookies.Item(System.String)">

+        <member name="F:HttpServer.ContentType.Text">

             <summary>

-            Gets the cookie of a given identifier (null if not existing).

+            text/plain

             </summary>

         </member>

-        <member name="T:HttpServer.RequestCookies">

+        <member name="F:HttpServer.ContentType.Html">

             <summary>

-            This class is created as a wrapper, since there are two different cookie types in .Net (Cookie and HttpCookie).

-            The framework might switch class in the future and we dont want to have to replace all instances

+            text/haml

             </summary>

         </member>

-        <member name="M:HttpServer.RequestCookies.#ctor(System.String)">

+        <member name="F:HttpServer.ContentType.Javascript">

             <summary>

-            Let's copy all the cookies.

+            content type for javascript documents = application/javascript

             </summary>

-            <param name="cookies">value from cookie header.</param>

+            <remarks>

+            <para>

+            RFC 4329 states that text/javascript have been superseeded by

+            application/javascript. You might still want to check browser versions

+            since older ones do not support application/javascript.

+            </para>

+            <para>Browser support: http://krijnhoetmer.nl/stuff/javascript/mime-types/</para>

+            </remarks>

         </member>

-        <member name="M:HttpServer.RequestCookies.Add(HttpServer.RequestCookie)">

+        <member name="F:HttpServer.ContentType.Xml">

             <summary>

-            Adds a cookie in the collection.

+            text/xml

             </summary>

-            <param name="cookie">cookie to add</param>

-            <exception cref="T:System.ArgumentNullException">cookie is null</exception>

         </member>

-        <member name="M:HttpServer.RequestCookies.GetEnumerator">

+        <member name="T:HttpServer.ContentTypes">

             <summary>

-            Gets a collection enumerator on the cookie list.

+            A list of content types

             </summary>

-            <returns>collection enumerator</returns>

         </member>

-        <member name="M:HttpServer.RequestCookies.Clear">

+        <member name="M:HttpServer.ContentTypes.#ctor(System.String)">

             <summary>

-            Remove all cookies.

+            

             </summary>

+            <param name="types">Semicolon separated content types.</param>

         </member>

-        <member name="M:HttpServer.RequestCookies.System#Collections#Generic#IEnumerable{HttpServer#RequestCookie}#GetEnumerator">

+        <member name="M:HttpServer.ContentTypes.GetEnumerator">

             <summary>

-            Returns an enumerator that iterates through the collection.

+            Returns an enumerator that iterates through a collection.

             </summary>

-            

             <returns>

-            A <see cref="T:System.Collections.Generic.IEnumerator`1"></see> that can be used to iterate through the collection.

+            An <see cref="T:System.Collections.IEnumerator"/> object that can be used to iterate through the collection.

             </returns>

-            <filterpriority>1</filterpriority>

         </member>

-        <member name="M:HttpServer.RequestCookies.Remove(System.String)">

-            <summary>

-            Remove a cookie from the collection.

-            </summary>

-            <param name="cookieName">Name of cookie.</param>

-        </member>

-        <member name="P:HttpServer.RequestCookies.Count">

-            <summary>

-            Gets the count of cookies in the collection.

-            </summary>

-        </member>

-        <member name="P:HttpServer.RequestCookies.Item(System.String)">

+        <member name="M:HttpServer.ContentTypes.Contains(System.String)">

             <summary>

-            Gets the cookie of a given identifier (null if not existing).

+            Searches for the specified type

             </summary>

+            <param name="type">Can also be a part of a type (searching for "xml" would return true for "application/xml").</param>

+            <returns>true if type was found.</returns>

         </member>

-        <member name="T:HttpServer.HttpListener">

+        <member name="P:HttpServer.ContentTypes.First">

             <summary>

-            New implementation of the HTTP listener.

+            Get this first content type.

             </summary>

-            <remarks>

-            Use the <c>Create</c> methods to create a default listener.

-            </remarks>

         </member>

-        <member name="M:HttpServer.HttpListener.#ctor(System.Net.IPAddress,System.Int32,HttpServer.IHttpContextFactory)">

+        <member name="P:HttpServer.ContentTypes.Item(System.String)">

             <summary>

-            Initializes a new instance of the <see cref="T:HttpServer.HttpListener"/> class.

+            Fetch a content type

             </summary>

-            <param name="address">IP Address to accept connections on</param>

-            <param name="port">TCP Port to listen on, default HTTP port is 80.</param>

-            <param name="factory">Factory used to create <see cref="T:HttpServer.IHttpClientContext"/>es.</param>

-            <exception cref="T:System.ArgumentNullException"><c>address</c> is null.</exception>

-            <exception cref="T:System.ArgumentException">Port must be a positive number.</exception>

+            <param name="type">Part of type ("xml" would return "application/xml")</param>

+            <returns></returns>

+            <remarks>All content types are in lower case.</remarks>

         </member>

-        <member name="M:HttpServer.HttpListener.#ctor(System.Net.IPAddress,System.Int32,HttpServer.IHttpContextFactory,System.Security.Cryptography.X509Certificates.X509Certificate)">

+        <member name="T:HttpServer.RequestParserFactory">

             <summary>

-            Initializes a new instance of the <see cref="T:HttpServer.HttpListener"/> class.

+            Creates request parsers when needed.

             </summary>

-            <param name="address">The address.</param>

-            <param name="port">The port.</param>

-            <param name="factory">The factory.</param>

-            <param name="certificate">The certificate.</param>

         </member>

-        <member name="M:HttpServer.HttpListener.#ctor(System.Net.IPAddress,System.Int32,HttpServer.IHttpContextFactory,System.Security.Cryptography.X509Certificates.X509Certificate,System.Security.Authentication.SslProtocols)">

+        <member name="T:HttpServer.IRequestParserFactory">

             <summary>

-            Initializes a new instance of the <see cref="T:HttpServer.HttpListener"/> class.

+            Creates request parsers when needed.

             </summary>

-            <param name="address">The address.</param>

-            <param name="port">The port.</param>

-            <param name="factory">The factory.</param>

-            <param name="certificate">The certificate.</param>

-            <param name="protocol">The protocol.</param>

         </member>

-        <member name="M:HttpServer.HttpListener.Create(System.Net.IPAddress,System.Int32)">

+        <member name="M:HttpServer.IRequestParserFactory.CreateParser(HttpServer.ILogWriter)">

             <summary>

-            Creates a new <see cref="T:HttpServer.HttpListener"/> instance with default factories.

+            Create a new request parser.

             </summary>

-            <param name="address">Address that the listener should accept connections on.</param>

-            <param name="port">Port that listener should accept connections on.</param>

-            <returns>Created HTTP listener.</returns>

+            <param name="logWriter">Used when logging should be enabled.</param>

+            <returns>A new request parser.</returns>

         </member>

-        <member name="M:HttpServer.HttpListener.Create(System.Net.IPAddress,System.Int32,System.Security.Cryptography.X509Certificates.X509Certificate)">

+        <member name="M:HttpServer.RequestParserFactory.CreateParser(HttpServer.ILogWriter)">

             <summary>

-            Creates a new <see cref="T:HttpServer.HttpListener"/> instance with default factories.

+            Create a new request parser.

             </summary>

-            <param name="address">Address that the listener should accept connections on.</param>

-            <param name="port">Port that listener should accept connections on.</param>

-            <param name="certificate">Certificate to use</param>

-            <returns>Created HTTP listener.</returns>

+            <param name="logWriter">Used when logging should be enabled.</param>

+            <returns>A new request parser.</returns>

         </member>

-        <member name="M:HttpServer.HttpListener.Create(System.Net.IPAddress,System.Int32,System.Security.Cryptography.X509Certificates.X509Certificate,System.Security.Authentication.SslProtocols)">

+        <member name="T:HttpServer.Exceptions.UnauthorizedException">

             <summary>

-            Creates a new <see cref="T:HttpServer.HttpListener"/> instance with default factories.

+            The request requires user authentication. The response MUST include a 

+            WWW-Authenticate header field (section 14.47) containing a challenge 

+            applicable to the requested resource. 

+            

+            The client MAY repeat the request with a suitable Authorization header 

+            field (section 14.8). If the request already included Authorization 

+            credentials, then the 401 response indicates that authorization has been 

+            refused for those credentials. If the 401 response contains the same challenge 

+            as the prior response, and the user agent has already attempted authentication 

+            at least once, then the user SHOULD be presented the entity that was given in the response, 

+            since that entity might include relevant diagnostic information. 

+            

+            HTTP access authentication is explained in rfc2617:

+            http://www.ietf.org/rfc/rfc2617.txt

+            

+            (description is taken from 

+            http://www.submissionchamber.com/help-guides/error-codes.php#sec10.4.2)

             </summary>

-            <param name="address">Address that the listener should accept connections on.</param>

-            <param name="port">Port that listener should accept connections on.</param>

-            <param name="certificate">Certificate to use</param>

-            <param name="protocol">which HTTPS protocol to use, default is TLS.</param>

-            <returns>Created HTTP listener.</returns>

         </member>

-        <member name="M:HttpServer.HttpListener.OnAcceptingSocket(System.Net.Sockets.Socket)">

+        <member name="M:HttpServer.Exceptions.UnauthorizedException.#ctor">

             <summary>

-            Can be used to create filtering of new connections.

+            Create a new unauhtorized exception.

             </summary>

-            <param name="socket">Accepted socket</param>

-            <returns>

-            true if connection can be accepted; otherwise false.

-            </returns>

+            <seealso cref="T:HttpServer.Exceptions.UnauthorizedException"/>

         </member>

-        <member name="E:HttpServer.HttpListener.Accepted">

+        <member name="M:HttpServer.Exceptions.UnauthorizedException.#ctor(System.String,System.Exception)">

             <summary>

-            A client have been accepted, but not handled, by the listener.

+            Create a new unauhtorized exception.

             </summary>

+            <param name="message">reason to why the request was unauthorized.</param>

+            <param name="inner">inner exception</param>

         </member>

-        <member name="T:HttpServer.HttpHelper">

+        <member name="M:HttpServer.Exceptions.UnauthorizedException.#ctor(System.String)">

             <summary>

-            Generic helper functions for HTTP

+            Create a new unauhtorized exception.

             </summary>

+            <param name="message">reason to why the request was unauthorized.</param>

         </member>

-        <member name="F:HttpServer.HttpHelper.HTTP10">

+        <member name="T:HttpServer.HttpModules.FileModule">

             <summary>

-            Version string for HTTP v1.0

+            The purpose of this module is to serve files.

             </summary>

         </member>

-        <member name="F:HttpServer.HttpHelper.HTTP11">

+        <member name="M:HttpServer.HttpModules.FileModule.#ctor(System.String,System.String,System.Boolean)">

             <summary>

-            Version string for HTTP v1.1

+            Initializes a new instance of the <see cref="T:HttpServer.HttpModules.FileModule"/> class.

             </summary>

+            <param name="baseUri">Uri to serve, for instance "/files/"</param>

+            <param name="basePath">Path on hard drive where we should start looking for files</param>

+            <param name="useLastModifiedHeader">If true a Last-Modifed header will be sent upon requests urging web browser to cache files</param>

         </member>

-        <member name="F:HttpServer.HttpHelper.EmptyUri">

+        <member name="M:HttpServer.HttpModules.FileModule.#ctor(System.String,System.String)">

             <summary>

-            An empty URI

+            Initializes a new instance of the <see cref="T:HttpServer.HttpModules.FileModule"/> class.

             </summary>

+            <param name="baseUri">Uri to serve, for instance "/files/"</param>

+            <param name="basePath">Path on hard drive where we should start looking for files</param>

         </member>

-        <member name="M:HttpServer.HttpHelper.ParseQueryString(System.String)">

+        <member name="M:HttpServer.HttpModules.FileModule.AddDefaultMimeTypes">

             <summary>

-            Parses a query string.

+            Mimtypes that this class can handle per default

             </summary>

-            <param name="queryString">Query string (URI encoded)</param>

-            <returns>A <see cref="T:HttpServer.HttpInput"/> object if successful; otherwise <see cref="F:HttpServer.HttpInput.Empty"/></returns>

-            <exception cref="T:System.ArgumentNullException"><c>queryString</c> is null.</exception>

-            <exception cref="T:System.FormatException">If string cannot be parsed.</exception>

         </member>

-        <member name="T:HttpServer.HttpModules.ReverseProxyModule">

+        <member name="M:HttpServer.HttpModules.FileModule.CanHandle(System.Uri)">

             <summary>

-            A reverse proxy are used to act as a bridge between local (protected/hidden) websites

-            and public clients.

-            

-            A typical usage is to allow web servers on non standard ports to still be available

-            to the public clients, or allow web servers on private ips to be available.

+            Determines if the request should be handled by this module.

+            Invoked by the <see cref="T:HttpServer.HttpServer"/>

             </summary>

+            <param name="uri"></param>

+            <returns>true if this module should handle it.</returns>

         </member>

-        <member name="M:HttpServer.HttpModules.ReverseProxyModule.#ctor(System.String,System.String)">

-            <summary>

-            

-            </summary>

-            <param name="source">Base url requested from browser</param>

-            <param name="destination">Base url on private web server</param>

-            <example>

-            // this will return contents from http://192.168.1.128/view/jonas when client requests http://www.gauffin.com/user/view/jonas

-            _server.Add(new ReverseProxyModule("http://www.gauffin.com/user/", "http://192.168.1.128/");

-            </example>

+        <member name="M:HttpServer.HttpModules.FileModule.GetPath(System.Uri)">

+            <exception cref="T:HttpServer.Exceptions.BadRequestException">Illegal path</exception>

         </member>

-        <member name="M:HttpServer.HttpModules.ReverseProxyModule.CanHandle(System.Uri)">

+        <member name="M:HttpServer.HttpModules.FileModule.Contains(System.String,System.Collections.Generic.IEnumerable{System.String})">

             <summary>

-            Method that determines if an url should be handled or not by the module

+            check if source contains any of the chars.

             </summary>

-            <param name="uri">Url requested by the client.</param>

-            <returns>true if module should handle the url.</returns>

+            <param name="source"></param>

+            <param name="chars"></param>

+            <returns></returns>

         </member>

-        <member name="M:HttpServer.HttpModules.ReverseProxyModule.Process(HttpServer.IHttpRequest,HttpServer.IHttpResponse,HttpServer.Sessions.IHttpSession)">

+        <member name="M:HttpServer.HttpModules.FileModule.Process(HttpServer.IHttpRequest,HttpServer.IHttpResponse,HttpServer.Sessions.IHttpSession)">

             <summary>

-            Method that process the url

+            Method that process the Uri.

             </summary>

             <param name="request">Information sent by the browser about the request</param>

             <param name="response">Information that is being sent back to the client.</param>

             <param name="session">Session used to </param>

+            <exception cref="T:HttpServer.Exceptions.InternalServerException">Failed to find file extension</exception>

+            <exception cref="T:HttpServer.Exceptions.ForbiddenException">File type is forbidden.</exception>

         </member>

-        <member name="T:HttpServer.HttpModules.HttpModuleExceptionEventArgs">

+        <member name="M:HttpServer.HttpModules.FileModule.GetFileExtension(System.String)">

             <summary>

-            Used to inform http server that 

+            return a file extension from an absolute Uri path (or plain filename)

             </summary>

+            <param name="uri"></param>

+            <returns></returns>

         </member>

-        <member name="M:HttpServer.HttpModules.HttpModuleExceptionEventArgs.#ctor(System.Exception)">

+        <member name="P:HttpServer.HttpModules.FileModule.MimeTypes">

             <summary>

-            Eventarguments used when an exception is thrown by a module

+            List with all mime-type that are allowed. 

             </summary>

-            <param name="e">the exception</param>

+            <remarks>All other mime types will result in a Forbidden http status code.</remarks>

         </member>

-        <member name="P:HttpServer.HttpModules.HttpModuleExceptionEventArgs.Exception">

+        <member name="P:HttpServer.HttpModules.FileModule.ForbiddenChars">

             <summary>

-            Exception thrown in a module

+            characters that may not  exist in a path.

             </summary>

+            <example>

+            fileMod.ForbiddenChars = new string[]{ "\\", "..", ":" };

+            </example>

         </member>

-        <member name="T:HttpServer.Helpers.Implementations.PrototypeImp">

+        <member name="T:HttpServer.Helpers.WebHelper">

             <summary>

-            PrototypeJS implementation of the javascript functions.

+            Webhelper provides helpers for common tasks in HTML.

             </summary>

         </member>

-        <member name="M:HttpServer.Helpers.Implementations.PrototypeImp.AjaxRequest(System.String,System.String[])">

+        <member name="F:HttpServer.Helpers.WebHelper.JSImplementation">

             <summary>

-            Requests a url through ajax

+            Used to let the website use different javascript libraries.

+            Default is <see cref="T:HttpServer.Helpers.Implementations.PrototypeImp"/>

             </summary>

-            <param name="url">url to fetch. Url is NOT enclosed in quotes by the implementation. You need to do that yourself.</param>

-            <param name="options">optional options in format "key, value, key, value", used in JS request object. All keys should end with colon.</param>

-            <returns>a link tag</returns>

-            <remarks>onclick attribute is used by this method.</remarks>

-            <example>

-            <code>

-            // plain text

-            JSHelper.AjaxRequest("'/user/show/1'");

-            

-            // ajax request using this.href

-            string link = "&lt;a href=\"/user/call/1\" onclick=\"" + JSHelper.AjaxRequest("this.href") + "/&lt;call user&lt;/a&gt;";

-            </code>

-            </example>

         </member>

-        <member name="M:HttpServer.Helpers.Implementations.PrototypeImp.Contains(System.Collections.Generic.IEnumerable{System.String},System.String)">

+        <member name="M:HttpServer.Helpers.WebHelper.AjaxRequest(System.String,System.String,System.String[])">

             <summary>

-            Determins if a list of strings contains a specific value

+            Creates a link that invokes through ajax.

             </summary>

-            <param name="options">options to check in</param>

-            <param name="value">value to find</param>

-            <returns>true if value was found</returns>

-            <remarks>case insensitive</remarks>

+            <param name="url">url to fetch</param>

+            <param name="title">link title</param>

+            <param name="options">

+            optional options in format "key, value, key, value". 

+            Javascript options starts with ':'.

+            </param>

+            <returns>a link tag</returns>

+            <example>

+            WebHelper.AjaxRequest("/users/add/", "Add user", "method:", "post", "onclick", "validate('this');");

+            </example>

         </member>

-        <member name="M:HttpServer.Helpers.Implementations.PrototypeImp.AjaxUpdater(System.String,System.String,System.String[])">

+        <member name="M:HttpServer.Helpers.WebHelper.AjaxUpdater(System.String,System.String,System.String,System.String[])">

             <summary>

-            Ajax requests that updates an element with

-            the fetched content

+            Builds a link that updates an element with the fetched ajax content.

             </summary>

-            <param name="url">URL to fetch. URL is NOT enclosed in quotes by the implementation. You need to do that yourself.</param>

-            <param name="targetId">element to update</param>

-            <param name="options">options in format "key, value, key, value". All keys should end with colon.</param>

+            <param name="url">Url to fetch content from</param>

+            <param name="title">link title</param>

+            <param name="targetId">html element to update with the results of the ajax request.</param>

+            <param name="options">optional options in format "key, value, key, value"</param>

             <returns>A link tag.</returns>

-            <example>

-            <code>

-            JSHelper.AjaxUpdater("'/user/show/1'", "user", "onsuccess:", "alert('hello');", "asynchronous:", "true");

-            </code>

-            </example>

         </member>

-        <member name="M:HttpServer.Helpers.Implementations.PrototypeImp.DialogLink(System.String,System.String,System.String[])">

+        <member name="M:HttpServer.Helpers.WebHelper.DialogLink(System.String,System.String,System.String[])">

             <summary>

             A link that pop ups a Dialog (overlay div)

             </summary>

-            <param name="url">URL to contents of dialog</param>

+            <param name="url">url to contents of dialog</param>

             <param name="title">link title</param>

-            <param name="htmlAttributes">name, value, name, value</param>

-            <returns>

-            A "a"-tag that popups a dialog when clicked

-            </returns>

-            <remarks><para>Requires Control.Modal found here: http://livepipe.net/projects/control_modal/</para>

-            And the following JavaScript (load it in application.js):

-            <code>

-            Event.observe(window, 'load',

-              function() {

-                document.getElementsByClassName('modal').each(function(link){  new Control.Modal(link);  });

-              }

-            );

-            </code>

-            </remarks>

+            <param name="htmlAttributes">name/value of html attributes.</param>

+            <returns>A "a"-tag that popups a dialog when clicked</returns>

             <example>

             WebHelper.DialogLink("/user/show/1", "show user", "onmouseover", "alert('booh!');");

             </example>

         </member>

-        <member name="M:HttpServer.Helpers.Implementations.PrototypeImp.CreateDialog(System.String,System.String,System.String[])">

+        <member name="M:HttpServer.Helpers.WebHelper.CreateDialog(System.String,System.String,System.String[])">

             <summary>

-            create a modal dialog (usually using DIVs)

+            Create/Open a dialog box using ajax

             </summary>

-            <param name="url">url to fetch</param>

-            <param name="title">dialog title</param>

-            <param name="options">javascript/html attributes. javascript options ends with colon ':'.</param>

+            <param name="url"></param>

+            <param name="title"></param>

+            <param name="parameters"></param>

             <returns></returns>

         </member>

-        <member name="M:HttpServer.Helpers.Implementations.PrototypeImp.CloseDialog">

+        <member name="M:HttpServer.Helpers.WebHelper.CloseDialog">

             <summary>

             Close a javascript dialog window/div.

             </summary>

             <returns>javascript for closing a dialog.</returns>

-            <see cref="M:HttpServer.Helpers.Implementations.PrototypeImp.DialogLink(System.String,System.String,System.String[])"/>

+            <see cref="M:HttpServer.Helpers.WebHelper.DialogLink(System.String,System.String,System.String[])"/>

         </member>

-        <member name="M:HttpServer.Helpers.Implementations.PrototypeImp.AjaxFormOnSubmit(System.String[])">

+        <member name="M:HttpServer.Helpers.WebHelper.FormStart(System.String,System.String,System.Boolean)">

             <summary>

-            javascript action that should be added to the "onsubmit" event in the form tag.

+            Create a &lt;form&gt; tag.

             </summary>

-            <param name="options">remember to encapsulate strings in ''</param>

-            <returns></returns>

-            <remarks>All javascript option names should end with colon.</remarks>

+            <param name="name">name of form</param>

+            <param name="action">action to invoke on submit</param>

+            <param name="isAjax">form should be posted as ajax</param>

+            <returns>html code</returns>

             <example>

-                <code>

-            JSHelper.AjaxRequest("/user/show/1", "onsuccess:", "$('userInfo').update(result);");

-            </code>

+            WebHelper.FormStart("frmLogin", "/user/login", Request.IsAjax);

             </example>

         </member>

-        <member name="T:HttpServer.Authentication.DigestAuthentication">

-            <summary>

-            Implements HTTP Digest authentication. It's more secure than Basic auth since password is 

-            encrypted with a "key" from the server. 

-            </summary>

-            <remarks>

-            Keep in mind that the password is encrypted with MD5. Use a combination of SSL and digest auth to be secure.

-            </remarks>

-        </member>

-        <member name="M:HttpServer.Authentication.DigestAuthentication.#ctor(HttpServer.Authentication.AuthenticationHandler,HttpServer.Authentication.AuthenticationRequiredHandler)">

-            <summary>

-            Initializes a new instance of the <see cref="T:HttpServer.Authentication.DigestAuthentication"/> class.

-            </summary>

-            <param name="authenticator">Delegate used to provide information used during authentication.</param>

-            <param name="authenticationRequiredHandler">Delegate used to determine if authentication is required (may be null).</param>

-        </member>

-        <member name="M:HttpServer.Authentication.DigestAuthentication.#ctor(HttpServer.Authentication.AuthenticationHandler)">

-            <summary>

-            Initializes a new instance of the <see cref="T:HttpServer.Authentication.DigestAuthentication"/> class.

-            </summary>

-            <param name="authenticator">Delegate used to provide information used during authentication.</param>

-        </member>

-        <member name="F:HttpServer.Authentication.DigestAuthentication.DisableNonceCheck">

+        <member name="M:HttpServer.Helpers.WebHelper.Link(System.String,System.String,System.String[])">

             <summary>

-            Used by test classes to be able to use hardcoded values

+            Create a link tag.

             </summary>

+            <param name="url">url to go to</param>

+            <param name="title">link title (text that is displayed)</param>

+            <param name="htmlAttributes">html attributes, name, value, name, value</param>

+            <returns>html code</returns>

+            <example>

+            WebHelper.Link("/user/show/1", "Show user", "id", "showUser", "onclick", "return confirm('Are you shure?');");

+            </example>

         </member>

-        <member name="M:HttpServer.Authentication.DigestAuthentication.Authenticate(System.String,System.String,System.String,System.Object[])">

+        <member name="M:HttpServer.Helpers.WebHelper.BuildLink(System.String,System.String,System.String[])">

             <summary>

-            An authentication response have been received from the web browser.

-            Check if it's correct

+            Build a link

             </summary>

-            <param name="authenticationHeader">Contents from the Authorization header</param>

-            <param name="realm">Realm that should be authenticated</param>

-            <param name="httpVerb">GET/POST/PUT/DELETE etc.</param>

-            <param name="options">First option: true if username/password is correct but not cnonce</param>

-            <returns>

-            Authentication object that is stored for the request. A user class or something like that.

-            </returns>

-            <exception cref="T:System.ArgumentException">if authenticationHeader is invalid</exception>

-            <exception cref="T:System.ArgumentNullException">If any of the paramters is empty or null.</exception>

+            <param name="url">url to go to.</param>

+            <param name="title">title of link (displayed text)</param>

+            <param name="htmlAttributes">extra html attributes.</param>

+            <returns>a complete link</returns>

         </member>

-        <member name="M:HttpServer.Authentication.DigestAuthentication.Encrypt(System.String,System.String,System.String,System.String,System.String,System.String,System.String,System.String,System.String)">

+        <member name="M:HttpServer.Helpers.WebHelper.BuildLink(System.String,System.String,System.String[],System.String[])">

             <summary>

-            Encrypts parameters into a Digest string

+            Build a link

             </summary>

-            <param name="realm">Realm that the user want to log into.</param>

-            <param name="userName">User logging in</param>

-            <param name="password">Users password.</param>

-            <param name="method">HTTP method.</param>

-            <param name="uri">Uri/domain that generated the login prompt.</param>

-            <param name="qop">Quality of Protection.</param>

-            <param name="nonce">"Number used ONCE"</param>

-            <param name="nc">Hexadecimal request counter.</param>

-            <param name="cnonce">"Client Number used ONCE"</param>

-            <returns>Digest encrypted string</returns>

+            <param name="url">url to go to.</param>

+            <param name="title">title of link (displayed text)</param>

+            <param name="htmlAttributes">extra html attributes.</param>

+            <returns>a complete link</returns>

+            <param name="options">more options</param>

         </member>

-        <member name="M:HttpServer.Authentication.DigestAuthentication.Encrypt(System.String,System.String,System.String,System.String,System.String,System.String)">

+        <member name="M:HttpServer.Helpers.WebHelper.Select(System.String,System.Collections.ICollection,HttpServer.Helpers.GetIdTitle,System.Object,System.Boolean)">

             <summary>

-            

+            Obsolete

             </summary>

-            <param name="ha1">Md5 hex encoded "userName:realm:password", without the quotes.</param>

-            <param name="ha2">Md5 hex encoded "method:uri", without the quotes</param>

-            <param name="qop">Quality of Protection</param>

-            <param name="nonce">"Number used ONCE"</param>

-            <param name="nc">Hexadecimal request counter.</param>

-            <param name="cnonce">Client number used once</param>

-            <returns></returns>

+            <param name="name">Obsolete</param>

+            <param name="collection">Obsolete</param>

+            <param name="getIdTitle">Obsolete</param>

+            <param name="selectedValue">Obsolete</param>

+            <param name="firstEmpty">Obsolete</param>

+            <returns>Obsolete</returns>

         </member>

-        <member name="M:HttpServer.Authentication.DigestAuthentication.CreateResponse(System.String,System.Object[])">

+        <member name="M:HttpServer.Helpers.WebHelper.Select(System.String,System.String,System.Collections.ICollection,HttpServer.Helpers.GetIdTitle,System.Object,System.Boolean)">

             <summary>

-            Create a response that can be sent in the WWW-Authenticate header.

+            Obsolete

             </summary>

-            <param name="realm">Realm that the user should authenticate in</param>

-            <param name="options">First options specifies if true if username/password is correct but not cnonce.</param>

-            <returns>A correct auth request.</returns>

-            <exception cref="T:System.ArgumentNullException">If realm is empty or null.</exception>

+            <param name="name">Obsolete</param>

+            <param name="id">Obsolete</param>

+            <param name="collection">Obsolete</param>

+            <param name="getIdTitle">Obsolete</param>

+            <param name="selectedValue">Obsolete</param>

+            <param name="firstEmpty">Obsolete</param>

+            <returns>Obsolete</returns>

         </member>

-        <member name="M:HttpServer.Authentication.DigestAuthentication.Decode(System.String,System.Text.Encoding)">

+        <member name="M:HttpServer.Helpers.WebHelper.List(System.Collections.Generic.IEnumerable{System.Object},System.String)">

             <summary>

-            Decodes authorization header value

+            Render errors into a UL with class "errors"

             </summary>

-            <param name="buffer">header value</param>

-            <param name="encoding">Encoding that the buffer is in</param>

-            <returns>All headers and their values if successful; otherwise null</returns>

-            <example>

-            NameValueCollection header = DigestAuthentication.Decode("response=\"6629fae49393a05397450978507c4ef1\",\r\nc=00001", Encoding.ASCII);

-            </example>

-            <remarks>Can handle lots of whitespaces and new lines without failing.</remarks>

+            <param name="className">class used by UL-tag.</param>

+            <param name="theList">items to list</param>

+            <returns>an unordered html list.</returns>

         </member>

-        <member name="M:HttpServer.Authentication.DigestAuthentication.GetCurrentNonce">

+        <member name="M:HttpServer.Helpers.WebHelper.List(System.Collections.Specialized.NameValueCollection,System.String)">

             <summary>

-            Gets the current nonce.

+            Render errors into a UL with class "errors"

             </summary>

-            <returns></returns>

+            <param name="className">class used by UL-tag.</param>

+            <param name="theList">items to list</param>

+            <returns>an unordered html list.</returns>

         </member>

-        <member name="M:HttpServer.Authentication.DigestAuthentication.GetMD5HashBinHex2(System.String)">

+        <member name="M:HttpServer.Helpers.WebHelper.Errors(System.Collections.Specialized.NameValueCollection)">

             <summary>

-            Gets the Md5 hash bin hex2.

+            Render errors into a UL with class "errors"

             </summary>

-            <param name="toBeHashed">To be hashed.</param>

+            <param name="errors"></param>

             <returns></returns>

         </member>

-        <member name="M:HttpServer.Authentication.DigestAuthentication.IsValidNonce(System.String)">

+        <member name="M:HttpServer.Helpers.WebHelper.GenerateHtmlAttributes(System.Text.StringBuilder,System.String[],System.String[])">

             <summary>

-            determines if the nonce is valid or has expired.

+            Generates a list with html attributes.

             </summary>

-            <param name="nonce">nonce value (check wikipedia for info)</param>

-            <returns>true if the nonce has not expired.</returns>

+            <param name="sb">StringBuilder that the options should be added to.</param>

+            <param name="firstOptions">attributes set by user.</param>

+            <param name="secondOptions">attributes set by any of the helper classes.</param>

         </member>

-        <member name="P:HttpServer.Authentication.DigestAuthentication.Name">

+        <member name="M:HttpServer.Helpers.WebHelper.GenerateHtmlAttributes(System.Text.StringBuilder,System.String[])">

             <summary>

-            name used in http request.

+            Generates a list with html attributes.

             </summary>

+            <param name="sb">StringBuilder that the options should be added to.</param>

+            <param name="options"></param>

         </member>

-        <member name="P:HttpServer.Authentication.DigestAuthentication.TokenIsHA1">

+        <member name="T:HttpServer.Helpers.GetIdTitle">

             <summary>

-            Gets or sets whether the token supplied in <see cref="T:HttpServer.Authentication.AuthenticationHandler"/> is a

-            HA1 generated string.

+            Delegate used by <see cref="M:HttpServer.Helpers.FormHelper.Select(System.String,System.Collections.IEnumerable,HttpServer.Helpers.GetIdTitle,System.Object,System.Boolean)"/> to populate select options.

             </summary>

+            <param name="obj">current object (for instance a User).</param>

+            <param name="id">Text that should be displayed in the value part of a &lt;optiongt;-tag.</param>

+            <param name="title">Text shown in the select list.</param>

+            <example>

+            // Class that is going to be used in a SELECT-tag.

+            public class User

+            {

+                private readonly string _realName;

+                private readonly int _id;

+                public User(int id, string realName)

+                {

+                    _id = id;

+                    _realName = realName;

+                }

+                public string RealName

+                {

+                    get { return _realName; }

+                }

+            

+                public int Id

+                {

+                    get { return _id; }

+                }

+            }

+            

+            // Using an inline delegate to generate the select list

+            public void UserInlineDelegate()

+            {

+                List&lt;User&gt; items = new List&lt;User&gt;();

+                items.Add(new User(1, "adam"));

+                items.Add(new User(2, "bertial"));

+                items.Add(new User(3, "david"));

+                string htmlSelect = Select("users", "users", items, delegate(object o, out object id, out object value)

+                                                                    {

+                                                                        User user = (User)o;

+                                                                        id = user.Id;

+                                                                        value = user.RealName;

+                                                                    }, 2, true);

+            }

+            

+            // Using an method as delegate to generate the select list.

+            public void UseExternalDelegate()

+            {

+                List&lt;User&gt; items = new List&lt;User&gt;();

+                items.Add(new User(1, "adam"));

+                items.Add(new User(2, "bertial"));

+                items.Add(new User(3, "david"));

+                string htmlSelect = Select("users", "users", items, UserOptions, 1, true);

+            }

+            

+            // delegate returning id and title

+            public static void UserOptions(object o, out object id, out object title)

+            {

+                User user = (User)o;

+                id = user.Id;

+                value = user.RealName;

+            }    /// </example>

         </member>

     </members>

 </doc>

diff --git a/prebuild.xml b/prebuild.xml
index 0a4c914..51a4e8b 100644
--- a/prebuild.xml
+++ b/prebuild.xml
@@ -1587,6 +1587,8 @@
       </Files>
     </Project>
 
+
+
     <Project frameworkVersion="v3_5" name="OpenSim.Region.ClientStack.LindenCaps" path="OpenSim/Region/ClientStack/Linden/Caps" type="Library">
       <Configuration name="Debug">
         <Options>
@@ -1631,6 +1633,7 @@
       </Files>
     </Project>
 
+    
     <Project frameworkVersion="v3_5" name="OpenSim.Region.CoreModules" path="OpenSim/Region/CoreModules" type="Library">
       <Configuration name="Debug">
         <Options>