netsurf/javascript/jsapi.c

611 lines
13 KiB
C

/*
* Copyright 2012 Vincent Sanders <vince@netsurf-browser.org>
*
* This file is part of NetSurf, http://www.netsurf-browser.org/
*
* NetSurf 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; version 2 of the License.
*
* NetSurf 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 this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <unistd.h>
#include <signal.h>
#include "javascript/jsapi.h"
#include "render/html_internal.h"
#include "content/content.h"
#include "javascript/content.h"
#include "javascript/js.h"
#include "utils/log.h"
#include "window.h"
#include "event.h"
#define ENABLE_JS_HEARTBEAT 1
static JSRuntime *rt; /* global runtime */
void js_initialise(void)
{
/* Create a JS runtime. */
#if JS_VERSION >= 180
JS_SetCStringsAreUTF8(); /* we prefer our runtime to be utf-8 */
#endif
rt = JS_NewRuntime(8L * 1024L * 1024L);
JSLOG("New runtime handle %p", rt);
if (rt != NULL) {
/* register script content handler */
javascript_init();
}
}
void js_finalise(void)
{
if (rt != NULL) {
JSLOG("destroying runtime handle %p", rt);
JS_DestroyRuntime(rt);
}
JS_ShutDown();
}
/* The error reporter callback. */
static void
js_reportError(JSContext *cx, const char *message, JSErrorReport *report)
{
JSLOG("%s:%u:%s",
report->filename ? report->filename : "<no filename>",
(unsigned int) report->lineno,
message);
}
/* heartbeat routines */
#ifndef ENABLE_JS_HEARTBEAT
struct heartbeat;
/* prepares a context with a heartbeat handler */
static bool
setup_heartbeat(JSContext *cx, int timeout, jscallback *cb, void *cbctx)
{
return true;
}
/* enables the heartbeat on a context */
static struct heartbeat *enable_heartbeat(JSContext *cx)
{
return NULL;
}
/* disables heartbeat on a context */
static bool
disable_heartbeat(struct heartbeat *hb)
{
return true;
}
#else
/* private context for heartbeats */
struct jscontext_priv {
int timeout;
jscallback *cb;
void *cbctx;
unsigned int branch_reset; /**< reset value for branch counter */
unsigned int branch_count; /**< counter for branch callback */
time_t last; /**< last time heartbeat happened */
time_t end; /**< end time for the current script execution */
};
/** execution heartbeat */
static JSBool heartbeat_callback(JSContext *cx)
{
struct jscontext_priv *priv = JS_GetContextPrivate(cx);
JSBool ret = JS_TRUE;
time_t now = time(NULL);
/* dynamically update the branch times to ensure we do not get
* called back more than once a second
*/
if (now == priv->last) {
priv->branch_reset = priv->branch_reset * 2;
}
priv->last = now;
JSLOG("Running heatbeat at %d end %d", now , priv->end);
if ((priv->cb != NULL) &&
(now > priv->end)) {
if (priv->cb(priv->cbctx) == false) {
ret = JS_FALSE; /* abort */
} else {
priv->end = time(NULL) + priv->timeout;
}
}
return ret;
}
#if JS_VERSION >= 180
struct heartbeat {
JSContext *cx;
struct sigaction sact; /* signal handler action to restore */
int alm; /* alarm value to restore */
};
static struct heartbeat *cur_hb;
static bool
setup_heartbeat(JSContext *cx, int timeout, jscallback *cb, void *cbctx)
{
struct jscontext_priv *priv;
if (timeout == 0) {
return true;
}
priv = calloc(1, sizeof(*priv));
if (priv == NULL) {
return false;
}
priv->timeout = timeout;
priv->cb = cb;
priv->cbctx = cbctx;
JS_SetContextPrivate(cx, priv);
/* if heartbeat is enabled disable JIT or callbacks do not happen */
JS_SetOptions(cx, JS_GetOptions(cx) & ~JSOPTION_JIT);
JS_SetOperationCallback(cx, heartbeat_callback);
return true;
}
static void sig_alm_handler(int signum)
{
JS_TriggerOperationCallback(cur_hb->cx);
alarm(1);
JSDBG("alarm signal handler for context %p", cur_hb->cx);
}
static struct heartbeat *enable_heartbeat(JSContext *cx)
{
struct jscontext_priv *priv = JS_GetContextPrivate(cx);
struct sigaction sact;
struct heartbeat *hb;
if (priv == NULL) {
return NULL;
}
priv->last = time(NULL);
priv->end = priv->last + priv->timeout;
hb = malloc(sizeof(*hb));
if (hb != NULL) {
sigemptyset(&sact.sa_mask);
sact.sa_flags = 0;
sact.sa_handler = sig_alm_handler;
if (sigaction(SIGALRM, &sact, &hb->sact) == 0) {
cur_hb = hb;
hb->cx = cx;
hb->alm = alarm(1);
} else {
free(hb);
hb = NULL;
LOG(("Unable to set heartbeat"));
}
}
return hb;
}
/** disable heartbeat
*
* /param hb heartbeat to disable may be NULL
* /return true on success.
*/
static bool
disable_heartbeat(struct heartbeat *hb)
{
if (hb != NULL) {
sigaction(SIGALRM, &hb->sact, NULL); /* restore old handler */
alarm(hb->alm); /* restore alarm signal */
}
return true;
}
#else
/* need to setup callback to prevent long running scripts infinite
* hanging.
*
* old method is to use:
* JSBranchCallback JS_SetBranchCallback(JSContext *cx, JSBranchCallback cb);
* which gets called a *lot* and should only do something every 5k calls
* The callback function
* JSBool (*JSBranchCallback)(JSContext *cx, JSScript *script);
* returns JS_TRUE to carry on and JS_FALSE to abort execution
* single thread of execution on the context
* documented in
* https://developer.mozilla.org/en-US/docs/SpiderMonkey/JSAPI_Reference/JS_SetBranchCallback
*
*/
#define INITIAL_BRANCH_RESET 5000
struct heartbeat;
static JSBool branch_callback(JSContext *cx, JSScript *script)
{
struct jscontext_priv *priv = JS_GetContextPrivate(cx);
JSBool ret = JS_TRUE;
priv->branch_count--;
if (priv->branch_count == 0) {
priv->branch_count = priv->branch_reset; /* reset branch count */
ret = heartbeat_callback(cx);
}
return ret;
}
static bool
setup_heartbeat(JSContext *cx, int timeout, jscallback *cb, void *cbctx)
{
struct jscontext_priv *priv;
if (timeout == 0) {
return true;
}
priv = calloc(1, sizeof(*priv));
if (priv == NULL) {
return false;
}
priv->timeout = timeout;
priv->cb = cb;
priv->cbctx = cbctx;
priv->branch_reset = INITIAL_BRANCH_RESET;
priv->branch_count = priv->branch_reset;
JS_SetContextPrivate(cx, priv);
JS_SetBranchCallback(cx, branch_callback);
return true;
}
static struct heartbeat *enable_heartbeat(JSContext *cx)
{
struct jscontext_priv *priv = JS_GetContextPrivate(cx);
if (priv != NULL) {
priv->last = time(NULL);
priv->end = priv->last + priv->timeout;
}
return NULL;
}
static bool
disable_heartbeat(struct heartbeat *hb)
{
return true;
}
#endif
#endif
jscontext *js_newcontext(int timeout, jscallback *cb, void *cbctx)
{
JSContext *cx;
if (rt == NULL) {
return NULL;
}
cx = JS_NewContext(rt, 8192);
if (cx == NULL) {
return NULL;
}
/* set options on context */
JS_SetOptions(cx, JS_GetOptions(cx) | JSOPTION_VAROBJFIX | JSOPTION_JIT);
JS_SetVersion(cx, JSVERSION_LATEST);
JS_SetErrorReporter(cx, js_reportError);
/* run a heartbeat */
setup_heartbeat(cx, timeout, cb, cbctx);
/*JS_SetGCZeal(cx, 2); */
JSLOG("New Context %p", cx);
return (jscontext *)cx;
}
void js_destroycontext(jscontext *ctx)
{
JSContext *cx = (JSContext *)ctx;
struct jscontext_priv *priv;
if (cx != NULL) {
JSLOG("Destroying Context %p", cx);
priv = JS_GetContextPrivate(cx);
JS_DestroyContext(cx);
free(priv);
}
}
/** Create new compartment to run scripts within
*
* This performs the following actions
* 1. constructs a new global object by initialising a window class
* 2. Instantiate the global a window object
*/
jsobject *js_newcompartment(jscontext *ctx, void *win_priv, void *doc_priv)
{
JSContext *cx = (JSContext *)ctx;
JSObject *window_proto;
JSObject *window;
if (cx == NULL) {
return NULL;
}
window_proto = jsapi_InitClass_Window(cx, NULL);
if (window_proto == NULL) {
JSLOG("Unable to initialise window class");
return NULL;
}
window = jsapi_new_Window(cx, window_proto, NULL, win_priv, doc_priv);
return (jsobject *)window;
}
bool js_exec(jscontext *ctx, const char *txt, size_t txtlen)
{
JSContext *cx = (JSContext *)ctx;
jsval rval;
JSBool eval_res;
struct heartbeat *hb;
/* JSLOG("%p \"%s\"",cx ,txt); */
if (ctx == NULL) {
return false;
}
if (txt == NULL) {
return false;
}
if (txtlen == 0) {
return false;
}
hb = enable_heartbeat(cx);
eval_res = JS_EvaluateScript(cx,
JS_GetGlobalObject(cx),
txt, txtlen,
"<head>", 0, &rval);
disable_heartbeat(hb);
if (eval_res == JS_TRUE) {
return true;
}
return false;
}
dom_exception _dom_event_create(dom_document *doc, dom_event **evt);
#define dom_event_create(d, e) _dom_event_create((dom_document *)(d), (dom_event **) (e))
bool js_fire_event(jscontext *ctx, const char *type, dom_document *doc, dom_node *target)
{
JSContext *cx = (JSContext *)ctx;
dom_node *node = target;
JSObject *jsevent;
jsval rval;
jsval argv[1];
JSBool ret = JS_TRUE;
dom_exception exc;
dom_event *event;
dom_string *type_dom;
struct heartbeat *hb;
if (cx == NULL) {
return false;
}
if (node == NULL) {
/* deliver manufactured event to window */
JSLOG("Dispatching event %s at window", type);
/* create and initialise and event object */
exc = dom_string_create((unsigned char*)type,
strlen(type),
&type_dom);
if (exc != DOM_NO_ERR) {
return false;
}
exc = dom_event_create(doc, &event);
if (exc != DOM_NO_ERR) {
return false;
}
exc = dom_event_init(event, type_dom, false, false);
dom_string_unref(type_dom);
if (exc != DOM_NO_ERR) {
return false;
}
jsevent = jsapi_new_Event(cx, NULL, NULL, event);
if (jsevent == NULL) {
return false;
}
hb = enable_heartbeat(cx);
/* dispatch event at the window object */
argv[0] = OBJECT_TO_JSVAL(jsevent);
ret = JS_CallFunctionName(cx,
JS_GetGlobalObject(cx),
"dispatchEvent",
1,
argv,
&rval);
disable_heartbeat(hb);
} else {
JSLOG("Dispatching event %s at %p", type, node);
/* create and initialise and event object */
exc = dom_string_create((unsigned char*)type,
strlen(type),
&type_dom);
if (exc != DOM_NO_ERR) {
return false;
}
exc = dom_event_create(doc, &event);
if (exc != DOM_NO_ERR) {
return false;
}
exc = dom_event_init(event, type_dom, true, true);
dom_string_unref(type_dom);
if (exc != DOM_NO_ERR) {
return false;
}
dom_event_target_dispatch_event(node, event, &ret);
}
if (ret == JS_TRUE) {
return true;
}
return false;
}
struct js_dom_event_private {
JSContext *cx; /* javascript context */
jsval funcval; /* javascript function to call */
struct dom_node *node; /* dom node event listening on */
dom_string *type; /* event type */
dom_event_listener *listener; /* the listener containing this */
};
static void
js_dom_event_listener(struct dom_event *event, void *pw)
{
struct js_dom_event_private *private = pw;
jsval event_argv[1];
jsval event_rval;
JSObject *jsevent;
JSLOG("WOOT dom event with %p", private);
if (!JSVAL_IS_VOID(private->funcval)) {
jsevent = jsapi_new_Event(private->cx, NULL, NULL, event);
if (jsevent != NULL) {
/* dispatch event at the window object */
event_argv[0] = OBJECT_TO_JSVAL(jsevent);
JS_CallFunctionValue(private->cx,
NULL,
private->funcval,
1,
event_argv,
&event_rval);
}
}
}
/* add a listener to a dom node
*
* 1. Create a dom_event_listener From a handle_event function pointer
* and a private word In a document context
*
* 2. Register for your events on a target (dom nodes are targets)
* dom_event_target_add_event_listener(node, evt_name, listener,
* capture_or_not)
*
*/
bool
js_dom_event_add_listener(jscontext *ctx,
struct dom_document *document,
struct dom_node *node,
struct dom_string *event_type_dom,
void *js_funcval)
{
JSContext *cx = (JSContext *)ctx;
dom_exception exc;
struct js_dom_event_private *private;
private = malloc(sizeof(struct js_dom_event_private));
if (private == NULL) {
return false;
}
exc = dom_event_listener_create(document,
js_dom_event_listener,
private,
&private->listener);
if (exc != DOM_NO_ERR) {
return false;
}
private->cx = cx;
private->funcval = *(jsval *)js_funcval;
private->node = node;
private->type = event_type_dom;
JSLOG("adding %p to listener", private);
JSAPI_ADD_VALUE_ROOT(cx, &private->funcval);
exc = dom_event_target_add_event_listener(private->node,
private->type,
private->listener,
true);
if (exc != DOM_NO_ERR) {
JSLOG("failed to add listener");
JSAPI_REMOVE_VALUE_ROOT(cx, &private->funcval);
}
return true;
}