Use NetworkLoadChecker for navigation loads
[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/MathExtras.h>
37 #include <wtf/StdLibExtras.h>
38 #include <wtf/text/StringView.h>
39
40 namespace WebCore {
41
42 bool isScriptAllowedByNosniff(const ResourceResponse& response)
43 {
44     if (parseContentTypeOptionsHeader(response.httpHeaderField(HTTPHeaderName::XContentTypeOptions)) != ContentTypeOptionsNosniff)
45         return true;
46     String mimeType = extractMIMETypeFromMediaType(response.httpHeaderField(HTTPHeaderName::ContentType));
47     return MIMETypeRegistry::isSupportedJavaScriptMIMEType(mimeType);
48 }
49
50 ResourceResponseBase::ResourceResponseBase()
51     : m_isNull(true)
52     , m_expectedContentLength(0)
53     , m_httpStatusCode(0)
54 {
55 }
56
57 ResourceResponseBase::ResourceResponseBase(const URL& url, const String& mimeType, long long expectedLength, const String& textEncodingName)
58     : m_isNull(false)
59     , m_url(url)
60     , m_mimeType(mimeType)
61     , m_expectedContentLength(expectedLength)
62     , m_textEncodingName(textEncodingName)
63     , m_certificateInfo(CertificateInfo()) // Empty but valid for synthetic responses.
64     , m_httpStatusCode(0)
65 {
66 }
67
68 ResourceResponseBase::CrossThreadData ResourceResponseBase::crossThreadData() const
69 {
70     CrossThreadData data;
71
72     data.url = url().isolatedCopy();
73     data.mimeType = mimeType().isolatedCopy();
74     data.expectedContentLength = expectedContentLength();
75     data.textEncodingName = textEncodingName().isolatedCopy();
76
77     data.httpStatusCode = httpStatusCode();
78     data.httpStatusText = httpStatusText().isolatedCopy();
79     data.httpVersion = httpVersion().isolatedCopy();
80
81     data.httpHeaderFields = httpHeaderFields().isolatedCopy();
82     data.networkLoadMetrics = m_networkLoadMetrics.isolatedCopy();
83     data.type = m_type;
84     data.tainting = m_tainting;
85     data.isRedirected = m_isRedirected;
86
87     return data;
88 }
89
90 ResourceResponse ResourceResponseBase::fromCrossThreadData(CrossThreadData&& data)
91 {
92     ResourceResponse response;
93
94     response.setURL(data.url);
95     response.setMimeType(data.mimeType);
96     response.setExpectedContentLength(data.expectedContentLength);
97     response.setTextEncodingName(data.textEncodingName);
98
99     response.setHTTPStatusCode(data.httpStatusCode);
100     response.setHTTPStatusText(data.httpStatusText);
101     response.setHTTPVersion(data.httpVersion);
102
103     response.m_httpHeaderFields = WTFMove(data.httpHeaderFields);
104     response.m_networkLoadMetrics = data.networkLoadMetrics;
105     response.m_type = data.type;
106     response.m_tainting = data.tainting;
107     response.m_isRedirected = data.isRedirected;
108
109     return response;
110 }
111
112 ResourceResponse ResourceResponseBase::filter(const ResourceResponse& response)
113 {
114     if (response.tainting() == Tainting::Opaque) {
115         ResourceResponse opaqueResponse;
116         opaqueResponse.setTainting(Tainting::Opaque);
117         opaqueResponse.setType(Type::Opaque);
118         return opaqueResponse;
119     }
120
121     if (response.tainting() == Tainting::Opaqueredirect) {
122         ResourceResponse opaqueResponse;
123         opaqueResponse.setTainting(Tainting::Opaqueredirect);
124         opaqueResponse.setType(Type::Opaqueredirect);
125         opaqueResponse.setURL(response.url());
126         return opaqueResponse;
127     }
128
129     ResourceResponse filteredResponse = response;
130     // Let's initialize filteredResponse to remove some header fields.
131     filteredResponse.lazyInit(AllFields);
132
133     if (response.tainting() == Tainting::Basic) {
134         filteredResponse.setType(Type::Basic);
135         filteredResponse.m_httpHeaderFields.remove(HTTPHeaderName::SetCookie);
136         filteredResponse.m_httpHeaderFields.remove(HTTPHeaderName::SetCookie2);
137         return filteredResponse;
138     }
139
140     ASSERT(response.tainting() == Tainting::Cors);
141     filteredResponse.setType(Type::Cors);
142
143     HTTPHeaderSet accessControlExposeHeaderSet;
144     parseAccessControlExposeHeadersAllowList(response.httpHeaderField(HTTPHeaderName::AccessControlExposeHeaders), accessControlExposeHeaderSet);
145     filteredResponse.m_httpHeaderFields.uncommonHeaders().removeIf([&](auto& entry) {
146         return !isCrossOriginSafeHeader(entry.key, accessControlExposeHeaderSet);
147     });
148     filteredResponse.m_httpHeaderFields.commonHeaders().removeIf([&](auto& entry) {
149         return !isCrossOriginSafeHeader(entry.key, accessControlExposeHeaderSet);
150     });
151
152     return filteredResponse;
153 }
154
155 // FIXME: Name does not make it clear this is true for HTTPS!
156 bool ResourceResponseBase::isHTTP() const
157 {
158     lazyInit(CommonFieldsOnly);
159
160     return m_url.protocolIsInHTTPFamily();
161 }
162
163 const URL& ResourceResponseBase::url() const
164 {
165     lazyInit(CommonFieldsOnly);
166
167     return m_url;
168 }
169
170 void ResourceResponseBase::setURL(const URL& url)
171 {
172     lazyInit(CommonFieldsOnly);
173     m_isNull = false;
174
175     m_url = url;
176
177     // FIXME: Should invalidate or update platform response if present.
178 }
179
180 const String& ResourceResponseBase::mimeType() const
181 {
182     lazyInit(CommonFieldsOnly);
183
184     return m_mimeType; 
185 }
186
187 void ResourceResponseBase::setMimeType(const String& mimeType)
188 {
189     lazyInit(CommonFieldsOnly);
190     m_isNull = false;
191
192     // FIXME: MIME type is determined by HTTP Content-Type header. We should update the header, so that it doesn't disagree with m_mimeType.
193     m_mimeType = mimeType;
194
195     // FIXME: Should invalidate or update platform response if present.
196 }
197
198 long long ResourceResponseBase::expectedContentLength() const 
199 {
200     lazyInit(CommonFieldsOnly);
201
202     return m_expectedContentLength;
203 }
204
205 void ResourceResponseBase::setExpectedContentLength(long long expectedContentLength)
206 {
207     lazyInit(CommonFieldsOnly);
208     m_isNull = false;
209
210     // FIXME: Content length is determined by HTTP Content-Length header. We should update the header, so that it doesn't disagree with m_expectedContentLength.
211     m_expectedContentLength = expectedContentLength; 
212
213     // FIXME: Should invalidate or update platform response if present.
214 }
215
216 const String& ResourceResponseBase::textEncodingName() const
217 {
218     lazyInit(CommonFieldsOnly);
219
220     return m_textEncodingName;
221 }
222
223 void ResourceResponseBase::setTextEncodingName(const String& encodingName)
224 {
225     lazyInit(CommonFieldsOnly);
226     m_isNull = false;
227
228     // FIXME: Text encoding is determined by HTTP Content-Type header. We should update the header, so that it doesn't disagree with m_textEncodingName.
229     m_textEncodingName = encodingName;
230
231     // FIXME: Should invalidate or update platform response if present.
232 }
233
234 void ResourceResponseBase::setType(Type type)
235 {
236     m_isNull = false;
237     m_type = type;
238 }
239
240 void ResourceResponseBase::includeCertificateInfo() const
241 {
242     if (m_certificateInfo)
243         return;
244     m_certificateInfo = static_cast<const ResourceResponse*>(this)->platformCertificateInfo();
245 }
246
247 String ResourceResponseBase::suggestedFilename() const
248 {
249     return static_cast<const ResourceResponse*>(this)->platformSuggestedFilename();
250 }
251
252 String ResourceResponseBase::sanitizeSuggestedFilename(const String& suggestedFilename)
253 {
254     if (suggestedFilename.isEmpty())
255         return suggestedFilename;
256
257     ResourceResponse response(URL(ParsedURLString, "http://example.com/"), String(), -1, String());
258     response.setHTTPStatusCode(200);
259     String escapedSuggestedFilename = String(suggestedFilename).replace('\\', "\\\\").replace('"', "\\\"");
260     String value = makeString("attachment; filename=\"", escapedSuggestedFilename, '"');
261     response.setHTTPHeaderField(HTTPHeaderName::ContentDisposition, value);
262     return response.suggestedFilename();
263 }
264
265 bool ResourceResponseBase::isSuccessful() const
266 {
267     int code = httpStatusCode();
268     return code >= 200 && code < 300;
269 }
270
271 int ResourceResponseBase::httpStatusCode() const
272 {
273     lazyInit(CommonFieldsOnly);
274
275     return m_httpStatusCode;
276 }
277
278 void ResourceResponseBase::setHTTPStatusCode(int statusCode)
279 {
280     lazyInit(CommonFieldsOnly);
281
282     m_httpStatusCode = statusCode;
283     m_isNull = false;
284
285     // FIXME: Should invalidate or update platform response if present.
286 }
287
288 const String& ResourceResponseBase::httpStatusText() const 
289 {
290     lazyInit(AllFields);
291
292     return m_httpStatusText; 
293 }
294
295 void ResourceResponseBase::setHTTPStatusText(const String& statusText) 
296 {
297     lazyInit(AllFields);
298
299     m_httpStatusText = statusText; 
300
301     // FIXME: Should invalidate or update platform response if present.
302 }
303
304 const String& ResourceResponseBase::httpVersion() const
305 {
306     lazyInit(AllFields);
307     
308     return m_httpVersion;
309 }
310
311 void ResourceResponseBase::setHTTPVersion(const String& versionText)
312 {
313     lazyInit(AllFields);
314     
315     m_httpVersion = versionText;
316     
317     // FIXME: Should invalidate or update platform response if present.
318 }
319
320 static bool isSafeRedirectionResponseHeader(HTTPHeaderName name)
321 {
322     // WebCore needs to keep location and cache related headers as it does caching.
323     // We also keep CORS/ReferrerPolicy headers until CORS checks/Referrer computation are done in NetworkProcess.
324     return name == HTTPHeaderName::Location
325         || name == HTTPHeaderName::ReferrerPolicy
326         || name == HTTPHeaderName::CacheControl
327         || name == HTTPHeaderName::Date
328         || name == HTTPHeaderName::Expires
329         || name == HTTPHeaderName::ETag
330         || name == HTTPHeaderName::LastModified
331         || name == HTTPHeaderName::Age
332         || name == HTTPHeaderName::Pragma
333         || name == HTTPHeaderName::ReferrerPolicy
334         || name == HTTPHeaderName::Refresh
335         || name == HTTPHeaderName::Vary
336         || name == HTTPHeaderName::AccessControlAllowCredentials
337         || name == HTTPHeaderName::AccessControlAllowHeaders
338         || name == HTTPHeaderName::AccessControlAllowMethods
339         || name == HTTPHeaderName::AccessControlAllowOrigin
340         || name == HTTPHeaderName::AccessControlExposeHeaders
341         || name == HTTPHeaderName::AccessControlMaxAge
342         || name == HTTPHeaderName::TimingAllowOrigin;
343 }
344
345 static bool isSafeCrossOriginResponseHeader(HTTPHeaderName name)
346 {
347     // All known response headers used in WebProcesses.
348     return name == HTTPHeaderName::AcceptRanges
349         || name == HTTPHeaderName::AccessControlAllowCredentials
350         || name == HTTPHeaderName::AccessControlAllowHeaders
351         || name == HTTPHeaderName::AccessControlAllowMethods
352         || name == HTTPHeaderName::AccessControlAllowOrigin
353         || name == HTTPHeaderName::AccessControlExposeHeaders
354         || name == HTTPHeaderName::AccessControlMaxAge
355         || name == HTTPHeaderName::AccessControlRequestHeaders
356         || name == HTTPHeaderName::AccessControlRequestMethod
357         || name == HTTPHeaderName::Age
358         || name == HTTPHeaderName::CacheControl
359         || name == HTTPHeaderName::ContentDisposition
360         || name == HTTPHeaderName::ContentEncoding
361         || name == HTTPHeaderName::ContentLanguage
362         || name == HTTPHeaderName::ContentLength
363         || name == HTTPHeaderName::ContentRange
364         || name == HTTPHeaderName::ContentSecurityPolicy
365         || name == HTTPHeaderName::ContentSecurityPolicyReportOnly
366         || name == HTTPHeaderName::ContentType
367         || name == HTTPHeaderName::Date
368         || name == HTTPHeaderName::ETag
369         || name == HTTPHeaderName::Expires
370         || name == HTTPHeaderName::IcyMetaInt
371         || name == HTTPHeaderName::IcyMetadata
372         || name == HTTPHeaderName::LastEventID
373         || name == HTTPHeaderName::LastModified
374         || name == HTTPHeaderName::Link
375         || name == HTTPHeaderName::Pragma
376         || name == HTTPHeaderName::Range
377         || name == HTTPHeaderName::ReferrerPolicy
378         || name == HTTPHeaderName::Refresh
379         || name == HTTPHeaderName::SourceMap
380         || name == HTTPHeaderName::XSourceMap
381         || name == HTTPHeaderName::TimingAllowOrigin
382         || name == HTTPHeaderName::Trailer
383         || name == HTTPHeaderName::Vary
384         || name == HTTPHeaderName::XContentTypeOptions
385         || name == HTTPHeaderName::XDNSPrefetchControl
386         || name == HTTPHeaderName::XFrameOptions
387         || name == HTTPHeaderName::XWebKitCSP
388         || name == HTTPHeaderName::XWebKitCSPReportOnly
389         || name == HTTPHeaderName::XXSSProtection;
390 }
391
392 void ResourceResponseBase::sanitizeHTTPHeaderFieldsAccordingToTainting()
393 {
394     switch (m_tainting) {
395     case ResourceResponse::Tainting::Basic:
396         return;
397     case ResourceResponse::Tainting::Cors: {
398         HTTPHeaderMap filteredHeaders;
399         for (auto& header : m_httpHeaderFields.commonHeaders()) {
400             if (isSafeCrossOriginResponseHeader(header.key))
401                 filteredHeaders.add(header.key, WTFMove(header.value));
402         }
403         if (auto corsSafeHeaderSet = parseAccessControlAllowList(httpHeaderField(HTTPHeaderName::AccessControlExposeHeaders))) {
404             for (auto& headerName : *corsSafeHeaderSet) {
405                 if (!filteredHeaders.contains(headerName)) {
406                     auto value = m_httpHeaderFields.get(headerName);
407                     if (!value.isNull())
408                         filteredHeaders.add(headerName, value);
409                 }
410             }
411         }
412         m_httpHeaderFields = WTFMove(filteredHeaders);
413         return;
414     }
415     case ResourceResponse::Tainting::Opaque: {
416         HTTPHeaderMap filteredHeaders;
417         for (auto& header : m_httpHeaderFields.commonHeaders()) {
418             if (isSafeCrossOriginResponseHeader(header.key))
419                 filteredHeaders.add(header.key, WTFMove(header.value));
420         }
421         m_httpHeaderFields = WTFMove(filteredHeaders);
422         return;
423     }
424     case ResourceResponse::Tainting::Opaqueredirect: {
425         auto location = httpHeaderField(HTTPHeaderName::Location);
426         m_httpHeaderFields.clear();
427         m_httpHeaderFields.add(HTTPHeaderName::Location, WTFMove(location));
428     }
429     }
430 }
431
432 void ResourceResponseBase::sanitizeHTTPHeaderFields(SanitizationType type)
433 {
434     lazyInit(AllFields);
435
436     m_httpHeaderFields.commonHeaders().remove(HTTPHeaderName::SetCookie);
437     m_httpHeaderFields.commonHeaders().remove(HTTPHeaderName::SetCookie2);
438
439     switch (type) {
440     case SanitizationType::RemoveCookies:
441         return;
442     case SanitizationType::Redirection: {
443         auto commonHeaders = WTFMove(m_httpHeaderFields.commonHeaders());
444         for (auto& header : commonHeaders) {
445             if (isSafeRedirectionResponseHeader(header.key))
446                 m_httpHeaderFields.add(header.key, WTFMove(header.value));
447         }
448         m_httpHeaderFields.uncommonHeaders().clear();
449         return;
450     }
451     case SanitizationType::CrossOriginSafe:
452         sanitizeHTTPHeaderFieldsAccordingToTainting();
453     }
454 }
455
456 bool ResourceResponseBase::isHTTP09() const
457 {
458     lazyInit(AllFields);
459
460     return m_httpVersion.startsWith("HTTP/0.9");
461 }
462
463 String ResourceResponseBase::httpHeaderField(const String& name) const
464 {
465     lazyInit(CommonFieldsOnly);
466
467     // If we already have the header, just return it instead of consuming memory by grabing all headers.
468     String value = m_httpHeaderFields.get(name);
469     if (!value.isEmpty())        
470         return value;
471
472     lazyInit(AllFields);
473
474     return m_httpHeaderFields.get(name); 
475 }
476
477 String ResourceResponseBase::httpHeaderField(HTTPHeaderName name) const
478 {
479     lazyInit(CommonFieldsOnly);
480
481     // If we already have the header, just return it instead of consuming memory by grabing all headers.
482     String value = m_httpHeaderFields.get(name);
483     if (!value.isEmpty())
484         return value;
485
486     lazyInit(AllFields);
487
488     return m_httpHeaderFields.get(name); 
489 }
490
491 void ResourceResponseBase::updateHeaderParsedState(HTTPHeaderName name)
492 {
493     switch (name) {
494     case HTTPHeaderName::Age:
495         m_haveParsedAgeHeader = false;
496         break;
497
498     case HTTPHeaderName::CacheControl:
499     case HTTPHeaderName::Pragma:
500         m_haveParsedCacheControlHeader = false;
501         break;
502
503     case HTTPHeaderName::Date:
504         m_haveParsedDateHeader = false;
505         break;
506
507     case HTTPHeaderName::Expires:
508         m_haveParsedExpiresHeader = false;
509         break;
510
511     case HTTPHeaderName::LastModified:
512         m_haveParsedLastModifiedHeader = false;
513         break;
514
515     case HTTPHeaderName::ContentRange:
516         m_haveParsedContentRangeHeader = false;
517         break;
518
519     default:
520         break;
521     }
522 }
523
524 void ResourceResponseBase::setHTTPHeaderField(const String& name, const String& value)
525 {
526     lazyInit(AllFields);
527
528     HTTPHeaderName headerName;
529     if (findHTTPHeaderName(name, headerName))
530         updateHeaderParsedState(headerName);
531
532     m_httpHeaderFields.set(name, value);
533
534     // FIXME: Should invalidate or update platform response if present.
535 }
536
537 void ResourceResponseBase::setHTTPHeaderFields(HTTPHeaderMap&& headerFields)
538 {
539     lazyInit(AllFields);
540
541     m_httpHeaderFields = WTFMove(headerFields);
542 }
543
544 void ResourceResponseBase::setHTTPHeaderField(HTTPHeaderName name, const String& value)
545 {
546     lazyInit(AllFields);
547
548     updateHeaderParsedState(name);
549
550     m_httpHeaderFields.set(name, value);
551
552     // FIXME: Should invalidate or update platform response if present.
553 }
554
555 void ResourceResponseBase::addHTTPHeaderField(HTTPHeaderName name, const String& value)
556 {
557     lazyInit(AllFields);
558     updateHeaderParsedState(name);
559     m_httpHeaderFields.add(name, value);
560 }
561
562 void ResourceResponseBase::addHTTPHeaderField(const String& name, const String& value)
563 {
564     HTTPHeaderName headerName;
565     if (findHTTPHeaderName(name, headerName))
566         addHTTPHeaderField(headerName, value);
567     else {
568         lazyInit(AllFields);
569         m_httpHeaderFields.add(name, value);
570     }
571 }
572
573 const HTTPHeaderMap& ResourceResponseBase::httpHeaderFields() const
574 {
575     lazyInit(AllFields);
576
577     return m_httpHeaderFields;
578 }
579
580 void ResourceResponseBase::parseCacheControlDirectives() const
581 {
582     ASSERT(!m_haveParsedCacheControlHeader);
583
584     lazyInit(CommonFieldsOnly);
585
586     m_cacheControlDirectives = WebCore::parseCacheControlDirectives(m_httpHeaderFields);
587     m_haveParsedCacheControlHeader = true;
588 }
589     
590 bool ResourceResponseBase::cacheControlContainsNoCache() const
591 {
592     if (!m_haveParsedCacheControlHeader)
593         parseCacheControlDirectives();
594     return m_cacheControlDirectives.noCache;
595 }
596
597 bool ResourceResponseBase::cacheControlContainsNoStore() const
598 {
599     if (!m_haveParsedCacheControlHeader)
600         parseCacheControlDirectives();
601     return m_cacheControlDirectives.noStore;
602 }
603
604 bool ResourceResponseBase::cacheControlContainsMustRevalidate() const
605 {
606     if (!m_haveParsedCacheControlHeader)
607         parseCacheControlDirectives();
608     return m_cacheControlDirectives.mustRevalidate;
609 }
610     
611 bool ResourceResponseBase::cacheControlContainsImmutable() const
612 {
613     if (!m_haveParsedCacheControlHeader)
614         parseCacheControlDirectives();
615     return m_cacheControlDirectives.immutable;
616 }
617
618 bool ResourceResponseBase::hasCacheValidatorFields() const
619 {
620     lazyInit(CommonFieldsOnly);
621
622     return !m_httpHeaderFields.get(HTTPHeaderName::LastModified).isEmpty() || !m_httpHeaderFields.get(HTTPHeaderName::ETag).isEmpty();
623 }
624
625 std::optional<Seconds> ResourceResponseBase::cacheControlMaxAge() const
626 {
627     if (!m_haveParsedCacheControlHeader)
628         parseCacheControlDirectives();
629     return m_cacheControlDirectives.maxAge;
630 }
631
632 static std::optional<WallTime> parseDateValueInHeader(const HTTPHeaderMap& headers, HTTPHeaderName headerName)
633 {
634     String headerValue = headers.get(headerName);
635     if (headerValue.isEmpty())
636         return std::nullopt;
637     // This handles all date formats required by RFC2616:
638     // Sun, 06 Nov 1994 08:49:37 GMT  ; RFC 822, updated by RFC 1123
639     // Sunday, 06-Nov-94 08:49:37 GMT ; RFC 850, obsoleted by RFC 1036
640     // Sun Nov  6 08:49:37 1994       ; ANSI C's asctime() format
641     return parseHTTPDate(headerValue);
642 }
643
644 std::optional<WallTime> ResourceResponseBase::date() const
645 {
646     lazyInit(CommonFieldsOnly);
647
648     if (!m_haveParsedDateHeader) {
649         m_date = parseDateValueInHeader(m_httpHeaderFields, HTTPHeaderName::Date);
650         m_haveParsedDateHeader = true;
651     }
652     return m_date;
653 }
654
655 std::optional<Seconds> ResourceResponseBase::age() const
656 {
657     lazyInit(CommonFieldsOnly);
658
659     if (!m_haveParsedAgeHeader) {
660         String headerValue = m_httpHeaderFields.get(HTTPHeaderName::Age);
661         bool ok;
662         double ageDouble = headerValue.toDouble(&ok);
663         if (ok)
664             m_age = Seconds { ageDouble };
665         m_haveParsedAgeHeader = true;
666     }
667     return m_age;
668 }
669
670 std::optional<WallTime> ResourceResponseBase::expires() const
671 {
672     lazyInit(CommonFieldsOnly);
673
674     if (!m_haveParsedExpiresHeader) {
675         m_expires = parseDateValueInHeader(m_httpHeaderFields, HTTPHeaderName::Expires);
676         m_haveParsedExpiresHeader = true;
677     }
678     return m_expires;
679 }
680
681 std::optional<WallTime> ResourceResponseBase::lastModified() const
682 {
683     lazyInit(CommonFieldsOnly);
684
685     if (!m_haveParsedLastModifiedHeader) {
686         m_lastModified = parseDateValueInHeader(m_httpHeaderFields, HTTPHeaderName::LastModified);
687 #if PLATFORM(COCOA)
688         // CFNetwork converts malformed dates into Epoch so we need to treat Epoch as
689         // an invalid value (rdar://problem/22352838).
690         const WallTime epoch = WallTime::fromRawSeconds(0);
691         if (m_lastModified && m_lastModified.value() == epoch)
692             m_lastModified = std::nullopt;
693 #endif
694         m_haveParsedLastModifiedHeader = true;
695     }
696     return m_lastModified;
697 }
698
699 static ParsedContentRange parseContentRangeInHeader(const HTTPHeaderMap& headers)
700 {
701     String contentRangeValue = headers.get(HTTPHeaderName::ContentRange);
702     if (contentRangeValue.isEmpty())
703         return ParsedContentRange();
704
705     return ParsedContentRange(contentRangeValue);
706 }
707
708 ParsedContentRange& ResourceResponseBase::contentRange() const
709 {
710     lazyInit(CommonFieldsOnly);
711
712     if (!m_haveParsedContentRangeHeader) {
713         m_contentRange = parseContentRangeInHeader(m_httpHeaderFields);
714         m_haveParsedContentRangeHeader = true;
715     }
716
717     return m_contentRange;
718 }
719
720 bool ResourceResponseBase::isAttachment() const
721 {
722     lazyInit(AllFields);
723
724     auto value = m_httpHeaderFields.get(HTTPHeaderName::ContentDisposition);
725     return equalLettersIgnoringASCIICase(value.left(value.find(';')).stripWhiteSpace(), "attachment");
726 }
727
728 bool ResourceResponseBase::isAttachmentWithFilename() const
729 {
730     lazyInit(AllFields);
731
732     String contentDisposition = m_httpHeaderFields.get(HTTPHeaderName::ContentDisposition);
733     if (contentDisposition.isNull())
734         return false;
735
736     if (!equalLettersIgnoringASCIICase(contentDisposition.left(contentDisposition.find(';')).stripWhiteSpace(), "attachment"))
737         return false;
738
739     String filename = filenameFromHTTPContentDisposition(contentDisposition);
740     return !filename.isNull();
741 }
742
743 ResourceResponseBase::Source ResourceResponseBase::source() const
744 {
745     lazyInit(AllFields);
746
747     return m_source;
748 }
749
750 void ResourceResponseBase::lazyInit(InitLevel initLevel) const
751 {
752     const_cast<ResourceResponse*>(static_cast<const ResourceResponse*>(this))->platformLazyInit(initLevel);
753 }
754
755 bool ResourceResponseBase::compare(const ResourceResponse& a, const ResourceResponse& b)
756 {
757     if (a.isNull() != b.isNull())
758         return false;  
759     if (a.url() != b.url())
760         return false;
761     if (a.mimeType() != b.mimeType())
762         return false;
763     if (a.expectedContentLength() != b.expectedContentLength())
764         return false;
765     if (a.textEncodingName() != b.textEncodingName())
766         return false;
767     if (a.suggestedFilename() != b.suggestedFilename())
768         return false;
769     if (a.httpStatusCode() != b.httpStatusCode())
770         return false;
771     if (a.httpStatusText() != b.httpStatusText())
772         return false;
773     if (a.httpHeaderFields() != b.httpHeaderFields())
774         return false;
775     if (a.deprecatedNetworkLoadMetrics() != b.deprecatedNetworkLoadMetrics())
776         return false;
777     return ResourceResponse::platformCompare(a, b);
778 }
779
780 }