f67414d58d207a6229b51c9dac90e0fafa400674
[WebKit-https.git] / Source / WebCore / platform / network / ResourceResponseBase.cpp
1 /*
2  * Copyright (C) 2006, 2008, 2016 Apple Inc. All rights reserved.
3  * Copyright (C) 2009 Google Inc. All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
15  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
17  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
18  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
19  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
20  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
21  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
22  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
24  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
25  */
26
27 #include "config.h"
28 #include "ResourceResponseBase.h"
29
30 #include "CacheValidation.h"
31 #include "HTTPHeaderNames.h"
32 #include "HTTPParsers.h"
33 #include "MIMETypeRegistry.h"
34 #include "ParsedContentRange.h"
35 #include "ResourceResponse.h"
36 #include <wtf/CurrentTime.h>
37 #include <wtf/MathExtras.h>
38 #include <wtf/StdLibExtras.h>
39 #include <wtf/text/StringView.h>
40
41 namespace WebCore {
42
43 bool isScriptAllowedByNosniff(const ResourceResponse& response)
44 {
45     if (parseContentTypeOptionsHeader(response.httpHeaderField(HTTPHeaderName::XContentTypeOptions)) != ContentTypeOptionsNosniff)
46         return true;
47     String mimeType = extractMIMETypeFromMediaType(response.httpHeaderField(HTTPHeaderName::ContentType));
48     return MIMETypeRegistry::isSupportedJavaScriptMIMEType(mimeType);
49 }
50
51 ResourceResponseBase::ResourceResponseBase()
52     : m_isNull(true)
53     , m_expectedContentLength(0)
54     , m_httpStatusCode(0)
55 {
56 }
57
58 ResourceResponseBase::ResourceResponseBase(const URL& url, const String& mimeType, long long expectedLength, const String& textEncodingName)
59     : m_isNull(false)
60     , m_url(url)
61     , m_mimeType(mimeType)
62     , m_expectedContentLength(expectedLength)
63     , m_textEncodingName(textEncodingName)
64     , m_certificateInfo(CertificateInfo()) // Empty but valid for synthetic responses.
65     , m_httpStatusCode(0)
66 {
67 }
68
69 ResourceResponseBase::CrossThreadData ResourceResponseBase::crossThreadData() const
70 {
71     CrossThreadData data;
72
73     data.url = url().isolatedCopy();
74     data.mimeType = mimeType().isolatedCopy();
75     data.expectedContentLength = expectedContentLength();
76     data.textEncodingName = textEncodingName().isolatedCopy();
77
78     data.httpStatusCode = httpStatusCode();
79     data.httpStatusText = httpStatusText().isolatedCopy();
80     data.httpVersion = httpVersion().isolatedCopy();
81
82     data.httpHeaderFields = httpHeaderFields().isolatedCopy();
83     data.networkLoadMetrics = m_networkLoadMetrics.isolatedCopy();
84     data.type = m_type;
85     data.tainting = m_tainting;
86     data.isRedirected = m_isRedirected;
87
88     return data;
89 }
90
91 ResourceResponse ResourceResponseBase::fromCrossThreadData(CrossThreadData&& data)
92 {
93     ResourceResponse response;
94
95     response.setURL(data.url);
96     response.setMimeType(data.mimeType);
97     response.setExpectedContentLength(data.expectedContentLength);
98     response.setTextEncodingName(data.textEncodingName);
99
100     response.setHTTPStatusCode(data.httpStatusCode);
101     response.setHTTPStatusText(data.httpStatusText);
102     response.setHTTPVersion(data.httpVersion);
103
104     response.m_httpHeaderFields = WTFMove(data.httpHeaderFields);
105     response.m_networkLoadMetrics = data.networkLoadMetrics;
106     response.m_type = data.type;
107     response.m_tainting = data.tainting;
108     response.m_isRedirected = data.isRedirected;
109
110     return response;
111 }
112
113 ResourceResponse ResourceResponseBase::filter(const ResourceResponse& response)
114 {
115     if (response.tainting() == Tainting::Opaque) {
116         ResourceResponse opaqueResponse;
117         opaqueResponse.setTainting(Tainting::Opaque);
118         opaqueResponse.setType(Type::Opaque);
119         return opaqueResponse;
120     }
121
122     if (response.tainting() == Tainting::Opaqueredirect) {
123         ResourceResponse opaqueResponse;
124         opaqueResponse.setTainting(Tainting::Opaqueredirect);
125         opaqueResponse.setType(Type::Opaqueredirect);
126         opaqueResponse.setURL(response.url());
127         return opaqueResponse;
128     }
129
130     ResourceResponse filteredResponse = response;
131     // Let's initialize filteredResponse to remove some header fields.
132     filteredResponse.lazyInit(AllFields);
133
134     if (response.tainting() == Tainting::Basic) {
135         filteredResponse.setType(Type::Basic);
136         filteredResponse.m_httpHeaderFields.remove(HTTPHeaderName::SetCookie);
137         filteredResponse.m_httpHeaderFields.remove(HTTPHeaderName::SetCookie2);
138         return filteredResponse;
139     }
140
141     ASSERT(response.tainting() == Tainting::Cors);
142     filteredResponse.setType(Type::Cors);
143
144     HTTPHeaderSet accessControlExposeHeaderSet;
145     parseAccessControlExposeHeadersAllowList(response.httpHeaderField(HTTPHeaderName::AccessControlExposeHeaders), accessControlExposeHeaderSet);
146     filteredResponse.m_httpHeaderFields.uncommonHeaders().removeIf([&](auto& entry) {
147         return !isCrossOriginSafeHeader(entry.key, accessControlExposeHeaderSet);
148     });
149     filteredResponse.m_httpHeaderFields.commonHeaders().removeIf([&](auto& entry) {
150         return !isCrossOriginSafeHeader(entry.key, accessControlExposeHeaderSet);
151     });
152
153     return filteredResponse;
154 }
155
156 // FIXME: Name does not make it clear this is true for HTTPS!
157 bool ResourceResponseBase::isHTTP() const
158 {
159     lazyInit(CommonFieldsOnly);
160
161     return m_url.protocolIsInHTTPFamily();
162 }
163
164 const URL& ResourceResponseBase::url() const
165 {
166     lazyInit(CommonFieldsOnly);
167
168     return m_url;
169 }
170
171 void ResourceResponseBase::setURL(const URL& url)
172 {
173     lazyInit(CommonFieldsOnly);
174     m_isNull = false;
175
176     m_url = url;
177
178     // FIXME: Should invalidate or update platform response if present.
179 }
180
181 const String& ResourceResponseBase::mimeType() const
182 {
183     lazyInit(CommonFieldsOnly);
184
185     return m_mimeType; 
186 }
187
188 void ResourceResponseBase::setMimeType(const String& mimeType)
189 {
190     lazyInit(CommonFieldsOnly);
191     m_isNull = false;
192
193     // FIXME: MIME type is determined by HTTP Content-Type header. We should update the header, so that it doesn't disagree with m_mimeType.
194     m_mimeType = mimeType;
195
196     // FIXME: Should invalidate or update platform response if present.
197 }
198
199 long long ResourceResponseBase::expectedContentLength() const 
200 {
201     lazyInit(CommonFieldsOnly);
202
203     return m_expectedContentLength;
204 }
205
206 void ResourceResponseBase::setExpectedContentLength(long long expectedContentLength)
207 {
208     lazyInit(CommonFieldsOnly);
209     m_isNull = false;
210
211     // FIXME: Content length is determined by HTTP Content-Length header. We should update the header, so that it doesn't disagree with m_expectedContentLength.
212     m_expectedContentLength = expectedContentLength; 
213
214     // FIXME: Should invalidate or update platform response if present.
215 }
216
217 const String& ResourceResponseBase::textEncodingName() const
218 {
219     lazyInit(CommonFieldsOnly);
220
221     return m_textEncodingName;
222 }
223
224 void ResourceResponseBase::setTextEncodingName(const String& encodingName)
225 {
226     lazyInit(CommonFieldsOnly);
227     m_isNull = false;
228
229     // FIXME: Text encoding is determined by HTTP Content-Type header. We should update the header, so that it doesn't disagree with m_textEncodingName.
230     m_textEncodingName = encodingName;
231
232     // FIXME: Should invalidate or update platform response if present.
233 }
234
235 void ResourceResponseBase::setType(Type type)
236 {
237     m_isNull = false;
238     m_type = type;
239 }
240
241 void ResourceResponseBase::includeCertificateInfo() const
242 {
243     if (m_certificateInfo)
244         return;
245     m_certificateInfo = static_cast<const ResourceResponse*>(this)->platformCertificateInfo();
246 }
247
248 String ResourceResponseBase::suggestedFilename() const
249 {
250     return static_cast<const ResourceResponse*>(this)->platformSuggestedFilename();
251 }
252
253 String ResourceResponseBase::sanitizeSuggestedFilename(const String& suggestedFilename)
254 {
255     if (suggestedFilename.isEmpty())
256         return suggestedFilename;
257
258     ResourceResponse response(URL(ParsedURLString, "http://example.com/"), String(), -1, String());
259     response.setHTTPStatusCode(200);
260     String escapedSuggestedFilename = String(suggestedFilename).replace('\\', "\\\\").replace('"', "\\\"");
261     String value = makeString("attachment; filename=\"", escapedSuggestedFilename, '"');
262     response.setHTTPHeaderField(HTTPHeaderName::ContentDisposition, value);
263     return response.suggestedFilename();
264 }
265
266 bool ResourceResponseBase::isSuccessful() const
267 {
268     int code = httpStatusCode();
269     return code >= 200 && code < 300;
270 }
271
272 int ResourceResponseBase::httpStatusCode() const
273 {
274     lazyInit(CommonFieldsOnly);
275
276     return m_httpStatusCode;
277 }
278
279 void ResourceResponseBase::setHTTPStatusCode(int statusCode)
280 {
281     lazyInit(CommonFieldsOnly);
282
283     m_httpStatusCode = statusCode;
284     m_isNull = false;
285
286     // FIXME: Should invalidate or update platform response if present.
287 }
288
289 const String& ResourceResponseBase::httpStatusText() const 
290 {
291     lazyInit(AllFields);
292
293     return m_httpStatusText; 
294 }
295
296 void ResourceResponseBase::setHTTPStatusText(const String& statusText) 
297 {
298     lazyInit(AllFields);
299
300     m_httpStatusText = statusText; 
301
302     // FIXME: Should invalidate or update platform response if present.
303 }
304
305 const String& ResourceResponseBase::httpVersion() const
306 {
307     lazyInit(AllFields);
308     
309     return m_httpVersion;
310 }
311
312 void ResourceResponseBase::setHTTPVersion(const String& versionText)
313 {
314     lazyInit(AllFields);
315     
316     m_httpVersion = versionText;
317     
318     // FIXME: Should invalidate or update platform response if present.
319 }
320
321 bool ResourceResponseBase::isHTTP09() const
322 {
323     lazyInit(AllFields);
324
325     return m_httpVersion.startsWith("HTTP/0.9");
326 }
327
328 String ResourceResponseBase::httpHeaderField(const String& name) const
329 {
330     lazyInit(CommonFieldsOnly);
331
332     // If we already have the header, just return it instead of consuming memory by grabing all headers.
333     String value = m_httpHeaderFields.get(name);
334     if (!value.isEmpty())        
335         return value;
336
337     lazyInit(AllFields);
338
339     return m_httpHeaderFields.get(name); 
340 }
341
342 String ResourceResponseBase::httpHeaderField(HTTPHeaderName name) const
343 {
344     lazyInit(CommonFieldsOnly);
345
346     // If we already have the header, just return it instead of consuming memory by grabing all headers.
347     String value = m_httpHeaderFields.get(name);
348     if (!value.isEmpty())
349         return value;
350
351     lazyInit(AllFields);
352
353     return m_httpHeaderFields.get(name); 
354 }
355
356 void ResourceResponseBase::updateHeaderParsedState(HTTPHeaderName name)
357 {
358     switch (name) {
359     case HTTPHeaderName::Age:
360         m_haveParsedAgeHeader = false;
361         break;
362
363     case HTTPHeaderName::CacheControl:
364     case HTTPHeaderName::Pragma:
365         m_haveParsedCacheControlHeader = false;
366         break;
367
368     case HTTPHeaderName::Date:
369         m_haveParsedDateHeader = false;
370         break;
371
372     case HTTPHeaderName::Expires:
373         m_haveParsedExpiresHeader = false;
374         break;
375
376     case HTTPHeaderName::LastModified:
377         m_haveParsedLastModifiedHeader = false;
378         break;
379
380     case HTTPHeaderName::ContentRange:
381         m_haveParsedContentRangeHeader = false;
382         break;
383
384     default:
385         break;
386     }
387 }
388
389 void ResourceResponseBase::setHTTPHeaderField(const String& name, const String& value)
390 {
391     lazyInit(AllFields);
392
393     HTTPHeaderName headerName;
394     if (findHTTPHeaderName(name, headerName))
395         updateHeaderParsedState(headerName);
396
397     m_httpHeaderFields.set(name, value);
398
399     // FIXME: Should invalidate or update platform response if present.
400 }
401
402 void ResourceResponseBase::setHTTPHeaderFields(HTTPHeaderMap&& headerFields)
403 {
404     lazyInit(AllFields);
405
406     m_httpHeaderFields = WTFMove(headerFields);
407 }
408
409 void ResourceResponseBase::setHTTPHeaderField(HTTPHeaderName name, const String& value)
410 {
411     lazyInit(AllFields);
412
413     updateHeaderParsedState(name);
414
415     m_httpHeaderFields.set(name, value);
416
417     // FIXME: Should invalidate or update platform response if present.
418 }
419
420 void ResourceResponseBase::addHTTPHeaderField(HTTPHeaderName name, const String& value)
421 {
422     lazyInit(AllFields);
423     updateHeaderParsedState(name);
424     m_httpHeaderFields.add(name, value);
425 }
426
427 void ResourceResponseBase::addHTTPHeaderField(const String& name, const String& value)
428 {
429     HTTPHeaderName headerName;
430     if (findHTTPHeaderName(name, headerName))
431         addHTTPHeaderField(headerName, value);
432     else {
433         lazyInit(AllFields);
434         m_httpHeaderFields.add(name, value);
435     }
436 }
437
438 const HTTPHeaderMap& ResourceResponseBase::httpHeaderFields() const
439 {
440     lazyInit(AllFields);
441
442     return m_httpHeaderFields;
443 }
444
445 void ResourceResponseBase::parseCacheControlDirectives() const
446 {
447     ASSERT(!m_haveParsedCacheControlHeader);
448
449     lazyInit(CommonFieldsOnly);
450
451     m_cacheControlDirectives = WebCore::parseCacheControlDirectives(m_httpHeaderFields);
452     m_haveParsedCacheControlHeader = true;
453 }
454     
455 bool ResourceResponseBase::cacheControlContainsNoCache() const
456 {
457     if (!m_haveParsedCacheControlHeader)
458         parseCacheControlDirectives();
459     return m_cacheControlDirectives.noCache;
460 }
461
462 bool ResourceResponseBase::cacheControlContainsNoStore() const
463 {
464     if (!m_haveParsedCacheControlHeader)
465         parseCacheControlDirectives();
466     return m_cacheControlDirectives.noStore;
467 }
468
469 bool ResourceResponseBase::cacheControlContainsMustRevalidate() const
470 {
471     if (!m_haveParsedCacheControlHeader)
472         parseCacheControlDirectives();
473     return m_cacheControlDirectives.mustRevalidate;
474 }
475     
476 bool ResourceResponseBase::cacheControlContainsImmutable() const
477 {
478     if (!m_haveParsedCacheControlHeader)
479         parseCacheControlDirectives();
480     return m_cacheControlDirectives.immutable;
481 }
482
483 bool ResourceResponseBase::hasCacheValidatorFields() const
484 {
485     lazyInit(CommonFieldsOnly);
486
487     return !m_httpHeaderFields.get(HTTPHeaderName::LastModified).isEmpty() || !m_httpHeaderFields.get(HTTPHeaderName::ETag).isEmpty();
488 }
489
490 std::optional<Seconds> ResourceResponseBase::cacheControlMaxAge() const
491 {
492     if (!m_haveParsedCacheControlHeader)
493         parseCacheControlDirectives();
494     return m_cacheControlDirectives.maxAge;
495 }
496
497 static std::optional<WallTime> parseDateValueInHeader(const HTTPHeaderMap& headers, HTTPHeaderName headerName)
498 {
499     String headerValue = headers.get(headerName);
500     if (headerValue.isEmpty())
501         return std::nullopt;
502     // This handles all date formats required by RFC2616:
503     // Sun, 06 Nov 1994 08:49:37 GMT  ; RFC 822, updated by RFC 1123
504     // Sunday, 06-Nov-94 08:49:37 GMT ; RFC 850, obsoleted by RFC 1036
505     // Sun Nov  6 08:49:37 1994       ; ANSI C's asctime() format
506     return parseHTTPDate(headerValue);
507 }
508
509 std::optional<WallTime> ResourceResponseBase::date() const
510 {
511     lazyInit(CommonFieldsOnly);
512
513     if (!m_haveParsedDateHeader) {
514         m_date = parseDateValueInHeader(m_httpHeaderFields, HTTPHeaderName::Date);
515         m_haveParsedDateHeader = true;
516     }
517     return m_date;
518 }
519
520 std::optional<Seconds> ResourceResponseBase::age() const
521 {
522     lazyInit(CommonFieldsOnly);
523
524     if (!m_haveParsedAgeHeader) {
525         String headerValue = m_httpHeaderFields.get(HTTPHeaderName::Age);
526         bool ok;
527         double ageDouble = headerValue.toDouble(&ok);
528         if (ok)
529             m_age = Seconds { ageDouble };
530         m_haveParsedAgeHeader = true;
531     }
532     return m_age;
533 }
534
535 std::optional<WallTime> ResourceResponseBase::expires() const
536 {
537     lazyInit(CommonFieldsOnly);
538
539     if (!m_haveParsedExpiresHeader) {
540         m_expires = parseDateValueInHeader(m_httpHeaderFields, HTTPHeaderName::Expires);
541         m_haveParsedExpiresHeader = true;
542     }
543     return m_expires;
544 }
545
546 std::optional<WallTime> ResourceResponseBase::lastModified() const
547 {
548     lazyInit(CommonFieldsOnly);
549
550     if (!m_haveParsedLastModifiedHeader) {
551         m_lastModified = parseDateValueInHeader(m_httpHeaderFields, HTTPHeaderName::LastModified);
552 #if PLATFORM(COCOA)
553         // CFNetwork converts malformed dates into Epoch so we need to treat Epoch as
554         // an invalid value (rdar://problem/22352838).
555         const WallTime epoch = WallTime::fromRawSeconds(0);
556         if (m_lastModified && m_lastModified.value() == epoch)
557             m_lastModified = std::nullopt;
558 #endif
559         m_haveParsedLastModifiedHeader = true;
560     }
561     return m_lastModified;
562 }
563
564 static ParsedContentRange parseContentRangeInHeader(const HTTPHeaderMap& headers)
565 {
566     String contentRangeValue = headers.get(HTTPHeaderName::ContentRange);
567     if (contentRangeValue.isEmpty())
568         return ParsedContentRange();
569
570     return ParsedContentRange(contentRangeValue);
571 }
572
573 ParsedContentRange& ResourceResponseBase::contentRange() const
574 {
575     lazyInit(CommonFieldsOnly);
576
577     if (!m_haveParsedContentRangeHeader) {
578         m_contentRange = parseContentRangeInHeader(m_httpHeaderFields);
579         m_haveParsedContentRangeHeader = true;
580     }
581
582     return m_contentRange;
583 }
584
585 bool ResourceResponseBase::isAttachment() const
586 {
587     lazyInit(AllFields);
588
589     auto value = m_httpHeaderFields.get(HTTPHeaderName::ContentDisposition);
590     return equalLettersIgnoringASCIICase(value.left(value.find(';')).stripWhiteSpace(), "attachment");
591 }
592
593 bool ResourceResponseBase::isAttachmentWithFilename() const
594 {
595     lazyInit(AllFields);
596
597     String contentDisposition = m_httpHeaderFields.get(HTTPHeaderName::ContentDisposition);
598     if (contentDisposition.isNull())
599         return false;
600
601     if (!equalLettersIgnoringASCIICase(contentDisposition.left(contentDisposition.find(';')).stripWhiteSpace(), "attachment"))
602         return false;
603
604     String filename = filenameFromHTTPContentDisposition(contentDisposition);
605     return !filename.isNull();
606 }
607
608 ResourceResponseBase::Source ResourceResponseBase::source() const
609 {
610     lazyInit(AllFields);
611
612     return m_source;
613 }
614
615 void ResourceResponseBase::lazyInit(InitLevel initLevel) const
616 {
617     const_cast<ResourceResponse*>(static_cast<const ResourceResponse*>(this))->platformLazyInit(initLevel);
618 }
619
620 bool ResourceResponseBase::compare(const ResourceResponse& a, const ResourceResponse& b)
621 {
622     if (a.isNull() != b.isNull())
623         return false;  
624     if (a.url() != b.url())
625         return false;
626     if (a.mimeType() != b.mimeType())
627         return false;
628     if (a.expectedContentLength() != b.expectedContentLength())
629         return false;
630     if (a.textEncodingName() != b.textEncodingName())
631         return false;
632     if (a.suggestedFilename() != b.suggestedFilename())
633         return false;
634     if (a.httpStatusCode() != b.httpStatusCode())
635         return false;
636     if (a.httpStatusText() != b.httpStatusText())
637         return false;
638     if (a.httpHeaderFields() != b.httpHeaderFields())
639         return false;
640     if (a.deprecatedNetworkLoadMetrics() != b.deprecatedNetworkLoadMetrics())
641         return false;
642     return ResourceResponse::platformCompare(a, b);
643 }
644
645 }