Back to index

php5  5.3.10
Defines | Functions | Variables
php_cli.c File Reference
#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 "zend.h"
#include "zend_extensions.h"
#include "php_ini.h"
#include "php_main.h"
#include "fopen_wrappers.h"
#include "ext/standard/php_standard.h"
#include "zend_compile.h"
#include "zend_execute.h"
#include "zend_highlight.h"
#include "zend_indent.h"
#include "zend_exceptions.h"
#include "php_getopt.h"
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Defines

#define php_select(m, r, w, e, t)   select(m, r, w, e, t)
#define O_BINARY   0
#define PHP_MODE_STANDARD   1
#define PHP_MODE_HIGHLIGHT   2
#define PHP_MODE_INDENT   3
#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_SHOW_INI_CONFIG   12
#define STDOUT_FILENO   1
#define INI_DEFAULT(name, value)

Functions

static int print_module_info (zend_module_entry *module TSRMLS_DC)
static int module_name_cmp (const void *a, const void *b TSRMLS_DC)
static void print_modules (TSRMLS_D)
static int print_extension_info (zend_extension *ext, void *arg TSRMLS_DC)
static int extension_name_cmp (const zend_llist_element **f, const zend_llist_element **s TSRMLS_DC)
static void print_extensions (TSRMLS_D)
static int sapi_cli_select (int fd TSRMLS_DC)
static size_t sapi_cli_single_write (const char *str, uint str_length TSRMLS_DC)
static int sapi_cli_ub_write (const char *str, uint str_length TSRMLS_DC)
static void sapi_cli_flush (void *server_context)
static void sapi_cli_register_variables (zval *track_vars_array TSRMLS_DC)
static void sapi_cli_log_message (char *message)
static int sapi_cli_deactivate (TSRMLS_D)
static char * sapi_cli_read_cookies (TSRMLS_D)
static int sapi_cli_header_handler (sapi_header_struct *h, sapi_header_op_enum op, sapi_headers_struct *s TSRMLS_DC)
static int sapi_cli_send_headers (sapi_headers_struct *sapi_headers TSRMLS_DC)
static void sapi_cli_send_header (sapi_header_struct *sapi_header, void *server_context TSRMLS_DC)
static int php_cli_startup (sapi_module_struct *sapi_module)
static void sapi_cli_ini_defaults (HashTable *configuration_hash)
static void php_cli_usage (char *argv0)
static void cli_register_file_handles (TSRMLS_D)
static int cli_seek_file_begin (zend_file_handle *file_handle, char *script_file, int *lineno TSRMLS_DC)
int main (int argc, char *argv[])

Variables

PHPAPI char * php_ini_opened_path
PHPAPI char * php_ini_scanned_path
PHPAPI char * php_ini_scanned_files
const char HARDCODED_INI [] = "max_input_time=-1\n\0"
static char * php_optarg = NULL
static int php_optind = 1
static const opt_struct OPTIONS []
static char * php_self = ""
static char * script_filename = ""
static sapi_module_struct cli_sapi_module
static const zend_function_entry additional_functions []
static php_stream * s_in_process = NULL
static const char * param_mode_conflict = "Either execute direct code, process stdin or use a file.\n"

Define Documentation

#define INI_DEFAULT (   name,
  value 
)
Value:
Z_SET_REFCOUNT(tmp, 0);\
       Z_UNSET_ISREF(tmp);  \
       ZVAL_STRINGL(&tmp, zend_strndup(value, sizeof(value)-1), sizeof(value)-1, 0);\
       zend_hash_update(configuration_hash, name, sizeof(name), &tmp, sizeof(zval), NULL);\

Definition at line 408 of file php_cli.c.

#define O_BINARY   0

Definition at line 105 of file php_cli.c.

#define PHP_MODE_CLI_DIRECT   6

Definition at line 113 of file php_cli.c.

#define PHP_MODE_HIGHLIGHT   2

Definition at line 109 of file php_cli.c.

#define PHP_MODE_INDENT   3

Definition at line 110 of file php_cli.c.

#define PHP_MODE_LINT   4

Definition at line 111 of file php_cli.c.

#define PHP_MODE_PROCESS_STDIN   7

Definition at line 114 of file php_cli.c.

#define PHP_MODE_REFLECTION_CLASS   9

Definition at line 116 of file php_cli.c.

Definition at line 118 of file php_cli.c.

Definition at line 117 of file php_cli.c.

Definition at line 115 of file php_cli.c.

#define PHP_MODE_SHOW_INI_CONFIG   12

Definition at line 119 of file php_cli.c.

#define PHP_MODE_STANDARD   1

Definition at line 108 of file php_cli.c.

#define PHP_MODE_STRIP   5

Definition at line 112 of file php_cli.c.

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

Definition at line 95 of file php_cli.c.

#define STDOUT_FILENO   1

Definition at line 229 of file php_cli.c.


Function Documentation

static void cli_register_file_handles ( TSRMLS_D  ) [static]

Definition at line 529 of file php_cli.c.

{
       zval *zin, *zout, *zerr;
       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;
       
       MAKE_STD_ZVAL(zin);
       MAKE_STD_ZVAL(zout);
       MAKE_STD_ZVAL(zerr);

       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) {
              FREE_ZVAL(zin);
              FREE_ZVAL(zout);
              FREE_ZVAL(zerr);
              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 PHP_DEBUG
       /* do not close stdout and stderr */
       s_out->flags |= PHP_STREAM_FLAG_NO_CLOSE;
       s_err->flags |= PHP_STREAM_FLAG_NO_CLOSE;
#endif

       s_in_process = s_in;

       php_stream_to_zval(s_in,  zin);
       php_stream_to_zval(s_out, zout);
       php_stream_to_zval(s_err, zerr);
       
       ic.value = *zin;
       ic.flags = CONST_CS;
       ic.name = zend_strndup(ZEND_STRL("STDIN"));
       ic.name_len = sizeof("STDIN");
       ic.module_number = 0;
       zend_register_constant(&ic TSRMLS_CC);

       oc.value = *zout;
       oc.flags = CONST_CS;
       oc.name = zend_strndup(ZEND_STRL("STDOUT"));
       oc.name_len = sizeof("STDOUT");
       oc.module_number = 0;
       zend_register_constant(&oc TSRMLS_CC);

       ec.value = *zerr;
       ec.flags = CONST_CS;
       ec.name = zend_strndup(ZEND_STRL("STDERR"));
       ec.name_len = sizeof("STDERR");
       ec.module_number = 0;
       zend_register_constant(&ec TSRMLS_CC);

       FREE_ZVAL(zin);
       FREE_ZVAL(zout);
       FREE_ZVAL(zerr);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int cli_seek_file_begin ( zend_file_handle file_handle,
char *  script_file,
int *lineno  TSRMLS_DC 
) [static]

Definition at line 597 of file php_cli.c.

{
       int c;

       *lineno = 1;

       file_handle->type = ZEND_HANDLE_FP;
       file_handle->opened_path = NULL;
       file_handle->free_filename = 0;
       if (!(file_handle->handle.fp = VCWD_FOPEN(script_file, "rb"))) {
              php_printf("Could not open input file: %s\n", script_file);
              return FAILURE;
       }
       file_handle->filename = script_file;

       /* #!php support */
       c = fgetc(file_handle->handle.fp);
       if (c == '#' && (c = fgetc(file_handle->handle.fp)) == '!') {
              while (c != '\n' && c != '\r' && c != EOF) {
                     c = fgetc(file_handle->handle.fp); /* skip to end of line */
              }
              /* handle situations where line is terminated by \r\n */
              if (c == '\r') {
                     if (fgetc(file_handle->handle.fp) != '\n') {
                            long pos = ftell(file_handle->handle.fp);
                            fseek(file_handle->handle.fp, pos - 1, SEEK_SET);
                     }
              }
              *lineno = 2;
       } else {
              rewind(file_handle->handle.fp);
       }

       return SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int extension_name_cmp ( const zend_llist_element **  f,
const zend_llist_element **s  TSRMLS_DC 
) [static]

Definition at line 209 of file php_cli.c.

{
       return strcmp(((zend_extension *)(*f)->data)->name,
                              ((zend_extension *)(*s)->data)->name);
}

Here is the caller graph for this function:

int main ( int  argc,
char *  argv[] 
)

Definition at line 639 of file php_cli.c.

{
       volatile int exit_status = SUCCESS;
       int c;
       zend_file_handle file_handle;
/* temporary locals */
       int behavior=PHP_MODE_STANDARD;
       char *reflection_what = NULL;
       int orig_optind=php_optind;
       char *orig_optarg=php_optarg;
       char *arg_free=NULL, **arg_excp=&arg_free;
       char *script_file=NULL;
       int interactive=0;
       volatile int module_started = 0;
       volatile int request_started = 0;
       int lineno = 0;
       char *exec_direct=NULL, *exec_run=NULL, *exec_begin=NULL, *exec_end=NULL;
       const char *param_error=NULL;
       int hide_argv = 0;
/* end of temporary locals */
#ifdef ZTS
       void ***tsrm_ls;
#endif
#ifdef PHP_CLI_WIN32_NO_CONSOLE
       int argc = __argc;
       char **argv = __argv;
#endif
       int ini_entries_len = 0;

#if defined(PHP_WIN32) && defined(_DEBUG) && defined(PHP_WIN32_DEBUG_HEAP)
       {
              int tmp_flag;
              _CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE);
              _CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDERR);
              _CrtSetReportMode(_CRT_ERROR, _CRTDBG_MODE_FILE);
              _CrtSetReportFile(_CRT_ERROR, _CRTDBG_FILE_STDERR);
              _CrtSetReportMode(_CRT_ASSERT, _CRTDBG_MODE_FILE);
              _CrtSetReportFile(_CRT_ASSERT, _CRTDBG_FILE_STDERR);
              tmp_flag = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG);
              tmp_flag |= _CRTDBG_DELAY_FREE_MEM_DF;
              tmp_flag |= _CRTDBG_LEAK_CHECK_DF;

              _CrtSetDbgFlag(tmp_flag);
       }
#endif

#ifdef HAVE_SIGNAL_H
#if defined(SIGPIPE) && defined(SIG_IGN)
       signal(SIGPIPE, SIG_IGN); /* ignore SIGPIPE in standalone mode so
                                                        that sockets created via fsockopen()
                                                        don't kill PHP if the remote site
                                                        closes it.  in apache|apxs mode apache
                                                        does that for us!  thies@thieso.net
                                                        20000419 */
#endif
#endif


#ifdef ZTS
       tsrm_startup(1, 1, 0, NULL);
       tsrm_ls = ts_resource(0);
#endif

       cli_sapi_module.ini_defaults = sapi_cli_ini_defaults;
       cli_sapi_module.php_ini_path_override = NULL;
       cli_sapi_module.phpinfo_as_text = 1;
       sapi_startup(&cli_sapi_module);

#ifdef PHP_WIN32
       _fmode = _O_BINARY;                /*sets default for file streams to binary */
       setmode(_fileno(stdin), O_BINARY);        /* make the stdio mode be binary */
       setmode(_fileno(stdout), O_BINARY);              /* make the stdio mode be binary */
       setmode(_fileno(stderr), O_BINARY);              /* make the stdio mode be binary */
#endif

       ini_entries_len = sizeof(HARDCODED_INI)-2;
       cli_sapi_module.ini_entries = malloc(sizeof(HARDCODED_INI));
       memcpy(cli_sapi_module.ini_entries, HARDCODED_INI, sizeof(HARDCODED_INI));

       while ((c = php_getopt(argc, argv, OPTIONS, &php_optarg, &php_optind, 0, 2))!=-1) {
              switch (c) {
                     case 'c':
                            if (cli_sapi_module.php_ini_path_override) {
                                   free(cli_sapi_module.php_ini_path_override);
                            }
                            cli_sapi_module.php_ini_path_override = strdup(php_optarg);
                            break;
                     case 'n':
                            cli_sapi_module.php_ini_ignore = 1;
                            break;
                     case 'd': {
                            /* define ini entries on command line */
                            int len = strlen(php_optarg);
                            char *val;

                            if ((val = strchr(php_optarg, '='))) {
                                   val++;
                                   if (!isalnum(*val) && *val != '"' && *val != '\'' && *val != '\0') {
                                          cli_sapi_module.ini_entries = realloc(cli_sapi_module.ini_entries, ini_entries_len + len + sizeof("\"\"\n\0"));
                                          memcpy(cli_sapi_module.ini_entries + ini_entries_len, php_optarg, (val - php_optarg));
                                          ini_entries_len += (val - php_optarg);
                                          memcpy(cli_sapi_module.ini_entries + ini_entries_len, "\"", 1);
                                          ini_entries_len++;
                                          memcpy(cli_sapi_module.ini_entries + ini_entries_len, val, len - (val - php_optarg));
                                          ini_entries_len += len - (val - php_optarg);
                                          memcpy(cli_sapi_module.ini_entries + ini_entries_len, "\"\n\0", sizeof("\"\n\0"));
                                          ini_entries_len += sizeof("\n\0\"") - 2;
                                   } else {
                                          cli_sapi_module.ini_entries = realloc(cli_sapi_module.ini_entries, ini_entries_len + len + sizeof("\n\0"));
                                          memcpy(cli_sapi_module.ini_entries + ini_entries_len, php_optarg, len);
                                          memcpy(cli_sapi_module.ini_entries + ini_entries_len + len, "\n\0", sizeof("\n\0"));
                                          ini_entries_len += len + sizeof("\n\0") - 2;
                                   }
                            } else {
                                   cli_sapi_module.ini_entries = realloc(cli_sapi_module.ini_entries, ini_entries_len + len + sizeof("=1\n\0"));
                                   memcpy(cli_sapi_module.ini_entries + ini_entries_len, php_optarg, len);
                                   memcpy(cli_sapi_module.ini_entries + ini_entries_len + len, "=1\n\0", sizeof("=1\n\0"));
                                   ini_entries_len += len + sizeof("=1\n\0") - 2;
                            }
                            break;
                     }
              }
       }
       php_optind = orig_optind;
       php_optarg = orig_optarg;

       cli_sapi_module.executable_location = argv[0];
       cli_sapi_module.additional_functions = additional_functions;

       /* startup after we get the above ini override se we get things right */
       if (cli_sapi_module.startup(&cli_sapi_module)==FAILURE) {
              /* there is no way to see if we must call zend_ini_deactivate()
               * since we cannot check if EG(ini_directives) has been initialised
               * because the executor's constructor does not set initialize it.
               * Apart from that there seems no need for zend_ini_deactivate() yet.
               * So we goto out_err.*/
              exit_status = 1;
              goto out_err;
       }
       module_started = 1;

       zend_first_try {
              CG(in_compilation) = 0; /* not initialized but needed for several options */
              EG(uninitialized_zval_ptr) = NULL;

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

                     case 'h': /* help & quit */
                     case '?':
                            if (php_request_startup(TSRMLS_C)==FAILURE) {
                                   goto err;
                            }
                            request_started = 1;
                            php_cli_usage(argv[0]);
                            php_end_ob_buffers(1 TSRMLS_CC);
                            exit_status = (c == '?' && argc > 1 && !strchr(argv[1],  c));
                            goto out;

                     case 'i': /* php info & quit */
                            if (php_request_startup(TSRMLS_C)==FAILURE) {
                                   goto err;
                            }
                            request_started = 1;
                            php_print_info(0xFFFFFFFF TSRMLS_CC);
                            php_end_ob_buffers(1 TSRMLS_CC);
                            exit_status=0;
                            goto out;

                     case 'm': /* list compiled in modules */
                            if (php_request_startup(TSRMLS_C)==FAILURE) {
                                   goto err;
                            }
                            request_started = 1;
                            php_printf("[PHP Modules]\n");
                            print_modules(TSRMLS_C);
                            php_printf("\n[Zend Modules]\n");
                            print_extensions(TSRMLS_C);
                            php_printf("\n");
                            php_end_ob_buffers(1 TSRMLS_CC);
                            exit_status=0;
                            goto out;

                     case 'v': /* show php version & quit */
                            if (php_request_startup(TSRMLS_C) == FAILURE) {
                                   goto err;
                            }

                            request_started = 1;
                            php_printf("PHP %s (%s) (built: %s %s) %s\nCopyright (c) 1997-2012 The PHP Group\n%s",
                                   PHP_VERSION, sapi_module.name, __DATE__, __TIME__,
#if ZEND_DEBUG && defined(HAVE_GCOV)
                                   "(DEBUG GCOV)",
#elif ZEND_DEBUG
                                   "(DEBUG)",
#elif defined(HAVE_GCOV)
                                   "(GCOV)",
#else
                                   "",
#endif
                                   get_zend_version()
                            );
                            php_end_ob_buffers(1 TSRMLS_CC);
                            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 'e': /* enable extended info output */
                            CG(compiler_options) |= ZEND_COMPILE_EXTENDED_INFO;
                            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;

#if 0 /* not yet operational, see also below ... */
                     case '': /* generate indented source mode*/
                            if (behavior == PHP_MODE_CLI_DIRECT || behavior == PHP_MODE_PROCESS_STDIN) {
                                   param_error = "Source indenting only works for files.\n";
                                   break;
                            }
                            behavior=PHP_MODE_INDENT;
                            break;
#endif

                     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_EXT_INFO;
                            reflection_what = php_optarg;
                            break;
                     case 14:
                            behavior = PHP_MODE_SHOW_INI_CONFIG;
                            break;
                     default:
                            break;
                     }
              }

              if (param_error) {
                     PUTS(param_error);
                     exit_status=1;
                     goto err;
              }

              if (interactive) {
#if (HAVE_LIBREADLINE || HAVE_LIBEDIT) && !defined(COMPILE_DL_READLINE)
                     printf("Interactive shell\n\n");
#else
                     printf("Interactive mode enabled\n\n");
#endif
                     fflush(stdout);
              }

              CG(interactive) = interactive;

              /* only set script_file if not set already and not in direct mode and not at end of parameter list */
              if (argc > php_optind 
                && !script_file 
                && behavior!=PHP_MODE_CLI_DIRECT 
                && behavior!=PHP_MODE_PROCESS_STDIN 
                && strcmp(argv[php_optind-1],"--")) 
              {
                     script_file=argv[php_optind];
                     php_optind++;
              }
              if (script_file) {
                     if (cli_seek_file_begin(&file_handle, script_file, &lineno TSRMLS_CC) != SUCCESS) {
                            goto err;
                     }
                     script_filename = script_file;
              } else {
                     /* We could handle PHP_MODE_PROCESS_STDIN in a different manner  */
                     /* here but this would make things only more complicated. And it */
                     /* is consitent with the way -R works where the stdin file handle*/
                     /* is also accessible. */
                     file_handle.filename = "-";
                     file_handle.handle.fp = stdin;
              }
              file_handle.type = ZEND_HANDLE_FP;
              file_handle.opened_path = NULL;
              file_handle.free_filename = 0;
              php_self = file_handle.filename;

              /* before registering argv to module exchange the *new* argv[0] */
              /* we can achieve this without allocating more memory */
              SG(request_info).argc=argc-php_optind+1;
              arg_excp = argv+php_optind-1;
              arg_free = argv[php_optind-1];
              SG(request_info).path_translated = file_handle.filename;
              argv[php_optind-1] = file_handle.filename;
              SG(request_info).argv=argv+php_optind-1;

              if (php_request_startup(TSRMLS_C)==FAILURE) {
                     *arg_excp = arg_free;
                     fclose(file_handle.handle.fp);
                     PUTS("Could not startup.\n");
                     goto err;
              }
              request_started = 1;
              CG(start_lineno) = lineno;
              *arg_excp = arg_free; /* reconstuct argv */

              if (hide_argv) {
                     int i;
                     for (i = 1; i < argc; i++) {
                            memset(argv[i], 0, strlen(argv[i]));
                     }
              }

              zend_is_auto_global("_SERVER", sizeof("_SERVER")-1 TSRMLS_CC);

              PG(during_request_startup) = 0;
              switch (behavior) {
              case PHP_MODE_STANDARD:
                     if (strcmp(file_handle.filename, "-")) {
                            cli_register_file_handles(TSRMLS_C);
                     }

#if (HAVE_LIBREADLINE || HAVE_LIBEDIT) && !defined(COMPILE_DL_READLINE)
                     if (interactive) {
                            char *line;
                            size_t size = 4096, pos = 0, len;
                            char *code = emalloc(size);
                            char *prompt = "php > ";
                            char *history_file;

                            if (PG(auto_prepend_file) && PG(auto_prepend_file)[0]) {
                                   zend_file_handle *prepend_file_p;
                                   zend_file_handle prepend_file = {0};

                                   prepend_file.filename = PG(auto_prepend_file);
                                   prepend_file.opened_path = NULL;
                                   prepend_file.free_filename = 0;
                                   prepend_file.type = ZEND_HANDLE_FILENAME;
                                   prepend_file_p = &prepend_file;

                                   zend_execute_scripts(ZEND_REQUIRE TSRMLS_CC, NULL, 1, prepend_file_p);
                            }

                            history_file = tilde_expand("~/.php_history");
                            rl_attempted_completion_function = cli_code_completion;
                            rl_special_prefixes = "$";
                            read_history(history_file);

                            EG(exit_status) = 0;
                            while ((line = readline(prompt)) != NULL) {
                                   if (strcmp(line, "exit") == 0 || strcmp(line, "quit") == 0) {
                                          free(line);
                                          break;
                                   }

                                   if (!pos && !*line) {
                                          free(line);
                                          continue;
                                   }

                                   len = strlen(line);
                                   if (pos + len + 2 > size) {
                                          size = pos + len + 2;
                                          code = erealloc(code, size);
                                   }
                                   memcpy(&code[pos], line, len);
                                   pos += len;
                                   code[pos] = '\n';
                                   code[++pos] = '\0';

                                   if (*line) {
                                          add_history(line);
                                   }

                                   free(line);

                                   if (!cli_is_valid_code(code, pos, &prompt TSRMLS_CC)) {
                                          continue;
                                   }

                                   zend_eval_stringl(code, pos, NULL, "php shell code" TSRMLS_CC);
                                   pos = 0;
                                   
                                   if (php_last_char != '\0' && php_last_char != '\n') {
                                          sapi_cli_single_write("\n", 1 TSRMLS_CC);
                                   }

                                   if (EG(exception)) {
                                          zend_exception_error(EG(exception), E_WARNING TSRMLS_CC);
                                   }

                                   php_last_char = '\0';
                            }
                            write_history(history_file);
                            free(history_file);
                            efree(code);
                            exit_status = EG(exit_status);
                            break;
                     }
#endif /* HAVE_LIBREADLINE || HAVE_LIBEDIT */
                     php_execute_script(&file_handle TSRMLS_CC);
                     exit_status = EG(exit_status);
                     break;
              case PHP_MODE_LINT:
                     exit_status = php_lint_script(&file_handle TSRMLS_CC);
                     if (exit_status==SUCCESS) {
                            zend_printf("No syntax errors detected in %s\n", file_handle.filename);
                     } else {
                            zend_printf("Errors parsing %s\n", file_handle.filename);
                     }
                     break;
              case PHP_MODE_STRIP:
                     if (open_file_for_scanning(&file_handle TSRMLS_CC)==SUCCESS) {
                            zend_strip(TSRMLS_C);
                     }
                     goto out;
                     break;
              case PHP_MODE_HIGHLIGHT:
                     {
                            zend_syntax_highlighter_ini syntax_highlighter_ini;

                            if (open_file_for_scanning(&file_handle TSRMLS_CC)==SUCCESS) {
                                   php_get_highlight_struct(&syntax_highlighter_ini);
                                   zend_highlight(&syntax_highlighter_ini TSRMLS_CC);
                            }
                            goto out;
                     }
                     break;
#if 0
                     /* Zeev might want to do something with this one day */
              case PHP_MODE_INDENT:
                     open_file_for_scanning(&file_handle TSRMLS_CC);
                     zend_indent();
                     zend_file_handle_dtor(file_handle.handle TSRMLS_CC);
                     goto out;
                     break;
#endif
              case PHP_MODE_CLI_DIRECT:
                     cli_register_file_handles(TSRMLS_C);
                     if (zend_eval_string_ex(exec_direct, NULL, "Command line code", 1 TSRMLS_CC) == FAILURE) {
                            exit_status=254;
                     }
                     break;
                     
              case PHP_MODE_PROCESS_STDIN:
                     {
                            char *input;
                            size_t len, index = 0;
                            zval *argn, *argi;

                            cli_register_file_handles(TSRMLS_C);
       
                            if (exec_begin && zend_eval_string_ex(exec_begin, NULL, "Command line begin code", 1 TSRMLS_CC) == FAILURE) {
                                   exit_status=254;
                            }
                            ALLOC_ZVAL(argi);
                            Z_TYPE_P(argi) = IS_LONG;
                            Z_LVAL_P(argi) = index;
                            INIT_PZVAL(argi);
                            zend_hash_update(&EG(symbol_table), "argi", sizeof("argi"), &argi, sizeof(zval *), NULL);
                            while (exit_status == SUCCESS && (input=php_stream_gets(s_in_process, NULL, 0)) != NULL) {
                                   len = strlen(input);
                                   while (len-- && (input[len]=='\n' || input[len]=='\r')) {
                                          input[len] = '\0';
                                   }
                                   ALLOC_ZVAL(argn);
                                   Z_TYPE_P(argn) = IS_STRING;
                                   Z_STRLEN_P(argn) = ++len;
                                   Z_STRVAL_P(argn) = estrndup(input, len);
                                   INIT_PZVAL(argn);
                                   zend_hash_update(&EG(symbol_table), "argn", sizeof("argn"), &argn, sizeof(zval *), NULL);
                                   Z_LVAL_P(argi) = ++index;
                                   if (exec_run) {
                                          if (zend_eval_string_ex(exec_run, NULL, "Command line run code", 1 TSRMLS_CC) == FAILURE) {
                                                 exit_status=254;
                                          }
                                   } else {
                                          if (script_file) {
                                                 if (cli_seek_file_begin(&file_handle, script_file, &lineno TSRMLS_CC) != SUCCESS) {
                                                        exit_status = 1;
                                                 } else {
                                                        CG(start_lineno) = lineno;
                                                        php_execute_script(&file_handle TSRMLS_CC);
                                                        exit_status = EG(exit_status);
                                                 }
                                          }
                                   }
                                   efree(input);
                            }
                            if (exec_end && zend_eval_string_ex(exec_end, NULL, "Command line end code", 1 TSRMLS_CC) == FAILURE) {
                                   exit_status=254;
                            }

                            break;
                     }
                     case PHP_MODE_REFLECTION_FUNCTION:
                     case PHP_MODE_REFLECTION_CLASS:
                     case PHP_MODE_REFLECTION_EXTENSION:
                            {
                                   zend_class_entry *pce = NULL;
                                   zval *arg, *ref;
                                   zend_execute_data execute_data;

                                   switch (behavior) {
                                          default:
                                                 break;
                                          case PHP_MODE_REFLECTION_FUNCTION:
                                                 if (strstr(reflection_what, "::")) {
                                                        pce = reflection_method_ptr;
                                                 } else {
                                                        pce = reflection_function_ptr;
                                                 }
                                                 break;
                                          case PHP_MODE_REFLECTION_CLASS:
                                                 pce = reflection_class_ptr;
                                                 break;
                                          case PHP_MODE_REFLECTION_EXTENSION:
                                                 pce = reflection_extension_ptr;
                                                 break;
                                   }
                                   
                                   MAKE_STD_ZVAL(arg);
                                   ZVAL_STRING(arg, reflection_what, 1);
                                   ALLOC_ZVAL(ref);
                                   object_init_ex(ref, pce);
                                   INIT_PZVAL(ref);

                                   memset(&execute_data, 0, sizeof(zend_execute_data));
                                   EG(current_execute_data) = &execute_data;
                                   EX(function_state).function = pce->constructor;
                                   zend_call_method_with_1_params(&ref, pce, &pce->constructor, "__construct", NULL, arg);

                                   if (EG(exception)) {
                                          zval *msg = zend_read_property(zend_exception_get_default(TSRMLS_C), EG(exception), "message", sizeof("message")-1, 0 TSRMLS_CC);
                                          zend_printf("Exception: %s\n", Z_STRVAL_P(msg));
                                          zval_ptr_dtor(&EG(exception));
                                          EG(exception) = NULL;
                                   } else {
                                          zend_call_method_with_1_params(NULL, reflection_ptr, NULL, "export", NULL, ref);
                                   }
                                   zval_ptr_dtor(&ref);
                                   zval_ptr_dtor(&arg);

                                   break;
                            }
                     case PHP_MODE_REFLECTION_EXT_INFO:
                            {
                                   int len = strlen(reflection_what);
                                   char *lcname = zend_str_tolower_dup(reflection_what, len);
                                   zend_module_entry *module;

                                   if (zend_hash_find(&module_registry, lcname, len+1, (void**)&module) == FAILURE) {
                                          if (!strcmp(reflection_what, "main")) {
                                                 display_ini_entries(NULL);
                                          } else {
                                                 zend_printf("Extension '%s' not present.\n", reflection_what);
                                                 exit_status = 1;
                                          }
                                   } else {
                                          php_info_print_module(module TSRMLS_CC);
                                   }
                                   
                                   efree(lcname);
                                   break;
                            }
                     case PHP_MODE_SHOW_INI_CONFIG:
                            {
                                   zend_printf("Configuration File (php.ini) Path: %s\n", PHP_CONFIG_FILE_PATH);
                                   zend_printf("Loaded Configuration File:         %s\n", php_ini_opened_path ? php_ini_opened_path : "(none)");
                                   zend_printf("Scan for additional .ini files in: %s\n", php_ini_scanned_path ? php_ini_scanned_path : "(none)");
                                   zend_printf("Additional .ini files parsed:      %s\n", php_ini_scanned_files ? php_ini_scanned_files : "(none)");
                                   break;
                            }
              }

       } zend_end_try();

out:
       if (request_started) {
              php_request_shutdown((void *) 0);
       }
       if (exit_status == 0) {
              exit_status = EG(exit_status);
       }
out_err:      
       if (cli_sapi_module.php_ini_path_override) {
              free(cli_sapi_module.php_ini_path_override);
       }
       if (cli_sapi_module.ini_entries) {
              free(cli_sapi_module.ini_entries);
       }

       if (module_started) {
              php_module_shutdown(TSRMLS_C);
       }
       sapi_shutdown();
#ifdef ZTS
       tsrm_shutdown();
#endif

       exit(exit_status);

err:
       sapi_deactivate(TSRMLS_C);
       zend_ini_deactivate(TSRMLS_C);
       exit_status = 1;
       goto out_err;
}
static int module_name_cmp ( const void *  a,
const void *b  TSRMLS_DC 
) [static]

Definition at line 179 of file php_cli.c.

{
       Bucket *f = *((Bucket **) a);
       Bucket *s = *((Bucket **) b);

       return strcasecmp(((zend_module_entry *)f->pData)->name,
                              ((zend_module_entry *)s->pData)->name);
}

Here is the caller graph for this function:

static int php_cli_startup ( sapi_module_struct *  sapi_module) [static]

Definition at line 396 of file php_cli.c.

{
       if (php_module_startup(sapi_module, NULL, 0)==FAILURE) {
              return FAILURE;
       }
       return SUCCESS;
}

Here is the call graph for this function:

static void php_cli_usage ( char *  argv0) [static]

Definition at line 470 of file php_cli.c.

{
       char *prog;

       prog = strrchr(argv0, '/');
       if (prog) {
              prog++;
       } else {
              prog = "php";
       }
       
       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] -- [args...]\n"
                   "       %s [options] -a\n"
                   "\n"
#if (HAVE_LIBREADLINE || 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 php.ini file 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               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"
                            "  --ri <name>      Show configuration for extension <name>.\n"
                            "\n"
                            , prog, prog, prog, prog, prog, prog);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int print_extension_info ( zend_extension *  ext,
void *arg  TSRMLS_DC 
) [static]

Definition at line 202 of file php_cli.c.

{
       php_printf("%s\n", ext->name);
       return ZEND_HASH_APPLY_KEEP;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void print_extensions ( TSRMLS_D  ) [static]

Definition at line 216 of file php_cli.c.

Here is the call graph for this function:

Here is the caller graph for this function:

static int print_module_info ( zend_module_entry *module  TSRMLS_DC) [static]

Definition at line 172 of file php_cli.c.

{
       php_printf("%s\n", module->name);
       return ZEND_HASH_APPLY_KEEP;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void print_modules ( TSRMLS_D  ) [static]

Definition at line 189 of file php_cli.c.

{
       HashTable sorted_registry;
       zend_module_entry tmp;

       zend_hash_init(&sorted_registry, 50, NULL, NULL, 1);
       zend_hash_copy(&sorted_registry, &module_registry, NULL, &tmp, sizeof(zend_module_entry));
       zend_hash_sort(&sorted_registry, zend_qsort, module_name_cmp, 0 TSRMLS_CC);
       zend_hash_apply(&sorted_registry, (apply_func_t) print_module_info TSRMLS_CC);
       zend_hash_destroy(&sorted_registry);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int sapi_cli_deactivate ( TSRMLS_D  ) [static]

Definition at line 360 of file php_cli.c.

{
       fflush(stdout);
       if(SG(request_info).argv0) {
              free(SG(request_info).argv0);
              SG(request_info).argv0 = NULL;
       }
       return SUCCESS;
}
static void sapi_cli_flush ( void *  server_context) [static]

Definition at line 304 of file php_cli.c.

{
       /* 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
       }
}

Here is the call graph for this function:

static int sapi_cli_header_handler ( sapi_header_struct h,
sapi_header_op_enum  op,
sapi_headers_struct *s  TSRMLS_DC 
) [static]

Definition at line 377 of file php_cli.c.

{
       return 0;
}
static void sapi_cli_ini_defaults ( HashTable configuration_hash) [static]

Definition at line 414 of file php_cli.c.

{
       zval tmp;
       INI_DEFAULT("report_zend_debug", "0");
       INI_DEFAULT("display_errors", "1");
}

Here is the caller graph for this function:

static void sapi_cli_log_message ( char *  message) [static]

Definition at line 354 of file php_cli.c.

{
       fprintf(stderr, "%s\n", message);
}
static char* sapi_cli_read_cookies ( TSRMLS_D  ) [static]

Definition at line 371 of file php_cli.c.

{
       return NULL;
}
static void sapi_cli_register_variables ( zval *track_vars_array  TSRMLS_DC) [static]

Definition at line 320 of file php_cli.c.

{
       unsigned int 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 TSRMLS_CC);

       /* 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 TSRMLS_CC)) {
              php_register_variable("PHP_SELF", php_self, track_vars_array TSRMLS_CC);
       }
       if (sapi_module.input_filter(PARSE_SERVER, "SCRIPT_NAME", &php_self, len, &len TSRMLS_CC)) {
              php_register_variable("SCRIPT_NAME", php_self, track_vars_array TSRMLS_CC);
       }
       /* filenames are empty for stdin */
       len = strlen(script_filename);
       if (sapi_module.input_filter(PARSE_SERVER, "SCRIPT_FILENAME", &script_filename, len, &len TSRMLS_CC)) {
              php_register_variable("SCRIPT_FILENAME", script_filename, track_vars_array TSRMLS_CC);
       }
       if (sapi_module.input_filter(PARSE_SERVER, "PATH_TRANSLATED", &script_filename, len, &len TSRMLS_CC)) {
              php_register_variable("PATH_TRANSLATED", script_filename, track_vars_array TSRMLS_CC);
       }
       /* just make it available */
       len = 0U;
       if (sapi_module.input_filter(PARSE_SERVER, "DOCUMENT_ROOT", &docroot, len, &len TSRMLS_CC)) {
              php_register_variable("DOCUMENT_ROOT", docroot, track_vars_array TSRMLS_CC);
       }
}

Here is the call graph for this function:

static int sapi_cli_select ( int fd  TSRMLS_DC) [inline, static]

Definition at line 232 of file php_cli.c.

{
       fd_set wfd, dfd;
       struct timeval tv;
       int ret;

       FD_ZERO(&wfd);
       FD_ZERO(&dfd);

       PHP_SAFE_FD_SET(fd, &wfd);

       tv.tv_sec = FG(default_socket_timeout);
       tv.tv_usec = 0;

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

       return ret != -1;
}

Here is the caller graph for this function:

static void sapi_cli_send_header ( sapi_header_struct sapi_header,
void *server_context  TSRMLS_DC 
) [static]

Definition at line 391 of file php_cli.c.

{
}
static int sapi_cli_send_headers ( sapi_headers_struct *sapi_headers  TSRMLS_DC) [static]

Definition at line 383 of file php_cli.c.

{
       /* We do nothing here, this function is needed to prevent that the fallback
        * header handling is called. */
       return SAPI_HEADER_SENT_SUCCESSFULLY;
}
static size_t sapi_cli_single_write ( const char *  str,
uint str_length  TSRMLS_DC 
) [inline, static]

Definition at line 251 of file php_cli.c.

{
#ifdef PHP_WRITE_STDOUT
       long ret;

       do {
              ret = write(STDOUT_FILENO, str, str_length);
       } while (ret <= 0 && errno == EAGAIN && sapi_cli_select(STDOUT_FILENO TSRMLS_CC));

       if (ret <= 0) {
              return 0;
       }

       return ret;
#else
       size_t ret;

       ret = fwrite(str, 1, MIN(str_length, 16384), stdout);
       return ret;
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int sapi_cli_ub_write ( const char *  str,
uint str_length  TSRMLS_DC 
) [static]

Definition at line 274 of file php_cli.c.

{
       const char *ptr = str;
       uint remaining = str_length;
       size_t ret;

#if (HAVE_LIBREADLINE || HAVE_LIBEDIT) && !defined(COMPILE_DL_READLINE)
       if (!str_length) {
              return 0;
       }
       php_last_char = str[str_length-1];
#endif

       while (remaining > 0)
       {
              ret = sapi_cli_single_write(ptr, remaining TSRMLS_CC);
              if (!ret) {
#ifndef PHP_CLI_WIN32_NO_CONSOLE
                     php_handle_aborted_connection();
#endif
                     break;
              }
              ptr += ret;
              remaining -= ret;
       }

       return (ptr - str);
}

Here is the call graph for this function:


Variable Documentation

Initial value:
 {
       ZEND_FE(dl, arginfo_dl)
       {NULL, NULL, NULL}
}

Definition at line 463 of file php_cli.c.

sapi_module_struct cli_sapi_module [static]

Definition at line 424 of file php_cli.c.

const char HARDCODED_INI[] = "max_input_time=-1\n\0"

Definition at line 121 of file php_cli.c.

const opt_struct OPTIONS[] [static]

Definition at line 135 of file php_cli.c.

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

Definition at line 593 of file php_cli.c.

Definition at line 70 of file php_ini.c.

Definition at line 73 of file php_ini.c.

Definition at line 72 of file php_ini.c.

char* php_optarg = NULL [static]

Definition at line 129 of file php_cli.c.

int php_optind = 1 [static]

Definition at line 130 of file php_cli.c.

char* php_self = "" [static]

Definition at line 317 of file php_cli.c.

php_stream* s_in_process = NULL [static]

Definition at line 527 of file php_cli.c.

char* script_filename = "" [static]

Definition at line 318 of file php_cli.c.