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