Merge pull request #35 from justcoding121/beta

Stable

README.md

@@ -23,8 +23,9 @@ Supports
 ### Server Name Indication
 
 ```csharp
-var yourClientStream = new CustomBufferedStream(clientStream, 4096)
-var clientSslHelloInfo = await SslTools.PeekClientHello(yourClientStream);
+var bufferPool = new DefaultBufferPool();
+var yourClientStream = new CustomBufferedStream(clientStream, bufferPool, 4096)
+var clientSslHelloInfo = await SslTools.PeekClientHello(yourClientStream, bufferPool);
 
 //will be null if no client hello was received (not a SSL connection)
 if (clientSslHelloInfo != null)
@@ -44,9 +45,9 @@ if (clientSslHelloInfo != null)
 
 ### Peek Client SSL Hello
 ```csharp
-
-var yourClientStream = new CustomBufferedStream(clientStream, 4096)
-var clientSslHelloInfo = await SslTools.PeekClientHello(yourClientStream);
+var bufferPool = new DefaultBufferPool();
+var yourClientStream = new CustomBufferedStream(clientStream, bufferPool, 4096)
+var clientSslHelloInfo = await SslTools.PeekClientHello(yourClientStream, bufferPool);
 
 //will be null if no client hello was received (not a SSL connection)
 if(clientSslHelloInfo!=null)
@@ -59,8 +60,9 @@ if(clientSslHelloInfo!=null)
 
 ### Peek Server SSL Hello
 ```csharp
-var yourServerStream = new CustomBufferedStream(serverStream, 4096)
-var serverSslHelloInfo = await SslTools.PeekServerHello(yourServerStream);
+var bufferPool = new DefaultBufferPool();
+var yourServerStream = new CustomBufferedStream(serverStream, bufferPool, 4096)
+var serverSslHelloInfo = await SslTools.PeekServerHello(yourServerStream, bufferPool);
 
 //will be null if no server hello was received (not a SSL connection)
 if(serverSslHelloInfo!=null)

StreamExtended/BufferPool/DefaultBufferPool.cs

@@ -0,0 +1,47 @@
+using System.Collections.Concurrent;
+
+namespace StreamExtended
+{
+
+    /// <summary>
+    ///     A concrete IBufferPool implementation using a thread-safe stack.
+    ///     Works well when all consumers ask for buffers with the same size.
+    ///     If your application would use size buffers consider implementing IBufferPool using System.Buffers library from Microsoft.
+    /// </summary>
+    public class DefaultBufferPool : IBufferPool
+    {
+        private readonly ConcurrentStack<byte[]> buffers = new ConcurrentStack<byte[]>();
+
+        /// <summary>
+        /// Gets a buffer.
+        /// </summary>
+        /// <param name="bufferSize">Size of the buffer.</param>
+        /// <returns></returns>
+        public byte[] GetBuffer(int bufferSize)
+        {
+            if (!buffers.TryPop(out var buffer) || buffer.Length != bufferSize)
+            {
+                buffer = new byte[bufferSize];
+            }
+
+            return buffer;
+        }
+
+        /// <summary>
+        /// Returns the buffer.
+        /// </summary>
+        /// <param name="buffer">The buffer.</param>
+        public void ReturnBuffer(byte[] buffer)
+        {
+            if (buffer != null)
+            {
+                buffers.Push(buffer);
+            }
+        }
+
+        public void Dispose()
+        {
+            buffers.Clear();
+        }
+    }
+}

StreamExtended/BufferPool/IBufferPool.cs

@@ -0,0 +1,14 @@
+using System;
+
+namespace StreamExtended
+{
+    /// <summary>
+    ///     Use this interface to implement custom buffer pool.
+    ///     To use the default buffer pool implementation use DefaultBufferPool class.
+    /// </summary>
+    public interface IBufferPool : IDisposable
+    {
+        byte[] GetBuffer(int bufferSize);
+        void ReturnBuffer(byte[] buffer);
+    }
+}

StreamExtended/ClientHelloInfo.cs

@@ -6,6 +6,9 @@
 
 namespace StreamExtended
 {
+    /// <summary>
+    /// Wraps up the client SSL hello information.
+    /// </summary>
     public class ClientHelloInfo
     {
         private static readonly string[] compressions = {

StreamExtended/Models/SslExtension.cs

@@ -1,5 +1,8 @@
 namespace StreamExtended.Models
 {
+    /// <summary>
+    ///     The SSL extension information.
+    /// </summary>
     public class SslExtension
     {
         /// <summary>

StreamExtended/Network/ClientHelloAlpnAdderStream.cs

@@ -7,10 +7,11 @@ namespace StreamExtended.Network
     public class ClientHelloAlpnAdderStream : Stream
     {
         private readonly CustomBufferedStream stream;
+        private readonly IBufferPool bufferPool;
 
         private bool called;
 
-        public ClientHelloAlpnAdderStream(CustomBufferedStream stream)
+        public ClientHelloAlpnAdderStream(CustomBufferedStream stream, IBufferPool bufferPool)
         {
             this.stream = stream;
         }
@@ -49,7 +50,7 @@ public override void Write(byte[] buffer, int offset, int count)
 
             //this can be non async, because reads from a memory stream
             var cts = new CancellationTokenSource();
-            var clientHello = SslTools.PeekClientHello(new CustomBufferedStream(ms, (int)ms.Length), cts.Token).Result;
+            var clientHello = SslTools.PeekClientHello(new CustomBufferedStream(ms, bufferPool, (int)ms.Length), bufferPool, cts.Token).Result;
             if (clientHello != null)
             {
                 // 0x00 0x10: ALPN identifier

StreamExtended/Network/CopyStream.cs

@@ -1,16 +1,21 @@
 using System;
 using System.Threading;
 using System.Threading.Tasks;
-using StreamExtended.Helpers;
 
 namespace StreamExtended.Network
 {
+    /// <summary>
+    ///     Copies the source stream to destination stream.
+    ///     But this let users to peek and read the copying process.
+    /// </summary>
     public class CopyStream : ICustomStreamReader, IDisposable
     {
         private readonly ICustomStreamReader reader;
 
         private readonly ICustomStreamWriter writer;
 
+        private readonly IBufferPool bufferPool;
+
         public int BufferSize { get; }
 
         private int bufferLength;
@@ -25,12 +30,12 @@ public class CopyStream : ICustomStreamReader, IDisposable
 
         public long ReadBytes { get; private set; }
 
-        public CopyStream(ICustomStreamReader reader, ICustomStreamWriter writer, int bufferSize)
+        public CopyStream(ICustomStreamReader reader, ICustomStreamWriter writer, IBufferPool bufferPool, int bufferSize)
         {
             this.reader = reader;
             this.writer = writer;
             BufferSize = bufferSize;
-            buffer = BufferPool.GetBuffer(bufferSize);
+            buffer = bufferPool.GetBuffer(bufferSize);
         }
 
         public async Task<bool> FillBufferAsync(CancellationToken cancellationToken = default(CancellationToken))
@@ -117,17 +122,17 @@ public int Read(byte[] buffer, int offset, int count)
 
         public Task<string> ReadLineAsync(CancellationToken cancellationToken = default(CancellationToken))
         {
-            return CustomBufferedStream.ReadLineInternalAsync(this, cancellationToken);
+            return CustomBufferedStream.ReadLineInternalAsync(this, bufferPool, cancellationToken);
         }
 
         public void Dispose()
         {
             if (!disposed)
             {
                 disposed = true;
-                var buf = buffer;
+                var b = buffer;
                 buffer = null;
-                BufferPool.ReturnBuffer(buf);
+                bufferPool.ReturnBuffer(b);
             }
         }
     }

StreamExtended/Network/CustomBufferedPeekStream.cs

@@ -1,17 +1,18 @@
-using System;
-using System.Threading;
+using System.Threading;
 using System.Threading.Tasks;
 
 namespace StreamExtended.Network
 {
-    public class CustomBufferedPeekStream : ICustomStreamReader
+    internal class CustomBufferedPeekStream : ICustomStreamReader
     {
+        private readonly IBufferPool bufferPool;
         private readonly ICustomStreamReader baseStream;
 
         internal int Position { get; private set; }
 
-        internal CustomBufferedPeekStream(ICustomStreamReader baseStream, int startPosition = 0)
+        internal CustomBufferedPeekStream(ICustomStreamReader baseStream, IBufferPool bufferPool, int startPosition = 0)
         {
+            this.bufferPool = bufferPool;
             this.baseStream = baseStream;
             Position = startPosition;
         }
@@ -130,7 +131,7 @@ Task<int> ICustomStreamReader.ReadAsync(byte[] buffer, int offset, int count, Ca
         /// <returns></returns>
         Task<string> ICustomStreamReader.ReadLineAsync(CancellationToken cancellationToken)
         {
-            return CustomBufferedStream.ReadLineInternalAsync(this, cancellationToken);
+            return CustomBufferedStream.ReadLineInternalAsync(this, bufferPool, cancellationToken);
         }
 
     }

StreamExtended/Network/CustomBufferedStream.cs

@@ -1,6 +1,4 @@
-using StreamExtended.Helpers;
-using System;
-using System.Collections.Generic;
+using System;
 using System.Diagnostics;
 using System.IO;
 using System.Text;
@@ -10,8 +8,9 @@
 namespace StreamExtended.Network
 {
     /// <summary>
-    /// A custom network stream inherited from stream
-    /// with an underlying buffer 
+    ///     A custom network stream inherited from stream
+    ///     with an underlying read buffer supporting both read/write 
+    ///     of UTF-8 encoded string or raw bytes asynchronously from last read position.
     /// </summary>
     /// <seealso cref="System.IO.Stream" />
     public class CustomBufferedStream : Stream, ICustomStreamReader
@@ -31,6 +30,8 @@ public class CustomBufferedStream : Stream, ICustomStreamReader
 
         private bool closed;
 
+        private readonly IBufferPool bufferPool;
+
         public int BufferSize { get; }
 
         public event EventHandler<DataEventArgs> DataRead;
@@ -41,14 +42,16 @@ public class CustomBufferedStream : Stream, ICustomStreamReader
         /// Initializes a new instance of the <see cref="CustomBufferedStream"/> class.
         /// </summary>
         /// <param name="baseStream">The base stream.</param>
+        /// <param name="bufferPool">Bufferpool.</param>
         /// <param name="bufferSize">Size of the buffer.</param>
         /// <param name="leaveOpen"><see langword="true" /> to leave the stream open after disposing the <see cref="T:CustomBufferedStream" /> object; otherwise, <see langword="false" />.</param>
-        public CustomBufferedStream(Stream baseStream, int bufferSize, bool leaveOpen = false)
+        public CustomBufferedStream(Stream baseStream, IBufferPool bufferPool, int bufferSize, bool leaveOpen = false)
         {
             this.baseStream = baseStream;
             BufferSize = bufferSize;
             this.leaveOpen = leaveOpen;
-            streamBuffer = BufferPool.GetBuffer(bufferSize);
+            streamBuffer = bufferPool.GetBuffer(bufferSize);
+            this.bufferPool = bufferPool; 
         }
 
         /// <summary>
@@ -291,7 +294,7 @@ public byte ReadByteFromBuffer()
         /// <param name="value">The byte to write to the stream.</param>
         public override void WriteByte(byte value)
         {
-            var buffer = BufferPool.GetBuffer(BufferSize);
+            var buffer = bufferPool.GetBuffer(BufferSize);
             try
             {
                 buffer[0] = value;
@@ -300,7 +303,7 @@ public override void WriteByte(byte value)
             }
             finally
             {
-                BufferPool.ReturnBuffer(buffer);
+                bufferPool.ReturnBuffer(buffer);
             }
         }
 
@@ -331,7 +334,7 @@ protected override void Dispose(bool disposing)
 
                 var buffer = streamBuffer;
                 streamBuffer = null;
-                BufferPool.ReturnBuffer(buffer);
+                bufferPool.ReturnBuffer(buffer);
             }
         }
 
@@ -493,21 +496,21 @@ public bool FillBuffer()
         /// <returns></returns>
         public Task<string> ReadLineAsync(CancellationToken cancellationToken = default(CancellationToken))
         {
-            return ReadLineInternalAsync(this, cancellationToken);
+            return ReadLineInternalAsync(this, bufferPool, cancellationToken);
         }
 
         /// <summary>
         /// Read a line from the byte stream
         /// </summary>
         /// <returns></returns>
-        internal static async Task<string> ReadLineInternalAsync(ICustomStreamReader reader, CancellationToken cancellationToken = default(CancellationToken))
+        internal static async Task<string> ReadLineInternalAsync(ICustomStreamReader reader, IBufferPool bufferPool, CancellationToken cancellationToken = default(CancellationToken))
         {
             byte lastChar = default(byte);
 
             int bufferDataLength = 0;
 
             // try to use buffer from the buffer pool, usually it is enough
-            var bufferPoolBuffer = BufferPool.GetBuffer(reader.BufferSize);
+            var bufferPoolBuffer = bufferPool.GetBuffer(reader.BufferSize);
             var buffer = bufferPoolBuffer;
 
             try
@@ -541,7 +544,7 @@ public bool FillBuffer()
             }
             finally
             {
-                BufferPool.ReturnBuffer(bufferPoolBuffer);
+                bufferPool.ReturnBuffer(bufferPoolBuffer);
             }
 
             if (bufferDataLength == 0)

StreamExtended/Network/DataEventArgs.cs

@@ -3,7 +3,7 @@
 namespace StreamExtended.Network
 {
     /// <summary>
-    ///     Wraps the data sent/received by a proxy server instance.
+    ///     Wraps the data sent/received event argument.
     /// </summary>
     public class DataEventArgs : EventArgs
     {

StreamExtended/Network/ICustomStreamReader.cs

@@ -4,6 +4,9 @@
 
 namespace StreamExtended.Network
 {
+    /// <summary>
+    ///     This concrete implemetation of interface acts as the source stream for CopyStream class.
+    /// </summary>
     public interface ICustomStreamReader
     {
         int BufferSize { get; }