JNIEXPORT void JNICALL WebKitGTK_NATIVE(_1soup_1cookie_1jar_1add_1cookie)
(JNIEnv *env, jclass that, jintLong arg0, jintLong arg1)
{
WebKitGTK_NATIVE_ENTER(env, that, _1soup_1cookie_1jar_1add_1cookie_FUNC);
soup_cookie_jar_add_cookie((SoupCookieJar *)arg0, (SoupCookie *)arg1);
WebKitGTK_NATIVE_EXIT(env, that, _1soup_1cookie_1jar_1add_1cookie_FUNC);
}
static int
callback (void *data, int argc, char **argv, char **colname)
{
SoupCookie *cookie = NULL;
SoupCookieJar *jar = SOUP_COOKIE_JAR (data);
char *name, *value, *host, *path;
time_t max_age, now;
gboolean http_only = FALSE, secure = FALSE;
now = time (NULL);
name = argv[COL_NAME];
value = argv[COL_VALUE];
host = argv[COL_HOST];
path = argv[COL_PATH];
max_age = strtoul (argv[COL_EXPIRY], NULL, 10) - now;
if (max_age <= 0)
return 0;
http_only = (strcmp (argv[COL_HTTP_ONLY], "1") == 0);
secure = (strcmp (argv[COL_SECURE], "1") == 0);
cookie = soup_cookie_new (name, value, host, path, max_age);
if (secure)
soup_cookie_set_secure (cookie, TRUE);
if (http_only)
soup_cookie_set_http_only (cookie, TRUE);
soup_cookie_jar_add_cookie (jar, cookie);
return 0;
}
gint
luaH_cookiejar_add_cookies(lua_State *L)
{
SoupCookieJar *sj = SOUP_COOKIE_JAR(soupconf.cookiejar);
LuakitCookieJar *j = LUAKIT_COOKIE_JAR(soupconf.cookiejar);
GSList *cookies;
gboolean silent = TRUE;
/* cookies table */
luaH_checktable(L, 1);
/* optional silent parameter */
if (lua_gettop(L) >= 2)
silent = luaH_checkboolean(L, 2);
/* get cookies from table */
if ((cookies = cookies_from_table(L, 1))) {
j->silent = silent;
/* insert cookies */
for (GSList *p = cookies; p; p = g_slist_next(p))
soup_cookie_jar_add_cookie(sj, soup_cookie_copy(p->data));
g_slist_free(cookies);
j->silent = FALSE;
}
return 0;
}
static void
parse_line (SoupCookieJar *jar, char *line, time_t now)
{
SoupCookie *cookie;
cookie = parse_cookie (line, now);
if (cookie)
soup_cookie_jar_add_cookie (jar, cookie);
}
static void
migrate_cookies ()
{
const char *cookies_file_sqlite = "cookies.sqlite";
const char *cookies_file_txt = "cookies.txt";
char *src_sqlite = NULL, *src_txt = NULL, *dest = NULL;
dest = g_build_filename (ephy_dot_dir (), cookies_file_sqlite, NULL);
/* If we already have a cookies.sqlite file, do nothing */
if (g_file_test (dest, G_FILE_TEST_EXISTS))
goto out;
src_sqlite = g_build_filename (ephy_dot_dir (), "mozilla",
"epiphany", cookies_file_sqlite, NULL);
src_txt = g_build_filename (ephy_dot_dir (), "mozilla",
"epiphany", cookies_file_txt, NULL);
/* First check if we have a cookies.sqlite file in Mozilla */
if (g_file_test (src_sqlite, G_FILE_TEST_EXISTS)) {
GFile *gsrc, *gdest;
/* Copy the file */
gsrc = g_file_new_for_path (src_sqlite);
gdest = g_file_new_for_path (dest);
if (!g_file_copy (gsrc, gdest, 0, NULL, NULL, NULL, NULL))
g_warning (_("Failed to copy cookies file from Mozilla."));
g_object_unref (gsrc);
g_object_unref (gdest);
} else if (g_file_test (src_txt, G_FILE_TEST_EXISTS)) {
/* Create a SoupCookieJarSQLite with the contents of the txt file */
GSList *cookies, *p;
SoupCookieJar *txt, *sqlite;
txt = soup_cookie_jar_text_new (src_txt, TRUE);
sqlite = soup_cookie_jar_sqlite_new (dest, FALSE);
cookies = soup_cookie_jar_all_cookies (txt);
for (p = cookies; p; p = p->next) {
SoupCookie *cookie = (SoupCookie*)p->data;
/* Cookie is stolen, so we won't free it */
soup_cookie_jar_add_cookie (sqlite, cookie);
}
g_slist_free (cookies);
g_object_unref (txt);
g_object_unref (sqlite);
}
out:
g_free (src_sqlite);
g_free (src_txt);
g_free (dest);
}
void
ossifer_session_set_cookie (const gchar *name, const gchar *value,
const gchar *domain, const gchar *path, gint max_age)
{
SoupCookie *cookie;
SoupCookieJar *cookie_jar = ossifer_session_get_cookie_jar ();
g_return_if_fail (cookie_jar != NULL);
cookie = soup_cookie_new (name, value, domain, path, max_age);
soup_cookie_jar_add_cookie (cookie_jar, cookie);
}
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);
}
void
setcookie(SoupCookie *c) {
int lock;
lock = open(cookiefile, 0);
flock(lock, LOCK_EX);
SoupDate *e;
SoupCookieJar *j = soup_cookie_jar_text_new(cookiefile, FALSE);
c = soup_cookie_copy(c);
if(c->expires == NULL && sessiontime) {
e = soup_date_new_from_time_t(time(NULL) + sessiontime);
soup_cookie_set_expires(c, e);
}
soup_cookie_jar_add_cookie(j, c);
g_object_unref(j);
flock(lock, LOCK_UN);
close(lock);
}
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);
}
static void
create_cookie_jar_for_domain (const char *address, const char *directory)
{
GSList *cookies, *p;
SoupCookieJar *current_jar, *new_jar;
char *domain, *filename;
SoupURI *uri;
/* Create the new cookie jar */
filename = g_build_filename (directory, "cookies.sqlite", NULL);
new_jar = (SoupCookieJar*)soup_cookie_jar_sqlite_new (filename, FALSE);
g_free (filename);
/* The app domain for the current view */
uri = soup_uri_new (address);
domain = uri->host;
/* The current cookies */
current_jar = get_current_cookie_jar ();
if (!current_jar) {
soup_uri_free (uri);
return;
}
cookies = soup_cookie_jar_all_cookies (current_jar);
for (p = cookies; p; p = p->next) {
SoupCookie *cookie = (SoupCookie*)p->data;
if (soup_cookie_domain_matches (cookie, domain))
soup_cookie_jar_add_cookie (new_jar, cookie);
else
soup_cookie_free (cookie);
}
soup_uri_free (uri);
g_slist_free (cookies);
g_object_unref (current_jar);
g_object_unref (new_jar);
}
void addCookie(const NetworkStorageSession& session, const URL&, const Cookie& cookie)
{
soup_cookie_jar_add_cookie(cookieJarForSession(session), toSoupCookie(cookie));
}
/* 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);
}
