debian
/
midori
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
midori/extensions/nojs/nojs.c

1045 lines
30 KiB
C
Raw Blame History

/*
Copyright (C) 2013 Stephan Haller <nomad@froevel.de>
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
See the file COPYING for the full license text.
*/
#include "nojs.h"
#include "nojs-view.h"
#include <errno.h>
/* Define this class in GObject system */
G_DEFINE_TYPE(NoJS,
nojs,
G_TYPE_OBJECT)
/* Properties */
enum
{
PROP_0,
PROP_EXTENSION,
PROP_APPLICATION,
PROP_DATABASE,
PROP_DATABASE_FILENAME,
PROP_ALLOW_LOCAL_PAGES,
PROP_ONLY_SECOND_LEVEL,
PROP_UNKNOWN_DOMAIN_POLICY,
PROP_LAST
};
static GParamSpec* NoJSProperties[PROP_LAST]={ 0, };
/* Signals */
enum
{
URI_LOAD_POLICY_STATUS,
POLICY_CHANGED,
SIGNAL_LAST
};
static guint NoJSSignals[SIGNAL_LAST]={ 0, };
/* Private structure - access only by public API if needed */
#define NOJS_GET_PRIVATE(obj) \
(G_TYPE_INSTANCE_GET_PRIVATE((obj), TYPE_NOJS, NoJSPrivate))
struct _NoJSPrivate
{
/* Extension related */
MidoriExtension *extension;
MidoriApp *application;
sqlite3 *database;
gchar *databaseFilename;
gboolean allowLocalPages;
gboolean checkOnlySecondLevel;
NoJSPolicy unknownDomainPolicy;
guint requestStartedSignalID;
};
/* Taken from http://www.w3.org/html/wg/drafts/html/master/scripting-1.html#scriptingLanguages
* A list of javascript mime types
*/
static const gchar* javascriptTypes[]= {
"application/ecmascript",
"application/javascript",
"application/x-ecmascript",
"application/x-javascript",
"text/ecmascript",
"text/javascript",
"text/javascript1.0",
"text/javascript1.1",
"text/javascript1.2",
"text/javascript1.3",
"text/javascript1.4",
"text/javascript1.5",
"text/jscript",
"text/livescript",
"text/x-ecmascript",
"text/x-javascript",
NULL
};
/* IMPLEMENTATION: Private variables and methods */
/* Closure for: void (*closure)(NoJS *self, gchar *inURI, NoJSPolicy inPolicy) */
static void _nojs_closure_VOID__STRING_ENUM(GClosure *inClosure,
GValue *ioReturnValue G_GNUC_UNUSED,
guint inNumberValues,
const GValue *inValues,
gpointer inInvocationHint G_GNUC_UNUSED,
gpointer inMarshalData)
{
typedef void (*GMarshalFunc_VOID__STRING_ENUM)(gpointer inObject, gpointer inArg1, gint inArg2, gpointer inUserData);
register GMarshalFunc_VOID__STRING_ENUM callback;
register GCClosure *closure=(GCClosure*)inClosure;
register gpointer object, userData;
g_return_if_fail(inNumberValues==3);
if(G_CCLOSURE_SWAP_DATA(inClosure))
{
object=inClosure->data;
userData=g_value_peek_pointer(inValues+0);
}
else
{
object=g_value_peek_pointer(inValues+0);
userData=inClosure->data;
}
callback=(GMarshalFunc_VOID__STRING_ENUM)(inMarshalData ? inMarshalData : closure->callback);
callback(object,
(gchar*)g_value_get_string(inValues+1),
g_value_get_enum(inValues+2),
userData);
}
/* Show common error dialog */
static void _nojs_error(NoJS *self, const gchar *inReason)
{
g_return_if_fail(IS_NOJS(self));
g_return_if_fail(inReason);
GtkWidget *dialog;
/* Show confirmation dialog for undetermined cookies */
dialog=gtk_message_dialog_new(NULL,
GTK_DIALOG_MODAL,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_OK,
_("A fatal error occurred which prevents "
"the NoJS extension to continue. "
"You should disable it."));
gtk_window_set_title(GTK_WINDOW(dialog), _("Error in NoJS extension"));
gtk_window_set_icon_name(GTK_WINDOW (dialog), "midori");
gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(dialog),
"%s:\n%s",
_("Reason"),
inReason);
gtk_dialog_run(GTK_DIALOG(dialog));
/* Free up allocated resources */
gtk_widget_destroy(dialog);
}
/* Open database containing policies for javascript sites.
* Create database and setup table structure if it does not exist yet.
*/
static void _nojs_open_database(NoJS *self)
{
g_return_if_fail(IS_NOJS(self));
NoJSPrivate *priv=self->priv;
const gchar *configDir;
gchar *sql;
gchar *error=NULL;
gint success;
/* Close any open database */
if(priv->database)
{
priv->databaseFilename=NULL;
sqlite3_close(priv->database);
priv->database=NULL;
g_object_notify_by_pspec(G_OBJECT(self), NoJSProperties[PROP_DATABASE]);
g_object_notify_by_pspec(G_OBJECT(self), NoJSProperties[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));
_nojs_error(self, _("Could not create configuration folder for extension."));
return;
}
/* Open database */
priv->databaseFilename=g_build_filename(configDir, NOJS_DATABASE, NULL);
success=sqlite3_open(priv->databaseFilename, &priv->database);
if(success!=SQLITE_OK)
{
g_warning(_("Could not open database of extension: %s"), sqlite3_errmsg(priv->database));
g_free(priv->databaseFilename);
priv->databaseFilename=NULL;
if(priv->database) sqlite3_close(priv->database);
priv->database=NULL;
_nojs_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(site text, value integer);",
NULL,
NULL,
&error);
if(success==SQLITE_OK)
{
success=sqlite3_exec(priv->database,
"CREATE UNIQUE INDEX IF NOT EXISTS "
"site ON policies (site);",
NULL,
NULL,
&error);
}
if(success==SQLITE_OK)
{
success=sqlite3_exec(priv->database,
"PRAGMA journal_mode=TRUNCATE;",
NULL,
NULL,
&error);
}
if(success!=SQLITE_OK || error)
{
_nojs_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 temporarily allowed sites */
sql=sqlite3_mprintf("DELETE FROM policies WHERE value=%d;", NOJS_POLICY_ACCEPT_TEMPORARILY);
success=sqlite3_exec(priv->database, sql, NULL, NULL, &error);
if(success!=SQLITE_OK) g_warning(_("SQL fails: %s"), error);
if(error) sqlite3_free(error);
sqlite3_free(sql);
g_object_notify_by_pspec(G_OBJECT(self), NoJSProperties[PROP_DATABASE]);
g_object_notify_by_pspec(G_OBJECT(self), NoJSProperties[PROP_DATABASE_FILENAME]);
}
/* A request through libsoup is going to start and http headers must be
* checked for content type
*/
static void _nojs_on_got_headers(NoJS *self, gpointer inUserData)
{
g_return_if_fail(IS_NOJS(self));
g_return_if_fail(SOUP_IS_MESSAGE(inUserData));
NoJSPrivate *priv=self->priv;
SoupMessage *message=SOUP_MESSAGE(inUserData);
SoupSession *session=webkit_get_default_session();
SoupMessageHeaders *headers;
SoupMessageBody *body;
const gchar *contentType;
SoupURI *uri;
gchar *uriText;
NoJSPolicy policy;
gboolean isJS;
const gchar **iter;
/* Get headers from message to retrieve content type */
g_object_get(message, "response-headers", &headers, NULL);
if(!headers)
{
g_warning("Could not get headers from message to check for javascript.");
return;
}
/* Get content type of uri and check if it is a javascript resource */
contentType=soup_message_headers_get_content_type(headers, NULL);
isJS=FALSE;
iter=javascriptTypes;
while(*iter && !isJS)
{
isJS=(g_strcmp0(contentType, *iter)==0);
iter++;
}
if(!isJS) return;
/* The document being loaded is javascript so get URI from message,
* get policy for domain of URI and emit signal
*/
uri=soup_message_get_uri(message);
policy=nojs_get_policy(self, uri);
if(policy==NOJS_POLICY_UNDETERMINED)
{
g_warning("Got invalid policy. Using default policy for unknown domains.");
policy=priv->unknownDomainPolicy;
}
uriText=soup_uri_to_string(uri, FALSE);
g_signal_emit(self, NoJSSignals[URI_LOAD_POLICY_STATUS], 0, uriText, policy==NOJS_POLICY_UNDETERMINED ? NOJS_POLICY_BLOCK : policy);
g_free(uriText);
/* Return here if policy is any type of accept */
if(policy!=NOJS_POLICY_UNDETERMINED && policy!=NOJS_POLICY_BLOCK) return;
/* Cancel this message */
soup_session_cancel_message(session, message, SOUP_STATUS_CANCELLED);
/* Discard any load data */
g_object_get(message, "response-body", &body, NULL);
if(body) soup_message_body_truncate(body);
}
static void _nojs_on_request_started(NoJS *self,
SoupMessage *inMessage,
SoupSocket *inSocket,
gpointer inUserData)
{
g_return_if_fail(IS_NOJS(self));
g_return_if_fail(SOUP_IS_MESSAGE(inMessage));
/* Connect to "got-headers" to cancel loading javascript documents early */
g_signal_connect_swapped(inMessage, "got-headers", G_CALLBACK(_nojs_on_got_headers), self);
}
/* The icon in statusbar was clicked */
static void _nojs_on_statusbar_icon_clicked(MidoriBrowser *inBrowser, gpointer inUserData)
{
g_return_if_fail(MIDORI_IS_BROWSER(inBrowser));
MidoriView *activeView;
NoJSView *view;
GtkMenu *menu;
/* Get current active midori view */
activeView=MIDORI_VIEW(midori_browser_get_current_tab(inBrowser));
g_return_if_fail(MIDORI_IS_VIEW(activeView));
/* Get NoJS view of current active midori view */
view=NOJS_VIEW(g_object_get_data(G_OBJECT(activeView), "nojs-view-instance"));
g_return_if_fail(NOJS_IS_VIEW(view));
/* Get menu of current view */
menu=nojs_view_get_menu(view);
g_return_if_fail(menu);
/* Show menu */
gtk_menu_popup(menu, NULL, NULL, NULL, NULL, 0, gtk_get_current_event_time());
}
gchar* nojs_get_icon_path (const gchar* icon)
{
gchar* nojs_dir = midori_paths_get_res_filename("nojs");
return g_build_filename (nojs_dir, icon, NULL);
}
/* Menu icon of a view has changed */
static void _nojs_on_menu_icon_changed(MidoriBrowser *inBrowser, GParamSpec *inSpec, gpointer inUserData)
{
g_return_if_fail(MIDORI_IS_BROWSER(inBrowser));
g_return_if_fail(NOJS_IS_VIEW(inUserData));
NoJSView *view=NOJS_VIEW(inUserData);
NoJSMenuIconState menuIconState;
GtkWidget *statusbarIcon;
GtkWidget *buttonImage;
gchar *imageFilename;
/* Get icon in status bar of this browser */
statusbarIcon=GTK_WIDGET(g_object_get_data(G_OBJECT(inBrowser), "nojs-statusicon"));
g_return_if_fail(GTK_IS_WIDGET(statusbarIcon));
/* Get menu icon state of view */
menuIconState=nojs_view_get_menu_icon_state(view);
/* Create image for statusbar button */
imageFilename=NULL;
switch(menuIconState)
{
case NOJS_MENU_ICON_STATE_ALLOWED:
imageFilename=nojs_get_icon_path("nojs-statusicon-allowed.png");
break;
case NOJS_MENU_ICON_STATE_MIXED:
imageFilename=nojs_get_icon_path("nojs-statusicon-mixed.png");
break;
case NOJS_MENU_ICON_STATE_DENIED:
case NOJS_MENU_ICON_STATE_UNDETERMINED:
imageFilename=nojs_get_icon_path("nojs-statusicon-denied.png");
break;
}
buttonImage=gtk_image_new_from_file(imageFilename);
g_free(imageFilename);
/* Set image at statusbar button */
gtk_button_set_image(GTK_BUTTON(statusbarIcon), buttonImage);
}
/* A tab in browser was activated */
static void _nojs_on_switch_tab(NoJS *self, MidoriView *inOldView, MidoriView *inNewView, gpointer inUserData)
{
g_return_if_fail(IS_NOJS(self));
g_return_if_fail(MIDORI_IS_BROWSER(inUserData));
MidoriBrowser *browser=MIDORI_BROWSER(inUserData);
NoJSView *view;
/* Disconnect signal handlers from old view */
if(inOldView)
{
/* Get NoJS view of old view */
view=(NoJSView*)g_object_get_data(G_OBJECT(inOldView), "nojs-view-instance");
g_return_if_fail(NOJS_IS_VIEW(view));
/* Disconnect signal handlers */
g_signal_handlers_disconnect_by_func(view, G_CALLBACK(_nojs_on_menu_icon_changed), browser);
}
/* Get NoJS view of new view */
view=(NoJSView*)g_object_get_data(G_OBJECT(inNewView), "nojs-view-instance");
g_return_if_fail(NOJS_IS_VIEW(view));
/* Connect signals */
g_signal_connect_swapped(view, "notify::menu-icon-state", G_CALLBACK(_nojs_on_menu_icon_changed), browser);
/* Update menu icon*/
_nojs_on_menu_icon_changed(browser, NULL, view);
}
/* A tab of a browser was removed */
static void _nojs_on_remove_tab(NoJS *self, MidoriView *inView, gpointer inUserData)
{
g_return_if_fail(IS_NOJS(self));
NoJSView *view;
/* Get NoJS view of current active midori view */
view=NOJS_VIEW(g_object_get_data(G_OBJECT(inView), "nojs-view-instance"));
g_return_if_fail(NOJS_IS_VIEW(view));
g_object_unref(view);
}
/* A tab of a browser was added */
static void _nojs_on_add_tab(NoJS *self, MidoriView *inView, gpointer inUserData)
{
g_return_if_fail(IS_NOJS(self));
g_return_if_fail(MIDORI_IS_BROWSER(inUserData));
/* Create nojs view and add to tab */
MidoriBrowser *browser=MIDORI_BROWSER(inUserData);
nojs_view_new(self, browser, inView);
}
/* A browser window was added */
static void _nojs_on_add_browser(NoJS *self, MidoriBrowser *inBrowser, gpointer inUserData)
{
g_return_if_fail(IS_NOJS(self));
g_return_if_fail(MIDORI_IS_BROWSER(inBrowser));
GList *tabs, *iter;
GtkWidget *statusbar;
GtkWidget *statusbarIcon;
MidoriView *view;
NoJSView *nojsView;
/* Set up all current available tabs in browser */
tabs=midori_browser_get_tabs(inBrowser);
for(iter=tabs; iter; iter=g_list_next(iter)) _nojs_on_add_tab(self, iter->data, inBrowser);
g_list_free(tabs);
/* Add status bar icon to browser */
g_object_get(inBrowser, "statusbar", &statusbar, NULL);
if(statusbar)
{
/* Create and set up status icon */
statusbarIcon=gtk_button_new();
gtk_button_set_relief(GTK_BUTTON(statusbarIcon), GTK_RELIEF_NONE);
gtk_widget_show_all(statusbarIcon);
gtk_box_pack_end(GTK_BOX(statusbar), statusbarIcon, FALSE, FALSE, 0);
g_object_set_data_full(G_OBJECT(inBrowser), "nojs-statusicon", g_object_ref(statusbarIcon), (GDestroyNotify)gtk_widget_destroy);
/* Connect signals */
g_signal_connect_swapped(statusbarIcon, "clicked", G_CALLBACK(_nojs_on_statusbar_icon_clicked), inBrowser);
/* Release our reference to statusbar and status icon */
g_object_unref(statusbarIcon);
g_object_unref(statusbar);
/* Update menu icon*/
view=MIDORI_VIEW(midori_browser_get_current_tab(inBrowser));
if(view)
{
nojsView=(NoJSView*)g_object_get_data(G_OBJECT(view), "nojs-view-instance");
if(nojsView) _nojs_on_menu_icon_changed(inBrowser, NULL, nojsView);
}
}
/* Listen to new tabs opened in browser */
g_signal_connect_swapped(inBrowser, "add-tab", G_CALLBACK(_nojs_on_add_tab), self);
g_signal_connect_swapped(inBrowser, "switch-tab", G_CALLBACK(_nojs_on_switch_tab), self);
g_signal_connect_swapped(inBrowser, "remove-tab", G_CALLBACK(_nojs_on_remove_tab), self);
}
/* Application property has changed */
static void _nojs_on_application_changed(NoJS *self)
{
g_return_if_fail(IS_NOJS(self));
NoJSPrivate *priv=NOJS(self)->priv;
GList *browsers, *iter;
/* Set up all current open browser windows */
browsers=midori_app_get_browsers(priv->application);
for(iter=browsers; iter; iter=g_list_next(iter)) _nojs_on_add_browser(self, MIDORI_BROWSER(iter->data), priv->application);
g_list_free(browsers);
/* Listen to new browser windows opened */
g_signal_connect_swapped(priv->application, "add-browser", G_CALLBACK(_nojs_on_add_browser), self);
/* Notify about property change */
g_object_notify_by_pspec(G_OBJECT(self), NoJSProperties[PROP_APPLICATION]);
}
/* IMPLEMENTATION: GObject */
/* Finalize this object */
static void nojs_finalize(GObject *inObject)
{
NoJS *self=NOJS(inObject);
NoJSPrivate *priv=self->priv;
GList *browsers, *browser;
GList *tabs, *tab;
WebKitWebView *webkitView;
SoupSession *session;
/* Dispose allocated resources */
session=webkit_get_default_session();
g_signal_handlers_disconnect_by_data(session, self);
if(priv->databaseFilename)
{
g_free(priv->databaseFilename);
priv->databaseFilename=NULL;
}
if(priv->database)
{
sqlite3_close(priv->database);
priv->database=NULL;
}
if(priv->application)
{
g_signal_handlers_disconnect_by_data(priv->application, self);
browsers=midori_app_get_browsers(priv->application);
for(browser=browsers; browser; browser=g_list_next(browser))
{
g_signal_handlers_disconnect_by_data(browser->data, self);
g_object_set_data(G_OBJECT(browser->data), "nojs-statusicon", NULL);
tabs=midori_browser_get_tabs(MIDORI_BROWSER(browser->data));
for(tab=tabs; tab; tab=g_list_next(tab))
{
g_signal_handlers_disconnect_by_data(tab->data, self);
webkitView=WEBKIT_WEB_VIEW(midori_view_get_web_view(MIDORI_VIEW(tab->data)));
g_signal_handlers_disconnect_by_data(webkitView, self);
}
g_list_free(tabs);
}
g_list_free(browsers);
priv->application=NULL;
}
/* Call parent's class finalize method */
G_OBJECT_CLASS(nojs_parent_class)->finalize(inObject);
}
/* Set/get properties */
static void nojs_set_property(GObject *inObject,
guint inPropID,
const GValue *inValue,
GParamSpec *inSpec)
{
NoJS *self=NOJS(inObject);
switch(inPropID)
{
/* Construct-only properties */
case PROP_EXTENSION:
self->priv->extension=g_value_get_object(inValue);
_nojs_open_database(self);
break;
case PROP_APPLICATION:
self->priv->application=g_value_get_object(inValue);
_nojs_on_application_changed(self);
break;
case PROP_ALLOW_LOCAL_PAGES:
self->priv->allowLocalPages=g_value_get_boolean(inValue);
g_object_notify_by_pspec(G_OBJECT(self), NoJSProperties[PROP_ALLOW_LOCAL_PAGES]);
break;
case PROP_ONLY_SECOND_LEVEL:
self->priv->checkOnlySecondLevel=g_value_get_boolean(inValue);
g_object_notify_by_pspec(G_OBJECT(self), NoJSProperties[PROP_ONLY_SECOND_LEVEL]);
break;
case PROP_UNKNOWN_DOMAIN_POLICY:
self->priv->unknownDomainPolicy=g_value_get_enum(inValue);
g_object_notify_by_pspec(G_OBJECT(self), NoJSProperties[PROP_UNKNOWN_DOMAIN_POLICY]);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(inObject, inPropID, inSpec);
break;
}
}
static void nojs_get_property(GObject *inObject,
guint inPropID,
GValue *outValue,
GParamSpec *inSpec)
{
NoJS *self=NOJS(inObject);
switch(inPropID)
{
case PROP_EXTENSION:
g_value_set_object(outValue, self->priv->extension);
break;
case PROP_APPLICATION:
g_value_set_object(outValue, self->priv->application);
break;
case PROP_DATABASE:
g_value_set_pointer(outValue, self->priv->database);
break;
case PROP_DATABASE_FILENAME:
g_value_set_string(outValue, self->priv->databaseFilename);
break;
case PROP_ALLOW_LOCAL_PAGES:
g_value_set_boolean(outValue, self->priv->allowLocalPages);
break;
case PROP_ONLY_SECOND_LEVEL:
g_value_set_boolean(outValue, self->priv->checkOnlySecondLevel);
break;
case PROP_UNKNOWN_DOMAIN_POLICY:
g_value_set_enum(outValue, self->priv->unknownDomainPolicy);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(inObject, inPropID, inSpec);
break;
}
}
/* Class initialization
* Override functions in parent classes and define properties and signals
*/
static void nojs_class_init(NoJSClass *klass)
{
GObjectClass *gobjectClass=G_OBJECT_CLASS(klass);
/* Override functions */
gobjectClass->finalize=nojs_finalize;
gobjectClass->set_property=nojs_set_property;
gobjectClass->get_property=nojs_get_property;
/* Set up private structure */
g_type_class_add_private(klass, sizeof(NoJSPrivate));
/* Define properties */
NoJSProperties[PROP_EXTENSION]=
g_param_spec_object("extension",
_("Extension instance"),
_("The Midori extension instance for this extension"),
MIDORI_TYPE_EXTENSION,
G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY);
NoJSProperties[PROP_APPLICATION]=
g_param_spec_object("application",
_("Application instance"),
_("The Midori application instance this extension belongs to"),
MIDORI_TYPE_APP,
G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY);
NoJSProperties[PROP_DATABASE]=
g_param_spec_pointer("database",
_("Database instance"),
_("Pointer to sqlite database instance used by this extension"),
G_PARAM_READABLE);
NoJSProperties[PROP_DATABASE_FILENAME]=
g_param_spec_string("database-filename",
_("Database path"),
_("Path to sqlite database instance used by this extension"),
NULL,
G_PARAM_READABLE);
NoJSProperties[PROP_ALLOW_LOCAL_PAGES]=
g_param_spec_boolean("allow-local-pages",
_("Allow local pages"),
_("Allow scripts to run on local (file://) pages"),
TRUE,
G_PARAM_READWRITE | G_PARAM_CONSTRUCT);
NoJSProperties[PROP_ONLY_SECOND_LEVEL]=
g_param_spec_boolean("only-second-level",
_("Only second level"),
_("Reduce each domain to its second-level (e.g. www.example.org to example.org) for comparison"),
TRUE,
G_PARAM_READWRITE | G_PARAM_CONSTRUCT);
NoJSProperties[PROP_UNKNOWN_DOMAIN_POLICY]=
g_param_spec_enum("unknown-domain-policy",
_("Unknown domain policy"),
_("Policy to use for unknown domains"),
NOJS_TYPE_POLICY,
NOJS_POLICY_BLOCK,
G_PARAM_READWRITE | G_PARAM_CONSTRUCT);
g_object_class_install_properties(gobjectClass, PROP_LAST, NoJSProperties);
/* Define signals */
/* Why does this signal exist?
*
* The problem I faced when developing this extension was
* that I needed to cancel a SoupMessage as soon as possible
* (when http headers were received).
* I tried to connect to signal "resource-response-received"
* of WebKitWebView but the SoupMessage instance was not
* exactly the same which were sent or received by SoupSession.
* So I could not cancel the SoupMessage or better: I cancelled
* a SoupMessage which is not be handled so it had no effect.
* The body of SoupMessage was still being loaded and javascript
* was executed. I think the problem is that webkit-gtk creates
* a copy of the real SoupMessage which is going to be sent and
* received.
*
* So I decided to connect to signal "got-headers" of every
* SoupMessage sent by the default SoupSession which I notice
* by connecting to signal "request-started" of SoupSession. Each
* NoJSView connects to signal "resource-request-starting" of
* WebKitWebView to remember each URI going to be loaded. When
* a SoupMessage hits "got-headers" and is a javascript resource
* I can cancel the message immediately and clear the body which
* causes webkit-gtk to copy a empty body if it does at all as the
* SoupMessage was cancelled. Then I emit this signal
* "uri-load-policy-status" to notify each view but the cancellation.
* (It also notifies all views if it is going to load to keep the
* menu in right state.) Each view will check if it _could_ be a
* resource itself requested and will update its menu accordingly.
* It might happen that a request will match two views because only
* the URI will be checked by the view because I cannot determine
* to which view the SoupMessage belongs to. But it doesn't matter
* because if a javascript resource was denied or allowed in one view
* it is likely be denied or allowed in other views too ;)
*/
NoJSSignals[URI_LOAD_POLICY_STATUS]=
g_signal_new("uri-load-policy-status",
G_TYPE_FROM_CLASS(klass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET(NoJSClass, uri_load_policy_status),
NULL,
NULL,
_nojs_closure_VOID__STRING_ENUM,
G_TYPE_NONE,
2,
G_TYPE_STRING,
NOJS_TYPE_POLICY);
NoJSSignals[POLICY_CHANGED]=
g_signal_new("policy-changed",
G_TYPE_FROM_CLASS(klass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET(NoJSClass, policy_changed),
NULL,
NULL,
g_cclosure_marshal_VOID__STRING,
G_TYPE_NONE,
1,
G_TYPE_STRING);
}
/* Object initialization
* Create private structure and set up default values
*/
static void nojs_init(NoJS *self)
{
NoJSPrivate *priv;
SoupSession *session;
priv=self->priv=NOJS_GET_PRIVATE(self);
/* Set up default values */
priv->database=NULL;
priv->databaseFilename=NULL;
priv->allowLocalPages=TRUE;
priv->checkOnlySecondLevel=TRUE;
priv->unknownDomainPolicy=NOJS_POLICY_BLOCK;
/* Connect to signals on session to be able to cancel messages
* loading javascript documents
*/
session=webkit_get_default_session();
g_signal_connect_swapped(session, "request-started", G_CALLBACK(_nojs_on_request_started), self);
}
/* Implementation: Public API */
/* Create new object */
NoJS* nojs_new(MidoriExtension *inExtension, MidoriApp *inApp)
{
return(g_object_new(TYPE_NOJS,
"extension", inExtension,
"application", inApp,
NULL));
}
/* Retrieves domain from uri depending on preferences (e.g. only second level domain) */
gchar* nojs_get_domain(NoJS *self, SoupURI *inURI)
{
g_return_val_if_fail(IS_NOJS(self), NULL);
g_return_val_if_fail(inURI, NULL);
NoJSPrivate *priv=self->priv;
const gchar *realDomain;
gchar *finalDomain;
/* Get domain of site to lookup */
realDomain=soup_uri_get_host(inURI);
if(priv->checkOnlySecondLevel)
finalDomain=midori_uri_get_base_domain(realDomain);
else
finalDomain=midori_uri_to_ascii(realDomain);
/* Return domain */
return(finalDomain);
}
/* Get/set policy for javascript from site */
gint nojs_get_policy(NoJS *self, SoupURI *inURI)
{
g_return_val_if_fail(IS_NOJS(self), NOJS_POLICY_UNDETERMINED);
g_return_val_if_fail(inURI, NOJS_POLICY_UNDETERMINED);
NoJSPrivate *priv=self->priv;
sqlite3_stmt *statement=NULL;
gint error;
gint policy=NOJS_POLICY_UNDETERMINED;
gchar *inDomain;
/* Check to allow local pages */
if(soup_uri_get_scheme(inURI) == SOUP_URI_SCHEME_FILE)
{
if(priv->allowLocalPages) return(NOJS_POLICY_ACCEPT);
else return(priv->unknownDomainPolicy);
}
/* Check for open database */
g_return_val_if_fail(priv->database, policy);
/* Get domain from URI */
inDomain=nojs_get_domain(self, inURI);
/* Lookup policy for site in database */
error=sqlite3_prepare_v2(priv->database,
"SELECT site, value FROM policies WHERE site LIKE ? LIMIT 1;",
-1,
&statement,
NULL);
if(statement && error==SQLITE_OK) error=sqlite3_bind_text(statement, 1, inDomain, -1, NULL);
if(statement && error==SQLITE_OK)
{
if(sqlite3_step(statement)==SQLITE_ROW) policy=sqlite3_column_int(statement, 1);
}
else g_warning(_("SQL fails: %s"), sqlite3_errmsg(priv->database));
sqlite3_finalize(statement);
/* If we have not found a policy for the domain then it is an unknown domain.
* Get default policy for unknown domains.
*/
if(policy==NOJS_POLICY_UNDETERMINED) policy=priv->unknownDomainPolicy;
return(policy);
}
void nojs_set_policy(NoJS *self, const gchar *inDomain, NoJSPolicy inPolicy)
{
g_return_if_fail(IS_NOJS(self));
g_return_if_fail(inDomain);
g_return_if_fail(inPolicy>=NOJS_POLICY_ACCEPT && inPolicy<=NOJS_POLICY_BLOCK);
NoJSPrivate *priv=self->priv;
gchar *sql;
gchar *error=NULL;
gint success;
/* Check for open database */
g_return_if_fail(priv->database);
/* Update policy in database */
sql=sqlite3_mprintf("INSERT OR REPLACE INTO policies (site, value) VALUES ('%q', %d);",
inDomain,
inPolicy);
success=sqlite3_exec(priv->database, sql, NULL, NULL, &error);
if(success!=SQLITE_OK) g_warning(_("SQL fails: %s"), error);
if(error) sqlite3_free(error);
sqlite3_free(sql);
/* Emit signal to notify about policy change */
if(success==SQLITE_OK) g_signal_emit(self, NoJSSignals[POLICY_CHANGED], 0, inDomain);
}
/* Get/set default policy for unknown domains */
NoJSPolicy nojs_get_policy_for_unknown_domain(NoJS *self)
{
g_return_val_if_fail(IS_NOJS(self), NOJS_POLICY_UNDETERMINED);
return(self->priv->unknownDomainPolicy);
}
void nojs_set_policy_for_unknown_domain(NoJS *self, NoJSPolicy inPolicy)
{
g_return_if_fail(IS_NOJS(self));
g_return_if_fail(inPolicy>=NOJS_POLICY_ACCEPT && inPolicy<=NOJS_POLICY_BLOCK);
if(self->priv->unknownDomainPolicy!=inPolicy)
{
self->priv->unknownDomainPolicy=inPolicy;
midori_extension_set_integer(self->priv->extension, "unknown-domain-policy", inPolicy);
g_object_notify_by_pspec(G_OBJECT(self), NoJSProperties[PROP_UNKNOWN_DOMAIN_POLICY]);
}
}
/* Get/set flag to allow javascript on local pages */
gboolean nojs_get_allow_local_pages(NoJS *self)
{
g_return_val_if_fail(IS_NOJS(self), TRUE);
return(self->priv->allowLocalPages);
}
void nojs_set_allow_local_pages(NoJS *self, gboolean inAllow)
{
g_return_if_fail(IS_NOJS(self));
if(self->priv->allowLocalPages!=inAllow)
{
self->priv->allowLocalPages=inAllow;
midori_extension_set_boolean(self->priv->extension, "allow-local-pages", inAllow);
g_object_notify_by_pspec(G_OBJECT(self), NoJSProperties[PROP_ALLOW_LOCAL_PAGES]);
}
}
/* Get/set flag to check for second-level domains only */
gboolean nojs_get_only_second_level_domain(NoJS *self)
{
g_return_val_if_fail(IS_NOJS(self), TRUE);
return(self->priv->checkOnlySecondLevel);
}
void nojs_set_only_second_level_domain(NoJS *self, gboolean inOnlySecondLevel)
{
g_return_if_fail(IS_NOJS(self));
if(self->priv->checkOnlySecondLevel!=inOnlySecondLevel)
{
self->priv->checkOnlySecondLevel=inOnlySecondLevel;
midori_extension_set_boolean(self->priv->extension, "only-second-level", inOnlySecondLevel);
g_object_notify_by_pspec(G_OBJECT(self), NoJSProperties[PROP_ONLY_SECOND_LEVEL]);
}
}
/************************************************************************************/
/* Implementation: Enumeration */
GType nojs_policy_get_type(void)
{
static volatile gsize g_define_type_id__volatile=0;
if(g_once_init_enter(&g_define_type_id__volatile))
{
static const GEnumValue values[]=
{
{ NOJS_POLICY_UNDETERMINED, "NOJS_POLICY_UNDETERMINED", N_("Undetermined") },
{ NOJS_POLICY_ACCEPT, "NOJS_POLICY_ACCEPT", N_("Accept") },
{ NOJS_POLICY_ACCEPT_TEMPORARILY, "NOJS_POLICY_ACCEPT_TEMPORARILY", N_("Accept temporarily") },
{ NOJS_POLICY_BLOCK, "NOJS_POLICY_BLOCK", N_("Block") },
{ 0, NULL, NULL }
};
GType g_define_type_id=g_enum_register_static(g_intern_static_string("NoJSPolicy"), values);
g_once_init_leave(&g_define_type_id__volatile, g_define_type_id);
}
return(g_define_type_id__volatile);
}
Reference in New Issue View Git Blame Copy Permalink