Skip to content

Instantly share code, notes, and snippets.

@moriyoshi

moriyoshi/php-embedded-server-20110220.patch.diff

Created February 20, 2011 04:35
Show Gist options
  • Save moriyoshi/835698 to your computer and use it in GitHub Desktop.
Save moriyoshi/835698 to your computer and use it in GitHub Desktop.
Download ZIP
Raw
php-embedded-server-20110220.patch.diff
Index: sapi/cli/config.w32
===================================================================
--- sapi/cli/config.w32 (revision 308839)
+++ sapi/cli/config.w32 (working copy)
@@ -6,7 +6,8 @@
ARG_ENABLE('cli-win32', 'Build console-less CLI version of PHP', 'no');
if (PHP_CLI == "yes") {
- SAPI('cli', 'php_cli.c', 'php.exe');
+ SAPI('cli', 'php_cli.c php_http_parser.c php_cli_server.c', 'php.exe');
+ ADD_FLAG("LIBS_CLI", "ws2_32.lib");
if (PHP_CRT_DEBUG == "yes") {
ADD_FLAG("CFLAGS_CLI", "/D PHP_WIN32_DEBUG_HEAP");
}
Index: sapi/cli/php_http_parser.c
===================================================================
--- sapi/cli/php_http_parser.c (revision 0)
+++ sapi/cli/php_http_parser.c (revision 0)
@@ -0,0 +1,1602 @@
+/* Copyright 2009,2010 Ryan Dahl <[email protected]>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+#include <assert.h>
+#include <stddef.h>
+#include "php_http_parser.h"
+
+
+#ifndef MIN
+# define MIN(a,b) ((a) < (b) ? (a) : (b))
+#endif
+
+
+#define CALLBACK2(FOR) \
+do { \
+ if (settings->on_##FOR) { \
+ if (0 != settings->on_##FOR(parser)) return (p - data); \
+ } \
+} while (0)
+
+
+#define MARK(FOR) \
+do { \
+ FOR##_mark = p; \
+} while (0)
+
+#define CALLBACK_NOCLEAR(FOR) \
+do { \
+ if (FOR##_mark) { \
+ if (settings->on_##FOR) { \
+ if (0 != settings->on_##FOR(parser, \
+ FOR##_mark, \
+ p - FOR##_mark)) \
+ { \
+ return (p - data); \
+ } \
+ } \
+ } \
+} while (0)
+
+
+#define CALLBACK(FOR) \
+do { \
+ CALLBACK_NOCLEAR(FOR); \
+ FOR##_mark = NULL; \
+} while (0)
+
+
+#define PROXY_CONNECTION "proxy-connection"
+#define CONNECTION "connection"
+#define CONTENT_LENGTH "content-length"
+#define TRANSFER_ENCODING "transfer-encoding"
+#define UPGRADE "upgrade"
+#define CHUNKED "chunked"
+#define KEEP_ALIVE "keep-alive"
+#define CLOSE "close"
+
+
+static const char *method_strings[] =
+ { "DELETE"
+ , "GET"
+ , "HEAD"
+ , "POST"
+ , "PUT"
+ , "CONNECT"
+ , "OPTIONS"
+ , "TRACE"
+ , "COPY"
+ , "LOCK"
+ , "MKCOL"
+ , "MOVE"
+ , "PROPFIND"
+ , "PROPPATCH"
+ , "UNLOCK"
+ , "REPORT"
+ , "MKACTIVITY"
+ , "CHECKOUT"
+ , "MERGE"
+ , "M-SEARCH"
+ , "NOTIFY"
+ , "SUBSCRIBE"
+ , "UNSUBSCRIBE"
+ };
+
+
+/* Tokens as defined by rfc 2616. Also lowercases them.
+ * token = 1*<any CHAR except CTLs or separators>
+ * separators = "(" | ")" | "<" | ">" | "@"
+ * | "," | ";" | ":" | "\" | <">
+ * | "/" | "[" | "]" | "?" | "="
+ * | "{" | "}" | SP | HT
+ */
+static const char tokens[256] = {
+/* 0 nul 1 soh 2 stx 3 etx 4 eot 5 enq 6 ack 7 bel */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+/* 8 bs 9 ht 10 nl 11 vt 12 np 13 cr 14 so 15 si */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+/* 16 dle 17 dc1 18 dc2 19 dc3 20 dc4 21 nak 22 syn 23 etb */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+/* 24 can 25 em 26 sub 27 esc 28 fs 29 gs 30 rs 31 us */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+/* 32 sp 33 ! 34 " 35 # 36 $ 37 % 38 & 39 ' */
+ ' ', '!', '"', '#', '$', '%', '&', '\'',
+/* 40 ( 41 ) 42 * 43 + 44 , 45 - 46 . 47 / */
+ 0, 0, '*', '+', 0, '-', '.', '/',
+/* 48 0 49 1 50 2 51 3 52 4 53 5 54 6 55 7 */
+ '0', '1', '2', '3', '4', '5', '6', '7',
+/* 56 8 57 9 58 : 59 ; 60 < 61 = 62 > 63 ? */
+ '8', '9', 0, 0, 0, 0, 0, 0,
+/* 64 @ 65 A 66 B 67 C 68 D 69 E 70 F 71 G */
+ 0, 'a', 'b', 'c', 'd', 'e', 'f', 'g',
+/* 72 H 73 I 74 J 75 K 76 L 77 M 78 N 79 O */
+ 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o',
+/* 80 P 81 Q 82 R 83 S 84 T 85 U 86 V 87 W */
+ 'p', 'q', 'r', 's', 't', 'u', 'v', 'w',
+/* 88 X 89 Y 90 Z 91 [ 92 \ 93 ] 94 ^ 95 _ */
+ 'x', 'y', 'z', 0, 0, 0, '^', '_',
+/* 96 ` 97 a 98 b 99 c 100 d 101 e 102 f 103 g */
+ '`', 'a', 'b', 'c', 'd', 'e', 'f', 'g',
+/* 104 h 105 i 106 j 107 k 108 l 109 m 110 n 111 o */
+ 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o',
+/* 112 p 113 q 114 r 115 s 116 t 117 u 118 v 119 w */
+ 'p', 'q', 'r', 's', 't', 'u', 'v', 'w',
+/* 120 x 121 y 122 z 123 { 124 | 125 } 126 ~ 127 del */
+ 'x', 'y', 'z', 0, '|', '}', '~', 0 };
+
+
+static const int8_t unhex[256] =
+ {-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1
+ ,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1
+ ,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1
+ , 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,-1,-1,-1,-1,-1,-1
+ ,-1,10,11,12,13,14,15,-1,-1,-1,-1,-1,-1,-1,-1,-1
+ ,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1
+ ,-1,10,11,12,13,14,15,-1,-1,-1,-1,-1,-1,-1,-1,-1
+ ,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1
+ };
+
+
+static const uint8_t normal_url_char[256] = {
+/* 0 nul 1 soh 2 stx 3 etx 4 eot 5 enq 6 ack 7 bel */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+/* 8 bs 9 ht 10 nl 11 vt 12 np 13 cr 14 so 15 si */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+/* 16 dle 17 dc1 18 dc2 19 dc3 20 dc4 21 nak 22 syn 23 etb */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+/* 24 can 25 em 26 sub 27 esc 28 fs 29 gs 30 rs 31 us */
+ 0, 0, 0, 0, 0, 0, 0, 0,
+/* 32 sp 33 ! 34 " 35 # 36 $ 37 % 38 & 39 ' */
+ 0, 1, 1, 0, 1, 1, 1, 1,
+/* 40 ( 41 ) 42 * 43 + 44 , 45 - 46 . 47 / */
+ 1, 1, 1, 1, 1, 1, 1, 1,
+/* 48 0 49 1 50 2 51 3 52 4 53 5 54 6 55 7 */
+ 1, 1, 1, 1, 1, 1, 1, 1,
+/* 56 8 57 9 58 : 59 ; 60 < 61 = 62 > 63 ? */
+ 1, 1, 1, 1, 1, 1, 1, 0,
+/* 64 @ 65 A 66 B 67 C 68 D 69 E 70 F 71 G */
+ 1, 1, 1, 1, 1, 1, 1, 1,
+/* 72 H 73 I 74 J 75 K 76 L 77 M 78 N 79 O */
+ 1, 1, 1, 1, 1, 1, 1, 1,
+/* 80 P 81 Q 82 R 83 S 84 T 85 U 86 V 87 W */
+ 1, 1, 1, 1, 1, 1, 1, 1,
+/* 88 X 89 Y 90 Z 91 [ 92 \ 93 ] 94 ^ 95 _ */
+ 1, 1, 1, 1, 1, 1, 1, 1,
+/* 96 ` 97 a 98 b 99 c 100 d 101 e 102 f 103 g */
+ 1, 1, 1, 1, 1, 1, 1, 1,
+/* 104 h 105 i 106 j 107 k 108 l 109 m 110 n 111 o */
+ 1, 1, 1, 1, 1, 1, 1, 1,
+/* 112 p 113 q 114 r 115 s 116 t 117 u 118 v 119 w */
+ 1, 1, 1, 1, 1, 1, 1, 1,
+/* 120 x 121 y 122 z 123 { 124 | 125 } 126 ~ 127 del */
+ 1, 1, 1, 1, 1, 1, 1, 0 };
+
+
+enum state
+ { s_dead = 1 /* important that this is > 0 */
+
+ , s_start_req_or_res
+ , s_res_or_resp_H
+ , s_start_res
+ , s_res_H
+ , s_res_HT
+ , s_res_HTT
+ , s_res_HTTP
+ , s_res_first_http_major
+ , s_res_http_major
+ , s_res_first_http_minor
+ , s_res_http_minor
+ , s_res_first_status_code
+ , s_res_status_code
+ , s_res_status
+ , s_res_line_almost_done
+
+ , s_start_req
+
+ , s_req_method
+ , s_req_spaces_before_url
+ , s_req_schema
+ , s_req_schema_slash
+ , s_req_schema_slash_slash
+ , s_req_host
+ , s_req_port
+ , s_req_path
+ , s_req_query_string_start
+ , s_req_query_string
+ , s_req_fragment_start
+ , s_req_fragment
+ , s_req_http_start
+ , s_req_http_H
+ , s_req_http_HT
+ , s_req_http_HTT
+ , s_req_http_HTTP
+ , s_req_first_http_major
+ , s_req_http_major
+ , s_req_first_http_minor
+ , s_req_http_minor
+ , s_req_line_almost_done
+
+ , s_header_field_start
+ , s_header_field
+ , s_header_value_start
+ , s_header_value
+
+ , s_header_almost_done
+
+ , s_headers_almost_done
+ /* Important: 's_headers_almost_done' must be the last 'header' state. All
+ * states beyond this must be 'body' states. It is used for overflow
+ * checking. See the PARSING_HEADER() macro.
+ */
+ , s_chunk_size_start
+ , s_chunk_size
+ , s_chunk_size_almost_done
+ , s_chunk_parameters
+ , s_chunk_data
+ , s_chunk_data_almost_done
+ , s_chunk_data_done
+
+ , s_body_identity
+ , s_body_identity_eof
+ };
+
+
+#define PARSING_HEADER(state) (state <= s_headers_almost_done && 0 == (parser->flags & F_TRAILING))
+
+
+enum header_states
+ { h_general = 0
+ , h_C
+ , h_CO
+ , h_CON
+
+ , h_matching_connection
+ , h_matching_proxy_connection
+ , h_matching_content_length
+ , h_matching_transfer_encoding
+ , h_matching_upgrade
+
+ , h_connection
+ , h_content_length
+ , h_transfer_encoding
+ , h_upgrade
+
+ , h_matching_transfer_encoding_chunked
+ , h_matching_connection_keep_alive
+ , h_matching_connection_close
+
+ , h_transfer_encoding_chunked
+ , h_connection_keep_alive
+ , h_connection_close
+ };
+
+
+enum flags
+ { F_CHUNKED = 1 << 0
+ , F_CONNECTION_KEEP_ALIVE = 1 << 1
+ , F_CONNECTION_CLOSE = 1 << 2
+ , F_TRAILING = 1 << 3
+ , F_UPGRADE = 1 << 4
+ , F_SKIPBODY = 1 << 5
+ };
+
+
+#define CR '\r'
+#define LF '\n'
+#define LOWER(c) (unsigned char)(c | 0x20)
+#define TOKEN(c) tokens[(unsigned char)c]
+
+
+#define start_state (parser->type == PHP_HTTP_REQUEST ? s_start_req : s_start_res)
+
+
+#if HTTP_PARSER_STRICT
+# define STRICT_CHECK(cond) if (cond) goto error
+# define NEW_MESSAGE() (http_should_keep_alive(parser) ? start_state : s_dead)
+#else
+# define STRICT_CHECK(cond)
+# define NEW_MESSAGE() start_state
+#endif
+
+
+size_t php_http_parser_execute (php_http_parser *parser,
+ const php_http_parser_settings *settings,
+ const char *data,
+ size_t len)
+{
+ char c, ch;
+ const char *p = data, *pe;
+ int64_t to_read;
+
+ enum state state = (enum state) parser->state;
+ enum header_states header_state = (enum header_states) parser->header_state;
+ uint64_t index = parser->index;
+ uint64_t nread = parser->nread;
+
+ /* technically we could combine all of these (except for url_mark) into one
+ variable, saving stack space, but it seems more clear to have them
+ separated. */
+ const char *header_field_mark = 0;
+ const char *header_value_mark = 0;
+ const char *fragment_mark = 0;
+ const char *query_string_mark = 0;
+ const char *path_mark = 0;
+ const char *url_mark = 0;
+
+ if (len == 0) {
+ if (state == s_body_identity_eof) {
+ CALLBACK2(message_complete);
+ }
+ return 0;
+ }
+
+ if (state == s_header_field)
+ header_field_mark = data;
+ if (state == s_header_value)
+ header_value_mark = data;
+ if (state == s_req_fragment)
+ fragment_mark = data;
+ if (state == s_req_query_string)
+ query_string_mark = data;
+ if (state == s_req_path)
+ path_mark = data;
+ if (state == s_req_path || state == s_req_schema || state == s_req_schema_slash
+ || state == s_req_schema_slash_slash || state == s_req_port
+ || state == s_req_query_string_start || state == s_req_query_string
+ || state == s_req_host
+ || state == s_req_fragment_start || state == s_req_fragment)
+ url_mark = data;
+
+ for (p=data, pe=data+len; p != pe; p++) {
+ ch = *p;
+
+ if (PARSING_HEADER(state)) {
+ ++nread;
+ /* Buffer overflow attack */
+ if (nread > PHP_HTTP_MAX_HEADER_SIZE) goto error;
+ }
+
+ switch (state) {
+
+ case s_dead:
+ /* this state is used after a 'Connection: close' message
+ * the parser will error out if it reads another message
+ */
+ goto error;
+
+ case s_start_req_or_res:
+ {
+ if (ch == CR || ch == LF)
+ break;
+ parser->flags = 0;
+ parser->content_length = -1;
+
+ CALLBACK2(message_begin);
+
+ if (ch == 'H')
+ state = s_res_or_resp_H;
+ else {
+ parser->type = PHP_HTTP_REQUEST;
+ goto start_req_method_assign;
+ }
+ break;
+ }
+
+ case s_res_or_resp_H:
+ if (ch == 'T') {
+ parser->type = PHP_HTTP_RESPONSE;
+ state = s_res_HT;
+ } else {
+ if (ch != 'E') goto error;
+ parser->type = PHP_HTTP_REQUEST;
+ parser->method = PHP_HTTP_HEAD;
+ index = 2;
+ state = s_req_method;
+ }
+ break;
+
+ case s_start_res:
+ {
+ parser->flags = 0;
+ parser->content_length = -1;
+
+ CALLBACK2(message_begin);
+
+ switch (ch) {
+ case 'H':
+ state = s_res_H;
+ break;
+
+ case CR:
+ case LF:
+ break;
+
+ default:
+ goto error;
+ }
+ break;
+ }
+
+ case s_res_H:
+ STRICT_CHECK(ch != 'T');
+ state = s_res_HT;
+ break;
+
+ case s_res_HT:
+ STRICT_CHECK(ch != 'T');
+ state = s_res_HTT;
+ break;
+
+ case s_res_HTT:
+ STRICT_CHECK(ch != 'P');
+ state = s_res_HTTP;
+ break;
+
+ case s_res_HTTP:
+ STRICT_CHECK(ch != '/');
+ state = s_res_first_http_major;
+ break;
+
+ case s_res_first_http_major:
+ if (ch < '1' || ch > '9') goto error;
+ parser->http_major = ch - '0';
+ state = s_res_http_major;
+ break;
+
+ /* major HTTP version or dot */
+ case s_res_http_major:
+ {
+ if (ch == '.') {
+ state = s_res_first_http_minor;
+ break;
+ }
+
+ if (ch < '0' || ch > '9') goto error;
+
+ parser->http_major *= 10;
+ parser->http_major += ch - '0';
+
+ if (parser->http_major > 999) goto error;
+ break;
+ }
+
+ /* first digit of minor HTTP version */
+ case s_res_first_http_minor:
+ if (ch < '0' || ch > '9') goto error;
+ parser->http_minor = ch - '0';
+ state = s_res_http_minor;
+ break;
+
+ /* minor HTTP version or end of request line */
+ case s_res_http_minor:
+ {
+ if (ch == ' ') {
+ state = s_res_first_status_code;
+ break;
+ }
+
+ if (ch < '0' || ch > '9') goto error;
+
+ parser->http_minor *= 10;
+ parser->http_minor += ch - '0';
+
+ if (parser->http_minor > 999) goto error;
+ break;
+ }
+
+ case s_res_first_status_code:
+ {
+ if (ch < '0' || ch > '9') {
+ if (ch == ' ') {
+ break;
+ }
+ goto error;
+ }
+ parser->status_code = ch - '0';
+ state = s_res_status_code;
+ break;
+ }
+
+ case s_res_status_code:
+ {
+ if (ch < '0' || ch > '9') {
+ switch (ch) {
+ case ' ':
+ state = s_res_status;
+ break;
+ case CR:
+ state = s_res_line_almost_done;
+ break;
+ case LF:
+ state = s_header_field_start;
+ break;
+ default:
+ goto error;
+ }
+ break;
+ }
+
+ parser->status_code *= 10;
+ parser->status_code += ch - '0';
+
+ if (parser->status_code > 999) goto error;
+ break;
+ }
+
+ case s_res_status:
+ /* the human readable status. e.g. "NOT FOUND"
+ * we are not humans so just ignore this */
+ if (ch == CR) {
+ state = s_res_line_almost_done;
+ break;
+ }
+
+ if (ch == LF) {
+ state = s_header_field_start;
+ break;
+ }
+ break;
+
+ case s_res_line_almost_done:
+ STRICT_CHECK(ch != LF);
+ state = s_header_field_start;
+ break;
+
+ case s_start_req:
+ {
+ if (ch == CR || ch == LF)
+ break;
+ parser->flags = 0;
+ parser->content_length = -1;
+
+ CALLBACK2(message_begin);
+
+ if (ch < 'A' || 'Z' < ch) goto error;
+
+ start_req_method_assign:
+ parser->method = (enum php_http_method) 0;
+ index = 1;
+ switch (ch) {
+ case 'C': parser->method = PHP_HTTP_CONNECT; /* or COPY, CHECKOUT */ break;
+ case 'D': parser->method = PHP_HTTP_DELETE; break;
+ case 'G': parser->method = PHP_HTTP_GET; break;
+ case 'H': parser->method = PHP_HTTP_HEAD; break;
+ case 'L': parser->method = PHP_HTTP_LOCK; break;
+ case 'M': parser->method = PHP_HTTP_MKCOL; /* or MOVE, MKACTIVITY, MERGE, M-SEARCH */ break;
+ case 'N': parser->method = PHP_HTTP_NOTIFY; break;
+ case 'O': parser->method = PHP_HTTP_OPTIONS; break;
+ case 'P': parser->method = PHP_HTTP_POST; /* or PROPFIND or PROPPATCH or PUT */ break;
+ case 'R': parser->method = PHP_HTTP_REPORT; break;
+ case 'S': parser->method = PHP_HTTP_SUBSCRIBE; break;
+ case 'T': parser->method = PHP_HTTP_TRACE; break;
+ case 'U': parser->method = PHP_HTTP_UNLOCK; /* or UNSUBSCRIBE */ break;
+ default: goto error;
+ }
+ state = s_req_method;
+ break;
+ }
+
+ case s_req_method:
+ {
+ const char *matcher;
+ if (ch == '\0')
+ goto error;
+
+ matcher = method_strings[parser->method];
+ if (ch == ' ' && matcher[index] == '\0') {
+ state = s_req_spaces_before_url;
+ } else if (ch == matcher[index]) {
+ ; /* nada */
+ } else if (parser->method == PHP_HTTP_CONNECT) {
+ if (index == 1 && ch == 'H') {
+ parser->method = PHP_HTTP_CHECKOUT;
+ } else if (index == 2 && ch == 'P') {
+ parser->method = PHP_HTTP_COPY;
+ }
+ } else if (parser->method == PHP_HTTP_MKCOL) {
+ if (index == 1 && ch == 'O') {
+ parser->method = PHP_HTTP_MOVE;
+ } else if (index == 1 && ch == 'E') {
+ parser->method = PHP_HTTP_MERGE;
+ } else if (index == 1 && ch == '-') {
+ parser->method = PHP_HTTP_MSEARCH;
+ } else if (index == 2 && ch == 'A') {
+ parser->method = PHP_HTTP_MKACTIVITY;
+ }
+ } else if (index == 1 && parser->method == PHP_HTTP_POST && ch == 'R') {
+ parser->method = PHP_HTTP_PROPFIND; /* or HTTP_PROPPATCH */
+ } else if (index == 1 && parser->method == PHP_HTTP_POST && ch == 'U') {
+ parser->method = PHP_HTTP_PUT;
+ } else if (index == 2 && parser->method == PHP_HTTP_UNLOCK && ch == 'S') {
+ parser->method = PHP_HTTP_UNSUBSCRIBE;
+ } else if (index == 4 && parser->method == PHP_HTTP_PROPFIND && ch == 'P') {
+ parser->method = PHP_HTTP_PROPPATCH;
+ } else {
+ goto error;
+ }
+
+ ++index;
+ break;
+ }
+ case s_req_spaces_before_url:
+ {
+ if (ch == ' ') break;
+
+ if (ch == '/' || ch == '*') {
+ MARK(url);
+ MARK(path);
+ state = s_req_path;
+ break;
+ }
+
+ c = LOWER(ch);
+
+ if (c >= 'a' && c <= 'z') {
+ MARK(url);
+ state = s_req_schema;
+ break;
+ }
+
+ goto error;
+ }
+
+ case s_req_schema:
+ {
+ c = LOWER(ch);
+
+ if (c >= 'a' && c <= 'z') break;
+
+ if (ch == ':') {
+ state = s_req_schema_slash;
+ break;
+ } else if (ch == '.') {
+ state = s_req_host;
+ break;
+ } else if ('0' <= ch && ch <= '9') {
+ state = s_req_host;
+ break;
+ }
+
+ goto error;
+ }
+
+ case s_req_schema_slash:
+ STRICT_CHECK(ch != '/');
+ state = s_req_schema_slash_slash;
+ break;
+
+ case s_req_schema_slash_slash:
+ STRICT_CHECK(ch != '/');
+ state = s_req_host;
+ break;
+
+ case s_req_host:
+ {
+ c = LOWER(ch);
+ if (c >= 'a' && c <= 'z') break;
+ if ((ch >= '0' && ch <= '9') || ch == '.' || ch == '-') break;
+ switch (ch) {
+ case ':':
+ state = s_req_port;
+ break;
+ case '/':
+ MARK(path);
+ state = s_req_path;
+ break;
+ case ' ':
+ /* The request line looks like:
+ * "GET http://foo.bar.com HTTP/1.1"
+ * That is, there is no path.
+ */
+ CALLBACK(url);
+ state = s_req_http_start;
+ break;
+ default:
+ goto error;
+ }
+ break;
+ }
+
+ case s_req_port:
+ {
+ if (ch >= '0' && ch <= '9') break;
+ switch (ch) {
+ case '/':
+ MARK(path);
+ state = s_req_path;
+ break;
+ case ' ':
+ /* The request line looks like:
+ * "GET http://foo.bar.com:1234 HTTP/1.1"
+ * That is, there is no path.
+ */
+ CALLBACK(url);
+ state = s_req_http_start;
+ break;
+ default:
+ goto error;
+ }
+ break;
+ }
+
+ case s_req_path:
+ {
+ if (normal_url_char[(unsigned char)ch]) break;
+
+ switch (ch) {
+ case ' ':
+ CALLBACK(url);
+ CALLBACK(path);
+ state = s_req_http_start;
+ break;
+ case CR:
+ CALLBACK(url);
+ CALLBACK(path);
+ parser->http_major = 0;
+ parser->http_minor = 9;
+ state = s_req_line_almost_done;
+ break;
+ case LF:
+ CALLBACK(url);
+ CALLBACK(path);
+ parser->http_major = 0;
+ parser->http_minor = 9;
+ state = s_header_field_start;
+ break;
+ case '?':
+ CALLBACK(path);
+ state = s_req_query_string_start;
+ break;
+ case '#':
+ CALLBACK(path);
+ state = s_req_fragment_start;
+ break;
+ default:
+ goto error;
+ }
+ break;
+ }
+
+ case s_req_query_string_start:
+ {
+ if (normal_url_char[(unsigned char)ch]) {
+ MARK(query_string);
+ state = s_req_query_string;
+ break;
+ }
+
+ switch (ch) {
+ case '?':
+ break; /* XXX ignore extra '?' ... is this right? */
+ case ' ':
+ CALLBACK(url);
+ state = s_req_http_start;
+ break;
+ case CR:
+ CALLBACK(url);
+ parser->http_major = 0;
+ parser->http_minor = 9;
+ state = s_req_line_almost_done;
+ break;
+ case LF:
+ CALLBACK(url);
+ parser->http_major = 0;
+ parser->http_minor = 9;
+ state = s_header_field_start;
+ break;
+ case '#':
+ state = s_req_fragment_start;
+ break;
+ default:
+ goto error;
+ }
+ break;
+ }
+
+ case s_req_query_string:
+ {
+ if (normal_url_char[(unsigned char)ch]) break;
+
+ switch (ch) {
+ case '?':
+ /* allow extra '?' in query string */
+ break;
+ case ' ':
+ CALLBACK(url);
+ CALLBACK(query_string);
+ state = s_req_http_start;
+ break;
+ case CR:
+ CALLBACK(url);
+ CALLBACK(query_string);
+ parser->http_major = 0;
+ parser->http_minor = 9;
+ state = s_req_line_almost_done;
+ break;
+ case LF:
+ CALLBACK(url);
+ CALLBACK(query_string);
+ parser->http_major = 0;
+ parser->http_minor = 9;
+ state = s_header_field_start;
+ break;
+ case '#':
+ CALLBACK(query_string);
+ state = s_req_fragment_start;
+ break;
+ default:
+ goto error;
+ }
+ break;
+ }
+
+ case s_req_fragment_start:
+ {
+ if (normal_url_char[(unsigned char)ch]) {
+ MARK(fragment);
+ state = s_req_fragment;
+ break;
+ }
+
+ switch (ch) {
+ case ' ':
+ CALLBACK(url);
+ state = s_req_http_start;
+ break;
+ case CR:
+ CALLBACK(url);
+ parser->http_major = 0;
+ parser->http_minor = 9;
+ state = s_req_line_almost_done;
+ break;
+ case LF:
+ CALLBACK(url);
+ parser->http_major = 0;
+ parser->http_minor = 9;
+ state = s_header_field_start;
+ break;
+ case '?':
+ MARK(fragment);
+ state = s_req_fragment;
+ break;
+ case '#':
+ break;
+ default:
+ goto error;
+ }
+ break;
+ }
+
+ case s_req_fragment:
+ {
+ if (normal_url_char[(unsigned char)ch]) break;
+
+ switch (ch) {
+ case ' ':
+ CALLBACK(url);
+ CALLBACK(fragment);
+ state = s_req_http_start;
+ break;
+ case CR:
+ CALLBACK(url);
+ CALLBACK(fragment);
+ parser->http_major = 0;
+ parser->http_minor = 9;
+ state = s_req_line_almost_done;
+ break;
+ case LF:
+ CALLBACK(url);
+ CALLBACK(fragment);
+ parser->http_major = 0;
+ parser->http_minor = 9;
+ state = s_header_field_start;
+ break;
+ case '?':
+ case '#':
+ break;
+ default:
+ goto error;
+ }
+ break;
+ }
+
+ case s_req_http_start:
+ switch (ch) {
+ case 'H':
+ state = s_req_http_H;
+ break;
+ case ' ':
+ break;
+ default:
+ goto error;
+ }
+ break;
+
+ case s_req_http_H:
+ STRICT_CHECK(ch != 'T');
+ state = s_req_http_HT;
+ break;
+
+ case s_req_http_HT:
+ STRICT_CHECK(ch != 'T');
+ state = s_req_http_HTT;
+ break;
+
+ case s_req_http_HTT:
+ STRICT_CHECK(ch != 'P');
+ state = s_req_http_HTTP;
+ break;
+
+ case s_req_http_HTTP:
+ STRICT_CHECK(ch != '/');
+ state = s_req_first_http_major;
+ break;
+
+ /* first digit of major HTTP version */
+ case s_req_first_http_major:
+ if (ch < '1' || ch > '9') goto error;
+ parser->http_major = ch - '0';
+ state = s_req_http_major;
+ break;
+
+ /* major HTTP version or dot */
+ case s_req_http_major:
+ {
+ if (ch == '.') {
+ state = s_req_first_http_minor;
+ break;
+ }
+
+ if (ch < '0' || ch > '9') goto error;
+
+ parser->http_major *= 10;
+ parser->http_major += ch - '0';
+
+ if (parser->http_major > 999) goto error;
+ break;
+ }
+
+ /* first digit of minor HTTP version */
+ case s_req_first_http_minor:
+ if (ch < '0' || ch > '9') goto error;
+ parser->http_minor = ch - '0';
+ state = s_req_http_minor;
+ break;
+
+ /* minor HTTP version or end of request line */
+ case s_req_http_minor:
+ {
+ if (ch == CR) {
+ state = s_req_line_almost_done;
+ break;
+ }
+
+ if (ch == LF) {
+ state = s_header_field_start;
+ break;
+ }
+
+ /* XXX allow spaces after digit? */
+
+ if (ch < '0' || ch > '9') goto error;
+
+ parser->http_minor *= 10;
+ parser->http_minor += ch - '0';
+
+ if (parser->http_minor > 999) goto error;
+ break;
+ }
+
+ /* end of request line */
+ case s_req_line_almost_done:
+ {
+ if (ch != LF) goto error;
+ state = s_header_field_start;
+ break;
+ }
+
+ case s_header_field_start:
+ {
+ if (ch == CR) {
+ state = s_headers_almost_done;
+ break;
+ }
+
+ if (ch == LF) {
+ /* they might be just sending \n instead of \r\n so this would be
+ * the second \n to denote the end of headers*/
+ state = s_headers_almost_done;
+ goto headers_almost_done;
+ }
+
+ c = TOKEN(ch);
+
+ if (!c) goto error;
+
+ MARK(header_field);
+
+ index = 0;
+ state = s_header_field;
+
+ switch (c) {
+ case 'c':
+ header_state = h_C;
+ break;
+
+ case 'p':
+ header_state = h_matching_proxy_connection;
+ break;
+
+ case 't':
+ header_state = h_matching_transfer_encoding;
+ break;
+
+ case 'u':
+ header_state = h_matching_upgrade;
+ break;
+
+ default:
+ header_state = h_general;
+ break;
+ }
+ break;
+ }
+
+ case s_header_field:
+ {
+ c = TOKEN(ch);
+
+ if (c) {
+ switch (header_state) {
+ case h_general:
+ break;
+
+ case h_C:
+ index++;
+ header_state = (c == 'o' ? h_CO : h_general);
+ break;
+
+ case h_CO:
+ index++;
+ header_state = (c == 'n' ? h_CON : h_general);
+ break;
+
+ case h_CON:
+ index++;
+ switch (c) {
+ case 'n':
+ header_state = h_matching_connection;
+ break;
+ case 't':
+ header_state = h_matching_content_length;
+ break;
+ default:
+ header_state = h_general;
+ break;
+ }
+ break;
+
+ /* connection */
+
+ case h_matching_connection:
+ index++;
+ if (index > sizeof(CONNECTION)-1
+ || c != CONNECTION[index]) {
+ header_state = h_general;
+ } else if (index == sizeof(CONNECTION)-2) {
+ header_state = h_connection;
+ }
+ break;
+
+ /* proxy-connection */
+
+ case h_matching_proxy_connection:
+ index++;
+ if (index > sizeof(PROXY_CONNECTION)-1
+ || c != PROXY_CONNECTION[index]) {
+ header_state = h_general;
+ } else if (index == sizeof(PROXY_CONNECTION)-2) {
+ header_state = h_connection;
+ }
+ break;
+
+ /* content-length */
+
+ case h_matching_content_length:
+ index++;
+ if (index > sizeof(CONTENT_LENGTH)-1
+ || c != CONTENT_LENGTH[index]) {
+ header_state = h_general;
+ } else if (index == sizeof(CONTENT_LENGTH)-2) {
+ header_state = h_content_length;
+ }
+ break;
+
+ /* transfer-encoding */
+
+ case h_matching_transfer_encoding:
+ index++;
+ if (index > sizeof(TRANSFER_ENCODING)-1
+ || c != TRANSFER_ENCODING[index]) {
+ header_state = h_general;
+ } else if (index == sizeof(TRANSFER_ENCODING)-2) {
+ header_state = h_transfer_encoding;
+ }
+ break;
+
+ /* upgrade */
+
+ case h_matching_upgrade:
+ index++;
+ if (index > sizeof(UPGRADE)-1
+ || c != UPGRADE[index]) {
+ header_state = h_general;
+ } else if (index == sizeof(UPGRADE)-2) {
+ header_state = h_upgrade;
+ }
+ break;
+
+ case h_connection:
+ case h_content_length:
+ case h_transfer_encoding:
+ case h_upgrade:
+ if (ch != ' ') header_state = h_general;
+ break;
+
+ default:
+ assert(0 && "Unknown header_state");
+ break;
+ }
+ break;
+ }
+
+ if (ch == ':') {
+ CALLBACK(header_field);
+ state = s_header_value_start;
+ break;
+ }
+
+ if (ch == CR) {
+ state = s_header_almost_done;
+ CALLBACK(header_field);
+ break;
+ }
+
+ if (ch == LF) {
+ CALLBACK(header_field);
+ state = s_header_field_start;
+ break;
+ }
+
+ goto error;
+ }
+
+ case s_header_value_start:
+ {
+ if (ch == ' ') break;
+
+ MARK(header_value);
+
+ state = s_header_value;
+ index = 0;
+
+ c = LOWER(ch);
+
+ if (ch == CR) {
+ CALLBACK(header_value);
+ header_state = h_general;
+ state = s_header_almost_done;
+ break;
+ }
+
+ if (ch == LF) {
+ CALLBACK(header_value);
+ state = s_header_field_start;
+ break;
+ }
+
+ switch (header_state) {
+ case h_upgrade:
+ parser->flags |= F_UPGRADE;
+ header_state = h_general;
+ break;
+
+ case h_transfer_encoding:
+ /* looking for 'Transfer-Encoding: chunked' */
+ if ('c' == c) {
+ header_state = h_matching_transfer_encoding_chunked;
+ } else {
+ header_state = h_general;
+ }
+ break;
+
+ case h_content_length:
+ if (ch < '0' || ch > '9') goto error;
+ parser->content_length = ch - '0';
+ break;
+
+ case h_connection:
+ /* looking for 'Connection: keep-alive' */
+ if (c == 'k') {
+ header_state = h_matching_connection_keep_alive;
+ /* looking for 'Connection: close' */
+ } else if (c == 'c') {
+ header_state = h_matching_connection_close;
+ } else {
+ header_state = h_general;
+ }
+ break;
+
+ default:
+ header_state = h_general;
+ break;
+ }
+ break;
+ }
+
+ case s_header_value:
+ {
+ c = LOWER(ch);
+
+ if (ch == CR) {
+ CALLBACK(header_value);
+ state = s_header_almost_done;
+ break;
+ }
+
+ if (ch == LF) {
+ CALLBACK(header_value);
+ goto header_almost_done;
+ }
+
+ switch (header_state) {
+ case h_general:
+ break;
+
+ case h_connection:
+ case h_transfer_encoding:
+ assert(0 && "Shouldn't get here.");
+ break;
+
+ case h_content_length:
+ if (ch == ' ') break;
+ if (ch < '0' || ch > '9') goto error;
+ parser->content_length *= 10;
+ parser->content_length += ch - '0';
+ break;
+
+ /* Transfer-Encoding: chunked */
+ case h_matching_transfer_encoding_chunked:
+ index++;
+ if (index > sizeof(CHUNKED)-1
+ || c != CHUNKED[index]) {
+ header_state = h_general;
+ } else if (index == sizeof(CHUNKED)-2) {
+ header_state = h_transfer_encoding_chunked;
+ }
+ break;
+
+ /* looking for 'Connection: keep-alive' */
+ case h_matching_connection_keep_alive:
+ index++;
+ if (index > sizeof(KEEP_ALIVE)-1
+ || c != KEEP_ALIVE[index]) {
+ header_state = h_general;
+ } else if (index == sizeof(KEEP_ALIVE)-2) {
+ header_state = h_connection_keep_alive;
+ }
+ break;
+
+ /* looking for 'Connection: close' */
+ case h_matching_connection_close:
+ index++;
+ if (index > sizeof(CLOSE)-1 || c != CLOSE[index]) {
+ header_state = h_general;
+ } else if (index == sizeof(CLOSE)-2) {
+ header_state = h_connection_close;
+ }
+ break;
+
+ case h_transfer_encoding_chunked:
+ case h_connection_keep_alive:
+ case h_connection_close:
+ if (ch != ' ') header_state = h_general;
+ break;
+
+ default:
+ state = s_header_value;
+ header_state = h_general;
+ break;
+ }
+ break;
+ }
+
+ case s_header_almost_done:
+ header_almost_done:
+ {
+ STRICT_CHECK(ch != LF);
+
+ state = s_header_field_start;
+
+ switch (header_state) {
+ case h_connection_keep_alive:
+ parser->flags |= F_CONNECTION_KEEP_ALIVE;
+ break;
+ case h_connection_close:
+ parser->flags |= F_CONNECTION_CLOSE;
+ break;
+ case h_transfer_encoding_chunked:
+ parser->flags |= F_CHUNKED;
+ break;
+ default:
+ break;
+ }
+ break;
+ }
+
+ case s_headers_almost_done:
+ headers_almost_done:
+ {
+ STRICT_CHECK(ch != LF);
+
+ if (parser->flags & F_TRAILING) {
+ /* End of a chunked request */
+ CALLBACK2(message_complete);
+ state = NEW_MESSAGE();
+ break;
+ }
+
+ nread = 0;
+
+ if (parser->flags & F_UPGRADE || parser->method == PHP_HTTP_CONNECT) {
+ parser->upgrade = 1;
+ }
+
+ /* Here we call the headers_complete callback. This is somewhat
+ * different than other callbacks because if the user returns 1, we
+ * will interpret that as saying that this message has no body. This
+ * is needed for the annoying case of recieving a response to a HEAD
+ * request.
+ */
+ if (settings->on_headers_complete) {
+ switch (settings->on_headers_complete(parser)) {
+ case 0:
+ break;
+
+ case 1:
+ parser->flags |= F_SKIPBODY;
+ break;
+
+ default:
+ return p - data; /* Error */
+ }
+ }
+
+ /* Exit, the rest of the connect is in a different protocol. */
+ if (parser->upgrade) {
+ CALLBACK2(message_complete);
+ return (p - data);
+ }
+
+ if (parser->flags & F_SKIPBODY) {
+ CALLBACK2(message_complete);
+ state = NEW_MESSAGE();
+ } else if (parser->flags & F_CHUNKED) {
+ /* chunked encoding - ignore Content-Length header */
+ state = s_chunk_size_start;
+ } else {
+ if (parser->content_length == 0) {
+ /* Content-Length header given but zero: Content-Length: 0\r\n */
+ CALLBACK2(message_complete);
+ state = NEW_MESSAGE();
+ } else if (parser->content_length > 0) {
+ /* Content-Length header given and non-zero */
+ state = s_body_identity;
+ } else {
+ if (parser->type == PHP_HTTP_REQUEST || php_http_should_keep_alive(parser)) {
+ /* Assume content-length 0 - read the next */
+ CALLBACK2(message_complete);
+ state = NEW_MESSAGE();
+ } else {
+ /* Read body until EOF */
+ state = s_body_identity_eof;
+ }
+ }
+ }
+
+ break;
+ }
+
+ case s_body_identity:
+ to_read = MIN(pe - p, (int64_t)parser->content_length);
+ if (to_read > 0) {
+ if (settings->on_body) settings->on_body(parser, p, to_read);
+ p += to_read - 1;
+ parser->content_length -= to_read;
+ if (parser->content_length == 0) {
+ CALLBACK2(message_complete);
+ state = NEW_MESSAGE();
+ }
+ }
+ break;
+
+ /* read until EOF */
+ case s_body_identity_eof:
+ to_read = pe - p;
+ if (to_read > 0) {
+ if (settings->on_body) settings->on_body(parser, p, to_read);
+ p += to_read - 1;
+ }
+ break;
+
+ case s_chunk_size_start:
+ {
+ assert(parser->flags & F_CHUNKED);
+
+ c = unhex[(unsigned char)ch];
+ if (c == -1) goto error;
+ parser->content_length = c;
+ state = s_chunk_size;
+ break;
+ }
+
+ case s_chunk_size:
+ {
+ assert(parser->flags & F_CHUNKED);
+
+ if (ch == CR) {
+ state = s_chunk_size_almost_done;
+ break;
+ }
+
+ c = unhex[(unsigned char)ch];
+
+ if (c == -1) {
+ if (ch == ';' || ch == ' ') {
+ state = s_chunk_parameters;
+ break;
+ }
+ goto error;
+ }
+
+ parser->content_length *= 16;
+ parser->content_length += c;
+ break;
+ }
+
+ case s_chunk_parameters:
+ {
+ assert(parser->flags & F_CHUNKED);
+ /* just ignore this shit. TODO check for overflow */
+ if (ch == CR) {
+ state = s_chunk_size_almost_done;
+ break;
+ }
+ break;
+ }
+
+ case s_chunk_size_almost_done:
+ {
+ assert(parser->flags & F_CHUNKED);
+ STRICT_CHECK(ch != LF);
+
+ if (parser->content_length == 0) {
+ parser->flags |= F_TRAILING;
+ state = s_header_field_start;
+ } else {
+ state = s_chunk_data;
+ }
+ break;
+ }
+
+ case s_chunk_data:
+ {
+ assert(parser->flags & F_CHUNKED);
+
+ to_read = MIN(pe - p, (int64_t)(parser->content_length));
+
+ if (to_read > 0) {
+ if (settings->on_body) settings->on_body(parser, p, to_read);
+ p += to_read - 1;
+ }
+
+ if (to_read == parser->content_length) {
+ state = s_chunk_data_almost_done;
+ }
+
+ parser->content_length -= to_read;
+ break;
+ }
+
+ case s_chunk_data_almost_done:
+ assert(parser->flags & F_CHUNKED);
+ STRICT_CHECK(ch != CR);
+ state = s_chunk_data_done;
+ break;
+
+ case s_chunk_data_done:
+ assert(parser->flags & F_CHUNKED);
+ STRICT_CHECK(ch != LF);
+ state = s_chunk_size_start;
+ break;
+
+ default:
+ assert(0 && "unhandled state");
+ goto error;
+ }
+ }
+
+ CALLBACK_NOCLEAR(header_field);
+ CALLBACK_NOCLEAR(header_value);
+ CALLBACK_NOCLEAR(fragment);
+ CALLBACK_NOCLEAR(query_string);
+ CALLBACK_NOCLEAR(path);
+ CALLBACK_NOCLEAR(url);
+
+ parser->state = state;
+ parser->header_state = header_state;
+ parser->index = index;
+ parser->nread = nread;
+
+ return len;
+
+error:
+ parser->state = s_dead;
+ return (p - data);
+}
+
+
+int
+php_http_should_keep_alive (php_http_parser *parser)
+{
+ if (parser->http_major > 0 && parser->http_minor > 0) {
+ /* HTTP/1.1 */
+ if (parser->flags & F_CONNECTION_CLOSE) {
+ return 0;
+ } else {
+ return 1;
+ }
+ } else {
+ /* HTTP/1.0 or earlier */
+ if (parser->flags & F_CONNECTION_KEEP_ALIVE) {
+ return 1;
+ } else {
+ return 0;
+ }
+ }
+}
+
+
+const char * php_http_method_str (enum php_http_method m)
+{
+ return method_strings[m];
+}
+
+
+void
+php_http_parser_init (php_http_parser *parser, enum php_http_parser_type t)
+{
+ parser->type = t;
+ parser->state = (t == PHP_HTTP_REQUEST ? s_start_req : (t == PHP_HTTP_RESPONSE ? s_start_res : s_start_req_or_res));
+ parser->nread = 0;
+ parser->upgrade = 0;
+ parser->flags = 0;
+ parser->method = 0;
+}
Index: sapi/cli/config.m4
===================================================================
--- sapi/cli/config.m4 (revision 308839)
+++ sapi/cli/config.m4 (working copy)
@@ -14,7 +14,7 @@
SAPI_CLI_PATH=sapi/cli/php
dnl Select SAPI
- PHP_SELECT_SAPI(cli, program, php_cli.c,, '$(SAPI_CLI_PATH)')
+ PHP_SELECT_SAPI(cli, program, php_cli.c php_http_parser.c php_cli_server.c,, '$(SAPI_CLI_PATH)')
case $host_alias in
*aix*)
Index: sapi/cli/php_cli_server.c
===================================================================
--- sapi/cli/php_cli_server.c (revision 0)
+++ sapi/cli/php_cli_server.c (revision 0)
@@ -0,0 +1,2083 @@
+/*
+ +----------------------------------------------------------------------+
+ | PHP Version 5 |
+ +----------------------------------------------------------------------+
+ | Copyright (c) 1997-2011 The PHP Group |
+ +----------------------------------------------------------------------+
+ | This source file is subject to version 3.01 of the PHP license, |
+ | that is bundled with this package in the file LICENSE, and is |
+ | available through the world-wide-web at the following url: |
+ | http://www.php.net/license/3_01.txt |
+ | If you did not receive a copy of the PHP license and are unable to |
+ | obtain it through the world-wide-web, please send a note to |
+ | [email protected] so we can mail you a copy immediately. |
+ +----------------------------------------------------------------------+
+ | Author: Moriyoshi Koizumi <[email protected]> |
+ +----------------------------------------------------------------------+
+*/
+
+/* $Id: php_cli.c 306938 2011-01-01 02:17:06Z felipe $ */
+
+#include <stdio.h>
+#include <fcntl.h>
+#include <assert.h>
+
+#ifdef PHP_WIN32
+#include <process.h>
+#include <io.h>
+#include "win32/time.h"
+#include "win32/signal.h"
+#include "win32/php_registry.h"
+#endif
+
+#ifdef __riscos__
+#include <unixlib/local.h>
+#endif
+
+
+#if HAVE_TIME_H
+#include <time.h>
+#endif
+#if HAVE_SYS_TIME_H
+#include <sys/time.h>
+#endif
+#if HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+#if HAVE_SIGNAL_H
+#include <signal.h>
+#endif
+#if HAVE_SETLOCALE
+#include <locale.h>
+#endif
+
+#include "SAPI.h"
+#include "php.h"
+#include "php_ini.h"
+#include "php_main.h"
+#include "php_globals.h"
+#include "php_variables.h"
+#include "zend_hash.h"
+#include "zend_modules.h"
+#include "fopen_wrappers.h"
+
+#include "zend_compile.h"
+#include "zend_execute.h"
+#include "zend_highlight.h"
+#include "zend_indent.h"
+#include "zend_exceptions.h"
+
+#include "php_getopt.h"
+
+#ifndef PHP_WIN32
+# define php_select(m, r, w, e, t) select(m, r, w, e, t)
+# define SOCK_EINVAL EINVAL
+# define SOCK_EAGAIN EAGAIN
+# define SOCK_EINTR EINTR
+# define SOCK_EADDRINUSE EADDRINUSE
+#else
+# include "win32/select.h"
+# define SOCK_EINVAL WSAEINVAL
+# define SOCK_EAGAIN WSAEWOULDBLOCK
+# define SOCK_EINTR WSAEINTR
+# define SOCK_EADDRINUSE WSAEADDRINUSE
+#endif
+
+#include "ext/standard/file.h" /* for php_set_sock_blocking() :-( */
+#include "ext/standard/php_smart_str.h"
+#include "ext/standard/html.h"
+#include "ext/standard/url.h" /* for php_url_decode() */
+#include "ext/standard/php_string.h" /* for php_dirname() */
+#include "ext/standard/info.h" /* for php_info_print_style() */
+#include "php_network.h"
+
+#include "php_http_parser.h"
+
+typedef struct php_cli_server_poller {
+ fd_set rfds, wfds;
+ struct {
+ fd_set rfds, wfds;
+ } active;
+ php_socket_t max_fd;
+} php_cli_server_poller;
+
+typedef struct php_cli_server_request {
+ enum php_http_method request_method;
+ int protocol_version;
+ char *request_uri;
+ size_t request_uri_len;
+ char *vpath;
+ size_t vpath_len;
+ char *path_translated;
+ size_t path_translated_len;
+ char *path_info;
+ size_t path_info_len;
+ char *query_string;
+ size_t query_string_len;
+ HashTable headers;
+ char *content;
+ size_t content_len;
+ const char *ext;
+ size_t ext_len;
+ struct stat sb;
+} php_cli_server_request;
+
+typedef struct php_cli_server_chunk {
+ struct php_cli_server_chunk *next;
+ enum php_cli_server_chunk_type {
+ PHP_CLI_SERVER_CHUNK_HEAP,
+ PHP_CLI_SERVER_CHUNK_IMMORTAL
+ } type;
+ union {
+ struct { void *block; char *p; size_t len; } heap;
+ struct { const char *p; size_t len; } immortal;
+ } data;
+} php_cli_server_chunk;
+
+typedef struct php_cli_server_buffer {
+ php_cli_server_chunk *first;
+ php_cli_server_chunk *last;
+} php_cli_server_buffer;
+
+typedef struct php_cli_server_content_sender {
+ php_cli_server_buffer buffer;
+} php_cli_server_content_sender;
+
+typedef struct php_cli_server_client {
+ struct php_cli_server *server;
+ php_socket_t sock;
+ struct sockaddr *addr;
+ socklen_t addr_len;
+ char *addr_str;
+ size_t addr_str_len;
+ php_http_parser parser;
+ int request_read:1;
+ char *current_header_name;
+ size_t current_header_name_len;
+ int current_header_name_allocated:1;
+ size_t post_read_offset;
+ php_cli_server_request request;
+ int content_sender_initialized:1;
+ php_cli_server_content_sender content_sender;
+ php_cli_server_buffer capture_buffer;
+ int capturing:1;
+ int file_fd;
+} php_cli_server_client;
+
+typedef struct php_cli_server {
+ php_socket_t server_sock;
+ php_cli_server_poller poller;
+ int is_running;
+ char *host;
+ int port;
+ int address_family;
+ char *document_root;
+ size_t document_root_len;
+ char *router;
+ size_t router_len;
+ socklen_t socklen;
+ HashTable clients;
+} php_cli_server;
+
+typedef struct php_cli_server_http_reponse_status_code_pair {
+ int code;
+ const char *str;
+} php_cli_server_http_reponse_status_code_pair;
+
+typedef struct php_cli_server_ext_mime_type_pair {
+ const char *ext;
+ const char *mime_type;
+} php_cli_server_ext_mime_type_pair;
+
+static php_cli_server_http_reponse_status_code_pair status_map[] = {
+ { 100, "Continue" },
+ { 101, "Switching Protocols" },
+ { 200, "OK" },
+ { 201, "Created" },
+ { 202, "Accepted" },
+ { 203, "Non-Authoritative Information" },
+ { 204, "No Content" },
+ { 205, "Reset Content" },
+ { 206, "Partial Content" },
+ { 300, "Multiple Choices" },
+ { 301, "Moved Permanently" },
+ { 302, "Found" },
+ { 303, "See Other" },
+ { 304, "Not Modified" },
+ { 305, "Use Proxy" },
+ { 307, "Temporary Redirect" },
+ { 400, "Bad Request" },
+ { 401, "Unauthorized" },
+ { 402, "Payment Required" },
+ { 403, "Forbidden" },
+ { 404, "Not Found" },
+ { 405, "Method Not Allowed" },
+ { 406, "Not Acceptable" },
+ { 407, "Proxy Authentication Required" },
+ { 408, "Request Timeout" },
+ { 409, "Conflict" },
+ { 410, "Gone" },
+ { 411, "Length Required" },
+ { 412, "Precondition Failed" },
+ { 413, "Request Entity Too Large" },
+ { 414, "Request-URI Too Long" },
+ { 415, "Unsupported Media Type" },
+ { 416, "Requested Range Not Satisfiable" },
+ { 417, "Expectation Failed" },
+ { 500, "Internal Server Error" },
+ { 501, "Not Implemented" },
+ { 502, "Bad Gateway" },
+ { 503, "Service Unavailable" },
+ { 504, "Gateway Timeout" },
+ { 505, "HTTP Version Not Supported" },
+};
+
+static php_cli_server_http_reponse_status_code_pair template_map[] = {
+ { 404, "<h1 class=\"h\">%s</h1><p>The requested resource %s was not found on this server.</p>" },
+ { 500, "<h1 class=\"h\">%s</h1><p>The server is temporality unavaiable.</p>" }
+};
+
+static php_cli_server_ext_mime_type_pair mime_type_map[] = {
+ { "gif", "image/gif" },
+ { "png", "image/png" },
+ { "jpe", "image/jpeg" },
+ { "jpg", "image/jpeg" },
+ { "jpeg", "image/jpeg" },
+ { "css", "text/css" },
+ { "html", "text/html" },
+ { "txt", "text/plain" },
+ { "js", "text/javascript" },
+ { NULL, NULL }
+};
+
+static size_t php_cli_server_client_send_through(php_cli_server_client *client, const char *str, size_t str_len);
+static php_cli_server_chunk *php_cli_server_chunk_heap_new_self_contained(size_t len);
+static void php_cli_server_buffer_append(php_cli_server_buffer *buffer, php_cli_server_chunk *chunk);
+static void php_cli_server_logf(const char *format TSRMLS_DC, ...);
+
+static void char_ptr_dtor_p(char **p) /* {{{ */
+{
+ pefree(*p, 1);
+} /* }}} */
+
+static char *get_last_error() /* {{{ */
+{
+ return pestrdup(strerror(errno), 1);
+} /* }}} */
+
+static const char *get_status_string(int code) /* {{{ */
+{
+ size_t e = (sizeof(status_map) / sizeof(php_cli_server_http_reponse_status_code_pair));
+ size_t s = 0;
+
+ while (e != s) {
+ size_t c = MIN((e + s + 1) / 2, e - 1);
+ int d = status_map[c].code;
+ if (d > code) {
+ e = c;
+ } else if (d < code) {
+ s = c;
+ } else {
+ return status_map[c].str;
+ }
+ }
+ return NULL;
+} /* }}} */
+
+static const char *get_template_string(int code) /* {{{ */
+{
+ size_t e = (sizeof(template_map) / sizeof(php_cli_server_http_reponse_status_code_pair));
+ size_t s = 0;
+
+ while (e != s) {
+ size_t c = MIN((e + s + 1) / 2, e - 1);
+ int d = template_map[c].code;
+ if (d > code) {
+ e = c;
+ } else if (d < code) {
+ s = c;
+ } else {
+ return template_map[c].str;
+ }
+ }
+ return NULL;
+} /* }}} */
+
+static void append_http_status_line(smart_str* buffer, int protocol_version, int response_code, int persistent) /* {{{ */
+{
+ smart_str_appendl_ex(buffer, "HTTP", 4, persistent);
+ smart_str_appendc_ex(buffer, '/', persistent);
+ smart_str_append_generic_ex(buffer, protocol_version / 100, persistent, int, _unsigned);
+ smart_str_appendc_ex(buffer, '.', persistent);
+ smart_str_append_generic_ex(buffer, protocol_version % 100, persistent, int, _unsigned);
+ smart_str_appendc_ex(buffer, ' ', persistent);
+ smart_str_append_generic_ex(buffer, response_code, persistent, int, _unsigned);
+ smart_str_appendc_ex(buffer, ' ', persistent);
+ smart_str_appends_ex(buffer, get_status_string(response_code), persistent);
+ smart_str_appendl_ex(buffer, "\r\n", 2, persistent);
+} /* }}} */
+
+static void append_essential_headers(smart_str* buffer, php_cli_server_client *client, int persistent) /* {{{ */
+{
+ {
+ char **val;
+ if (SUCCESS == zend_hash_find(&client->request.headers, "Host", sizeof("Host"), (void**)&val)) {
+ smart_str_appendl_ex(buffer, "Host", sizeof("Host") - 1, persistent);
+ smart_str_appendl_ex(buffer, ": ", sizeof(": ") - 1, persistent);
+ smart_str_appends_ex(buffer, *val, persistent);
+ smart_str_appendl_ex(buffer, "\r\n", 2, persistent);
+ }
+ }
+ smart_str_appendl_ex(buffer, "Connection: closed\r\n", sizeof("Connection: closed\r\n") - 1, persistent);
+} /* }}} */
+
+static const char *get_mime_type(const char *ext, size_t ext_len) /* {{{ */
+{
+ php_cli_server_ext_mime_type_pair *pair;
+ for (pair = mime_type_map; pair->ext; pair++) {
+ size_t len = strlen(pair->ext);
+ if (len == ext_len && memcmp(pair->ext, ext, len) == 0) {
+ return pair->mime_type;
+ }
+ }
+ return NULL;
+} /* }}} */
+
+static int sapi_cli_server_startup(sapi_module_struct *sapi_module) /* {{{ */
+{
+ if (php_module_startup(sapi_module, NULL, 0) == FAILURE) {
+ return FAILURE;
+ }
+
+ return SUCCESS;
+} /* }}} */
+
+static int sapi_cli_server_ub_write(const char *str, uint str_length TSRMLS_DC) /* {{{ */
+{
+ php_cli_server_client *client = SG(server_context);
+ if (client->capturing) {
+ php_cli_server_chunk *chunk = php_cli_server_chunk_heap_new_self_contained(str_length);
+ if (!chunk) {
+ zend_bailout();
+ }
+ memmove(chunk->data.heap.p, str, str_length);
+ php_cli_server_buffer_append(&client->capture_buffer, chunk);
+ return str_length;
+ } else {
+ return php_cli_server_client_send_through(client, str, str_length);
+ }
+} /* }}} */
+
+static void sapi_cli_server_flush(void *server_context) /* {{{ */
+{
+ php_cli_server_client *client = server_context;
+ TSRMLS_FETCH();
+
+ if (!client) {
+ return;
+ }
+
+ if (client->sock < 0) {
+ php_handle_aborted_connection();
+ return;
+ }
+
+ if (!SG(headers_sent)) {
+ sapi_send_headers(TSRMLS_C);
+ SG(headers_sent) = 1;
+ }
+} /* }}} */
+
+static int sapi_cli_server_send_headers(sapi_headers_struct *sapi_headers TSRMLS_DC) /* {{{ */
+{
+ php_cli_server_client *client = SG(server_context);
+ smart_str buffer = { 0 };
+ sapi_header_struct *h;
+ zend_llist_position pos;
+
+ if (client->capturing || SG(request_info).no_headers) {
+ return SAPI_HEADER_SENT_SUCCESSFULLY;
+ }
+
+ if (SG(sapi_headers).http_status_line) {
+ smart_str_appends(&buffer, SG(sapi_headers).http_status_line);
+ smart_str_appendl(&buffer, "\r\n", 2);
+ } else {
+ append_http_status_line(&buffer, client->request.protocol_version, SG(sapi_headers).http_response_code, 0);
+ }
+
+ append_essential_headers(&buffer, client, 0);
+
+ h = (sapi_header_struct*)zend_llist_get_first_ex(&sapi_headers->headers, &pos);
+ while (h) {
+ if (!h->header_len) {
+ continue;
+ }
+ smart_str_appendl(&buffer, h->header, h->header_len);
+ smart_str_appendl(&buffer, "\r\n", 2);
+ h = (sapi_header_struct*)zend_llist_get_next_ex(&sapi_headers->headers, &pos);
+ }
+ smart_str_appendl(&buffer, "\r\n", 2);
+
+ php_cli_server_client_send_through(client, buffer.c, buffer.len);
+
+ smart_str_free(&buffer);
+ return SAPI_HEADER_SENT_SUCCESSFULLY;
+}
+/* }}} */
+
+static char *sapi_cli_server_read_cookies(TSRMLS_D) /* {{{ */
+{
+ php_cli_server_client *client = SG(server_context);
+ char **val;
+ if (FAILURE == zend_hash_find(&client->request.headers, "Cookie", sizeof("Cookie"), (void**)&val)) {
+ return NULL;
+ }
+ return *val;
+} /* }}} */
+
+static int sapi_cli_server_read_post(char *buf, uint count_bytes TSRMLS_DC) /* {{{ */
+{
+ php_cli_server_client *client = SG(server_context);
+ if (client->request.content) {
+ size_t content_len = client->request.content_len;
+ size_t nbytes_copied = MIN(client->post_read_offset + count_bytes, content_len) - client->post_read_offset;
+ memmove(buf, client->request.content + client->post_read_offset, nbytes_copied);
+ client->post_read_offset += nbytes_copied;
+ return nbytes_copied;
+ }
+ return 0;
+} /* }}} */
+
+static void sapi_cli_server_register_variable(zval *track_vars_array, const char *key, const char *val TSRMLS_DC) /* {{{ */
+{
+ char *new_val = (char *)val;
+ uint new_val_len;
+ if (sapi_module.input_filter(PARSE_SERVER, (char*)key, &new_val, strlen(val), &new_val_len TSRMLS_CC)) {
+ php_register_variable_safe((char *)key, new_val, new_val_len, track_vars_array TSRMLS_CC);
+ }
+} /* }}} */
+
+static void sapi_cli_server_register_variables(zval *track_vars_array TSRMLS_DC) /* {{{ */
+{
+ php_cli_server_client *client = SG(server_context);
+ sapi_cli_server_register_variable(track_vars_array, "DOCUMENT_ROOT", client->server->document_root TSRMLS_CC);
+ {
+ smart_str buf = { 0 };
+ smart_str_appends(&buf, client->server->host);
+ smart_str_appendc(&buf, ':');
+ smart_str_append_generic_ex(&buf, client->server->port, 0, int, _unsigned);
+ smart_str_0(&buf);
+ sapi_cli_server_register_variable(track_vars_array, "HTTP_HOST", buf.c TSRMLS_CC);
+ smart_str_free(&buf);
+ }
+ {
+ char **val;
+ if (SUCCESS == zend_hash_find(&client->request.headers, "Cookie", sizeof("Cookie"), (void**)&val)) {
+ sapi_cli_server_register_variable(track_vars_array, "HTTP_COOKIE", *val TSRMLS_CC);
+ }
+ }
+ {
+ char **val;
+ if (SUCCESS == zend_hash_find(&client->request.headers, "Referer", sizeof("Referer"), (void**)&val)) {
+ sapi_cli_server_register_variable(track_vars_array, "HTTP_REFERER", *val TSRMLS_CC);
+ }
+ }
+ sapi_cli_server_register_variable(track_vars_array, "REQUEST_URI", client->request.request_uri TSRMLS_CC);
+ sapi_cli_server_register_variable(track_vars_array, "REQUEST_METHOD", SG(request_info).request_method TSRMLS_CC);
+ sapi_cli_server_register_variable(track_vars_array, "PHP_SELF", client->request.vpath TSRMLS_CC);
+ if (SG(request_info).path_translated) {
+ sapi_cli_server_register_variable(track_vars_array, "SCRIPT_FILENAME", SG(request_info).path_translated TSRMLS_CC);
+ }
+ if (client->request.path_info) {
+ sapi_cli_server_register_variable(track_vars_array, "PATH_INFO", client->request.path_info TSRMLS_CC);
+ }
+ if (client->request.query_string) {
+ sapi_cli_server_register_variable(track_vars_array, "QUERY_STRING", client->request.query_string TSRMLS_CC);
+ }
+} /* }}} */
+
+static void sapi_cli_server_log_message(char *msg TSRMLS_DC) /* {{{ */
+{
+ struct timeval tv;
+ struct tm tm;
+ char buf[52];
+ gettimeofday(&tv, NULL);
+ php_localtime_r(&tv.tv_sec, &tm);
+ php_asctime_r(&tm, buf);
+ {
+ size_t l = strlen(buf);
+ if (l > 0) {
+ buf[l - 1] = '\0';
+ } else {
+ memcpy(buf, "unknown", sizeof("unknown"));
+ }
+ }
+ fprintf(stderr, "[%s] %s\n", buf, msg);
+} /* }}} */
+
+/* {{{ sapi_module_struct cli_server_sapi_module
+ */
+sapi_module_struct cli_server_sapi_module = {
+ "cli-server", /* name */
+ "Built-in HTTP server", /* pretty name */
+
+ sapi_cli_server_startup, /* startup */
+ php_module_shutdown_wrapper, /* shutdown */
+
+ NULL, /* activate */
+ NULL, /* deactivate */
+
+ sapi_cli_server_ub_write, /* unbuffered write */
+ sapi_cli_server_flush, /* flush */
+ NULL, /* get uid */
+ NULL, /* getenv */
+
+ php_error, /* error handler */
+
+ NULL, /* header handler */
+ sapi_cli_server_send_headers, /* send headers handler */
+ NULL, /* send header handler */
+
+ sapi_cli_server_read_post, /* read POST data */
+ sapi_cli_server_read_cookies, /* read Cookies */
+
+ sapi_cli_server_register_variables, /* register server variables */
+ sapi_cli_server_log_message, /* Log message */
+ NULL, /* Get request time */
+ NULL, /* Child terminate */
+
+ STANDARD_SAPI_MODULE_PROPERTIES
+}; /* }}} */
+
+static int php_cli_server_poller_ctor(php_cli_server_poller *poller) /* {{{ */
+{
+ FD_ZERO(&poller->rfds);
+ FD_ZERO(&poller->wfds);
+ poller->max_fd = -1;
+ return SUCCESS;
+} /* }}} */
+
+static void php_cli_server_poller_add(php_cli_server_poller *poller, int mode, int fd) /* {{{ */
+{
+ if (mode & POLLIN) {
+ PHP_SAFE_FD_SET(fd, &poller->rfds);
+ }
+ if (mode & POLLOUT) {
+ PHP_SAFE_FD_SET(fd, &poller->wfds);
+ }
+ if (fd > poller->max_fd) {
+ poller->max_fd = fd;
+ }
+} /* }}} */
+
+static void php_cli_server_poller_remove(php_cli_server_poller *poller, int mode, int fd) /* {{{ */
+{
+ if (mode & POLLIN) {
+ PHP_SAFE_FD_CLR(fd, &poller->rfds);
+ }
+ if (mode & POLLOUT) {
+ PHP_SAFE_FD_CLR(fd, &poller->wfds);
+ }
+#ifndef PHP_WIN32
+ if (fd == poller->max_fd) {
+ while (fd > 0) {
+ fd--;
+ if (((unsigned int *)&poller->rfds)[fd / (8 * sizeof(unsigned int))] || ((unsigned int *)&poller->wfds)[fd / (8 * sizeof(unsigned int))]) {
+ break;
+ }
+ fd -= fd % (8 * sizeof(unsigned int));
+ }
+ poller->max_fd = fd;
+ }
+#endif
+} /* }}} */
+
+static int php_cli_server_poller_poll(php_cli_server_poller *poller, const struct timeval *tv) /* {{{ */
+{
+ memcpy(&poller->active.rfds, &poller->rfds, sizeof(poller->rfds));
+ memcpy(&poller->active.wfds, &poller->wfds, sizeof(poller->wfds));
+ return php_select(poller->max_fd + 1, &poller->active.rfds, &poller->active.wfds, NULL, (struct timeval *)tv);
+} /* }}} */
+
+static int php_cli_server_poller_iter_on_active(php_cli_server_poller *poller, void *opaque, int(*callback)(void *, int fd, int events)) /* {{{ */
+{
+ int retval = SUCCESS;
+#ifdef PHP_WIN32
+ struct socket_entry {
+ SOCKET fd;
+ int events;
+ } entries[FD_SETSIZE * 2];
+ php_socket_t fd = 0;
+ size_t i;
+ struct socket_entry *n = entries, *m;
+
+ for (i = 0; i < poller->active.rfds.fd_count; i++) {
+ n->events = POLLIN;
+ n->fd = poller->active.rfds.fd_array[i];
+ n++;
+ }
+
+ m = n;
+ for (i = 0; i < poller->active.wfds.fd_count; i++) {
+ struct socket_entry *e;
+ SOCKET fd = poller->active.wfds.fd_array[i];
+ for (e = entries; e < m; e++) {
+ if (e->fd == fd) {
+ e->events |= POLLOUT;
+ }
+ }
+ if (e == m) {
+ assert(n < entries + FD_SETSIZE * 2);
+ n->events = POLLOUT;
+ n->fd = fd;
+ n++;
+ }
+ }
+
+ {
+ struct socket_entry *e = entries;
+ for (; e < n; e++) {
+ if (SUCCESS != callback(opaque, e->fd, e->events)) {
+ retval = FAILURE;
+ }
+ }
+ }
+
+#else
+ php_socket_t fd = 0;
+ const php_socket_t max_fd = poller->max_fd;
+ const unsigned int *pr = (unsigned int *)&poller->active.rfds,
+ *pw = (unsigned int *)&poller->active.wfds,
+ *e = pr + (max_fd + (8 * sizeof(unsigned int)) - 1) / (8 * sizeof(unsigned int));
+ unsigned int mask;
+ while (pr < e && fd <= max_fd) {
+ for (mask = 1; mask; mask <<= 1, fd++) {
+ int events = (*pr & mask ? POLLIN: 0) | (*pw & mask ? POLLOUT: 0);
+ if (events) {
+ if (SUCCESS != callback(opaque, fd, events)) {
+ retval = FAILURE;
+ }
+ }
+ }
+ pr++;
+ pw++;
+ }
+#endif
+ return retval;
+} /* }}} */
+
+static size_t php_cli_server_chunk_size(const php_cli_server_chunk *chunk) /* {{{ */
+{
+ switch (chunk->type) {
+ case PHP_CLI_SERVER_CHUNK_HEAP:
+ return chunk->data.heap.len;
+ case PHP_CLI_SERVER_CHUNK_IMMORTAL:
+ return chunk->data.immortal.len;
+ }
+ return 0;
+} /* }}} */
+
+static void php_cli_server_chunk_dtor(php_cli_server_chunk *chunk) /* {{{ */
+{
+ switch (chunk->type) {
+ case PHP_CLI_SERVER_CHUNK_HEAP:
+ if (chunk->data.heap.block != chunk) {
+ pefree(chunk->data.heap.block, 1);
+ }
+ break;
+ case PHP_CLI_SERVER_CHUNK_IMMORTAL:
+ break;
+ }
+} /* }}} */
+
+static void php_cli_server_buffer_dtor(php_cli_server_buffer *buffer) /* {{{ */
+{
+ php_cli_server_chunk *chunk, *next;
+ for (chunk = buffer->first; chunk; chunk = next) {
+ next = chunk->next;
+ php_cli_server_chunk_dtor(chunk);
+ pefree(chunk, 1);
+ }
+} /* }}} */
+
+static void php_cli_server_buffer_ctor(php_cli_server_buffer *buffer) /* {{{ */
+{
+ buffer->first = NULL;
+ buffer->last = NULL;
+} /* }}} */
+
+static void php_cli_server_buffer_append(php_cli_server_buffer *buffer, php_cli_server_chunk *chunk) /* {{{ */
+{
+ php_cli_server_chunk *last;
+ for (last = chunk; last->next; last = last->next);
+ if (!buffer->last) {
+ buffer->first = chunk;
+ } else {
+ buffer->last->next = chunk;
+ }
+ buffer->last = last;
+} /* }}} */
+
+static void php_cli_server_buffer_prepend(php_cli_server_buffer *buffer, php_cli_server_chunk *chunk) /* {{{ */
+{
+ php_cli_server_chunk *last;
+ for (last = chunk; last->next; last = last->next);
+ last->next = buffer->first;
+ if (!buffer->last) {
+ buffer->last = last;
+ }
+ buffer->first = chunk;
+} /* }}} */
+
+static size_t php_cli_server_buffer_size(const php_cli_server_buffer *buffer) /* {{{ */
+{
+ php_cli_server_chunk *chunk;
+ size_t retval = 0;
+ for (chunk = buffer->first; chunk; chunk = chunk->next) {
+ retval += php_cli_server_chunk_size(chunk);
+ }
+ return retval;
+} /* }}} */
+
+static php_cli_server_chunk *php_cli_server_chunk_immortal_new(const char *buf, size_t len) /* {{{ */
+{
+ php_cli_server_chunk *chunk = pemalloc(sizeof(php_cli_server_chunk), 1);
+ if (!chunk) {
+ return NULL;
+ }
+
+ chunk->type = PHP_CLI_SERVER_CHUNK_IMMORTAL;
+ chunk->next = NULL;
+ chunk->data.immortal.p = buf;
+ chunk->data.immortal.len = len;
+ return chunk;
+} /* }}} */
+
+static php_cli_server_chunk *php_cli_server_chunk_heap_new(char *block, char *buf, size_t len) /* {{{ */
+{
+ php_cli_server_chunk *chunk = pemalloc(sizeof(php_cli_server_chunk), 1);
+ if (!chunk) {
+ return NULL;
+ }
+
+ chunk->type = PHP_CLI_SERVER_CHUNK_HEAP;
+ chunk->next = NULL;
+ chunk->data.heap.block = block;
+ chunk->data.heap.p = buf;
+ chunk->data.heap.len = len;
+ return chunk;
+} /* }}} */
+
+static php_cli_server_chunk *php_cli_server_chunk_heap_new_self_contained(size_t len) /* {{{ */
+{
+ php_cli_server_chunk *chunk = pemalloc(sizeof(php_cli_server_chunk) + len, 1);
+ if (!chunk) {
+ return NULL;
+ }
+
+ chunk->type = PHP_CLI_SERVER_CHUNK_HEAP;
+ chunk->next = NULL;
+ chunk->data.heap.block = chunk;
+ chunk->data.heap.p = (char *)(chunk + 1);
+ chunk->data.heap.len = len;
+ return chunk;
+} /* }}} */
+
+static void php_cli_server_content_sender_dtor(php_cli_server_content_sender *sender) /* {{{ */
+{
+ php_cli_server_buffer_dtor(&sender->buffer);
+} /* }}} */
+
+static void php_cli_server_content_sender_ctor(php_cli_server_content_sender *sender) /* {{{ */
+{
+ php_cli_server_buffer_ctor(&sender->buffer);
+} /* }}} */
+
+static int php_cli_server_content_sender_send(php_cli_server_content_sender *sender, php_socket_t fd, size_t *nbytes_sent_total) /* {{{ */
+{
+ php_cli_server_chunk *chunk, *next;
+ size_t _nbytes_sent_total = 0;
+
+ for (chunk = sender->buffer.first; chunk; chunk = next) {
+ ssize_t nbytes_sent;
+ next = chunk->next;
+
+ switch (chunk->type) {
+ case PHP_CLI_SERVER_CHUNK_HEAP:
+ nbytes_sent = send(fd, chunk->data.heap.p, chunk->data.heap.len, 0);
+ if (nbytes_sent < 0) {
+ *nbytes_sent_total = _nbytes_sent_total;
+ return php_socket_errno();
+ } else if (nbytes_sent == chunk->data.heap.len) {
+ php_cli_server_chunk_dtor(chunk);
+ pefree(chunk, 1);
+ sender->buffer.first = next;
+ if (!next) {
+ sender->buffer.last = NULL;
+ }
+ } else {
+ chunk->data.heap.p += nbytes_sent;
+ chunk->data.heap.len -= nbytes_sent;
+ }
+ _nbytes_sent_total += nbytes_sent;
+ break;
+
+ case PHP_CLI_SERVER_CHUNK_IMMORTAL:
+ nbytes_sent = send(fd, chunk->data.immortal.p, chunk->data.immortal.len, 0);
+ if (nbytes_sent < 0) {
+ *nbytes_sent_total = _nbytes_sent_total;
+ return php_socket_errno();
+ } else if (nbytes_sent == chunk->data.immortal.len) {
+ php_cli_server_chunk_dtor(chunk);
+ pefree(chunk, 1);
+ sender->buffer.first = next;
+ if (!next) {
+ sender->buffer.last = NULL;
+ }
+ } else {
+ chunk->data.immortal.p += nbytes_sent;
+ chunk->data.immortal.len -= nbytes_sent;
+ }
+ _nbytes_sent_total += nbytes_sent;
+ break;
+ }
+ }
+ *nbytes_sent_total = _nbytes_sent_total;
+ return 0;
+} /* }}} */
+
+static int php_cli_server_content_sender_pull(php_cli_server_content_sender *sender, int fd, size_t *nbytes_read) /* {{{ */
+{
+ ssize_t _nbytes_read;
+ php_cli_server_chunk *chunk = php_cli_server_chunk_heap_new_self_contained(131072);
+
+ _nbytes_read = read(fd, chunk->data.heap.p, chunk->data.heap.len);
+ if (_nbytes_read < 0) {
+ char *errstr = get_last_error();
+ TSRMLS_FETCH();
+ php_cli_server_logf("%s" TSRMLS_CC, errstr);
+ pefree(errstr, 1);
+ php_cli_server_chunk_dtor(chunk);
+ pefree(chunk, 1);
+ return 1;
+ }
+ chunk->data.heap.len = _nbytes_read;
+ php_cli_server_buffer_append(&sender->buffer, chunk);
+ *nbytes_read = _nbytes_read;
+ return 0;
+} /* }}} */
+
+static void php_cli_server_logf(const char *format TSRMLS_DC, ...) /* {{{ */
+{
+ char buf[1024];
+ va_list ap;
+#ifdef ZTS
+ va_start(ap, tsrm_ls);
+#else
+ va_start(ap, format);
+#endif
+ vsnprintf(buf, sizeof(buf), format, ap);
+ va_end(ap);
+ if (sapi_module.log_message) {
+ sapi_module.log_message(buf TSRMLS_CC);
+ }
+} /* }}} */
+
+static int php_network_listen_socket(const char *host, int *port, int socktype, int *af, socklen_t *socklen, char **errstr TSRMLS_DC) /* {{{ */
+{
+ int retval = SOCK_ERR;
+ int err = 0;
+ struct sockaddr *sa = NULL, **p, **sal;
+
+ int num_addrs = php_network_getaddresses(host, socktype, &sal, errstr TSRMLS_CC);
+ if (num_addrs == 0) {
+ return -1;
+ }
+ for (p = sal; *p; p++) {
+ if (sa) {
+ pefree(sa, 1);
+ }
+
+ retval = socket((*p)->sa_family, socktype, 0);
+ if (retval == SOCK_ERR) {
+ continue;
+ }
+
+ switch ((*p)->sa_family) {
+#if HAVE_GETADDRINFO && HAVE_IPV6
+ case AF_INET6:
+ sa = pemalloc(sizeof(struct sockaddr_in6), 1);
+ if (!sa) {
+ closesocket(retval);
+ retval = SOCK_ERR;
+ *errstr = NULL;
+ goto out;
+ }
+ *(struct sockaddr_in6 *)sa = *(struct sockaddr_in6 *)*p;
+ ((struct sockaddr_in6 *)sa)->sin6_port = htons(*port);
+ *socklen = sizeof(struct sockaddr_in6);
+ break;
+#endif
+ case AF_INET:
+ sa = pemalloc(sizeof(struct sockaddr_in), 1);
+ if (!sa) {
+ closesocket(retval);
+ retval = SOCK_ERR;
+ *errstr = NULL;
+ goto out;
+ }
+ *(struct sockaddr_in *)sa = *(struct sockaddr_in *)*p;
+ ((struct sockaddr_in *)sa)->sin_port = htons(*port);
+ *socklen = sizeof(struct sockaddr_in);
+ break;
+ default:
+ /* Unknown family */
+ *socklen = 0;
+ closesocket(retval);
+ continue;
+ }
+
+#ifdef SO_REUSEADDR
+ {
+ int val = 1;
+ setsockopt(retval, SOL_SOCKET, SO_REUSEADDR, (char*)&val, sizeof(val));
+ }
+#endif
+
+ if (bind(retval, sa, *socklen) == SOCK_CONN_ERR) {
+ err = php_socket_errno();
+ if (err == SOCK_EINVAL || err == SOCK_EADDRINUSE) {
+ goto out;
+ }
+ closesocket(retval);
+ retval = SOCK_ERR;
+ continue;
+ }
+ err = 0;
+
+ *af = sa->sa_family;
+ if (*port == 0) {
+ if (getsockname(retval, sa, socklen)) {
+ err = php_socket_errno();
+ goto out;
+ }
+ switch (sa->sa_family) {
+#if HAVE_GETADDRINFO && HAVE_IPV6
+ case AF_INET6:
+ *port = ntohs(((struct sockaddr_in6 *)sa)->sin6_port);
+ break;
+#endif
+ case AF_INET:
+ *port = ntohs(((struct sockaddr_in *)sa)->sin_port);
+ break;
+ }
+ }
+
+ break;
+ }
+
+ if (retval == SOCK_ERR) {
+ goto out;
+ }
+
+ if (listen(retval, SOMAXCONN)) {
+ err = php_socket_errno();
+ goto out;
+ }
+
+out:
+ if (sa) {
+ pefree(sa, 1);
+ }
+ if (sal) {
+ php_network_freeaddresses(sal);
+ }
+ if (err) {
+ if (retval >= 0) {
+ closesocket(retval);
+ }
+ if (errstr) {
+ *errstr = php_socket_strerror(err, NULL, 0);
+ }
+ return SOCK_ERR;
+ }
+ return retval;
+} /* }}} */
+
+static int php_cli_server_request_ctor(php_cli_server_request *req) /* {{{ */
+{
+ req->protocol_version = 0;
+ req->request_uri = NULL;
+ req->request_uri_len = 0;
+ req->vpath = NULL;
+ req->vpath_len = 0;
+ req->path_translated = NULL;
+ req->path_translated_len = 0;
+ req->path_info = NULL;
+ req->path_info_len = 0;
+ req->query_string = NULL;
+ req->query_string_len = 0;
+ zend_hash_init(&req->headers, 0, NULL, (void(*)(void*))char_ptr_dtor_p, 1);
+ req->content = NULL;
+ req->content_len = 0;
+ req->ext = NULL;
+ req->ext_len = 0;
+ return SUCCESS;
+} /* }}} */
+
+static void php_cli_server_request_dtor(php_cli_server_request *req) /* {{{ */
+{
+ if (req->request_uri) {
+ pefree(req->request_uri, 1);
+ }
+ if (req->vpath) {
+ pefree(req->vpath, 1);
+ }
+ if (req->path_translated) {
+ pefree(req->path_translated, 1);
+ }
+ if (req->path_info) {
+ pefree(req->path_info, 1);
+ }
+ if (req->query_string) {
+ pefree(req->query_string, 1);
+ }
+ zend_hash_destroy(&req->headers);
+ if (req->content) {
+ pefree(req->content, 1);
+ }
+} /* }}} */
+
+static void php_cli_server_request_translate_vpath(php_cli_server_request *request, const char *document_root, size_t document_root_len) /* {{{ */
+{
+ struct stat sb;
+ static const char *index_files[] = { "index.html", "index.php", NULL };
+ char *buf = safe_pemalloc(1, request->vpath_len, 1 + document_root_len + 1 + sizeof("index.html"), 1);
+ char *p = buf, *prev_patch = 0, *q, *vpath;
+ memmove(p, document_root, document_root_len);
+ p += document_root_len;
+ vpath = p;
+ if (request->vpath_len > 0 && request->vpath[0] != '/') {
+ *p++ = '/';
+ }
+ memmove(p, request->vpath, request->vpath_len);
+ p += request->vpath_len;
+ *p = '\0';
+ q = p;
+ while (q > buf) {
+ if (!stat(buf, &sb)) {
+ if (sb.st_mode & S_IFDIR) {
+ const char **file = index_files;
+ if (p > buf && p[-1] != '/') {
+ *p++ = '/';
+ }
+ while (*file) {
+ size_t l = strlen(*file);
+ memmove(p, *file, l + 1);
+ if (!stat(buf, &sb) && (sb.st_mode & S_IFREG)) {
+ p += l;
+ break;
+ }
+ file++;
+ }
+ if (!*file) {
+ pefree(buf, 1);
+ return;
+ }
+ }
+ break; /* regular file */
+ }
+ while (q > buf && *(--q) != '/');
+ if (prev_patch) {
+ *prev_patch = '/';
+ }
+ *q = '\0';
+ prev_patch = q;
+ }
+ if (prev_patch) {
+ *prev_patch = '/';
+ request->path_info = pestrndup(prev_patch, p - prev_patch, 1);
+ request->path_info_len = p - prev_patch;
+ pefree(request->vpath, 1);
+ request->vpath = pestrndup(vpath, prev_patch - vpath, 1);
+ request->vpath_len = prev_patch - vpath;
+ *prev_patch = '\0';
+ request->path_translated = buf;
+ request->path_translated_len = prev_patch - buf;
+ } else {
+ pefree(request->vpath, 1);
+ request->vpath = pestrndup(vpath, p - vpath, 1);
+ request->vpath_len = p - vpath;
+ request->path_translated = buf;
+ request->path_translated_len = p - buf;
+ }
+ request->sb = sb;
+} /* }}} */
+
+static void normalize_vpath(char **retval, size_t *retval_len, const char *vpath, size_t vpath_len, int persistent) /* {{{ */
+{
+ char *decoded_vpath = NULL;
+ char *decoded_vpath_end;
+ char *p;
+
+ *retval = NULL;
+
+ decoded_vpath = pestrndup(vpath, vpath_len, persistent);
+ if (!decoded_vpath) {
+ return;
+ }
+
+ decoded_vpath_end = decoded_vpath + php_url_decode(decoded_vpath, vpath_len);
+
+ p = decoded_vpath;
+
+ if (p < decoded_vpath_end && *p == '/') {
+ char *n = p;
+ while (n < decoded_vpath_end && *n == '/') n++;
+ memmove(++p, n, decoded_vpath_end - n);
+ decoded_vpath_end -= n - p;
+ }
+
+ while (p < decoded_vpath_end) {
+ char *n = p;
+ while (n < decoded_vpath_end && *n != '/') n++;
+ if (n - p == 2 && p[0] == '.' && p[1] == '.') {
+ if (p > decoded_vpath) {
+ --p;
+ for (;;) {
+ if (p == decoded_vpath) {
+ if (*p == '/') {
+ p++;
+ }
+ break;
+ }
+ if (*(--p) == '/') {
+ p++;
+ break;
+ }
+ }
+ }
+ while (n < decoded_vpath_end && *n == '/') n++;
+ memmove(p, n, decoded_vpath_end - n);
+ decoded_vpath_end -= n - p;
+ } else if (n - p == 1 && p[0] == '.') {
+ while (n < decoded_vpath_end && *n == '/') n++;
+ memmove(p, n, decoded_vpath_end - n);
+ decoded_vpath_end -= n - p;
+ } else {
+ if (n < decoded_vpath_end) {
+ char *nn = n;
+ while (nn < decoded_vpath_end && *nn == '/') nn++;
+ p = n + 1;
+ memmove(p, nn, decoded_vpath_end - nn);
+ decoded_vpath_end -= nn - p;
+ } else {
+ p = n;
+ }
+ }
+ }
+
+ *decoded_vpath_end = '\0';
+ *retval = decoded_vpath;
+ *retval_len = decoded_vpath_end - decoded_vpath;
+} /* }}} */
+
+/* {{{ php_cli_server_client_read_request */
+static int php_cli_server_client_read_request_on_message_begin(php_http_parser *parser)
+{
+ return 0;
+}
+
+static int php_cli_server_client_read_request_on_path(php_http_parser *parser, const char *at, size_t length)
+{
+ php_cli_server_client *client = parser->data;
+ {
+ char *vpath;
+ size_t vpath_len;
+ normalize_vpath(&vpath, &vpath_len, at, length, 1);
+ client->request.vpath = vpath;
+ client->request.vpath_len = vpath_len;
+ }
+ return 0;
+}
+
+static int php_cli_server_client_read_request_on_query_string(php_http_parser *parser, const char *at, size_t length)
+{
+ php_cli_server_client *client = parser->data;
+ client->request.query_string = pestrndup(at, length, 1);
+ client->request.query_string_len = length;
+ return 0;
+}
+
+static int php_cli_server_client_read_request_on_url(php_http_parser *parser, const char *at, size_t length)
+{
+ php_cli_server_client *client = parser->data;
+ client->request.request_method = parser->method;
+ client->request.request_uri = pestrndup(at, length, 1);
+ client->request.request_uri_len = length;
+ return 0;
+}
+
+static int php_cli_server_client_read_request_on_fragment(php_http_parser *parser, const char *at, size_t length)
+{
+ return 0;
+}
+
+static int php_cli_server_client_read_request_on_header_field(php_http_parser *parser, const char *at, size_t length)
+{
+ php_cli_server_client *client = parser->data;
+ if (client->current_header_name_allocated) {
+ pefree(client->current_header_name, 1);
+ client->current_header_name_allocated = 0;
+ }
+ client->current_header_name = (char *)at;
+ client->current_header_name_len = length;
+ return 0;
+}
+
+static int php_cli_server_client_read_request_on_header_value(php_http_parser *parser, const char *at, size_t length)
+{
+ php_cli_server_client *client = parser->data;
+ char *value = pestrndup(at, length, 1);
+ if (!value) {
+ return 1;
+ }
+ {
+ char *header_name = client->current_header_name;
+ size_t header_name_len = client->current_header_name_len;
+ char c = header_name[header_name_len];
+ header_name[header_name_len] = '\0';
+ zend_hash_add(&client->request.headers, header_name, header_name_len + 1, &value, sizeof(char *), NULL);
+ header_name[header_name_len] = c;
+ }
+
+ if (client->current_header_name_allocated) {
+ pefree(client->current_header_name, 1);
+ client->current_header_name_allocated = 0;
+ }
+ return 0;
+}
+
+static int php_cli_server_client_read_request_on_headers_complete(php_http_parser *parser)
+{
+ php_cli_server_client *client = parser->data;
+ if (client->current_header_name_allocated) {
+ pefree(client->current_header_name, 1);
+ client->current_header_name_allocated = 0;
+ }
+ client->current_header_name = NULL;
+ return 0;
+}
+
+static int php_cli_server_client_read_request_on_body(php_http_parser *parser, const char *at, size_t length)
+{
+ php_cli_server_client *client = parser->data;
+ if (!client->request.content) {
+ client->request.content = pemalloc(parser->content_length, 1);
+ client->request.content_len = 0;
+ }
+ memmove(client->request.content + client->request.content_len, at, length);
+ client->request.content_len += length;
+ return 0;
+}
+
+static int php_cli_server_client_read_request_on_message_complete(php_http_parser *parser)
+{
+ php_cli_server_client *client = parser->data;
+ client->request.protocol_version = parser->http_major * 100 + parser->http_minor;
+ php_cli_server_request_translate_vpath(&client->request, client->server->document_root, client->server->document_root_len);
+ {
+ const char *vpath = client->request.vpath, *end = vpath + client->request.vpath_len, *p = end;
+ client->request.ext = end;
+ client->request.ext_len = 0;
+ while (p > vpath) {
+ --p;
+ if (*p == '.') {
+ ++p;
+ client->request.ext = p;
+ client->request.ext_len = end - p;
+ break;
+ }
+ }
+ }
+ client->request_read = 1;
+ return 0;
+}
+
+static int php_cli_server_client_read_request(php_cli_server_client *client, char **errstr TSRMLS_DC)
+{
+ char buf[16384];
+ static const php_http_parser_settings settings = {
+ php_cli_server_client_read_request_on_message_begin,
+ php_cli_server_client_read_request_on_path,
+ php_cli_server_client_read_request_on_query_string,
+ php_cli_server_client_read_request_on_url,
+ php_cli_server_client_read_request_on_fragment,
+ php_cli_server_client_read_request_on_header_field,
+ php_cli_server_client_read_request_on_header_value,
+ php_cli_server_client_read_request_on_headers_complete,
+ php_cli_server_client_read_request_on_body,
+ php_cli_server_client_read_request_on_message_complete
+ };
+ size_t nbytes_consumed;
+ int nbytes_read;
+ if (client->request_read) {
+ return 1;
+ }
+ nbytes_read = recv(client->sock, buf, sizeof(buf) - 1, 0);
+ if (nbytes_read < 0) {
+ int err = php_socket_errno();
+ if (err == SOCK_EAGAIN) {
+ return 0;
+ }
+ *errstr = php_socket_strerror(err, NULL, 0);
+ return -1;
+ } else if (nbytes_read == 0) {
+ *errstr = estrdup("Unexpected EOF");
+ return -1;
+ }
+ client->parser.data = client;
+ nbytes_consumed = php_http_parser_execute(&client->parser, &settings, buf, nbytes_read);
+ if (nbytes_consumed != nbytes_read) {
+ *errstr = estrdup("Malformed HTTP request");
+ return -1;
+ }
+ if (client->current_header_name) {
+ char *header_name = safe_pemalloc(client->current_header_name_len, 1, 1, 1);
+ memcpy(header_name, client->current_header_name, client->current_header_name_len);
+ client->current_header_name = header_name;
+ client->current_header_name_allocated = 1;
+ }
+ return client->request_read ? 1: 0;
+}
+/* }}} */
+
+static size_t php_cli_server_client_send_through(php_cli_server_client *client, const char *str, size_t str_len) /* }}} */
+{
+ struct timeval tv = { 10, 0 };
+ ssize_t nbytes_left = str_len;
+ do {
+ ssize_t nbytes_sent = send(client->sock, str, str_len, 0);
+ if (nbytes_sent < 0) {
+ int err = php_socket_errno();
+ if (err == EAGAIN) {
+ int nfds = php_pollfd_for(client->sock, POLLOUT, &tv);
+ if (nfds > 0) {
+ continue;
+ } else if (nfds < 0) {
+ /* error */
+ php_handle_aborted_connection();
+ return nbytes_left;
+ } else {
+ /* timeout */
+ php_handle_aborted_connection();
+ return nbytes_left;
+ }
+ } else {
+ php_handle_aborted_connection();
+ return nbytes_left;
+ }
+ }
+ nbytes_left -= nbytes_sent;
+ } while (nbytes_left > 0);
+
+ return str_len;
+} /* }}} */
+
+static void php_cli_server_client_populate_request_info(const php_cli_server_client *client, sapi_request_info *request_info) /* {{{ */
+{
+ request_info->request_method = php_http_method_str(client->request.request_method);
+ request_info->proto_num = client->request.protocol_version;
+ request_info->request_uri = client->request.request_uri;
+ request_info->path_translated = client->request.path_translated;
+ request_info->query_string = client->request.query_string;
+ request_info->post_data = client->request.content;
+ request_info->content_length = request_info->post_data_length = client->request.content_len;
+ {
+ char **val;
+ if (SUCCESS == zend_hash_find(&client->request.headers, "Content-Type", sizeof("Content-Type"), (void**)&val)) {
+ request_info->content_type = *val;
+ }
+ }
+} /* }}} */
+
+static void destroy_request_info(sapi_request_info *request_info) /* {{{ */
+{
+} /* }}} */
+
+static void php_cli_server_client_begin_capture(php_cli_server_client *client) /* {{{ */
+{
+ php_cli_server_buffer_ctor(&client->capture_buffer);
+ client->capturing = 1;
+} /* }}} */
+
+static void php_cli_server_client_end_capture(php_cli_server_client *client) /* {{{ */
+{
+ client->capturing = 0;
+ php_cli_server_buffer_dtor(&client->capture_buffer);
+} /* }}} */
+
+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) /* {{{ */
+{
+ client->server = server;
+ client->sock = client_sock;
+ client->addr = addr;
+ client->addr_len = addr_len;
+ {
+ char *addr_str = 0;
+ long addr_str_len = 0;
+ php_network_populate_name_from_sockaddr(addr, addr_len, &addr_str, &addr_str_len, NULL, 0 TSRMLS_CC);
+ client->addr_str = pestrndup(addr_str, addr_str_len, 1);
+ client->addr_str_len = addr_str_len;
+ efree(addr_str);
+ }
+ php_http_parser_init(&client->parser, PHP_HTTP_REQUEST);
+ client->request_read = 0;
+ client->current_header_name = NULL;
+ client->current_header_name_len = 0;
+ client->current_header_name_allocated = 0;
+ client->post_read_offset = 0;
+ if (FAILURE == php_cli_server_request_ctor(&client->request)) {
+ return FAILURE;
+ }
+ client->content_sender_initialized = 0;
+ client->capturing = 0;
+ client->file_fd = -1;
+ return SUCCESS;
+} /* }}} */
+
+static void php_cli_server_client_dtor(php_cli_server_client *client) /* {{{ */
+{
+ php_cli_server_request_dtor(&client->request);
+ if (client->file_fd >= 0) {
+ close(client->file_fd);
+ client->file_fd = -1;
+ }
+ pefree(client->addr, 1);
+ pefree(client->addr_str, 1);
+ if (client->content_sender_initialized) {
+ php_cli_server_content_sender_dtor(&client->content_sender);
+ }
+ if (client->capturing) {
+ php_cli_server_buffer_dtor(&client->capture_buffer);
+ }
+} /* }}} */
+
+static void php_cli_server_close_connection(php_cli_server *server, php_cli_server_client *client TSRMLS_DC) /* {{{ */
+{
+#ifdef DEBUG
+ php_cli_server_logf("%s: Closing" TSRMLS_CC, client->addr_str);
+#endif
+ zend_hash_index_del(&server->clients, client->sock);
+} /* }}} */
+
+static int php_cli_server_send_error_page(php_cli_server *server, php_cli_server_client *client, int status TSRMLS_DC) /* {{{ */
+{
+ char *escaped_request_uri = NULL;
+ size_t escaped_request_uri_len;
+ const char *status_string = get_status_string(status);
+ const char *content_template = get_template_string(status);
+ assert(status_string && content_template);
+
+ php_cli_server_content_sender_ctor(&client->content_sender);
+ client->content_sender_initialized = 1;
+
+ 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);
+
+ {
+ static const char prologue_template[] = "<html><head><title>%d %s</title>";
+ php_cli_server_chunk *chunk = php_cli_server_chunk_heap_new_self_contained(strlen(prologue_template) + 3 + strlen(status_string) + 1);
+ if (!chunk) {
+ goto fail;
+ }
+ snprintf(chunk->data.heap.p, chunk->data.heap.len, prologue_template, status, status_string, escaped_request_uri);
+ chunk->data.heap.len = strlen(chunk->data.heap.p);
+ php_cli_server_buffer_append(&client->content_sender.buffer, chunk);
+ }
+ {
+ int err = 0;
+ sapi_activate_headers_only(TSRMLS_C);
+ php_cli_server_client_begin_capture(client);
+ zend_try {
+ php_info_print_style(TSRMLS_C);
+ php_cli_server_buffer_append(&client->content_sender.buffer, client->capture_buffer.first);
+ client->capture_buffer.first = client->capture_buffer.last = NULL;
+ } zend_catch {
+ err = 1;
+ } zend_end_try();
+ php_cli_server_client_end_capture(client);
+ sapi_deactivate(TSRMLS_C);
+ if (err) {
+ goto fail;
+ }
+ }
+ {
+ static const char template[] = "</head><body>";
+ php_cli_server_chunk *chunk = php_cli_server_chunk_immortal_new(template, sizeof(template) - 1);
+ if (!chunk) {
+ goto fail;
+ }
+ php_cli_server_buffer_append(&client->content_sender.buffer, chunk);
+ }
+ {
+ 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);
+ if (!chunk) {
+ goto fail;
+ }
+ snprintf(chunk->data.heap.p, chunk->data.heap.len, content_template, status_string, escaped_request_uri);
+ chunk->data.heap.len = strlen(chunk->data.heap.p);
+ php_cli_server_buffer_append(&client->content_sender.buffer, chunk);
+ }
+ {
+ static const char epilogue_template[] = "</body></html>";
+ php_cli_server_chunk *chunk = php_cli_server_chunk_immortal_new(epilogue_template, sizeof(epilogue_template) - 1);
+ if (!chunk) {
+ goto fail;
+ }
+ php_cli_server_buffer_append(&client->content_sender.buffer, chunk);
+ }
+
+ {
+ php_cli_server_chunk *chunk;
+ smart_str buffer = { 0 };
+ append_http_status_line(&buffer, client->request.protocol_version, status, 1);
+ if (!buffer.c) {
+ /* out of memory */
+ goto fail;
+ }
+ append_essential_headers(&buffer, client, 1);
+ smart_str_appends_ex(&buffer, "Content-Type: text/html; charset=UTF-8\r\n", 1);
+ smart_str_appends_ex(&buffer, "Content-Length: ", 1);
+ smart_str_append_generic_ex(&buffer, php_cli_server_buffer_size(&client->content_sender.buffer), 1, size_t, _unsigned);
+ smart_str_appendl_ex(&buffer, "\r\n", 2, 1);
+ smart_str_appendl_ex(&buffer, "\r\n", 2, 1);
+
+ chunk = php_cli_server_chunk_heap_new(buffer.c, buffer.c, buffer.len);
+ if (!chunk) {
+ smart_str_free_ex(&buffer, 1);
+ goto fail;
+ }
+ php_cli_server_buffer_prepend(&client->content_sender.buffer, chunk);
+ }
+
+ php_cli_server_logf("%s: %s - Sending error page (%d)" TSRMLS_CC, client->addr_str, client->request.request_uri, status);
+ php_cli_server_poller_add(&server->poller, POLLOUT, client->sock);
+ efree(escaped_request_uri);
+ return SUCCESS;
+
+fail:
+ efree(escaped_request_uri);
+ return FAILURE;
+} /* }}} */
+
+static int php_cli_server_dispatch_script(php_cli_server *server, php_cli_server_client *client TSRMLS_DC) /* {{{ */
+{
+ php_cli_server_client_populate_request_info(client, &SG(request_info));
+ {
+ zval **val;
+ if (SUCCESS == zend_hash_find(&client->request.headers, "Authorization", sizeof("Authorization"), (void**)&val)) {
+ php_handle_auth_data(Z_STRVAL_PP(val) TSRMLS_CC);
+ }
+ }
+ SG(sapi_headers).http_response_code = 200;
+ if (FAILURE == php_request_startup(TSRMLS_C)) {
+ /* should never be happen */
+ destroy_request_info(&SG(request_info));
+ return FAILURE;
+ }
+ {
+ zend_file_handle zfd;
+ zfd.type = ZEND_HANDLE_FILENAME;
+ zfd.filename = SG(request_info).path_translated;
+ zfd.handle.fp = NULL;
+ zfd.free_filename = 0;
+ zfd.opened_path = NULL;
+ zend_try {
+ php_execute_script(&zfd TSRMLS_CC);
+ } zend_end_try();
+ }
+
+ php_request_shutdown(0);
+ php_cli_server_close_connection(server, client TSRMLS_CC);
+ destroy_request_info(&SG(request_info));
+ return SUCCESS;
+} /* }}} */
+
+static int php_cli_server_begin_send_static(php_cli_server *server, php_cli_server_client *client TSRMLS_DC) /* {{{ */
+{
+ int fd;
+ int status = 200;
+
+ fd = client->request.path_translated ? open(client->request.path_translated, O_RDONLY): -1;
+ if (fd < 0) {
+ char *errstr = get_last_error();
+ if (errstr) {
+ php_cli_server_logf("%s: %s - %s" TSRMLS_CC, client->addr_str, client->request.request_uri, errstr);
+ pefree(errstr, 1);
+ } else {
+ php_cli_server_logf("%s: %s - ?" TSRMLS_CC, client->addr_str, client->request.request_uri);
+ }
+ return php_cli_server_send_error_page(server, client, 404 TSRMLS_CC);
+ }
+
+ php_cli_server_content_sender_ctor(&client->content_sender);
+ client->content_sender_initialized = 1;
+ client->file_fd = fd;
+
+ {
+ php_cli_server_chunk *chunk;
+ smart_str buffer = { 0 };
+ const char *mime_type = get_mime_type(client->request.ext, client->request.ext_len);
+ if (!mime_type) {
+ mime_type = "application/octet-stream";
+ }
+
+ append_http_status_line(&buffer, client->request.protocol_version, status, 1);
+ if (!buffer.c) {
+ /* out of memory */
+ return FAILURE;
+ }
+ append_essential_headers(&buffer, client, 1);
+ smart_str_appendl_ex(&buffer, "Content-Type: ", sizeof("Content-Type: ") - 1, 1);
+ smart_str_appends_ex(&buffer, mime_type, 1);
+ if (strncmp(mime_type, "text/", 5) == 0) {
+ smart_str_appends_ex(&buffer, "; charset=UTF-8", 1);
+ }
+ smart_str_appendl_ex(&buffer, "\r\n", 2, 1);
+ smart_str_appends_ex(&buffer, "Content-Length: ", 1);
+ smart_str_append_generic_ex(&buffer, client->request.sb.st_size, 1, size_t, _unsigned);
+ smart_str_appendl_ex(&buffer, "\r\n", 2, 1);
+ smart_str_appendl_ex(&buffer, "\r\n", 2, 1);
+ chunk = php_cli_server_chunk_heap_new(buffer.c, buffer.c, buffer.len);
+ if (!chunk) {
+ smart_str_free_ex(&buffer, 1);
+ return FAILURE;
+ }
+ php_cli_server_buffer_append(&client->content_sender.buffer, chunk);
+ }
+ php_cli_server_poller_add(&server->poller, POLLOUT, client->sock);
+ return SUCCESS;
+}
+/* }}} */
+
+static int php_cli_server_dispatch_router(php_cli_server *server, php_cli_server_client *client TSRMLS_DC) /* {{{ */
+{
+ int decline = 0;
+
+ if (!server->router) {
+ return 1;
+ }
+
+ php_cli_server_client_populate_request_info(client, &SG(request_info));
+ {
+ zval **val;
+ if (SUCCESS == zend_hash_find(&client->request.headers, "Authorization", sizeof("Authorization"), (void**)&val)) {
+ php_handle_auth_data(Z_STRVAL_PP(val) TSRMLS_CC);
+ }
+ }
+ SG(sapi_headers).http_response_code = 200;
+ if (FAILURE == php_request_startup(TSRMLS_C)) {
+ /* should never be happen */
+ destroy_request_info(&SG(request_info));
+ return -1;
+ }
+ {
+ zend_file_handle zfd;
+ zfd.type = ZEND_HANDLE_FILENAME;
+ zfd.filename = server->router;
+ zfd.handle.fp = NULL;
+ zfd.free_filename = 0;
+ zfd.opened_path = NULL;
+ zend_try {
+ zval *retval = NULL;
+ if (SUCCESS == zend_execute_scripts(ZEND_REQUIRE TSRMLS_CC, &retval, 1, &zfd)) {
+ if (retval) {
+ decline = Z_TYPE_P(retval) == IS_BOOL && !Z_LVAL_P(retval);
+ zval_ptr_dtor(&retval);
+ }
+ } else {
+ decline = 1;
+ }
+ } zend_end_try();
+ }
+
+ if (decline) {
+ php_request_shutdown_for_hook(0);
+ } else {
+ php_request_shutdown(0);
+ php_cli_server_close_connection(server, client TSRMLS_CC);
+ }
+ destroy_request_info(&SG(request_info));
+
+ return decline ? 1: 0;
+}
+/* }}} */
+
+static int php_cli_server_dispatch(php_cli_server *server, php_cli_server_client *client TSRMLS_DC) /* {{{ */
+{
+ int status;
+
+ SG(server_context) = client;
+ status = php_cli_server_dispatch_router(server, client TSRMLS_CC);
+
+ if (status < 0) {
+ goto fail;
+ } else if (status > 0) {
+ if (client->request.ext_len == 3 && memcmp(client->request.ext, "php", 3) == 0 && client->request.path_translated) {
+ if (SUCCESS != php_cli_server_dispatch_script(server, client TSRMLS_CC) &&
+ SUCCESS != php_cli_server_send_error_page(server, client, 500 TSRMLS_CC)) {
+ goto fail;
+ }
+ } else {
+ if (SUCCESS != php_cli_server_begin_send_static(server, client TSRMLS_CC)) {
+ goto fail;
+ }
+ }
+ }
+ SG(server_context) = 0;
+ return SUCCESS;
+fail:
+ SG(server_context) = 0;
+ php_cli_server_close_connection(server, client TSRMLS_CC);
+ return SUCCESS;
+}
+
+static void php_cli_server_dtor(php_cli_server *server TSRMLS_DC) /* {{{ */
+{
+ zend_hash_destroy(&server->clients);
+ if (server->server_sock >= 0) {
+ closesocket(server->server_sock);
+ }
+ if (server->host) {
+ pefree(server->host, 1);
+ }
+ if (server->document_root) {
+ pefree(server->document_root, 1);
+ }
+ if (server->router) {
+ pefree(server->router, 1);
+ }
+} /* }}} */
+
+static void php_cli_server_client_dtor_wrapper(php_cli_server_client **p) /* {{{ */
+{
+ closesocket((*p)->sock);
+ php_cli_server_poller_remove(&(*p)->server->poller, POLLIN | POLLOUT, (*p)->sock);
+ php_cli_server_client_dtor(*p);
+ pefree(*p, 1);
+} /* }}} */
+
+static int php_cli_server_ctor(php_cli_server *server, const char *addr, const char *document_root, const char *router TSRMLS_DC) /* {{{ */
+{
+ int retval = SUCCESS;
+ char *host = NULL;
+ char *errstr = NULL;
+ char *_document_root = NULL;
+ char *_router = NULL;
+ int err = 0;
+ int port = 3000;
+ php_socket_t server_sock = SOCK_ERR;
+
+ host = pestrdup(addr, 1);
+ if (!host) {
+ return FAILURE;
+ }
+
+ {
+ char *p = strchr(host, ':');
+ if (p) {
+ *p++ = '\0';
+ port = strtol(p, &p, 10);
+ }
+ }
+
+ server_sock = php_network_listen_socket(host, &port, SOCK_STREAM, &server->address_family, &server->socklen, &errstr TSRMLS_CC);
+ if (server_sock == SOCK_ERR) {
+ php_cli_server_logf("Failed to listen on %s:%d (reason: %s)" TSRMLS_CC, host, port, errstr ? errstr: "?");
+ efree(errstr);
+ retval = FAILURE;
+ goto out;
+ }
+ server->server_sock = server_sock;
+
+ err = php_cli_server_poller_ctor(&server->poller);
+ if (SUCCESS != err) {
+ goto out;
+ }
+
+ php_cli_server_poller_add(&server->poller, POLLIN, server_sock);
+
+ server->host = host;
+ server->port = port;
+
+ zend_hash_init(&server->clients, 0, NULL, (void(*)(void*))php_cli_server_client_dtor_wrapper, 1);
+
+ {
+ size_t document_root_len = strlen(document_root);
+ _document_root = pestrndup(document_root, document_root_len, 1);
+ if (!_document_root) {
+ retval = FAILURE;
+ goto out;
+ }
+ server->document_root = _document_root;
+ server->document_root_len = document_root_len;
+ }
+
+ if (router) {
+ size_t router_len = strlen(router);
+ _router = pestrndup(router, router_len, 1);
+ if (!_router) {
+ retval = FAILURE;
+ goto out;
+ }
+ server->router = _router;
+ server->router_len = router_len;
+ } else {
+ server->router = NULL;
+ server->router_len = 0;
+ }
+
+ server->is_running = 1;
+out:
+ if (retval != SUCCESS) {
+ if (host) {
+ pefree(host, 1);
+ }
+ if (_document_root) {
+ pefree(_document_root, 1);
+ }
+ if (_router) {
+ pefree(_router, 1);
+ }
+ if (server_sock >= -1) {
+ closesocket(server_sock);
+ }
+ }
+ return retval;
+} /* }}} */
+
+static int php_cli_server_recv_event_read_request(php_cli_server *server, php_cli_server_client *client TSRMLS_DC) /* {{{ */
+{
+ char *errstr = NULL;
+ int status = php_cli_server_client_read_request(client, &errstr TSRMLS_CC);
+ if (status < 0) {
+ php_cli_server_logf("%s: Invalid request (%s)" TSRMLS_CC, client->addr_str, errstr);
+ efree(errstr);
+ php_cli_server_close_connection(server, client TSRMLS_CC);
+ return FAILURE;
+ } else if (status == 1) {
+ php_cli_server_logf("%s: %s" TSRMLS_CC, client->addr_str, client->request.request_uri);
+ php_cli_server_poller_remove(&server->poller, POLLIN, client->sock);
+ php_cli_server_dispatch(server, client TSRMLS_CC);
+ } else {
+ php_cli_server_poller_add(&server->poller, POLLIN, client->sock);
+ }
+
+ return SUCCESS;
+} /* }}} */
+
+static int php_cli_server_send_event(php_cli_server *server, php_cli_server_client *client TSRMLS_DC) /* {{{ */
+{
+ if (client->content_sender_initialized) {
+ if (client->file_fd >= 0 && !client->content_sender.buffer.first) {
+ size_t nbytes_read;
+ if (php_cli_server_content_sender_pull(&client->content_sender, client->file_fd, &nbytes_read)) {
+ php_cli_server_close_connection(server, client TSRMLS_CC);
+ return FAILURE;
+ }
+ if (nbytes_read == 0) {
+ close(client->file_fd);
+ client->file_fd = -1;
+ }
+ }
+ {
+ size_t nbytes_sent;
+ int err = php_cli_server_content_sender_send(&client->content_sender, client->sock, &nbytes_sent);
+ if (err && err != SOCK_EAGAIN) {
+ php_cli_server_close_connection(server, client TSRMLS_CC);
+ return FAILURE;
+ }
+ }
+ if (!client->content_sender.buffer.first && client->file_fd < 0) {
+ php_cli_server_close_connection(server, client TSRMLS_CC);
+ }
+ }
+ return SUCCESS;
+}
+/* }}} */
+
+typedef struct php_cli_server_do_event_for_each_fd_callback_params {
+#ifdef ZTS
+ void ***tsrm_ls;
+#endif
+ 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);
+} php_cli_server_do_event_for_each_fd_callback_params;
+
+static int php_cli_server_do_event_for_each_fd_callback(void *_params, int fd, int event)
+{
+ php_cli_server_do_event_for_each_fd_callback_params *params = _params;
+#ifdef ZTS
+ void ***tsrm_ls = params->tsrm_ls;
+#endif
+ php_cli_server *server = params->server;
+ if (server->server_sock == fd) {
+ php_cli_server_client *client = NULL;
+ php_socket_t client_sock;
+ socklen_t socklen = server->socklen;
+ struct sockaddr *sa = pemalloc(server->socklen, 1);
+ if (!sa) {
+ return FAILURE;
+ }
+ client_sock = accept(server->server_sock, sa, &socklen);
+ if (client_sock < 0) {
+ char *errstr;
+ errstr = php_socket_strerror(php_socket_errno(), NULL, 0);
+ php_cli_server_logf("Failed to accept a client (reason: %s)" TSRMLS_CC, errstr);
+ efree(errstr);
+ pefree(sa, 1);
+ return SUCCESS;
+ }
+ if (SUCCESS != php_set_sock_blocking(client_sock, 0 TSRMLS_CC)) {
+ pefree(sa, 1);
+ closesocket(client_sock);
+ return SUCCESS;
+ }
+ if (!(client = pemalloc(sizeof(php_cli_server_client), 1)) || FAILURE == php_cli_server_client_ctor(client, server, client_sock, sa, socklen TSRMLS_CC)) {
+ php_cli_server_logf("Failed to create a new request object" TSRMLS_CC);
+ pefree(sa, 1);
+ closesocket(client_sock);
+ return SUCCESS;
+ }
+#ifdef DEBUG
+ php_cli_server_logf("%s: Accepted" TSRMLS_CC, client->addr_str);
+#endif
+ zend_hash_index_update(&server->clients, client_sock, &client, sizeof(client), NULL);
+ php_cli_server_recv_event_read_request(server, client TSRMLS_CC);
+ } else {
+ php_cli_server_client **client;
+ if (SUCCESS == zend_hash_index_find(&server->clients, fd, (void **)&client)) {
+ if (event & POLLIN) {
+ params->rhandler(server, *client TSRMLS_CC);
+ }
+ if (event & POLLOUT) {
+ params->whandler(server, *client TSRMLS_CC);
+ }
+ }
+ }
+ return SUCCESS;
+}
+
+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) /* {{{ */
+{
+ php_cli_server_do_event_for_each_fd_callback_params params = {
+#ifdef ZTS
+ tsrm_ls,
+#endif
+ server,
+ rhandler,
+ whandler
+ };
+
+ php_cli_server_poller_iter_on_active(&server->poller, &params, php_cli_server_do_event_for_each_fd_callback);
+} /* }}} */
+
+static int php_cli_server_do_event_loop(php_cli_server *server TSRMLS_DC) /* {{{ */
+{
+ int retval = SUCCESS;
+ while (server->is_running) {
+ static const struct timeval tv = { 1, 0 };
+ int n = php_cli_server_poller_poll(&server->poller, &tv);
+ if (n > 0) {
+ php_cli_server_do_event_for_each_fd(server,
+ php_cli_server_recv_event_read_request,
+ php_cli_server_send_event TSRMLS_CC);
+ } else if (n == 0) {
+ /* do nothing */
+ } else {
+ int err = php_socket_errno();
+ if (err != SOCK_EINTR) {
+ char *errstr = php_socket_strerror(err, NULL, 0);
+ php_cli_server_logf("%s" TSRMLS_CC, errstr);
+ efree(errstr);
+ retval = FAILURE;
+ goto out;
+ }
+ }
+ }
+out:
+ return retval;
+} /* }}} */
+
+
+static php_cli_server server;
+
+static void php_cli_server_sigint_handler(int sig)
+{
+ server.is_running = 0;
+};
+
+int do_cli_server(int argc, char **argv TSRMLS_DC) /* {{{ */
+{
+ char *php_optarg = NULL;
+ int php_optind = 1;
+ int c;
+ const char *server_bind_address = NULL;
+ extern const opt_struct OPTIONS[];
+ char buf[MAXPATHLEN];
+ const char *document_root;
+ const char *router = NULL;
+
+ while ((c = php_getopt(argc, argv, OPTIONS, &php_optarg, &php_optind, 0, 2))!=-1) {
+ switch (c) {
+ case 'S':
+ server_bind_address = php_optarg;
+ break;
+ }
+ }
+
+ if (argc > php_optind) {
+ struct stat sb;
+ document_root = argv[php_optind];
+ if (stat(document_root, &sb)) {
+ fprintf(stderr, "Directory or script %s does not exist.\n", document_root);
+ return 1;
+ }
+ if ((sb.st_mode & S_IFREG)) {
+ strncpy(buf, document_root, sizeof(buf) - 1);
+ php_dirname(buf, strlen(buf));
+ router = document_root;
+ document_root = buf;
+ } else if (!(sb.st_mode & S_IFDIR)) {
+ fprintf(stderr, "%s is neither a directory nor a script.\n", document_root);
+ return 1;
+ }
+ } else {
+ document_root = getcwd(buf, sizeof(buf));
+ }
+
+ if (FAILURE == php_cli_server_ctor(&server, server_bind_address, document_root, router TSRMLS_CC)) {
+ return 1;
+ }
+ sapi_module.phpinfo_as_text = 0;
+
+ printf("Server is listening on %s:%d... Press CTRL-C to quit.\n", server.host, server.port);
+
+#if defined(HAVE_SIGNAL_H) && defined(SIGINT)
+ signal(SIGINT, php_cli_server_sigint_handler);
+#endif
+ php_cli_server_do_event_loop(&server TSRMLS_CC);
+ php_cli_server_dtor(&server TSRMLS_CC);
+ return 0;
+} /* }}} */
+
+/*
+ * Local variables:
+ * tab-width: 4
+ * c-basic-offset: 4
+ * End:
+ * vim600: noet sw=4 ts=4 fdm=marker
+ * vim<600: noet sw=4 ts=4
+ */
Index: sapi/cli/php_http_parser.h
===================================================================
--- sapi/cli/php_http_parser.h (revision 0)
+++ sapi/cli/php_http_parser.h (revision 0)
@@ -0,0 +1,182 @@
+/* Copyright 2009,2010 Ryan Dahl <[email protected]>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+/* modified by Moriyoshi Koizumi <[email protected]> to make it fit to PHP source tree. */
+#ifndef php_http_parser_h
+#define php_http_parser_h
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+#include <sys/types.h>
+#if defined(_WIN32) && !defined(__MINGW32__)
+typedef __int8 int8_t;
+typedef unsigned __int8 uint8_t;
+typedef __int16 int16_t;
+typedef unsigned __int16 uint16_t;
+typedef __int32 int32_t;
+typedef unsigned __int32 uint32_t;
+typedef __int64 int64_t;
+typedef unsigned __int64 uint64_t;
+
+typedef unsigned int size_t;
+typedef int ssize_t;
+#else
+#include <stdint.h>
+#endif
+
+/* Compile with -DPHP_HTTP_PARSER_STRICT=0 to make less checks, but run
+ * faster
+ */
+#ifndef PHP_HTTP_PARSER_STRICT
+# define PHP_HTTP_PARSER_STRICT 1
+#else
+# define PHP_HTTP_PARSER_STRICT 0
+#endif
+
+
+/* Maximium header size allowed */
+#define PHP_HTTP_MAX_HEADER_SIZE (80*1024)
+
+
+typedef struct php_http_parser php_http_parser;
+typedef struct php_http_parser_settings php_http_parser_settings;
+
+
+/* Callbacks should return non-zero to indicate an error. The parser will
+ * then halt execution.
+ *
+ * The one exception is on_headers_complete. In a PHP_HTTP_RESPONSE parser
+ * returning '1' from on_headers_complete will tell the parser that it
+ * should not expect a body. This is used when receiving a response to a
+ * HEAD request which may contain 'Content-Length' or 'Transfer-Encoding:
+ * chunked' headers that indicate the presence of a body.
+ *
+ * http_data_cb does not return data chunks. It will be call arbitrarally
+ * many times for each string. E.G. you might get 10 callbacks for "on_path"
+ * each providing just a few characters more data.
+ */
+typedef int (*php_http_data_cb) (php_http_parser*, const char *at, size_t length);
+typedef int (*php_http_cb) (php_http_parser*);
+
+
+/* Request Methods */
+enum php_http_method
+ { PHP_HTTP_DELETE = 0
+ , PHP_HTTP_GET
+ , PHP_HTTP_HEAD
+ , PHP_HTTP_POST
+ , PHP_HTTP_PUT
+ /* pathological */
+ , PHP_HTTP_CONNECT
+ , PHP_HTTP_OPTIONS
+ , PHP_HTTP_TRACE
+ /* webdav */
+ , PHP_HTTP_COPY
+ , PHP_HTTP_LOCK
+ , PHP_HTTP_MKCOL
+ , PHP_HTTP_MOVE
+ , PHP_HTTP_PROPFIND
+ , PHP_HTTP_PROPPATCH
+ , PHP_HTTP_UNLOCK
+ /* subversion */
+ , PHP_HTTP_REPORT
+ , PHP_HTTP_MKACTIVITY
+ , PHP_HTTP_CHECKOUT
+ , PHP_HTTP_MERGE
+ /* upnp */
+ , PHP_HTTP_MSEARCH
+ , PHP_HTTP_NOTIFY
+ , PHP_HTTP_SUBSCRIBE
+ , PHP_HTTP_UNSUBSCRIBE
+ };
+
+
+enum php_http_parser_type { PHP_HTTP_REQUEST, PHP_HTTP_RESPONSE, PHP_HTTP_BOTH };
+
+
+struct php_http_parser {
+ /** PRIVATE **/
+ unsigned char type : 2;
+ unsigned char flags : 6;
+ unsigned char state;
+ unsigned char header_state;
+ unsigned char index;
+
+ uint32_t nread;
+ int64_t content_length;
+
+ /** READ-ONLY **/
+ unsigned short http_major;
+ unsigned short http_minor;
+ unsigned short status_code; /* responses only */
+ unsigned char method; /* requests only */
+
+ /* 1 = Upgrade header was present and the parser has exited because of that.
+ * 0 = No upgrade header present.
+ * Should be checked when http_parser_execute() returns in addition to
+ * error checking.
+ */
+ char upgrade;
+
+ /** PUBLIC **/
+ void *data; /* A pointer to get hook to the "connection" or "socket" object */
+};
+
+
+struct php_http_parser_settings {
+ php_http_cb on_message_begin;
+ php_http_data_cb on_path;
+ php_http_data_cb on_query_string;
+ php_http_data_cb on_url;
+ php_http_data_cb on_fragment;
+ php_http_data_cb on_header_field;
+ php_http_data_cb on_header_value;
+ php_http_cb on_headers_complete;
+ php_http_data_cb on_body;
+ php_http_cb on_message_complete;
+};
+
+
+void php_http_parser_init(php_http_parser *parser, enum php_http_parser_type type);
+
+
+size_t php_http_parser_execute(php_http_parser *parser,
+ const php_http_parser_settings *settings,
+ const char *data,
+ size_t len);
+
+
+/* If php_http_should_keep_alive() in the on_headers_complete or
+ * on_message_complete callback returns true, then this will be should be
+ * the last message on the connection.
+ * If you are the server, respond with the "Connection: close" header.
+ * If you are the client, close the connection.
+ */
+int php_http_should_keep_alive(php_http_parser *parser);
+
+/* Returns a string version of the HTTP method. */
+const char *php_http_method_str(enum php_http_method);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
Index: sapi/cli/php_cli_server.h
===================================================================
--- sapi/cli/php_cli_server.h (revision 0)
+++ sapi/cli/php_cli_server.h (revision 0)
@@ -0,0 +1,38 @@
+/*
+ +----------------------------------------------------------------------+
+ | PHP Version 5 |
+ +----------------------------------------------------------------------+
+ | Copyright (c) 1997-2011 The PHP Group |
+ +----------------------------------------------------------------------+
+ | This source file is subject to version 3.01 of the PHP license, |
+ | that is bundled with this package in the file LICENSE, and is |
+ | available through the world-wide-web at the following url: |
+ | http://www.php.net/license/3_01.txt |
+ | If you did not receive a copy of the PHP license and are unable to |
+ | obtain it through the world-wide-web, please send a note to |
+ | [email protected] so we can mail you a copy immediately. |
+ +----------------------------------------------------------------------+
+ | Author: Moriyoshi Koizumi <[email protected]> |
+ +----------------------------------------------------------------------+
+*/
+
+/* $Id: php_cli.c 306938 2011-01-01 02:17:06Z felipe $ */
+
+#ifndef PHP_CLI_SERVER_H
+#define PHP_CLI_SERVER_H
+
+#include "SAPI.h"
+
+extern sapi_module_struct cli_server_sapi_module;
+extern int do_cli_server(int argc, char **argv TSRMLS_DC);
+
+#endif /* PHP_CLI_SERVER_H */
+
+/*
+ * Local variables:
+ * tab-width: 4
+ * c-basic-offset: 4
+ * End:
+ * vim600: noet sw=4 ts=4 fdm=marker
+ * vim<600: noet sw=4 ts=4
+ */
Index: sapi/cli/php_cli.c
===================================================================
--- sapi/cli/php_cli.c (revision 308839)
+++ sapi/cli/php_cli.c (working copy)
@@ -84,6 +84,10 @@
#include "php_getopt.h"
+#ifndef PHP_CLI_WIN32_NO_CONSOLE
+#include "php_cli_server.h"
+#endif
+
#ifndef PHP_WIN32
# define php_select(m, r, w, e, t) select(m, r, w, e, t)
#else
@@ -126,10 +130,8 @@
"max_execution_time=0\n"
"max_input_time=-1\n\0";
-static char *php_optarg = NULL;
-static int php_optind = 1;
-static const opt_struct OPTIONS[] = {
+const opt_struct OPTIONS[] = {
{'a', 0, "interactive"},
{'B', 1, "process-begin"},
{'C', 0, "no-chdir"}, /* for compatibility with CGI (do not chdir to script directory) */
@@ -150,6 +152,7 @@
{'r', 1, "run"},
{'s', 0, "syntax-highlight"},
{'s', 0, "syntax-highlighting"},
+ {'S', 1, "server"},
{'w', 0, "strip"},
{'?', 0, "usage"},/* help alias (both '?' and 'usage') */
{'v', 0, "version"},
@@ -172,7 +175,7 @@
static int print_module_info(zend_module_entry *module TSRMLS_DC) /* {{{ */
{
- php_printf("%s\n", module->name);
+ printf("%s\n", module->name);
return ZEND_HASH_APPLY_KEEP;
}
/* }}} */
@@ -202,7 +205,7 @@
static int print_extension_info(zend_extension *ext, void *arg TSRMLS_DC) /* {{{ */
{
- php_printf("%s\n", ext->name);
+ printf("%s\n", ext->name);
return ZEND_HASH_APPLY_KEEP;
}
/* }}} */
@@ -494,7 +497,7 @@
prog = "php";
}
- php_printf( "Usage: %s [options] [-f] <file> [--] [args...]\n"
+ printf( "Usage: %s [options] [-f] <file> [--] [args...]\n"
" %s [options] -r <code> [--] [args...]\n"
" %s [options] [-B <begin_code>] -R <code> [-E <end_code>] [--] [args...]\n"
" %s [options] [-B <begin_code>] -F <file> [-E <end_code>] [--] [args...]\n"
@@ -650,689 +653,708 @@
}
/* }}} */
-/* {{{ main
- */
-#ifdef PHP_CLI_WIN32_NO_CONSOLE
-int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nShowCmd)
-#else
-int main(int argc, char *argv[])
-#endif
+static int do_cli(int argc, char **argv TSRMLS_DC) /* {{{ */
{
- volatile int exit_status = SUCCESS;
int c;
zend_file_handle file_handle;
-/* temporary locals */
- int behavior=PHP_MODE_STANDARD;
+ int behavior = PHP_MODE_STANDARD;
char *reflection_what = NULL;
- int orig_optind=php_optind;
- char *orig_optarg=php_optarg;
+ volatile int request_started = 0;
+ volatile int exit_status = 0;
+ char *php_optarg = NULL, *orig_optarg = NULL;
+ int php_optind = 1, orig_optind = 1;
+ char *exec_direct=NULL, *exec_run=NULL, *exec_begin=NULL, *exec_end=NULL;
char *arg_free=NULL, **arg_excp=&arg_free;
char *script_file=NULL;
int interactive=0;
- volatile int module_started = 0;
- volatile int request_started = 0;
int lineno = 0;
- char *exec_direct=NULL, *exec_run=NULL, *exec_begin=NULL, *exec_end=NULL;
const char *param_error=NULL;
int hide_argv = 0;
-/* end of temporary locals */
-#ifdef ZTS
- void ***tsrm_ls;
-#endif
-#ifdef PHP_CLI_WIN32_NO_CONSOLE
- int argc = __argc;
- char **argv = __argv;
-#endif
- int ini_entries_len = 0;
-#if defined(PHP_WIN32) && defined(_DEBUG) && defined(PHP_WIN32_DEBUG_HEAP)
- {
- int tmp_flag;
- _CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE);
- _CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDERR);
- _CrtSetReportMode(_CRT_ERROR, _CRTDBG_MODE_FILE);
- _CrtSetReportFile(_CRT_ERROR, _CRTDBG_FILE_STDERR);
- _CrtSetReportMode(_CRT_ASSERT, _CRTDBG_MODE_FILE);
- _CrtSetReportFile(_CRT_ASSERT, _CRTDBG_FILE_STDERR);
- tmp_flag = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG);
- tmp_flag |= _CRTDBG_DELAY_FREE_MEM_DF;
- tmp_flag |= _CRTDBG_LEAK_CHECK_DF;
+ CG(in_compilation) = 0; /* not initialized but needed for several options */
+ EG(uninitialized_zval_ptr) = NULL;
- _CrtSetDbgFlag(tmp_flag);
- }
-#endif
-
-#ifdef HAVE_SIGNAL_H
-#if defined(SIGPIPE) && defined(SIG_IGN)
- signal(SIGPIPE, SIG_IGN); /* ignore SIGPIPE in standalone mode so
- that sockets created via fsockopen()
- don't kill PHP if the remote site
- closes it. in apache|apxs mode apache
- does that for us! [email protected]
- 20000419 */
-#endif
-#endif
-
-
-#ifdef ZTS
- tsrm_startup(1, 1, 0, NULL);
- tsrm_ls = ts_resource(0);
-#endif
-
- cli_sapi_module.ini_defaults = sapi_cli_ini_defaults;
- cli_sapi_module.php_ini_path_override = NULL;
- cli_sapi_module.phpinfo_as_text = 1;
- cli_sapi_module.php_ini_ignore_cwd = 1;
- sapi_startup(&cli_sapi_module);
-
-#ifdef PHP_WIN32
- _fmode = _O_BINARY; /*sets default for file streams to binary */
- setmode(_fileno(stdin), O_BINARY); /* make the stdio mode be binary */
- setmode(_fileno(stdout), O_BINARY); /* make the stdio mode be binary */
- setmode(_fileno(stderr), O_BINARY); /* make the stdio mode be binary */
-#endif
-
- ini_entries_len = sizeof(HARDCODED_INI)-2;
- cli_sapi_module.ini_entries = malloc(sizeof(HARDCODED_INI));
- memcpy(cli_sapi_module.ini_entries, HARDCODED_INI, sizeof(HARDCODED_INI));
-
- while ((c = php_getopt(argc, argv, OPTIONS, &php_optarg, &php_optind, 0, 2))!=-1) {
+ while ((c = php_getopt(argc, argv, OPTIONS, &php_optarg, &php_optind, 0, 2)) != -1) {
switch (c) {
- case 'c':
- if (cli_sapi_module.php_ini_path_override) {
- free(cli_sapi_module.php_ini_path_override);
- }
- cli_sapi_module.php_ini_path_override = strdup(php_optarg);
- break;
- case 'n':
- cli_sapi_module.php_ini_ignore = 1;
- break;
- case 'd': {
- /* define ini entries on command line */
- int len = strlen(php_optarg);
- char *val;
- if ((val = strchr(php_optarg, '='))) {
- val++;
- if (!isalnum(*val) && *val != '"' && *val != '\'' && *val != '\0') {
- cli_sapi_module.ini_entries = realloc(cli_sapi_module.ini_entries, ini_entries_len + len + sizeof("\"\"\n\0"));
- memcpy(cli_sapi_module.ini_entries + ini_entries_len, php_optarg, (val - php_optarg));
- ini_entries_len += (val - php_optarg);
- memcpy(cli_sapi_module.ini_entries + ini_entries_len, "\"", 1);
- ini_entries_len++;
- memcpy(cli_sapi_module.ini_entries + ini_entries_len, val, len - (val - php_optarg));
- ini_entries_len += len - (val - php_optarg);
- memcpy(cli_sapi_module.ini_entries + ini_entries_len, "\"\n\0", sizeof("\"\n\0"));
- ini_entries_len += sizeof("\n\0\"") - 2;
- } else {
- cli_sapi_module.ini_entries = realloc(cli_sapi_module.ini_entries, ini_entries_len + len + sizeof("\n\0"));
- memcpy(cli_sapi_module.ini_entries + ini_entries_len, php_optarg, len);
- memcpy(cli_sapi_module.ini_entries + ini_entries_len + len, "\n\0", sizeof("\n\0"));
- ini_entries_len += len + sizeof("\n\0") - 2;
- }
- } else {
- cli_sapi_module.ini_entries = realloc(cli_sapi_module.ini_entries, ini_entries_len + len + sizeof("=1\n\0"));
- memcpy(cli_sapi_module.ini_entries + ini_entries_len, php_optarg, len);
- memcpy(cli_sapi_module.ini_entries + ini_entries_len + len, "=1\n\0", sizeof("=1\n\0"));
- ini_entries_len += len + sizeof("=1\n\0") - 2;
- }
- break;
+ case 'i': /* php info & quit */
+ if (php_request_startup(TSRMLS_C)==FAILURE) {
+ goto err;
}
- }
- }
- php_optind = orig_optind;
- php_optarg = orig_optarg;
+ request_started = 1;
+ php_print_info(0xFFFFFFFF TSRMLS_CC);
+ php_output_end_all(TSRMLS_C);
+ exit_status=0;
+ goto out;
- cli_sapi_module.executable_location = argv[0];
- cli_sapi_module.additional_functions = additional_functions;
-
- /* startup after we get the above ini override se we get things right */
- if (cli_sapi_module.startup(&cli_sapi_module)==FAILURE) {
- /* there is no way to see if we must call zend_ini_deactivate()
- * since we cannot check if EG(ini_directives) has been initialised
- * because the executor's constructor does not set initialize it.
- * Apart from that there seems no need for zend_ini_deactivate() yet.
- * So we goto out_err.*/
- exit_status = 1;
- goto out_err;
- }
- module_started = 1;
-
- zend_first_try {
- CG(in_compilation) = 0; /* not initialized but needed for several options */
- EG(uninitialized_zval_ptr) = NULL;
-
- while ((c = php_getopt(argc, argv, OPTIONS, &php_optarg, &php_optind, 0, 2)) != -1) {
- switch (c) {
-
- case 'h': /* help & quit */
- case '?':
- if (php_request_startup(TSRMLS_C)==FAILURE) {
- goto err;
- }
- request_started = 1;
- php_cli_usage(argv[0]);
- php_output_end_all(TSRMLS_C);
- exit_status=0;
- goto out;
-
- case 'i': /* php info & quit */
- if (php_request_startup(TSRMLS_C)==FAILURE) {
- goto err;
- }
- request_started = 1;
- php_print_info(0xFFFFFFFF TSRMLS_CC);
- php_output_end_all(TSRMLS_C);
- exit_status=0;
- goto out;
-
- case 'm': /* list compiled in modules */
- if (php_request_startup(TSRMLS_C)==FAILURE) {
- goto err;
- }
- request_started = 1;
- php_printf("[PHP Modules]\n");
- print_modules(TSRMLS_C);
- php_printf("\n[Zend Modules]\n");
- print_extensions(TSRMLS_C);
- php_printf("\n");
- php_output_end_all(TSRMLS_C);
- exit_status=0;
- goto out;
-
- case 'v': /* show php version & quit */
- if (php_request_startup(TSRMLS_C) == FAILURE) {
- goto err;
- }
-
- request_started = 1;
- php_printf("PHP %s (%s) (built: %s %s) %s\nCopyright (c) 1997-2011 The PHP Group\n%s",
- PHP_VERSION, sapi_module.name, __DATE__, __TIME__,
+ case 'v': /* show php version & quit */
+ php_printf("PHP %s (%s) (built: %s %s) %s\nCopyright (c) 1997-2011 The PHP Group\n%s",
+ PHP_VERSION, cli_sapi_module.name, __DATE__, __TIME__,
#if ZEND_DEBUG && defined(HAVE_GCOV)
- "(DEBUG GCOV)",
+ "(DEBUG GCOV)",
#elif ZEND_DEBUG
- "(DEBUG)",
+ "(DEBUG)",
#elif defined(HAVE_GCOV)
- "(GCOV)",
+ "(GCOV)",
#else
- "",
+ "",
#endif
- get_zend_version()
- );
- php_output_end_all(TSRMLS_C);
- exit_status=0;
- goto out;
+ get_zend_version()
+ );
+ goto out;
- default:
- break;
+ case 'm': /* list compiled in modules */
+ if (php_request_startup(TSRMLS_C)==FAILURE) {
+ goto err;
}
+ request_started = 1;
+ php_printf("[PHP Modules]\n");
+ print_modules(TSRMLS_C);
+ php_printf("\n[Zend Modules]\n");
+ print_extensions(TSRMLS_C);
+ php_printf("\n");
+ php_output_end_all(TSRMLS_C);
+ exit_status=0;
+ goto out;
+
+ default:
+ break;
}
+ }
- /* Set some CLI defaults */
- SG(options) |= SAPI_OPTION_NO_CHDIR;
+ /* Set some CLI defaults */
+ SG(options) |= SAPI_OPTION_NO_CHDIR;
- php_optind = orig_optind;
- php_optarg = orig_optarg;
- while ((c = php_getopt(argc, argv, OPTIONS, &php_optarg, &php_optind, 0, 2)) != -1) {
- switch (c) {
+ php_optind = orig_optind;
+ php_optarg = orig_optarg;
+ while ((c = php_getopt(argc, argv, OPTIONS, &php_optarg, &php_optind, 0, 2)) != -1) {
+ switch (c) {
- case 'a': /* interactive mode */
- if (!interactive) {
- if (behavior != PHP_MODE_STANDARD) {
- param_error = param_mode_conflict;
- break;
- }
-
- interactive=1;
+ case 'a': /* interactive mode */
+ if (!interactive) {
+ if (behavior != PHP_MODE_STANDARD) {
+ param_error = param_mode_conflict;
+ break;
}
- break;
- case 'C': /* don't chdir to the script directory */
- /* This is default so NOP */
- break;
+ interactive=1;
+ }
+ break;
- case 'e': /* enable extended info output */
- CG(compiler_options) |= ZEND_COMPILE_EXTENDED_INFO;
- break;
+ case 'C': /* don't chdir to the script directory */
+ /* This is default so NOP */
+ break;
- case 'F':
- if (behavior == PHP_MODE_PROCESS_STDIN) {
- if (exec_run || script_file) {
- param_error = "You can use -R or -F only once.\n";
- break;
- }
- } else if (behavior != PHP_MODE_STANDARD) {
- param_error = param_mode_conflict;
+ case 'F':
+ if (behavior == PHP_MODE_PROCESS_STDIN) {
+ if (exec_run || script_file) {
+ param_error = "You can use -R or -F only once.\n";
break;
}
- behavior=PHP_MODE_PROCESS_STDIN;
- script_file = php_optarg;
+ } else if (behavior != PHP_MODE_STANDARD) {
+ param_error = param_mode_conflict;
break;
+ }
+ behavior=PHP_MODE_PROCESS_STDIN;
+ script_file = php_optarg;
+ break;
- case 'f': /* parse file */
- if (behavior == PHP_MODE_CLI_DIRECT || behavior == PHP_MODE_PROCESS_STDIN) {
- param_error = param_mode_conflict;
- break;
- } else if (script_file) {
- param_error = "You can use -f only once.\n";
- break;
- }
- script_file = php_optarg;
+ case 'f': /* parse file */
+ if (behavior == PHP_MODE_CLI_DIRECT || behavior == PHP_MODE_PROCESS_STDIN) {
+ param_error = param_mode_conflict;
break;
+ } else if (script_file) {
+ param_error = "You can use -f only once.\n";
+ break;
+ }
+ script_file = php_optarg;
+ break;
- case 'l': /* syntax check mode */
- if (behavior != PHP_MODE_STANDARD) {
- break;
- }
- behavior=PHP_MODE_LINT;
+ case 'l': /* syntax check mode */
+ if (behavior != PHP_MODE_STANDARD) {
break;
+ }
+ behavior=PHP_MODE_LINT;
+ break;
#if 0 /* not yet operational, see also below ... */
- case '': /* generate indented source mode*/
- if (behavior == PHP_MODE_CLI_DIRECT || behavior == PHP_MODE_PROCESS_STDIN) {
- param_error = "Source indenting only works for files.\n";
- break;
- }
- behavior=PHP_MODE_INDENT;
+ case '': /* generate indented source mode*/
+ if (behavior == PHP_MODE_CLI_DIRECT || behavior == PHP_MODE_PROCESS_STDIN) {
+ param_error = "Source indenting only works for files.\n";
break;
+ }
+ behavior=PHP_MODE_INDENT;
+ break;
#endif
- case 'q': /* do not generate HTTP headers */
- /* This is default so NOP */
- break;
+ case 'q': /* do not generate HTTP headers */
+ /* This is default so NOP */
+ break;
- case 'r': /* run code from command line */
- if (behavior == PHP_MODE_CLI_DIRECT) {
- if (exec_direct || script_file) {
- param_error = "You can use -r only once.\n";
- break;
- }
- } else if (behavior != PHP_MODE_STANDARD || interactive) {
- param_error = param_mode_conflict;
+ case 'r': /* run code from command line */
+ if (behavior == PHP_MODE_CLI_DIRECT) {
+ if (exec_direct || script_file) {
+ param_error = "You can use -r only once.\n";
break;
}
- behavior=PHP_MODE_CLI_DIRECT;
- exec_direct=php_optarg;
+ } else if (behavior != PHP_MODE_STANDARD || interactive) {
+ param_error = param_mode_conflict;
break;
-
- case 'R':
- if (behavior == PHP_MODE_PROCESS_STDIN) {
- if (exec_run || script_file) {
- param_error = "You can use -R or -F only once.\n";
- break;
- }
- } else if (behavior != PHP_MODE_STANDARD) {
- param_error = param_mode_conflict;
+ }
+ behavior=PHP_MODE_CLI_DIRECT;
+ exec_direct=php_optarg;
+ break;
+
+ case 'R':
+ if (behavior == PHP_MODE_PROCESS_STDIN) {
+ if (exec_run || script_file) {
+ param_error = "You can use -R or -F only once.\n";
break;
}
- behavior=PHP_MODE_PROCESS_STDIN;
- exec_run=php_optarg;
+ } else if (behavior != PHP_MODE_STANDARD) {
+ param_error = param_mode_conflict;
break;
+ }
+ behavior=PHP_MODE_PROCESS_STDIN;
+ exec_run=php_optarg;
+ break;
- case 'B':
- if (behavior == PHP_MODE_PROCESS_STDIN) {
- if (exec_begin) {
- param_error = "You can use -B only once.\n";
- break;
- }
- } else if (behavior != PHP_MODE_STANDARD || interactive) {
- param_error = param_mode_conflict;
+ case 'B':
+ if (behavior == PHP_MODE_PROCESS_STDIN) {
+ if (exec_begin) {
+ param_error = "You can use -B only once.\n";
break;
}
- behavior=PHP_MODE_PROCESS_STDIN;
- exec_begin=php_optarg;
+ } else if (behavior != PHP_MODE_STANDARD || interactive) {
+ param_error = param_mode_conflict;
break;
+ }
+ behavior=PHP_MODE_PROCESS_STDIN;
+ exec_begin=php_optarg;
+ break;
- case 'E':
- if (behavior == PHP_MODE_PROCESS_STDIN) {
- if (exec_end) {
- param_error = "You can use -E only once.\n";
- break;
- }
- } else if (behavior != PHP_MODE_STANDARD || interactive) {
- param_error = param_mode_conflict;
+ case 'E':
+ if (behavior == PHP_MODE_PROCESS_STDIN) {
+ if (exec_end) {
+ param_error = "You can use -E only once.\n";
break;
}
- behavior=PHP_MODE_PROCESS_STDIN;
- exec_end=php_optarg;
+ } else if (behavior != PHP_MODE_STANDARD || interactive) {
+ param_error = param_mode_conflict;
break;
+ }
+ behavior=PHP_MODE_PROCESS_STDIN;
+ exec_end=php_optarg;
+ break;
- case 's': /* generate highlighted HTML from source */
- if (behavior == PHP_MODE_CLI_DIRECT || behavior == PHP_MODE_PROCESS_STDIN) {
- param_error = "Source highlighting only works for files.\n";
- break;
- }
- behavior=PHP_MODE_HIGHLIGHT;
+ case 's': /* generate highlighted HTML from source */
+ if (behavior == PHP_MODE_CLI_DIRECT || behavior == PHP_MODE_PROCESS_STDIN) {
+ param_error = "Source highlighting only works for files.\n";
break;
+ }
+ behavior=PHP_MODE_HIGHLIGHT;
+ break;
- case 'w':
- if (behavior == PHP_MODE_CLI_DIRECT || behavior == PHP_MODE_PROCESS_STDIN) {
- param_error = "Source stripping only works for files.\n";
- break;
- }
- behavior=PHP_MODE_STRIP;
+ case 'w':
+ if (behavior == PHP_MODE_CLI_DIRECT || behavior == PHP_MODE_PROCESS_STDIN) {
+ param_error = "Source stripping only works for files.\n";
break;
+ }
+ behavior=PHP_MODE_STRIP;
+ break;
- case 'z': /* load extension file */
- zend_load_extension(php_optarg);
- break;
- case 'H':
- hide_argv = 1;
- break;
+ case 'z': /* load extension file */
+ zend_load_extension(php_optarg);
+ break;
+ case 'H':
+ hide_argv = 1;
+ break;
#ifdef HAVE_REFLECTION
- case 10:
- behavior=PHP_MODE_REFLECTION_FUNCTION;
- reflection_what = php_optarg;
- break;
- case 11:
- behavior=PHP_MODE_REFLECTION_CLASS;
- reflection_what = php_optarg;
- break;
- case 12:
- behavior=PHP_MODE_REFLECTION_EXTENSION;
- reflection_what = php_optarg;
- break;
- case 13:
- behavior=PHP_MODE_REFLECTION_ZEND_EXTENSION;
- reflection_what = php_optarg;
- break;
+ case 10:
+ behavior=PHP_MODE_REFLECTION_FUNCTION;
+ reflection_what = php_optarg;
+ break;
+ case 11:
+ behavior=PHP_MODE_REFLECTION_CLASS;
+ reflection_what = php_optarg;
+ break;
+ case 12:
+ behavior=PHP_MODE_REFLECTION_EXTENSION;
+ reflection_what = php_optarg;
+ break;
+ case 13:
+ behavior=PHP_MODE_REFLECTION_ZEND_EXTENSION;
+ reflection_what = php_optarg;
+ break;
#endif
- case 14:
- behavior=PHP_MODE_REFLECTION_EXT_INFO;
- reflection_what = php_optarg;
- break;
- case 15:
- behavior = PHP_MODE_SHOW_INI_CONFIG;
- break;
- default:
- break;
- }
+ case 14:
+ behavior=PHP_MODE_REFLECTION_EXT_INFO;
+ reflection_what = php_optarg;
+ break;
+ case 15:
+ behavior = PHP_MODE_SHOW_INI_CONFIG;
+ break;
+ default:
+ break;
}
+ }
- if (param_error) {
- PUTS(param_error);
- exit_status=1;
- goto err;
- }
+ if (param_error) {
+ PUTS(param_error);
+ exit_status=1;
+ goto err;
+ }
- if (interactive) {
+ if (interactive) {
#if (HAVE_LIBREADLINE || HAVE_LIBEDIT) && !defined(COMPILE_DL_READLINE)
- printf("Interactive shell\n\n");
+ printf("Interactive shell\n\n");
#else
- printf("Interactive mode enabled\n\n");
+ printf("Interactive mode enabled\n\n");
#endif
- fflush(stdout);
- }
+ fflush(stdout);
+ }
- CG(interactive) = interactive;
+ CG(interactive) = interactive;
- /* only set script_file if not set already and not in direct mode and not at end of parameter list */
- if (argc > php_optind
- && !script_file
- && behavior!=PHP_MODE_CLI_DIRECT
- && behavior!=PHP_MODE_PROCESS_STDIN
- && strcmp(argv[php_optind-1],"--"))
- {
- script_file=argv[php_optind];
- php_optind++;
+ /* only set script_file if not set already and not in direct mode and not at end of parameter list */
+ if (argc > php_optind
+ && !script_file
+ && behavior!=PHP_MODE_CLI_DIRECT
+ && behavior!=PHP_MODE_PROCESS_STDIN
+ && strcmp(argv[php_optind-1],"--"))
+ {
+ script_file=argv[php_optind];
+ php_optind++;
+ }
+ if (script_file) {
+ if (cli_seek_file_begin(&file_handle, script_file, &lineno TSRMLS_CC) != SUCCESS) {
+ goto err;
}
- if (script_file) {
- if (cli_seek_file_begin(&file_handle, script_file, &lineno TSRMLS_CC) != SUCCESS) {
- goto err;
- }
- script_filename = script_file;
- } else {
- /* We could handle PHP_MODE_PROCESS_STDIN in a different manner */
- /* here but this would make things only more complicated. And it */
- /* is consitent with the way -R works where the stdin file handle*/
- /* is also accessible. */
- file_handle.filename = "-";
- file_handle.handle.fp = stdin;
- }
- file_handle.type = ZEND_HANDLE_FP;
- file_handle.opened_path = NULL;
- file_handle.free_filename = 0;
- php_self = file_handle.filename;
+ script_filename = script_file;
+ } else {
+ /* We could handle PHP_MODE_PROCESS_STDIN in a different manner */
+ /* here but this would make things only more complicated. And it */
+ /* is consitent with the way -R works where the stdin file handle*/
+ /* is also accessible. */
+ file_handle.filename = "-";
+ file_handle.handle.fp = stdin;
+ }
+ file_handle.type = ZEND_HANDLE_FP;
+ file_handle.opened_path = NULL;
+ file_handle.free_filename = 0;
+ php_self = file_handle.filename;
- /* before registering argv to module exchange the *new* argv[0] */
- /* we can achieve this without allocating more memory */
- SG(request_info).argc=argc-php_optind+1;
- arg_excp = argv+php_optind-1;
- arg_free = argv[php_optind-1];
- SG(request_info).path_translated = file_handle.filename;
- argv[php_optind-1] = file_handle.filename;
- SG(request_info).argv=argv+php_optind-1;
+ /* before registering argv to module exchange the *new* argv[0] */
+ /* we can achieve this without allocating more memory */
+ SG(request_info).argc=argc-php_optind+1;
+ arg_excp = argv+php_optind-1;
+ arg_free = argv[php_optind-1];
+ SG(request_info).path_translated = file_handle.filename;
+ argv[php_optind-1] = file_handle.filename;
+ SG(request_info).argv=argv+php_optind-1;
- if (php_request_startup(TSRMLS_C)==FAILURE) {
- *arg_excp = arg_free;
- fclose(file_handle.handle.fp);
- PUTS("Could not startup.\n");
- goto err;
- }
- request_started = 1;
- CG(start_lineno) = lineno;
- *arg_excp = arg_free; /* reconstuct argv */
+ if (php_request_startup(TSRMLS_C)==FAILURE) {
+ *arg_excp = arg_free;
+ fclose(file_handle.handle.fp);
+ PUTS("Could not startup.\n");
+ goto err;
+ }
+ request_started = 1;
+ CG(start_lineno) = lineno;
+ *arg_excp = arg_free; /* reconstuct argv */
- if (hide_argv) {
- int i;
- for (i = 1; i < argc; i++) {
- memset(argv[i], 0, strlen(argv[i]));
- }
+ if (hide_argv) {
+ int i;
+ for (i = 1; i < argc; i++) {
+ memset(argv[i], 0, strlen(argv[i]));
}
+ }
- zend_is_auto_global("_SERVER", sizeof("_SERVER")-1 TSRMLS_CC);
+ zend_is_auto_global("_SERVER", sizeof("_SERVER")-1 TSRMLS_CC);
- PG(during_request_startup) = 0;
- switch (behavior) {
- case PHP_MODE_STANDARD:
- if (strcmp(file_handle.filename, "-")) {
- cli_register_file_handles(TSRMLS_C);
- }
+ PG(during_request_startup) = 0;
+ switch (behavior) {
+ case PHP_MODE_STANDARD:
+ if (strcmp(file_handle.filename, "-")) {
+ cli_register_file_handles(TSRMLS_C);
+ }
- if (interactive && cli_shell_callbacks.cli_shell_run) {
- exit_status = cli_shell_callbacks.cli_shell_run(TSRMLS_C);
- } else {
- php_execute_script(&file_handle TSRMLS_CC);
- exit_status = EG(exit_status);
- }
+ if (interactive && cli_shell_callbacks.cli_shell_run) {
+ exit_status = cli_shell_callbacks.cli_shell_run(TSRMLS_C);
+ } else {
+ php_execute_script(&file_handle TSRMLS_CC);
+ exit_status = EG(exit_status);
+ }
+ break;
+ case PHP_MODE_LINT:
+ exit_status = php_lint_script(&file_handle TSRMLS_CC);
+ if (exit_status==SUCCESS) {
+ zend_printf("No syntax errors detected in %s\n", file_handle.filename);
+ } else {
+ zend_printf("Errors parsing %s\n", file_handle.filename);
+ }
+ break;
+ case PHP_MODE_STRIP:
+ if (open_file_for_scanning(&file_handle TSRMLS_CC)==SUCCESS) {
+ zend_strip(TSRMLS_C);
+ }
+ goto out;
+ break;
+ case PHP_MODE_HIGHLIGHT:
+ {
+ zend_syntax_highlighter_ini syntax_highlighter_ini;
- break;
- case PHP_MODE_LINT:
- exit_status = php_lint_script(&file_handle TSRMLS_CC);
- if (exit_status==SUCCESS) {
- zend_printf("No syntax errors detected in %s\n", file_handle.filename);
- } else {
- zend_printf("Errors parsing %s\n", file_handle.filename);
- }
- break;
- case PHP_MODE_STRIP:
if (open_file_for_scanning(&file_handle TSRMLS_CC)==SUCCESS) {
- zend_strip(TSRMLS_C);
+ php_get_highlight_struct(&syntax_highlighter_ini);
+ zend_highlight(&syntax_highlighter_ini TSRMLS_CC);
}
goto out;
- break;
- case PHP_MODE_HIGHLIGHT:
- {
- zend_syntax_highlighter_ini syntax_highlighter_ini;
-
- if (open_file_for_scanning(&file_handle TSRMLS_CC)==SUCCESS) {
- php_get_highlight_struct(&syntax_highlighter_ini);
- zend_highlight(&syntax_highlighter_ini TSRMLS_CC);
- }
- goto out;
- }
- break;
+ }
+ break;
#if 0
- /* Zeev might want to do something with this one day */
- case PHP_MODE_INDENT:
- open_file_for_scanning(&file_handle TSRMLS_CC);
- zend_indent();
- zend_file_handle_dtor(file_handle.handle TSRMLS_CC);
- goto out;
- break;
+ /* Zeev might want to do something with this one day */
+ case PHP_MODE_INDENT:
+ open_file_for_scanning(&file_handle TSRMLS_CC);
+ zend_indent();
+ zend_file_handle_dtor(file_handle.handle TSRMLS_CC);
+ goto out;
+ break;
#endif
- case PHP_MODE_CLI_DIRECT:
+ case PHP_MODE_CLI_DIRECT:
+ cli_register_file_handles(TSRMLS_C);
+ if (zend_eval_string_ex(exec_direct, NULL, "Command line code", 1 TSRMLS_CC) == FAILURE) {
+ exit_status=254;
+ }
+ break;
+
+ case PHP_MODE_PROCESS_STDIN:
+ {
+ char *input;
+ size_t len, index = 0;
+ zval *argn, *argi;
+
cli_register_file_handles(TSRMLS_C);
- if (zend_eval_string_ex(exec_direct, NULL, "Command line code", 1 TSRMLS_CC) == FAILURE) {
+
+ if (exec_begin && zend_eval_string_ex(exec_begin, NULL, "Command line begin code", 1 TSRMLS_CC) == FAILURE) {
exit_status=254;
}
- break;
-
- case PHP_MODE_PROCESS_STDIN:
- {
- char *input;
- size_t len, index = 0;
- zval *argn, *argi;
-
- cli_register_file_handles(TSRMLS_C);
-
- if (exec_begin && zend_eval_string_ex(exec_begin, NULL, "Command line begin code", 1 TSRMLS_CC) == FAILURE) {
- exit_status=254;
+ ALLOC_ZVAL(argi);
+ Z_TYPE_P(argi) = IS_LONG;
+ Z_LVAL_P(argi) = index;
+ INIT_PZVAL(argi);
+ zend_hash_update(&EG(symbol_table), "argi", sizeof("argi"), &argi, sizeof(zval *), NULL);
+ while (exit_status == SUCCESS && (input=php_stream_gets(s_in_process, NULL, 0)) != NULL) {
+ len = strlen(input);
+ while (len-- && (input[len]=='\n' || input[len]=='\r')) {
+ input[len] = '\0';
}
- ALLOC_ZVAL(argi);
- Z_TYPE_P(argi) = IS_LONG;
- Z_LVAL_P(argi) = index;
- INIT_PZVAL(argi);
- zend_hash_update(&EG(symbol_table), "argi", sizeof("argi"), &argi, sizeof(zval *), NULL);
- while (exit_status == SUCCESS && (input=php_stream_gets(s_in_process, NULL, 0)) != NULL) {
- len = strlen(input);
- while (len-- && (input[len]=='\n' || input[len]=='\r')) {
- input[len] = '\0';
+ ALLOC_ZVAL(argn);
+ Z_TYPE_P(argn) = IS_STRING;
+ Z_STRLEN_P(argn) = ++len;
+ Z_STRVAL_P(argn) = estrndup(input, len);
+ INIT_PZVAL(argn);
+ zend_hash_update(&EG(symbol_table), "argn", sizeof("argn"), &argn, sizeof(zval *), NULL);
+ Z_LVAL_P(argi) = ++index;
+ if (exec_run) {
+ if (zend_eval_string_ex(exec_run, NULL, "Command line run code", 1 TSRMLS_CC) == FAILURE) {
+ exit_status=254;
}
- ALLOC_ZVAL(argn);
- Z_TYPE_P(argn) = IS_STRING;
- Z_STRLEN_P(argn) = ++len;
- Z_STRVAL_P(argn) = estrndup(input, len);
- INIT_PZVAL(argn);
- zend_hash_update(&EG(symbol_table), "argn", sizeof("argn"), &argn, sizeof(zval *), NULL);
- Z_LVAL_P(argi) = ++index;
- if (exec_run) {
- if (zend_eval_string_ex(exec_run, NULL, "Command line run code", 1 TSRMLS_CC) == FAILURE) {
- exit_status=254;
+ } else {
+ if (script_file) {
+ if (cli_seek_file_begin(&file_handle, script_file, &lineno TSRMLS_CC) != SUCCESS) {
+ exit_status = 1;
+ } else {
+ CG(start_lineno) = lineno;
+ php_execute_script(&file_handle TSRMLS_CC);
+ exit_status = EG(exit_status);
}
- } else {
- if (script_file) {
- if (cli_seek_file_begin(&file_handle, script_file, &lineno TSRMLS_CC) != SUCCESS) {
- exit_status = 1;
- } else {
- CG(start_lineno) = lineno;
- php_execute_script(&file_handle TSRMLS_CC);
- exit_status = EG(exit_status);
- }
- }
}
- efree(input);
}
- if (exec_end && zend_eval_string_ex(exec_end, NULL, "Command line end code", 1 TSRMLS_CC) == FAILURE) {
- exit_status=254;
+ efree(input);
+ }
+ if (exec_end && zend_eval_string_ex(exec_end, NULL, "Command line end code", 1 TSRMLS_CC) == FAILURE) {
+ exit_status=254;
+ }
+
+ break;
+ }
+#ifdef HAVE_REFLECTION
+ case PHP_MODE_REFLECTION_FUNCTION:
+ case PHP_MODE_REFLECTION_CLASS:
+ case PHP_MODE_REFLECTION_EXTENSION:
+ case PHP_MODE_REFLECTION_ZEND_EXTENSION:
+ {
+ zend_class_entry *pce = NULL;
+ zval *arg, *ref;
+ zend_execute_data execute_data;
+
+ switch (behavior) {
+ default:
+ break;
+ case PHP_MODE_REFLECTION_FUNCTION:
+ if (strstr(reflection_what, "::")) {
+ pce = reflection_method_ptr;
+ } else {
+ pce = reflection_function_ptr;
+ }
+ break;
+ case PHP_MODE_REFLECTION_CLASS:
+ pce = reflection_class_ptr;
+ break;
+ case PHP_MODE_REFLECTION_EXTENSION:
+ pce = reflection_extension_ptr;
+ break;
+ case PHP_MODE_REFLECTION_ZEND_EXTENSION:
+ pce = reflection_zend_extension_ptr;
+ break;
}
+
+ MAKE_STD_ZVAL(arg);
+ ZVAL_STRING(arg, reflection_what, 1);
+ ALLOC_ZVAL(ref);
+ object_init_ex(ref, pce);
+ INIT_PZVAL(ref);
+ memset(&execute_data, 0, sizeof(zend_execute_data));
+ EG(current_execute_data) = &execute_data;
+ EX(function_state).function = pce->constructor;
+ zend_call_method_with_1_params(&ref, pce, &pce->constructor, "__construct", NULL, arg);
+
+ if (EG(exception)) {
+ zval *msg = zend_read_property(zend_exception_get_default(TSRMLS_C), EG(exception), "message", sizeof("message")-1, 0 TSRMLS_CC);
+ zend_printf("Exception: %s\n", Z_STRVAL_P(msg));
+ zval_ptr_dtor(&EG(exception));
+ EG(exception) = NULL;
+ } else {
+ zend_call_method_with_1_params(NULL, reflection_ptr, NULL, "export", NULL, ref);
+ }
+ zval_ptr_dtor(&ref);
+ zval_ptr_dtor(&arg);
+
break;
}
-#ifdef HAVE_REFLECTION
- case PHP_MODE_REFLECTION_FUNCTION:
- case PHP_MODE_REFLECTION_CLASS:
- case PHP_MODE_REFLECTION_EXTENSION:
- case PHP_MODE_REFLECTION_ZEND_EXTENSION:
- {
- zend_class_entry *pce = NULL;
- zval *arg, *ref;
- zend_execute_data execute_data;
+#endif /* reflection */
+ case PHP_MODE_REFLECTION_EXT_INFO:
+ {
+ int len = strlen(reflection_what);
+ char *lcname = zend_str_tolower_dup(reflection_what, len);
+ zend_module_entry *module;
- switch (behavior) {
- default:
- break;
- case PHP_MODE_REFLECTION_FUNCTION:
- if (strstr(reflection_what, "::")) {
- pce = reflection_method_ptr;
- } else {
- pce = reflection_function_ptr;
- }
- break;
- case PHP_MODE_REFLECTION_CLASS:
- pce = reflection_class_ptr;
- break;
- case PHP_MODE_REFLECTION_EXTENSION:
- pce = reflection_extension_ptr;
- break;
- case PHP_MODE_REFLECTION_ZEND_EXTENSION:
- pce = reflection_zend_extension_ptr;
- break;
+ if (zend_hash_find(&module_registry, lcname, len+1, (void**)&module) == FAILURE) {
+ if (!strcmp(reflection_what, "main")) {
+ display_ini_entries(NULL);
+ } else {
+ zend_printf("Extension '%s' not present.\n", reflection_what);
+ exit_status = 1;
}
-
- MAKE_STD_ZVAL(arg);
- ZVAL_STRING(arg, reflection_what, 1);
- ALLOC_ZVAL(ref);
- object_init_ex(ref, pce);
- INIT_PZVAL(ref);
+ } else {
+ php_info_print_module(module TSRMLS_CC);
+ }
+
+ efree(lcname);
+ break;
+ }
+ case PHP_MODE_SHOW_INI_CONFIG:
+ {
+ zend_printf("Configuration File (php.ini) Path: %s\n", PHP_CONFIG_FILE_PATH);
+ zend_printf("Loaded Configuration File: %s\n", php_ini_opened_path ? php_ini_opened_path : "(none)");
+ zend_printf("Scan for additional .ini files in: %s\n", php_ini_scanned_path ? php_ini_scanned_path : "(none)");
+ zend_printf("Additional .ini files parsed: %s\n", php_ini_scanned_files ? php_ini_scanned_files : "(none)");
+ break;
+ }
+ }
- memset(&execute_data, 0, sizeof(zend_execute_data));
- EG(current_execute_data) = &execute_data;
- EX(function_state).function = pce->constructor;
- zend_call_method_with_1_params(&ref, pce, &pce->constructor, "__construct", NULL, arg);
+out:
+ if (exit_status == 0) {
+ exit_status = EG(exit_status);
+ }
+ if (request_started) {
+ php_request_shutdown((void *) 0);
+ }
+ return exit_status;
+err:
+ sapi_deactivate(TSRMLS_C);
+ zend_ini_deactivate(TSRMLS_C);
+ exit_status = 1;
+ goto out;
+}
+/* }}} */
- if (EG(exception)) {
- zval *msg = zend_read_property(zend_exception_get_default(TSRMLS_C), EG(exception), "message", sizeof("message")-1, 0 TSRMLS_CC);
- zend_printf("Exception: %s\n", Z_STRVAL_P(msg));
- zval_ptr_dtor(&EG(exception));
- EG(exception) = NULL;
- } else {
- zend_call_method_with_1_params(NULL, reflection_ptr, NULL, "export", NULL, ref);
- }
- zval_ptr_dtor(&ref);
- zval_ptr_dtor(&arg);
+/* {{{ main
+ */
+#ifdef PHP_CLI_WIN32_NO_CONSOLE
+int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nShowCmd)
+#else
+int main(int argc, char *argv[])
+#endif
+{
+#ifdef ZTS
+ void ***tsrm_ls;
+#endif
+#ifdef PHP_CLI_WIN32_NO_CONSOLE
+ int argc = __argc;
+ char **argv = __argv;
+#endif
+ int c;
+ int exit_status = SUCCESS;
+ int module_started = 0;
+ char *php_optarg = NULL;
+ int php_optind = 1;
+ char *ini_path_override = NULL;
+ char *ini_entries = NULL;
+ int ini_entries_len = 0;
+ int ini_ignore = 0;
+ sapi_module_struct *sapi_module = &cli_sapi_module;
- break;
+ cli_sapi_module.additional_functions = additional_functions;
+
+#if defined(PHP_WIN32) && defined(_DEBUG) && defined(PHP_WIN32_DEBUG_HEAP)
+ {
+ int tmp_flag;
+ _CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE);
+ _CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDERR);
+ _CrtSetReportMode(_CRT_ERROR, _CRTDBG_MODE_FILE);
+ _CrtSetReportFile(_CRT_ERROR, _CRTDBG_FILE_STDERR);
+ _CrtSetReportMode(_CRT_ASSERT, _CRTDBG_MODE_FILE);
+ _CrtSetReportFile(_CRT_ASSERT, _CRTDBG_FILE_STDERR);
+ tmp_flag = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG);
+ tmp_flag |= _CRTDBG_DELAY_FREE_MEM_DF;
+ tmp_flag |= _CRTDBG_LEAK_CHECK_DF;
+
+ _CrtSetDbgFlag(tmp_flag);
+ }
+#endif
+
+#ifdef HAVE_SIGNAL_H
+#if defined(SIGPIPE) && defined(SIG_IGN)
+ signal(SIGPIPE, SIG_IGN); /* ignore SIGPIPE in standalone mode so
+ that sockets created via fsockopen()
+ don't kill PHP if the remote site
+ closes it. in apache|apxs mode apache
+ does that for us! [email protected]
+ 20000419 */
+#endif
+#endif
+
+
+#ifdef ZTS
+ tsrm_startup(1, 1, 0, NULL);
+ tsrm_ls = ts_resource(0);
+#endif
+
+#ifdef PHP_WIN32
+ _fmode = _O_BINARY; /*sets default for file streams to binary */
+ setmode(_fileno(stdin), O_BINARY); /* make the stdio mode be binary */
+ setmode(_fileno(stdout), O_BINARY); /* make the stdio mode be binary */
+ setmode(_fileno(stderr), O_BINARY); /* make the stdio mode be binary */
+#endif
+
+ while ((c = php_getopt(argc, argv, OPTIONS, &php_optarg, &php_optind, 0, 2))!=-1) {
+ switch (c) {
+ case 'c':
+ if (ini_path_override) {
+ free(ini_path_override);
}
-#endif /* reflection */
- case PHP_MODE_REFLECTION_EXT_INFO:
- {
- int len = strlen(reflection_what);
- char *lcname = zend_str_tolower_dup(reflection_what, len);
- zend_module_entry *module;
+ ini_path_override = strdup(php_optarg);
+ break;
+ case 'n':
+ ini_ignore = 1;
+ break;
+ case 'd': {
+ /* define ini entries on command line */
+ int len = strlen(php_optarg);
+ char *val;
- if (zend_hash_find(&module_registry, lcname, len+1, (void**)&module) == FAILURE) {
- if (!strcmp(reflection_what, "main")) {
- display_ini_entries(NULL);
- } else {
- zend_printf("Extension '%s' not present.\n", reflection_what);
- exit_status = 1;
- }
+ if ((val = strchr(php_optarg, '='))) {
+ val++;
+ if (!isalnum(*val) && *val != '"' && *val != '\'' && *val != '\0') {
+ ini_entries = realloc(ini_entries, ini_entries_len + len + sizeof("\"\"\n\0"));
+ memcpy(ini_entries + ini_entries_len, php_optarg, (val - php_optarg));
+ ini_entries_len += (val - php_optarg);
+ memcpy(ini_entries + ini_entries_len, "\"", 1);
+ ini_entries_len++;
+ memcpy(ini_entries + ini_entries_len, val, len - (val - php_optarg));
+ ini_entries_len += len - (val - php_optarg);
+ memcpy(ini_entries + ini_entries_len, "\"\n\0", sizeof("\"\n\0"));
+ ini_entries_len += sizeof("\n\0\"") - 2;
} else {
- php_info_print_module(module TSRMLS_CC);
+ ini_entries = realloc(ini_entries, ini_entries_len + len + sizeof("\n\0"));
+ memcpy(ini_entries + ini_entries_len, php_optarg, len);
+ memcpy(ini_entries + ini_entries_len + len, "\n\0", sizeof("\n\0"));
+ ini_entries_len += len + sizeof("\n\0") - 2;
}
-
- efree(lcname);
- break;
+ } else {
+ ini_entries = realloc(ini_entries, ini_entries_len + len + sizeof("=1\n\0"));
+ memcpy(ini_entries + ini_entries_len, php_optarg, len);
+ memcpy(ini_entries + ini_entries_len + len, "=1\n\0", sizeof("=1\n\0"));
+ ini_entries_len += len + sizeof("=1\n\0") - 2;
}
- case PHP_MODE_SHOW_INI_CONFIG:
- {
- zend_printf("Configuration File (php.ini) Path: %s\n", PHP_CONFIG_FILE_PATH);
- zend_printf("Loaded Configuration File: %s\n", php_ini_opened_path ? php_ini_opened_path : "(none)");
- zend_printf("Scan for additional .ini files in: %s\n", php_ini_scanned_path ? php_ini_scanned_path : "(none)");
- zend_printf("Additional .ini files parsed: %s\n", php_ini_scanned_files ? php_ini_scanned_files : "(none)");
- break;
- }
+ break;
+ }
+#ifndef PHP_CLI_WIN32_NO_CONSOLE
+ case 'S':
+ sapi_module = &cli_server_sapi_module;
+ break;
+#endif
+ case 'h': /* help & quit */
+ case '?':
+ php_cli_usage(argv[0]);
+ goto out;
+ case 'i': case 'v': case 'm':
+ sapi_module = &cli_sapi_module;
+ goto exit_loop;
+ case 'e': /* enable extended info output */
+ CG(compiler_options) |= ZEND_COMPILE_EXTENDED_INFO;
+ break;
}
+ }
+exit_loop:
+ sapi_module->ini_defaults = sapi_cli_ini_defaults;
+ sapi_module->php_ini_path_override = ini_path_override;
+ sapi_module->phpinfo_as_text = 1;
+ sapi_module->php_ini_ignore_cwd = 1;
+ sapi_startup(sapi_module);
+
+ sapi_module->ini_entries = ini_entries;
+ sapi_module->php_ini_ignore = ini_ignore;
+
+ sapi_module->executable_location = argv[0];
+
+ /* startup after we get the above ini override se we get things right */
+ if (sapi_module->startup(sapi_module) == FAILURE) {
+ /* there is no way to see if we must call zend_ini_deactivate()
+ * since we cannot check if EG(ini_directives) has been initialised
+ * because the executor's constructor does not set initialize it.
+ * Apart from that there seems no need for zend_ini_deactivate() yet.
+ * So we goto out_err.*/
+ exit_status = 1;
+ goto out;
+ }
+ module_started = 1;
+
+ zend_first_try {
+#ifndef PHP_CLI_WIN32_NO_CONSOLE
+ if (sapi_module == &cli_sapi_module) {
+#endif
+ ini_entries_len += sizeof(HARDCODED_INI) - 2;
+ ini_entries = realloc(ini_entries, ini_entries_len + sizeof(HARDCODED_INI));
+ memcpy(ini_entries, HARDCODED_INI, sizeof(HARDCODED_INI));
+ exit_status = do_cli(argc, argv TSRMLS_CC);
+#ifndef PHP_CLI_WIN32_NO_CONSOLE
+ } else {
+ exit_status = do_cli_server(argc, argv TSRMLS_CC);
+ }
+#endif
} zend_end_try();
-
out:
- if (request_started) {
- php_request_shutdown((void *) 0);
+ if (ini_path_override) {
+ free(ini_path_override);
}
- if (exit_status == 0) {
- exit_status = EG(exit_status);
+ if (ini_entries) {
+ free(ini_entries);
}
-out_err:
- if (cli_sapi_module.php_ini_path_override) {
- free(cli_sapi_module.php_ini_path_override);
- }
- if (cli_sapi_module.ini_entries) {
- free(cli_sapi_module.ini_entries);
- }
-
if (module_started) {
php_module_shutdown(TSRMLS_C);
}
@@ -1342,12 +1364,6 @@
#endif
exit(exit_status);
-
-err:
- sapi_deactivate(TSRMLS_C);
- zend_ini_deactivate(TSRMLS_C);
- exit_status = 1;
- goto out_err;
}
/* }}} */
Index: main/network.c
===================================================================
--- main/network.c (revision 308839)
+++ main/network.c (working copy)
@@ -148,7 +148,7 @@
/* {{{ php_network_freeaddresses
*/
-static void php_network_freeaddresses(struct sockaddr **sal)
+PHPAPI void php_network_freeaddresses(struct sockaddr **sal)
{
struct sockaddr **sap;
@@ -163,7 +163,7 @@
/* {{{ php_network_getaddresses
* Returns number of addresses, 0 for none/error
*/
-static int php_network_getaddresses(const char *host, int socktype, struct sockaddr ***sal, char **error_string TSRMLS_DC)
+PHPAPI int php_network_getaddresses(const char *host, int socktype, struct sockaddr ***sal, char **error_string TSRMLS_DC)
{
struct sockaddr **sap;
int n;
Index: main/php_main.h
===================================================================
--- main/php_main.h (revision 308839)
+++ main/php_main.h (working copy)
@@ -35,6 +35,7 @@
PHPAPI void php_module_shutdown_for_exec(void);
PHPAPI int php_module_shutdown_wrapper(sapi_module_struct *sapi_globals);
PHPAPI int php_request_startup_for_hook(TSRMLS_D);
+PHPAPI void php_request_shutdown_for_hook(void *dummy);
PHPAPI int php_register_extensions(zend_module_entry **ptr, int count TSRMLS_DC);
Index: main/php_network.h
===================================================================
--- main/php_network.h (revision 308839)
+++ main/php_network.h (working copy)
@@ -194,10 +194,12 @@
/* it is safe to FD_SET too many fd's under win32; the macro will simply ignore
* descriptors that go beyond the default FD_SETSIZE */
# define PHP_SAFE_FD_SET(fd, set) FD_SET(fd, set)
+# define PHP_SAFE_FD_CLR(fd, set) FD_CLR(fd, set)
# define PHP_SAFE_FD_ISSET(fd, set) FD_ISSET(fd, set)
# define PHP_SAFE_MAX_FD(m, n) do { if (n + 1 >= FD_SETSIZE) { _php_emit_fd_setsize_warning(n); }} while(0)
#else
# define PHP_SAFE_FD_SET(fd, set) do { if (fd < FD_SETSIZE) FD_SET(fd, set); } while(0)
+# define PHP_SAFE_FD_CLR(fd, set) do { if (fd < FD_SETSIZE) FD_CLR(fd, set); } while(0)
# define PHP_SAFE_FD_ISSET(fd, set) ((fd < FD_SETSIZE) && FD_ISSET(fd, set))
# define PHP_SAFE_MAX_FD(m, n) do { if (m >= FD_SETSIZE) { _php_emit_fd_setsize_warning(m); m = FD_SETSIZE - 1; }} while(0)
#endif
@@ -220,6 +222,9 @@
#endif
BEGIN_EXTERN_C()
+PHPAPI int php_network_getaddresses(const char *host, int socktype, struct sockaddr ***sal, char **error_string TSRMLS_DC);
+PHPAPI void php_network_freeaddresses(struct sockaddr **sal);
+
PHPAPI php_socket_t php_network_connect_socket_to_host(const char *host, unsigned short port,
int socktype, int asynchronous, struct timeval *timeout, char **error_string,
int *error_code, char *bindto, unsigned short bindport
@kirkegaard
Copy link

thumbs up!

@xqpmjh
Copy link

xqpmjh commented Mar 4, 2011

up ！Interesting idea ~

@sveneisenschmidt
Copy link

Currently A Co-Worker and I implementing a Webserver written completly in PHP from simple php Scripts up to forked full featured web applications like Symfony2 utilizing workers and so on.
(https://github.com/fate/pint-io)

I like the idea of implemeting a native web server, though.

@zircote
Copy link

zircote commented Mar 4, 2011

+1

@meal
Copy link

meal commented Mar 31, 2011

+1

@toddgeist
Copy link

The problem with pint-io is that you need runkit, and it is unix only.

@busbyjon
Copy link

I've built https://github.com/busbyjon/php-web-server - but it cant handle threads (a limitation of php on windows)..

@ptdorf
Copy link

ptdorf commented Jun 10, 2011

+1

@youngj
Copy link

youngj commented Jun 15, 2011

It's possible to build a HTTP server in pure PHP that executes arbitrary PHP scripts (with no dependency on runkit). The server just needs to invoke the PHP-CGI executable with the correct environment variables according to the CGI specification.

https://github.com/youngj/httpserver

  • works on Windows as well as POSIX systems
  • uses non-blocking sockets to handle multiple concurrent requests
  • implements HTTP Keep-Alive
  • single-process (since sockets can't be shared across processes in PHP on Windows, as far as I know)

Clients just subclass HTTPServer and define application-specific routing rules in PHP. Examples:

https://github.com/youngj/Envaya/blob/master/scripts/web_server.php
https://github.com/youngj/httpserver/blob/master/examples/example_server.php

@halfdan
Copy link

halfdan commented Jun 19, 2011

+1 Definitely will become handy once merged into PHP core.

@rmdir
Copy link

rmdir commented Jun 20, 2011

Why not use libevent ? It's portable, It has a great, fast and mostly complete http implementation.
And has far as I know fpm already uses it. http://monkey.org/~provos/libevent/

@dator-zz
Copy link

+1

@leandro
Copy link

leandro commented Jul 15, 2011

Question: to which release should I apply this?

@halfdan
Copy link

halfdan commented Jul 15, 2011

AFAIK this is already applied to php trunk. Latest build from trunk already contains an embedded webserver.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment