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