v8js_object_export.cc 33 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996
  1. /*
  2. +----------------------------------------------------------------------+
  3. | PHP Version 5 |
  4. +----------------------------------------------------------------------+
  5. | Copyright (c) 1997-2013 The PHP Group |
  6. +----------------------------------------------------------------------+
  7. | http://www.opensource.org/licenses/mit-license.php MIT License |
  8. +----------------------------------------------------------------------+
  9. | Author: Jani Taskinen <[email protected]> |
  10. | Author: Patrick Reilly <[email protected]> |
  11. +----------------------------------------------------------------------+
  12. */
  13. #ifdef HAVE_CONFIG_H
  14. #include "config.h"
  15. #endif
  16. extern "C" {
  17. #include "php.h"
  18. #include "ext/date/php_date.h"
  19. #include "ext/standard/php_string.h"
  20. #include "zend_interfaces.h"
  21. #include "zend_closures.h"
  22. #include "zend_exceptions.h"
  23. }
  24. #include "php_v8js_macros.h"
  25. #include "v8js_array_access.h"
  26. #include "v8js_object_export.h"
  27. #include "v8js_v8object_class.h"
  28. static void v8js_weak_object_callback(const v8::WeakCallbackData<v8::Object, zval> &data);
  29. /* Callback for PHP methods and functions */
  30. static void v8js_call_php_func(zval *value, zend_class_entry *ce, zend_function *method_ptr, v8::Isolate *isolate, const v8::FunctionCallbackInfo<v8::Value>& info TSRMLS_DC) /* {{{ */
  31. {
  32. v8::Handle<v8::Value> return_value = V8JS_NULL;
  33. zend_fcall_info fci;
  34. zend_fcall_info_cache fcc;
  35. zval fname, *retval_ptr = NULL, **argv = NULL;
  36. zend_uint argc = info.Length(), min_num_args = 0, max_num_args = 0;
  37. char *error;
  38. int error_len, i;
  39. v8js_ctx *ctx = (v8js_ctx *) isolate->GetData(0);
  40. /* Set parameter limits */
  41. min_num_args = method_ptr->common.required_num_args;
  42. max_num_args = method_ptr->common.num_args;
  43. /* Function name to call */
  44. INIT_ZVAL(fname);
  45. ZVAL_STRING(&fname, method_ptr->common.function_name, 0);
  46. /* zend_fcall_info */
  47. fci.size = sizeof(fci);
  48. fci.function_table = &ce->function_table;
  49. fci.function_name = &fname;
  50. fci.symbol_table = NULL;
  51. fci.object_ptr = value;
  52. fci.retval_ptr_ptr = &retval_ptr;
  53. fci.param_count = 0;
  54. /* Check for passed vs required number of arguments */
  55. if (argc < min_num_args)
  56. {
  57. error_len = spprintf(&error, 0,
  58. "%s::%s() expects %s %d parameter%s, %d given",
  59. ce->name,
  60. method_ptr->common.function_name,
  61. min_num_args == max_num_args ? "exactly" : argc < min_num_args ? "at least" : "at most",
  62. argc < min_num_args ? min_num_args : max_num_args,
  63. (argc < min_num_args ? min_num_args : max_num_args) == 1 ? "" : "s",
  64. argc);
  65. return_value = V8JS_THROW(isolate, TypeError, error, error_len);
  66. if (ce == zend_ce_closure) {
  67. efree(const_cast<char*>(method_ptr->internal_function.function_name));
  68. efree(method_ptr);
  69. }
  70. efree(error);
  71. info.GetReturnValue().Set(return_value);
  72. return;
  73. }
  74. /* Convert parameters passed from V8 */
  75. if (argc) {
  76. fci.params = (zval ***) safe_emalloc(argc, sizeof(zval **), 0);
  77. argv = (zval **) safe_emalloc(argc, sizeof(zval *), 0);
  78. for (i = 0; i < argc; i++) {
  79. v8::Local<v8::Value> php_object;
  80. if (info[i]->IsObject()) {
  81. php_object = v8::Local<v8::Object>::Cast(info[i])->GetHiddenValue(V8JS_SYM(PHPJS_OBJECT_KEY));
  82. }
  83. if (!php_object.IsEmpty()) {
  84. /* This is a PHP object, passed to JS and back. */
  85. argv[i] = reinterpret_cast<zval *>(v8::External::Cast(*php_object)->Value());
  86. Z_ADDREF_P(argv[i]);
  87. } else {
  88. MAKE_STD_ZVAL(argv[i]);
  89. if (v8js_to_zval(info[i], argv[i], ctx->flags, isolate TSRMLS_CC) == FAILURE) {
  90. fci.param_count++;
  91. error_len = spprintf(&error, 0, "converting parameter #%d passed to %s() failed", i + 1, method_ptr->common.function_name);
  92. return_value = V8JS_THROW(isolate, Error, error, error_len);
  93. efree(error);
  94. goto failure;
  95. }
  96. }
  97. fci.params[fci.param_count++] = &argv[i];
  98. }
  99. } else {
  100. fci.params = NULL;
  101. }
  102. fci.no_separation = 1;
  103. info.GetReturnValue().Set(V8JS_NULL);
  104. zend_try {
  105. {
  106. isolate->Exit();
  107. v8::Unlocker unlocker(isolate);
  108. /* zend_fcall_info_cache */
  109. fcc.initialized = 1;
  110. fcc.function_handler = method_ptr;
  111. fcc.calling_scope = ce;
  112. fcc.called_scope = ce;
  113. fcc.object_ptr = value;
  114. zend_call_function(&fci, &fcc TSRMLS_CC);
  115. }
  116. isolate->Enter();
  117. }
  118. zend_catch {
  119. v8js_terminate_execution(isolate);
  120. V8JSG(fatal_error_abort) = 1;
  121. }
  122. zend_end_try();
  123. failure:
  124. /* Cleanup */
  125. if (argc) {
  126. for (i = 0; i < fci.param_count; i++) {
  127. zval_ptr_dtor(&argv[i]);
  128. }
  129. efree(argv);
  130. efree(fci.params);
  131. }
  132. if(EG(exception)) {
  133. if(ctx->flags & V8JS_FLAG_PROPAGATE_PHP_EXCEPTIONS) {
  134. return_value = isolate->ThrowException(zval_to_v8js(EG(exception), isolate TSRMLS_CC));
  135. zend_clear_exception(TSRMLS_C);
  136. } else {
  137. v8js_terminate_execution(isolate);
  138. }
  139. } else if (retval_ptr != NULL) {
  140. return_value = zval_to_v8js(retval_ptr, isolate TSRMLS_CC);
  141. }
  142. if (retval_ptr != NULL) {
  143. zval_ptr_dtor(&retval_ptr);
  144. }
  145. info.GetReturnValue().Set(return_value);
  146. }
  147. /* }}} */
  148. /* Callback for PHP methods and functions */
  149. static void v8js_php_callback(const v8::FunctionCallbackInfo<v8::Value>& info) /* {{{ */
  150. {
  151. v8::Isolate *isolate = info.GetIsolate();
  152. v8::Local<v8::Object> self = info.Holder();
  153. V8JS_TSRMLS_FETCH();
  154. zval *value = reinterpret_cast<zval *>(v8::External::Cast(*self->GetHiddenValue(V8JS_SYM(PHPJS_OBJECT_KEY)))->Value());
  155. zend_function *method_ptr;
  156. zend_class_entry *ce = Z_OBJCE_P(value);
  157. /* Set method_ptr from v8::External or fetch the closure invoker */
  158. if (!info.Data().IsEmpty() && info.Data()->IsExternal()) {
  159. method_ptr = static_cast<zend_function *>(v8::External::Cast(*info.Data())->Value());
  160. } else {
  161. method_ptr = zend_get_closure_invoke_method(value TSRMLS_CC);
  162. }
  163. return v8js_call_php_func(value, ce, method_ptr, isolate, info TSRMLS_CC);
  164. }
  165. /* Callback for PHP constructor calls */
  166. static void v8js_construct_callback(const v8::FunctionCallbackInfo<v8::Value>& info) /* {{{ */
  167. {
  168. v8::Isolate *isolate = info.GetIsolate();
  169. info.GetReturnValue().Set(V8JS_UNDEFINED);
  170. // @todo assert constructor call
  171. v8::Handle<v8::Object> newobj = info.This();
  172. v8::Local<v8::External> php_object;
  173. zval *value;
  174. if (!info.IsConstructCall()) {
  175. return;
  176. }
  177. v8::Local<v8::Array> cons_data = v8::Local<v8::Array>::Cast(info.Data());
  178. v8::Local<v8::External> ext_tmpl = v8::Local<v8::External>::Cast(cons_data->Get(0));
  179. v8::Local<v8::External> ext_ce = v8::Local<v8::External>::Cast(cons_data->Get(1));
  180. v8js_ctx *ctx = (v8js_ctx *) isolate->GetData(0);
  181. if (info[0]->IsExternal()) {
  182. // Object created by v8js in v8js_hash_to_jsobj, PHP object passed as v8::External.
  183. php_object = v8::Local<v8::External>::Cast(info[0]);
  184. value = reinterpret_cast<zval *>(php_object->Value());
  185. if(ctx->weak_objects.count(value)) {
  186. // We already exported this object, hence no need to add another
  187. // ref, v8 won't give us a second weak-object callback anyways.
  188. newobj->SetAlignedPointerInInternalField(0, ext_tmpl->Value());
  189. newobj->SetHiddenValue(V8JS_SYM(PHPJS_OBJECT_KEY), php_object);
  190. return;
  191. }
  192. // Increase the reference count of this value because we're storing it internally for use later
  193. // See https://github.com/preillyme/v8js/issues/6
  194. Z_ADDREF_P(value);
  195. } else {
  196. // Object created from JavaScript context. Need to create PHP object first.
  197. V8JS_TSRMLS_FETCH();
  198. zend_class_entry *ce = static_cast<zend_class_entry *>(ext_ce->Value());
  199. zend_function *ctor_ptr = ce->constructor;
  200. // Check access on __construct function, if any
  201. if (ctor_ptr != NULL && (ctor_ptr->common.fn_flags & ZEND_ACC_PUBLIC) == 0) {
  202. info.GetReturnValue().Set(isolate->ThrowException(V8JS_SYM("Call to protected __construct() not allowed")));
  203. return;
  204. }
  205. MAKE_STD_ZVAL(value);
  206. object_init_ex(value, ce);
  207. // Call __construct function
  208. if (ctor_ptr != NULL) {
  209. v8js_call_php_func(value, ce, ctor_ptr, isolate, info TSRMLS_CC);
  210. }
  211. php_object = v8::External::New(isolate, value);
  212. }
  213. newobj->SetAlignedPointerInInternalField(0, ext_tmpl->Value());
  214. newobj->SetHiddenValue(V8JS_SYM(PHPJS_OBJECT_KEY), php_object);
  215. // Since we got to decrease the reference count again, in case v8 garbage collector
  216. // decides to dispose the JS object, we add a weak persistent handle and register
  217. // a callback function that removes the reference.
  218. ctx->weak_objects[value].Reset(isolate, newobj);
  219. ctx->weak_objects[value].SetWeak(value, v8js_weak_object_callback);
  220. // Just tell v8 that we're allocating some external memory
  221. // (for the moment we just always tell 1k instead of trying to find out actual values)
  222. isolate->AdjustAmountOfExternalAllocatedMemory(1024);
  223. }
  224. /* }}} */
  225. static void v8js_weak_object_callback(const v8::WeakCallbackData<v8::Object, zval> &data) {
  226. v8::Isolate *isolate = data.GetIsolate();
  227. zval *value = data.GetParameter();
  228. zval_ptr_dtor(&value);
  229. v8js_ctx *ctx = (v8js_ctx *) isolate->GetData(0);
  230. ctx->weak_objects.at(value).Reset();
  231. ctx->weak_objects.erase(value);
  232. isolate->AdjustAmountOfExternalAllocatedMemory(-1024);
  233. }
  234. static void v8js_weak_closure_callback(const v8::WeakCallbackData<v8::Object, v8js_tmpl_t> &data) {
  235. v8::Isolate *isolate = data.GetIsolate();
  236. v8js_tmpl_t *persist_tpl_ = data.GetParameter();
  237. persist_tpl_->Reset();
  238. delete persist_tpl_;
  239. v8js_ctx *ctx = (v8js_ctx *) isolate->GetData(0);
  240. ctx->weak_closures.at(persist_tpl_).Reset();
  241. ctx->weak_closures.erase(persist_tpl_);
  242. };
  243. /* These are not defined by Zend */
  244. #define ZEND_WAKEUP_FUNC_NAME "__wakeup"
  245. #define ZEND_SLEEP_FUNC_NAME "__sleep"
  246. #define ZEND_SET_STATE_FUNC_NAME "__set_state"
  247. #define IS_MAGIC_FUNC(mname) \
  248. ((key_len == sizeof(mname)) && \
  249. !strncasecmp(key, mname, key_len - 1))
  250. #define PHP_V8JS_CALLBACK(isolate, mptr, tmpl) \
  251. v8::FunctionTemplate::New((isolate), v8js_php_callback, v8::External::New((isolate), mptr), v8::Signature::New((isolate), tmpl))->GetFunction()
  252. static void v8js_named_property_enumerator(const v8::PropertyCallbackInfo<v8::Array> &info) /* {{{ */
  253. {
  254. // note: 'special' properties like 'constructor' are not enumerated.
  255. v8::Isolate *isolate = info.GetIsolate();
  256. v8::Local<v8::Object> self = info.Holder();
  257. v8::Local<v8::Array> result = v8::Array::New(isolate, 0);
  258. uint32_t result_len = 0;
  259. V8JS_TSRMLS_FETCH();
  260. zend_class_entry *ce;
  261. zend_function *method_ptr;
  262. HashTable *proptable;
  263. HashPosition pos;
  264. char *key = NULL;
  265. uint key_len;
  266. ulong index;
  267. zval *object = reinterpret_cast<zval *>(v8::External::Cast(*self->GetHiddenValue(V8JS_SYM(PHPJS_OBJECT_KEY)))->Value());
  268. ce = Z_OBJCE_P(object);
  269. /* enumerate all methods */
  270. zend_hash_internal_pointer_reset_ex(&ce->function_table, &pos);
  271. for (;; zend_hash_move_forward_ex(&ce->function_table, &pos)) {
  272. if (zend_hash_get_current_key_ex(&ce->function_table, &key, &key_len, &index, 0, &pos) != HASH_KEY_IS_STRING ||
  273. zend_hash_get_current_data_ex(&ce->function_table, (void **) &method_ptr, &pos) == FAILURE
  274. ) {
  275. break;
  276. }
  277. if ((method_ptr->common.fn_flags & ZEND_ACC_PUBLIC) == 0) {
  278. /* Allow only public methods */
  279. continue;
  280. }
  281. if ((method_ptr->common.fn_flags & (ZEND_ACC_CTOR|ZEND_ACC_DTOR|ZEND_ACC_CLONE)) != 0) {
  282. /* no __construct, __destruct(), or __clone() functions */
  283. continue;
  284. }
  285. // hide (do not enumerate) other PHP magic functions
  286. if (IS_MAGIC_FUNC(ZEND_CALLSTATIC_FUNC_NAME) ||
  287. IS_MAGIC_FUNC(ZEND_SLEEP_FUNC_NAME) ||
  288. IS_MAGIC_FUNC(ZEND_WAKEUP_FUNC_NAME) ||
  289. IS_MAGIC_FUNC(ZEND_SET_STATE_FUNC_NAME) ||
  290. IS_MAGIC_FUNC(ZEND_GET_FUNC_NAME) ||
  291. IS_MAGIC_FUNC(ZEND_SET_FUNC_NAME) ||
  292. IS_MAGIC_FUNC(ZEND_UNSET_FUNC_NAME) ||
  293. IS_MAGIC_FUNC(ZEND_CALL_FUNC_NAME) ||
  294. IS_MAGIC_FUNC(ZEND_INVOKE_FUNC_NAME) ||
  295. IS_MAGIC_FUNC(ZEND_ISSET_FUNC_NAME)) {
  296. continue;
  297. }
  298. v8::Local<v8::String> method_name = V8JS_STR(method_ptr->common.function_name);
  299. // rename PHP special method names to JS equivalents.
  300. if (IS_MAGIC_FUNC(ZEND_TOSTRING_FUNC_NAME)) {
  301. method_name = V8JS_SYM("toString");
  302. }
  303. result->Set(result_len++, method_name);
  304. }
  305. /* enumerate all properties */
  306. /* Z_OBJPROP uses the get_properties handler */
  307. proptable = Z_OBJPROP_P(object);
  308. zend_hash_internal_pointer_reset_ex(proptable, &pos);
  309. for (;; zend_hash_move_forward_ex(proptable, &pos)) {
  310. int i = zend_hash_get_current_key_ex(proptable, &key, &key_len, &index, 0, &pos);
  311. if (i == HASH_KEY_NON_EXISTANT)
  312. break;
  313. // for consistency with the 'in' operator, skip properties whose
  314. // value IS_NULL (like isset does)
  315. zval **data;
  316. if (zend_hash_get_current_data_ex(proptable, (void **) &data, &pos) == SUCCESS &&
  317. ZVAL_IS_NULL(*data))
  318. continue;
  319. if (i == HASH_KEY_IS_STRING) {
  320. /* skip protected and private members */
  321. if (key[0] == '\0') {
  322. continue;
  323. }
  324. // prefix enumerated property names with '$' so they can be
  325. // dereferenced unambiguously (ie, don't conflict with method
  326. // names)
  327. char *prefixed = static_cast<char *>(emalloc(key_len + 1));
  328. prefixed[0] = '$';
  329. strncpy(prefixed + 1, key, key_len);
  330. result->Set(result_len++, V8JS_STRL(prefixed, key_len));
  331. efree(prefixed);
  332. } else {
  333. // even numeric indices are enumerated as strings in JavaScript
  334. result->Set(result_len++, V8JS_FLOAT((double) index)->ToString());
  335. }
  336. }
  337. /* done */
  338. info.GetReturnValue().Set(result);
  339. }
  340. /* }}} */
  341. static void v8js_invoke_callback(const v8::FunctionCallbackInfo<v8::Value>& info) /* {{{ */
  342. {
  343. v8::Isolate *isolate = info.GetIsolate();
  344. v8::Local<v8::Object> self = info.Holder();
  345. v8::Local<v8::Function> cb = v8::Local<v8::Function>::Cast(info.Data());
  346. int argc = info.Length(), i;
  347. v8::Local<v8::Value> *argv = static_cast<v8::Local<v8::Value> *>(alloca(sizeof(v8::Local<v8::Value>) * argc));
  348. v8::Local<v8::Value> result;
  349. V8JS_TSRMLS_FETCH();
  350. for (i=0; i<argc; i++) {
  351. new(&argv[i]) v8::Local<v8::Value>;
  352. argv[i] = info[i];
  353. }
  354. if (info.IsConstructCall()) {
  355. v8js_ctx *ctx = (v8js_ctx *) isolate->GetData(0);
  356. v8::String::Utf8Value str(self->GetConstructorName()->ToString());
  357. const char *constructor_name = ToCString(str);
  358. zend_class_entry **pce;
  359. zend_lookup_class(constructor_name, str.length(), &pce TSRMLS_CC);
  360. v8::Local<v8::FunctionTemplate> new_tpl;
  361. new_tpl = v8::Local<v8::FunctionTemplate>::New
  362. (isolate, ctx->template_cache.at((*pce)->name));
  363. result = new_tpl->GetFunction()->NewInstance(argc, argv);
  364. } else {
  365. result = cb->Call(self, argc, argv);
  366. }
  367. info.GetReturnValue().Set(result);
  368. }
  369. /* }}} */
  370. // this is a magic '__call' implementation for PHP classes which don't actually
  371. // have a '__call' magic function. This way we can always force a method
  372. // call (as opposed to a property get) from JavaScript using __call.
  373. static void v8js_fake_call_impl(const v8::FunctionCallbackInfo<v8::Value>& info) /* {{{ */
  374. {
  375. v8::Isolate *isolate = info.GetIsolate();
  376. v8::Local<v8::Object> self = info.Holder();
  377. v8::Handle<v8::Value> return_value;
  378. char *error;
  379. int error_len;
  380. V8JS_TSRMLS_FETCH();
  381. zend_class_entry *ce;
  382. zval *object = reinterpret_cast<zval *>(v8::External::Cast(*self->GetHiddenValue(V8JS_SYM(PHPJS_OBJECT_KEY)))->Value());
  383. ce = Z_OBJCE_P(object);
  384. // first arg is method name, second arg is array of args.
  385. if (info.Length() < 2) {
  386. error_len = spprintf(&error, 0,
  387. "%s::__call expects 2 parameters, %d given",
  388. ce->name, (int) info.Length());
  389. return_value = V8JS_THROW(isolate, TypeError, error, error_len);
  390. efree(error);
  391. info.GetReturnValue().Set(return_value);
  392. return;
  393. }
  394. if (!info[1]->IsArray()) {
  395. error_len = spprintf(&error, 0,
  396. "%s::__call expects 2nd parameter to be an array",
  397. ce->name);
  398. return_value = V8JS_THROW(isolate, TypeError, error, error_len);
  399. efree(error);
  400. info.GetReturnValue().Set(return_value);
  401. return;
  402. }
  403. v8::String::Utf8Value str(info[0]->ToString());
  404. const char *method_name = ToCString(str);
  405. uint method_name_len = strlen(method_name);
  406. v8::Local<v8::Array> args = v8::Local<v8::Array>::Cast(info[1]);
  407. if (args->Length() > 1000000) {
  408. // prevent overflow, since args->Length() is a uint32_t and args
  409. // in the Function->Call method below is a (signed) int.
  410. error_len = spprintf(&error, 0,
  411. "%s::__call expects fewer than a million arguments",
  412. ce->name);
  413. return_value = V8JS_THROW(isolate, TypeError, error, error_len);
  414. efree(error);
  415. info.GetReturnValue().Set(return_value);
  416. return;
  417. }
  418. // okay, look up the method name and manually invoke it.
  419. const zend_object_handlers *h = Z_OBJ_HT_P(object);
  420. zend_function *method_ptr =
  421. h->get_method(&object, (char*)method_name, method_name_len
  422. ZEND_HASH_KEY_NULL TSRMLS_CC);
  423. if (method_ptr == NULL ||
  424. (method_ptr->common.fn_flags & ZEND_ACC_PUBLIC) == 0 ||
  425. (method_ptr->common.fn_flags & (ZEND_ACC_CTOR|ZEND_ACC_DTOR|ZEND_ACC_CLONE)) != 0) {
  426. error_len = spprintf(&error, 0,
  427. "%s::__call to %s method %s", ce->name,
  428. (method_ptr == NULL) ? "undefined" : "non-public", method_name);
  429. return_value = V8JS_THROW(isolate, TypeError, error, error_len);
  430. efree(error);
  431. info.GetReturnValue().Set(return_value);
  432. return;
  433. }
  434. v8::Local<v8::FunctionTemplate> tmpl =
  435. v8::Local<v8::FunctionTemplate>::New
  436. (isolate, *reinterpret_cast<v8js_tmpl_t *>(self->GetAlignedPointerFromInternalField(0)));
  437. // use v8js_php_callback to actually execute the method
  438. v8::Local<v8::Function> cb = PHP_V8JS_CALLBACK(isolate, method_ptr, tmpl);
  439. uint32_t i, argc = args->Length();
  440. v8::Local<v8::Value> *argv = static_cast<v8::Local<v8::Value> *>(alloca(sizeof(v8::Local<v8::Value>) * argc));
  441. for (i=0; i<argc; i++) {
  442. new(&argv[i]) v8::Local<v8::Value>;
  443. argv[i] = args->Get(i);
  444. }
  445. return_value = cb->Call(info.This(), (int) argc, argv);
  446. info.GetReturnValue().Set(return_value);
  447. }
  448. /* }}} */
  449. /* This method handles named property and method get/set/query/delete. */
  450. template<typename T>
  451. inline v8::Local<v8::Value> v8js_named_property_callback(v8::Local<v8::String> property, const v8::PropertyCallbackInfo<T> &info, property_op_t callback_type, v8::Local<v8::Value> set_value) /* {{{ */
  452. {
  453. v8::Isolate *isolate = info.GetIsolate();
  454. v8::String::Utf8Value cstr(property);
  455. const char *name = ToCString(cstr);
  456. uint name_len = strlen(name);
  457. char *lower = estrndup(name, name_len);
  458. const char *method_name;
  459. uint method_name_len;
  460. v8js_ctx *ctx = (v8js_ctx *) isolate->GetData(0);
  461. v8::Local<v8::Object> self = info.Holder();
  462. v8::Local<v8::Value> ret_value;
  463. v8::Local<v8::Function> cb;
  464. V8JS_TSRMLS_FETCH();
  465. zend_class_entry *scope, *ce;
  466. zend_function *method_ptr = NULL;
  467. zval *php_value;
  468. zval *object = reinterpret_cast<zval *>(v8::External::Cast(*self->GetHiddenValue(V8JS_SYM(PHPJS_OBJECT_KEY)))->Value());
  469. v8::Local<v8::FunctionTemplate> tmpl =
  470. v8::Local<v8::FunctionTemplate>::New
  471. (isolate, *reinterpret_cast<v8js_tmpl_t *>(self->GetAlignedPointerFromInternalField(0)));
  472. ce = scope = Z_OBJCE_P(object);
  473. /* First, check the (case-insensitive) method table */
  474. php_strtolower(lower, name_len);
  475. method_name = lower;
  476. method_name_len = name_len;
  477. // toString() -> __tostring()
  478. if (name_len == 8 && strcmp(name, "toString") == 0) {
  479. method_name = ZEND_TOSTRING_FUNC_NAME;
  480. method_name_len = sizeof(ZEND_TOSTRING_FUNC_NAME) - 1;
  481. }
  482. bool is_constructor = (name_len == 11 && strcmp(name, "constructor") == 0);
  483. bool is_magic_call = (method_name_len == 6 && strcmp(method_name, "__call") == 0);
  484. if (is_constructor ||
  485. (name[0] != '$' /* leading '$' means property, not method */ &&
  486. zend_hash_find(&ce->function_table, method_name, method_name_len + 1, (void**)&method_ptr) == SUCCESS &&
  487. ((method_ptr->common.fn_flags & ZEND_ACC_PUBLIC) != 0) && /* Allow only public methods */
  488. ((method_ptr->common.fn_flags & (ZEND_ACC_CTOR|ZEND_ACC_DTOR|ZEND_ACC_CLONE)) == 0) /* no __construct, __destruct(), or __clone() functions */
  489. ) || (method_ptr=NULL, is_magic_call)
  490. ) {
  491. if (callback_type == V8JS_PROP_GETTER) {
  492. if (is_constructor) {
  493. // Don't set a return value here, i.e. indicate that we don't
  494. // have a special value. V8 "knows" the constructor anyways
  495. // (from the template) and will use that.
  496. } else {
  497. if (is_magic_call && method_ptr==NULL) {
  498. // Fake __call implementation
  499. // (only use this if method_ptr==NULL, which means
  500. // there is no actual PHP __call() implementation)
  501. v8::Local<v8::Function> cb =
  502. v8::FunctionTemplate::New(isolate,
  503. v8js_fake_call_impl, V8JS_NULL,
  504. v8::Signature::New(isolate, tmpl))->GetFunction();
  505. cb->SetName(property);
  506. ret_value = cb;
  507. } else {
  508. ret_value = PHP_V8JS_CALLBACK(isolate, method_ptr, tmpl);
  509. }
  510. }
  511. } else if (callback_type == V8JS_PROP_QUERY) {
  512. // methods are not enumerable
  513. ret_value = V8JS_UINT(v8::ReadOnly|v8::DontEnum|v8::DontDelete);
  514. } else if (callback_type == V8JS_PROP_SETTER) {
  515. ret_value = set_value; // lie. this field is read-only.
  516. } else if (callback_type == V8JS_PROP_DELETER) {
  517. ret_value = V8JS_BOOL(false);
  518. } else {
  519. /* shouldn't reach here! but bail safely */
  520. ret_value = v8::Handle<v8::Value>();
  521. }
  522. } else {
  523. if (name[0]=='$') {
  524. // this is a property (not a method)
  525. name++; name_len--;
  526. }
  527. if (callback_type == V8JS_PROP_GETTER) {
  528. /* Nope, not a method -- must be a (case-sensitive) property */
  529. zval zname;
  530. INIT_ZVAL(zname);
  531. ZVAL_STRINGL(&zname, name, name_len, 0);
  532. zend_property_info *property_info = zend_get_property_info(ce, &zname, 1 TSRMLS_CC);
  533. if(property_info && property_info->flags & ZEND_ACC_PUBLIC) {
  534. php_value = zend_read_property(NULL, object, V8JS_CONST name, name_len, true TSRMLS_CC);
  535. // special case uninitialized_zval_ptr and return an empty value
  536. // (indicating that we don't intercept this property) if the
  537. // property doesn't exist.
  538. if (php_value == EG(uninitialized_zval_ptr)) {
  539. ret_value = v8::Handle<v8::Value>();
  540. } else {
  541. // wrap it
  542. ret_value = zval_to_v8js(php_value, isolate TSRMLS_CC);
  543. /* We don't own the reference to php_value... unless the
  544. * returned refcount was 0, in which case the below code
  545. * will free it. */
  546. zval_add_ref(&php_value);
  547. zval_ptr_dtor(&php_value);
  548. }
  549. }
  550. else if (zend_hash_find(&ce->function_table, "__get", 6, (void**)&method_ptr) == SUCCESS
  551. /* Allow only public methods */
  552. && ((method_ptr->common.fn_flags & ZEND_ACC_PUBLIC) != 0)) {
  553. /* Okay, let's call __get. */
  554. zend_fcall_info fci;
  555. zval fmember;
  556. INIT_ZVAL(fmember);
  557. ZVAL_STRING(&fmember, "__get", 0);
  558. fci.size = sizeof(fci);
  559. fci.function_table = &ce->function_table;
  560. fci.function_name = &fmember;
  561. fci.symbol_table = NULL;
  562. fci.retval_ptr_ptr = &php_value;
  563. zval *zname_ptr = &zname;
  564. zval **zname_ptr_ptr = &zname_ptr;
  565. fci.param_count = 1;
  566. fci.params = &zname_ptr_ptr;
  567. fci.object_ptr = object;
  568. fci.no_separation = 0;
  569. zend_call_function(&fci, NULL TSRMLS_CC);
  570. ret_value = zval_to_v8js(php_value, isolate TSRMLS_CC);
  571. zval_ptr_dtor(&php_value);
  572. }
  573. } else if (callback_type == V8JS_PROP_SETTER) {
  574. MAKE_STD_ZVAL(php_value);
  575. if (v8js_to_zval(set_value, php_value, ctx->flags, isolate TSRMLS_CC) != SUCCESS) {
  576. ret_value = v8::Handle<v8::Value>();
  577. }
  578. else {
  579. zval zname;
  580. INIT_ZVAL(zname);
  581. ZVAL_STRINGL(&zname, name, name_len, 0);
  582. zend_property_info *property_info = zend_get_property_info(ce, &zname, 1 TSRMLS_CC);
  583. if(property_info && property_info->flags & ZEND_ACC_PUBLIC) {
  584. zend_update_property(scope, object, V8JS_CONST name, name_len, php_value TSRMLS_CC);
  585. ret_value = set_value;
  586. }
  587. else if (zend_hash_find(&ce->function_table, "__set", 6, (void**)&method_ptr) == SUCCESS
  588. /* Allow only public methods */
  589. && ((method_ptr->common.fn_flags & ZEND_ACC_PUBLIC) != 0)) {
  590. /* Okay, let's call __set. */
  591. zend_fcall_info fci;
  592. zval fmember;
  593. INIT_ZVAL(fmember);
  594. ZVAL_STRING(&fmember, "__set", 0);
  595. zval *php_ret_value;
  596. fci.size = sizeof(fci);
  597. fci.function_table = &ce->function_table;
  598. fci.function_name = &fmember;
  599. fci.symbol_table = NULL;
  600. fci.retval_ptr_ptr = &php_ret_value;
  601. zval *zname_ptr = &zname;
  602. zval **params[2];
  603. fci.param_count = 2;
  604. fci.params = params;
  605. fci.params[0] = &zname_ptr;
  606. fci.params[1] = &php_value;
  607. fci.object_ptr = object;
  608. fci.no_separation = 1;
  609. zend_call_function(&fci, NULL TSRMLS_CC);
  610. ret_value = zval_to_v8js(php_ret_value, isolate TSRMLS_CC);
  611. zval_ptr_dtor(&php_ret_value);
  612. }
  613. }
  614. // if PHP wanted to hold on to this value, update_property would
  615. // have bumped the refcount
  616. zval_ptr_dtor(&php_value);
  617. } else if (callback_type == V8JS_PROP_QUERY ||
  618. callback_type == V8JS_PROP_DELETER) {
  619. const zend_object_handlers *h = Z_OBJ_HT_P(object);
  620. zval *prop;
  621. MAKE_STD_ZVAL(prop);
  622. ZVAL_STRINGL(prop, name, name_len, 1);
  623. if (callback_type == V8JS_PROP_QUERY) {
  624. if (h->has_property(object, prop, 0 ZEND_HASH_KEY_NULL TSRMLS_CC)) {
  625. ret_value = V8JS_UINT(v8::None);
  626. } else {
  627. ret_value = v8::Handle<v8::Value>(); // empty handle
  628. }
  629. } else {
  630. zend_property_info *property_info = zend_get_property_info(ce, prop, 1 TSRMLS_CC);
  631. if(property_info && property_info->flags & ZEND_ACC_PUBLIC) {
  632. h->unset_property(object, prop ZEND_HASH_KEY_NULL TSRMLS_CC);
  633. ret_value = V8JS_BOOL(true);
  634. }
  635. else {
  636. ret_value = v8::Handle<v8::Value>(); // empty handle
  637. }
  638. }
  639. zval_ptr_dtor(&prop);
  640. } else {
  641. /* shouldn't reach here! but bail safely */
  642. ret_value = v8::Handle<v8::Value>();
  643. }
  644. }
  645. efree(lower);
  646. return ret_value;
  647. }
  648. /* }}} */
  649. static void v8js_named_property_getter(v8::Local<v8::String> property, const v8::PropertyCallbackInfo<v8::Value> &info) /* {{{ */
  650. {
  651. info.GetReturnValue().Set(v8js_named_property_callback(property, info, V8JS_PROP_GETTER));
  652. }
  653. /* }}} */
  654. static void v8js_named_property_setter(v8::Local<v8::String> property, v8::Local<v8::Value> value, const v8::PropertyCallbackInfo<v8::Value> &info) /* {{{ */
  655. {
  656. info.GetReturnValue().Set(v8js_named_property_callback(property, info, V8JS_PROP_SETTER, value));
  657. }
  658. /* }}} */
  659. static void v8js_named_property_query(v8::Local<v8::String> property, const v8::PropertyCallbackInfo<v8::Integer> &info) /* {{{ */
  660. {
  661. v8::Local<v8::Value> r = v8js_named_property_callback(property, info, V8JS_PROP_QUERY);
  662. if (!r.IsEmpty()) {
  663. info.GetReturnValue().Set(r->ToInteger());
  664. }
  665. }
  666. /* }}} */
  667. static void v8js_named_property_deleter(v8::Local<v8::String> property, const v8::PropertyCallbackInfo<v8::Boolean> &info) /* {{{ */
  668. {
  669. v8::Local<v8::Value> r = v8js_named_property_callback(property, info, V8JS_PROP_DELETER);
  670. if (!r.IsEmpty()) {
  671. info.GetReturnValue().Set(r->ToBoolean());
  672. }
  673. }
  674. /* }}} */
  675. static v8::Handle<v8::Object> v8js_wrap_object(v8::Isolate *isolate, zend_class_entry *ce, zval *value TSRMLS_DC) /* {{{ */
  676. {
  677. v8js_ctx *ctx = (v8js_ctx *) isolate->GetData(0);
  678. v8::Local<v8::FunctionTemplate> new_tpl;
  679. v8js_tmpl_t *persist_tpl_;
  680. try {
  681. new_tpl = v8::Local<v8::FunctionTemplate>::New
  682. (isolate, ctx->template_cache.at(ce->name));
  683. }
  684. catch (const std::out_of_range &) {
  685. /* No cached v8::FunctionTemplate available as of yet, create one. */
  686. new_tpl = v8::FunctionTemplate::New(isolate, 0);
  687. new_tpl->SetClassName(V8JS_STRL(ce->name, ce->name_length));
  688. new_tpl->InstanceTemplate()->SetInternalFieldCount(1);
  689. if (ce == zend_ce_closure) {
  690. /* Got a closure, mustn't cache ... */
  691. persist_tpl_ = new v8js_tmpl_t(isolate, new_tpl);
  692. /* We'll free persist_tpl_ via v8js_weak_closure_callback, below */
  693. new_tpl->InstanceTemplate()->SetCallAsFunctionHandler(v8js_php_callback);
  694. } else {
  695. /* Add new v8::FunctionTemplate to tpl_map, as long as it is not a closure. */
  696. persist_tpl_ = &ctx->template_cache[ce->name];
  697. persist_tpl_->Reset(isolate, new_tpl);
  698. /* We'll free persist_tpl_ when template_cache is destroyed */
  699. v8::Local<v8::ObjectTemplate> inst_tpl = new_tpl->InstanceTemplate();
  700. v8::NamedPropertyGetterCallback getter = v8js_named_property_getter;
  701. v8::NamedPropertyEnumeratorCallback enumerator = v8js_named_property_enumerator;
  702. /* Check for ArrayAccess object */
  703. if (V8JSG(use_array_access) && ce) {
  704. bool has_array_access = false;
  705. bool has_countable = false;
  706. for (int i = 0; i < ce->num_interfaces; i ++) {
  707. if (strcmp (ce->interfaces[i]->name, "ArrayAccess") == 0) {
  708. has_array_access = true;
  709. }
  710. else if (strcmp (ce->interfaces[i]->name, "Countable") == 0) {
  711. has_countable = true;
  712. }
  713. }
  714. if(has_array_access && has_countable) {
  715. inst_tpl->SetIndexedPropertyHandler(v8js_array_access_getter,
  716. v8js_array_access_setter,
  717. v8js_array_access_query,
  718. v8js_array_access_deleter,
  719. v8js_array_access_enumerator);
  720. /* Switch to special ArrayAccess getter, which falls back to
  721. * v8js_named_property_getter, but possibly bridges the
  722. * call to Array.prototype functions. */
  723. getter = v8js_array_access_named_getter;
  724. /* Overwrite enumerator, since for(... in ...) loop should
  725. * not see the methods but iterate over the elements. */
  726. enumerator = 0;
  727. }
  728. }
  729. // Finish setup of new_tpl
  730. inst_tpl->SetNamedPropertyHandler
  731. (getter, /* getter */
  732. v8js_named_property_setter, /* setter */
  733. v8js_named_property_query, /* query */
  734. v8js_named_property_deleter, /* deleter */
  735. enumerator, /* enumerator */
  736. V8JS_NULL /* data */
  737. );
  738. // add __invoke() handler
  739. zend_function *invoke_method_ptr;
  740. if (zend_hash_find(&ce->function_table, ZEND_INVOKE_FUNC_NAME,
  741. sizeof(ZEND_INVOKE_FUNC_NAME),
  742. (void**)&invoke_method_ptr) == SUCCESS &&
  743. invoke_method_ptr->common.fn_flags & ZEND_ACC_PUBLIC) {
  744. new_tpl->InstanceTemplate()->SetCallAsFunctionHandler(v8js_invoke_callback, PHP_V8JS_CALLBACK(isolate, invoke_method_ptr, new_tpl));
  745. }
  746. }
  747. v8::Local<v8::Array> call_handler_data = v8::Array::New(isolate, 2);
  748. call_handler_data->Set(0, v8::External::New(isolate, persist_tpl_));
  749. call_handler_data->Set(1, v8::External::New(isolate, ce));
  750. new_tpl->SetCallHandler(v8js_construct_callback, call_handler_data);
  751. }
  752. // Create v8 wrapper object
  753. v8::Handle<v8::Value> external = v8::External::New(isolate, value);
  754. v8::Handle<v8::Object> newobj = new_tpl->GetFunction()->NewInstance(1, &external);
  755. if (ce == zend_ce_closure) {
  756. // free uncached function template when object is freed
  757. ctx->weak_closures[persist_tpl_].Reset(isolate, newobj);
  758. ctx->weak_closures[persist_tpl_].SetWeak(persist_tpl_, v8js_weak_closure_callback);
  759. }
  760. return newobj;
  761. }
  762. /* }}} */
  763. static v8::Handle<v8::Object> v8js_wrap_array_to_object(v8::Isolate *isolate, zval *value TSRMLS_DC) /* {{{ */
  764. {
  765. int i;
  766. HashPosition pos;
  767. char *key = NULL;
  768. uint key_len;
  769. ulong index;
  770. // @todo re-use template likewise
  771. v8::Local<v8::FunctionTemplate> new_tpl = v8::FunctionTemplate::New(isolate, 0);
  772. /* Call it Array, but it is not a native array, especially it doesn't have
  773. * have the typical Array.prototype functions. */
  774. new_tpl->SetClassName(V8JS_SYM("Array"));
  775. v8::Handle<v8::Object> newobj = new_tpl->InstanceTemplate()->NewInstance();
  776. HashTable *myht = HASH_OF(value);
  777. i = myht ? zend_hash_num_elements(myht) : 0;
  778. if (i > 0)
  779. {
  780. zval **data;
  781. HashTable *tmp_ht;
  782. zend_hash_internal_pointer_reset_ex(myht, &pos);
  783. for (;; zend_hash_move_forward_ex(myht, &pos)) {
  784. i = zend_hash_get_current_key_ex(myht, &key, &key_len, &index, 0, &pos);
  785. if (i == HASH_KEY_NON_EXISTANT)
  786. break;
  787. if (zend_hash_get_current_data_ex(myht, (void **) &data, &pos) == SUCCESS)
  788. {
  789. tmp_ht = HASH_OF(*data);
  790. if (tmp_ht) {
  791. tmp_ht->nApplyCount++;
  792. }
  793. if (i == HASH_KEY_IS_STRING)
  794. {
  795. if (key[0] == '\0' && Z_TYPE_P(value) == IS_OBJECT) {
  796. /* Skip protected and private members. */
  797. if (tmp_ht) {
  798. tmp_ht->nApplyCount--;
  799. }
  800. continue;
  801. }
  802. newobj->Set(V8JS_STRL(key, key_len - 1), zval_to_v8js(*data, isolate TSRMLS_CC));
  803. } else {
  804. newobj->Set(index, zval_to_v8js(*data, isolate TSRMLS_CC));
  805. }
  806. if (tmp_ht) {
  807. tmp_ht->nApplyCount--;
  808. }
  809. }
  810. }
  811. }
  812. return newobj;
  813. }
  814. /* }}} */
  815. v8::Handle<v8::Value> v8js_hash_to_jsobj(zval *value, v8::Isolate *isolate TSRMLS_DC) /* {{{ */
  816. {
  817. HashTable *myht;
  818. zend_class_entry *ce = NULL;
  819. if (Z_TYPE_P(value) == IS_ARRAY) {
  820. myht = HASH_OF(value);
  821. } else {
  822. myht = Z_OBJPROP_P(value);
  823. ce = Z_OBJCE_P(value);
  824. }
  825. /* Prevent recursion */
  826. if (myht && myht->nApplyCount > 1) {
  827. return V8JS_NULL;
  828. }
  829. /* Special case, passing back object originating from JS to JS */
  830. if (ce == php_ce_v8function) {
  831. v8js_v8object *c = (v8js_v8object *) zend_object_store_get_object(value TSRMLS_CC);
  832. if(isolate != c->ctx->isolate) {
  833. php_error_docref(NULL TSRMLS_CC, E_WARNING, "V8Function object passed to wrong V8Js instance");
  834. return V8JS_NULL;
  835. }
  836. return v8::Local<v8::Value>::New(isolate, c->v8obj);
  837. }
  838. /* If it's a PHP object, wrap it */
  839. if (ce) {
  840. return v8js_wrap_object(isolate, ce, value TSRMLS_CC);
  841. }
  842. /* Associative PHP arrays cannot be wrapped to JS arrays, convert them to
  843. * JS objects and attach all their array keys as properties. */
  844. return v8js_wrap_array_to_object(isolate, value TSRMLS_CC);
  845. }
  846. /* }}} */
  847. /*
  848. * Local variables:
  849. * tab-width: 4
  850. * c-basic-offset: 4
  851. * End:
  852. * vim600: noet sw=4 ts=4 fdm=marker
  853. * vim<600: noet sw=4 ts=4
  854. */