/**

* PHP WebAssembly SAPI module.

*

* This file abstracts the entire PHP API with the minimal set

* of functions required to run PHP code from JavaScript.

*/

#include <main/php.h>

#include <main/SAPI.h>

#include <main/php_main.h>

#include <main/php_variables.h>

#include <main/php_ini.h>

#include <main/php_streams.h>

#include <zend_ini.h>

#include "ext/standard/php_standard.h"

#include <emscripten.h>

#include <stdlib.h>

#include <stdio.h>

#include <fcntl.h>

#include <unistd.h>

#include "zend_globals_macros.h"

#include "zend_exceptions.h"

#if PHP_MAJOR_VERSION >= 6 || (PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION >= 3)

#include "zend_closures.h"

#endif

#include "zend_hash.h"

#include "rfc1867.h"

#include "SAPI.h"

#include "proc_open.h"

// Created by Dockerfile:

#include "php_wasm_asyncify.h"

unsigned int wasm_sleep(unsigned int time)

{

emscripten_sleep(time * 1000); // emscripten_sleep takes time in milliseconds

return time;

}

/**

* Shims usleep(3) functionallity.

*/

EMSCRIPTEN_KEEPALIVE unsigned int __wrap_usleep(unsigned int time_microseconds)

{

// We don't have access to microsecond granularity in JavaScript so let's

// settle for milliseconds.

int time_milliseconds = time_microseconds / 1000;

emscripten_sleep(time_milliseconds);

return time_microseconds;

}

extern int *wasm_setsockopt(int sockfd, int level, int optname, intptr_t optval, size_t optlen, int dummy);

static int redirect_stream_to_file(FILE *stream, char *file_path);

static void restore_stream_handler(FILE *original_stream, int replacement_stream);

/**

* Shims popen(3) functionallity:

* https://man7.org/linux/man-pages/man3/popen.3.html

*

* Uses the same PHPWASM.spawnProcess callback as js_open_process,

* but waits for the process to exit and returns a path to a file

* with all the output bufferred.

*

* @TODO: get rid of this function and only rely on js_open_process

* instead.

*

* @param {int} command Command to execute

* @param {int} mode Mode to open the command in

* @param {int} exitCodePtr Pointer to the exit code

* @returns {int} File descriptor of the command output

*/

#ifdef PLAYGROUND_JSPI

EM_ASYNC_JS(char*, js_popen_to_file, (const char *command, const char *mode, uint8_t *exitCodePtr), {

const returnCallback = (resolver) => new Promise(resolver);

#else

EM_JS(char*, js_popen_to_file, (const char *command, const char *mode, uint8_t *exitCodePtr), {

const returnCallback = (resolver) => Asyncify.handleSleep(resolver);

#endif

// Parse args

if (!command)

return 1; // shell is available

const cmdstr = UTF8ToString(command);

if (!cmdstr.length)

return 0; // this is what glibc seems to do (shell works test?)

const modestr = UTF8ToString(mode);

if (!modestr.length)

return 0; // this is what glibc seems to do (shell works test?)

if (modestr === 'w')

{

console.error('popen($cmd, "w") is not implemented yet');

}

return returnCallback(async (wakeUp) => {

let cp;

try {

cp = PHPWASM.spawnProcess(cmdstr, []);

if (cp instanceof Promise) {

cp = await cp;

}

} catch (e) {

console.error(e);

if (e.code === 'SPAWN_UNSUPPORTED') {

return 1;

}

throw e;

}

const outByteArrays = [];

cp.stdout.on('data', function (data) {

outByteArrays.push(data);

});

const outputPath = '/tmp/popen_output';

cp.on('exit', function (exitCode) {

// Concat outByteArrays, an array of UInt8Arrays

// into a single Uint8Array.

const outBytes = new Uint8Array(

outByteArrays.reduce((acc, curr) => acc + curr.length, 0)

);

let offset = 0;

for (const byteArray of outByteArrays) {

outBytes.set(byteArray, offset);

offset += byteArray.length;

}

FS.writeFile(outputPath, outBytes);

HEAPU8[exitCodePtr] = exitCode;

wakeUp(allocateUTF8OnStack(outputPath)); // 2 is SIGINT

});

});

});

/**

* Shims poll(2) functionallity for asynchronous websockets:

* https://man7.org/linux/man-pages/man2/poll.2.html

*

* The semantics don't line up exactly with poll(2) but

* the intent does. This function is called in php_pollfd_for()

* to await a websocket-related event.

*

* @param {int} socketd The socket descriptor

* @param {int} events The events to wait for

* @param {int} timeout The timeout in milliseconds

* @returns {int} 1 if any event was triggered, 0 if the timeout expired

*/

#ifdef PLAYGROUND_JSPI

EM_ASYNC_JS(int, wasm_poll_socket, (php_socket_t socketd, int events, int timeout), {

const returnCallback = (resolver) => new Promise(resolver);

#else

EM_JS(int, wasm_poll_socket, (php_socket_t socketd, int events, int timeout), {

const returnCallback = (resolver) => Asyncify.handleSleep(resolver);

#endif

const POLLIN = 0x0001; /* There is data to read */

const POLLPRI = 0x0002; /* There is urgent data to read */

const POLLOUT = 0x0004; /* Writing now will not block */

const POLLERR = 0x0008; /* Error condition */

const POLLHUP = 0x0010; /* Hung up */

const POLLNVAL = 0x0020; /* Invalid request: fd not open */

return returnCallback((wakeUp) => {

const polls = [];

/**

* Special semantics for polling sockets.

*

* @TODO: Remove this code branch entirely and poll sockets using the second if/else

* branch below. The only reason this wasn't done yet is that the original PR

* was focusing on removing child process-related special casing and did not

* want to increase the risk of breaking other code, especially around listening

* network sockets.

*/

const stream = FS.getStream(socketd);

if (FS.isSocket(stream?.node.mode)) {

// This is, most likely, a websocket. Let's make sure.

const sock = getSocketFromFD(socketd);

if (!sock) {

wakeUp(0);

return;

}

const lookingFor = new Set();

if (events & POLLIN || events & POLLPRI) {

if (sock.server) {

for (const client of sock.pending) {

if ((client.recv_queue || []).length > 0) {

wakeUp(1);

return;

}

}

} else if ((sock.recv_queue || []).length > 0) {

wakeUp(1);

return;

}

}

const webSockets = PHPWASM.getAllWebSockets(sock);

if (!webSockets.length) {

wakeUp(0);

return;

}

for (const ws of webSockets) {

if (events & POLLIN || events & POLLPRI) {

polls.push(PHPWASM.awaitData(ws));

lookingFor.add('POLLIN');

}

if (events & POLLOUT) {

polls.push(PHPWASM.awaitConnection(ws));

lookingFor.add('POLLOUT');

}

// Notify the user the socket is now closed even if the only requested

// in or out events.

if (

events & POLLHUP ||

events & POLLIN ||

events & POLLOUT ||

events & POLLERR

) {

polls.push(PHPWASM.awaitClose(ws));

lookingFor.add('POLLHUP');

}

if (events & POLLERR || events & POLLNVAL) {

polls.push(PHPWASM.awaitError(ws));

lookingFor.add('POLLERR');

}

}

} else if (stream?.stream_ops?.poll) {

// Poll the stream for data.

// @TODO: Consider reusing the polling implementation in js_fd_read().

let interrupted = false;

async function poll() {

try {

// Inlined ___syscall_poll with added await support:

while (true) {

var mask = POLLNVAL;

mask = SYSCALLS.DEFAULT_POLLMASK;

if (FS.isClosed(stream)) {

return ERRNO_CODES.EBADF;

}

if (stream.stream_ops?.poll) {

mask = stream.stream_ops.poll(stream, -1);

}

mask &= events | POLLERR | POLLHUP;

if (mask) {

return mask;

}

if (interrupted) {

return ERRNO_CODES.ETIMEDOUT;

}

await new Promise(resolve => setTimeout(resolve, 10));

}

} catch (e) {

if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;

return -e.errno;

}

}

polls.push([

poll(),

() => {

interrupted = true;

}

]);

} else {

setTimeout(function () {

wakeUp(1);

}, timeout);

return;

}

if (polls.length === 0) {

console.warn(

'Unsupported poll event ' +

events +

', defaulting to setTimeout().'

);

setTimeout(function () {

wakeUp(0);

}, timeout);

return;

}

const promises = polls.map(([promise]) => promise);

const clearPolling = () => polls.forEach(([, clear]) => clear());

let awaken = false;

let timeoutId;

Promise.race(promises).then(function (results) {

if (!awaken) {

awaken = true;

wakeUp(1);

if (timeoutId) {

clearTimeout(timeoutId);

}

clearPolling();

}

});

if (timeout !== -1) {

timeoutId = setTimeout(function () {

if (!awaken) {

awaken = true;

wakeUp(0);

clearPolling();

}

}, timeout);

}

});

});

/**

* Shims read(2) functionallity.

* Enables reading from blocking pipes. By default, Emscripten

* will throw an EWOULDBLOCK error when trying to read from a

* blocking pipe. This function overrides that behavior and

* instead waits for the pipe to become readable.

*

* @see https://github.com/WordPress/wordpress-playground/issues/951

* @see https://github.com/emscripten-core/emscripten/issues/13214

*/

EM_JS(__wasi_errno_t, js_fd_read, (__wasi_fd_t fd, const __wasi_iovec_t *iov, size_t iovcnt, __wasi_size_t *pnum), {

#ifdef PLAYGROUND_JSPI

const returnCallback = (resolver) => new Promise(resolver);

#else

const returnCallback = (resolver) => Asyncify.handleSleep(resolver);

#endif

const pollAsync = arguments[4] === undefined ? true : !!arguments[4];

if (Asyncify?.State?.Normal === undefined || Asyncify?.state === Asyncify?.State?.Normal) {

var stream;

try

{

stream = SYSCALLS.getStreamFromFD(fd);

// How many bytes did we read?

HEAPU32[pnum >> 2] = doReadv(stream, iov, iovcnt);

return 0;

}

catch (e)

{

// Rethrow any unexpected non-filesystem errors.

if (typeof FS == "undefined" || !(e.name === "ErrnoError"))

{

throw e;

}

// Propagate all errors except ones indicating that the stream is waiting for

// more data.

if (e.errno !== ERRNO_CODES.EWOULDBLOCK && e.errno !== ERRNO_CODES.EAGAIN) {

return e.errno;

}

// If the stream is non-blocking, we can return immediately.

const nonBlocking = stream.flags & PHPWASM.O_NONBLOCK;

if (nonBlocking) {

return e.errno;

}

// Otherwise, fallthrough to polling.

}

}

// Allow the caller to disable polling.

// @TODO: Check if we should even poll here, or is it up to the caller to decide

// and call poll() on their own.

if (false === pollAsync) {

return ERRNO_CODES.EWOULDBLOCK;

}

// At this point we're certain we need to poll.

//

// You might wonder why we duplicate the code here instead of just reusing

// Asyncify.handleSleep(). The reason is performance. Most of the time,

// the read operation will work synchronously and won't require yielding

// back to JS. In these cases we don't want to pay the Asyncify overhead,

// save the stack, yield back to JS, restore the stack etc.

return returnCallback(async (wakeUp) => {

var retries = 0;

var interval = 50;

var timeout = 5000;

// We poll for data and give up after a timeout.

// We can't simply rely on PHP timeout here because we don't want

// to, say, block the entire PHPUnit test suite without any visible

// feedback.

var maxRetries = timeout / interval;

while(true) {

var returnCode;

var stream;

let num;

try {

stream = SYSCALLS.getStreamFromFD(fd);

num = doReadv(stream, iov, iovcnt);

returnCode = 0;

} catch (e) {

if (

typeof FS == 'undefined' ||

!(e.name === 'ErrnoError')

) {

console.error(e);

throw e;

}

returnCode = e.errno;

}

// read succeeded!

if (returnCode === 0) {

HEAPU32[pnum >> 2] = num;

return wakeUp(0);

}

if (

// Too many retries? That's an error, too!

++retries > maxRetries ||

// Stream closed? That's an error.

!stream || FS.isClosed(stream) ||

// Error different than EWOULDBLOCK – propagate it to the caller.

returnCode !== ERRNO_CODES.EWOULDBLOCK ||

// Broken pipe

('pipe' in stream.node && stream.node.pipe.refcnt < 2)

) {

HEAPU32[pnum >> 2] = num;

return wakeUp(returnCode);

}

// It's a blocking stream and we Blocking stream with no data available yet.

// Let's poll up to a timeout.

await new Promise(resolve => setTimeout(resolve, interval));

}

})

});

extern int __wasi_syscall_ret(__wasi_errno_t code);

extern void js_popen_set_pid_for_fd(int fd, int pid);

extern int js_popen_get_pid_for_fd(int fd);

extern void js_popen_clear_pid_for_fd(int fd);

/**

* Passes a message to the JavaScript module and writes the response

* data, if any, to the response_buffer pointer.

*

* @param message The message to pass into JavaScript.

* @param response_buffer The address where the response will be stored. The

* JS module will allocate a memory block for the response buffer and write

* its address to **response_buffer. The caller is responsible for freeing

* that memory after use.

*

* @return The size of the response_buffer (it can contain null bytes).

*

* @note The caller should ensure that the memory allocated for response_buffer

* is freed after its use to prevent memory leaks. It's also recommended

* to handle exceptions and errors gracefully within the function to ensure

* the stability of the system.

*/

EM_ASYNC_JS(size_t, js_module_onMessage, (const char *data, char **response_buffer), {

if (Module['onMessage']) {

const dataStr = UTF8ToString(data);

return Module['onMessage'](dataStr)

.then((response) => {

const responseBytes =

typeof response === 'string'

? new TextEncoder().encode(response)

: response;

// Copy the response bytes to heap

const responseSize = responseBytes.byteLength;

const responsePtr = _malloc(responseSize + 1);

HEAPU8.set(responseBytes, responsePtr);

HEAPU8[responsePtr + responseSize] = 0;

HEAPU8[response_buffer] = responsePtr;

HEAPU8[response_buffer + 1] = responsePtr >> 8;

HEAPU8[response_buffer + 2] = responsePtr >> 16;

HEAPU8[response_buffer + 3] = responsePtr >> 24;

return responseSize;

})

.catch((e) => {

// Log the error and return NULL. Message passing

// separates JS context from the PHP context so we

// don't let PHP crash here.

console.error(e);

return -1;

});

}

});

// popen() shim

// -----------------------------------------------------------

// We have a custom popen handler because the original one calls

// fork() which emscripten does not support.

//

// PHP_FUNCTION(popen) and other compiled C call sites reach this through

// the linker-level __wrap_popen wrapper below.

//

// The `js_popen_to_file` is defined in phpwasm-emscripten-library.js.

// It runs the `cmd` command and returns the path to a file that contains the

// output. The exit code is assigned to the exit_code_ptr.

EMSCRIPTEN_KEEPALIVE FILE *wasm_popen(const char *cmd, const char *mode)

{

FILE *fp;

if (*mode == 'r')

{

uint8_t last_exit_code;

char *file_path = js_popen_to_file(cmd, mode, &last_exit_code);

fp = fopen(file_path, mode);

FG(pclose_ret) = last_exit_code;

}

else if (*mode == 'w')

{

php_file_descriptor_t stdin_pipe[2];

php_file_descriptor_t stdout_pipe[2];

php_file_descriptor_t stderr_pipe[2];

if (0 != pipe(stdout_pipe) || 0 != pipe(stderr_pipe) || 0 != pipe(stdin_pipe))

{

php_error_docref(NULL, E_WARNING, "unable to create pipe %s", strerror(errno));

errno = EINVAL;

return 0;

}

fp = fdopen(stdin_pipe[1], "w");

if (!fp) {

php_error_docref(NULL, E_WARNING, "unable to create pipe %s", strerror(errno));

errno = EINVAL;

return 0;

}

int *stdin = safe_emalloc(sizeof(int), 3, 0);

int *stdout = safe_emalloc(sizeof(int), 3, 0);

int *stderr = safe_emalloc(sizeof(int), 3, 0);

stdin[0] = 0;

stdin[1] = stdin_pipe[0];

stdin[2] = stdin_pipe[1];

stdout[0] = 1;

stdout[1] = stdout_pipe[0];

stdout[2] = stdout_pipe[1];

stderr[0] = 2;

stderr[1] = stderr_pipe[0];

stderr[2] = stderr_pipe[1];

int **descv = safe_emalloc(sizeof(int *), 3, 0);

descv[0] = stdin;

descv[1] = stdout;

descv[2] = stderr;

int pid = js_open_process(

cmd,

NULL,

0,

descv,

3,

"",

0,

0,

0

);

js_popen_set_pid_for_fd(fileno(fp), pid);

efree(stdin);

efree(stdout);

efree(stderr);

efree(descv);

}

else

{

printf("wasm_popen: mode '%s' not supported (cmd: %s)! \n", mode, cmd);

errno = EINVAL;

return 0;

}

return fp;

}

/**

* Close a FILE* created by wasm_popen and wait for the spawned process

* to exit. Returns the process exit code, or -1 on error.

*/

extern int js_waitpid(int pid, int *exitcode);

EMSCRIPTEN_KEEPALIVE int wasm_pclose(FILE *fp)

{

int pid = js_popen_get_pid_for_fd(fileno(fp));

js_popen_clear_pid_for_fd(fileno(fp));

fclose(fp);

if (pid < 0) {

return -1;

}

int wstatus = 0;

js_waitpid(pid, &wstatus);

FG(pclose_ret) = wstatus;

return wstatus;

}

/**

* Linker-level wrappers so every compiled C call to popen()/pclose()

* is redirected here via -Wl,--wrap=popen/pclose.

*/

FILE *__wrap_popen(const char *cmd, const char *mode)

{

return wasm_popen(cmd, mode);

}

extern int __real_pclose(FILE *fp);

int __wrap_pclose(FILE *fp)

{

if (js_popen_get_pid_for_fd(fileno(fp)) >= 0) {

return wasm_pclose(fp);

}

return __real_pclose(fp);

}

/**

* Ship php_exec, the function powering the following PHP

* functions:

* * exec()

* * passthru()

* * system()

* * shell_exec()

*

* The wasm_php_exec function is called thanks

* to -Dphp_exec=wasm_php_exec in the Dockerfile and also a

* small patch that removes php_exec and marks wasm_php_exec()

* as external.

*

* {{{

*/

// These utility functions are copied from php-src/ext/standard/exec.c

static size_t strip_trailing_whitespace(char *buf, size_t bufl)

{

size_t l = bufl;

while (l-- > 0 && isspace(((unsigned char *)buf)[l]))

;

if (l != (bufl - 1))

{

bufl = l + 1;

buf[bufl] = '\0';

}

return bufl;

}

static size_t handle_line(int type, zval *array, char *buf, size_t bufl)

{

if (type == 1)

{

PHPWRITE(buf, bufl);

#if PHP_MAJOR_VERSION >= 6 || (PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION >= 4)

if (php_output_get_level() < 1)

{

sapi_flush();

}

#else

if (OG(ob_nesting_level) < 1)

{

sapi_flush();

}

#endif

}

else if (type == 2)

{

bufl = strip_trailing_whitespace(buf, bufl);

#if PHP_MAJOR_VERSION >= 7

add_next_index_stringl(array, buf, bufl);

#else

add_next_index_stringl(array, buf, bufl, 1);

#endif

}

return bufl;

}

/**

* Shims read(2) functionallity.

* Enables reading from blocking pipes. By default, Emscripten

* will throw an EWOULDBLOCK error when trying to read from a

* blocking pipe. This function overrides that behavior and

* instead waits for the pipe to become readable.

*

* @see https://github.com/WordPress/wordpress-playground/issues/951

* @see https://github.com/emscripten-core/emscripten/issues/13214

*/

EMSCRIPTEN_KEEPALIVE ssize_t wasm_read(int fd, void *buf, size_t count)

{

struct __wasi_iovec_t iov = {

.buf = buf,

.buf_len = count};

size_t num;

if (__wasi_syscall_ret(js_fd_read(fd, &iov, 1, &num)))

{

return -1;

}

return num;

}

/*

* If type==0, only last line of output is returned (exec)

* If type==1, all lines will be printed and last lined returned (system)

* If type==2, all lines will be saved to given array (exec with &$array)

* If type==3, output will be printed binary, no lines will be saved or returned (passthru)

*/

EMSCRIPTEN_KEEPALIVE int wasm_php_exec(int type, const char *cmd, zval *array, zval *return_value)

{

FILE *fp;

char *buf;

int pclose_return;

char *b, *d = NULL;

php_stream *stream;

size_t buflen, bufl = 0;

#if PHP_SIGCHILD

void (*sig_handler)() = NULL;

#endif

#if PHP_SIGCHILD

sig_handler = signal(SIGCHLD, SIG_DFL);

#endif

// Reuse the process-opening logic

fp = wasm_popen(cmd, "r");

if (!fp)

{

php_error_docref(NULL, E_WARNING, "Unable to fork [%s]", cmd);

goto err;

}

stream = php_stream_fopen_from_pipe(fp, "rb");

buf = (char *)emalloc(EXEC_INPUT_BUF);

buflen = EXEC_INPUT_BUF;

if (type != 3)

{

b = buf;

while (php_stream_get_line(stream, b, EXEC_INPUT_BUF, &bufl))

{

/* no new line found, let's read some more */

if (b[bufl - 1] != '\n' && !php_stream_eof(stream))

{

if (buflen < (bufl + (b - buf) + EXEC_INPUT_BUF))

{

bufl += b - buf;

buflen = bufl + EXEC_INPUT_BUF;

buf = erealloc(buf, buflen);

b = buf + bufl;

}

else

{

b += bufl;

}

continue;

}

else if (b != buf)

{

bufl += b - buf;

}

bufl = handle_line(type, array, buf, bufl);

b = buf;

}

if (bufl)

{

if (buf != b)

{

/* Process remaining output */

bufl = handle_line(type, array, buf, bufl);

}

/* Return last line from the shell command */

bufl = strip_trailing_whitespace(buf, bufl);

#if PHP_MAJOR_VERSION >= 7

RETVAL_STRINGL(buf, bufl);

#else

RETVAL_STRINGL(buf, bufl, 1);

#endif

}

else

{ /* should return NULL, but for BC we return "" */

RETVAL_EMPTY_STRING();

}

}

else

{

ssize_t read;

while ((read = php_stream_read(stream, buf, EXEC_INPUT_BUF)) > 0)

{

PHPWRITE(buf, read);

}

}

pclose_return = php_stream_close(stream);

if (pclose_return == -1)

{

pclose_return = FG(pclose_ret);

}

efree(buf);

done:

#if PHP_SIGCHILD

if (sig_handler)

{

signal(SIGCHLD, sig_handler);

}

#endif

if (d)

{

efree(d);

}

return pclose_return;

err:

pclose_return = -1;

RETVAL_FALSE;

goto done;

}

// }}}

// -----------------------------------------------------------

int wasm_socket_has_data(php_socket_t fd);

/* hybrid select(2)/poll(2) for a single descriptor.

* timeouttv follows same rules as select(2), but is reduced to millisecond accuracy.

* Returns 0 on timeout, -1 on error, or the event mask (ala poll(2)).

*/

EMSCRIPTEN_KEEPALIVE inline int php_pollfd_for(php_socket_t fd, int events, struct timeval *timeouttv)

{

php_pollfd p;

int n;

p.fd = fd;

p.events = events;

p.revents = 0;

// must yield back to JS event loop to get the network response:

wasm_poll_socket(fd, events, php_tvtoto(timeouttv));

n = php_poll2(&p, 1, php_tvtoto(timeouttv));

if (n > 0)

{

return p.revents;

}

return n;

}

ZEND_BEGIN_ARG_INFO(arginfo_dl, 0)

ZEND_ARG_INFO(0, extension_filename)

ZEND_END_ARG_INFO()

/**

* select(2).

*/

EMSCRIPTEN_KEEPALIVE int __wrap_select(int max_fd, fd_set *read_fds, fd_set *write_fds, fd_set *except_fds, struct timeval *timeouttv)

{

emscripten_sleep(0); // always yield to JS event loop

int timeoutms = php_tvtoto(timeouttv);

int n = 0;

for (int i = 0; i < max_fd; i++)

{

if (FD_ISSET(i, read_fds))

{

n += wasm_poll_socket(i, POLLIN | POLLOUT, timeoutms);

}

if (FD_ISSET(i, write_fds))

{

n += wasm_poll_socket(i, POLLOUT, timeoutms);

}

if (FD_ISSET(i, except_fds))

{

n += wasm_poll_socket(i, POLLERR, timeoutms);

FD_CLR(i, except_fds);

}

}

return n;

}

#if !defined(TSRMLS_DC)

#define TSRMLS_DC

#endif

#if !defined(TSRMLS_D)

#define TSRMLS_D

#endif

#if !defined(TSRMLS_CC)

#define TSRMLS_CC

#endif

#if !defined(TSRMLS_C)

#define TSRMLS_C

#endif

#if !defined(TSRMLS_FETCH)

#define TSRMLS_FETCH()

#endif

typedef struct wasm_array_entry

{

char *key;

char *value;

struct wasm_array_entry *next;

} wasm_array_entry_t;

typedef struct wasm_uploaded_file

{

char *key,

*name,

*type,

*tmp_name;

int error, size;

struct wasm_uploaded_file *next;

} wasm_uploaded_file_t;

typedef struct

{

char *document_root,

*query_string,

*path_translated,

*request_uri,

*request_method,

*request_host,

*content_type,

*request_body,

*cookies;

struct wasm_array_entry *server_array_entries;

struct wasm_array_entry *env_array_entries;

int content_length,

request_port,

skip_shebang;

} wasm_server_context_t;

static wasm_server_context_t *wasm_server_context;

int wasm_sapi_module_startup(sapi_module_struct *sapi_module);

int wasm_sapi_shutdown_wrapper(sapi_module_struct *sapi_globals);

void wasm_sapi_module_shutdown();

static int wasm_sapi_deactivate(TSRMLS_D);

#if PHP_MAJOR_VERSION >= 7

static size_t wasm_sapi_ub_write(const char *str, size_t str_length TSRMLS_DC);

static size_t wasm_sapi_read_post_body(char *buffer, size_t count_bytes);

#else

static int wasm_sapi_ub_write(const char *str, unsigned int str_length TSRMLS_DC);

static int wasm_sapi_read_post_body(char *buffer, unsigned int count_bytes);

#endif

#if PHP_MAJOR_VERSION >= 8

static void wasm_sapi_log_message(const char *message TSRMLS_DC, int syslog_type_int);

#else

#if (PHP_MAJOR_VERSION == 7 && PHP_MINOR_VERSION >= 1)

static void wasm_sapi_log_message(char *message TSRMLS_DC, int syslog_type_int);

#else

static void wasm_sapi_log_message(char *message TSRMLS_DC);

#endif

#endif

static void wasm_sapi_flush(void *server_context);

static int wasm_sapi_send_headers(sapi_headers_struct *sapi_headers TSRMLS_DC);

static void wasm_sapi_send_header(sapi_header_struct *sapi_header, void *server_context TSRMLS_DC);

static char *wasm_sapi_read_cookies(TSRMLS_D);

static void wasm_sapi_register_server_variables(zval *track_vars_array TSRMLS_DC);

void wasm_init_server_context();

static char *int_to_string(int i);

#if (PHP_MAJOR_VERSION >= 8)

static char *wasm_sapi_getenv(const char *name, size_t name_len)

#else

#if (PHP_MAJOR_VERSION == 7 && PHP_MINOR_VERSION >= 4)

static char *wasm_sapi_getenv(char *name, size_t name_len)

#else

static char *wasm_sapi_getenv(char *name, unsigned long name_len)

#endif

#endif

{

wasm_array_entry_t *current_entry = wasm_server_context->env_array_entries;

while (current_entry != NULL)

{

if (strncmp(current_entry->key, name, name_len) == 0)

{

return current_entry->value;

}

current_entry = current_entry->next;

}

return NULL;

}

SAPI_API sapi_module_struct php_wasm_sapi_module = {

"wasm", /* name */

#ifdef PLAYGROUND_JSPI

"PHP WASM SAPI (JSPI)", /* pretty name */

#else

"PHP WASM SAPI (Asyncify)", /* pretty name */

#endif

wasm_sapi_module_startup, /* startup */

wasm_sapi_shutdown_wrapper, /* shutdown */

NULL, /* activate */

wasm_sapi_deactivate, /* deactivate */