1/*
2   +----------------------------------------------------------------------+
3   | PHP Version 5                                                        |
4   +----------------------------------------------------------------------+
5   | Copyright (c) 1997-2013 The PHP Group                                |
6   +----------------------------------------------------------------------+
7   | This source file is subject to version 3.01 of the PHP license,      |
8   | that is bundled with this package in the file LICENSE, and is        |
9   | available through the world-wide-web at the following url:           |
10   | http://www.php.net/license/3_01.txt                                  |
11   | If you did not receive a copy of the PHP license and are unable to   |
12   | obtain it through the world-wide-web, please send a note to          |
13   | license@php.net so we can mail you a copy immediately.               |
14   +----------------------------------------------------------------------+
15   | Author: Edin Kadribasic <edink@php.net>                              |
16   |         Marcus Boerger <helly@php.net>                               |
17   |         Johannes Schlueter <johannes@php.net>                        |
18   |         Parts based on CGI SAPI Module by                            |
19   |         Rasmus Lerdorf, Stig Bakken and Zeev Suraski                 |
20   +----------------------------------------------------------------------+
21*/
22
23/* $Id$ */
24
25#include "php.h"
26#include "php_globals.h"
27#include "php_variables.h"
28#include "zend_hash.h"
29#include "zend_modules.h"
30#include "zend_interfaces.h"
31
32#include "ext/reflection/php_reflection.h"
33
34#include "SAPI.h"
35
36#include <stdio.h>
37#include "php.h"
38#ifdef PHP_WIN32
39#include "win32/time.h"
40#include "win32/signal.h"
41#include <process.h>
42#endif
43#if HAVE_SYS_TIME_H
44#include <sys/time.h>
45#endif
46#if HAVE_UNISTD_H
47#include <unistd.h>
48#endif
49#if HAVE_SIGNAL_H
50#include <signal.h>
51#endif
52#if HAVE_SETLOCALE
53#include <locale.h>
54#endif
55#include "zend.h"
56#include "zend_extensions.h"
57#include "php_ini.h"
58#include "php_globals.h"
59#include "php_main.h"
60#include "fopen_wrappers.h"
61#include "ext/standard/php_standard.h"
62#ifdef PHP_WIN32
63#include <io.h>
64#include <fcntl.h>
65#include "win32/php_registry.h"
66#endif
67
68#if HAVE_SIGNAL_H
69#include <signal.h>
70#endif
71
72#ifdef __riscos__
73#include <unixlib/local.h>
74#endif
75
76#if (HAVE_LIBREADLINE || HAVE_LIBEDIT) && !defined(COMPILE_DL_READLINE)
77#if HAVE_LIBEDIT
78#include <editline/readline.h>
79#else
80#include <readline/readline.h>
81#include <readline/history.h>
82#endif
83#include "php_cli_readline.h"
84#endif /* HAVE_LIBREADLINE || HAVE_LIBEDIT */
85
86#include "zend_compile.h"
87#include "zend_execute.h"
88#include "zend_highlight.h"
89#include "zend_indent.h"
90#include "zend_exceptions.h"
91
92#include "php_getopt.h"
93
94#ifndef PHP_WIN32
95# define php_select(m, r, w, e, t)  select(m, r, w, e, t)
96#else
97# include "win32/select.h"
98#endif
99
100PHPAPI extern char *php_ini_opened_path;
101PHPAPI extern char *php_ini_scanned_path;
102PHPAPI extern char *php_ini_scanned_files;
103
104#ifndef O_BINARY
105#define O_BINARY 0
106#endif
107
108#define PHP_MODE_STANDARD      1
109#define PHP_MODE_HIGHLIGHT     2
110#define PHP_MODE_INDENT        3
111#define PHP_MODE_LINT          4
112#define PHP_MODE_STRIP         5
113#define PHP_MODE_CLI_DIRECT    6
114#define PHP_MODE_PROCESS_STDIN 7
115#define PHP_MODE_REFLECTION_FUNCTION    8
116#define PHP_MODE_REFLECTION_CLASS       9
117#define PHP_MODE_REFLECTION_EXTENSION   10
118#define PHP_MODE_REFLECTION_EXT_INFO    11
119#define PHP_MODE_SHOW_INI_CONFIG        12
120
121const char HARDCODED_INI[] =
122    "html_errors=0\n"
123    "register_argc_argv=1\n"
124    "implicit_flush=1\n"
125    "output_buffering=0\n"
126    "max_execution_time=0\n"
127    "max_input_time=-1\n\0";
128
129static char *php_optarg = NULL;
130static int php_optind = 1;
131#if (HAVE_LIBREADLINE || HAVE_LIBEDIT) && !defined(COMPILE_DL_READLINE)
132static char php_last_char = '\0';
133#endif
134
135static const opt_struct OPTIONS[] = {
136    {'a', 0, "interactive"},
137    {'B', 1, "process-begin"},
138    {'C', 0, "no-chdir"}, /* for compatibility with CGI (do not chdir to script directory) */
139    {'c', 1, "php-ini"},
140    {'d', 1, "define"},
141    {'E', 1, "process-end"},
142    {'e', 0, "profile-info"},
143    {'F', 1, "process-file"},
144    {'f', 1, "file"},
145    {'h', 0, "help"},
146    {'i', 0, "info"},
147    {'l', 0, "syntax-check"},
148    {'m', 0, "modules"},
149    {'n', 0, "no-php-ini"},
150    {'q', 0, "no-header"}, /* for compatibility with CGI (do not generate HTTP headers) */
151    {'R', 1, "process-code"},
152    {'H', 0, "hide-args"},
153    {'r', 1, "run"},
154    {'s', 0, "syntax-highlight"},
155    {'s', 0, "syntax-highlighting"},
156    {'w', 0, "strip"},
157    {'?', 0, "usage"},/* help alias (both '?' and 'usage') */
158    {'v', 0, "version"},
159    {'z', 1, "zend-extension"},
160    {10,  1, "rf"},
161    {10,  1, "rfunction"},
162    {11,  1, "rc"},
163    {11,  1, "rclass"},
164    {12,  1, "re"},
165    {12,  1, "rextension"},
166    {13,  1, "ri"},
167    {13,  1, "rextinfo"},
168    {14,  0, "ini"},
169    {'-', 0, NULL} /* end of args */
170};
171
172static int print_module_info(zend_module_entry *module TSRMLS_DC) /* {{{ */
173{
174    php_printf("%s\n", module->name);
175    return ZEND_HASH_APPLY_KEEP;
176}
177/* }}} */
178
179static int module_name_cmp(const void *a, const void *b TSRMLS_DC) /* {{{ */
180{
181    Bucket *f = *((Bucket **) a);
182    Bucket *s = *((Bucket **) b);
183
184    return strcasecmp(((zend_module_entry *)f->pData)->name,
185                  ((zend_module_entry *)s->pData)->name);
186}
187/* }}} */
188
189static void print_modules(TSRMLS_D) /* {{{ */
190{
191    HashTable sorted_registry;
192    zend_module_entry tmp;
193
194    zend_hash_init(&sorted_registry, 50, NULL, NULL, 1);
195    zend_hash_copy(&sorted_registry, &module_registry, NULL, &tmp, sizeof(zend_module_entry));
196    zend_hash_sort(&sorted_registry, zend_qsort, module_name_cmp, 0 TSRMLS_CC);
197    zend_hash_apply(&sorted_registry, (apply_func_t) print_module_info TSRMLS_CC);
198    zend_hash_destroy(&sorted_registry);
199}
200/* }}} */
201
202static int print_extension_info(zend_extension *ext, void *arg TSRMLS_DC) /* {{{ */
203{
204    php_printf("%s\n", ext->name);
205    return ZEND_HASH_APPLY_KEEP;
206}
207/* }}} */
208
209static int extension_name_cmp(const zend_llist_element **f, const zend_llist_element **s TSRMLS_DC) /* {{{ */
210{
211    return strcmp(((zend_extension *)(*f)->data)->name,
212                  ((zend_extension *)(*s)->data)->name);
213}
214/* }}} */
215
216static void print_extensions(TSRMLS_D) /* {{{ */
217{
218    zend_llist sorted_exts;
219
220    zend_llist_copy(&sorted_exts, &zend_extensions);
221    sorted_exts.dtor = NULL;
222    zend_llist_sort(&sorted_exts, extension_name_cmp TSRMLS_CC);
223    zend_llist_apply(&sorted_exts, (llist_apply_func_t) print_extension_info TSRMLS_CC);
224    zend_llist_destroy(&sorted_exts);
225}
226/* }}} */
227
228#ifndef STDOUT_FILENO
229#define STDOUT_FILENO 1
230#endif
231
232static inline int sapi_cli_select(int fd TSRMLS_DC)
233{
234    fd_set wfd, dfd;
235    struct timeval tv;
236    int ret;
237
238    FD_ZERO(&wfd);
239    FD_ZERO(&dfd);
240
241    PHP_SAFE_FD_SET(fd, &wfd);
242
243    tv.tv_sec = FG(default_socket_timeout);
244    tv.tv_usec = 0;
245
246    ret = php_select(fd+1, &dfd, &wfd, &dfd, &tv);
247
248    return ret != -1;
249}
250
251static inline size_t sapi_cli_single_write(const char *str, uint str_length TSRMLS_DC) /* {{{ */
252{
253#ifdef PHP_WRITE_STDOUT
254    long ret;
255
256    do {
257        ret = write(STDOUT_FILENO, str, str_length);
258    } while (ret <= 0 && errno == EAGAIN && sapi_cli_select(STDOUT_FILENO TSRMLS_CC));
259
260    if (ret <= 0) {
261        return 0;
262    }
263
264    return ret;
265#else
266    size_t ret;
267
268    ret = fwrite(str, 1, MIN(str_length, 16384), stdout);
269    return ret;
270#endif
271}
272/* }}} */
273
274static int sapi_cli_ub_write(const char *str, uint str_length TSRMLS_DC) /* {{{ */
275{
276    const char *ptr = str;
277    uint remaining = str_length;
278    size_t ret;
279
280#if (HAVE_LIBREADLINE || HAVE_LIBEDIT) && !defined(COMPILE_DL_READLINE)
281    if (!str_length) {
282        return 0;
283    }
284    php_last_char = str[str_length-1];
285#endif
286
287    while (remaining > 0)
288    {
289        ret = sapi_cli_single_write(ptr, remaining TSRMLS_CC);
290        if (!ret) {
291#ifndef PHP_CLI_WIN32_NO_CONSOLE
292            php_handle_aborted_connection();
293#endif
294            break;
295        }
296        ptr += ret;
297        remaining -= ret;
298    }
299
300    return (ptr - str);
301}
302/* }}} */
303
304static void sapi_cli_flush(void *server_context) /* {{{ */
305{
306    /* Ignore EBADF here, it's caused by the fact that STDIN/STDOUT/STDERR streams
307     * are/could be closed before fflush() is called.
308     */
309    if (fflush(stdout)==EOF && errno!=EBADF) {
310#ifndef PHP_CLI_WIN32_NO_CONSOLE
311        php_handle_aborted_connection();
312#endif
313    }
314}
315/* }}} */
316
317static char *php_self = "";
318static char *script_filename = "";
319
320static void sapi_cli_register_variables(zval *track_vars_array TSRMLS_DC) /* {{{ */
321{
322    unsigned int len;
323    char   *docroot = "";
324
325    /* In CGI mode, we consider the environment to be a part of the server
326     * variables
327     */
328    php_import_environment_variables(track_vars_array TSRMLS_CC);
329
330    /* Build the special-case PHP_SELF variable for the CLI version */
331    len = strlen(php_self);
332    if (sapi_module.input_filter(PARSE_SERVER, "PHP_SELF", &php_self, len, &len TSRMLS_CC)) {
333        php_register_variable("PHP_SELF", php_self, track_vars_array TSRMLS_CC);
334    }
335    if (sapi_module.input_filter(PARSE_SERVER, "SCRIPT_NAME", &php_self, len, &len TSRMLS_CC)) {
336        php_register_variable("SCRIPT_NAME", php_self, track_vars_array TSRMLS_CC);
337    }
338    /* filenames are empty for stdin */
339    len = strlen(script_filename);
340    if (sapi_module.input_filter(PARSE_SERVER, "SCRIPT_FILENAME", &script_filename, len, &len TSRMLS_CC)) {
341        php_register_variable("SCRIPT_FILENAME", script_filename, track_vars_array TSRMLS_CC);
342    }
343    if (sapi_module.input_filter(PARSE_SERVER, "PATH_TRANSLATED", &script_filename, len, &len TSRMLS_CC)) {
344        php_register_variable("PATH_TRANSLATED", script_filename, track_vars_array TSRMLS_CC);
345    }
346    /* just make it available */
347    len = 0U;
348    if (sapi_module.input_filter(PARSE_SERVER, "DOCUMENT_ROOT", &docroot, len, &len TSRMLS_CC)) {
349        php_register_variable("DOCUMENT_ROOT", docroot, track_vars_array TSRMLS_CC);
350    }
351}
352/* }}} */
353
354static void sapi_cli_log_message(char *message) /* {{{ */
355{
356    fprintf(stderr, "%s\n", message);
357}
358/* }}} */
359
360static int sapi_cli_deactivate(TSRMLS_D) /* {{{ */
361{
362    fflush(stdout);
363    if(SG(request_info).argv0) {
364        free(SG(request_info).argv0);
365        SG(request_info).argv0 = NULL;
366    }
367    return SUCCESS;
368}
369/* }}} */
370
371static char* sapi_cli_read_cookies(TSRMLS_D) /* {{{ */
372{
373    return NULL;
374}
375/* }}} */
376
377static int sapi_cli_header_handler(sapi_header_struct *h, sapi_header_op_enum op, sapi_headers_struct *s TSRMLS_DC) /* {{{ */
378{
379    return 0;
380}
381/* }}} */
382
383static int sapi_cli_send_headers(sapi_headers_struct *sapi_headers TSRMLS_DC) /* {{{ */
384{
385    /* We do nothing here, this function is needed to prevent that the fallback
386     * header handling is called. */
387    return SAPI_HEADER_SENT_SUCCESSFULLY;
388}
389/* }}} */
390
391static void sapi_cli_send_header(sapi_header_struct *sapi_header, void *server_context TSRMLS_DC) /* {{{ */
392{
393}
394/* }}} */
395
396static int php_cli_startup(sapi_module_struct *sapi_module) /* {{{ */
397{
398    if (php_module_startup(sapi_module, NULL, 0)==FAILURE) {
399        return FAILURE;
400    }
401    return SUCCESS;
402}
403/* }}} */
404
405/* {{{ sapi_cli_ini_defaults */
406
407/* overwriteable ini defaults must be set in sapi_cli_ini_defaults() */
408#define INI_DEFAULT(name,value)\
409    Z_SET_REFCOUNT(tmp, 0);\
410    Z_UNSET_ISREF(tmp); \
411    ZVAL_STRINGL(&tmp, zend_strndup(value, sizeof(value)-1), sizeof(value)-1, 0);\
412    zend_hash_update(configuration_hash, name, sizeof(name), &tmp, sizeof(zval), NULL);\
413
414static void sapi_cli_ini_defaults(HashTable *configuration_hash)
415{
416    zval tmp;
417    INI_DEFAULT("report_zend_debug", "0");
418    INI_DEFAULT("display_errors", "1");
419}
420/* }}} */
421
422/* {{{ sapi_module_struct cli_sapi_module
423 */
424static sapi_module_struct cli_sapi_module = {
425    "cli",                          /* name */
426    "Command Line Interface",       /* pretty name */
427
428    php_cli_startup,                /* startup */
429    php_module_shutdown_wrapper,    /* shutdown */
430
431    NULL,                           /* activate */
432    sapi_cli_deactivate,            /* deactivate */
433
434    sapi_cli_ub_write,              /* unbuffered write */
435    sapi_cli_flush,                 /* flush */
436    NULL,                           /* get uid */
437    NULL,                           /* getenv */
438
439    php_error,                      /* error handler */
440
441    sapi_cli_header_handler,        /* header handler */
442    sapi_cli_send_headers,          /* send headers handler */
443    sapi_cli_send_header,           /* send header handler */
444
445    NULL,                           /* read POST data */
446    sapi_cli_read_cookies,          /* read Cookies */
447
448    sapi_cli_register_variables,    /* register server variables */
449    sapi_cli_log_message,           /* Log message */
450    NULL,                           /* Get request time */
451    NULL,                           /* Child terminate */
452
453    STANDARD_SAPI_MODULE_PROPERTIES
454};
455/* }}} */
456
457/* {{{ arginfo ext/standard/dl.c */
458ZEND_BEGIN_ARG_INFO(arginfo_dl, 0)
459    ZEND_ARG_INFO(0, extension_filename)
460ZEND_END_ARG_INFO()
461/* }}} */
462
463static const zend_function_entry additional_functions[] = {
464    ZEND_FE(dl, arginfo_dl)
465    {NULL, NULL, NULL}
466};
467
468/* {{{ php_cli_usage
469 */
470static void php_cli_usage(char *argv0)
471{
472    char *prog;
473
474    prog = strrchr(argv0, '/');
475    if (prog) {
476        prog++;
477    } else {
478        prog = "php";
479    }
480
481    php_printf( "Usage: %s [options] [-f] <file> [--] [args...]\n"
482                "       %s [options] -r <code> [--] [args...]\n"
483                "       %s [options] [-B <begin_code>] -R <code> [-E <end_code>] [--] [args...]\n"
484                "       %s [options] [-B <begin_code>] -F <file> [-E <end_code>] [--] [args...]\n"
485                "       %s [options] -- [args...]\n"
486                "       %s [options] -a\n"
487                "\n"
488#if (HAVE_LIBREADLINE || HAVE_LIBEDIT) && !defined(COMPILE_DL_READLINE)
489                "  -a               Run as interactive shell\n"
490#else
491                "  -a               Run interactively\n"
492#endif
493                "  -c <path>|<file> Look for php.ini file in this directory\n"
494                "  -n               No php.ini file will be used\n"
495                "  -d foo[=bar]     Define INI entry foo with value 'bar'\n"
496                "  -e               Generate extended information for debugger/profiler\n"
497                "  -f <file>        Parse and execute <file>.\n"
498                "  -h               This help\n"
499                "  -i               PHP information\n"
500                "  -l               Syntax check only (lint)\n"
501                "  -m               Show compiled in modules\n"
502                "  -r <code>        Run PHP <code> without using script tags <?..?>\n"
503                "  -B <begin_code>  Run PHP <begin_code> before processing input lines\n"
504                "  -R <code>        Run PHP <code> for every input line\n"
505                "  -F <file>        Parse and execute <file> for every input line\n"
506                "  -E <end_code>    Run PHP <end_code> after processing all input lines\n"
507                "  -H               Hide any passed arguments from external tools.\n"
508                "  -s               Output HTML syntax highlighted source.\n"
509                "  -v               Version number\n"
510                "  -w               Output source with stripped comments and whitespace.\n"
511                "  -z <file>        Load Zend extension <file>.\n"
512                "\n"
513                "  args...          Arguments passed to script. Use -- args when first argument\n"
514                "                   starts with - or script is read from stdin\n"
515                "\n"
516                "  --ini            Show configuration file names\n"
517                "\n"
518                "  --rf <name>      Show information about function <name>.\n"
519                "  --rc <name>      Show information about class <name>.\n"
520                "  --re <name>      Show information about extension <name>.\n"
521                "  --ri <name>      Show configuration for extension <name>.\n"
522                "\n"
523                , prog, prog, prog, prog, prog, prog);
524}
525/* }}} */
526
527static php_stream *s_in_process = NULL;
528
529static void cli_register_file_handles(TSRMLS_D) /* {{{ */
530{
531    zval *zin, *zout, *zerr;
532    php_stream *s_in, *s_out, *s_err;
533    php_stream_context *sc_in=NULL, *sc_out=NULL, *sc_err=NULL;
534    zend_constant ic, oc, ec;
535
536    MAKE_STD_ZVAL(zin);
537    MAKE_STD_ZVAL(zout);
538    MAKE_STD_ZVAL(zerr);
539
540    s_in  = php_stream_open_wrapper_ex("php://stdin",  "rb", 0, NULL, sc_in);
541    s_out = php_stream_open_wrapper_ex("php://stdout", "wb", 0, NULL, sc_out);
542    s_err = php_stream_open_wrapper_ex("php://stderr", "wb", 0, NULL, sc_err);
543
544    if (s_in==NULL || s_out==NULL || s_err==NULL) {
545        FREE_ZVAL(zin);
546        FREE_ZVAL(zout);
547        FREE_ZVAL(zerr);
548        if (s_in) php_stream_close(s_in);
549        if (s_out) php_stream_close(s_out);
550        if (s_err) php_stream_close(s_err);
551        return;
552    }
553
554#if PHP_DEBUG
555    /* do not close stdout and stderr */
556    s_out->flags |= PHP_STREAM_FLAG_NO_CLOSE;
557    s_err->flags |= PHP_STREAM_FLAG_NO_CLOSE;
558#endif
559
560    s_in_process = s_in;
561
562    php_stream_to_zval(s_in,  zin);
563    php_stream_to_zval(s_out, zout);
564    php_stream_to_zval(s_err, zerr);
565
566    ic.value = *zin;
567    ic.flags = CONST_CS;
568    ic.name = zend_strndup(ZEND_STRL("STDIN"));
569    ic.name_len = sizeof("STDIN");
570    ic.module_number = 0;
571    zend_register_constant(&ic TSRMLS_CC);
572
573    oc.value = *zout;
574    oc.flags = CONST_CS;
575    oc.name = zend_strndup(ZEND_STRL("STDOUT"));
576    oc.name_len = sizeof("STDOUT");
577    oc.module_number = 0;
578    zend_register_constant(&oc TSRMLS_CC);
579
580    ec.value = *zerr;
581    ec.flags = CONST_CS;
582    ec.name = zend_strndup(ZEND_STRL("STDERR"));
583    ec.name_len = sizeof("STDERR");
584    ec.module_number = 0;
585    zend_register_constant(&ec TSRMLS_CC);
586
587    FREE_ZVAL(zin);
588    FREE_ZVAL(zout);
589    FREE_ZVAL(zerr);
590}
591/* }}} */
592
593static const char *param_mode_conflict = "Either execute direct code, process stdin or use a file.\n";
594
595/* {{{ cli_seek_file_begin
596 */
597static int cli_seek_file_begin(zend_file_handle *file_handle, char *script_file, int *lineno TSRMLS_DC)
598{
599    int c;
600
601    *lineno = 1;
602
603    file_handle->type = ZEND_HANDLE_FP;
604    file_handle->opened_path = NULL;
605    file_handle->free_filename = 0;
606    if (!(file_handle->handle.fp = VCWD_FOPEN(script_file, "rb"))) {
607        php_printf("Could not open input file: %s\n", script_file);
608        return FAILURE;
609    }
610    file_handle->filename = script_file;
611
612    /* #!php support */
613    c = fgetc(file_handle->handle.fp);
614    if (c == '#' && (c = fgetc(file_handle->handle.fp)) == '!') {
615        while (c != '\n' && c != '\r' && c != EOF) {
616            c = fgetc(file_handle->handle.fp);  /* skip to end of line */
617        }
618        /* handle situations where line is terminated by \r\n */
619        if (c == '\r') {
620            if (fgetc(file_handle->handle.fp) != '\n') {
621                long pos = ftell(file_handle->handle.fp);
622                fseek(file_handle->handle.fp, pos - 1, SEEK_SET);
623            }
624        }
625        *lineno = 2;
626    } else {
627        rewind(file_handle->handle.fp);
628    }
629
630    return SUCCESS;
631}
632/* }}} */
633
634/* {{{ main
635 */
636#ifdef PHP_CLI_WIN32_NO_CONSOLE
637int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nShowCmd)
638#else
639int main(int argc, char *argv[])
640#endif
641{
642    volatile int exit_status = SUCCESS;
643    int c;
644    zend_file_handle file_handle;
645/* temporary locals */
646    int behavior=PHP_MODE_STANDARD;
647    char *reflection_what = NULL;
648    int orig_optind=php_optind;
649    char *orig_optarg=php_optarg;
650    char *arg_free=NULL, **arg_excp=&arg_free;
651    char *script_file=NULL, *translated_path = NULL;
652    int interactive=0;
653    volatile int module_started = 0;
654    volatile int request_started = 0;
655    int lineno = 0;
656    char *exec_direct=NULL, *exec_run=NULL, *exec_begin=NULL, *exec_end=NULL;
657    const char *param_error=NULL;
658    int hide_argv = 0;
659/* end of temporary locals */
660#ifdef ZTS
661    void ***tsrm_ls;
662#endif
663#ifdef PHP_CLI_WIN32_NO_CONSOLE
664    int argc = __argc;
665    char **argv = __argv;
666#endif
667    int ini_entries_len = 0;
668
669#if defined(PHP_WIN32) && defined(_DEBUG) && defined(PHP_WIN32_DEBUG_HEAP)
670    {
671        int tmp_flag;
672        _CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE);
673        _CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDERR);
674        _CrtSetReportMode(_CRT_ERROR, _CRTDBG_MODE_FILE);
675        _CrtSetReportFile(_CRT_ERROR, _CRTDBG_FILE_STDERR);
676        _CrtSetReportMode(_CRT_ASSERT, _CRTDBG_MODE_FILE);
677        _CrtSetReportFile(_CRT_ASSERT, _CRTDBG_FILE_STDERR);
678        tmp_flag = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG);
679        tmp_flag |= _CRTDBG_DELAY_FREE_MEM_DF;
680        tmp_flag |= _CRTDBG_LEAK_CHECK_DF;
681
682        _CrtSetDbgFlag(tmp_flag);
683    }
684#endif
685
686#ifdef HAVE_SIGNAL_H
687#if defined(SIGPIPE) && defined(SIG_IGN)
688    signal(SIGPIPE, SIG_IGN); /* ignore SIGPIPE in standalone mode so
689                                that sockets created via fsockopen()
690                                don't kill PHP if the remote site
691                                closes it.  in apache|apxs mode apache
692                                does that for us!  thies@thieso.net
693                                20000419 */
694#endif
695#endif
696
697
698#ifdef ZTS
699    tsrm_startup(1, 1, 0, NULL);
700    tsrm_ls = ts_resource(0);
701#endif
702
703    cli_sapi_module.ini_defaults = sapi_cli_ini_defaults;
704    cli_sapi_module.php_ini_path_override = NULL;
705    cli_sapi_module.phpinfo_as_text = 1;
706    sapi_startup(&cli_sapi_module);
707
708#ifdef PHP_WIN32
709    _fmode = _O_BINARY;         /*sets default for file streams to binary */
710    setmode(_fileno(stdin), O_BINARY);      /* make the stdio mode be binary */
711    setmode(_fileno(stdout), O_BINARY);     /* make the stdio mode be binary */
712    setmode(_fileno(stderr), O_BINARY);     /* make the stdio mode be binary */
713#endif
714
715    ini_entries_len = sizeof(HARDCODED_INI)-2;
716    cli_sapi_module.ini_entries = malloc(sizeof(HARDCODED_INI));
717    memcpy(cli_sapi_module.ini_entries, HARDCODED_INI, sizeof(HARDCODED_INI));
718
719    while ((c = php_getopt(argc, argv, OPTIONS, &php_optarg, &php_optind, 0, 2))!=-1) {
720        switch (c) {
721            case 'c':
722                if (cli_sapi_module.php_ini_path_override) {
723                    free(cli_sapi_module.php_ini_path_override);
724                }
725                cli_sapi_module.php_ini_path_override = strdup(php_optarg);
726                break;
727            case 'n':
728                cli_sapi_module.php_ini_ignore = 1;
729                break;
730            case 'd': {
731                /* define ini entries on command line */
732                int len = strlen(php_optarg);
733                char *val;
734
735                if ((val = strchr(php_optarg, '='))) {
736                    val++;
737                    if (!isalnum(*val) && *val != '"' && *val != '\'' && *val != '\0') {
738                        cli_sapi_module.ini_entries = realloc(cli_sapi_module.ini_entries, ini_entries_len + len + sizeof("\"\"\n\0"));
739                        memcpy(cli_sapi_module.ini_entries + ini_entries_len, php_optarg, (val - php_optarg));
740                        ini_entries_len += (val - php_optarg);
741                        memcpy(cli_sapi_module.ini_entries + ini_entries_len, "\"", 1);
742                        ini_entries_len++;
743                        memcpy(cli_sapi_module.ini_entries + ini_entries_len, val, len - (val - php_optarg));
744                        ini_entries_len += len - (val - php_optarg);
745                        memcpy(cli_sapi_module.ini_entries + ini_entries_len, "\"\n\0", sizeof("\"\n\0"));
746                        ini_entries_len += sizeof("\n\0\"") - 2;
747                    } else {
748                        cli_sapi_module.ini_entries = realloc(cli_sapi_module.ini_entries, ini_entries_len + len + sizeof("\n\0"));
749                        memcpy(cli_sapi_module.ini_entries + ini_entries_len, php_optarg, len);
750                        memcpy(cli_sapi_module.ini_entries + ini_entries_len + len, "\n\0", sizeof("\n\0"));
751                        ini_entries_len += len + sizeof("\n\0") - 2;
752                    }
753                } else {
754                    cli_sapi_module.ini_entries = realloc(cli_sapi_module.ini_entries, ini_entries_len + len + sizeof("=1\n\0"));
755                    memcpy(cli_sapi_module.ini_entries + ini_entries_len, php_optarg, len);
756                    memcpy(cli_sapi_module.ini_entries + ini_entries_len + len, "=1\n\0", sizeof("=1\n\0"));
757                    ini_entries_len += len + sizeof("=1\n\0") - 2;
758                }
759                break;
760            }
761        }
762    }
763    php_optind = orig_optind;
764    php_optarg = orig_optarg;
765
766    cli_sapi_module.executable_location = argv[0];
767    cli_sapi_module.additional_functions = additional_functions;
768
769    /* startup after we get the above ini override se we get things right */
770    if (cli_sapi_module.startup(&cli_sapi_module)==FAILURE) {
771        /* there is no way to see if we must call zend_ini_deactivate()
772         * since we cannot check if EG(ini_directives) has been initialised
773         * because the executor's constructor does not set initialize it.
774         * Apart from that there seems no need for zend_ini_deactivate() yet.
775         * So we goto out_err.*/
776        exit_status = 1;
777        goto out_err;
778    }
779    module_started = 1;
780
781    zend_first_try {
782        CG(in_compilation) = 0; /* not initialized but needed for several options */
783        EG(uninitialized_zval_ptr) = NULL;
784
785        while ((c = php_getopt(argc, argv, OPTIONS, &php_optarg, &php_optind, 0, 2)) != -1) {
786            switch (c) {
787
788            case 'h': /* help & quit */
789            case '?':
790                if (php_request_startup(TSRMLS_C)==FAILURE) {
791                    goto err;
792                }
793                request_started = 1;
794                php_cli_usage(argv[0]);
795                php_end_ob_buffers(1 TSRMLS_CC);
796                exit_status = (c == '?' && argc > 1 && !strchr(argv[1],  c));
797                goto out;
798
799            case 'i': /* php info & quit */
800                if (php_request_startup(TSRMLS_C)==FAILURE) {
801                    goto err;
802                }
803                request_started = 1;
804                php_print_info(0xFFFFFFFF TSRMLS_CC);
805                php_end_ob_buffers(1 TSRMLS_CC);
806                exit_status=0;
807                goto out;
808
809            case 'm': /* list compiled in modules */
810                if (php_request_startup(TSRMLS_C)==FAILURE) {
811                    goto err;
812                }
813                request_started = 1;
814                php_printf("[PHP Modules]\n");
815                print_modules(TSRMLS_C);
816                php_printf("\n[Zend Modules]\n");
817                print_extensions(TSRMLS_C);
818                php_printf("\n");
819                php_end_ob_buffers(1 TSRMLS_CC);
820                exit_status=0;
821                goto out;
822
823            case 'v': /* show php version & quit */
824                if (php_request_startup(TSRMLS_C) == FAILURE) {
825                    goto err;
826                }
827
828                request_started = 1;
829                php_printf("PHP %s (%s) (built: %s %s) %s\nCopyright (c) 1997-2013 The PHP Group\n%s",
830                    PHP_VERSION, sapi_module.name, __DATE__, __TIME__,
831#if ZEND_DEBUG && defined(HAVE_GCOV)
832                    "(DEBUG GCOV)",
833#elif ZEND_DEBUG
834                    "(DEBUG)",
835#elif defined(HAVE_GCOV)
836                    "(GCOV)",
837#else
838                    "",
839#endif
840                    get_zend_version()
841                );
842                php_end_ob_buffers(1 TSRMLS_CC);
843                exit_status=0;
844                goto out;
845
846            default:
847                break;
848            }
849        }
850
851        /* Set some CLI defaults */
852        SG(options) |= SAPI_OPTION_NO_CHDIR;
853
854        php_optind = orig_optind;
855        php_optarg = orig_optarg;
856        while ((c = php_getopt(argc, argv, OPTIONS, &php_optarg, &php_optind, 0, 2)) != -1) {
857            switch (c) {
858
859            case 'a':   /* interactive mode */
860                if (!interactive) {
861                    if (behavior != PHP_MODE_STANDARD) {
862                        param_error = param_mode_conflict;
863                        break;
864                    }
865
866                    interactive=1;
867                }
868                break;
869
870            case 'C': /* don't chdir to the script directory */
871                /* This is default so NOP */
872                break;
873
874            case 'e': /* enable extended info output */
875                CG(compiler_options) |= ZEND_COMPILE_EXTENDED_INFO;
876                break;
877
878            case 'F':
879                if (behavior == PHP_MODE_PROCESS_STDIN) {
880                    if (exec_run || script_file) {
881                        param_error = "You can use -R or -F only once.\n";
882                        break;
883                    }
884                } else if (behavior != PHP_MODE_STANDARD) {
885                    param_error = param_mode_conflict;
886                    break;
887                }
888                behavior=PHP_MODE_PROCESS_STDIN;
889                script_file = php_optarg;
890                break;
891
892            case 'f': /* parse file */
893                if (behavior == PHP_MODE_CLI_DIRECT || behavior == PHP_MODE_PROCESS_STDIN) {
894                    param_error = param_mode_conflict;
895                    break;
896                } else if (script_file) {
897                    param_error = "You can use -f only once.\n";
898                    break;
899                }
900                script_file = php_optarg;
901                break;
902
903            case 'l': /* syntax check mode */
904                if (behavior != PHP_MODE_STANDARD) {
905                    break;
906                }
907                behavior=PHP_MODE_LINT;
908                break;
909
910#if 0 /* not yet operational, see also below ... */
911            case '': /* generate indented source mode*/
912                if (behavior == PHP_MODE_CLI_DIRECT || behavior == PHP_MODE_PROCESS_STDIN) {
913                    param_error = "Source indenting only works for files.\n";
914                    break;
915                }
916                behavior=PHP_MODE_INDENT;
917                break;
918#endif
919
920            case 'q': /* do not generate HTTP headers */
921                /* This is default so NOP */
922                break;
923
924            case 'r': /* run code from command line */
925                if (behavior == PHP_MODE_CLI_DIRECT) {
926                    if (exec_direct || script_file) {
927                        param_error = "You can use -r only once.\n";
928                        break;
929                    }
930                } else if (behavior != PHP_MODE_STANDARD || interactive) {
931                    param_error = param_mode_conflict;
932                    break;
933                }
934                behavior=PHP_MODE_CLI_DIRECT;
935                exec_direct=php_optarg;
936                break;
937
938            case 'R':
939                if (behavior == PHP_MODE_PROCESS_STDIN) {
940                    if (exec_run || script_file) {
941                        param_error = "You can use -R or -F only once.\n";
942                        break;
943                    }
944                } else if (behavior != PHP_MODE_STANDARD) {
945                    param_error = param_mode_conflict;
946                    break;
947                }
948                behavior=PHP_MODE_PROCESS_STDIN;
949                exec_run=php_optarg;
950                break;
951
952            case 'B':
953                if (behavior == PHP_MODE_PROCESS_STDIN) {
954                    if (exec_begin) {
955                        param_error = "You can use -B only once.\n";
956                        break;
957                    }
958                } else if (behavior != PHP_MODE_STANDARD || interactive) {
959                    param_error = param_mode_conflict;
960                    break;
961                }
962                behavior=PHP_MODE_PROCESS_STDIN;
963                exec_begin=php_optarg;
964                break;
965
966            case 'E':
967                if (behavior == PHP_MODE_PROCESS_STDIN) {
968                    if (exec_end) {
969                        param_error = "You can use -E only once.\n";
970                        break;
971                    }
972                } else if (behavior != PHP_MODE_STANDARD || interactive) {
973                    param_error = param_mode_conflict;
974                    break;
975                }
976                behavior=PHP_MODE_PROCESS_STDIN;
977                exec_end=php_optarg;
978                break;
979
980            case 's': /* generate highlighted HTML from source */
981                if (behavior == PHP_MODE_CLI_DIRECT || behavior == PHP_MODE_PROCESS_STDIN) {
982                    param_error = "Source highlighting only works for files.\n";
983                    break;
984                }
985                behavior=PHP_MODE_HIGHLIGHT;
986                break;
987
988            case 'w':
989                if (behavior == PHP_MODE_CLI_DIRECT || behavior == PHP_MODE_PROCESS_STDIN) {
990                    param_error = "Source stripping only works for files.\n";
991                    break;
992                }
993                behavior=PHP_MODE_STRIP;
994                break;
995
996            case 'z': /* load extension file */
997                zend_load_extension(php_optarg);
998                break;
999            case 'H':
1000                hide_argv = 1;
1001                break;
1002            case 10:
1003                behavior=PHP_MODE_REFLECTION_FUNCTION;
1004                reflection_what = php_optarg;
1005                break;
1006            case 11:
1007                behavior=PHP_MODE_REFLECTION_CLASS;
1008                reflection_what = php_optarg;
1009                break;
1010            case 12:
1011                behavior=PHP_MODE_REFLECTION_EXTENSION;
1012                reflection_what = php_optarg;
1013                break;
1014            case 13:
1015                behavior=PHP_MODE_REFLECTION_EXT_INFO;
1016                reflection_what = php_optarg;
1017                break;
1018            case 14:
1019                behavior = PHP_MODE_SHOW_INI_CONFIG;
1020                break;
1021            default:
1022                break;
1023            }
1024        }
1025
1026        if (param_error) {
1027            PUTS(param_error);
1028            exit_status=1;
1029            goto err;
1030        }
1031
1032        if (interactive) {
1033#if (HAVE_LIBREADLINE || HAVE_LIBEDIT) && !defined(COMPILE_DL_READLINE)
1034            printf("Interactive shell\n\n");
1035#else
1036            printf("Interactive mode enabled\n\n");
1037#endif
1038            fflush(stdout);
1039        }
1040
1041        CG(interactive) = interactive;
1042
1043        /* only set script_file if not set already and not in direct mode and not at end of parameter list */
1044        if (argc > php_optind
1045          && !script_file
1046          && behavior!=PHP_MODE_CLI_DIRECT
1047          && behavior!=PHP_MODE_PROCESS_STDIN
1048          && strcmp(argv[php_optind-1],"--"))
1049        {
1050            script_file=argv[php_optind];
1051            php_optind++;
1052        }
1053        if (script_file) {
1054            if (cli_seek_file_begin(&file_handle, script_file, &lineno TSRMLS_CC) != SUCCESS) {
1055                goto err;
1056            } else {
1057                char real_path[MAXPATHLEN];
1058                if (VCWD_REALPATH(script_file, real_path)) {
1059                    translated_path = strdup(real_path);
1060                }
1061                script_filename = script_file;
1062            }
1063        } else {
1064            /* We could handle PHP_MODE_PROCESS_STDIN in a different manner  */
1065            /* here but this would make things only more complicated. And it */
1066            /* is consitent with the way -R works where the stdin file handle*/
1067            /* is also accessible. */
1068            file_handle.filename = "-";
1069            file_handle.handle.fp = stdin;
1070        }
1071        file_handle.type = ZEND_HANDLE_FP;
1072        file_handle.opened_path = NULL;
1073        file_handle.free_filename = 0;
1074        php_self = file_handle.filename;
1075
1076        /* before registering argv to module exchange the *new* argv[0] */
1077        /* we can achieve this without allocating more memory */
1078        SG(request_info).argc=argc-php_optind+1;
1079        arg_excp = argv+php_optind-1;
1080        arg_free = argv[php_optind-1];
1081        SG(request_info).path_translated = translated_path? translated_path : file_handle.filename;
1082        argv[php_optind-1] = file_handle.filename;
1083        SG(request_info).argv=argv+php_optind-1;
1084
1085        if (php_request_startup(TSRMLS_C)==FAILURE) {
1086            *arg_excp = arg_free;
1087            fclose(file_handle.handle.fp);
1088            PUTS("Could not startup.\n");
1089            goto err;
1090        }
1091        request_started = 1;
1092        CG(start_lineno) = lineno;
1093        *arg_excp = arg_free; /* reconstuct argv */
1094
1095        if (hide_argv) {
1096            int i;
1097            for (i = 1; i < argc; i++) {
1098                memset(argv[i], 0, strlen(argv[i]));
1099            }
1100        }
1101
1102        zend_is_auto_global("_SERVER", sizeof("_SERVER")-1 TSRMLS_CC);
1103
1104        PG(during_request_startup) = 0;
1105        switch (behavior) {
1106        case PHP_MODE_STANDARD:
1107            if (strcmp(file_handle.filename, "-")) {
1108                cli_register_file_handles(TSRMLS_C);
1109            }
1110
1111#if (HAVE_LIBREADLINE || HAVE_LIBEDIT) && !defined(COMPILE_DL_READLINE)
1112            if (interactive) {
1113                char *line;
1114                size_t size = 4096, pos = 0, len;
1115                char *code = emalloc(size);
1116                char *prompt = "php > ";
1117                char *history_file;
1118
1119                if (PG(auto_prepend_file) && PG(auto_prepend_file)[0]) {
1120                    zend_file_handle *prepend_file_p;
1121                    zend_file_handle prepend_file = {0};
1122
1123                    prepend_file.filename = PG(auto_prepend_file);
1124                    prepend_file.opened_path = NULL;
1125                    prepend_file.free_filename = 0;
1126                    prepend_file.type = ZEND_HANDLE_FILENAME;
1127                    prepend_file_p = &prepend_file;
1128
1129                    zend_execute_scripts(ZEND_REQUIRE TSRMLS_CC, NULL, 1, prepend_file_p);
1130                }
1131
1132                history_file = tilde_expand("~/.php_history");
1133                rl_attempted_completion_function = cli_code_completion;
1134                rl_special_prefixes = "$";
1135                read_history(history_file);
1136
1137                EG(exit_status) = 0;
1138                while ((line = readline(prompt)) != NULL) {
1139                    if (strcmp(line, "exit") == 0 || strcmp(line, "quit") == 0) {
1140                        free(line);
1141                        break;
1142                    }
1143
1144                    if (!pos && !*line) {
1145                        free(line);
1146                        continue;
1147                    }
1148
1149                    len = strlen(line);
1150                    if (pos + len + 2 > size) {
1151                        size = pos + len + 2;
1152                        code = erealloc(code, size);
1153                    }
1154                    memcpy(&code[pos], line, len);
1155                    pos += len;
1156                    code[pos] = '\n';
1157                    code[++pos] = '\0';
1158
1159                    if (*line) {
1160                        add_history(line);
1161                    }
1162
1163                    free(line);
1164
1165                    if (!cli_is_valid_code(code, pos, &prompt TSRMLS_CC)) {
1166                        continue;
1167                    }
1168
1169                    zend_eval_stringl(code, pos, NULL, "php shell code" TSRMLS_CC);
1170                    pos = 0;
1171
1172                    if (php_last_char != '\0' && php_last_char != '\n') {
1173                        sapi_cli_single_write("\n", 1 TSRMLS_CC);
1174                    }
1175
1176                    if (EG(exception)) {
1177                        zend_exception_error(EG(exception), E_WARNING TSRMLS_CC);
1178                    }
1179
1180                    php_last_char = '\0';
1181                }
1182                write_history(history_file);
1183                free(history_file);
1184                efree(code);
1185                exit_status = EG(exit_status);
1186                break;
1187            }
1188#endif /* HAVE_LIBREADLINE || HAVE_LIBEDIT */
1189            php_execute_script(&file_handle TSRMLS_CC);
1190            exit_status = EG(exit_status);
1191            break;
1192        case PHP_MODE_LINT:
1193            exit_status = php_lint_script(&file_handle TSRMLS_CC);
1194            if (exit_status==SUCCESS) {
1195                zend_printf("No syntax errors detected in %s\n", file_handle.filename);
1196            } else {
1197                zend_printf("Errors parsing %s\n", file_handle.filename);
1198            }
1199            break;
1200        case PHP_MODE_STRIP:
1201            if (open_file_for_scanning(&file_handle TSRMLS_CC)==SUCCESS) {
1202                zend_strip(TSRMLS_C);
1203            }
1204            goto out;
1205            break;
1206        case PHP_MODE_HIGHLIGHT:
1207            {
1208                zend_syntax_highlighter_ini syntax_highlighter_ini;
1209
1210                if (open_file_for_scanning(&file_handle TSRMLS_CC)==SUCCESS) {
1211                    php_get_highlight_struct(&syntax_highlighter_ini);
1212                    zend_highlight(&syntax_highlighter_ini TSRMLS_CC);
1213                }
1214                goto out;
1215            }
1216            break;
1217#if 0
1218            /* Zeev might want to do something with this one day */
1219        case PHP_MODE_INDENT:
1220            open_file_for_scanning(&file_handle TSRMLS_CC);
1221            zend_indent();
1222            zend_file_handle_dtor(file_handle.handle TSRMLS_CC);
1223            goto out;
1224            break;
1225#endif
1226        case PHP_MODE_CLI_DIRECT:
1227            cli_register_file_handles(TSRMLS_C);
1228            if (zend_eval_string_ex(exec_direct, NULL, "Command line code", 1 TSRMLS_CC) == FAILURE) {
1229                exit_status=254;
1230            }
1231            break;
1232
1233        case PHP_MODE_PROCESS_STDIN:
1234            {
1235                char *input;
1236                size_t len, index = 0;
1237                zval *argn, *argi;
1238
1239                cli_register_file_handles(TSRMLS_C);
1240
1241                if (exec_begin && zend_eval_string_ex(exec_begin, NULL, "Command line begin code", 1 TSRMLS_CC) == FAILURE) {
1242                    exit_status=254;
1243                }
1244                ALLOC_ZVAL(argi);
1245                Z_TYPE_P(argi) = IS_LONG;
1246                Z_LVAL_P(argi) = index;
1247                INIT_PZVAL(argi);
1248                zend_hash_update(&EG(symbol_table), "argi", sizeof("argi"), &argi, sizeof(zval *), NULL);
1249                while (exit_status == SUCCESS && (input=php_stream_gets(s_in_process, NULL, 0)) != NULL) {
1250                    len = strlen(input);
1251                    while (len-- && (input[len]=='\n' || input[len]=='\r')) {
1252                        input[len] = '\0';
1253                    }
1254                    ALLOC_ZVAL(argn);
1255                    Z_TYPE_P(argn) = IS_STRING;
1256                    Z_STRLEN_P(argn) = ++len;
1257                    Z_STRVAL_P(argn) = estrndup(input, len);
1258                    INIT_PZVAL(argn);
1259                    zend_hash_update(&EG(symbol_table), "argn", sizeof("argn"), &argn, sizeof(zval *), NULL);
1260                    Z_LVAL_P(argi) = ++index;
1261                    if (exec_run) {
1262                        if (zend_eval_string_ex(exec_run, NULL, "Command line run code", 1 TSRMLS_CC) == FAILURE) {
1263                            exit_status=254;
1264                        }
1265                    } else {
1266                        if (script_file) {
1267                            if (cli_seek_file_begin(&file_handle, script_file, &lineno TSRMLS_CC) != SUCCESS) {
1268                                exit_status = 1;
1269                            } else {
1270                                CG(start_lineno) = lineno;
1271                                php_execute_script(&file_handle TSRMLS_CC);
1272                                exit_status = EG(exit_status);
1273                            }
1274                        }
1275                    }
1276                    efree(input);
1277                }
1278                if (exec_end && zend_eval_string_ex(exec_end, NULL, "Command line end code", 1 TSRMLS_CC) == FAILURE) {
1279                    exit_status=254;
1280                }
1281
1282                break;
1283            }
1284            case PHP_MODE_REFLECTION_FUNCTION:
1285            case PHP_MODE_REFLECTION_CLASS:
1286            case PHP_MODE_REFLECTION_EXTENSION:
1287                {
1288                    zend_class_entry *pce = NULL;
1289                    zval *arg, *ref;
1290                    zend_execute_data execute_data;
1291
1292                    switch (behavior) {
1293                        default:
1294                            break;
1295                        case PHP_MODE_REFLECTION_FUNCTION:
1296                            if (strstr(reflection_what, "::")) {
1297                                pce = reflection_method_ptr;
1298                            } else {
1299                                pce = reflection_function_ptr;
1300                            }
1301                            break;
1302                        case PHP_MODE_REFLECTION_CLASS:
1303                            pce = reflection_class_ptr;
1304                            break;
1305                        case PHP_MODE_REFLECTION_EXTENSION:
1306                            pce = reflection_extension_ptr;
1307                            break;
1308                    }
1309
1310                    MAKE_STD_ZVAL(arg);
1311                    ZVAL_STRING(arg, reflection_what, 1);
1312                    ALLOC_ZVAL(ref);
1313                    object_init_ex(ref, pce);
1314                    INIT_PZVAL(ref);
1315
1316                    memset(&execute_data, 0, sizeof(zend_execute_data));
1317                    EG(current_execute_data) = &execute_data;
1318                    EX(function_state).function = pce->constructor;
1319                    zend_call_method_with_1_params(&ref, pce, &pce->constructor, "__construct", NULL, arg);
1320
1321                    if (EG(exception)) {
1322                        zval *msg = zend_read_property(zend_exception_get_default(TSRMLS_C), EG(exception), "message", sizeof("message")-1, 0 TSRMLS_CC);
1323                        zend_printf("Exception: %s\n", Z_STRVAL_P(msg));
1324                        zval_ptr_dtor(&EG(exception));
1325                        EG(exception) = NULL;
1326                    } else {
1327                        zend_call_method_with_1_params(NULL, reflection_ptr, NULL, "export", NULL, ref);
1328                    }
1329                    zval_ptr_dtor(&ref);
1330                    zval_ptr_dtor(&arg);
1331
1332                    break;
1333                }
1334            case PHP_MODE_REFLECTION_EXT_INFO:
1335                {
1336                    int len = strlen(reflection_what);
1337                    char *lcname = zend_str_tolower_dup(reflection_what, len);
1338                    zend_module_entry *module;
1339
1340                    if (zend_hash_find(&module_registry, lcname, len+1, (void**)&module) == FAILURE) {
1341                        if (!strcmp(reflection_what, "main")) {
1342                            display_ini_entries(NULL);
1343                        } else {
1344                            zend_printf("Extension '%s' not present.\n", reflection_what);
1345                            exit_status = 1;
1346                        }
1347                    } else {
1348                        php_info_print_module(module TSRMLS_CC);
1349                    }
1350
1351                    efree(lcname);
1352                    break;
1353                }
1354            case PHP_MODE_SHOW_INI_CONFIG:
1355                {
1356                    zend_printf("Configuration File (php.ini) Path: %s\n", PHP_CONFIG_FILE_PATH);
1357                    zend_printf("Loaded Configuration File:         %s\n", php_ini_opened_path ? php_ini_opened_path : "(none)");
1358                    zend_printf("Scan for additional .ini files in: %s\n", php_ini_scanned_path ? php_ini_scanned_path : "(none)");
1359                    zend_printf("Additional .ini files parsed:      %s\n", php_ini_scanned_files ? php_ini_scanned_files : "(none)");
1360                    break;
1361                }
1362        }
1363
1364    } zend_end_try();
1365
1366out:
1367    if (request_started) {
1368        php_request_shutdown((void *) 0);
1369    }
1370    if (translated_path) {
1371        free(translated_path);
1372    }
1373    if (exit_status == 0) {
1374        exit_status = EG(exit_status);
1375    }
1376out_err:
1377    if (cli_sapi_module.php_ini_path_override) {
1378        free(cli_sapi_module.php_ini_path_override);
1379    }
1380    if (cli_sapi_module.ini_entries) {
1381        free(cli_sapi_module.ini_entries);
1382    }
1383
1384    if (module_started) {
1385        php_module_shutdown(TSRMLS_C);
1386    }
1387    sapi_shutdown();
1388#ifdef ZTS
1389    tsrm_shutdown();
1390#endif
1391
1392    exit(exit_status);
1393
1394err:
1395    sapi_deactivate(TSRMLS_C);
1396    zend_ini_deactivate(TSRMLS_C);
1397    exit_status = 1;
1398    goto out_err;
1399}
1400/* }}} */
1401
1402/*
1403 * Local variables:
1404 * tab-width: 4
1405 * c-basic-offset: 4
1406 * End:
1407 * vim600: sw=4 ts=4 fdm=marker
1408 * vim<600: sw=4 ts=4
1409 */
1410