Support scalars, enums and arrays

Author: nicolas-grekas

docs/sidekicks.md

@@ -43,15 +43,19 @@ $all = frankenphp_sidekick_get_vars(['redis-watcher', 'feature-flags']);
 
 - `$name` is available as `$_SERVER['FRANKENPHP_SIDEKICK_NAME']` and `$_SERVER['argv'][1]` in the entrypoint script
 - Throws `RuntimeException` on timeout, missing entrypoint, or sidekick crash
+- Throws `LogicException` if the vars contain an enum class or case that cannot be resolved
 - Works in both worker and non-worker mode
 
 ### `frankenphp_sidekick_set_vars(array $vars): void`
 
-Publishes a snapshot of string key-value pairs from inside a sidekick.
+Publishes a snapshot of key-value pairs from inside a sidekick.
 Each call **replaces** the entire snapshot atomically.
 
+Supported value types: `null`, `bool`, `int`, `float`, `string`, `array` (nested), and **enums**.
+Objects, resources, and references are rejected.
+
 - Throws `RuntimeException` if not called from a sidekick context
-- Throws `ValueError` if keys or values are not strings
+- Throws `ValueError` if values contain objects, resources, or references
 
 ### `frankenphp_sidekick_get_signaling_stream(): resource`
 

frankenphp.c

@@ -1,6 +1,7 @@
 #include "frankenphp.h"
 #include <SAPI.h>
 #include <Zend/zend_alloc.h>
+#include <Zend/zend_enum.h>
 #include <Zend/zend_exceptions.h>
 #include <Zend/zend_interfaces.h>
 #include <errno.h>
@@ -675,63 +676,232 @@ PHP_FUNCTION(frankenphp_handle_request) {
   RETURN_TRUE;
 }
 
+/* Persistent enum storage */
+typedef struct {
+  zend_string *class_name;
+  zend_string *case_name;
+} sidekick_enum_t;
+
+/* Validate that a zval tree contains only scalars, arrays, and enums */
+static bool sidekick_validate_zval(zval *z) {
+  switch (Z_TYPE_P(z)) {
+  case IS_NULL:
+  case IS_FALSE:
+  case IS_TRUE:
+  case IS_LONG:
+  case IS_DOUBLE:
+  case IS_STRING:
+    return true;
+  case IS_OBJECT:
+    return (Z_OBJCE_P(z)->ce_flags & ZEND_ACC_ENUM) != 0;
+  case IS_ARRAY: {
+    zval *val;
+    ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(z), val) {
+      if (!sidekick_validate_zval(val))
+        return false;
+    }
+    ZEND_HASH_FOREACH_END();
+    return true;
+  }
+  default:
+    return false;
+  }
+}
+
+/* Deep-copy a zval into persistent memory */
+static void sidekick_persist_zval(zval *dst, zval *src) {
+  switch (Z_TYPE_P(src)) {
+  case IS_NULL:
+  case IS_FALSE:
+  case IS_TRUE:
+    ZVAL_COPY_VALUE(dst, src);
+    break;
+  case IS_LONG:
+    ZVAL_LONG(dst, Z_LVAL_P(src));
+    break;
+  case IS_DOUBLE:
+    ZVAL_DOUBLE(dst, Z_DVAL_P(src));
+    break;
+  case IS_STRING: {
+    zend_string *ps = zend_string_init(Z_STRVAL_P(src), Z_STRLEN_P(src), 1);
+    ZVAL_NEW_STR(dst, ps);
+    break;
+  }
+  case IS_OBJECT: {
+    /* Must be an enum (validated earlier) */
+    zend_class_entry *ce = Z_OBJCE_P(src);
+    sidekick_enum_t *e = pemalloc(sizeof(sidekick_enum_t), 1);
+    e->class_name = zend_string_init(ZSTR_VAL(ce->name), ZSTR_LEN(ce->name), 1);
+    zval *case_name_zval = zend_enum_fetch_case_name(Z_OBJ_P(src));
+    e->case_name = zend_string_init(Z_STRVAL_P(case_name_zval),
+                                    Z_STRLEN_P(case_name_zval), 1);
+    ZVAL_PTR(dst, e);
+    break;
+  }
+  case IS_ARRAY: {
+    HashTable *src_ht = Z_ARRVAL_P(src);
+    HashTable *dst_ht = pemalloc(sizeof(HashTable), 1);
+    zend_hash_init(dst_ht, zend_hash_num_elements(src_ht), NULL, NULL, 1);
+    ZVAL_ARR(dst, dst_ht);
+
+    zend_string *key;
+    zend_ulong idx;
+    zval *val;
+    ZEND_HASH_FOREACH_KEY_VAL(src_ht, idx, key, val) {
+      zval pval;
+      sidekick_persist_zval(&pval, val);
+      if (key) {
+        zend_string *pkey = zend_string_init(ZSTR_VAL(key), ZSTR_LEN(key), 1);
+        zend_hash_add_new(dst_ht, pkey, &pval);
+        zend_string_release(pkey);
+      } else {
+        zend_hash_index_add_new(dst_ht, idx, &pval);
+      }
+    }
+    ZEND_HASH_FOREACH_END();
+    break;
+  }
+  default:
+    ZVAL_NULL(dst);
+    break;
+  }
+}
+
+/* Deep-free a persistent zval tree */
+static void sidekick_free_persistent_zval(zval *z) {
+  switch (Z_TYPE_P(z)) {
+  case IS_STRING:
+    zend_string_free(Z_STR_P(z));
+    break;
+  case IS_PTR: {
+    sidekick_enum_t *e = (sidekick_enum_t *)Z_PTR_P(z);
+    zend_string_free(e->class_name);
+    zend_string_free(e->case_name);
+    pefree(e, 1);
+    break;
+  }
+  case IS_ARRAY: {
+    zval *val;
+    ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(z), val) {
+      sidekick_free_persistent_zval(val);
+    }
+    ZEND_HASH_FOREACH_END();
+    zend_hash_destroy(Z_ARRVAL_P(z));
+    pefree(Z_ARRVAL_P(z), 1);
+    break;
+  }
+  default:
+    break;
+  }
+}
+
+/* Deep-copy a persistent zval tree into request memory */
+static void sidekick_request_copy_zval(zval *dst, zval *src) {
+  switch (Z_TYPE_P(src)) {
+  case IS_NULL:
+  case IS_FALSE:
+  case IS_TRUE:
+    ZVAL_COPY_VALUE(dst, src);
+    break;
+  case IS_LONG:
+    ZVAL_LONG(dst, Z_LVAL_P(src));
+    break;
+  case IS_DOUBLE:
+    ZVAL_DOUBLE(dst, Z_DVAL_P(src));
+    break;
+  case IS_STRING:
+    ZVAL_STRINGL(dst, Z_STRVAL_P(src), Z_STRLEN_P(src));
+    break;
+  case IS_PTR: {
+    sidekick_enum_t *e = (sidekick_enum_t *)Z_PTR_P(src);
+    zend_class_entry *ce = zend_lookup_class(e->class_name);
+    if (!ce || !(ce->ce_flags & ZEND_ACC_ENUM)) {
+      zend_throw_exception_ex(spl_ce_LogicException, 0,
+                              "Sidekick enum class \"%s\" not found",
+                              ZSTR_VAL(e->class_name));
+      ZVAL_NULL(dst);
+      break;
+    }
+    zend_object *enum_obj = zend_enum_get_case_cstr(ce, ZSTR_VAL(e->case_name));
+    if (!enum_obj) {
+      zend_throw_exception_ex(spl_ce_LogicException, 0,
+                              "Sidekick enum case \"%s::%s\" not found",
+                              ZSTR_VAL(e->class_name), ZSTR_VAL(e->case_name));
+      ZVAL_NULL(dst);
+      break;
+    }
+    ZVAL_OBJ_COPY(dst, enum_obj);
+    break;
+  }
+  case IS_ARRAY: {
+    HashTable *src_ht = Z_ARRVAL_P(src);
+    array_init_size(dst, zend_hash_num_elements(src_ht));
+    HashTable *dst_ht = Z_ARRVAL_P(dst);
+
+    zend_string *key;
+    zend_ulong idx;
+    zval *val;
+    ZEND_HASH_FOREACH_KEY_VAL(src_ht, idx, key, val) {
+      zval rval;
+      sidekick_request_copy_zval(&rval, val);
+      if (EG(exception)) {
+        zval_ptr_dtor(&rval);
+        break;
+      }
+      if (key) {
+        zend_string *rkey = zend_string_init(ZSTR_VAL(key), ZSTR_LEN(key), 0);
+        ZSTR_H(rkey) = ZSTR_H(key);
+        zend_hash_add_new(dst_ht, rkey, &rval);
+        zend_string_release(rkey);
+      } else {
+        zend_hash_index_add_new(dst_ht, idx, &rval);
+      }
+    }
+    ZEND_HASH_FOREACH_END();
+    break;
+  }
+  default:
+    ZVAL_NULL(dst);
+    break;
+  }
+}
+
 PHP_FUNCTION(frankenphp_sidekick_set_vars) {
   zval *vars_array = NULL;
 
   ZEND_PARSE_PARAMETERS_START(1, 1);
   Z_PARAM_ARRAY(vars_array);
   ZEND_PARSE_PARAMETERS_END();
 
-  /* Validate all keys and values are strings */
-  HashTable *ht = Z_ARRVAL_P(vars_array);
-  zend_string *key;
+  /* Validate: reject objects, resources, references */
   zval *val;
-  ZEND_HASH_FOREACH_STR_KEY_VAL(ht, key, val) {
-    if (key == NULL) {
-      zend_value_error("All keys must be strings");
-      RETURN_THROWS();
-    }
-    if (Z_TYPE_P(val) != IS_STRING) {
-      zend_value_error("All values must be strings");
+  ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(vars_array), val) {
+    if (!sidekick_validate_zval(val)) {
+      zend_value_error("Values must be scalars, strings, arrays, or null; "
+                       "objects and resources are not allowed");
       RETURN_THROWS();
     }
   }
   ZEND_HASH_FOREACH_END();
 
-  HashTable *persistent = pemalloc(sizeof(HashTable), 1);
-  zend_hash_init(persistent, zend_hash_num_elements(ht), NULL, NULL, 1);
-
-  ZEND_HASH_FOREACH_STR_KEY_VAL(ht, key, val) {
-    zend_string *pkey = zend_string_init(ZSTR_VAL(key), ZSTR_LEN(key), 1);
-    zend_string *pval_str =
-        zend_string_init(Z_STRVAL_P(val), Z_STRLEN_P(val), 1);
-    zval pval;
-    ZVAL_NEW_STR(&pval, pval_str);
-    zend_hash_add_new(persistent, pkey, &pval);
-    zend_string_release(pkey);
-  }
-  ZEND_HASH_FOREACH_END();
+  /* Deep-copy to persistent memory */
+  zval persistent;
+  sidekick_persist_zval(&persistent, vars_array);
 
   void *old = NULL;
-  char *error = go_frankenphp_sidekick_set_vars(thread_index, persistent, &old);
+  char *error =
+      go_frankenphp_sidekick_set_vars(thread_index, Z_ARRVAL(persistent), &old);
   if (error) {
-    zval *ev;
-    ZEND_HASH_FOREACH_VAL(persistent, ev) { zend_string_free(Z_STR_P(ev)); }
-    ZEND_HASH_FOREACH_END();
-    zend_hash_destroy(persistent);
-    pefree(persistent, 1);
+    sidekick_free_persistent_zval(&persistent);
     zend_throw_exception(spl_ce_RuntimeException, error, 0);
     free(error);
     RETURN_THROWS();
   }
 
   if (old != NULL) {
-    HashTable *old_ht = (HashTable *)old;
-    zval *v;
-    ZEND_HASH_FOREACH_VAL(old_ht, v) { zend_string_free(Z_STR_P(v)); }
-    ZEND_HASH_FOREACH_END();
-    zend_hash_destroy(old_ht);
-    pefree(old_ht, 1);
+    zval old_zval;
+    ZVAL_ARR(&old_zval, (HashTable *)old);
+    sidekick_free_persistent_zval(&old_zval);
   }
 }
 
@@ -772,16 +942,15 @@ PHP_FUNCTION(frankenphp_sidekick_get_vars) {
       RETURN_THROWS();
     }
 
-    array_init(return_value);
     if (vars_ptr) {
-      HashTable *persistent = (HashTable *)vars_ptr;
-      zend_string *key;
-      zval *val;
-      ZEND_HASH_FOREACH_STR_KEY_VAL(persistent, key, val) {
-        add_assoc_stringl(return_value, ZSTR_VAL(key), Z_STRVAL_P(val),
-                          Z_STRLEN_P(val));
+      zval src;
+      ZVAL_ARR(&src, (HashTable *)vars_ptr);
+      sidekick_request_copy_zval(return_value, &src);
+      if (EG(exception)) {
+        RETURN_THROWS();
       }
-      ZEND_HASH_FOREACH_END();
+    } else {
+      array_init(return_value);
     }
     return;
   }
@@ -847,16 +1016,16 @@ PHP_FUNCTION(frankenphp_sidekick_get_vars) {
   idx = 0;
   ZEND_HASH_FOREACH_VAL(ht, val) {
     zval sidekick_vars;
-    array_init(&sidekick_vars);
     if (vars_ptrs[idx]) {
-      HashTable *persistent = (HashTable *)vars_ptrs[idx];
-      zend_string *k;
-      zval *v;
-      ZEND_HASH_FOREACH_STR_KEY_VAL(persistent, k, v) {
-        add_assoc_stringl(&sidekick_vars, ZSTR_VAL(k), Z_STRVAL_P(v),
-                          Z_STRLEN_P(v));
+      zval src;
+      ZVAL_ARR(&src, (HashTable *)vars_ptrs[idx]);
+      sidekick_request_copy_zval(&sidekick_vars, &src);
+      if (EG(exception)) {
+        zval_ptr_dtor(&sidekick_vars);
+        break;
       }
-      ZEND_HASH_FOREACH_END();
+    } else {
+      array_init(&sidekick_vars);
     }
     add_assoc_zval(return_value, Z_STRVAL_P(val), &sidekick_vars);
     idx++;