JNIEXPORT void JNICALL WebKitGTK_NATIVE(_1soup_1cookie_1jar_1delete_1cookie)
(JNIEnv *env, jclass that, jintLong arg0, jintLong arg1)
{
WebKitGTK_NATIVE_ENTER(env, that, _1soup_1cookie_1jar_1delete_1cookie_FUNC);
soup_cookie_jar_delete_cookie((SoupCookieJar *)arg0, (SoupCookie *)arg1);
WebKitGTK_NATIVE_EXIT(env, that, _1soup_1cookie_1jar_1delete_1cookie_FUNC);
}
/* A cookie was changed outside a request (e.g. Javascript) */
static void _cookie_permission_manager_on_cookie_changed(CookiePermissionManager *self,
SoupCookie *inOldCookie,
SoupCookie *inNewCookie,
SoupCookieJar *inCookieJar)
{
/* Do not check changed cookies because they must have been allowed before.
* Also do not check removed cookies because they are removed ;)
*/
if(inNewCookie==NULL || inOldCookie) return;
/* New cookie is a new cookie so check */
switch(_cookie_permission_manager_get_policy(self, inNewCookie))
{
case COOKIE_PERMISSION_MANAGER_POLICY_ACCEPT:
case COOKIE_PERMISSION_MANAGER_POLICY_ACCEPT_FOR_SESSION:
break;
case COOKIE_PERMISSION_MANAGER_POLICY_UNDETERMINED:
/* Fallthrough!
* The problem here is that we don't know the view to ask user
* for policy to follow for this cookie domain. Therefore we
* delete the cookie from jar and assume that we will be asked
* again in _cookie_permission_manager_on_response_received().
*/
default:
soup_cookie_jar_delete_cookie(inCookieJar, inNewCookie);
break;
}
}
static void
do_cookies_accept_policy_test (void)
{
SoupSession *session;
SoupMessage *msg;
SoupURI *uri;
SoupCookieJar *jar;
GSList *l, *p;
int i;
debug_printf (1, "SoupCookieJarAcceptPolicy test\n");
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);
soup_session_add_feature_by_type (session, SOUP_TYPE_COOKIE_JAR);
jar = SOUP_COOKIE_JAR (soup_session_get_feature (session, SOUP_TYPE_COOKIE_JAR));
for (i = 0; i < G_N_ELEMENTS (validResults); i++) {
soup_cookie_jar_set_accept_policy (jar, validResults[i].policy);
uri = soup_uri_new_with_base (first_party_uri, "/index.html");
msg = soup_message_new_from_uri ("GET", uri);
soup_message_set_first_party (msg, first_party_uri);
soup_session_send_message (session, msg);
soup_uri_free (uri);
g_object_unref (msg);
/* We can't use two servers due to limitations in
* test_server, so let's swap first and third party here
* to simulate a cookie coming from a third party.
*/
uri = soup_uri_new_with_base (first_party_uri, "/foo.jpg");
msg = soup_message_new_from_uri ("GET", uri);
soup_message_set_first_party (msg, third_party_uri);
soup_session_send_message (session, msg);
soup_uri_free (uri);
g_object_unref (msg);
l = soup_cookie_jar_all_cookies (jar);
if (g_slist_length (l) < validResults[i].n_cookies) {
debug_printf (1, " accepted less cookies than it should have\n");
errors++;
} else if (g_slist_length (l) > validResults[i].n_cookies) {
debug_printf (1, " accepted more cookies than it should have\n");
errors++;
}
for (p = l; p; p = p->next) {
soup_cookie_jar_delete_cookie (jar, p->data);
soup_cookie_free (p->data);
}
g_slist_free (l);
}
soup_test_session_abort_unref (session);
}
void deleteAllCookies(NetworkingContext* context)
{
SoupCookieJar* cookieJar = context ? cookieJarForContext(context) : soupCookieJar();
GOwnPtr<GSList> cookies(soup_cookie_jar_all_cookies(cookieJar));
for (GSList* item = cookies.get(); item; item = g_slist_next(item)) {
SoupCookie* cookie = static_cast<SoupCookie*>(item->data);
soup_cookie_jar_delete_cookie(cookieJar, cookie);
soup_cookie_free(cookie);
}
}
void deleteAllCookies(const NetworkStorageSession& session)
{
SoupCookieJar* cookieJar = cookieJarForSession(session);
GUniquePtr<GSList> cookies(soup_cookie_jar_all_cookies(cookieJar));
for (GSList* item = cookies.get(); item; item = g_slist_next(item)) {
SoupCookie* cookie = static_cast<SoupCookie*>(item->data);
soup_cookie_jar_delete_cookie(cookieJar, cookie);
soup_cookie_free(cookie);
}
}
void deleteCookiesForHostname(const NetworkStorageSession& session, const String& hostname)
{
CString hostNameString = hostname.utf8();
SoupCookieJar* cookieJar = cookieJarForSession(session);
GUniquePtr<GSList> cookies(soup_cookie_jar_all_cookies(cookieJar));
for (GSList* item = cookies.get(); item; item = g_slist_next(item)) {
SoupCookie* cookie = static_cast<SoupCookie*>(item->data);
if (soup_cookie_domain_matches(cookie, hostNameString.data()))
soup_cookie_jar_delete_cookie(cookieJar, cookie);
soup_cookie_free(cookie);
}
}
void deleteCookiesForHostname(NetworkingContext* context, const String& hostname)
{
CString hostNameString = hostname.utf8();
SoupCookieJar* cookieJar = context ? cookieJarForContext(context) : soupCookieJar();
GOwnPtr<GSList> cookies(soup_cookie_jar_all_cookies(cookieJar));
for (GSList* item = cookies.get(); item; item = g_slist_next(item)) {
SoupCookie* cookie = static_cast<SoupCookie*>(item->data);
if (soup_cookie_domain_matches(cookie, hostNameString.data()))
soup_cookie_jar_delete_cookie(cookieJar, cookie);
soup_cookie_free(cookie);
}
}
void ewk_cookies_clear(void)
{
GSList* list;
GSList* p;
SoupCookieJar* cookieJar = WebCore::soupCookieJar();
list = soup_cookie_jar_all_cookies(cookieJar);
for (p = list; p; p = p->next)
soup_cookie_jar_delete_cookie(cookieJar, (SoupCookie*)p->data);
soup_cookies_free(list);
}
gboolean
ossifer_session_delete_cookie (const gchar *name, const gchar *domain, const gchar *path)
{
SoupCookie *cookie = ossifer_session_get_cookie (name, domain, path);
if (cookie != NULL) {
soup_cookie_jar_delete_cookie (ossifer_session_get_cookie_jar (), cookie);
soup_cookie_free (cookie);
return TRUE;
}
return FALSE;
}
/**
* Clears all the cookies from the cookie jar.
*/
void ewk_cookies_clear(void)
{
#if USE(SOUP)
GSList* l;
GSList* p;
SoupCookieJar* cookieJar = WebCore::defaultCookieJar();
l = soup_cookie_jar_all_cookies(cookieJar);
for (p = l; p; p = p->next)
soup_cookie_jar_delete_cookie(cookieJar, (SoupCookie*)p->data);
soup_cookies_free(l);
#endif
}
void
reloadcookies() {
SoupCookieJar *jar;
GSList *l, *e;
lockcookie = TRUE;
for(l = e = soup_cookie_jar_all_cookies(cookies); e; e = e->next)
soup_cookie_jar_delete_cookie(cookies, (SoupCookie *)e->data);
soup_cookies_free(l);
jar = soup_cookie_jar_text_new(cookiefile, TRUE);
for(l = e = soup_cookie_jar_all_cookies(jar); e; e = e->next)
soup_cookie_jar_add_cookie(cookies, (SoupCookie *)e->data);
g_slist_free(l);
lockcookie = FALSE;
g_object_unref(jar);
}
/* Hide the authentication browser */
void
auth_browser_hide (AuthBrowser *browser)
{
AuthBrowserPrivate *priv = GET_PRIVATE (browser);
SoupSession *session = webkit_get_default_session ();
SoupCookieJar* jar = (SoupCookieJar*)soup_session_get_feature (session, SOUP_TYPE_COOKIE_JAR);
GSList *l, *p;
gtk_widget_hide (priv->window);
/* clear cookies */
l = soup_cookie_jar_all_cookies (jar);
for (p = l; p; p = p->next)
soup_cookie_jar_delete_cookie (jar, (SoupCookie*)p->data);
soup_cookies_free (l);
}
void
changecookie(SoupCookieJar *j, SoupCookie *oc, SoupCookie *c, gpointer p) {
SoupDate *e;
SoupCookieJar *jar;
if(lockcookie)
return;
if(c && c->expires == NULL) {
e = soup_date_new_from_time_t(time(NULL) + sessiontime);
c = soup_cookie_copy(c);
soup_cookie_set_expires(c, e);
}
jar = soup_cookie_jar_text_new(cookiefile, FALSE);
if(c)
soup_cookie_jar_add_cookie(jar, soup_cookie_copy(c));
else
soup_cookie_jar_delete_cookie(jar, oc);
g_object_unref(jar);
}
void deleteCookie(NetworkingContext* context, const KURL& url, const String& name)
{
SoupCookieJar* jar = context ? cookieJarForContext(context) : soupCookieJar();
if (!jar)
return;
GOwnPtr<GSList> cookies(soup_cookie_jar_all_cookies(jar));
if (!cookies)
return;
CString cookieName = name.utf8();
GOwnPtr<SoupURI> uri(soup_uri_new(url.string().utf8().data()));
for (GSList* iter = cookies.get(); iter; iter = g_slist_next(iter)) {
GOwnPtr<SoupCookie> cookie(static_cast<SoupCookie*>(iter->data));
if (!soup_cookie_applies_to_uri(cookie.get(), uri.get()))
continue;
if (cookieName == cookie->name)
soup_cookie_jar_delete_cookie(jar, cookie.get());
}
}
void ewk_cookies_cookie_del(Ewk_Cookie* cookie)
{
EINA_SAFETY_ON_NULL_RETURN(cookie);
GSList* list;
GSList* p;
SoupCookieJar* cookieJar = WebCore::soupCookieJar();
SoupCookie* cookie1 = soup_cookie_new(
cookie->name, cookie->value, cookie->domain, cookie->path, -1);
list = soup_cookie_jar_all_cookies(cookieJar);
for (p = list; p; p = p->next) {
SoupCookie* cookie2 = static_cast<SoupCookie*>(p->data);
if (soup_cookie_equal(cookie1, cookie2)) {
soup_cookie_jar_delete_cookie(cookieJar, cookie2);
break;
}
}
soup_cookie_free(cookie1);
soup_cookies_free(list);
}
void deleteCookie(const NetworkStorageSession& session, const URL& url, const String& name)
{
SoupCookieJar* jar = cookieJarForSession(session);
if (!jar)
return;
GUniquePtr<SoupURI> uri = url.createSoupURI();
GUniquePtr<GSList> cookies(soup_cookie_jar_get_cookie_list(jar, uri.get(), TRUE));
if (!cookies)
return;
CString cookieName = name.utf8();
bool wasDeleted = false;
for (GSList* iter = cookies.get(); iter; iter = g_slist_next(iter)) {
SoupCookie* cookie = static_cast<SoupCookie*>(iter->data);
if (!wasDeleted && cookieName == cookie->name) {
soup_cookie_jar_delete_cookie(jar, cookie);
wasDeleted = true;
}
soup_cookie_free(cookie);
}
}
/**
* Deletes a cookie from the cookie jar.
*
* Note that the fields name, value, domain and path are used to match this
* cookie in the cookie jar.
*
* @param cookie an @c Ewk_Cookie that has the info relative to that cookie.
*/
void ewk_cookies_cookie_del(Ewk_Cookie *cookie)
{
#if USE(SOUP)
EINA_SAFETY_ON_NULL_RETURN(cookie);
GSList* l;
GSList* p;
SoupCookieJar* cookieJar = WebCore::defaultCookieJar();
SoupCookie* c1 = soup_cookie_new(
cookie->name, cookie->value, cookie->domain, cookie->path, -1);
l = soup_cookie_jar_all_cookies(cookieJar);
for (p = l; p; p = p->next) {
SoupCookie* c2 = static_cast<SoupCookie*>(p->data);
if (soup_cookie_equal(c1, c2)) {
soup_cookie_jar_delete_cookie(cookieJar, c2);
break;
}
}
soup_cookie_free(c1);
soup_cookies_free(l);
#endif
}
/* Open database containing policies for cookie domains.
* Create database and setup table structure if it does not exist yet.
*/
static void _cookie_permission_manager_open_database(CookiePermissionManager *self)
{
CookiePermissionManagerPrivate *priv=self->priv;
const gchar *configDir;
gchar *error=NULL;
gint success;
sqlite3_stmt *statement=NULL;
/* Close any open database */
if(priv->database)
{
g_free(priv->databaseFilename);
priv->databaseFilename=NULL;
sqlite3_close(priv->database);
priv->database=NULL;
g_object_notify_by_pspec(G_OBJECT(self), CookiePermissionManagerProperties[PROP_DATABASE]);
g_object_notify_by_pspec(G_OBJECT(self), CookiePermissionManagerProperties[PROP_DATABASE_FILENAME]);
}
/* Build path to database file */
configDir=midori_extension_get_config_dir(priv->extension);
if(!configDir)
return;
if(katze_mkdir_with_parents(configDir, 0700))
{
g_warning(_("Could not create configuration folder for extension: %s"), g_strerror(errno));
_cookie_permission_manager_error(self, _("Could not create configuration folder for extension."));
return;
}
/* Open database */
priv->databaseFilename=g_build_filename(configDir, COOKIE_PERMISSION_DATABASE, NULL);
success=sqlite3_open(priv->databaseFilename, &priv->database);
if(success!=SQLITE_OK)
{
g_warning(_("Could not open database of extenstion: %s"), sqlite3_errmsg(priv->database));
g_free(priv->databaseFilename);
priv->databaseFilename=NULL;
if(priv->database) sqlite3_close(priv->database);
priv->database=NULL;
_cookie_permission_manager_error(self, _("Could not open database of extension."));
return;
}
/* Create table structure if it does not exist */
success=sqlite3_exec(priv->database,
"CREATE TABLE IF NOT EXISTS "
"policies(domain text, value integer);",
NULL,
NULL,
&error);
if(success==SQLITE_OK)
{
success=sqlite3_exec(priv->database,
"CREATE UNIQUE INDEX IF NOT EXISTS "
"domain ON policies (domain);",
NULL,
NULL,
&error);
}
if(success==SQLITE_OK)
{
success=sqlite3_exec(priv->database,
"PRAGMA journal_mode=TRUNCATE;",
NULL,
NULL,
&error);
}
if(success!=SQLITE_OK || error)
{
_cookie_permission_manager_error(self, _("Could not set up database structure of extension."));
if(error)
{
g_critical(_("Failed to execute database statement: %s"), error);
sqlite3_free(error);
}
g_free(priv->databaseFilename);
priv->databaseFilename=NULL;
sqlite3_close(priv->database);
priv->database=NULL;
return;
}
// Delete all cookies allowed only in one session
success=sqlite3_prepare_v2(priv->database,
"SELECT domain FROM policies WHERE value=? ORDER BY domain DESC;",
-1,
&statement,
NULL);
if(statement && success==SQLITE_OK) success=sqlite3_bind_int(statement, 1, COOKIE_PERMISSION_MANAGER_POLICY_ACCEPT_FOR_SESSION);
if(statement && success==SQLITE_OK)
{
while(sqlite3_step(statement)==SQLITE_ROW)
{
gchar *domain=(gchar*)sqlite3_column_text(statement, 0);
GSList *cookies, *cookie;
#ifdef HAVE_LIBSOUP_2_40_0
SoupURI *uri;
uri=soup_uri_new(NULL);
soup_uri_set_host(uri, domain);
soup_uri_set_path(uri, "/");
cookies=soup_cookie_jar_get_cookie_list(priv->cookieJar, uri, TRUE);
for(cookie=cookies; cookie; cookie=cookie->next)
{
soup_cookie_jar_delete_cookie(priv->cookieJar, (SoupCookie*)cookie->data);
}
soup_cookies_free(cookies);
soup_uri_free(uri);
#else
cookies=soup_cookie_jar_all_cookies(priv->cookieJar);
for(cookie=cookies; cookie; cookie=cookie->next)
{
if(soup_cookie_domain_matches((SoupCookie*)cookie->data, domain))
{
soup_cookie_jar_delete_cookie(priv->cookieJar, (SoupCookie*)cookie->data);
}
}
soup_cookies_free(cookies);
#endif
}
}
else g_warning(_("SQL fails: %s"), sqlite3_errmsg(priv->database));
sqlite3_finalize(statement);
g_object_notify_by_pspec(G_OBJECT(self), CookiePermissionManagerProperties[PROP_DATABASE]);
g_object_notify_by_pspec(G_OBJECT(self), CookiePermissionManagerProperties[PROP_DATABASE_FILENAME]);
}