refactor new line

justcoding121 · justcoding121 · commit 67bfa3bc8454 · 2018-08-23T10:10:52.000-04:00
diff --git a/Titanium.Web.Proxy/Helpers/HttpWriter.cs b/Titanium.Web.Proxy/Helpers/HttpWriter.cs
@@ -16,7 +16,7 @@ internal class HttpWriter : ICustomStreamWriter
         private readonly Stream stream;
         private readonly IBufferPool bufferPool;
 
-        private static readonly byte[] newLine = ProxyConstants.NewLine;
+        private static readonly byte[] newLine = ProxyConstants.NewLineBytes;
 
         private static readonly Encoder encoder = Encoding.ASCII.GetEncoder();
 
@@ -109,9 +109,9 @@ internal async Task WriteHeadersAsync(HeaderCollection headers, bool flush = tru
             var headerBuilder = new StringBuilder();
             foreach (var header in headers)
             {
-                headerBuilder.AppendLine(header.ToString());
+                headerBuilder.Append($"{header.ToString()}{ProxyConstants.NewLine}");
             }
-            headerBuilder.AppendLine();
+            headerBuilder.Append(ProxyConstants.NewLine);
 
             await WriteAsync(headerBuilder.ToString(), cancellationToken);
 
diff --git a/Titanium.Web.Proxy/Http/HttpWebClient.cs b/Titanium.Web.Proxy/Http/HttpWebClient.cs
@@ -8,6 +8,7 @@
 using Titanium.Web.Proxy.Extensions;
 using Titanium.Web.Proxy.Models;
 using Titanium.Web.Proxy.Network.Tcp;
+using Titanium.Web.Proxy.Shared;
 
 namespace Titanium.Web.Proxy.Http
 {
@@ -16,8 +17,6 @@ namespace Titanium.Web.Proxy.Http
     /// </summary>
     public class HttpWebClient
     {
-        private const string CRLF = "\r\n";
-
         internal HttpWebClient(Request request = null, Response response = null)
         {
             Request = request ?? new Request();
@@ -111,21 +110,20 @@ await writer.WriteLineAsync(Request.CreateRequestLine(Request.Method,
                                && !string.IsNullOrEmpty(upstreamProxy.UserName)
                                && upstreamProxy.Password != null)
             {
-                headerBuilder.AppendFormat("{0}{1}", HttpHeader.ProxyConnectionKeepAlive, CRLF);
-                headerBuilder.AppendFormat("{0}{1}",
-                    HttpHeader.GetProxyAuthorizationHeader(upstreamProxy.UserName, upstreamProxy.Password), CRLF);
+                headerBuilder.Append($"{HttpHeader.ProxyConnectionKeepAlive}{ProxyConstants.NewLine}");
+                headerBuilder.Append($"{HttpHeader.GetProxyAuthorizationHeader(upstreamProxy.UserName, upstreamProxy.Password)}{ProxyConstants.NewLine}");
             }
 
             // write request headers
             foreach (var header in Request.Headers)
             {
                 if (isTransparent || header.Name != KnownHeaders.ProxyAuthorization)
                 {
-                    headerBuilder.AppendFormat("{0}{1}", header, CRLF);
+                    headerBuilder.Append($"{header}{ProxyConstants.NewLine}");
                 }
             }
 
-            headerBuilder.Append(CRLF);
+            headerBuilder.Append(ProxyConstants.NewLine);
             
             await writer.WriteAsync(headerBuilder.ToString(), cancellationToken);
 
diff --git a/Titanium.Web.Proxy/Http/Request.cs b/Titanium.Web.Proxy/Http/Request.cs
@@ -140,13 +140,13 @@ public override string HeaderText
             get
             {
                 var sb = new StringBuilder();
-                sb.AppendLine(CreateRequestLine(Method, OriginalUrl, HttpVersion));
+                sb.Append($"{CreateRequestLine(Method, OriginalUrl, HttpVersion)}{ProxyConstants.NewLine}");
                 foreach (var header in Headers)
                 {
-                    sb.AppendLine(header.ToString());
+                    sb.Append($"{header.ToString()}{ProxyConstants.NewLine}");
                 }
 
-                sb.AppendLine();
+                sb.Append(ProxyConstants.NewLine);
                 return sb.ToString();
             }
         }
diff --git a/Titanium.Web.Proxy/Http/Response.cs b/Titanium.Web.Proxy/Http/Response.cs
@@ -110,13 +110,13 @@ public override string HeaderText
             get
             {
                 var sb = new StringBuilder();
-                sb.AppendLine(CreateResponseLine(HttpVersion, StatusCode, StatusDescription));
+                sb.Append($"{CreateResponseLine(HttpVersion, StatusCode, StatusDescription)}{ProxyConstants.NewLine}");
                 foreach (var header in Headers)
                 {
-                    sb.AppendLine(header.ToString());
+                    sb.Append($"{header.ToString()}{ProxyConstants.NewLine}");
                 }
 
-                sb.AppendLine();
+                sb.Append(ProxyConstants.NewLine);
                 return sb.ToString();
             }
         }
diff --git a/Titanium.Web.Proxy/RequestHandler.cs b/Titanium.Web.Proxy/RequestHandler.cs
@@ -16,6 +16,7 @@
 using Titanium.Web.Proxy.Http;
 using Titanium.Web.Proxy.Models;
 using Titanium.Web.Proxy.Network.Tcp;
+using Titanium.Web.Proxy.Shared;
 
 namespace Titanium.Web.Proxy
 {
@@ -24,15 +25,6 @@ namespace Titanium.Web.Proxy
     /// </summary>
     public partial class ProxyServer
     {
-        private static readonly Regex uriSchemeRegex =
-            new Regex("^[a-z]*://", RegexOptions.IgnoreCase | RegexOptions.Compiled);
-
-        private static readonly HashSet<string> proxySupportedCompressions =
-            new HashSet<string>(StringComparer.OrdinalIgnoreCase)
-            {
-                "gzip",
-                "deflate"
-            };
 
         private bool isWindowsAuthenticationEnabledAndSupported =>
             EnableWinAuth && RunTime.IsWindows && !RunTime.IsRunningOnMono;
@@ -96,7 +88,7 @@ await HeaderParser.ReadHeaders(clientStream, args.WebSession.Request.Headers,
                                 cancellationToken);
 
                             Uri httpRemoteUri;
-                            if (uriSchemeRegex.IsMatch(httpUrl))
+                            if (ProxyConstants.UriSchemeRegex.IsMatch(httpUrl))
                             {
                                 try
                                 {
@@ -400,7 +392,7 @@ private void prepareRequestHeaders(HeaderCollection requestHeaders)
                 //only allow proxy supported compressions
                 supportedAcceptEncoding.AddRange(acceptEncoding.Split(',')
                     .Select(x => x.Trim())
-                    .Where(x => proxySupportedCompressions.Contains(x)));
+                    .Where(x => ProxyConstants.ProxySupportedCompressions.Contains(x)));
 
                 //uncompressed is always supported by proxy
                 supportedAcceptEncoding.Add("identity");
diff --git a/Titanium.Web.Proxy/Shared/ProxyConstants.cs b/Titanium.Web.Proxy/Shared/ProxyConstants.cs
@@ -1,4 +1,6 @@
-﻿using System.Text.RegularExpressions;
+﻿using System;
+using System.Collections.Generic;
+using System.Text.RegularExpressions;
 
 namespace Titanium.Web.Proxy.Shared
 {
@@ -14,9 +16,20 @@ internal class ProxyConstants
         internal static readonly char[] SemiColonSplit = { ';' };
         internal static readonly char[] EqualSplit = { '=' };
 
-        internal static readonly byte[] NewLine = { (byte)'\r', (byte)'\n' };
+        internal static readonly string NewLine = "\r\n";
+        internal static readonly byte[] NewLineBytes = { (byte)'\r', (byte)'\n' };
 
-        public static readonly Regex CNRemoverRegex =
+        internal static readonly Regex UriSchemeRegex =
+            new Regex("^[a-z]*://", RegexOptions.IgnoreCase | RegexOptions.Compiled);
+
+        internal static readonly HashSet<string> ProxySupportedCompressions =
+            new HashSet<string>(StringComparer.OrdinalIgnoreCase)
+            {
+                "gzip",
+                "deflate"
+            };
+
+        internal static readonly Regex CNRemoverRegex =
             new Regex(@"^CN\s*=\s*", RegexOptions.IgnoreCase | RegexOptions.Compiled);
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -8,6 +8,7 @@`
`8`	`8`	`using Titanium.Web.Proxy.Extensions;`
`9`	`9`	`using Titanium.Web.Proxy.Models;`
`10`	`10`	`using Titanium.Web.Proxy.Network.Tcp;`
	`11`	`+using Titanium.Web.Proxy.Shared;`
`11`	`12`
`12`	`13`	`namespace Titanium.Web.Proxy.Http`
`13`	`14`	`{`
`@@ -16,8 +17,6 @@ namespace Titanium.Web.Proxy.Http`
`16`	`17`	`/// </summary>`
`17`	`18`	`public class HttpWebClient`
`18`	`19`	`{`
`19`		`- private const string CRLF = "\r\n";`
`20`		`-`
`21`	`20`	`internal HttpWebClient(Request request = null, Response response = null)`
`22`	`21`	`{`
`23`	`22`	`Request = request ?? new Request();`
`@@ -111,21 +110,20 @@ await writer.WriteLineAsync(Request.CreateRequestLine(Request.Method,`
`111`	`110`	`&& !string.IsNullOrEmpty(upstreamProxy.UserName)`
`112`	`111`	`&& upstreamProxy.Password != null)`
`113`	`112`	`{`
`114`		`- headerBuilder.AppendFormat("{0}{1}", HttpHeader.ProxyConnectionKeepAlive, CRLF);`
`115`		`- headerBuilder.AppendFormat("{0}{1}",`
`116`		`- HttpHeader.GetProxyAuthorizationHeader(upstreamProxy.UserName, upstreamProxy.Password), CRLF);`
	`113`	`+ headerBuilder.Append($"{HttpHeader.ProxyConnectionKeepAlive}{ProxyConstants.NewLine}");`
	`114`	`+ headerBuilder.Append($"{HttpHeader.GetProxyAuthorizationHeader(upstreamProxy.UserName, upstreamProxy.Password)}{ProxyConstants.NewLine}");`
`117`	`115`	`}`
`118`	`116`
`119`	`117`	`// write request headers`
`120`	`118`	`foreach (var header in Request.Headers)`
`121`	`119`	`{`
`122`	`120`	`if (isTransparent \|\| header.Name != KnownHeaders.ProxyAuthorization)`
`123`	`121`	`{`
`124`		`- headerBuilder.AppendFormat("{0}{1}", header, CRLF);`
	`122`	`+ headerBuilder.Append($"{header}{ProxyConstants.NewLine}");`
`125`	`123`	`}`
`126`	`124`	`}`
`127`	`125`
`128`		`- headerBuilder.Append(CRLF);`
	`126`	`+ headerBuilder.Append(ProxyConstants.NewLine);`
`129`	`127`
`130`	`128`	`await writer.WriteAsync(headerBuilder.ToString(), cancellationToken);`
`131`	`129`
Original file line number	Diff line number	Diff line change
`@@ -140,13 +140,13 @@ public override string HeaderText`
`140`	`140`	`get`
`141`	`141`	`{`
`142`	`142`	`var sb = new StringBuilder();`
`143`		`- sb.AppendLine(CreateRequestLine(Method, OriginalUrl, HttpVersion));`
	`143`	`+ sb.Append($"{CreateRequestLine(Method, OriginalUrl, HttpVersion)}{ProxyConstants.NewLine}");`
`144`	`144`	`foreach (var header in Headers)`
`145`	`145`	`{`
`146`		`- sb.AppendLine(header.ToString());`
	`146`	`+ sb.Append($"{header.ToString()}{ProxyConstants.NewLine}");`
`147`	`147`	`}`
`148`	`148`
`149`		`- sb.AppendLine();`
	`149`	`+ sb.Append(ProxyConstants.NewLine);`
`150`	`150`	`return sb.ToString();`
`151`	`151`	`}`
`152`	`152`	`}`
Original file line number	Diff line number	Diff line change
`@@ -110,13 +110,13 @@ public override string HeaderText`
`110`	`110`	`get`
`111`	`111`	`{`
`112`	`112`	`var sb = new StringBuilder();`
`113`		`- sb.AppendLine(CreateResponseLine(HttpVersion, StatusCode, StatusDescription));`
	`113`	`+ sb.Append($"{CreateResponseLine(HttpVersion, StatusCode, StatusDescription)}{ProxyConstants.NewLine}");`
`114`	`114`	`foreach (var header in Headers)`
`115`	`115`	`{`
`116`		`- sb.AppendLine(header.ToString());`
	`116`	`+ sb.Append($"{header.ToString()}{ProxyConstants.NewLine}");`
`117`	`117`	`}`
`118`	`118`
`119`		`- sb.AppendLine();`
	`119`	`+ sb.Append(ProxyConstants.NewLine);`
`120`	`120`	`return sb.ToString();`
`121`	`121`	`}`
`122`	`122`	`}`