#include <stdio.h>

#include <fcntl.h>

#include <assert.h>

#ifdef PHP_WIN32

#include <process.h>

#include <io.h>

#include "win32/time.h"

#include "win32/signal.h"

#include "win32/php_registry.h"

# include "php_config.h"

#ifdef __riscos__

#include <unixlib/local.h>

#if HAVE_TIME_H

#include <time.h>

#if HAVE_SYS_TIME_H

#include <sys/time.h>

#if HAVE_UNISTD_H

#include <unistd.h>

#if HAVE_SIGNAL_H

#include <signal.h>

#if HAVE_SETLOCALE

#include <locale.h>

#if HAVE_DLFCN_H

#include <dlfcn.h>

#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 "zend_compile.h"

#include "zend_execute.h"

#include "zend_highlight.h"

#include "zend_indent.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

# include "win32/select.h"

# define SOCK_EINVAL WSAEINVAL

# define SOCK_EAGAIN WSAEWOULDBLOCK

# define SOCK_EINTR WSAEINTR

# define SOCK_EADDRINUSE WSAEADDRINUSE

#ifndef S_ISDIR

#define S_ISDIR(mode) (((mode)&S_IFMT) == S_IFDIR)

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

#include "ext/standard/php_smart_str.h"

#include "ext/standard/html.h"

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

#include "ext/standard/php_string.h" /* for php_dirname() */

#include "php_network.h"

#include "php_http_parser.h"

#include "php_cli_server.h"

#define OUTPUT_NOT_CHECKED -1

#define OUTPUT_IS_TTY 1

#define OUTPUT_NOT_TTY 0

typedef struct php_cli_server_poller {

} php_cli_server_poller;

typedef struct php_cli_server_request {

} php_cli_server_request;

typedef struct php_cli_server_chunk {

} 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 {

} php_cli_server_client;

typedef struct php_cli_server {

} php_cli_server;

typedef struct php_cli_server_http_reponse_status_code_pair {

int code;

const char *str;

} php_cli_server_http_reponse_status_code_pair;

typedef struct php_cli_server_ext_mime_type_pair {

const char *ext;

const char *mime_type;

} php_cli_server_ext_mime_type_pair;

static php_cli_server_http_reponse_status_code_pair status_map[] = {

{ 100, "Continue" },

{ 101, "Switching Protocols" },

{ 200, "OK" },

{ 201, "Created" },

{ 202, "Accepted" },

{ 203, "Non-Authoritative Information" },

{ 204, "No Content" },

{ 205, "Reset Content" },

{ 206, "Partial Content" },

{ 300, "Multiple Choices" },

{ 301, "Moved Permanently" },

{ 302, "Found" },

{ 303, "See Other" },

{ 304, "Not Modified" },

{ 305, "Use Proxy" },

{ 307, "Temporary Redirect" },

{ 400, "Bad Request" },

{ 401, "Unauthorized" },

{ 402, "Payment Required" },

{ 403, "Forbidden" },

{ 404, "Not Found" },

{ 405, "Method Not Allowed" },

{ 406, "Not Acceptable" },

{ 407, "Proxy Authentication Required" },

{ 408, "Request Timeout" },

{ 409, "Conflict" },

{ 410, "Gone" },

{ 411, "Length Required" },

{ 412, "Precondition Failed" },

{ 413, "Request Entity Too Large" },

{ 414, "Request-URI Too Long" },

{ 415, "Unsupported Media Type" },

{ 416, "Requested Range Not Satisfiable" },

{ 417, "Expectation Failed" },

{ 500, "Internal Server Error" },

{ 501, "Not Implemented" },

{ 502, "Bad Gateway" },

{ 503, "Service Unavailable" },

{ 504, "Gateway Timeout" },

{ 505, "HTTP Version Not Supported" },

};

static php_cli_server_http_reponse_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 %s was not found on this server.</p>" },

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

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

};

static php_cli_server_ext_mime_type_pair mime_type_map[] = {

{ "html", "text/html" },

{ "htm", "text/html" },

{ "js", "text/javascript" },

{ "css", "text/css" },

{ "gif", "image/gif" },

{ "jpg", "image/jpeg" },

{ "jpeg", "image/jpeg" },

{ "jpe", "image/jpeg" },

{ "png", "image/png" },

{ "svg", "image/svg+xml" },

{ "txt", "text/plain" },

{ "webm", "video/webm" },

{ "ogv", "video/ogg" },

{ "ogg", "audio/ogg" },

{ NULL, NULL }

};

static int php_cli_output_is_tty = OUTPUT_NOT_CHECKED;

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(const char *format TSRMLS_DC, ...);

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

ZEND_DECLARE_MODULE_GLOBALS(cli_server);

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

"body { background-color: #ffffff; color: #000000; }\n" \

"h1 { font-family: sans-serif; font-size: 150%; background-color: #9999cc; font-weight: bold; color: #000000; margin-top: 0;}\n" \

"</style>\n";

static void char_ptr_dtor_p(char **p) /* {{{ */

{

pefree(*p, 1);

} /* }}} */

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

{

return pestrdup(strerror(errno), 1);

} /* }}} */

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

{

size_t e = (sizeof(status_map) / sizeof(php_cli_server_http_reponse_status_code_pair));

size_t s = 0;

while (e != s) {

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

int d = status_map[c].code;

if (d > code) {

e = c;

} else if (d < code) {

s = c;

} else {

return status_map[c].str;

}

}

return NULL;

} /* }}} */

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

{

size_t e = (sizeof(template_map) / sizeof(php_cli_server_http_reponse_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, int persistent) /* {{{ */

{

if (!response_code) {

response_code = 200;

}

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

smart_str_appendc_ex(buffer, '/', persistent);

smart_str_append_generic_ex(buffer, protocol_version / 100, persistent, int, _unsigned);

smart_str_appendc_ex(buffer, '.', persistent);

smart_str_append_generic_ex(buffer, protocol_version % 100, persistent, int, _unsigned);

smart_str_appendc_ex(buffer, ' ', persistent);

smart_str_append_generic_ex(buffer, response_code, persistent, int, _unsigned);

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, int persistent) /* {{{ */

{

{

char **val;

if (SUCCESS == zend_hash_find(&client->request.headers, "Host", sizeof("Host"), (void**)&val)) {

smart_str_appendl_ex(buffer, "Host", sizeof("Host") - 1, persistent);

smart_str_appendl_ex(buffer, ": ", sizeof(": ") - 1, persistent);

smart_str_appends_ex(buffer, *val, persistent);

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

}

}

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

} /* }}} */

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

{

php_cli_server_ext_mime_type_pair *pair;

for (pair = mime_type_map; pair->ext; pair++) {

size_t len = strlen(pair->ext);

if (len == ext_len && memcmp(pair->ext, ext, len) == 0) {

return pair->mime_type;

}

}

return NULL;

} /* }}} */

static void cli_server_init_globals(zend_cli_server_globals *cg TSRMLS_DC)

{

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

}

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

};

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

{

if (php_module_startup(sapi_module, &cli_server_module_entry, 1) == FAILURE) {

return FAILURE;

}

return SUCCESS;

} /* }}} */

static int sapi_cli_server_ub_write(const char *str, uint str_length TSRMLS_DC) /* {{{ */

{

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;

TSRMLS_FETCH();

if (!client) {

return;

}

if (client->sock < 0) {

php_handle_aborted_connection();

return;

}

if (!SG(headers_sent)) {

sapi_send_headers(TSRMLS_C);

SG(headers_sent) = 1;

}

} /* }}} */

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

return SAPI_HEADER_SENT_SUCCESSFULLY;

}

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

{

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);

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

while (h) {

if (!h->header_len) {

continue;

}

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, buffer.c, buffer.len);

smart_str_free(&buffer);

return SAPI_HEADER_SENT_SUCCESSFULLY;

}

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

{

php_cli_server_client *client = SG(server_context);

char **val;

if (FAILURE == zend_hash_find(&client->request.headers, "Cookie", sizeof("Cookie"), (void**)&val)) {

return NULL;

}

return *val;

} /* }}} */

static int sapi_cli_server_read_post(char *buf, uint count_bytes TSRMLS_DC) /* {{{ */

{

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 TSRMLS_DC) /* {{{ */

{

char *new_val = (char *)val;

uint new_val_len;

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

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

}

} /* }}} */

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

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

if (hash_key->nKeyLength) {

char *real_key, *key;

uint i;

key = estrndup(hash_key->arKey, hash_key->nKeyLength);

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

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

key[i] = '_';

} else {

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

}

}

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

sapi_cli_server_register_variable(track_vars_array, real_key, *entry TSRMLS_CC);

efree(key);

efree(real_key);

}

return ZEND_HASH_APPLY_KEEP;

}

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

{

php_cli_server_client *client = SG(server_context);

sapi_cli_server_register_variable(track_vars_array, "DOCUMENT_ROOT", client->server->document_root TSRMLS_CC);

{

char *tmp;

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

char addr[64], port[8];

strncpy(port, tmp + 1, 8);

port[7] = '\0';

strncpy(addr, client->addr_str, tmp - client->addr_str);

addr[tmp - client->addr_str] = '\0';

sapi_cli_server_register_variable(track_vars_array, "REMOTE_ADDR", addr TSRMLS_CC);

sapi_cli_server_register_variable(track_vars_array, "REMOTE_PORT", port TSRMLS_CC);

} else {

sapi_cli_server_register_variable(track_vars_array, "REMOTE_ADDR", client->addr_str TSRMLS_CC);

}

}

{

char *tmp;

spprintf(&tmp, 0, "PHP %s Development Server", PHP_VERSION);

sapi_cli_server_register_variable(track_vars_array, "SERVER_SOFTWARE", tmp TSRMLS_CC);

efree(tmp);

}

{

char *tmp;

spprintf(&tmp, 0, "HTTP/%d.%d", client->request.protocol_version / 100, client->request.protocol_version % 100);

sapi_cli_server_register_variable(track_vars_array, "SERVER_PROTOCOL", tmp TSRMLS_CC);

efree(tmp);

}

sapi_cli_server_register_variable(track_vars_array, "SERVER_NAME", client->server->host TSRMLS_CC);

{

char *tmp;

spprintf(&tmp, 0, "%i", client->server->port);

sapi_cli_server_register_variable(track_vars_array, "SERVER_PORT", tmp TSRMLS_CC);

efree(tmp);

}

sapi_cli_server_register_variable(track_vars_array, "REQUEST_URI", client->request.request_uri TSRMLS_CC);

sapi_cli_server_register_variable(track_vars_array, "REQUEST_METHOD", SG(request_info).request_method TSRMLS_CC);

sapi_cli_server_register_variable(track_vars_array, "SCRIPT_NAME", client->request.vpath TSRMLS_CC);

if (SG(request_info).path_translated) {

sapi_cli_server_register_variable(track_vars_array, "SCRIPT_FILENAME", SG(request_info).path_translated TSRMLS_CC);

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

char *temp;

spprintf(&temp, 0, "%s/%s", client->server->document_root, client->server->router);

sapi_cli_server_register_variable(track_vars_array, "SCRIPT_FILENAME", temp TSRMLS_CC);

efree(temp);

}

if (client->request.path_info) {

sapi_cli_server_register_variable(track_vars_array, "PATH_INFO", client->request.path_info TSRMLS_CC);

}

if (client->request.path_info_len) {

char *tmp;

spprintf(&tmp, 0, "%s%s", client->request.vpath, client->request.path_info);

sapi_cli_server_register_variable(track_vars_array, "PHP_SELF", tmp TSRMLS_CC);

efree(tmp);

} else {

sapi_cli_server_register_variable(track_vars_array, "PHP_SELF", client->request.vpath TSRMLS_CC);

}

if (client->request.query_string) {

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

}

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

} /* }}} */

static void sapi_cli_server_log_message(char *msg TSRMLS_DC) /* {{{ */

{

struct timeval tv;

struct tm tm;

char buf[52];

gettimeofday(&tv, NULL);

php_localtime_r(&tv.tv_sec, &tm);

php_asctime_r(&tm, buf);

{

size_t l = strlen(buf);

if (l > 0) {

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

} else {

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

}

}

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

} /* }}} */

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 int php_cli_server_poller_ctor(php_cli_server_poller *poller) /* {{{ */

{

FD_ZERO(&poller->rfds);

FD_ZERO(&poller->wfds);

poller->max_fd = -1;

return SUCCESS;

} /* }}} */

static void php_cli_server_poller_add(php_cli_server_poller *poller, int mode, int 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, int 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 (((unsigned int *)&poller->rfds)[fd / (8 * sizeof(unsigned int))] || ((unsigned int *)&poller->wfds)[fd / (8 * sizeof(unsigned int))]) {

break;

}

fd -= fd % (8 * sizeof(unsigned int));

}

poller->max_fd = fd;

}

} /* }}} */

static int php_cli_server_poller_poll(php_cli_server_poller *poller, const 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, (struct timeval *)tv);

} /* }}} */

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

{

int retval = SUCCESS;

#ifdef PHP_WIN32

struct socket_entry {

SOCKET fd;

int events;

} entries[FD_SETSIZE * 2];

php_socket_t fd = 0;

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;

}

}

}

php_socket_t fd = 0;

const php_socket_t max_fd = poller->max_fd;

const unsigned int *pr = (unsigned int *)&poller->active.rfds,

*pw = (unsigned int *)&poller->active.wfds,

*e = pr + (max_fd + (8 * sizeof(unsigned int)) - 1) / (8 * sizeof(unsigned int));

unsigned int mask;

while (pr < e && fd <= max_fd) {

for (mask = 1; mask; mask <<= 1, fd++) {

int events = (*pr & mask ? POLLIN: 0) | (*pw & mask ? POLLOUT: 0);

if (events) {

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

retval = FAILURE;

}

}

}

pr++;

pw++;

}

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;

size_t retval = 0;

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

retval += php_cli_server_chunk_size(chunk);

}

return retval;

} /* }}} */

static php_cli_server_chunk *php_cli_server_chunk_immortal_new(const char *buf, size_t len) /* {{{ */

{

php_cli_server_chunk *chunk = pemalloc(sizeof(php_cli_server_chunk), 1);

if (!chunk) {

return NULL;

}

chunk->type = PHP_CLI_SERVER_CHUNK_IMMORTAL;

chunk->next = NULL;

chunk->data.immortal.p = buf;

chunk->data.immortal.len = len;

return chunk;

} /* }}} */

static php_cli_server_chunk *php_cli_server_chunk_heap_new(char *block, char *buf, size_t len) /* {{{ */

{

php_cli_server_chunk *chunk = pemalloc(sizeof(php_cli_server_chunk), 1);

if (!chunk) {

return NULL;

}

chunk->type = PHP_CLI_SERVER_CHUNK_HEAP;

chunk->next = NULL;

chunk->data.heap.block = block;

chunk->data.heap.p = buf;

chunk->data.heap.len = len;

return chunk;

} /* }}} */

static php_cli_server_chunk *php_cli_server_chunk_heap_new_self_contained(size_t len) /* {{{ */

{

php_cli_server_chunk *chunk = pemalloc(sizeof(php_cli_server_chunk) + len, 1);

if (!chunk) {

return NULL;

}

chunk->type = PHP_CLI_SERVER_CHUNK_HEAP;

chunk->next = NULL;

chunk->data.heap.block = chunk;

chunk->data.heap.p = (char *)(chunk + 1);

chunk->data.heap.len = len;

return chunk;

} /* }}} */

static void php_cli_server_content_sender_dtor(php_cli_server_content_sender *sender) /* {{{ */

{

php_cli_server_buffer_dtor(&sender->buffer);

} /* }}} */

static void php_cli_server_content_sender_ctor(php_cli_server_content_sender *sender) /* {{{ */

{

php_cli_server_buffer_ctor(&sender->buffer);

} /* }}} */

static int php_cli_server_content_sender_send(php_cli_server_content_sender *sender, php_socket_t fd, size_t *nbytes_sent_total) /* {{{ */

{

php_cli_server_chunk *chunk, *next;

size_t _nbytes_sent_total = 0;

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

ssize_t nbytes_sent;

next = chunk->next;

switch (chunk->type) {

case PHP_CLI_SERVER_CHUNK_HEAP:

nbytes_sent = send(fd, chunk->data.heap.p, chunk->data.heap.len, 0);

if (nbytes_sent < 0) {

*nbytes_sent_total = _nbytes_sent_total;

return php_socket_errno();

} else if (nbytes_sent == chunk->data.heap.len) {

php_cli_server_chunk_dtor(chunk);

pefree(chunk, 1);

sender->buffer.first = next;

if (!next) {

sender->buffer.last = NULL;

}

} else {

chunk->data.heap.p += nbytes_sent;

chunk->data.heap.len -= nbytes_sent;

}

_nbytes_sent_total += nbytes_sent;

break;

case PHP_CLI_SERVER_CHUNK_IMMORTAL:

nbytes_sent = send(fd, chunk->data.immortal.p, chunk->data.immortal.len, 0);

if (nbytes_sent < 0) {

*nbytes_sent_total = _nbytes_sent_total;

return php_socket_errno();

} else if (nbytes_sent == chunk->data.immortal.len) {

php_cli_server_chunk_dtor(chunk);

pefree(chunk, 1);

sender->buffer.first = next;

if (!next) {

sender->buffer.last = NULL;

}

} else {

chunk->data.immortal.p += nbytes_sent;

chunk->data.immortal.len -= nbytes_sent;

}

_nbytes_sent_total += nbytes_sent;

break;

}

}

*nbytes_sent_total = _nbytes_sent_total;

return 0;

} /* }}} */

static int php_cli_server_content_sender_pull(php_cli_server_content_sender *sender, int fd, size_t *nbytes_read) /* {{{ */

{

ssize_t _nbytes_read;

php_cli_server_chunk *chunk = php_cli_server_chunk_heap_new_self_contained(131072);

_nbytes_read = read(fd, chunk->data.heap.p, chunk->data.heap.len);

if (_nbytes_read < 0) {

char *errstr = get_last_error();

TSRMLS_FETCH();

php_cli_server_logf("%s" TSRMLS_CC, errstr);

pefree(errstr, 1);

php_cli_server_chunk_dtor(chunk);

pefree(chunk, 1);

return 1;

}

chunk->data.heap.len = _nbytes_read;

php_cli_server_buffer_append(&sender->buffer, chunk);

*nbytes_read = _nbytes_read;

return 0;

} /* }}} */

#if HAVE_UNISTD_H

static int php_cli_is_output_tty() /* {{{ */

{