1 /*
2 +----------------------------------------------------------------------+
3 | Copyright (c) The PHP Group |
4 +----------------------------------------------------------------------+
5 | This source file is subject to version 3.01 of the PHP license, |
6 | that is bundled with this package in the file LICENSE, and is |
7 | available through the world-wide-web at the following url: |
8 | https://www.php.net/license/3_01.txt |
9 | If you did not receive a copy of the PHP license and are unable to |
10 | obtain it through the world-wide-web, please send a note to |
11 | license@php.net so we can mail you a copy immediately. |
12 +----------------------------------------------------------------------+
13 | Author: Moriyoshi Koizumi <moriyoshi@php.net> |
14 | Xinchen Hui <laruence@php.net> |
15 +----------------------------------------------------------------------+
16 */
17
18 #include <stdio.h>
19 #include <stdlib.h>
20 #include <fcntl.h>
21 #include <assert.h>
22 #include <signal.h>
23
24 #ifdef PHP_WIN32
25 # include <process.h>
26 # include <io.h>
27 # include "win32/time.h"
28 # include "win32/signal.h"
29 # include "win32/php_registry.h"
30 # include <sys/timeb.h>
31 #else
32 # include "php_config.h"
33 #endif
34
35 #ifdef __riscos__
36 #include <unixlib/local.h>
37 #endif
38
39 #if HAVE_SYS_TIME_H
40 #include <sys/time.h>
41 #endif
42 #if HAVE_UNISTD_H
43 #include <unistd.h>
44 #endif
45
46 #include <signal.h>
47 #include <locale.h>
48
49 #if HAVE_DLFCN_H
50 #include <dlfcn.h>
51 #endif
52
53 #ifdef HAVE_PRCTL
54 # include <sys/prctl.h>
55 #endif
56
57 #ifdef HAVE_PROCCTL
58 # include <sys/procctl.h>
59 #endif
60
61 #include "SAPI.h"
62 #include "php.h"
63 #include "php_ini.h"
64 #include "php_main.h"
65 #include "php_globals.h"
66 #include "php_variables.h"
67 #include "zend_hash.h"
68 #include "zend_modules.h"
69 #include "fopen_wrappers.h"
70 #include "http_status_codes.h"
71
72 #include "zend_compile.h"
73 #include "zend_execute.h"
74 #include "zend_highlight.h"
75 #include "zend_exceptions.h"
76
77 #include "php_getopt.h"
78
79 #ifndef PHP_WIN32
80 # define php_select(m, r, w, e, t) select(m, r, w, e, t)
81 # define SOCK_EINVAL EINVAL
82 # define SOCK_EAGAIN EAGAIN
83 # define SOCK_EINTR EINTR
84 # define SOCK_EADDRINUSE EADDRINUSE
85 #else
86 # include "win32/select.h"
87 # define SOCK_EINVAL WSAEINVAL
88 # define SOCK_EAGAIN WSAEWOULDBLOCK
89 # define SOCK_EINTR WSAEINTR
90 # define SOCK_EADDRINUSE WSAEADDRINUSE
91 #endif
92
93 #include "ext/standard/file.h" /* for php_set_sock_blocking() :-( */
94 #include "zend_smart_str.h"
95 #include "ext/standard/html.h"
96 #include "ext/standard/url.h" /* for php_raw_url_decode() */
97 #include "ext/standard/php_string.h" /* for php_dirname() */
98 #include "ext/date/php_date.h" /* for php_format_date() */
99 #include "php_network.h"
100
101 #include "php_http_parser.h"
102 #include "php_cli_server.h"
103 #include "php_cli_server_arginfo.h"
104 #include "mime_type_map.h"
105
106 #include "php_cli_process_title.h"
107 #include "php_cli_process_title_arginfo.h"
108
109 #define OUTPUT_NOT_CHECKED -1
110 #define OUTPUT_IS_TTY 1
111 #define OUTPUT_NOT_TTY 0
112
113 #if HAVE_FORK
114 # include <sys/wait.h>
115 static pid_t php_cli_server_master;
116 static pid_t *php_cli_server_workers;
117 static zend_long php_cli_server_workers_max;
118 #endif
119
120 static zend_string* cli_concat_persistent_zstr_with_char(zend_string *old_str, const char *at, size_t length);
121
122 typedef struct php_cli_server_poller {
123 fd_set rfds, wfds;
124 struct {
125 fd_set rfds, wfds;
126 } active;
127 php_socket_t max_fd;
128 } php_cli_server_poller;
129
130 typedef struct php_cli_server_request {
131 enum php_http_method request_method;
132 int protocol_version;
133 zend_string *request_uri;
134 char *vpath;
135 size_t vpath_len;
136 char *path_translated;
137 size_t path_translated_len;
138 char *path_info;
139 size_t path_info_len;
140 char *query_string;
141 size_t query_string_len;
142 HashTable headers;
143 HashTable headers_original_case;
144 char *content;
145 size_t content_len;
146 const char *ext;
147 size_t ext_len;
148 zend_stat_t sb;
149 } php_cli_server_request;
150
151 typedef struct php_cli_server_chunk {
152 struct php_cli_server_chunk *next;
153 enum php_cli_server_chunk_type {
154 PHP_CLI_SERVER_CHUNK_HEAP,
155 PHP_CLI_SERVER_CHUNK_IMMORTAL
156 } type;
157 union {
158 struct { void *block; char *p; size_t len; } heap;
159 struct { const char *p; size_t len; } immortal;
160 } data;
161 } php_cli_server_chunk;
162
163 typedef struct php_cli_server_buffer {
164 php_cli_server_chunk *first;
165 php_cli_server_chunk *last;
166 } php_cli_server_buffer;
167
168 typedef struct php_cli_server_content_sender {
169 php_cli_server_buffer buffer;
170 } php_cli_server_content_sender;
171
172 typedef struct php_cli_server_client {
173 struct php_cli_server *server;
174 php_socket_t sock;
175 struct sockaddr *addr;
176 socklen_t addr_len;
177 zend_string *addr_str;
178 php_http_parser parser;
179 bool request_read;
180 zend_string *current_header_name;
181 zend_string *current_header_value;
182 enum { HEADER_NONE=0, HEADER_FIELD, HEADER_VALUE } last_header_element;
183 size_t post_read_offset;
184 php_cli_server_request request;
185 bool content_sender_initialized;
186 php_cli_server_content_sender content_sender;
187 int file_fd;
188 } php_cli_server_client;
189
190 typedef struct php_cli_server {
191 php_socket_t server_sock;
192 php_cli_server_poller poller;
193 int is_running;
194 char *host;
195 int port;
196 int address_family;
197 char *document_root;
198 size_t document_root_len;
199 char *router;
200 size_t router_len;
201 socklen_t socklen;
202 HashTable clients;
203 HashTable extension_mime_types;
204 } php_cli_server;
205
206 typedef struct php_cli_server_http_response_status_code_pair {
207 int code;
208 const char *str;
209 } php_cli_server_http_response_status_code_pair;
210
211 static const php_cli_server_http_response_status_code_pair template_map[] = {
212 { 400, "<h1>%s</h1><p>Your browser sent a request that this server could not understand.</p>" },
213 { 404, "<h1>%s</h1><p>The requested resource <code class=\"url\">%s</code> was not found on this server.</p>" },
214 { 405, "<h1>%s</h1><p>Requested method not allowed.</p>" },
215 { 500, "<h1>%s</h1><p>The server is temporarily unavailable.</p>" },
216 { 501, "<h1>%s</h1><p>Request method not supported.</p>" }
217 };
218
219 #define PHP_CLI_SERVER_LOG_PROCESS 1
220 #define PHP_CLI_SERVER_LOG_ERROR 2
221 #define PHP_CLI_SERVER_LOG_MESSAGE 3
222
223 static int php_cli_server_log_level = 3;
224
225 #if HAVE_UNISTD_H || defined(PHP_WIN32)
226 static int php_cli_output_is_tty = OUTPUT_NOT_CHECKED;
227 #endif
228
229 static const char php_cli_server_request_error_unexpected_eof[] = "Unexpected EOF";
230
231 static size_t php_cli_server_client_send_through(php_cli_server_client *client, const char *str, size_t str_len);
232 static php_cli_server_chunk *php_cli_server_chunk_heap_new_self_contained(size_t len);
233 static void php_cli_server_buffer_append(php_cli_server_buffer *buffer, php_cli_server_chunk *chunk);
234 static void php_cli_server_logf(int type, const char *format, ...);
235 static void php_cli_server_log_response(php_cli_server_client *client, int status, const char *message);
236
237 ZEND_DECLARE_MODULE_GLOBALS(cli_server)
238
239 /* {{{ static char php_cli_server_css[]
240 * copied from ext/standard/info.c
241 */
242 static const char php_cli_server_css[] = "<style>\n" \
243 "body { background-color: #fcfcfc; color: #333333; margin: 0; padding:0; }\n" \
244 "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" \
245 "h1, p { padding-left: 10px; }\n" \
246 "code.url { background-color: #eeeeee; font-family:monospace; padding:0 2px;}\n" \
247 "</style>\n";
248 /* }}} */
249
250 #ifdef PHP_WIN32
php_cli_server_get_system_time(char * buf)251 static bool php_cli_server_get_system_time(char *buf) {
252 struct _timeb system_time;
253 errno_t err;
254
255 if (buf == NULL) {
256 return false;
257 }
258
259 _ftime(&system_time);
260 err = ctime_s(buf, 52, &(system_time.time) );
261 if (err) {
262 return false;
263 }
264 return true;
265 }
266 #else
php_cli_server_get_system_time(char * buf)267 static bool php_cli_server_get_system_time(char *buf) {
268 struct timeval tv;
269 struct tm tm;
270
271 gettimeofday(&tv, NULL);
272
273 if (!php_localtime_r(&tv.tv_sec, &tm)) {
274 return false;
275 }
276 return php_asctime_r(&tm, buf) != NULL;
277 }
278 #endif
279
280 /* Destructor for php_cli_server_request->headers, this frees header value */
cli_header_value_dtor(zval * zv)281 static void cli_header_value_dtor(zval *zv) /* {{{ */
282 {
283 zend_string_release_ex(Z_STR_P(zv), /* persistent */ true);
284 } /* }}} */
285
get_last_error(void)286 static char *get_last_error(void) /* {{{ */
287 {
288 return pestrdup(strerror(errno), 1);
289 } /* }}} */
290
status_comp(const void * a,const void * b)291 static int status_comp(const void *a, const void *b) /* {{{ */
292 {
293 const http_response_status_code_pair *pa = (const http_response_status_code_pair *) a;
294 const http_response_status_code_pair *pb = (const http_response_status_code_pair *) b;
295
296 if (pa->code < pb->code) {
297 return -1;
298 } else if (pa->code > pb->code) {
299 return 1;
300 }
301
302 return 0;
303 } /* }}} */
304
get_status_string(int code)305 static const char *get_status_string(int code) /* {{{ */
306 {
307 http_response_status_code_pair needle = {code, NULL},
308 *result = NULL;
309
310 result = bsearch(&needle, http_status_map, http_status_map_len, sizeof(needle), status_comp);
311
312 if (result) {
313 return result->str;
314 }
315
316 /* Returning NULL would require complicating append_http_status_line() to
317 * not segfault in that case, so let's just return a placeholder, since RFC
318 * 2616 requires a reason phrase. This is basically what a lot of other Web
319 * servers do in this case anyway. */
320 return "Unknown Status Code";
321 } /* }}} */
322
get_template_string(int code)323 static const char *get_template_string(int code) /* {{{ */
324 {
325 size_t e = (sizeof(template_map) / sizeof(php_cli_server_http_response_status_code_pair));
326 size_t s = 0;
327
328 while (e != s) {
329 size_t c = MIN((e + s + 1) / 2, e - 1);
330 int d = template_map[c].code;
331 if (d > code) {
332 e = c;
333 } else if (d < code) {
334 s = c;
335 } else {
336 return template_map[c].str;
337 }
338 }
339 return NULL;
340 } /* }}} */
341
append_http_status_line(smart_str * buffer,int protocol_version,int response_code,bool persistent)342 static void append_http_status_line(smart_str *buffer, int protocol_version, int response_code, bool persistent) /* {{{ */
343 {
344 if (!response_code) {
345 response_code = 200;
346 }
347 smart_str_appendl_ex(buffer, "HTTP", 4, persistent);
348 smart_str_appendc_ex(buffer, '/', persistent);
349 smart_str_append_long_ex(buffer, protocol_version / 100, persistent);
350 smart_str_appendc_ex(buffer, '.', persistent);
351 smart_str_append_long_ex(buffer, protocol_version % 100, persistent);
352 smart_str_appendc_ex(buffer, ' ', persistent);
353 smart_str_append_long_ex(buffer, response_code, persistent);
354 smart_str_appendc_ex(buffer, ' ', persistent);
355 smart_str_appends_ex(buffer, get_status_string(response_code), persistent);
356 smart_str_appendl_ex(buffer, "\r\n", 2, persistent);
357 } /* }}} */
358
append_essential_headers(smart_str * buffer,php_cli_server_client * client,bool persistent,sapi_headers_struct * sapi_headers)359 static void append_essential_headers(smart_str* buffer, php_cli_server_client *client, bool persistent, sapi_headers_struct *sapi_headers) /* {{{ */
360 {
361 zval *val;
362 struct timeval tv = {0};
363 bool append_date_header = true;
364
365 if (sapi_headers != NULL) {
366 zend_llist_position pos;
367 sapi_header_struct *h = (sapi_header_struct*)zend_llist_get_first_ex(&sapi_headers->headers, &pos);
368 while (h) {
369 if (h->header_len > strlen("Date:")) {
370 if (strncasecmp(h->header, "Date:", strlen("Date:")) == 0) {
371 append_date_header = false;
372 break;
373 }
374 }
375 h = (sapi_header_struct*)zend_llist_get_next_ex(&sapi_headers->headers, &pos);
376 }
377 }
378
379 if (NULL != (val = zend_hash_find(&client->request.headers, ZSTR_KNOWN(ZEND_STR_HOST)))) {
380 smart_str_appends_ex(buffer, "Host: ", persistent);
381 smart_str_append_ex(buffer, Z_STR_P(val), persistent);
382 smart_str_appends_ex(buffer, "\r\n", persistent);
383 }
384
385 if (append_date_header && !gettimeofday(&tv, NULL)) {
386 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);
387 smart_str_appends_ex(buffer, "Date: ", persistent);
388 smart_str_append_ex(buffer, dt, persistent);
389 smart_str_appends_ex(buffer, " GMT\r\n", persistent);
390 zend_string_release_ex(dt, 0);
391 }
392
393 smart_str_appendl_ex(buffer, "Connection: close\r\n", sizeof("Connection: close\r\n") - 1, persistent);
394 } /* }}} */
395
get_mime_type(const php_cli_server * server,const char * ext,size_t ext_len)396 static const char *get_mime_type(const php_cli_server *server, const char *ext, size_t ext_len) /* {{{ */
397 {
398 char *ret;
399 ALLOCA_FLAG(use_heap)
400 char *ext_lower = do_alloca(ext_len + 1, use_heap);
401 zend_str_tolower_copy(ext_lower, ext, ext_len);
402 ret = zend_hash_str_find_ptr(&server->extension_mime_types, ext_lower, ext_len);
403 free_alloca(ext_lower, use_heap);
404 return (const char*)ret;
405 } /* }}} */
406
PHP_FUNCTION(apache_request_headers)407 PHP_FUNCTION(apache_request_headers) /* {{{ */
408 {
409 php_cli_server_client *client;
410
411 if (zend_parse_parameters_none() == FAILURE) {
412 RETURN_THROWS();
413 }
414
415 client = SG(server_context);
416
417 /* Need to duplicate the header HashTable */
418 RETURN_ARR(zend_array_dup(&client->request.headers_original_case));
419 }
420 /* }}} */
421
add_response_header(sapi_header_struct * h,zval * return_value)422 static void add_response_header(sapi_header_struct *h, zval *return_value) /* {{{ */
423 {
424 char *s, *p;
425 ptrdiff_t len;
426 ALLOCA_FLAG(use_heap)
427
428 if (h->header_len > 0) {
429 p = strchr(h->header, ':');
430 len = p - h->header;
431 if (p && (len > 0)) {
432 while (len > 0 && (h->header[len-1] == ' ' || h->header[len-1] == '\t')) {
433 len--;
434 }
435 if (len) {
436 s = do_alloca(len + 1, use_heap);
437 memcpy(s, h->header, len);
438 s[len] = 0;
439 do {
440 p++;
441 } while (*p == ' ' || *p == '\t');
442 add_assoc_stringl_ex(return_value, s, (uint32_t)len, p, h->header_len - (p - h->header));
443 free_alloca(s, use_heap);
444 }
445 }
446 }
447 }
448 /* }}} */
449
PHP_FUNCTION(apache_response_headers)450 PHP_FUNCTION(apache_response_headers) /* {{{ */
451 {
452 if (zend_parse_parameters_none() == FAILURE) {
453 RETURN_THROWS();
454 }
455
456 array_init(return_value);
457 zend_llist_apply_with_argument(&SG(sapi_headers).headers, (llist_apply_with_arg_func_t)add_response_header, return_value);
458 }
459 /* }}} */
460
461 /* {{{ cli_server module */
462
cli_server_init_globals(zend_cli_server_globals * cg)463 static void cli_server_init_globals(zend_cli_server_globals *cg)
464 {
465 cg->color = 0;
466 }
467
468 PHP_INI_BEGIN()
469 STD_PHP_INI_BOOLEAN("cli_server.color", "0", PHP_INI_ALL, OnUpdateBool, color, zend_cli_server_globals, cli_server_globals)
PHP_INI_END()470 PHP_INI_END()
471
472 static PHP_MINIT_FUNCTION(cli_server)
473 {
474 ZEND_INIT_MODULE_GLOBALS(cli_server, cli_server_init_globals, NULL);
475 REGISTER_INI_ENTRIES();
476 return SUCCESS;
477 }
478
PHP_MSHUTDOWN_FUNCTION(cli_server)479 static PHP_MSHUTDOWN_FUNCTION(cli_server)
480 {
481 UNREGISTER_INI_ENTRIES();
482 return SUCCESS;
483 }
484
PHP_MINFO_FUNCTION(cli_server)485 static PHP_MINFO_FUNCTION(cli_server)
486 {
487 DISPLAY_INI_ENTRIES();
488 }
489
490 zend_module_entry cli_server_module_entry = {
491 STANDARD_MODULE_HEADER,
492 "cli_server",
493 NULL,
494 PHP_MINIT(cli_server),
495 PHP_MSHUTDOWN(cli_server),
496 NULL,
497 NULL,
498 PHP_MINFO(cli_server),
499 PHP_VERSION,
500 STANDARD_MODULE_PROPERTIES
501 };
502 /* }}} */
503
504 const zend_function_entry server_additional_functions[] = {
505 PHP_FE(cli_set_process_title, arginfo_cli_set_process_title)
506 PHP_FE(cli_get_process_title, arginfo_cli_get_process_title)
507 PHP_FE(apache_request_headers, arginfo_apache_request_headers)
508 PHP_FE(apache_response_headers, arginfo_apache_response_headers)
509 PHP_FALIAS(getallheaders, apache_request_headers, arginfo_getallheaders)
510 PHP_FE_END
511 };
512
sapi_cli_server_startup(sapi_module_struct * sapi_module)513 static int sapi_cli_server_startup(sapi_module_struct *sapi_module) /* {{{ */
514 {
515 return php_module_startup(sapi_module, &cli_server_module_entry);
516 } /* }}} */
517
sapi_cli_server_ub_write(const char * str,size_t str_length)518 static size_t sapi_cli_server_ub_write(const char *str, size_t str_length) /* {{{ */
519 {
520 php_cli_server_client *client = SG(server_context);
521 if (!client) {
522 return 0;
523 }
524 return php_cli_server_client_send_through(client, str, str_length);
525 } /* }}} */
526
sapi_cli_server_flush(void * server_context)527 static void sapi_cli_server_flush(void *server_context) /* {{{ */
528 {
529 php_cli_server_client *client = server_context;
530
531 if (!client) {
532 return;
533 }
534
535 if (!ZEND_VALID_SOCKET(client->sock)) {
536 php_handle_aborted_connection();
537 return;
538 }
539
540 if (!SG(headers_sent)) {
541 sapi_send_headers();
542 SG(headers_sent) = 1;
543 }
544 } /* }}} */
545
sapi_cli_server_discard_headers(sapi_headers_struct * sapi_headers)546 static int sapi_cli_server_discard_headers(sapi_headers_struct *sapi_headers) /* {{{ */{
547 return SAPI_HEADER_SENT_SUCCESSFULLY;
548 }
549 /* }}} */
550
sapi_cli_server_send_headers(sapi_headers_struct * sapi_headers)551 static int sapi_cli_server_send_headers(sapi_headers_struct *sapi_headers) /* {{{ */
552 {
553 php_cli_server_client *client = SG(server_context);
554 smart_str buffer = { 0 };
555 sapi_header_struct *h;
556 zend_llist_position pos;
557
558 if (client == NULL || SG(request_info).no_headers) {
559 return SAPI_HEADER_SENT_SUCCESSFULLY;
560 }
561
562 if (SG(sapi_headers).http_status_line) {
563 smart_str_appends(&buffer, SG(sapi_headers).http_status_line);
564 smart_str_appendl(&buffer, "\r\n", 2);
565 } else {
566 append_http_status_line(&buffer, client->request.protocol_version, SG(sapi_headers).http_response_code, 0);
567 }
568
569 append_essential_headers(&buffer, client, 0, sapi_headers);
570
571 h = (sapi_header_struct*)zend_llist_get_first_ex(&sapi_headers->headers, &pos);
572 while (h) {
573 if (h->header_len) {
574 smart_str_appendl(&buffer, h->header, h->header_len);
575 smart_str_appendl(&buffer, "\r\n", 2);
576 }
577 h = (sapi_header_struct*)zend_llist_get_next_ex(&sapi_headers->headers, &pos);
578 }
579 smart_str_appendl(&buffer, "\r\n", 2);
580
581 php_cli_server_client_send_through(client, ZSTR_VAL(buffer.s), ZSTR_LEN(buffer.s));
582
583 smart_str_free(&buffer);
584 return SAPI_HEADER_SENT_SUCCESSFULLY;
585 }
586 /* }}} */
587
sapi_cli_server_read_cookies(void)588 static char *sapi_cli_server_read_cookies(void) /* {{{ */
589 {
590 php_cli_server_client *client = SG(server_context);
591 zval *val;
592 if (NULL == (val = zend_hash_str_find(&client->request.headers, "cookie", sizeof("cookie")-1))) {
593 return NULL;
594 }
595 return Z_STRVAL_P(val);
596 } /* }}} */
597
sapi_cli_server_read_post(char * buf,size_t count_bytes)598 static size_t sapi_cli_server_read_post(char *buf, size_t count_bytes) /* {{{ */
599 {
600 php_cli_server_client *client = SG(server_context);
601 if (client->request.content) {
602 size_t content_len = client->request.content_len;
603 size_t nbytes_copied = MIN(client->post_read_offset + count_bytes, content_len) - client->post_read_offset;
604 memmove(buf, client->request.content + client->post_read_offset, nbytes_copied);
605 client->post_read_offset += nbytes_copied;
606 return nbytes_copied;
607 }
608 return 0;
609 } /* }}} */
610
sapi_cli_server_register_variable(zval * track_vars_array,const char * key,const char * val)611 static void sapi_cli_server_register_variable(zval *track_vars_array, const char *key, const char *val) /* {{{ */
612 {
613 char *new_val = (char *)val;
614 size_t new_val_len;
615
616 if (NULL == val) {
617 return;
618 }
619
620 if (sapi_module.input_filter(PARSE_SERVER, (char*)key, &new_val, strlen(val), &new_val_len)) {
621 php_register_variable_safe((char *)key, new_val, new_val_len, track_vars_array);
622 }
623 } /* }}} */
624
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)625 static void sapi_cli_server_register_known_var_char(zval *track_vars_array,
626 const char *var_name, size_t var_name_len, const char *value, size_t value_len)
627 {
628 zval new_entry;
629
630 if (!value) {
631 return;
632 }
633
634 ZVAL_STRINGL_FAST(&new_entry, value, value_len);
635
636 php_register_known_variable(var_name, var_name_len, &new_entry, track_vars_array);
637 }
638
sapi_cli_server_register_known_var_str(zval * track_vars_array,const char * var_name,size_t var_name_len,zend_string * value)639 static void sapi_cli_server_register_known_var_str(zval *track_vars_array,
640 const char *var_name, size_t var_name_len, /* const */ zend_string *value)
641 {
642 zval new_entry;
643
644 if (!value) {
645 return;
646 }
647
648 ZVAL_STR_COPY(&new_entry, value);
649
650 php_register_known_variable(var_name, var_name_len, &new_entry, track_vars_array);
651 }
652
653 /* The entry zval will always contain a zend_string* */
sapi_cli_server_register_entry_cb(zval * entry,int num_args,va_list args,zend_hash_key * hash_key)654 static int sapi_cli_server_register_entry_cb(zval *entry, int num_args, va_list args, zend_hash_key *hash_key) /* {{{ */ {
655 zval *track_vars_array = va_arg(args, zval *);
656
657 ZEND_ASSERT(Z_TYPE_P(entry) == IS_STRING);
658
659 if (hash_key->key) {
660 char *real_key, *key;
661 uint32_t i;
662 key = estrndup(ZSTR_VAL(hash_key->key), ZSTR_LEN(hash_key->key));
663 for(i=0; i<ZSTR_LEN(hash_key->key); i++) {
664 if (key[i] == '-') {
665 key[i] = '_';
666 } else {
667 key[i] = toupper(key[i]);
668 }
669 }
670 spprintf(&real_key, 0, "%s_%s", "HTTP", key);
671 if (strcmp(key, "CONTENT_TYPE") == 0 || strcmp(key, "CONTENT_LENGTH") == 0) {
672 /* Is it possible to use sapi_cli_server_register_known_var_char() and not go through the SAPI filter? */
673 sapi_cli_server_register_variable(track_vars_array, key, Z_STRVAL_P(entry));
674 }
675 sapi_cli_server_register_variable(track_vars_array, real_key, Z_STRVAL_P(entry));
676 efree(key);
677 efree(real_key);
678 }
679
680 return ZEND_HASH_APPLY_KEEP;
681 }
682 /* }}} */
683
sapi_cli_server_register_variables(zval * track_vars_array)684 static void sapi_cli_server_register_variables(zval *track_vars_array) /* {{{ */
685 {
686 php_cli_server_client *client = SG(server_context);
687
688 sapi_cli_server_register_known_var_char(track_vars_array,
689 "DOCUMENT_ROOT", strlen("DOCUMENT_ROOT"), client->server->document_root, client->server->document_root_len);
690 {
691 char *tmp;
692 if ((tmp = strrchr(ZSTR_VAL(client->addr_str), ':'))) {
693 char addr[64], port[8];
694 const char *addr_start = ZSTR_VAL(client->addr_str), *addr_end = tmp;
695 if (addr_start[0] == '[') addr_start++;
696 if (addr_end[-1] == ']') addr_end--;
697
698 strncpy(port, tmp + 1, 8);
699 port[7] = '\0';
700 size_t addr_len = addr_end - addr_start;
701 strncpy(addr, addr_start, addr_len);
702 addr[addr_len] = '\0';
703 ZEND_ASSERT(addr_len == strlen(addr));
704 sapi_cli_server_register_known_var_char(track_vars_array,
705 "REMOTE_ADDR", strlen("REMOTE_ADDR"), addr, addr_len);
706 sapi_cli_server_register_known_var_char(track_vars_array,
707 "REMOTE_PORT", strlen("REMOTE_PORT"), port, strlen(port));
708 } else {
709 sapi_cli_server_register_known_var_str(track_vars_array,
710 "REMOTE_ADDR", strlen("REMOTE_ADDR"), client->addr_str);
711 }
712 }
713 {
714 zend_string *tmp = strpprintf(0, "PHP/%s (Development Server)", PHP_VERSION);
715 sapi_cli_server_register_known_var_str(track_vars_array, "SERVER_SOFTWARE", strlen("SERVER_SOFTWARE"), tmp);
716 zend_string_release_ex(tmp, /* persistent */ false);
717 }
718 {
719 zend_string *tmp = strpprintf(0, "HTTP/%d.%d", client->request.protocol_version / 100, client->request.protocol_version % 100);
720 sapi_cli_server_register_known_var_str(track_vars_array, "SERVER_PROTOCOL", strlen("SERVER_PROTOCOL"), tmp);
721 zend_string_release_ex(tmp, /* persistent */ false);
722 }
723 sapi_cli_server_register_known_var_char(track_vars_array,
724 "SERVER_NAME", strlen("SERVER_NAME"), client->server->host, strlen(client->server->host));
725 {
726 zend_string *tmp = strpprintf(0, "%i", client->server->port);
727 sapi_cli_server_register_known_var_str(track_vars_array, "SERVER_PORT", strlen("SERVER_PORT"), tmp);
728 zend_string_release_ex(tmp, /* persistent */ false);
729 }
730
731 sapi_cli_server_register_known_var_str(track_vars_array,
732 "REQUEST_URI", strlen("REQUEST_URI"), client->request.request_uri);
733 sapi_cli_server_register_known_var_char(track_vars_array,
734 "REQUEST_METHOD", strlen("REQUEST_METHOD"),
735 SG(request_info).request_method, strlen(SG(request_info).request_method));
736 sapi_cli_server_register_known_var_char(track_vars_array,
737 "SCRIPT_NAME", strlen("SCRIPT_NAME"), client->request.vpath, client->request.vpath_len);
738 if (SG(request_info).path_translated) {
739 sapi_cli_server_register_known_var_char(track_vars_array,
740 "SCRIPT_FILENAME", strlen("SCRIPT_FILENAME"),
741 SG(request_info).path_translated, strlen(SG(request_info).path_translated));
742 } else if (client->server->router) {
743 sapi_cli_server_register_known_var_char(track_vars_array,
744 "SCRIPT_FILENAME", strlen("SCRIPT_FILENAME"), client->server->router, client->server->router_len);
745 }
746 if (client->request.path_info) {
747 sapi_cli_server_register_known_var_char(track_vars_array,
748 "PATH_INFO", strlen("PATH_INFO"), client->request.path_info, client->request.path_info_len);
749 }
750 if (client->request.path_info_len) {
751 zend_string *tmp = strpprintf(0, "%s%s", client->request.vpath, client->request.path_info);
752 sapi_cli_server_register_known_var_str(track_vars_array, "PHP_SELF", strlen("PHP_SELF"), tmp);
753 zend_string_release_ex(tmp, /* persistent */ false);
754 } else {
755 sapi_cli_server_register_known_var_char(track_vars_array,
756 "PHP_SELF", strlen("PHP_SELF"), client->request.vpath, client->request.vpath_len);
757 }
758 if (client->request.query_string) {
759 /* Use sapi_cli_server_register_variable() to pass query string through SAPI input filter,
760 * and check keys are proper PHP var names */
761 sapi_cli_server_register_variable(track_vars_array, "QUERY_STRING", client->request.query_string);
762 }
763 /* Use sapi_cli_server_register_variable() to pass header values through SAPI input filter,
764 * and check keys are proper PHP var names */
765 zend_hash_apply_with_arguments(&client->request.headers, (apply_func_args_t)sapi_cli_server_register_entry_cb, 1, track_vars_array);
766 } /* }}} */
767
sapi_cli_server_log_write(int type,const char * msg)768 static void sapi_cli_server_log_write(int type, const char *msg) /* {{{ */
769 {
770 char buf[52];
771
772 if (php_cli_server_log_level < type) {
773 return;
774 }
775
776 if (!php_cli_server_get_system_time(buf)) {
777 memmove(buf, "unknown time, can't be fetched", sizeof("unknown time, can't be fetched"));
778 } else {
779 size_t l = strlen(buf);
780 if (l > 0) {
781 buf[l - 1] = '\0';
782 } else {
783 memmove(buf, "unknown", sizeof("unknown"));
784 }
785 }
786 #ifdef HAVE_FORK
787 if (php_cli_server_workers_max > 1) {
788 fprintf(stderr, "[%ld] [%s] %s\n", (long) getpid(), buf, msg);
789 } else {
790 fprintf(stderr, "[%s] %s\n", buf, msg);
791 }
792 #else
793 fprintf(stderr, "[%s] %s\n", buf, msg);
794 #endif
795 } /* }}} */
796
sapi_cli_server_log_message(const char * msg,int syslog_type_int)797 static void sapi_cli_server_log_message(const char *msg, int syslog_type_int) /* {{{ */
798 {
799 sapi_cli_server_log_write(PHP_CLI_SERVER_LOG_MESSAGE, msg);
800 } /* }}} */
801
802 /* {{{ sapi_module_struct cli_server_sapi_module */
803 sapi_module_struct cli_server_sapi_module = {
804 "cli-server", /* name */
805 "Built-in HTTP server", /* pretty name */
806
807 sapi_cli_server_startup, /* startup */
808 php_module_shutdown_wrapper, /* shutdown */
809
810 NULL, /* activate */
811 NULL, /* deactivate */
812
813 sapi_cli_server_ub_write, /* unbuffered write */
814 sapi_cli_server_flush, /* flush */
815 NULL, /* get uid */
816 NULL, /* getenv */
817
818 php_error, /* error handler */
819
820 NULL, /* header handler */
821 sapi_cli_server_send_headers, /* send headers handler */
822 NULL, /* send header handler */
823
824 sapi_cli_server_read_post, /* read POST data */
825 sapi_cli_server_read_cookies, /* read Cookies */
826
827 sapi_cli_server_register_variables, /* register server variables */
828 sapi_cli_server_log_message, /* Log message */
829 NULL, /* Get request time */
830 NULL, /* Child terminate */
831
832 STANDARD_SAPI_MODULE_PROPERTIES
833 }; /* }}} */
834
php_cli_server_poller_ctor(php_cli_server_poller * poller)835 static void php_cli_server_poller_ctor(php_cli_server_poller *poller) /* {{{ */
836 {
837 FD_ZERO(&poller->rfds);
838 FD_ZERO(&poller->wfds);
839 poller->max_fd = -1;
840 } /* }}} */
841
php_cli_server_poller_add(php_cli_server_poller * poller,int mode,php_socket_t fd)842 static void php_cli_server_poller_add(php_cli_server_poller *poller, int mode, php_socket_t fd) /* {{{ */
843 {
844 if (mode & POLLIN) {
845 PHP_SAFE_FD_SET(fd, &poller->rfds);
846 }
847 if (mode & POLLOUT) {
848 PHP_SAFE_FD_SET(fd, &poller->wfds);
849 }
850 if (fd > poller->max_fd) {
851 poller->max_fd = fd;
852 }
853 } /* }}} */
854
php_cli_server_poller_remove(php_cli_server_poller * poller,int mode,php_socket_t fd)855 static void php_cli_server_poller_remove(php_cli_server_poller *poller, int mode, php_socket_t fd) /* {{{ */
856 {
857 if (mode & POLLIN) {
858 PHP_SAFE_FD_CLR(fd, &poller->rfds);
859 }
860 if (mode & POLLOUT) {
861 PHP_SAFE_FD_CLR(fd, &poller->wfds);
862 }
863 #ifndef PHP_WIN32
864 if (fd == poller->max_fd) {
865 while (fd > 0) {
866 fd--;
867 if (PHP_SAFE_FD_ISSET(fd, &poller->rfds) || PHP_SAFE_FD_ISSET(fd, &poller->wfds)) {
868 break;
869 }
870 }
871 poller->max_fd = fd;
872 }
873 #endif
874 } /* }}} */
875
php_cli_server_poller_poll(php_cli_server_poller * poller,struct timeval * tv)876 static int php_cli_server_poller_poll(php_cli_server_poller *poller, struct timeval *tv) /* {{{ */
877 {
878 memmove(&poller->active.rfds, &poller->rfds, sizeof(poller->rfds));
879 memmove(&poller->active.wfds, &poller->wfds, sizeof(poller->wfds));
880 return php_select(poller->max_fd + 1, &poller->active.rfds, &poller->active.wfds, NULL, tv);
881 } /* }}} */
882
php_cli_server_poller_iter_on_active(php_cli_server_poller * poller,void * opaque,zend_result (* callback)(void *,php_socket_t fd,int events))883 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)) /* {{{ */
884 {
885 zend_result retval = SUCCESS;
886 #ifdef PHP_WIN32
887 struct socket_entry {
888 SOCKET fd;
889 int events;
890 } entries[FD_SETSIZE * 2];
891 size_t i;
892 struct socket_entry *n = entries, *m;
893
894 for (i = 0; i < poller->active.rfds.fd_count; i++) {
895 n->events = POLLIN;
896 n->fd = poller->active.rfds.fd_array[i];
897 n++;
898 }
899
900 m = n;
901 for (i = 0; i < poller->active.wfds.fd_count; i++) {
902 struct socket_entry *e;
903 SOCKET fd = poller->active.wfds.fd_array[i];
904 for (e = entries; e < m; e++) {
905 if (e->fd == fd) {
906 e->events |= POLLOUT;
907 }
908 }
909 if (e == m) {
910 assert(n < entries + FD_SETSIZE * 2);
911 n->events = POLLOUT;
912 n->fd = fd;
913 n++;
914 }
915 }
916
917 {
918 struct socket_entry *e = entries;
919 for (; e < n; e++) {
920 if (SUCCESS != callback(opaque, e->fd, e->events)) {
921 retval = FAILURE;
922 }
923 }
924 }
925
926 #else
927 php_socket_t fd;
928 const php_socket_t max_fd = poller->max_fd;
929
930 for (fd=0 ; fd<=max_fd ; fd++) {
931 if (PHP_SAFE_FD_ISSET(fd, &poller->active.rfds)) {
932 if (SUCCESS != callback(opaque, fd, POLLIN)) {
933 retval = FAILURE;
934 }
935 }
936 if (PHP_SAFE_FD_ISSET(fd, &poller->active.wfds)) {
937 if (SUCCESS != callback(opaque, fd, POLLOUT)) {
938 retval = FAILURE;
939 }
940 }
941 }
942 #endif
943 return retval;
944 } /* }}} */
945
php_cli_server_chunk_size(const php_cli_server_chunk * chunk)946 static size_t php_cli_server_chunk_size(const php_cli_server_chunk *chunk) /* {{{ */
947 {
948 switch (chunk->type) {
949 case PHP_CLI_SERVER_CHUNK_HEAP:
950 return chunk->data.heap.len;
951 case PHP_CLI_SERVER_CHUNK_IMMORTAL:
952 return chunk->data.immortal.len;
953 }
954 return 0;
955 } /* }}} */
956
php_cli_server_chunk_dtor(php_cli_server_chunk * chunk)957 static void php_cli_server_chunk_dtor(php_cli_server_chunk *chunk) /* {{{ */
958 {
959 switch (chunk->type) {
960 case PHP_CLI_SERVER_CHUNK_HEAP:
961 if (chunk->data.heap.block != chunk) {
962 pefree(chunk->data.heap.block, 1);
963 }
964 break;
965 case PHP_CLI_SERVER_CHUNK_IMMORTAL:
966 break;
967 }
968 } /* }}} */
969
php_cli_server_buffer_dtor(php_cli_server_buffer * buffer)970 static void php_cli_server_buffer_dtor(php_cli_server_buffer *buffer) /* {{{ */
971 {
972 php_cli_server_chunk *chunk, *next;
973 for (chunk = buffer->first; chunk; chunk = next) {
974 next = chunk->next;
975 php_cli_server_chunk_dtor(chunk);
976 pefree(chunk, 1);
977 }
978 } /* }}} */
979
php_cli_server_buffer_ctor(php_cli_server_buffer * buffer)980 static void php_cli_server_buffer_ctor(php_cli_server_buffer *buffer) /* {{{ */
981 {
982 buffer->first = NULL;
983 buffer->last = NULL;
984 } /* }}} */
985
php_cli_server_buffer_append(php_cli_server_buffer * buffer,php_cli_server_chunk * chunk)986 static void php_cli_server_buffer_append(php_cli_server_buffer *buffer, php_cli_server_chunk *chunk) /* {{{ */
987 {
988 php_cli_server_chunk *last;
989 for (last = chunk; last->next; last = last->next);
990 if (!buffer->last) {
991 buffer->first = chunk;
992 } else {
993 buffer->last->next = chunk;
994 }
995 buffer->last = last;
996 } /* }}} */
997
php_cli_server_buffer_prepend(php_cli_server_buffer * buffer,php_cli_server_chunk * chunk)998 static void php_cli_server_buffer_prepend(php_cli_server_buffer *buffer, php_cli_server_chunk *chunk) /* {{{ */
999 {
1000 php_cli_server_chunk *last;
1001 for (last = chunk; last->next; last = last->next);
1002 last->next = buffer->first;
1003 if (!buffer->last) {
1004 buffer->last = last;
1005 }
1006 buffer->first = chunk;
1007 } /* }}} */
1008
php_cli_server_buffer_size(const php_cli_server_buffer * buffer)1009 static size_t php_cli_server_buffer_size(const php_cli_server_buffer *buffer) /* {{{ */
1010 {
1011 php_cli_server_chunk *chunk;
1012 size_t retval = 0;
1013 for (chunk = buffer->first; chunk; chunk = chunk->next) {
1014 retval += php_cli_server_chunk_size(chunk);
1015 }
1016 return retval;
1017 } /* }}} */
1018
php_cli_server_chunk_immortal_new(const char * buf,size_t len)1019 static php_cli_server_chunk *php_cli_server_chunk_immortal_new(const char *buf, size_t len) /* {{{ */
1020 {
1021 php_cli_server_chunk *chunk = pemalloc(sizeof(php_cli_server_chunk), 1);
1022
1023 chunk->type = PHP_CLI_SERVER_CHUNK_IMMORTAL;
1024 chunk->next = NULL;
1025 chunk->data.immortal.p = buf;
1026 chunk->data.immortal.len = len;
1027 return chunk;
1028 } /* }}} */
1029
php_cli_server_chunk_heap_new(void * block,char * buf,size_t len)1030 static php_cli_server_chunk *php_cli_server_chunk_heap_new(void *block, char *buf, size_t len) /* {{{ */
1031 {
1032 php_cli_server_chunk *chunk = pemalloc(sizeof(php_cli_server_chunk), 1);
1033
1034 chunk->type = PHP_CLI_SERVER_CHUNK_HEAP;
1035 chunk->next = NULL;
1036 chunk->data.heap.block = block;
1037 chunk->data.heap.p = buf;
1038 chunk->data.heap.len = len;
1039 return chunk;
1040 } /* }}} */
1041
php_cli_server_chunk_heap_new_self_contained(size_t len)1042 static php_cli_server_chunk *php_cli_server_chunk_heap_new_self_contained(size_t len) /* {{{ */
1043 {
1044 php_cli_server_chunk *chunk = pemalloc(sizeof(php_cli_server_chunk) + len, 1);
1045
1046 chunk->type = PHP_CLI_SERVER_CHUNK_HEAP;
1047 chunk->next = NULL;
1048 chunk->data.heap.block = chunk;
1049 chunk->data.heap.p = (char *)(chunk + 1);
1050 chunk->data.heap.len = len;
1051 return chunk;
1052 } /* }}} */
1053
php_cli_server_content_sender_dtor(php_cli_server_content_sender * sender)1054 static void php_cli_server_content_sender_dtor(php_cli_server_content_sender *sender) /* {{{ */
1055 {
1056 php_cli_server_buffer_dtor(&sender->buffer);
1057 } /* }}} */
1058
php_cli_server_content_sender_ctor(php_cli_server_content_sender * sender)1059 static void php_cli_server_content_sender_ctor(php_cli_server_content_sender *sender) /* {{{ */
1060 {
1061 php_cli_server_buffer_ctor(&sender->buffer);
1062 } /* }}} */
1063
php_cli_server_content_sender_send(php_cli_server_content_sender * sender,php_socket_t fd,size_t * nbytes_sent_total)1064 static int php_cli_server_content_sender_send(php_cli_server_content_sender *sender, php_socket_t fd, size_t *nbytes_sent_total) /* {{{ */
1065 {
1066 php_cli_server_chunk *chunk, *next;
1067 size_t _nbytes_sent_total = 0;
1068
1069 for (chunk = sender->buffer.first; chunk; chunk = next) {
1070 #ifdef PHP_WIN32
1071 int nbytes_sent;
1072 #else
1073 ssize_t nbytes_sent;
1074 #endif
1075 next = chunk->next;
1076
1077 switch (chunk->type) {
1078 case PHP_CLI_SERVER_CHUNK_HEAP:
1079 #ifdef PHP_WIN32
1080 nbytes_sent = send(fd, chunk->data.heap.p, (int)chunk->data.heap.len, 0);
1081 #else
1082 nbytes_sent = send(fd, chunk->data.heap.p, chunk->data.heap.len, 0);
1083 #endif
1084 if (nbytes_sent < 0) {
1085 *nbytes_sent_total = _nbytes_sent_total;
1086 return php_socket_errno();
1087 #ifdef PHP_WIN32
1088 } else if (nbytes_sent == chunk->data.heap.len) {
1089 #else
1090 } else if (nbytes_sent == (ssize_t)chunk->data.heap.len) {
1091 #endif
1092 php_cli_server_chunk_dtor(chunk);
1093 pefree(chunk, 1);
1094 sender->buffer.first = next;
1095 if (!next) {
1096 sender->buffer.last = NULL;
1097 }
1098 } else {
1099 chunk->data.heap.p += nbytes_sent;
1100 chunk->data.heap.len -= nbytes_sent;
1101 }
1102 _nbytes_sent_total += nbytes_sent;
1103 break;
1104
1105 case PHP_CLI_SERVER_CHUNK_IMMORTAL:
1106 #ifdef PHP_WIN32
1107 nbytes_sent = send(fd, chunk->data.immortal.p, (int)chunk->data.immortal.len, 0);
1108 #else
1109 nbytes_sent = send(fd, chunk->data.immortal.p, chunk->data.immortal.len, 0);
1110 #endif
1111 if (nbytes_sent < 0) {
1112 *nbytes_sent_total = _nbytes_sent_total;
1113 return php_socket_errno();
1114 #ifdef PHP_WIN32
1115 } else if (nbytes_sent == chunk->data.immortal.len) {
1116 #else
1117 } else if (nbytes_sent == (ssize_t)chunk->data.immortal.len) {
1118 #endif
1119 php_cli_server_chunk_dtor(chunk);
1120 pefree(chunk, 1);
1121 sender->buffer.first = next;
1122 if (!next) {
1123 sender->buffer.last = NULL;
1124 }
1125 } else {
1126 chunk->data.immortal.p += nbytes_sent;
1127 chunk->data.immortal.len -= nbytes_sent;
1128 }
1129 _nbytes_sent_total += nbytes_sent;
1130 break;
1131 }
1132 }
1133 *nbytes_sent_total = _nbytes_sent_total;
1134 return 0;
1135 } /* }}} */
1136
php_cli_server_content_sender_pull(php_cli_server_content_sender * sender,int fd,size_t * nbytes_read)1137 static bool php_cli_server_content_sender_pull(php_cli_server_content_sender *sender, int fd, size_t *nbytes_read) /* {{{ */
1138 {
1139 #ifdef PHP_WIN32
1140 int _nbytes_read;
1141 #else
1142 ssize_t _nbytes_read;
1143 #endif
1144 php_cli_server_chunk *chunk = php_cli_server_chunk_heap_new_self_contained(131072);
1145
1146 #ifdef PHP_WIN32
1147 _nbytes_read = read(fd, chunk->data.heap.p, (unsigned int)chunk->data.heap.len);
1148 #else
1149 _nbytes_read = read(fd, chunk->data.heap.p, chunk->data.heap.len);
1150 #endif
1151 if (_nbytes_read < 0) {
1152 if (php_cli_server_log_level >= PHP_CLI_SERVER_LOG_ERROR) {
1153 char *errstr = get_last_error();
1154 php_cli_server_logf(PHP_CLI_SERVER_LOG_ERROR, "%s", errstr);
1155 pefree(errstr, 1);
1156 }
1157 php_cli_server_chunk_dtor(chunk);
1158 pefree(chunk, 1);
1159 return false;
1160 }
1161 chunk->data.heap.len = _nbytes_read;
1162 php_cli_server_buffer_append(&sender->buffer, chunk);
1163 *nbytes_read = _nbytes_read;
1164 return true;
1165 } /* }}} */
1166
1167 #if HAVE_UNISTD_H
php_cli_is_output_tty(void)1168 static int php_cli_is_output_tty(void) /* {{{ */
1169 {
1170 if (php_cli_output_is_tty == OUTPUT_NOT_CHECKED) {
1171 php_cli_output_is_tty = isatty(STDOUT_FILENO);
1172 }
1173 return php_cli_output_is_tty;
1174 } /* }}} */
1175 #elif defined(PHP_WIN32)
php_cli_is_output_tty()1176 static int php_cli_is_output_tty() /* {{{ */
1177 {
1178 if (php_cli_output_is_tty == OUTPUT_NOT_CHECKED) {
1179 php_cli_output_is_tty = php_win32_console_fileno_is_console(STDOUT_FILENO) && php_win32_console_fileno_has_vt100(STDOUT_FILENO);
1180 }
1181 return php_cli_output_is_tty;
1182 } /* }}} */
1183 #endif
1184
php_cli_server_log_response(php_cli_server_client * client,int status,const char * message)1185 static void php_cli_server_log_response(php_cli_server_client *client, int status, const char *message) /* {{{ */
1186 {
1187 int color = 0, effective_status = status;
1188 char *basic_buf, *message_buf = "", *error_buf = "";
1189 bool append_error_message = 0;
1190
1191 if (PG(last_error_message)) {
1192 if (PG(last_error_type) & E_FATAL_ERRORS) {
1193 if (status == 200) {
1194 /* the status code isn't changed by a fatal error, so fake it */
1195 effective_status = 500;
1196 }
1197
1198 append_error_message = 1;
1199 }
1200 }
1201
1202 #if HAVE_UNISTD_H || defined(PHP_WIN32)
1203 if (CLI_SERVER_G(color) && php_cli_is_output_tty() == OUTPUT_IS_TTY) {
1204 if (effective_status >= 500) {
1205 /* server error: red */
1206 color = 1;
1207 } else if (effective_status >= 400) {
1208 /* client error: yellow */
1209 color = 3;
1210 } else if (effective_status >= 200) {
1211 /* success: green */
1212 color = 2;
1213 }
1214 }
1215 #endif
1216
1217 /* basic */
1218 spprintf(&basic_buf, 0, "%s [%d]: %s %s", ZSTR_VAL(client->addr_str), status,
1219 php_http_method_str(client->request.request_method), ZSTR_VAL(client->request.request_uri));
1220 if (!basic_buf) {
1221 return;
1222 }
1223
1224 /* message */
1225 if (message) {
1226 spprintf(&message_buf, 0, " - %s", message);
1227 if (!message_buf) {
1228 efree(basic_buf);
1229 return;
1230 }
1231 }
1232
1233 /* error */
1234 if (append_error_message) {
1235 spprintf(&error_buf, 0, " - %s in %s on line %d",
1236 ZSTR_VAL(PG(last_error_message)), ZSTR_VAL(PG(last_error_file)), PG(last_error_lineno));
1237 if (!error_buf) {
1238 efree(basic_buf);
1239 if (message) {
1240 efree(message_buf);
1241 }
1242 return;
1243 }
1244 }
1245
1246 if (color) {
1247 php_cli_server_logf(PHP_CLI_SERVER_LOG_MESSAGE, "\x1b[3%dm%s%s%s\x1b[0m", color, basic_buf, message_buf, error_buf);
1248 } else {
1249 php_cli_server_logf(PHP_CLI_SERVER_LOG_MESSAGE, "%s%s%s", basic_buf, message_buf, error_buf);
1250 }
1251
1252 efree(basic_buf);
1253 if (message) {
1254 efree(message_buf);
1255 }
1256 if (append_error_message) {
1257 efree(error_buf);
1258 }
1259 } /* }}} */
1260
php_cli_server_logf(int type,const char * format,...)1261 static void php_cli_server_logf(int type, const char *format, ...) /* {{{ */
1262 {
1263 char *buf = NULL;
1264 va_list ap;
1265
1266 if (php_cli_server_log_level < type) {
1267 return;
1268 }
1269
1270 va_start(ap, format);
1271 vspprintf(&buf, 0, format, ap);
1272 va_end(ap);
1273
1274 if (!buf) {
1275 return;
1276 }
1277
1278 sapi_cli_server_log_write(type, buf);
1279
1280 efree(buf);
1281 } /* }}} */
1282
php_network_listen_socket(const char * host,int * port,int socktype,int * af,socklen_t * socklen,zend_string ** errstr)1283 static php_socket_t php_network_listen_socket(const char *host, int *port, int socktype, int *af, socklen_t *socklen, zend_string **errstr) /* {{{ */
1284 {
1285 php_socket_t retval = SOCK_ERR;
1286 int err = 0;
1287 struct sockaddr *sa = NULL, **p, **sal;
1288
1289 int num_addrs = php_network_getaddresses(host, socktype, &sal, errstr);
1290 if (num_addrs == 0) {
1291 return -1;
1292 }
1293 for (p = sal; *p; p++) {
1294 if (sa) {
1295 pefree(sa, 1);
1296 sa = NULL;
1297 }
1298
1299 retval = socket((*p)->sa_family, socktype, 0);
1300 if (retval == SOCK_ERR) {
1301 continue;
1302 }
1303
1304 switch ((*p)->sa_family) {
1305 #if HAVE_GETADDRINFO && HAVE_IPV6
1306 case AF_INET6:
1307 sa = pemalloc(sizeof(struct sockaddr_in6), 1);
1308 *(struct sockaddr_in6 *)sa = *(struct sockaddr_in6 *)*p;
1309 ((struct sockaddr_in6 *)sa)->sin6_port = htons(*port);
1310 *socklen = sizeof(struct sockaddr_in6);
1311 break;
1312 #endif
1313 case AF_INET:
1314 sa = pemalloc(sizeof(struct sockaddr_in), 1);
1315 *(struct sockaddr_in *)sa = *(struct sockaddr_in *)*p;
1316 ((struct sockaddr_in *)sa)->sin_port = htons(*port);
1317 *socklen = sizeof(struct sockaddr_in);
1318 break;
1319 default:
1320 /* Unknown family */
1321 *socklen = 0;
1322 closesocket(retval);
1323 continue;
1324 }
1325
1326 #ifdef SO_REUSEADDR
1327 {
1328 int val = 1;
1329 setsockopt(retval, SOL_SOCKET, SO_REUSEADDR, (char*)&val, sizeof(val));
1330 }
1331 #endif
1332
1333 if (bind(retval, sa, *socklen) == SOCK_CONN_ERR) {
1334 err = php_socket_errno();
1335 if (err == SOCK_EINVAL || err == SOCK_EADDRINUSE) {
1336 goto out;
1337 }
1338 closesocket(retval);
1339 retval = SOCK_ERR;
1340 continue;
1341 }
1342 err = 0;
1343
1344 *af = sa->sa_family;
1345 if (*port == 0) {
1346 if (getsockname(retval, sa, socklen)) {
1347 err = php_socket_errno();
1348 goto out;
1349 }
1350 switch (sa->sa_family) {
1351 #if HAVE_GETADDRINFO && HAVE_IPV6
1352 case AF_INET6:
1353 *port = ntohs(((struct sockaddr_in6 *)sa)->sin6_port);
1354 break;
1355 #endif
1356 case AF_INET:
1357 *port = ntohs(((struct sockaddr_in *)sa)->sin_port);
1358 break;
1359 }
1360 }
1361
1362 break;
1363 }
1364
1365 if (retval == SOCK_ERR) {
1366 goto out;
1367 }
1368
1369 if (listen(retval, SOMAXCONN)) {
1370 err = php_socket_errno();
1371 goto out;
1372 }
1373
1374 out:
1375 if (sa) {
1376 pefree(sa, 1);
1377 }
1378 if (sal) {
1379 php_network_freeaddresses(sal);
1380 }
1381 if (err) {
1382 if (ZEND_VALID_SOCKET(retval)) {
1383 closesocket(retval);
1384 }
1385 if (errstr) {
1386 *errstr = php_socket_error_str(err);
1387 }
1388 return SOCK_ERR;
1389 }
1390 return retval;
1391 } /* }}} */
1392
php_cli_server_request_ctor(php_cli_server_request * req)1393 static void php_cli_server_request_ctor(php_cli_server_request *req) /* {{{ */
1394 {
1395 req->protocol_version = 0;
1396 req->request_uri = NULL;
1397 req->vpath = NULL;
1398 req->vpath_len = 0;
1399 req->path_translated = NULL;
1400 req->path_translated_len = 0;
1401 req->path_info = NULL;
1402 req->path_info_len = 0;
1403 req->query_string = NULL;
1404 req->query_string_len = 0;
1405 zend_hash_init(&req->headers, 0, NULL, cli_header_value_dtor, 1);
1406 /* No destructor is registered as the value pointed by is the same as for &req->headers */
1407 GC_MAKE_PERSISTENT_LOCAL(&req->headers);
1408 zend_hash_init(&req->headers_original_case, 0, NULL, NULL, 1);
1409 GC_MAKE_PERSISTENT_LOCAL(&req->headers_original_case);
1410 req->content = NULL;
1411 req->content_len = 0;
1412 req->ext = NULL;
1413 req->ext_len = 0;
1414 } /* }}} */
1415
php_cli_server_request_dtor(php_cli_server_request * req)1416 static void php_cli_server_request_dtor(php_cli_server_request *req) /* {{{ */
1417 {
1418 if (req->request_uri) {
1419 zend_string_release_ex(req->request_uri, /* persistent */ true);
1420 }
1421 if (req->vpath) {
1422 pefree(req->vpath, 1);
1423 }
1424 if (req->path_translated) {
1425 pefree(req->path_translated, 1);
1426 }
1427 if (req->path_info) {
1428 pefree(req->path_info, 1);
1429 }
1430 if (req->query_string) {
1431 pefree(req->query_string, 1);
1432 }
1433 zend_hash_destroy(&req->headers);
1434 zend_hash_destroy(&req->headers_original_case);
1435 if (req->content) {
1436 pefree(req->content, 1);
1437 }
1438 } /* }}} */
1439
php_cli_server_request_translate_vpath(php_cli_server_request * request,const char * document_root,size_t document_root_len)1440 static void php_cli_server_request_translate_vpath(php_cli_server_request *request, const char *document_root, size_t document_root_len) /* {{{ */
1441 {
1442 zend_stat_t sb = {0};
1443 static const char *index_files[] = { "index.php", "index.html", NULL };
1444 char *buf = safe_pemalloc(1, request->vpath_len, 1 + document_root_len + 1 + sizeof("index.html"), 1);
1445 char *p = buf, *prev_path = NULL, *q, *vpath;
1446 size_t prev_path_len = 0;
1447 int is_static_file = 0;
1448
1449 memmove(p, document_root, document_root_len);
1450 p += document_root_len;
1451 vpath = p;
1452 if (request->vpath_len != 0) {
1453 if (request->vpath[0] != '/') {
1454 *p++ = DEFAULT_SLASH;
1455 }
1456 q = request->vpath + request->vpath_len;
1457 while (q > request->vpath) {
1458 if (*q-- == '.') {
1459 is_static_file = 1;
1460 break;
1461 }
1462 }
1463 memmove(p, request->vpath, request->vpath_len);
1464 #ifdef PHP_WIN32
1465 q = p + request->vpath_len;
1466 do {
1467 if (*q == '/') {
1468 *q = '\\';
1469 }
1470 } while (q-- > p);
1471 #endif
1472 p += request->vpath_len;
1473 }
1474 *p = '\0';
1475 q = p;
1476 while (q > buf) {
1477 if (!php_sys_stat(buf, &sb)) {
1478 if (sb.st_mode & S_IFDIR) {
1479 const char **file = index_files;
1480 if (q[-1] != DEFAULT_SLASH) {
1481 *q++ = DEFAULT_SLASH;
1482 }
1483 while (*file) {
1484 size_t l = strlen(*file);
1485 memmove(q, *file, l + 1);
1486 if (!php_sys_stat(buf, &sb) && (sb.st_mode & S_IFREG)) {
1487 q += l;
1488 break;
1489 }
1490 file++;
1491 }
1492 if (!*file || is_static_file) {
1493 if (prev_path) {
1494 pefree(prev_path, 1);
1495 }
1496 pefree(buf, 1);
1497 return;
1498 }
1499 }
1500 break; /* regular file */
1501 }
1502 if (prev_path) {
1503 pefree(prev_path, 1);
1504 *q = DEFAULT_SLASH;
1505 }
1506 while (q > buf && *(--q) != DEFAULT_SLASH);
1507 prev_path_len = p - q;
1508 prev_path = pestrndup(q, prev_path_len, 1);
1509 *q = '\0';
1510 }
1511 if (prev_path) {
1512 request->path_info_len = prev_path_len;
1513 #ifdef PHP_WIN32
1514 while (prev_path_len--) {
1515 if (prev_path[prev_path_len] == '\\') {
1516 prev_path[prev_path_len] = '/';
1517 }
1518 }
1519 #endif
1520 request->path_info = prev_path;
1521 pefree(request->vpath, 1);
1522 request->vpath = pestrndup(vpath, q - vpath, 1);
1523 request->vpath_len = q - vpath;
1524 request->path_translated = buf;
1525 request->path_translated_len = q - buf;
1526 } else {
1527 pefree(request->vpath, 1);
1528 request->vpath = pestrndup(vpath, q - vpath, 1);
1529 request->vpath_len = q - vpath;
1530 request->path_translated = buf;
1531 request->path_translated_len = q - buf;
1532 }
1533 #ifdef PHP_WIN32
1534 {
1535 uint32_t i = 0;
1536 for (;i<request->vpath_len;i++) {
1537 if (request->vpath[i] == '\\') {
1538 request->vpath[i] = '/';
1539 }
1540 }
1541 }
1542 #endif
1543 request->sb = sb;
1544 } /* }}} */
1545
normalize_vpath(char ** retval,size_t * retval_len,const char * vpath,size_t vpath_len,int persistent)1546 static void normalize_vpath(char **retval, size_t *retval_len, const char *vpath, size_t vpath_len, int persistent) /* {{{ */
1547 {
1548 char *decoded_vpath = NULL;
1549 char *decoded_vpath_end;
1550 char *p;
1551
1552 *retval = NULL;
1553 *retval_len = 0;
1554
1555 decoded_vpath = pestrndup(vpath, vpath_len, persistent);
1556 if (!decoded_vpath) {
1557 return;
1558 }
1559
1560 decoded_vpath_end = decoded_vpath + php_raw_url_decode(decoded_vpath, (int)vpath_len);
1561
1562 #ifdef PHP_WIN32
1563 {
1564 char *p = decoded_vpath;
1565
1566 do {
1567 if (*p == '\\') {
1568 *p = '/';
1569 }
1570 } while (*p++);
1571 }
1572 #endif
1573
1574 p = decoded_vpath;
1575
1576 if (p < decoded_vpath_end && *p == '/') {
1577 char *n = p;
1578 while (n < decoded_vpath_end && *n == '/') n++;
1579 memmove(++p, n, decoded_vpath_end - n);
1580 decoded_vpath_end -= n - p;
1581 }
1582
1583 while (p < decoded_vpath_end) {
1584 char *n = p;
1585 while (n < decoded_vpath_end && *n != '/') n++;
1586 if (n - p == 2 && p[0] == '.' && p[1] == '.') {
1587 if (p > decoded_vpath) {
1588 --p;
1589 for (;;) {
1590 if (p == decoded_vpath) {
1591 if (*p == '/') {
1592 p++;
1593 }
1594 break;
1595 }
1596 if (*(--p) == '/') {
1597 p++;
1598 break;
1599 }
1600 }
1601 }
1602 while (n < decoded_vpath_end && *n == '/') n++;
1603 memmove(p, n, decoded_vpath_end - n);
1604 decoded_vpath_end -= n - p;
1605 } else if (n - p == 1 && p[0] == '.') {
1606 while (n < decoded_vpath_end && *n == '/') n++;
1607 memmove(p, n, decoded_vpath_end - n);
1608 decoded_vpath_end -= n - p;
1609 } else {
1610 if (n < decoded_vpath_end) {
1611 char *nn = n;
1612 while (nn < decoded_vpath_end && *nn == '/') nn++;
1613 p = n + 1;
1614 memmove(p, nn, decoded_vpath_end - nn);
1615 decoded_vpath_end -= nn - p;
1616 } else {
1617 p = n;
1618 }
1619 }
1620 }
1621
1622 *decoded_vpath_end = '\0';
1623 *retval = decoded_vpath;
1624 *retval_len = decoded_vpath_end - decoded_vpath;
1625 } /* }}} */
1626
1627 // TODO Update these functions and php_http_parser.h
1628 /* {{{ php_cli_server_client_read_request */
php_cli_server_client_read_request_on_message_begin(php_http_parser * parser)1629 static int php_cli_server_client_read_request_on_message_begin(php_http_parser *parser)
1630 {
1631 return 0;
1632 }
1633
php_cli_server_client_read_request_on_path(php_http_parser * parser,const char * at,size_t length)1634 static int php_cli_server_client_read_request_on_path(php_http_parser *parser, const char *at, size_t length)
1635 {
1636 php_cli_server_client *client = parser->data;
1637 {
1638 char *vpath;
1639 size_t vpath_len;
1640 if (UNEXPECTED(client->request.vpath != NULL)) {
1641 return 1;
1642 }
1643 normalize_vpath(&vpath, &vpath_len, at, length, 1);
1644 client->request.vpath = vpath;
1645 client->request.vpath_len = vpath_len;
1646 }
1647 return 0;
1648 }
1649
php_cli_server_client_read_request_on_query_string(php_http_parser * parser,const char * at,size_t length)1650 static int php_cli_server_client_read_request_on_query_string(php_http_parser *parser, const char *at, size_t length)
1651 {
1652 php_cli_server_client *client = parser->data;
1653 if (EXPECTED(client->request.query_string == NULL)) {
1654 client->request.query_string = pestrndup(at, length, 1);
1655 client->request.query_string_len = length;
1656 } else {
1657 ZEND_ASSERT(length <= PHP_HTTP_MAX_HEADER_SIZE && PHP_HTTP_MAX_HEADER_SIZE - length >= client->request.query_string_len);
1658 client->request.query_string = perealloc(client->request.query_string, client->request.query_string_len + length + 1, 1);
1659 memcpy(client->request.query_string + client->request.query_string_len, at, length);
1660 client->request.query_string_len += length;
1661 client->request.query_string[client->request.query_string_len] = '\0';
1662 }
1663 return 0;
1664 }
1665
php_cli_server_client_read_request_on_url(php_http_parser * parser,const char * at,size_t length)1666 static int php_cli_server_client_read_request_on_url(php_http_parser *parser, const char *at, size_t length)
1667 {
1668 php_cli_server_client *client = parser->data;
1669 if (EXPECTED(client->request.request_uri == NULL)) {
1670 client->request.request_method = parser->method;
1671 client->request.request_uri = zend_string_init(at, length, /* persistent */ true);
1672 GC_MAKE_PERSISTENT_LOCAL(client->request.request_uri);
1673 } else {
1674 ZEND_ASSERT(client->request.request_method == parser->method);
1675 ZEND_ASSERT(length <= PHP_HTTP_MAX_HEADER_SIZE && PHP_HTTP_MAX_HEADER_SIZE - length >= client->request.query_string_len);
1676 /* Extend URI, append content to it */
1677 client->request.request_uri = cli_concat_persistent_zstr_with_char(client->request.request_uri, at, length);
1678 }
1679 return 0;
1680 }
1681
php_cli_server_client_read_request_on_fragment(php_http_parser * parser,const char * at,size_t length)1682 static int php_cli_server_client_read_request_on_fragment(php_http_parser *parser, const char *at, size_t length)
1683 {
1684 return 0;
1685 }
1686
php_cli_server_client_save_header(php_cli_server_client * client)1687 static void php_cli_server_client_save_header(php_cli_server_client *client)
1688 {
1689 /* Wrap header value in a zval to add is to the HashTable which acts as an array */
1690 zval tmp;
1691 ZVAL_STR(&tmp, client->current_header_value);
1692 /* strip off the colon */
1693 zend_string *lc_header_name = zend_string_tolower_ex(client->current_header_name, /* persistent */ true);
1694 GC_MAKE_PERSISTENT_LOCAL(lc_header_name);
1695
1696 /* Add the wrapped zend_string to the HashTable */
1697 zend_hash_add(&client->request.headers, lc_header_name, &tmp);
1698 zend_hash_add(&client->request.headers_original_case, client->current_header_name, &tmp);
1699
1700 zend_string_release_ex(lc_header_name, /* persistent */ true);
1701 zend_string_release_ex(client->current_header_name, /* persistent */ true);
1702
1703 client->current_header_name = NULL;
1704 client->current_header_value = NULL;
1705 }
1706
cli_concat_persistent_zstr_with_char(zend_string * old_str,const char * at,size_t length)1707 static zend_string* cli_concat_persistent_zstr_with_char(zend_string *old_str, const char *at, size_t length)
1708 {
1709 /* Assert that there is only one reference to the string, as then zend_string_extends()
1710 * will reallocate it such that we do not need to release the old value. */
1711 ZEND_ASSERT(GC_REFCOUNT(old_str) == 1);
1712 /* Previous element was part of header value, append content to it */
1713 size_t old_length = ZSTR_LEN(old_str);
1714 zend_string *str = zend_string_extend(old_str, old_length + length, /* persistent */ true);
1715 memcpy(ZSTR_VAL(str) + old_length, at, length);
1716 // Null terminate
1717 ZSTR_VAL(str)[ZSTR_LEN(str)] = '\0';
1718 return str;
1719 }
1720
php_cli_server_client_read_request_on_header_field(php_http_parser * parser,const char * at,size_t length)1721 static int php_cli_server_client_read_request_on_header_field(php_http_parser *parser, const char *at, size_t length)
1722 {
1723 php_cli_server_client *client = parser->data;
1724 switch (client->last_header_element) {
1725 case HEADER_VALUE:
1726 /* Save previous header before creating new one */
1727 php_cli_server_client_save_header(client);
1728 ZEND_FALLTHROUGH;
1729 case HEADER_NONE:
1730 /* Create new header field */
1731 client->current_header_name = zend_string_init(at, length, /* persistent */ true);
1732 GC_MAKE_PERSISTENT_LOCAL(client->current_header_name);
1733 break;
1734 case HEADER_FIELD: {
1735 /* Append header name to the previous value of it */
1736 client->current_header_name = cli_concat_persistent_zstr_with_char(client->current_header_name, at, length);
1737 break;
1738 }
1739 }
1740
1741 client->last_header_element = HEADER_FIELD;
1742 return 0;
1743 }
1744
php_cli_server_client_read_request_on_header_value(php_http_parser * parser,const char * at,size_t length)1745 static int php_cli_server_client_read_request_on_header_value(php_http_parser *parser, const char *at, size_t length)
1746 {
1747 php_cli_server_client *client = parser->data;
1748 switch (client->last_header_element) {
1749 case HEADER_FIELD:
1750 /* Previous element was the header field, create the header value */
1751 client->current_header_value = zend_string_init(at, length, /* persistent */ true);
1752 GC_MAKE_PERSISTENT_LOCAL(client->current_header_value);
1753 break;
1754 case HEADER_VALUE: {
1755 /* Append header value to the previous value of it */
1756 client->current_header_value = cli_concat_persistent_zstr_with_char(client->current_header_value, at, length);
1757 break;
1758 }
1759 case HEADER_NONE:
1760 /* Cannot happen as a header field must have been found before */
1761 assert(0);
1762 break;
1763 }
1764 client->last_header_element = HEADER_VALUE;
1765 return 0;
1766 }
1767
php_cli_server_client_read_request_on_headers_complete(php_http_parser * parser)1768 static int php_cli_server_client_read_request_on_headers_complete(php_http_parser *parser)
1769 {
1770 php_cli_server_client *client = parser->data;
1771 switch (client->last_header_element) {
1772 case HEADER_NONE:
1773 break;
1774 case HEADER_FIELD:
1775 /* Previous element was the header field, set it's value to an empty string */
1776 client->current_header_value = ZSTR_EMPTY_ALLOC();
1777 ZEND_FALLTHROUGH;
1778 case HEADER_VALUE:
1779 /* Save last header value */
1780 php_cli_server_client_save_header(client);
1781 break;
1782 }
1783 client->last_header_element = HEADER_NONE;
1784 return 0;
1785 }
1786
php_cli_server_client_read_request_on_body(php_http_parser * parser,const char * at,size_t length)1787 static int php_cli_server_client_read_request_on_body(php_http_parser *parser, const char *at, size_t length)
1788 {
1789 php_cli_server_client *client = parser->data;
1790 if (!client->request.content) {
1791 client->request.content = pemalloc(parser->content_length, 1);
1792 client->request.content_len = 0;
1793 }
1794 client->request.content = perealloc(client->request.content, client->request.content_len + length, 1);
1795 memmove(client->request.content + client->request.content_len, at, length);
1796 client->request.content_len += length;
1797 return 0;
1798 }
1799
php_cli_server_client_read_request_on_message_complete(php_http_parser * parser)1800 static int php_cli_server_client_read_request_on_message_complete(php_http_parser *parser)
1801 {
1802 php_cli_server_client *client = parser->data;
1803 client->request.protocol_version = parser->http_major * 100 + parser->http_minor;
1804 php_cli_server_request_translate_vpath(&client->request, client->server->document_root, client->server->document_root_len);
1805 if (client->request.vpath) {
1806 const char *vpath = client->request.vpath;
1807 const char *end = vpath + client->request.vpath_len;
1808 const char *p = end;
1809 client->request.ext = end;
1810 client->request.ext_len = 0;
1811 while (p > vpath) {
1812 --p;
1813 if (*p == '.') {
1814 ++p;
1815 client->request.ext = p;
1816 client->request.ext_len = end - p;
1817 break;
1818 }
1819 }
1820 }
1821 client->request_read = true;
1822 return 0;
1823 }
1824
1825 /* Returns:
1826 -1 when an error occurs
1827 0 when the request has not been read (try again?)
1828 1 when the request has been read
1829 */
php_cli_server_client_read_request(php_cli_server_client * client,char ** errstr)1830 static int php_cli_server_client_read_request(php_cli_server_client *client, char **errstr)
1831 {
1832 char buf[16384];
1833 static const php_http_parser_settings settings = {
1834 php_cli_server_client_read_request_on_message_begin,
1835 php_cli_server_client_read_request_on_path,
1836 php_cli_server_client_read_request_on_query_string,
1837 php_cli_server_client_read_request_on_url,
1838 php_cli_server_client_read_request_on_fragment,
1839 php_cli_server_client_read_request_on_header_field,
1840 php_cli_server_client_read_request_on_header_value,
1841 php_cli_server_client_read_request_on_headers_complete,
1842 php_cli_server_client_read_request_on_body,
1843 php_cli_server_client_read_request_on_message_complete
1844 };
1845 size_t nbytes_consumed;
1846 int nbytes_read;
1847 if (client->request_read) {
1848 return 1;
1849 }
1850 nbytes_read = recv(client->sock, buf, sizeof(buf) - 1, 0);
1851 if (nbytes_read < 0) {
1852 int err = php_socket_errno();
1853 if (err == SOCK_EAGAIN) {
1854 return 0;
1855 }
1856
1857 if (php_cli_server_log_level >= PHP_CLI_SERVER_LOG_ERROR) {
1858 *errstr = php_socket_strerror(err, NULL, 0);
1859 }
1860
1861 return -1;
1862 } else if (nbytes_read == 0) {
1863 if (php_cli_server_log_level >= PHP_CLI_SERVER_LOG_ERROR) {
1864 *errstr = estrdup(php_cli_server_request_error_unexpected_eof);
1865 }
1866
1867 return -1;
1868 }
1869 client->parser.data = client;
1870 nbytes_consumed = php_http_parser_execute(&client->parser, &settings, buf, nbytes_read);
1871 if (nbytes_consumed != (size_t)nbytes_read) {
1872 if (php_cli_server_log_level >= PHP_CLI_SERVER_LOG_ERROR) {
1873 if ((buf[0] & 0x80) /* SSLv2 */ || buf[0] == 0x16 /* SSLv3/TLSv1 */) {
1874 *errstr = estrdup("Unsupported SSL request");
1875 } else {
1876 *errstr = estrdup("Malformed HTTP request");
1877 }
1878 }
1879
1880 return -1;
1881 }
1882
1883 return client->request_read ? 1: 0;
1884 }
1885 /* }}} */
1886
php_cli_server_client_send_through(php_cli_server_client * client,const char * str,size_t str_len)1887 static size_t php_cli_server_client_send_through(php_cli_server_client *client, const char *str, size_t str_len) /* {{{ */
1888 {
1889 struct timeval tv = { 10, 0 };
1890 #ifdef PHP_WIN32
1891 int nbytes_left = (int)str_len;
1892 #else
1893 ssize_t nbytes_left = (ssize_t)str_len;
1894 #endif
1895 do {
1896 #ifdef PHP_WIN32
1897 int nbytes_sent;
1898 #else
1899 ssize_t nbytes_sent;
1900 #endif
1901
1902 nbytes_sent = send(client->sock, str + str_len - nbytes_left, nbytes_left, 0);
1903 if (nbytes_sent < 0) {
1904 int err = php_socket_errno();
1905 if (err == SOCK_EAGAIN) {
1906 int nfds = php_pollfd_for(client->sock, POLLOUT, &tv);
1907 if (nfds > 0) {
1908 continue;
1909 } else {
1910 /* error or timeout */
1911 php_handle_aborted_connection();
1912 return nbytes_left;
1913 }
1914 } else {
1915 php_handle_aborted_connection();
1916 return nbytes_left;
1917 }
1918 }
1919 nbytes_left -= nbytes_sent;
1920 } while (nbytes_left > 0);
1921
1922 return str_len;
1923 } /* }}} */
1924
php_cli_server_client_populate_request_info(const php_cli_server_client * client,sapi_request_info * request_info)1925 static void php_cli_server_client_populate_request_info(const php_cli_server_client *client, sapi_request_info *request_info) /* {{{ */
1926 {
1927 zval *val;
1928
1929 request_info->request_method = php_http_method_str(client->request.request_method);
1930 request_info->proto_num = client->request.protocol_version;
1931 request_info->request_uri = ZSTR_VAL(client->request.request_uri);
1932 request_info->path_translated = client->request.path_translated;
1933 request_info->query_string = client->request.query_string;
1934 request_info->content_length = client->request.content_len;
1935 request_info->auth_user = request_info->auth_password = request_info->auth_digest = NULL;
1936 if (NULL != (val = zend_hash_str_find(&client->request.headers, "content-type", sizeof("content-type")-1))) {
1937 request_info->content_type = Z_STRVAL_P(val);
1938 }
1939 } /* }}} */
1940
1941 // TODO Remove?
destroy_request_info(sapi_request_info * request_info)1942 static void destroy_request_info(sapi_request_info *request_info) /* {{{ */
1943 {
1944 } /* }}} */
1945
php_cli_server_client_ctor(php_cli_server_client * client,php_cli_server * server,php_socket_t client_sock,struct sockaddr * addr,socklen_t addr_len)1946 static void php_cli_server_client_ctor(php_cli_server_client *client, php_cli_server *server, php_socket_t client_sock, struct sockaddr *addr, socklen_t addr_len) /* {{{ */
1947 {
1948 client->server = server;
1949 client->sock = client_sock;
1950 client->addr = addr;
1951 client->addr_len = addr_len;
1952
1953 // TODO To prevent the reallocation need to retrieve a persistent string
1954 // Create a new php_network_populate_name_from_sockaddr_ex() API with a persistent flag?
1955 zend_string *tmp_addr = NULL;
1956 php_network_populate_name_from_sockaddr(addr, addr_len, &tmp_addr, NULL, 0);
1957 client->addr_str = zend_string_dup(tmp_addr, /* persistent */ true);
1958 GC_MAKE_PERSISTENT_LOCAL(client->addr_str);
1959 zend_string_release_ex(tmp_addr, /* persistent */ false);
1960
1961 php_http_parser_init(&client->parser, PHP_HTTP_REQUEST);
1962 client->request_read = false;
1963
1964 client->last_header_element = HEADER_NONE;
1965 client->current_header_name = NULL;
1966 client->current_header_value = NULL;
1967
1968 client->post_read_offset = 0;
1969
1970 php_cli_server_request_ctor(&client->request);
1971
1972 client->content_sender_initialized = false;
1973 client->file_fd = -1;
1974 } /* }}} */
1975
php_cli_server_client_dtor(php_cli_server_client * client)1976 static void php_cli_server_client_dtor(php_cli_server_client *client) /* {{{ */
1977 {
1978 php_cli_server_request_dtor(&client->request);
1979 if (client->file_fd >= 0) {
1980 close(client->file_fd);
1981 client->file_fd = -1;
1982 }
1983 pefree(client->addr, 1);
1984 zend_string_release_ex(client->addr_str, /* persistent */ true);
1985
1986 if (client->content_sender_initialized) {
1987 /* Headers must be set if we reached the content initialisation */
1988 assert(client->current_header_name == NULL);
1989 assert(client->current_header_value == NULL);
1990 php_cli_server_content_sender_dtor(&client->content_sender);
1991 }
1992 } /* }}} */
1993
php_cli_server_close_connection(php_cli_server * server,php_cli_server_client * client)1994 static void php_cli_server_close_connection(php_cli_server *server, php_cli_server_client *client) /* {{{ */
1995 {
1996 php_cli_server_logf(PHP_CLI_SERVER_LOG_MESSAGE, "%s Closing", ZSTR_VAL(client->addr_str));
1997
1998 zend_hash_index_del(&server->clients, client->sock);
1999 } /* }}} */
2000
php_cli_server_send_error_page(php_cli_server * server,php_cli_server_client * client,int status)2001 static zend_result php_cli_server_send_error_page(php_cli_server *server, php_cli_server_client *client, int status) /* {{{ */
2002 {
2003 zend_string *escaped_request_uri = NULL;
2004 const char *status_string = get_status_string(status);
2005 const char *content_template = get_template_string(status);
2006 char *errstr = get_last_error();
2007 assert(status_string && content_template);
2008
2009 php_cli_server_content_sender_ctor(&client->content_sender);
2010 client->content_sender_initialized = true;
2011
2012 if (client->request.request_method != PHP_HTTP_HEAD) {
2013 escaped_request_uri = php_escape_html_entities_ex((const unsigned char *) ZSTR_VAL(client->request.request_uri), ZSTR_LEN(client->request.request_uri), 0, ENT_QUOTES, NULL, /* double_encode */ 0, /* quiet */ 0);
2014
2015 {
2016 static const char prologue_template[] = "<!doctype html><html><head><title>%d %s</title>";
2017 php_cli_server_chunk *chunk = php_cli_server_chunk_heap_new_self_contained(strlen(prologue_template) + 3 + strlen(status_string) + 1);
2018 if (!chunk) {
2019 goto fail;
2020 }
2021 snprintf(chunk->data.heap.p, chunk->data.heap.len, prologue_template, status, status_string);
2022 chunk->data.heap.len = strlen(chunk->data.heap.p);
2023 php_cli_server_buffer_append(&client->content_sender.buffer, chunk);
2024 }
2025 {
2026 php_cli_server_chunk *chunk = php_cli_server_chunk_immortal_new(php_cli_server_css, sizeof(php_cli_server_css) - 1);
2027 if (!chunk) {
2028 goto fail;
2029 }
2030 php_cli_server_buffer_append(&client->content_sender.buffer, chunk);
2031 }
2032 {
2033 static const char template[] = "</head><body>";
2034 php_cli_server_chunk *chunk = php_cli_server_chunk_immortal_new(template, sizeof(template) - 1);
2035 if (!chunk) {
2036 goto fail;
2037 }
2038 php_cli_server_buffer_append(&client->content_sender.buffer, chunk);
2039 }
2040 {
2041 php_cli_server_chunk *chunk = php_cli_server_chunk_heap_new_self_contained(strlen(content_template) + ZSTR_LEN(escaped_request_uri) + 3 + strlen(status_string) + 1);
2042 if (!chunk) {
2043 goto fail;
2044 }
2045 snprintf(chunk->data.heap.p, chunk->data.heap.len, content_template, status_string, ZSTR_VAL(escaped_request_uri));
2046 chunk->data.heap.len = strlen(chunk->data.heap.p);
2047 php_cli_server_buffer_append(&client->content_sender.buffer, chunk);
2048 }
2049 {
2050 static const char epilogue_template[] = "</body></html>";
2051 php_cli_server_chunk *chunk = php_cli_server_chunk_immortal_new(epilogue_template, sizeof(epilogue_template) - 1);
2052 if (!chunk) {
2053 goto fail;
2054 }
2055 php_cli_server_buffer_append(&client->content_sender.buffer, chunk);
2056 }
2057 }
2058
2059 {
2060 php_cli_server_chunk *chunk;
2061 smart_str buffer = { 0 };
2062 append_http_status_line(&buffer, client->request.protocol_version, status, 1);
2063 if (!buffer.s) {
2064 /* out of memory */
2065 goto fail;
2066 }
2067 append_essential_headers(&buffer, client, 1, NULL);
2068 smart_str_appends_ex(&buffer, "Content-Type: text/html; charset=UTF-8\r\n", 1);
2069 smart_str_appends_ex(&buffer, "Content-Length: ", 1);
2070 smart_str_append_unsigned_ex(&buffer, php_cli_server_buffer_size(&client->content_sender.buffer), 1);
2071 smart_str_appendl_ex(&buffer, "\r\n", 2, 1);
2072 if (status == 405) {
2073 smart_str_appends_ex(&buffer, "Allow: ", 1);
2074 smart_str_appends_ex(&buffer, php_http_method_str(PHP_HTTP_GET), 1);
2075 smart_str_appends_ex(&buffer, ", ", 1);
2076 smart_str_appends_ex(&buffer, php_http_method_str(PHP_HTTP_HEAD), 1);
2077 smart_str_appends_ex(&buffer, ", ", 1);
2078 smart_str_appends_ex(&buffer, php_http_method_str(PHP_HTTP_POST), 1);
2079 smart_str_appendl_ex(&buffer, "\r\n", 2, 1);
2080 }
2081 smart_str_appendl_ex(&buffer, "\r\n", 2, 1);
2082
2083 chunk = php_cli_server_chunk_heap_new(buffer.s, ZSTR_VAL(buffer.s), ZSTR_LEN(buffer.s));
2084 if (!chunk) {
2085 smart_str_free_ex(&buffer, 1);
2086 goto fail;
2087 }
2088 php_cli_server_buffer_prepend(&client->content_sender.buffer, chunk);
2089 }
2090
2091 php_cli_server_log_response(client, status, errstr ? errstr : "?");
2092 php_cli_server_poller_add(&server->poller, POLLOUT, client->sock);
2093 if (errstr) {
2094 pefree(errstr, 1);
2095 }
2096 if (escaped_request_uri) {
2097 zend_string_free(escaped_request_uri);
2098 }
2099 return SUCCESS;
2100
2101 fail:
2102 if (errstr) {
2103 pefree(errstr, 1);
2104 }
2105 if (escaped_request_uri) {
2106 zend_string_free(escaped_request_uri);
2107 }
2108 return FAILURE;
2109 } /* }}} */
2110
php_cli_server_dispatch_script(php_cli_server * server,php_cli_server_client * client)2111 static zend_result php_cli_server_dispatch_script(php_cli_server *server, php_cli_server_client *client) /* {{{ */
2112 {
2113 if (strlen(client->request.path_translated) != client->request.path_translated_len) {
2114 /* can't handle paths that contain nul bytes */
2115 return php_cli_server_send_error_page(server, client, 400);
2116 }
2117
2118 zend_file_handle zfd;
2119 zend_stream_init_filename(&zfd, SG(request_info).path_translated);
2120 zfd.primary_script = 1;
2121 zend_try {
2122 php_execute_script(&zfd);
2123 } zend_end_try();
2124 zend_destroy_file_handle(&zfd);
2125
2126 php_cli_server_log_response(client, SG(sapi_headers).http_response_code, NULL);
2127 return SUCCESS;
2128 } /* }}} */
2129
php_cli_server_begin_send_static(php_cli_server * server,php_cli_server_client * client)2130 static zend_result php_cli_server_begin_send_static(php_cli_server *server, php_cli_server_client *client) /* {{{ */
2131 {
2132 int fd;
2133 int status = 200;
2134
2135 if (client->request.request_method == PHP_HTTP_DELETE
2136 || client->request.request_method == PHP_HTTP_PUT
2137 || client->request.request_method == PHP_HTTP_PATCH) {
2138 return php_cli_server_send_error_page(server, client, 405);
2139 }
2140
2141 if (client->request.path_translated && strlen(client->request.path_translated) != client->request.path_translated_len) {
2142 /* can't handle paths that contain nul bytes */
2143 return php_cli_server_send_error_page(server, client, 400);
2144 }
2145
2146 #ifdef PHP_WIN32
2147 /* The win32 namespace will cut off trailing dots and spaces. Since the
2148 VCWD functionality isn't used here, a sophisticated functionality
2149 would have to be reimplemented to know ahead there are no files
2150 with invalid names there. The simplest is just to forbid invalid
2151 filenames, which is done here. */
2152 if (client->request.path_translated &&
2153 ('.' == client->request.path_translated[client->request.path_translated_len-1] ||
2154 ' ' == client->request.path_translated[client->request.path_translated_len-1])) {
2155 return php_cli_server_send_error_page(server, client, 500);
2156 }
2157
2158 fd = client->request.path_translated ? php_win32_ioutil_open(client->request.path_translated, O_RDONLY): -1;
2159 #else
2160 fd = client->request.path_translated ? open(client->request.path_translated, O_RDONLY): -1;
2161 #endif
2162 if (fd < 0) {
2163 return php_cli_server_send_error_page(server, client, 404);
2164 }
2165
2166 php_cli_server_content_sender_ctor(&client->content_sender);
2167 client->content_sender_initialized = true;
2168 if (client->request.request_method != PHP_HTTP_HEAD) {
2169 client->file_fd = fd;
2170 }
2171
2172 {
2173 php_cli_server_chunk *chunk;
2174 smart_str buffer = { 0 };
2175 const char *mime_type = get_mime_type(server, client->request.ext, client->request.ext_len);
2176
2177 append_http_status_line(&buffer, client->request.protocol_version, status, 1);
2178 if (!buffer.s) {
2179 /* out of memory */
2180 php_cli_server_log_response(client, 500, NULL);
2181 return FAILURE;
2182 }
2183 append_essential_headers(&buffer, client, 1, NULL);
2184 if (mime_type) {
2185 smart_str_appendl_ex(&buffer, "Content-Type: ", sizeof("Content-Type: ") - 1, 1);
2186 smart_str_appends_ex(&buffer, mime_type, 1);
2187 if (strncmp(mime_type, "text/", 5) == 0) {
2188 smart_str_appends_ex(&buffer, "; charset=UTF-8", 1);
2189 }
2190 smart_str_appendl_ex(&buffer, "\r\n", 2, 1);
2191 }
2192 smart_str_appends_ex(&buffer, "Content-Length: ", 1);
2193 smart_str_append_unsigned_ex(&buffer, client->request.sb.st_size, 1);
2194 smart_str_appendl_ex(&buffer, "\r\n", 2, 1);
2195 smart_str_appendl_ex(&buffer, "\r\n", 2, 1);
2196 chunk = php_cli_server_chunk_heap_new(buffer.s, ZSTR_VAL(buffer.s), ZSTR_LEN(buffer.s));
2197 if (!chunk) {
2198 smart_str_free_ex(&buffer, 1);
2199 php_cli_server_log_response(client, 500, NULL);
2200 return FAILURE;
2201 }
2202 php_cli_server_buffer_append(&client->content_sender.buffer, chunk);
2203 }
2204 php_cli_server_log_response(client, 200, NULL);
2205 php_cli_server_poller_add(&server->poller, POLLOUT, client->sock);
2206 return SUCCESS;
2207 }
2208 /* }}} */
2209
php_cli_server_request_startup(php_cli_server * server,php_cli_server_client * client)2210 static zend_result php_cli_server_request_startup(php_cli_server *server, php_cli_server_client *client) { /* {{{ */
2211 zval *auth;
2212 php_cli_server_client_populate_request_info(client, &SG(request_info));
2213 if (NULL != (auth = zend_hash_str_find(&client->request.headers, "authorization", sizeof("authorization")-1))) {
2214 php_handle_auth_data(Z_STRVAL_P(auth));
2215 }
2216 SG(sapi_headers).http_response_code = 200;
2217 if (FAILURE == php_request_startup()) {
2218 return FAILURE;
2219 }
2220 PG(during_request_startup) = 0;
2221
2222 return SUCCESS;
2223 }
2224 /* }}} */
2225
php_cli_server_request_shutdown(php_cli_server * server,php_cli_server_client * client)2226 static void php_cli_server_request_shutdown(php_cli_server *server, php_cli_server_client *client) { /* {{{ */
2227 php_request_shutdown(0);
2228 php_cli_server_close_connection(server, client);
2229 destroy_request_info(&SG(request_info));
2230 SG(server_context) = NULL;
2231 SG(rfc1867_uploaded_files) = NULL;
2232 }
2233 /* }}} */
2234
php_cli_server_dispatch_router(php_cli_server * server,php_cli_server_client * client)2235 static bool php_cli_server_dispatch_router(php_cli_server *server, php_cli_server_client *client) /* {{{ */
2236 {
2237 bool decline = false;
2238 zend_file_handle zfd;
2239 char *old_cwd;
2240
2241 ALLOCA_FLAG(use_heap)
2242 old_cwd = do_alloca(MAXPATHLEN, use_heap);
2243 old_cwd[0] = '\0';
2244 php_ignore_value(VCWD_GETCWD(old_cwd, MAXPATHLEN - 1));
2245
2246 zend_stream_init_filename(&zfd, server->router);
2247 zfd.primary_script = 1;
2248
2249 zend_try {
2250 zval retval;
2251
2252 /* Normally php_execute_script restarts the timer with max_execution_time if it has
2253 * previously been initialized with max_input_time. We're not using php_execute_script here
2254 * because it does not provide a way to get the return value of the main script, so we need
2255 * to restart the timer manually. */
2256 if (PG(max_input_time) != -1) {
2257 #ifdef PHP_WIN32
2258 zend_unset_timeout();
2259 #endif
2260 zend_set_timeout(INI_INT("max_execution_time"), 0);
2261 }
2262
2263 ZVAL_UNDEF(&retval);
2264 if (SUCCESS == zend_execute_scripts(ZEND_REQUIRE, &retval, 1, &zfd)) {
2265 if (Z_TYPE(retval) != IS_UNDEF) {
2266 decline = Z_TYPE(retval) == IS_FALSE;
2267 zval_ptr_dtor(&retval);
2268 }
2269 }
2270 } zend_end_try();
2271
2272 zend_destroy_file_handle(&zfd);
2273
2274 if (old_cwd[0] != '\0') {
2275 php_ignore_value(VCWD_CHDIR(old_cwd));
2276 }
2277
2278 free_alloca(old_cwd, use_heap);
2279
2280 return decline;
2281 }
2282 /* }}} */
2283
php_cli_server_dispatch(php_cli_server * server,php_cli_server_client * client)2284 static zend_result php_cli_server_dispatch(php_cli_server *server, php_cli_server_client *client) /* {{{ */
2285 {
2286 int is_static_file = 0;
2287 const char *ext = client->request.ext;
2288
2289 SG(server_context) = client;
2290 if (client->request.ext_len != 3
2291 || (ext[0] != 'p' && ext[0] != 'P') || (ext[1] != 'h' && ext[1] != 'H') || (ext[2] != 'p' && ext[2] != 'P')
2292 || !client->request.path_translated) {
2293 is_static_file = 1;
2294 }
2295
2296 if (server->router || !is_static_file) {
2297 if (FAILURE == php_cli_server_request_startup(server, client)) {
2298 php_cli_server_request_shutdown(server, client);
2299 return FAILURE;
2300 }
2301 }
2302
2303 if (server->router) {
2304 if (!php_cli_server_dispatch_router(server, client)) {
2305 php_cli_server_request_shutdown(server, client);
2306 return SUCCESS;
2307 }
2308 }
2309
2310 if (!is_static_file) {
2311 // TODO What?
2312 if (SUCCESS == php_cli_server_dispatch_script(server, client)
2313 || FAILURE == php_cli_server_send_error_page(server, client, 500)) {
2314 if (SG(sapi_headers).http_response_code == 304) {
2315 SG(sapi_headers).send_default_content_type = 0;
2316 }
2317 php_cli_server_request_shutdown(server, client);
2318 return SUCCESS;
2319 }
2320 } else {
2321 if (server->router) {
2322 static int (*send_header_func)(sapi_headers_struct *);
2323 send_header_func = sapi_module.send_headers;
2324 /* do not generate default content type header */
2325 SG(sapi_headers).send_default_content_type = 0;
2326 /* we don't want headers to be sent */
2327 sapi_module.send_headers = sapi_cli_server_discard_headers;
2328 php_request_shutdown(0);
2329 sapi_module.send_headers = send_header_func;
2330 SG(sapi_headers).send_default_content_type = 1;
2331 SG(rfc1867_uploaded_files) = NULL;
2332 }
2333 if (FAILURE == php_cli_server_begin_send_static(server, client)) {
2334 php_cli_server_close_connection(server, client);
2335 }
2336 SG(server_context) = NULL;
2337 return SUCCESS;
2338 }
2339
2340 SG(server_context) = NULL;
2341 destroy_request_info(&SG(request_info));
2342 return SUCCESS;
2343 }
2344 /* }}} */
2345
php_cli_server_mime_type_ctor(php_cli_server * server,const php_cli_server_ext_mime_type_pair * mime_type_map)2346 static void php_cli_server_mime_type_ctor(php_cli_server *server, const php_cli_server_ext_mime_type_pair *mime_type_map) /* {{{ */
2347 {
2348 const php_cli_server_ext_mime_type_pair *pair;
2349
2350 zend_hash_init(&server->extension_mime_types, 0, NULL, NULL, 1);
2351 GC_MAKE_PERSISTENT_LOCAL(&server->extension_mime_types);
2352
2353 for (pair = mime_type_map; pair->ext; pair++) {
2354 size_t ext_len = strlen(pair->ext);
2355 zend_hash_str_add_ptr(&server->extension_mime_types, pair->ext, ext_len, (void*)pair->mime_type);
2356 }
2357 } /* }}} */
2358
php_cli_server_dtor(php_cli_server * server)2359 static void php_cli_server_dtor(php_cli_server *server) /* {{{ */
2360 {
2361 zend_hash_destroy(&server->clients);
2362 zend_hash_destroy(&server->extension_mime_types);
2363 if (ZEND_VALID_SOCKET(server->server_sock)) {
2364 closesocket(server->server_sock);
2365 }
2366 if (server->host) {
2367 pefree(server->host, 1);
2368 }
2369 if (server->document_root) {
2370 pefree(server->document_root, 1);
2371 }
2372 if (server->router) {
2373 pefree(server->router, 1);
2374 }
2375 #if HAVE_FORK
2376 if (php_cli_server_workers_max > 1 &&
2377 php_cli_server_workers &&
2378 getpid() == php_cli_server_master) {
2379 zend_long php_cli_server_worker;
2380
2381 for (php_cli_server_worker = 0;
2382 php_cli_server_worker < php_cli_server_workers_max;
2383 php_cli_server_worker++) {
2384 int php_cli_server_worker_status;
2385
2386 do {
2387 if (waitpid(php_cli_server_workers[php_cli_server_worker],
2388 &php_cli_server_worker_status,
2389 0) == FAILURE) {
2390 /* an extremely bad thing happened */
2391 break;
2392 }
2393
2394 } while (!WIFEXITED(php_cli_server_worker_status) &&
2395 !WIFSIGNALED(php_cli_server_worker_status));
2396 }
2397
2398 pefree(php_cli_server_workers, 1);
2399 }
2400 #endif
2401 } /* }}} */
2402
php_cli_server_client_dtor_wrapper(zval * zv)2403 static void php_cli_server_client_dtor_wrapper(zval *zv) /* {{{ */
2404 {
2405 php_cli_server_client *p = Z_PTR_P(zv);
2406
2407 shutdown(p->sock, SHUT_RDWR);
2408 closesocket(p->sock);
2409 php_cli_server_poller_remove(&p->server->poller, POLLIN | POLLOUT, p->sock);
2410 php_cli_server_client_dtor(p);
2411 pefree(p, 1);
2412 } /* }}} */
2413
2414 /**
2415 * Parse the host and port portions of an address specifier in
2416 * one of the following forms:
2417 * - hostOrIP:port
2418 * - [hostOrIP]:port
2419 */
php_cli_server_parse_addr(const char * addr,int * pport)2420 static char *php_cli_server_parse_addr(const char *addr, int *pport) {
2421 const char *p, *end;
2422 long port;
2423
2424 if (addr[0] == '[') {
2425 /* Encapsulated [hostOrIP]:port */
2426 const char *start = addr + 1;
2427 end = strchr(start, ']');
2428 if (!end) {
2429 /* No ending ] delimiter to match [ */
2430 return NULL;
2431 }
2432
2433 p = end + 1;
2434 if (*p != ':') {
2435 /* Invalid char following address/missing port */
2436 return NULL;
2437 }
2438
2439 port = strtol(p + 1, (char**)&p, 10);
2440 if (p && *p) {
2441 /* Non-numeric in port */
2442 return NULL;
2443 }
2444 if (port < 0 || port > 65535) {
2445 /* Invalid port */
2446 return NULL;
2447 }
2448
2449 /* Full [hostOrIP]:port provided */
2450 *pport = (int)port;
2451 return pestrndup(start, end - start, 1);
2452 }
2453
2454 end = strchr(addr, ':');
2455 if (!end) {
2456 /* Missing port */
2457 return NULL;
2458 }
2459
2460 port = strtol(end + 1, (char**)&p, 10);
2461 if (p && *p) {
2462 /* Non-numeric port */
2463 return NULL;
2464 }
2465 if (port < 0 || port > 65535) {
2466 /* Invalid port */
2467 return NULL;
2468 }
2469 *pport = (int)port;
2470 return pestrndup(addr, end - addr, 1);
2471 }
2472
2473 #if defined(HAVE_PRCTL) || defined(HAVE_PROCCTL)
php_cli_server_worker_install_pdeathsig(void)2474 static void php_cli_server_worker_install_pdeathsig(void)
2475 {
2476 // Ignore failure to register PDEATHSIG, it's not available on all platforms anyway
2477 #if defined(HAVE_PRCTL)
2478 prctl(PR_SET_PDEATHSIG, SIGTERM);
2479 #elif defined(HAVE_PROCCTL)
2480 int signal = SIGTERM;
2481 procctl(P_PID, 0, PROC_PDEATHSIG_CTL, &signal);
2482 #endif
2483
2484 // Check if parent has exited just after the fork
2485 if (getppid() != php_cli_server_master) {
2486 exit(1);
2487 }
2488 }
2489 #endif
2490
php_cli_server_startup_workers(void)2491 static void php_cli_server_startup_workers(void) {
2492 char *workers = getenv("PHP_CLI_SERVER_WORKERS");
2493 if (!workers) {
2494 return;
2495 }
2496
2497 #if HAVE_FORK
2498 php_cli_server_workers_max = ZEND_ATOL(workers);
2499 if (php_cli_server_workers_max > 1) {
2500 zend_long php_cli_server_worker;
2501
2502 php_cli_server_workers = pecalloc(
2503 php_cli_server_workers_max, sizeof(pid_t), 1);
2504
2505 php_cli_server_master = getpid();
2506
2507 for (php_cli_server_worker = 0;
2508 php_cli_server_worker < php_cli_server_workers_max;
2509 php_cli_server_worker++) {
2510 pid_t pid = fork();
2511
2512 if (pid < 0) {
2513 /* no more forks allowed, work with what we have ... */
2514 php_cli_server_workers_max =
2515 php_cli_server_worker + 1;
2516 return;
2517 } else if (pid == 0) {
2518 #if defined(HAVE_PRCTL) || defined(HAVE_PROCCTL)
2519 php_cli_server_worker_install_pdeathsig();
2520 #endif
2521 return;
2522 } else {
2523 php_cli_server_workers[php_cli_server_worker] = pid;
2524 }
2525 }
2526 } else {
2527 fprintf(stderr, "number of workers must be larger than 1\n");
2528 }
2529 #else
2530 fprintf(stderr, "forking is not supported on this platform\n");
2531 #endif
2532 }
2533
php_cli_server_ctor(php_cli_server * server,const char * addr,const char * document_root,const char * router)2534 static zend_result php_cli_server_ctor(php_cli_server *server, const char *addr, const char *document_root, const char *router) /* {{{ */
2535 {
2536 zend_result retval = SUCCESS;
2537 char *host = NULL;
2538 zend_string *errstr = NULL;
2539 char *_document_root = NULL;
2540 char *_router = NULL;
2541 int port = 3000;
2542 php_socket_t server_sock = SOCK_ERR;
2543
2544 host = php_cli_server_parse_addr(addr, &port);
2545 if (!host) {
2546 fprintf(stderr, "Invalid address: %s\n", addr);
2547 retval = FAILURE;
2548 goto out;
2549 }
2550
2551 server_sock = php_network_listen_socket(host, &port, SOCK_STREAM, &server->address_family, &server->socklen, &errstr);
2552 if (server_sock == SOCK_ERR) {
2553 php_cli_server_logf(PHP_CLI_SERVER_LOG_ERROR, "Failed to listen on %s:%d (reason: %s)", host, port, errstr ? ZSTR_VAL(errstr) : "?");
2554 if (errstr) {
2555 zend_string_release_ex(errstr, 0);
2556 }
2557 retval = FAILURE;
2558 goto out;
2559 }
2560 // server_sock needs to be non-blocking when using multiple processes. Without it, the first process would
2561 // successfully accept the connection but the others would block, causing client sockets of the same select
2562 // call not to be handled.
2563 if (SUCCESS != php_set_sock_blocking(server_sock, 0)) {
2564 php_cli_server_logf(PHP_CLI_SERVER_LOG_ERROR, "Failed to make server socket non-blocking");
2565 retval = FAILURE;
2566 goto out;
2567 }
2568 server->server_sock = server_sock;
2569
2570 php_cli_server_startup_workers();
2571
2572 php_cli_server_poller_ctor(&server->poller);
2573
2574 php_cli_server_poller_add(&server->poller, POLLIN, server_sock);
2575
2576 server->host = host;
2577 server->port = port;
2578
2579 zend_hash_init(&server->clients, 0, NULL, php_cli_server_client_dtor_wrapper, 1);
2580
2581 {
2582 size_t document_root_len = strlen(document_root);
2583 _document_root = pestrndup(document_root, document_root_len, 1);
2584 server->document_root = _document_root;
2585 server->document_root_len = document_root_len;
2586 }
2587
2588 if (router) {
2589 size_t router_len = strlen(router);
2590 _router = pestrndup(router, router_len, 1);
2591 server->router = _router;
2592 server->router_len = router_len;
2593 } else {
2594 server->router = NULL;
2595 server->router_len = 0;
2596 }
2597
2598 php_cli_server_mime_type_ctor(server, mime_type_map);
2599
2600 server->is_running = 1;
2601 out:
2602 if (retval == FAILURE) {
2603 if (host) {
2604 pefree(host, 1);
2605 }
2606 if (_document_root) {
2607 pefree(_document_root, 1);
2608 }
2609 if (_router) {
2610 pefree(_router, 1);
2611 }
2612 if (server_sock > -1) {
2613 closesocket(server_sock);
2614 }
2615 }
2616 return retval;
2617 } /* }}} */
2618
php_cli_server_recv_event_read_request(php_cli_server * server,php_cli_server_client * client)2619 static zend_result php_cli_server_recv_event_read_request(php_cli_server *server, php_cli_server_client *client) /* {{{ */
2620 {
2621 char *errstr = NULL;
2622
2623 switch (php_cli_server_client_read_request(client, &errstr)) {
2624 case -1:
2625 if (errstr) {
2626 if (strcmp(errstr, php_cli_server_request_error_unexpected_eof) == 0 && client->parser.state == s_start_req) {
2627 php_cli_server_logf(PHP_CLI_SERVER_LOG_MESSAGE,
2628 "%s Closed without sending a request; it was probably just an unused speculative preconnection", ZSTR_VAL(client->addr_str));
2629 } else {
2630 php_cli_server_logf(PHP_CLI_SERVER_LOG_ERROR, "%s Invalid request (%s)", ZSTR_VAL(client->addr_str), errstr);
2631 }
2632 efree(errstr);
2633 }
2634 php_cli_server_close_connection(server, client);
2635 return FAILURE;
2636 case 1:
2637 if (client->request.request_method == PHP_HTTP_NOT_IMPLEMENTED) {
2638 return php_cli_server_send_error_page(server, client, 501);
2639 }
2640 php_cli_server_poller_remove(&server->poller, POLLIN, client->sock);
2641 return php_cli_server_dispatch(server, client);
2642 case 0:
2643 php_cli_server_poller_add(&server->poller, POLLIN, client->sock);
2644 return SUCCESS;
2645 EMPTY_SWITCH_DEFAULT_CASE();
2646 }
2647 /* Under ASAN the compiler somehow doesn't realise that the switch block always returns */
2648 return FAILURE;
2649 } /* }}} */
2650
php_cli_server_send_event(php_cli_server * server,php_cli_server_client * client)2651 static zend_result php_cli_server_send_event(php_cli_server *server, php_cli_server_client *client) /* {{{ */
2652 {
2653 if (client->content_sender_initialized) {
2654 if (client->file_fd >= 0 && !client->content_sender.buffer.first) {
2655 size_t nbytes_read;
2656 if (!php_cli_server_content_sender_pull(&client->content_sender, client->file_fd, &nbytes_read)) {
2657 php_cli_server_close_connection(server, client);
2658 return FAILURE;
2659 }
2660 if (nbytes_read == 0) {
2661 close(client->file_fd);
2662 client->file_fd = -1;
2663 }
2664 }
2665
2666 size_t nbytes_sent;
2667 int err = php_cli_server_content_sender_send(&client->content_sender, client->sock, &nbytes_sent);
2668 if (err && err != SOCK_EAGAIN) {
2669 php_cli_server_close_connection(server, client);
2670 return FAILURE;
2671 }
2672
2673 if (!client->content_sender.buffer.first && client->file_fd < 0) {
2674 php_cli_server_close_connection(server, client);
2675 }
2676 }
2677 return SUCCESS;
2678 }
2679 /* }}} */
2680
2681 typedef struct php_cli_server_do_event_for_each_fd_callback_params {
2682 php_cli_server *server;
2683 zend_result(*rhandler)(php_cli_server*, php_cli_server_client*);
2684 zend_result(*whandler)(php_cli_server*, php_cli_server_client*);
2685 } php_cli_server_do_event_for_each_fd_callback_params;
2686
php_cli_server_do_event_for_each_fd_callback(void * _params,php_socket_t fd,int event)2687 static zend_result php_cli_server_do_event_for_each_fd_callback(void *_params, php_socket_t fd, int event) /* {{{ */
2688 {
2689 php_cli_server_do_event_for_each_fd_callback_params *params = _params;
2690 php_cli_server *server = params->server;
2691 if (server->server_sock == fd) {
2692 php_cli_server_client *client = NULL;
2693 php_socket_t client_sock;
2694 socklen_t socklen = server->socklen;
2695 struct sockaddr *sa = pemalloc(server->socklen, 1);
2696 client_sock = accept(server->server_sock, sa, &socklen);
2697 if (!ZEND_VALID_SOCKET(client_sock)) {
2698 int err = php_socket_errno();
2699 if (err != SOCK_EAGAIN && php_cli_server_log_level >= PHP_CLI_SERVER_LOG_ERROR) {
2700 char *errstr = php_socket_strerror(php_socket_errno(), NULL, 0);
2701 php_cli_server_logf(PHP_CLI_SERVER_LOG_ERROR,
2702 "Failed to accept a client (reason: %s)", errstr);
2703 efree(errstr);
2704 }
2705 pefree(sa, 1);
2706 return FAILURE;
2707 }
2708 if (SUCCESS != php_set_sock_blocking(client_sock, 0)) {
2709 pefree(sa, 1);
2710 closesocket(client_sock);
2711 return FAILURE;
2712 }
2713 client = pemalloc(sizeof(php_cli_server_client), 1);
2714
2715 php_cli_server_client_ctor(client, server, client_sock, sa, socklen);
2716
2717 php_cli_server_logf(PHP_CLI_SERVER_LOG_MESSAGE, "%s Accepted", ZSTR_VAL(client->addr_str));
2718
2719 zend_hash_index_update_ptr(&server->clients, client_sock, client);
2720
2721 php_cli_server_poller_add(&server->poller, POLLIN, client->sock);
2722 } else {
2723 php_cli_server_client *client;
2724 if (NULL != (client = zend_hash_index_find_ptr(&server->clients, fd))) {
2725 if (event & POLLIN) {
2726 params->rhandler(server, client);
2727 }
2728 if (event & POLLOUT) {
2729 params->whandler(server, client);
2730 }
2731 }
2732 }
2733 return SUCCESS;
2734 } /* }}} */
2735
php_cli_server_do_event_for_each_fd(php_cli_server * server,zend_result (* rhandler)(php_cli_server *,php_cli_server_client *),zend_result (* whandler)(php_cli_server *,php_cli_server_client *))2736 static void php_cli_server_do_event_for_each_fd(php_cli_server *server,
2737 zend_result(*rhandler)(php_cli_server*, php_cli_server_client*),
2738 zend_result(*whandler)(php_cli_server*, php_cli_server_client*)) /* {{{ */
2739 {
2740 php_cli_server_do_event_for_each_fd_callback_params params = {
2741 server,
2742 rhandler,
2743 whandler
2744 };
2745
2746 if (SUCCESS != php_cli_server_poller_iter_on_active(&server->poller, ¶ms, php_cli_server_do_event_for_each_fd_callback)) {
2747 php_cli_server_logf(PHP_CLI_SERVER_LOG_ERROR, "Failed to poll event");
2748 }
2749 } /* }}} */
2750
php_cli_server_do_event_loop(php_cli_server * server)2751 static zend_result php_cli_server_do_event_loop(php_cli_server *server) /* {{{ */
2752 {
2753 zend_result retval = SUCCESS;
2754 while (server->is_running) {
2755 struct timeval tv = { 1, 0 };
2756 int n = php_cli_server_poller_poll(&server->poller, &tv);
2757 if (n > 0) {
2758 php_cli_server_do_event_for_each_fd(server,
2759 php_cli_server_recv_event_read_request,
2760 php_cli_server_send_event);
2761 } else if (n == 0) {
2762 /* do nothing */
2763 } else {
2764 int err = php_socket_errno();
2765 if (err != SOCK_EINTR) {
2766 if (php_cli_server_log_level >= PHP_CLI_SERVER_LOG_ERROR) {
2767 char *errstr = php_socket_strerror(err, NULL, 0);
2768 php_cli_server_logf(PHP_CLI_SERVER_LOG_ERROR, "%s", errstr);
2769 efree(errstr);
2770 }
2771 retval = FAILURE;
2772 goto out;
2773 }
2774 }
2775 }
2776 out:
2777 return retval;
2778 } /* }}} */
2779
2780 static php_cli_server server;
2781
php_cli_server_sigint_handler(int sig)2782 static void php_cli_server_sigint_handler(int sig) /* {{{ */
2783 {
2784 server.is_running = 0;
2785 }
2786 /* }}} */
2787
2788 /* Returns status code */
do_cli_server(int argc,char ** argv)2789 int do_cli_server(int argc, char **argv) /* {{{ */
2790 {
2791 char *php_optarg = NULL;
2792 int php_optind = 1;
2793 int c, r;
2794 const char *server_bind_address = NULL;
2795 extern const opt_struct OPTIONS[];
2796 const char *document_root = NULL;
2797 #ifdef PHP_WIN32
2798 char document_root_tmp[MAXPATHLEN];
2799 size_t k;
2800 #endif
2801 const char *router = NULL;
2802 char document_root_buf[MAXPATHLEN];
2803
2804 while ((c = php_getopt(argc, argv, OPTIONS, &php_optarg, &php_optind, 0, 2))!=-1) {
2805 switch (c) {
2806 case 'S':
2807 server_bind_address = php_optarg;
2808 break;
2809 case 't':
2810 #ifndef PHP_WIN32
2811 document_root = php_optarg;
2812 #else
2813 k = strlen(php_optarg);
2814 if (k + 1 > MAXPATHLEN) {
2815 fprintf(stderr, "Document root path is too long.\n");
2816 return 1;
2817 }
2818 memmove(document_root_tmp, php_optarg, k + 1);
2819 /* Clean out any trailing garbage that might have been passed
2820 from a batch script. */
2821 do {
2822 document_root_tmp[k] = '\0';
2823 k--;
2824 } while ('"' == document_root_tmp[k] || ' ' == document_root_tmp[k]);
2825 document_root = document_root_tmp;
2826 #endif
2827 break;
2828 case 'q':
2829 if (php_cli_server_log_level > 1) {
2830 php_cli_server_log_level--;
2831 }
2832 break;
2833 }
2834 }
2835
2836 if (document_root) {
2837 zend_stat_t sb = {0};
2838
2839 if (php_sys_stat(document_root, &sb)) {
2840 fprintf(stderr, "Directory %s does not exist.\n", document_root);
2841 return 1;
2842 }
2843 if (!S_ISDIR(sb.st_mode)) {
2844 fprintf(stderr, "%s is not a directory.\n", document_root);
2845 return 1;
2846 }
2847 if (VCWD_REALPATH(document_root, document_root_buf)) {
2848 document_root = document_root_buf;
2849 }
2850 } else {
2851 char *ret = NULL;
2852
2853 #if HAVE_GETCWD
2854 ret = VCWD_GETCWD(document_root_buf, MAXPATHLEN);
2855 #elif HAVE_GETWD
2856 ret = VCWD_GETWD(document_root_buf);
2857 #endif
2858 document_root = ret ? document_root_buf: ".";
2859 }
2860
2861 if (argc > php_optind) {
2862 router = argv[php_optind];
2863 }
2864
2865 if (FAILURE == php_cli_server_ctor(&server, server_bind_address, document_root, router)) {
2866 return 1;
2867 }
2868 sapi_module.phpinfo_as_text = 0;
2869
2870 {
2871 r = 0;
2872 bool ipv6 = strchr(server.host, ':');
2873 php_cli_server_logf(
2874 PHP_CLI_SERVER_LOG_PROCESS,
2875 "PHP %s Development Server (http://%s%s%s:%d) started",
2876 PHP_VERSION, ipv6 ? "[" : "", server.host,
2877 ipv6 ? "]" : "", server.port);
2878 }
2879
2880 #if defined(SIGINT)
2881 signal(SIGINT, php_cli_server_sigint_handler);
2882 #endif
2883
2884 #if defined(SIGPIPE)
2885 signal(SIGPIPE, SIG_IGN);
2886 #endif
2887
2888 zend_signal_init();
2889
2890 if (SUCCESS != php_cli_server_do_event_loop(&server)) {
2891 r = 1;
2892 }
2893 php_cli_server_dtor(&server);
2894 return r;
2895 } /* }}} */
2896