Merge pull request #221 from justcoding121/develop

justcoding121 · web-flow · commit 54cfea8f2e00 · 2017-05-14T17:54:30.000-04:00
Beta Merge
diff --git a/Examples/Titanium.Web.Proxy.Examples.Basic/ProxyTestController.cs b/Examples/Titanium.Web.Proxy.Examples.Basic/ProxyTestController.cs
@@ -1,7 +1,6 @@
 ﻿using System;
 using System.Collections.Generic;
 using System.Net;
-using System.Security.Cryptography.X509Certificates;
 using System.Threading.Tasks;
 using Titanium.Web.Proxy.EventArguments;
 using Titanium.Web.Proxy.Models;
@@ -18,6 +17,7 @@ public class ProxyTestController
         public ProxyTestController()
         {
             proxyServer = new ProxyServer();
+            proxyServer.ExceptionFunc = exception => Console.WriteLine(exception.Message);
             proxyServer.TrustRootCertificate = true;
 
             //optionally set the Certificate Engine
@@ -99,7 +99,7 @@ public async Task OnRequest(object sender, SessionEventArgs e)
         {
             Console.WriteLine(e.WebSession.Request.Url);
 
-            ////read request headers
+            //read request headers
             var requestHeaders = e.WebSession.Request.RequestHeaders;
 
             var method = e.WebSession.Request.Method.ToUpper();
@@ -128,6 +128,7 @@ await e.Ok("<!DOCTYPE html>" +
                       "</body>" +
                       "</html>");
             }
+
             //Redirect example
             if (e.WebSession.Request.RequestUri.AbsoluteUri.Contains("wikipedia.org"))
             {
@@ -143,6 +144,7 @@ public async Task OnResponse(object sender, SessionEventArgs e)
                 //access request body by looking up the shared dictionary using requestId
                 var requestBody = requestBodyHistory[e.Id];
             }
+
             //read response headers
             var responseHeaders = e.WebSession.Response.ResponseHeaders;
 
diff --git a/Tests/Titanium.Web.Proxy.IntegrationTests/SslTests.cs b/Tests/Titanium.Web.Proxy.IntegrationTests/SslTests.cs
@@ -1,7 +1,6 @@
 ﻿using System;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using System.Net;
-using System.Collections.Generic;
 using System.Threading.Tasks;
 using Titanium.Web.Proxy.EventArguments;
 using Titanium.Web.Proxy.Models;
@@ -28,14 +27,13 @@ public void TestSsl()
             {
                 var response = client.GetAsync(new Uri(testUrl)).Result;
             }
-
         }
 
         private HttpClient CreateHttpClient(string url, int localProxyPort)
         {
             var handler = new HttpClientHandler
             {
-                Proxy = new WebProxy(string.Format("http://localhost:{0}", localProxyPort), false),
+                Proxy = new WebProxy($"http://localhost:{localProxyPort}", false),
                 UseProxy = true,
             };
 
@@ -47,7 +45,7 @@ private HttpClient CreateHttpClient(string url, int localProxyPort)
 
     public class ProxyTestController
     {
-        private ProxyServer proxyServer;
+        private readonly ProxyServer proxyServer;
 
         public ProxyTestController()
         {
@@ -63,7 +61,6 @@ public void StartProxy(int proxyPort)
             proxyServer.ClientCertificateSelectionCallback += OnCertificateSelection;
 
             var explicitEndPoint = new ExplicitProxyEndPoint(IPAddress.Any, proxyPort, true);
-          
 
             //An explicit endpoint is where the client knows about the existance of a proxy
             //So client sends request in a proxy friendly manner
@@ -73,7 +70,6 @@ public void StartProxy(int proxyPort)
             foreach (var endPoint in proxyServer.ProxyEndPoints)
                 Console.WriteLine("Listening on '{0}' endpoint at Ip {1} and port: {2} ",
                     endPoint.GetType().Name, endPoint.IpAddress, endPoint.Port);
-
         }
 
         public void Stop()
diff --git a/Tests/Titanium.Web.Proxy.UnitTests/CertificateManagerTests.cs b/Tests/Titanium.Web.Proxy.UnitTests/CertificateManagerTests.cs
@@ -20,8 +20,7 @@ public async Task Simple_Create_Certificate_Stress_Test()
         {
             var tasks = new List<Task>();
 
-            var mgr = new CertificateManager(CertificateEngine.DefaultWindows, "Titanium", "Titanium Root Certificate Authority", 
-                new Lazy<Action<Exception>>(() => (e => { })).Value);
+            var mgr = new CertificateManager(new Lazy<Action<Exception>>(() => (e => { })).Value);
 
             mgr.ClearIdleCertificates(1);
 
diff --git a/Titanium.Web.Proxy.sln.DotSettings b/Titanium.Web.Proxy.sln.DotSettings
@@ -1,5 +1,7 @@
 ﻿<wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
+	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=BC/@EntryIndexedValue">BC</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/PredefinedNamingRules/=PrivateConstants/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/PredefinedNamingRules/=PrivateInstanceFields/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
+	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/PredefinedNamingRules/=PrivateStaticFields/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/PredefinedNamingRules/=PrivateStaticReadonly/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/UserRules/=dda2ffa1_002D435c_002D4111_002D88eb_002D1a7c93c382f0/@EntryIndexedValue">&lt;Policy&gt;&lt;Descriptor Staticness="Static, Instance" AccessRightKinds="Private" Description="Property (private)"&gt;&lt;ElementKinds&gt;&lt;Kind Name="PROPERTY" /&gt;&lt;/ElementKinds&gt;&lt;/Descriptor&gt;&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;&lt;/Policy&gt;</s:String></wpf:ResourceDictionary>
diff --git a/Titanium.Web.Proxy/Decompression/DeflateDecompression.cs b/Titanium.Web.Proxy/Decompression/DeflateDecompression.cs
@@ -21,7 +21,7 @@ public async Task<byte[]> Decompress(byte[] compressedArray, int bufferSize)
                     int read;
                     while ((read = await decompressor.ReadAsync(buffer, 0, buffer.Length)) > 0)
                     {
-                        await output.WriteAsync(buffer, 0, read);
+                        output.Write(buffer, 0, read);
                     }
 
                     return output.ToArray();
diff --git a/Titanium.Web.Proxy/Decompression/GZipDecompression.cs b/Titanium.Web.Proxy/Decompression/GZipDecompression.cs
@@ -19,8 +19,9 @@ public async Task<byte[]> Decompress(byte[] compressedArray, int bufferSize)
                     int read;
                     while ((read = await decompressor.ReadAsync(buffer, 0, buffer.Length)) > 0)
                     {
-                       await output.WriteAsync(buffer, 0, read);
+                       output.Write(buffer, 0, read);
                     }
+
                     return output.ToArray();
                 }
             }
diff --git a/Titanium.Web.Proxy/Extensions/StreamExtensions.cs b/Titanium.Web.Proxy/Extensions/StreamExtensions.cs
@@ -46,7 +46,7 @@ internal static async Task CopyBytesToStream(this CustomBinaryReader streamReade
 
             while (totalbytesRead < totalBytesToRead)
             {
-                var buffer = await streamReader.ReadBytesAsync(bufferSize, bytesToRead);
+                var buffer = await streamReader.ReadBytesAsync(bytesToRead);
 
                 if (buffer.Length == 0)
                 {
@@ -81,7 +81,7 @@ internal static async Task CopyBytesToStreamChunked(this CustomBinaryReader clie
 
                 if (chunkSize != 0)
                 {
-                    var buffer = await clientStreamReader.ReadBytesAsync(bufferSize, chunkSize);
+                    var buffer = await clientStreamReader.ReadBytesAsync(chunkSize);
                     await stream.WriteAsync(buffer, 0, buffer.Length);
                     //chunk trail
                     await clientStreamReader.ReadLineAsync();
@@ -179,7 +179,7 @@ internal static async Task WriteResponseBodyChunked(this CustomBinaryReader inSt
 
                 if (chunkSize != 0)
                 {
-                    var buffer = await inStreamReader.ReadBytesAsync(bufferSize, chunkSize);
+                    var buffer = await inStreamReader.ReadBytesAsync(chunkSize);
 
                     var chunkHeadBytes = Encoding.ASCII.GetBytes(chunkSize.ToString("x2"));
 
diff --git a/Titanium.Web.Proxy/Extensions/StringExtensions.cs b/Titanium.Web.Proxy/Extensions/StringExtensions.cs
@@ -1,9 +1,4 @@
-﻿using System;
-using System.Collections.Generic;
-using System.Globalization;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
+﻿using System.Globalization;
 
 namespace Titanium.Web.Proxy.Extensions
 {
diff --git a/Titanium.Web.Proxy/Helpers/CustomBinaryReader.cs b/Titanium.Web.Proxy/Helpers/CustomBinaryReader.cs
@@ -19,18 +19,18 @@ internal class CustomBinaryReader : IDisposable
         private readonly Encoding encoding;
 
         [ThreadStatic]
-        private static byte[] staticBuffer;
+        private static byte[] staticBufferField;
 
-        private byte[] buffer
+        private byte[] staticBuffer
         {
             get
             {
-                if (staticBuffer == null || staticBuffer.Length != bufferSize)
+                if (staticBufferField == null || staticBufferField.Length != bufferSize)
                 {
-                    staticBuffer = new byte[bufferSize];
+                    staticBufferField = new byte[bufferSize];
                 }
 
-                return staticBuffer;
+                return staticBufferField;
             }
         }
 
@@ -56,7 +56,7 @@ internal async Task<string> ReadLineAsync()
             int bufferDataLength = 0;
 
             // try to use the thread static buffer, usually it is enough
-            var buffer = this.buffer;
+            var buffer = staticBuffer;
 
             while (stream.DataAvailable || await stream.FillBufferAsync())
             {
@@ -117,22 +117,16 @@ internal async Task ReadAndIgnoreAllLinesAsync()
         /// <summary>
         /// Read the specified number of raw bytes from the base stream
         /// </summary>
-        /// <param name="bufferSize"></param>
         /// <param name="totalBytesToRead"></param>
         /// <returns></returns>
-        internal async Task<byte[]> ReadBytesAsync(int bufferSize, long totalBytesToRead)
+        internal async Task<byte[]> ReadBytesAsync(long totalBytesToRead)
         {
             int bytesToRead = bufferSize;
 
             if (totalBytesToRead < bufferSize)
                 bytesToRead = (int)totalBytesToRead;
 
-            var buffer = this.buffer;
-            if (bytesToRead > buffer.Length)
-            {
-                buffer = new byte[bytesToRead];
-            }
-
+            var buffer = staticBuffer;
             int bytesRead;
             var totalBytesRead = 0;
 
diff --git a/Titanium.Web.Proxy/Helpers/CustomBufferedStream.cs b/Titanium.Web.Proxy/Helpers/CustomBufferedStream.cs
@@ -16,7 +16,7 @@ internal class CustomBufferedStream : Stream
     {
         private readonly Stream baseStream;
         
-        private readonly byte[] buffer;
+        private readonly byte[] streamBuffer;
         
         private int bufferLength;
         
@@ -30,7 +30,7 @@ internal class CustomBufferedStream : Stream
         public CustomBufferedStream(Stream baseStream, int bufferSize)
         {
             this.baseStream = baseStream;
-            buffer = new byte[bufferSize];
+            streamBuffer = new byte[bufferSize];
         }
 
         /// <summary>
@@ -84,7 +84,7 @@ public override int Read(byte[] buffer, int offset, int count)
             int available = Math.Min(bufferLength, count);
             if (available > 0)
             {
-                Buffer.BlockCopy(this.buffer, bufferPos, buffer, offset, available);
+                Buffer.BlockCopy(streamBuffer, bufferPos, buffer, offset, available);
                 bufferPos += available;
                 bufferLength -= available;
             }
@@ -120,7 +120,7 @@ public override IAsyncResult BeginRead(byte[] buffer, int offset, int count, Asy
             if (bufferLength > 0)
             {
                 int available = Math.Min(bufferLength, count);
-                Buffer.BlockCopy(this.buffer, bufferPos, buffer, offset, available);
+                Buffer.BlockCopy(streamBuffer, bufferPos, buffer, offset, available);
                 bufferPos += available;
                 bufferLength -= available;
                 return new ReadAsyncResult(available);
@@ -167,7 +167,7 @@ public override async Task CopyToAsync(Stream destination, int bufferSize, Cance
         {
             if (bufferLength > 0)
             {
-                await destination.WriteAsync(buffer, bufferPos, bufferLength, cancellationToken);
+                await destination.WriteAsync(streamBuffer, bufferPos, bufferLength, cancellationToken);
             }
 
             await baseStream.CopyToAsync(destination, bufferSize, cancellationToken);
@@ -256,7 +256,7 @@ public override async Task<int> ReadAsync(byte[] buffer, int offset, int count,
             int available = Math.Min(bufferLength, count);
             if (available > 0)
             {
-                Buffer.BlockCopy(this.buffer, bufferPos, buffer, offset, available);
+                Buffer.BlockCopy(streamBuffer, bufferPos, buffer, offset, available);
                 bufferPos += available;
                 bufferLength -= available;
             }
@@ -283,7 +283,7 @@ public override int ReadByte()
             }
 
             bufferLength--;
-            return buffer[bufferPos++];
+            return streamBuffer[bufferPos++];
         }
 
         public byte ReadByteFromBuffer()
@@ -294,7 +294,7 @@ public byte ReadByteFromBuffer()
             }
 
             bufferLength--;
-            return buffer[bufferPos++];
+            return streamBuffer[bufferPos++];
         }
 
         /// <summary>
@@ -390,7 +390,7 @@ public override int WriteTimeout
         /// </summary>
         public bool FillBuffer()
         {
-            bufferLength = baseStream.Read(buffer, 0, buffer.Length);
+            bufferLength = baseStream.Read(streamBuffer, 0, streamBuffer.Length);
             bufferPos = 0;
             return bufferLength > 0;
         }
@@ -411,7 +411,7 @@ public Task<bool> FillBufferAsync()
         /// <returns></returns>
         public async Task<bool> FillBufferAsync(CancellationToken cancellationToken)
         {
-            bufferLength = await baseStream.ReadAsync(buffer, 0, buffer.Length, cancellationToken);
+            bufferLength = await baseStream.ReadAsync(streamBuffer, 0, streamBuffer.Length, cancellationToken);
             bufferPos = 0;
             return bufferLength > 0;
         }
diff --git a/Titanium.Web.Proxy/Helpers/Network.cs b/Titanium.Web.Proxy/Helpers/Network.cs
@@ -55,7 +55,7 @@ internal static bool IsLocalIpAddress(string hostName)
             {
                 localhost = Dns.GetHostEntry(Dns.GetHostName());
 
-                IPAddress ipAddress = null;
+                IPAddress ipAddress;
 
                 if (IPAddress.TryParse(hostName, out ipAddress))
                     isLocalhost = localhost.AddressList.Any(x => x.Equals(ipAddress));
diff --git a/Titanium.Web.Proxy/Models/EndPoint.cs b/Titanium.Web.Proxy/Models/EndPoint.cs
@@ -21,9 +21,9 @@ public abstract class ProxyEndPoint
         /// <param name="enableSsl"></param>
         protected ProxyEndPoint(IPAddress ipAddress, int port, bool enableSsl)
         {
-            this.IpAddress = ipAddress;
-            this.Port = port;
-            this.EnableSsl = enableSsl;
+            IpAddress = ipAddress;
+            Port = port;
+            EnableSsl = enableSsl;
         }
 
         /// <summary>
@@ -55,8 +55,8 @@ protected ProxyEndPoint(IPAddress ipAddress, int port, bool enableSsl)
     /// </summary>
     public class ExplicitProxyEndPoint : ProxyEndPoint
     {
-        internal List<Regex> excludedHttpsHostNameRegex;
-        internal List<Regex> includedHttpsHostNameRegex;
+        internal List<Regex> ExcludedHttpsHostNameRegexList;
+        internal List<Regex> IncludedHttpsHostNameRegexList;
 
         internal bool IsSystemHttpProxy { get; set; }
 
@@ -67,15 +67,15 @@ public class ExplicitProxyEndPoint : ProxyEndPoint
         /// </summary>
         public IEnumerable<string> ExcludedHttpsHostNameRegex
         {
-            get { return excludedHttpsHostNameRegex?.Select(x => x.ToString()).ToList(); }
+            get { return ExcludedHttpsHostNameRegexList?.Select(x => x.ToString()).ToList(); }
             set
             {
                 if (IncludedHttpsHostNameRegex != null)
                 {
                     throw new ArgumentException("Cannot set excluded when included is set");
                 }
 
-                excludedHttpsHostNameRegex = value?.Select(x=>new Regex(x, RegexOptions.Compiled)).ToList();
+                ExcludedHttpsHostNameRegexList = value?.Select(x=>new Regex(x, RegexOptions.Compiled)).ToList();
             }
         }
 
@@ -84,15 +84,15 @@ public IEnumerable<string> ExcludedHttpsHostNameRegex
         /// </summary>
         public IEnumerable<string> IncludedHttpsHostNameRegex
         {
-            get { return includedHttpsHostNameRegex?.Select(x => x.ToString()).ToList(); }
+            get { return IncludedHttpsHostNameRegexList?.Select(x => x.ToString()).ToList(); }
             set
             {
                 if (ExcludedHttpsHostNameRegex != null)
                 {
                     throw new ArgumentException("Cannot set included when excluded is set");
                 }
 
-                includedHttpsHostNameRegex = value?.Select(x => new Regex(x, RegexOptions.Compiled)).ToList();
+                IncludedHttpsHostNameRegexList = value?.Select(x => new Regex(x, RegexOptions.Compiled)).ToList();
             }
         }
 
@@ -136,7 +136,7 @@ public class TransparentProxyEndPoint : ProxyEndPoint
         public TransparentProxyEndPoint(IPAddress ipAddress, int port, bool enableSsl)
             : base(ipAddress, port, enableSsl)
         {
-            this.GenericCertificateName = "localhost";
+            GenericCertificateName = "localhost";
         }
     }
 
diff --git a/Titanium.Web.Proxy/Network/Certificate/BCCertificateMaker.cs b/Titanium.Web.Proxy/Network/Certificate/BCCertificateMaker.cs
diff --git a/Titanium.Web.Proxy/Network/CertificateManager.cs b/Titanium.Web.Proxy/Network/CertificateManager.cs
diff --git a/Titanium.Web.Proxy/Network/Tcp/TcpConnection.cs b/Titanium.Web.Proxy/Network/Tcp/TcpConnection.cs
diff --git a/Titanium.Web.Proxy/ProxyServer.cs b/Titanium.Web.Proxy/ProxyServer.cs
diff --git a/Titanium.Web.Proxy/RequestHandler.cs b/Titanium.Web.Proxy/RequestHandler.cs

Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,6 @@`
`1`	`1`	`using System;`
`2`	`2`	`using Microsoft.VisualStudio.TestTools.UnitTesting;`
`3`	`3`	`using System.Net;`
`4`		`-using System.Collections.Generic;`
`5`	`4`	`using System.Threading.Tasks;`
`6`	`5`	`using Titanium.Web.Proxy.EventArguments;`
`7`	`6`	`using Titanium.Web.Proxy.Models;`
`@@ -28,14 +27,13 @@ public void TestSsl()`
`28`	`27`	`{`
`29`	`28`	`var response = client.GetAsync(new Uri(testUrl)).Result;`
`30`	`29`	`}`
`31`		`-`
`32`	`30`	`}`
`33`	`31`
`34`	`32`	`private HttpClient CreateHttpClient(string url, int localProxyPort)`
`35`	`33`	`{`
`36`	`34`	`var handler = new HttpClientHandler`
`37`	`35`	`{`
`38`		`- Proxy = new WebProxy(string.Format("http://localhost:{0}", localProxyPort), false),`
	`36`	`+ Proxy = new WebProxy($"http://localhost:{localProxyPort}", false),`
`39`	`37`	`UseProxy = true,`
`40`	`38`	`};`
`41`	`39`
`@@ -47,7 +45,7 @@ private HttpClient CreateHttpClient(string url, int localProxyPort)`
`47`	`45`
`48`	`46`	`public class ProxyTestController`
`49`	`47`	`{`
`50`		`- private ProxyServer proxyServer;`
	`48`	`+ private readonly ProxyServer proxyServer;`
`51`	`49`
`52`	`50`	`public ProxyTestController()`
`53`	`51`	`{`
`@@ -63,7 +61,6 @@ public void StartProxy(int proxyPort)`
`63`	`61`	`proxyServer.ClientCertificateSelectionCallback += OnCertificateSelection;`
`64`	`62`
`65`	`63`	`var explicitEndPoint = new ExplicitProxyEndPoint(IPAddress.Any, proxyPort, true);`
`66`		`-`
`67`	`64`
`68`	`65`	`//An explicit endpoint is where the client knows about the existance of a proxy`
`69`	`66`	`//So client sends request in a proxy friendly manner`
`@@ -73,7 +70,6 @@ public void StartProxy(int proxyPort)`
`73`	`70`	`foreach (var endPoint in proxyServer.ProxyEndPoints)`
`74`	`71`	`Console.WriteLine("Listening on '{0}' endpoint at Ip {1} and port: {2} ",`
`75`	`72`	`endPoint.GetType().Name, endPoint.IpAddress, endPoint.Port);`
`76`		`-`
`77`	`73`	`}`
`78`	`74`
`79`	`75`	`public void Stop()`
Original file line number	Diff line number	Diff line change
`@@ -20,8 +20,7 @@ public async Task Simple_Create_Certificate_Stress_Test()`
`20`	`20`	`{`
`21`	`21`	`var tasks = new List<Task>();`
`22`	`22`
`23`		`- var mgr = new CertificateManager(CertificateEngine.DefaultWindows, "Titanium", "Titanium Root Certificate Authority",`
`24`		`- new Lazy<Action<Exception>>(() => (e => { })).Value);`
	`23`	`+ var mgr = new CertificateManager(new Lazy<Action<Exception>>(() => (e => { })).Value);`
`25`	`24`
`26`	`25`	`mgr.ClearIdleCertificates(1);`
`27`	`26`
Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,7 @@ public async Task<byte[]> Decompress(byte[] compressedArray, int bufferSize)`
`21`	`21`	`int read;`
`22`	`22`	`while ((read = await decompressor.ReadAsync(buffer, 0, buffer.Length)) > 0)`
`23`	`23`	`{`
`24`		`- await output.WriteAsync(buffer, 0, read);`
	`24`	`+ output.Write(buffer, 0, read);`
`25`	`25`	`}`
`26`	`26`
`27`	`27`	`return output.ToArray();`
Original file line number	Diff line number	Diff line change
`@@ -19,8 +19,9 @@ public async Task<byte[]> Decompress(byte[] compressedArray, int bufferSize)`
`19`	`19`	`int read;`
`20`	`20`	`while ((read = await decompressor.ReadAsync(buffer, 0, buffer.Length)) > 0)`
`21`	`21`	`{`
`22`		`- await output.WriteAsync(buffer, 0, read);`
	`22`	`+ output.Write(buffer, 0, read);`
`23`	`23`	`}`
	`24`	`+`
`24`	`25`	`return output.ToArray();`
`25`	`26`	`}`
`26`	`27`	`}`
Original file line number	Diff line number	Diff line change
`@@ -46,7 +46,7 @@ internal static async Task CopyBytesToStream(this CustomBinaryReader streamReade`
`46`	`46`
`47`	`47`	`while (totalbytesRead < totalBytesToRead)`
`48`	`48`	`{`
`49`		`- var buffer = await streamReader.ReadBytesAsync(bufferSize, bytesToRead);`
	`49`	`+ var buffer = await streamReader.ReadBytesAsync(bytesToRead);`
`50`	`50`
`51`	`51`	`if (buffer.Length == 0)`
`52`	`52`	`{`
`@@ -81,7 +81,7 @@ internal static async Task CopyBytesToStreamChunked(this CustomBinaryReader clie`
`81`	`81`
`82`	`82`	`if (chunkSize != 0)`
`83`	`83`	`{`
`84`		`- var buffer = await clientStreamReader.ReadBytesAsync(bufferSize, chunkSize);`
	`84`	`+ var buffer = await clientStreamReader.ReadBytesAsync(chunkSize);`
`85`	`85`	`await stream.WriteAsync(buffer, 0, buffer.Length);`
`86`	`86`	`//chunk trail`
`87`	`87`	`await clientStreamReader.ReadLineAsync();`
`@@ -179,7 +179,7 @@ internal static async Task WriteResponseBodyChunked(this CustomBinaryReader inSt`
`179`	`179`
`180`	`180`	`if (chunkSize != 0)`
`181`	`181`	`{`
`182`		`- var buffer = await inStreamReader.ReadBytesAsync(bufferSize, chunkSize);`
	`182`	`+ var buffer = await inStreamReader.ReadBytesAsync(chunkSize);`
`183`	`183`
`184`	`184`	`var chunkHeadBytes = Encoding.ASCII.GetBytes(chunkSize.ToString("x2"));`
`185`	`185`
Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,7 @@ internal class CustomBufferedStream : Stream`
`16`	`16`	`{`
`17`	`17`	`private readonly Stream baseStream;`
`18`	`18`
`19`		`- private readonly byte[] buffer;`
	`19`	`+ private readonly byte[] streamBuffer;`
`20`	`20`
`21`	`21`	`private int bufferLength;`
`22`	`22`
`@@ -30,7 +30,7 @@ internal class CustomBufferedStream : Stream`
`30`	`30`	`public CustomBufferedStream(Stream baseStream, int bufferSize)`
`31`	`31`	`{`
`32`	`32`	`this.baseStream = baseStream;`
`33`		`- buffer = new byte[bufferSize];`
	`33`	`+ streamBuffer = new byte[bufferSize];`
`34`	`34`	`}`
`35`	`35`
`36`	`36`	`/// <summary>`
`@@ -84,7 +84,7 @@ public override int Read(byte[] buffer, int offset, int count)`
`84`	`84`	`int available = Math.Min(bufferLength, count);`
`85`	`85`	`if (available > 0)`
`86`	`86`	`{`
`87`		`- Buffer.BlockCopy(this.buffer, bufferPos, buffer, offset, available);`
	`87`	`+ Buffer.BlockCopy(streamBuffer, bufferPos, buffer, offset, available);`
`88`	`88`	`bufferPos += available;`
`89`	`89`	`bufferLength -= available;`
`90`	`90`	`}`
`@@ -120,7 +120,7 @@ public override IAsyncResult BeginRead(byte[] buffer, int offset, int count, Asy`
`120`	`120`	`if (bufferLength > 0)`
`121`	`121`	`{`
`122`	`122`	`int available = Math.Min(bufferLength, count);`
`123`		`- Buffer.BlockCopy(this.buffer, bufferPos, buffer, offset, available);`
	`123`	`+ Buffer.BlockCopy(streamBuffer, bufferPos, buffer, offset, available);`
`124`	`124`	`bufferPos += available;`
`125`	`125`	`bufferLength -= available;`
`126`	`126`	`return new ReadAsyncResult(available);`
`@@ -167,7 +167,7 @@ public override async Task CopyToAsync(Stream destination, int bufferSize, Cance`
`167`	`167`	`{`
`168`	`168`	`if (bufferLength > 0)`
`169`	`169`	`{`
`170`		`- await destination.WriteAsync(buffer, bufferPos, bufferLength, cancellationToken);`
	`170`	`+ await destination.WriteAsync(streamBuffer, bufferPos, bufferLength, cancellationToken);`
`171`	`171`	`}`
`172`	`172`
`173`	`173`	`await baseStream.CopyToAsync(destination, bufferSize, cancellationToken);`
`@@ -256,7 +256,7 @@ public override async Task<int> ReadAsync(byte[] buffer, int offset, int count,`
`256`	`256`	`int available = Math.Min(bufferLength, count);`
`257`	`257`	`if (available > 0)`
`258`	`258`	`{`
`259`		`- Buffer.BlockCopy(this.buffer, bufferPos, buffer, offset, available);`
	`259`	`+ Buffer.BlockCopy(streamBuffer, bufferPos, buffer, offset, available);`
`260`	`260`	`bufferPos += available;`
`261`	`261`	`bufferLength -= available;`
`262`	`262`	`}`
`@@ -283,7 +283,7 @@ public override int ReadByte()`
`283`	`283`	`}`
`284`	`284`
`285`	`285`	`bufferLength--;`
`286`		`- return buffer[bufferPos++];`
	`286`	`+ return streamBuffer[bufferPos++];`
`287`	`287`	`}`
`288`	`288`
`289`	`289`	`public byte ReadByteFromBuffer()`
`@@ -294,7 +294,7 @@ public byte ReadByteFromBuffer()`
`294`	`294`	`}`
`295`	`295`
`296`	`296`	`bufferLength--;`
`297`		`- return buffer[bufferPos++];`
	`297`	`+ return streamBuffer[bufferPos++];`
`298`	`298`	`}`
`299`	`299`
`300`	`300`	`/// <summary>`
`@@ -390,7 +390,7 @@ public override int WriteTimeout`
`390`	`390`	`/// </summary>`
`391`	`391`	`public bool FillBuffer()`
`392`	`392`	`{`
`393`		`- bufferLength = baseStream.Read(buffer, 0, buffer.Length);`
	`393`	`+ bufferLength = baseStream.Read(streamBuffer, 0, streamBuffer.Length);`
`394`	`394`	`bufferPos = 0;`
`395`	`395`	`return bufferLength > 0;`
`396`	`396`	`}`
`@@ -411,7 +411,7 @@ public Task<bool> FillBufferAsync()`
`411`	`411`	`/// <returns></returns>`
`412`	`412`	`public async Task<bool> FillBufferAsync(CancellationToken cancellationToken)`
`413`	`413`	`{`
`414`		`- bufferLength = await baseStream.ReadAsync(buffer, 0, buffer.Length, cancellationToken);`
	`414`	`+ bufferLength = await baseStream.ReadAsync(streamBuffer, 0, streamBuffer.Length, cancellationToken);`
`415`	`415`	`bufferPos = 0;`
`416`	`416`	`return bufferLength > 0;`
`417`	`417`	`}`