internal RequestCachingSectionInternal(RequestCachingSection section)
{
if (!section.DisableAllCaching)
{
this.defaultCachePolicy = new RequestCachePolicy(section.DefaultPolicyLevel);
this.isPrivateCache = section.IsPrivateCache;
this.unspecifiedMaximumAge = section.UnspecifiedMaximumAge;
}
else
{
this.disableAllCaching = true;
}
this.httpRequestCacheValidator = new HttpRequestCacheValidator(false, this.UnspecifiedMaximumAge);
this.ftpRequestCacheValidator = new FtpRequestCacheValidator(false, this.UnspecifiedMaximumAge);
this.defaultCache = new WinInetCache(this.IsPrivateCache, true, true);
if (!section.DisableAllCaching)
{
HttpCachePolicyElement defaultHttpCachePolicy = section.DefaultHttpCachePolicy;
if (defaultHttpCachePolicy.WasReadFromConfig)
{
if (defaultHttpCachePolicy.PolicyLevel == HttpRequestCacheLevel.Default)
{
HttpCacheAgeControl cacheAgeControl = (defaultHttpCachePolicy.MinimumFresh != TimeSpan.MinValue) ? HttpCacheAgeControl.MaxAgeAndMinFresh : HttpCacheAgeControl.MaxAgeAndMaxStale;
this.defaultHttpCachePolicy = new HttpRequestCachePolicy(cacheAgeControl, defaultHttpCachePolicy.MaximumAge, (defaultHttpCachePolicy.MinimumFresh != TimeSpan.MinValue) ? defaultHttpCachePolicy.MinimumFresh : defaultHttpCachePolicy.MaximumStale);
}
else
{
this.defaultHttpCachePolicy = new HttpRequestCachePolicy(defaultHttpCachePolicy.PolicyLevel);
}
}
FtpCachePolicyElement defaultFtpCachePolicy = section.DefaultFtpCachePolicy;
if (defaultFtpCachePolicy.WasReadFromConfig)
{
this.defaultFtpCachePolicy = new RequestCachePolicy(defaultFtpCachePolicy.PolicyLevel);
}
}
}
public static void ConstructUnconditionalRefreshRequest(HttpRequestCacheValidator ctx)
{
WebHeaderCollection headers = ctx.Request.Headers;
headers["Cache-Control"] = "max-age=0";
headers["Pragma"] = "no-cache";
if (ctx.RequestIfHeader1 != null)
{
headers.RemoveInternal(ctx.RequestIfHeader1);
ctx.RequestIfHeader1 = null;
}
if (ctx.RequestIfHeader2 != null)
{
headers.RemoveInternal(ctx.RequestIfHeader2);
ctx.RequestIfHeader2 = null;
}
if (ctx.RequestRangeCache)
{
headers.RemoveInternal("Range");
ctx.RequestRangeCache = false;
}
}
/*
This Validator should be called ONLY before submitting any response
*/
/*
Returns:
- Valid : Cache can be returned to the app subject to effective policy
- Invalid : A Conditional request MUST be made (unconditional request is also fine)
*/
internal static TriState ValidateCacheBySpecialCases(HttpRequestCacheValidator ctx) {
/*
no-cache
If the no-cache directive does not specify a field-name, then a
cache MUST NOT use the response to satisfy a subsequent request
without successful revalidation with the origin server. This
allows an origin server to prevent caching even by caches that
have been configured to return stale responses to client requests.
*/
if (ctx.CacheCacheControl.NoCache) {
if (ctx.CacheCacheControl.NoCacheHeaders == null)
{
if(Logging.On)Logging.PrintInfo(Logging.RequestCache, SR.GetString(SR.net_log_cache_control_no_cache));
return TriState.Invalid;
}
/*
If the no-cache directive does specify one or more field-names, then a cache MAY
use the response to satisfy a subsequent request, subject to any other restrictions
on caching.
However, the specified field-name(s) MUST NOT be sent in the response to
a subsequent request without successful revalidation with the origin server.
This allows an origin server to prevent the re-use of certain header fields
in a response, while still allowing caching of the rest of the response.
*/
if(Logging.On)Logging.PrintInfo(Logging.RequestCache, SR.GetString(SR.net_log_cache_control_no_cache_removing_some_headers));
for (int i = 0; i < ctx.CacheCacheControl.NoCacheHeaders.Length; ++i) {
ctx.CacheHeaders.Remove(ctx.CacheCacheControl.NoCacheHeaders[i]);
}
}
/*
must-revalidate
When the must-revalidate
directive is present in a response received by a cache, that cache
MUST NOT use the entry after it becomes stale to respond to a
subsequent request without first revalidating it with the origin
server. (I.e., the cache MUST do an end-to-end revalidation every
time, if, based solely on the origin server's Expires or max-age
value, the cached response is stale.)
proxy-revalidate
The proxy-revalidate directive has the same meaning as the must-
revalidate directive, except that it does not apply to non-shared
user agent caches.
*/
if (ctx.CacheCacheControl.MustRevalidate ||
(!ctx.CacheEntry.IsPrivateEntry && ctx.CacheCacheControl.ProxyRevalidate))
{
if (ctx.CacheFreshnessStatus != CacheFreshnessStatus.Fresh) {
if(Logging.On)Logging.PrintInfo(Logging.RequestCache, SR.GetString(SR.net_log_cache_control_must_revalidate));
return TriState.Invalid;
}
}
/*
When a shared cache (see section 13.7) receives a request
containing an Authorization field, it MUST NOT return the
corresponding response as a reply to any other request, unless one
of the following specific exceptions holds:
1. If the response includes the "s-maxage" cache-control
directive, the cache MAY use that response in replying to a
subsequent request. But (if the specified maximum age has
passed) a proxy cache MUST first revalidate it with the origin
server, using the request-headers from the new request to allow
the origin server to authenticate the new request. (This is the
defined behavior for s-maxage.) If the response includes "s-
maxage=0", the proxy MUST always revalidate it before re-using
it.
2. If the response includes the "must-revalidate" cache-control
directive, the cache MAY use that response in replying to a
subsequent request. But if the response is stale, all caches
MUST first revalidate it with the origin server, using the
request-headers from the new request to allow the origin server
to authenticate the new request.
3. If the response includes the "public" cache-control directive,
it MAY be returned in reply to any subsequent request.
*/
if (ctx.Request.Headers[HttpKnownHeaderNames.Authorization] != null) {
if (ctx.CacheFreshnessStatus != CacheFreshnessStatus.Fresh) {
if(Logging.On)Logging.PrintInfo(Logging.RequestCache, SR.GetString(SR.net_log_cache_cached_auth_header));
return TriState.Invalid;
}
if (!ctx.CacheEntry.IsPrivateEntry && ctx.CacheCacheControl.SMaxAge == -1 && !ctx.CacheCacheControl.MustRevalidate && !ctx.CacheCacheControl.Public) {
if(Logging.On)Logging.PrintInfo(Logging.RequestCache, SR.GetString(SR.net_log_cache_cached_auth_header_no_control_directive));
return TriState.Invalid;
}
}
return TriState.Valid;
}
/*
Returns:
- Valid : The cache can be updated with the response
- Unknown : The response should not go into cache
*/
internal static TriState OnUpdateCache(HttpRequestCacheValidator ctx, HttpWebResponse resp) {
/*
Quick check on supported methods.
*/
if (ctx.RequestMethod != HttpMethod.Head &&
ctx.RequestMethod != HttpMethod.Get &&
ctx.RequestMethod != HttpMethod.Post) {
if(Logging.On)Logging.PrintInfo(Logging.RequestCache, SR.GetString(SR.net_log_cache_not_a_get_head_post));
return TriState.Unknown;
}
//If the entry did not exist ...
if (ctx.CacheStream == Stream.Null || (int)ctx.CacheStatusCode == 0) {
if(resp.StatusCode == HttpStatusCode.NotModified) {
// Protection from some weird case when user has changed things
if(Logging.On)Logging.PrintWarning(Logging.RequestCache, SR.GetString(SR.net_log_cache_cannot_update_cache_if_304));
return TriState.Unknown;
}
if (ctx.RequestMethod == HttpMethod.Head) {
// Protection from some caching Head response when entry does not exist.
if(Logging.On)Logging.PrintWarning(Logging.RequestCache, SR.GetString(SR.net_log_cache_cannot_update_cache_with_head_resp));
return TriState.Unknown;
}
}
if (resp == null) {
if(Logging.On)Logging.PrintWarning(Logging.RequestCache, SR.GetString(SR.net_log_cache_http_resp_is_null));
return TriState.Unknown;
}
//
// We assume that ctx.ResponseCacheControl is already updated based on a live response
//
/*
no-store
... If sent in a response,
a cache MUST NOT store any part of either this response or the
request that elicited it.
*/
if (ctx.ResponseCacheControl.NoStore) {
if(Logging.On)Logging.PrintInfo(Logging.RequestCache, SR.GetString(SR.net_log_cache_resp_cache_control_is_no_store));
return TriState.Unknown;
}
/*
If there is neither a cache validator nor an explicit expiration time
associated with a response, we do not expect it to be cached, but
certain caches MAY violate this expectation (for example, when little
or no network connectivity is available). A client can usually detect
that such a response was taken from a cache by comparing the Date
header to the current time.
*/
// NOTE: If no Expire and no Validator peresnt we choose to CACHE
//===============================================================
/*
Note: a new response that has an older Date header value than
existing cached responses is not cacheable.
*/
if (ctx.ResponseDate != DateTime.MinValue && ctx.CacheDate != DateTime.MinValue) {
if (ctx.ResponseDate < ctx.CacheDate) {
if(Logging.On)Logging.PrintWarning(Logging.RequestCache, SR.GetString(SR.net_log_cache_resp_older_than_cache));
return TriState.Unknown;
}
}
/*
public
Indicates that the response MAY be cached by any cache, even if it
would normally be non-cacheable or cacheable only within a non-
shared cache. (See also Authorization, section 14.8, for
additional details.)
*/
if (ctx.ResponseCacheControl.Public) {
if(Logging.On)Logging.PrintInfo(Logging.RequestCache, SR.GetString(SR.net_log_cache_resp_cache_control_is_public));
return TriState.Valid;
}
// sometiem public cache can cache a response with "private" directive, subject to other restrictions
TriState result = TriState.Unknown;
/*
private
Indicates that all or part of the response message is intended for
a single user and MUST NOT be cached by a shared cache. This
allows an origin server to state that the specified parts of the
response are intended for only one user and are not a valid
response for requests by other users. A private (non-shared) cache
MAY cache the response.
*/
if (ctx.ResponseCacheControl.Private) {
if (!ctx.CacheEntry.IsPrivateEntry) {
if (ctx.ResponseCacheControl.PrivateHeaders == null) {
if(Logging.On)Logging.PrintInfo(Logging.RequestCache, SR.GetString(SR.net_log_cache_resp_cache_control_is_private));
return TriState.Unknown;
}
if(Logging.On)Logging.PrintInfo(Logging.RequestCache, SR.GetString(SR.net_log_cache_resp_cache_control_is_private_plus_headers));
for (int i = 0; i < ctx.ResponseCacheControl.PrivateHeaders.Length; ++i) {
ctx.CacheHeaders.Remove(ctx.ResponseCacheControl.PrivateHeaders[i]);
result = TriState.Valid;
}
}
else {
result = TriState.Valid;
}
}
/*
The RFC is funky on no-cache directive.
But the bottom line is sometime you CAN cache no-cache responses.
*/
if (ctx.ResponseCacheControl.NoCache)
{
if (ctx.ResponseLastModified == DateTime.MinValue && ctx.Response.Headers.ETag == null) {
if(Logging.On)Logging.PrintWarning(Logging.RequestCache, SR.GetString(SR.net_log_cache_revalidation_required));
return TriState.Unknown;
}
if(Logging.On)Logging.PrintInfo(Logging.RequestCache, SR.GetString(SR.net_log_cache_needs_revalidation));
return TriState.Valid;
}
if (ctx.ResponseCacheControl.SMaxAge != -1 || ctx.ResponseCacheControl.MaxAge != -1) {
if(Logging.On)Logging.PrintInfo(Logging.RequestCache, SR.GetString(SR.net_log_cache_resp_allows_caching, ctx.ResponseCacheControl.ToString()));
return TriState.Valid;
}
/*
When a shared cache (see section 13.7) receives a request
containing an Authorization field, it MUST NOT return the
corresponding response as a reply to any other request, unless one
of the following specific exceptions holds:
1. If the response includes the "s-maxage" cache-control
2. If the response includes the "must-revalidate" cache-control
3. If the response includes the "public" cache-control directive,
*/
if (!ctx.CacheEntry.IsPrivateEntry && ctx.Request.Headers[HttpKnownHeaderNames.Authorization] != null) {
// we've already passed an opportunity to cache.
if(Logging.On)Logging.PrintInfo(Logging.RequestCache, SR.GetString(SR.net_log_cache_auth_header_and_no_s_max_age));
return TriState.Unknown;
}
/*
POST
Responses to this method are not cacheable, unless the response
includes appropriate Cache-Control or Expires header fields.
*/
if (ctx.RequestMethod == HttpMethod.Post && resp.Headers.Expires == null) {
if(Logging.On)Logging.PrintInfo(Logging.RequestCache, SR.GetString(SR.net_log_cache_post_resp_without_cache_control_or_expires));
return TriState.Unknown;
}
/*
A response received with a status code of 200, 203, 206, 300, 301 or
410 MAY be stored by a cache and used in reply to a subsequent
request, subject to the expiration mechanism, unless a cache-control
directive prohibits caching. However, a cache that does not support
the Range and Content-Range headers MUST NOT cache 206 (Partial
Content) responses.
NOTE: We added 304 here which is correct
*/
if (resp.StatusCode == HttpStatusCode.NotModified ||
resp.StatusCode == HttpStatusCode.OK ||
resp.StatusCode == HttpStatusCode.NonAuthoritativeInformation ||
resp.StatusCode == HttpStatusCode.PartialContent ||
resp.StatusCode == HttpStatusCode.MultipleChoices ||
resp.StatusCode == HttpStatusCode.MovedPermanently ||
resp.StatusCode == HttpStatusCode.Gone)
{
if(Logging.On)Logging.PrintInfo(Logging.RequestCache, SR.GetString(SR.net_log_cache_valid_based_on_status_code, (int)resp.StatusCode));
return TriState.Valid;
}
/*
A response received with any other status code (e.g. status codes 302
and 307) MUST NOT be returned in a reply to a subsequent request
unless there are cache-control directives or another header(s) that
explicitly allow it. For example, these include the following: an
Expires header (section 14.21); a "max-age", "s-maxage", "must-
revalidate", "proxy-revalidate", "public" or "private" cache-control
directive (section 14.9).
*/
if (result != TriState.Valid) {
// otheriwse there was a "safe" private directive that allows caching
if(Logging.On)Logging.PrintInfo(Logging.RequestCache, SR.GetString(SR.net_log_cache_resp_no_cache_control, (int)resp.StatusCode));
}
return result;
}
/*----------*/
// Continue = Proceed to the next protocol stage.
// DoNotTakeFromCache = Don't used caches value for this request
// DoNotUseCache = Cache is not used for this request and response is not cached.
public static CacheValidationStatus OnValidateRequest(HttpRequestCacheValidator ctx)
{
CacheValidationStatus result = Common.OnValidateRequest(ctx);
if (result == CacheValidationStatus.DoNotUseCache)
{
return result;
}
/*
HTTP/1.1 caches SHOULD treat "Pragma: no-cache" as if the client had
sent "Cache-Control: no-cache". No new Pragma directives will be
defined in HTTP.
we use above information to remove pragma header (we control it itself)
*/
ctx.Request.Headers.RemoveInternal(HttpKnownHeaderNames.Pragma);
/*
we want to control cache-control header as well, any specifi extensions should be done
using a derived validator class and custom policy
*/
ctx.Request.Headers.RemoveInternal(HttpKnownHeaderNames.CacheControl);
if (ctx.Policy.Level == HttpRequestCacheLevel.NoCacheNoStore)
{
//adjust request headers since retrieval validators will be suppressed upon return.
ctx.Request.Headers.AddInternal(HttpKnownHeaderNames.CacheControl, "no-store");
ctx.Request.Headers.AddInternal(HttpKnownHeaderNames.CacheControl, "no-cache");
ctx.Request.Headers.AddInternal(HttpKnownHeaderNames.Pragma, "no-cache");
result = CacheValidationStatus.DoNotTakeFromCache;
}
else if (result == CacheValidationStatus.Continue)
{
if (ctx.Policy.Level == HttpRequestCacheLevel.Reload || ctx.Policy.Level == HttpRequestCacheLevel.NoCacheNoStore)
{
//adjust request headers since retrieval validators will be suppressed upon return.
ctx.Request.Headers.AddInternal(HttpKnownHeaderNames.CacheControl, "no-cache");
ctx.Request.Headers.AddInternal(HttpKnownHeaderNames.Pragma, "no-cache");
result = CacheValidationStatus.DoNotTakeFromCache;
}
else if (ctx.Policy.Level == HttpRequestCacheLevel.Refresh)
{
//adjust request headers since retrieval validators will be suppressed upon return.
ctx.Request.Headers.AddInternal(HttpKnownHeaderNames.CacheControl, "max-age=0");
ctx.Request.Headers.AddInternal(HttpKnownHeaderNames.Pragma, "no-cache");
result = CacheValidationStatus.DoNotTakeFromCache;
}
else if (ctx.Policy.Level == HttpRequestCacheLevel.Default)
{
//Transfer Policy into CacheControl directives
if (ctx.Policy.MinFresh > TimeSpan.Zero) {
ctx.Request.Headers.AddInternal(HttpKnownHeaderNames.CacheControl, "min-fresh=" + (int)ctx.Policy.MinFresh.TotalSeconds);
}
if (ctx.Policy.MaxAge != TimeSpan.MaxValue) {
ctx.Request.Headers.AddInternal(HttpKnownHeaderNames.CacheControl, "max-age=" + (int)ctx.Policy.MaxAge.TotalSeconds);
}
if (ctx.Policy.MaxStale > TimeSpan.Zero) {
ctx.Request.Headers.AddInternal(HttpKnownHeaderNames.CacheControl, "max-stale=" + (int)ctx.Policy.MaxStale.TotalSeconds);
}
}
else if (ctx.Policy.Level == HttpRequestCacheLevel.CacheOnly || ctx.Policy.Level == HttpRequestCacheLevel.CacheOrNextCacheOnly)
{
// In case other validators will not be called
ctx.Request.Headers.AddInternal(HttpKnownHeaderNames.CacheControl, "only-if-cached");
}
}
return result;
}
/*----------*/
// Returns:
// CacheResponse = Replace cache entry with received live response
// UpdateResponseInformation = Update Metadata of cache entry using live response headers
// RemoveFromCache = Remove cache entry referenced to by a cache key.
// Continue = Simply do not update cache.
//
public static CacheValidationStatus OnUpdateCache(HttpRequestCacheValidator ctx) {
// Below condition is to get rid of a broken cache entry, we cannot update cache in that case
if (ctx.CacheStatusCode == HttpStatusCode.NotModified) {
if(Logging.On)Logging.PrintWarning(Logging.RequestCache, SR.GetString(SR.net_log_cache_need_to_remove_invalid_cache_entry_304));
return CacheValidationStatus.RemoveFromCache;
}
HttpWebResponse resp = ctx.Response as HttpWebResponse;
if(Logging.On)Logging.PrintInfo(Logging.RequestCache, SR.GetString(SR.net_log_cache_resp_status, resp.StatusCode));
/*********
Vs Whidbey#127214
It was decided not to play with ResponseContentLocation in our implementation.
A derived class may still want to play.
// Compute new Cache Update Key if Content-Location is present on the response
if (ctx.ResponseContentLocation != null) {
if (!Uri.TryParse(ctx.ResponseContentLocation, true, true, out cacheUri)) {
if(Logging.On)Logging.PrintError(Logging.RequestCache, "Cannot parse Uri from Response Content-Location: " + ctx.ResponseContentLocation);
return CacheValidationStatus.RemoveFromCache;
}
if (!cacheUri.IsAbsoluteUri) {
try {
ctx.CacheKey = new Uri(ctx.RequestUri, cacheUri);
}
catch {
return CacheValidationStatus.RemoveFromCache;
}
}
}
*********/
if (ctx.ValidationStatus == CacheValidationStatus.RemoveFromCache) {
return CacheValidationStatus.RemoveFromCache;
}
CacheValidationStatus noUpdateResult =
(ctx.RequestMethod >= HttpMethod.Post && ctx.RequestMethod <= HttpMethod.Delete || ctx.RequestMethod == HttpMethod.Other)
?CacheValidationStatus.RemoveFromCache
:CacheValidationStatus.DoNotUpdateCache;
if (Common.OnUpdateCache(ctx, resp) != TriState.Valid) {
return noUpdateResult;
}
CacheValidationStatus result = CacheValidationStatus.CacheResponse;
ctx.CacheEntry.IsPartialEntry = false;
if (resp.StatusCode == HttpStatusCode.NotModified || ctx.RequestMethod == HttpMethod.Head)
{
result = CacheValidationStatus.UpdateResponseInformation;
// This may take a shorter path when updating the entry
if(Logging.On)Logging.PrintInfo(Logging.RequestCache, SR.GetString(SR.net_log_cache_resp_304_or_request_head));
if (ctx.CacheDontUpdateHeaders) {
if(Logging.On)Logging.PrintInfo(Logging.RequestCache, SR.GetString(SR.net_log_cache_dont_update_cached_headers));
ctx.CacheHeaders = null;
ctx.CacheEntry.ExpiresUtc = ctx.ResponseExpires;
ctx.CacheEntry.LastModifiedUtc = ctx.ResponseLastModified;
if (ctx.Policy.Level == HttpRequestCacheLevel.Default) {
ctx.CacheEntry.MaxStale = ctx.Policy.MaxStale;
}
else {
ctx.CacheEntry.MaxStale = TimeSpan.MinValue;
}
ctx.CacheEntry.LastSynchronizedUtc = DateTime.UtcNow;
}
else {
if(Logging.On)Logging.PrintInfo(Logging.RequestCache, SR.GetString(SR.net_log_cache_update_cached_headers));
}
}
else if (resp.StatusCode == HttpStatusCode.PartialContent)
{
// Check on whether the user requested range can be appended to the cache entry
// We only support combining of non-overlapped increasing bytes ranges
if (ctx.CacheEntry.StreamSize != ctx.ResponseRangeStart && ctx.ResponseRangeStart != 0)
{
if(Logging.On)Logging.PrintWarning(Logging.RequestCache, SR.GetString(SR.net_log_cache_partial_resp_not_combined_with_existing_entry, ctx.CacheEntry.StreamSize, ctx.ResponseRangeStart));
return noUpdateResult;
}
// We might be appending a live stream to cache BUT user has asked for a specific range.
// Hence don't reset CacheStreamOffset here so the protocol will create a cache forwarding stream that will hide first bytes from the user
if (!ctx.RequestRangeUser) {
ctx.CacheStreamOffset = 0;
}
// Below code assumes that a combined response has been given to the user,
Common.ReplaceOrUpdateCacheHeaders(ctx, resp);
ctx.CacheHttpVersion = resp.ProtocolVersion;
ctx.CacheEntityLength = ctx.ResponseEntityLength;
ctx.CacheStreamLength = ctx.CacheEntry.StreamSize = ctx.ResponseRangeEnd+1;
if (ctx.CacheEntityLength > 0 && ctx.CacheEntityLength == ctx.CacheEntry.StreamSize)
{
//eventually cache is about to store a complete response
Common.Construct200ok(ctx);
}
else
Common.Construct206PartialContent(ctx, 0);
}
else
{
Common.ReplaceOrUpdateCacheHeaders(ctx, resp);
ctx.CacheHttpVersion = resp.ProtocolVersion;
ctx.CacheStatusCode = resp.StatusCode;
ctx.CacheStatusDescription = resp.StatusDescription;
ctx.CacheEntry.StreamSize = resp.ContentLength;
}
return result;
}
//
// This is called when we have decided to take from Cache or update Cache
//
public static void ReplaceOrUpdateCacheHeaders(HttpRequestCacheValidator ctx, HttpWebResponse resp) {
/*
In other words, the set of end-to-end headers received in the
incoming response overrides all corresponding end-to-end headers
stored with the cache entry (except for stored Warning headers with
warn-code 1xx, which are deleted even if not overridden).
This rule does not allow an origin server to use
a 304 (Not Modified) or a 206 (Partial Content) response to
entirely delete a header that it had provided with a previous
response.
*/
if (ctx.CacheHeaders == null || (resp.StatusCode != HttpStatusCode.NotModified && resp.StatusCode != HttpStatusCode.PartialContent))
{
// existing context is dropped
ctx.CacheHeaders = new WebHeaderCollection();
}
// Here we preserve Request headers that are present in the response Vary header
string[] respVary = resp.Headers.GetValues(HttpKnownHeaderNames.Vary);
if (respVary != null) {
ArrayList varyValues = new ArrayList();
HttpRequestCacheValidator.ParseHeaderValues(respVary,
HttpRequestCacheValidator.ParseValuesCallback,
varyValues);
if (varyValues.Count != 0 && ((string)(varyValues[0]))[0] != '*') {
// we got some request headers to save
if(Logging.On)Logging.PrintInfo(Logging.RequestCache, SR.GetString(SR.net_log_cache_saving_request_headers, resp.Headers[HttpKnownHeaderNames.Vary]));
if (ctx.SystemMeta == null) {
ctx.SystemMeta = new NameValueCollection(varyValues.Count+1, CaseInsensitiveAscii.StaticInstance);
}
for (int i = 0; i < varyValues.Count; ++i) {
string headerValue = ctx.Request.Headers[(string)varyValues[i]];
ctx.SystemMeta[(string)varyValues[i]] = headerValue;
}
}
}
/*
- Hop-by-hop headers, which are meaningful only for a single
transport-level connection, and are not stored by caches or
forwarded by proxies.
The following HTTP/1.1 headers are hop-by-hop headers:
- Connection
- Keep-Alive
- Proxy-Authenticate
- Proxy-Authorization
- TE
- Trailers
- Transfer-Encoding
- Upgrade
*/
// We add or Replace headers from the live response
for (int i = 0; i < ctx.Response.Headers.Count; ++i) {
string key = ctx.Response.Headers.GetKey(i);
if (AsciiLettersNoCaseEqual(key, HttpKnownHeaderNames.Connection) ||
AsciiLettersNoCaseEqual(key, HttpKnownHeaderNames.KeepAlive) ||
AsciiLettersNoCaseEqual(key, HttpKnownHeaderNames.ProxyAuthenticate) ||
AsciiLettersNoCaseEqual(key, HttpKnownHeaderNames.ProxyAuthorization) ||
AsciiLettersNoCaseEqual(key, HttpKnownHeaderNames.TE) ||
AsciiLettersNoCaseEqual(key, HttpKnownHeaderNames.TransferEncoding) ||
AsciiLettersNoCaseEqual(key, HttpKnownHeaderNames.Trailer) ||
AsciiLettersNoCaseEqual(key, HttpKnownHeaderNames.Upgrade))
{
continue;
}
if (resp.StatusCode == HttpStatusCode.NotModified && AsciiLettersNoCaseEqual(key, HttpKnownHeaderNames.ContentLength)) {
continue;
}
ctx.CacheHeaders.ChangeInternal(key, ctx.Response.Headers[i]);
}
}
//
// A template for 200 response, used by cache update
//
public static void Construct200ok(HttpRequestCacheValidator ctx) {
ctx.CacheStatusCode = HttpStatusCode.OK;
ctx.CacheStatusDescription = Common.OkDescription;
if (ctx.CacheHttpVersion == null)
ctx.CacheHttpVersion = new Version(1,1);
ctx.CacheHeaders.Remove(HttpKnownHeaderNames.ContentRange);
if (ctx.CacheEntityLength == -1)
{ctx.CacheHeaders.Remove(HttpKnownHeaderNames.ContentLength);}
else
{ctx.CacheHeaders[HttpKnownHeaderNames.ContentLength] = ctx.CacheEntityLength.ToString(NumberFormatInfo.InvariantInfo);}
ctx.CacheEntry.IsPartialEntry = false;
}
/*----------*/
public static CacheFreshnessStatus OnValidateFreshness(HttpRequestCacheValidator ctx)
{
// This will figure out ctx.CacheAge and ctx.CacheMaxAge memebers
CacheFreshnessStatus result = Common.ComputeFreshness(ctx);
/*
We note one exception to this rule: since some applications have
traditionally used GETs and HEADs with query URLs (those containing a
"?" in the rel_path part) to perform operations with significant side
effects, caches MUST NOT treat responses to such URIs as fresh unless
the server provides an explicit expiration time. This specifically
means that responses from HTTP/1.0 servers for such URIs SHOULD NOT
be taken from a cache. See section 9.1.1 for related information.
*/
if (ctx.Uri.Query.Length != 0) {
if (ctx.CacheHeaders.Expires == null && (ctx.CacheEntry.IsPrivateEntry?ctx.CacheCacheControl.MaxAge == -1:ctx.CacheCacheControl.SMaxAge == -1)) {
if(Logging.On)Logging.PrintInfo(Logging.RequestCache, SR.GetString(SR.net_log_cache_uri_with_query_has_no_expiration));
return CacheFreshnessStatus.Stale;
}
if (ctx.CacheHttpVersion.Major <= 1 && ctx.CacheHttpVersion.Minor < 1) {
if(Logging.On)Logging.PrintInfo(Logging.RequestCache, SR.GetString(SR.net_log_cache_uri_with_query_and_cached_resp_from_http_10));
return CacheFreshnessStatus.Stale;
}
}
return result;
}
//
// Second Time (after response) cache validation always goes through this method.
//
// Returns
// - ReturnCachedResponse = Take from cache, cache stream may be replaced and response stream is closed
// - DoNotTakeFromCache = Disregard the cache
// - RemoveFromCache = Disregard and remove cache entry
// - CombineCachedAndServerResponse = The combined cache+live stream has been constructed.
//
public static CacheValidationStatus ValidateCacheAfterResponse(HttpRequestCacheValidator ctx, HttpWebResponse resp) {
if(Logging.On)Logging.PrintInfo(Logging.RequestCache, SR.GetString(SR.net_log_cache_after_validation));
if ((ctx.CacheStream == Stream.Null || (int)ctx.CacheStatusCode == 0) && resp.StatusCode == HttpStatusCode.NotModified) {
if(Logging.On)Logging.PrintWarning(Logging.RequestCache, SR.GetString(SR.net_log_cache_resp_status_304));
return CacheValidationStatus.DoNotTakeFromCache;
}
if (ctx.RequestMethod == HttpMethod.Head) {
/*
The response to a HEAD request MAY be cacheable in the sense that the
information contained in the response MAY be used to update a
previously cached entity from that resource. If the new field values
indicate that the cached entity differs from the current entity (as
would be indicated by a change in Content-Length, Content-MD5, ETag
or Last-Modified), then the cache MUST treat the cache entry as
stale.
*/
bool invalidate = false;
if (ctx.ResponseEntityLength != -1 && ctx.ResponseEntityLength != ctx.CacheEntityLength) {
if(Logging.On)Logging.PrintInfo(Logging.RequestCache, SR.GetString(SR.net_log_cache_head_resp_has_different_content_length));
invalidate = true;
}
if (resp.Headers[HttpKnownHeaderNames.ContentMD5] != ctx.CacheHeaders[HttpKnownHeaderNames.ContentMD5]) {
if(Logging.On)Logging.PrintInfo(Logging.RequestCache, SR.GetString(SR.net_log_cache_head_resp_has_different_content_md5));
invalidate = true;
}
if (resp.Headers.ETag != ctx.CacheHeaders.ETag) {
if(Logging.On)Logging.PrintInfo(Logging.RequestCache, SR.GetString(SR.net_log_cache_head_resp_has_different_etag));
invalidate = true;
}
if (resp.StatusCode != HttpStatusCode.NotModified && resp.Headers.LastModified != ctx.CacheHeaders.LastModified)
{
if(Logging.On)Logging.PrintWarning(Logging.RequestCache, SR.GetString(SR.net_log_cache_304_head_resp_has_different_last_modified));
invalidate = true;
}
if (invalidate) {
if(Logging.On)Logging.PrintWarning(Logging.RequestCache, SR.GetString(SR.net_log_cache_existing_entry_has_to_be_discarded));
return CacheValidationStatus.RemoveFromCache;
}
}
// If server has returned 206 partial content
if (resp.StatusCode == HttpStatusCode.PartialContent) {
/*
A cache MUST NOT combine a 206 response with other previously cached
content if the ETag or Last-Modified headers do not match exactly,
see 13.5.4.
*/
// Sometime if ETag has been used the server won't include Last-Modified, which seems to be OK
if (ctx.CacheHeaders.ETag != ctx.Response.Headers.ETag ||
(ctx.CacheHeaders.LastModified != ctx.Response.Headers.LastModified
&& (ctx.Response.Headers.LastModified != null || ctx.Response.Headers.ETag == null)))
{
if(Logging.On)Logging.PrintInfo(Logging.RequestCache, SR.GetString(SR.net_log_cache_206_resp_non_matching_entry));
if(Logging.On)Logging.PrintWarning(Logging.RequestCache, SR.GetString(SR.net_log_cache_existing_entry_should_be_discarded));
return CacheValidationStatus.RemoveFromCache;
}
// check does the live stream fit exactly into our cache tail
if (ctx.CacheEntry.StreamSize != ctx.ResponseRangeStart) {
if(Logging.On)Logging.PrintInfo(Logging.RequestCache, SR.GetString(SR.net_log_cache_206_resp_starting_position_not_adjusted));
return CacheValidationStatus.DoNotTakeFromCache;
}
Common.ReplaceOrUpdateCacheHeaders(ctx, resp);
if (ctx.RequestRangeUser) {
// This happens when a response is being downloaded page by page
// We request combining the streams
// A user will see data starting CacheStreamOffset of a combined stream
ctx.CacheStreamOffset = ctx.CacheEntry.StreamSize;
// This is a user response content length
ctx.CacheStreamLength = ctx.ResponseRangeEnd - ctx.ResponseRangeStart + 1;
// This is a new cache stream size
ctx.CacheEntityLength = ctx.ResponseEntityLength;
ctx.CacheStatusCode = resp.StatusCode;
ctx.CacheStatusDescription = resp.StatusDescription;
ctx.CacheHttpVersion = resp.ProtocolVersion;
}
else {
// This happens when previous response was downloaded partly
ctx.CacheStreamOffset = 0;
ctx.CacheStreamLength = ctx.ResponseEntityLength;
ctx.CacheEntityLength = ctx.ResponseEntityLength;
ctx.CacheStatusCode = HttpStatusCode.OK;
ctx.CacheStatusDescription = Common.OkDescription;
ctx.CacheHttpVersion = resp.ProtocolVersion;
ctx.CacheHeaders.Remove(HttpKnownHeaderNames.ContentRange);
if (ctx.CacheStreamLength == -1)
{ctx.CacheHeaders.Remove(HttpKnownHeaderNames.ContentLength);}
else
{ctx.CacheHeaders[HttpKnownHeaderNames.ContentLength] = ctx.CacheStreamLength.ToString(NumberFormatInfo.InvariantInfo);}
}
// At this point the protocol should create a combined stream made up of the cached and live streams
if(Logging.On)Logging.PrintInfo(Logging.RequestCache, SR.GetString(SR.net_log_cache_combined_resp_requested));
return CacheValidationStatus.CombineCachedAndServerResponse;
}
/*
304 Not Modified
The response MUST include the following header fields:
- Date, unless its omission is required by section 14.18.1
If a clockless origin server obeys these rules, and proxies and
clients add their own Date to any response received without one (as
already specified by [RFC 2068], section 14.19), caches will operate
correctly.
- ETag and/or Content-Location, if the header would have been sent
in a 200 response to the same request
- Expires, Cache-Control, and/or Vary, if the field-value might
differ from that sent in any previous response for the same
variant
*/
if (resp.StatusCode == HttpStatusCode.NotModified) {
// We will return the response from cache.
// We try to avoid to update Cache update in case the server has
// sent only headers that are "safe" to ignore
// It's not the best way but WinInet does not work well with headers update.
WebHeaderCollection cc = resp.Headers;
string location = null;
string etag = null;
if ((ctx.CacheExpires != ctx.ResponseExpires) ||
(ctx.CacheLastModified != ctx.ResponseLastModified) ||
(ctx.CacheDate != ctx.ResponseDate) ||
(ctx.ResponseCacheControl.IsNotEmpty) ||
((location=cc[HttpKnownHeaderNames.ContentLocation]) != null && location != ctx.CacheHeaders[HttpKnownHeaderNames.ContentLocation]) ||
((etag=cc.ETag) != null && etag != ctx.CacheHeaders.ETag)) {
// Headers have to be updated
// Note that would allow a new E-Tag header to come in without changing the content.
if(Logging.On)Logging.PrintInfo(Logging.RequestCache, SR.GetString(SR.net_log_cache_updating_headers_on_304));
Common.ReplaceOrUpdateCacheHeaders(ctx, resp);
return CacheValidationStatus.ReturnCachedResponse;
}
//Try to not update headers if they are invariant or the same
int ignoredHeaders = 0;
if (etag != null) {
++ignoredHeaders;
}
if (location != null) {
++ignoredHeaders;
}
if (ctx.ResponseAge != TimeSpan.MinValue) {
++ignoredHeaders;
}
if (ctx.ResponseLastModified != DateTime.MinValue) {
++ignoredHeaders;
}
if (ctx.ResponseExpires != DateTime.MinValue) {
++ignoredHeaders;
}
if (ctx.ResponseDate != DateTime.MinValue) {
++ignoredHeaders;
}
if (cc.Via != null) {
++ignoredHeaders;
}
if (cc[HttpKnownHeaderNames.Connection] != null) {
++ignoredHeaders;
}
if (cc[HttpKnownHeaderNames.KeepAlive] != null) {
++ignoredHeaders;
}
if (cc.ProxyAuthenticate != null) {
++ignoredHeaders;
}
if (cc[HttpKnownHeaderNames.ProxyAuthorization] != null) {
++ignoredHeaders;
}
if (cc[HttpKnownHeaderNames.TE] != null) {
++ignoredHeaders;
}
if (cc[HttpKnownHeaderNames.TransferEncoding] != null) {
++ignoredHeaders;
}
if (cc[HttpKnownHeaderNames.Trailer] != null) {
++ignoredHeaders;
}
if (cc[HttpKnownHeaderNames.Upgrade] != null) {
++ignoredHeaders;
}
if (resp.Headers.Count <= ignoredHeaders) {
if(Logging.On)Logging.PrintInfo(Logging.RequestCache, SR.GetString(SR.net_log_cache_suppressing_headers_update_on_304));
ctx.CacheDontUpdateHeaders = true;
}
else {
Common.ReplaceOrUpdateCacheHeaders(ctx, resp);
}
return CacheValidationStatus.ReturnCachedResponse;
}
// Any other response
if(Logging.On)Logging.PrintInfo(Logging.RequestCache, SR.GetString(SR.net_log_cache_status_code_not_304_206));
return CacheValidationStatus.DoNotTakeFromCache;
}
public static CacheValidationStatus TryConditionalRequest(HttpRequestCacheValidator ctx)
{
string str;
Rfc2616.TriState state = CheckForRangeRequest(ctx, out str);
if (state != Rfc2616.TriState.Invalid)
{
if (state != Rfc2616.TriState.Valid)
{
return ConstructConditionalRequest(ctx);
}
if (ctx is FtpRequestCacheValidator)
{
return CacheValidationStatus.DoNotTakeFromCache;
}
if (!TryConditionalRangeRequest(ctx))
{
return CacheValidationStatus.DoNotTakeFromCache;
}
ctx.RequestRangeCache = true;
((HttpWebRequest) ctx.Request).AddRange((int) ctx.CacheEntry.StreamSize);
if (Logging.On)
{
Logging.PrintInfo(Logging.RequestCache, SR.GetString("net_log_cache_range", new object[] { ctx.Request.Headers["Range"] }));
}
}
return CacheValidationStatus.Continue;
}
private static bool TryConditionalRangeRequest(HttpRequestCacheValidator ctx)
{
if (ctx.CacheEntry.StreamSize >= 0x7fffffffL)
{
if (Logging.On)
{
Logging.PrintWarning(Logging.RequestCache, SR.GetString("net_log_cache_entry_size_too_big", new object[] { ctx.CacheEntry.StreamSize }));
}
return false;
}
string eTag = ctx.CacheHeaders.ETag;
if (eTag != null)
{
ctx.Request.Headers["If-Range"] = eTag;
ctx.RequestIfHeader1 = "If-Range";
ctx.RequestValidator1 = eTag;
if (Logging.On)
{
Logging.PrintInfo(Logging.RequestCache, SR.GetString("net_log_cache_condition_if_range", new object[] { ctx.Request.Headers["If-Range"] }));
}
return true;
}
if (ctx.CacheEntry.LastModifiedUtc != DateTime.MinValue)
{
eTag = ctx.CacheEntry.LastModifiedUtc.ToString("r", CultureInfo.InvariantCulture);
if ((ctx.CacheHttpVersion.Major == 1) && (ctx.CacheHttpVersion.Minor == 0))
{
if (Logging.On)
{
Logging.PrintWarning(Logging.RequestCache, SR.GetString("net_log_cache_conditional_range_not_implemented_on_http_10"));
}
return false;
}
ctx.Request.Headers["If-Range"] = eTag;
ctx.RequestIfHeader1 = "If-Range";
ctx.RequestValidator1 = eTag;
if (Logging.On)
{
Logging.PrintInfo(Logging.RequestCache, SR.GetString("net_log_cache_condition_if_range", new object[] { ctx.Request.Headers["If-Range"] }));
}
return true;
}
if (Logging.On)
{
Logging.PrintWarning(Logging.RequestCache, SR.GetString("net_log_cache_cannot_construct_conditional_range_request"));
}
return false;
}
public static void ReplaceOrUpdateCacheHeaders(HttpRequestCacheValidator ctx, HttpWebResponse resp)
{
if ((ctx.CacheHeaders == null) || ((resp.StatusCode != HttpStatusCode.NotModified) && (resp.StatusCode != HttpStatusCode.PartialContent)))
{
ctx.CacheHeaders = new WebHeaderCollection();
}
string[] values = resp.Headers.GetValues("Vary");
if (values != null)
{
ArrayList list = new ArrayList();
HttpRequestCacheValidator.ParseHeaderValues(values, HttpRequestCacheValidator.ParseValuesCallback, list);
if ((list.Count != 0) && (((string) list[0])[0] != '*'))
{
if (Logging.On)
{
Logging.PrintInfo(Logging.RequestCache, SR.GetString("net_log_cache_saving_request_headers", new object[] { resp.Headers["Vary"] }));
}
if (ctx.SystemMeta == null)
{
ctx.SystemMeta = new NameValueCollection(list.Count + 1, CaseInsensitiveAscii.StaticInstance);
}
for (int j = 0; j < list.Count; j++)
{
string str = ctx.Request.Headers[(string) list[j]];
ctx.SystemMeta[(string) list[j]] = str;
}
}
}
for (int i = 0; i < ctx.Response.Headers.Count; i++)
{
string key = ctx.Response.Headers.GetKey(i);
if ((((!AsciiLettersNoCaseEqual(key, "Connection") && !AsciiLettersNoCaseEqual(key, "Keep-Alive")) && (!AsciiLettersNoCaseEqual(key, "Proxy-Authenticate") && !AsciiLettersNoCaseEqual(key, "Proxy-Authorization"))) && ((!AsciiLettersNoCaseEqual(key, "TE") && !AsciiLettersNoCaseEqual(key, "Transfer-Encoding")) && (!AsciiLettersNoCaseEqual(key, "Trailer") && !AsciiLettersNoCaseEqual(key, "Upgrade")))) && ((resp.StatusCode != HttpStatusCode.NotModified) || !AsciiLettersNoCaseEqual(key, "Content-Length")))
{
ctx.CacheHeaders.ChangeInternal(key, ctx.Response.Headers[i]);
}
}
}
public static CacheValidationStatus OnValidateRequest(HttpRequestCacheValidator ctx)
{
if ((ctx.RequestMethod >= HttpMethod.Post) && (ctx.RequestMethod <= HttpMethod.Delete))
{
if (ctx.Policy.Level == HttpRequestCacheLevel.CacheOnly)
{
ctx.FailRequest(WebExceptionStatus.RequestProhibitedByCachePolicy);
}
return CacheValidationStatus.DoNotTakeFromCache;
}
if ((ctx.RequestMethod < HttpMethod.Head) || (ctx.RequestMethod > HttpMethod.Get))
{
if (ctx.Policy.Level == HttpRequestCacheLevel.CacheOnly)
{
ctx.FailRequest(WebExceptionStatus.RequestProhibitedByCachePolicy);
}
return CacheValidationStatus.DoNotUseCache;
}
if (((ctx.Request.Headers["If-Modified-Since"] == null) && (ctx.Request.Headers["If-None-Match"] == null)) && (((ctx.Request.Headers["If-Range"] == null) && (ctx.Request.Headers["If-Match"] == null)) && (ctx.Request.Headers["If-Unmodified-Since"] == null)))
{
return CacheValidationStatus.Continue;
}
if (Logging.On)
{
Logging.PrintWarning(Logging.RequestCache, SR.GetString("net_log_cache_request_contains_conditional_header"));
}
if (ctx.Policy.Level == HttpRequestCacheLevel.CacheOnly)
{
ctx.FailRequest(WebExceptionStatus.RequestProhibitedByCachePolicy);
}
return CacheValidationStatus.DoNotTakeFromCache;
}
internal static Rfc2616.TriState OnUpdateCache(HttpRequestCacheValidator ctx, HttpWebResponse resp)
{
if (((ctx.RequestMethod != HttpMethod.Head) && (ctx.RequestMethod != HttpMethod.Get)) && (ctx.RequestMethod != HttpMethod.Post))
{
if (Logging.On)
{
Logging.PrintInfo(Logging.RequestCache, SR.GetString("net_log_cache_not_a_get_head_post"));
}
return Rfc2616.TriState.Unknown;
}
if ((ctx.CacheStream == Stream.Null) || (ctx.CacheStatusCode == ((HttpStatusCode) 0)))
{
if (resp.StatusCode == HttpStatusCode.NotModified)
{
if (Logging.On)
{
Logging.PrintWarning(Logging.RequestCache, SR.GetString("net_log_cache_cannot_update_cache_if_304"));
}
return Rfc2616.TriState.Unknown;
}
if (ctx.RequestMethod == HttpMethod.Head)
{
if (Logging.On)
{
Logging.PrintWarning(Logging.RequestCache, SR.GetString("net_log_cache_cannot_update_cache_with_head_resp"));
}
return Rfc2616.TriState.Unknown;
}
}
if (resp == null)
{
if (Logging.On)
{
Logging.PrintWarning(Logging.RequestCache, SR.GetString("net_log_cache_http_resp_is_null"));
}
return Rfc2616.TriState.Unknown;
}
if (ctx.ResponseCacheControl.NoStore)
{
if (Logging.On)
{
Logging.PrintInfo(Logging.RequestCache, SR.GetString("net_log_cache_resp_cache_control_is_no_store"));
}
return Rfc2616.TriState.Unknown;
}
if (((ctx.ResponseDate != DateTime.MinValue) && (ctx.CacheDate != DateTime.MinValue)) && (ctx.ResponseDate < ctx.CacheDate))
{
if (Logging.On)
{
Logging.PrintWarning(Logging.RequestCache, SR.GetString("net_log_cache_resp_older_than_cache"));
}
return Rfc2616.TriState.Unknown;
}
if (ctx.ResponseCacheControl.Public)
{
if (Logging.On)
{
Logging.PrintInfo(Logging.RequestCache, SR.GetString("net_log_cache_resp_cache_control_is_public"));
}
return Rfc2616.TriState.Valid;
}
Rfc2616.TriState unknown = Rfc2616.TriState.Unknown;
if (ctx.ResponseCacheControl.Private)
{
if (!ctx.CacheEntry.IsPrivateEntry)
{
if (ctx.ResponseCacheControl.PrivateHeaders == null)
{
if (Logging.On)
{
Logging.PrintInfo(Logging.RequestCache, SR.GetString("net_log_cache_resp_cache_control_is_private"));
}
return Rfc2616.TriState.Unknown;
}
if (Logging.On)
{
Logging.PrintInfo(Logging.RequestCache, SR.GetString("net_log_cache_resp_cache_control_is_private_plus_headers"));
}
for (int i = 0; i < ctx.ResponseCacheControl.PrivateHeaders.Length; i++)
{
ctx.CacheHeaders.Remove(ctx.ResponseCacheControl.PrivateHeaders[i]);
unknown = Rfc2616.TriState.Valid;
}
}
else
{
unknown = Rfc2616.TriState.Valid;
}
}
if (ctx.ResponseCacheControl.NoCache)
{
if ((ctx.ResponseLastModified == DateTime.MinValue) && (ctx.Response.Headers.ETag == null))
{
if (Logging.On)
{
Logging.PrintWarning(Logging.RequestCache, SR.GetString("net_log_cache_revalidation_required"));
}
return Rfc2616.TriState.Unknown;
}
if (Logging.On)
{
Logging.PrintInfo(Logging.RequestCache, SR.GetString("net_log_cache_needs_revalidation"));
}
return Rfc2616.TriState.Valid;
}
if ((ctx.ResponseCacheControl.SMaxAge != -1) || (ctx.ResponseCacheControl.MaxAge != -1))
{
if (Logging.On)
{
Logging.PrintInfo(Logging.RequestCache, SR.GetString("net_log_cache_resp_allows_caching", new object[] { ctx.ResponseCacheControl.ToString() }));
}
return Rfc2616.TriState.Valid;
}
if (!ctx.CacheEntry.IsPrivateEntry && (ctx.Request.Headers["Authorization"] != null))
{
if (Logging.On)
{
Logging.PrintInfo(Logging.RequestCache, SR.GetString("net_log_cache_auth_header_and_no_s_max_age"));
}
return Rfc2616.TriState.Unknown;
}
if ((ctx.RequestMethod == HttpMethod.Post) && (resp.Headers.Expires == null))
{
if (Logging.On)
{
Logging.PrintInfo(Logging.RequestCache, SR.GetString("net_log_cache_post_resp_without_cache_control_or_expires"));
}
return Rfc2616.TriState.Unknown;
}
if ((((resp.StatusCode == HttpStatusCode.NotModified) || (resp.StatusCode == HttpStatusCode.OK)) || ((resp.StatusCode == HttpStatusCode.NonAuthoritativeInformation) || (resp.StatusCode == HttpStatusCode.PartialContent))) || (((resp.StatusCode == HttpStatusCode.MultipleChoices) || (resp.StatusCode == HttpStatusCode.MovedPermanently)) || (resp.StatusCode == HttpStatusCode.Gone)))
{
if (Logging.On)
{
Logging.PrintInfo(Logging.RequestCache, SR.GetString("net_log_cache_valid_based_on_status_code", new object[] { (int) resp.StatusCode }));
}
return Rfc2616.TriState.Valid;
}
if ((unknown != Rfc2616.TriState.Valid) && Logging.On)
{
Logging.PrintInfo(Logging.RequestCache, SR.GetString("net_log_cache_resp_no_cache_control", new object[] { (int) resp.StatusCode }));
}
return unknown;
}
/*
Returns:
- true: Conditional Partial request has been constructed
- false: Conditional Partial request cannot be constructed
*/
private static bool TryConditionalRangeRequest(HttpRequestCacheValidator ctx) {
//
// The response is partially cached (that has been checked before calling this method)
//
if (ctx.CacheEntry.StreamSize >= Int32.MaxValue) {
//This is a restriction of HttpWebRequest implementation as on 01/28/03
if(Logging.On)Logging.PrintWarning(Logging.RequestCache, SR.GetString(SR.net_log_cache_entry_size_too_big, ctx.CacheEntry.StreamSize));
return false;
}
/*
If the entity tag given in the If-Range header matches the current
entity tag for the entity, then the server SHOULD provide the
specified sub-range of the entity using a 206 (Partial content)
response. If the entity tag does not match, then the server SHOULD
return the entire entity using a 200 (OK) response.
*/
string str = ctx.CacheHeaders.ETag;
if (str != null) {
ctx.Request.Headers[HttpKnownHeaderNames.IfRange] = str;
ctx.RequestIfHeader1 = HttpKnownHeaderNames.IfRange;
ctx.RequestValidator1 =str;
if(Logging.On)Logging.PrintInfo(Logging.RequestCache, SR.GetString(SR.net_log_cache_condition_if_range, ctx.Request.Headers[HttpKnownHeaderNames.IfRange]));
return true;
}
/*
- If only a Last-Modified value has been provided by an HTTP/1.0
origin server, MAY use that value in subrange cache-conditional
requests (using If-Unmodified-Since:). The user agent SHOULD
provide a way to disable this, in case of difficulty.
*/
if (ctx.CacheEntry.LastModifiedUtc != DateTime.MinValue)
{
str = ctx.CacheEntry.LastModifiedUtc.ToString("r", CultureInfo.InvariantCulture);
if (ctx.CacheHttpVersion.Major == 1 && ctx.CacheHttpVersion.Minor == 0)
{
// Well If-Unmodified-Since would require an additional request in case it WAS modified
// A User may want to excerise this path without relying on our implementation.
if(Logging.On)Logging.PrintWarning(Logging.RequestCache, SR.GetString(SR.net_log_cache_conditional_range_not_implemented_on_http_10));
return false;
/*
//Http == 1.0
ctx.Request.Headers[HttpKnownHeaderNames.IfUnmodifiedSince] = str;
ctx.RequestIfHeader1 = HttpKnownHeaderNames.IfUnmodifiedSince;
ctx.RequestValidator1 = str;
if(Logging.On)Logging.PrintInfo(Logging.RequestCache, "Request Condition = If-Unmodified-Since:" + ctx.Request.Headers[HttpKnownHeaderNames.IfUnmodifiedSince]);
return true;
*/
}
else
{
//Http > 1.0
ctx.Request.Headers[HttpKnownHeaderNames.IfRange] = str;
ctx.RequestIfHeader1 = HttpKnownHeaderNames.IfRange;
ctx.RequestValidator1 =str;
if(Logging.On)Logging.PrintInfo(Logging.RequestCache, SR.GetString(SR.net_log_cache_condition_if_range, ctx.Request.Headers[HttpKnownHeaderNames.IfRange]));
return true;
}
}
if(Logging.On)Logging.PrintWarning(Logging.RequestCache, SR.GetString(SR.net_log_cache_cannot_construct_conditional_range_request));
//Cannot construct a conditional request
return false;
}
//
// A template for 206 response that we serve from cache on a user range request
// It's also used for cache update.
//
public static void Construct206PartialContent(HttpRequestCacheValidator ctx, int rangeStart) {
ctx.CacheStatusCode = HttpStatusCode.PartialContent;
ctx.CacheStatusDescription = PartialContentDescription;
if (ctx.CacheHttpVersion == null) {
ctx.CacheHttpVersion = new Version(1,1);
}
string ranges = "bytes " + rangeStart + '-' + (rangeStart + ctx.CacheStreamLength-1) +'/' + (ctx.CacheEntityLength <= 0?"*":ctx.CacheEntityLength.ToString(NumberFormatInfo.InvariantInfo));
ctx.CacheHeaders[HttpKnownHeaderNames.ContentRange] = ranges;
ctx.CacheHeaders[HttpKnownHeaderNames.ContentLength] = ctx.CacheStreamLength.ToString(NumberFormatInfo.InvariantInfo);
ctx.CacheEntry.IsPartialEntry = true;
}
/*
Returns:
- ReturnCachedResponse : Cache may be returned to the app
- DoNotTakeFromCache : Cache must not be returned to the app
*/
public static CacheValidationStatus ValidateCacheOn5XXResponse(HttpRequestCacheValidator ctx) {
/*
If a cache receives a 5xx response while attempting to revalidate an
entry, it MAY either forward this response to the requesting client,
or act as if the server failed to respond. In the latter case, it MAY
return a previously received response unless the cached entry
includes the "must-revalidate" cache-control directive
*/
// Do we have cached item?
if (ctx.CacheStream == Stream.Null || ctx.CacheStatusCode == (HttpStatusCode)0) {
return CacheValidationStatus.DoNotTakeFromCache;
}
if (ctx.CacheEntityLength != ctx.CacheEntry.StreamSize || ctx.CacheStatusCode == HttpStatusCode.PartialContent) {
// Partial cache remains partial, user will not know that.
// This is because user either did not provide a Range Header or
// the user range was just forwarded to the server bypassing cache
return CacheValidationStatus.DoNotTakeFromCache;
}
if (ValidateCacheBySpecialCases(ctx) != TriState.Valid) {
// This response cannot be used without _successful_ revalidation
return CacheValidationStatus.DoNotTakeFromCache;
}
if (ctx.Policy.Level == HttpRequestCacheLevel.CacheOnly || ctx.Policy.Level == HttpRequestCacheLevel.CacheIfAvailable || ctx.Policy.Level == HttpRequestCacheLevel.CacheOrNextCacheOnly)
{
// that was a cache only request
if(Logging.On)Logging.PrintInfo(Logging.RequestCache, SR.GetString(SR.net_log_cache_sxx_resp_cache_only));
return CacheValidationStatus.ReturnCachedResponse;
}
if (ctx.Policy.Level == HttpRequestCacheLevel.Default || ctx.Policy.Level == HttpRequestCacheLevel.Revalidate)
{
if (ValidateCacheByClientPolicy(ctx)) {
if(Logging.On)Logging.PrintInfo(Logging.RequestCache, SR.GetString(SR.net_log_cache_sxx_resp_can_be_replaced));
ctx.CacheHeaders.Add(HttpKnownHeaderNames.Warning, HttpRequestCacheValidator.Warning_111);
return CacheValidationStatus.ReturnCachedResponse;
}
}
return CacheValidationStatus.DoNotTakeFromCache;
}
//
// Clear the request from any conditional headers and request no-cache
//
public static void ConstructUnconditionalRefreshRequest(HttpRequestCacheValidator ctx) {
WebHeaderCollection cc = ctx.Request.Headers;
cc[HttpKnownHeaderNames.CacheControl]="max-age=0";
cc[HttpKnownHeaderNames.Pragma]="no-cache";
if (ctx.RequestIfHeader1 != null) {
cc.RemoveInternal(ctx.RequestIfHeader1);
ctx.RequestIfHeader1 = null;
}
if (ctx.RequestIfHeader2 != null) {
cc.RemoveInternal(ctx.RequestIfHeader2);
ctx.RequestIfHeader2 = null;
}
if (ctx.RequestRangeCache) {
cc.RemoveInternal(HttpKnownHeaderNames.Range);
ctx.RequestRangeCache = false;
}
}
/*
When the cache receives a subsequent request whose Request-URI
specifies one or more cache entries including a Vary header field,
the cache MUST NOT use such a cache entry to construct a response to
the new request unless all of the selecting request-headers present
in the new request match the corresponding stored request-headers in
the original request.
The selecting request-headers from two requests are defined to match
if and only if the selecting request-headers in the first request can
be transformed to the selecting request-headers in the second request
by adding or removing linear white space (LWS) at places where this
is allowed by the corresponding BNF, and/or combining multiple
message-header fields with the same field name following the rules
about message headers in section 4.2.
A Vary header field-value of "*" always fails to match and subsequent
requests on that resource can only be properly interpreted by the
origin server.
*/
/*
Returns:
- Valid : Vary header values match in both request and cache
- Invalid : Vary header values do not match
- Unknown : Vary header is not present in cache
*/
internal static TriState ValidateCacheByVaryHeader(HttpRequestCacheValidator ctx) {
string[] cacheVary = ctx.CacheHeaders.GetValues(HttpKnownHeaderNames.Vary);
if (cacheVary == null) {
return TriState.Unknown;
}
ArrayList varyValues = new ArrayList();
HttpRequestCacheValidator.ParseHeaderValues(cacheVary,
HttpRequestCacheValidator.ParseValuesCallback,
varyValues);
if (varyValues.Count == 0) {
if(Logging.On)Logging.PrintWarning(Logging.RequestCache, SR.GetString(SR.net_log_cache_vary_header_empty));
return TriState.Invalid;
}
if (((string)(varyValues[0]))[0] == '*') {
if(Logging.On)Logging.PrintInfo(Logging.RequestCache, SR.GetString(SR.net_log_cache_vary_header_contains_asterisks));
return TriState.Invalid;
}
if (ctx.SystemMeta == null || ctx.SystemMeta.Count == 0) {
// We keep there previous request headers
if(Logging.On)Logging.PrintWarning(Logging.RequestCache, SR.GetString(SR.net_log_cache_no_headers_in_metadata));
return TriState.Invalid;
}
/*
A Vary field value consisting of a list of field-names signals that
the representation selected for the response is based on a selection
algorithm which considers ONLY the listed request-header field values
in selecting the most appropriate representation. A cache MAY assume
that the same selection will be made for future requests with the
same values for the listed field names, for the duration of time for
which the response is fresh.
*/
for (int i = 0; i < varyValues.Count; ++i) {
string[] requestValues = ctx.Request.Headers.GetValues((string)varyValues[i]);
ArrayList requestFields = new ArrayList();
if (requestValues != null) {
HttpRequestCacheValidator.ParseHeaderValues(requestValues,
HttpRequestCacheValidator.ParseValuesCallback,
requestFields);
}
string[] cacheValues = ctx.SystemMeta.GetValues((string)varyValues[i]);
ArrayList cacheFields = new ArrayList();
if (cacheValues != null) {
HttpRequestCacheValidator.ParseHeaderValues(cacheValues,
HttpRequestCacheValidator.ParseValuesCallback,
cacheFields);
}
if (requestFields.Count != cacheFields.Count) {
if(Logging.On)Logging.PrintInfo(Logging.RequestCache, SR.GetString(SR.net_log_cache_vary_header_mismatched_count, (string)varyValues[i]));
return TriState.Invalid;
}
// NB: fields order is significant as per RFC.
for (int j = 0; j < cacheFields.Count; ++j) {
if (!AsciiLettersNoCaseEqual((string)cacheFields[j], (string)requestFields[j])) {
if(Logging.On)Logging.PrintInfo(Logging.RequestCache, SR.GetString(SR.net_log_cache_vary_header_mismatched_field, (string)varyValues[i], (string)cacheFields[j], (string)requestFields[j]));
return TriState.Invalid;
}
}
}
if(Logging.On)Logging.PrintInfo(Logging.RequestCache, SR.GetString(SR.net_log_cache_vary_header_match));
// The Vary header is in cache and all headers values referenced to are equal to those in the Request.
return TriState.Valid;
}
/*----------*/
// Returns
// RetryResponseFromServer = Retry this request as the result of invalid response received
// Continue = The response can be accepted
public static CacheValidationStatus OnValidateResponse(HttpRequestCacheValidator ctx)
{
//
// At this point we assume that policy >= CacheOrNextCacheOnly && policy < Refresh
//
// If there was a retry already, it should go with cache disabled so by default we won't retry it again
if (ctx.ResponseCount > 1) {
if(Logging.On)Logging.PrintInfo(Logging.RequestCache, SR.GetString(SR.net_log_cache_accept_based_on_retry_count, ctx.ResponseCount));
return CacheValidationStatus.Continue;
}
// We don't convert user-range request to a conditional one
if (ctx.RequestRangeUser) {
// was a user range request, we did not touch it.
return CacheValidationStatus.Continue;
}
//If a live response has older Date, then request should be retried
if (ctx.CacheDate != DateTime.MinValue &&
ctx.ResponseDate != DateTime.MinValue &&
ctx.CacheDate > ctx.ResponseDate) {
if(Logging.On)Logging.PrintError(Logging.RequestCache, SR.GetString(SR.net_log_cache_date_header_older_than_cache_entry));
Common.ConstructUnconditionalRefreshRequest(ctx);
return CacheValidationStatus.RetryResponseFromServer;
}
HttpWebResponse resp = ctx.Response as HttpWebResponse;
if (ctx.RequestRangeCache && resp.StatusCode == HttpStatusCode.RequestedRangeNotSatisfiable) {
if(Logging.On)Logging.PrintError(Logging.RequestCache, SR.GetString(SR.net_log_cache_server_didnt_satisfy_range, ctx.Request.Headers[HttpKnownHeaderNames.Range]));
Common.ConstructUnconditionalRefreshRequest(ctx);
return CacheValidationStatus.RetryResponseFromServer;
}
if (resp.StatusCode == HttpStatusCode.NotModified)
{
if (ctx.RequestIfHeader1 == null)
{
// something is really broken on the wire
if(Logging.On)Logging.PrintError(Logging.RequestCache, SR.GetString(SR.net_log_cache_304_received_on_unconditional_request));
Common.ConstructUnconditionalRefreshRequest(ctx);
return CacheValidationStatus.RetryResponseFromServer;
}
else if (ctx.RequestRangeCache)
{
// The way _we_ create range requests shoyuld never result in 304
if(Logging.On)Logging.PrintError(Logging.RequestCache, SR.GetString(SR.net_log_cache_304_received_on_unconditional_request_expected_200_206));
Common.ConstructUnconditionalRefreshRequest(ctx);
return CacheValidationStatus.RetryResponseFromServer;
}
}
if (ctx.CacheHttpVersion.Major <= 1 && resp.ProtocolVersion.Major <=1 &&
ctx.CacheHttpVersion.Minor < 1 && resp.ProtocolVersion.Minor <1 &&
ctx.CacheLastModified > ctx.ResponseLastModified)
{
if(Logging.On)Logging.PrintError(Logging.RequestCache, SR.GetString(SR.net_log_cache_last_modified_header_older_than_cache_entry));
// On http <= 1.0 cache LastModified > resp LastModified
Common.ConstructUnconditionalRefreshRequest(ctx);
return CacheValidationStatus.RetryResponseFromServer;
}
if (ctx.Policy.Level == HttpRequestCacheLevel.Default && ctx.ResponseAge != TimeSpan.MinValue) {
// If the client has requested MaxAge/MinFresh/MaxStale
// check does the response meet the requirements
if ( (ctx.ResponseAge > ctx.Policy.MaxAge) ||
(ctx.ResponseExpires != DateTime.MinValue &&
(ctx.Policy.MinFresh > TimeSpan.Zero && (ctx.ResponseExpires - DateTime.UtcNow) < ctx.Policy.MinFresh) ||
(ctx.Policy.MaxStale > TimeSpan.Zero && (DateTime.UtcNow - ctx.ResponseExpires) > ctx.Policy.MaxStale)))
{
if(Logging.On)Logging.PrintError(Logging.RequestCache, SR.GetString(SR.net_log_cache_freshness_outside_policy_limits));
Common.ConstructUnconditionalRefreshRequest(ctx);
return CacheValidationStatus.RetryResponseFromServer;
}
}
//Cleanup what we've done to this request since protcol can resubmit for auth or redirect.
if (ctx.RequestIfHeader1 != null) {
ctx.Request.Headers.RemoveInternal(ctx.RequestIfHeader1);
ctx.RequestIfHeader1 = null;
}
if (ctx.RequestIfHeader2 != null) {
ctx.Request.Headers.RemoveInternal(ctx.RequestIfHeader2);
ctx.RequestIfHeader2 = null;
}
if (ctx.RequestRangeCache) {
ctx.Request.Headers.RemoveInternal(HttpKnownHeaderNames.Range);
ctx.RequestRangeCache = false;
}
return CacheValidationStatus.Continue;
}
// Returns
// - DoNotTakeFromCache = A request shall go as is and the cache will be dropped
// - Continue = Cache should be preserved and after-response validator should be called
public static CacheValidationStatus TryConditionalRequest(HttpRequestCacheValidator ctx) {
string ranges;
TriState isPartial = CheckForRangeRequest(ctx, out ranges);
if (isPartial == TriState.Invalid) {
// This is a user requested range, pass it as is
return CacheValidationStatus.Continue;
}
if(isPartial == TriState.Valid) {
// Not all proxy servers, support requesting a range on an FTP
// command, so to be safe, never try to mix the cache with a range
// response. Always get the whole thing fresh in the case of FTP
// over proxy.
if (ctx is FtpRequestCacheValidator)
return CacheValidationStatus.DoNotTakeFromCache;
// We only have a partial response, need to complete it
if (TryConditionalRangeRequest(ctx)){
// We can do a conditional range request
ctx.RequestRangeCache = true;
((HttpWebRequest)ctx.Request).AddRange((int)ctx.CacheEntry.StreamSize);
if(Logging.On)Logging.PrintInfo(Logging.RequestCache, SR.GetString(SR.net_log_cache_range, ctx.Request.Headers[HttpKnownHeaderNames.Range]));
return CacheValidationStatus.Continue;
}
return CacheValidationStatus.DoNotTakeFromCache;
}
//This is not a range request
return ConstructConditionalRequest(ctx);
}
//
// Implements logic as of the Request caching suitability.
//
// Returns:
// Continue = Proceed to the next protocol stage.
// DoNotTakeFromCache = Don't use cached response for this request
// DoNotUseCache = Cache is not used for this request and response is not cached.
public static CacheValidationStatus OnValidateRequest(HttpRequestCacheValidator ctx) {
/*
Some HTTP methods MUST cause a cache to invalidate an entity. This is
either the entity referred to by the Request-URI, or by the Location
or Content-Location headers (if present). These methods are:
PUT, DELETE, POST.
A cache that passes through requests for methods it does not
understand SHOULD invalidate any entities referred to by the
Request-URI
*/
if (ctx.RequestMethod >= HttpMethod.Post && ctx.RequestMethod <= HttpMethod.Delete)
{
if (ctx.Policy.Level == HttpRequestCacheLevel.CacheOnly)
{
// Throw because the request must hit the wire and it's cache-only policy
ctx.FailRequest(WebExceptionStatus.RequestProhibitedByCachePolicy);
}
// here we could return a hint on removing existing entry, but UpdateCache should handle this case correctly
return CacheValidationStatus.DoNotTakeFromCache;
}
//
// Additionally to said above we can only cache GET or HEAD, for any other methods we request bypassing cache.
//
if (ctx.RequestMethod < HttpMethod.Head || ctx.RequestMethod > HttpMethod.Get )
{
if (ctx.Policy.Level == HttpRequestCacheLevel.CacheOnly)
{
// Throw because the request must hit the wire and it's cache-only policy
ctx.FailRequest(WebExceptionStatus.RequestProhibitedByCachePolicy);
}
return CacheValidationStatus.DoNotUseCache;
}
if (ctx.Request.Headers[HttpKnownHeaderNames.IfModifiedSince] != null ||
ctx.Request.Headers[HttpKnownHeaderNames.IfNoneMatch] != null ||
ctx.Request.Headers[HttpKnownHeaderNames.IfRange] != null ||
ctx.Request.Headers[HttpKnownHeaderNames.IfMatch] != null ||
ctx.Request.Headers[HttpKnownHeaderNames.IfUnmodifiedSince] != null )
{
// The _user_ request contains conditonal cache directives
// Those will conflict with the caching engine => do not lookup a cached item.
if(Logging.On)Logging.PrintWarning(Logging.RequestCache, SR.GetString(SR.net_log_cache_request_contains_conditional_header));
if (ctx.Policy.Level == HttpRequestCacheLevel.CacheOnly)
{
// Throw because the request must hit the wire and it's cache-only policy
ctx.FailRequest(WebExceptionStatus.RequestProhibitedByCachePolicy);
}
return CacheValidationStatus.DoNotTakeFromCache;
}
return CacheValidationStatus.Continue;
}
// Returns:
// ReturnFromCache = Take it from cache
// DoNotTakeFromCache= Reload from server and disregard current cache
// Continue = Send a request that may have added a conditional header
public static CacheValidationStatus TryResponseFromCache(HttpRequestCacheValidator ctx) {
string ranges;
TriState isRange = CheckForRangeRequest(ctx, out ranges);
if (isRange == TriState.Unknown) {
return CacheValidationStatus.ReturnCachedResponse;
}
if (isRange == TriState.Invalid) {
// user range request
long start = 0;
long end = 0;
long total = 0;
if (!GetBytesRange(ranges, ref start, ref end, ref total, true)) {
if(Logging.On)Logging.PrintError(Logging.RequestCache, SR.GetString(SR.net_log_cache_range_invalid_format, ranges));
return CacheValidationStatus.DoNotTakeFromCache;
}
if (start >= ctx.CacheEntry.StreamSize
|| end > ctx.CacheEntry.StreamSize
|| (end == -1 && ctx.CacheEntityLength == -1)
|| (end == -1 && ctx.CacheEntityLength > ctx.CacheEntry.StreamSize)
|| (start == -1 && (end == -1
|| ctx.CacheEntityLength == -1
|| (ctx.CacheEntityLength - end >= ctx.CacheEntry.StreamSize))))
{
// we don't have such a range in cache
if(Logging.On)Logging.PrintWarning(Logging.RequestCache, SR.GetString(SR.net_log_cache_range_not_in_cache, ranges));
return CacheValidationStatus.Continue;
}
if (start == -1) {
start = ctx.CacheEntityLength - end;
}
if (end <= 0) {
end = ctx.CacheEntry.StreamSize - 1;
}
ctx.CacheStreamOffset = start;
ctx.CacheStreamLength = end-start+1;
Construct206PartialContent(ctx, (int) start);
if(Logging.On)Logging.PrintInfo(Logging.RequestCache, SR.GetString(SR.net_log_cache_range_in_cache, ctx.CacheHeaders[HttpKnownHeaderNames.ContentRange]));
return CacheValidationStatus.ReturnCachedResponse;
}
//
// Here we got a partially cached response and the user wants a whole response
//
if (ctx.Policy.Level == HttpRequestCacheLevel.CacheOnly &&
((object)ctx.Uri.Scheme == (object)Uri.UriSchemeHttp ||
(object)ctx.Uri.Scheme == (object)Uri.UriSchemeHttps))
{
// Here we should strictly report a failure
// Only for HTTP and HTTPS we choose to return a partial content even user did not ask for it
ctx.CacheStreamOffset = 0;
ctx.CacheStreamLength = ctx.CacheEntry.StreamSize;
Construct206PartialContent(ctx, 0);
if(Logging.On)Logging.PrintInfo(Logging.RequestCache, SR.GetString(SR.net_log_cache_partial_resp, ctx.CacheHeaders[HttpKnownHeaderNames.ContentRange]));
return CacheValidationStatus.ReturnCachedResponse;
}
if (ctx.CacheEntry.StreamSize >= Int32.MaxValue) {
if(Logging.On)Logging.PrintWarning(Logging.RequestCache, SR.GetString(SR.net_log_cache_entry_size_too_big, ctx.CacheEntry.StreamSize));
return CacheValidationStatus.DoNotTakeFromCache;
}
if (TryConditionalRangeRequest(ctx)) {
ctx.RequestRangeCache = true;
((HttpWebRequest)ctx.Request).AddRange((int)ctx.CacheEntry.StreamSize);
if(Logging.On)Logging.PrintInfo(Logging.RequestCache, SR.GetString(SR.net_log_cache_range, ctx.Request.Headers[HttpKnownHeaderNames.Range]));
return CacheValidationStatus.Continue;
}
// This will let an unconditional request go
return CacheValidationStatus.Continue;
}
//
// Implements logic as to compute cache freshness.
// Client Policy is not considered
//
public static CacheFreshnessStatus ComputeFreshness(HttpRequestCacheValidator ctx) {
if(Logging.On)Logging.PrintInfo(Logging.RequestCache, SR.GetString(SR.net_log_cache_now_time, DateTime.UtcNow.ToString("r", CultureInfo.InvariantCulture)));
/*
apparent_age = max(0, response_time - date_value);
*/
DateTime nowDate = DateTime.UtcNow;
TimeSpan age = TimeSpan.MaxValue;
DateTime date = ctx.CacheDate;
if (date != DateTime.MinValue) {
age = (nowDate - date);
if(Logging.On)Logging.PrintInfo(Logging.RequestCache, SR.GetString(SR.net_log_cache_age1_date_header, ((int)age.TotalSeconds).ToString(NumberFormatInfo.InvariantInfo), ctx.CacheDate.ToString("r", CultureInfo.InvariantCulture)));
}
else if (ctx.CacheEntry.LastSynchronizedUtc != DateTime.MinValue) {
/*
Another way to compute cache age but only if Date header is absent.
*/
age = nowDate - ctx.CacheEntry.LastSynchronizedUtc;
if (ctx.CacheAge != TimeSpan.MinValue) {
age += ctx.CacheAge;
}
if(Logging.On) {
if (ctx.CacheAge != TimeSpan.MinValue)
Logging.PrintInfo(Logging.RequestCache, SR.GetString(SR.net_log_cache_age1_last_synchronized_age_header, ((int)age.TotalSeconds).ToString(NumberFormatInfo.InvariantInfo), ctx.CacheEntry.LastSynchronizedUtc.ToString("r", CultureInfo.InvariantCulture), ((int)ctx.CacheAge.TotalSeconds).ToString(NumberFormatInfo.InvariantInfo)));
else
Logging.PrintInfo(Logging.RequestCache, SR.GetString(SR.net_log_cache_age1_last_synchronized, ((int)age.TotalSeconds).ToString(NumberFormatInfo.InvariantInfo), ctx.CacheEntry.LastSynchronizedUtc.ToString("r", CultureInfo.InvariantCulture)));
}
}
/*
corrected_received_age = max(apparent_age, age_value);
*/
if (ctx.CacheAge != TimeSpan.MinValue) {
if(Logging.On)Logging.PrintInfo(Logging.RequestCache, SR.GetString(SR.net_log_cache_age2, ((int)ctx.CacheAge.TotalSeconds).ToString(NumberFormatInfo.InvariantInfo)));
if (ctx.CacheAge > age || age == TimeSpan.MaxValue) {
age = ctx.CacheAge;
}
}
// Updating CacheAge ...
// Note we don't account on response "transit" delay
// Also undefined cache entry Age is reported as TimeSpan.MaxValue (which is impossble to get from HTTP)
// Also a negative age is reset to 0 as per RFC
ctx.CacheAge = (age < TimeSpan.Zero? TimeSpan.Zero: age);
// Now we start checking the server specified requirements
/*
The calculation to determine if a response has expired is quite simple:
response_is_fresh = (freshness_lifetime > current_age)
*/
// If we managed to compute the Cache Age
if (ctx.CacheAge != TimeSpan.MinValue) {
/*
s-maxage
If a response includes an s-maxage directive, then for a shared
cache (but not for a private cache), the maximum age specified by
this directive overrides the maximum age specified by either the
max-age directive or the Expires header.
*/
if (!ctx.CacheEntry.IsPrivateEntry && ctx.CacheCacheControl.SMaxAge != -1) {
ctx.CacheMaxAge = TimeSpan.FromSeconds(ctx.CacheCacheControl.SMaxAge);
if(Logging.On)Logging.PrintInfo(Logging.RequestCache, SR.GetString(SR.net_log_cache_max_age_cache_s_max_age, ((int)ctx.CacheMaxAge.TotalSeconds).ToString(NumberFormatInfo.InvariantInfo)));
if (ctx.CacheAge < ctx.CacheMaxAge) {
return CacheFreshnessStatus.Fresh;
}
return CacheFreshnessStatus.Stale;
}
/*
The max-age directive takes priority over Expires, so if max-age is
present in a response, the calculation is simply:
freshness_lifetime = max_age_value
*/
if (ctx.CacheCacheControl.MaxAge != -1) {
ctx.CacheMaxAge = TimeSpan.FromSeconds(ctx.CacheCacheControl.MaxAge);
if(Logging.On)Logging.PrintInfo(Logging.RequestCache, SR.GetString(SR.net_log_cache_max_age_cache_max_age, ((int)ctx.CacheMaxAge.TotalSeconds).ToString(NumberFormatInfo.InvariantInfo)));
if (ctx.CacheAge < ctx.CacheMaxAge) {
return CacheFreshnessStatus.Fresh;
}
return CacheFreshnessStatus.Stale;
}
}
/*
Otherwise, if Expires is present in the response, the calculation is:
freshness_lifetime = expires_value - date_value
*/
if (date == DateTime.MinValue) {
date = ctx.CacheEntry.LastSynchronizedUtc;
}
DateTime expiresDate = ctx.CacheEntry.ExpiresUtc;
if (ctx.CacheExpires != DateTime.MinValue && ctx.CacheExpires < expiresDate) {
expiresDate = ctx.CacheExpires;
}
// If absolute Expires and Response Date and Cache Age can be recovered
if (expiresDate != DateTime.MinValue && date != DateTime.MinValue && ctx.CacheAge != TimeSpan.MinValue) {
ctx.CacheMaxAge = expiresDate - date;
if(Logging.On)Logging.PrintInfo(Logging.RequestCache, SR.GetString(SR.net_log_cache_max_age_expires_date, ((int)((expiresDate - date).TotalSeconds)).ToString(NumberFormatInfo.InvariantInfo), expiresDate.ToString("r", CultureInfo.InvariantCulture)));
if (ctx.CacheAge < ctx.CacheMaxAge) {
return CacheFreshnessStatus.Fresh;
}
return CacheFreshnessStatus.Stale;
}
// If absolute Expires can be recovered
if (expiresDate != DateTime.MinValue) {
ctx.CacheMaxAge = expiresDate - DateTime.UtcNow;
//Take absolute Expires value
if(Logging.On)Logging.PrintWarning(Logging.RequestCache, SR.GetString(SR.net_log_cache_max_age_absolute, expiresDate.ToString("r", CultureInfo.InvariantCulture)));
if (expiresDate < DateTime.UtcNow) {
return CacheFreshnessStatus.Fresh;
}
return CacheFreshnessStatus.Stale;
}
/*
If none of Expires, Cache-Control: max-age, or Cache-Control: s-
maxage (see section 14.9.3) appears in the response, and the response
does not include other restrictions on caching, the cache MAY compute
a freshness lifetime using a heuristic. The cache MUST attach Warning
113 to any response whose age is more than 24 hours if such warning
has not already been added.
Also, if the response does have a Last-Modified time, the heuristic
expiration value SHOULD be no more than some fraction of the interval
since that time. A typical setting of this fraction might be 10%.
response_is_fresh = (freshness_lifetime > current_age)
*/
ctx.HeuristicExpiration = true;
DateTime lastModifiedDate = ctx.CacheEntry.LastModifiedUtc;
if (ctx.CacheLastModified > lastModifiedDate) {
lastModifiedDate = ctx.CacheLastModified;
} ctx.CacheMaxAge = ctx.UnspecifiedMaxAge;
if (lastModifiedDate != DateTime.MinValue) {
TimeSpan span = (nowDate - lastModifiedDate);
int maxAgeSeconds = (int)(span.TotalSeconds/10);
ctx.CacheMaxAge = TimeSpan.FromSeconds(maxAgeSeconds);
if(Logging.On)Logging.PrintInfo(Logging.RequestCache, SR.GetString(SR.net_log_cache_no_max_age_use_10_percent, maxAgeSeconds.ToString(NumberFormatInfo.InvariantInfo), lastModifiedDate.ToString("r", CultureInfo.InvariantCulture)));
if (ctx.CacheAge.TotalSeconds < maxAgeSeconds) {
return CacheFreshnessStatus.Fresh;
}
return CacheFreshnessStatus.Stale;
}
// Else we can only rely on UnspecifiedMaxAge hint
ctx.CacheMaxAge = ctx.UnspecifiedMaxAge;
if(Logging.On)Logging.PrintWarning(Logging.RequestCache, SR.GetString(SR.net_log_cache_no_max_age_use_default, ((int)(ctx.UnspecifiedMaxAge.TotalSeconds)).ToString(NumberFormatInfo.InvariantInfo)));
if (ctx.CacheMaxAge >= ctx.CacheAge) {
return CacheFreshnessStatus.Fresh;
}
return CacheFreshnessStatus.Stale;
}
/*----------*/
// ReturnCachedResponse = Return cached response to the application
// DoNotTakeFromCache = Don't used caches value for this request
// Continue = Proceed to the next protocol stage.
public static CacheValidationStatus OnValidateCache(HttpRequestCacheValidator ctx)
{
if (Common.ValidateCacheByVaryHeader(ctx) == TriState.Invalid) {
// RFC 2616 is tricky on this. In theory we could make a conditional request.
// However we rather will not.
// And the reason can be deducted from the RFC definitoin of the response Vary Header.
return CacheValidationStatus.DoNotTakeFromCache;
}
// For Revalidate option we perform a wire request anyway
if (ctx.Policy.Level == HttpRequestCacheLevel.Revalidate) {
return Common.TryConditionalRequest(ctx);
}
if (Common.ValidateCacheBySpecialCases(ctx) == TriState.Invalid)
{
// This takes over the cache policy since the cache content may be sematically incorrect
if (ctx.Policy.Level == HttpRequestCacheLevel.CacheOnly) {
// Cannot do a wire request
return CacheValidationStatus.DoNotTakeFromCache;
}
return Common.TryConditionalRequest(ctx);
}
// So now we have either fresh or stale entry that might be used in place of the response
// At this point it's safe to consider cache freshness and effective Policy as the core decision rules
// Reminder: This method should not be executed with Level >= CacheLevel.Refresh
bool enoughFresh = Common.ValidateCacheByClientPolicy(ctx);
if (enoughFresh || ctx.Policy.Level == HttpRequestCacheLevel.CacheOnly || ctx.Policy.Level == HttpRequestCacheLevel.CacheIfAvailable || ctx.Policy.Level == HttpRequestCacheLevel.CacheOrNextCacheOnly)
{
// The freshness does not matter, check does user requested Range fits into cached entry
CacheValidationStatus result = Common.TryResponseFromCache(ctx);
if (result != CacheValidationStatus.ReturnCachedResponse) {
if (ctx.Policy.Level == HttpRequestCacheLevel.CacheOnly) {
// Cannot do a wire request
return CacheValidationStatus.DoNotTakeFromCache;
}
return result;
}
if(Logging.On)Logging.PrintInfo(Logging.RequestCache, SR.GetString(SR.net_log_cache_valid_as_fresh_or_because_policy, ctx.Policy.ToString()));
return CacheValidationStatus.ReturnCachedResponse;
}
// This will return either Continue=conditional request or DoNotTakeFromCache==Unconditional request
return Common.TryConditionalRequest(ctx);
}
/*----------*/
//
// This method checks sutability of cached entry based on the client policy.
//
/*
Returns:
- true : The cache is still good
- false : The cache age does not fit into client policy
*/
public static bool ValidateCacheByClientPolicy(HttpRequestCacheValidator ctx) {
if (ctx.Policy.Level == HttpRequestCacheLevel.Default)
{
if(Logging.On)Logging.PrintInfo(Logging.RequestCache, SR.GetString(SR.net_log_cache_age, (ctx.CacheAge != TimeSpan.MinValue ? ((int)ctx.CacheAge.TotalSeconds).ToString(NumberFormatInfo.InvariantInfo) : SR.GetString(SR.net_log_unknown)), (ctx.CacheMaxAge != TimeSpan.MinValue? ((int)ctx.CacheMaxAge.TotalSeconds).ToString(NumberFormatInfo.InvariantInfo): SR.GetString(SR.net_log_unknown))));
if (ctx.Policy.MinFresh > TimeSpan.Zero)
{
if(Logging.On)Logging.PrintInfo(Logging.RequestCache, SR.GetString(SR.net_log_cache_policy_min_fresh, ((int)ctx.Policy.MinFresh.TotalSeconds).ToString(NumberFormatInfo.InvariantInfo)));
if (ctx.CacheAge + ctx.Policy.MinFresh >= ctx.CacheMaxAge) {return false;}
}
if (ctx.Policy.MaxAge != TimeSpan.MaxValue)
{
if(Logging.On)Logging.PrintInfo(Logging.RequestCache, SR.GetString(SR.net_log_cache_policy_max_age, ((int)ctx.Policy.MaxAge.TotalSeconds).ToString(NumberFormatInfo.InvariantInfo)));
if (ctx.CacheAge >= ctx.Policy.MaxAge) {return false;}
}
if (ctx.Policy.InternalCacheSyncDateUtc != DateTime.MinValue)
{
if(Logging.On)Logging.PrintInfo(Logging.RequestCache, SR.GetString(SR.net_log_cache_policy_cache_sync_date, ctx.Policy.InternalCacheSyncDateUtc.ToString("r", CultureInfo.CurrentCulture), ctx.CacheEntry.LastSynchronizedUtc.ToString(CultureInfo.CurrentCulture)));
if (ctx.CacheEntry.LastSynchronizedUtc < ctx.Policy.InternalCacheSyncDateUtc) {
return false;
}
}
TimeSpan adjustedMaxAge = ctx.CacheMaxAge;
if (ctx.Policy.MaxStale > TimeSpan.Zero)
{
if(Logging.On)Logging.PrintInfo(Logging.RequestCache, SR.GetString(SR.net_log_cache_policy_max_stale, ((int)ctx.Policy.MaxStale.TotalSeconds).ToString(NumberFormatInfo.InvariantInfo)));
if (adjustedMaxAge < TimeSpan.MaxValue - ctx.Policy.MaxStale)
{
adjustedMaxAge = adjustedMaxAge + ctx.Policy.MaxStale;
}
else
{
adjustedMaxAge = TimeSpan.MaxValue;
}
if (ctx.CacheAge >= adjustedMaxAge)
return false;
else
return true;
}
}
// not stale means "fresh enough"
return ctx.CacheFreshnessStatus == CacheFreshnessStatus.Fresh;
}
/*
Discovers the fact that cached response is a partial one.
Returns:
- Invalid : It's a user range request
- Valid : It's a partial cached response
- Unknown : It's neither a range request nor the cache does have a partial response
*/
private static TriState CheckForRangeRequest(HttpRequestCacheValidator ctx, out string ranges) {
if ((ranges = ctx.Request.Headers[HttpKnownHeaderNames.Range]) != null) {
// A request already contains range.
// The caller will either return it from cache or pass as is to the server
ctx.RequestRangeUser = true;
if(Logging.On)Logging.PrintInfo(Logging.RequestCache, SR.GetString(SR.net_log_cache_range_request_range, ctx.Request.Headers[HttpKnownHeaderNames.Range]));
return TriState.Invalid;
}
if (ctx.CacheStatusCode == HttpStatusCode.PartialContent && ctx.CacheEntityLength == ctx.CacheEntry.StreamSize)
{
// this is a whole resposne
ctx.CacheStatusCode = HttpStatusCode.OK;
ctx.CacheStatusDescription = Common.OkDescription;
return TriState.Unknown;
}
if (ctx.CacheEntry.IsPartialEntry || (ctx.CacheEntityLength != -1 && ctx.CacheEntityLength != ctx.CacheEntry.StreamSize) || ctx.CacheStatusCode == HttpStatusCode.PartialContent)
{ //The cache may contain a partial response
if(Logging.On)Logging.PrintInfo(Logging.RequestCache, SR.GetString(SR.net_log_cache_could_be_partial, ctx.CacheEntry.StreamSize, ctx.CacheEntityLength));
return TriState.Valid;
}
return TriState.Unknown;
}
/*
HTTP/1.1 clients:
- If an entity tag has been provided by the origin server, MUST
use that entity tag in any cache-conditional request (using If-
Match or If-None-Match).
- If only a Last-Modified value has been provided by the origin
server, SHOULD use that value in non-subrange cache-conditional
requests (using If-Modified-Since).
- If only a Last-Modified value has been provided by an HTTP/1.0
origin server, MAY use that value in subrange cache-conditional
requests (using If-Unmodified-Since:). The user agent SHOULD
provide a way to disable this, in case of difficulty.
- If both an entity tag and a Last-Modified value have been
provided by the origin server, SHOULD use both validators in
cache-conditional requests. This allows both HTTP/1.0 and
HTTP/1.1 caches to respond appropriately.
*/
/*
Returns:
- Continue : Conditional request has been constructed
- DoNotTakeFromCache : Conditional request cannot be constructed
*/
public static CacheValidationStatus ConstructConditionalRequest(HttpRequestCacheValidator ctx) {
CacheValidationStatus result = CacheValidationStatus.DoNotTakeFromCache;
// The assumption is that a _user_ conditional request was already filtered out
bool validator2 = false;
string str = ctx.CacheHeaders.ETag;
if (str != null) {
result = CacheValidationStatus.Continue;
ctx.Request.Headers[HttpKnownHeaderNames.IfNoneMatch] = str;
ctx.RequestIfHeader1 = HttpKnownHeaderNames.IfNoneMatch;
ctx.RequestValidator1 = str;
validator2 = true;
if(Logging.On)Logging.PrintInfo(Logging.RequestCache, SR.GetString(SR.net_log_cache_condition_if_none_match, ctx.Request.Headers[HttpKnownHeaderNames.IfNoneMatch]));
}
if (ctx.CacheEntry.LastModifiedUtc != DateTime.MinValue) {
result = CacheValidationStatus.Continue;
str = ctx.CacheEntry.LastModifiedUtc.ToString("r", CultureInfo.InvariantCulture);
ctx.Request.Headers.ChangeInternal(HttpKnownHeaderNames.IfModifiedSince, str);
if (validator2) {
ctx.RequestIfHeader2 = HttpKnownHeaderNames.IfModifiedSince;
ctx.RequestValidator2 = str;
}
else {
ctx.RequestIfHeader1 = HttpKnownHeaderNames.IfModifiedSince;
ctx.RequestValidator1 = str;
}
if(Logging.On)Logging.PrintInfo(Logging.RequestCache, SR.GetString(SR.net_log_cache_condition_if_modified_since, ctx.Request.Headers[HttpKnownHeaderNames.IfModifiedSince]));
}
if(Logging.On) {
if (result == CacheValidationStatus.DoNotTakeFromCache) {
Logging.PrintWarning(Logging.RequestCache, SR.GetString(SR.net_log_cache_cannot_construct_conditional_request));
}
}
return result;
}
public static CacheValidationStatus ConstructConditionalRequest(HttpRequestCacheValidator ctx)
{
CacheValidationStatus doNotTakeFromCache = CacheValidationStatus.DoNotTakeFromCache;
bool flag = false;
string eTag = ctx.CacheHeaders.ETag;
if (eTag != null)
{
doNotTakeFromCache = CacheValidationStatus.Continue;
ctx.Request.Headers["If-None-Match"] = eTag;
ctx.RequestIfHeader1 = "If-None-Match";
ctx.RequestValidator1 = eTag;
flag = true;
if (Logging.On)
{
Logging.PrintInfo(Logging.RequestCache, SR.GetString("net_log_cache_condition_if_none_match", new object[] { ctx.Request.Headers["If-None-Match"] }));
}
}
if (ctx.CacheEntry.LastModifiedUtc != DateTime.MinValue)
{
doNotTakeFromCache = CacheValidationStatus.Continue;
eTag = ctx.CacheEntry.LastModifiedUtc.ToString("r", CultureInfo.InvariantCulture);
ctx.Request.Headers.ChangeInternal("If-Modified-Since", eTag);
if (flag)
{
ctx.RequestIfHeader2 = "If-Modified-Since";
ctx.RequestValidator2 = eTag;
}
else
{
ctx.RequestIfHeader1 = "If-Modified-Since";
ctx.RequestValidator1 = eTag;
}
if (Logging.On)
{
Logging.PrintInfo(Logging.RequestCache, SR.GetString("net_log_cache_condition_if_modified_since", new object[] { ctx.Request.Headers["If-Modified-Since"] }));
}
}
if (Logging.On && (doNotTakeFromCache == CacheValidationStatus.DoNotTakeFromCache))
{
Logging.PrintWarning(Logging.RequestCache, SR.GetString("net_log_cache_cannot_construct_conditional_request"));
}
return doNotTakeFromCache;
}