예제 #1
0
            public void Must_parse_correctly(string headerValue, int year, int month, int day, int hour, int minute, int second)
            {
                IfModifiedSinceHeader header = IfModifiedSinceHeader.Parse(headerValue);

                Assert.That(header, Is.Not.Null);
                Assert.That(header.HttpDate.Year, Is.EqualTo(year));
                Assert.That(header.HttpDate.Month, Is.EqualTo(month));
                Assert.That(header.HttpDate.Day, Is.EqualTo(day));
                Assert.That(header.HttpDate.Hour, Is.EqualTo(hour));
                Assert.That(header.HttpDate.Minute, Is.EqualTo(minute));
                Assert.That(header.HttpDate.Second, Is.EqualTo(second));
            }
 /// <summary>
 /// Initializes a new instance of the <see cref="WebDavRequestHeaders"/> class.
 /// </summary>
 /// <param name="headers">The headers to parse</param>
 /// <param name="context">The WebDAV request context</param>
 public WebDavRequestHeaders([NotNull] IEnumerable <KeyValuePair <string, IEnumerable <string> > > headers, [NotNull] IWebDavContext context)
 {
     Headers           = headers.ToDictionary(x => x.Key, x => (IReadOnlyCollection <string>)x.Value.ToList(), StringComparer.OrdinalIgnoreCase);
     Depth             = ParseHeader("Depth", args => DepthHeader.Parse(args.Single()));
     Overwrite         = ParseHeader("Overwrite", args => OverwriteHeader.Parse(args.Single()));
     Range             = ParseHeader("Range", RangeHeader.Parse);
     If                = ParseHeader("If", args => IfHeader.Parse(args.Single(), EntityTagComparer.Strong, context));
     IfMatch           = ParseHeader("If-Match", IfMatchHeader.Parse);
     IfNoneMatch       = ParseHeader("If-None-Match", IfNoneMatchHeader.Parse);
     IfModifiedSince   = ParseHeader("If-Modified-Since", args => IfModifiedSinceHeader.Parse(args.Single()));
     IfUnmodifiedSince = ParseHeader("If-Unmodified-Since", args => IfUnmodifiedSinceHeader.Parse(args.Single()));
     Timeout           = ParseHeader("Timeout", TimeoutHeader.Parse);
     ContentLength     = ParseHeader("Content-Length", args => (long?)XmlConvert.ToInt64(args.Single()));
 }
        public async Task <ResponseHandlerResult> HandleResponseAsync(HttpContextBase context, IResponse suggestedResponse, ICache cache, string cacheKey)
        {
            context.ThrowIfNull("context");
            suggestedResponse.ThrowIfNull("suggestedResponse");

            if (!suggestedResponse.CachePolicy.HasPolicy || cache == null || cacheKey == null)
            {
                return(ResponseHandlerResult.ResponseNotHandled());
            }

            CacheItem cacheItem = await cache.GetAsync(cacheKey);

            string responseETag = suggestedResponse.CachePolicy.ETag;

            #region If-Match precondition header

            IfMatchHeader[] ifMatchHeaders = IfMatchHeader.ParseMany(context.Request.Headers["If-Match"]).ToArray();

            // Only consider If-Match headers if response status code is 2xx or 412
            if (ifMatchHeaders.Any() && ((suggestedResponse.StatusCode.StatusCode >= 200 && suggestedResponse.StatusCode.StatusCode <= 299) || suggestedResponse.StatusCode.StatusCode == 412))
            {
                // Return 412 if no If-Match header matches the response ETag
                // Return 412 if an "If-Match: *" header is present and the response has no ETag
                if (ifMatchHeaders.All(arg => arg.EntityTag.Value != responseETag) ||
                    (responseETag == null && ifMatchHeaders.Any(arg => arg.EntityTag.Value == "*")))
                {
                    return(await WriteResponseAsync(context.Response, new Response().PreconditionFailed()));
                }
            }

            #endregion

            #region If-None-Match precondition header

            IfNoneMatchHeader[] ifNoneMatchHeaders = IfNoneMatchHeader.ParseMany(context.Request.Headers["If-None-Match"]).ToArray();

            if (ifNoneMatchHeaders.Any())
            {
                // Return 304 if an If-None-Match header matches the response ETag and the request method was GET or HEAD
                // Return 304 if an "If-None-Match: *" header is present, the response has an ETag and the request method was GET or HEAD
                // Return 412 if an "If-None-Match: *" header is present, the response has an ETag and the request method was not GET or HEAD
                if (ifNoneMatchHeaders.Any(arg => arg.EntityTag.Value == responseETag) ||
                    (ifNoneMatchHeaders.Any(arg => arg.EntityTag.Value == "*") && responseETag != null))
                {
                    if (String.Equals(context.Request.HttpMethod, "GET", StringComparison.OrdinalIgnoreCase) || String.Equals(context.Request.HttpMethod, "HEAD", StringComparison.OrdinalIgnoreCase))
                    {
                        if (cacheItem != null)
                        {
                            cacheItem.Response.CachePolicy.Apply(context.Response.Cache);
                        }
                        else
                        {
                            suggestedResponse.CachePolicy.Apply(context.Response.Cache);
                        }

                        return(await WriteResponseAsync(context.Response, new Response().NotModified()));
                    }

                    return(await WriteResponseAsync(context.Response, new Response().PreconditionFailed()));
                }
            }

            #endregion

            #region If-Modified-Since precondition header

            IfModifiedSinceHeader ifModifiedSinceHeader = IfModifiedSinceHeader.Parse(context.Request.Headers["If-Modified-Since"]);
            bool validIfModifiedSinceHttpDate           = ifModifiedSinceHeader != null && ifModifiedSinceHeader.HttpDate <= _systemClock.UtcDateTime;

            // Only consider an If-Modified-Since header if response status code is 200 and the HTTP-date is valid
            if (suggestedResponse.StatusCode.ParsedStatusCode == HttpStatusCode.OK && validIfModifiedSinceHttpDate)
            {
                // Return 304 if the response was cached before the HTTP-date
                if (cacheItem != null && cacheItem.CachedUtcTimestamp < ifModifiedSinceHeader.HttpDate)
                {
                    return(await WriteResponseAsync(context.Response, new Response().NotModified()));
                }
            }

            #endregion

            #region If-Unmodified-Since precondition header

            IfUnmodifiedSinceHeader ifUnmodifiedSinceHeader = IfUnmodifiedSinceHeader.Parse(context.Request.Headers["If-Unmodified-Since"]);
            bool validIfUnmodifiedSinceHttpDate             = ifUnmodifiedSinceHeader != null && ifUnmodifiedSinceHeader.HttpDate <= _systemClock.UtcDateTime;

            // Only consider an If-Unmodified-Since header if response status code is 2xx or 412 and the HTTP-date is valid
            if (((suggestedResponse.StatusCode.StatusCode >= 200 && suggestedResponse.StatusCode.StatusCode <= 299) || suggestedResponse.StatusCode.StatusCode == 412) && validIfUnmodifiedSinceHttpDate)
            {
                // Return 412 if the previous response was removed from the cache or was cached again at a later time
                if (cacheItem == null || cacheItem.CachedUtcTimestamp >= ifUnmodifiedSinceHeader.HttpDate)
                {
                    return(await WriteResponseAsync(context.Response, new Response().PreconditionFailed()));
                }
            }

            #endregion

            #region No server caching

            // Do not cache the response when the response sends a non-cacheable status code, or when an Authorization header is present
            if (!_cacheableStatusCodes.Contains(suggestedResponse.StatusCode) || context.Request.Headers["Authorization"] != null)
            {
                return(await WriteResponseAsync(context.Response, suggestedResponse));
            }

            CacheControlHeader cacheControlHeader = CacheControlHeader.Parse(context.Request.Headers["Cache-Control"]);

            // Do not cache the response if a "Cache-Control: no-cache" or "Cache-Control: no-store" header is present
            if (cacheControlHeader != null && (cacheControlHeader.NoCache || cacheControlHeader.NoStore))
            {
                return(await WriteResponseAsync(context.Response, suggestedResponse));
            }

            IEnumerable <PragmaHeader> pragmaHeader = PragmaHeader.ParseMany(context.Request.Headers["Pragma"]);

            // Do not cache the response if a "Pragma: no-cache" header is present
            if (pragmaHeader.Any(arg => String.Equals(arg.Name, "no-cache", StringComparison.OrdinalIgnoreCase)))
            {
                return(await WriteResponseAsync(context.Response, suggestedResponse));
            }

            #endregion

            // Return 504 if the response has not been cached but the client is requesting to receive only a cached response
            if (cacheItem == null && cacheControlHeader != null && cacheControlHeader.OnlyIfCached)
            {
                return(await WriteResponseAsync(context.Response, new Response().GatewayTimeout()));
            }

            if (cacheItem != null)
            {
                // Write the cached response if no Cache-Control header is present
                // Write the cached response if a "Cache-Control: max-age" header is validated
                // Write the cached response if a "Cache-Control: max-stale" header is validated
                // Write the cached response if a "Cache-Control: min-fresh" header is validated
                if (cacheControlHeader == null ||
                    _systemClock.UtcDateTime - cacheItem.CachedUtcTimestamp <= cacheControlHeader.MaxAge ||
                    cacheControlHeader.OnlyIfCached ||
                    cacheItem.ExpiresUtcTimestamp == null ||
                    _systemClock.UtcDateTime - cacheItem.ExpiresUtcTimestamp.Value <= cacheControlHeader.MaxStale ||
                    cacheItem.ExpiresUtcTimestamp.Value - _systemClock.UtcDateTime < cacheControlHeader.MinFresh)
                {
                    return(await WriteResponseInCacheAsync(context.Response, cacheItem));
                }
            }

            bool cacheOnServer = suggestedResponse.CachePolicy.AllowsServerCaching;
            var  cacheResponse = new CacheResponse(suggestedResponse);

            if (cacheOnServer)
            {
                DateTime expirationUtcTimestamp = suggestedResponse.CachePolicy.ServerCacheExpirationUtcTimestamp != null
                                        ? suggestedResponse.CachePolicy.ServerCacheExpirationUtcTimestamp.Value
                                        : _systemClock.UtcDateTime + suggestedResponse.CachePolicy.ServerCacheMaxAge.Value;

                await cache.AddAsync(cacheKey, cacheResponse, expirationUtcTimestamp);
            }

            return(await WriteResponseAsync(context.Response, cacheResponse));
        }
 public void Must_not_result_in_header(string headerValue)
 {
     Assert.That(IfModifiedSinceHeader.Parse(headerValue), Is.Null);
 }