source: src/router/php7/sapi/cli/php_cli.c @ 31879

Last change on this file since 31879 was 31879, checked in by brainslayer, 3 months ago

update php

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