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