/*

+----------------------------------------------------------------------+

| Copyright © The PHP Group and Contributors. |

+----------------------------------------------------------------------+

| This source file is subject to the Modified BSD License that is |

| bundled with this package in the file LICENSE, and is available |

| through the World Wide Web at <https://www.php.net/license/>. |

| |

| SPDX-License-Identifier: BSD-3-Clause |

+----------------------------------------------------------------------+

| Author: Moriyoshi Koizumi <moriyoshi@php.net> |

| Xinchen Hui <laruence@php.net> |

+----------------------------------------------------------------------+

*/

#include <stdio.h>

#include <stdlib.h>

#include <fcntl.h>

#include <assert.h>

#include <signal.h>

#ifdef PHP_WIN32

# include <process.h>

# include <io.h>

# include "win32/console.h"

# include "win32/time.h"

# include "win32/signal.h"

# include "win32/php_registry.h"

# include <sys/timeb.h>

#else

# include <php_config.h>

#endif

#ifdef __riscos__

#include <unixlib/local.h>

#endif

#ifdef HAVE_SYS_TIME_H

#include <sys/time.h>

#endif

#ifdef HAVE_UNISTD_H

#include <unistd.h>

#endif

#include <locale.h>

#ifdef HAVE_DLFCN_H

#include <dlfcn.h>

#endif

#ifdef HAVE_PRCTL

# include <sys/prctl.h>

#endif

#ifdef HAVE_PROCCTL

# include <sys/procctl.h>

#endif

#include "SAPI.h"

#include "php.h"

#include "php_ini.h"

#include "php_main.h"

#include "php_globals.h"

#include "php_variables.h"

#include "zend_hash.h"

#include "zend_modules.h"

#include "fopen_wrappers.h"

#include "http_status_codes.h"

#include "zend_compile.h"

#include "zend_execute.h"

#include "zend_highlight.h"

#include "zend_exceptions.h"

#include "php_getopt.h"

#ifndef PHP_WIN32

# define php_select(m, r, w, e, t) select(m, r, w, e, t)

# define SOCK_EINVAL EINVAL

# define SOCK_EAGAIN EAGAIN

# define SOCK_EINTR EINTR

# define SOCK_EADDRINUSE EADDRINUSE

#else

# include "win32/select.h"

# define SOCK_EINVAL WSAEINVAL

# define SOCK_EAGAIN WSAEWOULDBLOCK

# define SOCK_EINTR WSAEINTR

# define SOCK_EADDRINUSE WSAEADDRINUSE

#endif

#include "ext/standard/file.h" /* for php_set_sock_blocking() :-( */

#include "zend_smart_str.h"

#include "ext/standard/html.h"

#include "ext/standard/url.h" /* for php_raw_url_decode() */

#include "ext/date/php_date.h" /* for php_format_date() */

#include "php_network.h"

#include "php_http_parser.h"

#include "php_cli_server.h"

#include "php_cli_server_arginfo.h"

#include "mime_type_map.h"

#include "php_cli_process_title.h"

#include "php_cli_process_title_arginfo.h"

#define OUTPUT_NOT_CHECKED -1

#define OUTPUT_IS_TTY 1

#define OUTPUT_NOT_TTY 0

#ifdef HAVE_FORK

# include <sys/wait.h>

static pid_t php_cli_server_master;

static pid_t *php_cli_server_workers;

static zend_long php_cli_server_workers_max;

#endif

static zend_string* cli_concat_persistent_zstr_with_char(zend_string *old_str, const char *at, size_t length);

typedef struct php_cli_server_poller {

fd_set rfds, wfds;

struct {

fd_set rfds, wfds;

} active;

php_socket_t max_fd;

} php_cli_server_poller;

typedef struct php_cli_server_request {

enum php_http_method request_method;

int protocol_version;

zend_string *request_uri;

char *vpath;

size_t vpath_len;

char *path_translated;

size_t path_translated_len;

char *path_info;

size_t path_info_len;

char *query_string;

size_t query_string_len;

HashTable headers;

HashTable headers_original_case;

char *content;

size_t content_len;

const char *ext;

size_t ext_len;

zend_stat_t sb;

} php_cli_server_request;

typedef struct php_cli_server_chunk {

struct php_cli_server_chunk *next;

enum php_cli_server_chunk_type {

PHP_CLI_SERVER_CHUNK_HEAP,

PHP_CLI_SERVER_CHUNK_IMMORTAL

} type;

union {

struct { void *block; char *p; size_t len; } heap;

struct { const char *p; size_t len; } immortal;

} data;

} php_cli_server_chunk;

typedef struct php_cli_server_buffer {

php_cli_server_chunk *first;

php_cli_server_chunk *last;

} php_cli_server_buffer;

typedef struct php_cli_server_content_sender {

php_cli_server_buffer buffer;

} php_cli_server_content_sender;

typedef struct php_cli_server_client {

struct php_cli_server *server;

php_socket_t sock;

struct sockaddr *addr;

socklen_t addr_len;

zend_string *addr_str;

php_http_parser parser;

bool request_read;

bool too_large_post;

zend_string *current_header_name;

zend_string *current_header_value;

enum { HEADER_NONE=0, HEADER_FIELD, HEADER_VALUE } last_header_element;

size_t post_read_offset;

php_cli_server_request request;

bool content_sender_initialized;

php_cli_server_content_sender content_sender;

int file_fd;

} php_cli_server_client;

typedef struct php_cli_server {

php_socket_t server_sock;

php_cli_server_poller poller;

int is_running;

char *host;

int port;

int address_family;

char *document_root;

size_t document_root_len;

char *router;

size_t router_len;

socklen_t socklen;

HashTable clients;

HashTable extension_mime_types;

} php_cli_server;

typedef struct php_cli_server_http_response_status_code_pair {

int code;

const char *str;

} php_cli_server_http_response_status_code_pair;

static const php_cli_server_http_response_status_code_pair template_map[] = {

{ 400, "<h1>%s</h1><p>Your browser sent a request that this server could not understand.</p>" },

{ 404, "<h1>%s</h1><p>The requested resource <code class=\"url\">%s</code> was not found on this server.</p>" },

{ 405, "<h1>%s</h1><p>Requested method not allowed.</p>" },

{ 413, "<h1>%s</h1><p>The request body exceeds the configured <code>post_max_size</code> of " ZEND_LONG_FMT " bytes.</p>" },

{ 500, "<h1>%s</h1><p>The server is temporarily unavailable.</p>" },

{ 501, "<h1>%s</h1><p>Request method not supported.</p>" }

};

#define PHP_CLI_SERVER_LOG_PROCESS 1

#define PHP_CLI_SERVER_LOG_ERROR 2

#define PHP_CLI_SERVER_LOG_MESSAGE 3

static int php_cli_server_log_level = 3;

#if defined(HAVE_UNISTD_H) || defined(PHP_WIN32)

static int php_cli_output_is_tty = OUTPUT_NOT_CHECKED;

#endif

static const char php_cli_server_request_error_unexpected_eof[] = "Unexpected EOF";

static size_t php_cli_server_client_send_through(php_cli_server_client *client, const char *str, size_t str_len);

static php_cli_server_chunk *php_cli_server_chunk_heap_new_self_contained(size_t len);

static void php_cli_server_buffer_append(php_cli_server_buffer *buffer, php_cli_server_chunk *chunk);

static void php_cli_server_logf(int type, const char *format, ...);

static void php_cli_server_log_response(php_cli_server_client *client, int status, const char *message);

ZEND_DECLARE_MODULE_GLOBALS(cli_server)

/* {{{ static char php_cli_server_css[]

* copied from ext/standard/info.c

*/

static const char php_cli_server_css[] = "<style>\n" \

"body { background-color: #fcfcfc; color: #333333; margin: 0; padding:0; }\n" \

"h1 { font-size: 1.5em; font-weight: normal; background-color: #9999cc; min-height:2em; line-height:2em; border-bottom: 1px inset black; margin: 0; }\n" \

"h1, p { padding-left: 10px; }\n" \

"code.url { background-color: #eeeeee; font-family:monospace; padding:0 2px;}\n" \

"</style>\n";

/* }}} */

#ifdef PHP_WIN32

static bool php_cli_server_get_system_time(char *buf) {

struct _timeb system_time;

errno_t err;

if (buf == NULL) {

return false;

}

_ftime(&system_time);

err = ctime_s(buf, 52, &(system_time.time) );

if (err) {

return false;

}

return true;

}

#else

static bool php_cli_server_get_system_time(char *buf) {

struct timeval tv;

struct tm tm;

gettimeofday(&tv, NULL);

if (!php_localtime_r(&tv.tv_sec, &tm)) {

return false;

}

return php_asctime_r(&tm, buf) != NULL;

}

#endif

/* Destructor for php_cli_server_request->headers, this frees header value */

static void cli_header_value_dtor(zval *zv) /* {{{ */

{

zend_string_release_ex(Z_STR_P(zv), /* persistent */ true);

} /* }}} */

static char *get_last_error(void) /* {{{ */

{

return pestrdup(strerror(errno), 1);

} /* }}} */

static int status_comp(const void *a, const void *b) /* {{{ */

{

const http_response_status_code_pair *pa = (const http_response_status_code_pair *) a;

const http_response_status_code_pair *pb = (const http_response_status_code_pair *) b;

if (pa->code < pb->code) {

return -1;

} else if (pa->code > pb->code) {

return 1;

}

return 0;

} /* }}} */

static const char *get_status_string(int code) /* {{{ */

{

const http_response_status_code_pair needle = {code, NULL},

*result = NULL;

result = bsearch(&needle, http_status_map, http_status_map_len, sizeof(needle), status_comp);

if (result) {

return result->str;

}

/* Returning NULL would require complicating append_http_status_line() to

* not segfault in that case, so let's just return a placeholder, since RFC

* 2616 requires a reason phrase. This is basically what a lot of other Web

* servers do in this case anyway. */

return "Unknown Status Code";

} /* }}} */

static const char *get_template_string(int code) /* {{{ */

{

size_t e = (sizeof(template_map) / sizeof(php_cli_server_http_response_status_code_pair));

size_t s = 0;

while (e != s) {

size_t c = MIN((e + s + 1) / 2, e - 1);

int d = template_map[c].code;

if (d > code) {

e = c;

} else if (d < code) {

s = c;

} else {

return template_map[c].str;

}

}

return NULL;

} /* }}} */

static void append_http_status_line(smart_str *buffer, int protocol_version, int response_code, bool persistent) /* {{{ */

{

if (!response_code) {

response_code = 200;

}

smart_str_appendl_ex(buffer, "HTTP", 4, persistent);

smart_str_appendc_ex(buffer, '/', persistent);

smart_str_append_long_ex(buffer, protocol_version / 100, persistent);

smart_str_appendc_ex(buffer, '.', persistent);

smart_str_append_long_ex(buffer, protocol_version % 100, persistent);

smart_str_appendc_ex(buffer, ' ', persistent);

smart_str_append_long_ex(buffer, response_code, persistent);

smart_str_appendc_ex(buffer, ' ', persistent);

smart_str_appends_ex(buffer, get_status_string(response_code), persistent);

smart_str_appendl_ex(buffer, "\r\n", 2, persistent);

} /* }}} */

static void append_essential_headers(smart_str* buffer, php_cli_server_client *client, bool persistent, sapi_headers_struct *sapi_headers) /* {{{ */

{

zval *val;

struct timeval tv = {0};

bool append_date_header = true;

if (sapi_headers != NULL) {

zend_llist_position pos;

sapi_header_struct *h = (sapi_header_struct*)zend_llist_get_first_ex(&sapi_headers->headers, &pos);

while (h) {

if (h->header_len > strlen("Date:")) {

if (strncasecmp(h->header, "Date:", strlen("Date:")) == 0) {

append_date_header = false;

break;

}

}

h = (sapi_header_struct*)zend_llist_get_next_ex(&sapi_headers->headers, &pos);

}

}

if (NULL != (val = zend_hash_find(&client->request.headers, ZSTR_KNOWN(ZEND_STR_HOST)))) {

smart_str_appends_ex(buffer, "Host: ", persistent);

smart_str_append_ex(buffer, Z_STR_P(val), persistent);

smart_str_appends_ex(buffer, "\r\n", persistent);

}

if (append_date_header && !gettimeofday(&tv, NULL)) {

zend_string *dt = php_format_date("D, d M Y H:i:s", sizeof("D, d M Y H:i:s") - 1, tv.tv_sec, 0);

smart_str_appends_ex(buffer, "Date: ", persistent);

smart_str_append_ex(buffer, dt, persistent);

smart_str_appends_ex(buffer, " GMT\r\n", persistent);

zend_string_release_ex(dt, 0);

}

smart_str_appendl_ex(buffer, "Connection: close\r\n", sizeof("Connection: close\r\n") - 1, persistent);

} /* }}} */

static const char *get_mime_type(const php_cli_server *server, const char *ext, size_t ext_len) /* {{{ */

{

return zend_hash_str_find_ptr_lc(&server->extension_mime_types, ext, ext_len);

} /* }}} */

PHP_FUNCTION(apache_request_headers) /* {{{ */

{

php_cli_server_client *client;

ZEND_PARSE_PARAMETERS_NONE();

client = SG(server_context);

/* Need to duplicate the header HashTable */

RETURN_ARR(zend_array_dup(&client->request.headers_original_case));

}

/* }}} */

static void add_response_header(sapi_header_struct *h, zval *return_value) /* {{{ */

{

char *s, *p;

ptrdiff_t len;

ALLOCA_FLAG(use_heap)

if (h->header_len > 0) {

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

len = p - h->header;

if (p && (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, (uint32_t)len, p, h->header_len - (p - h->header));

free_alloca(s, use_heap);

}

}

}

}

/* }}} */

PHP_FUNCTION(apache_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);

}

/* }}} */

/* {{{ cli_server module */

static void cli_server_init_globals(zend_cli_server_globals *cg)

{

cg->color = 0;

}

PHP_INI_BEGIN()

STD_PHP_INI_BOOLEAN("cli_server.color", "0", PHP_INI_ALL, OnUpdateBool, color, zend_cli_server_globals, cli_server_globals)

PHP_INI_END()

static PHP_MINIT_FUNCTION(cli_server)

{

ZEND_INIT_MODULE_GLOBALS(cli_server, cli_server_init_globals, NULL);

REGISTER_INI_ENTRIES();

return SUCCESS;

}

static PHP_MSHUTDOWN_FUNCTION(cli_server)

{

UNREGISTER_INI_ENTRIES();

return SUCCESS;

}

static PHP_MINFO_FUNCTION(cli_server)

{

DISPLAY_INI_ENTRIES();

}

static zend_module_entry cli_server_module_entry = {

STANDARD_MODULE_HEADER,

"cli_server",

NULL,

PHP_MINIT(cli_server),

PHP_MSHUTDOWN(cli_server),

NULL,

NULL,

PHP_MINFO(cli_server),

PHP_VERSION,

STANDARD_MODULE_PROPERTIES

};

/* }}} */

const zend_function_entry server_additional_functions[] = {

PHP_FE(cli_set_process_title, arginfo_cli_set_process_title)

PHP_FE(cli_get_process_title, arginfo_cli_get_process_title)

PHP_FE(apache_request_headers, arginfo_apache_request_headers)

PHP_FE(apache_response_headers, arginfo_apache_response_headers)

PHP_FALIAS(getallheaders, apache_request_headers, arginfo_getallheaders)

PHP_FE_END

};

static int sapi_cli_server_startup(sapi_module_struct *sapi_module_ptr) /* {{{ */

{

return php_module_startup(sapi_module_ptr, &cli_server_module_entry);

} /* }}} */

static size_t sapi_cli_server_ub_write(const char *str, size_t str_length) /* {{{ */

{

php_cli_server_client *client = SG(server_context);

if (!client) {

return 0;

}

return php_cli_server_client_send_through(client, str, str_length);

} /* }}} */

static void sapi_cli_server_flush(void *server_context) /* {{{ */

{

php_cli_server_client *client = server_context;

if (!client) {

return;

}

if (!ZEND_VALID_SOCKET(client->sock)) {

php_handle_aborted_connection();

return;

}

if (!SG(headers_sent)) {

sapi_send_headers();

SG(headers_sent) = true;

}

} /* }}} */

static int sapi_cli_server_discard_headers(sapi_headers_struct *sapi_headers) /* {{{ */{

return SAPI_HEADER_SENT_SUCCESSFULLY;

}

/* }}} */

static int sapi_cli_server_send_headers(sapi_headers_struct *sapi_headers) /* {{{ */

{

php_cli_server_client *client = SG(server_context);

smart_str buffer = { 0 };

sapi_header_struct *h;

zend_llist_position pos;

if (client == NULL || SG(request_info).no_headers) {

return SAPI_HEADER_SENT_SUCCESSFULLY;

}

if (SG(sapi_headers).http_status_line) {

smart_str_appends(&buffer, SG(sapi_headers).http_status_line);

smart_str_appendl(&buffer, "\r\n", 2);

} else {

append_http_status_line(&buffer, client->request.protocol_version, SG(sapi_headers).http_response_code, 0);

}

append_essential_headers(&buffer, client, 0, sapi_headers);

h = (sapi_header_struct*)zend_llist_get_first_ex(&sapi_headers->headers, &pos);

while (h) {

if (h->header_len) {

smart_str_appendl(&buffer, h->header, h->header_len);

smart_str_appendl(&buffer, "\r\n", 2);

}

h = (sapi_header_struct*)zend_llist_get_next_ex(&sapi_headers->headers, &pos);

}

smart_str_appendl(&buffer, "\r\n", 2);

php_cli_server_client_send_through(client, ZSTR_VAL(buffer.s), ZSTR_LEN(buffer.s));

smart_str_free(&buffer);

return SAPI_HEADER_SENT_SUCCESSFULLY;

}

/* }}} */

static char *sapi_cli_server_read_cookies(void) /* {{{ */

{

php_cli_server_client *client = SG(server_context);

zval *val;

if (NULL == (val = zend_hash_str_find(&client->request.headers, "cookie", sizeof("cookie")-1))) {

return NULL;

}

return Z_STRVAL_P(val);

} /* }}} */

static size_t sapi_cli_server_read_post(char *buf, size_t count_bytes) /* {{{ */

{

php_cli_server_client *client = SG(server_context);

if (client->request.content) {

size_t content_len = client->request.content_len;

size_t nbytes_copied = MIN(client->post_read_offset + count_bytes, content_len) - client->post_read_offset;

memmove(buf, client->request.content + client->post_read_offset, nbytes_copied);

client->post_read_offset += nbytes_copied;

return nbytes_copied;

}

return 0;

} /* }}} */

static void sapi_cli_server_register_variable(zval *track_vars_array, const char *key, const char *val) /* {{{ */

{

char *new_val = (char *)val;

size_t new_val_len;

if (NULL == val) {

return;

}

if (sapi_module.input_filter(PARSE_SERVER, (char*)key, &new_val, strlen(val), &new_val_len)) {

php_register_variable_safe((char *)key, new_val, new_val_len, track_vars_array);

}

} /* }}} */

static void sapi_cli_server_register_known_var_char(zval *track_vars_array,

const char *var_name, size_t var_name_len, const char *value, size_t value_len)

{

zval new_entry;

if (!value) {

return;

}

ZVAL_STRINGL_FAST(&new_entry, value, value_len);

php_register_known_variable(var_name, var_name_len, &new_entry, track_vars_array);

}

static void sapi_cli_server_register_known_var_str(zval *track_vars_array,

const char *var_name, size_t var_name_len, /* const */ zend_string *value)

{

zval new_entry;

if (!value) {

return;

}

ZVAL_STR_COPY(&new_entry, value);

php_register_known_variable(var_name, var_name_len, &new_entry, track_vars_array);

}

/* The entry zval will always contain a zend_string* */

static int sapi_cli_server_register_entry_cb(zval *entry, int num_args, va_list args, zend_hash_key *hash_key) /* {{{ */ {

zval *track_vars_array = va_arg(args, zval *);

ZEND_ASSERT(Z_TYPE_P(entry) == IS_STRING);

if (hash_key->key) {

char *real_key, *key;

uint32_t i;

key = estrndup(ZSTR_VAL(hash_key->key), ZSTR_LEN(hash_key->key));

for(i=0; i<ZSTR_LEN(hash_key->key); i++) {

if (key[i] == '-') {

key[i] = '_';

} else {

key[i] = toupper((unsigned char)key[i]);

}

}

spprintf(&real_key, 0, "%s_%s", "HTTP", key);

if (strcmp(key, "CONTENT_TYPE") == 0 || strcmp(key, "CONTENT_LENGTH") == 0) {

/* Is it possible to use sapi_cli_server_register_known_var_char() and not go through the SAPI filter? */

sapi_cli_server_register_variable(track_vars_array, key, Z_STRVAL_P(entry));

}

sapi_cli_server_register_variable(track_vars_array, real_key, Z_STRVAL_P(entry));

efree(key);

efree(real_key);

}

return ZEND_HASH_APPLY_KEEP;

}

/* }}} */

static void sapi_cli_server_register_variables(zval *track_vars_array) /* {{{ */

{

php_cli_server_client *client = SG(server_context);

sapi_cli_server_register_known_var_char(track_vars_array,

"DOCUMENT_ROOT", strlen("DOCUMENT_ROOT"), client->server->document_root, client->server->document_root_len);

{

char *tmp;

if ((tmp = strrchr(ZSTR_VAL(client->addr_str), ':'))) {

char addr[64], port[8];

const char *addr_start = ZSTR_VAL(client->addr_str), *addr_end = tmp;

if (addr_start[0] == '[') addr_start++;

if (addr_end[-1] == ']') addr_end--;

strncpy(port, tmp + 1, 8);

port[7] = '\0';

size_t addr_len = addr_end - addr_start;

strncpy(addr, addr_start, addr_len);

addr[addr_len] = '\0';

ZEND_ASSERT(addr_len == strlen(addr));

sapi_cli_server_register_known_var_char(track_vars_array,

"REMOTE_ADDR", strlen("REMOTE_ADDR"), addr, addr_len);

sapi_cli_server_register_known_var_char(track_vars_array,

"REMOTE_PORT", strlen("REMOTE_PORT"), port, strlen(port));

} else {

sapi_cli_server_register_known_var_str(track_vars_array,

"REMOTE_ADDR", strlen("REMOTE_ADDR"), client->addr_str);

}

}

{

zend_string *tmp = strpprintf(0, "PHP/%s (Development Server)", PHP_VERSION);

sapi_cli_server_register_known_var_str(track_vars_array, "SERVER_SOFTWARE", strlen("SERVER_SOFTWARE"), tmp);

zend_string_release_ex(tmp, /* persistent */ false);

}

{

zend_string *tmp = strpprintf(0, "HTTP/%d.%d", client->request.protocol_version / 100, client->request.protocol_version % 100);

sapi_cli_server_register_known_var_str(track_vars_array, "SERVER_PROTOCOL", strlen("SERVER_PROTOCOL"), tmp);

zend_string_release_ex(tmp, /* persistent */ false);

}

sapi_cli_server_register_known_var_char(track_vars_array,

"SERVER_NAME", strlen("SERVER_NAME"), client->server->host, strlen(client->server->host));

{

zend_string *tmp = strpprintf(0, "%i", client->server->port);

sapi_cli_server_register_known_var_str(track_vars_array, "SERVER_PORT", strlen("SERVER_PORT"), tmp);

zend_string_release_ex(tmp, /* persistent */ false);

}

sapi_cli_server_register_known_var_str(track_vars_array,

"REQUEST_URI", strlen("REQUEST_URI"), client->request.request_uri);

sapi_cli_server_register_known_var_char(track_vars_array,

"REQUEST_METHOD", strlen("REQUEST_METHOD"),

SG(request_info).request_method, strlen(SG(request_info).request_method));

sapi_cli_server_register_known_var_char(track_vars_array,

"SCRIPT_NAME", strlen("SCRIPT_NAME"), client->request.vpath, client->request.vpath_len);

if (SG(request_info).path_translated) {

sapi_cli_server_register_known_var_char(track_vars_array,

"SCRIPT_FILENAME", strlen("SCRIPT_FILENAME"),

SG(request_info).path_translated, strlen(SG(request_info).path_translated));

} else if (client->server->router) {

sapi_cli_server_register_known_var_char(track_vars_array,

"SCRIPT_FILENAME", strlen("SCRIPT_FILENAME"), client->server->router, client->server->router_len);

}

if (client->request.path_info) {

sapi_cli_server_register_known_var_char(track_vars_array,

"PATH_INFO", strlen("PATH_INFO"), client->request.path_info, client->request.path_info_len);

}

if (client->request.path_info_len) {

zend_string *tmp = strpprintf(0, "%s%s", client->request.vpath, client->request.path_info);

sapi_cli_server_register_known_var_str(track_vars_array, "PHP_SELF", strlen("PHP_SELF"), tmp);

zend_string_release_ex(tmp, /* persistent */ false);

} else {

sapi_cli_server_register_known_var_char(track_vars_array,

"PHP_SELF", strlen("PHP_SELF"), client->request.vpath, client->request.vpath_len);

}

if (client->request.query_string) {

/* Use sapi_cli_server_register_variable() to pass query string through SAPI input filter,

* and check keys are proper PHP var names */

sapi_cli_server_register_variable(track_vars_array, "QUERY_STRING", client->request.query_string);

}

/* Use sapi_cli_server_register_variable() to pass header values through SAPI input filter,

* and check keys are proper PHP var names */

zend_hash_apply_with_arguments(&client->request.headers, (apply_func_args_t)sapi_cli_server_register_entry_cb, 1, track_vars_array);

} /* }}} */

static void sapi_cli_server_log_write(int type, const char *msg) /* {{{ */

{

char buf[52];

if (php_cli_server_log_level < type) {

return;

}

if (!php_cli_server_get_system_time(buf)) {

memmove(buf, "unknown time, can't be fetched", sizeof("unknown time, can't be fetched"));

} else {

size_t l = strlen(buf);

if (l > 0) {

buf[l - 1] = '\0';

} else {

memmove(buf, "unknown", sizeof("unknown"));

}

}

#ifdef HAVE_FORK

if (php_cli_server_workers_max > 1) {

fprintf(stderr, "[%ld] [%s] %s\n", (long) getpid(), buf, msg);

} else {

fprintf(stderr, "[%s] %s\n", buf, msg);

}

#else

fprintf(stderr, "[%s] %s\n", buf, msg);

#endif

} /* }}} */

static void sapi_cli_server_log_message(const char *msg, int syslog_type_int) /* {{{ */

{

sapi_cli_server_log_write(PHP_CLI_SERVER_LOG_MESSAGE, msg);

} /* }}} */

/* {{{ sapi_module_struct cli_server_sapi_module */

sapi_module_struct cli_server_sapi_module = {

"cli-server", /* name */

"Built-in HTTP server", /* pretty name */

sapi_cli_server_startup, /* startup */

php_module_shutdown_wrapper, /* shutdown */

NULL, /* activate */

NULL, /* deactivate */

sapi_cli_server_ub_write, /* unbuffered write */

sapi_cli_server_flush, /* flush */

NULL, /* get uid */

NULL, /* getenv */

php_error, /* error handler */

NULL, /* header handler */

sapi_cli_server_send_headers, /* send headers handler */

NULL, /* send header handler */

sapi_cli_server_read_post, /* read POST data */

sapi_cli_server_read_cookies, /* read Cookies */

sapi_cli_server_register_variables, /* register server variables */

sapi_cli_server_log_message, /* Log message */

NULL, /* Get request time */

NULL, /* Child terminate */

STANDARD_SAPI_MODULE_PROPERTIES

}; /* }}} */

static void php_cli_server_poller_ctor(php_cli_server_poller *poller) /* {{{ */

{

FD_ZERO(&poller->rfds);

FD_ZERO(&poller->wfds);

poller->max_fd = -1;

} /* }}} */

static void php_cli_server_poller_add(php_cli_server_poller *poller, int mode, php_socket_t fd) /* {{{ */

{

if (mode & POLLIN) {

PHP_SAFE_FD_SET(fd, &poller->rfds);

}

if (mode & POLLOUT) {

PHP_SAFE_FD_SET(fd, &poller->wfds);

}

if (fd > poller->max_fd) {

poller->max_fd = fd;

}

} /* }}} */

static void php_cli_server_poller_remove(php_cli_server_poller *poller, int mode, php_socket_t fd) /* {{{ */

{

if (mode & POLLIN) {

PHP_SAFE_FD_CLR(fd, &poller->rfds);

}

if (mode & POLLOUT) {

PHP_SAFE_FD_CLR(fd, &poller->wfds);

}

#ifndef PHP_WIN32

if (fd == poller->max_fd) {

while (fd > 0) {

fd--;

if (PHP_SAFE_FD_ISSET(fd, &poller->rfds) || PHP_SAFE_FD_ISSET(fd, &poller->wfds)) {

break;

}

}

poller->max_fd = fd;

}

#endif

} /* }}} */

static int php_cli_server_poller_poll(php_cli_server_poller *poller, struct timeval *tv) /* {{{ */

{

memmove(&poller->active.rfds, &poller->rfds, sizeof(poller->rfds));

memmove(&poller->active.wfds, &poller->wfds, sizeof(poller->wfds));

return php_select(poller->max_fd + 1, &poller->active.rfds, &poller->active.wfds, NULL, tv);

} /* }}} */

static zend_result php_cli_server_poller_iter_on_active(php_cli_server_poller *poller, void *opaque, zend_result(*callback)(void *, php_socket_t fd, int events)) /* {{{ */

{

zend_result retval = SUCCESS;

#ifdef PHP_WIN32

struct socket_entry {

SOCKET fd;

int events;

} entries[FD_SETSIZE * 2];

size_t i;

struct socket_entry *n = entries, *m;

for (i = 0; i < poller->active.rfds.fd_count; i++) {

n->events = POLLIN;

n->fd = poller->active.rfds.fd_array[i];

n++;

}

m = n;

for (i = 0; i < poller->active.wfds.fd_count; i++) {

struct socket_entry *e;

SOCKET fd = poller->active.wfds.fd_array[i];

for (e = entries; e < m; e++) {

if (e->fd == fd) {

e->events |= POLLOUT;

}

}

if (e == m) {

assert(n < entries + FD_SETSIZE * 2);

n->events = POLLOUT;

n->fd = fd;

n++;

}

}

{

struct socket_entry *e = entries;

for (; e < n; e++) {

if (SUCCESS != callback(opaque, e->fd, e->events)) {

retval = FAILURE;

}

}

}

#else

php_socket_t fd;

const php_socket_t max_fd = poller->max_fd;

for (fd=0 ; fd<=max_fd ; fd++) {

if (PHP_SAFE_FD_ISSET(fd, &poller->active.rfds)) {

if (SUCCESS != callback(opaque, fd, POLLIN)) {

retval = FAILURE;

}

}

if (PHP_SAFE_FD_ISSET(fd, &poller->active.wfds)) {

if (SUCCESS != callback(opaque, fd, POLLOUT)) {

retval = FAILURE;

}

}

}

#endif

return retval;

} /* }}} */

static size_t php_cli_server_chunk_size(const php_cli_server_chunk *chunk) /* {{{ */

{

switch (chunk->type) {

case PHP_CLI_SERVER_CHUNK_HEAP:

return chunk->data.heap.len;

case PHP_CLI_SERVER_CHUNK_IMMORTAL:

return chunk->data.immortal.len;

}

return 0;

} /* }}} */

static void php_cli_server_chunk_dtor(php_cli_server_chunk *chunk) /* {{{ */

{

switch (chunk->type) {

case PHP_CLI_SERVER_CHUNK_HEAP:

if (chunk->data.heap.block != chunk) {

pefree(chunk->data.heap.block, 1);

}

break;

case PHP_CLI_SERVER_CHUNK_IMMORTAL:

break;

}

} /* }}} */

static void php_cli_server_buffer_dtor(php_cli_server_buffer *buffer) /* {{{ */

{

php_cli_server_chunk *chunk, *next;

for (chunk = buffer->first; chunk; chunk = next) {

next = chunk->next;

php_cli_server_chunk_dtor(chunk);

pefree(chunk, 1);

}

} /* }}} */

static void php_cli_server_buffer_ctor(php_cli_server_buffer *buffer) /* {{{ */

{

buffer->first = NULL;

buffer->last = NULL;

} /* }}} */

static void php_cli_server_buffer_append(php_cli_server_buffer *buffer, php_cli_server_chunk *chunk) /* {{{ */

{

php_cli_server_chunk *last;

for (last = chunk; last->next; last = last->next);

if (!buffer->last) {

buffer->first = chunk;

} else {

buffer->last->next = chunk;

}

buffer->last = last;

} /* }}} */

static void php_cli_server_buffer_prepend(php_cli_server_buffer *buffer, php_cli_server_chunk *chunk) /* {{{ */

{

php_cli_server_chunk *last;

for (last = chunk; last->next; last = last->next);

last->next = buffer->first;

if (!buffer->last) {

buffer->last = last;

}

buffer->first = chunk;

} /* }}} */

static size_t php_cli_server_buffer_size(const php_cli_server_buffer *buffer) /* {{{ */

{

php_cli_server_chunk *chunk;