PHP  
 PHP: Test and Code Coverage Analysis
downloads | QA | documentation | faq | getting help | mailing lists | reporting bugs | php.net sites | links | my php.net 
 

LCOV - code coverage report
Current view: top level - ext/standard - proc_open.c (source / functions) Hit Total Coverage
Test: PHP Code Coverage Lines: 185 249 74.3 %
Date: 2014-11-22 Functions: 8 8 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*
       2             :    +----------------------------------------------------------------------+
       3             :    | PHP Version 7                                                        |
       4             :    +----------------------------------------------------------------------+
       5             :    | Copyright (c) 1997-2014 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: Wez Furlong <wez@thebrainroom.com>                           |
      16             :    +----------------------------------------------------------------------+
      17             :  */
      18             : /* $Id$ */
      19             : 
      20             : #if 0 && (defined(__linux__) || defined(sun) || defined(__IRIX__))
      21             : # define _BSD_SOURCE            /* linux wants this when XOPEN mode is on */
      22             : # define _BSD_COMPAT            /* irix: uint */
      23             : # define _XOPEN_SOURCE 500  /* turn on Unix98 */
      24             : # define __EXTENSIONS__ 1       /* Solaris: uint */
      25             : #endif
      26             : 
      27             : #include "php.h"
      28             : #include <stdio.h>
      29             : #include <ctype.h>
      30             : #include "php_string.h"
      31             : #include "ext/standard/head.h"
      32             : #include "ext/standard/basic_functions.h"
      33             : #include "ext/standard/file.h"
      34             : #include "exec.h"
      35             : #include "php_globals.h"
      36             : #include "SAPI.h"
      37             : #include "main/php_network.h"
      38             : 
      39             : #ifdef NETWARE
      40             : #include <proc.h>
      41             : #include <library.h>
      42             : #endif
      43             : 
      44             : #if HAVE_SYS_WAIT_H
      45             : #include <sys/wait.h>
      46             : #endif
      47             : #if HAVE_SIGNAL_H
      48             : #include <signal.h>
      49             : #endif
      50             : 
      51             : #if HAVE_SYS_STAT_H
      52             : #include <sys/stat.h>
      53             : #endif
      54             : #if HAVE_FCNTL_H
      55             : #include <fcntl.h>
      56             : #endif
      57             : 
      58             : /* This symbol is defined in ext/standard/config.m4.
      59             :  * Essentially, it is set if you HAVE_FORK || PHP_WIN32
      60             :  * Other platforms may modify that configure check and add suitable #ifdefs
      61             :  * around the alternate code.
      62             :  * */
      63             : #ifdef PHP_CAN_SUPPORT_PROC_OPEN
      64             : 
      65             : #if 0 && HAVE_PTSNAME && HAVE_GRANTPT && HAVE_UNLOCKPT && HAVE_SYS_IOCTL_H && HAVE_TERMIOS_H
      66             : # include <sys/ioctl.h>
      67             : # include <termios.h>
      68             : # define PHP_CAN_DO_PTS 1
      69             : #endif
      70             : 
      71             : #include "proc_open.h"
      72             : 
      73             : static int le_proc_open;
      74             : 
      75             : /* {{{ _php_array_to_envp */
      76       20356 : static php_process_env_t _php_array_to_envp(zval *environment, int is_persistent TSRMLS_DC)
      77             : {
      78             :         zval *element;
      79             :         php_process_env_t env;
      80             :         zend_string *string_key;
      81             : #ifndef PHP_WIN32
      82             :         char **ep;
      83             : #endif
      84             :         char *p;
      85       20356 :         size_t cnt, l, sizeenv=0;
      86             :         HashTable *target_hash;
      87             : 
      88       20356 :         memset(&env, 0, sizeof(env));
      89             : 
      90       20356 :         if (!environment) {
      91           0 :                 return env;
      92             :         }
      93             : 
      94       20356 :         cnt = zend_hash_num_elements(Z_ARRVAL_P(environment));
      95             : 
      96       20356 :         if (cnt < 1) {
      97             : #ifndef PHP_WIN32
      98           4 :                 env.envarray = (char **) pecalloc(1, sizeof(char *), is_persistent);
      99             : #endif
     100           4 :                 env.envp = (char *) pecalloc(4, 1, is_persistent);
     101           4 :                 return env;
     102             :         }
     103             : 
     104       20352 :         target_hash = HASH_OF(environment);
     105       20352 :         if (!target_hash) {
     106           0 :                 return env;
     107             :         }
     108             : 
     109             :         /* first, we have to get the size of all the elements in the hash */
     110     2210202 :         ZEND_HASH_FOREACH_STR_KEY_VAL(target_hash, string_key, element) {
     111     1094925 :                 zend_string *str = zval_get_string(element);
     112     1094925 :                 size_t el_len = str->len;
     113             :                 zend_string_release(str);
     114             : 
     115     1094925 :                 if (el_len == 0) {
     116      162765 :                         continue;
     117             :                 }
     118             : 
     119      932160 :                 sizeenv += el_len + 1;
     120             : 
     121      932160 :                 if (string_key) {
     122      932160 :                         if (string_key->len == 0) {
     123           0 :                                 continue;
     124             :                         }
     125      932160 :                         sizeenv += string_key->len + 1;
     126             :                 }
     127             :         } ZEND_HASH_FOREACH_END();
     128             : 
     129             : #ifndef PHP_WIN32
     130       20352 :         ep = env.envarray = (char **) pecalloc(cnt + 1, sizeof(char *), is_persistent);
     131             : #endif
     132       20352 :         p = env.envp = (char *) pecalloc(sizeenv + 4, 1, is_persistent);
     133             : 
     134     2210202 :         ZEND_HASH_FOREACH_STR_KEY_VAL(target_hash, string_key, element) {
     135     1094925 :                 zend_string *str = zval_get_string(element);
     136             : 
     137     1094925 :                 if (str->len == 0) {
     138      162765 :                         goto next_element;
     139             :                 }
     140             : 
     141      932160 :                 if (string_key) {
     142      932160 :                         if (string_key->len == 0) {
     143           0 :                                 goto next_element;
     144             :                         }
     145             : 
     146      932160 :                         l = string_key->len + str->len + 2;
     147      932160 :                         memcpy(p, string_key->val, string_key->len);
     148      932160 :                         strncat(p, "=", 1);
     149      932160 :                         strncat(p, str->val, str->len);
     150             : 
     151             : #ifndef PHP_WIN32
     152      932160 :                         *ep = p;
     153      932160 :                         ++ep;
     154             : #endif
     155      932160 :                         p += l;
     156             :                 } else {
     157           0 :                         memcpy(p, str->val, str->len);
     158             : #ifndef PHP_WIN32
     159           0 :                         *ep = p;
     160           0 :                         ++ep;
     161             : #endif
     162           0 :                         p += str->len + 1;
     163             :                 }
     164             : next_element:
     165             :                 zend_string_release(str);
     166             :         } ZEND_HASH_FOREACH_END();
     167             : 
     168             :         assert((uint)(p - env.envp) <= sizeenv);
     169             : 
     170       20352 :         return env;
     171             : }
     172             : /* }}} */
     173             : 
     174             : /* {{{ _php_free_envp */
     175       20421 : static void _php_free_envp(php_process_env_t env, int is_persistent)
     176             : {
     177             : #ifndef PHP_WIN32
     178       20421 :         if (env.envarray) {
     179       20356 :                 pefree(env.envarray, is_persistent);
     180             :         }
     181             : #endif
     182       20421 :         if (env.envp) {
     183       20356 :                 pefree(env.envp, is_persistent);
     184             :         }
     185       20421 : }
     186             : /* }}} */
     187             : 
     188             : /* {{{ proc_open_rsrc_dtor */
     189       20421 : static void proc_open_rsrc_dtor(zend_resource *rsrc TSRMLS_DC)
     190             : {
     191       20421 :         struct php_process_handle *proc = (struct php_process_handle*)rsrc->ptr;
     192             :         int i;
     193             : #ifdef PHP_WIN32
     194             :         DWORD wstatus;
     195             : #elif HAVE_SYS_WAIT_H
     196             :         int wstatus;
     197       20421 :         int waitpid_options = 0;
     198             :         pid_t wait_pid;
     199             : #endif
     200             : 
     201             :         /* Close all handles to avoid a deadlock */
     202       81677 :         for (i = 0; i < proc->npipes; i++) {
     203       61256 :                 if (proc->pipes[i] != 0) {
     204       61142 :                         GC_REFCOUNT(proc->pipes[i])--;
     205       61142 :                         zend_list_close(proc->pipes[i]);
     206       61142 :                         proc->pipes[i] = 0;
     207             :                 }
     208             :         }
     209             : 
     210             : #ifdef PHP_WIN32
     211             :         if (FG(pclose_wait)) {
     212             :                 WaitForSingleObject(proc->childHandle, INFINITE);
     213             :         }
     214             :         GetExitCodeProcess(proc->childHandle, &wstatus);
     215             :         if (wstatus == STILL_ACTIVE) {
     216             :                 FG(pclose_ret) = -1;
     217             :         } else {
     218             :                 FG(pclose_ret) = wstatus;
     219             :         }
     220             :         CloseHandle(proc->childHandle);
     221             : 
     222             : #elif HAVE_SYS_WAIT_H
     223             : 
     224       20421 :         if (!FG(pclose_wait)) {
     225          34 :                 waitpid_options = WNOHANG;
     226             :         }
     227             :         do {
     228       20421 :                 wait_pid = waitpid(proc->child, &wstatus, waitpid_options);
     229       20421 :         } while (wait_pid == -1 && errno == EINTR);
     230             : 
     231       20421 :         if (wait_pid <= 0) {
     232       20343 :                 FG(pclose_ret) = -1;
     233             :         } else {
     234          78 :                 if (WIFEXITED(wstatus))
     235          47 :                         wstatus = WEXITSTATUS(wstatus);
     236          78 :                 FG(pclose_ret) = wstatus;
     237             :         }
     238             : 
     239             : #else
     240             :         FG(pclose_ret) = -1;
     241             : #endif
     242       20421 :         _php_free_envp(proc->env, proc->is_persistent);
     243       20421 :         pefree(proc->command, proc->is_persistent);
     244       20421 :         pefree(proc, proc->is_persistent);
     245             : 
     246       20421 : }
     247             : /* }}} */
     248             : 
     249             : /* {{{ PHP_MINIT_FUNCTION(proc_open) */
     250       20507 : PHP_MINIT_FUNCTION(proc_open)
     251             : {
     252       20507 :         le_proc_open = zend_register_list_destructors_ex(proc_open_rsrc_dtor, NULL, "process", module_number);
     253       20507 :         return SUCCESS;
     254             : }
     255             : /* }}} */
     256             : 
     257             : /* {{{ proto bool proc_terminate(resource process [, long signal])
     258             :    kill a process opened by proc_open */
     259          37 : PHP_FUNCTION(proc_terminate)
     260             : {
     261             :         zval *zproc;
     262             :         struct php_process_handle *proc;
     263          37 :         zend_long sig_no = SIGTERM;
     264             : 
     265          37 :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|l", &zproc, &sig_no) == FAILURE) {
     266           0 :                 RETURN_FALSE;
     267             :         }
     268             : 
     269          37 :         ZEND_FETCH_RESOURCE(proc, struct php_process_handle *, zproc, -1, "process", le_proc_open);
     270             : 
     271             : #ifdef PHP_WIN32
     272             :         if (TerminateProcess(proc->childHandle, 255)) {
     273             :                 RETURN_TRUE;
     274             :         } else {
     275             :                 RETURN_FALSE;
     276             :         }
     277             : #else
     278          37 :         if (kill(proc->child, sig_no) == 0) {
     279          37 :                 RETURN_TRUE;
     280             :         } else {
     281           0 :                 RETURN_FALSE;
     282             :         }
     283             : #endif
     284             : }
     285             : /* }}} */
     286             : 
     287             : /* {{{ proto int proc_close(resource process)
     288             :    close a process opened by proc_open */
     289       20387 : PHP_FUNCTION(proc_close)
     290             : {
     291             :         zval *zproc;
     292             :         struct php_process_handle *proc;
     293             : 
     294       20387 :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &zproc) == FAILURE) {
     295           0 :                 RETURN_FALSE;
     296             :         }
     297             : 
     298       20387 :         ZEND_FETCH_RESOURCE(proc, struct php_process_handle *, zproc, -1, "process", le_proc_open);
     299             : 
     300       20387 :         FG(pclose_wait) = 1;
     301       20387 :         zend_list_close(Z_RES_P(zproc));
     302       20387 :         FG(pclose_wait) = 0;
     303       20387 :         RETURN_LONG(FG(pclose_ret));
     304             : }
     305             : /* }}} */
     306             : 
     307             : /* {{{ proto array proc_get_status(resource process)
     308             :    get information about a process opened by proc_open */
     309       24248 : PHP_FUNCTION(proc_get_status)
     310             : {
     311             :         zval *zproc;
     312             :         struct php_process_handle *proc;
     313             : #ifdef PHP_WIN32
     314             :         DWORD wstatus;
     315             : #elif HAVE_SYS_WAIT_H
     316             :         int wstatus;
     317             :         pid_t wait_pid;
     318             : #endif
     319       24248 :         int running = 1, signaled = 0, stopped = 0;
     320       24248 :         int exitcode = -1, termsig = 0, stopsig = 0;
     321             : 
     322       24248 :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &zproc) == FAILURE) {
     323           0 :                 RETURN_FALSE;
     324             :         }
     325             : 
     326       24248 :         ZEND_FETCH_RESOURCE(proc, struct php_process_handle *, zproc, -1, "process", le_proc_open);
     327             : 
     328       24248 :         array_init(return_value);
     329             : 
     330       24248 :         add_assoc_string(return_value, "command", proc->command);
     331       24248 :         add_assoc_long(return_value, "pid", (zend_long) proc->child);
     332             : 
     333             : #ifdef PHP_WIN32
     334             : 
     335             :         GetExitCodeProcess(proc->childHandle, &wstatus);
     336             : 
     337             :         running = wstatus == STILL_ACTIVE;
     338             :         exitcode = running ? -1 : wstatus;
     339             : 
     340             : #elif HAVE_SYS_WAIT_H
     341             : 
     342       24248 :         errno = 0;
     343       24248 :         wait_pid = waitpid(proc->child, &wstatus, WNOHANG|WUNTRACED);
     344             : 
     345       24248 :         if (wait_pid == proc->child) {
     346       20339 :                 if (WIFEXITED(wstatus)) {
     347       20338 :                         running = 0;
     348       20338 :                         exitcode = WEXITSTATUS(wstatus);
     349             :                 }
     350       20339 :                 if (WIFSIGNALED(wstatus)) {
     351           1 :                         running = 0;
     352           1 :                         signaled = 1;
     353             : #ifdef NETWARE
     354             :                         termsig = WIFTERMSIG(wstatus);
     355             : #else
     356           1 :                         termsig = WTERMSIG(wstatus);
     357             : #endif
     358             :                 }
     359       20339 :                 if (WIFSTOPPED(wstatus)) {
     360           0 :                         stopped = 1;
     361           0 :                         stopsig = WSTOPSIG(wstatus);
     362             :                 }
     363        3909 :         } else if (wait_pid == -1) {
     364           0 :                 running = 0;
     365             :         }
     366             : #endif
     367             : 
     368       24248 :         add_assoc_bool(return_value, "running", running);
     369       24248 :         add_assoc_bool(return_value, "signaled", signaled);
     370       24248 :         add_assoc_bool(return_value, "stopped", stopped);
     371       24248 :         add_assoc_long(return_value, "exitcode", exitcode);
     372       24248 :         add_assoc_long(return_value, "termsig", termsig);
     373       24248 :         add_assoc_long(return_value, "stopsig", stopsig);
     374             : }
     375             : /* }}} */
     376             : 
     377             : /* {{{ handy definitions for portability/readability */
     378             : #ifdef PHP_WIN32
     379             : # define pipe(pair)             (CreatePipe(&pair[0], &pair[1], &security, 0) ? 0 : -1)
     380             : 
     381             : # define COMSPEC_NT     "cmd.exe"
     382             : 
     383             : static inline HANDLE dup_handle(HANDLE src, BOOL inherit, BOOL closeorig)
     384             : {
     385             :         HANDLE copy, self = GetCurrentProcess();
     386             : 
     387             :         if (!DuplicateHandle(self, src, self, &copy, 0, inherit, DUPLICATE_SAME_ACCESS |
     388             :                                 (closeorig ? DUPLICATE_CLOSE_SOURCE : 0)))
     389             :                 return NULL;
     390             :         return copy;
     391             : }
     392             : 
     393             : static inline HANDLE dup_fd_as_handle(int fd)
     394             : {
     395             :         return dup_handle((HANDLE)_get_osfhandle(fd), TRUE, FALSE);
     396             : }
     397             : 
     398             : # define close_descriptor(fd)   CloseHandle(fd)
     399             : #else
     400             : # define close_descriptor(fd)   close(fd)
     401             : #endif
     402             : 
     403             : #define DESC_PIPE               1
     404             : #define DESC_FILE               2
     405             : #define DESC_PARENT_MODE_WRITE  8
     406             : 
     407             : struct php_proc_open_descriptor_item {
     408             :         int index;                                                      /* desired fd number in child process */
     409             :         php_file_descriptor_t parentend, childend;      /* fds for pipes in parent/child */
     410             :         int mode;                                                       /* mode for proc_open code */
     411             :         int mode_flags;                                         /* mode flags for opening fds */
     412             : };
     413             : /* }}} */
     414             : 
     415             : /* {{{ proto resource proc_open(string command, array descriptorspec, array &pipes [, string cwd [, array env [, array other_options]]])
     416             :    Run a process with more control over it's file descriptors */
     417       20421 : PHP_FUNCTION(proc_open)
     418             : {
     419       20421 :         char *command, *cwd=NULL;
     420       20421 :         size_t command_len, cwd_len = 0;
     421             :         zval *descriptorspec;
     422             :         zval *pipes;
     423       20421 :         zval *environment = NULL;
     424       20421 :         zval *other_options = NULL;
     425             :         php_process_env_t env;
     426       20421 :         int ndesc = 0;
     427             :         int i;
     428       20421 :         zval *descitem = NULL;
     429             :         zend_string *str_index;
     430             :         zend_ulong nindex;
     431             :         struct php_proc_open_descriptor_item descriptors[PHP_PROC_OPEN_MAX_DESCRIPTORS];
     432             : #ifdef PHP_WIN32
     433             :         PROCESS_INFORMATION pi;
     434             :         HANDLE childHandle;
     435             :         STARTUPINFO si;
     436             :         BOOL newprocok;
     437             :         SECURITY_ATTRIBUTES security;
     438             :         DWORD dwCreateFlags = 0;
     439             :         char *command_with_cmd;
     440             :         UINT old_error_mode;
     441             :         char cur_cwd[MAXPATHLEN];
     442             : #endif
     443             : #ifdef NETWARE
     444             :         char** child_argv = NULL;
     445             :         char* command_dup = NULL;
     446             :         char* orig_cwd = NULL;
     447             :         int command_num_args = 0;
     448             :         wiring_t channel;
     449             : #endif
     450             :         php_process_id_t child;
     451             :         struct php_process_handle *proc;
     452       20421 :         int is_persistent = 0; /* TODO: ensure that persistent procs will work */
     453             : #ifdef PHP_WIN32
     454             :         int suppress_errors = 0;
     455             :         int bypass_shell = 0;
     456             : #endif
     457             : #if PHP_CAN_DO_PTS
     458             :         php_file_descriptor_t dev_ptmx = -1;    /* master */
     459             :         php_file_descriptor_t slave_pty = -1;
     460             : #endif
     461             : 
     462       20421 :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "saz/|s!a!a!", &command,
     463             :                                 &command_len, &descriptorspec, &pipes, &cwd, &cwd_len, &environment,
     464             :                                 &other_options) == FAILURE) {
     465           0 :                 RETURN_FALSE;
     466             :         }
     467             : 
     468       20421 :         command = pestrdup(command, is_persistent);
     469             : 
     470             : #ifdef PHP_WIN32
     471             :         if (other_options) {
     472             :                 zval *item = zend_hash_str_find(Z_ARRVAL_P(other_options), "suppress_errors", sizeof("suppress_errors") - 1);
     473             :                 if (item != NULL) {
     474             :                         if (Z_TYPE_P(item) == IS_TRUE || ((Z_TYPE_P(item) == IS_LONG) && Z_LVAL_P(item))) {
     475             :                                 suppress_errors = 1;
     476             :                         }
     477             :                 }
     478             : 
     479             :                 item = zend_hash_str_find(Z_ARRVAL_P(other_options), "bypass_shell", sizeof("bypass_shell") - 1);
     480             :                 if (item != NULL) {
     481             :                         if (Z_TYPE_P(item) == IS_TRUE || ((Z_TYPE_P(item) == IS_LONG) && Z_LVAL_P(item))) {
     482             :                                 bypass_shell = 1;
     483             :                         }
     484             :                 }
     485             :         }
     486             : #endif
     487             : 
     488       20421 :         command_len = strlen(command);
     489             : 
     490       20421 :         if (environment) {
     491       20356 :                 env = _php_array_to_envp(environment, is_persistent TSRMLS_CC);
     492             :         } else {
     493          65 :                 memset(&env, 0, sizeof(env));
     494             :         }
     495             : 
     496       20421 :         memset(descriptors, 0, sizeof(descriptors));
     497             : 
     498             : #ifdef PHP_WIN32
     499             :         /* we use this to allow the child to inherit handles */
     500             :         memset(&security, 0, sizeof(security));
     501             :         security.nLength = sizeof(security);
     502             :         security.bInheritHandle = TRUE;
     503             :         security.lpSecurityDescriptor = NULL;
     504             : #endif
     505             : 
     506             :         /* walk the descriptor spec and set up files/pipes */
     507      142933 :         ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(descriptorspec), nindex, str_index, descitem) {
     508             :                 zval *ztype;
     509             : 
     510       61256 :                 if (str_index) {
     511           0 :                         php_error_docref(NULL TSRMLS_CC, E_WARNING, "descriptor spec must be an integer indexed array");
     512           0 :                         goto exit_fail;
     513             :                 }
     514             : 
     515       61256 :                 descriptors[ndesc].index = (int)nindex;
     516             : 
     517       61256 :                 if (Z_TYPE_P(descitem) == IS_RESOURCE) {
     518             :                         /* should be a stream - try and dup the descriptor */
     519             :                         php_stream *stream;
     520             :                         php_socket_t fd;
     521             : 
     522         114 :                         php_stream_from_zval(stream, descitem);
     523             : 
     524         114 :                         if (FAILURE == php_stream_cast(stream, PHP_STREAM_AS_FD, (void **)&fd, REPORT_ERRORS)) {
     525           0 :                                 goto exit_fail;
     526             :                         }
     527             : 
     528             : #ifdef PHP_WIN32
     529             :                         descriptors[ndesc].childend = dup_fd_as_handle((int)fd);
     530             :                         if (descriptors[ndesc].childend == NULL) {
     531             :                                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "unable to dup File-Handle for descriptor %d", nindex);
     532             :                                 goto exit_fail;
     533             :                         }
     534             : #else
     535         114 :                         descriptors[ndesc].childend = dup(fd);
     536         114 :                         if (descriptors[ndesc].childend < 0) {
     537           0 :                                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "unable to dup File-Handle for descriptor %pd - %s", nindex, strerror(errno));
     538           0 :                                 goto exit_fail;
     539             :                         }
     540             : #endif
     541         114 :                         descriptors[ndesc].mode = DESC_FILE;
     542             : 
     543       61142 :                 } else if (Z_TYPE_P(descitem) != IS_ARRAY) {
     544           0 :                         php_error_docref(NULL TSRMLS_CC, E_WARNING, "Descriptor item must be either an array or a File-Handle");
     545           0 :                         goto exit_fail;
     546             :                 } else {
     547             : 
     548       61142 :                         if ((ztype = zend_hash_index_find(Z_ARRVAL_P(descitem), 0)) != NULL) {
     549       61142 :                                 convert_to_string_ex(ztype);
     550             :                         } else {
     551           0 :                                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Missing handle qualifier in array");
     552           0 :                                 goto exit_fail;
     553             :                         }
     554             : 
     555       61142 :                         if (strcmp(Z_STRVAL_P(ztype), "pipe") == 0) {
     556             :                                 php_file_descriptor_t newpipe[2];
     557             :                                 zval *zmode;
     558             : 
     559       61142 :                                 if ((zmode = zend_hash_index_find(Z_ARRVAL_P(descitem), 1)) != NULL) {
     560       61142 :                                         convert_to_string_ex(zmode);
     561             :                                 } else {
     562           0 :                                         php_error_docref(NULL TSRMLS_CC, E_WARNING, "Missing mode parameter for 'pipe'");
     563           0 :                                         goto exit_fail;
     564             :                                 }
     565             : 
     566       61142 :                                 descriptors[ndesc].mode = DESC_PIPE;
     567             : 
     568       61142 :                                 if (0 != pipe(newpipe)) {
     569           0 :                                         php_error_docref(NULL TSRMLS_CC, E_WARNING, "unable to create pipe %s", strerror(errno));
     570           0 :                                         goto exit_fail;
     571             :                                 }
     572             : 
     573       61142 :                                 if (strncmp(Z_STRVAL_P(zmode), "w", 1) != 0) {
     574       20393 :                                         descriptors[ndesc].parentend = newpipe[1];
     575       20393 :                                         descriptors[ndesc].childend = newpipe[0];
     576       20393 :                                         descriptors[ndesc].mode |= DESC_PARENT_MODE_WRITE;
     577             :                                 } else {
     578       40749 :                                         descriptors[ndesc].parentend = newpipe[0];
     579       40749 :                                         descriptors[ndesc].childend = newpipe[1];
     580             :                                 }
     581             : #ifdef PHP_WIN32
     582             :                                 /* don't let the child inherit the parent side of the pipe */
     583             :                                 descriptors[ndesc].parentend = dup_handle(descriptors[ndesc].parentend, FALSE, TRUE);
     584             : #endif
     585       61142 :                                 descriptors[ndesc].mode_flags = descriptors[ndesc].mode & DESC_PARENT_MODE_WRITE ? O_WRONLY : O_RDONLY;
     586             : #ifdef PHP_WIN32
     587             :                                 if (Z_STRLEN_P(zmode) >= 2 && Z_STRVAL_P(zmode)[1] == 'b')
     588             :                                         descriptors[ndesc].mode_flags |= O_BINARY;
     589             : #endif
     590             : 
     591           0 :                         } else if (strcmp(Z_STRVAL_P(ztype), "file") == 0) {
     592             :                                 zval *zfile, *zmode;
     593             :                                 php_socket_t fd;
     594             :                                 php_stream *stream;
     595             : 
     596           0 :                                 descriptors[ndesc].mode = DESC_FILE;
     597             : 
     598           0 :                                 if ((zfile = zend_hash_index_find(Z_ARRVAL_P(descitem), 1)) != NULL) {
     599           0 :                                         convert_to_string_ex(zfile);
     600             :                                 } else {
     601           0 :                                         php_error_docref(NULL TSRMLS_CC, E_WARNING, "Missing file name parameter for 'file'");
     602           0 :                                         goto exit_fail;
     603             :                                 }
     604             : 
     605           0 :                                 if ((zmode = zend_hash_index_find(Z_ARRVAL_P(descitem), 2)) != NULL) {
     606           0 :                                         convert_to_string_ex(zmode);
     607             :                                 } else {
     608           0 :                                         php_error_docref(NULL TSRMLS_CC, E_WARNING, "Missing mode parameter for 'file'");
     609           0 :                                         goto exit_fail;
     610             :                                 }
     611             : 
     612             :                                 /* try a wrapper */
     613           0 :                                 stream = php_stream_open_wrapper(Z_STRVAL_P(zfile), Z_STRVAL_P(zmode),
     614             :                                                 REPORT_ERRORS|STREAM_WILL_CAST, NULL);
     615             : 
     616             :                                 /* force into an fd */
     617           0 :                                 if (stream == NULL || FAILURE == php_stream_cast(stream,
     618             :                                                         PHP_STREAM_CAST_RELEASE|PHP_STREAM_AS_FD,
     619             :                                                         (void **)&fd, REPORT_ERRORS)) {
     620             :                                         goto exit_fail;
     621             :                                 }
     622             : 
     623             : #ifdef PHP_WIN32
     624             :                                 descriptors[ndesc].childend = dup_fd_as_handle((int)fd);
     625             :                                 _close((int)fd);
     626             : 
     627             :                                 /* simulate the append mode by fseeking to the end of the file
     628             :                                 this introduces a potential race-condition, but it is the best we can do, though */
     629             :                                 if (strchr(Z_STRVAL_P(zmode), 'a')) {
     630             :                                         SetFilePointer(descriptors[ndesc].childend, 0, NULL, FILE_END);
     631             :                                 }
     632             : #else
     633           0 :                                 descriptors[ndesc].childend = fd;
     634             : #endif
     635           0 :                         } else if (strcmp(Z_STRVAL_P(ztype), "pty") == 0) {
     636             : #if PHP_CAN_DO_PTS
     637             :                                 if (dev_ptmx == -1) {
     638             :                                         /* open things up */
     639             :                                         dev_ptmx = open("/dev/ptmx", O_RDWR);
     640             :                                         if (dev_ptmx == -1) {
     641             :                                                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "failed to open /dev/ptmx, errno %d", errno);
     642             :                                                 goto exit_fail;
     643             :                                         }
     644             :                                         grantpt(dev_ptmx);
     645             :                                         unlockpt(dev_ptmx);
     646             :                                         slave_pty = open(ptsname(dev_ptmx), O_RDWR);
     647             : 
     648             :                                         if (slave_pty == -1) {
     649             :                                                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "failed to open slave pty, errno %d", errno);
     650             :                                                 goto exit_fail;
     651             :                                         }
     652             :                                 }
     653             :                                 descriptors[ndesc].mode = DESC_PIPE;
     654             :                                 descriptors[ndesc].childend = dup(slave_pty);
     655             :                                 descriptors[ndesc].parentend = dup(dev_ptmx);
     656             :                                 descriptors[ndesc].mode_flags = O_RDWR;
     657             : #else
     658           0 :                                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "pty pseudo terminal not supported on this system");
     659           0 :                                 goto exit_fail;
     660             : #endif
     661             :                         } else {
     662           0 :                                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s is not a valid descriptor spec/mode", Z_STRVAL_P(ztype));
     663           0 :                                 goto exit_fail;
     664             :                         }
     665             :                 }
     666             : 
     667       61256 :                 if (++ndesc == PHP_PROC_OPEN_MAX_DESCRIPTORS)
     668           0 :                         break;
     669             :         } ZEND_HASH_FOREACH_END();
     670             : 
     671             : #ifdef PHP_WIN32
     672             :         if (cwd == NULL) {
     673             :                 char *getcwd_result;
     674             :                 getcwd_result = VCWD_GETCWD(cur_cwd, MAXPATHLEN);
     675             :                 if (!getcwd_result) {
     676             :                         php_error_docref(NULL TSRMLS_CC, E_WARNING, "Cannot get current directory");
     677             :                         goto exit_fail;
     678             :                 }
     679             :                 cwd = cur_cwd;
     680             :         }
     681             : 
     682             :         memset(&si, 0, sizeof(si));
     683             :         si.cb = sizeof(si);
     684             :         si.dwFlags = STARTF_USESTDHANDLES;
     685             : 
     686             :         si.hStdInput = GetStdHandle(STD_INPUT_HANDLE);
     687             :         si.hStdOutput = GetStdHandle(STD_OUTPUT_HANDLE);
     688             :         si.hStdError = GetStdHandle(STD_ERROR_HANDLE);
     689             : 
     690             :         /* redirect stdin/stdout/stderr if requested */
     691             :         for (i = 0; i < ndesc; i++) {
     692             :                 switch(descriptors[i].index) {
     693             :                         case 0:
     694             :                                 si.hStdInput = descriptors[i].childend;
     695             :                                 break;
     696             :                         case 1:
     697             :                                 si.hStdOutput = descriptors[i].childend;
     698             :                                 break;
     699             :                         case 2:
     700             :                                 si.hStdError = descriptors[i].childend;
     701             :                                 break;
     702             :                 }
     703             :         }
     704             : 
     705             : 
     706             :         memset(&pi, 0, sizeof(pi));
     707             : 
     708             :         if (suppress_errors) {
     709             :                 old_error_mode = SetErrorMode(SEM_FAILCRITICALERRORS|SEM_NOGPFAULTERRORBOX);
     710             :         }
     711             : 
     712             :         dwCreateFlags = NORMAL_PRIORITY_CLASS;
     713             :         if(strcmp(sapi_module.name, "cli") != 0) {
     714             :                 dwCreateFlags |= CREATE_NO_WINDOW;
     715             :         }
     716             : 
     717             :         if (bypass_shell) {
     718             :                 newprocok = CreateProcess(NULL, command, &security, &security, TRUE, dwCreateFlags, env.envp, cwd, &si, &pi);
     719             :         } else {
     720             :                 spprintf(&command_with_cmd, 0, "%s /c %s", COMSPEC_NT, command);
     721             : 
     722             :                 newprocok = CreateProcess(NULL, command_with_cmd, &security, &security, TRUE, dwCreateFlags, env.envp, cwd, &si, &pi);
     723             : 
     724             :                 efree(command_with_cmd);
     725             :         }
     726             : 
     727             :         if (suppress_errors) {
     728             :                 SetErrorMode(old_error_mode);
     729             :         }
     730             : 
     731             :         if (FALSE == newprocok) {
     732             :                 DWORD dw = GetLastError();
     733             : 
     734             :                 /* clean up all the descriptors */
     735             :                 for (i = 0; i < ndesc; i++) {
     736             :                         CloseHandle(descriptors[i].childend);
     737             :                         if (descriptors[i].parentend) {
     738             :                                 CloseHandle(descriptors[i].parentend);
     739             :                         }
     740             :                 }
     741             :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "CreateProcess failed, error code - %u", dw);
     742             :                 goto exit_fail;
     743             :         }
     744             : 
     745             :         childHandle = pi.hProcess;
     746             :         child       = pi.dwProcessId;
     747             :         CloseHandle(pi.hThread);
     748             : 
     749             : #elif defined(NETWARE)
     750             :         if (cwd) {
     751             :                 orig_cwd = getcwd(NULL, PATH_MAX);
     752             :                 chdir2(cwd);
     753             :         }
     754             :         channel.infd = descriptors[0].childend;
     755             :         channel.outfd = descriptors[1].childend;
     756             :         channel.errfd = -1;
     757             :         /* Duplicate the command as processing downwards will modify it*/
     758             :         command_dup = strdup(command);
     759             :         if (!command_dup) {
     760             :                 goto exit_fail;
     761             :         }
     762             :         /* get a number of args */
     763             :         construct_argc_argv(command_dup, NULL, &command_num_args, NULL);
     764             :         child_argv = (char**) malloc((command_num_args + 1) * sizeof(char*));
     765             :         if(!child_argv) {
     766             :                 free(command_dup);
     767             :                 if (cwd && orig_cwd) {
     768             :                         chdir2(orig_cwd);
     769             :                         free(orig_cwd);
     770             :                 }
     771             :         }
     772             :         /* fill the child arg vector */
     773             :         construct_argc_argv(command_dup, NULL, &command_num_args, child_argv);
     774             :         child_argv[command_num_args] = NULL;
     775             :         child = procve(child_argv[0], PROC_DETACHED|PROC_INHERIT_CWD, NULL, &channel, NULL, NULL, 0, NULL, (const char**)child_argv);
     776             :         free(child_argv);
     777             :         free(command_dup);
     778             :         if (cwd && orig_cwd) {
     779             :                 chdir2(orig_cwd);
     780             :                 free(orig_cwd);
     781             :         }
     782             :         if (child < 0) {
     783             :                 /* failed to fork() */
     784             :                 /* clean up all the descriptors */
     785             :                 for (i = 0; i < ndesc; i++) {
     786             :                         close(descriptors[i].childend);
     787             :                         if (descriptors[i].parentend)
     788             :                                 close(descriptors[i].parentend);
     789             :                 }
     790             :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "procve failed - %s", strerror(errno));
     791             :                 goto exit_fail;
     792             :         }
     793             : #elif HAVE_FORK
     794             :         /* the unix way */
     795       20421 :         child = fork();
     796             : 
     797       20421 :         if (child == 0) {
     798             :                 /* this is the child process */
     799             : 
     800             : #if PHP_CAN_DO_PTS
     801             :                 if (dev_ptmx >= 0) {
     802             :                         int my_pid = getpid();
     803             : 
     804             : #ifdef TIOCNOTTY
     805             :                         /* detach from original tty. Might only need this if isatty(0) is true */
     806             :                         ioctl(0,TIOCNOTTY,NULL);
     807             : #else
     808             :                         setsid();
     809             : #endif
     810             :                         /* become process group leader */
     811             :                         setpgid(my_pid, my_pid);
     812             :                         tcsetpgrp(0, my_pid);
     813             :                 }
     814             : #endif
     815             : 
     816             :                 /* close those descriptors that we just opened for the parent stuff,
     817             :                  * dup new descriptors into required descriptors and close the original
     818             :                  * cruft */
     819       61252 :                 for (i = 0; i < ndesc; i++) {
     820       61252 :                         switch (descriptors[i].mode & ~DESC_PARENT_MODE_WRITE) {
     821             :                                 case DESC_PIPE:
     822       61138 :                                         close(descriptors[i].parentend);
     823             :                                         break;
     824             :                         }
     825       61252 :                         if (dup2(descriptors[i].childend, descriptors[i].index) < 0)
     826           0 :                                 perror("dup2");
     827       61252 :                         if (descriptors[i].childend != descriptors[i].index)
     828       61252 :                                 close(descriptors[i].childend);
     829             :                 }
     830             : 
     831             : #if PHP_CAN_DO_PTS
     832             :                 if (dev_ptmx >= 0) {
     833             :                         close(dev_ptmx);
     834             :                         close(slave_pty);
     835             :                 }
     836             : #endif
     837             : 
     838           0 :                 if (cwd) {
     839       20386 :                         php_ignore_value(chdir(cwd));
     840             :                 }
     841             : 
     842           0 :                 if (env.envarray) {
     843           0 :                         execle("/bin/sh", "sh", "-c", command, NULL, env.envarray);
     844             :                 } else {
     845           0 :                         execl("/bin/sh", "sh", "-c", command, NULL);
     846             :                 }
     847           0 :                 _exit(127);
     848             : 
     849       20421 :         } else if (child < 0) {
     850             :                 /* failed to fork() */
     851             : 
     852             :                 /* clean up all the descriptors */
     853           0 :                 for (i = 0; i < ndesc; i++) {
     854           0 :                         close(descriptors[i].childend);
     855           0 :                         if (descriptors[i].parentend)
     856           0 :                                 close(descriptors[i].parentend);
     857             :                 }
     858             : 
     859           0 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "fork failed - %s", strerror(errno));
     860             : 
     861           0 :                 goto exit_fail;
     862             : 
     863             :         }
     864             : #else
     865             : # error You lose (configure should not have let you get here)
     866             : #endif
     867             :         /* we forked/spawned and this is the parent */
     868             : 
     869       40842 :         proc = (struct php_process_handle*)pemalloc(sizeof(struct php_process_handle), is_persistent);
     870       20421 :         proc->is_persistent = is_persistent;
     871       20421 :         proc->command = command;
     872       20421 :         proc->npipes = ndesc;
     873       20421 :         proc->child = child;
     874             : #ifdef PHP_WIN32
     875             :         proc->childHandle = childHandle;
     876             : #endif
     877       20421 :         proc->env = env;
     878             : 
     879       20421 :         if (pipes != NULL) {
     880       20421 :                 zval_dtor(pipes);
     881             :         } 
     882             : 
     883       20421 :         array_init(pipes);
     884             : 
     885             : #if PHP_CAN_DO_PTS
     886             :         if (dev_ptmx >= 0) {
     887             :                 close(dev_ptmx);
     888             :                 close(slave_pty);
     889             :         }
     890             : #endif
     891             : 
     892             :         /* clean up all the child ends and then open streams on the parent
     893             :          * ends, where appropriate */
     894       81677 :         for (i = 0; i < ndesc; i++) {
     895       61256 :                 char *mode_string=NULL;
     896       61256 :                 php_stream *stream = NULL;
     897             : 
     898       61256 :                 close_descriptor(descriptors[i].childend);
     899             : 
     900       61256 :                 switch (descriptors[i].mode & ~DESC_PARENT_MODE_WRITE) {
     901             :                         case DESC_PIPE:
     902       61142 :                                 switch(descriptors[i].mode_flags) {
     903             : #ifdef PHP_WIN32
     904             :                                         case O_WRONLY|O_BINARY:
     905             :                                                 mode_string = "wb";
     906             :                                                 break;
     907             :                                         case O_RDONLY|O_BINARY:
     908             :                                                 mode_string = "rb";
     909             :                                                 break;
     910             : #endif
     911             :                                         case O_WRONLY:
     912       20393 :                                                 mode_string = "w";
     913       20393 :                                                 break;
     914             :                                         case O_RDONLY:
     915       40749 :                                                 mode_string = "r";
     916       40749 :                                                 break;
     917             :                                         case O_RDWR:
     918           0 :                                                 mode_string = "r+";
     919             :                                                 break;
     920             :                                 }
     921             : #ifdef PHP_WIN32
     922             :                                 stream = php_stream_fopen_from_fd(_open_osfhandle((zend_intptr_t)descriptors[i].parentend,
     923             :                                                         descriptors[i].mode_flags), mode_string, NULL);
     924             : #else
     925       61142 :                                 stream = php_stream_fopen_from_fd(descriptors[i].parentend, mode_string, NULL);
     926             : # if defined(F_SETFD) && defined(FD_CLOEXEC)
     927             :                                 /* mark the descriptor close-on-exec, so that it won't be inherited by potential other children */
     928       61142 :                                 fcntl(descriptors[i].parentend, F_SETFD, FD_CLOEXEC);
     929             : # endif
     930             : #endif
     931       61142 :                                 if (stream) {
     932             :                                         zval retfp;
     933             : 
     934             :                                         /* nasty hack; don't copy it */
     935       61142 :                                         stream->flags |= PHP_STREAM_FLAG_NO_SEEK;
     936             : 
     937       61142 :                                         php_stream_to_zval(stream, &retfp);
     938       61142 :                                         add_index_zval(pipes, descriptors[i].index, &retfp);
     939             : 
     940       61142 :                                         proc->pipes[i] = Z_RES(retfp);
     941             :                                         Z_ADDREF(retfp);
     942             :                                 }
     943       61142 :                                 break;
     944             :                         default:
     945         114 :                                 proc->pipes[i] = NULL;
     946             :                 }
     947             :         }
     948             : 
     949       20421 :         ZEND_REGISTER_RESOURCE(return_value, proc, le_proc_open);
     950       20421 :         return;
     951             : 
     952             : exit_fail:
     953           0 :         _php_free_envp(env, is_persistent);
     954           0 :         pefree(command, is_persistent);
     955             : #if PHP_CAN_DO_PTS
     956             :         if (dev_ptmx >= 0) {
     957             :                 close(dev_ptmx);
     958             :         }
     959             :         if (slave_pty >= 0) {
     960             :                 close(slave_pty);
     961             :         }
     962             : #endif
     963           0 :         RETURN_FALSE;
     964             : 
     965             : }
     966             : /* }}} */
     967             : 
     968             : #endif /* PHP_CAN_SUPPORT_PROC_OPEN */
     969             : 
     970             : /*
     971             :  * Local variables:
     972             :  * tab-width: 4
     973             :  * c-basic-offset: 4
     974             :  * End:
     975             :  * vim600: sw=4 ts=4 fdm=marker
     976             :  * vim<600: sw=4 ts=4
     977             :  */

Generated by: LCOV version 1.10

Generated at Sat, 22 Nov 2014 23:01:26 +0000 (27 hours ago)

Copyright © 2005-2014 The PHP Group
All rights reserved.