issues#88,issues#86,issues#83,issues#82

beetlex-io · beetlex-io · commit 5005556bc8f7 · 2019-12-23T21:09:51.000+08:00
diff --git a/src/ActionHandlerFactory.cs b/src/ActionHandlerFactory.cs
@@ -340,10 +340,10 @@ private void Register(HttpOptions config, Type controllerType, object controller
                     route = put.Route;
                 }
 
-                if (server.Options.UrlIgnoreCase)
-                {
-                    url = sourceUrl.ToLower();
-                }
+                //if (server.Options.UrlIgnoreCase)
+                //{
+                //    url = sourceUrl.ToLower();
+                //}
                 RouteTemplateAttribute ra = null;
                 if (!string.IsNullOrEmpty(route))
                 {
@@ -457,8 +457,8 @@ public void ExecuteWithWS(HttpRequest request, HttpApiServer server, JToken toke
             }
             result.Url = url.Value<string>();
             string baseurl = result.Url;
-            if (server.Options.UrlIgnoreCase)
-                baseurl = HttpParse.CharToLower(result.Url);
+            //if (server.Options.UrlIgnoreCase)
+            //    baseurl = HttpParse.CharToLower(result.Url);
             if (baseurl[0] != '/')
                 baseurl = "/" + baseurl;
             result.Url = baseurl;
diff --git a/src/BeetleX.FastHttpApi.csproj b/src/BeetleX.FastHttpApi.csproj
@@ -6,16 +6,16 @@
     <Authors>henryfan</Authors>
     <Company>ikende.com</Company>
     <Description>high performance and lightweight web api and websocket server components for .NETCore,performance higher than asp.net core mvc api 200%.</Description>
-    <Version>1.7.4</Version>
+    <Version>1.7.6</Version>
     <PackageProjectUrl>https://github.com/IKende/FastHttpApi</PackageProjectUrl>
     <PackageLicenseUrl>https://github.com/IKende/FastHttpApi/blob/master/LICENSE</PackageLicenseUrl>
-    <AssemblyVersion>1.7.4.0</AssemblyVersion>
-    <FileVersion>1.7.4.0</FileVersion>
+    <AssemblyVersion>1.7.6.0</AssemblyVersion>
+    <FileVersion>1.7.6.0</FileVersion>
     <LangVersion>7.3</LangVersion>
     <Product>BeetleX.FastHttpApi</Product>
     <PackageRequireLicenseAcceptance>false</PackageRequireLicenseAcceptance>
     <PackageReleaseNotes>high performance and lightweight web api and websocket server components for .NETCore,performance higher than asp.net core mvc api 200%.</PackageReleaseNotes>
-    <SignAssembly>true</SignAssembly>
+    <SignAssembly>false</SignAssembly>
     <AssemblyOriginatorKeyFile>Beetlex.FastHttpApi.pfx</AssemblyOriginatorKeyFile>
     <DelaySign>false</DelaySign>
   </PropertyGroup>
@@ -43,11 +43,8 @@
   </ItemGroup>
 
   <ItemGroup>
+    <PackageReference Include="BeetleX" Version="1.4.7" />
     <PackageReference Include="Newtonsoft.Json" Version="11.0.2" />
   </ItemGroup>
 
-  <ItemGroup>
-    <ProjectReference Include="..\src\BeetleX\BeetleX.csproj" />
-  </ItemGroup>
-
 </Project>
diff --git a/src/HttpApiServer.cs b/src/HttpApiServer.cs
@@ -214,7 +214,7 @@ public object this[string name]
 
         public void Register(params System.Reflection.Assembly[] assemblies)
         {
-            mUrlRewrite.UrlIgnoreCase = Options.UrlIgnoreCase;
+            //mUrlRewrite.UrlIgnoreCase = Options.UrlIgnoreCase;
             mAssemblies.AddRange(assemblies);
             try
             {
@@ -252,7 +252,7 @@ public void Open()
             var ct = ContentTypes.TEXT_UTF8;
             var a = HeaderTypeFactory.Find("Content-Length");
             AppDomain.CurrentDomain.AssemblyResolve += ResolveHandler;
-            HttpPacket hp = new HttpPacket(this, this);
+            HttpPacket hp = new HttpPacket(this, this.FrameSerializer);
             var gtmdate = GMTDate.Default;
             string serverInfo = $"Server: BeetleX[{typeof(BeetleX.BXException).Assembly.GetName().Version}]/FastHttpApi[{typeof(HttpApiServer).Assembly.GetName().Version}]\r\n";
             HeaderTypeFactory.SERVAR_HEADER_BYTES = Encoding.ASCII.GetBytes(serverInfo);
@@ -310,7 +310,7 @@ public void Open()
             StartTime = DateTime.Now;
             mServer.Open();
             mServerCounter = new ServerCounter(this);
-            mUrlRewrite.UrlIgnoreCase = Options.UrlIgnoreCase;
+           // mUrlRewrite.UrlIgnoreCase = Options.UrlIgnoreCase;
             mUrlRewrite.Load();
             //mUrlRewrite.AddRegion(this.Options.Routes);
             HeaderTypeFactory.Find(HeaderTypeFactory.HOST);
diff --git a/src/HttpOptions.cs b/src/HttpOptions.cs
@@ -36,7 +36,7 @@ public HttpOptions()
             FileManager = false;
             CacheFileSize = 500;
             PacketCombined = 0;
-            UrlIgnoreCase = true;
+           // UrlIgnoreCase = true;
             UseIPv6 = true;
             SessionTimeOut = 60 * 30;
             BufferPoolMaxMemory = 500;
@@ -105,7 +105,7 @@ public void SetDebug(string viewpath = null)
 
         public bool UseIPv6 { get; set; }
 
-        public bool UrlIgnoreCase { get; set; }
+       // public bool UrlIgnoreCase { get; set; }
 
         [JsonIgnore]
         public OptionsAttribute CrossDomain { get; set; }
diff --git a/src/HttpPacket.cs b/src/HttpPacket.cs
@@ -66,6 +66,7 @@ private void OnHttpDecode(ISession session, PipeStream pstream)
             }
             else
             {
+                HttpToken token = (HttpToken)session.Tag;
                 if (session.Server.EnableLog(LogType.Info))
                     session.Server.Log(LogType.Info, session, $"HTTP {mRequest.ID} {session.RemoteEndPoint} request from multi receive");
                 if (mRequest.State == LoadedState.None)
@@ -76,7 +77,10 @@ private void OnHttpDecode(ISession session, PipeStream pstream)
                         {
                             session.Server.Log(LogType.Warring, session, $"HTTP {mRequest.ID} {session.RemoteEndPoint} receive data error!");
                         }
-                        session.Dispose();
+                        token.KeepAlive = false;
+                        var response = mRequest.CreateResponse();
+                        InnerErrorResult innerErrorResult = new InnerErrorResult("400", "Request http receive data error!");
+                        response.Result(innerErrorResult);
                         return;
                     }
                     var span = pstream.FirstBuffer.Memory.Slice(0, 10).Span;
@@ -89,29 +93,34 @@ private void OnHttpDecode(ISession session, PipeStream pstream)
                         if (session.Server.EnableLog(LogType.Warring))
                         {
                             session.Server.Log(LogType.Warring, session, $"HTTP {mRequest.ID} {session.RemoteEndPoint} protocol data error!");
-                        }
-                        session.Dispose();
+                        }     
+                        token.KeepAlive = false;
+                        var response = mRequest.CreateResponse();
+                        InnerErrorResult innerErrorResult = new InnerErrorResult("400", "Request http protocol data error!");
+                        response.Result(innerErrorResult);
                         return;
                     }
                 }
-                if ((int)mRequest.State < (int)LoadedState.Header && pstream.Length > 1024 * 4)
+                if ((int)mRequest.State < (int)LoadedState.Header && (pstream.Length > 1024 * 4 || mReceives > 20))
                 {
                     if (session.Server.EnableLog(LogType.Warring))
                     {
                         session.Server.Log(LogType.Warring, session, $"HTTP {mRequest.ID} {session.RemoteEndPoint} header too long!");
                     }
-                    session.Dispose();
+                    token.KeepAlive = false;
+                    var response = mRequest.CreateResponse();
+                    InnerErrorResult innerErrorResult = new InnerErrorResult("400", "Request header too large");
+                    response.Result(innerErrorResult);
                 }
                 else if (mRequest.Length > mServerConfig.MaxBodyLength)
                 {
                     if (session.Server.EnableLog(LogType.Warring))
                     {
                         session.Server.Log(LogType.Warring, session, $"HTTP {mRequest.ID} {session.RemoteEndPoint} body too long!");
                     }
-                    HttpToken token = (HttpToken)session.Tag;
                     token.KeepAlive = false;
                     var response = mRequest.CreateResponse();
-                    InnerErrorResult innerErrorResult = new InnerErrorResult("413", "Request Entity Too Large");
+                    InnerErrorResult innerErrorResult = new InnerErrorResult("400", "Request entity too large");
                     response.Result(innerErrorResult);
                     return;
                 }
@@ -130,22 +139,27 @@ private void OnWebSocketDecode(ISession session, PipeStream pstream)
             {
                 mWebSocketRequest++;
                 long now = session.Server.GetRunTime();
-                if (now - mLastTime > 1000)
+                if (now - mLastTime < 1000)
                 {
                     if (mServerConfig.WebSocketMaxRPS > 0 && mWebSocketRequest > mServerConfig.WebSocketMaxRPS)
                     {
                         if (session.Server.EnableLog(LogType.Warring))
                         {
-                            session.Server.Log(LogType.Warring, session, $"Websocket {mRequest?.ID} {session.RemoteEndPoint} session rps to max!");
+                            session.Server.Log(LogType.Warring, session, $"Websocket {mRequest?.ID} {session.RemoteEndPoint} session rps limit!");
                         }
-                        session.Dispose();
-                    }
-                    else
-                    {
-                        mWebSocketRequest = 0;
-                        mLastTime = now;
+                        HttpToken token = (HttpToken)session.Tag;
+                        token.KeepAlive = false;
+                        var error = new ActionResult(500, "session rps limit!");
+                        var frame = mServer.CreateDataFrame(error);
+                        frame.Send(session);
+                      //  session.Dispose();
                     }
                 }
+                else
+                {
+                    mWebSocketRequest = 0;
+                    mLastTime = now;
+                }
                 DataFrame data = mDataPacket;
                 mDataPacket = null;
                 Completed?.Invoke(this, mCompletedArgs.SetInfo(session, data));
diff --git a/src/HttpParse.cs b/src/HttpParse.cs
@@ -496,28 +496,17 @@ public static int ReadUrlQueryString(ReadOnlySpan<char> url, QueryString querySt
 
         public static void ReadUrlPathAndExt(ReadOnlySpan<char> url, QueryString queryString, HttpRequest request, HttpOptions config)
         {
-            bool urlIgnoreCase = config.UrlIgnoreCase;
-
-            if (urlIgnoreCase)
-                request.BaseUrl = CharToLower(url);
-            else
-                request.BaseUrl = new string(url);
+            request.BaseUrl = new string(url);
             for (int i = url.Length - 1; i >= 0; i--)
             {
                 if (url[i] == '.' && request.Ext == null)
-                {
-                    //if (urlIgnoreCase)
+                {          
                     request.Ext = CharToLower(url.Slice(i + 1, url.Length - i - 1));
-                    //else
-                    //    request.Ext = new string(url.Slice(i + 1, url.Length - i - 1));
                     continue;
                 }
                 if (url[i] == '/')
                 {
-                    if (urlIgnoreCase)
-                        request.Path = CharToLower(url.Slice(0, i + 1));
-                    else
-                        request.Path = new string(url.Slice(0, i + 1));
+                    request.Path = new string(url.Slice(0, i + 1));
                     return;
                 }
             }
diff --git a/src/HttpRequest.cs b/src/HttpRequest.cs
@@ -38,17 +38,23 @@ public HttpRequest()
 
         private static long mID = 0;
 
+        private static object mLockID = new object();
+
         internal static long GetID()
         {
-            var id = System.Threading.Interlocked.Increment(ref mID);
-            if (id > 10000000)
+            lock (mLockID)
             {
-                long prefix = (long)(DateTime.Now - DateTime.Parse("1970-1-1")).TotalSeconds;
-                prefix = prefix << 24;
-                System.Threading.Interlocked.Exchange(ref mID, 0);
-                System.Threading.Interlocked.Exchange(ref mIDPrefix, prefix);
+                var id = ++mID;
+                long result = mIDPrefix | id;
+                if (id == 5000000)
+                {
+                    long prefix = (long)(DateTime.Now - DateTime.Parse("1970-1-1")).TotalSeconds;
+                    prefix = prefix << 24;
+                    mIDPrefix = prefix;
+                    mID = 0;
+                }
+                return result;
             }
-            return mIDPrefix | id;
         }
 
         public long ID { get; internal set; }
@@ -91,9 +97,9 @@ internal HttpResponse CreateResponse()
             else
                 Response.Reset();
             HttpResponse response = Response;
-            response.HttpVersion = this.HttpVersion;
             response.Session = this.Session;
-            response.HttpVersion = this.HttpVersion;
+            if (this.HttpVersion != null)
+                response.HttpVersion = this.HttpVersion;
             response.Request = this;
             if (VersionNumber == "1.0" && this.KeepAlive)
                 response.Header[HeaderTypeFactory.CONNECTION] = "Keep-Alive";
@@ -274,7 +280,7 @@ private void LoadMethod(PipeStream stream)
                 if (mQueryStringIndex > 0)
                     HttpParse.ReadUrlPathAndExt(Url.AsSpan().Slice(0, mQueryStringIndex), mQueryString, this, this.Server.Options);
                 else
-                    HttpParse.ReadUrlPathAndExt(Url.AsSpan(), mQueryString, this, this.Server.Options);         
+                    HttpParse.ReadUrlPathAndExt(Url.AsSpan(), mQueryString, this, this.Server.Options);
                 mState = LoadedState.Method;
             }
         }
diff --git a/src/HttpResponse.cs b/src/HttpResponse.cs
@@ -143,7 +143,7 @@ public void SetContentType(string type)
             Header[HeaderTypeFactory.CONTENT_TYPE] = type;
         }
 
-        public string HttpVersion { get; set; }
+        public string HttpVersion { get; set; } = "HTTP/1.1";
 
         public void SetStatus(string code, string msg)
         {
diff --git a/src/Route/RouteRewrite.cs b/src/Route/RouteRewrite.cs
@@ -17,15 +17,12 @@ public class RouteRewrite
         public RouteRewrite(HttpApiServer server)
         {
             mServer = server;
-            this.UrlIgnoreCase = mServer.Options.UrlIgnoreCase;
             mRouteCached = new LRUCached(mServer.Options.RewriteIgnoreCase ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal);
             mRouteCached.MaxSize = mServer.Options.RewriteCachedSize;
         }
 
         private long mVersion = 0;
 
-        public bool UrlIgnoreCase { get; set; }
-
         private LRUCached mRouteCached;
 
         private ConcurrentDictionary<string, RouteGroup> mRoutes = new ConcurrentDictionary<string, RouteGroup>(StringComparer.OrdinalIgnoreCase);
@@ -73,7 +70,6 @@ private void ChangeVersion()
         private void Add(UrlRoute item)
         {
             mServer.Log(EventArgs.LogType.Info, $"HTTP set rewrite url [{item.Host}{item.Url}] to [{item.Rewrite}]");
-            item.UrlIgnoreCase = this.UrlIgnoreCase;
             item.Init();
             RouteGroup rg = null;
             mRoutes.TryGetValue(item.Path, out rg);
diff --git a/src/StaticResurce/ResourceCenter.cs b/src/StaticResurce/ResourceCenter.cs
@@ -55,9 +55,9 @@ public void SetFileExts(string exts)
             }
         }
 
-        private ConcurrentDictionary<string, FileResource> mResources = new ConcurrentDictionary<string, FileResource>();
+        private ConcurrentDictionary<string, FileResource> mResources = new ConcurrentDictionary<string, FileResource>(StringComparer.OrdinalIgnoreCase);
 
-        private ConcurrentDictionary<string, FileContentType> mExts = new ConcurrentDictionary<string, FileContentType>();
+        private ConcurrentDictionary<string, FileContentType> mExts = new ConcurrentDictionary<string, FileContentType>(StringComparer.OrdinalIgnoreCase);
 
         private List<FileSystemWatcher> mFileWatch = new List<FileSystemWatcher>();
 
@@ -108,9 +108,9 @@ private string GetResourceUrl(string name)
             {
                 charname[indexs[i]] = '/';
             }
-            if (Server.Options.UrlIgnoreCase)
-                return HttpParse.CharToLower(charname);
-            else
+            //if (Server.Options.UrlIgnoreCase)
+            //    return HttpParse.CharToLower(charname);
+            //else
                 return new string(charname);
         }
 
@@ -264,8 +264,8 @@ private void OutputFileResource(FileContentType fct, FileResource fr, HttpRespon
         public void ProcessFile(HttpRequest request, HttpResponse response)
         {
             string url = request.BaseUrl;
-            if (Server.Options.UrlIgnoreCase)
-                url = HttpParse.CharToLower(request.BaseUrl);
+            //if (Server.Options.UrlIgnoreCase)
+            //    url = HttpParse.CharToLower(request.BaseUrl);
             if (url[url.Length - 1] == '/')
             {
                 for (int i = 0; i < mDefaultPages.Count; i++)
@@ -411,9 +411,9 @@ public string GetUrl(string file)
                 }
                 else
                 {
-                    if (Server.Options.UrlIgnoreCase)
-                        charbuffer[i + offset] = Char.ToLower(filebuffer[i]);
-                    else
+                    //if (Server.Options.UrlIgnoreCase)
+                    //    charbuffer[i + offset] = Char.ToLower(filebuffer[i]);
+                    //else
                         charbuffer[i + offset] = filebuffer[i];
                 }
             }
diff --git a/src/WebSockets/DataFrame.cs b/src/WebSockets/DataFrame.cs
@@ -130,13 +130,20 @@ internal DataPacketLoadStep Read(PipeStream stream)
             }
             if (mLoadStep == DataPacketLoadStep.Mask)
             {
-                if (this.Length > 0 && (ulong)stream.Length >= this.Length)
+                if (this.Length == 0)
                 {
-                    if (this.IsMask)
-                        ReadMask(stream);
-                    Body = this.DataPacketSerializer.FrameDeserialize(this, stream);
                     mLoadStep = DataPacketLoadStep.Completed;
                 }
+                else
+                {
+                    if ((ulong)stream.Length >= this.Length)
+                    {
+                        if (this.IsMask)
+                            ReadMask(stream);
+                        Body = this.DataPacketSerializer.FrameDeserialize(this, stream);
+                        mLoadStep = DataPacketLoadStep.Completed;
+                    }
+                }
             }
             return mLoadStep;
         }

Original file line number	Diff line number	Diff line change
`@@ -66,6 +66,7 @@ private void OnHttpDecode(ISession session, PipeStream pstream)`
`66`	`66`	`}`
`67`	`67`	`else`
`68`	`68`	`{`
	`69`	`+ HttpToken token = (HttpToken)session.Tag;`
`69`	`70`	`if (session.Server.EnableLog(LogType.Info))`
`70`	`71`	`session.Server.Log(LogType.Info, session, $"HTTP {mRequest.ID} {session.RemoteEndPoint} request from multi receive");`
`71`	`72`	`if (mRequest.State == LoadedState.None)`
`@@ -76,7 +77,10 @@ private void OnHttpDecode(ISession session, PipeStream pstream)`
`76`	`77`	`{`
`77`	`78`	`session.Server.Log(LogType.Warring, session, $"HTTP {mRequest.ID} {session.RemoteEndPoint} receive data error!");`
`78`	`79`	`}`
`79`		`- session.Dispose();`
	`80`	`+ token.KeepAlive = false;`
	`81`	`+ var response = mRequest.CreateResponse();`
	`82`	`+ InnerErrorResult innerErrorResult = new InnerErrorResult("400", "Request http receive data error!");`
	`83`	`+ response.Result(innerErrorResult);`
`80`	`84`	`return;`
`81`	`85`	`}`
`82`	`86`	`var span = pstream.FirstBuffer.Memory.Slice(0, 10).Span;`
`@@ -89,29 +93,34 @@ private void OnHttpDecode(ISession session, PipeStream pstream)`
`89`	`93`	`if (session.Server.EnableLog(LogType.Warring))`
`90`	`94`	`{`
`91`	`95`	`session.Server.Log(LogType.Warring, session, $"HTTP {mRequest.ID} {session.RemoteEndPoint} protocol data error!");`
`92`		`- }`
`93`		`- session.Dispose();`
	`96`	`+ }`
	`97`	`+ token.KeepAlive = false;`
	`98`	`+ var response = mRequest.CreateResponse();`
	`99`	`+ InnerErrorResult innerErrorResult = new InnerErrorResult("400", "Request http protocol data error!");`
	`100`	`+ response.Result(innerErrorResult);`
`94`	`101`	`return;`
`95`	`102`	`}`
`96`	`103`	`}`
`97`		`- if ((int)mRequest.State < (int)LoadedState.Header && pstream.Length > 1024 * 4)`
	`104`	`+ if ((int)mRequest.State < (int)LoadedState.Header && (pstream.Length > 1024 * 4 \|\| mReceives > 20))`
`98`	`105`	`{`
`99`	`106`	`if (session.Server.EnableLog(LogType.Warring))`
`100`	`107`	`{`
`101`	`108`	`session.Server.Log(LogType.Warring, session, $"HTTP {mRequest.ID} {session.RemoteEndPoint} header too long!");`
`102`	`109`	`}`
`103`		`- session.Dispose();`
	`110`	`+ token.KeepAlive = false;`
	`111`	`+ var response = mRequest.CreateResponse();`
	`112`	`+ InnerErrorResult innerErrorResult = new InnerErrorResult("400", "Request header too large");`
	`113`	`+ response.Result(innerErrorResult);`
`104`	`114`	`}`
`105`	`115`	`else if (mRequest.Length > mServerConfig.MaxBodyLength)`
`106`	`116`	`{`
`107`	`117`	`if (session.Server.EnableLog(LogType.Warring))`
`108`	`118`	`{`
`109`	`119`	`session.Server.Log(LogType.Warring, session, $"HTTP {mRequest.ID} {session.RemoteEndPoint} body too long!");`
`110`	`120`	`}`
`111`		`- HttpToken token = (HttpToken)session.Tag;`
`112`	`121`	`token.KeepAlive = false;`
`113`	`122`	`var response = mRequest.CreateResponse();`
`114`		`- InnerErrorResult innerErrorResult = new InnerErrorResult("413", "Request Entity Too Large");`
	`123`	`+ InnerErrorResult innerErrorResult = new InnerErrorResult("400", "Request entity too large");`
`115`	`124`	`response.Result(innerErrorResult);`
`116`	`125`	`return;`
`117`	`126`	`}`
`@@ -130,22 +139,27 @@ private void OnWebSocketDecode(ISession session, PipeStream pstream)`
`130`	`139`	`{`
`131`	`140`	`mWebSocketRequest++;`
`132`	`141`	`long now = session.Server.GetRunTime();`
`133`		`- if (now - mLastTime > 1000)`
	`142`	`+ if (now - mLastTime < 1000)`
`134`	`143`	`{`
`135`	`144`	`if (mServerConfig.WebSocketMaxRPS > 0 && mWebSocketRequest > mServerConfig.WebSocketMaxRPS)`
`136`	`145`	`{`
`137`	`146`	`if (session.Server.EnableLog(LogType.Warring))`
`138`	`147`	`{`
`139`		`- session.Server.Log(LogType.Warring, session, $"Websocket {mRequest?.ID} {session.RemoteEndPoint} session rps to max!");`
	`148`	`+ session.Server.Log(LogType.Warring, session, $"Websocket {mRequest?.ID} {session.RemoteEndPoint} session rps limit!");`
`140`	`149`	`}`
`141`		`- session.Dispose();`
`142`		`- }`
`143`		`- else`
`144`		`- {`
`145`		`- mWebSocketRequest = 0;`
`146`		`- mLastTime = now;`
	`150`	`+ HttpToken token = (HttpToken)session.Tag;`
	`151`	`+ token.KeepAlive = false;`
	`152`	`+ var error = new ActionResult(500, "session rps limit!");`
	`153`	`+ var frame = mServer.CreateDataFrame(error);`
	`154`	`+ frame.Send(session);`
	`155`	`+ // session.Dispose();`
`147`	`156`	`}`
`148`	`157`	`}`
	`158`	`+ else`
	`159`	`+ {`
	`160`	`+ mWebSocketRequest = 0;`
	`161`	`+ mLastTime = now;`
	`162`	`+ }`
`149`	`163`	`DataFrame data = mDataPacket;`
`150`	`164`	`mDataPacket = null;`
`151`	`165`	`Completed?.Invoke(this, mCompletedArgs.SetInfo(session, data));`
Original file line number	Diff line number	Diff line change
`@@ -496,28 +496,17 @@ public static int ReadUrlQueryString(ReadOnlySpan<char> url, QueryString querySt`
`496`	`496`
`497`	`497`	`public static void ReadUrlPathAndExt(ReadOnlySpan<char> url, QueryString queryString, HttpRequest request, HttpOptions config)`
`498`	`498`	`{`
`499`		`- bool urlIgnoreCase = config.UrlIgnoreCase;`
`500`		`-`
`501`		`- if (urlIgnoreCase)`
`502`		`- request.BaseUrl = CharToLower(url);`
`503`		`- else`
`504`		`- request.BaseUrl = new string(url);`
	`499`	`+ request.BaseUrl = new string(url);`
`505`	`500`	`for (int i = url.Length - 1; i >= 0; i--)`
`506`	`501`	`{`
`507`	`502`	`if (url[i] == '.' && request.Ext == null)`
`508`		`- {`
`509`		`- //if (urlIgnoreCase)`
	`503`	`+ {`
`510`	`504`	`request.Ext = CharToLower(url.Slice(i + 1, url.Length - i - 1));`
`511`		`- //else`
`512`		`- // request.Ext = new string(url.Slice(i + 1, url.Length - i - 1));`
`513`	`505`	`continue;`
`514`	`506`	`}`
`515`	`507`	`if (url[i] == '/')`
`516`	`508`	`{`
`517`		`- if (urlIgnoreCase)`
`518`		`- request.Path = CharToLower(url.Slice(0, i + 1));`
`519`		`- else`
`520`		`- request.Path = new string(url.Slice(0, i + 1));`
	`509`	`+ request.Path = new string(url.Slice(0, i + 1));`
`521`	`510`	`return;`
`522`	`511`	`}`
`523`	`512`	`}`
Original file line number	Diff line number	Diff line change
`@@ -143,7 +143,7 @@ public void SetContentType(string type)`
`143`	`143`	`Header[HeaderTypeFactory.CONTENT_TYPE] = type;`
`144`	`144`	`}`
`145`	`145`
`146`		`- public string HttpVersion { get; set; }`
	`146`	`+ public string HttpVersion { get; set; } = "HTTP/1.1";`
`147`	`147`
`148`	`148`	`public void SetStatus(string code, string msg)`
`149`	`149`	`{`
Original file line number	Diff line number	Diff line change
`@@ -55,9 +55,9 @@ public void SetFileExts(string exts)`
`55`	`55`	`}`
`56`	`56`	`}`
`57`	`57`
`58`		`- private ConcurrentDictionary<string, FileResource> mResources = new ConcurrentDictionary<string, FileResource>();`
	`58`	`+ private ConcurrentDictionary<string, FileResource> mResources = new ConcurrentDictionary<string, FileResource>(StringComparer.OrdinalIgnoreCase);`
`59`	`59`
`60`		`- private ConcurrentDictionary<string, FileContentType> mExts = new ConcurrentDictionary<string, FileContentType>();`
	`60`	`+ private ConcurrentDictionary<string, FileContentType> mExts = new ConcurrentDictionary<string, FileContentType>(StringComparer.OrdinalIgnoreCase);`
`61`	`61`
`62`	`62`	`private List<FileSystemWatcher> mFileWatch = new List<FileSystemWatcher>();`
`63`	`63`
`@@ -108,9 +108,9 @@ private string GetResourceUrl(string name)`
`108`	`108`	`{`
`109`	`109`	`charname[indexs[i]] = '/';`
`110`	`110`	`}`
`111`		`- if (Server.Options.UrlIgnoreCase)`
`112`		`- return HttpParse.CharToLower(charname);`
`113`		`- else`
	`111`	`+ //if (Server.Options.UrlIgnoreCase)`
	`112`	`+ // return HttpParse.CharToLower(charname);`
	`113`	`+ //else`
`114`	`114`	`return new string(charname);`
`115`	`115`	`}`
`116`	`116`
`@@ -264,8 +264,8 @@ private void OutputFileResource(FileContentType fct, FileResource fr, HttpRespon`
`264`	`264`	`public void ProcessFile(HttpRequest request, HttpResponse response)`
`265`	`265`	`{`
`266`	`266`	`string url = request.BaseUrl;`
`267`		`- if (Server.Options.UrlIgnoreCase)`
`268`		`- url = HttpParse.CharToLower(request.BaseUrl);`
	`267`	`+ //if (Server.Options.UrlIgnoreCase)`
	`268`	`+ // url = HttpParse.CharToLower(request.BaseUrl);`
`269`	`269`	`if (url[url.Length - 1] == '/')`
`270`	`270`	`{`
`271`	`271`	`for (int i = 0; i < mDefaultPages.Count; i++)`
`@@ -411,9 +411,9 @@ public string GetUrl(string file)`
`411`	`411`	`}`
`412`	`412`	`else`
`413`	`413`	`{`
`414`		`- if (Server.Options.UrlIgnoreCase)`
`415`		`- charbuffer[i + offset] = Char.ToLower(filebuffer[i]);`
`416`		`- else`
	`414`	`+ //if (Server.Options.UrlIgnoreCase)`
	`415`	`+ // charbuffer[i + offset] = Char.ToLower(filebuffer[i]);`
	`416`	`+ //else`
`417`	`417`	`charbuffer[i + offset] = filebuffer[i];`
`418`	`418`	`}`
`419`	`419`	`}`