/*

+----------------------------------------------------------------------+

| Copyright (c) The PHP Group |

+----------------------------------------------------------------------+

| This source file is subject to version 3.01 of the PHP license, |

| that is bundled with this package in the file LICENSE, and is |

| available through the world-wide-web at the following url: |

| http://www.php.net/license/3_01.txt |

| If you did not receive a copy of the PHP license and are unable to |

| obtain it through the world-wide-web, please send a note to |

| license@php.net so we can mail you a copy immediately. |

+----------------------------------------------------------------------+

| Author: Edin Kadribasic <edink@php.net> |

| Marcus Boerger <helly@php.net> |

| Johannes Schlueter <johannes@php.net> |

| Parts based on CGI SAPI Module by |

| Rasmus Lerdorf, Stig Bakken and Zeev Suraski |

+----------------------------------------------------------------------+

*/

#include "php.h"

#include "php_globals.h"

#include "php_variables.h"

#include "zend_hash.h"

#include "zend_modules.h"

#include "zend_interfaces.h"

#include "ext/reflection/php_reflection.h"

#include "SAPI.h"

#include <stdio.h>

#include "php.h"

#ifdef PHP_WIN32

#include "win32/time.h"

#include "win32/signal.h"

#include "win32/console.h"

#include <process.h>

#include <shellapi.h>

#endif

#if HAVE_SYS_TIME_H

#include <sys/time.h>

#endif

#if HAVE_UNISTD_H

#include <unistd.h>

#endif

#include <signal.h>

#include <locale.h>

#include "zend.h"

#include "zend_extensions.h"

#include "php_ini.h"

#include "php_globals.h"

#include "php_main.h"

#include "fopen_wrappers.h"

#include "ext/standard/php_standard.h"

#include "ext/standard/dl_arginfo.h"

#include "cli.h"

#ifdef PHP_WIN32

#include <io.h>

#include <fcntl.h>

#include "win32/php_registry.h"

#endif

#ifdef __riscos__

#include <unixlib/local.h>

#endif

#include "zend_compile.h"

#include "zend_execute.h"

#include "zend_highlight.h"

#include "zend_exceptions.h"

#include "php_getopt.h"

#ifndef PHP_CLI_WIN32_NO_CONSOLE

#include "php_cli_server.h"

#endif

#include "ps_title.h"

#include "php_cli_process_title.h"

#include "php_cli_process_title_arginfo.h"

#ifndef PHP_WIN32

# define php_select(m, r, w, e, t) select(m, r, w, e, t)

#else

# include "win32/select.h"

#endif

#if defined(PHP_WIN32) && defined(HAVE_OPENSSL)

# include "openssl/applink.c"

#endif

PHPAPI extern char *php_ini_opened_path;

PHPAPI extern char *php_ini_scanned_path;

PHPAPI extern char *php_ini_scanned_files;

#if defined(PHP_WIN32)

#if defined(ZTS)

ZEND_TSRMLS_CACHE_DEFINE()

#endif

static DWORD orig_cp = 0;

#endif

#ifndef O_BINARY

#define O_BINARY 0

#endif

#define PHP_MODE_STANDARD 1

#define PHP_MODE_HIGHLIGHT 2

#define PHP_MODE_LINT 4

#define PHP_MODE_STRIP 5

#define PHP_MODE_CLI_DIRECT 6

#define PHP_MODE_PROCESS_STDIN 7

#define PHP_MODE_REFLECTION_FUNCTION 8

#define PHP_MODE_REFLECTION_CLASS 9

#define PHP_MODE_REFLECTION_EXTENSION 10

#define PHP_MODE_REFLECTION_EXT_INFO 11

#define PHP_MODE_REFLECTION_ZEND_EXTENSION 12

#define PHP_MODE_SHOW_INI_CONFIG 13

cli_shell_callbacks_t cli_shell_callbacks = { NULL, NULL, NULL };

PHP_CLI_API cli_shell_callbacks_t *php_cli_get_shell_callbacks(void)

{

return &cli_shell_callbacks;

}

const char HARDCODED_INI[] =

"html_errors=0\n"

"register_argc_argv=1\n"

"implicit_flush=1\n"

"output_buffering=0\n"

"max_execution_time=0\n"

"max_input_time=-1\n\0";

const opt_struct OPTIONS[] = {

{'a', 0, "interactive"},

{'B', 1, "process-begin"},

{'C', 0, "no-chdir"}, /* for compatibility with CGI (do not chdir to script directory) */

{'c', 1, "php-ini"},

{'d', 1, "define"},

{'E', 1, "process-end"},

{'e', 0, "profile-info"},

{'F', 1, "process-file"},

{'f', 1, "file"},

{'h', 0, "help"},

{'i', 0, "info"},

{'l', 0, "syntax-check"},

{'m', 0, "modules"},

{'n', 0, "no-php-ini"},

{'q', 0, "no-header"}, /* for compatibility with CGI (do not generate HTTP headers) */

{'R', 1, "process-code"},

{'H', 0, "hide-args"},

{'r', 1, "run"},

{'s', 0, "syntax-highlight"},

{'s', 0, "syntax-highlighting"},

{'S', 1, "server"},

{'t', 1, "docroot"},

{'w', 0, "strip"},

{'?', 0, "usage"},/* help alias (both '?' and 'usage') */

{'v', 0, "version"},

{'z', 1, "zend-extension"},

{10, 1, "rf"},

{10, 1, "rfunction"},

{11, 1, "rc"},

{11, 1, "rclass"},

{12, 1, "re"},

{12, 1, "rextension"},

{13, 1, "rz"},

{13, 1, "rzendextension"},

{14, 1, "ri"},

{14, 1, "rextinfo"},

{15, 0, "ini"},

/* Internal testing option -- may be changed or removed without notice,

* including in patch releases. */

{16, 1, "repeat"},

{'-', 0, NULL} /* end of args */

};

static int module_name_cmp(Bucket *f, Bucket *s) /* {{{ */

{

return strcasecmp(((zend_module_entry *)Z_PTR(f->val))->name,

((zend_module_entry *)Z_PTR(s->val))->name);

}

/* }}} */

static void print_modules(void) /* {{{ */

{

HashTable sorted_registry;

zend_module_entry *module;

zend_hash_init(&sorted_registry, 50, NULL, NULL, 0);

zend_hash_copy(&sorted_registry, &module_registry, NULL);

zend_hash_sort(&sorted_registry, module_name_cmp, 0);

ZEND_HASH_FOREACH_PTR(&sorted_registry, module) {

php_printf("%s\n", module->name);

} ZEND_HASH_FOREACH_END();

zend_hash_destroy(&sorted_registry);

}

/* }}} */

static void print_extension_info(zend_extension *ext) /* {{{ */

{

php_printf("%s\n", ext->name);

}

/* }}} */

static int extension_name_cmp(const zend_llist_element **f, const zend_llist_element **s) /* {{{ */

{

zend_extension *fe = (zend_extension*)(*f)->data;

zend_extension *se = (zend_extension*)(*s)->data;

return strcmp(fe->name, se->name);

}

/* }}} */

static void print_extensions(void) /* {{{ */

{

zend_llist sorted_exts;

zend_llist_copy(&sorted_exts, &zend_extensions);

sorted_exts.dtor = NULL;

zend_llist_sort(&sorted_exts, extension_name_cmp);

zend_llist_apply(&sorted_exts, (llist_apply_func_t) print_extension_info);

zend_llist_destroy(&sorted_exts);

}

/* }}} */

#ifndef STDOUT_FILENO

#define STDOUT_FILENO 1

#endif

#ifndef STDERR_FILENO

#define STDERR_FILENO 2

#endif

static inline int sapi_cli_select(php_socket_t fd)

{

fd_set wfd;

struct timeval tv;

int ret;

FD_ZERO(&wfd);

PHP_SAFE_FD_SET(fd, &wfd);

tv.tv_sec = (long)FG(default_socket_timeout);

tv.tv_usec = 0;

ret = php_select(fd+1, NULL, &wfd, NULL, &tv);

return ret != -1;

}

PHP_CLI_API ssize_t sapi_cli_single_write(const char *str, size_t str_length) /* {{{ */

{

ssize_t ret;

if (cli_shell_callbacks.cli_shell_write) {

cli_shell_callbacks.cli_shell_write(str, str_length);

}

#ifdef PHP_WRITE_STDOUT

do {

ret = write(STDOUT_FILENO, str, str_length);

} while (ret <= 0 && errno == EAGAIN && sapi_cli_select(STDOUT_FILENO));

#else

ret = fwrite(str, 1, MIN(str_length, 16384), stdout);

if (ret == 0 && ferror(stdout)) {

return -1;

}

#endif

return ret;

}

/* }}} */

static size_t sapi_cli_ub_write(const char *str, size_t str_length) /* {{{ */

{

const char *ptr = str;

size_t remaining = str_length;

ssize_t ret;

if (!str_length) {

return 0;

}

if (cli_shell_callbacks.cli_shell_ub_write) {

size_t ub_wrote;

ub_wrote = cli_shell_callbacks.cli_shell_ub_write(str, str_length);

if (ub_wrote != (size_t) -1) {

return ub_wrote;

}

}

while (remaining > 0)

{

ret = sapi_cli_single_write(ptr, remaining);

if (ret < 0) {

#ifndef PHP_CLI_WIN32_NO_CONSOLE

EG(exit_status) = 255;

php_handle_aborted_connection();

#endif

break;

}

ptr += ret;

remaining -= ret;

}

return (ptr - str);

}

/* }}} */

static void sapi_cli_flush(void *server_context) /* {{{ */

{

/* Ignore EBADF here, it's caused by the fact that STDIN/STDOUT/STDERR streams

* are/could be closed before fflush() is called.

*/

if (fflush(stdout)==EOF && errno!=EBADF) {

#ifndef PHP_CLI_WIN32_NO_CONSOLE

php_handle_aborted_connection();

#endif

}

}

/* }}} */

static char *php_self = "";

static char *script_filename = "";

static void sapi_cli_register_variables(zval *track_vars_array) /* {{{ */

{

size_t len;

char *docroot = "";

/* In CGI mode, we consider the environment to be a part of the server

* variables

*/

php_import_environment_variables(track_vars_array);

/* Build the special-case PHP_SELF variable for the CLI version */

len = strlen(php_self);

if (sapi_module.input_filter(PARSE_SERVER, "PHP_SELF", &php_self, len, &len)) {

php_register_variable("PHP_SELF", php_self, track_vars_array);

}

if (sapi_module.input_filter(PARSE_SERVER, "SCRIPT_NAME", &php_self, len, &len)) {

php_register_variable("SCRIPT_NAME", php_self, track_vars_array);

}

/* filenames are empty for stdin */

len = strlen(script_filename);

if (sapi_module.input_filter(PARSE_SERVER, "SCRIPT_FILENAME", &script_filename, len, &len)) {

php_register_variable("SCRIPT_FILENAME", script_filename, track_vars_array);

}

if (sapi_module.input_filter(PARSE_SERVER, "PATH_TRANSLATED", &script_filename, len, &len)) {

php_register_variable("PATH_TRANSLATED", script_filename, track_vars_array);

}

/* just make it available */

len = 0U;

if (sapi_module.input_filter(PARSE_SERVER, "DOCUMENT_ROOT", &docroot, len, &len)) {

php_register_variable("DOCUMENT_ROOT", docroot, track_vars_array);

}

}

/* }}} */

static void sapi_cli_log_message(const char *message, int syslog_type_int) /* {{{ */

{

fprintf(stderr, "%s\n", message);

#ifdef PHP_WIN32

fflush(stderr);

#endif

}

/* }}} */

static int sapi_cli_deactivate(void) /* {{{ */

{

fflush(stdout);

if(SG(request_info).argv0) {

free(SG(request_info).argv0);

SG(request_info).argv0 = NULL;

}

return SUCCESS;

}

/* }}} */

static char* sapi_cli_read_cookies(void) /* {{{ */

{

return NULL;

}

/* }}} */

static int sapi_cli_header_handler(sapi_header_struct *h, sapi_header_op_enum op, sapi_headers_struct *s) /* {{{ */

{

return 0;

}

/* }}} */

static int sapi_cli_send_headers(sapi_headers_struct *sapi_headers) /* {{{ */

{

/* We do nothing here, this function is needed to prevent that the fallback

* header handling is called. */

return SAPI_HEADER_SENT_SUCCESSFULLY;

}

/* }}} */

static void sapi_cli_send_header(sapi_header_struct *sapi_header, void *server_context) /* {{{ */

{

}

/* }}} */

static int php_cli_startup(sapi_module_struct *sapi_module) /* {{{ */

{

if (php_module_startup(sapi_module, NULL, 0)==FAILURE) {

return FAILURE;

}

return SUCCESS;

}

/* }}} */

/* {{{ sapi_cli_ini_defaults */

/* overwritable ini defaults must be set in sapi_cli_ini_defaults() */

#define INI_DEFAULT(name,value)\

ZVAL_NEW_STR(&tmp, zend_string_init(value, sizeof(value)-1, 1));\

zend_hash_str_update(configuration_hash, name, sizeof(name)-1, &tmp);\

static void sapi_cli_ini_defaults(HashTable *configuration_hash)

{

zval tmp;

INI_DEFAULT("display_errors", "1");

}

/* }}} */

/* {{{ sapi_module_struct cli_sapi_module */

static sapi_module_struct cli_sapi_module = {

"cli", /* name */

"Command Line Interface", /* pretty name */

php_cli_startup, /* startup */

php_module_shutdown_wrapper, /* shutdown */

NULL, /* activate */

sapi_cli_deactivate, /* deactivate */

sapi_cli_ub_write, /* unbuffered write */

sapi_cli_flush, /* flush */

NULL, /* get uid */

NULL, /* getenv */

php_error, /* error handler */

sapi_cli_header_handler, /* header handler */

sapi_cli_send_headers, /* send headers handler */

sapi_cli_send_header, /* send header handler */

NULL, /* read POST data */

sapi_cli_read_cookies, /* read Cookies */

sapi_cli_register_variables, /* register server variables */

sapi_cli_log_message, /* Log message */

NULL, /* Get request time */

NULL, /* Child terminate */

STANDARD_SAPI_MODULE_PROPERTIES

};

/* }}} */

static const zend_function_entry additional_functions[] = {

ZEND_FE(dl, arginfo_dl)

PHP_FE(cli_set_process_title, arginfo_cli_set_process_title)

PHP_FE(cli_get_process_title, arginfo_cli_get_process_title)

PHP_FE_END

};

/* {{{ php_cli_usage */

static void php_cli_usage(char *argv0)

{

char *prog;

prog = strrchr(argv0, '/');

if (prog) {

prog++;

} else {

prog = "php";

}

printf( "Usage: %s [options] [-f] <file> [--] [args...]\n"

" %s [options] -r <code> [--] [args...]\n"

" %s [options] [-B <begin_code>] -R <code> [-E <end_code>] [--] [args...]\n"

" %s [options] [-B <begin_code>] -F <file> [-E <end_code>] [--] [args...]\n"

" %s [options] -S <addr>:<port> [-t docroot] [router]\n"

" %s [options] -- [args...]\n"

" %s [options] -a\n"

"\n"

#if (defined(HAVE_LIBREADLINE) || defined(HAVE_LIBEDIT)) && !defined(COMPILE_DL_READLINE)

" -a Run as interactive shell\n"

#else

" -a Run interactively\n"

#endif

" -c <path>|<file> Look for php.ini file in this directory\n"

" -n No configuration (ini) files will be used\n"

" -d foo[=bar] Define INI entry foo with value 'bar'\n"

" -e Generate extended information for debugger/profiler\n"

" -f <file> Parse and execute <file>.\n"

" -h This help\n"

" -i PHP information\n"

" -l Syntax check only (lint)\n"

" -m Show compiled in modules\n"

" -r <code> Run PHP <code> without using script tags <?..?>\n"

" -B <begin_code> Run PHP <begin_code> before processing input lines\n"

" -R <code> Run PHP <code> for every input line\n"

" -F <file> Parse and execute <file> for every input line\n"

" -E <end_code> Run PHP <end_code> after processing all input lines\n"

" -H Hide any passed arguments from external tools.\n"

" -S <addr>:<port> Run with built-in web server.\n"

" -t <docroot> Specify document root <docroot> for built-in web server.\n"

" -s Output HTML syntax highlighted source.\n"

" -v Version number\n"

" -w Output source with stripped comments and whitespace.\n"

" -z <file> Load Zend extension <file>.\n"

"\n"

" args... Arguments passed to script. Use -- args when first argument\n"

" starts with - or script is read from stdin\n"

"\n"

" --ini Show configuration file names\n"

"\n"

" --rf <name> Show information about function <name>.\n"

" --rc <name> Show information about class <name>.\n"

" --re <name> Show information about extension <name>.\n"

" --rz <name> Show information about Zend extension <name>.\n"

" --ri <name> Show configuration for extension <name>.\n"

"\n"

, prog, prog, prog, prog, prog, prog, prog);

}

/* }}} */

static php_stream *s_in_process = NULL;

static void cli_register_file_handles(bool no_close) /* {{{ */

{

php_stream *s_in, *s_out, *s_err;

php_stream_context *sc_in=NULL, *sc_out=NULL, *sc_err=NULL;

zend_constant ic, oc, ec;

s_in = php_stream_open_wrapper_ex("php://stdin", "rb", 0, NULL, sc_in);

s_out = php_stream_open_wrapper_ex("php://stdout", "wb", 0, NULL, sc_out);

s_err = php_stream_open_wrapper_ex("php://stderr", "wb", 0, NULL, sc_err);

if (s_in==NULL || s_out==NULL || s_err==NULL) {

if (s_in) php_stream_close(s_in);

if (s_out) php_stream_close(s_out);

if (s_err) php_stream_close(s_err);

return;

}

if (no_close) {

s_in->flags |= PHP_STREAM_FLAG_NO_CLOSE;

s_out->flags |= PHP_STREAM_FLAG_NO_CLOSE;

s_err->flags |= PHP_STREAM_FLAG_NO_CLOSE;

}

s_in_process = s_in;

php_stream_to_zval(s_in, &ic.value);

php_stream_to_zval(s_out, &oc.value);

php_stream_to_zval(s_err, &ec.value);

ZEND_CONSTANT_SET_FLAGS(&ic, CONST_CS, 0);

ic.name = zend_string_init_interned("STDIN", sizeof("STDIN")-1, 0);

zend_register_constant(&ic);

ZEND_CONSTANT_SET_FLAGS(&oc, CONST_CS, 0);

oc.name = zend_string_init_interned("STDOUT", sizeof("STDOUT")-1, 0);

zend_register_constant(&oc);

ZEND_CONSTANT_SET_FLAGS(&ec, CONST_CS, 0);

ec.name = zend_string_init_interned("STDERR", sizeof("STDERR")-1, 0);

zend_register_constant(&ec);

}

/* }}} */

static const char *param_mode_conflict = "Either execute direct code, process stdin or use a file.\n";

/* {{{ cli_seek_file_begin */

static int cli_seek_file_begin(zend_file_handle *file_handle, char *script_file)

{

FILE *fp = VCWD_FOPEN(script_file, "rb");

if (!fp) {

php_printf("Could not open input file: %s\n", script_file);

return FAILURE;

}

zend_stream_init_fp(file_handle, fp, script_file);

return SUCCESS;

}

/* }}} */

/*{{{ php_cli_win32_ctrl_handler */

#if defined(PHP_WIN32)

BOOL WINAPI php_cli_win32_ctrl_handler(DWORD sig)

{

(void)php_win32_cp_cli_do_restore(orig_cp);

return FALSE;

}

#endif

/*}}}*/

static int do_cli(int argc, char **argv) /* {{{ */

{

int c;

zend_file_handle file_handle;

int behavior = PHP_MODE_STANDARD;

char *reflection_what = NULL;

volatile int request_started = 0;

char *php_optarg = NULL, *orig_optarg = NULL;

int php_optind = 1, orig_optind = 1;

char *exec_direct=NULL, *exec_run=NULL, *exec_begin=NULL, *exec_end=NULL;

char *arg_free=NULL, **arg_excp=&arg_free;

char *script_file=NULL, *translated_path = NULL;

int interactive=0;

const char *param_error=NULL;

int hide_argv = 0;

int num_repeats = 1;

pid_t pid = getpid();

zend_try {

CG(in_compilation) = 0; /* not initialized but needed for several options */

while ((c = php_getopt(argc, argv, OPTIONS, &php_optarg, &php_optind, 0, 2)) != -1) {

switch (c) {

case 'i': /* php info & quit */

if (php_request_startup()==FAILURE) {

goto err;

}

request_started = 1;

php_print_info(PHP_INFO_ALL & ~PHP_INFO_CREDITS);

php_output_end_all();

EG(exit_status) = (c == '?' && argc > 1 && !strchr(argv[1], c));

goto out;

case 'v': /* show php version & quit */

php_printf("PHP %s (%s) (built: %s %s) ( %s)\nCopyright (c) The PHP Group\n%s",

PHP_VERSION, cli_sapi_module.name, __DATE__, __TIME__,

#ifdef ZTS

"ZTS "

#else

"NTS "

#endif

#ifdef PHP_BUILD_COMPILER

PHP_BUILD_COMPILER

" "

#endif

#ifdef PHP_BUILD_ARCH

PHP_BUILD_ARCH

" "

#endif

#if ZEND_DEBUG

"DEBUG "

#endif

#ifdef HAVE_GCOV

"GCOV "

#endif

,

get_zend_version()

);

sapi_deactivate();

goto out;

case 'm': /* list compiled in modules */

if (php_request_startup()==FAILURE) {

goto err;

}

request_started = 1;

php_printf("[PHP Modules]\n");

print_modules();

php_printf("\n[Zend Modules]\n");

print_extensions();

php_printf("\n");

php_output_end_all();

EG(exit_status) = 0;

goto out;

default:

break;

}

}

/* Set some CLI defaults */

SG(options) |= SAPI_OPTION_NO_CHDIR;

php_optind = orig_optind;

php_optarg = orig_optarg;

while ((c = php_getopt(argc, argv, OPTIONS, &php_optarg, &php_optind, 0, 2)) != -1) {

switch (c) {

case 'a': /* interactive mode */

if (!interactive) {

if (behavior != PHP_MODE_STANDARD) {

param_error = param_mode_conflict;

break;

}

interactive=1;

}

break;

case 'C': /* don't chdir to the script directory */

/* This is default so NOP */

break;

case 'F':

if (behavior == PHP_MODE_PROCESS_STDIN) {

if (exec_run || script_file) {

param_error = "You can use -R or -F only once.\n";

break;

}

} else if (behavior != PHP_MODE_STANDARD) {

param_error = param_mode_conflict;

break;

}

behavior=PHP_MODE_PROCESS_STDIN;

script_file = php_optarg;

break;

case 'f': /* parse file */

if (behavior == PHP_MODE_CLI_DIRECT || behavior == PHP_MODE_PROCESS_STDIN) {

param_error = param_mode_conflict;

break;

} else if (script_file) {

param_error = "You can use -f only once.\n";

break;

}

script_file = php_optarg;

break;

case 'l': /* syntax check mode */

if (behavior != PHP_MODE_STANDARD) {

break;

}

behavior=PHP_MODE_LINT;

break;

case 'q': /* do not generate HTTP headers */

/* This is default so NOP */

break;

case 'r': /* run code from command line */

if (behavior == PHP_MODE_CLI_DIRECT) {

if (exec_direct || script_file) {

param_error = "You can use -r only once.\n";

break;

}

} else if (behavior != PHP_MODE_STANDARD || interactive) {

param_error = param_mode_conflict;

break;

}

behavior=PHP_MODE_CLI_DIRECT;

exec_direct=php_optarg;

break;

case 'R':

if (behavior == PHP_MODE_PROCESS_STDIN) {

if (exec_run || script_file) {

param_error = "You can use -R or -F only once.\n";

break;

}

} else if (behavior != PHP_MODE_STANDARD) {

param_error = param_mode_conflict;

break;

}

behavior=PHP_MODE_PROCESS_STDIN;

exec_run=php_optarg;

break;

case 'B':

if (behavior == PHP_MODE_PROCESS_STDIN) {

if (exec_begin) {

param_error = "You can use -B only once.\n";

break;

}

} else if (behavior != PHP_MODE_STANDARD || interactive) {

param_error = param_mode_conflict;

break;

}

behavior=PHP_MODE_PROCESS_STDIN;

exec_begin=php_optarg;

break;

case 'E':

if (behavior == PHP_MODE_PROCESS_STDIN) {

if (exec_end) {

param_error = "You can use -E only once.\n";

break;

}

} else if (behavior != PHP_MODE_STANDARD || interactive) {

param_error = param_mode_conflict;

break;

}

behavior=PHP_MODE_PROCESS_STDIN;

exec_end=php_optarg;

break;

case 's': /* generate highlighted HTML from source */

if (behavior == PHP_MODE_CLI_DIRECT || behavior == PHP_MODE_PROCESS_STDIN) {

param_error = "Source highlighting only works for files.\n";

break;

}

behavior=PHP_MODE_HIGHLIGHT;

break;

case 'w':

if (behavior == PHP_MODE_CLI_DIRECT || behavior == PHP_MODE_PROCESS_STDIN) {

param_error = "Source stripping only works for files.\n";

break;

}

behavior=PHP_MODE_STRIP;

break;

case 'z': /* load extension file */

zend_load_extension(php_optarg);

break;

case 'H':

hide_argv = 1;

break;

case 10:

behavior=PHP_MODE_REFLECTION_FUNCTION;

reflection_what = php_optarg;

break;

case 11:

behavior=PHP_MODE_REFLECTION_CLASS;

reflection_what = php_optarg;

break;

case 12:

behavior=PHP_MODE_REFLECTION_EXTENSION;

reflection_what = php_optarg;

break;

case 13:

behavior=PHP_MODE_REFLECTION_ZEND_EXTENSION;

reflection_what = php_optarg;

break;

case 14:

behavior=PHP_MODE_REFLECTION_EXT_INFO;

reflection_what = php_optarg;

break;

case 15:

behavior = PHP_MODE_SHOW_INI_CONFIG;

break;

case 16:

num_repeats = atoi(php_optarg);

break;

default:

break;

}

}

if (param_error) {

PUTS(param_error);

EG(exit_status) = 1;

goto err;

}

#if defined(PHP_WIN32) && !defined(PHP_CLI_WIN32_NO_CONSOLE) && (HAVE_LIBREADLINE || HAVE_LIBEDIT) && !defined(COMPILE_DL_READLINE)

if (!interactive) {

/* The -a option was not passed. If there is no file, it could

still make sense to run interactively. The presence of a file

is essential to mitigate buggy console info. */

interactive = php_win32_console_is_own() &&

!(script_file ||

argc > php_optind && behavior!=PHP_MODE_CLI_DIRECT &&

behavior!=PHP_MODE_PROCESS_STDIN &&

strcmp(argv[php_optind-1],"--")

);

}

#endif

if (interactive) {

#if (defined(HAVE_LIBREADLINE) || defined(HAVE_LIBEDIT)) && !defined(COMPILE_DL_READLINE)

printf("Interactive shell\n\n");

#else

printf("Interactive mode enabled\n\n");

#endif

fflush(stdout);

}

if (num_repeats > 1) {

fprintf(stdout, "Executing for the first time...\n");

fflush(stdout);

}

do_repeat:

/* only set script_file if not set already and not in direct mode and not at end of parameter list */

if (argc > php_optind

&& !script_file

&& behavior!=PHP_MODE_CLI_DIRECT

&& behavior!=PHP_MODE_PROCESS_STDIN

&& strcmp(argv[php_optind-1],"--"))

{

script_file=argv[php_optind];

php_optind++;

}

if (script_file) {

virtual_cwd_activate();

if (cli_seek_file_begin(&file_handle, script_file) != SUCCESS) {

goto err;

} else {

char real_path[MAXPATHLEN];

if (VCWD_REALPATH(script_file, real_path)) {

translated_path = strdup(real_path);

}

script_filename = script_file;

}

} else {

/* We could handle PHP_MODE_PROCESS_STDIN in a different manner */

/* here but this would make things only more complicated. And it */

/* is consistent with the way -R works where the stdin file handle*/

/* is also accessible. */

zend_stream_init_fp(&file_handle, stdin, "Standard input code");

}

php_self = (char*)file_handle.filename;

/* before registering argv to module exchange the *new* argv[0] */

/* we can achieve this without allocating more memory */

SG(request_info).argc=argc-php_optind+1;

arg_excp = argv+php_optind-1;

arg_free = argv[php_optind-1];

SG(request_info).path_translated = translated_path? translated_path: (char*)file_handle.filename;

argv[php_optind-1] = (char*)file_handle.filename;

SG(request_info).argv=argv+php_optind-1;

if (php_request_startup()==FAILURE) {

*arg_excp = arg_free;

fclose(file_handle.handle.fp);

PUTS("Could not startup.\n");

goto err;

}

request_started = 1;

CG(skip_shebang) = 1;

zend_register_bool_constant(

ZEND_STRL("PHP_CLI_PROCESS_TITLE"),

is_ps_title_available() == PS_TITLE_SUCCESS,

CONST_CS, 0);

*arg_excp = arg_free; /* reconstuct argv */

if (hide_argv) {

int i;

for (i = 1; i < argc; i++) {

memset(argv[i], 0, strlen(argv[i]));

}

}

zend_is_auto_global_str(ZEND_STRL("_SERVER"));

PG(during_request_startup) = 0;

switch (behavior) {

case PHP_MODE_STANDARD:

if (strcmp(file_handle.filename, "Standard input code")) {

cli_register_file_handles(/* no_close */ PHP_DEBUG || num_repeats > 1);

}

if (interactive && cli_shell_callbacks.cli_shell_run) {

EG(exit_status) = cli_shell_callbacks.cli_shell_run();

} else {

php_execute_script(&file_handle);

}

break;

case PHP_MODE_LINT:

EG(exit_status) = php_lint_script(&file_handle);

if (EG(exit_status) == SUCCESS) {

zend_printf("No syntax errors detected in %s\n", file_handle.filename);

} else {

zend_printf("Errors parsing %s\n", file_handle.filename);

}

break;

case PHP_MODE_STRIP:

if (open_file_for_scanning(&file_handle)==SUCCESS) {

zend_strip();

}

goto out;

break;

case PHP_MODE_HIGHLIGHT:

{

zend_syntax_highlighter_ini syntax_highlighter_ini;

if (open_file_for_scanning(&file_handle)==SUCCESS) {

php_get_highlight_struct(&syntax_highlighter_ini);

zend_highlight(&syntax_highlighter_ini);

}

goto out;

}

break;

case PHP_MODE_CLI_DIRECT:

cli_register_file_handles(/* no_close */ PHP_DEBUG || num_repeats > 1);

zend_eval_string_ex(exec_direct, NULL, "Command line code", 1);

break;

case PHP_MODE_PROCESS_STDIN:

{

char *input;

size_t len, index = 0;