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