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 - exec.c (source / functions) Hit Total Coverage
Test: PHP Code Coverage Lines: 155 192 80.7 %
Date: 2014-04-08 Functions: 11 11 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*
       2             :    +----------------------------------------------------------------------+
       3             :    | PHP Version 5                                                        |
       4             :    +----------------------------------------------------------------------+
       5             :    | Copyright (c) 1997-2013 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: Rasmus Lerdorf <rasmus@php.net>                              |
      16             :    |         Ilia Alshanetsky <iliaa@php.net>                             |
      17             :    +----------------------------------------------------------------------+
      18             :  */
      19             : /* $Id$ */
      20             : 
      21             : #include <stdio.h>
      22             : #include "php.h"
      23             : #include <ctype.h>
      24             : #include "php_string.h"
      25             : #include "safe_mode.h"
      26             : #include "ext/standard/head.h"
      27             : #include "ext/standard/file.h"
      28             : #include "basic_functions.h"
      29             : #include "exec.h"
      30             : #include "php_globals.h"
      31             : #include "SAPI.h"
      32             : 
      33             : #if HAVE_SYS_WAIT_H
      34             : #include <sys/wait.h>
      35             : #endif
      36             : #if HAVE_SIGNAL_H
      37             : #include <signal.h>
      38             : #endif
      39             : 
      40             : #if HAVE_SYS_TYPES_H
      41             : #include <sys/types.h>
      42             : #endif
      43             : #if HAVE_SYS_STAT_H
      44             : #include <sys/stat.h>
      45             : #endif
      46             : #if HAVE_FCNTL_H
      47             : #include <fcntl.h>
      48             : #endif
      49             : 
      50             : #if HAVE_NICE && HAVE_UNISTD_H
      51             : #include <unistd.h>
      52             : #endif
      53             : 
      54             : /* {{{ php_exec
      55             :  * If type==0, only last line of output is returned (exec)
      56             :  * If type==1, all lines will be printed and last lined returned (system)
      57             :  * If type==2, all lines will be saved to given array (exec with &$array)
      58             :  * If type==3, output will be printed binary, no lines will be saved or returned (passthru)
      59             :  *
      60             :  */
      61          27 : PHPAPI int php_exec(int type, char *cmd, zval *array, zval *return_value TSRMLS_DC)
      62             : {
      63             :         FILE *fp;
      64          27 :         char *buf, *tmp=NULL;
      65          27 :         int l = 0, pclose_return;
      66          27 :         char *cmd_p, *b, *c, *d=NULL;
      67             :         php_stream *stream;
      68          27 :         size_t buflen, bufl = 0;
      69             : #if PHP_SIGCHILD
      70             :         void (*sig_handler)() = NULL;
      71             : #endif
      72             : 
      73          27 :         if (PG(safe_mode)) {
      74           0 :                 if ((c = strchr(cmd, ' '))) {
      75           0 :                         *c = '\0';
      76           0 :                         c++;
      77             :                 }
      78           0 :                 if (strstr(cmd, "..")) {
      79           0 :                         php_error_docref(NULL TSRMLS_CC, E_WARNING, "No '..' components allowed in path");
      80           0 :                         goto err;
      81             :                 }
      82             :                 
      83           0 :                 b = strrchr(cmd, PHP_DIR_SEPARATOR);
      84             : 
      85             : #ifdef PHP_WIN32
      86             :                 if (b && *b == '\\' && b == cmd) {
      87             :                         php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid absolute path.");
      88             :                         goto err;
      89             :                 }
      90             : #endif
      91             : 
      92           0 :                 spprintf(&d, 0, "%s%s%s%s%s", PG(safe_mode_exec_dir), (b ? "" : "/"), (b ? b : cmd), (c ? " " : ""), (c ? c : ""));
      93           0 :                 if (c) {
      94           0 :                         *(c - 1) = ' ';
      95             :                 }
      96           0 :                 cmd_p = php_escape_shell_cmd(d);
      97           0 :                 efree(d);
      98           0 :                 d = cmd_p;
      99             :         } else {
     100          27 :                 cmd_p = cmd;
     101             :         }
     102             : 
     103             : #if PHP_SIGCHILD
     104             :         sig_handler = signal (SIGCHLD, SIG_DFL);
     105             : #endif
     106             : 
     107             : #ifdef PHP_WIN32
     108             :         fp = VCWD_POPEN(cmd_p, "rb");
     109             : #else
     110          27 :         fp = VCWD_POPEN(cmd_p, "r");
     111             : #endif
     112          27 :         if (!fp) {
     113           0 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to fork [%s]", cmd);
     114           0 :                 goto err;
     115             :         }
     116             : 
     117          27 :         stream = php_stream_fopen_from_pipe(fp, "rb");
     118             : 
     119          27 :         buf = (char *) emalloc(EXEC_INPUT_BUF);
     120          27 :         buflen = EXEC_INPUT_BUF;
     121             : 
     122          27 :         if (type != 3) {
     123          13 :                 b = buf;
     124             :                 
     125        3735 :                 while (php_stream_get_line(stream, b, EXEC_INPUT_BUF, &bufl)) {
     126             :                         /* no new line found, let's read some more */
     127        3709 :                         if (b[bufl - 1] != '\n' && !php_stream_eof(stream)) {
     128          14 :                                 if (buflen < (bufl + (b - buf) + EXEC_INPUT_BUF)) {
     129          10 :                                         bufl += b - buf;
     130          10 :                                         buflen = bufl + EXEC_INPUT_BUF;
     131          10 :                                         buf = erealloc(buf, buflen);
     132          10 :                                         b = buf + bufl;
     133             :                                 } else {
     134           4 :                                         b += bufl;
     135             :                                 }
     136          14 :                                 continue;
     137        3695 :                         } else if (b != buf) {
     138           5 :                                 bufl += b - buf;
     139             :                         }
     140             : 
     141        3695 :                         if (type == 1) {
     142        3678 :                                 PHPWRITE(buf, bufl);
     143        3678 :                                 if (OG(ob_nesting_level) < 1) {
     144           3 :                                         sapi_flush(TSRMLS_C);
     145             :                                 }
     146          17 :                         } else if (type == 2) {
     147             :                                 /* strip trailing whitespaces */
     148          17 :                                 l = bufl;
     149          33 :                                 while (l-- && isspace(((unsigned char *)buf)[l]));
     150          17 :                                 if (l != (int)(bufl - 1)) {
     151          16 :                                         bufl = l + 1;
     152          16 :                                         buf[bufl] = '\0';
     153             :                                 }
     154          17 :                                 add_next_index_stringl(array, buf, bufl, 1);
     155             :                         }
     156        3695 :                         b = buf;
     157             :                 }
     158          13 :                 if (bufl) {
     159             :                         /* strip trailing whitespaces if we have not done so already */
     160          11 :                         if ((type == 2 && buf != b) || type != 2) {
     161           6 :                                 l = bufl;
     162          12 :                                 while (l-- && isspace(((unsigned char *)buf)[l]));
     163           6 :                                 if (l != (int)(bufl - 1)) {
     164           6 :                                         bufl = l + 1;
     165           6 :                                         buf[bufl] = '\0';
     166             :                                 }
     167           6 :                                 if (type == 2) {
     168           0 :                                         add_next_index_stringl(array, buf, bufl, 1);
     169             :                                 }
     170             :                         }
     171             : 
     172             :                         /* Return last line from the shell command */
     173          11 :                         if (PG(magic_quotes_runtime)) {
     174             :                                 int len;
     175             : 
     176           0 :                                 tmp = php_addslashes(buf, bufl, &len, 0 TSRMLS_CC);
     177           0 :                                 RETVAL_STRINGL(tmp, len, 0);
     178             :                         } else {
     179          11 :                                 RETVAL_STRINGL(buf, bufl, 1);
     180             :                         }
     181             :                 } else { /* should return NULL, but for BC we return "" */
     182           2 :                         RETVAL_EMPTY_STRING();
     183             :                 }
     184             :         } else {
     185        8339 :                 while((bufl = php_stream_read(stream, buf, EXEC_INPUT_BUF)) > 0) {
     186        8311 :                         PHPWRITE(buf, bufl);
     187             :                 }
     188             :         }
     189             : 
     190          27 :         pclose_return = php_stream_close(stream);
     191          27 :         efree(buf);
     192             : 
     193             : done:
     194             : #if PHP_SIGCHILD
     195             :         if (sig_handler) {
     196             :                 signal(SIGCHLD, sig_handler);
     197             :         }
     198             : #endif
     199          27 :         if (d) {
     200           0 :                 efree(d);
     201             :         }
     202          27 :         return pclose_return;
     203             : err:
     204           0 :         pclose_return = -1;
     205           0 :         goto done;
     206             : }
     207             : /* }}} */
     208             : 
     209          27 : static void php_exec_ex(INTERNAL_FUNCTION_PARAMETERS, int mode) /* {{{ */
     210             : {
     211             :         char *cmd;
     212             :         int cmd_len;
     213          27 :         zval *ret_code=NULL, *ret_array=NULL;
     214             :         int ret;
     215             : 
     216          27 :         if (mode) {
     217          20 :                 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|z/", &cmd, &cmd_len, &ret_code) == FAILURE) {
     218           0 :                         RETURN_FALSE;
     219             :                 }
     220             :         } else {
     221           7 :                 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|z/z/", &cmd, &cmd_len, &ret_array, &ret_code) == FAILURE) {
     222           0 :                         RETURN_FALSE;
     223             :                 }
     224             :         }
     225          27 :         if (!cmd_len) {
     226           0 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Cannot execute a blank command");
     227           0 :                 RETURN_FALSE;
     228             :         }
     229             : 
     230          27 :         if (!ret_array) {
     231          22 :                 ret = php_exec(mode, cmd, NULL, return_value TSRMLS_CC);
     232             :         } else {
     233           5 :                 if (Z_TYPE_P(ret_array) != IS_ARRAY) {
     234           3 :                         zval_dtor(ret_array);
     235           3 :                         array_init(ret_array);
     236             :                 }
     237           5 :                 ret = php_exec(2, cmd, ret_array, return_value TSRMLS_CC);
     238             :         }
     239          27 :         if (ret_code) {
     240           2 :                 zval_dtor(ret_code);
     241           2 :                 ZVAL_LONG(ret_code, ret);
     242             :         }
     243             : }
     244             : /* }}} */
     245             : 
     246             : /* {{{ proto string exec(string command [, array &output [, int &return_value]])
     247             :    Execute an external program */
     248           7 : PHP_FUNCTION(exec)
     249             : {
     250           7 :         php_exec_ex(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0);
     251           7 : }
     252             : /* }}} */
     253             : 
     254             : /* {{{ proto int system(string command [, int &return_value])
     255             :    Execute an external program and display output */
     256           6 : PHP_FUNCTION(system)
     257             : {
     258           6 :         php_exec_ex(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1);
     259           6 : }
     260             : /* }}} */
     261             : 
     262             : /* {{{ proto void passthru(string command [, int &return_value])
     263             :    Execute an external program and display raw output */
     264          14 : PHP_FUNCTION(passthru)
     265             : {
     266          14 :         php_exec_ex(INTERNAL_FUNCTION_PARAM_PASSTHRU, 3);
     267          14 : }
     268             : /* }}} */
     269             : 
     270             : /* {{{ php_escape_shell_cmd
     271             :    Escape all chars that could possibly be used to
     272             :    break out of a shell command
     273             : 
     274             :    This function emalloc's a string and returns the pointer.
     275             :    Remember to efree it when done with it.
     276             : 
     277             :    *NOT* safe for binary strings
     278             : */
     279          15 : PHPAPI char *php_escape_shell_cmd(char *str)
     280             : {
     281          15 :         register int x, y, l = strlen(str);
     282             :         char *cmd;
     283          15 :         char *p = NULL;
     284          15 :         size_t estimate = (2 * l) + 1;
     285             : 
     286             :         TSRMLS_FETCH();
     287             : 
     288          15 :         cmd = safe_emalloc(2, l, 1);
     289             : 
     290         484 :         for (x = 0, y = 0; x < l; x++) {
     291         469 :                 int mb_len = php_mblen(str + x, (l - x));
     292             : 
     293             :                 /* skip non-valid multibyte characters */
     294         469 :                 if (mb_len < 0) {
     295           0 :                         continue;
     296         469 :                 } else if (mb_len > 1) {
     297           5 :                         memcpy(cmd + y, str + x, mb_len);
     298           5 :                         y += mb_len;
     299           5 :                         x += mb_len - 1;
     300           5 :                         continue;
     301             :                 }
     302             : 
     303         464 :                 switch (str[x]) {
     304             : #ifndef PHP_WIN32
     305             :                         case '"':
     306             :                         case '\'':
     307           2 :                                 if (!p && (p = memchr(str + x + 1, str[x], l - x - 1))) {
     308             :                                         /* noop */
     309           2 :                                 } else if (p && *p == str[x]) {
     310           1 :                                         p = NULL;
     311             :                                 } else {
     312           0 :                                         cmd[y++] = '\\';
     313             :                                 }
     314           2 :                                 cmd[y++] = str[x];
     315           2 :                                 break;
     316             : #else
     317             :                         /* % is Windows specific for enviromental variables, ^%PATH% will 
     318             :                                 output PATH whil ^%PATH^% not. escapeshellcmd will escape all %.
     319             :                         */
     320             :                         case '%':
     321             :                         case '"':
     322             :                         case '\'':
     323             : #endif
     324             :                         case '#': /* This is character-set independent */
     325             :                         case '&':
     326             :                         case ';':
     327             :                         case '`':
     328             :                         case '|':
     329             :                         case '*':
     330             :                         case '?':
     331             :                         case '~':
     332             :                         case '<':
     333             :                         case '>':
     334             :                         case '^':
     335             :                         case '(':
     336             :                         case ')':
     337             :                         case '[':
     338             :                         case ']':
     339             :                         case '{':
     340             :                         case '}':
     341             :                         case '$':
     342             :                         case '\\':
     343             :                         case '\x0A': /* excluding these two */
     344             :                         case '\xFF':
     345             : #ifdef PHP_WIN32
     346             :                                 cmd[y++] = '^';
     347             : #else
     348           6 :                                 cmd[y++] = '\\';
     349             : #endif
     350             :                                 /* fall-through */
     351             :                         default:
     352         462 :                                 cmd[y++] = str[x];
     353             : 
     354             :                 }
     355             :         }
     356          15 :         cmd[y] = '\0';
     357             : 
     358          15 :         if ((estimate - y) > 4096) {
     359             :                 /* realloc if the estimate was way overill
     360             :                  * Arbitrary cutoff point of 4096 */
     361           0 :                 cmd = erealloc(cmd, y + 1);
     362             :         }
     363             : 
     364          15 :         return cmd;
     365             : }
     366             : /* }}} */
     367             : 
     368             : /* {{{ php_escape_shell_arg
     369             :  */
     370          44 : PHPAPI char *php_escape_shell_arg(char *str)
     371             : {
     372          44 :         int x, y = 0, l = strlen(str);
     373             :         char *cmd;
     374          44 :         size_t estimate = (4 * l) + 3;
     375             : 
     376             :         TSRMLS_FETCH();
     377             : 
     378          44 :         cmd = safe_emalloc(4, l, 3); /* worst case */
     379             : 
     380             : #ifdef PHP_WIN32
     381             :         cmd[y++] = '"';
     382             : #else
     383          44 :         cmd[y++] = '\'';
     384             : #endif
     385             : 
     386         679 :         for (x = 0; x < l; x++) {
     387         635 :                 int mb_len = php_mblen(str + x, (l - x));
     388             : 
     389             :                 /* skip non-valid multibyte characters */
     390         635 :                 if (mb_len < 0) {
     391           0 :                         continue;
     392         635 :                 } else if (mb_len > 1) {
     393           4 :                         memcpy(cmd + y, str + x, mb_len);
     394           4 :                         y += mb_len;
     395           4 :                         x += mb_len - 1;
     396           4 :                         continue;
     397             :                 }
     398             : 
     399         631 :                 switch (str[x]) {
     400             : #ifdef PHP_WIN32
     401             :                 case '"':
     402             :                 case '%':
     403             :                         cmd[y++] = ' ';
     404             :                         break;
     405             : #else
     406             :                 case '\'':
     407           7 :                         cmd[y++] = '\'';
     408           7 :                         cmd[y++] = '\\';
     409           7 :                         cmd[y++] = '\'';
     410             : #endif
     411             :                         /* fall-through */
     412             :                 default:
     413         631 :                         cmd[y++] = str[x];
     414             :                 }
     415             :         }
     416             : #ifdef PHP_WIN32
     417             :         cmd[y++] = '"';
     418             : #else
     419          44 :         cmd[y++] = '\'';
     420             : #endif
     421          44 :         cmd[y] = '\0';
     422             : 
     423          44 :         if ((estimate - y) > 4096) {
     424             :                 /* realloc if the estimate was way overill
     425             :                  * Arbitrary cutoff point of 4096 */
     426           0 :                 cmd = erealloc(cmd, y + 1);
     427             :         }
     428          44 :         return cmd;
     429             : }
     430             : /* }}} */
     431             : 
     432             : /* {{{ proto string escapeshellcmd(string command)
     433             :    Escape shell metacharacters */
     434          13 : PHP_FUNCTION(escapeshellcmd)
     435             : {
     436             :         char *command;
     437             :         int command_len;
     438          13 :         char *cmd = NULL;
     439             : 
     440          13 :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &command, &command_len) == FAILURE) {
     441           0 :                 return;
     442             :         }
     443             : 
     444          13 :         if (command_len) {
     445          13 :                 cmd = php_escape_shell_cmd(command);
     446          13 :                 RETVAL_STRING(cmd, 0);
     447             :         } else {
     448           0 :                 RETVAL_EMPTY_STRING();
     449             :         }
     450             : }
     451             : /* }}} */
     452             : 
     453             : /* {{{ proto string escapeshellarg(string arg)
     454             :    Quote and escape an argument for use in a shell command */
     455          49 : PHP_FUNCTION(escapeshellarg)
     456             : {
     457             :         char *argument;
     458             :         int argument_len;
     459          49 :         char *cmd = NULL;
     460             : 
     461          49 :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &argument, &argument_len) == FAILURE) {
     462           5 :                 return;
     463             :         }
     464             : 
     465          44 :         if (argument) {
     466          44 :                 cmd = php_escape_shell_arg(argument);
     467          44 :                 RETVAL_STRING(cmd, 0);
     468             :         }
     469             : }
     470             : /* }}} */
     471             : 
     472             : /* {{{ proto string shell_exec(string cmd)
     473             :    Execute command via shell and return complete output as string */
     474         112 : PHP_FUNCTION(shell_exec)
     475             : {
     476             :         FILE *in;
     477             :         size_t total_readbytes;
     478             :         char *command;
     479             :         int command_len;
     480             :         char *ret;
     481             :         php_stream *stream;
     482             : 
     483         112 :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &command, &command_len) == FAILURE) {
     484           0 :                 return;
     485             :         }
     486             : 
     487         112 :         if (PG(safe_mode)) {
     488           0 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Cannot execute using backquotes in Safe Mode");
     489           0 :                 RETURN_FALSE;
     490             :         }
     491             : 
     492             : #ifdef PHP_WIN32
     493             :         if ((in=VCWD_POPEN(command, "rt"))==NULL) {
     494             : #else
     495         112 :         if ((in=VCWD_POPEN(command, "r"))==NULL) {
     496             : #endif
     497           0 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to execute '%s'", command);
     498           0 :                 RETURN_FALSE;
     499             :         }
     500             : 
     501         112 :         stream = php_stream_fopen_from_pipe(in, "rb");
     502         112 :         total_readbytes = php_stream_copy_to_mem(stream, &ret, PHP_STREAM_COPY_ALL, 0);
     503         112 :         php_stream_close(stream);
     504             : 
     505         112 :         if (total_readbytes > 0) {
     506          98 :                 RETVAL_STRINGL(ret, total_readbytes, 0);
     507             :         }
     508             : }
     509             : /* }}} */
     510             : 
     511             : #ifdef HAVE_NICE
     512             : /* {{{ proto bool proc_nice(int priority)
     513             :    Change the priority of the current process */
     514          25 : PHP_FUNCTION(proc_nice)
     515             : {
     516             :         long pri;
     517             : 
     518          25 :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &pri) == FAILURE) {
     519          12 :                 RETURN_FALSE;
     520             :         }
     521             : 
     522          13 :         errno = 0;
     523          13 :         nice(pri);
     524          13 :         if (errno) {
     525           1 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Only a super user may attempt to increase the priority of a process");
     526           1 :                 RETURN_FALSE;
     527             :         }
     528             : 
     529          12 :         RETURN_TRUE;
     530             : }
     531             : /* }}} */
     532             : #endif
     533             : 
     534             : /*
     535             :  * Local variables:
     536             :  * tab-width: 4
     537             :  * c-basic-offset: 4
     538             :  * End:
     539             :  * vim600: sw=4 ts=4 fdm=marker
     540             :  * vim<600: sw=4 ts=4
     541             :  */

Generated by: LCOV version 1.10

Generated at Tue, 08 Apr 2014 11:59:47 +0000 (9 days ago)

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