/* -*- Mode: C; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2; -*- */
/*
* Copyright © 2017, 2019 Igalia S.L.
*
* This file is part of Epiphany.
*
* Epiphany is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Epiphany is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Epiphany. If not, see .
*/
#include "config.h"
#include "ephy-filters-manager.h"
#include "ephy-debug.h"
#include "ephy-download.h"
#include "ephy-file-helpers.h"
#include "ephy-prefs.h"
#include "ephy-settings.h"
#include "ephy-embed-shell.h"
#include
#include
#define ADBLOCK_FILTER_UPDATE_FREQUENCY 24 * 60 * 60 /* In seconds */
#define ADBLOCK_FILTER_SIDECAR_FILE_SUFFIX ".filterinfo"
struct _EphyFiltersManager {
GObject parent_instance;
gboolean is_initialized;
char *filters_dir;
GHashTable *filters; /* (identifier, FilterInfo) */
gint64 update_time;
guint update_timeout_id;
GCancellable *cancellable;
WebKitUserContentFilter *wk_filter;
WebKitUserContentFilterStore *store;
};
G_DEFINE_TYPE (EphyFiltersManager, ephy_filters_manager, G_TYPE_OBJECT)
enum {
FILTER_READY,
FILTER_REMOVED,
FILTERS_DISABLED,
LAST_SIGNAL,
};
static guint s_signals[LAST_SIGNAL];
enum {
PROP_0,
PROP_FILTERS_DIR,
PROP_IS_INITIALIZED,
N_PROPERTIES
};
static GParamSpec *object_properties[N_PROPERTIES] = { NULL, };
typedef struct {
EphyFiltersManager *manager;
char *identifier; /* Lazily derived from source_uri. */
char *source_uri; /* Saved. */
char *checksum; /* Saved. */
gint64 last_update; /* Saved, seconds since the Epoch. */
gboolean found : 1; /* WebKitUserContentFilter found during lookup. */
gboolean local : 1; /* The source_uri is a local file URI. */
gboolean done : 1; /* Filter setup done (successfully or errored). */
} FilterInfo;
/* The "saved" fields from the struct above are stored as versioned sidecar
* metadata files, using GVariant for serialization. An integer indicating
* the version of the on-disk format is prepended to the data, and it must
* be increased by 1 in the source code whenever the GVariant format below
* changes.
*/
#define FILTER_INFO_VARIANT_VERSION ((uint32_t)2)
#define FILTER_INFO_VARIANT_FORMAT "(usmsx)"
static void filter_info_setup_done (FilterInfo *self);
static void
filter_info_free (FilterInfo *self)
{
g_clear_weak_pointer (&self->manager);
g_clear_pointer (&self->identifier, g_free);
g_clear_pointer (&self->source_uri, g_free);
g_clear_pointer (&self->checksum, g_free);
g_free (self);
}
G_DEFINE_AUTOPTR_CLEANUP_FUNC (FilterInfo, filter_info_free)
static FilterInfo *
filter_info_new (const char *source_uri,
EphyFiltersManager *manager)
{
g_autoptr (FilterInfo) self = NULL;
g_assert (source_uri);
g_assert (manager);
self = g_new0 (FilterInfo, 1);
self->source_uri = g_strdup (source_uri);
self->last_update = G_MININT64; /* Oldest possible time: never updated. */
g_set_weak_pointer (&self->manager, manager);
return g_steal_pointer (&self);
}
static gboolean
filter_info_load_from_bytes (FilterInfo *self,
GBytes *data,
GError **error)
{
uint32_t saved_version = 0;
g_autofree char *source_uri = NULL;
g_autofree char *checksum = NULL;
guint64 last_update = 0;
g_autoptr (GVariantType) value_type = g_variant_type_new (FILTER_INFO_VARIANT_FORMAT);
g_autoptr (GVariant) value = g_variant_ref_sink (g_variant_new_from_bytes (value_type, data, TRUE));
if (!value) {
g_set_error_literal (error,
G_IO_ERROR,
G_IO_ERROR_INVALID_ARGUMENT,
"Cannot decode GVariant from bytes");
return FALSE;
}
g_variant_get_child (value, 0, "u", &saved_version);
if (saved_version != FILTER_INFO_VARIANT_VERSION) {
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_INVALID_DATA,
"Attempted to decode content filter data GVariant with"
" format version %" PRIu32 " (expected %" PRIu32 ")",
saved_version,
FILTER_INFO_VARIANT_VERSION);
return FALSE;
}
g_variant_get (value,
FILTER_INFO_VARIANT_FORMAT,
NULL, /* Ignore the version, it has been checked already. */
&source_uri,
&checksum,
&last_update);
if (strcmp (source_uri, self->source_uri) != 0) {
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_INVALID_DATA,
"Attempted to decode content filter data GVariant with"
" wrong filter URI <%s> (expected <%s>)",
source_uri,
self->source_uri);
return FALSE;
}
/* All sanity checks passed. The "source_uri" member does not need to
* be updated in the struct because at this point it is known to be the
* same as in the sidecar metadata file, and the same applies to the
* "identifier" field.
*/
g_clear_pointer (&self->checksum, g_free);
self->checksum = g_steal_pointer (&checksum);
self->last_update = last_update;
LOG ("Loaded metadata: uri=<%s>, identifier=%s, checksum=%s, last_update=%" PRIu64,
self->source_uri,
self->identifier,
self->checksum,
self->last_update);
return TRUE;
}
static char *
filter_info_identifier_for_source_uri (const char *source_uri)
{
g_assert (source_uri);
return g_compute_checksum_for_string (G_CHECKSUM_SHA256, source_uri, -1);
}
static const char *
filter_info_get_identifier (FilterInfo *self)
{
g_assert (self);
if (!self->identifier)
self->identifier = filter_info_identifier_for_source_uri (self->source_uri);
return self->identifier;
}
static GFile *
filter_info_get_sidecar_file (FilterInfo *self)
{
const char *filters_dir = ephy_filters_manager_get_adblock_filters_dir (self->manager);
g_autofree char *sidecar_filename = g_strconcat (filter_info_get_identifier (self),
ADBLOCK_FILTER_SIDECAR_FILE_SUFFIX,
NULL);
return g_file_new_build_filename (filters_dir, sidecar_filename, NULL);
}
static void
sidecar_bytes_loaded_cb (GFile *file,
GAsyncResult *result,
GTask *task)
{
GError *error = NULL;
FilterInfo *self = g_task_get_task_data (task);
g_autoptr (GBytes) data = g_file_load_bytes_finish (file,
result,
NULL, /* etag_out */
&error);
if (data && filter_info_load_from_bytes (self, data, &error)) {
g_task_return_boolean (task, TRUE);
} else {
g_task_return_error (task, error);
}
g_object_unref (task);
}
static void
filter_info_load_sidecar (FilterInfo *self,
GCancellable *cancellable,
GAsyncReadyCallback callback,
void *user_data)
{
g_autoptr (GFile) sidecar_file = filter_info_get_sidecar_file (self);
g_autofree char *sidecar_file_path = g_file_get_path (sidecar_file);
GFileType file_type = g_file_query_file_type (sidecar_file,
G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS,
NULL);
if (file_type != G_FILE_TYPE_REGULAR) {
int error_code;
const char *message;
if (file_type == G_FILE_TYPE_UNKNOWN) {
error_code = G_IO_ERROR_NOT_FOUND;
message = "File not found";
} else {
error_code = G_IO_ERROR_NOT_REGULAR_FILE;
message = "Not a regular file";
}
g_task_report_new_error (NULL,
callback,
user_data,
filter_info_load_sidecar,
G_IO_ERROR,
error_code,
"%s: %s",
sidecar_file_path,
message);
} else {
GTask *task = g_task_new (NULL,
cancellable,
callback,
user_data);
g_autofree char *task_name = g_strconcat ("load sidecar file: ",
sidecar_file_path,
NULL);
/* The FilterInfo itself as used async task data: it already contains
* all the bits of information needed by the completion callback.
*/
g_task_set_task_data (task, self, NULL);
g_task_set_name (task, task_name);
g_file_load_bytes_async (sidecar_file,
g_task_get_cancellable (task),
(GAsyncReadyCallback)sidecar_bytes_loaded_cb,
task);
}
}
static gboolean
filter_info_load_sidecar_finish (GAsyncResult *result,
GError **error)
{
return g_task_propagate_boolean (G_TASK (result), error);
}
static GBytes *
filter_info_get_data_as_bytes (FilterInfo *self)
{
g_autoptr (GVariant) value = g_variant_ref_sink (g_variant_new (FILTER_INFO_VARIANT_FORMAT,
FILTER_INFO_VARIANT_VERSION,
self->source_uri,
self->checksum,
self->last_update));
return g_variant_get_data_as_bytes (value);
}
static void
sidecar_contents_replaced_cb (GFile *file,
GAsyncResult *result,
GTask *task)
{
GError *error = NULL;
if (g_file_replace_contents_finish (file,
result,
NULL, /* new_etag */
&error)) {
g_task_return_boolean (task, TRUE);
} else {
g_task_return_error (task, error);
}
}
static void
filter_info_save_sidecar (FilterInfo *self,
GCancellable *cancellable,
GAsyncReadyCallback callback,
void *user_data)
{
g_autoptr (GBytes) data = filter_info_get_data_as_bytes (self);
g_autoptr (GFile) sidecar_file = filter_info_get_sidecar_file (self);
g_autofree char *sidecar_file_path = g_file_get_path (sidecar_file);
g_autofree char *task_name = g_strconcat ("save sidecar file: ",
sidecar_file_path,
NULL);
GTask *task = g_task_new (NULL, cancellable, callback, user_data);
g_task_set_name (task, task_name);
LOG ("Saving metadata: uri=<%s>, identifier=%s, checksum=%s, last_update=%" PRIu64,
self->source_uri,
self->identifier,
self->checksum,
self->last_update);
/* Using G_FILE_CREATE_REPLACE_DESTINATION is needed to ensure that
* different processes trying to write the same file replace its
* contents atomically so there is no partially written data. If two
* processes write the same file, the one which finishes writing later
* "wins", but that is fine because both would have downloaded the
* same rule set and their metadata files will only have a slightly
* different (but very close) timestamp.
*/
g_file_replace_contents_bytes_async (sidecar_file,
data,
NULL, /* etag */
FALSE, /* make_backup */
G_FILE_CREATE_PRIVATE | G_FILE_CREATE_REPLACE_DESTINATION,
g_task_get_cancellable (task),
(GAsyncReadyCallback)sidecar_contents_replaced_cb,
task);
}
static gboolean
filter_info_save_sidecar_finish (GAsyncResult *result,
GError **error)
{
return g_task_propagate_boolean (G_TASK (result), error);
}
static GFile *
filter_info_get_source_file (FilterInfo *self)
{
/* It is possible that different Epiphany processes try to download the
* same ruleset file simultanously. Using different file names ensures
* that they do not step on each other toes when writing the downloaded
* data to disk.
*/
g_autofree char *filename = g_strdup_printf ("%s-%" G_PID_FORMAT ".json",
filter_info_get_identifier (self),
getpid ());
const char *filters_dir = ephy_filters_manager_get_adblock_filters_dir (self->manager);
return g_file_new_build_filename (filters_dir, filename, NULL);
}
static void
filter_info_setup_enable_compiled_filter (FilterInfo *self,
WebKitUserContentFilter *wk_filter)
{
g_assert (self);
g_assert (wk_filter);
LOG ("Emitting EphyFiltersManager::filter-ready for %s.", filter_info_get_identifier (self));
g_signal_emit (self->manager, s_signals[FILTER_READY], 0, wk_filter);
}
static gboolean
filter_info_needs_updating_from_source (const FilterInfo *self)
{
g_assert (self);
if (!self->manager)
return FALSE;
/* For local files, check whether their modification time is newer
* than the last update time saved for it.
*/
if (self->local) {
g_autoptr (GDateTime) modification_time = NULL;
g_autoptr (GError) error = NULL;
g_autoptr (GFile) source_file = g_file_new_for_uri (self->source_uri);
g_autoptr (GFileInfo) info = g_file_query_info (source_file,
G_FILE_ATTRIBUTE_TIME_MODIFIED,
G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS,
NULL,
&error);
if (!info) {
g_warning ("Cannot get file modification time: %s", error->message);
return TRUE;
}
modification_time = g_file_info_get_modification_date_time (info);
return g_date_time_to_unix (modification_time) > self->last_update;
}
/*
* For remote filters, check the time elapsed since the last fetch.
*
* Note that timestamps are signed; calculating (update time - last update)
* can overflow. Instead find the point in time after which a filter should
* have been last updated to be considered "recent enough" (that is, current
* time minus the update frequency). Then a filter needs an update if its
* last update was before that moment. Also check that the "recent enough"
* time point can be calculated without undeflowing beforehand.
*/
return (self->manager->update_time < ADBLOCK_FILTER_UPDATE_FREQUENCY) ||
(self->last_update <= (self->manager->update_time - ADBLOCK_FILTER_UPDATE_FREQUENCY));
}
static void
file_removed_cb (GFile *file,
GAsyncResult *result,
void *user_data)
{
g_autoptr (GError) error = NULL;
g_assert (G_IS_FILE (file));
g_assert (result);
if (!g_file_delete_finish (file, result, &error) &&
!g_error_matches (error, G_FILE_ERROR, G_FILE_ERROR_NOENT) &&
!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) {
g_autofree char *file_path = g_file_get_path (file);
g_warning ("Cannot delete '%s': %s", file_path, error->message);
}
}
static void
sidecar_saved_cb (GObject *source_object,
GAsyncResult *result,
FilterInfo *self)
{
g_autoptr (GError) error = NULL;
if (filter_info_save_sidecar_finish (result, &error)) {
LOG ("Sidecar successfully saved for filter %s.",
filter_info_get_identifier (self));
} else {
g_warning ("Cannot save sidecar for filter %s: %s",
filter_info_get_identifier (self),
error->message);
}
}
static void
filter_saved_cb (WebKitUserContentFilterStore *store,
GAsyncResult *result,
FilterInfo *self)
{
g_autoptr (GError) error = NULL;
if (!self->manager)
return;
g_assert (WEBKIT_IS_USER_CONTENT_FILTER_STORE (store));
g_assert (result);
g_assert (self);
g_assert (self->manager->store == store);
g_clear_pointer (&self->manager->wk_filter, webkit_user_content_filter_unref);
self->manager->wk_filter = webkit_user_content_filter_store_save_finish (self->manager->store,
result,
&error);
if (self->manager->wk_filter) {
LOG ("Filter %s compiled successfully.", filter_info_get_identifier (self));
filter_info_setup_enable_compiled_filter (self, self->manager->wk_filter);
filter_info_save_sidecar (self,
self->manager->cancellable,
(GAsyncReadyCallback)sidecar_saved_cb,
self);
} else if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) {
g_warning ("Filter %s <%s> cannot be compiled: %s.",
filter_info_get_identifier (self), self->source_uri,
error->message);
}
/* In either case, setting up this filter is done. */
filter_info_setup_done (self);
}
static void
filter_info_setup_load_file (FilterInfo *self,
GFile *json_file)
{
g_autofree char *old_checksum = NULL;
g_autofree char *json_file_path = NULL;
g_autoptr (GMappedFile) file_map = NULL;
g_autoptr (GBytes) json_data = NULL;
g_autoptr (GError) error = NULL;
g_assert (self);
g_assert (G_IS_FILE (json_file));
if (!self->manager)
return;
/* Some filter source JSON files can be big (tens of megabytes), so instead
* of reading the data for compilation, just map the source file in memory.
*/
json_file_path = g_file_get_path (json_file);
file_map = g_mapped_file_new (json_file_path,
FALSE, /* writable */
&error);
/* Immediately unlink a fetched file after it has been mapped. */
if (!self->local) {
LOG ("Unlinking fetched JSON file: %s", json_file_path);
g_file_delete_async (json_file,
G_PRIORITY_LOW,
self->manager->cancellable,
(GAsyncReadyCallback)file_removed_cb,
NULL);
}
if (!file_map) {
g_warning ("Cannot map filter %s source file %s: %s",
filter_info_get_identifier (self),
json_file_path, error->message);
filter_info_setup_done (self);
return;
}
json_data = g_mapped_file_get_bytes (file_map);
old_checksum = g_steal_pointer (&self->checksum);
self->checksum = g_compute_checksum_for_bytes (G_CHECKSUM_SHA256, json_data);
self->last_update = self->manager->update_time;
if (!filter_info_needs_updating_from_source (self) && self->found &&
old_checksum && strcmp (self->checksum, old_checksum) == 0) {
/* Even if an update is not needed, the sidecar needs to be updated. */
filter_info_save_sidecar (self,
self->manager->cancellable,
(GAsyncReadyCallback)sidecar_saved_cb,
self);
LOG ("Filter %s not stale, source checksum unchanged (%s), recompilation skipped.",
filter_info_get_identifier (self), self->checksum);
filter_info_setup_done (self);
} else {
webkit_user_content_filter_store_save (self->manager->store,
filter_info_get_identifier (self),
json_data,
self->manager->cancellable,
(GAsyncReadyCallback)filter_saved_cb,
self);
}
}
static void
json_file_deleted (GObject *source,
GAsyncResult *res,
gpointer user_data)
{
g_autoptr (GError) error = NULL;
if (!g_file_delete_finish (G_FILE (source), res, &error))
g_warning ("Could not delete filter json file: %s", error->message);
}
typedef struct {
EphyDownload *download;
FilterInfo *self;
} FilterJsonInfoAsyncData;
static void
json_file_info_callback (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
g_autoptr (GError) error = NULL;
FilterJsonInfoAsyncData *data = user_data;
GFile *json_file = G_FILE (source_object);
g_autoptr (GFileInfo) info = g_file_query_info_finish (json_file, res, &error);
const char *content_type = NULL;
if (info)
content_type = g_file_info_get_content_type (info);
else
g_warning ("Couldn't query filter file %s: %s", ephy_download_get_destination_uri (data->download), error->message);
if (content_type && g_strcmp0 ("application/json", content_type) == 0) {
filter_info_setup_load_file (data->self, json_file);
} else {
g_warning ("Filter source %s has invalid MIME type: %s",
ephy_download_get_destination_uri (data->download),
content_type);
g_file_delete_async (json_file, G_PRIORITY_DEFAULT, NULL, json_file_deleted, NULL);
filter_info_setup_done (data->self);
}
g_object_unref (data->download);
g_free (data);
}
static void
download_completed_cb (EphyDownload *download,
FilterInfo *self)
{
g_autoptr (GFile) json_file = NULL;
FilterJsonInfoAsyncData *data = NULL;
g_assert (download);
g_assert (self);
g_signal_handlers_disconnect_by_data (download, self);
LOG ("Filter source %s fetched from <%s>", filter_info_get_identifier (self), self->source_uri);
data = g_new0 (FilterJsonInfoAsyncData, 1);
data->download = download;
data->self = self;
json_file = g_file_new_for_uri (ephy_download_get_destination_uri (download));
g_file_query_info_async (json_file,
G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE,
G_FILE_QUERY_INFO_NONE,
G_PRIORITY_DEFAULT,
NULL,
json_file_info_callback,
data);
}
static void
download_errored_cb (EphyDownload *download,
GError *error,
FilterInfo *self)
{
g_assert (download);
g_assert (error);
g_assert (self);
g_signal_handlers_disconnect_by_data (download, self);
if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
g_warning ("Cannot fetch source for filter %s from <%s>: %s",
filter_info_get_identifier (self), self->source_uri,
error ? error->message : "Unknown error");
/* There is not much else we can do if the download failed. Note that it
* is still possible that if a precompiled version of the filter was found
* that may get used instead.
*/
filter_info_setup_done (self);
g_object_unref (download);
}
static void
filter_load_cb (WebKitUserContentFilterStore *store,
GAsyncResult *result,
FilterInfo *self)
{
g_autoptr (GError) error = NULL;
g_autoptr (GFile) source_file = NULL;
g_autoptr (GFile) json_file = NULL;
g_autofree char *json_file_uri = NULL;
EphyDownload *download;
if (!self->manager)
return;
g_assert (WEBKIT_IS_USER_CONTENT_FILTER_STORE (store));
g_assert (result);
g_assert (self);
g_assert (store == self->manager->store);
g_clear_pointer (&self->manager->wk_filter, webkit_user_content_filter_unref);
self->manager->wk_filter = webkit_user_content_filter_store_load_finish (self->manager->store,
result,
&error);
self->found = (self->manager->wk_filter != NULL);
if (self->manager->wk_filter) {
LOG ("Found compiled filter %s.", filter_info_get_identifier (self));
filter_info_setup_enable_compiled_filter (self, self->manager->wk_filter);
LOG ("Update %sneeded for filter %s (last %" PRIu64 "s ago, interval %us)",
filter_info_needs_updating_from_source (self) ? "" : "not ",
filter_info_get_identifier (self),
(self->manager->update_time - self->last_update),
ADBLOCK_FILTER_UPDATE_FREQUENCY);
} else if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) {
filter_info_setup_done (self);
return;
} else if (g_error_matches (error,
WEBKIT_USER_CONTENT_FILTER_ERROR,
WEBKIT_USER_CONTENT_FILTER_ERROR_NOT_FOUND)) {
LOG ("Compiled filter %s not found, needs fetching.",
filter_info_get_identifier (self));
} else {
g_warning ("Lookup failed for compiled filter %s: %s.",
filter_info_get_identifier (self),
error->message);
}
if (!filter_info_needs_updating_from_source (self)) {
filter_info_setup_done (self);
return;
}
/* Even if a compiled filter was found, we may need to compile an updated
* version if the local file has changed, or the contents of remote URIs
* have changed. If an updated ruleset is available, it will replace the
* precompiled version found above (if any) once it has been compiled.
*/
LOG ("Loading filter %s from <%s>", filter_info_get_identifier (self), self->source_uri);
/* Skip fetching local file:// URIs; load them directly. */
source_file = g_file_new_for_uri (self->source_uri);
if ((self->local = g_file_is_native (source_file))) {
filter_info_setup_load_file (self, source_file);
return;
}
/* Download non-local URIs. */
download = ephy_download_new_for_uri_internal (self->source_uri);
json_file = filter_info_get_source_file (self);
json_file_uri = g_file_get_uri (json_file);
ephy_download_set_destination_uri (download, json_file_uri);
ephy_download_disable_desktop_notification (download);
webkit_download_set_allow_overwrite (ephy_download_get_webkit_download (download), TRUE);
g_signal_connect (download, "completed",
G_CALLBACK (download_completed_cb), self);
g_signal_connect (download, "error",
G_CALLBACK (download_errored_cb), self);
}
static void
filter_info_setup_start (FilterInfo *self)
{
g_assert (self);
if (!self->manager)
return;
LOG ("Setup started for <%s> id=%s", self->source_uri, filter_info_get_identifier (self));
self->done = FALSE;
webkit_user_content_filter_store_load (self->manager->store,
filter_info_get_identifier (self),
self->manager->cancellable,
(GAsyncReadyCallback)filter_load_cb,
self);
}
static void
filters_manager_ensure_initialized (EphyFiltersManager *manager)
{
g_assert (EPHY_IS_FILTERS_MANAGER (manager));
if (manager->is_initialized)
return;
LOG ("Setting EphyFiltersManager as initialized.");
manager->is_initialized = TRUE;
g_object_notify_by_pspec (G_OBJECT (manager),
object_properties[PROP_IS_INITIALIZED]);
}
static void
accumulate_filter_done (const char *identifier,
FilterInfo *filter,
gboolean *done)
{
g_assert (strcmp (identifier, filter_info_get_identifier (filter)) == 0);
g_assert (g_hash_table_contains (filter->manager->filters, identifier));
*done = *done && filter->done;
}
static void
filter_info_setup_done (FilterInfo *self)
{
gboolean done = self->done = TRUE;
g_hash_table_foreach (self->manager->filters,
(GHFunc)accumulate_filter_done,
&done);
LOG ("Setup for filter %s from <%s> completed.",
filter_info_get_identifier (self), self->source_uri);
if (done) {
LOG ("Setup completed for %u filters.",
g_hash_table_size (self->manager->filters));
filters_manager_ensure_initialized (self->manager);
}
}
static void
filter_removed_cb (WebKitUserContentFilterStore *store,
GAsyncResult *result,
void *user_data)
{
g_autoptr (GError) error = NULL;
g_assert (WEBKIT_IS_USER_CONTENT_FILTER_STORE (store));
g_assert (result);
if (!webkit_user_content_filter_store_remove_finish (store,
result,
&error) &&
!g_error_matches (error,
WEBKIT_USER_CONTENT_FILTER_ERROR,
WEBKIT_USER_CONTENT_FILTER_ERROR_NOT_FOUND)) {
g_warning ("Cannot remove compiled filter: %s", error->message);
}
}
static void
remove_unused_filter (const char *identifier,
FilterInfo *filter,
EphyFiltersManager *manager)
{
g_autoptr (GFile) sidecar_file = filter_info_get_sidecar_file (filter);
g_assert (strcmp (identifier, filter_info_get_identifier (filter)) == 0);
g_assert (!g_hash_table_contains (filter->manager->filters, identifier));
LOG ("Emitting EphyFiltersManager::filter-removed for %s.", identifier);
g_signal_emit (manager, s_signals[FILTER_REMOVED], 0, identifier);
g_file_delete_async (sidecar_file,
G_PRIORITY_LOW,
filter->manager->cancellable,
(GAsyncReadyCallback)file_removed_cb,
NULL);
webkit_user_content_filter_store_remove (filter->manager->store,
identifier,
filter->manager->cancellable,
(GAsyncReadyCallback)filter_removed_cb,
NULL);
LOG ("Filter %s removal scheduled scheduled.", identifier);
}
void
sidecar_loaded_cb (GObject *source_object,
GAsyncResult *result,
FilterInfo *self)
{
g_autoptr (GError) error = NULL;
if (!filter_info_load_sidecar_finish (result, &error)) {
if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
return;
if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND)) {
LOG ("Sidecar missing for filter %s: %s",
filter_info_get_identifier (self),
error->message);
} else {
g_warning ("Cannot load sidecar file for filter %s: %s",
filter_info_get_identifier (self),
error->message);
}
}
filter_info_setup_start (self);
}
static void
update_adblock_filter_files_cb (GSettings *settings,
char *key,
EphyFiltersManager *manager)
{
const gint64 update_time = g_get_real_time () / G_USEC_PER_SEC;
g_autoptr (GHashTable) old_filters = NULL;
g_auto (GStrv) uris = NULL;
g_assert (manager);
if ((!g_settings_get_boolean (EPHY_SETTINGS_WEB, EPHY_PREFS_WEB_ENABLE_ADBLOCK)) ||
(ephy_embed_shell_get_mode (ephy_embed_shell_get_default ()) == EPHY_EMBED_SHELL_MODE_AUTOMATION)) {
LOG ("Filters are disabled, skipping update.");
g_signal_emit (manager, s_signals[FILTERS_DISABLED], 0);
/* If the ad blocker is disabled, initialization is done. */
filters_manager_ensure_initialized (manager);
return;
}
/* Only once at a time please! Newest set of filters wins. */
g_cancellable_cancel (manager->cancellable);
g_object_unref (manager->cancellable);
manager->cancellable = g_cancellable_new ();
manager->update_time = update_time;
old_filters = g_steal_pointer (&manager->filters);
manager->filters = g_hash_table_new_full (g_str_hash,
g_str_equal,
NULL,
(GDestroyNotify)filter_info_free);
uris = g_settings_get_strv (EPHY_SETTINGS_MAIN, EPHY_PREFS_CONTENT_FILTERS);
for (unsigned i = 0; uris[i]; i++) {
g_autofree char *filter_id = filter_info_identifier_for_source_uri (uris[i]);
FilterInfo *filter_info = NULL;
char *old_filter_id = NULL;
/* Check whether there was already a FilterInfo for the URI in the old
* filters table, and reuse it instead of creating a new one and reloading
* the sidecar file from disk.
*
* Note that the value is stolen from the old hash table in order to
* look it up and remove it from the old table *without* destroying it.
*/
if (g_hash_table_steal_extended (old_filters,
filter_id,
(void **)&old_filter_id,
(void **)&filter_info)) {
g_assert (strcmp (old_filter_id, filter_id) == 0);
g_assert (strcmp (old_filter_id, filter_info_get_identifier (filter_info)) == 0);
LOG ("Filter %s in old set, stolen and starting setup.", filter_id);
filter_info_setup_start (filter_info);
} else {
/* Filter was not present in the old hash table: create a FilterInfo
* for the URI and start by loading its sidecar file.
*/
LOG ("Filter %s not in old set, creating anew.", filter_id);
filter_info = filter_info_new (uris[i], manager);
filter_info->identifier = g_steal_pointer (&filter_id);
filter_info_load_sidecar (filter_info,
manager->cancellable,
(GAsyncReadyCallback)sidecar_loaded_cb,
filter_info);
}
g_hash_table_replace (manager->filters,
(void *)filter_info_get_identifier (filter_info),
filter_info);
}
/* Remove the filters which are no longer in the configured set. */
g_hash_table_foreach (old_filters,
(GHFunc)remove_unused_filter,
manager);
}
static void
ephy_filters_manager_dispose (GObject *object)
{
EphyFiltersManager *manager = EPHY_FILTERS_MANAGER (object);
g_clear_handle_id (&manager->update_timeout_id, g_source_remove);
if (manager->cancellable) {
g_cancellable_cancel (manager->cancellable);
g_clear_object (&manager->cancellable);
}
g_clear_pointer (&manager->wk_filter, webkit_user_content_filter_unref);
g_clear_object (&manager->store);
G_OBJECT_CLASS (ephy_filters_manager_parent_class)->dispose (object);
}
static void
ephy_filters_manager_finalize (GObject *object)
{
EphyFiltersManager *manager = EPHY_FILTERS_MANAGER (object);
g_clear_pointer (&manager->filters, g_hash_table_unref);
g_free (manager->filters_dir);
G_OBJECT_CLASS (ephy_filters_manager_parent_class)->finalize (object);
}
static gboolean
update_timeout_cb (EphyFiltersManager *manager)
{
g_assert (EPHY_IS_FILTERS_MANAGER (manager));
update_adblock_filter_files_cb (NULL, NULL, manager);
return G_SOURCE_CONTINUE;
}
static void
ephy_filters_manager_constructed (GObject *object)
{
EphyFiltersManager *manager = EPHY_FILTERS_MANAGER (object);
g_autofree char *saved_filters_dir = NULL;
G_OBJECT_CLASS (ephy_filters_manager_parent_class)->constructed (object);
/* Disable filter manager during tests */
if (ephy_embed_shell_get_mode (ephy_embed_shell_get_default ()) == EPHY_EMBED_SHELL_MODE_TEST)
return;
if (!manager->filters_dir) {
g_autofree char *cache_dir = ephy_default_cache_dir ();
manager->filters_dir = g_build_filename (cache_dir, "adblock", NULL);
}
saved_filters_dir = g_build_filename (manager->filters_dir, "compiled", NULL);
g_mkdir_with_parents (saved_filters_dir, 0700);
manager->store = webkit_user_content_filter_store_new (saved_filters_dir);
/* Note: up here because we must connect *before* reading the settings. */
g_signal_connect_object (EPHY_SETTINGS_MAIN, "changed::" EPHY_PREFS_CONTENT_FILTERS,
G_CALLBACK (update_adblock_filter_files_cb), manager, 0);
g_signal_connect_object (EPHY_SETTINGS_WEB, "changed::" EPHY_PREFS_WEB_ENABLE_ADBLOCK,
G_CALLBACK (update_adblock_filter_files_cb), manager, 0);
update_adblock_filter_files_cb (NULL, NULL, manager);
manager->update_timeout_id = g_timeout_add_seconds (ADBLOCK_FILTER_UPDATE_FREQUENCY,
(GSourceFunc)update_timeout_cb,
manager);
}
static void
ephy_filters_manager_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
EphyFiltersManager *manager = EPHY_FILTERS_MANAGER (object);
switch (prop_id) {
case PROP_FILTERS_DIR:
manager->filters_dir = g_value_dup_string (value);
break;
case PROP_IS_INITIALIZED:
manager->is_initialized = g_value_get_boolean (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
}
}
static void
ephy_filters_manager_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
EphyFiltersManager *manager = EPHY_FILTERS_MANAGER (object);
switch (prop_id) {
case PROP_FILTERS_DIR:
g_value_set_string (value, manager->filters_dir);
break;
case PROP_IS_INITIALIZED:
g_value_set_boolean (value, manager->is_initialized);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
}
}
static void
ephy_filters_manager_class_init (EphyFiltersManagerClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
object_class->constructed = ephy_filters_manager_constructed;
object_class->dispose = ephy_filters_manager_dispose;
object_class->finalize = ephy_filters_manager_finalize;
object_class->set_property = ephy_filters_manager_set_property;
object_class->get_property = ephy_filters_manager_get_property;
s_signals[FILTER_READY] =
g_signal_new ("filter-ready",
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_FIRST,
0, NULL, NULL, NULL,
G_TYPE_NONE, 1,
WEBKIT_TYPE_USER_CONTENT_FILTER);
s_signals[FILTER_REMOVED] =
g_signal_new ("filter-removed",
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_FIRST,
0, NULL, NULL, NULL,
G_TYPE_NONE, 1,
G_TYPE_STRING);
s_signals[FILTERS_DISABLED] =
g_signal_new ("filters-disabled",
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_FIRST,
0, NULL, NULL, NULL,
G_TYPE_NONE, 0);
object_properties[PROP_FILTERS_DIR] =
g_param_spec_string ("filters-dir",
"Filters directory",
"The directory in which adblock filters are saved",
NULL,
G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS);
object_properties[PROP_IS_INITIALIZED] =
g_param_spec_boolean ("is-initialized",
"Filters manager is initialized",
"Whether initialization was completed",
FALSE,
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
g_object_class_install_properties (object_class,
N_PROPERTIES,
object_properties);
}
static void
ephy_filters_manager_init (EphyFiltersManager *manager)
{
manager->cancellable = g_cancellable_new ();
manager->filters = g_hash_table_new_full (g_str_hash,
g_str_equal,
NULL,
(GDestroyNotify)filter_info_free);
}
EphyFiltersManager *
ephy_filters_manager_new (const char *filters_dir)
{
return EPHY_FILTERS_MANAGER (g_object_new (EPHY_TYPE_FILTERS_MANAGER,
"filters-dir", filters_dir,
NULL));
}
const char *
ephy_filters_manager_get_adblock_filters_dir (EphyFiltersManager *manager)
{
return manager->filters_dir;
}
gboolean
ephy_filters_manager_get_is_initialized (EphyFiltersManager *manager)
{
return manager->is_initialized;
}
void
ephy_filters_manager_set_ucm_forbids_ads (EphyFiltersManager *manager,
WebKitUserContentManager *ucm,
gboolean forbids_ads)
{
if (!manager->wk_filter)
return;
if (forbids_ads)
webkit_user_content_manager_add_filter (ucm, manager->wk_filter);
else
webkit_user_content_manager_remove_filter (ucm, manager->wk_filter);
}