#include "frankenphp.h"

#include <SAPI.h>

#include <Zend/zend_alloc.h>

#include <Zend/zend_exceptions.h>

#include <Zend/zend_interfaces.h>

#include <Zend/zend_smart_str.h>

#include <errno.h>

#include <ext/spl/spl_exceptions.h>

#include <ext/standard/basic_functions.h>

#include <ext/standard/head.h>

#include <ext/standard/info.h>

#include <ext/standard/php_fopen_wrappers.h>

#ifdef HAVE_PHP_SESSION

#include <ext/session/php_session.h>

#include <inttypes.h>

#include <php.h>

#ifdef PHP_WIN32

#include <config.w32.h>

#include <php_config.h>

#include <php_ini.h>

#include <php_main.h>

#include <php_output.h>

#include <php_variables.h>

#include <php_version.h>

#include <pthread.h>

#include <sapi/embed/php_embed.h>

#include <signal.h>

#include <stdint.h>

#include <stdio.h>

#include <stdlib.h>

#ifndef PHP_WIN32

#include <unistd.h>

#if defined(__linux__)

#include <sys/prctl.h>

#elif defined(__FreeBSD__)

#include <pthread_np.h>

#include <sys/procctl.h>

#elif defined(__OpenBSD__)

#include <pthread_np.h>

#if defined(__APPLE__) || defined(__OpenBSD__) || defined(__NetBSD__) || \

defined(__DragonFly__)

#define FRANKENPHP_KQUEUE_PARENT_DEATH 1

#include <sys/event.h>

#include <sys/types.h>

#if PHP_VERSION_ID >= 80600

#include <sapi/cli/cli.h>

#include "emulate_php_cli.h"

#include "_cgo_export.h"

#include "frankenphp_arginfo.h"

#ifdef FRANKENPHP_TEST

#include "zval.h"

#if defined(PHP_WIN32) && defined(ZTS)

ZEND_TSRMLS_CACHE_DEFINE()

static const char *MODULES_TO_RELOAD[] = {

"filter",

#ifndef HAVE_PHP_SESSION

/* When the session extension is not visible at build time (e.g. it is

"session",

NULL};

frankenphp_version frankenphp_get_version() {

return (frankenphp_version){

PHP_MAJOR_VERSION, PHP_MINOR_VERSION, PHP_RELEASE_VERSION,

PHP_EXTRA_VERSION, PHP_VERSION, PHP_VERSION_ID,

};

}

frankenphp_config frankenphp_get_config() {

return (frankenphp_config){

#ifdef ZTS

true,

false,

#ifdef ZEND_SIGNALS

true,

false,

#ifdef ZEND_MAX_EXECUTION_TIMERS

true,

false,

};

}

bool should_filter_var = 0;

bool original_user_abort_setting = 0;

frankenphp_interned_strings_t frankenphp_strings = {0};

HashTable *main_thread_env = NULL;

#if defined(__ELF__) && defined(__GNUC__)

#define THREAD_LOCAL __thread __attribute__((tls_model("local-exec")))

#define THREAD_LOCAL __thread

static THREAD_LOCAL uintptr_t thread_index;

static THREAD_LOCAL bool is_worker_thread = false;

static THREAD_LOCAL HashTable *sandboxed_env = NULL;

static THREAD_LOCAL HashTable *prepared_env = NULL;

static THREAD_LOCAL HashTable *worker_env = NULL;

typedef struct {

uintptr_t thread_index;

} frankenphp_server_ctx;

static THREAD_LOCAL frankenphp_server_ctx frankenphp_local_server_ctx;

uintptr_t frankenphp_thread_index(void) {

frankenphp_server_ctx *ctx = (frankenphp_server_ctx *)SG(server_context);

/* Fall back to the OS thread's own TLS before

return ctx == NULL ? thread_index : ctx->thread_index;

}

#ifndef PHP_WIN32

static bool is_forked_child = false;

static pid_t fork_parent_pid = 0;

static void frankenphp_fork_prepare(void) { fork_parent_pid = getpid(); }

static void frankenphp_mark_fork_child(void) { is_forked_child = true; }

#if defined(FRANKENPHP_KQUEUE_PARENT_DEATH)

static void *frankenphp_parent_death_watcher(void *arg) {

pid_t ppid = (pid_t)(intptr_t)arg;

int kq = kqueue();

if (kq < 0) {

_exit(1);

}

struct kevent kev;

EV_SET(&kev, ppid, EVFILT_PROC, EV_ADD | EV_ONESHOT, NOTE_EXIT, 0, NULL);

if (kevent(kq, &kev, 1, NULL, 0, NULL) < 0) {

_exit(1);

}

struct kevent event;

while (kevent(kq, NULL, 0, &event, 1, NULL) < 0 && errno == EINTR)

;

_exit(1);

}

static void frankenphp_fork_child(void) {

// a fork of a fork (e.g. a daemonizer) must outlive its short-lived parent

if (is_forked_child) {

return;

}

frankenphp_mark_fork_child();

#if defined(__linux__)

// if the parent process dies between fork() and this prctl()

if (prctl(PR_SET_PDEATHSIG, SIGKILL, 0, 0, 0) != 0 ||

getppid() != fork_parent_pid) {

_exit(1);

}

#elif defined(__FreeBSD__)

/* FreeBSD analogue of PR_SET_PDEATHSIG - except with

int sig = SIGKILL;

if (procctl(P_PID, 0, PROC_PDEATHSIG_CTL, &sig) != 0 ||

getppid() != fork_parent_pid) {

_exit(1);

}

#elif defined(FRANKENPHP_KQUEUE_PARENT_DEATH)

/* No kernel parent-death signal available; spawn a watcher that

if (getppid() != fork_parent_pid) {

_exit(1);

}

pthread_t watcher;

if (pthread_create(&watcher, NULL, frankenphp_parent_death_watcher,

(void *)(intptr_t)fork_parent_pid) != 0) {

_exit(1);

}

pthread_detach(watcher);

}

static void frankenphp_register_atfork(void) {

pthread_atfork(frankenphp_fork_prepare, NULL, frankenphp_fork_child);

}

static void frankenphp_register_cli_atfork(void) {

pthread_atfork(NULL, NULL, frankenphp_mark_fork_child);

}

static void frankenphp_fill_cli_signal_set(sigset_t *s) {

sigemptyset(s);

#ifdef SIGUSR1

sigaddset(s, SIGUSR1);

#ifdef SIGUSR2

sigaddset(s, SIGUSR2);

#ifdef SIGALRM

sigaddset(s, SIGALRM);

}

__attribute__((constructor)) static void frankenphp_libpreinit(void) {

sigset_t set;

frankenphp_fill_cli_signal_set(&set);

/* Single-threaded at this point (constructors run before Go's runtime),

sigprocmask(SIG_BLOCK, &set, NULL);

}

#ifdef PHP_WIN32

static void CALLBACK frankenphp_noop_apc(ULONG_PTR param) { (void)param; }

#ifdef FRANKENPHP_HAS_KILL_SIGNAL

static void frankenphp_kill_signal_handler(int sig) { (void)sig; }

static pthread_once_t kill_signal_handler_installed = PTHREAD_ONCE_INIT;

static zend_atomic_bool kill_signal_handler_active;

static void install_kill_signal_handler(void) {

/* No SA_RESTART so syscalls return EINTR rather than being restarted.

struct sigaction sa;

memset(&sa, 0, sizeof(sa));

sa.sa_handler = frankenphp_kill_signal_handler;

sigemptyset(&sa.sa_mask);

sa.sa_flags = SA_ONSTACK;

if (sigaction(FRANKENPHP_KILL_SIGNAL, &sa, NULL) == 0) {

zend_atomic_bool_store(&kill_signal_handler_active, true);

}

}

static void frankenphp_register_thread_for_kill(uintptr_t idx) {

force_kill_slot slot;

memset(&slot, 0, sizeof(slot));

slot.vm_interrupt = &EG(vm_interrupt);

slot.timed_out = &EG(timed_out);

#ifdef FRANKENPHP_HAS_KILL_SIGNAL

slot.tid = pthread_self();

pthread_once(&kill_signal_handler_installed, install_kill_signal_handler);

#elif defined(PHP_WIN32)

if (!DuplicateHandle(GetCurrentProcess(), GetCurrentThread(),

GetCurrentProcess(), &slot.thread_handle, 0, FALSE,

DUPLICATE_SAME_ACCESS)) {

/* On failure, force_kill falls back to atomic-bool only. */

slot.thread_handle = NULL;

}

go_frankenphp_store_force_kill_slot(idx, slot);

}

void frankenphp_force_kill_thread(force_kill_slot slot) {

if (slot.vm_interrupt == NULL) {

/* Boot aborted before the slot was published. */

return;

}

/* Atomic stores first: by the time the thread wakes (signal-driven or

zend_atomic_bool_store(slot.timed_out, true);

zend_atomic_bool_store(slot.vm_interrupt, true);

#ifdef FRANKENPHP_HAS_KILL_SIGNAL

/* ESRCH (thread already exited) / EINVAL are both benign here.

if (zend_atomic_bool_load(&kill_signal_handler_active)) {

pthread_kill(slot.tid, FRANKENPHP_KILL_SIGNAL);

}

#elif defined(PHP_WIN32)

if (slot.thread_handle != NULL) {

CancelSynchronousIo(slot.thread_handle);

QueueUserAPC((PAPCFUNC)frankenphp_noop_apc, slot.thread_handle, 0);

}

}

void frankenphp_release_thread_for_kill(force_kill_slot slot) {

#ifdef PHP_WIN32

if (slot.thread_handle != NULL) {

CloseHandle(slot.thread_handle);

}

(void)slot;

}

void frankenphp_update_local_thread_context(bool is_worker) {

is_worker_thread = is_worker;

/* workers should keep running if the user aborts the connection */

PG(ignore_user_abort) = is_worker ? 1 : original_user_abort_setting;

}

static void frankenphp_update_request_context() {

/* the server context is stored on the go side, still SG(server_context) needs

frankenphp_local_server_ctx.thread_index = thread_index;

SG(server_context) = &frankenphp_local_server_ctx;

/* status It is not reset by zend engine, set it to 200. */

SG(sapi_headers).http_response_code = 200;

char *authorization_header =

go_update_request_info(thread_index, &SG(request_info));

/* let PHP handle basic auth */

php_handle_auth_data(authorization_header);

}

static void frankenphp_free_request_context() {

if (SG(request_info).cookie_data != NULL) {

free(SG(request_info).cookie_data);

SG(request_info).cookie_data = NULL;

}

/* freed via thread.Unpin() */

SG(request_info).request_method = NULL;

SG(request_info).query_string = NULL;

SG(request_info).content_type = NULL;

SG(request_info).path_translated = NULL;

SG(request_info).request_uri = NULL;

}

static void frankenphp_reset_super_globals() {

zend_try {

/* only $_FILES needs to be flushed explicitly

zval *files = &PG(http_globals)[TRACK_VARS_FILES];

zval_ptr_dtor_nogc(files);

memset(files, 0, sizeof(*files));

/* $_SESSION must be explicitly deleted from the symbol table.

zend_hash_str_del(&EG(symbol_table), "_SESSION", sizeof("_SESSION") - 1);

}

zend_end_try();

zend_auto_global *auto_global;

zend_string *_env = ZSTR_KNOWN(ZEND_STR_AUTOGLOBAL_ENV);

zend_string *_server = ZSTR_KNOWN(ZEND_STR_AUTOGLOBAL_SERVER);

ZEND_HASH_MAP_FOREACH_PTR(CG(auto_globals), auto_global) {

if (auto_global->name == _env) {

/* skip $_ENV */

} else if (auto_global->name == _server) {

/* always reimport $_SERVER */

auto_global->armed = auto_global->auto_global_callback(auto_global->name);

} else if (auto_global->jit) {

/* JIT globals ($_REQUEST, $GLOBALS) need special handling:

if (auto_global->name == ZSTR_KNOWN(ZEND_STR_AUTOGLOBAL_REQUEST) &&

zend_hash_exists(&EG(symbol_table), auto_global->name)) {

auto_global->armed =

auto_global->auto_global_callback(auto_global->name);

}

} else if (auto_global->auto_global_callback) {

/* $_GET, $_POST, $_COOKIE, $_FILES are reimported here */

auto_global->armed = auto_global->auto_global_callback(auto_global->name);

} else {

/* $_SESSION will land here (not an http_global) */

auto_global->armed = 0;

}

}

ZEND_HASH_FOREACH_END();

}

typedef struct {

php_stream *body;

zend_off_t position;

} frankenphp_stream_input;

static void frankenphp_release_request_body(php_stream *request_body) {

zend_resource *body_res = NULL;

zend_resource *res;

ZEND_HASH_FOREACH_PTR(&EG(regular_list), res) {

if (res->type != php_file_le_stream()) {

continue;

}

php_stream *stream = (php_stream *)res->ptr;

if (stream == request_body) {

body_res = res;

} else if (stream->wrapper == &php_stream_php_wrapper &&

strcmp(stream->ops->label, "Input") == 0 &&

((frankenphp_stream_input *)stream->abstract)->body ==

request_body) {

return;

}

}

ZEND_HASH_FOREACH_END();

if (body_res != NULL) {

zend_list_delete(body_res);

}

}

#ifdef HAVE_PHP_SESSION

static void frankenphp_reset_session_state(void) {

if (PS(session_status) == php_session_active) {

php_session_flush(1);

}

if (!Z_ISUNDEF(PS(http_session_vars))) {

zval_ptr_dtor(&PS(http_session_vars));

ZVAL_UNDEF(&PS(http_session_vars));

}

if (PS(mod_data) || PS(mod_user_implemented)) {

zend_try { PS(mod)->s_close(&PS(mod_data)); }

zend_end_try();

}

if (PS(id)) {

zend_string_release_ex(PS(id), 0);

PS(id) = NULL;

}

if (PS(session_vars)) {

zend_string_release_ex(PS(session_vars), 0);

PS(session_vars) = NULL;

}

/* PS(mod_user_class_name) and PS(mod_user_names) are preserved */

#if PHP_VERSION_ID >= 80300

if (PS(session_started_filename)) {

zend_string_release(PS(session_started_filename));

PS(session_started_filename) = NULL;

PS(session_started_lineno) = 0;

}

PS(session_status) = php_session_none;

PS(in_save_handler) = 0;

PS(set_handler) = 0;

PS(mod_data) = NULL;

PS(mod_user_is_open) = 0;

PS(define_sid) = 1;

}

static void frankenphp_reset_last_errors(void) {

if (PG(last_error_message)) {

zend_string_release(PG(last_error_message));

PG(last_error_message) = NULL;

}

if (PG(last_error_file)) {

zend_string_release(PG(last_error_file));

PG(last_error_file) = NULL;

}

PG(last_error_type) = 0;

PG(last_error_lineno) = 0;

#if PHP_VERSION_ID >= 80400

/* http_get_last_response_headers() */

zval_ptr_dtor(&BG(last_http_headers));

ZVAL_UNDEF(&BG(last_http_headers));

/* Called by name to avoid depending on libxml2 headers */

zend_function *libxml_clear_errors = zend_hash_str_find_ptr(

CG(function_table), ZEND_STRL("libxml_clear_errors"));

if (libxml_clear_errors) {

zend_call_known_function(libxml_clear_errors, NULL, NULL, NULL, 0, NULL,

NULL);

}

}

static void frankenphp_reset_url_scanner(url_adapt_state_ex_t *ctx) {

smart_str_free(&ctx->result);

smart_str_free(&ctx->buf);

smart_str_free(&ctx->tag);

smart_str_free(&ctx->arg);

smart_str_free(&ctx->attr_val);

smart_str_free(&ctx->form_app);

smart_str_free(&ctx->url_app);

ctx->active = 0;

ctx->tag_type = 0;

ctx->attr_type = 0;

}

static void frankenphp_reset_basic_state(void) {

if (BG(strtok_string)) {

zend_string_release(BG(strtok_string));

BG(strtok_string) = NULL;

}

/* output_add_rewrite_var() and session.use_trans_sid */

frankenphp_reset_url_scanner(&BG(url_adapt_session_ex));

frankenphp_reset_url_scanner(&BG(url_adapt_output_ex));

}

static frankenphp_thread_metrics *thread_metrics = NULL;

static void frankenphp_worker_request_shutdown() {

__atomic_store_n(&thread_metrics[thread_index].last_memory_usage,

zend_memory_usage(0), __ATOMIC_RELAXED);

/* Flush all output buffers */

zend_try { php_output_end_all(); }

zend_end_try();

const char **module_name;

zend_module_entry *module;

for (module_name = MODULES_TO_RELOAD; *module_name; module_name++) {

if ((module = zend_hash_str_find_ptr(&module_registry, *module_name,

strlen(*module_name)))) {

module->request_shutdown_func(module->type, module->module_number);

}

}

#ifdef HAVE_PHP_SESSION

frankenphp_reset_session_state();

frankenphp_reset_last_errors();

/* Shutdown output layer (send the set HTTP headers, cleanup output handlers,

zend_try { php_output_deactivate(); }

zend_end_try();

frankenphp_reset_basic_state();

/* sapi_deactivate() drops the request body stream without closing it, it

php_stream *request_body = SG(request_info).request_body;

/* SAPI related shutdown (free stuff) */

zend_try { sapi_deactivate(); }

zend_end_try();

/* sapi_deactivate() frees these without clearing them (fixed in PHP 8.6),

SG(request_info).content_type_dup = NULL;

SG(request_info).current_user = NULL;

SG(request_info).current_user_length = 0;

if (request_body != NULL) {

frankenphp_release_request_body(request_body);

}

frankenphp_free_request_context();

if (prepared_env != NULL) {

zend_hash_release(prepared_env);

prepared_env = NULL;

}

zend_set_memory_limit(PG(memory_limit));

}

bool frankenphp_shutdown_dummy_request(void) {

if (SG(server_context) == NULL) {

return false;

}

worker_env = prepared_env;

prepared_env = NULL;

frankenphp_worker_request_shutdown();

return true;

}

static void frankenphp_copy_prepared_env(HashTable *ht) {

if (worker_env != NULL) {

zend_hash_copy(ht, worker_env, (copy_ctor_func_t)zval_add_ref);

}

if (prepared_env != NULL) {

zend_hash_copy(ht, prepared_env, (copy_ctor_func_t)zval_add_ref);

}

}

void get_full_env(zval *track_vars_array) {

HashTable *ht = Z_ARR_P(track_vars_array);

zend_hash_extend(ht, zend_hash_num_elements(main_thread_env), 0);

zend_hash_copy(ht, main_thread_env, NULL);

/* $_ENV outlives worker requests, it must not capture the env of the

HashTable *env = worker_env != NULL ? worker_env : prepared_env;

if (env != NULL) {

zend_hash_copy(ht, env, (copy_ctor_func_t)zval_add_ref);

}

}

static int frankenphp_worker_request_startup() {

int retval = SUCCESS;

frankenphp_update_request_context();

zend_try {

php_output_activate();

/* initialize global variables */

PG(header_is_being_sent) = 0;

PG(connection_status) = PHP_CONNECTION_NORMAL;

/* Keep the current execution context */

sapi_activate();

#ifdef ZEND_MAX_EXECUTION_TIMERS

if (PG(max_input_time) == -1) {

zend_set_timeout(EG(timeout_seconds), 1);

} else {

zend_set_timeout(PG(max_input_time), 1);

}

if (PG(expose_php)) {

sapi_add_header(SAPI_PHP_VERSION_HEADER,

sizeof(SAPI_PHP_VERSION_HEADER) - 1, 1);

}

/* PG(output_handler) is a char* before PHP 8.6, a zend_string* since */

#if PHP_VERSION_ID < 80600

if (PG(output_handler) && PG(output_handler)[0]) {

zval oh;

ZVAL_STRING(&oh, PG(output_handler));

if (PG(output_handler) && ZSTR_LEN(PG(output_handler))) {

zval oh;

ZVAL_STR(&oh, zend_string_dup(PG(output_handler), false));

php_output_start_user(&oh, 0, PHP_OUTPUT_HANDLER_STDFLAGS);

zval_ptr_dtor(&oh);

} else if (PG(output_buffering)) {

php_output_start_user(NULL,

PG(output_buffering) > 1 ? PG(output_buffering) : 0,

PHP_OUTPUT_HANDLER_STDFLAGS);

} else if (PG(implicit_flush)) {

php_output_set_implicit_flush(1);

}

frankenphp_reset_super_globals();

const char **module_name;

zend_module_entry *module;

for (module_name = MODULES_TO_RELOAD; *module_name; module_name++) {

if ((module = zend_hash_str_find_ptr(&module_registry, *module_name,

strlen(*module_name))) &&

module->request_startup_func) {

module->request_startup_func(module->type, module->module_number);

}

}

}

zend_catch { retval = FAILURE; }

zend_end_try();

SG(sapi_started) = 1;

return retval;

}

PHP_FUNCTION(frankenphp_finish_request) { /* {{{ */

ZEND_PARSE_PARAMETERS_NONE();

uintptr_t idx = frankenphp_thread_index();

if (go_is_context_done(idx)) {

RETURN_FALSE;

}

php_output_end_all();

php_header();

go_frankenphp_finish_php_request(idx);

RETURN_TRUE;

} /* }}} */

PHP_FUNCTION(frankenphp_putenv) {

char *setting;

size_t setting_len;

ZEND_PARSE_PARAMETERS_START(1, 1)

Z_PARAM_STRING(setting, setting_len)

ZEND_PARSE_PARAMETERS_END();

if (setting_len == 0 || setting[0] == '=') {

zend_argument_value_error(1, "must have a valid syntax");

RETURN_THROWS();

}

if (sandboxed_env == NULL) {

sandboxed_env = zend_new_array(0);

}

/* cut at null byte to stay consistent with regular putenv */

char *null_pos = memchr(setting, '\0', setting_len);

if (null_pos != NULL) {

setting_len = null_pos - setting;

}

/* cut the string at the first '=' */

char *eq_pos = memchr(setting, '=', setting_len);

/* no '=' found, delete the variable */

if (eq_pos == NULL) {

zval unset;

ZVAL_NULL(&unset);

zend_hash_str_update(sandboxed_env, setting, setting_len, &unset);

RETURN_TRUE;

}

size_t name_len = eq_pos - setting;

size_t value_len =

(setting_len > name_len + 1) ? (setting_len - name_len - 1) : 0;

zval val = {0};

ZVAL_STRINGL(&val, eq_pos + 1, value_len);

zend_hash_str_update(sandboxed_env, setting, name_len, &val);

RETURN_TRUE;

} /* }}} */

static inline zval *frankenphp_lookup_env(const char *name, size_t name_len) {

HashTable *layers[] = {sandboxed_env, prepared_env, worker_env,

main_thread_env};

for (size_t i = 0; i < sizeof(layers) / sizeof(layers[0]); i++) {

if (layers[i] != NULL) {

zval *env_val = zend_hash_str_find(layers[i], name, name_len);

if (env_val != NULL) {

return env_val;

}

}

}

return NULL;

}

static inline HashTable *frankenphp_dup_env(void) {

HashTable *env = zend_array_dup(main_thread_env);

frankenphp_copy_prepared_env(env);

if (sandboxed_env != NULL) {

zend_string *key;

zval *val;

ZEND_HASH_FOREACH_STR_KEY_VAL(sandboxed_env, key, val) {

if (Z_TYPE_P(val) == IS_NULL) {

zend_hash_del(env, key);

} else {

Z_TRY_ADDREF_P(val);

zend_hash_update(env, key, val);

}

}

ZEND_HASH_FOREACH_END();

}

return env;

}

PHP_FUNCTION(frankenphp_getenv) {

zend_string *name = NULL;

bool local_only = 0;

ZEND_PARSE_PARAMETERS_START(0, 2)

Z_PARAM_OPTIONAL

Z_PARAM_STR_OR_NULL(name)

Z_PARAM_BOOL(local_only)

ZEND_PARSE_PARAMETERS_END();

if (!name) {

RETURN_ARR(frankenphp_dup_env());

return;

}

zval *env_val = frankenphp_lookup_env(ZSTR_VAL(name), ZSTR_LEN(name));

if (env_val && Z_TYPE_P(env_val) == IS_STRING) {

zend_string *str = Z_STR_P(env_val);

zend_string_addref(str);

RETVAL_STR(str);

} else {

RETVAL_FALSE;

}

} /* }}} */

PHP_FUNCTION(frankenphp_request_headers) {

ZEND_PARSE_PARAMETERS_NONE();

struct go_apache_request_headers_return headers =

go_apache_request_headers(frankenphp_thread_index());

array_init_size(return_value, headers.r1);

for (size_t i = 0; i < headers.r1; i++) {

go_string key = headers.r0[i * 2];

go_string val = headers.r0[(i * 2) + 1];

add_assoc_stringl_ex(return_value, key.data, key.len, val.data, val.len);

}

}

static void add_response_header(sapi_header_struct *h,

zval *return_value) /* {{{ */

{

if (h->header_len > 0) {

char *s;

size_t len = 0;

ALLOCA_FLAG(use_heap)

char *p = strchr(h->header, ':');

if (NULL != p) {

len = p - h->header;

}

if (len > 0) {

while (len != 0 &&

(h->header[len - 1] == ' ' || h->header[len - 1] == '\t')) {

len--;

}

if (len) {

s = do_alloca(len + 1, use_heap);

memcpy(s, h->header, len);

s[len] = 0;

do {

p++;

} while (*p == ' ' || *p == '\t');

add_assoc_stringl_ex(return_value, s, len, p,

h->header_len - (p - h->header));

free_alloca(s, use_heap);

}

}

}

}

PHP_FUNCTION(frankenphp_response_headers) /* {{{ */

{

ZEND_PARSE_PARAMETERS_NONE();

array_init(return_value);

zend_llist_apply_with_argument(

&SG(sapi_headers).headers,

(llist_apply_with_arg_func_t)add_response_header, return_value);

}

PHP_FUNCTION(frankenphp_handle_request) {

zend_fcall_info fci;

zend_fcall_info_cache fcc;

ZEND_PARSE_PARAMETERS_START(1, 1)

Z_PARAM_FUNC(fci, fcc)

ZEND_PARSE_PARAMETERS_END();

if (!is_worker_thread) {

/* not a worker, throw an error */

zend_throw_exception(

spl_ce_RuntimeException,

"frankenphp_handle_request() called while not in worker mode", 0);

RETURN_THROWS();

}

#ifdef ZEND_MAX_EXECUTION_TIMERS

/* Disable timeouts while waiting for a request to handle */

zend_unset_timeout();

struct go_frankenphp_worker_handle_request_start_return result =

go_frankenphp_worker_handle_request_start(thread_index);

/* Startup also runs when shutting down, to keep sapi_activate() and

if (frankenphp_worker_request_startup() == FAILURE) {

/* The engine can't run userland code after a caught bailout, end the

zend_bailout();

}

if (!result.r0) {

/* Shutting down */

RETURN_FALSE;

}

#ifdef ZEND_MAX_EXECUTION_TIMERS

/*

if (PG(max_input_time) != -1) {

#if PHP_VERSION_ID < 80600

zend_set_timeout(INI_INT("max_execution_time"), 0);

zend_set_timeout(zend_ini_long_literal("max_execution_time"), 0);

}