Remove std::chrono completely
[WebKit.git] / Source / WebCore / platform / network / CacheValidation.cpp
1 /*
2  * Copyright (C) 2014-2017 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
14  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
15  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
17  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
18  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
19  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
20  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
21  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
22  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
23  * THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #include "config.h"
27 #include "CacheValidation.h"
28
29 #include "CookiesStrategy.h"
30 #include "HTTPHeaderMap.h"
31 #include "NetworkStorageSession.h"
32 #include "PlatformCookieJar.h"
33 #include "PlatformStrategies.h"
34 #include "ResourceRequest.h"
35 #include "ResourceResponse.h"
36 #include <wtf/CurrentTime.h>
37 #include <wtf/text/StringView.h>
38
39 namespace WebCore {
40
41 // These response headers are not copied from a revalidated response to the
42 // cached response headers. For compatibility, this list is based on Chromium's
43 // net/http/http_response_headers.cc.
44 static const char* const headersToIgnoreAfterRevalidation[] = {
45     "allow",
46     "connection",
47     "etag",
48     "keep-alive",
49     "last-modified",
50     "proxy-authenticate",
51     "proxy-connection",
52     "trailer",
53     "transfer-encoding",
54     "upgrade",
55     "www-authenticate",
56     "x-frame-options",
57     "x-xss-protection",
58 };
59
60 // Some header prefixes mean "Don't copy this header from a 304 response.".
61 // Rather than listing all the relevant headers, we can consolidate them into
62 // this list, also grabbed from Chromium's net/http/http_response_headers.cc.
63 static const char* const headerPrefixesToIgnoreAfterRevalidation[] = {
64     "content-",
65     "x-content-",
66     "x-webkit-"
67 };
68
69 static inline bool shouldUpdateHeaderAfterRevalidation(const String& header)
70 {
71     for (auto& headerToIgnore : headersToIgnoreAfterRevalidation) {
72         if (equalIgnoringASCIICase(header, headerToIgnore))
73             return false;
74     }
75     for (auto& prefixToIgnore : headerPrefixesToIgnoreAfterRevalidation) {
76         // FIXME: Would be more efficient if we added an overload of
77         // startsWithIgnoringASCIICase that takes a const char*.
78         if (header.startsWithIgnoringASCIICase(prefixToIgnore))
79             return false;
80     }
81     return true;
82 }
83
84 void updateResponseHeadersAfterRevalidation(ResourceResponse& response, const ResourceResponse& validatingResponse)
85 {
86     // Freshening stored response upon validation:
87     // http://tools.ietf.org/html/rfc7234#section-4.3.4
88     for (const auto& header : validatingResponse.httpHeaderFields()) {
89         // Entity headers should not be sent by servers when generating a 304
90         // response; misconfigured servers send them anyway. We shouldn't allow
91         // such headers to update the original request. We'll base this on the
92         // list defined by RFC2616 7.1, with a few additions for extension headers
93         // we care about.
94         if (!shouldUpdateHeaderAfterRevalidation(header.key))
95             continue;
96         response.setHTTPHeaderField(header.key, header.value);
97     }
98 }
99
100 Seconds computeCurrentAge(const ResourceResponse& response, WallTime responseTime)
101 {
102     // Age calculation:
103     // http://tools.ietf.org/html/rfc7234#section-4.2.3
104     // No compensation for latency as that is not terribly important in practice.
105     auto dateValue = response.date();
106     auto apparentAge = dateValue ? std::max(0_us, responseTime - *dateValue) : 0_us;
107     auto ageValue = response.age().value_or(0_us);
108     auto correctedInitialAge = std::max(apparentAge, ageValue);
109     auto residentTime = WallTime::now() - responseTime;
110     return correctedInitialAge + residentTime;
111 }
112
113 Seconds computeFreshnessLifetimeForHTTPFamily(const ResourceResponse& response, WallTime responseTime)
114 {
115     if (!response.url().protocolIsInHTTPFamily())
116         return 0_us;
117
118     // Freshness Lifetime:
119     // http://tools.ietf.org/html/rfc7234#section-4.2.1
120     auto maxAge = response.cacheControlMaxAge();
121     if (maxAge)
122         return *maxAge;
123
124     auto date = response.date();
125     auto effectiveDate = date.value_or(responseTime);
126     if (auto expires = response.expires())
127         return *expires - effectiveDate;
128
129     // Implicit lifetime.
130     switch (response.httpStatusCode()) {
131     case 301: // Moved Permanently
132     case 410: // Gone
133         // These are semantically permanent and so get long implicit lifetime.
134         return 24_h * 365;
135     default:
136         // Heuristic Freshness:
137         // http://tools.ietf.org/html/rfc7234#section-4.2.2
138         if (auto lastModified = response.lastModified())
139             return (effectiveDate - *lastModified) * 0.1;
140         return 0_us;
141     }
142 }
143
144 void updateRedirectChainStatus(RedirectChainCacheStatus& redirectChainCacheStatus, const ResourceResponse& response)
145 {
146     if (redirectChainCacheStatus.status == RedirectChainCacheStatus::NotCachedRedirection)
147         return;
148     if (response.cacheControlContainsNoStore() || response.cacheControlContainsNoCache() || response.cacheControlContainsMustRevalidate()) {
149         redirectChainCacheStatus.status = RedirectChainCacheStatus::NotCachedRedirection;
150         return;
151     }
152
153     redirectChainCacheStatus.status = RedirectChainCacheStatus::CachedRedirection;
154     auto responseTimestamp = WallTime::now();
155     // Store the nearest end of cache validity date
156     auto endOfValidity = responseTimestamp + computeFreshnessLifetimeForHTTPFamily(response, responseTimestamp) - computeCurrentAge(response, responseTimestamp);
157     redirectChainCacheStatus.endOfValidity = std::min(redirectChainCacheStatus.endOfValidity, endOfValidity);
158 }
159
160 bool redirectChainAllowsReuse(RedirectChainCacheStatus redirectChainCacheStatus, ReuseExpiredRedirectionOrNot reuseExpiredRedirection)
161 {
162     switch (redirectChainCacheStatus.status) {
163     case RedirectChainCacheStatus::NoRedirection:
164         return true;
165     case RedirectChainCacheStatus::NotCachedRedirection:
166         return false;
167     case RedirectChainCacheStatus::CachedRedirection:
168         return reuseExpiredRedirection || WallTime::now() <= redirectChainCacheStatus.endOfValidity;
169     }
170     ASSERT_NOT_REACHED();
171     return false;
172 }
173
174 inline bool isCacheHeaderSeparator(UChar c)
175 {
176     // http://tools.ietf.org/html/rfc7230#section-3.2.6
177     switch (c) {
178     case '(':
179     case ')':
180     case '<':
181     case '>':
182     case '@':
183     case ',':
184     case ';':
185     case ':':
186     case '\\':
187     case '"':
188     case '/':
189     case '[':
190     case ']':
191     case '?':
192     case '=':
193     case '{':
194     case '}':
195     case ' ':
196     case '\t':
197         return true;
198     default:
199         return false;
200     }
201 }
202
203 inline bool isControlCharacterOrSpace(UChar character)
204 {
205     return character <= ' ' || character == 127;
206 }
207
208 inline StringView trimToNextSeparator(StringView string)
209 {
210     return string.substring(0, string.find(isCacheHeaderSeparator));
211 }
212
213 static Vector<std::pair<String, String>> parseCacheHeader(const String& header)
214 {
215     Vector<std::pair<String, String>> result;
216
217     String safeHeaderString = header.removeCharacters(isControlCharacterOrSpace);
218     StringView safeHeader = safeHeaderString;
219     unsigned max = safeHeader.length();
220     unsigned pos = 0;
221     while (pos < max) {
222         size_t nextCommaPosition = safeHeader.find(',', pos);
223         size_t nextEqualSignPosition = safeHeader.find('=', pos);
224         if (nextEqualSignPosition == notFound && nextCommaPosition == notFound) {
225             // Add last directive to map with empty string as value
226             result.append({ trimToNextSeparator(safeHeader.substring(pos, max - pos)).toString(), emptyString() });
227             return result;
228         }
229         if (nextCommaPosition != notFound && (nextCommaPosition < nextEqualSignPosition || nextEqualSignPosition == notFound)) {
230             // Add directive to map with empty string as value
231             result.append({ trimToNextSeparator(safeHeader.substring(pos, nextCommaPosition - pos)).toString(), emptyString() });
232             pos += nextCommaPosition - pos + 1;
233             continue;
234         }
235         // Get directive name, parse right hand side of equal sign, then add to map
236         String directive = trimToNextSeparator(safeHeader.substring(pos, nextEqualSignPosition - pos)).toString();
237         pos += nextEqualSignPosition - pos + 1;
238
239         StringView value = safeHeader.substring(pos, max - pos);
240         if (value[0] == '"') {
241             // The value is a quoted string
242             size_t nextDoubleQuotePosition = value.find('"', 1);
243             if (nextDoubleQuotePosition == notFound) {
244                 // Parse error; just use the rest as the value
245                 result.append({ directive, trimToNextSeparator(value.substring(1)).toString() });
246                 return result;
247             }
248             // Store the value as a quoted string without quotes
249             result.append({ directive, value.substring(1, nextDoubleQuotePosition - 1).toString() });
250             pos += (safeHeader.find('"', pos) - pos) + nextDoubleQuotePosition + 1;
251             // Move past next comma, if there is one
252             size_t nextCommaPosition2 = safeHeader.find(',', pos);
253             if (nextCommaPosition2 == notFound)
254                 return result; // Parse error if there is anything left with no comma
255             pos += nextCommaPosition2 - pos + 1;
256             continue;
257         }
258         // The value is a token until the next comma
259         size_t nextCommaPosition2 = value.find(',');
260         if (nextCommaPosition2 == notFound) {
261             // The rest is the value; no change to value needed
262             result.append({ directive, trimToNextSeparator(value).toString() });
263             return result;
264         }
265         // The value is delimited by the next comma
266         result.append({ directive, trimToNextSeparator(value.substring(0, nextCommaPosition2)).toString() });
267         pos += (safeHeader.find(',', pos) - pos) + 1;
268     }
269     return result;
270 }
271
272 CacheControlDirectives parseCacheControlDirectives(const HTTPHeaderMap& headers)
273 {
274     CacheControlDirectives result;
275
276     String cacheControlValue = headers.get(HTTPHeaderName::CacheControl);
277     if (!cacheControlValue.isEmpty()) {
278         auto directives = parseCacheHeader(cacheControlValue);
279
280         size_t directivesSize = directives.size();
281         for (size_t i = 0; i < directivesSize; ++i) {
282             // A no-cache directive with a value is only meaningful for proxy caches.
283             // It should be ignored by a browser level cache.
284             // http://tools.ietf.org/html/rfc7234#section-5.2.2.2
285             if (equalLettersIgnoringASCIICase(directives[i].first, "no-cache") && directives[i].second.isEmpty())
286                 result.noCache = true;
287             else if (equalLettersIgnoringASCIICase(directives[i].first, "no-store"))
288                 result.noStore = true;
289             else if (equalLettersIgnoringASCIICase(directives[i].first, "must-revalidate"))
290                 result.mustRevalidate = true;
291             else if (equalLettersIgnoringASCIICase(directives[i].first, "max-age")) {
292                 if (result.maxAge) {
293                     // First max-age directive wins if there are multiple ones.
294                     continue;
295                 }
296                 bool ok;
297                 double maxAge = directives[i].second.toDouble(&ok);
298                 if (ok)
299                     result.maxAge = Seconds { maxAge };
300             } else if (equalLettersIgnoringASCIICase(directives[i].first, "max-stale")) {
301                 // https://tools.ietf.org/html/rfc7234#section-5.2.1.2
302                 if (result.maxStale) {
303                     // First max-stale directive wins if there are multiple ones.
304                     continue;
305                 }
306                 if (directives[i].second.isEmpty()) {
307                     // if no value is assigned to max-stale, then the client is willing to accept a stale response of any age.
308                     result.maxStale = Seconds::infinity();
309                     continue;
310                 }
311                 bool ok;
312                 double maxStale = directives[i].second.toDouble(&ok);
313                 if (ok)
314                     result.maxStale = Seconds { maxStale };
315             } else if (equalLettersIgnoringASCIICase(directives[i].first, "immutable"))
316                 result.immutable = true;
317         }
318     }
319
320     if (!result.noCache) {
321         // Handle Pragma: no-cache
322         // This is deprecated and equivalent to Cache-control: no-cache
323         // Don't bother tokenizing the value; handling that exactly right is not important.
324         result.noCache = headers.get(HTTPHeaderName::Pragma).containsIgnoringASCIICase("no-cache");
325     }
326
327     return result;
328 }
329
330 static String headerValueForVary(const ResourceRequest& request, const String& headerName, PAL::SessionID sessionID)
331 {
332     // Explicit handling for cookies is needed because they are added magically by the networking layer.
333     // FIXME: The value might have changed between making the request and retrieving the cookie here.
334     // We could fetch the cookie when making the request but that seems overkill as the case is very rare and it
335     // is a blocking operation. This should be sufficient to cover reasonable cases.
336     if (headerName == httpHeaderNameString(HTTPHeaderName::Cookie)) {
337         auto includeSecureCookies = request.url().protocolIs("https") ? IncludeSecureCookies::Yes : IncludeSecureCookies::No;
338         auto* cookieStrategy = platformStrategies() ? platformStrategies()->cookiesStrategy() : nullptr;
339         if (!cookieStrategy) {
340             ASSERT(sessionID == PAL::SessionID::defaultSessionID());
341             return cookieRequestHeaderFieldValue(NetworkStorageSession::defaultStorageSession(), request.firstPartyForCookies(), request.url(), std::nullopt, std::nullopt, includeSecureCookies).first;
342         }
343         return cookieStrategy->cookieRequestHeaderFieldValue(sessionID, request.firstPartyForCookies(), request.url(), std::nullopt, std::nullopt, includeSecureCookies).first;
344     }
345     return request.httpHeaderField(headerName);
346 }
347
348 Vector<std::pair<String, String>> collectVaryingRequestHeaders(const WebCore::ResourceRequest& request, const WebCore::ResourceResponse& response, PAL::SessionID sessionID)
349 {
350     String varyValue = response.httpHeaderField(WebCore::HTTPHeaderName::Vary);
351     if (varyValue.isEmpty())
352         return { };
353     Vector<String> varyingHeaderNames;
354     varyValue.split(',', varyingHeaderNames);
355     Vector<std::pair<String, String>> varyingRequestHeaders;
356     varyingRequestHeaders.reserveCapacity(varyingHeaderNames.size());
357     for (auto& varyHeaderName : varyingHeaderNames) {
358         String headerName = varyHeaderName.stripWhiteSpace();
359         String headerValue = headerValueForVary(request, headerName, sessionID);
360         varyingRequestHeaders.append(std::make_pair(headerName, headerValue));
361     }
362     return varyingRequestHeaders;
363 }
364
365 bool verifyVaryingRequestHeaders(const Vector<std::pair<String, String>>& varyingRequestHeaders, const WebCore::ResourceRequest& request, PAL::SessionID sessionID)
366 {
367     for (auto& varyingRequestHeader : varyingRequestHeaders) {
368         // FIXME: Vary: * in response would ideally trigger a cache delete instead of a store.
369         if (varyingRequestHeader.first == "*")
370             return false;
371         String headerValue = headerValueForVary(request, varyingRequestHeader.first, sessionID);
372         if (headerValue != varyingRequestHeader.second)
373             return false;
374     }
375     return true;
376 }
377
378 // http://tools.ietf.org/html/rfc7231#page-48
379 bool isStatusCodeCacheableByDefault(int statusCode)
380 {
381     switch (statusCode) {
382     case 200: // OK
383     case 203: // Non-Authoritative Information
384     case 204: // No Content
385     case 206: // Partial Content
386     case 300: // Multiple Choices
387     case 301: // Moved Permanently
388     case 404: // Not Found
389     case 405: // Method Not Allowed
390     case 410: // Gone
391     case 414: // URI Too Long
392     case 501: // Not Implemented
393         return true;
394     default:
395         return false;
396     }
397 }
398
399 bool isStatusCodePotentiallyCacheable(int statusCode)
400 {
401     switch (statusCode) {
402     case 201: // Created
403     case 202: // Accepted
404     case 205: // Reset Content
405     case 302: // Found
406     case 303: // See Other
407     case 307: // Temporary redirect
408     case 403: // Forbidden
409     case 406: // Not Acceptable
410     case 415: // Unsupported Media Type
411         return true;
412     default:
413         return false;
414     }
415 }
416
417 }