Cross-protocol, cross-site scripting (XPSS) using HTML forms
[WebKit-https.git] / Source / WebCore / platform / network / ResourceResponseBase.h
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 #ifndef ResourceResponseBase_h
28 #define ResourceResponseBase_h
29
30 #include "CacheValidation.h"
31 #include "CertificateInfo.h"
32 #include "HTTPHeaderMap.h"
33 #include "ResourceLoadTiming.h"
34 #include "URL.h"
35
36 #if OS(SOLARIS)
37 #include <sys/time.h> // For time_t structure.
38 #endif
39
40 namespace WebCore {
41
42 class ResourceResponse;
43 struct CrossThreadResourceResponseData;
44
45 // Do not use this class directly, use the class ResponseResponse instead
46 class ResourceResponseBase {
47     WTF_MAKE_FAST_ALLOCATED;
48 public:
49     static std::unique_ptr<ResourceResponse> adopt(std::unique_ptr<CrossThreadResourceResponseData>);
50
51     // Gets a copy of the data suitable for passing to another thread.
52     std::unique_ptr<CrossThreadResourceResponseData> copyData() const;
53
54     bool isNull() const { return m_isNull; }
55     WEBCORE_EXPORT bool isHTTP() const;
56
57     WEBCORE_EXPORT const URL& url() const;
58     WEBCORE_EXPORT void setURL(const URL&);
59
60     WEBCORE_EXPORT const String& mimeType() const;
61     WEBCORE_EXPORT void setMimeType(const String& mimeType);
62
63     WEBCORE_EXPORT long long expectedContentLength() const;
64     WEBCORE_EXPORT void setExpectedContentLength(long long expectedContentLength);
65
66     WEBCORE_EXPORT const String& textEncodingName() const;
67     WEBCORE_EXPORT void setTextEncodingName(const String& name);
68
69     WEBCORE_EXPORT int httpStatusCode() const;
70     WEBCORE_EXPORT void setHTTPStatusCode(int);
71     
72     WEBCORE_EXPORT const String& httpStatusText() const;
73     WEBCORE_EXPORT void setHTTPStatusText(const String&);
74
75     WEBCORE_EXPORT const String& httpVersion() const;
76     WEBCORE_EXPORT void setHTTPVersion(const String&);
77     bool isHttpVersion0_9() const;
78
79     WEBCORE_EXPORT const HTTPHeaderMap& httpHeaderFields() const;
80
81     String httpHeaderField(const String& name) const;
82     WEBCORE_EXPORT String httpHeaderField(HTTPHeaderName) const;
83     WEBCORE_EXPORT void setHTTPHeaderField(const String& name, const String& value);
84     void setHTTPHeaderField(HTTPHeaderName, const String& value);
85
86     void addHTTPHeaderField(const String& name, const String& value);
87
88     // Instead of passing a string literal to any of these functions, just use a HTTPHeaderName instead.
89     template<size_t length> String httpHeaderField(const char (&)[length]) const = delete;
90     template<size_t length> void setHTTPHeaderField(const char (&)[length], const String&) = delete;
91     template<size_t length> void addHTTPHeaderField(const char (&)[length], const String&) = delete;
92
93     bool isMultipart() const { return mimeType() == "multipart/x-mixed-replace"; }
94
95     WEBCORE_EXPORT bool isAttachment() const;
96     WEBCORE_EXPORT String suggestedFilename() const;
97
98     WEBCORE_EXPORT void includeCertificateInfo() const;
99     bool containsCertificateInfo() const { return m_includesCertificateInfo; }
100     WEBCORE_EXPORT CertificateInfo certificateInfo() const;
101     
102     // These functions return parsed values of the corresponding response headers.
103     // NaN means that the header was not present or had invalid value.
104     WEBCORE_EXPORT bool cacheControlContainsNoCache() const;
105     WEBCORE_EXPORT bool cacheControlContainsNoStore() const;
106     WEBCORE_EXPORT bool cacheControlContainsMustRevalidate() const;
107     WEBCORE_EXPORT bool hasCacheValidatorFields() const;
108     WEBCORE_EXPORT Optional<std::chrono::microseconds> cacheControlMaxAge() const;
109     WEBCORE_EXPORT Optional<std::chrono::system_clock::time_point> date() const;
110     WEBCORE_EXPORT Optional<std::chrono::microseconds> age() const;
111     WEBCORE_EXPORT Optional<std::chrono::system_clock::time_point> expires() const;
112     WEBCORE_EXPORT Optional<std::chrono::system_clock::time_point> lastModified() const;
113
114     // This is primarily for testing support. It is not necessarily accurate in all scenarios.
115     enum class Source { Unknown, Network, DiskCache, DiskCacheAfterValidation, MemoryCache, MemoryCacheAfterValidation };
116     WEBCORE_EXPORT Source source() const;
117     WEBCORE_EXPORT void setSource(Source);
118
119     ResourceLoadTiming& resourceLoadTiming() const { return m_resourceLoadTiming; }
120
121     // The ResourceResponse subclass may "shadow" this method to provide platform-specific memory usage information
122     unsigned memoryUsage() const
123     {
124         // average size, mostly due to URL and Header Map strings
125         return 1280;
126     }
127
128     static bool compare(const ResourceResponse&, const ResourceResponse&);
129
130     template<class Encoder> void encode(Encoder&) const;
131     template<class Decoder> static bool decode(Decoder&, ResourceResponseBase&);
132
133 protected:
134     enum InitLevel {
135         Uninitialized,
136         CommonFieldsOnly,
137         AllFields
138     };
139
140     WEBCORE_EXPORT ResourceResponseBase();
141     WEBCORE_EXPORT ResourceResponseBase(const URL&, const String& mimeType, long long expectedLength, const String& textEncodingName);
142
143     WEBCORE_EXPORT void lazyInit(InitLevel) const;
144
145     // The ResourceResponse subclass should shadow these functions to lazily initialize platform specific fields
146     void platformLazyInit(InitLevel) { }
147     CertificateInfo platformCertificateInfo() const { return CertificateInfo(); };
148     String platformSuggestedFileName() const { return String(); }
149
150     static bool platformCompare(const ResourceResponse&, const ResourceResponse&) { return true; }
151
152 private:
153     const ResourceResponse& asResourceResponse() const;
154     void parseCacheControlDirectives() const;
155     void updateHeaderParsedState(HTTPHeaderName);
156
157 protected:
158     bool m_isNull;
159     URL m_url;
160     AtomicString m_mimeType;
161     long long m_expectedContentLength;
162     AtomicString m_textEncodingName;
163     AtomicString m_httpStatusText;
164     AtomicString m_httpVersion;
165     HTTPHeaderMap m_httpHeaderFields;
166     mutable ResourceLoadTiming m_resourceLoadTiming;
167
168     mutable bool m_includesCertificateInfo;
169     mutable CertificateInfo m_certificateInfo;
170
171     int m_httpStatusCode;
172
173 private:
174     mutable Optional<std::chrono::microseconds> m_age;
175     mutable Optional<std::chrono::system_clock::time_point> m_date;
176     mutable Optional<std::chrono::system_clock::time_point> m_expires;
177     mutable Optional<std::chrono::system_clock::time_point> m_lastModified;
178     mutable CacheControlDirectives m_cacheControlDirectives;
179
180     mutable bool m_haveParsedCacheControlHeader { false };
181     mutable bool m_haveParsedAgeHeader { false };
182     mutable bool m_haveParsedDateHeader { false };
183     mutable bool m_haveParsedExpiresHeader { false };
184     mutable bool m_haveParsedLastModifiedHeader { false };
185
186     Source m_source { Source::Unknown };
187 };
188
189 inline bool operator==(const ResourceResponse& a, const ResourceResponse& b) { return ResourceResponseBase::compare(a, b); }
190 inline bool operator!=(const ResourceResponse& a, const ResourceResponse& b) { return !(a == b); }
191
192 template<class Encoder>
193 void ResourceResponseBase::encode(Encoder& encoder) const
194 {
195     encoder << m_isNull;
196     if (m_isNull)
197         return;
198     lazyInit(AllFields);
199
200     encoder << m_url.string();
201     encoder << m_mimeType;
202     encoder << static_cast<int64_t>(m_expectedContentLength);
203     encoder << m_textEncodingName;
204     encoder << m_httpStatusText;
205     encoder << m_httpVersion;
206     encoder << m_httpHeaderFields;
207     encoder << m_resourceLoadTiming;
208     encoder << m_httpStatusCode;
209     encoder << m_includesCertificateInfo;
210     if (m_includesCertificateInfo)
211         encoder << m_certificateInfo;
212     encoder.encodeEnum(m_source);
213 }
214
215 template<class Decoder>
216 bool ResourceResponseBase::decode(Decoder& decoder, ResourceResponseBase& response)
217 {
218     ASSERT(response.m_isNull);
219     bool responseIsNull;
220     if (!decoder.decode(responseIsNull))
221         return false;
222     if (responseIsNull)
223         return true;
224
225     String url;
226     if (!decoder.decode(url))
227         return false;
228     response.m_url = URL(URL(), url);
229     if (!decoder.decode(response.m_mimeType))
230         return false;
231     int64_t expectedContentLength;
232     if (!decoder.decode(expectedContentLength))
233         return false;
234     response.m_expectedContentLength = expectedContentLength;
235     if (!decoder.decode(response.m_textEncodingName))
236         return false;
237     if (!decoder.decode(response.m_httpStatusText))
238         return false;
239     if (!decoder.decode(response.m_httpVersion))
240         return false;
241     if (!decoder.decode(response.m_httpHeaderFields))
242         return false;
243     if (!decoder.decode(response.m_resourceLoadTiming))
244         return false;
245     if (!decoder.decode(response.m_httpStatusCode))
246         return false;
247     if (!decoder.decode(response.m_includesCertificateInfo))
248         return false;
249     if (response.m_includesCertificateInfo) {
250         if (!decoder.decode(response.m_certificateInfo))
251             return false;
252     }
253     if (!decoder.decodeEnum(response.m_source))
254         return false;
255     response.m_isNull = false;
256
257     return true;
258 }
259
260 struct CrossThreadResourceResponseDataBase {
261     WTF_MAKE_NONCOPYABLE(CrossThreadResourceResponseDataBase); WTF_MAKE_FAST_ALLOCATED;
262 public:
263     CrossThreadResourceResponseDataBase() { }
264     URL m_url;
265     String m_mimeType;
266     long long m_expectedContentLength;
267     String m_textEncodingName;
268     int m_httpStatusCode;
269     String m_httpStatusText;
270     String m_httpVersion;
271     std::unique_ptr<CrossThreadHTTPHeaderMapData> m_httpHeaders;
272     ResourceLoadTiming m_resourceLoadTiming;
273 };
274
275 } // namespace WebCore
276
277 #endif // ResourceResponseBase_h