Merge pull request #39 from umbraco/bugfix/entitytagheadervalue

Correctly parse ETag value, path, access conditions and use HeaderNames constants

Author: ronaldbarendse

src/Umbraco.StorageProviders.AzureBlob/AzureBlobFileSystemMiddleware.cs

@@ -83,13 +83,13 @@ private async Task HandleRequestAsync(HttpContext context, RequestDelegate next)
             var request = context.Request;
             var response = context.Response;
 
-            if (!context.Request.Path.StartsWithSegments(_rootPath, StringComparison.InvariantCultureIgnoreCase))
+            if (!context.Request.Path.StartsWithSegments(_rootPath, StringComparison.InvariantCultureIgnoreCase, out PathString path))
             {
                 await next(context).ConfigureAwait(false);
                 return;
             }
 
-            string containerPath = $"{_containerRootPath.TrimEnd('/')}/{(request.Path.Value.Remove(0, _rootPath.Length)).TrimStart('/')}";
+            string containerPath = $"{_containerRootPath.TrimEnd('/')}/{path.Value?.TrimStart('/')}";
             var blob = _fileSystemProvider.GetFileSystem(_name).GetBlobClient(containerPath);
 
             var blobRequestConditions = GetAccessCondition(context.Request);
@@ -114,7 +114,7 @@ private async Task HandleRequestAsync(HttpContext context, RequestDelegate next)
                 // a Content-Range header is needed with the new length
                 ignoreRange = true;
                 properties = await blob.GetPropertiesAsync().ConfigureAwait(false);
-                response.Headers.Append("Content-Range", $"bytes */{properties.Value.ContentLength}");
+                response.Headers.Append(HeaderNames.ContentRange, $"bytes */{properties.Value.ContentLength}");
             }
             catch (RequestFailedException ex) when (ex.Status == (int)HttpStatusCode.NotModified)
             {
@@ -128,15 +128,15 @@ private async Task HandleRequestAsync(HttpContext context, RequestDelegate next)
             // and not a request failed with status NotModified :(
             catch (Exception ex) when (ex.Message == "The condition specified using HTTP conditional header(s) is not met.")
             {
-                if (blobRequestConditions != null
-                    && (blobRequestConditions.IfMatch.HasValue || blobRequestConditions.IfUnmodifiedSince.HasValue))
+                if (blobRequestConditions != null &&
+                    (blobRequestConditions.IfMatch.HasValue || blobRequestConditions.IfUnmodifiedSince.HasValue))
                 {
                     // If-Range or If-Unmodified-Since is not met
                     // if the resource has been modified, we need to send the whole file back with a 200 OK
                     // a Content-Range header is needed with the new length
                     ignoreRange = true;
                     properties = await blob.GetPropertiesAsync().ConfigureAwait(false);
-                    response.Headers.Append("Content-Range", $"bytes */{properties.Value.ContentLength}");
+                    response.Headers.Append(HeaderNames.ContentRange, $"bytes */{properties.Value.ContentLength}");
                 }
                 else
                 {
@@ -155,22 +155,24 @@ private async Task HandleRequestAsync(HttpContext context, RequestDelegate next)
 
             var responseHeaders = response.GetTypedHeaders();
 
-            responseHeaders.CacheControl =
-                new CacheControlHeaderValue
-                {
-                    Public = true,
-                    MustRevalidate = true,
-                    MaxAge = _maxAge,
-                };
+            responseHeaders.CacheControl = new CacheControlHeaderValue
+            {
+                Public = true,
+                MustRevalidate = true,
+                MaxAge = _maxAge,
+            };
 
             responseHeaders.LastModified = properties.Value.LastModified;
-            responseHeaders.ETag = new EntityTagHeaderValue(properties.Value.ETag.ToString("H"));
-            responseHeaders.Append(HeaderNames.Vary, "Accept-Encoding");
 
-            var requestHeaders = request.GetTypedHeaders();
+            if (EntityTagHeaderValue.TryParse(properties.Value.ETag.ToString("H"), out EntityTagHeaderValue entityTagHeaderValue))
+            {
+                responseHeaders.ETag = entityTagHeaderValue;
+            }
 
-            var rangeHeader = requestHeaders.Range;
+            responseHeaders.Append(HeaderNames.Vary, HeaderNames.AcceptEncoding);
 
+            var requestHeaders = request.GetTypedHeaders();
+            var rangeHeader = requestHeaders.Range;
             if (!ignoreRange && rangeHeader != null)
             {
                 if (!ValidateRanges(rangeHeader.Ranges, properties.Value.ContentLength))
@@ -223,6 +225,7 @@ private async Task HandleRequestAsync(HttpContext context, RequestDelegate next)
                     return;
                 }
             }
+
             response.StatusCode = (int)HttpStatusCode.OK;
             response.ContentType = properties.Value.ContentType;
             responseHeaders.ContentLength = properties.Value.ContentLength;
@@ -234,11 +237,11 @@ private async Task HandleRequestAsync(HttpContext context, RequestDelegate next)
 
         private static BlobRequestConditions? GetAccessCondition(HttpRequest request)
         {
-            var range = request.Headers["Range"];
+            var range = request.Headers[HeaderNames.Range];
             if (string.IsNullOrEmpty(range))
             {
                 // etag
-                var ifNoneMatch = request.Headers["If-None-Match"];
+                var ifNoneMatch = request.Headers[HeaderNames.IfNoneMatch];
                 if (!string.IsNullOrEmpty(ifNoneMatch))
                 {
                     return new BlobRequestConditions
@@ -247,40 +250,46 @@ private async Task HandleRequestAsync(HttpContext context, RequestDelegate next)
                     };
                 }
 
-                var ifModifiedSince = request.Headers["If-Modified-Since"];
-                if (!string.IsNullOrEmpty(ifModifiedSince))
+                var ifModifiedSince = request.Headers[HeaderNames.IfModifiedSince];
+                if (!string.IsNullOrEmpty(ifModifiedSince) &&
+                    DateTimeOffset.TryParse(ifModifiedSince, CultureInfo.InvariantCulture, DateTimeStyles.None, out DateTimeOffset ifModifiedSinceDate))
                 {
                     return new BlobRequestConditions
                     {
-                        IfModifiedSince = DateTimeOffset.Parse(ifModifiedSince, CultureInfo.InvariantCulture)
+                        IfModifiedSince = ifModifiedSinceDate
                     };
                 }
             }
             else
             {
                 // handle If-Range header, it can be either an etag or a date
                 // see https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/If-Range and https://tools.ietf.org/html/rfc7233#section-3.2
-                var ifRange = request.Headers["If-Range"];
+                var ifRange = request.Headers[HeaderNames.IfRange];
                 if (!string.IsNullOrEmpty(ifRange))
                 {
-                    var conditions = new BlobRequestConditions();
-
-                    if (DateTimeOffset.TryParse(ifRange, out var date))
+                    if (DateTimeOffset.TryParse(ifRange, CultureInfo.InvariantCulture, DateTimeStyles.None, out DateTimeOffset ifRangeDate))
                     {
-                        conditions.IfUnmodifiedSince = date;
+                        return new BlobRequestConditions()
+                        {
+                            IfUnmodifiedSince = ifRangeDate
+                        };
                     }
                     else
                     {
-                        conditions.IfMatch = new ETag(ifRange);
+                        return new BlobRequestConditions()
+                        {
+                            IfMatch = new ETag(ifRange)
+                        };
                     }
                 }
 
-                var ifUnmodifiedSince = request.Headers["If-Unmodified-Since"];
-                if (!string.IsNullOrEmpty(ifUnmodifiedSince))
+                var ifUnmodifiedSince = request.Headers[HeaderNames.IfUnmodifiedSince];
+                if (!string.IsNullOrEmpty(ifUnmodifiedSince) &&
+                    DateTimeOffset.TryParse(ifUnmodifiedSince, CultureInfo.InvariantCulture, DateTimeStyles.None, out DateTimeOffset ifUnmodifiedSinceDate))
                 {
                     return new BlobRequestConditions
                     {
-                        IfUnmodifiedSince = DateTimeOffset.Parse(ifUnmodifiedSince, CultureInfo.InvariantCulture)
+                        IfUnmodifiedSince = ifUnmodifiedSinceDate
                     };
                 }
             }
@@ -291,14 +300,21 @@ private async Task HandleRequestAsync(HttpContext context, RequestDelegate next)
         private static bool ValidateRanges(ICollection<RangeItemHeaderValue> ranges, long length)
         {
             if (ranges.Count == 0)
+            {
                 return false;
+            }
 
             foreach (var range in ranges)
             {
                 if (range.From > range.To)
+                {
                     return false;
+                }
+
                 if (range.To >= length)
+                {
                     return false;
+                }
             }
 
             return true;
@@ -337,8 +353,7 @@ private static ContentRangeHeaderValue GetRangeHeader(BlobProperties properties,
             return new ContentRangeHeaderValue(from, to, properties.ContentLength);
         }
 
-        private static async Task DownloadRangeToStreamAsync(BlobClient blob, BlobProperties properties,
-            Stream outputStream, ContentRangeHeaderValue contentRange, CancellationToken cancellationToken)
+        private static async Task DownloadRangeToStreamAsync(BlobClient blob, BlobProperties properties, Stream outputStream, ContentRangeHeaderValue contentRange, CancellationToken cancellationToken)
         {
             var offset = contentRange.From.GetValueOrDefault(0L);
             var length = properties.ContentLength;
@@ -359,8 +374,7 @@ private static async Task DownloadRangeToStreamAsync(BlobClient blob, BlobProper
             await DownloadRangeToStreamAsync(blob, outputStream, offset, length, cancellationToken).ConfigureAwait(false);
         }
 
-        private static async Task DownloadRangeToStreamAsync(BlobClient blob, Stream outputStream,
-            long offset, long length, CancellationToken cancellationToken)
+        private static async Task DownloadRangeToStreamAsync(BlobClient blob, Stream outputStream, long offset, long length, CancellationToken cancellationToken)
         {
             try
             {