Eina_List* ewk_cookies_get_all(void)
{
Eina_List* result = 0;
GSList* list;
GSList* p;
SoupCookieJar* cookieJar = WebCore::soupCookieJar();
list = soup_cookie_jar_all_cookies(cookieJar);
for (p = list; p; p = p->next) {
SoupCookie* cookie = static_cast<SoupCookie*>(p->data);
Ewk_Cookie* ewkCookie = new Ewk_Cookie;
ewkCookie->name = eina_stringshare_add(cookie->name);
ewkCookie->value = eina_stringshare_add(cookie->value);
ewkCookie->domain = eina_stringshare_add(cookie->domain);
ewkCookie->path = eina_stringshare_add(cookie->path);
ewkCookie->expires = soup_date_to_time_t(cookie->expires);
ewkCookie->secure = static_cast<Eina_Bool>(cookie->secure);
ewkCookie->http_only = static_cast<Eina_Bool>(cookie->http_only);
result = eina_list_append(result, ewkCookie);
}
soup_cookies_free(list);
return result;
}
void setCookiesFromDOM(const NetworkStorageSession& session, const URL& firstParty, const URL& url, const String& value)
{
SoupCookieJar* jar = cookieJarForSession(session);
if (!jar)
return;
GUniquePtr<SoupURI> origin = url.createSoupURI();
GUniquePtr<SoupURI> firstPartyURI = firstParty.createSoupURI();
// Get existing cookies for this origin.
GSList* existingCookies = soup_cookie_jar_get_cookie_list(jar, origin.get(), TRUE);
Vector<String> cookies;
value.split('\n', cookies);
const size_t cookiesCount = cookies.size();
for (size_t i = 0; i < cookiesCount; ++i) {
GUniquePtr<SoupCookie> cookie(soup_cookie_parse(cookies[i].utf8().data(), origin.get()));
if (!cookie)
continue;
// Make sure the cookie is not httpOnly since such cookies should not be set from JavaScript.
if (soup_cookie_get_http_only(cookie.get()))
continue;
// Make sure we do not overwrite httpOnly cookies from JavaScript.
if (httpOnlyCookieExists(existingCookies, soup_cookie_get_name(cookie.get()), soup_cookie_get_path(cookie.get())))
continue;
soup_cookie_jar_add_cookie_with_first_party(jar, firstPartyURI.get(), cookie.release());
}
soup_cookies_free(existingCookies);
}
/**
* Returns a list of cookies in the cookie jar.
*
* @return an @c Eina_List with all the cookies in the cookie jar.
*/
Eina_List* ewk_cookies_get_all(void)
{
Eina_List* el = 0;
#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) {
SoupCookie* cookie = static_cast<SoupCookie*>(p->data);
Ewk_Cookie* c = static_cast<Ewk_Cookie*>(malloc(sizeof(*c)));
c->name = strdup(cookie->name);
c->value = strdup(cookie->value);
c->domain = strdup(cookie->domain);
c->path = strdup(cookie->path);
c->expires = soup_date_to_time_t(cookie->expires);
c->secure = static_cast<Eina_Bool>(cookie->secure);
c->http_only = static_cast<Eina_Bool>(cookie->http_only);
el = eina_list_append(el, c);
}
soup_cookies_free(l);
#endif
return el;
}
void
soup_cookie_jar_delete_cookie(SoupCookieJar *jar, SoupCookie *c)
{
GSList *cf;
SoupCookie *ci;
print_cookie("soup_cookie_jar_delete_cookie", c);
if (cookies_enabled == 0)
return;
if (jar == NULL || c == NULL)
return;
/* find and remove from persistent jar */
cf = soup_cookie_jar_all_cookies(p_cookiejar);
for (;cf; cf = cf->next) {
ci = cf->data;
if (soup_cookie_equal(ci, c)) {
_soup_cookie_jar_delete_cookie(p_cookiejar, ci);
break;
}
}
soup_cookies_free(cf);
/* delete from session jar */
_soup_cookie_jar_delete_cookie(s_cookiejar, c);
}
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);
}
void
gotheaders(SoupMessage *msg, gpointer v) {
SoupURI *uri;
GSList *l, *p;
uri = soup_message_get_uri(msg);
for(p = l = soup_cookies_from_response(msg); p;
p = g_slist_next(p)) {
setcookie((SoupCookie *)p->data);
}
soup_cookies_free(l);
}
static void
finalize (GObject *object)
{
SoupCookieJarPrivate *priv = SOUP_COOKIE_JAR_GET_PRIVATE (object);
GHashTableIter iter;
gpointer key, value;
g_hash_table_iter_init (&iter, priv->domains);
while (g_hash_table_iter_next (&iter, &key, &value))
soup_cookies_free (value);
g_hash_table_destroy (priv->domains);
G_OBJECT_CLASS (soup_cookie_jar_parent_class)->finalize (object);
}
/**
* 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
transfer_cookies(void)
{
GSList *cf;
SoupCookie *sc, *pc;
cf = soup_cookie_jar_all_cookies(p_cookiejar);
for (;cf; cf = cf->next) {
pc = cf->data;
sc = soup_cookie_copy(pc);
_soup_cookie_jar_add_cookie(s_cookiejar, sc);
}
soup_cookies_free(cf);
}
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 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);
}
/**
* 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
}
SoupCookie *
ossifer_session_get_cookie (const gchar *name, const gchar *domain, const gchar *path)
{
GSList *cookies;
GSList *item;
SoupCookie *found_cookie = NULL;
cookies = soup_cookie_jar_all_cookies (ossifer_session_get_cookie_jar ());
for (item = cookies; item != NULL; item = item->next) {
SoupCookie *cookie = (SoupCookie *)item->data;
if (g_str_equal (name, cookie->name) &&
g_str_equal (domain, cookie->domain) &&
g_str_equal (path, cookie->path)) {
found_cookie = soup_cookie_copy (cookie);
break;
}
}
soup_cookies_free (cookies);
return found_cookie;
}
static void
do_get (OtTrivialHttpd *self,
SoupServer *server,
SoupMessage *msg,
const char *path,
SoupClientContext *context)
{
char *slash;
int ret;
struct stat stbuf;
httpd_log (self, "serving %s\n", path);
if (opt_expected_cookies)
{
GSList *cookies = soup_cookies_from_request (msg);
GSList *l;
int i;
for (i = 0 ; opt_expected_cookies[i] != NULL; i++)
{
gboolean found = FALSE;
gchar *k = opt_expected_cookies[i];
gchar *v = strchr (k, '=') + 1;
for (l = cookies; l != NULL ; l = g_slist_next (l))
{
SoupCookie *c = l->data;
if (!strncmp (k, soup_cookie_get_name (c), v - k - 1) &&
!strcmp (v, soup_cookie_get_value (c)))
{
found = TRUE;
break;
}
}
if (!found)
{
httpd_log (self, "Expected cookie not found %s\n", k);
soup_message_set_status (msg, SOUP_STATUS_FORBIDDEN);
soup_cookies_free (cookies);
goto out;
}
}
soup_cookies_free (cookies);
}
if (opt_expected_headers)
{
for (int i = 0 ; opt_expected_headers[i] != NULL; i++)
{
const gchar *kv = opt_expected_headers[i];
const gchar *eq = strchr (kv, '=');
g_assert (eq);
{
g_autofree char *k = g_strndup (kv, eq - kv);
const gchar *expected_v = eq + 1;
const gchar *found_v = soup_message_headers_get_one (msg->request_headers, k);
if (!found_v)
{
httpd_log (self, "Expected header not found %s\n", k);
soup_message_set_status (msg, SOUP_STATUS_FORBIDDEN);
goto out;
}
if (strcmp (found_v, expected_v) != 0)
{
httpd_log (self, "Expected header %s: %s but found %s\n", k, expected_v, found_v);
soup_message_set_status (msg, SOUP_STATUS_FORBIDDEN);
goto out;
}
}
}
}
if (strstr (path, "../") != NULL)
{
soup_message_set_status (msg, SOUP_STATUS_FORBIDDEN);
goto out;
}
if (opt_random_500s_percentage > 0 &&
emitted_random_500s_count < opt_random_500s_max &&
g_random_int_range (0, 100) < opt_random_500s_percentage)
{
emitted_random_500s_count++;
soup_message_set_status (msg, SOUP_STATUS_INTERNAL_SERVER_ERROR);
goto out;
}
while (path[0] == '/')
path++;
do
ret = fstatat (self->root_dfd, path, &stbuf, 0);
while (ret == -1 && errno == EINTR);
if (ret == -1)
{
if (errno == EPERM)
soup_message_set_status (msg, SOUP_STATUS_FORBIDDEN);
else if (errno == ENOENT)
soup_message_set_status (msg, SOUP_STATUS_NOT_FOUND);
else
soup_message_set_status (msg, SOUP_STATUS_INTERNAL_SERVER_ERROR);
goto out;
}
if (!is_safe_to_access (&stbuf))
{
soup_message_set_status (msg, SOUP_STATUS_FORBIDDEN);
goto out;
}
if (S_ISDIR (stbuf.st_mode))
{
slash = strrchr (path, '/');
if (!slash || slash[1])
{
g_autofree char *redir_uri = NULL;
redir_uri = g_strdup_printf ("%s/", soup_message_get_uri (msg)->path);
soup_message_set_redirect (msg, SOUP_STATUS_MOVED_PERMANENTLY,
redir_uri);
}
else
{
g_autofree char *index_realpath = g_strconcat (path, "/index.html", NULL);
if (fstatat (self->root_dfd, index_realpath, &stbuf, 0) != -1)
{
g_autofree char *index_path = g_strconcat (path, "/index.html", NULL);
do_get (self, server, msg, index_path, context);
}
else
{
GString *listing = get_directory_listing (self->root_dfd, path);
soup_message_set_response (msg, "text/html",
SOUP_MEMORY_TAKE,
listing->str, listing->len);
soup_message_set_status (msg, SOUP_STATUS_OK);
g_string_free (listing, FALSE);
}
}
}
else
{
if (!S_ISREG (stbuf.st_mode))
{
soup_message_set_status (msg, SOUP_STATUS_FORBIDDEN);
goto out;
}
if (msg->method == SOUP_METHOD_GET)
{
glnx_autofd int fd = -1;
g_autoptr(GMappedFile) mapping = NULL;
gsize buffer_length, file_size;
SoupRange *ranges;
int ranges_length;
gboolean have_ranges;
fd = openat (self->root_dfd, path, O_RDONLY | O_CLOEXEC);
if (fd < 0)
{
soup_message_set_status (msg, SOUP_STATUS_INTERNAL_SERVER_ERROR);
goto out;
}
mapping = g_mapped_file_new_from_fd (fd, FALSE, NULL);
if (!mapping)
{
soup_message_set_status (msg, SOUP_STATUS_INTERNAL_SERVER_ERROR);
goto out;
}
(void) close (fd); fd = -1;
file_size = g_mapped_file_get_length (mapping);
have_ranges = soup_message_headers_get_ranges(msg->request_headers, file_size, &ranges, &ranges_length);
if (opt_force_ranges && !have_ranges && g_strrstr (path, "/objects") != NULL)
{
SoupSocket *sock;
buffer_length = file_size/2;
soup_message_headers_set_content_length (msg->response_headers, file_size);
soup_message_headers_append (msg->response_headers,
"Connection", "close");
/* soup-message-io will wait for us to add
* another chunk after the first, to fill out
* the declared Content-Length. Instead, we
* forcibly close the socket at that point.
*/
sock = soup_client_context_get_socket (context);
g_signal_connect (msg, "wrote-chunk", G_CALLBACK (close_socket), sock);
}
else
buffer_length = file_size;
if (have_ranges)
{
if (ranges_length > 0 && ranges[0].start >= file_size)
{
soup_message_set_status (msg, SOUP_STATUS_REQUESTED_RANGE_NOT_SATISFIABLE);
soup_message_headers_free_ranges (msg->request_headers, ranges);
goto out;
}
soup_message_headers_free_ranges (msg->request_headers, ranges);
}
if (buffer_length > 0)
{
SoupBuffer *buffer;
buffer = soup_buffer_new_with_owner (g_mapped_file_get_contents (mapping),
buffer_length,
g_mapped_file_ref (mapping),
(GDestroyNotify)g_mapped_file_unref);
soup_message_body_append_buffer (msg->response_body, buffer);
soup_buffer_free (buffer);
}
}
else /* msg->method == SOUP_METHOD_HEAD */
{
g_autofree char *length = NULL;
/* We could just use the same code for both GET and
* HEAD (soup-message-server-io.c will fix things up).
* But we'll optimize and avoid the extra I/O.
*/
length = g_strdup_printf ("%lu", (gulong)stbuf.st_size);
soup_message_headers_append (msg->response_headers,
"Content-Length", length);
}
soup_message_set_status (msg, SOUP_STATUS_OK);
}
out:
{
guint status = 0;
g_autofree gchar *reason = NULL;
g_object_get (msg,
"status-code", &status,
"reason-phrase", &reason,
NULL);
httpd_log (self, " status: %s (%u)\n", reason, status);
}
return;
}
/* 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]);
}
int feed_main(match_data **feed_matches, int *feed_matches_counter) {
omnibet_match_data omnibet_match;
GSList *cookies;
char tmp_file[1024];
char tmp_file2[1024];
char tmp_file3[1024];
memset(&omnibet_match.match_time[0], '\0', sizeof(omnibet_match.match_time));
memset(&omnibet_match.team_home[0], '\0', sizeof(omnibet_match.team_home));
memset(&omnibet_match.team_away[0], '\0', sizeof(omnibet_match.team_away));
omnibet_match.score_home = 0;
omnibet_match.score_away = 0;
omnibet_match.stage = -1;
omnibet_match.skip = FALSE;
struct passwd *pw = getpwuid(getuid());
snprintf(&tmp_file[0], sizeof(tmp_file), "%s-%u", OMNIBET_FILENAME, pw->pw_uid);
snprintf(&tmp_file2[0], sizeof(tmp_file), "%s-%u-a", OMNIBET_FILENAME, pw->pw_uid);
// Get our cookie from main page
if (get_url(OMNIBET_URL1, OMNIBET_USER_AGENT, &tmp_file[0], NULL, &cookies))
return 1;
// Fetch actual page
if (get_url(OMNIBET_URL2, OMNIBET_USER_AGENT, &tmp_file[0], cookies, NULL)) {
if (cookies)
soup_cookies_free(cookies);
return 1;
}
if (cookies)
soup_cookies_free(cookies);
char *orig_xml = omnibet_load_file(&tmp_file[0]);
if (!orig_xml)
return 0;
char *fixed_xml2 = omnibet_replace(orig_xml, "<strong>", "<strong custom=livescore>");
if (!fixed_xml2)
return 0;
FILE *fp = fopen (&tmp_file2[0], "w");
if (!fp) {
printf("Cannot open output file!\n");
return 0;
}
fprintf(fp, "%s\n", fixed_xml2);
fclose(fp);
htmlDocPtr parser = htmlReadFile(&tmp_file2[0], OMNIBET_CHARSET,
HTML_PARSE_RECOVER |
//HTML_PARSE_NOBLANKS |
HTML_PARSE_NOERROR |
HTML_PARSE_NOWARNING |
#ifdef HAVE_MATE
HTML_PARSE_NOIMPLIED |
#endif
HTML_PARSE_COMPACT);
omnibet_walk_tree(xmlDocGetRootElement(parser), &omnibet_match, feed_matches, feed_matches_counter);
xmlFreeDoc(parser);
free(orig_xml);
free(fixed_xml2);
return 1;
}
int
wl_save(struct tab *t, struct karg *args, int list)
{
char file[PATH_MAX], *lst_str = NULL;
FILE *f = NULL;
char *line = NULL, *lt = NULL, *dom;
size_t linelen;
const gchar *uri;
struct karg a;
struct domain *d;
GSList *cf;
SoupCookie *ci, *c;
if (t == NULL || args == NULL)
return (1);
if (runtime_settings[0] == '\0')
return (1);
switch (list) {
case XT_WL_JAVASCRIPT:
lst_str = "JavaScript";
break;
case XT_WL_COOKIE:
lst_str = "Cookie";
break;
case XT_WL_PLUGIN:
lst_str = "Plugin";
break;
default:
show_oops(t, "Invalid list id: %d", list);
return (1);
}
uri = get_uri(t);
dom = find_domain(uri, args->i & XT_WL_TOPLEVEL);
if (uri == NULL || dom == NULL ||
webkit_web_view_get_load_status(t->wv) == WEBKIT_LOAD_FAILED) {
show_oops(t, "Can't add domain to %s white list", lst_str);
goto done;
}
switch (list) {
case XT_WL_JAVASCRIPT:
lt = g_strdup_printf("js_wl=%s", dom);
break;
case XT_WL_COOKIE:
lt = g_strdup_printf("cookie_wl=%s", dom);
break;
case XT_WL_PLUGIN:
lt = g_strdup_printf("pl_wl=%s", dom);
break;
default:
/* can't happen */
show_oops(t, "Invalid list id: %d", list);
goto done;
}
snprintf(file, sizeof file, "%s" PS "%s", work_dir, runtime_settings);
if ((f = fopen(file, "r+")) == NULL) {
show_oops(t, "can't open file %s");
goto done;
}
while (!feof(f)) {
line = fparseln(f, &linelen, NULL, NULL, 0);
if (line == NULL)
continue;
if (!strcmp(line, lt))
goto done;
free(line);
line = NULL;
}
fprintf(f, "%s\n", lt);
a.i = XT_WL_ENABLE;
a.i |= args->i;
switch (list) {
case XT_WL_JAVASCRIPT:
d = wl_find(dom, &js_wl);
if (!d) {
settings_add("js_wl", dom);
d = wl_find(dom, &js_wl);
}
toggle_js(t, &a);
break;
case XT_WL_COOKIE:
d = wl_find(dom, &c_wl);
if (!d) {
settings_add("cookie_wl", dom);
d = wl_find(dom, &c_wl);
}
toggle_cwl(t, &a);
/* find and add to persistent jar */
cf = soup_cookie_jar_all_cookies(s_cookiejar);
for (;cf; cf = cf->next) {
ci = cf->data;
if (!strcmp(dom, ci->domain) ||
!strcmp(&dom[1], ci->domain)) /* deal with leading . */ {
c = soup_cookie_copy(ci);
_soup_cookie_jar_add_cookie(p_cookiejar, c);
}
}
soup_cookies_free(cf);
break;
case XT_WL_PLUGIN:
d = wl_find(dom, &pl_wl);
if (!d) {
settings_add("pl_wl", dom);
d = wl_find(dom, &pl_wl);
}
toggle_pl(t, &a);
break;
default:
abort(); /* can't happen */
}
if (d)
d->handy = 1;
done:
if (line)
free(line);
if (dom)
g_free(dom);
if (lt)
g_free(lt);
if (f)
fclose(f);
return (0);
}
