07ee84a480a1ed0d0dc9f04fbd3fd0405c491012
[WebKit-https.git] / Source / WebCore / platform / network / CacheValidation.cpp
1 /*
2  * Copyright (C) 2014-2016 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
38 namespace WebCore {
39
40 // These response headers are not copied from a revalidated response to the
41 // cached response headers. For compatibility, this list is based on Chromium's
42 // net/http/http_response_headers.cc.
43 const char* const headersToIgnoreAfterRevalidation[] = {
44     "allow",
45     "connection",
46     "etag",
47     "keep-alive",
48     "last-modified"
49     "proxy-authenticate",
50     "proxy-connection",
51     "trailer",
52     "transfer-encoding",
53     "upgrade",
54     "www-authenticate",
55     "x-frame-options",
56     "x-xss-protection",
57 };
58
59 // Some header prefixes mean "Don't copy this header from a 304 response.".
60 // Rather than listing all the relevant headers, we can consolidate them into
61 // this list, also grabbed from Chromium's net/http/http_response_headers.cc.
62 const char* const headerPrefixesToIgnoreAfterRevalidation[] = {
63     "content-",
64     "x-content-",
65     "x-webkit-"
66 };
67
68 static inline bool shouldUpdateHeaderAfterRevalidation(const String& header)
69 {
70     for (auto& headerToIgnore : headersToIgnoreAfterRevalidation) {
71         if (equalIgnoringASCIICase(header, headerToIgnore))
72             return false;
73     }
74     for (size_t i = 0; i < WTF_ARRAY_LENGTH(headerPrefixesToIgnoreAfterRevalidation); i++) {
75         if (header.startsWith(headerPrefixesToIgnoreAfterRevalidation[i], false))
76             return false;
77     }
78     return true;
79 }
80
81 void updateResponseHeadersAfterRevalidation(ResourceResponse& response, const ResourceResponse& validatingResponse)
82 {
83     // Freshening stored response upon validation:
84     // http://tools.ietf.org/html/rfc7234#section-4.3.4
85     for (const auto& header : validatingResponse.httpHeaderFields()) {
86         // Entity headers should not be sent by servers when generating a 304
87         // response; misconfigured servers send them anyway. We shouldn't allow
88         // such headers to update the original request. We'll base this on the
89         // list defined by RFC2616 7.1, with a few additions for extension headers
90         // we care about.
91         if (!shouldUpdateHeaderAfterRevalidation(header.key))
92             continue;
93         response.setHTTPHeaderField(header.key, header.value);
94     }
95 }
96
97 std::chrono::microseconds computeCurrentAge(const ResourceResponse& response, std::chrono::system_clock::time_point responseTime)
98 {
99     using namespace std::chrono;
100
101     // Age calculation:
102     // http://tools.ietf.org/html/rfc7234#section-4.2.3
103     // No compensation for latency as that is not terribly important in practice.
104     auto dateValue = response.date();
105     auto apparentAge = dateValue ? std::max(microseconds::zero(), duration_cast<microseconds>(responseTime - dateValue.value())) : microseconds::zero();
106     auto ageValue = response.age().valueOr(microseconds::zero());
107     auto correctedInitialAge = std::max(apparentAge, ageValue);
108     auto residentTime = duration_cast<microseconds>(system_clock::now() - responseTime);
109     return correctedInitialAge + residentTime;
110 }
111
112 std::chrono::microseconds computeFreshnessLifetimeForHTTPFamily(const ResourceResponse& response, std::chrono::system_clock::time_point responseTime)
113 {
114     using namespace std::chrono;
115     ASSERT(response.url().protocolIsInHTTPFamily());
116
117     // Freshness Lifetime:
118     // http://tools.ietf.org/html/rfc7234#section-4.2.1
119     auto maxAge = response.cacheControlMaxAge();
120     if (maxAge)
121         return maxAge.value();
122     auto expires = response.expires();
123     auto date = response.date();
124     auto dateValue = date ? date.value() : responseTime;
125     if (expires)
126         return duration_cast<microseconds>(expires.value() - dateValue);
127
128     // Implicit lifetime.
129     switch (response.httpStatusCode()) {
130     case 301: // Moved Permanently
131     case 410: // Gone
132         // These are semantically permanent and so get long implicit lifetime.
133         return hours(365 * 24);
134     default:
135         // Heuristic Freshness:
136         // http://tools.ietf.org/html/rfc7234#section-4.2.2
137         auto lastModified = response.lastModified();
138         if (lastModified)
139             return duration_cast<microseconds>((dateValue - lastModified.value()) * 0.1);
140         return microseconds::zero();
141     }
142 }
143
144 void updateRedirectChainStatus(RedirectChainCacheStatus& redirectChainCacheStatus, const ResourceResponse& response)
145 {
146     using namespace std::chrono;
147
148     if (redirectChainCacheStatus.status == RedirectChainCacheStatus::NotCachedRedirection)
149         return;
150     if (response.cacheControlContainsNoStore() || response.cacheControlContainsNoCache() || response.cacheControlContainsMustRevalidate()) {
151         redirectChainCacheStatus.status = RedirectChainCacheStatus::NotCachedRedirection;
152         return;
153     }
154
155     redirectChainCacheStatus.status = RedirectChainCacheStatus::CachedRedirection;
156     auto responseTimestamp = system_clock::now();
157     // Store the nearest end of cache validity date
158     auto endOfValidity = responseTimestamp + computeFreshnessLifetimeForHTTPFamily(response, responseTimestamp) - computeCurrentAge(response, responseTimestamp);
159     redirectChainCacheStatus.endOfValidity = std::min(redirectChainCacheStatus.endOfValidity, endOfValidity);
160 }
161
162 bool redirectChainAllowsReuse(RedirectChainCacheStatus redirectChainCacheStatus, ReuseExpiredRedirectionOrNot reuseExpiredRedirection)
163 {
164     switch (redirectChainCacheStatus.status) {
165     case RedirectChainCacheStatus::NoRedirection:
166         return true;
167     case RedirectChainCacheStatus::NotCachedRedirection:
168         return false;
169     case RedirectChainCacheStatus::CachedRedirection:
170         return reuseExpiredRedirection || std::chrono::system_clock::now() <= redirectChainCacheStatus.endOfValidity;
171     }
172     ASSERT_NOT_REACHED();
173     return false;
174 }
175
176 inline bool isCacheHeaderSeparator(UChar c)
177 {
178     // http://tools.ietf.org/html/rfc7230#section-3.2.6
179     switch (c) {
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 '}':
197     case ' ':
198     case '\t':
199         return true;
200     default:
201         return false;
202     }
203 }
204
205 inline bool isControlCharacter(UChar c)
206 {
207     return c < ' ' || c == 127;
208 }
209
210 inline String trimToNextSeparator(const String& str)
211 {
212     return str.substring(0, str.find(isCacheHeaderSeparator));
213 }
214
215 static Vector<std::pair<String, String>> parseCacheHeader(const String& header)
216 {
217     Vector<std::pair<String, String>> result;
218
219     const String safeHeader = header.removeCharacters(isControlCharacter);
220     unsigned max = safeHeader.length();
221     unsigned pos = 0;
222     while (pos < max) {
223         size_t nextCommaPosition = safeHeader.find(',', pos);
224         size_t nextEqualSignPosition = safeHeader.find('=', pos);
225         if (nextEqualSignPosition == notFound && nextCommaPosition == notFound) {
226             // Add last directive to map with empty string as value
227             result.append(std::make_pair(trimToNextSeparator(safeHeader.substring(pos, max - pos).stripWhiteSpace()), ""));
228             return result;
229         }
230         if (nextCommaPosition != notFound && (nextCommaPosition < nextEqualSignPosition || nextEqualSignPosition == notFound)) {
231             // Add directive to map with empty string as value
232             result.append(std::make_pair(trimToNextSeparator(safeHeader.substring(pos, nextCommaPosition - pos).stripWhiteSpace()), ""));
233             pos += nextCommaPosition - pos + 1;
234             continue;
235         }
236         // Get directive name, parse right hand side of equal sign, then add to map
237         String directive = trimToNextSeparator(safeHeader.substring(pos, nextEqualSignPosition - pos).stripWhiteSpace());
238         pos += nextEqualSignPosition - pos + 1;
239
240         String value = safeHeader.substring(pos, max - pos).stripWhiteSpace();
241         if (value[0] == '"') {
242             // The value is a quoted string
243             size_t nextDoubleQuotePosition = value.find('"', 1);
244             if (nextDoubleQuotePosition == notFound) {
245                 // Parse error; just use the rest as the value
246                 result.append(std::make_pair(directive, trimToNextSeparator(value.substring(1, value.length() - 1).stripWhiteSpace())));
247                 return result;
248             }
249             // Store the value as a quoted string without quotes
250             result.append(std::make_pair(directive, value.substring(1, nextDoubleQuotePosition - 1).stripWhiteSpace()));
251             pos += (safeHeader.find('"', pos) - pos) + nextDoubleQuotePosition + 1;
252             // Move past next comma, if there is one
253             size_t nextCommaPosition2 = safeHeader.find(',', pos);
254             if (nextCommaPosition2 == notFound)
255                 return result; // Parse error if there is anything left with no comma
256             pos += nextCommaPosition2 - pos + 1;
257             continue;
258         }
259         // The value is a token until the next comma
260         size_t nextCommaPosition2 = value.find(',');
261         if (nextCommaPosition2 == notFound) {
262             // The rest is the value; no change to value needed
263             result.append(std::make_pair(directive, trimToNextSeparator(value)));
264             return result;
265         }
266         // The value is delimited by the next comma
267         result.append(std::make_pair(directive, trimToNextSeparator(value.substring(0, nextCommaPosition2).stripWhiteSpace())));
268         pos += (safeHeader.find(',', pos) - pos) + 1;
269     }
270     return result;
271 }
272
273 CacheControlDirectives parseCacheControlDirectives(const HTTPHeaderMap& headers)
274 {
275     using namespace std::chrono;
276
277     CacheControlDirectives result;
278
279     String cacheControlValue = headers.get(HTTPHeaderName::CacheControl);
280     if (!cacheControlValue.isEmpty()) {
281         auto directives = parseCacheHeader(cacheControlValue);
282
283         size_t directivesSize = directives.size();
284         for (size_t i = 0; i < directivesSize; ++i) {
285             // A no-cache directive with a value is only meaningful for proxy caches.
286             // It should be ignored by a browser level cache.
287             // http://tools.ietf.org/html/rfc7234#section-5.2.2.2
288             if (equalLettersIgnoringASCIICase(directives[i].first, "no-cache") && directives[i].second.isEmpty())
289                 result.noCache = true;
290             else if (equalLettersIgnoringASCIICase(directives[i].first, "no-store"))
291                 result.noStore = true;
292             else if (equalLettersIgnoringASCIICase(directives[i].first, "must-revalidate"))
293                 result.mustRevalidate = true;
294             else if (equalLettersIgnoringASCIICase(directives[i].first, "max-age")) {
295                 if (result.maxAge) {
296                     // First max-age directive wins if there are multiple ones.
297                     continue;
298                 }
299                 bool ok;
300                 double maxAge = directives[i].second.toDouble(&ok);
301                 if (ok)
302                     result.maxAge = duration_cast<microseconds>(duration<double>(maxAge));
303             } else if (equalLettersIgnoringASCIICase(directives[i].first, "max-stale")) {
304                 // https://tools.ietf.org/html/rfc7234#section-5.2.1.2
305                 if (result.maxStale) {
306                     // First max-stale directive wins if there are multiple ones.
307                     continue;
308                 }
309                 if (directives[i].second.isEmpty()) {
310                     // if no value is assigned to max-stale, then the client is willing to accept a stale response of any age.
311                     result.maxStale = microseconds::max();
312                     continue;
313                 }
314                 bool ok;
315                 double maxStale = directives[i].second.toDouble(&ok);
316                 if (ok)
317                     result.maxStale = duration_cast<microseconds>(duration<double>(maxStale));
318             }
319         }
320     }
321
322     if (!result.noCache) {
323         // Handle Pragma: no-cache
324         // This is deprecated and equivalent to Cache-control: no-cache
325         // Don't bother tokenizing the value, it is not important
326         String pragmaValue = headers.get(HTTPHeaderName::Pragma);
327
328         result.noCache = pragmaValue.contains("no-cache", false);
329     }
330
331     return result;
332 }
333
334 static String headerValueForVary(const ResourceRequest& request, const String& headerName, SessionID sessionID)
335 {
336     // Explicit handling for cookies is needed because they are added magically by the networking layer.
337     // FIXME: The value might have changed between making the request and retrieving the cookie here.
338     // We could fetch the cookie when making the request but that seems overkill as the case is very rare and it
339     // is a blocking operation. This should be sufficient to cover reasonable cases.
340     if (headerName == httpHeaderNameString(HTTPHeaderName::Cookie)) {
341         if (sessionID != SessionID::defaultSessionID()) {
342             // FIXME: Don't know how to get the cookie. There should be a global way to get NetworkStorageSession from sessionID.
343             return "";
344         }
345         auto& session = NetworkStorageSession::defaultStorageSession();
346         auto* cookieStrategy = platformStrategies() ? platformStrategies()->cookiesStrategy() : nullptr;
347         if (!cookieStrategy)
348             return cookieRequestHeaderFieldValue(session, request.firstPartyForCookies(), request.url());
349         return cookieStrategy->cookieRequestHeaderFieldValue(session, request.firstPartyForCookies(), request.url());
350     }
351     return request.httpHeaderField(headerName);
352 }
353
354 Vector<std::pair<String, String>> collectVaryingRequestHeaders(const WebCore::ResourceRequest& request, const WebCore::ResourceResponse& response, SessionID sessionID)
355 {
356     String varyValue = response.httpHeaderField(WebCore::HTTPHeaderName::Vary);
357     if (varyValue.isEmpty())
358         return { };
359     Vector<String> varyingHeaderNames;
360     varyValue.split(',', /*allowEmptyEntries*/ false, varyingHeaderNames);
361     Vector<std::pair<String, String>> varyingRequestHeaders;
362     varyingRequestHeaders.reserveCapacity(varyingHeaderNames.size());
363     for (auto& varyHeaderName : varyingHeaderNames) {
364         String headerName = varyHeaderName.stripWhiteSpace();
365         String headerValue = headerValueForVary(request, headerName, sessionID);
366         varyingRequestHeaders.append(std::make_pair(headerName, headerValue));
367     }
368     return varyingRequestHeaders;
369 }
370
371 bool verifyVaryingRequestHeaders(const Vector<std::pair<String, String>>& varyingRequestHeaders, const WebCore::ResourceRequest& request, SessionID sessionID)
372 {
373     for (auto& varyingRequestHeader : varyingRequestHeaders) {
374         // FIXME: Vary: * in response would ideally trigger a cache delete instead of a store.
375         if (varyingRequestHeader.first == "*")
376             return false;
377         if (sessionID != SessionID::defaultSessionID() && varyingRequestHeader.first == httpHeaderNameString(HTTPHeaderName::Cookie)) {
378             // FIXME: See the comment in headerValueForVary.
379             return false;
380         }
381         String headerValue = headerValueForVary(request, varyingRequestHeader.first, sessionID);
382         if (headerValue != varyingRequestHeader.second)
383             return false;
384     }
385     return true;
386 }
387
388 }