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

Generated by: LCOV version 1.10

Generated at Tue, 27 Sep 2016 10:26:09 +0000 (3 days ago)

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