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: 146 171 85.4 %
Date: 2015-09-02 Functions: 11 11 100.0 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.10

Generated at Wed, 02 Sep 2015 17:19:19 +0000 (2 days ago)

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