0e7d80cbf85eb1dacfcddf5523a71830647c671d
[WebKit-https.git] / Source / WebKit / NetworkProcess / NetworkResourceLoadParameters.cpp
1 /*
2  * Copyright (C) 2012 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 "NetworkResourceLoadParameters.h"
28
29 #include "ArgumentCoders.h"
30 #include "DataReference.h"
31 #include "WebCoreArgumentCoders.h"
32 #include <WebCore/SecurityOriginData.h>
33
34 using namespace WebCore;
35
36 namespace WebKit {
37
38 void NetworkResourceLoadParameters::encode(IPC::Encoder& encoder) const
39 {
40     encoder << identifier;
41     encoder << webPageID;
42     encoder << webFrameID;
43     encoder << sessionID;
44     encoder << request;
45
46     encoder << static_cast<bool>(request.httpBody());
47     if (request.httpBody()) {
48         request.httpBody()->encode(encoder);
49
50         const Vector<FormDataElement>& elements = request.httpBody()->elements();
51         size_t fileCount = 0;
52         for (size_t i = 0, count = elements.size(); i < count; ++i) {
53             if (elements[i].m_type == FormDataElement::Type::EncodedFile)
54                 ++fileCount;
55         }
56
57         SandboxExtension::HandleArray requestBodySandboxExtensions;
58         requestBodySandboxExtensions.allocate(fileCount);
59         size_t extensionIndex = 0;
60         for (size_t i = 0, count = elements.size(); i < count; ++i) {
61             const FormDataElement& element = elements[i];
62             if (element.m_type == FormDataElement::Type::EncodedFile) {
63                 const String& path = element.m_shouldGenerateFile ? element.m_generatedFilename : element.m_filename;
64                 SandboxExtension::createHandle(path, SandboxExtension::Type::ReadOnly, requestBodySandboxExtensions[extensionIndex++]);
65             }
66         }
67         encoder << requestBodySandboxExtensions;
68     }
69
70     if (request.url().isLocalFile()) {
71         SandboxExtension::Handle requestSandboxExtension;
72         SandboxExtension::createHandle(request.url().fileSystemPath(), SandboxExtension::Type::ReadOnly, requestSandboxExtension);
73         encoder << requestSandboxExtension;
74     }
75
76     encoder.encodeEnum(contentSniffingPolicy);
77     encoder.encodeEnum(contentEncodingSniffingPolicy);
78     encoder.encodeEnum(storedCredentialsPolicy);
79     encoder.encodeEnum(clientCredentialPolicy);
80     encoder.encodeEnum(shouldPreconnectOnly);
81     encoder << shouldFollowRedirects;
82     encoder << shouldClearReferrerOnHTTPSToHTTPRedirect;
83     encoder << defersLoading;
84     encoder << needsCertificateInfo;
85     encoder << maximumBufferingTime;
86     encoder << derivedCachedDataTypesToRetrieve;
87
88     encoder << static_cast<bool>(sourceOrigin);
89     if (sourceOrigin)
90         encoder << SecurityOriginData::fromSecurityOrigin(*sourceOrigin);
91     encoder.encodeEnum(mode);
92     encoder << cspResponseHeaders;
93
94 #if ENABLE(CONTENT_EXTENSIONS)
95     encoder << mainDocumentURL;
96     encoder << contentRuleLists;
97 #endif
98 }
99
100 bool NetworkResourceLoadParameters::decode(IPC::Decoder& decoder, NetworkResourceLoadParameters& result)
101 {
102     if (!decoder.decode(result.identifier))
103         return false;
104
105     if (!decoder.decode(result.webPageID))
106         return false;
107
108     if (!decoder.decode(result.webFrameID))
109         return false;
110
111     if (!decoder.decode(result.sessionID))
112         return false;
113
114     if (!decoder.decode(result.request))
115         return false;
116
117     bool hasHTTPBody;
118     if (!decoder.decode(hasHTTPBody))
119         return false;
120
121     if (hasHTTPBody) {
122         RefPtr<FormData> formData = FormData::decode(decoder);
123         if (!formData)
124             return false;
125         result.request.setHTTPBody(WTFMove(formData));
126
127         SandboxExtension::HandleArray requestBodySandboxExtensionHandles;
128         if (!decoder.decode(requestBodySandboxExtensionHandles))
129             return false;
130         for (size_t i = 0; i < requestBodySandboxExtensionHandles.size(); ++i) {
131             if (auto extension = SandboxExtension::create(WTFMove(requestBodySandboxExtensionHandles[i])))
132                 result.requestBodySandboxExtensions.append(WTFMove(extension));
133         }
134     }
135
136     if (result.request.url().isLocalFile()) {
137         std::optional<SandboxExtension::Handle> resourceSandboxExtensionHandle;
138         decoder >> resourceSandboxExtensionHandle;
139         if (!resourceSandboxExtensionHandle)
140             return false;
141         result.resourceSandboxExtension = SandboxExtension::create(WTFMove(*resourceSandboxExtensionHandle));
142     }
143
144     if (!decoder.decodeEnum(result.contentSniffingPolicy))
145         return false;
146     if (!decoder.decodeEnum(result.contentEncodingSniffingPolicy))
147         return false;
148     if (!decoder.decodeEnum(result.storedCredentialsPolicy))
149         return false;
150     if (!decoder.decodeEnum(result.clientCredentialPolicy))
151         return false;
152     if (!decoder.decodeEnum(result.shouldPreconnectOnly))
153         return false;
154     if (!decoder.decode(result.shouldFollowRedirects))
155         return false;
156     if (!decoder.decode(result.shouldClearReferrerOnHTTPSToHTTPRedirect))
157         return false;
158     if (!decoder.decode(result.defersLoading))
159         return false;
160     if (!decoder.decode(result.needsCertificateInfo))
161         return false;
162     if (!decoder.decode(result.maximumBufferingTime))
163         return false;
164     if (!decoder.decode(result.derivedCachedDataTypesToRetrieve))
165         return false;
166
167     bool hasSourceOrigin;
168     if (!decoder.decode(hasSourceOrigin))
169         return false;
170     if (hasSourceOrigin) {
171         std::optional<SecurityOriginData> sourceOriginData;
172         decoder >> sourceOriginData;
173         if (!sourceOriginData)
174             return false;
175         ASSERT(!sourceOriginData->isEmpty());
176         result.sourceOrigin = sourceOriginData->securityOrigin();
177     }
178     if (!decoder.decodeEnum(result.mode))
179         return false;
180     if (!decoder.decode(result.cspResponseHeaders))
181         return false;
182
183 #if ENABLE(CONTENT_EXTENSIONS)
184     if (!decoder.decode(result.mainDocumentURL))
185         return false;
186
187     std::optional<Vector<std::pair<String, WebCompiledContentRuleListData>>> contentRuleLists;
188     decoder >> contentRuleLists;
189     if (!contentRuleLists)
190         return false;
191     result.contentRuleLists = WTFMove(*contentRuleLists);
192 #endif
193
194     return true;
195 }
196     
197 } // namespace WebKit