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