void WebCookieManager::setCookiePersistentStorage(const String& storagePath, uint32_t storageType)
{
GRefPtr<SoupCookieJar> jar;
switch (storageType) {
case SoupCookiePersistentStorageText:
jar = adoptGRef(soup_cookie_jar_text_new(storagePath.utf8().data(), FALSE));
break;
case SoupCookiePersistentStorageSQLite:
jar = adoptGRef(webkitSoupCookieJarSqliteNew(storagePath));
break;
default:
ASSERT_NOT_REACHED();
}
soup_cookie_jar_set_accept_policy(jar.get(), soup_cookie_jar_get_accept_policy(WebCore::soupCookieJar()));
SoupNetworkSession::defaultSession().setCookieJar(jar.get());
WebCore::setSoupCookieJar(jar.get());
}
Ewk_Cookie_Policy ewk_cookies_policy_get(void)
{
Ewk_Cookie_Policy ewkPolicy = EWK_COOKIE_JAR_ACCEPT_ALWAYS;
SoupCookieJar* cookieJar = WebCore::soupCookieJar();
SoupCookieJarAcceptPolicy policy;
policy = soup_cookie_jar_get_accept_policy(cookieJar);
switch (policy) {
case SOUP_COOKIE_JAR_ACCEPT_NEVER:
ewkPolicy = EWK_COOKIE_JAR_ACCEPT_NEVER;
break;
case SOUP_COOKIE_JAR_ACCEPT_ALWAYS:
ewkPolicy = EWK_COOKIE_JAR_ACCEPT_ALWAYS;
break;
case SOUP_COOKIE_JAR_ACCEPT_NO_THIRD_PARTY:
ewkPolicy = EWK_COOKIE_JAR_ACCEPT_NO_THIRD_PARTY;
break;
}
return ewkPolicy;
}
HTTPCookieAcceptPolicy WebCookieManager::platformGetHTTPCookieAcceptPolicy()
{
SoupCookieJar* cookieJar = WebCore::soupCookieJar();
SoupCookieJarAcceptPolicy soupPolicy;
HTTPCookieAcceptPolicy policy;
soupPolicy = soup_cookie_jar_get_accept_policy(cookieJar);
switch (soupPolicy) {
case SOUP_COOKIE_JAR_ACCEPT_ALWAYS:
policy = HTTPCookieAcceptPolicyAlways;
break;
case SOUP_COOKIE_JAR_ACCEPT_NEVER:
policy = HTTPCookieAcceptPolicyNever;
break;
case SOUP_COOKIE_JAR_ACCEPT_NO_THIRD_PARTY:
policy = HTTPCookieAcceptPolicyOnlyFromMainDocumentDomain;
break;
default:
policy = HTTPCookieAcceptPolicyAlways;
}
return policy;
}
/* We received the HTTP headers of the request and it contains cookie-managing headers */
static void _cookie_permission_manager_on_response_received(WebKitWebView *inView,
WebKitWebFrame *inFrame,
WebKitWebResource *inResource,
WebKitNetworkResponse *inResponse,
gpointer inUserData)
{
g_return_if_fail(IS_COOKIE_PERMISSION_MANAGER(inUserData));
CookiePermissionManager *self=COOKIE_PERMISSION_MANAGER(inUserData);
CookiePermissionManagerPrivate *priv=self->priv;
GSList *newCookies, *cookie;
GSList *unknownCookies=NULL, *acceptedCookies=NULL;
SoupURI *firstParty;
SoupCookieJarAcceptPolicy cookiePolicy;
gint unknownCookiesPolicy;
SoupMessage *message;
/* If policy is to deny all cookies return immediately */
cookiePolicy=soup_cookie_jar_get_accept_policy(priv->cookieJar);
if(cookiePolicy==SOUP_COOKIE_JAR_ACCEPT_NEVER) return;
/* Get SoupMessage */
message=webkit_network_response_get_message(inResponse);
if(!message || !SOUP_IS_MESSAGE(message)) return;
/* Iterate through cookies in response and check if they should be
* blocked (remove from cookies list) or accepted (added to cookie jar).
* If we could not determine what to do collect these cookies and
* ask user
*/
newCookies=soup_cookies_from_response(message);
firstParty=soup_message_get_first_party(message);
for(cookie=newCookies; cookie; cookie=cookie->next)
{
switch(_cookie_permission_manager_get_policy(self, cookie->data))
{
case COOKIE_PERMISSION_MANAGER_POLICY_BLOCK:
soup_cookie_free(cookie->data);
break;
case COOKIE_PERMISSION_MANAGER_POLICY_ACCEPT:
case COOKIE_PERMISSION_MANAGER_POLICY_ACCEPT_FOR_SESSION:
if((cookiePolicy==SOUP_COOKIE_JAR_ACCEPT_NO_THIRD_PARTY &&
firstParty!=NULL &&
firstParty->host &&
soup_cookie_domain_matches(cookie->data, firstParty->host)) ||
cookiePolicy==SOUP_COOKIE_JAR_ACCEPT_ALWAYS)
{
acceptedCookies=g_slist_prepend(acceptedCookies, cookie->data);
}
else soup_cookie_free(cookie->data);
break;
case COOKIE_PERMISSION_MANAGER_POLICY_UNDETERMINED:
default:
if((cookiePolicy==SOUP_COOKIE_JAR_ACCEPT_NO_THIRD_PARTY &&
firstParty!=NULL &&
firstParty->host &&
soup_cookie_domain_matches(cookie->data, firstParty->host)) ||
cookiePolicy==SOUP_COOKIE_JAR_ACCEPT_ALWAYS)
{
unknownCookies=g_slist_prepend(unknownCookies, cookie->data);
}
else soup_cookie_free(cookie->data);
break;
}
}
/* Prepending an item to list is the fastest method but the order of cookies
* is reversed now and may be added to cookie jar in the wrong order. So we
* need to reverse list now of both - undetermined and accepted cookies
*/
unknownCookies=g_slist_reverse(unknownCookies);
acceptedCookies=g_slist_reverse(acceptedCookies);
/* Ask user for his decision what to do with cookies whose policy is undetermined
* But only ask if there is any undetermined one
*/
if(g_slist_length(unknownCookies)>0)
{
/* Get view */
MidoriView *view;
view=MIDORI_VIEW(g_object_get_data(G_OBJECT(inView), "midori-view"));
/* Ask for user's decision */
unknownCookiesPolicy=_cookie_permission_manager_ask_for_policy(self, view, message, unknownCookies);
if(unknownCookiesPolicy==COOKIE_PERMISSION_MANAGER_POLICY_ACCEPT ||
unknownCookiesPolicy==COOKIE_PERMISSION_MANAGER_POLICY_ACCEPT_FOR_SESSION)
{
/* Add accepted undetermined cookies to cookie jar */
for(cookie=unknownCookies; cookie; cookie=cookie->next)
{
soup_cookie_jar_add_cookie(priv->cookieJar, (SoupCookie*)cookie->data);
}
}
else
{
/* Free cookies because they should be blocked */
for(cookie=unknownCookies; cookie; cookie=cookie->next)
{
soup_cookie_free((SoupCookie*)cookie->data);
}
}
}
/* Add accepted cookies to cookie jar */
for(cookie=acceptedCookies; cookie; cookie=cookie->next)
{
soup_cookie_jar_add_cookie(priv->cookieJar, (SoupCookie*)cookie->data);
}
/* Free list of cookies */
g_slist_free(unknownCookies);
g_slist_free(acceptedCookies);
g_slist_free(newCookies);
}
/* Get policy for cookies from domain */
static gint _cookie_permission_manager_get_policy(CookiePermissionManager *self, SoupCookie *inCookie)
{
CookiePermissionManagerPrivate *priv=self->priv;
sqlite3_stmt *statement=NULL;
gchar *domain;
gint error;
gint policy=COOKIE_PERMISSION_MANAGER_POLICY_UNDETERMINED;
gboolean foundPolicy=FALSE;
/* Check for open database */
g_return_val_if_fail(priv->database, COOKIE_PERMISSION_MANAGER_POLICY_UNDETERMINED);
/* Lookup policy for cookie domain in database */
domain=g_strdup(soup_cookie_get_domain(inCookie));
if(*domain=='.') *domain='%';
error=sqlite3_prepare_v2(priv->database,
"SELECT domain, value FROM policies WHERE domain LIKE ? ORDER BY domain DESC;",
-1,
&statement,
NULL);
if(statement && error==SQLITE_OK) error=sqlite3_bind_text(statement, 1, domain, -1, NULL);
if(statement && error==SQLITE_OK)
{
while(policy==COOKIE_PERMISSION_MANAGER_POLICY_UNDETERMINED &&
sqlite3_step(statement)==SQLITE_ROW)
{
gchar *policyDomain=(gchar*)sqlite3_column_text(statement, 0);
if(soup_cookie_domain_matches(inCookie, policyDomain))
{
policy=sqlite3_column_int(statement, 1);
foundPolicy=TRUE;
}
}
}
else g_warning(_("SQL fails: %s"), sqlite3_errmsg(priv->database));
sqlite3_finalize(statement);
/* Check if policy is undetermined. If it is then check if this policy was set by user.
* If it was not set by user, check what to do.
*/
if(!foundPolicy)
{
/* A SoupCookieJar that doesn't want to accept any cookies should override the user's
* choice, in case of e.g. private mode, to err on the side of caution. */
SoupCookieJarAcceptPolicy soup_policy=soup_cookie_jar_get_accept_policy(priv->cookieJar);
if(soup_policy==SOUP_COOKIE_JAR_ACCEPT_ALWAYS || soup_policy==SOUP_COOKIE_JAR_ACCEPT_NO_THIRD_PARTY)
{
policy=priv->unknownPolicy;
}
else
{
if(soup_policy!=SOUP_COOKIE_JAR_ACCEPT_NEVER)
g_critical(_("Could not determine global cookie policy to set for domain: %s"), domain);
policy=COOKIE_PERMISSION_MANAGER_POLICY_BLOCK;
}
}
/* Release allocated resources */
g_free(domain);
return(policy);
}
