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