d3ca9cb52d541088365e7861650f0f9955e60bd6
[WebKit.git] / Source / WebKit / NetworkProcess / NetworkResourceLoader.cpp
1 /*
2  * Copyright (C) 2012-2018 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 "NetworkResourceLoader.h"
28
29 #include "DataReference.h"
30 #include "Logging.h"
31 #include "NetworkBlobRegistry.h"
32 #include "NetworkCache.h"
33 #include "NetworkConnectionToWebProcess.h"
34 #include "NetworkLoad.h"
35 #include "NetworkProcess.h"
36 #include "NetworkProcessConnectionMessages.h"
37 #include "SessionTracker.h"
38 #include "WebCoreArgumentCoders.h"
39 #include "WebErrors.h"
40 #include "WebResourceLoaderMessages.h"
41 #include "WebsiteDataStoreParameters.h"
42 #include <WebCore/BlobDataFileReference.h>
43 #include <WebCore/CertificateInfo.h>
44 #include <WebCore/DiagnosticLoggingKeys.h>
45 #include <WebCore/HTTPHeaderNames.h>
46 #include <WebCore/NetworkLoadMetrics.h>
47 #include <WebCore/ProtectionSpace.h>
48 #include <WebCore/SharedBuffer.h>
49 #include <WebCore/SynchronousLoaderClient.h>
50 #include <wtf/RunLoop.h>
51
52 #if HAVE(CFNETWORK_STORAGE_PARTITIONING) && !RELEASE_LOG_DISABLED
53 #include <WebCore/NetworkStorageSession.h>
54 #include <WebCore/PlatformCookieJar.h>
55 #endif
56
57 using namespace WebCore;
58
59 #define RELEASE_LOG_IF_ALLOWED(fmt, ...) RELEASE_LOG_IF(isAlwaysOnLoggingAllowed(), Network, "%p - NetworkResourceLoader::" fmt, this, ##__VA_ARGS__)
60 #define RELEASE_LOG_ERROR_IF_ALLOWED(fmt, ...) RELEASE_LOG_ERROR_IF(isAlwaysOnLoggingAllowed(), Network, "%p - NetworkResourceLoader::" fmt, this, ##__VA_ARGS__)
61
62 namespace WebKit {
63
64 struct NetworkResourceLoader::SynchronousLoadData {
65     SynchronousLoadData(RefPtr<Messages::NetworkConnectionToWebProcess::PerformSynchronousLoad::DelayedReply>&& reply)
66         : delayedReply(WTFMove(reply))
67     {
68         ASSERT(delayedReply);
69     }
70     ResourceRequest currentRequest;
71     RefPtr<Messages::NetworkConnectionToWebProcess::PerformSynchronousLoad::DelayedReply> delayedReply;
72     ResourceResponse response;
73     ResourceError error;
74 };
75
76 static void sendReplyToSynchronousRequest(NetworkResourceLoader::SynchronousLoadData& data, const SharedBuffer* buffer)
77 {
78     ASSERT(data.delayedReply);
79     ASSERT(!data.response.isNull() || !data.error.isNull());
80
81     Vector<char> responseBuffer;
82     if (buffer && buffer->size())
83         responseBuffer.append(buffer->data(), buffer->size());
84
85     data.delayedReply->send(data.error, data.response, responseBuffer);
86     data.delayedReply = nullptr;
87 }
88
89 NetworkResourceLoader::NetworkResourceLoader(const NetworkResourceLoadParameters& parameters, NetworkConnectionToWebProcess& connection, RefPtr<Messages::NetworkConnectionToWebProcess::PerformSynchronousLoad::DelayedReply>&& synchronousReply)
90     : m_parameters { parameters }
91     , m_connection { connection }
92     , m_defersLoading { parameters.defersLoading }
93     , m_isAllowedToAskUserForCredentials { parameters.clientCredentialPolicy == ClientCredentialPolicy::MayAskClientForCredentials }
94     , m_bufferingTimer { *this, &NetworkResourceLoader::bufferingTimerFired }
95     , m_cache { sessionID().isEphemeral() ? nullptr : NetworkProcess::singleton().cache() }
96 {
97     ASSERT(RunLoop::isMain());
98     // FIXME: This is necessary because of the existence of EmptyFrameLoaderClient in WebCore.
99     //        Once bug 116233 is resolved, this ASSERT can just be "m_webPageID && m_webFrameID"
100     ASSERT((m_parameters.webPageID && m_parameters.webFrameID) || m_parameters.clientCredentialPolicy == ClientCredentialPolicy::CannotAskClientForCredentials);
101
102     if (originalRequest().httpBody()) {
103         for (const auto& element : originalRequest().httpBody()->elements()) {
104             if (element.m_type == FormDataElement::Type::EncodedBlob)
105                 m_fileReferences.appendVector(NetworkBlobRegistry::singleton().filesInBlob(connection, element.m_url));
106         }
107     }
108
109     if (synchronousReply)
110         m_synchronousLoadData = std::make_unique<SynchronousLoadData>(WTFMove(synchronousReply));
111 }
112
113 NetworkResourceLoader::~NetworkResourceLoader()
114 {
115     ASSERT(RunLoop::isMain());
116     ASSERT(!m_networkLoad);
117     ASSERT(!isSynchronous() || !m_synchronousLoadData->delayedReply);
118 }
119
120 bool NetworkResourceLoader::canUseCache(const ResourceRequest& request) const
121 {
122     if (!m_cache)
123         return false;
124     ASSERT(!sessionID().isEphemeral());
125
126     if (!request.url().protocolIsInHTTPFamily())
127         return false;
128     if (originalRequest().cachePolicy() == WebCore::DoNotUseAnyCache)
129         return false;
130
131     return true;
132 }
133
134 bool NetworkResourceLoader::canUseCachedRedirect(const ResourceRequest& request) const
135 {
136     if (!canUseCache(request))
137         return false;
138     // Limit cached redirects to avoid cycles and other trouble.
139     // Networking layer follows over 30 redirects but caching that many seems unnecessary.
140     static const unsigned maximumCachedRedirectCount { 5 };
141     if (m_redirectCount > maximumCachedRedirectCount)
142         return false;
143
144     return true;
145 }
146
147 bool NetworkResourceLoader::isSynchronous() const
148 {
149     return !!m_synchronousLoadData;
150 }
151
152 void NetworkResourceLoader::start()
153 {
154     ASSERT(RunLoop::isMain());
155
156     if (m_defersLoading) {
157         RELEASE_LOG_IF_ALLOWED("start: Loading is deferred (pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ", isMainResource = %d, isSynchronous = %d)", m_parameters.webPageID, m_parameters.webFrameID, m_parameters.identifier, isMainResource(), isSynchronous());
158         return;
159     }
160
161     ASSERT(!m_wasStarted);
162     m_wasStarted = true;
163
164     if (canUseCache(originalRequest())) {
165         RELEASE_LOG_IF_ALLOWED("start: Checking cache for resource (pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ", isMainResource = %d, isSynchronous = %d)", m_parameters.webPageID, m_parameters.webFrameID, m_parameters.identifier, isMainResource(), isSynchronous());
166         retrieveCacheEntry(originalRequest());
167         return;
168     }
169
170     startNetworkLoad(originalRequest());
171 }
172
173 void NetworkResourceLoader::retrieveCacheEntry(const ResourceRequest& request)
174 {
175     ASSERT(canUseCache(request));
176
177     RefPtr<NetworkResourceLoader> loader(this);
178     m_cache->retrieve(request, { m_parameters.webPageID, m_parameters.webFrameID }, [this, loader = WTFMove(loader), request](auto entry) {
179 #if RELEASE_LOG_DISABLED
180         UNUSED_PARAM(this);
181 #endif
182         if (loader->hasOneRef()) {
183             // The loader has been aborted and is only held alive by this lambda.
184             return;
185         }
186         if (!entry) {
187             RELEASE_LOG_IF_ALLOWED("retrieveCacheEntry: Resource not in cache (pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ", isMainResource = %d, isSynchronous = %d)", m_parameters.webPageID, m_parameters.webFrameID, m_parameters.identifier, isMainResource(), isSynchronous());
188             loader->startNetworkLoad(request);
189             return;
190         }
191         if (entry->redirectRequest()) {
192             RELEASE_LOG_IF_ALLOWED("retrieveCacheEntry: Handling redirect (pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ", isMainResource = %d, isSynchronous = %d)", m_parameters.webPageID, m_parameters.webFrameID, m_parameters.identifier, isMainResource(), isSynchronous());
193             loader->dispatchWillSendRequestForCacheEntry(WTFMove(entry));
194             return;
195         }
196         if (loader->m_parameters.needsCertificateInfo && !entry->response().certificateInfo()) {
197             RELEASE_LOG_IF_ALLOWED("retrieveCacheEntry: Resource does not have required certificate (pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ", isMainResource = %d, isSynchronous = %d)", m_parameters.webPageID, m_parameters.webFrameID, m_parameters.identifier, isMainResource(), isSynchronous());
198             loader->startNetworkLoad(request);
199             return;
200         }
201         if (entry->needsValidation() || request.cachePolicy() == WebCore::RefreshAnyCacheData) {
202             RELEASE_LOG_IF_ALLOWED("retrieveCacheEntry: Validating cache entry (pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ", isMainResource = %d, isSynchronous = %d)", m_parameters.webPageID, m_parameters.webFrameID, m_parameters.identifier, isMainResource(), isSynchronous());
203             loader->validateCacheEntry(WTFMove(entry));
204             return;
205         }
206         RELEASE_LOG_IF_ALLOWED("retrieveCacheEntry: Retrieved resource from cache (pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ", isMainResource = %d, isSynchronous = %d)", m_parameters.webPageID, m_parameters.webFrameID, m_parameters.identifier, isMainResource(), isSynchronous());
207         loader->didRetrieveCacheEntry(WTFMove(entry));
208     });
209 }
210
211 void NetworkResourceLoader::startNetworkLoad(const ResourceRequest& request)
212 {
213     RELEASE_LOG_IF_ALLOWED("startNetworkLoad: (pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ", isMainResource = %d, isSynchronous = %d)", m_parameters.webPageID, m_parameters.webFrameID, m_parameters.identifier, isMainResource(), isSynchronous());
214
215     consumeSandboxExtensions();
216
217     if (isSynchronous() || m_parameters.maximumBufferingTime > 0_s)
218         m_bufferedData = SharedBuffer::create();
219
220     if (canUseCache(request))
221         m_bufferedDataForCache = SharedBuffer::create();
222
223     NetworkLoadParameters parameters = m_parameters;
224     parameters.defersLoading = m_defersLoading;
225     parameters.request = request;
226
227     if (request.url().protocolIsBlob())
228         parameters.blobFileReferences = NetworkBlobRegistry::singleton().filesInBlob(m_connection, originalRequest().url());
229
230     auto* networkSession = SessionTracker::networkSession(parameters.sessionID);
231     if (!networkSession && parameters.sessionID.isEphemeral()) {
232         NetworkProcess::singleton().addWebsiteDataStore(WebsiteDataStoreParameters::privateSessionParameters(parameters.sessionID));
233         networkSession = SessionTracker::networkSession(parameters.sessionID);
234     }
235     if (!networkSession) {
236         WTFLogAlways("Attempted to create a NetworkLoad with a session (id=%" PRIu64 ") that does not exist.", parameters.sessionID.sessionID());
237         RELEASE_LOG_ERROR_IF_ALLOWED("startNetworkLoad: Attempted to create a NetworkLoad with a session that does not exist (pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ", sessionID=%" PRIu64 ")", m_parameters.webPageID, m_parameters.webFrameID, m_parameters.identifier, parameters.sessionID.sessionID());
238         NetworkProcess::singleton().logDiagnosticMessage(m_parameters.webPageID, WebCore::DiagnosticLoggingKeys::internalErrorKey(), WebCore::DiagnosticLoggingKeys::invalidSessionIDKey(), WebCore::ShouldSample::No);
239         didFailLoading(internalError(request.url()));
240         return;
241     }
242     m_networkLoad = std::make_unique<NetworkLoad>(*this, WTFMove(parameters), *networkSession);
243
244     if (m_defersLoading) {
245         RELEASE_LOG_IF_ALLOWED("startNetworkLoad: Created, but deferred (pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ")",
246             m_parameters.webPageID, m_parameters.webFrameID, m_parameters.identifier);
247     }
248 }
249
250 void NetworkResourceLoader::setDefersLoading(bool defers)
251 {
252     if (m_defersLoading == defers)
253         return;
254     m_defersLoading = defers;
255
256     if (defers)
257         RELEASE_LOG_IF_ALLOWED("setDefersLoading: Deferring resource load (pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ")", m_parameters.webPageID, m_parameters.webFrameID, m_parameters.identifier);
258     else
259         RELEASE_LOG_IF_ALLOWED("setDefersLoading: Resuming deferred resource load (pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ")", m_parameters.webPageID, m_parameters.webFrameID, m_parameters.identifier);
260
261     if (m_networkLoad) {
262         m_networkLoad->setDefersLoading(defers);
263         return;
264     }
265
266     if (!m_defersLoading && !m_wasStarted)
267         start();
268     else
269         RELEASE_LOG_IF_ALLOWED("setDefersLoading: defers = %d, but nothing to do (pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ")", m_defersLoading, m_parameters.webPageID, m_parameters.webFrameID, m_parameters.identifier);
270 }
271
272 void NetworkResourceLoader::cleanup()
273 {
274     ASSERT(RunLoop::isMain());
275
276     m_bufferingTimer.stop();
277
278     invalidateSandboxExtensions();
279
280     m_networkLoad = nullptr;
281
282     // This will cause NetworkResourceLoader to be destroyed and therefore we do it last.
283     m_connection->didCleanupResourceLoader(*this);
284 }
285
286 void NetworkResourceLoader::convertToDownload(DownloadID downloadID, const ResourceRequest& request, const ResourceResponse& response)
287 {
288     ASSERT(m_networkLoad);
289     NetworkProcess::singleton().downloadManager().convertNetworkLoadToDownload(downloadID, std::exchange(m_networkLoad, nullptr), WTFMove(m_fileReferences), request, response);
290 }
291
292 void NetworkResourceLoader::abort()
293 {
294     ASSERT(RunLoop::isMain());
295
296     RELEASE_LOG_IF_ALLOWED("abort: Canceling resource load (pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ")",
297         m_parameters.webPageID, m_parameters.webFrameID, m_parameters.identifier);
298
299     if (m_networkLoad) {
300         if (canUseCache(m_networkLoad->currentRequest())) {
301             // We might already have used data from this incomplete load. Ensure older versions don't remain in the cache after cancel.
302             if (!m_response.isNull())
303                 m_cache->remove(m_networkLoad->currentRequest());
304         }
305         m_networkLoad->cancel();
306     }
307
308     cleanup();
309 }
310
311 auto NetworkResourceLoader::didReceiveResponse(ResourceResponse&& receivedResponse) -> ShouldContinueDidReceiveResponse
312 {
313     RELEASE_LOG_IF_ALLOWED("didReceiveResponse: (pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ", httpStatusCode = %d, length = %" PRId64 ")", m_parameters.webPageID, m_parameters.webFrameID, m_parameters.identifier, receivedResponse.httpStatusCode(), receivedResponse.expectedContentLength());
314
315     m_response = WTFMove(receivedResponse);
316
317     // For multipart/x-mixed-replace didReceiveResponseAsync gets called multiple times and buffering would require special handling.
318     if (!isSynchronous() && m_response.isMultipart())
319         m_bufferedData = nullptr;
320
321     if (m_response.isMultipart())
322         m_bufferedDataForCache = nullptr;
323
324     if (m_cacheEntryForValidation) {
325         bool validationSucceeded = m_response.httpStatusCode() == 304; // 304 Not Modified
326         if (validationSucceeded) {
327             m_cacheEntryForValidation = m_cache->update(originalRequest(), { m_parameters.webPageID, m_parameters.webFrameID }, *m_cacheEntryForValidation, m_response);
328             // If the request was conditional then this revalidation was not triggered by the network cache and we pass the 304 response to WebCore.
329             if (originalRequest().isConditional())
330                 m_cacheEntryForValidation = nullptr;
331         } else
332             m_cacheEntryForValidation = nullptr;
333     }
334     bool shouldSendDidReceiveResponse = !m_cacheEntryForValidation;
335
336     bool shouldWaitContinueDidReceiveResponse = isMainResource();
337     if (shouldSendDidReceiveResponse) {
338         if (isSynchronous())
339             m_synchronousLoadData->response = m_response;
340         else
341             send(Messages::WebResourceLoader::DidReceiveResponse(m_response, shouldWaitContinueDidReceiveResponse));
342     }
343
344     // For main resources, the web process is responsible for sending back a NetworkResourceLoader::ContinueDidReceiveResponse message.
345     bool shouldContinueDidReceiveResponse = !shouldWaitContinueDidReceiveResponse || m_cacheEntryForValidation;
346
347     if (shouldContinueDidReceiveResponse) {
348         RELEASE_LOG_IF_ALLOWED("didReceiveResponse: Should not wait for message from WebContent process before continuing resource load (pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ")", m_parameters.webPageID, m_parameters.webFrameID, m_parameters.identifier);
349         return ShouldContinueDidReceiveResponse::Yes;
350     }
351
352     RELEASE_LOG_IF_ALLOWED("didReceiveResponse: Should wait for message from WebContent process before continuing resource load (pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ")", m_parameters.webPageID, m_parameters.webFrameID, m_parameters.identifier);
353     return ShouldContinueDidReceiveResponse::No;
354 }
355
356 void NetworkResourceLoader::didReceiveBuffer(Ref<SharedBuffer>&& buffer, int reportedEncodedDataLength)
357 {
358     if (!m_numBytesReceived) {
359         RELEASE_LOG_IF_ALLOWED("didReceiveBuffer: Started receiving data (pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ")", m_parameters.webPageID, m_parameters.webFrameID, m_parameters.identifier);
360     }
361     m_numBytesReceived += buffer->size();
362
363     ASSERT(!m_cacheEntryForValidation);
364
365     if (m_bufferedDataForCache) {
366         // Prevent memory growth in case of streaming data.
367         const size_t maximumCacheBufferSize = 10 * 1024 * 1024;
368         if (m_bufferedDataForCache->size() + buffer->size() <= maximumCacheBufferSize)
369             m_bufferedDataForCache->append(buffer.get());
370         else
371             m_bufferedDataForCache = nullptr;
372     }
373     // FIXME: At least on OS X Yosemite we always get -1 from the resource handle.
374     unsigned encodedDataLength = reportedEncodedDataLength >= 0 ? reportedEncodedDataLength : buffer->size();
375
376     m_bytesReceived += buffer->size();
377     if (m_bufferedData) {
378         m_bufferedData->append(buffer.get());
379         m_bufferedDataEncodedDataLength += encodedDataLength;
380         startBufferingTimerIfNeeded();
381         return;
382     }
383     sendBuffer(buffer, encodedDataLength);
384 }
385
386 void NetworkResourceLoader::didFinishLoading(const NetworkLoadMetrics& networkLoadMetrics)
387 {
388     RELEASE_LOG_IF_ALLOWED("didFinishLoading: (pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ", length = %zd)", m_parameters.webPageID, m_parameters.webFrameID, m_parameters.identifier, m_numBytesReceived);
389
390     if (m_cacheEntryForValidation) {
391         // 304 Not Modified
392         ASSERT(m_response.httpStatusCode() == 304);
393         LOG(NetworkCache, "(NetworkProcess) revalidated");
394         didRetrieveCacheEntry(WTFMove(m_cacheEntryForValidation));
395         return;
396     }
397
398 #if HAVE(CFNETWORK_STORAGE_PARTITIONING) && !RELEASE_LOG_DISABLED
399     if (shouldLogCookieInformation())
400         logCookieInformation();
401 #endif
402
403     if (isSynchronous())
404         sendReplyToSynchronousRequest(*m_synchronousLoadData, m_bufferedData.get());
405     else {
406         if (m_bufferedData && !m_bufferedData->isEmpty()) {
407             // FIXME: Pass a real value or remove the encoded data size feature.
408             sendBuffer(*m_bufferedData, -1);
409         }
410         send(Messages::WebResourceLoader::DidFinishResourceLoad(networkLoadMetrics));
411     }
412
413     tryStoreAsCacheEntry();
414
415     cleanup();
416 }
417
418 void NetworkResourceLoader::didFailLoading(const ResourceError& error)
419 {
420     RELEASE_LOG_IF_ALLOWED("didFailLoading: (pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ", isTimeout = %d, isCancellation = %d, errCode = %d)", m_parameters.webPageID, m_parameters.webFrameID, m_parameters.identifier, error.isTimeout(), error.isCancellation(), error.errorCode());
421
422     ASSERT(!error.isNull());
423
424     m_cacheEntryForValidation = nullptr;
425
426     if (isSynchronous()) {
427         m_synchronousLoadData->error = error;
428         sendReplyToSynchronousRequest(*m_synchronousLoadData, nullptr);
429     } else if (auto* connection = messageSenderConnection())
430         connection->send(Messages::WebResourceLoader::DidFailResourceLoad(error), messageSenderDestinationID());
431
432     cleanup();
433 }
434
435 void NetworkResourceLoader::didBlockAuthenticationChallenge()
436 {
437     send(Messages::WebResourceLoader::DidBlockAuthenticationChallenge());
438 }
439
440 void NetworkResourceLoader::willSendRedirectedRequest(ResourceRequest&& request, WebCore::ResourceRequest&& redirectRequest, ResourceResponse&& redirectResponse)
441 {
442     ++m_redirectCount;
443
444     if (isSynchronous()) {
445         ResourceRequest overridenRequest = redirectRequest;
446         // FIXME: This needs to be fixed to follow the redirect correctly even for cross-domain requests.
447         // This includes at least updating host records, and comparing the current request instead of the original request here.
448         if (!protocolHostAndPortAreEqual(originalRequest().url(), redirectRequest.url())) {
449             ASSERT(m_synchronousLoadData->error.isNull());
450             m_synchronousLoadData->error = SynchronousLoaderClient::platformBadResponseError();
451             m_networkLoad->clearCurrentRequest();
452             overridenRequest = ResourceRequest();
453         }
454         // We do not support prompting for credentials for synchronous loads. If we ever change this policy then
455         // we need to take care to prompt if and only if request and redirectRequest are not mixed content.
456         continueWillSendRequest(WTFMove(overridenRequest), false);
457         return;
458     }
459     if (canUseCachedRedirect(request))
460         m_cache->storeRedirect(request, redirectResponse, redirectRequest);
461
462     send(Messages::WebResourceLoader::WillSendRequest(redirectRequest, sanitizeRedirectResponseIfPossible(WTFMove(redirectResponse))));
463 }
464
465 ResourceResponse NetworkResourceLoader::sanitizeRedirectResponseIfPossible(ResourceResponse&& response)
466 {
467     if (m_parameters.shouldRestrictHTTPResponseAccess)
468         response.sanitizeRedirectionHTTPHeaderFields();
469     return WTFMove(response);
470 }
471
472 void NetworkResourceLoader::continueWillSendRequest(ResourceRequest&& newRequest, bool isAllowedToAskUserForCredentials)
473 {
474     RELEASE_LOG_IF_ALLOWED("continueWillSendRequest: (pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ")", m_parameters.webPageID, m_parameters.webFrameID, m_parameters.identifier);
475
476     m_isAllowedToAskUserForCredentials = isAllowedToAskUserForCredentials;
477
478     // If there is a match in the network cache, we need to reuse the original cache policy and partition.
479     newRequest.setCachePolicy(originalRequest().cachePolicy());
480     newRequest.setCachePartition(originalRequest().cachePartition());
481
482     if (m_isWaitingContinueWillSendRequestForCachedRedirect) {
483         m_isWaitingContinueWillSendRequestForCachedRedirect = false;
484
485         LOG(NetworkCache, "(NetworkProcess) Retrieving cached redirect");
486
487         if (canUseCachedRedirect(newRequest))
488             retrieveCacheEntry(newRequest);
489         else
490             startNetworkLoad(newRequest);
491
492         return;
493     }
494
495     if (m_networkLoad)
496         m_networkLoad->continueWillSendRequest(WTFMove(newRequest));
497 }
498
499 void NetworkResourceLoader::continueDidReceiveResponse()
500 {
501     if (m_cacheEntryWaitingForContinueDidReceiveResponse) {
502         continueProcessingCachedEntryAfterDidReceiveResponse(WTFMove(m_cacheEntryWaitingForContinueDidReceiveResponse));
503         return;
504     }
505
506     // FIXME: Remove this check once BlobResourceHandle implements didReceiveResponseAsync correctly.
507     // Currently, it does not wait for response, so the load is likely to finish before continueDidReceiveResponse.
508     if (m_networkLoad)
509         m_networkLoad->continueDidReceiveResponse();
510 }
511
512 void NetworkResourceLoader::didSendData(unsigned long long bytesSent, unsigned long long totalBytesToBeSent)
513 {
514     if (!isSynchronous())
515         send(Messages::WebResourceLoader::DidSendData(bytesSent, totalBytesToBeSent));
516 }
517
518 void NetworkResourceLoader::startBufferingTimerIfNeeded()
519 {
520     if (isSynchronous())
521         return;
522     if (m_bufferingTimer.isActive())
523         return;
524     m_bufferingTimer.startOneShot(m_parameters.maximumBufferingTime);
525 }
526
527 void NetworkResourceLoader::bufferingTimerFired()
528 {
529     ASSERT(m_bufferedData);
530     ASSERT(m_networkLoad);
531
532     if (m_bufferedData->isEmpty())
533         return;
534
535     IPC::SharedBufferDataReference dataReference(m_bufferedData.get());
536     size_t encodedLength = m_bufferedDataEncodedDataLength;
537
538     m_bufferedData = SharedBuffer::create();
539     m_bufferedDataEncodedDataLength = 0;
540
541     send(Messages::WebResourceLoader::DidReceiveData(dataReference, encodedLength));
542 }
543
544 void NetworkResourceLoader::sendBuffer(SharedBuffer& buffer, size_t encodedDataLength)
545 {
546     ASSERT(!isSynchronous());
547
548     IPC::SharedBufferDataReference dataReference(&buffer);
549     send(Messages::WebResourceLoader::DidReceiveData(dataReference, encodedDataLength));
550 }
551
552 void NetworkResourceLoader::tryStoreAsCacheEntry()
553 {
554     if (!canUseCache(m_networkLoad->currentRequest()))
555         return;
556     if (!m_bufferedDataForCache)
557         return;
558
559     m_cache->store(m_networkLoad->currentRequest(), m_response, WTFMove(m_bufferedDataForCache), [loader = makeRef(*this)](auto& mappedBody) mutable {
560 #if ENABLE(SHAREABLE_RESOURCE)
561         if (mappedBody.shareableResourceHandle.isNull())
562             return;
563         LOG(NetworkCache, "(NetworkProcess) sending DidCacheResource");
564         loader->send(Messages::NetworkProcessConnection::DidCacheResource(loader->originalRequest(), mappedBody.shareableResourceHandle, loader->sessionID()));
565 #endif
566     });
567 }
568
569 void NetworkResourceLoader::didRetrieveCacheEntry(std::unique_ptr<NetworkCache::Entry> entry)
570 {
571     if (isSynchronous()) {
572         m_synchronousLoadData->response = entry->response();
573         sendReplyToSynchronousRequest(*m_synchronousLoadData, entry->buffer());
574         cleanup();
575         return;
576     }
577
578     bool needsContinueDidReceiveResponseMessage = isMainResource();
579     send(Messages::WebResourceLoader::DidReceiveResponse(entry->response(), needsContinueDidReceiveResponseMessage));
580
581     if (needsContinueDidReceiveResponseMessage)
582         m_cacheEntryWaitingForContinueDidReceiveResponse = WTFMove(entry);
583     else
584         continueProcessingCachedEntryAfterDidReceiveResponse(WTFMove(entry));
585 }
586
587 void NetworkResourceLoader::continueProcessingCachedEntryAfterDidReceiveResponse(std::unique_ptr<NetworkCache::Entry> entry)
588 {
589     if (entry->sourceStorageRecord().bodyHash && !m_parameters.derivedCachedDataTypesToRetrieve.isEmpty()) {
590         auto bodyHash = *entry->sourceStorageRecord().bodyHash;
591         auto* entryPtr = entry.release();
592         auto retrieveCount = m_parameters.derivedCachedDataTypesToRetrieve.size();
593
594         for (auto& type : m_parameters.derivedCachedDataTypesToRetrieve) {
595             NetworkCache::DataKey key { originalRequest().cachePartition(), type, bodyHash };
596             m_cache->retrieveData(key, [loader = makeRef(*this), entryPtr, type, retrieveCount] (const uint8_t* data, size_t size) mutable {
597                 loader->m_retrievedDerivedDataCount++;
598                 bool retrievedAll = loader->m_retrievedDerivedDataCount == retrieveCount;
599                 std::unique_ptr<NetworkCache::Entry> entry(retrievedAll ? entryPtr : nullptr);
600                 if (loader->hasOneRef())
601                     return;
602                 if (data) {
603                     IPC::DataReference dataReference(data, size);
604                     loader->send(Messages::WebResourceLoader::DidRetrieveDerivedData(type, dataReference));
605                 }
606                 if (retrievedAll) {
607                     loader->sendResultForCacheEntry(WTFMove(entry));
608                     loader->cleanup();
609                 }
610             });
611         }
612         return;
613     }
614
615     sendResultForCacheEntry(WTFMove(entry));
616
617     cleanup();
618 }
619
620 void NetworkResourceLoader::sendResultForCacheEntry(std::unique_ptr<NetworkCache::Entry> entry)
621 {
622 #if ENABLE(SHAREABLE_RESOURCE)
623     if (!entry->shareableResourceHandle().isNull()) {
624         send(Messages::WebResourceLoader::DidReceiveResource(entry->shareableResourceHandle()));
625         return;
626     }
627 #endif
628
629 #if HAVE(CFNETWORK_STORAGE_PARTITIONING) && !RELEASE_LOG_DISABLED
630     if (shouldLogCookieInformation())
631         logCookieInformation();
632 #endif
633
634     WebCore::NetworkLoadMetrics networkLoadMetrics;
635     networkLoadMetrics.markComplete();
636     networkLoadMetrics.requestHeaderBytesSent = 0;
637     networkLoadMetrics.requestBodyBytesSent = 0;
638     networkLoadMetrics.responseHeaderBytesReceived = 0;
639     networkLoadMetrics.responseBodyBytesReceived = 0;
640     networkLoadMetrics.responseBodyDecodedSize = 0;
641
642     sendBuffer(*entry->buffer(), entry->buffer()->size());
643     send(Messages::WebResourceLoader::DidFinishResourceLoad(networkLoadMetrics));
644 }
645
646 void NetworkResourceLoader::validateCacheEntry(std::unique_ptr<NetworkCache::Entry> entry)
647 {
648     ASSERT(!m_networkLoad);
649
650     // If the request is already conditional then the revalidation was not triggered by the disk cache
651     // and we should not overwrite the existing conditional headers.
652     ResourceRequest revalidationRequest = originalRequest();
653     if (!revalidationRequest.isConditional()) {
654         String eTag = entry->response().httpHeaderField(HTTPHeaderName::ETag);
655         String lastModified = entry->response().httpHeaderField(HTTPHeaderName::LastModified);
656         if (!eTag.isEmpty())
657             revalidationRequest.setHTTPHeaderField(HTTPHeaderName::IfNoneMatch, eTag);
658         if (!lastModified.isEmpty())
659             revalidationRequest.setHTTPHeaderField(HTTPHeaderName::IfModifiedSince, lastModified);
660     }
661
662     m_cacheEntryForValidation = WTFMove(entry);
663
664     startNetworkLoad(revalidationRequest);
665 }
666
667 void NetworkResourceLoader::dispatchWillSendRequestForCacheEntry(std::unique_ptr<NetworkCache::Entry> entry)
668 {
669     ASSERT(entry->redirectRequest());
670     ASSERT(!m_isWaitingContinueWillSendRequestForCachedRedirect);
671
672     LOG(NetworkCache, "(NetworkProcess) Executing cached redirect");
673
674     ++m_redirectCount;
675     send(Messages::WebResourceLoader::WillSendRequest { *entry->redirectRequest(), sanitizeRedirectResponseIfPossible(ResourceResponse { entry->response() }) });
676     m_isWaitingContinueWillSendRequestForCachedRedirect = true;
677 }
678
679 IPC::Connection* NetworkResourceLoader::messageSenderConnection()
680 {
681     return &connectionToWebProcess().connection();
682 }
683
684 void NetworkResourceLoader::consumeSandboxExtensions()
685 {
686     ASSERT(!m_didConsumeSandboxExtensions);
687
688     for (auto& extension : m_parameters.requestBodySandboxExtensions)
689         extension->consume();
690
691     if (auto& extension = m_parameters.resourceSandboxExtension)
692         extension->consume();
693
694     for (auto& fileReference : m_fileReferences)
695         fileReference->prepareForFileAccess();
696
697     m_didConsumeSandboxExtensions = true;
698 }
699
700 void NetworkResourceLoader::invalidateSandboxExtensions()
701 {
702     if (m_didConsumeSandboxExtensions) {
703         for (auto& extension : m_parameters.requestBodySandboxExtensions)
704             extension->revoke();
705         if (auto& extension = m_parameters.resourceSandboxExtension)
706             extension->revoke();
707         for (auto& fileReference : m_fileReferences)
708             fileReference->revokeFileAccess();
709
710         m_didConsumeSandboxExtensions = false;
711     }
712
713     m_fileReferences.clear();
714 }
715
716 #if USE(PROTECTION_SPACE_AUTH_CALLBACK)
717 void NetworkResourceLoader::canAuthenticateAgainstProtectionSpaceAsync(const ProtectionSpace& protectionSpace)
718 {
719     NetworkProcess::singleton().canAuthenticateAgainstProtectionSpace(*this, protectionSpace);
720 }
721
722 void NetworkResourceLoader::continueCanAuthenticateAgainstProtectionSpace(bool result)
723 {
724     if (m_networkLoad)
725         m_networkLoad->continueCanAuthenticateAgainstProtectionSpace(result);
726 }
727 #endif
728
729 bool NetworkResourceLoader::isAlwaysOnLoggingAllowed() const
730 {
731     if (NetworkProcess::singleton().sessionIsControlledByAutomation(sessionID()))
732         return true;
733
734     return sessionID().isAlwaysOnLoggingAllowed();
735 }
736
737 bool NetworkResourceLoader::shouldCaptureExtraNetworkLoadMetrics() const
738 {
739     return m_connection->captureExtraNetworkLoadMetricsEnabled();
740 }
741
742 #if HAVE(CFNETWORK_STORAGE_PARTITIONING) && !RELEASE_LOG_DISABLED
743 bool NetworkResourceLoader::shouldLogCookieInformation()
744 {
745     return NetworkProcess::singleton().shouldLogCookieInformation();
746 }
747
748 static String escapeForJSON(String s)
749 {
750     return s.replace('\\', "\\\\").replace('"', "\\\"");
751 }
752
753 static String escapeIDForJSON(const std::optional<uint64_t>& value)
754 {
755     return value ? String::number(value.value()) : String("None");
756 };
757
758 void NetworkResourceLoader::logCookieInformation() const
759 {
760     ASSERT(shouldLogCookieInformation());
761
762     auto networkStorageSession = WebCore::NetworkStorageSession::storageSession(sessionID());
763     ASSERT(networkStorageSession);
764
765     logCookieInformation("NetworkResourceLoader", reinterpret_cast<const void*>(this), *networkStorageSession, originalRequest().firstPartyForCookies(), originalRequest().url(), originalRequest().httpReferrer(), frameID(), pageID(), identifier());
766 }
767
768 static void logBlockedCookieInformation(const String& label, const void* loggedObject, const WebCore::NetworkStorageSession& networkStorageSession, const WebCore::URL& firstParty, const WebCore::URL& url, const String& referrer, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, std::optional<uint64_t> identifier)
769 {
770     ASSERT(NetworkResourceLoader::shouldLogCookieInformation());
771
772     auto escapedURL = escapeForJSON(url.string());
773     auto escapedFirstParty = escapeForJSON(firstParty.string());
774     auto escapedFrameID = escapeIDForJSON(frameID);
775     auto escapedPageID = escapeIDForJSON(pageID);
776     auto escapedIdentifier = escapeIDForJSON(identifier);
777     auto escapedReferrer = escapeForJSON(referrer);
778
779 #define LOCAL_LOG_IF_ALLOWED(fmt, ...) RELEASE_LOG_IF(networkStorageSession.sessionID().isAlwaysOnLoggingAllowed(), Network, "%p - %s::" fmt, loggedObject, label.utf8().data(), ##__VA_ARGS__)
780 #define LOCAL_LOG(str, ...) \
781     LOCAL_LOG_IF_ALLOWED("logCookieInformation: BLOCKED cookie access for pageID = %s, frameID = %s, resourceID = %s, firstParty = %s: " str, escapedPageID.utf8().data(), escapedFrameID.utf8().data(), escapedIdentifier.utf8().data(), escapedFirstParty.utf8().data(), ##__VA_ARGS__)
782
783     LOCAL_LOG(R"({ "url": "%{public}s",)", escapedURL.utf8().data());
784     LOCAL_LOG(R"(  "partition": "%{public}s",)", "BLOCKED");
785     LOCAL_LOG(R"(  "hasStorageAccess": %{public}s,)", "false");
786     LOCAL_LOG(R"(  "referer": "%{public}s",)", escapedReferrer.utf8().data());
787     LOCAL_LOG(R"(  "cookies": [])");
788     LOCAL_LOG(R"(  "})");
789 #undef LOCAL_LOG
790 #undef LOCAL_LOG_IF_ALLOWED
791 }
792
793 static void logCookieInformationInternal(const String& label, const void* loggedObject, const WebCore::NetworkStorageSession& networkStorageSession, const WebCore::URL& partition, const WebCore::URL& url, const String& referrer, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, std::optional<uint64_t> identifier)
794 {
795     ASSERT(NetworkResourceLoader::shouldLogCookieInformation());
796
797     Vector<WebCore::Cookie> cookies;
798     if (!WebCore::getRawCookies(networkStorageSession, partition, url, frameID, pageID, cookies))
799         return;
800
801     auto escapedURL = escapeForJSON(url.string());
802     auto escapedPartition = escapeForJSON(partition.string());
803     auto escapedReferrer = escapeForJSON(referrer);
804     auto escapedFrameID = escapeIDForJSON(frameID);
805     auto escapedPageID = escapeIDForJSON(pageID);
806     auto escapedIdentifier = escapeIDForJSON(identifier);
807     bool hasStorageAccess = (frameID && pageID) ? networkStorageSession.hasStorageAccess(url.string(), partition.string(), frameID.value(), pageID.value()) : false;
808
809 #define LOCAL_LOG_IF_ALLOWED(fmt, ...) RELEASE_LOG_IF(networkStorageSession.sessionID().isAlwaysOnLoggingAllowed(), Network, "%p - %s::" fmt, loggedObject, label.utf8().data(), ##__VA_ARGS__)
810 #define LOCAL_LOG(str, ...) \
811     LOCAL_LOG_IF_ALLOWED("logCookieInformation: pageID = %s, frameID = %s, resourceID = %s: " str, escapedPageID.utf8().data(), escapedFrameID.utf8().data(), escapedIdentifier.utf8().data(), ##__VA_ARGS__)
812
813     LOCAL_LOG(R"({ "url": "%{public}s",)", escapedURL.utf8().data());
814     LOCAL_LOG(R"(  "partition": "%{public}s",)", escapedPartition.utf8().data());
815     LOCAL_LOG(R"(  "hasStorageAccess": %{public}s,)", hasStorageAccess ? "true" : "false");
816     LOCAL_LOG(R"(  "referer": "%{public}s",)", escapedReferrer.utf8().data());
817     LOCAL_LOG(R"(  "cookies": [)");
818
819     auto size = cookies.size();
820     decltype(size) count = 0;
821     for (const auto& cookie : cookies) {
822         const char* trailingComma = ",";
823         if (++count == size)
824             trailingComma = "";
825
826         auto escapedName = escapeForJSON(cookie.name);
827         auto escapedValue = escapeForJSON(cookie.value);
828         auto escapedDomain = escapeForJSON(cookie.domain);
829         auto escapedPath = escapeForJSON(cookie.path);
830         auto escapedComment = escapeForJSON(cookie.comment);
831         auto escapedCommentURL = escapeForJSON(cookie.commentURL.string());
832
833         LOCAL_LOG(R"(  { "name": "%{public}s",)", escapedName.utf8().data());
834         LOCAL_LOG(R"(    "value": "%{public}s",)", escapedValue.utf8().data());
835         LOCAL_LOG(R"(    "domain": "%{public}s",)", escapedDomain.utf8().data());
836         LOCAL_LOG(R"(    "path": "%{public}s",)", escapedPath.utf8().data());
837         LOCAL_LOG(R"(    "created": %f,)", cookie.created);
838         LOCAL_LOG(R"(    "expires": %f,)", cookie.expires);
839         LOCAL_LOG(R"(    "httpOnly": %{public}s,)", cookie.httpOnly ? "true" : "false");
840         LOCAL_LOG(R"(    "secure": %{public}s,)", cookie.secure ? "true" : "false");
841         LOCAL_LOG(R"(    "session": %{public}s,)", cookie.session ? "true" : "false");
842         LOCAL_LOG(R"(    "comment": "%{public}s",)", escapedComment.utf8().data());
843         LOCAL_LOG(R"(    "commentURL": "%{public}s")", escapedCommentURL.utf8().data());
844         LOCAL_LOG(R"(  }%{public}s)", trailingComma);
845     }
846     LOCAL_LOG(R"(]})");
847 #undef LOCAL_LOG
848 #undef LOCAL_LOG_IF_ALLOWED
849 }
850
851 void NetworkResourceLoader::logCookieInformation(const String& label, const void* loggedObject, const NetworkStorageSession& networkStorageSession, const URL& firstParty, const URL& url, const String& referrer, std::optional<uint64_t> frameID, std::optional<uint64_t> pageID, std::optional<uint64_t> identifier)
852 {
853     ASSERT(shouldLogCookieInformation());
854
855     if (networkStorageSession.shouldBlockCookies(firstParty, url))
856         logBlockedCookieInformation(label, loggedObject, networkStorageSession, firstParty, url, referrer, frameID, pageID, identifier);
857     else {
858         auto partition = URL(ParsedURLString, networkStorageSession.cookieStoragePartition(firstParty, url, frameID, pageID));
859         logCookieInformationInternal(label, loggedObject, networkStorageSession, partition, url, referrer, frameID, pageID, identifier);
860     }
861 }
862 #endif
863
864 } // namespace WebKit