diff --git a/Common/ConfigurationExtension.cs b/Common/ConfigurationExtension.cs
index 8a47505a1..116aae9f3 100644
--- a/Common/ConfigurationExtension.cs
+++ b/Common/ConfigurationExtension.cs
@@ -58,6 +58,24 @@ public static string GetValue(this NameValueCollection collection, string key, s
         public static void Deserialize<TElement>(this TElement section, XmlReader reader)
             where TElement : ConfigurationElement
         {
+            if (section is ConfigurationElementCollection)
+            {
+                var collectionType = section.GetType();
+                var att = collectionType.GetCustomAttributes(typeof(ConfigurationCollectionAttribute), true).FirstOrDefault() as ConfigurationCollectionAttribute;
+
+                if (att != null)
+                {
+                    var property = collectionType.GetProperty("AddElementName", BindingFlags.NonPublic | BindingFlags.Instance);
+                    property.SetValue(section, att.AddItemName, null);
+
+                    property = collectionType.GetProperty("RemoveElementName", BindingFlags.NonPublic | BindingFlags.Instance);
+                    property.SetValue(section, att.RemoveItemName, null);
+
+                    property = collectionType.GetProperty("ClearElementName", BindingFlags.NonPublic | BindingFlags.Instance);
+                    property.SetValue(section, att.ClearItemsName, null);
+                }
+            }
+
             var deserializeElementMethod = typeof(TElement).GetMethod("DeserializeElement", BindingFlags.NonPublic | BindingFlags.Instance);
             deserializeElementMethod.Invoke(section, new object[] { reader, false });
         }
diff --git a/Common/SmartPool.cs b/Common/SmartPool.cs
index df3cfc098..2b01ea2a2 100644
--- a/Common/SmartPool.cs
+++ b/Common/SmartPool.cs
@@ -9,20 +9,10 @@
 namespace SuperSocket.Common
 {
     /// <summary>
-    /// The basic interface of smart pool
+    /// The pool information class
     /// </summary>
-    /// <typeparam name="T"></typeparam>
-    public interface ISmartPool<T>
+    public interface IPoolInfo
     {
-        /// <summary>
-        /// Initializes the specified min pool size.
-        /// </summary>
-        /// <param name="minPoolSize">The min size of the pool.</param>
-        /// <param name="maxPoolSize">The max size of the pool.</param>
-        /// <param name="sourceCreator">The source creator.</param>
-        /// <returns></returns>
-        void Initialize(int minPoolSize, int maxPoolSize, ISmartPoolSourceCreator<T> sourceCreator);
-
         /// <summary>
         /// Gets the min size of the pool.
         /// </summary>
@@ -48,6 +38,31 @@ public interface ISmartPool<T>
         /// </value>
         int AvialableItemsCount { get; }
 
+
+        /// <summary>
+        /// Gets the total items count, include items in the pool and outside the pool.
+        /// </summary>
+        /// <value>
+        /// The total items count.
+        /// </value>
+        int TotalItemsCount { get; }
+    }
+
+    /// <summary>
+    /// The basic interface of smart pool
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    public interface ISmartPool<T> : IPoolInfo
+    {
+        /// <summary>
+        /// Initializes the specified min pool size.
+        /// </summary>
+        /// <param name="minPoolSize">The min size of the pool.</param>
+        /// <param name="maxPoolSize">The max size of the pool.</param>
+        /// <param name="sourceCreator">The source creator.</param>
+        /// <returns></returns>
+        void Initialize(int minPoolSize, int maxPoolSize, ISmartPoolSourceCreator<T> sourceCreator);        
+
         /// <summary>
         /// Pushes the specified item into the pool.
         /// </summary>
@@ -186,6 +201,19 @@ public int AvialableItemsCount
             }
         }
 
+        private int m_TotalItemsCount;
+
+        /// <summary>
+        /// Gets the total items count, include items in the pool and outside the pool.
+        /// </summary>
+        /// <value>
+        /// The total items count.
+        /// </value>
+        public int TotalItemsCount
+        {
+            get { return m_TotalItemsCount; }
+        }
+
         /// <summary>
         /// Initializes the specified min and max pool size.
         /// </summary>
@@ -228,8 +256,12 @@ public void Initialize(int minPoolSize, int maxPoolSize, ISmartPoolSourceCreator
             {
                 m_GlobalStack.Push(items[i]);
             }
+
+            m_TotalItemsCount = m_MinPoolSize;
         }
 
+        private int m_IsIncreasing = 0;
+
         /// <summary>
         /// Pushes the specified item into the pool.
         /// </summary>
@@ -239,6 +271,24 @@ public void Push(T item)
             m_GlobalStack.Push(item);
         }
 
+        bool TryPopWithWait(out T item, int waitTicks)
+        {
+            var spinWait = new SpinWait();
+
+            while (true)
+            {
+                spinWait.SpinOnce();
+
+                if (m_GlobalStack.TryPop(out item))
+                    return true;
+
+                if (spinWait.Count >= waitTicks)
+                {
+                    return false;
+                }
+            }
+        }
+
         /// <summary>
         /// Tries to get one item from the pool.
         /// </summary>
@@ -253,42 +303,43 @@ public bool TryGet(out T item)
             var currentSourceCount = m_CurrentSourceCount;
 
             if (currentSourceCount >= m_ItemsSource.Length)
-                return false;
-
-            if (Interlocked.CompareExchange(ref m_CurrentSourceCount, currentSourceCount + 1, currentSourceCount) != currentSourceCount)
             {
-                var spinWait = new SpinWait();
+                return TryPopWithWait(out item, 100);
+            }
 
-                while (true)
-                {
-                    spinWait.SpinOnce();
+            var isIncreasing = m_IsIncreasing;
 
-                    if (m_GlobalStack.TryPop(out item))
-                        return true;
+            if (isIncreasing == 1)
+                return TryPopWithWait(out item, 100);
 
-                    if (spinWait.Count >= 100)
-                        return false;
-                }
-            }
+            if (Interlocked.CompareExchange(ref m_IsIncreasing, 1, isIncreasing) != isIncreasing)
+                return TryPopWithWait(out item, 100);
+
+            IncreaseCapacity();
 
-            int totalItemsCount = 0;
+            m_IsIncreasing = 0;
 
-            for (var i = 0; i < currentSourceCount; i++)
+            if (!m_GlobalStack.TryPop(out item))
             {
-                totalItemsCount += m_ItemsSource[i].Count;
+                return false;
             }
 
-            totalItemsCount = Math.Min(totalItemsCount, m_MaxPoolSize - totalItemsCount);
+            return true;
+        }
+
+        private void IncreaseCapacity()
+        {
+            var newItemsCount = Math.Min(m_TotalItemsCount, m_MaxPoolSize - m_TotalItemsCount);
 
             T[] items;
-            m_ItemsSource[currentSourceCount] = m_SourceCreator.Create(totalItemsCount, out items);
+            m_ItemsSource[m_CurrentSourceCount] = m_SourceCreator.Create(newItemsCount, out items);
+
+            m_TotalItemsCount += newItemsCount;
 
             for (var i = 0; i < items.Length; i++)
             {
                 m_GlobalStack.Push(items[i]);
             }
-
-            return m_GlobalStack.TryPop(out item);
         }
     }
 }
diff --git a/Facility/HttpBase/HttpReceiveFilterBase.cs b/Facility/HttpBase/HttpReceiveFilterBase.cs
deleted file mode 100644
index feb1f7469..000000000
--- a/Facility/HttpBase/HttpReceiveFilterBase.cs
+++ /dev/null
@@ -1,115 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Collections.Specialized;
-using System.IO;
-using System.Linq;
-using System.Text;
-using SuperSocket.Common;
-using SuperSocket.SocketBase;
-using SuperSocket.SocketBase.Protocol;
-
-namespace SuperSocket.Facility.HttpBase
-{
-    /// <summary>
-    /// HttpReceiveFilterBase
-    /// </summary>
-    /// <typeparam name="TRequestInfo">The type of the request info.</typeparam>
-    public abstract class HttpReceiveFilterBase<TRequestInfo> : TerminatorReceiveFilter<TRequestInfo>
-        where TRequestInfo : IRequestInfo
-    {
-        /// <summary>
-        /// Http header terminator
-        /// </summary>
-        private static readonly byte[] NewLine = Encoding.ASCII.GetBytes("\r\n\r\n");
-
-        /// <summary>
-        /// indicate whether the header has been parsed
-        /// </summary>
-        private bool m_HeaderParsed = false;
-
-        /// <summary>
-        /// Gets the header items.
-        /// </summary>
-        protected NameValueCollection HeaderItems { get; private set; }
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="HttpReceiveFilterBase&lt;TRequestInfo&gt;"/> class.
-        /// </summary>
-        protected HttpReceiveFilterBase(IAppSession session)
-            : base(session, NewLine)
-        {
-            
-        }
-
-        /// <summary>
-        /// Filters the specified session.
-        /// </summary>
-        /// <param name="readBuffer">The read buffer.</param>
-        /// <param name="offset">The offset.</param>
-        /// <param name="length">The length.</param>
-        /// <param name="toBeCopied">if set to <c>true</c> [to be copied].</param>
-        /// <param name="rest">The rest.</param>
-        /// <returns></returns>
-        public override TRequestInfo Filter(byte[] readBuffer, int offset, int length, bool toBeCopied, out int rest)
-        {
-            if (!m_HeaderParsed)
-            {
-                return base.Filter(readBuffer, offset, length, toBeCopied, out rest);
-            }
-            else
-            {
-                return FilterRequestBody(readBuffer, offset, length, toBeCopied, out rest);
-            }
-        }
-
-        /// <summary>
-        /// Filters the request body.
-        /// </summary>
-        /// <param name="readBuffer">The read buffer.</param>
-        /// <param name="offset">The offset.</param>
-        /// <param name="length">The length.</param>
-        /// <param name="toBeCopied">if set to <c>true</c> [to be copied].</param>
-        /// <param name="rest">The rest data size.</param>
-        /// <returns></returns>
-        protected abstract TRequestInfo FilterRequestBody(byte[] readBuffer, int offset, int length, bool toBeCopied, out int rest);
-
-        /// <summary>
-        /// Resolves the specified data.
-        /// </summary>
-        /// <param name="data">The data.</param>
-        /// <param name="offset">The offset.</param>
-        /// <param name="length">The length.</param>
-        /// <returns></returns>
-        protected override TRequestInfo ProcessMatchedRequest(byte[] data, int offset, int length)
-        {
-            string header = Encoding.UTF8.GetString(data, offset, length);
-
-            var headerItems = new NameValueCollection();
-            MimeHeaderHelper.ParseHttpHeader(header, headerItems);
-            HeaderItems = headerItems;
-
-            OnHeaderParsed(headerItems);
-
-            return NullRequestInfo;
-        }
-
-        /// <summary>
-        /// Called when [header parsed].
-        /// </summary>
-        /// <param name="header">The header.</param>
-        protected virtual void OnHeaderParsed(NameValueCollection header)
-        {
-            
-        }
-
-        /// <summary>
-        /// Resets this instance to inital state.
-        /// </summary>
-        public override void Reset()
-        {
-            m_HeaderParsed = false;
-            HeaderItems = null;
-            base.Reset();
-        }
-    }
-}
diff --git a/Facility/HttpBase/HttpRequestInfoBase.cs b/Facility/HttpBase/HttpRequestInfoBase.cs
deleted file mode 100644
index 2e72ed886..000000000
--- a/Facility/HttpBase/HttpRequestInfoBase.cs
+++ /dev/null
@@ -1,71 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using SuperSocket.SocketBase.Protocol;
-using System.Collections.Specialized;
-
-namespace SuperSocket.Facility.HttpBase
-{
-    /// <summary>
-    /// IHttpRequestInfo
-    /// </summary>
-    public interface IHttpRequestInfo : IRequestInfo
-    {
-        /// <summary>
-        /// Gets the http header.
-        /// </summary>
-        NameValueCollection Header { get; }
-    }
-
-    /// <summary>
-    /// HttpRequestInfoBase
-    /// </summary>
-    public abstract class HttpRequestInfoBase : IHttpRequestInfo
-    {
-        /// <summary>
-        /// Gets the key of this request.
-        /// </summary>
-        public string Key { get; private set; }
-
-        /// <summary>
-        /// Gets the http header.
-        /// </summary>
-        public NameValueCollection Header { get; private set; }
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="HttpRequestInfoBase"/> class.
-        /// </summary>
-        /// <param name="key">The key.</param>
-        /// <param name="header">The header.</param>
-        protected HttpRequestInfoBase(string key, NameValueCollection header)
-        {
-            Key = key;
-            Header = header;
-        }
-    }
-
-    /// <summary>
-    /// HttpRequestInfoBase
-    /// </summary>
-    /// <typeparam name="TRequestBody">The type of the request body.</typeparam>
-    public abstract class HttpRequestInfoBase<TRequestBody> : HttpRequestInfoBase
-    {
-        /// <summary>
-        /// Gets the body.
-        /// </summary>
-        public TRequestBody Body { get; private set; }
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="HttpRequestInfoBase&lt;TRequestBody&gt;"/> class.
-        /// </summary>
-        /// <param name="key">The key.</param>
-        /// <param name="header">The header.</param>
-        /// <param name="body">The body.</param>
-        protected HttpRequestInfoBase(string key, NameValueCollection header, TRequestBody body)
-            : base(key, header)
-        {
-            Body = body;
-        }
-    }
-}
diff --git a/Facility/HttpBase/MimeHeaderHelper.cs b/Facility/HttpBase/MimeHeaderHelper.cs
deleted file mode 100644
index 63be598bc..000000000
--- a/Facility/HttpBase/MimeHeaderHelper.cs
+++ /dev/null
@@ -1,85 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Collections.Specialized;
-using System.IO;
-using System.Linq;
-using System.Text;
-
-namespace SuperSocket.Facility.HttpBase
-{
-    /// <summary>
-    /// MimeHeader Helper class
-    /// </summary>
-    public static class MimeHeaderHelper
-    {
-        private const string Tab = "\t";
-        private const char Colon = ':';
-        private const string Space = " ";
-        private const string ValueSeparator = ", ";
-
-        /// <summary>
-        /// Parses the HTTP header.
-        /// </summary>
-        /// <param name="headerData">The header data.</param>
-        /// <param name="header">The header.</param>
-        public static void ParseHttpHeader(string headerData, NameValueCollection header)
-        {
-            string line;
-            string firstLine = string.Empty;
-            string prevKey = string.Empty;
-
-            var reader = new StringReader(headerData);
-
-            while (!string.IsNullOrEmpty(line = reader.ReadLine()))
-            {
-                if (string.IsNullOrEmpty(firstLine))
-                {
-                    firstLine = line;
-                    continue;
-                }
-
-                if (line.StartsWith(Tab) && !string.IsNullOrEmpty(prevKey))
-                {
-                    string currentValue = header[prevKey];
-                    header[prevKey] = currentValue + line.Trim();
-                    continue;
-                }
-
-                int pos = line.IndexOf(Colon);
-
-                if (pos <= 0)
-                    continue;
-
-                string key = line.Substring(0, pos);
-
-                if (!string.IsNullOrEmpty(key))
-                    key = key.Trim();
-
-                var valueOffset = pos + 1;
-
-                if (line.Length <= valueOffset) //No value in this line
-                    continue;
-
-                string value = line.Substring(valueOffset);
-                if (!string.IsNullOrEmpty(value) && value.StartsWith(Space) && value.Length > 1)
-                    value = value.Substring(1);
-
-                if (string.IsNullOrEmpty(key))
-                    continue;
-
-                string oldValue = header[key];
-
-                if (string.IsNullOrEmpty(oldValue))
-                {
-                    header.Add(key, value);
-                }
-                else
-                {
-                    header[key] = oldValue + ValueSeparator + value;
-                }
-
-                prevKey = key;
-            }
-        }
-    }
-}
diff --git a/Facility/Protocol/CountSpliterReceiveFilter.cs b/Facility/Protocol/CountSpliterReceiveFilter.cs
index 5ffbc62fe..f2e84495a 100644
--- a/Facility/Protocol/CountSpliterReceiveFilter.cs
+++ b/Facility/Protocol/CountSpliterReceiveFilter.cs
@@ -160,7 +160,7 @@ public void Reset()
         /// <value>
         /// The filter state.
         /// </value>
-        public FilterState State { get; private set; }
+        public FilterState State { get; protected set; }
     }
 
     /// <summary>
diff --git a/Facility/Protocol/FixedSizeReceiveFilter.cs b/Facility/Protocol/FixedSizeReceiveFilter.cs
index d7e964d88..cede1b4df 100644
--- a/Facility/Protocol/FixedSizeReceiveFilter.cs
+++ b/Facility/Protocol/FixedSizeReceiveFilter.cs
@@ -10,7 +10,7 @@ namespace SuperSocket.Facility.Protocol
     /// FixedSizeReceiveFilter
     /// </summary>
     /// <typeparam name="TRequestInfo">The type of the request info.</typeparam>
-    public abstract class FixedSizeReceiveFilter<TRequestInfo> : IReceiveFilter<TRequestInfo>, IOffsetAdapter
+    public abstract class FixedSizeReceiveFilter<TRequestInfo> : IReceiveFilter<TRequestInfo>, IOffsetAdapter, IReceiveFilterInitializer
         where TRequestInfo : IRequestInfo
     {
         private int m_ParsedLength;
@@ -39,6 +39,13 @@ protected FixedSizeReceiveFilter(int size)
             m_Size = size;
         }
 
+        private int m_OrigOffset;
+
+        void IReceiveFilterInitializer.Initialize(IAppServer appServer, IAppSession session)
+        {
+            m_OrigOffset = session.SocketSession.OrigReceiveOffset;
+        }
+
         /// <summary>
         /// Filters the specified session.
         /// </summary>
@@ -54,7 +61,7 @@ public virtual TRequestInfo Filter(byte[] readBuffer, int offset, int length, bo
 
             if (rest >= 0)
             {
-                var requestInfo = ProcessMatchedRequest(readBuffer, offset - m_ParsedLength, m_ParsedLength + length, toBeCopied);
+                var requestInfo = ProcessMatchedRequest(readBuffer, offset - m_ParsedLength, m_Size, toBeCopied);
                 InternalReset();
                 return requestInfo;
             }
@@ -63,6 +70,15 @@ public virtual TRequestInfo Filter(byte[] readBuffer, int offset, int length, bo
                 m_ParsedLength += length;
                 m_OffsetDelta = m_ParsedLength;
                 rest = 0;
+
+                var expectedOffset = offset + length;
+                var newOffset = m_OrigOffset + m_OffsetDelta;
+
+                if (newOffset < expectedOffset)
+                {
+                    Buffer.BlockCopy(readBuffer, offset - m_ParsedLength + length, readBuffer, m_OrigOffset, m_ParsedLength);
+                }
+
                 return NullRequestInfo;
             }
         }
@@ -113,7 +129,7 @@ int IOffsetAdapter.OffsetDelta
         /// <value>
         /// The filter state.
         /// </value>
-        public FilterState State { get; private set; }
+        public FilterState State { get; protected set; }
 
         private void InternalReset()
         {
diff --git a/Facility/SuperSocket.Facility.Net35.csproj b/Facility/SuperSocket.Facility.Net35.csproj
index 3da787a8d..194c35d55 100644
--- a/Facility/SuperSocket.Facility.Net35.csproj
+++ b/Facility/SuperSocket.Facility.Net35.csproj
@@ -55,9 +55,6 @@
     <Compile Include="..\Solution Items\GlobalAssemblyInfo.cs">
       <Link>GlobalAssemblyInfo.cs</Link>
     </Compile>
-    <Compile Include="HttpBase\HttpReceiveFilterBase.cs" />
-    <Compile Include="HttpBase\HttpRequestInfoBase.cs" />
-    <Compile Include="HttpBase\MimeHeaderHelper.cs" />
     <Compile Include="PolicyServer\FlashPolicyServer.cs" />
     <Compile Include="PolicyServer\PolicyReceiveFilter.cs" />
     <Compile Include="PolicyServer\PolicyReceiveFilterFactory.cs" />
diff --git a/Facility/SuperSocket.Facility.Net40.csproj b/Facility/SuperSocket.Facility.Net40.csproj
index e3c962ee8..2d95084f6 100644
--- a/Facility/SuperSocket.Facility.Net40.csproj
+++ b/Facility/SuperSocket.Facility.Net40.csproj
@@ -51,9 +51,6 @@
     <Compile Include="..\Solution Items\GlobalAssemblyInfo.cs">
       <Link>GlobalAssemblyInfo.cs</Link>
     </Compile>
-    <Compile Include="HttpBase\HttpReceiveFilterBase.cs" />
-    <Compile Include="HttpBase\HttpRequestInfoBase.cs" />
-    <Compile Include="HttpBase\MimeHeaderHelper.cs" />
     <Compile Include="PolicyServer\FlashPolicyServer.cs" />
     <Compile Include="PolicyServer\PolicyReceiveFilter.cs" />
     <Compile Include="PolicyServer\PolicyReceiveFilterFactory.cs" />
diff --git a/Facility/SuperSocket.Facility.Net45.csproj b/Facility/SuperSocket.Facility.Net45.csproj
index 067a87a45..12e76901e 100644
--- a/Facility/SuperSocket.Facility.Net45.csproj
+++ b/Facility/SuperSocket.Facility.Net45.csproj
@@ -54,9 +54,6 @@
     <Compile Include="..\Solution Items\GlobalAssemblyInfo.cs">
       <Link>GlobalAssemblyInfo.cs</Link>
     </Compile>
-    <Compile Include="HttpBase\HttpReceiveFilterBase.cs" />
-    <Compile Include="HttpBase\HttpRequestInfoBase.cs" />
-    <Compile Include="HttpBase\MimeHeaderHelper.cs" />
     <Compile Include="PolicyServer\FlashPolicyServer.cs" />
     <Compile Include="PolicyServer\PolicyReceiveFilter.cs" />
     <Compile Include="PolicyServer\PolicyReceiveFilterFactory.cs" />
diff --git a/Push.bat b/Push.bat
index 655830d92..0cca31270 100644
--- a/Push.bat
+++ b/Push.bat
@@ -1,3 +1,3 @@
-git push origin
-git push github
+git push origin v1.5:v1.5
+git push github v1.5:v1.5
 pause
\ No newline at end of file
diff --git a/QuickStart/ServerPush/PushServer.cs b/QuickStart/ServerPush/PushServer.cs
index 1d44d1bed..a5f1523fc 100644
--- a/QuickStart/ServerPush/PushServer.cs
+++ b/QuickStart/ServerPush/PushServer.cs
@@ -11,7 +11,7 @@ public class PushServer : AppServer
     {
         private Timer m_PushTimer;
 
-        private int m_Interval = 60 * 1000 * 5; //5 minutes
+        private int m_Interval = 60 * 1000; //1 minute
 
         protected override void OnStartup()
         {
diff --git a/QuickStart/ServerPush/ServerPush.csproj b/QuickStart/ServerPush/ServerPush.csproj
index c4153745e..da1679858 100644
--- a/QuickStart/ServerPush/ServerPush.csproj
+++ b/QuickStart/ServerPush/ServerPush.csproj
@@ -34,8 +34,6 @@
     <Reference Include="System" />
     <Reference Include="System.Core" />
     <Reference Include="Microsoft.CSharp" />
-    <Reference Include="System.Data" />
-    <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
     <Compile Include="Properties\AssemblyInfo.cs" />
@@ -50,6 +48,19 @@
       <Project>{40b77789-ea11-4c05-8f52-86711d7bcaaf}</Project>
       <Name>SuperSocket.SocketBase.Net40</Name>
     </ProjectReference>
+    <ProjectReference Include="..\..\SocketEngine\SuperSocket.SocketEngine.Net40.csproj">
+      <Project>{153fef72-191c-43d9-be71-2b351c7ac760}</Project>
+      <Name>SuperSocket.SocketEngine.Net40</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\SocketService\SuperSocket.SocketService.Net40.csproj">
+      <Project>{b9113694-7226-4152-938d-3172b11571a1}</Project>
+      <Name>SuperSocket.SocketService.Net40</Name>
+    </ProjectReference>
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="SuperSocket.SocketService.exe.config">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
diff --git a/QuickStart/ServerPush/SuperSocket.SocketService.exe.config b/QuickStart/ServerPush/SuperSocket.SocketService.exe.config
new file mode 100644
index 000000000..c1eccf22f
--- /dev/null
+++ b/QuickStart/ServerPush/SuperSocket.SocketService.exe.config
@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<configuration>
+    <configSections>
+        <section name="superSocket" type="SuperSocket.SocketEngine.Configuration.SocketServiceConfig, SuperSocket.SocketEngine"/>
+    </configSections>
+    <appSettings>
+        <add key="ServiceName" value="PushService"/>
+    </appSettings>
+    <superSocket>
+        <servers>
+            <server name="PushServer"
+                    serverType="SuperSocket.QuickStart.ServerPush.PushServer, SuperSocket.QuickStart.ServerPush"
+                    ip="Any" port="2012">
+            </server>
+        </servers>
+    </superSocket>
+    <startup>
+        <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.0" />
+    </startup>
+    <runtime>
+        <gcServer enabled="true" />
+    </runtime>
+</configuration>
\ No newline at end of file
diff --git a/README.TXT b/README.TXT
index 27c35d788..79030ce44 100644
--- a/README.TXT
+++ b/README.TXT
@@ -3,7 +3,7 @@ SuperSocket
 
 SuperSocket is a light weight extensible socket application framework.
 You can use it to build a command based server side socket application easily without thinking about how to use socket,
-how to maintain the socket connections and how socket works(synchronize/asynchronize).
+how to maintain the socket connections and how socket works.
 
 It is a pure C# project which is designed to be extended, so it is easy to be integrated to your existing system.
 As long as your systems (like forum/CRM/MIS/HRM/ERP) are developed in .NET language,
@@ -11,9 +11,10 @@ you must be able to use SuperSocket to build your socket application as a part o
 
 
 Project homepage:	http://supersocket.codeplex.com/
+Documentation:		http://docs.supersocket.net/
 Git URL:		https://git01.codeplex.com/supersocket
 Author email address:	kerry-jiang@hotmail.com
-
+Releases download:	http://supersocket.codeplex.com/releases/
 
 Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
@@ -25,4 +26,4 @@ Unless required by applicable law or agreed to in writing, software distributed
 See the License for the specific language governing permissions and limitations under the License.
 
 
-Copyright 2012 Kerry Jiang (kerry-jiang@hotmail.com)
\ No newline at end of file
+Copyright 2010-2013 Kerry Jiang (kerry-jiang@hotmail.com)
\ No newline at end of file
diff --git a/Reference/nunit.framework.dll b/Reference/nunit.framework.dll
index 07e4c6eae..6856e51ef 100644
Binary files a/Reference/nunit.framework.dll and b/Reference/nunit.framework.dll differ
diff --git a/SocketBase/AppServerBase.cs b/SocketBase/AppServerBase.cs
index 439808b28..ef0e11b16 100644
--- a/SocketBase/AppServerBase.cs
+++ b/SocketBase/AppServerBase.cs
@@ -632,9 +632,27 @@ bool IWorkItem.Setup(IBootstrap bootstrap, IServerConfig config, ProviderFactory
 
             Logger = CreateLogger(this.Name);
 
+            IEnumerable<IConnectionFilter> connectionFilters = null;
+
+            if (!TryGetProviderInstances(factories, ProviderKey.ConnectionFilter, out connectionFilters,
+                    (p, f) =>
+                    {
+                        var ret = p.Initialize(f.Name, this);
+
+                        if(!ret)
+                        {
+                            Logger.ErrorFormat("Failed to initialize the connection filter: {0}.", f.Name);
+                        }
+
+                        return ret;
+                    }))
+            {
+                return false;
+            }
+
             if (!SetupMedium(
                     GetSingleProviderInstance<IReceiveFilterFactory<TRequestInfo>>(factories, ProviderKey.ReceiveFilterFactory),
-                    GetProviderInstances<IConnectionFilter>(factories, ProviderKey.ConnectionFilter),
+                    connectionFilters,
                     GetProviderInstances<ICommandLoader>(factories, ProviderKey.CommandLoader)))
             {
                 return false;
@@ -664,15 +682,40 @@ private TProvider GetSingleProviderInstance<TProvider>(ProviderFactoryInfo[] fac
             return factory.ExportFactory.CreateExport<TProvider>();
         }
 
-        private IEnumerable<TProvider> GetProviderInstances<TProvider>(ProviderFactoryInfo[] factories, ProviderKey key)
+        private bool TryGetProviderInstances<TProvider>(ProviderFactoryInfo[] factories, ProviderKey key, out IEnumerable<TProvider> providers, Func<TProvider, ProviderFactoryInfo, bool> initializer)
             where TProvider : class
         {
             IEnumerable<ProviderFactoryInfo> selectedFactories = factories.Where(p => p.Key.Name == key.Name);
 
             if (!selectedFactories.Any())
-                return null;
+            {
+                providers = null;
+                return true;
+            }
 
-            return selectedFactories.Select(f => f.ExportFactory.CreateExport<TProvider>());
+            providers = new List<TProvider>();
+
+            var list = (List<TProvider>)providers;
+
+            foreach (var f in selectedFactories)
+            {
+                var provider = f.ExportFactory.CreateExport<TProvider>();
+
+                if (!initializer(provider, f))
+                    return false;
+
+                list.Add(provider);
+            }
+
+            return true;
+        }
+
+        private IEnumerable<TProvider> GetProviderInstances<TProvider>(ProviderFactoryInfo[] factories, ProviderKey key)
+            where TProvider : class
+        {
+            IEnumerable<TProvider> providers;
+            TryGetProviderInstances<TProvider>(factories, key, out providers, (p, f) => true);
+            return providers;
         }
 
         private bool SetupLogFactory(ILogFactory logFactory)
@@ -868,7 +911,7 @@ private bool SetupListeners(IServerConfig config)
                     {
                         SslProtocols configProtocol;
 
-                        if (string.IsNullOrEmpty(l.Security) && BasicSecurity != SslProtocols.None)
+                        if (string.IsNullOrEmpty(l.Security))
                         {
                             configProtocol = BasicSecurity;
                         }
@@ -1240,7 +1283,7 @@ IAppSession IAppServer.CreateAppSession(ISocketSession socketSession)
             if (!RegisterSession(socketSession.SessionID, appSession))
                 return NullAppSession;
 
-            appSession.Initialize(this, socketSession, ReceiveFilterFactory.CreateFilter(this, appSession, socketSession.RemoteEndPoint));
+            appSession.Initialize(this, socketSession);
             socketSession.Closed += OnSocketSessionClosed;
 
             if (Config.LogBasicSessionActivity && Logger.IsInfoEnabled)
@@ -1320,7 +1363,7 @@ public void ResetSessionSecurity(IAppSession session, SslProtocols security)
         private void OnSocketSessionClosed(ISocketSession session, CloseReason reason)
         {
             //Even if LogBasicSessionActivity is false, we also log the unexpected closing because the close reason probably be useful
-            if (Logger.IsInfoEnabled && (Config.LogBasicSessionActivity || (reason != CloseReason.ServerClosing && reason != CloseReason.ClientClosing && reason != CloseReason.ServerShutdown)))
+            if (Logger.IsInfoEnabled && (Config.LogBasicSessionActivity || (reason != CloseReason.ServerClosing && reason != CloseReason.ClientClosing && reason != CloseReason.ServerShutdown && reason != CloseReason.SocketError)))
                 Logger.Info(session, string.Format("This session was closed for {0}!", reason));
 
             var appSession = session.AppSession as TAppSession;
@@ -1466,6 +1509,8 @@ protected virtual void UpdateServerSummary(ServerSummary serverSummary)
 
             serverSummary.RequestHandlingSpeed = ((this.TotalHandledRequests - serverSummary.TotalHandledRequests) / now.Subtract(serverSummary.CollectedTime).TotalSeconds);
             serverSummary.TotalHandledRequests = this.TotalHandledRequests;
+            serverSummary.AvialableSendingQueueItems = m_SocketServer.SendingQueuePool.AvialableItemsCount;
+            serverSummary.TotalSendingQueueItems = m_SocketServer.SendingQueuePool.TotalItemsCount;
 
             serverSummary.CollectedTime = now;
         }
diff --git a/SocketBase/AppSession.cs b/SocketBase/AppSession.cs
index 5e3e01b5b..94509bf70 100644
--- a/SocketBase/AppSession.cs
+++ b/SocketBase/AppSession.cs
@@ -181,14 +181,19 @@ public AppSession()
         /// </summary>
         /// <param name="appServer">The app server.</param>
         /// <param name="socketSession">The socket session.</param>
-        /// <param name="receiveFilter">The receive filter.</param>
-        public virtual void Initialize(IAppServer<TAppSession, TRequestInfo> appServer, ISocketSession socketSession, IReceiveFilter<TRequestInfo> receiveFilter)
+        public virtual void Initialize(IAppServer<TAppSession, TRequestInfo> appServer, ISocketSession socketSession)
         {
-            AppServer = (AppServerBase<TAppSession, TRequestInfo>)appServer;
+            var castedAppServer = (AppServerBase<TAppSession, TRequestInfo>)appServer;
+            AppServer = castedAppServer;
             SocketSession = socketSession;
             SessionID = socketSession.SessionID;
             m_Connected = true;
-            m_ReceiveFilter = receiveFilter;
+            m_ReceiveFilter = castedAppServer.ReceiveFilterFactory.CreateFilter(appServer, this, socketSession.RemoteEndPoint);
+
+            var filterInitializer = m_ReceiveFilter as IReceiveFilterInitializer;
+            if (filterInitializer != null)
+                filterInitializer.Initialize(castedAppServer, this);
+
             OnInit();
         }
 
@@ -341,13 +346,8 @@ public virtual void SendResponse(byte[] data, int offset, int length)
             Send(data, offset, length);
         }
 
-        private const string CANNOT_SEND_NOT_CONNECTED = "You cannot send data any more, because this session is not connected.";
-
         private bool InternalTrySend(ArraySegment<byte> segment)
         {
-            if (!m_Connected)
-                throw new Exception(CANNOT_SEND_NOT_CONNECTED);
-
             if (!SocketSession.TrySend(segment))
                 return false;
 
@@ -362,12 +362,18 @@ private bool InternalTrySend(ArraySegment<byte> segment)
         /// <returns>Indicate whether the message was pushed into the sending queue</returns>
         public virtual bool TrySend(ArraySegment<byte> segment)
         {
+            if (!m_Connected)
+                return false;
+
             return InternalTrySend(segment);
         }
 
 
         private void InternalSend(ArraySegment<byte> segment)
         {
+            if (!m_Connected)
+                return;
+
             if (InternalTrySend(segment))
                 return;
 
@@ -395,7 +401,7 @@ public virtual void Send(ArraySegment<byte> segment)
         /// Sends the response.
         /// </summary>
         /// <param name="segment">The segment which will be sent.</param>
-        /// <returns>Indicate whether the message was pushed into the sending queue</returns>
+        /// <returns>Indicate whether the message was pushed into the sending queue; if it returns false, the sending queue may be full or the socket is not connected</returns>
         [Obsolete("Use 'Send(ArraySegment<byte> segment)' instead")]
         public virtual void SendResponse(ArraySegment<byte> segment)
         {
@@ -405,9 +411,6 @@ public virtual void SendResponse(ArraySegment<byte> segment)
 
         private bool InternalTrySend(IList<ArraySegment<byte>> segments)
         {
-            if (!m_Connected)
-                throw new Exception(CANNOT_SEND_NOT_CONNECTED);
-
             if (!SocketSession.TrySend(segments))
                 return false;
 
@@ -419,14 +422,20 @@ private bool InternalTrySend(IList<ArraySegment<byte>> segments)
         /// Try to send the data segments to clinet.
         /// </summary>
         /// <param name="segments">The segments.</param>
-        /// <returns>Indicate whether the message was pushed into the sending queue</returns>
+        /// <returns>Indicate whether the message was pushed into the sending queue; if it returns false, the sending queue may be full or the socket is not connected</returns>
         public virtual bool TrySend(IList<ArraySegment<byte>> segments)
         {
+            if (!m_Connected)
+                return false;
+
             return InternalTrySend(segments);
         }
 
         private void InternalSend(IList<ArraySegment<byte>> segments)
         {
+            if (!m_Connected)
+                return;
+
             if (InternalTrySend(segments))
                 return;
 
diff --git a/SocketBase/Config/CommandAssemblyConfig.cs b/SocketBase/Config/CommandAssemblyConfig.cs
index 1b61b79a8..01b24f83c 100644
--- a/SocketBase/Config/CommandAssemblyConfig.cs
+++ b/SocketBase/Config/CommandAssemblyConfig.cs
@@ -8,6 +8,7 @@ namespace SuperSocket.SocketBase.Config
     /// <summary>
     /// Command assembly config
     /// </summary>
+    [Serializable]
     public class CommandAssemblyConfig : ICommandAssemblyConfig
     {
         /// <summary>
diff --git a/SocketBase/Config/ServerConfig.cs b/SocketBase/Config/ServerConfig.cs
index feb7e463b..17a90dc60 100644
--- a/SocketBase/Config/ServerConfig.cs
+++ b/SocketBase/Config/ServerConfig.cs
@@ -36,6 +36,16 @@ public class ServerConfig : IServerConfig
         /// </summary>
         public const int DefaultMaxRequestLength = 1024;
 
+        /// <summary>
+        /// Default clear idle session interval
+        /// </summary>
+        public const int DefaultClearIdleSessionInterval = 120;
+
+        /// <summary>
+        /// Default idle session timeout
+        /// </summary>
+        public const int DefaultIdleSessionTimeOut = 300;
+
         /// <summary>
         /// Initializes a new instance of the <see cref="ServerConfig"/> class.
         /// </summary>
@@ -52,12 +62,12 @@ public ServerConfig(IServerConfig serverConfig)
 
             if (serverConfig.Listeners != null && serverConfig.Listeners.Any())
             {
-                this.Listeners = serverConfig.Listeners.Select(l => l.CopyPropertiesTo(new ListenerConfig()));
+                this.Listeners = serverConfig.Listeners.Select(l => l.CopyPropertiesTo(new ListenerConfig())).OfType<ListenerConfig>().ToArray();
             }
 
             if (serverConfig.CommandAssemblies != null && serverConfig.CommandAssemblies.Any())
             {
-                this.CommandAssemblies = serverConfig.CommandAssemblies.Select(c => c.CopyPropertiesTo(new CommandAssemblyConfig()));
+                this.CommandAssemblies = serverConfig.CommandAssemblies.Select(c => c.CopyPropertiesTo(new CommandAssemblyConfig())).OfType<CommandAssemblyConfig>().ToArray();
             }
         }
 
@@ -75,6 +85,8 @@ public ServerConfig()
             ListenBacklog = 100;
             ReceiveBufferSize = DefaultReceiveBufferSize;
             SendingQueueSize = DefaultSendingQueueSize;
+            ClearIdleSessionInterval = DefaultClearIdleSessionInterval;
+            IdleSessionTimeOut = DefaultIdleSessionTimeOut;
         }
 
         #region IServerConfig Members
diff --git a/SocketBase/IAppSession.cs b/SocketBase/IAppSession.cs
index 11543479c..a08a757c5 100644
--- a/SocketBase/IAppSession.cs
+++ b/SocketBase/IAppSession.cs
@@ -130,7 +130,6 @@ public interface IAppSession<TAppSession, TRequestInfo> : IAppSession
         /// </summary>
         /// <param name="server">The server.</param>
         /// <param name="socketSession">The socket session.</param>
-        /// <param name="requestFilter">The Receive filter.</param>
-        void Initialize(IAppServer<TAppSession, TRequestInfo> server, ISocketSession socketSession, IReceiveFilter<TRequestInfo> requestFilter);
+        void Initialize(IAppServer<TAppSession, TRequestInfo> server, ISocketSession socketSession);
     }
 }
diff --git a/SocketBase/ISocketServer.cs b/SocketBase/ISocketServer.cs
index 49b8b1b8a..93eb882e6 100644
--- a/SocketBase/ISocketServer.cs
+++ b/SocketBase/ISocketServer.cs
@@ -3,6 +3,7 @@
 using System.Linq;
 using System.Text;
 using System.Security.Authentication;
+using SuperSocket.Common;
 
 namespace SuperSocket.SocketBase
 {
@@ -32,6 +33,14 @@ public interface ISocketServer
         /// </value>
         bool IsRunning { get; }
 
+        /// <summary>
+        /// Gets the information of the sending queue pool.
+        /// </summary>
+        /// <value>
+        /// The sending queue pool.
+        /// </value>
+        IPoolInfo SendingQueuePool { get; }
+
         /// <summary>
         /// Stops this instance.
         /// </summary>
diff --git a/SocketBase/ISocketSession.cs b/SocketBase/ISocketSession.cs
index aa35bd735..6718c637d 100644
--- a/SocketBase/ISocketSession.cs
+++ b/SocketBase/ISocketSession.cs
@@ -13,52 +13,52 @@ namespace SuperSocket.SocketBase
     /// <summary>
     /// CloseReason enum
     /// </summary>
-    public enum CloseReason
+    public enum CloseReason : int
     {
+        /// <summary>
+        /// The socket is closed for unknown reason
+        /// </summary>
+        Unknown = 0,
+
         /// <summary>
         /// Close for server shutdown
         /// </summary>
-        ServerShutdown,
+        ServerShutdown = 1,
 
         /// <summary>
         /// The client close the socket
         /// </summary>
-        ClientClosing,
+        ClientClosing = 2,
 
         /// <summary>
         /// The server side close the socket
         /// </summary>
-        ServerClosing,
+        ServerClosing = 3,
 
         /// <summary>
         /// Application error
         /// </summary>
-        ApplicationError,
+        ApplicationError = 4,
 
         /// <summary>
         /// The socket is closed for a socket error
         /// </summary>
-        SocketError,
+        SocketError = 5,
 
         /// <summary>
         /// The socket is closed by server for timeout
         /// </summary>
-        TimeOut,
+        TimeOut = 6,
 
         /// <summary>
         /// Protocol error 
         /// </summary>
-        ProtocolError,
+        ProtocolError = 7,
 
         /// <summary>
         /// SuperSocket internal error
         /// </summary>
-        InternalError,
-
-        /// <summary>
-        /// The socket is closed for unknown reason
-        /// </summary>
-        Unknown
+        InternalError = 8,
     }
 
     /// <summary>
@@ -128,5 +128,14 @@ public interface ISocketSession : ISessionBase
         /// Gets the app session assosiated with this socket session.
         /// </summary>
         IAppSession AppSession { get; }
+
+
+        /// <summary>
+        /// Gets the original receive buffer offset.
+        /// </summary>
+        /// <value>
+        /// The original receive buffer offset.
+        /// </value>
+        int OrigReceiveOffset { get; }
     }
 }
diff --git a/SocketBase/LoggerExtension.cs b/SocketBase/LoggerExtension.cs
index 98fab2faf..63dccfb05 100644
--- a/SocketBase/LoggerExtension.cs
+++ b/SocketBase/LoggerExtension.cs
@@ -14,17 +14,6 @@ public static class LoggerExtension
     {
         private readonly static string m_SessionInfoTemplate = "Session: {0}/{1}";
 
-        /// <summary>
-        /// Logs the error
-        /// </summary>
-        /// <param name="logger">The logger.</param>
-        /// <param name="session">The session.</param>
-        /// <param name="e">The e.</param>
-        public static void Error(this ILog logger, ISessionBase session, Exception e)
-        {
-            logger.Error(string.Format(m_SessionInfoTemplate, session.SessionID, session.RemoteEndPoint), e);
-        }
-
         /// <summary>
         /// Logs the error
         /// </summary>
diff --git a/SocketBase/Logging/LogFactoryBase.cs b/SocketBase/Logging/LogFactoryBase.cs
index 19a23f087..2ce2c7bbe 100644
--- a/SocketBase/Logging/LogFactoryBase.cs
+++ b/SocketBase/Logging/LogFactoryBase.cs
@@ -16,13 +16,8 @@ public abstract class LogFactoryBase : ILogFactory
         /// Gets the config file file path.
         /// </summary>
         protected string ConfigFile { get; private set; }
-
-        /// <summary>
-        /// Gets a value indicating whether this instance is isolated.
-        /// </summary>
-        /// <value>
-        /// <c>true</c> if this instance is isolated; otherwise, <c>false</c>.
-        /// </value>
+        
+		/// Gets a value indicating whether the server instance is running in isolation mode and the multiple server instances share the same logging configuration.
         protected bool IsSharedConfig { get; private set; }
 
         /// <summary>
@@ -42,7 +37,15 @@ protected LogFactoryBase(string configFile)
                 configFile = Path.GetFileNameWithoutExtension(configFile) + ".unix" + Path.GetExtension(configFile);
             }
 
-            if (AppDomain.CurrentDomain.IsDefaultAppDomain())
+            var currentAppDomain = AppDomain.CurrentDomain;
+            var isolation = IsolationMode.None;
+
+            var isolationValue = currentAppDomain.GetData(typeof(IsolationMode).Name);
+
+            if (isolationValue != null)
+                isolation = (IsolationMode)isolationValue;
+
+            if (isolation == IsolationMode.None)
             {
                 var filePath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, configFile);
 
diff --git a/SocketBase/Protocol/IReceiveFilterInitializer.cs b/SocketBase/Protocol/IReceiveFilterInitializer.cs
new file mode 100644
index 000000000..eb73c43f4
--- /dev/null
+++ b/SocketBase/Protocol/IReceiveFilterInitializer.cs
@@ -0,0 +1,20 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace SuperSocket.SocketBase.Protocol
+{
+    /// <summary>
+    /// Provide the initializing interface for ReceiveFilter
+    /// </summary>
+    public interface IReceiveFilterInitializer
+    {
+        /// <summary>
+        /// Initializes the ReceiveFilter with the specified appServer and appSession
+        /// </summary>
+        /// <param name="appServer">The app server.</param>
+        /// <param name="session">The session.</param>
+        void Initialize(IAppServer appServer, IAppSession session);
+    }
+}
diff --git a/SocketBase/Protocol/TerminatorReceiveFilter.cs b/SocketBase/Protocol/TerminatorReceiveFilter.cs
index 7803bdb87..3d9cb55df 100644
--- a/SocketBase/Protocol/TerminatorReceiveFilter.cs
+++ b/SocketBase/Protocol/TerminatorReceiveFilter.cs
@@ -10,12 +10,12 @@ namespace SuperSocket.SocketBase.Protocol
     /// Terminator Receive filter
     /// </summary>
     /// <typeparam name="TRequestInfo">The type of the request info.</typeparam>
-    public abstract class TerminatorReceiveFilter<TRequestInfo> : ReceiveFilterBase<TRequestInfo>, IOffsetAdapter
+    public abstract class TerminatorReceiveFilter<TRequestInfo> : ReceiveFilterBase<TRequestInfo>, IOffsetAdapter, IReceiveFilterInitializer
         where TRequestInfo : IRequestInfo
     {
         private readonly SearchMarkState<byte> m_SearchState;
 
-        private readonly IAppSession m_Session;
+        private IAppSession m_Session;
 
         /// <summary>
         /// Gets the session assosiated with the Receive filter.
@@ -35,14 +35,17 @@ protected IAppSession Session
         /// <summary>
         /// Initializes a new instance of the <see cref="TerminatorReceiveFilter&lt;TRequestInfo&gt;"/> class.
         /// </summary>
-        /// <param name="session">The session.</param>
         /// <param name="terminator">The terminator.</param>
-        protected TerminatorReceiveFilter(IAppSession session, byte[] terminator)
+        protected TerminatorReceiveFilter(byte[] terminator)
         {
-            m_Session = session;
             m_SearchState = new SearchMarkState<byte>(terminator);
         }
 
+        void IReceiveFilterInitializer.Initialize(IAppServer appServer, IAppSession session)
+        {
+            m_Session = session;
+        }
+
         /// <summary>
         /// Filters received data of the specific session into request info.
         /// </summary>
@@ -138,6 +141,11 @@ public override TRequestInfo Filter(byte[] readBuffer, int offset, int length, b
             {
                 if (this.BufferSegments != null && this.BufferSegments.Count > 0)
                 {
+                    if (m_ParsedLengthInBuffer > 0)
+                    {
+                        this.BufferSegments.AddSegment(readBuffer, offset, m_ParsedLengthInBuffer);
+                    }
+
                     requestInfo = ProcessMatchedRequest(BufferSegments, 0, BufferSegments.Count);
                 }
                 else
@@ -212,23 +220,21 @@ public class TerminatorReceiveFilter : TerminatorReceiveFilter<StringRequestInfo
         /// <summary>
         /// Initializes a new instance of the <see cref="TerminatorReceiveFilter"/> class.
         /// </summary>
-        /// <param name="session">The session.</param>
         /// <param name="terminator">The terminator.</param>
         /// <param name="encoding">The encoding.</param>
-        public TerminatorReceiveFilter(IAppSession session, byte[] terminator, Encoding encoding)
-            : this(session, terminator, encoding, BasicRequestInfoParser.DefaultInstance)
+        public TerminatorReceiveFilter(byte[] terminator, Encoding encoding)
+            : this(terminator, encoding, BasicRequestInfoParser.DefaultInstance)
         {
             
         }
         /// <summary>
         /// Initializes a new instance of the <see cref="TerminatorReceiveFilter"/> class.
         /// </summary>
-        /// <param name="session">The session.</param>
         /// <param name="terminator">The terminator.</param>
         /// <param name="encoding">The encoding.</param>
         /// <param name="requestParser">The request parser.</param>
-        public TerminatorReceiveFilter(IAppSession session, byte[] terminator, Encoding encoding, IRequestInfoParser<StringRequestInfo> requestParser)
-            : base(session, terminator)
+        public TerminatorReceiveFilter(byte[] terminator, Encoding encoding, IRequestInfoParser<StringRequestInfo> requestParser)
+            : base(terminator)
         {
             m_Encoding = encoding;
             m_RequestParser = requestParser;
diff --git a/SocketBase/Protocol/TerminatorReceiveFilterFactory.cs b/SocketBase/Protocol/TerminatorReceiveFilterFactory.cs
index 9264f2a34..e049747fa 100644
--- a/SocketBase/Protocol/TerminatorReceiveFilterFactory.cs
+++ b/SocketBase/Protocol/TerminatorReceiveFilterFactory.cs
@@ -60,7 +60,7 @@ public TerminatorReceiveFilterFactory(string terminator, Encoding encoding, IReq
         /// </returns>
         public virtual IReceiveFilter<StringRequestInfo> CreateFilter(IAppServer appServer, IAppSession appSession, IPEndPoint remoteEndPoint)
         {
-            return new TerminatorReceiveFilter(appSession, m_Terminator, m_Encoding, m_RequestInfoParser);
+            return new TerminatorReceiveFilter(m_Terminator, m_Encoding, m_RequestInfoParser);
         }
     }
 }
diff --git a/SocketBase/ServerSummary.cs b/SocketBase/ServerSummary.cs
index d12bc41d5..a10056098 100644
--- a/SocketBase/ServerSummary.cs
+++ b/SocketBase/ServerSummary.cs
@@ -90,5 +90,24 @@ public class ServerSummary
         /// </value>
         [Display("Listeners", Order = 6, OutputInPerfLog = false)]
         public ListenerInfo[] Listeners { get; set; }
+
+
+        /// <summary>
+        /// Gets or sets the avialable sending queue items.
+        /// </summary>
+        /// <value>
+        /// The avialable sending queue items.
+        /// </value>
+        [Display("Avialable Sending Queue Items", Format = "{0:N0}", Order = 7)]
+        public int AvialableSendingQueueItems { get; set; }
+
+        /// <summary>
+        /// Gets or sets the total sending queue items.
+        /// </summary>
+        /// <value>
+        /// The total sending queue items.
+        /// </value>
+        [Display("Total Sending Queue Items", Format = "{0:N0}", Order = 8)]
+        public int TotalSendingQueueItems { get; set; }
     }
 }
diff --git a/SocketBase/SuperSocket.SocketBase.Net35.csproj b/SocketBase/SuperSocket.SocketBase.Net35.csproj
index ced16a856..f6b2075bd 100644
--- a/SocketBase/SuperSocket.SocketBase.Net35.csproj
+++ b/SocketBase/SuperSocket.SocketBase.Net35.csproj
@@ -122,6 +122,7 @@
     <Compile Include="Protocol\IOffsetAdapter.cs" />
     <Compile Include="Protocol\IReceiveFilter.cs" />
     <Compile Include="Protocol\IReceiveFilterFactory.cs" />
+    <Compile Include="Protocol\IReceiveFilterInitializer.cs" />
     <Compile Include="Protocol\IRequestInfo.cs" />
     <Compile Include="Protocol\IRequestInfoParser.cs" />
     <Compile Include="Protocol\ReceiveFilterBase.cs" />
diff --git a/SocketBase/SuperSocket.SocketBase.Net40.csproj b/SocketBase/SuperSocket.SocketBase.Net40.csproj
index bdc65b6bd..9551ff91d 100644
--- a/SocketBase/SuperSocket.SocketBase.Net40.csproj
+++ b/SocketBase/SuperSocket.SocketBase.Net40.csproj
@@ -100,6 +100,7 @@
     <Compile Include="Logging\Log4NetLogFactory.cs" />
     <Compile Include="Logging\LogFactoryBase.cs" />
     <Compile Include="Protocol\FilterState.cs" />
+    <Compile Include="Protocol\IReceiveFilterInitializer.cs" />
     <Compile Include="Protocol\IOffsetAdapter.cs" />
     <Compile Include="Protocol\TerminatorReceiveFilterFactory.cs" />
     <Compile Include="Provider\ExportFactory.cs" />
diff --git a/SocketBase/SuperSocket.SocketBase.Net45.csproj b/SocketBase/SuperSocket.SocketBase.Net45.csproj
index dc674b9f9..13766b658 100644
--- a/SocketBase/SuperSocket.SocketBase.Net45.csproj
+++ b/SocketBase/SuperSocket.SocketBase.Net45.csproj
@@ -109,6 +109,7 @@
     <Compile Include="Protocol\IOffsetAdapter.cs" />
     <Compile Include="Protocol\IReceiveFilter.cs" />
     <Compile Include="Protocol\IReceiveFilterFactory.cs" />
+    <Compile Include="Protocol\IReceiveFilterInitializer.cs" />
     <Compile Include="Protocol\ReceiveFilterBase.cs" />
     <Compile Include="Protocol\TerminatorReceiveFilter.cs" />
     <Compile Include="Protocol\TerminatorReceiveFilterFactory.cs" />
diff --git a/SocketEngine/AppDomainAppServer.cs b/SocketEngine/AppDomainAppServer.cs
index 6a635e9df..f6329cca4 100644
--- a/SocketEngine/AppDomainAppServer.cs
+++ b/SocketEngine/AppDomainAppServer.cs
@@ -111,6 +111,8 @@ public bool Start()
                         null,
                         new object[0]);
 
+                m_HostDomain.SetData(typeof(IsolationMode).Name, IsolationMode.AppDomain);
+
                 m_AppServer = (IWorkItem)m_HostDomain.CreateInstanceAndUnwrap(marshalServerType.Assembly.FullName,
                         marshalServerType.FullName,
                         true,
diff --git a/SocketEngine/AsyncSocket/SocketAsyncEventArgsProxy.cs b/SocketEngine/AsyncSocket/SocketAsyncEventArgsProxy.cs
index 51c18ca96..df73667c9 100644
--- a/SocketEngine/AsyncSocket/SocketAsyncEventArgsProxy.cs
+++ b/SocketEngine/AsyncSocket/SocketAsyncEventArgsProxy.cs
@@ -12,6 +12,8 @@ class SocketAsyncEventArgsProxy
     {
         public SocketAsyncEventArgs SocketEventArgs { get; private set; }
 
+        public int OrigOffset { get; private set; }
+
         private SocketAsyncEventArgsProxy()
         {
 
@@ -20,6 +22,7 @@ private SocketAsyncEventArgsProxy()
         public SocketAsyncEventArgsProxy(SocketAsyncEventArgs socketEventArgs)
         {
             SocketEventArgs = socketEventArgs;
+            OrigOffset = socketEventArgs.Offset;
             SocketEventArgs.Completed += new EventHandler<SocketAsyncEventArgs>(SocketEventArgs_Completed);
         }
 
diff --git a/SocketEngine/AsyncSocketServer.cs b/SocketEngine/AsyncSocketServer.cs
index 1d0fa8637..5fc409640 100644
--- a/SocketEngine/AsyncSocketServer.cs
+++ b/SocketEngine/AsyncSocketServer.cs
@@ -133,12 +133,19 @@ public override void ResetSessionSecurity(IAppSession session, SslProtocols secu
         void SessionClosed(ISocketSession session, CloseReason reason)
         {
             var socketSession = session as IAsyncSocketSessionBase;
+
             if (socketSession != null && this.m_ReadWritePool != null)
             {
-                socketSession.SocketAsyncProxy.Reset();
+                var proxy = socketSession.SocketAsyncProxy;
+                proxy.Reset();
+
+                if (proxy.OrigOffset != proxy.SocketEventArgs.Offset)
+                {
+                    proxy.SocketEventArgs.SetBuffer(proxy.OrigOffset, AppServer.Config.ReceiveBufferSize);
+                }
 
                 if (m_ReadWritePool != null)
-                    m_ReadWritePool.Push(socketSession.SocketAsyncProxy);
+                    m_ReadWritePool.Push(proxy);
             }
         }
 
diff --git a/SocketEngine/AsyncSocketSession.cs b/SocketEngine/AsyncSocketSession.cs
index d349eb0f3..2ef8e054e 100644
--- a/SocketEngine/AsyncSocketSession.cs
+++ b/SocketEngine/AsyncSocketSession.cs
@@ -21,8 +21,6 @@ class AsyncSocketSession : SocketSession, IAsyncSocketSession
 
         private SocketAsyncEventArgs m_SocketEventArgSend;
 
-        private int m_OrigOffset;
-
         public AsyncSocketSession(Socket client, SocketAsyncEventArgsProxy socketAsyncProxy)
             : this(client, socketAsyncProxy, false)
         {
@@ -33,7 +31,6 @@ public AsyncSocketSession(Socket client, SocketAsyncEventArgsProxy socketAsyncPr
             : base(client)
         {
             SocketAsyncProxy = socketAsyncProxy;
-            m_OrigOffset = socketAsyncProxy.SocketEventArgs.Offset;
             m_IsReset = isReset;
         }
 
@@ -60,59 +57,49 @@ public override void Start()
 
         bool ProcessCompleted(SocketAsyncEventArgs e)
         {
-            // check if the remote host closed the connection
-            if (e.BytesTransferred <= 0)
+            if (e.SocketError == SocketError.Success)
             {
-                Close(CloseReason.ClientClosing);
-                return false;
-            }
-
-            if (e.SocketError != SocketError.Success)
-            {
-                if (Config.LogAllSocketException ||
-                        (e.SocketError != SocketError.ConnectionAborted
-                            && e.SocketError != SocketError.ConnectionReset
-                            && e.SocketError != SocketError.Interrupted
-                            && e.SocketError != SocketError.Shutdown))
+                if (e.BytesTransferred > 0)
                 {
-                    AppSession.Logger.Error(AppSession, new SocketException((int)e.SocketError));
+                    return true;
                 }
-
-                Close(CloseReason.SocketError);
-                return false;
+            }
+            else
+            {
+                LogError((int)e.SocketError);
             }
 
-            return true;
+            return false;
         }
 
         void OnSendingCompleted(object sender, SocketAsyncEventArgs e)
         {
+            var queue = e.UserToken as SendingQueue;
+
             if (!ProcessCompleted(e))
+            {
+                ClearPrevSendState(e);
+                OnSendError(queue, CloseReason.SocketError);
                 return;
+            }
 
-            var queue = e.UserToken as SendingQueue;
-            e.UserToken = null;
-
+            ClearPrevSendState(e);
             base.OnSendingCompleted(queue);
         }
 
-        private bool IsIgnorableException(Exception e)
+        private void ClearPrevSendState(SocketAsyncEventArgs e)
         {
-            if (e is ObjectDisposedException || e is NullReferenceException)
-                return true;
+            e.UserToken = null;
 
-            if (e is SocketException)
+            //Clear previous sending buffer of sae to avoid memory leak
+            if (e.Buffer != null)
             {
-                if (Config.LogAllSocketException)
-                    return false;
-
-                var se = e as SocketException;
-
-                if (se.ErrorCode == 10004 || se.ErrorCode == 10053 || se.ErrorCode == 10054 || se.ErrorCode == 10058)
-                    return true;
+                e.SetBuffer(null, 0, 0);
+            }
+            else if (e.BufferList != null)
+            {
+                e.BufferList = null;
             }
-
-            return false;
         }
 
         private void StartReceive(SocketAsyncEventArgs e)
@@ -122,9 +109,6 @@ private void StartReceive(SocketAsyncEventArgs e)
 
         private void StartReceive(SocketAsyncEventArgs e, int offsetDelta)
         {
-            if (IsClosed)
-                return;
-
             bool willRaiseEvent = false;
 
             try
@@ -132,21 +116,24 @@ private void StartReceive(SocketAsyncEventArgs e, int offsetDelta)
                 if (offsetDelta < 0 || offsetDelta >= Config.ReceiveBufferSize)
                     throw new ArgumentException(string.Format("Illigal offsetDelta: {0}", offsetDelta), "offsetDelta");
 
-                var predictOffset = m_OrigOffset + offsetDelta;
+                var predictOffset = SocketAsyncProxy.OrigOffset + offsetDelta;
 
                 if (e.Offset != predictOffset)
                 {
                     e.SetBuffer(predictOffset, Config.ReceiveBufferSize - offsetDelta);
                 }
 
+                if (IsInClosingOrClosed)
+                    return;
+
+                OnReceiveStarted();
                 willRaiseEvent = Client.ReceiveAsync(e);
             }
             catch (Exception exc)
             {
-                if (!IsIgnorableException(exc))
-                    AppSession.Logger.Error(AppSession, exc);
+                LogError(exc);
 
-                Close(CloseReason.SocketError);
+                OnReceiveError(CloseReason.SocketError);
                 return;
             }
 
@@ -171,17 +158,16 @@ protected override void SendSync(SendingQueue queue)
 
                     client.Send(item.Array, item.Offset, item.Count, SocketFlags.None);
                 }
+
+                OnSendingCompleted(queue);
             }
             catch (Exception e)
             {
-                if (!IsIgnorableException(e))
-                    AppSession.Logger.Error(AppSession, e);
+                LogError(e);
 
-                Close(CloseReason.SocketError);
+                OnSendError(queue, CloseReason.SocketError);
                 return;
             }
-
-            OnSendingCompleted(queue);
         }
 
         protected override void SendAsync(SendingQueue queue)
@@ -189,79 +175,46 @@ protected override void SendAsync(SendingQueue queue)
             try
             {
                 m_SocketEventArgSend.UserToken = queue;
-                m_SocketEventArgSend.BufferList = queue;
+
+                if (queue.Count > 1)
+                    m_SocketEventArgSend.BufferList = queue;
+                else
+                {
+                    var item = queue[0];
+                    m_SocketEventArgSend.SetBuffer(item.Array, item.Offset, item.Count);
+                }
 
                 var client = Client;
 
                 if (client == null)
+                {
+                    OnSendError(queue, CloseReason.SocketError);
                     return;
+                }
 
                 if (!client.SendAsync(m_SocketEventArgSend))
                     OnSendingCompleted(client, m_SocketEventArgSend);
             }
             catch (Exception e)
             {
-                if (!IsIgnorableException(e))
-                    AppSession.Logger.Error(AppSession, e);
+                LogError(e);
 
-                Close(CloseReason.SocketError);
+                ClearPrevSendState(m_SocketEventArgSend);
+                OnSendError(queue, CloseReason.SocketError);
             }
         }
 
-        //protected override void SendAsync(IPosList<ArraySegment<byte>> queue)
-        //{
-        //    try
-        //    {
-        //        if (queue.Count > 1)
-        //        {
-        //            if (m_SocketEventArgSend.Buffer != null)
-        //                m_SocketEventArgSend.SetBuffer(null, 0, 0);
-
-        //            m_SocketEventArgSend.BufferList = items;
-        //        }
-        //        else
-        //        {
-        //            var currentItem = items[0];
-
-        //            try
-        //            {
-        //                if (m_SocketEventArgSend.BufferList != null)
-        //                    m_SocketEventArgSend.BufferList = null;
-        //            }//Supress this exception
-        //            catch (Exception) //a strange NullReference exception
-        //            {
-        //                //if (AppSession.Logger.IsErrorEnabled)
-        //                //    AppSession.Logger.Error(AppSession, e);
-        //            }
-        //            finally
-        //            {
-        //                m_SocketEventArgSend.SetBuffer(currentItem.Array, 0, currentItem.Count);
-        //            }
-        //        }
-
-        //        var client = Client;
-
-        //        if (client == null)
-        //            return;
-
-        //        if (!client.SendAsync(m_SocketEventArgSend))
-        //            OnSendingCompleted(client, m_SocketEventArgSend);
-        //    }
-        //    catch (Exception e)
-        //    {
-        //        if (!IsIgnorableException(e))
-        //            AppSession.Logger.Error(AppSession, e);
-
-        //        Close(CloseReason.SocketError);
-        //    }
-        //}
-
         public SocketAsyncEventArgsProxy SocketAsyncProxy { get; private set; }
 
         public void ProcessReceive(SocketAsyncEventArgs e)
         {
             if (!ProcessCompleted(e))
+            {
+                OnReceiveError(CloseReason.ClientClosing);
                 return;
+            }
+
+            OnReceiveEnded();
 
             int offsetDelta;
 
@@ -271,7 +224,7 @@ public void ProcessReceive(SocketAsyncEventArgs e)
             }
             catch (Exception exc)
             {
-                AppSession.Logger.Error(AppSession, "protocol error", exc);
+                LogError("Protocol error", exc);
                 this.Close(CloseReason.ProtocolError);
                 return;
             }
@@ -285,12 +238,9 @@ public override void ApplySecureProtocol()
             //TODO: Implement async socket SSL/TLS encryption
         }
 
-        protected override void OnClose(CloseReason reason)
+        public override int OrigReceiveOffset
         {
-            if (m_OrigOffset != SocketAsyncProxy.SocketEventArgs.Offset)
-                SocketAsyncProxy.SocketEventArgs.SetBuffer(m_OrigOffset, Config.ReceiveBufferSize);
-
-            base.OnClose(reason);
+            get { return SocketAsyncProxy.OrigOffset; }
         }
     }
 }
diff --git a/SocketEngine/AsyncStreamSocketSession.cs b/SocketEngine/AsyncStreamSocketSession.cs
index 6903a6bc2..bb0f81808 100644
--- a/SocketEngine/AsyncStreamSocketSession.cs
+++ b/SocketEngine/AsyncStreamSocketSession.cs
@@ -18,7 +18,6 @@ namespace SuperSocket.SocketEngine
     class AsyncStreamSocketSession : SocketSession, IAsyncSocketSessionBase
     {
         private byte[] m_ReadBuffer;
-        private int m_OrigOffset;
         private int m_Offset;
         private int m_Length;
 
@@ -37,37 +36,12 @@ public AsyncStreamSocketSession(Socket client, SslProtocols security, SocketAsyn
             SocketAsyncProxy = socketAsyncProxy;
             var e = socketAsyncProxy.SocketEventArgs;
             m_ReadBuffer = e.Buffer;
-            m_OrigOffset = m_Offset = e.Offset;
+            m_Offset = e.Offset;
             m_Length = e.Count;
 
             m_IsReset = isReset;
         }
 
-        private bool IsIgnorableException(Exception e)
-        {
-            if (e is ObjectDisposedException)
-                return true;
-
-            if (e is IOException)
-            {
-                if (e.InnerException is ObjectDisposedException)
-                    return true;
-
-                if (e.InnerException is SocketException)
-                {
-                    if (Config.LogAllSocketException)
-                        return false;
-
-                    var se = e.InnerException as SocketException;
-
-                    if (se.ErrorCode == 10004 || se.ErrorCode == 10053 || se.ErrorCode == 10054 || se.ErrorCode == 10058 || se.ErrorCode == -1073741299)
-                        return true;
-                }
-            }
-
-            return false;
-        }
-
         /// <summary>
         /// Starts this session communication.
         /// </summary>
@@ -87,8 +61,7 @@ public override void Start()
             }
             catch (Exception e)
             {
-                if(!IsIgnorableException(e))
-                    AppSession.Logger.Error(AppSession, e);
+                LogError(e);
 
                 Close(CloseReason.SocketError);
                 return;
@@ -99,14 +72,14 @@ private void OnSessionStarting()
         {
             try
             {
+                OnReceiveStarted();
                 m_Stream.BeginRead(m_ReadBuffer, m_Offset, m_Length, OnStreamEndRead, m_Stream);
             }
             catch (Exception e)
             {
-                if (!IsIgnorableException(e))
-                    AppSession.Logger.Error(AppSession, e);
-
-                this.Close(CloseReason.SocketError);
+                LogError(e);
+                OnReceiveError(CloseReason.SocketError);
+                return;
             }
 
             if (!m_IsReset)
@@ -125,19 +98,19 @@ private void OnStreamEndRead(IAsyncResult result)
             }
             catch (Exception e)
             {
-                if (!IsIgnorableException(e))
-                    AppSession.Logger.Error(AppSession, e);
-
-                this.Close(CloseReason.SocketError);
+                LogError(e);
+                OnReceiveError(CloseReason.SocketError);
                 return;
             }
 
             if (thisRead <= 0)
             {
-                this.Close(CloseReason.ClientClosing);
+                OnReceiveError(CloseReason.ClientClosing);
                 return;
             }
 
+            OnReceiveEnded();
+
             int offsetDelta;
 
             try
@@ -146,7 +119,7 @@ private void OnStreamEndRead(IAsyncResult result)
             }
             catch (Exception ex)
             {
-                AppSession.Logger.Error(AppSession, "protocol error", ex);
+                LogError("protocol error", ex);
                 this.Close(CloseReason.ProtocolError);
                 return;
             }
@@ -156,17 +129,16 @@ private void OnStreamEndRead(IAsyncResult result)
                 if (offsetDelta < 0 || offsetDelta >= Config.ReceiveBufferSize)
                     throw new ArgumentException(string.Format("Illigal offsetDelta: {0}", offsetDelta), "offsetDelta");
 
-                m_Offset = m_OrigOffset + offsetDelta;
+                m_Offset = SocketAsyncProxy.OrigOffset + offsetDelta;
                 m_Length = Config.ReceiveBufferSize - offsetDelta;
 
+                OnReceiveStarted();
                 m_Stream.BeginRead(m_ReadBuffer, m_Offset, m_Length, OnStreamEndRead, m_Stream);
             }
             catch (Exception exc)
             {
-                if (!IsIgnorableException(exc))
-                    AppSession.Logger.Error(AppSession, exc);
-
-                this.Close(CloseReason.SocketError);
+                LogError(exc);
+                OnReceiveError(CloseReason.SocketError);
                 return;
             }
         }
@@ -213,11 +185,14 @@ private void OnBeginInitStream(IAsyncResult result)
             {
                 sslStream.EndAuthenticateAsServer(result);
             }
+            catch (IOException)
+            {
+                this.Close(CloseReason.SocketError);
+                return;
+            }
             catch (Exception e)
             {
-                if(!IsIgnorableException(e))
-                    AppSession.Logger.Error(AppSession, e);
-
+                LogError(e);
                 this.Close(CloseReason.SocketError);
                 return;
             }
@@ -234,17 +209,15 @@ protected override void SendSync(SendingQueue queue)
                     var item = queue[i];
                     m_Stream.Write(item.Array, item.Offset, item.Count);
                 }
+
+                OnSendingCompleted(queue);
             }
             catch (Exception e)
             {
-                if (!IsIgnorableException(e))
-                    AppSession.Logger.Error(AppSession, e);
-
-                Close(CloseReason.SocketError);
+                LogError(e);
+                OnSendError(queue, CloseReason.SocketError);
                 return;
             }
-
-            OnSendingCompleted(queue);
         }
 
         protected override void OnSendingCompleted(SendingQueue queue)
@@ -255,10 +228,8 @@ protected override void OnSendingCompleted(SendingQueue queue)
             }
             catch (Exception e)
             {
-                if (!IsIgnorableException(e))
-                    AppSession.Logger.Error(AppSession, e);
-
-                Close(CloseReason.SocketError);
+                LogError(e);
+                OnSendError(queue, CloseReason.SocketError);
                 return;
             }
 
@@ -274,29 +245,26 @@ protected override void SendAsync(SendingQueue queue)
             }
             catch (Exception e)
             {
-                if (!IsIgnorableException(e))
-                    AppSession.Logger.Error(AppSession, e);
-
-                Close(CloseReason.SocketError);
+                LogError(e);
+                OnSendError(queue, CloseReason.SocketError);
             }
         }
 
         private void OnEndWrite(IAsyncResult result)
         {
+            var queue = result.AsyncState as SendingQueue;
+
             try
             {
                 m_Stream.EndWrite(result);
             }
             catch (Exception e)
             {
-                if (!IsIgnorableException(e))
-                    AppSession.Logger.Error(AppSession, e);
-
-                Close(CloseReason.SocketError);
+                LogError(e);
+                OnSendError(queue, CloseReason.SocketError);
                 return;
             }
-
-            var queue = result.AsyncState as SendingQueue;
+            
             var nextPos = queue.Position + 1;
 
             //Has more data to send
@@ -324,5 +292,10 @@ ILog ILoggerProvider.Logger
         {
             get { return AppSession.Logger; }
         }
+
+        public override int OrigReceiveOffset
+        {
+            get { return SocketAsyncProxy.OrigOffset; }
+        }
     }
 }
diff --git a/SocketEngine/Configuration/Listener.cs b/SocketEngine/Configuration/Listener.cs
index 4cca34759..cb7f2f265 100644
--- a/SocketEngine/Configuration/Listener.cs
+++ b/SocketEngine/Configuration/Listener.cs
@@ -43,7 +43,7 @@ public int Backlog
         /// <summary>
         /// Gets the security option, None/Default/Tls/Ssl/...
         /// </summary>
-        [ConfigurationProperty("security", IsRequired = false, DefaultValue = "None")]
+        [ConfigurationProperty("security", IsRequired = false)]
         public string Security
         {
             get
diff --git a/SocketEngine/Configuration/Server.cs b/SocketEngine/Configuration/Server.cs
index 1aa746f4f..4ee29d5c5 100644
--- a/SocketEngine/Configuration/Server.cs
+++ b/SocketEngine/Configuration/Server.cs
@@ -193,7 +193,7 @@ public bool ClearIdleSession
         /// Gets the clear idle session interval, in seconds.
         /// </summary>
         /// <value>The clear idle session interval.</value>
-        [ConfigurationProperty("clearIdleSessionInterval", IsRequired = false, DefaultValue = 120)]
+        [ConfigurationProperty("clearIdleSessionInterval", IsRequired = false, DefaultValue = ServerConfig.DefaultClearIdleSessionInterval)]
         public int ClearIdleSessionInterval
         {
             get { return (int)this["clearIdleSessionInterval"]; }
@@ -204,7 +204,7 @@ public int ClearIdleSessionInterval
         /// Gets the idle session timeout time length, in seconds.
         /// </summary>
         /// <value>The idle session time out.</value>
-        [ConfigurationProperty("idleSessionTimeOut", IsRequired = false, DefaultValue = 300)]
+        [ConfigurationProperty("idleSessionTimeOut", IsRequired = false, DefaultValue = ServerConfig.DefaultIdleSessionTimeOut)]
         public int IdleSessionTimeOut
         {
             get { return (int)this["idleSessionTimeOut"]; }
diff --git a/SocketEngine/DefaultBootstrap.cs b/SocketEngine/DefaultBootstrap.cs
index 333e7a644..870f5802e 100644
--- a/SocketEngine/DefaultBootstrap.cs
+++ b/SocketEngine/DefaultBootstrap.cs
@@ -292,6 +292,8 @@ public virtual bool Initialize(Func<IServerConfig, IServerConfig> serverConfigRe
                 LogFactory = logFactory;
                 m_GlobalLog = logFactory.GetLog(this.GetType().Name);
 
+                AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(CurrentDomain_UnhandledException);
+
                 try
                 {
                     workItemFactories = factoryInfoLoader.LoadResult(serverConfigResolver);
@@ -367,6 +369,11 @@ public virtual bool Initialize(Func<IServerConfig, IServerConfig> serverConfigRe
             return true;
         }
 
+        void CurrentDomain_UnhandledException(object sender, UnhandledExceptionEventArgs e)
+        {
+            m_GlobalLog.Error("The process crashed for an unhandled exception!", (Exception)e.ExceptionObject);
+        }
+
         /// <summary>
         /// Initializes the bootstrap with the configuration and config resolver.
         /// </summary>
diff --git a/SocketEngine/MarshalAppServer.cs b/SocketEngine/MarshalAppServer.cs
index bff29c808..b458543a5 100644
--- a/SocketEngine/MarshalAppServer.cs
+++ b/SocketEngine/MarshalAppServer.cs
@@ -91,5 +91,19 @@ ServerSummary IWorkItem.CollectServerSummary(NodeSummary nodeSummary)
         {
             return m_AppServer.CollectServerSummary(nodeSummary);   
         }
+
+        /// <summary>
+        /// Obtains a lifetime service object to control the lifetime policy for this instance.
+        /// </summary>
+        /// <returns>
+        /// An object of type <see cref="T:System.Runtime.Remoting.Lifetime.ILease" /> used to control the lifetime policy for this instance. This is the current lifetime service object for this instance if one exists; otherwise, a new lifetime service object initialized to the value of the <see cref="P:System.Runtime.Remoting.Lifetime.LifetimeServices.LeaseManagerPollTime" /> property.
+        /// </returns>
+        /// <PermissionSet>
+        ///   <IPermission class="System.Security.Permissions.SecurityPermission, mscorlib, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" version="1" Flags="RemotingConfiguration, Infrastructure" />
+        ///   </PermissionSet>
+        public override object InitializeLifetimeService()
+        {
+            return null;
+        }
     }
 }
diff --git a/SocketEngine/PerformanceMonitor.cs b/SocketEngine/PerformanceMonitor.cs
index 85bb5cdeb..1382c33f5 100644
--- a/SocketEngine/PerformanceMonitor.cs
+++ b/SocketEngine/PerformanceMonitor.cs
@@ -32,6 +32,8 @@ class PerformanceMonitor : IDisposable
 
         public PerformanceMonitor(IRootConfig config, IEnumerable<IWorkItem> appServers, ILogFactory logFactory)
         {
+            m_PerfLog = logFactory.GetLog("Performance");
+
             m_AppServers = appServers.ToArray();
 
             Process process = Process.GetCurrentProcess();
@@ -41,16 +43,19 @@ public PerformanceMonitor(IRootConfig config, IEnumerable<IWorkItem> appServers,
             var isUnix = Environment.OSVersion.Platform == PlatformID.Unix || Environment.OSVersion.Platform == PlatformID.MacOSX;
             var instanceName = (isUnix || Platform.IsMono) ? string.Format("{0}/{1}", process.Id, process.ProcessName) : GetPerformanceCounterInstanceName(process);
 
-            m_CpuUsagePC = new PerformanceCounter("Process", "% Processor Time", instanceName);
-            m_ThreadCountPC = new PerformanceCounter("Process", "Thread Count", instanceName);
-            m_WorkingSetPC = new PerformanceCounter("Process", "Working Set", instanceName);
-
-            m_PerfLog = logFactory.GetLog("Performance");
+            SetupPerformanceCounters(instanceName);
 
             m_TimerInterval = config.PerformanceDataCollectInterval * 1000;
             m_PerformanceTimer = new Timer(OnPerformanceTimerCallback);
         }
 
+        private void SetupPerformanceCounters(string instanceName)
+        {
+            m_CpuUsagePC = new PerformanceCounter("Process", "% Processor Time", instanceName);
+            m_ThreadCountPC = new PerformanceCounter("Process", "Thread Count", instanceName);
+            m_WorkingSetPC = new PerformanceCounter("Process", "Working Set", instanceName);
+        }
+
         //Tt is only used in windows
         private static string GetPerformanceCounterInstanceName(Process process)
         {
@@ -117,16 +122,44 @@ private void OnPerformanceTimerCallback(object state)
             int maxCompletionPortThreads;
             ThreadPool.GetMaxThreads(out maxWorkingThreads, out maxCompletionPortThreads);
 
-            var globalPerfData = new NodeSummary
+            NodeSummary globalPerfData = null;
+
+            var retry = false;
+
+            while(true)
             {
-                AvailableWorkingThreads = availableWorkingThreads,
-                AvailableCompletionPortThreads = availableCompletionPortThreads,
-                MaxCompletionPortThreads = maxCompletionPortThreads,
-                MaxWorkingThreads = maxWorkingThreads,
-                CpuUsage = m_CpuUsagePC.NextValue() / m_CpuCores,
-                TotalThreadCount = (int)m_ThreadCountPC.NextValue(),
-                WorkingSet = (long)m_WorkingSetPC.NextValue()
-            };
+                try
+                {
+                    globalPerfData = new NodeSummary
+                    {
+                        AvailableWorkingThreads = availableWorkingThreads,
+                        AvailableCompletionPortThreads = availableCompletionPortThreads,
+                        MaxCompletionPortThreads = maxCompletionPortThreads,
+                        MaxWorkingThreads = maxWorkingThreads,
+                        CpuUsage = m_CpuUsagePC.NextValue() / m_CpuCores,
+                        TotalThreadCount = (int)m_ThreadCountPC.NextValue(),
+                        WorkingSet = (long)m_WorkingSetPC.NextValue()
+                    };
+
+                    break;
+                }
+                catch (InvalidOperationException e)
+                {
+                    //Only re-get performance counter one time
+                    if (retry)
+                        throw e;
+
+                    //Only re-get performance counter for .NET/Windows
+                    if (Environment.OSVersion.Platform == PlatformID.Unix || Environment.OSVersion.Platform == PlatformID.MacOSX || Platform.IsMono)
+                        throw e;
+
+                    //If a same name process exited, this process's performance counters instance name could be changed,
+                    //so if the old performance counter cannot be access, get the performance counter's name again
+                    var newInstanceName = GetPerformanceCounterInstanceName(Process.GetCurrentProcess());
+                    SetupPerformanceCounters(newInstanceName);
+                    retry = true;
+                }
+            }
 
             var perfBuilder = new StringBuilder();
 
diff --git a/SocketEngine/SocketListenerBase.cs b/SocketEngine/SocketListenerBase.cs
index 0d723e4bd..da85919f1 100644
--- a/SocketEngine/SocketListenerBase.cs
+++ b/SocketEngine/SocketListenerBase.cs
@@ -51,7 +51,18 @@ protected void OnError(string errorMessage)
 
         protected virtual void OnNewClientAccepted(Socket socket, object state)
         {
-            NewClientAccepted.BeginInvoke(this, socket, state, null, null);
+            var handler = NewClientAccepted;
+
+            if (handler != null)
+                handler(this, socket, state);
+        }
+
+        protected void OnNewClientAcceptedAsync(Socket socket, object state)
+        {
+            var handler = NewClientAccepted;
+
+            if (handler != null)
+                handler.BeginInvoke(this, socket, state, null, null);
         }
 
         /// <summary>
diff --git a/SocketEngine/SocketServerBase.cs b/SocketEngine/SocketServerBase.cs
index a076c6b4d..460db1df7 100644
--- a/SocketEngine/SocketServerBase.cs
+++ b/SocketEngine/SocketServerBase.cs
@@ -39,6 +39,11 @@ abstract class SocketServerBase : ISocketServer, IDisposable
         /// </value>
         internal ISmartPool<SendingQueue> SendingQueuePool { get; private set; }
 
+        IPoolInfo ISocketServer.SendingQueuePool
+        {
+            get { return this.SendingQueuePool; }
+        }
+
         public SocketServerBase(IAppServer appServer, ListenerInfo[] listeners)
         {
             AppServer = appServer;
@@ -110,18 +115,7 @@ void OnListenerError(ISocketListener listener, Exception e)
             if(!logger.IsErrorEnabled)
                 return;
 
-            if (e is ObjectDisposedException || e is NullReferenceException)
-                return;
-
-            var socketException = e as SocketException;
-
-            if (socketException != null)
-            {
-                if (socketException.ErrorCode == 995 || socketException.ErrorCode == 10004 || socketException.ErrorCode == 10038)
-                    return;
-            }
-
-            logger.ErrorFormat(string.Format("Listener ({0}) error: {1}", listener.EndPoint, e.Message), e);
+            logger.Error(string.Format("Listener ({0}) error: {1}", listener.EndPoint, e.Message), e);
         }
 
         void OnListenerStopped(object sender, EventArgs e)
diff --git a/SocketEngine/SocketSession.Net.cs b/SocketEngine/SocketSession.Net.cs
new file mode 100644
index 000000000..03259e9f5
--- /dev/null
+++ b/SocketEngine/SocketSession.Net.cs
@@ -0,0 +1,64 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Net.Sockets;
+using SuperSocket.SocketBase;
+
+namespace SuperSocket.SocketEngine
+{
+    abstract partial class SocketSession
+    {
+        private const string m_GeneralErrorMessage = "Unexpected error";
+        private const string m_GeneralSocketErrorMessage = "Unexpected socket error: {0}";
+
+        /// <summary>
+        /// Logs the error, skip the ignored exception
+        /// </summary>
+        /// <param name="exception">The exception.</param>
+        protected void LogError(Exception exception)
+        {
+            int socketErrorCode;
+
+            //This exception is ignored, needn't log it
+            if (IsIgnorableException(exception, out socketErrorCode))
+                return;
+
+            var message = socketErrorCode > 0 ? string.Format(m_GeneralSocketErrorMessage, socketErrorCode) : m_GeneralErrorMessage;
+
+            AppSession.Logger.Error(this, message, exception);
+        }
+
+        /// <summary>
+        /// Logs the error, skip the ignored exception
+        /// </summary>
+        /// <param name="message">The message.</param>
+        /// <param name="exception">The exception.</param>
+        protected void LogError(string message, Exception exception)
+        {
+            int socketErrorCode;
+
+            //This exception is ignored, needn't log it
+            if (IsIgnorableException(exception, out socketErrorCode))
+                return;
+
+            AppSession.Logger.Error(this, message, exception);
+        }
+
+        /// <summary>
+        /// Logs the socket error, skip the ignored error
+        /// </summary>
+        /// <param name="socketErrorCode">The socket error code.</param>
+        protected void LogError(int socketErrorCode)
+        {
+            if (!Config.LogAllSocketException)
+            {
+                //This error is ignored, needn't log it
+                if (IsIgnorableSocketError(socketErrorCode))
+                    return;
+            }
+
+            AppSession.Logger.Error(this, string.Format(m_GeneralSocketErrorMessage, socketErrorCode), new SocketException(socketErrorCode));
+        }
+    }
+}
diff --git a/SocketEngine/SocketSession.Net45.cs b/SocketEngine/SocketSession.Net45.cs
new file mode 100644
index 000000000..d06ff43cb
--- /dev/null
+++ b/SocketEngine/SocketSession.Net45.cs
@@ -0,0 +1,81 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net.Sockets;
+using System.Runtime.CompilerServices;
+using System.Text;
+using SuperSocket.SocketBase;
+
+namespace SuperSocket.SocketEngine
+{
+    abstract partial class SocketSession
+    {
+        private const string m_GeneralErrorMessage = "Unexpected error";
+        private const string m_GeneralSocketErrorMessage = "Unexpected socket error: {0}";
+        private const string m_CallerInformation = "Caller: {0}, file path: {1}, line number: {2}";
+
+        /// <summary>
+        /// Logs the error, skip the ignored exception
+        /// </summary>
+        /// <param name="exception">The exception.</param>
+        /// <param name="caller">The caller.</param>
+        /// <param name="callerFilePath">The caller file path.</param>
+        /// <param name="callerLineNumber">The caller line number.</param>
+        protected void LogError(Exception exception, [CallerMemberName] string caller = "", [CallerFilePath] string callerFilePath = "", [CallerLineNumber] int callerLineNumber = -1)
+        {
+            int socketErrorCode;
+
+            //This exception is ignored, needn't log it
+            if (IsIgnorableException(exception, out socketErrorCode))
+                return;
+
+            var message = socketErrorCode > 0 ? string.Format(m_GeneralSocketErrorMessage, socketErrorCode) : m_GeneralErrorMessage;
+
+            AppSession.Logger.Error(this
+                , message + Environment.NewLine + string.Format(m_CallerInformation, caller, callerFilePath, callerLineNumber)
+                , exception);
+        }
+
+        /// <summary>
+        /// Logs the error, skip the ignored exception
+        /// </summary>
+        /// <param name="message">The message.</param>
+        /// <param name="exception">The exception.</param>
+        /// <param name="caller">The caller.</param>
+        /// <param name="callerFilePath">The caller file path.</param>
+        /// <param name="callerLineNumber">The caller line number.</param>
+        protected void LogError(string message, Exception exception, [CallerMemberName] string caller = "", [CallerFilePath] string callerFilePath = "", [CallerLineNumber] int callerLineNumber = -1)
+        {
+            int socketErrorCode;
+
+            //This exception is ignored, needn't log it
+            if (IsIgnorableException(exception, out socketErrorCode))
+                return;
+
+            AppSession.Logger.Error(this
+                , message + Environment.NewLine + string.Format(m_CallerInformation, caller, callerFilePath, callerLineNumber)
+                , exception);
+        }
+
+        /// <summary>
+        /// Logs the socket error, skip the ignored error
+        /// </summary>
+        /// <param name="socketErrorCode">The socket error code.</param>
+        /// <param name="caller">The caller.</param>
+        /// <param name="callerFilePath">The caller file path.</param>
+        /// <param name="callerLineNumber">The caller line number.</param>
+        protected void LogError(int socketErrorCode, [CallerMemberName] string caller = "", [CallerFilePath] string callerFilePath = "", [CallerLineNumber] int callerLineNumber = -1)
+        {
+            if (!Config.LogAllSocketException)
+            {
+                //This error is ignored, needn't log it
+                if (IsIgnorableSocketError(socketErrorCode))
+                    return;
+            }
+
+            AppSession.Logger.Error(this
+                , string.Format(m_GeneralSocketErrorMessage, socketErrorCode) + Environment.NewLine + string.Format(m_CallerInformation, caller, callerFilePath, callerLineNumber)
+                , new SocketException(socketErrorCode));
+        }
+    }
+}
diff --git a/SocketEngine/SocketSession.cs b/SocketEngine/SocketSession.cs
index 1e79840cb..dd11fa552 100644
--- a/SocketEngine/SocketSession.cs
+++ b/SocketEngine/SocketSession.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
@@ -16,16 +16,83 @@
 
 namespace SuperSocket.SocketEngine
 {
+    static class SocketState
+    {
+        public const int Normal = 0;//0000 0000
+        public const int InClosing = 16;//0001 0000  >= 16
+        public const int Closed = 16777216;//256 * 256 * 256; 0x01 0x00 0x00 0x00
+        public const int InSending = 1;//0000 0001  > 1
+        public const int InReceiving = 2;//0000 0010 > 2
+        public const int InSendingReceivingMask = -4;// ~(InSending | InReceiving); 0xf0 0xff 0xff 0xff
+    }
+
     /// <summary>
     /// Socket Session, all application session should base on this class
     /// </summary>
-    abstract class SocketSession : ISocketSession
+    abstract partial class SocketSession : ISocketSession
     {
         public IAppSession AppSession { get; private set; }
 
         protected readonly object SyncRoot = new object();
 
-        private int m_InSending = 0;
+        //0x00 0x00 0x00 0x00
+        //1st byte: Closed(Y/N) - 0x01
+        //2nd byte: N/A
+        //3th byte: CloseReason
+        //Last byte: 0000 0000 - normal state
+        //0000 0001: in sending
+        //0000 0010: in receiving
+        //0001 0000: in closing
+        private int m_State = 0;
+
+        private void AddStateFlag(int stateValue)
+        {
+            while(true)
+            {
+                var oldState = m_State;
+                var newState = m_State | stateValue;
+
+                if(Interlocked.CompareExchange(ref m_State, newState, oldState) == oldState)
+                    return;
+            }
+        }
+
+        private bool TryAddStateFlag(int stateValue)
+        {
+            while (true)
+            {
+                var oldState = m_State;
+                var newState = m_State | stateValue;
+
+                //Already marked
+                if (oldState == newState)
+                {
+                    return false;
+                }
+
+                var compareState = Interlocked.CompareExchange(ref m_State, newState, oldState);
+
+                if (compareState == oldState)
+                    return true;
+            }
+        }
+
+        private void RemoveStateFlag(int stateValue)
+        {
+            while(true)
+            {
+                var oldState = m_State;
+                var newState = m_State & (~stateValue);
+
+                if(Interlocked.CompareExchange(ref m_State, newState, oldState) == oldState)
+                    return;
+            }
+        }
+
+        private bool CheckState(int stateValue)
+        {
+            return (m_State & stateValue) == stateValue;
+        }
 
         protected bool SyncSend { get; private set; }
 
@@ -93,17 +160,27 @@ protected virtual void StartSession()
         /// <summary>
         /// Called when [close].
         /// </summary>
-        protected virtual void OnClose(CloseReason reason)
+        protected virtual void OnClosed(CloseReason reason)
         {
-            m_IsClosed = true;
-            m_InSending = 0;
-            
-            var queue = m_SendingQueue;
+            //Already closed
+            if (!TryAddStateFlag(SocketState.Closed))
+                return;
 
-            if (queue != null)
+            //Before changing m_SendingQueue, must check m_IsClosed
+            while (true)
             {
-                queue.StopEnqueue();
-                m_SendingQueuePool.Push(queue);
+                var sendingQueue = m_SendingQueue;
+
+                if (sendingQueue == null)
+                    break;
+
+                //There is no sending was started after the m_Closed ws set to 'true'
+                if (Interlocked.CompareExchange(ref m_SendingQueue, null, sendingQueue) == sendingQueue)
+                {
+                    sendingQueue.Clear();
+                    m_SendingQueuePool.Push(sendingQueue);
+                    break;
+                }
             }
 
             var closedHandler = Closed;
@@ -144,7 +221,14 @@ public bool TrySend(IList<ArraySegment<byte>> segments)
         /// <returns></returns>
         public bool TrySend(ArraySegment<byte> segment)
         {
+            if (IsClosed)
+                return false;
+
             var queue = m_SendingQueue;
+
+            if (queue == null)
+                return false;
+
             var trackID = queue.TrackID;
 
             if (!queue.Enqueue(segment, trackID))
@@ -182,7 +266,7 @@ private void StartSend(SendingQueue queue, int sendingTrackID, bool initial)
         {
             if (initial)
             {
-                if (Interlocked.CompareExchange(ref m_InSending, 1, 0) != 0)
+                if (!TryAddStateFlag(SocketState.InSending))
                 {
                     return;
                 }
@@ -191,16 +275,24 @@ private void StartSend(SendingQueue queue, int sendingTrackID, bool initial)
 
                 if (currentQueue != queue || sendingTrackID != currentQueue.TrackID)
                 {
-                    m_InSending = 0;
+                    //Has been sent
+                    OnSendEnd();
                     return;
                 }
             }
 
+            if (IsInClosingOrClosed && m_Client == null)
+            {
+                OnSendEnd(true);
+                return;
+            }
+
             SendingQueue newQueue;
 
             if (!m_SendingQueuePool.TryGet(out newQueue))
             {
                 AppSession.Logger.Error("There is no enougth sending queue can be used.");
+                OnSendEnd(false);
                 this.Close(CloseReason.InternalError);
                 return;
             }
@@ -212,8 +304,17 @@ private void StartSend(SendingQueue queue, int sendingTrackID, bool initial)
                 if (newQueue != null)
                     m_SendingQueuePool.Push(newQueue);
 
-                AppSession.Logger.Error("Failed to switch the sending queue.");
-                this.Close(CloseReason.InternalError);
+                if (IsInClosingOrClosed)
+                {
+                    OnSendEnd(true);
+                }
+                else
+                {
+                    OnSendEnd(false);
+                    AppSession.Logger.Error("Failed to switch the sending queue.");
+                    this.Close(CloseReason.InternalError);
+                }
+
                 return;
             }
 
@@ -224,6 +325,8 @@ private void StartSend(SendingQueue queue, int sendingTrackID, bool initial)
             if (queue.Count == 0)
             {
                 AppSession.Logger.Error("There is no data to be sent in the queue.");
+                m_SendingQueuePool.Push(queue);
+                OnSendEnd(false);
                 this.Close(CloseReason.InternalError);
                 return;
             }
@@ -231,6 +334,39 @@ private void StartSend(SendingQueue queue, int sendingTrackID, bool initial)
             Send(queue);
         }
 
+        private void OnSendEnd()
+        {
+            OnSendEnd(IsInClosingOrClosed);
+        }
+
+        private void OnSendEnd(bool isInClosingOrClosed)
+        {
+            RemoveStateFlag(SocketState.InSending);
+
+            if (isInClosingOrClosed)
+            {
+                var client = m_Client;
+                //The socket has not been closed, close it now
+                if (client != null)
+                {
+                    //No data to be sent
+                    if (m_SendingQueue.Count == 0)
+                    {
+                        //Not can close it now
+                        InternalClose(client, GetCloseReasonFromState(), false);
+                        return;
+                    }
+
+                    return;
+                }
+
+                if (ValidateNotInSendingReceiving())
+                {
+                    FireCloseEvent();
+                }
+            }
+        }
+
         protected virtual void OnSendingCompleted(SendingQueue queue)
         {
             queue.Clear();
@@ -238,9 +374,22 @@ protected virtual void OnSendingCompleted(SendingQueue queue)
 
             var newQueue = m_SendingQueue;
 
+            if (IsInClosingOrClosed)
+            {
+                //has data is being sent and the socket isn't closed
+                if (newQueue.Count > 0 && m_Client != null)
+                {
+                    StartSend(newQueue, newQueue.TrackID, false);
+                    return;
+                }
+
+                OnSendEnd(true);
+                return;
+            }
+
             if (newQueue.Count == 0)
             {
-                m_InSending = 0;
+                OnSendEnd();
 
                 if (newQueue.Count > 0)
                 {
@@ -270,11 +419,14 @@ public Socket Client
             get { return m_Client; }
         }
 
-        private bool m_IsClosed = false;
+        protected bool IsInClosingOrClosed
+        {
+            get { return m_State >= SocketState.InClosing; }
+        }
 
         protected bool IsClosed
         {
-            get { return m_IsClosed; }
+            get { return m_State >= SocketState.Closed; }
         }
 
         /// <summary>
@@ -297,16 +449,161 @@ protected bool IsClosed
 
         public virtual void Close(CloseReason reason)
         {
+            if (!TryAddStateFlag(SocketState.InClosing))
+                return;
+
             var client = m_Client;
 
-            if(client == null)
+            //Already closed/closing
+            if (client == null)
                 return;
 
+            //Some data is in sending
+            if (CheckState(SocketState.InSending))
+            {
+                //Set closing reason only, don't close the socket directly
+                AddStateFlag(GetCloseReasonValue(reason));
+                return;
+            }
+
+            InternalClose(client, reason, true);
+        }
+
+        private void InternalClose(Socket client, CloseReason reason, bool setCloseReason)
+        {
             if (Interlocked.CompareExchange(ref m_Client, null, client) == client)
             {
+                if (setCloseReason)
+                    AddStateFlag(GetCloseReasonValue(reason));
+
                 client.SafeClose();
-                OnClose(reason);
+
+                if (ValidateNotInSendingReceiving())
+                {
+                    OnClosed(reason);
+                }
+            }
+        }
+
+        protected void OnSendError(SendingQueue queue, CloseReason closeReason)
+        {
+            queue.Clear();
+            m_SendingQueuePool.Push(queue);
+            OnSendEnd();
+            ValidateClosed(closeReason);
+        }
+
+        protected void OnReceiveError(CloseReason closeReason)
+        {
+            OnReceiveEnded();
+            ValidateClosed(closeReason);
+        }
+
+        protected void OnReceiveStarted()
+        {
+            AddStateFlag(SocketState.InReceiving);
+        }
+
+        protected void OnReceiveEnded()
+        {
+            RemoveStateFlag(SocketState.InReceiving);
+        }
+
+        private bool ValidateNotInSendingReceiving()
+        {
+            var oldState = m_State;
+
+            if ((oldState & SocketState.InSendingReceivingMask) == oldState)
+            {
+                return true;
+            }
+
+            return false;
+        }
+
+        private const int m_CloseReasonMagic = 256;
+
+        private int GetCloseReasonValue(CloseReason reason)
+        {
+            return ((int)reason + 1) * m_CloseReasonMagic;
+        }
+
+        private CloseReason GetCloseReasonFromState()
+        {
+            return (CloseReason)(m_State / m_CloseReasonMagic - 1);
+        }
+
+        private void FireCloseEvent()
+        {
+            OnClosed(GetCloseReasonFromState());
+        }
+
+        private void ValidateClosed(CloseReason closeReason)
+        {
+            if (IsClosed)
+                return;
+
+            if (CheckState(SocketState.InClosing))
+            {
+                if (ValidateNotInSendingReceiving())
+                {
+                    FireCloseEvent();
+                }
+            }
+            else
+            {
+                Close(closeReason);
+            }
+        }
+
+        public abstract int OrigReceiveOffset { get; }
+
+        protected virtual bool IsIgnorableSocketError(int socketErrorCode)
+        {
+            if (socketErrorCode == 10004 //Interrupted
+                || socketErrorCode == 10053 //ConnectionAborted
+                || socketErrorCode == 10054 //ConnectionReset
+                || socketErrorCode == 10058 //Shutdown
+                || socketErrorCode == 10060 //TimedOut
+                || socketErrorCode == 995 //OperationAborted
+                || socketErrorCode == -1073741299)
+            {
+                return true;
+            }
+
+            return false;
+        }
+
+        protected virtual bool IsIgnorableException(Exception e, out int socketErrorCode)
+        {
+            socketErrorCode = 0;
+
+            if (e is ObjectDisposedException || e is NullReferenceException)
+                return true;
+
+            SocketException socketException = null;
+
+            if (e is IOException)
+            {
+                if (e.InnerException is ObjectDisposedException || e.InnerException is NullReferenceException)
+                    return true;
+
+                socketException = e.InnerException as SocketException;
             }
+            else
+            {
+                socketException = e as SocketException;
+            }
+
+            if (socketException == null)
+                return false;
+
+            socketErrorCode = socketException.ErrorCode;
+
+            if (Config.LogAllSocketException)
+                return false;
+
+            return IsIgnorableSocketError(socketErrorCode);
         }
     }
 }
diff --git a/SocketEngine/SuperSocket.SocketEngine.Net35.csproj b/SocketEngine/SuperSocket.SocketEngine.Net35.csproj
index b220cbd08..870acba4d 100644
--- a/SocketEngine/SuperSocket.SocketEngine.Net35.csproj
+++ b/SocketEngine/SuperSocket.SocketEngine.Net35.csproj
@@ -109,6 +109,7 @@
     <Compile Include="SocketServerFactory.cs" />
     <Compile Include="SocketServerBase.cs" />
     <Compile Include="SocketSession.cs" />
+    <Compile Include="SocketSession.Net.cs" />
     <Compile Include="TcpAsyncSocketListener.cs" />
     <Compile Include="TcpSocketServerBase.cs" />
     <Compile Include="UdpSocketListener.cs" />
diff --git a/SocketEngine/SuperSocket.SocketEngine.Net40.csproj b/SocketEngine/SuperSocket.SocketEngine.Net40.csproj
index 0af0bcffe..0aebdf863 100644
--- a/SocketEngine/SuperSocket.SocketEngine.Net40.csproj
+++ b/SocketEngine/SuperSocket.SocketEngine.Net40.csproj
@@ -81,6 +81,7 @@
     <Compile Include="BootstrapFactory.cs" />
     <Compile Include="Configuration\CommandAssembly.cs" />
     <Compile Include="Configuration\SocketServiceConfig.cs" />
+    <Compile Include="SocketSession.Net.cs" />
     <Compile Include="WorkItemFactoryInfoLoader.cs" />
     <Compile Include="IAsyncSocketSession.cs" />
     <Compile Include="DefaultBootstrap.cs" />
diff --git a/SocketEngine/SuperSocket.SocketEngine.Net45.csproj b/SocketEngine/SuperSocket.SocketEngine.Net45.csproj
index 5911636f5..c2602c4d3 100644
--- a/SocketEngine/SuperSocket.SocketEngine.Net45.csproj
+++ b/SocketEngine/SuperSocket.SocketEngine.Net45.csproj
@@ -82,6 +82,7 @@
     <Compile Include="AssemblyImport.cs" />
     <Compile Include="BootstrapFactory.cs" />
     <Compile Include="Configuration\CommandAssembly.cs" />
+    <Compile Include="SocketSession.Net45.cs" />
     <Compile Include="WorkItemFactoryInfoLoader.cs" />
     <Compile Include="IAsyncSocketSession.cs" />
     <Compile Include="DefaultBootstrap.cs" />
diff --git a/SocketEngine/TcpAsyncSocketListener.cs b/SocketEngine/TcpAsyncSocketListener.cs
index 719e21b6e..5bf6cdc06 100644
--- a/SocketEngine/TcpAsyncSocketListener.cs
+++ b/SocketEngine/TcpAsyncSocketListener.cs
@@ -66,13 +66,22 @@ void acceptEventArg_Completed(object sender, SocketAsyncEventArgs e)
 
         void ProcessAccept(SocketAsyncEventArgs e)
         {
+            Socket socket = null;
+
             if (e.SocketError != SocketError.Success)
             {
-                OnError(new SocketException((int)e.SocketError));
-                return;
-            }
+                var errorCode = (int)e.SocketError;
 
-            OnNewClientAccepted(e.AcceptSocket, null);
+                //The listen socket was closed
+                if (errorCode == 995 || errorCode == 10004 || errorCode == 10038)
+                    return;
+
+                OnError(new SocketException(errorCode));
+            }
+            else
+            {
+                socket = e.AcceptSocket;
+            }
 
             e.AcceptSocket = null;
 
@@ -82,12 +91,30 @@ void ProcessAccept(SocketAsyncEventArgs e)
             {
                 willRaiseEvent = m_ListenSocket.AcceptAsync(e);
             }
+            catch (ObjectDisposedException)
+            {
+                //The listener was stopped
+                //Do nothing
+                //make sure ProcessAccept won't be executed in this thread
+                willRaiseEvent = true;
+            }
+            catch (NullReferenceException)
+            {
+                //The listener was stopped
+                //Do nothing
+                //make sure ProcessAccept won't be executed in this thread
+                willRaiseEvent = true;
+            }
             catch (Exception exc)
             {
                 OnError(exc);
-                return;
+                //make sure ProcessAccept won't be executed in this thread
+                willRaiseEvent = true;
             }
 
+            if (socket != null)
+                OnNewClientAccepted(socket, null);
+
             if (!willRaiseEvent)
                 ProcessAccept(e);
         }
diff --git a/SocketEngine/TcpSocketServerBase.cs b/SocketEngine/TcpSocketServerBase.cs
index b80604371..f652b216a 100644
--- a/SocketEngine/TcpSocketServerBase.cs
+++ b/SocketEngine/TcpSocketServerBase.cs
@@ -52,8 +52,8 @@ protected ISocketSession RegisterSession(Socket client, ISocketSession session)
             if (m_SendBufferSize > 0)
                 client.SendBufferSize = m_SendBufferSize;
 
-            if(!Platform.SupportSocketIOControlByCodeEnum)
-                client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.KeepAlive, true);
+            if (!Platform.SupportSocketIOControlByCodeEnum)
+                client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.KeepAlive, m_KeepAliveOptionValues);
             else
                 client.IOControl(IOControlCode.KeepAliveValues, m_KeepAliveOptionValues, m_KeepAliveOptionOutValues);
 
diff --git a/SocketEngine/UdpSocketListener.cs b/SocketEngine/UdpSocketListener.cs
index 889bf4d5a..c8b418a94 100644
--- a/SocketEngine/UdpSocketListener.cs
+++ b/SocketEngine/UdpSocketListener.cs
@@ -69,15 +69,28 @@ void eventArgs_Completed(object sender, SocketAsyncEventArgs e)
         {
             if (e.SocketError != SocketError.Success)
             {
-                OnError(new SocketException((int)e.SocketError));
-                return;
+                var errorCode = (int)e.SocketError;
+
+                //The listen socket was closed
+                if (errorCode == 995 || errorCode == 10004 || errorCode == 10038)
+                    return;
+
+                OnError(new SocketException(errorCode));
             }
 
             if (e.LastOperation == SocketAsyncOperation.ReceiveFrom)
             {
                 try
                 {
-                    OnNewClientAccepted(m_ListenSocket, new object[] { e.Buffer.CloneRange(e.Offset, e.BytesTransferred), e.RemoteEndPoint.Serialize() });
+                    OnNewClientAcceptedAsync(m_ListenSocket, new object[] { e.Buffer.CloneRange(e.Offset, e.BytesTransferred), e.RemoteEndPoint.Serialize() });
+                }
+                catch (Exception exc)
+                {
+                    OnError(exc);
+                }
+
+                try
+                {
                     m_ListenSocket.ReceiveFromAsync(e);
                 }
                 catch (Exception exc)
diff --git a/SocketEngine/UdpSocketServer.cs b/SocketEngine/UdpSocketServer.cs
index c80cae873..b550f2248 100644
--- a/SocketEngine/UdpSocketServer.cs
+++ b/SocketEngine/UdpSocketServer.cs
@@ -60,13 +60,21 @@ protected override void OnNewClientAccepted(ISocketListener listener, Socket cli
             var socketAddress = paramArray[1] as SocketAddress;
             var remoteEndPoint = (socketAddress.Family == AddressFamily.InterNetworkV6 ? m_EndPointIPv6.Create(socketAddress) : m_EndPointIPv4.Create(socketAddress)) as IPEndPoint;
 
-            if (m_IsUdpRequestInfo)
+            try
             {
-                ProcessPackageWithSessionID(client, remoteEndPoint, receivedData);
+                if (m_IsUdpRequestInfo)
+                {
+                    ProcessPackageWithSessionID(client, remoteEndPoint, receivedData);
+                }
+                else
+                {
+                    ProcessPackageWithoutSessionID(client, remoteEndPoint, receivedData);
+                }
             }
-            else
+            catch (Exception e)
             {
-                ProcessPackageWithoutSessionID(client, remoteEndPoint, receivedData);
+                if (AppServer.Logger.IsErrorEnabled)
+                    AppServer.Logger.Error("Process UDP package error!", e);
             }
         }
 
diff --git a/SocketEngine/UdpSocketSession.cs b/SocketEngine/UdpSocketSession.cs
index c24af93b3..016317fcf 100644
--- a/SocketEngine/UdpSocketSession.cs
+++ b/SocketEngine/UdpSocketSession.cs
@@ -65,6 +65,8 @@ protected override void SendAsync(SendingQueue queue)
 
         void SendingCompleted(object sender, SocketAsyncEventArgs e)
         {
+            var queue = e.UserToken as SendingQueue;
+
             if (e.SocketError != SocketError.Success)
             {
                 var log = AppSession.Logger;
@@ -72,11 +74,11 @@ void SendingCompleted(object sender, SocketAsyncEventArgs e)
                 if (log.IsErrorEnabled)
                     log.Error(new SocketException((int)e.SocketError));
 
+                e.UserToken = null;
+                OnSendError(queue, CloseReason.SocketError);
                 return;
             }
 
-            var queue = e.UserToken as SendingQueue;
-
             var newPos = queue.Position + 1;
 
             if (newPos >= queue.Count)
@@ -109,7 +111,12 @@ public override void ApplySecureProtocol()
         public override void Close(CloseReason reason)
         {
             if (!IsClosed)
-                OnClose(reason);
+                OnClosed(reason);
+        }
+
+        public override int OrigReceiveOffset
+        {
+            get { return 0; }
         }
     }
 }
diff --git a/SocketService/RunServer.bat b/SocketService/RunServer.bat
deleted file mode 100644
index 8099737ec..000000000
--- a/SocketService/RunServer.bat
+++ /dev/null
@@ -1,2 +0,0 @@
-SuperSocket.SocketService.exe -c
-pause
\ No newline at end of file
diff --git a/Solution Items/GlobalAssemblyInfo.cs b/Solution Items/GlobalAssemblyInfo.cs
index 25576a039..b60c8abf9 100644
--- a/Solution Items/GlobalAssemblyInfo.cs	
+++ b/Solution Items/GlobalAssemblyInfo.cs	
@@ -8,10 +8,10 @@
 //      Build Number
 //      Revision
 //
-[assembly: AssemblyVersion("1.5.0.6")]
-[assembly: AssemblyFileVersion("1.5.0.6")]
+[assembly: AssemblyVersion("1.5.4.0")]
+[assembly: AssemblyFileVersion("1.5.4.0")]
 [assembly: AssemblyCompany("SuperSocket")]
 [assembly: AssemblyProduct("SuperSocket")]
-[assembly: AssemblyCopyright("Copyright © supersocket.codeplex.com 2012")]
+[assembly: AssemblyCopyright("Copyright © supersocket.codeplex.com 2010-2013")]
 [assembly: AssemblyTrademark("")]
 [assembly: AssemblyCulture("")]
\ No newline at end of file
diff --git a/Solution Items/log4net.unix.config b/Solution Items/log4net.unix.config
index 4a173effe..d6f357029 100644
--- a/Solution Items/log4net.unix.config	
+++ b/Solution Items/log4net.unix.config	
@@ -44,7 +44,7 @@
     </appender>
     <appender name="perfAppender" type="log4net.Appender.RollingFileAppender">
         <filter type="log4net.Filter.LevelMatchFilter">
-            <levelToMatch value="TRACE" />
+            <levelToMatch value="INFO" />
         </filter>
         <filter type="log4net.Filter.DenyAllFilter" />
         <File value="Logs/perf.log" />
diff --git a/Test/AppDomainSocketServerTest.cs b/Test/AppDomainSocketServerTest.cs
index e61fa0215..a794ee9c0 100644
--- a/Test/AppDomainSocketServerTest.cs
+++ b/Test/AppDomainSocketServerTest.cs
@@ -20,28 +20,21 @@ namespace SuperSocket.Test
     [TestFixture]
     public class AppDomainSocketServerTest : TcpSocketServerTest
     {
-        protected override IWorkItem CreateAppServer<T>(IRootConfig rootConfig, IServerConfig serverConfig)
+        protected override string DefaultServerConfig
         {
-            var appServer = new AppDomainAppServer(typeof(T));
-
-            var config = new ConfigurationSource();
-            rootConfig.CopyPropertiesTo(config);
-
-            appServer.Setup(new AppDomainBootstrap(config), serverConfig, new ProviderFactoryInfo[]
+            get
             {
-                new ProviderFactoryInfo(ProviderKey.SocketServerFactory, ProviderKey.SocketServerFactory.Name, typeof(SocketServerFactory)),
-                new ProviderFactoryInfo(ProviderKey.LogFactory, ProviderKey.LogFactory.Name, typeof(ConsoleLogFactory))
-            });
-
-            return appServer;
+                return "AppDomainTestServer.config";
+            }
         }
 
         [Test]
         public void TestAppDomain()
         {
-            StartServer();
+            var configSource = StartBootstrap(DefaultServerConfig);
+            var serverConfig = configSource.Servers.FirstOrDefault();
 
-            EndPoint serverAddress = new IPEndPoint(IPAddress.Parse("127.0.0.1"), m_Config.Port);
+            EndPoint serverAddress = new IPEndPoint(IPAddress.Parse("127.0.0.1"), serverConfig.Port);
 
             using (Socket socket = CreateClientSocket())
             {
@@ -59,7 +52,7 @@ public void TestAppDomain()
 
                     var line = reader.ReadLine();
 
-                    Assert.AreEqual(m_Config.Name, line);
+                    Assert.AreEqual(serverConfig.Name, line);
                 }
             }
         }
diff --git a/Test/BootstrapTest.cs b/Test/BootstrapTest.cs
index 7e4e1f05f..f52ef40f9 100644
--- a/Test/BootstrapTest.cs
+++ b/Test/BootstrapTest.cs
@@ -14,48 +14,10 @@
 namespace SuperSocket.Test
 {
     [TestFixture]
-    public class BootstrapTest
+    public partial class BootstrapTest : BootstrapTestBase
     {
-        private IBootstrap m_BootStrap;
-
         private Encoding m_Encoding = new UTF8Encoding();
 
-        [TearDown]
-        public void ClearBootstrap()
-        {
-            if(m_BootStrap != null)
-            {
-                m_BootStrap.Stop();
-                m_BootStrap = null;
-            }
-        }
-
-        private IConfigurationSource CreateBootstrap(string configFile)
-        {
-            var fileMap = new ExeConfigurationFileMap();
-            var filePath = Path.Combine(@"Config", configFile);
-            fileMap.ExeConfigFilename = filePath;
-            var config = ConfigurationManager.OpenMappedExeConfiguration(fileMap, ConfigurationUserLevel.None);
-            var configSource = config.GetSection("superSocket") as IConfigurationSource;
-
-            m_BootStrap = BootstrapFactory.CreateBootstrap(configSource);
-
-            return configSource;
-        }
-
-        private IConfigurationSource SetupBootstrap(string configFile)
-        {
-            var configSource = CreateBootstrap(configFile);
-
-            Assert.IsTrue(m_BootStrap.Initialize());
-
-            var result = m_BootStrap.Start();
-
-            Assert.AreEqual(StartResult.Success, result);
-
-            return configSource;
-        }
-
         [Test]
         public void TestBasicConfig()
         {
@@ -64,7 +26,7 @@ public void TestBasicConfig()
 
         private void TestBasicConfig(string configFile)
         {
-            var configSource = SetupBootstrap(configFile);
+            var configSource = StartBootstrap(configFile);
 
             EndPoint serverAddress = new IPEndPoint(IPAddress.Parse("127.0.0.1"), configSource.Servers.FirstOrDefault().Port);
 
@@ -98,7 +60,7 @@ public void TestServerTypeConfig()
         [Test]
         public void TestListenersConfig()
         {
-            var configSource = SetupBootstrap("Listeners.config");
+            var configSource = StartBootstrap("Listeners.config");
 
             var serverConfig = configSource.Servers.FirstOrDefault();
 
@@ -130,7 +92,7 @@ public void TestListenersConfig()
         [Test]
         public void TestAppDomainConfig()
         {
-            var configSource = SetupBootstrap("AppDomain.config");
+            var configSource = StartBootstrap("AppDomain.config");
 
             var serverConfig = configSource.Servers.FirstOrDefault();
             
@@ -155,7 +117,7 @@ public void TestAppDomainConfig()
         [Test]
         public void TestDLRConfig()
         {
-            var configSource = SetupBootstrap("DLR.config");
+            var configSource = StartBootstrap("DLR.config");
 
             var serverConfig = configSource.Servers.FirstOrDefault();
 
@@ -229,9 +191,9 @@ public void TestListenEndPointReplacement()
             var endPointReplacement = new Dictionary<string, IPEndPoint>(StringComparer.OrdinalIgnoreCase);
             endPointReplacement.Add("TestServer_2012", new IPEndPoint(IPAddress.Any, 3012));
 
-            m_BootStrap.Initialize(endPointReplacement);
+            BootStrap.Initialize(endPointReplacement);
 
-            var appServer = m_BootStrap.AppServers.OfType<IAppServer>().FirstOrDefault();
+            var appServer = BootStrap.AppServers.OfType<IAppServer>().FirstOrDefault();
 
             Assert.AreEqual(1, appServer.Listeners.Length);
 
@@ -243,9 +205,9 @@ public void TestListenEndPointReplacement()
             endPointReplacement.Add("TestServer_2012", new IPEndPoint(IPAddress.Any, 3012));
             endPointReplacement.Add("TestServer_2013", new IPEndPoint(IPAddress.Any, 3013));
 
-            m_BootStrap.Initialize(endPointReplacement);
+            BootStrap.Initialize(endPointReplacement);
 
-            appServer = m_BootStrap.AppServers.OfType<IAppServer>().FirstOrDefault();
+            appServer = BootStrap.AppServers.OfType<IAppServer>().FirstOrDefault();
 
             Assert.AreEqual(2, appServer.Listeners.Length);
 
diff --git a/Test/BootstrapTestBase.cs b/Test/BootstrapTestBase.cs
new file mode 100644
index 000000000..d3a3cabbb
--- /dev/null
+++ b/Test/BootstrapTestBase.cs
@@ -0,0 +1,82 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using NUnit.Framework;
+using SuperSocket.SocketBase.Config;
+using SuperSocket.SocketEngine;
+using SuperSocket.SocketBase;
+using System.Configuration;
+using System.IO;
+
+namespace SuperSocket.Test
+{
+    public abstract class BootstrapTestBase
+    {
+        private IBootstrap m_BootStrap;
+
+        protected IBootstrap BootStrap
+        {
+            get { return m_BootStrap; }
+        }
+
+        [TearDown]
+        public void ClearBootstrap()
+        {
+            if (m_BootStrap != null)
+            {
+                m_BootStrap.Stop();
+                m_BootStrap = null;
+                OnBootstrapCleared();
+            }
+        }
+
+        protected virtual void OnBootstrapCleared()
+        {
+
+        }
+
+        protected IConfigurationSource CreateBootstrap(string configFile)
+        {
+            var fileMap = new ExeConfigurationFileMap();
+            var filePath = Path.Combine(@"Config", configFile);
+            fileMap.ExeConfigFilename = filePath;
+            var config = ConfigurationManager.OpenMappedExeConfiguration(fileMap, ConfigurationUserLevel.None);
+            var configSource = config.GetSection("superSocket") as IConfigurationSource;
+
+            m_BootStrap = BootstrapFactory.CreateBootstrap(configSource);
+
+            return configSource;
+        }
+
+        protected IConfigurationSource SetupBootstrap(string configFile, Func<IServerConfig, IServerConfig> configResolver)
+        {
+            var configSource = CreateBootstrap(configFile);
+
+            if(configResolver != null)
+                Assert.IsTrue(m_BootStrap.Initialize(configResolver));
+            else
+                Assert.IsTrue(m_BootStrap.Initialize());
+
+            return configSource;
+        }
+
+        protected IConfigurationSource SetupBootstrap(string configFile)
+        {
+            return SetupBootstrap(configFile, null);
+        }
+
+        protected IConfigurationSource StartBootstrap(string configFile, Func<IServerConfig, IServerConfig> configResolver)
+        {
+            var configSource = SetupBootstrap(configFile, configResolver);
+            var result = m_BootStrap.Start();
+            Assert.AreEqual(StartResult.Success, result);
+            return configSource;
+        }
+
+        protected IConfigurationSource StartBootstrap(string configFile)
+        {
+            return StartBootstrap(configFile, null);
+        }
+    }
+}
diff --git a/Test/Command/CLOSE.cs b/Test/Command/CLOSE.cs
new file mode 100644
index 000000000..c3bf2530f
--- /dev/null
+++ b/Test/Command/CLOSE.cs
@@ -0,0 +1,18 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using SuperSocket.SocketBase.Command;
+using SuperSocket.SocketBase.Protocol;
+using SuperSocket.SocketBase;
+
+namespace SuperSocket.Test.Command
+{
+    public class CLOSE : StringCommandBase<TestSession>
+    {
+        public override void ExecuteCommand(TestSession session, StringRequestInfo requestInfo)
+        {
+            session.Close(CloseReason.ServerClosing);
+        }
+    }
+}
diff --git a/Test/Config/AppDomainTestServer.config b/Test/Config/AppDomainTestServer.config
new file mode 100644
index 000000000..742e1ffc8
--- /dev/null
+++ b/Test/Config/AppDomainTestServer.config
@@ -0,0 +1,29 @@
+<?xml version="1.0"?>
+<configuration>
+  <configSections>
+    <section name="superSocket" type="SuperSocket.SocketEngine.Configuration.SocketServiceConfig, SuperSocket.SocketEngine" />
+  </configSections>
+  <superSocket logFactory="ConsoleLogFactory"
+               isolation="AppDomain"
+               disablePerformanceDataCollector="true"
+               maxWorkingThreads="500"
+               maxCompletionPortThreads="500"
+               minWorkingThreads="5"
+               minCompletionPortThreads="5">
+    <servers>
+      <server name="TestServer"
+              serverType="SuperSocket.Test.TestServer, SuperSocket.Test"
+              ip="Any"
+              port="2012"
+              clearIdleSession="true"
+              clearIdleSessionInterval="1"
+              idleSessionTimeOut="5"
+              maxConnectionNumber="100">
+      </server>
+    </servers>
+    <logFactories>
+      <add name="ConsoleLogFactory"
+           type="SuperSocket.SocketBase.Logging.ConsoleLogFactory, SuperSocket.SocketBase" />
+    </logFactories>
+  </superSocket>
+</configuration>
diff --git a/Test/Config/Basic.config b/Test/Config/Basic.config
index ee0a9c54d..b91b5d939 100644
--- a/Test/Config/Basic.config
+++ b/Test/Config/Basic.config
@@ -19,7 +19,4 @@
            type="SuperSocket.SocketBase.Logging.ConsoleLogFactory, SuperSocket.SocketBase" />
     </logFactories>
   </superSocket>
-  <startup>
-    <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.0" />
-  </startup>
 </configuration>
diff --git a/Test/Config/ChildConfig.cs b/Test/Config/ChildConfig.cs
index 4c6e48ad9..5db80dcf2 100644
--- a/Test/Config/ChildConfig.cs
+++ b/Test/Config/ChildConfig.cs
@@ -15,7 +15,7 @@ public int Value
         }
     }
 
-    [ConfigurationCollection(typeof(ChildConfig))]
+    [ConfigurationCollection(typeof(ChildConfig), AddItemName = "child")]
     public class ChildConfigCollection : ConfigurationElementCollection
     {
         [ConfigurationProperty("globalValue", IsRequired = true)]
diff --git a/Test/Config/ChildConfigD.config b/Test/Config/ChildConfigD.config
index 0cf8ae8cd..7f28d93c8 100644
--- a/Test/Config/ChildConfigD.config
+++ b/Test/Config/ChildConfigD.config
@@ -8,9 +8,9 @@
       <server name="TestServer" serverTypeName="TestServer"
               ip="Any" port="2012" maxConnectionNumber="5">
         <children globalValue="8848">
-          <add value="10" />
-          <add value="20" />
-          <add value="30" />
+          <child value="10" />
+          <child value="20" />
+          <child value="30" />
         </children>
       </server>
     </servers>
diff --git a/Test/Config/ConnectionFilter.config b/Test/Config/ConnectionFilter.config
new file mode 100644
index 000000000..74a83cdec
--- /dev/null
+++ b/Test/Config/ConnectionFilter.config
@@ -0,0 +1,27 @@
+<?xml version="1.0"?>
+<configuration>
+  <configSections>
+    <section name="superSocket" type="SuperSocket.SocketEngine.Configuration.SocketServiceConfig, SuperSocket.SocketEngine" />
+  </configSections>
+  <superSocket logFactory="ConsoleLogFactory" disablePerformanceDataCollector="true">
+    <servers>
+      <server name="TestServer"
+              serverTypeName="TestServer"
+              ip="Any" port="2012" maxConnectionNumber="1"
+              connectionFilter="TestFilter">
+      </server>
+    </servers>
+    <serverTypes>
+      <add name="TestServer"
+           type="SuperSocket.Test.TestServer, SuperSocket.Test" />
+    </serverTypes>
+    <connectionFilters>
+      <add name="TestFilter"
+           type="SuperSocket.Test.ConnectionFilter.TestConnectionFilter, SuperSocket.Test" />
+    </connectionFilters>
+    <logFactories>
+      <add name="ConsoleLogFactory"
+           type="SuperSocket.SocketBase.Logging.ConsoleLogFactory, SuperSocket.SocketBase" />
+    </logFactories>
+  </superSocket>
+</configuration>
diff --git a/Test/Config/DLR.config b/Test/Config/DLR.config
index 59969ce85..417dc4f56 100644
--- a/Test/Config/DLR.config
+++ b/Test/Config/DLR.config
@@ -6,7 +6,9 @@
     <section name="microsoft.scripting" requirePermission="false"
              type="Microsoft.Scripting.Hosting.Configuration.Section, Microsoft.Scripting"/>
   </configSections>
-  <superSocket isolation="AppDomain" logFactory="ConsoleLogFactory" disablePerformanceDataCollector="true">
+  <superSocket isolation="AppDomain"
+               logFactory="ConsoleLogFactory"
+               disablePerformanceDataCollector="true">
     <servers>
       <server name="TestServer" serverTypeName="TestServer"
               ip="Any" port="2012" maxConnectionNumber="5"
@@ -33,7 +35,4 @@
                 names="IronPython;Python;py"/>
     </languages>
   </microsoft.scripting>
-  <startup>
-    <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.0" />
-  </startup>
 </configuration>
diff --git a/Test/Config/SecureTestServer.config b/Test/Config/SecureTestServer.config
new file mode 100644
index 000000000..b17dcc423
--- /dev/null
+++ b/Test/Config/SecureTestServer.config
@@ -0,0 +1,30 @@
+<?xml version="1.0"?>
+<configuration>
+  <configSections>
+    <section name="superSocket" type="SuperSocket.SocketEngine.Configuration.SocketServiceConfig, SuperSocket.SocketEngine" />
+  </configSections>
+  <superSocket logFactory="ConsoleLogFactory"
+               disablePerformanceDataCollector="true"
+               maxWorkingThreads="500"
+               maxCompletionPortThreads="500"
+               minWorkingThreads="5"
+               minCompletionPortThreads="5">
+    <servers>
+      <server name="TestServer"
+              serverType="SuperSocket.Test.TestServer, SuperSocket.Test"
+              ip="Any"
+              port="2012"
+              clearIdleSession="true"
+              clearIdleSessionInterval="1"
+              idleSessionTimeOut="5"
+              maxConnectionNumber="100"
+              security="tls">
+        <certificate filePath="supersocket.pfx" password="supersocket"></certificate>
+      </server>
+    </servers>
+    <logFactories>
+      <add name="ConsoleLogFactory"
+           type="SuperSocket.SocketBase.Logging.ConsoleLogFactory, SuperSocket.SocketBase" />
+    </logFactories>
+  </superSocket>
+</configuration>
diff --git a/Test/Config/TestServer.config b/Test/Config/TestServer.config
new file mode 100644
index 000000000..cf45bbe89
--- /dev/null
+++ b/Test/Config/TestServer.config
@@ -0,0 +1,28 @@
+<?xml version="1.0"?>
+<configuration>
+  <configSections>
+    <section name="superSocket" type="SuperSocket.SocketEngine.Configuration.SocketServiceConfig, SuperSocket.SocketEngine" />
+  </configSections>
+  <superSocket logFactory="ConsoleLogFactory"
+               disablePerformanceDataCollector="true"
+               maxWorkingThreads="500"
+               maxCompletionPortThreads="500"
+               minWorkingThreads="5"
+               minCompletionPortThreads="5">
+    <servers>
+      <server name="TestServer"
+              serverType="SuperSocket.Test.TestServer, SuperSocket.Test"
+              ip="Any"
+              port="2012"
+              clearIdleSession="true"
+              clearIdleSessionInterval="1"
+              idleSessionTimeOut="5"
+              maxConnectionNumber="100">
+      </server>
+    </servers>
+    <logFactories>
+      <add name="ConsoleLogFactory"
+           type="SuperSocket.SocketBase.Logging.ConsoleLogFactory, SuperSocket.SocketBase" />
+    </logFactories>
+  </superSocket>
+</configuration>
diff --git a/Test/ConnectionFilter/TestConnectionFilter.cs b/Test/ConnectionFilter/TestConnectionFilter.cs
index 05fc57526..c8e78bd29 100644
--- a/Test/ConnectionFilter/TestConnectionFilter.cs
+++ b/Test/ConnectionFilter/TestConnectionFilter.cs
@@ -9,9 +9,12 @@ namespace SuperSocket.Test.ConnectionFilter
 {
     public class TestConnectionFilter : IConnectionFilter
     {
+        internal IAppServer AppServer { get; private set; }
+
         public bool Initialize(string name, IAppServer appServer)
         {
             Name = name;
+            AppServer = appServer;
             return true;
         }
 
diff --git a/Test/ConnectionFilterTest.cs b/Test/ConnectionFilterTest.cs
index 600bae09c..ae3557056 100644
--- a/Test/ConnectionFilterTest.cs
+++ b/Test/ConnectionFilterTest.cs
@@ -16,32 +16,8 @@
 namespace SuperSocket.Test
 {
     [TestFixture]
-    public class ConnectionFilterTest
+    public class ConnectionFilterTest : BootstrapTestBase
     {
-        private TestServer m_Server;
-
-        private IServerConfig m_ServerConfig;
-
-        [TestFixtureSetUp]
-        public void Setup()
-        {
-            m_ServerConfig = new ServerConfig
-                {
-                    Ip = "Any",
-                    LogCommand = false,
-                    MaxConnectionNumber = 1,
-                    Mode = SocketMode.Tcp,
-                    Name = "TestServer",
-                    Port = 2012,
-                    ClearIdleSession = false
-                };
-
-            m_Server = new TestServer();
-            m_Server.NewSessionConnected += new SessionHandler<TestSession>(m_Server_NewSessionConnected);
-            m_Server.Setup(new RootConfig(), m_ServerConfig, null, null, new ConsoleLogFactory(), new IConnectionFilter[] { new TestConnectionFilter() }, null);
-        }
-
-
         private AutoResetEvent m_NewSessionConnectedEvent = new AutoResetEvent(false);
 
         void m_Server_NewSessionConnected(TestSession obj)
@@ -49,20 +25,28 @@ void m_Server_NewSessionConnected(TestSession obj)
             m_NewSessionConnectedEvent.Set();
         }
 
-        [TearDown]
-        public void StopServer()
+        [Test]
+        public void TestInitialize()
         {
-            if (m_Server.State == ServerState.Running)
-                m_Server.Stop();
+            StartBootstrap("ConnectionFilter.config");
+
+            var appServer = BootStrap.AppServers.FirstOrDefault() as TestServer;
+            
+            var connectionFilter = appServer.ConnectionFilters.FirstOrDefault() as TestConnectionFilter;
+
+            Assert.AreEqual("TestFilter", connectionFilter.Name);
+            Assert.AreEqual(appServer, connectionFilter.AppServer);
         }
 
         [Test]
         public void TestAllow()
         {
-            if (m_Server.State != ServerState.Running)
-                m_Server.Start();
+            var configSource = StartBootstrap("ConnectionFilter.config");
+            var serverConfig = configSource.Servers.FirstOrDefault();
+            var appServer = BootStrap.AppServers.FirstOrDefault() as TestServer;
+            appServer.NewSessionConnected += m_Server_NewSessionConnected;
 
-            EndPoint serverAddress = new IPEndPoint(IPAddress.Parse("127.0.0.1"), m_ServerConfig.Port);
+            EndPoint serverAddress = new IPEndPoint(IPAddress.Parse("127.0.0.1"), serverConfig.Port);
 
             using (Socket socket = new Socket(serverAddress.AddressFamily, SocketType.Stream, ProtocolType.Tcp))
             {
@@ -90,10 +74,12 @@ public void TestAllow()
         [Test]
         public void TestDisallow()
         {
-            if (m_Server.State != ServerState.Running)
-                m_Server.Start();
+            var configSource = StartBootstrap("ConnectionFilter.config");
+            var serverConfig = configSource.Servers.FirstOrDefault();
+            var appServer = BootStrap.AppServers.FirstOrDefault() as TestServer;
+            appServer.NewSessionConnected += m_Server_NewSessionConnected;
 
-            EndPoint serverAddress = new IPEndPoint(IPAddress.Parse("127.0.0.1"), m_ServerConfig.Port);
+            EndPoint serverAddress = new IPEndPoint(IPAddress.Parse("127.0.0.1"), serverConfig.Port);
 
             using (Socket socket = new Socket(serverAddress.AddressFamily, SocketType.Stream, ProtocolType.Tcp))
             {
diff --git a/Test/DLRSocketServerTest.cs b/Test/DLRSocketServerTest.cs
index f622ee506..30fc1bab1 100644
--- a/Test/DLRSocketServerTest.cs
+++ b/Test/DLRSocketServerTest.cs
@@ -18,54 +18,18 @@
 namespace SuperSocket.Test
 {
     [TestFixture]
-    public class DLRSocketServerTest
+    public class DLRSocketServerTest : BootstrapTestBase
     {
-        private TestServer m_Server;
-
-        private IServerConfig m_ServerConfig;
-
-        private Encoding m_Encoding;
-
-        [TestFixtureSetUp]
-        public void Setup()
-        {
-            m_Encoding = new UTF8Encoding();
-            m_ServerConfig = new ServerConfig
-                {
-                    Ip = "Any",
-                    LogCommand = false,
-                    MaxConnectionNumber = 100,
-                    Mode = SocketMode.Tcp,
-                    Name = "DLR Socket Server",
-                    Port = 2012,
-                    ClearIdleSession = true
-                };
-
-            m_Server = new TestServer();
-            var scriptRuntime = new ScriptRuntime(new ScriptRuntimeSetup
-                {
-                    LanguageSetups =
-                    {
-                        new LanguageSetup("IronPython.Runtime.PythonContext, IronPython", "IronPython", "IronPython;Python;py".Split(';'), new string[] { ".py" })
-                    }
-                });
-            m_Server.Setup(new RootConfig(), m_ServerConfig, null, null, new ConsoleLogFactory(), null, new ICommandLoader[] { new DynamicCommandLoader(scriptRuntime) });
-        }
-
-        [TearDown]
-        public void StopServer()
-        {
-            if (m_Server.State == ServerState.Running)
-                m_Server.Stop();
-        }
+        private Encoding m_Encoding = new UTF8Encoding();
 
         [Test]
         public void TestCommands()
         {
-            if (m_Server.State != ServerState.Running)
-                m_Server.Start();
+            var configSource = StartBootstrap("DLR.config");
+
+            var serverConfig = configSource.Servers.FirstOrDefault();
 
-            EndPoint serverAddress = new IPEndPoint(IPAddress.Parse("127.0.0.1"), m_ServerConfig.Port);
+            EndPoint serverAddress = new IPEndPoint(IPAddress.Parse("127.0.0.1"), serverConfig.Port);
 
             using (Socket socket = new Socket(serverAddress.AddressFamily, SocketType.Stream, ProtocolType.Tcp))
             {
@@ -109,10 +73,11 @@ public void TestCommands()
         [Test]
         public void TestPerformance()
         {
-            if (m_Server.State != ServerState.Running)
-                m_Server.Start();
+            var configSource = StartBootstrap("DLR.config");
+
+            var serverConfig = configSource.Servers.FirstOrDefault();
 
-            EndPoint serverAddress = new IPEndPoint(IPAddress.Parse("127.0.0.1"), m_ServerConfig.Port);
+            EndPoint serverAddress = new IPEndPoint(IPAddress.Parse("127.0.0.1"), serverConfig.Port);
 
             using (Socket socket = new Socket(serverAddress.AddressFamily, SocketType.Stream, ProtocolType.Tcp))
             {
diff --git a/Test/Protocol/CountSpliterProtocolTest.cs b/Test/Protocol/CountSpliterProtocolTest.cs
index 24d2411cc..05e04c805 100644
--- a/Test/Protocol/CountSpliterProtocolTest.cs
+++ b/Test/Protocol/CountSpliterProtocolTest.cs
@@ -2,11 +2,13 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
+using NUnit.Framework;
 using SuperSocket.Facility.Protocol;
 using SuperSocket.SocketBase.Protocol;
 
 namespace SuperSocket.Test.Protocol
 {
+    [TestFixture]
     public class CountSpliterProtocolTest : ProtocolTestBase
     {
         class TestReceiveFilter : CountSpliterReceiveFilter<StringRequestInfo>
diff --git a/Test/Protocol/FixedHeaderProtocolTest.cs b/Test/Protocol/FixedHeaderProtocolTest.cs
new file mode 100644
index 000000000..f0cf5fb16
--- /dev/null
+++ b/Test/Protocol/FixedHeaderProtocolTest.cs
@@ -0,0 +1,45 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using NUnit.Framework;
+using SuperSocket.Facility.Protocol;
+using SuperSocket.SocketBase.Protocol;
+
+namespace SuperSocket.Test.Protocol
+{
+    [TestFixture]
+    public class FixedHeaderProtocolTest : ProtocolTestBase
+    {
+        class TestReceiveFilter : FixedHeaderReceiveFilter<StringRequestInfo>
+        {
+            public TestReceiveFilter()
+                : base(8)
+            {
+
+            }
+
+            protected override int GetBodyLengthFromHeader(byte[] header, int offset, int length)
+            {
+                var strLen = Encoding.ASCII.GetString(header, offset + 4, 4);
+                return int.Parse(strLen.TrimStart('0'));
+            }
+
+            protected override StringRequestInfo ResolveRequestInfo(ArraySegment<byte> header, byte[] bodyBuffer, int offset, int length)
+            {
+                var body = Encoding.ASCII.GetString(bodyBuffer, offset, length);
+                return new StringRequestInfo(Encoding.ASCII.GetString(header.Array, header.Offset, 4), body, new string[] { body });
+            }
+        }
+
+        protected override IReceiveFilterFactory<StringRequestInfo> CurrentReceiveFilterFactory
+        {
+            get { return new DefaultReceiveFilterFactory<TestReceiveFilter, StringRequestInfo>(); }
+        }
+
+        protected override string CreateRequest(string sourceLine)
+        {
+            return string.Format("ECHO{0}{1}", sourceLine.Length.ToString().PadLeft(4), sourceLine);
+        }
+    }
+}
diff --git a/Test/Protocol/FixedSizeProtocolTest.cs b/Test/Protocol/FixedSizeProtocolTest.cs
new file mode 100644
index 000000000..30656046d
--- /dev/null
+++ b/Test/Protocol/FixedSizeProtocolTest.cs
@@ -0,0 +1,38 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using SuperSocket.Facility.Protocol;
+using SuperSocket.SocketBase.Protocol;
+
+namespace SuperSocket.Test.Protocol
+{
+    public class FixedSizeProtocolTest : ProtocolTestBase
+    {
+        class TestReceiveFilter : FixedSizeReceiveFilter<StringRequestInfo>
+        {
+            private BasicRequestInfoParser m_Parser = new BasicRequestInfoParser();
+
+            public TestReceiveFilter()
+                : base(41)
+            {
+
+            }
+
+            protected override StringRequestInfo ProcessMatchedRequest(byte[] buffer, int offset, int length, bool toBeCopied)
+            {
+                return m_Parser.ParseRequestInfo(Encoding.ASCII.GetString(buffer, offset, length));
+            }
+        }
+
+        protected override IReceiveFilterFactory<StringRequestInfo> CurrentReceiveFilterFactory
+        {
+            get { return new DefaultReceiveFilterFactory<TestReceiveFilter, StringRequestInfo>(); }
+        }
+
+        protected override string CreateRequest(string sourceLine)
+        {
+            return "ECHO " + sourceLine;
+        }
+    }
+}
diff --git a/Test/Protocol/ProtocolTestBase.cs b/Test/Protocol/ProtocolTestBase.cs
index 4d11951d6..beb7b1088 100644
--- a/Test/Protocol/ProtocolTestBase.cs
+++ b/Test/Protocol/ProtocolTestBase.cs
@@ -8,6 +8,7 @@
 using System.Threading;
 using System.Threading.Tasks;
 using NUnit.Framework;
+using SuperSocket.SocketBase;
 using SuperSocket.SocketBase.Config;
 using SuperSocket.SocketBase.Logging;
 using SuperSocket.SocketBase.Protocol;
@@ -20,25 +21,33 @@ public abstract class ProtocolTestBase
 
         protected abstract IReceiveFilterFactory<StringRequestInfo> CurrentReceiveFilterFactory { get; }
 
-        [TestFixtureSetUp]
+        [SetUp]
         public void Setup()
         {
-            m_Server = CreateServer(CurrentReceiveFilterFactory);
+            var mode = TestContext.CurrentContext.Test.Name.Contains("Udp") ? SocketMode.Udp : SocketMode.Tcp;
+            m_Server = CreateServer(CurrentReceiveFilterFactory, mode);
         }
 
-        [TestFixtureTearDown]
+        [TearDown]
         public void TearDown()
         {
             m_Server.Stop();
         }
 
         private TestServer CreateServer(IReceiveFilterFactory<StringRequestInfo> receiveFilterFactory)
+        {
+            return CreateServer(receiveFilterFactory, SocketMode.Tcp);
+        }
+
+        private TestServer CreateServer(IReceiveFilterFactory<StringRequestInfo> receiveFilterFactory, SocketMode mode)
         {
             var appServer = new TestServer();
 
             var serverConfig = new ServerConfig();
             serverConfig.Ip = "127.0.0.1";
             serverConfig.Port = 2012;
+            serverConfig.Mode = mode;
+            serverConfig.DisableSessionSnapshot = true;
 
             var setupResult = appServer.Setup(serverConfig, null, receiveFilterFactory, new ConsoleLogFactory(), null, null);
 
@@ -82,6 +91,31 @@ public void TestNormalRequest()
             }
         }
 
+        [Test]
+        public void TestMiddleBreak()
+        {
+            for (var i = 0; i < 100; i++)
+            {
+                using (var socket = CreateClient())
+                {
+                    var socketStream = new NetworkStream(socket);
+                    using (var reader = new StreamReader(socketStream, Encoding.ASCII, true))
+                    using (var writer = new ConsoleWriter(socketStream, Encoding.ASCII, 1024 * 8))
+                    {
+                        reader.ReadLine();
+
+                        var line = Guid.NewGuid().ToString();
+                        var sendingLine = CreateRequest(line);
+                        writer.Write(sendingLine.Substring(0, sendingLine.Length / 2));
+                        writer.Flush();
+
+                        var s = m_Server.GetAllSessions().FirstOrDefault();
+                        s.Close();
+                    }
+                }
+            }
+        }
+
         [Test]
         public void TestFragmentRequest()
         {
@@ -204,5 +238,26 @@ public void TestBreakRequest()
                 }
             }
         }
+
+
+        [Test]
+        public void TestUdpRequest()
+        {
+            EndPoint serverAddress = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 2012);
+            var client = new Socket(serverAddress.AddressFamily, SocketType.Dgram, ProtocolType.Udp);
+
+            var line = Guid.NewGuid().ToString();
+
+            var data = Encoding.ASCII.GetBytes(CreateRequest(line));
+
+            client.SendTo(data, serverAddress);
+
+            var receiveData = new byte[data.Length];
+
+            var len = client.ReceiveFrom(receiveData, ref serverAddress);
+
+            Assert.AreEqual(line.Length, len);
+            Assert.AreEqual(line, Encoding.ASCII.GetString(receiveData, 0, len));
+        }
     }
 }
diff --git a/Test/Protocol/TerminatorProtocolTest.cs b/Test/Protocol/TerminatorProtocolTest.cs
index c96e66e60..37e5da6ab 100644
--- a/Test/Protocol/TerminatorProtocolTest.cs
+++ b/Test/Protocol/TerminatorProtocolTest.cs
@@ -2,10 +2,12 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
+using NUnit.Framework;
 using SuperSocket.SocketBase.Protocol;
 
 namespace SuperSocket.Test.Protocol
 {
+    [TestFixture]
     public class TerminatorProtocolTest : ProtocolTestBase
     {
         private readonly Encoding m_Encoding = new ASCIIEncoding();
diff --git a/Test/SecureTcpSocketServerTest.cs b/Test/SecureTcpSocketServerTest.cs
index 489481a97..ee94970cf 100644
--- a/Test/SecureTcpSocketServerTest.cs
+++ b/Test/SecureTcpSocketServerTest.cs
@@ -16,29 +16,11 @@ namespace SuperSocket.Test
     [TestFixture]
     public class SecureTcpSocketServerTest : SocketServerTest
     {
-        protected override IServerConfig DefaultServerConfig
+        protected override string DefaultServerConfig
         {
             get
             {
-                return new ServerConfig
-                {
-                    Ip = "Any",
-                    LogCommand = true,
-                    MaxConnectionNumber = 100,
-                    Mode = SocketMode.Tcp,
-                    Name = "Secure Test Socket Server",
-                    Port = 2012,
-                    ClearIdleSession = true,
-                    ClearIdleSessionInterval = 1,
-                    IdleSessionTimeOut = 5,
-                    Security = "Tls",
-                    SendingQueueSize = 100,
-                    Certificate = new CertificateConfig
-                    {
-                        Password = "supersocket",
-                        FilePath = "supersocket.pfx"
-                    }
-                };
+                return "SecureTestServer.config";
             }
         }
 
diff --git a/Test/SocketServerTest.cs b/Test/SocketServerTest.cs
index cc9e4f1ed..578326404 100644
--- a/Test/SocketServerTest.cs
+++ b/Test/SocketServerTest.cs
@@ -6,6 +6,7 @@
 using System.Net.Sockets;
 using System.Text;
 using System.Threading;
+using System.Threading.Tasks;
 using NUnit.Framework;
 using SuperSocket.Common;
 using SuperSocket.SocketBase;
@@ -17,108 +18,37 @@
 
 namespace SuperSocket.Test
 {
-    public abstract class SocketServerTest
+    public abstract class SocketServerTest : BootstrapTestBase
     {
-        private static Dictionary<IServerConfig, IWorkItem[]> m_Servers = new Dictionary<IServerConfig, IWorkItem[]>();
-
-        protected readonly IServerConfig m_Config;
-
-        private IRootConfig m_RootConfig;
-        
         protected Encoding m_Encoding;
 
         public SocketServerTest()
         {
-            m_Config = DefaultServerConfig;
-            m_RootConfig = new RootConfig
-            {
-                MaxWorkingThreads = 500,
-                MaxCompletionPortThreads = 500,
-                MinWorkingThreads = 5,
-                MinCompletionPortThreads = 5,
-                DisablePerformanceDataCollector = true
-            };
-            
             m_Encoding = new UTF8Encoding();
         }
 
-        private IWorkItem GetServerByIndex(int index)
-        {
-            IWorkItem[] servers = new IWorkItem[0];
-
-            if (!m_Servers.TryGetValue(m_Config, out servers))
-                return null;
-
-            return servers[index];
-        }
-
-        private IWorkItem ServerX
-        {
-            get
-            {
-                return GetServerByIndex(0);
-            }
-        }
-
-        private IWorkItem ServerY
-        {
-            get
-            {
-                return GetServerByIndex(1);
-            }
-        }
-
-        protected abstract IServerConfig DefaultServerConfig { get; }
-
-        [TestFixtureSetUp]
-        public void Setup()
-        {
-            if (m_Servers.ContainsKey(m_Config))
-                return;
+        protected abstract string DefaultServerConfig { get; }
 
-            var serverX = CreateAppServer<TestServer>();
-
-            var serverY = CreateAppServer<TestServerWithCustomRequestFilter>();
-
-            m_Servers[m_Config] = new IWorkItem[]
-            {
-                serverX,
-                serverY
-            };
-        }
-
-        private IWorkItem CreateAppServer<T>()
-            where T : IWorkItem, ITestSetup, new()
+        [Test, Repeat(3)]
+        public void TestStartStop()
         {
-            return CreateAppServer<T>(m_RootConfig, m_Config);
-        }
+            SetupBootstrap(DefaultServerConfig);
+            var bootstrap = BootStrap;
+            var server = bootstrap.GetServerByName("TestServer");
 
-        protected virtual IWorkItem CreateAppServer<T>(IRootConfig rootConfig, IServerConfig serverConfig)
-            where T : IWorkItem, ITestSetup, new()
-        {
-            var appServer = new T();
-            appServer.Setup(rootConfig, serverConfig);
-            return appServer;
-        }
+            bootstrap.Start();
+            Assert.IsTrue(server.State == ServerState.Running);
 
-        [TearDown]
-        public void StopAllServers()
-        {
-            StopServer();
-        }
+            bootstrap.Stop();
+            Assert.IsTrue(server.State == ServerState.NotStarted);
 
-        [Test, Repeat(10)]
-        public void TestStartStop()
-        {
-            StartServer();
-            Assert.IsTrue(ServerX.State == ServerState.Running);
-            StopServer();
-            Assert.IsTrue(ServerX.State == ServerState.NotStarted);
+            bootstrap.Start();
+            Assert.IsTrue(server.State == ServerState.Running);
         }
 
-        private bool CanConnect()
+        private bool CanConnect(int port)
         {
-            EndPoint serverAddress = new IPEndPoint(IPAddress.Parse("127.0.0.1"), m_Config.Port);
+            EndPoint serverAddress = new IPEndPoint(IPAddress.Parse("127.0.0.1"), port);
 
             using (Socket socket = CreateClientSocket())
             {
@@ -134,31 +64,6 @@ private bool CanConnect()
             }
         }
 
-        protected void StartServer()
-        {
-            if (ServerX.State == ServerState.Running)
-                ServerX.Stop();
-
-            ServerX.Start();
-            Console.WriteLine("Socket server X has been started!");
-        }
-
-        [TearDown]
-        public void StopServer()
-        {
-            if (ServerX.State == ServerState.Running)
-            {
-                ServerX.Stop();
-                Console.WriteLine("Socket server X has been stopped!");
-            }
-
-            if (ServerY != null && ServerY.State == ServerState.Running)
-            {
-                ServerY.Stop();
-                Console.WriteLine("Socket server Y has been stopped!");
-            }
-        }
-
         protected virtual Socket CreateClientSocket()
         {
             return new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
@@ -172,9 +77,9 @@ protected virtual Stream GetSocketStream(Socket socket)
         [Test, Repeat(3)]
         public void TestWelcomeMessage()
         {
-            StartServer();
-
-            EndPoint serverAddress = new IPEndPoint(IPAddress.Parse("127.0.0.1"), m_Config.Port);
+            var configSource = StartBootstrap(DefaultServerConfig);
+            var serverConfig = configSource.Servers.FirstOrDefault();
+            EndPoint serverAddress = new IPEndPoint(IPAddress.Parse("127.0.0.1"), serverConfig.Port);
 
             using (Socket socket = CreateClientSocket())
             {
@@ -184,7 +89,7 @@ public void TestWelcomeMessage()
                 using (ConsoleWriter writer = new ConsoleWriter(socketStream, m_Encoding, 1024 * 8))
                 {
                     string welcomeString = reader.ReadLine();
-                    Assert.AreEqual(string.Format(TestSession.WelcomeMessageFormat, m_Config.Name), welcomeString);
+                    Assert.AreEqual(string.Format(TestSession.WelcomeMessageFormat, serverConfig.Name), welcomeString);
                 }
             }
         }
@@ -192,15 +97,21 @@ public void TestWelcomeMessage()
         [Test]
         public void TestSessionConnectedState()
         {
-            StartServer();
+            byte[] data = new byte[] { 0xff, 0xff, 0xff, 0xf0 };
+
+            Console.WriteLine(BitConverter.ToInt32(data, 0));
 
-            var server = ServerX as IAppServer;
+            var configSource = SetupBootstrap(DefaultServerConfig);
 
-            //AppDomain isolation
-            if (server == null)
+            if (configSource.Isolation != IsolationMode.None)
                 return;
 
-            EndPoint serverAddress = new IPEndPoint(IPAddress.Parse("127.0.0.1"), m_Config.Port);
+            var serverConfig = configSource.Servers.FirstOrDefault();
+            EndPoint serverAddress = new IPEndPoint(IPAddress.Parse("127.0.0.1"), serverConfig.Port);
+
+            BootStrap.Start();
+
+            var server = BootStrap.AppServers.FirstOrDefault() as IAppServer;
 
             using (Socket socket = CreateClientSocket())
             {
@@ -235,38 +146,67 @@ public void TestSessionConnectedState()
                         catch { }
                     }
 
-                    Thread.Sleep(100);
-                    Assert.IsFalse(session.Connected);
+                    while (true)
+                    {
+                        Thread.Sleep(5000);
+
+                        if (!session.Connected)
+                            break;
+                    }
                 }
             }
         }
 
-        private bool TestMaxConnectionNumber(int maxConnectionNumber)
+        private bool TryConnect(EndPoint serverAddress)
         {
-            var defaultConfig = DefaultServerConfig;
+            var task = Task.Factory.StartNew(() =>
+                {
+                    using (Socket trySocket = CreateClientSocket())
+                    {
+                        trySocket.Connect(serverAddress);
+                        var innerSocketStream = GetSocketStream(trySocket);
+                        innerSocketStream.ReadTimeout = 500;
 
-            var config = new ServerConfig
+                        using (var tryReader = new StreamReader(innerSocketStream, m_Encoding, true))
+                        {
+                            return tryReader.ReadLine() != null;
+                        }
+                    }
+                });
+
+            try
+            {
+                if (!task.Wait(1500))
+                    return false;
+            }
+            catch
             {
-                Ip = defaultConfig.Ip,
-                LogCommand = defaultConfig.LogCommand,
-                MaxConnectionNumber = maxConnectionNumber,
-                Mode = defaultConfig.Mode,
-                Name = defaultConfig.Name,
-                Port = defaultConfig.Port,
-                Security = defaultConfig.Security,
-                Certificate = defaultConfig.Certificate
-            };
-
-            var server = CreateAppServer<TestServer>(m_RootConfig, config);
+                return false;
+            }
+
+            return task.Result;
+        }
+
+        private bool TestMaxConnectionNumber(int maxConnectionNumber)
+        {
+            var configSource = SetupBootstrap(DefaultServerConfig, new Func<IServerConfig, IServerConfig>(c =>
+                {
+                    var nc = new ServerConfig(c);
+                    nc.MaxConnectionNumber = maxConnectionNumber;
+                    return nc;
+                }));
+
+            BootStrap.Start();
+
+            var config = configSource.Servers.FirstOrDefault();
+            EndPoint serverAddress = new IPEndPoint(IPAddress.Parse("127.0.0.1"), config.Port);
 
             List<Socket> sockets = new List<Socket>();
 
+            var server = BootStrap.AppServers.FirstOrDefault();
+
             try
             {
-                server.Start();
-
-                EndPoint serverAddress = new IPEndPoint(IPAddress.Parse("127.0.0.1"), m_Config.Port);
-
                 for (int i = 0; i < maxConnectionNumber; i++)
                 {
                     Socket socket = CreateClientSocket();
@@ -277,35 +217,26 @@ private bool TestMaxConnectionNumber(int maxConnectionNumber)
                     sockets.Add(socket);
                 }
 
-                try
-                {
-                    using (Socket trySocket = CreateClientSocket())
-                    {
-                        trySocket.Connect(serverAddress);
-                        var innerSocketStream = new NetworkStream(trySocket);
-                        innerSocketStream.ReadTimeout = 500;
+                Assert.AreEqual(maxConnectionNumber, server.SessionCount);
 
-                        using (StreamReader tryReader = new StreamReader(innerSocketStream, m_Encoding, true))
-                        {
-                            string welcome = tryReader.ReadLine();
-                            Console.WriteLine(welcome);
-                            return true;
-                        }
-                    }
-                }
-                catch (Exception)
-                {
-                    return true;
-                }
+                Assert.IsFalse(TryConnect(serverAddress));
+
+                sockets[0].SafeClose();
+
+                Thread.Sleep(500);
+
+                Assert.AreEqual(maxConnectionNumber - 1, server.SessionCount);
+
+                return TryConnect(serverAddress);
             }
             catch (Exception e)
             {
                 Console.WriteLine(e.Message + " " + e.StackTrace);
-                return false;
+                throw e;
             }
             finally
             {
-                server.Stop();
+                ClearBootstrap();
             }
         }
 
@@ -321,9 +252,9 @@ public void TestMaxConnectionNumber()
         [Test, Repeat(2)]
         public void TestUnknownCommand()
         {
-            StartServer();
-
-            EndPoint serverAddress = new IPEndPoint(IPAddress.Parse("127.0.0.1"), m_Config.Port);
+            var configSource = StartBootstrap(DefaultServerConfig);
+            var serverConfig = configSource.Servers.FirstOrDefault();
+            EndPoint serverAddress = new IPEndPoint(IPAddress.Parse("127.0.0.1"), serverConfig.Port);
 
             using (Socket socket = CreateClientSocket())
             {
@@ -355,9 +286,9 @@ public void TestUnknownCommand()
         [Test]
         public void TestEchoMessage()
         {
-            StartServer();
-
-            EndPoint serverAddress = new IPEndPoint(IPAddress.Parse("127.0.0.1"), m_Config.Port);
+            var configSource = StartBootstrap(DefaultServerConfig);
+            var serverConfig = configSource.Servers.FirstOrDefault();
+            EndPoint serverAddress = new IPEndPoint(IPAddress.Parse("127.0.0.1"), serverConfig.Port);
 
             using (Socket socket = CreateClientSocket())
             {
@@ -394,9 +325,9 @@ public void TestEchoMessage()
         [Test]
         public void TestCommandCombining()
         {
-            StartServer();
-
-            EndPoint serverAddress = new IPEndPoint(IPAddress.Parse("127.0.0.1"), m_Config.Port);
+            var configSource = StartBootstrap(DefaultServerConfig);
+            var serverConfig = configSource.Servers.FirstOrDefault();
+            EndPoint serverAddress = new IPEndPoint(IPAddress.Parse("127.0.0.1"), serverConfig.Port);
 
             using (Socket socket = CreateClientSocket())
             {
@@ -443,9 +374,9 @@ public void TestCommandCombining()
         [Test]
         public void TestBrokenCommandBlock()
         {
-            StartServer();
-
-            EndPoint serverAddress = new IPEndPoint(IPAddress.Parse("127.0.0.1"), m_Config.Port);
+            var configSource = StartBootstrap(DefaultServerConfig);
+            var serverConfig = configSource.Servers.FirstOrDefault();
+            EndPoint serverAddress = new IPEndPoint(IPAddress.Parse("127.0.0.1"), serverConfig.Port);
 
             using (Socket socket = CreateClientSocket())
             {
@@ -493,9 +424,9 @@ public void TestBrokenCommandBlock()
             }
         }
 
-        private bool RunEchoMessage(int runIndex)
+        private bool RunEchoMessage(int port, int runIndex)
         {
-            EndPoint serverAddress = new IPEndPoint(IPAddress.Parse("127.0.0.1"), m_Config.Port);
+            EndPoint serverAddress = new IPEndPoint(IPAddress.Parse("127.0.0.1"), port);
 
             Socket socket = CreateClientSocket();
             socket.Connect(serverAddress);
@@ -533,7 +464,11 @@ private bool RunEchoMessage(int runIndex)
         [Test, Repeat(3), Category("Concurrency")]
         public void TestConcurrencyCommunication()
         {
-            StartServer();
+            var configSource = StartBootstrap(DefaultServerConfig, c => new ServerConfig(c)
+                {
+                    IdleSessionTimeOut = 180
+                });
+            var serverConfig = configSource.Servers.FirstOrDefault();
 
             int concurrencyCount = 100;
 
@@ -543,7 +478,7 @@ public void TestConcurrencyCommunication()
 
             System.Threading.Tasks.Parallel.For(0, concurrencyCount, i =>
             {
-                resultArray[i] = RunEchoMessage(i);
+                resultArray[i] = RunEchoMessage(serverConfig.Port, i);
                 semaphore.Release();
             });
 
@@ -569,9 +504,15 @@ public void TestConcurrencyCommunication()
         [Test, Repeat(5)]
         public virtual void TestClearTimeoutSession()
         {
-            StartServer();
+            var configSource = StartBootstrap(DefaultServerConfig, c => new ServerConfig(c)
+            {
+                ClearIdleSession = true
+            });
 
-            EndPoint serverAddress = new IPEndPoint(IPAddress.Parse("127.0.0.1"), m_Config.Port);
+            var serverConfig = configSource.Servers.FirstOrDefault();
+            EndPoint serverAddress = new IPEndPoint(IPAddress.Parse("127.0.0.1"), serverConfig.Port);
+
+            var server = BootStrap.AppServers.FirstOrDefault();
 
             Socket socket = CreateClientSocket();
             socket.Connect(serverAddress);
@@ -582,19 +523,19 @@ public virtual void TestClearTimeoutSession()
                 reader.ReadLine();
             }
 
-            Assert.AreEqual(1, ServerX.SessionCount);
+            Assert.AreEqual(1, server.SessionCount);
             Thread.Sleep(2000);
-            Assert.AreEqual(1, ServerX.SessionCount);
+            Assert.AreEqual(1, server.SessionCount);
             Thread.Sleep(5000);
-            Assert.AreEqual(0, ServerX.SessionCount);
+            Assert.AreEqual(0, server.SessionCount);
         }
 
         [Test]
         public void TestCustomCommandName()
         {
-            StartServer();
-
-            EndPoint serverAddress = new IPEndPoint(IPAddress.Parse("127.0.0.1"), m_Config.Port);
+            var configSource = StartBootstrap(DefaultServerConfig);
+            var serverConfig = configSource.Servers.FirstOrDefault();
+            EndPoint serverAddress = new IPEndPoint(IPAddress.Parse("127.0.0.1"), serverConfig.Port);
 
             using (Socket socket = CreateClientSocket())
             {
@@ -617,13 +558,14 @@ public void TestCustomCommandName()
         [Test, Repeat(3)]
         public void TestCommandParser()
         {
-            if (ServerY.State == ServerState.Running)
-                ServerY.Stop();
-
-            ServerY.Start();
-            Console.WriteLine("Socket server Y has been started!");
+            var configSource = StartBootstrap(DefaultServerConfig, c =>
+                new ServerConfig(c)
+                {
+                    ServerType = "SuperSocket.Test.TestServerWithCustomRequestFilter, SuperSocket.Test"
+                });
 
-            EndPoint serverAddress = new IPEndPoint(IPAddress.Parse("127.0.0.1"), m_Config.Port);
+            var serverConfig = configSource.Servers.FirstOrDefault();
+            EndPoint serverAddress = new IPEndPoint(IPAddress.Parse("127.0.0.1"), serverConfig.Port);
 
             using (Socket socket = CreateClientSocket())
             {
@@ -642,12 +584,116 @@ public void TestCommandParser()
             }
         }
 
+        [Test]
+        public void TestCloseFromClient()
+        {
+            var configSource = StartBootstrap(DefaultServerConfig, c =>
+                new ServerConfig(c)
+                {
+                    LogBasicSessionActivity = false,
+                    ClearIdleSession = false,
+                    MaxConnectionNumber = 1000,
+                });
+
+            var n = 100;
+            var sockets = new List<Socket>(n);
+            var server = BootStrap.AppServers.FirstOrDefault();
+
+            var serverConfig = configSource.Servers.FirstOrDefault();
+            EndPoint serverAddress = new IPEndPoint(IPAddress.Parse("127.0.0.1"), serverConfig.Port);
+
+            for (var i = 0; i < n; i++)
+            {
+                Socket socket = CreateClientSocket();
+                socket.Connect(serverAddress);
+                sockets.Add(socket);
+            }
+
+            Console.WriteLine(sockets.Count);
+            Thread.Sleep(500);
+            Assert.AreEqual(n, server.SessionCount);
+
+            for (var i = n - 1; i >= 0; i--)
+            {
+                var s = sockets[i];
+
+                s.SafeClose();
+
+                Thread.Sleep(100);
+
+                if (i != server.SessionCount)
+                {
+                    Thread.Sleep(500);
+                    Assert.AreEqual(i, server.SessionCount);
+                }
+                
+                Console.WriteLine("Conn: {0}", i);
+            }
+        }
+
+        [Test]
+        public void TestCloseFromServer()
+        {
+            var configSource = StartBootstrap(DefaultServerConfig, c =>
+                new ServerConfig(c)
+                {
+                    LogBasicSessionActivity = false,
+                    ClearIdleSession = false,
+                    MaxConnectionNumber = 1000,
+                });
+
+            var n = 100;
+            var sockets = new List<Socket>(n);
+            var server = BootStrap.AppServers.FirstOrDefault();
+
+            var serverConfig = configSource.Servers.FirstOrDefault();
+            EndPoint serverAddress = new IPEndPoint(IPAddress.Parse("127.0.0.1"), serverConfig.Port);
+
+            for (var i = 0; i < n; i++)
+            {
+                Socket socket = CreateClientSocket();
+                socket.Connect(serverAddress);
+                sockets.Add(socket);
+            }
+
+            Console.WriteLine(sockets.Count);
+            Thread.Sleep(500);
+            Assert.AreEqual(n, server.SessionCount);
+
+            for (var i = n - 1; i >= 0; i--)
+            {
+                var s = sockets[i];
+
+                Stream socketStream = GetSocketStream(s);
+                using (ConsoleWriter writer = new ConsoleWriter(socketStream, m_Encoding, 1024 * 8))
+                {
+                    writer.WriteLine("CLOSE");
+                    writer.Flush();
+                }
+
+                Thread.Sleep(100);
+
+                if (i != server.SessionCount)
+                {
+                    Thread.Sleep(500);
+                    Assert.AreEqual(i, server.SessionCount);
+                }
+
+                Console.WriteLine("Conn: {0}", i);
+            }
+        }
+
         [Test, Repeat(5)]
         public void TestConcurrentSending()
         {
-            StartServer();
+            var configSource = StartBootstrap(DefaultServerConfig, c => new ServerConfig(c)
+                {
+                    SendingQueueSize = 100
+                });
 
-            EndPoint serverAddress = new IPEndPoint(IPAddress.Parse("127.0.0.1"), m_Config.Port);
+            var serverConfig = configSource.Servers.FirstOrDefault();
+
+            EndPoint serverAddress = new IPEndPoint(IPAddress.Parse("127.0.0.1"), serverConfig.Port);
 
             string[] source = SEND.GetStringSource();
 
@@ -702,13 +748,15 @@ public void TestConcurrentSending()
         [Test]
         public void TestFastSending()
         {
-            StartServer();
+            var configSource = StartBootstrap(DefaultServerConfig, c => new ServerConfig(c)
+                {
+                    LogBasicSessionActivity = false,
+                    SendingQueueSize = 100
+                });
 
-            EndPoint serverAddress = new IPEndPoint(IPAddress.Parse("127.0.0.1"), m_Config.Port);
+            var serverConfig = configSource.Servers.FirstOrDefault();
 
-            string[] source = SEND.GetStringSource();
-
-            string[] received = new string[source.Length];
+            EndPoint serverAddress = new IPEndPoint(IPAddress.Parse("127.0.0.1"), serverConfig.Port);
 
             using (Socket socket = CreateClientSocket())
             {
diff --git a/Test/SuperSocket.Test.NET35.csproj b/Test/SuperSocket.Test.NET35.csproj
index ffd49c69c..ab6e8707e 100644
--- a/Test/SuperSocket.Test.NET35.csproj
+++ b/Test/SuperSocket.Test.NET35.csproj
@@ -73,8 +73,10 @@
   <ItemGroup>
     <Compile Include="AppDomainSocketServerTest.cs" />
     <Compile Include="BootstrapTest.cs" />
+    <Compile Include="BootstrapTestBase.cs" />
     <Compile Include="ChildConfigTestServer.cs" />
     <Compile Include="Command\ADDCS.cs" />
+    <Compile Include="Command\CLOSE.cs" />
     <Compile Include="Command\DOMAIN.cs" />
     <Compile Include="Command\ECHO.cs" />
     <Compile Include="Command\MULTCS.cs" />
@@ -94,6 +96,8 @@
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="Protocol\BeginEndMarkProtocolTest.cs" />
     <Compile Include="Protocol\CountSpliterProtocolTest.cs" />
+    <Compile Include="Protocol\FixedHeaderProtocolTest.cs" />
+    <Compile Include="Protocol\FixedSizeProtocolTest.cs" />
     <Compile Include="Protocol\ProtocolTestBase.cs" />
     <Compile Include="Protocol\TerminatorProtocolTest.cs" />
     <Compile Include="SecureTcpSocketServerTest.cs" />
@@ -121,6 +125,12 @@
     <Content Include="supersocket.pfx">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </Content>
+    <None Include="Config\ConnectionFilter.config">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
+    <None Include="Config\TestServer.config">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\Common\SuperSocket.Common.Net35.csproj">
@@ -148,6 +158,9 @@
     <None Include="Config\AppDomain.config">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </None>
+    <None Include="Config\AppDomainTestServer.config">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
     <None Include="Config\Basic.config">
       <SubType>Designer</SubType>
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
@@ -174,6 +187,9 @@
     </None>
   </ItemGroup>
   <ItemGroup>
+    <None Include="Config\SecureTestServer.config">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
     <None Include="Config\ServerType.config">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </None>
diff --git a/Test/SuperSocket.Test.Net40.csproj b/Test/SuperSocket.Test.Net40.csproj
index 7b30331be..afd89dc43 100644
--- a/Test/SuperSocket.Test.Net40.csproj
+++ b/Test/SuperSocket.Test.Net40.csproj
@@ -36,6 +36,12 @@
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
   </PropertyGroup>
+  <PropertyGroup>
+    <SignAssembly>true</SignAssembly>
+  </PropertyGroup>
+  <PropertyGroup>
+    <AssemblyOriginatorKeyFile>..\supersocket.snk</AssemblyOriginatorKeyFile>
+  </PropertyGroup>
   <ItemGroup>
     <Reference Include="IronPython">
       <HintPath>..\Reference\IronPython\Net40\IronPython.dll</HintPath>
@@ -68,8 +74,10 @@
   <ItemGroup>
     <Compile Include="AppDomainSocketServerTest.cs" />
     <Compile Include="BootstrapTest.cs" />
+    <Compile Include="BootstrapTestBase.cs" />
     <Compile Include="ChildConfigTestServer.cs" />
     <Compile Include="Command\ADDCS.cs" />
+    <Compile Include="Command\CLOSE.cs" />
     <Compile Include="Command\DOMAIN.cs" />
     <Compile Include="Command\MULTCS.cs" />
     <Compile Include="Command\SEND.cs" />
@@ -81,6 +89,8 @@
     <Compile Include="ITestSetup.cs" />
     <Compile Include="Protocol\BeginEndMarkProtocolTest.cs" />
     <Compile Include="Protocol\CountSpliterProtocolTest.cs" />
+    <Compile Include="Protocol\FixedHeaderProtocolTest.cs" />
+    <Compile Include="Protocol\FixedSizeProtocolTest.cs" />
     <Compile Include="Protocol\ProtocolTestBase.cs" />
     <Compile Include="Protocol\TerminatorProtocolTest.cs" />
     <Compile Include="TcpSocketServerTest.cs" />
@@ -143,6 +153,18 @@
     <None Include="Config\Basic.config">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </None>
+    <None Include="Config\AppDomainTestServer.config">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
+    <None Include="Config\ConnectionFilter.config">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
+    <None Include="Config\SecureTestServer.config">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
+    <None Include="Config\TestServer.config">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
     <None Include="Config\Listeners.config">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </None>
@@ -156,6 +178,7 @@
   <ItemGroup>
     <None Include="Config\DLR.config">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+      <SubType>Designer</SubType>
     </None>
   </ItemGroup>
   <ItemGroup>
diff --git a/Test/SuperSocket.Test.Net45.csproj b/Test/SuperSocket.Test.Net45.csproj
index 763f61d13..51d4bcfcb 100644
--- a/Test/SuperSocket.Test.Net45.csproj
+++ b/Test/SuperSocket.Test.Net45.csproj
@@ -70,8 +70,10 @@
   <ItemGroup>
     <Compile Include="AppDomainSocketServerTest.cs" />
     <Compile Include="BootstrapTest.cs" />
+    <Compile Include="BootstrapTestBase.cs" />
     <Compile Include="ChildConfigTestServer.cs" />
     <Compile Include="Command\ADDCS.cs" />
+    <Compile Include="Command\CLOSE.cs" />
     <Compile Include="Command\DOMAIN.cs" />
     <Compile Include="Command\MULTCS.cs" />
     <Compile Include="Command\SEND.cs" />
@@ -83,6 +85,8 @@
     <Compile Include="ITestSetup.cs" />
     <Compile Include="Protocol\BeginEndMarkProtocolTest.cs" />
     <Compile Include="Protocol\CountSpliterProtocolTest.cs" />
+    <Compile Include="Protocol\FixedHeaderProtocolTest.cs" />
+    <Compile Include="Protocol\FixedSizeProtocolTest.cs" />
     <Compile Include="Protocol\ProtocolTestBase.cs" />
     <Compile Include="Protocol\TerminatorProtocolTest.cs" />
     <Compile Include="TcpSocketServerTest.cs" />
@@ -140,8 +144,17 @@
     <Content Include="supersocket.pfx">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </Content>
+    <None Include="Config\ConnectionFilter.config">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
+    <None Include="Config\TestServer.config">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
   </ItemGroup>
   <ItemGroup>
+    <None Include="Config\AppDomainTestServer.config">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
     <None Include="Config\Basic.config">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </None>
@@ -182,6 +195,9 @@
     </None>
   </ItemGroup>
   <ItemGroup>
+    <None Include="Config\SecureTestServer.config">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
     <None Include="Config\ServerType.config">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </None>
diff --git a/Test/TcpSocketServerTest.cs b/Test/TcpSocketServerTest.cs
index e5b578af1..50c23179b 100644
--- a/Test/TcpSocketServerTest.cs
+++ b/Test/TcpSocketServerTest.cs
@@ -11,23 +11,11 @@ namespace SuperSocket.Test
     [TestFixture]
     public class TcpSocketServerTest : SocketServerTest
     {
-        protected override IServerConfig DefaultServerConfig
+        protected override string DefaultServerConfig
         {
             get
             {
-                return new ServerConfig
-                    {
-                        Ip = "Any",
-                        LogCommand = false,
-                        MaxConnectionNumber = 100,
-                        Mode = SocketMode.Tcp,
-                        Name = "Async Test Socket Server",
-                        Port = 2012,
-                        ClearIdleSession = true,
-                        ClearIdleSessionInterval = 1,
-                        IdleSessionTimeOut = 5,
-                        SendingQueueSize = 100
-                    };
+                return "TestServer.config";
             }
         }
     }
diff --git a/Test/TestServer.cs b/Test/TestServer.cs
index 7a278dce1..9a97c3d0f 100644
--- a/Test/TestServer.cs
+++ b/Test/TestServer.cs
@@ -3,6 +3,7 @@
 using System.Linq;
 using System.Text;
 using SuperSocket.Dlr;
+using SuperSocket.Common;
 using SuperSocket.SocketBase;
 using SuperSocket.SocketBase.Command;
 using SuperSocket.SocketBase.Config;
@@ -35,9 +36,19 @@ public TestServer(IRequestInfoParser<StringRequestInfo> requestInfoParser)
             
         }
 
-        void ITestSetup.Setup(IRootConfig rootConfig, IServerConfig serverConfig)
+        protected override bool Setup(IRootConfig rootConfig, IServerConfig serverConfig)
         {
+            var sendWelcome = true;
+            bool.TryParse(serverConfig.Options.GetValue("sendWelcome", "true"), out sendWelcome);
+            SendWelcome = sendWelcome;
+            return true;
+        }
+
+        void ITestSetup.Setup(IRootConfig rootConfig, IServerConfig serverConfig)
+        {            
             base.Setup(rootConfig, serverConfig, null, null, new ConsoleLogFactory(), null);
         }
+
+        internal bool SendWelcome { get; private set; }
     }
 }
diff --git a/Test/TestSession.cs b/Test/TestSession.cs
index a8e58fd59..556673beb 100644
--- a/Test/TestSession.cs
+++ b/Test/TestSession.cs
@@ -12,10 +12,18 @@ public class TestSession : AppSession<TestSession>
         public const string WelcomeMessageFormat = "Welcome to {0}";
         public const string UnknownCommandMessageFormat = "Unknown command: {0}";
 
+        public new TestServer AppServer
+        {
+            get { return (TestServer)base.AppServer; }
+        }
+
         protected override void OnSessionStarted()
         {
-            if(AppServer.Config.Mode != SocketMode.Udp)
-                Send(string.Format(WelcomeMessageFormat, AppServer.Name));
+            if (AppServer.SendWelcome)
+            {
+                if (AppServer.Config.Mode != SocketMode.Udp)
+                    Send(string.Format(WelcomeMessageFormat, AppServer.Name));
+            }
         }
 
         protected override void HandleException(Exception e)
diff --git a/Test/UdpSocketServerTest.cs b/Test/UdpSocketServerTest.cs
index c295d12de..b0c45803a 100644
--- a/Test/UdpSocketServerTest.cs
+++ b/Test/UdpSocketServerTest.cs
@@ -6,16 +6,16 @@
 using System.Net.Sockets;
 using System.Text;
 using System.Threading;
+using System.Threading.Tasks;
 using NUnit.Framework;
 using SuperSocket.Common;
 using SuperSocket.SocketBase;
 using SuperSocket.SocketBase.Command;
 using SuperSocket.SocketBase.Config;
+using SuperSocket.SocketBase.Logging;
 using SuperSocket.SocketBase.Protocol;
 using SuperSocket.SocketEngine;
 using SuperSocket.Test.Udp;
-using SuperSocket.SocketBase.Logging;
-using System.Threading.Tasks;
 
 namespace SuperSocket.Test
 {
@@ -37,10 +37,11 @@ public byte[] ToData()
             data.AddRange(Encoding.ASCII.GetBytes(SessionID));
 
             int expectedLen = 36 + 4;
+            int maxLen = expectedLen - data.Count;
 
-            if (data.Count < expectedLen)
+            if (maxLen > 0)
             {
-                for (var i = 0; i < expectedLen - data.Count; i++)
+                for (var i = 0; i < maxLen; i++)
                 {
                     data.Add(0x00);
                 }
@@ -60,6 +61,8 @@ public class UdpSocketServerTest
         private IRootConfig m_RootConfig;
         private Encoding m_Encoding;
 
+		private string m_NewLine = "\r\n";
+
         protected IServerConfig DefaultServerConfig
         {
             get
@@ -68,7 +71,7 @@ protected IServerConfig DefaultServerConfig
                     {
                         Ip = "127.0.0.1",
                         LogCommand = true,
-                        MaxConnectionNumber = 100,
+                        MaxConnectionNumber = 1000,
                         Mode = SocketMode.Udp,
                         Name = "Udp Test Socket Server",
                         Port = 2196,
@@ -151,7 +154,7 @@ public void TestEchoMessage()
                     sb.Append(chars[rd.Next(0, chars.Length - 1)]);
                     string command = sb.ToString();
                     Console.WriteLine("Client prepare sent:" + command);
-                    socket.SendTo(m_Encoding.GetBytes("ECHO " + command + Environment.NewLine), serverAddress);
+                    socket.SendTo(m_Encoding.GetBytes("ECHO " + command + m_NewLine), serverAddress);
                     Console.WriteLine("Client sent:" + command);
                     string echoMessage = m_Encoding.GetString(ReceiveMessage(socket, serverAddress).ToArray());
                     Console.WriteLine("C:" + echoMessage);
@@ -231,7 +234,7 @@ public void TestCommandCombining()
                         sb.Append(chars[rd.Next(0, chars.Length - 1)]);
                         string command = sb.ToString();
                         source.Add(command);
-                        sbCombile.AppendLine("ECHO " + command);
+                        sbCombile.Append("ECHO " + command + m_NewLine);
                     }
 
                     socket.SendTo(m_Encoding.GetBytes(sbCombile.ToString()), serverAddress);                    
@@ -266,7 +269,7 @@ private bool RunEchoMessage()
                     sb.Append(chars[rd.Next(0, chars.Length - 1)]);
                     string command = sb.ToString();
 
-                    socket.SendTo(m_Encoding.GetBytes("ECHO " + command + Environment.NewLine), serverAddress);
+                    socket.SendTo(m_Encoding.GetBytes("ECHO " + command + m_NewLine), serverAddress);
                     string echoMessage = m_Encoding.GetString(ReceiveMessage(socket, serverAddress).ToArray());
                     if (!string.Equals(command, echoMessage))
                     {
@@ -320,7 +323,7 @@ public void TestUnknownCommand()
                 {
                     string commandName = Guid.NewGuid().ToString().Substring(0, 3);
                     string command = commandName + " " + DateTime.Now;
-                    socket.SendTo(m_Encoding.GetBytes(command + Environment.NewLine), serverAddress);
+                    socket.SendTo(m_Encoding.GetBytes(command + m_NewLine), serverAddress);
                     string line = m_Encoding.GetString(ReceiveMessage(socket, serverAddress).ToArray());
                     Console.WriteLine(line);
                     Assert.AreEqual(string.Format(TestSession.UnknownCommandMessageFormat, commandName), line);
@@ -338,7 +341,7 @@ public void TestCustomCommandName()
             using (Socket socket = CreateClientSocket())
             {
                 string param = Guid.NewGuid().ToString();
-                string command = "325 " + param + Environment.NewLine;
+                string command = "325 " + param + m_NewLine;
                 socket.SendTo(m_Encoding.GetBytes(command), serverAddress);
                 string echoMessage = m_Encoding.GetString(ReceiveMessage(socket, serverAddress).ToArray());
                 Console.WriteLine("C:" + echoMessage);
@@ -361,7 +364,7 @@ public void TestCommandParser()
                 using (Socket socket = CreateClientSocket())
                 {
                     string command = string.Format("Hello World ({0})!", Guid.NewGuid().ToString());
-                    socket.SendTo(m_Encoding.GetBytes("ECHO:" + command + Environment.NewLine), serverAddress);
+                    socket.SendTo(m_Encoding.GetBytes("ECHO:" + command + m_NewLine), serverAddress);
                     string echoMessage = m_Encoding.GetString(ReceiveMessage(socket, serverAddress).ToArray());
                     Assert.AreEqual(command, echoMessage);
                 }
@@ -405,14 +408,14 @@ private bool TestMaxConnectionNumber(int maxConnectionNumber)
                 for (int i = 0; i < maxConnectionNumber; i++)
                 {
                     Socket socket = CreateClientSocket();
-                    socket.SendTo(m_Encoding.GetBytes(Guid.NewGuid().ToString() + Environment.NewLine), serverAddress);
+                    socket.SendTo(m_Encoding.GetBytes(Guid.NewGuid().ToString() + m_NewLine), serverAddress);
                     Console.WriteLine("C: " + m_Encoding.GetString(ReceiveMessage(socket, serverAddress).ToArray()));
                     sockets.Add(socket);
                 }
 
                 using (Socket trySocket = CreateClientSocket())
                 {
-                    trySocket.SendTo(m_Encoding.GetBytes(Guid.NewGuid().ToString() + Environment.NewLine), serverAddress);
+                    trySocket.SendTo(m_Encoding.GetBytes(Guid.NewGuid().ToString() + m_NewLine), serverAddress);
                     Thread thread = new Thread(new ThreadStart(() =>
                         {
                             Console.WriteLine("C: " + m_Encoding.GetString(ReceiveMessage(trySocket, serverAddress).ToArray()));
@@ -460,7 +463,7 @@ public void TestClearTimeoutSession()
             using (Socket socket = CreateClientSocket())
             {
                 string param = Guid.NewGuid().ToString();
-                string command = "325 " + param + Environment.NewLine;
+                string command = "325 " + param + m_NewLine;
                 socket.SendTo(m_Encoding.GetBytes(command), serverAddress);
                 string echoMessage = m_Encoding.GetString(ReceiveMessage(socket, serverAddress).ToArray());
                 Console.WriteLine("C:" + echoMessage);