blob: c50d67c873fd9d5bd8ebc2eba4c167fe13515112 [file] [log] [blame]
/*
* Copyright (C) 2012 Apple Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
* THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "config.h"
#include "NetworkProcess.h"
#if ENABLE(NETWORK_PROCESS)
#include "ArgumentCoders.h"
#include "Attachment.h"
#include "AuthenticationManager.h"
#include "CustomProtocolManager.h"
#include "Logging.h"
#include "NetworkConnectionToWebProcess.h"
#include "NetworkProcessCreationParameters.h"
#include "NetworkProcessPlatformStrategies.h"
#include "NetworkProcessProxyMessages.h"
#include "NetworkResourceLoader.h"
#include "RemoteNetworkingContext.h"
#include "SessionTracker.h"
#include "StatisticsData.h"
#include "WebCookieManager.h"
#include "WebProcessPoolMessages.h"
#include "WebsiteDataTypes.h"
#include <WebCore/Logging.h>
#include <WebCore/MemoryPressureHandler.h>
#include <WebCore/PlatformCookieJar.h>
#include <WebCore/ResourceRequest.h>
#include <WebCore/SessionID.h>
#include <wtf/RunLoop.h>
#include <wtf/text/CString.h>
#if ENABLE(SEC_ITEM_SHIM)
#include "SecItemShim.h"
#endif
using namespace WebCore;
namespace WebKit {
NetworkProcess& NetworkProcess::singleton()
{
static NeverDestroyed<NetworkProcess> networkProcess;
return networkProcess;
}
NetworkProcess::NetworkProcess()
: m_hasSetCacheModel(false)
, m_cacheModel(CacheModelDocumentViewer)
, m_diskCacheIsDisabledForTesting(false)
, m_canHandleHTTPSServerTrustEvaluation(true)
#if PLATFORM(COCOA)
, m_clearCacheDispatchGroup(0)
#endif
{
NetworkProcessPlatformStrategies::initialize();
addSupplement<AuthenticationManager>();
addSupplement<WebCookieManager>();
addSupplement<CustomProtocolManager>();
}
NetworkProcess::~NetworkProcess()
{
}
AuthenticationManager& NetworkProcess::authenticationManager()
{
return *supplement<AuthenticationManager>();
}
DownloadManager& NetworkProcess::downloadManager()
{
static NeverDestroyed<DownloadManager> downloadManager(this);
return downloadManager;
}
void NetworkProcess::removeNetworkConnectionToWebProcess(NetworkConnectionToWebProcess* connection)
{
size_t vectorIndex = m_webProcessConnections.find(connection);
ASSERT(vectorIndex != notFound);
m_webProcessConnections.remove(vectorIndex);
}
bool NetworkProcess::shouldTerminate()
{
// Network process keeps session cookies and credentials, so it should never terminate (as long as UI process connection is alive).
return false;
}
void NetworkProcess::didReceiveMessage(IPC::Connection& connection, IPC::MessageDecoder& decoder)
{
if (messageReceiverMap().dispatchMessage(connection, decoder))
return;
didReceiveNetworkProcessMessage(connection, decoder);
}
void NetworkProcess::didReceiveSyncMessage(IPC::Connection& connection, IPC::MessageDecoder& decoder, std::unique_ptr<IPC::MessageEncoder>& replyEncoder)
{
messageReceiverMap().dispatchSyncMessage(connection, decoder, replyEncoder);
}
void NetworkProcess::didClose(IPC::Connection&)
{
// The UIProcess just exited.
RunLoop::current().stop();
}
void NetworkProcess::didReceiveInvalidMessage(IPC::Connection&, IPC::StringReference, IPC::StringReference)
{
RunLoop::current().stop();
}
void NetworkProcess::didCreateDownload()
{
disableTermination();
}
void NetworkProcess::didDestroyDownload()
{
enableTermination();
}
IPC::Connection* NetworkProcess::downloadProxyConnection()
{
return parentProcessConnection();
}
AuthenticationManager& NetworkProcess::downloadsAuthenticationManager()
{
return authenticationManager();
}
void NetworkProcess::initializeNetworkProcess(const NetworkProcessCreationParameters& parameters)
{
platformInitializeNetworkProcess(parameters);
WTF::setCurrentThreadIsUserInitiated();
auto& memoryPressureHandler = MemoryPressureHandler::singleton();
memoryPressureHandler.setLowMemoryHandler([this] (bool critical) {
platformLowMemoryHandler(critical);
WTF::releaseFastMallocFreeMemory();
});
memoryPressureHandler.install();
m_diskCacheIsDisabledForTesting = parameters.shouldUseTestingNetworkSession;
setCacheModel(static_cast<uint32_t>(parameters.cacheModel));
setCanHandleHTTPSServerTrustEvaluation(parameters.canHandleHTTPSServerTrustEvaluation);
#if PLATFORM(MAC) || USE(CFNETWORK)
SessionTracker::setIdentifierBase(parameters.uiProcessBundleIdentifier);
#endif
// FIXME: instead of handling this here, a message should be sent later (scales to multiple sessions)
if (parameters.privateBrowsingEnabled)
RemoteNetworkingContext::ensurePrivateBrowsingSession(SessionID::legacyPrivateSessionID());
if (parameters.shouldUseTestingNetworkSession)
NetworkStorageSession::switchToNewTestingSession();
NetworkProcessSupplementMap::const_iterator it = m_supplements.begin();
NetworkProcessSupplementMap::const_iterator end = m_supplements.end();
for (; it != end; ++it)
it->value->initialize(parameters);
}
void NetworkProcess::initializeConnection(IPC::Connection* connection)
{
ChildProcess::initializeConnection(connection);
#if ENABLE(SEC_ITEM_SHIM)
SecItemShim::singleton().initializeConnection(connection);
#endif
NetworkProcessSupplementMap::const_iterator it = m_supplements.begin();
NetworkProcessSupplementMap::const_iterator end = m_supplements.end();
for (; it != end; ++it)
it->value->initializeConnection(connection);
}
void NetworkProcess::createNetworkConnectionToWebProcess()
{
#if OS(DARWIN)
// Create the listening port.
mach_port_t listeningPort;
mach_port_allocate(mach_task_self(), MACH_PORT_RIGHT_RECEIVE, &listeningPort);
// Create a listening connection.
RefPtr<NetworkConnectionToWebProcess> connection = NetworkConnectionToWebProcess::create(IPC::Connection::Identifier(listeningPort));
m_webProcessConnections.append(connection.release());
IPC::Attachment clientPort(listeningPort, MACH_MSG_TYPE_MAKE_SEND);
parentProcessConnection()->send(Messages::NetworkProcessProxy::DidCreateNetworkConnectionToWebProcess(clientPort), 0);
#elif USE(UNIX_DOMAIN_SOCKETS)
IPC::Connection::SocketPair socketPair = IPC::Connection::createPlatformConnection();
RefPtr<NetworkConnectionToWebProcess> connection = NetworkConnectionToWebProcess::create(socketPair.server);
m_webProcessConnections.append(connection.release());
IPC::Attachment clientSocket(socketPair.client);
parentProcessConnection()->send(Messages::NetworkProcessProxy::DidCreateNetworkConnectionToWebProcess(clientSocket), 0);
#else
notImplemented();
#endif
}
void NetworkProcess::ensurePrivateBrowsingSession(SessionID sessionID)
{
RemoteNetworkingContext::ensurePrivateBrowsingSession(sessionID);
}
void NetworkProcess::destroyPrivateBrowsingSession(SessionID sessionID)
{
SessionTracker::destroySession(sessionID);
}
void NetworkProcess::deleteWebsiteData(WebCore::SessionID sessionID, uint64_t websiteDataTypes, std::chrono::system_clock::time_point modifiedSince, uint64_t callbackID)
{
if (websiteDataTypes & WebsiteDataTypeCookies) {
if (auto* networkStorageSession = SessionTracker::session(sessionID))
deleteAllCookiesModifiedSince(*networkStorageSession, modifiedSince);
}
auto completionHandler = [this, callbackID] {
parentProcessConnection()->send(Messages::NetworkProcessProxy::DidDeleteWebsiteData(callbackID), 0);
};
if ((websiteDataTypes & WebsiteDataTypeDiskCache) & !sessionID.isEphemeral()) {
clearDiskCache(modifiedSince, WTF::move(completionHandler));
return;
}
completionHandler();
}
void NetworkProcess::downloadRequest(uint64_t downloadID, const ResourceRequest& request)
{
downloadManager().startDownload(downloadID, request);
}
void NetworkProcess::resumeDownload(uint64_t downloadID, const IPC::DataReference& resumeData, const String& path, const WebKit::SandboxExtension::Handle& sandboxExtensionHandle)
{
downloadManager().resumeDownload(downloadID, resumeData, path, sandboxExtensionHandle);
}
void NetworkProcess::cancelDownload(uint64_t downloadID)
{
downloadManager().cancelDownload(downloadID);
}
void NetworkProcess::setCacheModel(uint32_t cm)
{
CacheModel cacheModel = static_cast<CacheModel>(cm);
if (!m_hasSetCacheModel || cacheModel != m_cacheModel) {
m_hasSetCacheModel = true;
m_cacheModel = cacheModel;
platformSetCacheModel(cacheModel);
}
}
void NetworkProcess::setCanHandleHTTPSServerTrustEvaluation(bool value)
{
m_canHandleHTTPSServerTrustEvaluation = value;
}
void NetworkProcess::getNetworkProcessStatistics(uint64_t callbackID)
{
NetworkResourceLoadScheduler& scheduler = NetworkProcess::singleton().networkResourceLoadScheduler();
StatisticsData data;
auto& networkProcess = NetworkProcess::singleton();
data.statisticsNumbers.set("LoadsPendingCount", scheduler.loadsPendingCount());
data.statisticsNumbers.set("LoadsActiveCount", scheduler.loadsActiveCount());
data.statisticsNumbers.set("DownloadsActiveCount", networkProcess.downloadManager().activeDownloadCount());
data.statisticsNumbers.set("OutstandingAuthenticationChallengesCount", networkProcess.authenticationManager().outstandingAuthenticationChallengeCount());
parentProcessConnection()->send(Messages::WebProcessPool::DidGetStatistics(data, callbackID), 0);
}
void NetworkProcess::logDiagnosticMessage(uint64_t webPageID, const String& message, const String& description, WebCore::ShouldSample shouldSample)
{
parentProcessConnection()->send(Messages::NetworkProcessProxy::LogDiagnosticMessage(webPageID, message, description, shouldSample == ShouldSample::Yes), 0);
}
void NetworkProcess::logDiagnosticMessageWithResult(uint64_t webPageID, const String& message, const String& description, WebCore::DiagnosticLoggingResultType result, WebCore::ShouldSample shouldSample)
{
parentProcessConnection()->send(Messages::NetworkProcessProxy::LogDiagnosticMessageWithResult(webPageID, message, description, result, shouldSample == ShouldSample::Yes), 0);
}
void NetworkProcess::logDiagnosticMessageWithValue(uint64_t webPageID, const String& message, const String& description, const String& value, WebCore::ShouldSample shouldSample)
{
parentProcessConnection()->send(Messages::NetworkProcessProxy::LogDiagnosticMessageWithValue(webPageID, message, description, value, shouldSample == ShouldSample::Yes), 0);
}
void NetworkProcess::terminate()
{
platformTerminate();
ChildProcess::terminate();
}
#if !PLATFORM(COCOA)
void NetworkProcess::initializeProcess(const ChildProcessInitializationParameters&)
{
}
void NetworkProcess::initializeProcessName(const ChildProcessInitializationParameters&)
{
}
void NetworkProcess::initializeSandbox(const ChildProcessInitializationParameters&, SandboxInitializationParameters&)
{
}
void NetworkProcess::platformLowMemoryHandler(bool)
{
}
#endif
} // namespace WebKit
#endif // ENABLE(NETWORK_PROCESS)