Merge pull request #80 from justcoding121/cleanup

Clean up

Author: justcoding121

Titanium.Web.Proxy/CertificateHandler.cs

@@ -0,0 +1,121 @@
+using System;
+using System.Linq;
+using System.Net.Security;
+using System.Security.Cryptography.X509Certificates;
+using System.Threading.Tasks;
+using Titanium.Web.Proxy.EventArguments;
+
+namespace Titanium.Web.Proxy
+{
+    public partial class ProxyServer
+    {
+        /// <summary>
+        /// Call back to override server certificate validation
+        /// </summary>
+        /// <param name="sender"></param>
+        /// <param name="certificate"></param>
+        /// <param name="chain"></param>
+        /// <param name="sslPolicyErrors"></param>
+        /// <returns></returns>
+        internal static bool ValidateServerCertificate(
+          object sender,
+          X509Certificate certificate,
+          X509Chain chain,
+          SslPolicyErrors sslPolicyErrors)
+        {
+            //if user callback is registered then do it
+            if (ServerCertificateValidationCallback != null)
+            {
+                var args = new CertificateValidationEventArgs();
+
+                args.Certificate = certificate;
+                args.Chain = chain;
+                args.SslPolicyErrors = sslPolicyErrors;
+
+
+                Delegate[] invocationList = ServerCertificateValidationCallback.GetInvocationList();
+                Task[] handlerTasks = new Task[invocationList.Length];
+
+                for (int i = 0; i < invocationList.Length; i++)
+                {
+                    handlerTasks[i] = ((Func<object, CertificateValidationEventArgs, Task>)invocationList[i])(null, args);
+                }
+
+                Task.WhenAll(handlerTasks).Wait();
+
+                return args.IsValid;
+            }
+
+            if (sslPolicyErrors == SslPolicyErrors.None)
+                return true;
+
+            //By default
+            //do not allow this client to communicate with unauthenticated servers.
+            return false;
+        }
+
+        /// <summary>
+        /// Call back to select client certificate used for mutual authentication
+        /// </summary>
+        /// <param name="sender"></param>
+        /// <param name="certificate"></param>
+        /// <param name="chain"></param>
+        /// <param name="sslPolicyErrors"></param>
+        /// <returns></returns>
+        internal static X509Certificate SelectClientCertificate(
+            object sender,
+            string targetHost,
+            X509CertificateCollection localCertificates,
+            X509Certificate remoteCertificate,
+            string[] acceptableIssuers)
+        {
+            X509Certificate clientCertificate = null;
+            var customSslStream = sender as SslStream;
+
+            if (acceptableIssuers != null &&
+                acceptableIssuers.Length > 0 &&
+                localCertificates != null &&
+                localCertificates.Count > 0)
+            {
+                // Use the first certificate that is from an acceptable issuer.
+                foreach (X509Certificate certificate in localCertificates)
+                {
+                    string issuer = certificate.Issuer;
+                    if (Array.IndexOf(acceptableIssuers, issuer) != -1)
+                        clientCertificate = certificate;
+                }
+            }
+
+            if (localCertificates != null &&
+                localCertificates.Count > 0)
+                clientCertificate = localCertificates[0];
+
+            //If user call back is registered
+            if (ClientCertificateSelectionCallback != null)
+            {
+                var args = new CertificateSelectionEventArgs();
+
+                args.targetHost = targetHost;
+                args.localCertificates = localCertificates;
+                args.remoteCertificate = remoteCertificate;
+                args.acceptableIssuers = acceptableIssuers;
+                args.clientCertificate = clientCertificate;
+
+                Delegate[] invocationList = ClientCertificateSelectionCallback.GetInvocationList();
+                Task[] handlerTasks = new Task[invocationList.Length];
+
+                for (int i = 0; i < invocationList.Length; i++)
+                {
+                    handlerTasks[i] = ((Func<object, CertificateSelectionEventArgs, Task>)invocationList[i])(null, args);
+                }
+
+                Task.WhenAll(handlerTasks).Wait();
+
+                return args.clientCertificate;
+            }
+
+            return clientCertificate;
+
+        }
+    }
+}

Titanium.Web.Proxy/Compression/CompressionFactory.cs

@@ -1,6 +1,9 @@
 namespace Titanium.Web.Proxy.Compression
 {
-    class CompressionFactory
+    /// <summary>
+    ///  A factory to generate the compression methods based on the type of compression
+    /// </summary>
+    internal class CompressionFactory
     {
         public ICompression Create(string type)
         {

Titanium.Web.Proxy/Compression/DeflateCompression.cs

@@ -4,15 +4,18 @@
 
 namespace Titanium.Web.Proxy.Compression
 {
-    class DeflateCompression : ICompression
+    /// <summary>
+    /// Concrete implementation of deflate compression
+    /// </summary>
+    internal class DeflateCompression : ICompression
     {
         public async Task<byte[]> Compress(byte[] responseBody)
         {
             using (var ms = new MemoryStream())
             {
                 using (var zip = new DeflateStream(ms, CompressionMode.Compress, true))
                 {
-                   await zip.WriteAsync(responseBody, 0, responseBody.Length).ConfigureAwait(false);
+                   await zip.WriteAsync(responseBody, 0, responseBody.Length);
                 }
 
                 return ms.ToArray();

Titanium.Web.Proxy/Compression/GZipCompression.cs

@@ -4,15 +4,18 @@
 
 namespace Titanium.Web.Proxy.Compression
 {
-    class GZipCompression : ICompression
+    /// <summary>
+    /// concreate implementation of gzip compression
+    /// </summary>
+    internal class GZipCompression : ICompression
     {
         public async Task<byte[]> Compress(byte[] responseBody)
         {
             using (var ms = new MemoryStream())
             {
                 using (var zip = new GZipStream(ms, CompressionMode.Compress, true))
                 {
-                   await zip.WriteAsync(responseBody, 0, responseBody.Length).ConfigureAwait(false);
+                   await zip.WriteAsync(responseBody, 0, responseBody.Length);
                 }
 
                 return ms.ToArray();

Titanium.Web.Proxy/Compression/ICompression.cs

@@ -2,6 +2,9 @@
 
 namespace Titanium.Web.Proxy.Compression
 {
+    /// <summary>
+    /// An inteface for http compression
+    /// </summary>
     interface ICompression
     {
         Task<byte[]> Compress(byte[] responseBody);

Titanium.Web.Proxy/Compression/ZlibCompression.cs

@@ -4,15 +4,18 @@
 
 namespace Titanium.Web.Proxy.Compression
 {
-    class ZlibCompression : ICompression
+    /// <summary>
+    /// concrete implementation of zlib compression
+    /// </summary>
+   internal class ZlibCompression : ICompression
     {
         public async Task<byte[]> Compress(byte[] responseBody)
         {
             using (var ms = new MemoryStream())
             {
                 using (var zip = new ZlibStream(ms, CompressionMode.Compress, true))
                 {
-                   await zip.WriteAsync(responseBody, 0, responseBody.Length).ConfigureAwait(false);
+                   await zip.WriteAsync(responseBody, 0, responseBody.Length);
                 }
 
                 return ms.ToArray();

Titanium.Web.Proxy/Decompression/DecompressionFactory.cs

@@ -1,5 +1,8 @@
 namespace Titanium.Web.Proxy.Decompression
 {
+    /// <summary>
+    /// A factory to generate the de-compression methods based on the type of compression
+    /// </summary>
     internal class DecompressionFactory
     {
         internal IDecompression Create(string type)

Titanium.Web.Proxy/Decompression/DefaultDecompression.cs

@@ -2,6 +2,10 @@
 
 namespace Titanium.Web.Proxy.Decompression
 {
+
+    /// <summary>
+    /// When no compression is specified just return the byte array
+    /// </summary>
     internal class DefaultDecompression : IDecompression
     {
         public Task<byte[]> Decompress(byte[] compressedArray)

Titanium.Web.Proxy/Decompression/DeflateDecompression.cs

@@ -5,6 +5,9 @@
 
 namespace Titanium.Web.Proxy.Decompression
 {
+    /// <summary>
+    /// concrete implementation of deflate de-compression
+    /// </summary>
     internal class DeflateDecompression : IDecompression
     {
         public async Task<byte[]> Decompress(byte[] compressedArray)
@@ -18,9 +21,9 @@ public async Task<byte[]> Decompress(byte[] compressedArray)
                 using (var output = new MemoryStream())
                 {
                     int read;
-                    while ((read = await decompressor.ReadAsync(buffer, 0, buffer.Length).ConfigureAwait(false)) > 0)
+                    while ((read = await decompressor.ReadAsync(buffer, 0, buffer.Length)) > 0)
                     {
-                       await output.WriteAsync(buffer, 0, read).ConfigureAwait(false);
+                       await output.WriteAsync(buffer, 0, read);
                     }
 
                     return output.ToArray();

Titanium.Web.Proxy/Decompression/GZipDecompression.cs

@@ -5,6 +5,9 @@
 
 namespace Titanium.Web.Proxy.Decompression
 {
+    /// <summary>
+    /// concrete implementation of gzip de-compression
+    /// </summary>
     internal class GZipDecompression : IDecompression
     {
         public async Task<byte[]> Decompress(byte[] compressedArray)
@@ -15,9 +18,9 @@ public async Task<byte[]> Decompress(byte[] compressedArray)
                 using (var output = new MemoryStream())
                 {
                     int read;
-                    while ((read = await decompressor.ReadAsync(buffer, 0, buffer.Length).ConfigureAwait(false)) > 0)
+                    while ((read = await decompressor.ReadAsync(buffer, 0, buffer.Length)) > 0)
                     {
-                       await output.WriteAsync(buffer, 0, read).ConfigureAwait(false);
+                       await output.WriteAsync(buffer, 0, read);
                     }
                     return output.ToArray();
                 }

Titanium.Web.Proxy/Decompression/IDecompression.cs

@@ -1,8 +1,10 @@
-using System.IO;
-using System.Threading.Tasks;
+using System.Threading.Tasks;
 
 namespace Titanium.Web.Proxy.Decompression
 {
+    /// <summary>
+    /// An interface for decompression
+    /// </summary>
     internal interface IDecompression
     {
        Task<byte[]> Decompress(byte[] compressedArray);

Titanium.Web.Proxy/Decompression/ZlibDecompression.cs

@@ -5,6 +5,9 @@
 
 namespace Titanium.Web.Proxy.Decompression
 {
+    /// <summary>
+    /// concrete implemetation of zlib de-compression
+    /// </summary>
     internal class ZlibDecompression : IDecompression
     {
         public async Task<byte[]> Decompress(byte[] compressedArray)
@@ -17,9 +20,9 @@ public async Task<byte[]> Decompress(byte[] compressedArray)
                 using (var output = new MemoryStream())
                 {
                     int read;
-                    while ((read = await decompressor.ReadAsync(buffer, 0, buffer.Length).ConfigureAwait(false)) > 0)
+                    while ((read = await decompressor.ReadAsync(buffer, 0, buffer.Length)) > 0)
                     {
-                       await output.WriteAsync(buffer, 0, read).ConfigureAwait(false);
+                       await output.WriteAsync(buffer, 0, read);
                     }
                     return output.ToArray();
                 }

Titanium.Web.Proxy/EventArguments/CertificateSelectionEventArgs.cs

@@ -3,6 +3,9 @@
 
 namespace Titanium.Web.Proxy.EventArguments
 {
+    /// <summary>
+    /// An argument passed on to user for client certificate selection during mutual SSL authentication
+    /// </summary>
     public class CertificateSelectionEventArgs : EventArgs, IDisposable
     {
         public object sender { get; internal set; }

Titanium.Web.Proxy/EventArguments/CertificateValidationEventArgs.cs

@@ -4,6 +4,9 @@
 
 namespace Titanium.Web.Proxy.EventArguments
 {
+    /// <summary>
+    /// An argument passed on to the user for validating the server certificate during SSL authentication
+    /// </summary>
     public class CertificateValidationEventArgs : EventArgs, IDisposable
     {
         public X509Certificate Certificate { get; internal set; }