storing and fetching exceptions catched

Author: hrissan

vkext/vk_zend.h

@@ -229,13 +229,19 @@ static zend_always_inline void vk_zend_update_public_property_long(zval *object,
 static zend_always_inline void vk_zend_call_known_instance_method(zval *object,
                                                                     const char * name, size_t name_len, zval *retval_ptr,
                                                                     uint32_t param_count, zval *params) {
-  // TODO - if we need PHP 7, add ifdef, like above
   zend_object* zobj = Z_OBJ_P(object);
   zend_string* method_name = zend_string_init(name, name_len, 0);
   zend_function* fun = Z_OBJ_HANDLER_P(object, get_method)(&zobj, method_name, 0);
   zend_string_release(method_name);
-  assert(fun);
+  if (!fun) {
+    return; // retval stays UNDEF
+  }
+#if PHP_MAJOR_VERSION >= 8
   zend_call_known_instance_method(fun, zobj, retval_ptr, param_count, params);
+#else
+  // TODO - this branch is not tested yet
+  zend_call_known_instance_method(fun, object, retval_ptr, param_count, params);
+#endif
 }
 
 #define ZAPI_TO_PP(az)          (&(az))

vkext/vkext-rpc-tl-serialization.cpp

@@ -932,33 +932,21 @@ bool store_function2(VK_ZVAL_API_P arr, zval *fetcher) {
     END_TIMER(store_function2)
     return false;
   }
-  zend_object* zobj = Z_OBJ_P(arr);
-
-  zend_string* method_name = zend_string_init("typedStore", strlen("typedStore"), 0);
-  zend_function* typedStore = Z_OBJ_HANDLER_P(arr, get_method)(&zobj, method_name, 0);
-  zend_string_release(method_name);
-
-  if (!typedStore) {
-    fprintf(stderr, "typedStore is not found\n");
-    END_TIMER(store_function2)
-    return false;
-  }
-  fprintf(stderr, "typedStore is found\n");
-  zend_call_known_instance_method(typedStore, zobj,
-                           fetcher, // Where to store the return value
-                           0,       // Number of parameters (0 in this case)
-                           NULL    // Parameter array (NULL if no parameters)
-  );
+  vk_zend_call_known_instance_method(arr, "typedStore", strlen("typedStore"), fetcher, 0, NULL);
   if (EG(exception)) {
-    OBJ_RELEASE(EG(exception));
+    // This behavior is consistent with old code, in this case, query_one will return qid 0
+    fprintf(stderr, "typedStore exception\n");
+    _zend_object* old_exception = EG(exception);
     EG(exception) = NULL;
+    OBJ_RELEASE(old_exception);
+    END_TIMER(store_function2)
+    return false;
   }
-  fprintf(stderr, "typedStore after call\n");
-  if (Z_TYPE_P(fetcher) == IS_NULL) {
+  if (Z_TYPE_P(fetcher) != IS_OBJECT) { // returned null or function not found
+    fprintf(stderr, "typedStore fetcher type is %d\n", Z_TYPE_P(fetcher));
     END_TIMER(store_function2)
     return false;
   }
-  assert(Z_TYPE_P(fetcher) == IS_OBJECT);
   // when using fetcher, tl_current_function_name will not be accessed. But we set it anyway in case we forgot something.
   tl_current_function_name = "typedStore";
   END_TIMER(store_function2)
@@ -1446,25 +1434,32 @@ zval *fetch_function2(zval *fetcher) {
     zval exception_zval;
     ZVAL_OBJ(&exception_zval, old_exception);
 
-    zval message;
-    ZVAL_UNDEF(&message);
-    vk_zend_call_known_instance_method(&exception_zval, "getMessage", strlen("getMessage"), &message, 0, NULL);
+    zval *message;
+    VK_ALLOC_INIT_ZVAL(message);
+    ZVAL_UNDEF(message);
+    vk_zend_call_known_instance_method(&exception_zval, "getMessage", strlen("getMessage"), message, 0, NULL);
     // fprintf(stderr, "getMessage after call %d\n", Z_TYPE(message));
-    assert(Z_TYPE(message) == IS_STRING);
+    assert(Z_TYPE_P(message) == IS_STRING);
 
     OBJ_RELEASE(old_exception);
 
     zval *_err = create_php_instance(reqResult_error_class_name);
 
-    zend_update_property(NULL, Z_OBJ(*_err), "error", strlen("error"), &message);
-    zval_ptr_dtor(&message);
+    vk_zend_update_public_property_nod(_err, "error", message);
 
     // vk_zend_update_public_property_string(_err, "error", "hren");
     vk_zend_update_public_property_long(_err, "error_code", -1000);
+    END_TIMER(fetch_function2)
     return _err;
   }
   fprintf(stderr, "typedFetch after call %d\n", Z_TYPE_P(return_value));
-  assert(Z_TYPE_P(return_value) == IS_OBJECT);
+  if (Z_TYPE_P(return_value) != IS_OBJECT) { // should be never, but that is user code
+    zval *_err = create_php_instance(reqResult_error_class_name);
+    vk_zend_update_public_property_string(_err, "error", "fetcher->typedFetch() did not return object, as expected");
+    vk_zend_update_public_property_long(_err, "error_code", -1000);
+    END_TIMER(fetch_function2)
+    return _err;
+  }
   if (rpc_error.header.has_value()) {
     zval *wrapped_err = create_php_instance(reqResult_header_class_name);
     zval *header_php_repr = convert_rpc_extra_header_to_php_repr(rpc_error.header.value());
@@ -1541,6 +1536,10 @@ void vk_rpc_tl_query_result_impl(struct rpc_queue *Q, double timeout, zval **r)
     }
 
     if (do_rpc_get_and_parse(qid, timeout - precise_now) < 0) {
+      // TODO - most likely. leak here (of both T and fetcher).
+      // But it is difficult to simulate this situation, so
+      // we decided to keep leak to avoid double delete in case we
+      // failed to completely understand this code.
       continue;
     }
     zval *res = make_query_result_or_error(vk_rpc_tl_query_result_one_impl(T, &fetcher), {TL_ERROR_RESPONSE_NOT_FOUND, "Response not found, probably timed out"});