2014-12-12 22:59:28 +00:00
|
|
|
/*
|
|
|
|
+----------------------------------------------------------------------+
|
|
|
|
| PHP Version 5 |
|
|
|
|
+----------------------------------------------------------------------+
|
2016-02-28 19:17:20 +00:00
|
|
|
| Copyright (c) 1997-2016 The PHP Group |
|
2014-12-12 22:59:28 +00:00
|
|
|
+----------------------------------------------------------------------+
|
|
|
|
| http://www.opensource.org/licenses/mit-license.php MIT License |
|
|
|
|
+----------------------------------------------------------------------+
|
|
|
|
| Author: Jani Taskinen <jani.taskinen@iki.fi> |
|
|
|
|
| Author: Patrick Reilly <preilly@php.net> |
|
2015-08-23 13:09:21 +00:00
|
|
|
| Author: Stefan Siegl <stesie@php.net> |
|
2014-12-12 22:59:28 +00:00
|
|
|
+----------------------------------------------------------------------+
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
|
|
#include "config.h"
|
|
|
|
#endif
|
|
|
|
|
|
|
|
extern "C" {
|
|
|
|
#include "php.h"
|
|
|
|
#include "ext/date/php_date.h"
|
|
|
|
#include "ext/standard/php_string.h"
|
|
|
|
#include "zend_interfaces.h"
|
|
|
|
#include "zend_closures.h"
|
|
|
|
#include "zend_exceptions.h"
|
|
|
|
}
|
|
|
|
|
2015-08-02 16:15:04 +00:00
|
|
|
#if !defined(_WIN32) && PHP_V8_API_VERSION >= 3029036
|
|
|
|
#include <libplatform/libplatform.h>
|
|
|
|
#endif
|
|
|
|
|
2014-12-12 22:59:28 +00:00
|
|
|
#include "php_v8js_macros.h"
|
|
|
|
#include "v8js_v8.h"
|
|
|
|
#include "v8js_timer.h"
|
|
|
|
#include "v8js_exceptions.h"
|
|
|
|
|
2016-02-28 19:17:20 +00:00
|
|
|
#if defined(PHP_V8_USE_EXTERNAL_STARTUP_DATA) && PHP_V8_API_VERSION < 4006076
|
|
|
|
/* Old V8 version, requires startup data but has no
|
|
|
|
* (internal/API) means to let it be loaded. */
|
|
|
|
static v8::StartupData natives_;
|
|
|
|
static v8::StartupData snapshot_;
|
|
|
|
|
|
|
|
static void v8js_v8_load_startup_data(const char* blob_file,
|
|
|
|
v8::StartupData* startup_data,
|
|
|
|
void (*setter_fn)(v8::StartupData*)) {
|
|
|
|
startup_data->data = NULL;
|
|
|
|
startup_data->raw_size = 0;
|
|
|
|
|
|
|
|
if (!blob_file) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
FILE* file = fopen(blob_file, "rb");
|
|
|
|
if (!file) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
fseek(file, 0, SEEK_END);
|
|
|
|
startup_data->raw_size = static_cast<int>(ftell(file));
|
|
|
|
rewind(file);
|
|
|
|
|
|
|
|
startup_data->data = new char[startup_data->raw_size];
|
|
|
|
int read_size = static_cast<int>(fread(const_cast<char*>(startup_data->data),
|
|
|
|
1, startup_data->raw_size, file));
|
|
|
|
fclose(file);
|
|
|
|
|
|
|
|
if (startup_data->raw_size == read_size) {
|
|
|
|
(*setter_fn)(startup_data);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
2014-12-12 22:59:28 +00:00
|
|
|
void v8js_v8_init(TSRMLS_D) /* {{{ */
|
|
|
|
{
|
2015-09-26 16:58:12 +00:00
|
|
|
/* Run only once; thread-local test first */
|
2014-12-12 22:59:28 +00:00
|
|
|
if (V8JSG(v8_initialized)) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2015-09-26 16:58:12 +00:00
|
|
|
/* Set thread-local flag, that V8 was initialized. */
|
|
|
|
V8JSG(v8_initialized) = 1;
|
|
|
|
|
|
|
|
#ifdef ZTS
|
|
|
|
v8js_process_globals.lock.lock();
|
|
|
|
|
|
|
|
if(v8js_process_globals.v8_initialized) {
|
|
|
|
/* V8 already has been initialized by another thread */
|
|
|
|
v8js_process_globals.lock.unlock();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2016-02-28 16:48:44 +00:00
|
|
|
#ifdef PHP_V8_USE_EXTERNAL_STARTUP_DATA
|
2016-02-28 19:17:20 +00:00
|
|
|
/* V8 doesn't work without startup data, load it. */
|
|
|
|
#if PHP_V8_API_VERSION >= 4006076
|
2016-02-28 16:48:44 +00:00
|
|
|
v8::V8::InitializeExternalStartupData(
|
|
|
|
PHP_V8_NATIVES_BLOB_PATH,
|
|
|
|
PHP_V8_SNAPSHOT_BLOB_PATH
|
|
|
|
);
|
2016-02-28 19:17:20 +00:00
|
|
|
#else
|
|
|
|
v8js_v8_load_startup_data(PHP_V8_NATIVES_BLOB_PATH, &natives_, v8::V8::SetNativesDataBlob);
|
|
|
|
v8js_v8_load_startup_data(PHP_V8_SNAPSHOT_BLOB_PATH, &snapshot_, v8::V8::SetSnapshotDataBlob);
|
|
|
|
#endif
|
2016-02-28 16:48:44 +00:00
|
|
|
#endif
|
|
|
|
|
2014-12-12 22:59:28 +00:00
|
|
|
#if !defined(_WIN32) && PHP_V8_API_VERSION >= 3029036
|
2015-09-26 16:58:12 +00:00
|
|
|
v8js_process_globals.v8_platform = v8::platform::CreateDefaultPlatform();
|
|
|
|
v8::V8::InitializePlatform(v8js_process_globals.v8_platform);
|
2014-12-12 22:59:28 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
/* Set V8 command line flags (must be done before V8::Initialize()!) */
|
2015-09-26 19:39:26 +00:00
|
|
|
if (v8js_process_globals.v8_flags) {
|
|
|
|
v8::V8::SetFlagsFromString(v8js_process_globals.v8_flags,
|
|
|
|
strlen(v8js_process_globals.v8_flags));
|
2014-12-12 22:59:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Initialize V8 */
|
|
|
|
v8::V8::Initialize();
|
|
|
|
|
2015-09-26 16:58:12 +00:00
|
|
|
#ifdef ZTS
|
|
|
|
v8js_process_globals.v8_initialized = 1;
|
|
|
|
v8js_process_globals.lock.unlock();
|
|
|
|
#endif
|
2014-12-12 22:59:28 +00:00
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
|
|
|
|
2014-12-13 00:15:29 +00:00
|
|
|
void v8js_v8_call(v8js_ctx *c, zval **return_value,
|
2014-12-12 22:59:28 +00:00
|
|
|
long flags, long time_limit, long memory_limit,
|
|
|
|
std::function< v8::Local<v8::Value>(v8::Isolate *) >& v8_call TSRMLS_DC) /* {{{ */
|
|
|
|
{
|
|
|
|
char *tz = NULL;
|
|
|
|
|
|
|
|
V8JS_CTX_PROLOGUE(c);
|
|
|
|
|
|
|
|
V8JSG(timer_mutex).lock();
|
|
|
|
c->time_limit_hit = false;
|
|
|
|
c->memory_limit_hit = false;
|
|
|
|
V8JSG(timer_mutex).unlock();
|
|
|
|
|
|
|
|
/* Catch JS exceptions */
|
|
|
|
v8::TryCatch try_catch;
|
|
|
|
|
|
|
|
/* Set flags for runtime use */
|
2015-08-21 14:12:12 +00:00
|
|
|
c->flags = flags;
|
2014-12-12 22:59:28 +00:00
|
|
|
|
|
|
|
/* Check if timezone has been changed and notify V8 */
|
|
|
|
tz = getenv("TZ");
|
|
|
|
|
|
|
|
if (tz != NULL) {
|
|
|
|
if (c->tz == NULL) {
|
|
|
|
c->tz = strdup(tz);
|
|
|
|
}
|
|
|
|
else if (strcmp(c->tz, tz) != 0) {
|
|
|
|
v8::Date::DateTimeConfigurationChangeNotification(c->isolate);
|
|
|
|
|
|
|
|
free(c->tz);
|
|
|
|
c->tz = strdup(tz);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (time_limit > 0 || memory_limit > 0) {
|
|
|
|
// If timer thread is not running then start it
|
|
|
|
if (!V8JSG(timer_thread)) {
|
|
|
|
// If not, start timer thread
|
|
|
|
V8JSG(timer_thread) = new std::thread(v8js_timer_thread TSRMLS_CC);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Always pass the timer to the stack so there can be follow-up changes to
|
|
|
|
* the time & memory limit. */
|
|
|
|
v8js_timer_push(time_limit, memory_limit, c TSRMLS_CC);
|
|
|
|
|
|
|
|
/* Execute script */
|
|
|
|
c->in_execution++;
|
|
|
|
v8::Local<v8::Value> result = v8_call(c->isolate);
|
|
|
|
c->in_execution--;
|
|
|
|
|
|
|
|
/* Pop our context from the stack and read (possibly updated) limits
|
|
|
|
* into local variables. */
|
|
|
|
V8JSG(timer_mutex).lock();
|
2014-12-13 00:15:29 +00:00
|
|
|
v8js_timer_ctx *timer_ctx = V8JSG(timer_stack).front();
|
2014-12-12 22:59:28 +00:00
|
|
|
V8JSG(timer_stack).pop_front();
|
|
|
|
V8JSG(timer_mutex).unlock();
|
|
|
|
|
|
|
|
time_limit = timer_ctx->time_limit;
|
|
|
|
memory_limit = timer_ctx->memory_limit;
|
|
|
|
|
|
|
|
efree(timer_ctx);
|
|
|
|
|
2014-12-13 00:30:23 +00:00
|
|
|
/* Check for fatal error marker possibly set by v8js_error_handler; just
|
2014-12-12 22:59:28 +00:00
|
|
|
* rethrow the error since we're now out of V8. */
|
|
|
|
if(V8JSG(fatal_error_abort)) {
|
|
|
|
zend_bailout();
|
|
|
|
}
|
|
|
|
|
|
|
|
char exception_string[64];
|
|
|
|
|
|
|
|
if (c->time_limit_hit) {
|
|
|
|
// Execution has been terminated due to time limit
|
|
|
|
sprintf(exception_string, "Script time limit of %lu milliseconds exceeded", time_limit);
|
|
|
|
zend_throw_exception(php_ce_v8js_time_limit_exception, exception_string, 0 TSRMLS_CC);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (c->memory_limit_hit) {
|
|
|
|
// Execution has been terminated due to memory limit
|
|
|
|
sprintf(exception_string, "Script memory limit of %lu bytes exceeded", memory_limit);
|
|
|
|
zend_throw_exception(php_ce_v8js_memory_limit_exception, exception_string, 0 TSRMLS_CC);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!try_catch.CanContinue()) {
|
|
|
|
// At this point we can't re-throw the exception
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* There was pending exception left from earlier executions -> throw to PHP */
|
|
|
|
if (c->pending_exception) {
|
|
|
|
zend_throw_exception_object(c->pending_exception TSRMLS_CC);
|
|
|
|
c->pending_exception = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Handle runtime JS exceptions */
|
|
|
|
if (try_catch.HasCaught()) {
|
|
|
|
|
|
|
|
/* Pending exceptions are set only in outer caller, inner caller exceptions are always rethrown */
|
|
|
|
if (c->in_execution < 1) {
|
|
|
|
|
|
|
|
/* Report immediately if report_uncaught is true */
|
|
|
|
if (c->report_uncaught) {
|
2015-08-23 13:09:21 +00:00
|
|
|
v8js_throw_script_exception(c->isolate, &try_catch TSRMLS_CC);
|
2014-12-12 22:59:28 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Exception thrown from JS, preserve it for future execution */
|
|
|
|
if (result.IsEmpty()) {
|
|
|
|
MAKE_STD_ZVAL(c->pending_exception);
|
2015-08-23 13:09:21 +00:00
|
|
|
v8js_create_script_exception(c->pending_exception, c->isolate, &try_catch TSRMLS_CC);
|
2014-12-12 22:59:28 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Rethrow back to JS */
|
|
|
|
try_catch.ReThrow();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Convert V8 value to PHP value */
|
|
|
|
if (!result.IsEmpty()) {
|
|
|
|
v8js_to_zval(result, *return_value, flags, c->isolate TSRMLS_CC);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
2015-08-21 13:55:52 +00:00
|
|
|
void v8js_terminate_execution(v8::Isolate *isolate) /* {{{ */
|
2014-12-12 22:59:28 +00:00
|
|
|
{
|
2015-09-22 20:36:50 +00:00
|
|
|
if(v8::V8::IsExecutionTerminating(isolate)) {
|
|
|
|
/* Execution already terminating, needn't trigger it again and
|
|
|
|
* especially must not execute the spinning loop (which would cause
|
|
|
|
* crashes in V8 itself, at least with 4.2 and 4.3 version lines). */
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2015-08-21 13:55:52 +00:00
|
|
|
/* Unfortunately just calling TerminateExecution on the isolate is not
|
|
|
|
* enough, since v8 just marks the thread as "to be aborted" and doesn't
|
|
|
|
* immediately do so. Hence we enter an endless loop after signalling
|
|
|
|
* termination, so we definitely don't execute JS code after the exit()
|
|
|
|
* statement. */
|
|
|
|
v8::Locker locker(isolate);
|
|
|
|
v8::Isolate::Scope isolate_scope(isolate);
|
|
|
|
v8::HandleScope handle_scope(isolate);
|
|
|
|
|
|
|
|
v8::Local<v8::String> source = V8JS_STR("for(;;);");
|
|
|
|
v8::Local<v8::Script> script = v8::Script::Compile(source);
|
|
|
|
v8::V8::TerminateExecution(isolate);
|
|
|
|
script->Run();
|
2014-12-12 22:59:28 +00:00
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
2014-12-12 23:28:09 +00:00
|
|
|
|
|
|
|
int v8js_get_properties_hash(v8::Handle<v8::Value> jsValue, HashTable *retval, int flags, v8::Isolate *isolate TSRMLS_DC) /* {{{ */
|
|
|
|
{
|
|
|
|
v8::Local<v8::Object> jsObj = jsValue->ToObject();
|
|
|
|
|
|
|
|
if (!jsObj.IsEmpty()) {
|
|
|
|
v8::Local<v8::Array> jsKeys = jsObj->GetPropertyNames();
|
|
|
|
|
|
|
|
for (unsigned i = 0; i < jsKeys->Length(); i++)
|
|
|
|
{
|
|
|
|
v8::Local<v8::String> jsKey = jsKeys->Get(i)->ToString();
|
|
|
|
|
|
|
|
/* Skip any prototype properties */
|
|
|
|
if (!jsObj->HasOwnProperty(jsKey) && !jsObj->HasRealNamedProperty(jsKey) && !jsObj->HasRealNamedCallbackProperty(jsKey)) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
v8::Local<v8::Value> jsVal = jsObj->Get(jsKey);
|
|
|
|
v8::String::Utf8Value cstr(jsKey);
|
|
|
|
const char *key = ToCString(cstr);
|
|
|
|
zval *value = NULL;
|
|
|
|
|
|
|
|
v8::Local<v8::Value> php_object;
|
|
|
|
if (jsVal->IsObject()) {
|
|
|
|
php_object = v8::Local<v8::Object>::Cast(jsVal)->GetHiddenValue(V8JS_SYM(PHPJS_OBJECT_KEY));
|
|
|
|
}
|
|
|
|
if (!php_object.IsEmpty()) {
|
|
|
|
/* This is a PHP object, passed to JS and back. */
|
|
|
|
value = reinterpret_cast<zval *>(v8::External::Cast(*php_object)->Value());
|
|
|
|
Z_ADDREF_P(value);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
MAKE_STD_ZVAL(value);
|
|
|
|
|
|
|
|
if (v8js_to_zval(jsVal, value, flags, isolate TSRMLS_CC) == FAILURE) {
|
|
|
|
zval_ptr_dtor(&value);
|
|
|
|
return FAILURE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((flags & V8JS_FLAG_FORCE_ARRAY) || jsValue->IsArray()) {
|
|
|
|
zend_symtable_update(retval, key, strlen(key) + 1, (void *)&value, sizeof(zval *), NULL);
|
|
|
|
} else {
|
|
|
|
zend_hash_update(retval, key, strlen(key) + 1, (void *) &value, sizeof(zval *), NULL);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return SUCCESS;
|
|
|
|
}
|
|
|
|
return FAILURE;
|
|
|
|
}
|
|
|
|
/* }}} */
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2014-12-12 22:59:28 +00:00
|
|
|
/*
|
|
|
|
* Local variables:
|
|
|
|
* tab-width: 4
|
|
|
|
* c-basic-offset: 4
|
|
|
|
* End:
|
|
|
|
* vim600: noet sw=4 ts=4 fdm=marker
|
|
|
|
* vim<600: noet sw=4 ts=4
|
|
|
|
*/
|