NetworkStorageSessionCurl.cpp [plain text]
#include "config.h"
#include "NetworkStorageSession.h"
#if USE(CURL)
#include "CookieJarDB.h"
#include "CookieRequestHeaderFieldProxy.h"
#include "CurlContext.h"
#include "HTTPCookieAcceptPolicy.h"
#include <wtf/FileSystem.h>
#include <wtf/URL.h>
#include <wtf/text/StringBuilder.h>
namespace WebCore {
static String defaultCookieJarPath()
{
static const char* defaultFileName = "cookie.jar.db";
char* cookieJarPath = getenv("CURL_COOKIE_JAR_PATH");
if (cookieJarPath)
return cookieJarPath;
#if PLATFORM(WIN)
return FileSystem::pathByAppendingComponent(FileSystem::localUserSpecificStorageDirectory(), defaultFileName);
#else
return defaultFileName;
#endif
}
static String cookiesForSession(const NetworkStorageSession& session, const URL& firstParty, const URL& url, bool forHTTPHeader)
{
StringBuilder cookies;
auto searchHTTPOnly = forHTTPHeader ? WTF::nullopt : Optional<bool> { false };
auto secure = url.protocolIs("https") ? WTF::nullopt : Optional<bool> { false };
if (auto result = session.cookieDatabase().searchCookies(firstParty, url, searchHTTPOnly, secure, WTF::nullopt)) {
for (const auto& cookie : *result) {
if (!cookies.isEmpty())
cookies.append("; ");
cookies.append(cookie.name);
cookies.append("=");
cookies.append(cookie.value);
}
}
return cookies.toString();
}
NetworkStorageSession::NetworkStorageSession(PAL::SessionID sessionID)
: m_sessionID(sessionID)
, m_cookieDatabase(makeUniqueRef<CookieJarDB>(sessionID.isEphemeral() ? ":memory:"_s : defaultCookieJarPath()))
{
}
NetworkStorageSession::~NetworkStorageSession()
{
}
void NetworkStorageSession::setCookieDatabase(UniqueRef<CookieJarDB>&& cookieDatabase)
{
m_cookieDatabase = WTFMove(cookieDatabase);
}
CookieJarDB& NetworkStorageSession::cookieDatabase() const
{
m_cookieDatabase->open();
return m_cookieDatabase;
}
void NetworkStorageSession::setCookiesFromDOM(const URL& firstParty, const SameSiteInfo&, const URL& url, Optional<FrameIdentifier> frameID, Optional<PageIdentifier> pageID, ShouldAskITP, const String& value, ShouldRelaxThirdPartyCookieBlocking shouldRelaxThirdPartyCookieBlocking) const
{
#if ENABLE(RESOURCE_LOAD_STATISTICS)
Optional<Seconds> cappedLifetime = clientSideCookieCap(RegistrableDomain { firstParty }, pageID);
#else
Optional<Seconds> cappedLifetime = WTF::nullopt;
#endif
cookieDatabase().setCookie(firstParty, url, value, CookieJarDB::Source::Script, cappedLifetime);
}
void NetworkStorageSession::setCookiesFromHTTPResponse(const URL& firstParty, const URL& url, const String& value) const
{
cookieDatabase().setCookie(firstParty, url, value, CookieJarDB::Source::Network);
}
void NetworkStorageSession::setCookieAcceptPolicy(CookieAcceptPolicy policy) const
{
cookieDatabase().setAcceptPolicy(policy);
}
HTTPCookieAcceptPolicy NetworkStorageSession::cookieAcceptPolicy() const
{
switch (cookieDatabase().acceptPolicy()) {
case CookieAcceptPolicy::Always:
return HTTPCookieAcceptPolicy::AlwaysAccept;
case CookieAcceptPolicy::Never:
return HTTPCookieAcceptPolicy::Never;
case CookieAcceptPolicy::OnlyFromMainDocumentDomain:
return HTTPCookieAcceptPolicy::OnlyFromMainDocumentDomain;
case CookieAcceptPolicy::ExclusivelyFromMainDocumentDomain:
return HTTPCookieAcceptPolicy::ExclusivelyFromMainDocumentDomain;
}
ASSERT_NOT_REACHED();
return HTTPCookieAcceptPolicy::OnlyFromMainDocumentDomain;
}
std::pair<String, bool> NetworkStorageSession::cookiesForDOM(const URL& firstParty, const SameSiteInfo&, const URL& url, Optional<FrameIdentifier>, Optional<PageIdentifier>, IncludeSecureCookies, ShouldAskITP, ShouldRelaxThirdPartyCookieBlocking) const
{
return { cookiesForSession(*this, firstParty, url, false), false };
}
void NetworkStorageSession::setCookies(const Vector<Cookie>& cookies, const URL&, const URL& )
{
for (const auto& cookie : cookies)
cookieDatabase().setCookie(cookie);
}
void NetworkStorageSession::setCookie(const Cookie& cookie)
{
cookieDatabase().setCookie(cookie);
}
void NetworkStorageSession::deleteCookie(const Cookie& cookie)
{
String url = makeString(cookie.secure ? "https"_s : "http"_s, "://"_s, cookie.domain, cookie.path);
cookieDatabase().deleteCookie(url, cookie.name);
}
void NetworkStorageSession::deleteCookie(const URL& url, const String& name) const
{
cookieDatabase().deleteCookie(url.string(), name);
}
void NetworkStorageSession::deleteAllCookies()
{
cookieDatabase().deleteAllCookies();
}
void NetworkStorageSession::deleteAllCookiesModifiedSince(WallTime)
{
}
void NetworkStorageSession::deleteCookiesForHostnames(const Vector<String>& cookieHostNames, IncludeHttpOnlyCookies includeHttpOnlyCookies)
{
for (auto hostname : cookieHostNames)
cookieDatabase().deleteCookiesForHostname(hostname, includeHttpOnlyCookies);
}
void NetworkStorageSession::deleteCookiesForHostnames(const Vector<String>& cookieHostNames)
{
deleteCookiesForHostnames(cookieHostNames, IncludeHttpOnlyCookies::Yes);
}
Vector<Cookie> NetworkStorageSession::getAllCookies()
{
return cookieDatabase().getAllCookies();
}
void NetworkStorageSession::getHostnamesWithCookies(HashSet<String>& hostnames)
{
hostnames = cookieDatabase().allDomains();
}
Vector<Cookie> NetworkStorageSession::getCookies(const URL&)
{
return { };
}
void NetworkStorageSession::hasCookies(const RegistrableDomain&, CompletionHandler<void(bool)>&& completionHandler) const
{
completionHandler(false);
}
bool NetworkStorageSession::getRawCookies(const URL& firstParty, const SameSiteInfo&, const URL& url, Optional<FrameIdentifier>, Optional<PageIdentifier>, ShouldAskITP, ShouldRelaxThirdPartyCookieBlocking, Vector<Cookie>& rawCookies) const
{
auto cookies = cookieDatabase().searchCookies(firstParty, url, WTF::nullopt, WTF::nullopt, WTF::nullopt);
if (!cookies)
return false;
rawCookies = WTFMove(*cookies);
return true;
}
void NetworkStorageSession::flushCookieStore()
{
}
std::pair<String, bool> NetworkStorageSession::cookieRequestHeaderFieldValue(const URL& firstParty, const SameSiteInfo&, const URL& url, Optional<FrameIdentifier>, Optional<PageIdentifier>, IncludeSecureCookies, ShouldAskITP, ShouldRelaxThirdPartyCookieBlocking) const
{
return { cookiesForSession(*this, firstParty, url, true), false };
}
std::pair<String, bool> NetworkStorageSession::cookieRequestHeaderFieldValue(const CookieRequestHeaderFieldProxy& headerFieldProxy) const
{
return cookieRequestHeaderFieldValue(headerFieldProxy.firstParty, headerFieldProxy.sameSiteInfo, headerFieldProxy.url, headerFieldProxy.frameID, headerFieldProxy.pageID, headerFieldProxy.includeSecureCookies, ShouldAskITP::Yes, ShouldRelaxThirdPartyCookieBlocking::No);
}
void NetworkStorageSession::setProxySettings(CurlProxySettings&& proxySettings)
{
CurlContext::singleton().setProxySettings(WTFMove(proxySettings));
}
}
#endif // USE(CURL)