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: 199 263 75.7 %
Date: 2014-04-19 Functions: 8 8 100.0 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.10

Generated at Sun, 20 Apr 2014 03:52:17 +0000 (4 days ago)

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