+++ /dev/null
-<?php
-// {{{ license
-
-// +----------------------------------------------------------------------+
-// | PHP Version 4.0 |
-// +----------------------------------------------------------------------+
-// | Copyright (c) 1997-2003 The PHP Group |
-// +----------------------------------------------------------------------+
-// | This source file is subject to version 2.02 of the PHP license, |
-// | that is bundled with this package in the file LICENSE, and is |
-// | available at through the world-wide-web at |
-// | http://www.php.net/license/2_02.txt. |
-// | If you did not receive a copy of the PHP license and are unable to |
-// | obtain it through the world-wide-web, please send a note to |
-// | license@php.net so we can mail you a copy immediately. |
-// +----------------------------------------------------------------------+
-// | Author: Anders Johannsen <anders@johannsen.com> |
-// | Author: Dan Allen <dan@mojavelinux.com>
-// +----------------------------------------------------------------------+
-
-// $Id: Command.php,v 1.9 2007/04/20 21:08:48 cconstantine Exp $
-
-// }}}
-// {{{ includes
-
-require_once 'PEAR.php';
-require_once 'System.php';
-
-// }}}
-// {{{ constants
-
-define('SYSTEM_COMMAND_OK', 1);
-define('SYSTEM_COMMAND_ERROR', -1);
-define('SYSTEM_COMMAND_NO_SHELL', -2);
-define('SYSTEM_COMMAND_INVALID_SHELL', -3);
-define('SYSTEM_COMMAND_TMPDIR_ERROR', -4);
-define('SYSTEM_COMMAND_INVALID_OPERATOR', -5);
-define('SYSTEM_COMMAND_INVALID_COMMAND', -6);
-define('SYSTEM_COMMAND_OPERATOR_PLACEMENT',-7);
-define('SYSTEM_COMMAND_COMMAND_PLACEMENT', -8);
-define('SYSTEM_COMMAND_NOHUP_MISSING', -9);
-define('SYSTEM_COMMAND_NO_OUTPUT', -10);
-define('SYSTEM_COMMAND_STDERR', -11);
-define('SYSTEM_COMMAND_NONZERO_EXIT', -12);
-
-// }}}
-
-// {{{ class System_Command
-
-/**
- * The System_Command:: class implements an abstraction for various ways
- * of executing commands (directly using the backtick operator,
- * as a background task after the script has terminated using
- * register_shutdown_function() or as a detached process using nohup).
- *
- * @author Anders Johannsen <anders@johannsen.com>
- * @author Dan Allen <dan@mojavelinux.com>
- * @version $Revision: 1.9 $
- */
-
-// }}}
-class System_Command {
- // {{{ properties
-
- /**
- * Array of settings used when creating the shell command
- *
- * @var array
- * @access private
- */
- var $options = array();
-
- /**
- * Array of available shells to use to execute the command
- *
- * @var array
- * @access private
- */
- var $shells = array();
-
- /**
- * Array of available control operators used between commands
- *
- * @var array
- * @access private
- */
- var $controlOperators = array();
-
- /**
- * The system command to be executed
- *
- * @var string
- * @access private
- */
- var $systemCommand = null;
-
- /**
- * Previously added part to the command string
- *
- * @var string
- * @access private
- */
- var $previousElement = null;
-
- /**
- * Directory for writing stderr output
- *
- * @var string
- * @access private
- */
- var $tmpDir = null;
-
- /**
- * To allow the pear error object to accumulate when building
- * the command, we use the command status to keep track when
- * a pear error is raised
- *
- * @var int
- * @access private
- */
- var $commandStatus = 0;
-
- /**
- * Hold initialization PEAR_Error
- *
- * @var object
- * @access private
- **/
- var $_initError = null;
-
- // }}}
- // {{{ constructor
-
- /**
- * Class constructor
- *
- * Defines all necessary constants and sets defaults
- *
- * @access public
- */
- function System_Command($in_shell = null)
- {
- // Defining constants
- $this->options = array(
- 'SEQUENCE' => true,
- 'SHUTDOWN' => false,
- 'SHELL' => $this->which($in_shell),
- 'OUTPUT' => true,
- 'NOHUP' => false,
- 'BACKGROUND' => false,
- 'STDERR' => false
- );
-
- // prepare the available control operators
- $this->controlOperators = array(
- 'PIPE' => '|',
- 'AND' => '&&',
- 'OR' => '||',
- 'GROUP' => ';',
- 'LFIFO' => '<',
- 'RFIFO' => '>',
- );
-
- // List of allowed/available shells
- $this->shells = array(
- 'sh',
- 'bash',
- 'zsh',
- 'tcsh',
- 'csh',
- 'ash',
- 'sash',
- 'esh',
- 'ksh'
- );
-
- // Find the first available shell
- if (empty($this->options['SHELL'])) {
- foreach ($this->shells as $shell) {
- if ($this->options['SHELL'] = $this->which($shell)) {
- break;
- }
- }
-
- // see if we still have no shell
- if (empty($this->options['SHELL'])) {
- $this->_initError =& PEAR::raiseError(null, SYSTEM_COMMAND_NO_SHELL, null, E_USER_WARNING, null, 'System_Command_Error', true);
- return;
- }
- }
-
- // Caputre a temporary directory for capturing stderr from commands
- $this->tmpDir = System::tmpdir();
- if (!System::mkDir("-p {$this->tmpDir}")) {
- $this->_initError =& PEAR::raiseError(null, SYSTEM_COMMAND_TMPDIR_ERROR, null, E_USER_WARNING, null, 'System_Command_Error', true);
- return;
- }
- }
-
- // }}}
- // {{{ setOption()
-
- /**
- * Sets the value for an option. Each option should be set to true
- * or false; except the 'SHELL' option which should be a string
- * naming a shell. The options are:
- *
- * 'SEQUENCE' Allow a sequence command or not (right now this is always on);
- *
- * 'SHUTDOWN' Execute commands via a shutdown function;
- *
- * 'SHELL' Path to shell;
- *
- * 'OUTPUT' Output stdout from process;
- *
- * 'NOHUP' Use nohup to detach process;
- *
- * 'BACKGROUND' Run as a background process with &;
- *
- * 'STDERR' Output on stderr will raise an error, even if
- * the command's exit value is zero. The output from
- * stderr can be retrieved using the getDebugInfo()
- * method of the Pear_ERROR object returned by
- * execute().;
- *
- * @param string $in_option is a case-sensitive string,
- * corresponding to the option
- * that should be changed
- * @param mixed $in_setting is the new value for the option
- * @access public
- * @return bool true if succes, else false
- */
- function setOption($in_option, $in_setting)
- {
- if ($this->_initError) {
- return $this->_initError;
- }
-
- $option = strtoupper($in_option);
-
- if (!isset($this->options[$option])) {
- PEAR::raiseError(null, SYSTEM_COMMAND_ERROR, null, E_USER_NOTICE, null, 'System_Command_Error', true);
- return false;
- }
-
- switch ($option) {
- case 'OUTPUT':
- case 'SHUTDOWN':
- case 'SEQUENCE':
- case 'BACKGROUND':
- case 'STDERR':
- $this->options[$option] = !empty($in_setting);
- return true;
- break;
-
- case 'SHELL':
- if (($shell = $this->which($in_setting)) !== false) {
- $this->options[$option] = $shell;
- return true;
- }
- else {
- PEAR::raiseError(null, SYSTEM_COMMAND_NO_SHELL, null, E_USER_NOTICE, $in_setting, 'System_Command_Error', true);
- return false;
- }
- break;
-
- case 'NOHUP':
- if (empty($in_setting)) {
- $this->options[$option] = false;
- }
- else if ($location = $this->which('nohup')) {
- $this->options[$option] = $location;
- }
- else {
- PEAR::raiseError(null, SYSTEM_COMMAND_NOHUP_MISSING, null, E_USER_NOTICE, null, 'System_Command_Error', true);
- return false;
- }
- break;
- }
- }
-
- // }}}
- // {{{ pushCommand()
-
- /**
- * Used to push a command onto the running command to be executed
- *
- * @param string $in_command binary to be run
- * @param string $in_argument either an option or argument value, to be handled appropriately
- * @param string $in_argument
- * @param ...
- *
- * @access public
- * @return boolean true on success {or System_Command_Error Exception}
- */
- function pushCommand($in_command)
- {
- if ($this->_initError) {
- return $this->_initError;
- }
-
- if (!is_null($this->previousElement) && !in_array($this->previousElement, $this->controlOperators)) {
- $this->commandStatus = -1;
- $error = PEAR::raiseError(null, SYSTEM_COMMAND_COMMAND_PLACEMENT, null, E_USER_WARNING, null, 'System_Command_Error', true);
- }
-
- // check for error here
- $command = escapeshellcmd($this->which($in_command));
- if ($command === false) {
- $error = PEAR::raiseError(null, SYSTEM_COMMAND_INVALID_COMMAND, null, E_USER_WARNING, null, 'System_Command_Error', true);
- }
-
- $argv = func_get_args();
- array_shift($argv);
- foreach($argv as $arg) {
- if (strpos($arg, '-') === 0) {
- $command .= ' ' . $arg;
- }
- elseif ($arg != '') {
- $command .= ' ' . escapeshellarg($arg);
- }
- }
-
- $this->previousElement = $command;
- $this->systemCommand .= $command;
-
- return isset($error) ? $error : true;
- }
-
- // }}}
- // {{{ pushOperator()
-
- /**
- * Used to push an operator onto the running command to be executed
- *
- * @param string $in_operator Either string reprentation of operator or system character
- *
- * @access public
- * @return boolean true on success {or System_Command_Error Exception}
- */
- function pushOperator($in_operator)
- {
- if ($this->_initError) {
- return $this->_initError;
- }
-
- $operator = isset($this->controlOperators[$in_operator]) ? $this->controlOperators[$in_operator] : $in_operator;
-
- if (is_null($this->previousElement) || in_array($this->previousElement, $this->controlOperators)) {
- $this->commandStatus = -1;
- $error = PEAR::raiseError(null, SYSTEM_COMMAND_OPERATOR_PLACEMENT, null, E_USER_WARNING, null, 'System_Command_Error', true);
- }
- elseif (!in_array($operator, $this->controlOperators)) {
- $this->commandStatus = -1;
- $error = PEAR::raiseError(null, SYSTEM_COMMAND_INVALID_OPERATOR, null, E_USER_WARNING, $operator, 'System_Command_Error', true);
- }
-
- $this->previousElement = $operator;
- $this->systemCommand .= ' ' . $operator . ' ';
- return isset($error) ? $error : true;
- }
-
- // }}}
- // {{{ execute()
-
- /**
- * Executes the code according to given options
- *
- * @return bool true if success {or System_Command_Exception}
- *
- * @access public
- */
- function execute()
- {
- if ($this->_initError) {
- return $this->_initError;
- }
-
- // if the command is empty or if the last element was a control operator, we can't continue
- if (is_null($this->previousElement) || $this->commandStatus == -1 || in_array($this->previousElement, $this->controlOperators)) {
- return PEAR::raiseError(null, SYSTEM_COMMAND_INVALID_COMMAND, null, E_USER_WARNING, $this->systemCommand, 'System_Command_Error', true);
- }
-
- // Warning about impossible mix of options
- if (!empty($this->options['OUTPUT'])) {
- if (!empty($this->options['SHUTDOWN']) || !empty($this->options['NOHUP'])) {
- return PEAR::raiseError(null, SYSTEM_COMMAND_NO_OUTPUT, null, E_USER_WARNING, null, 'System_Command_Error', true);
- }
- }
-
- // if this is not going to stdout, then redirect to /dev/null
- if (empty($this->options['OUTPUT'])) {
- $this->systemCommand .= ' >/dev/null';
- }
-
- $suffix = '';
- // run a command immune to hangups, with output to a non-tty
- if (!empty($this->options['NOHUP'])) {
- $this->systemCommand = $this->options['NOHUP'] . $this->systemCommand;
- }
- // run a background process (only if not nohup)
- elseif (!empty($this->options['BACKGROUND'])) {
- $suffix = ' &';
- }
-
- // Register to be run on shutdown
- if (!empty($this->options['SHUTDOWN'])) {
- $line = "system(\"{$this->systemCommand}$suffix\");";
- $function = create_function('', $line);
- register_shutdown_function($function);
- return true;
- }
- else {
- // send stderr to a file so that we can reap the error message
- $tmpFile = tempnam($this->tmpDir, 'System_Command-');
- $this->systemCommand .= ' 2>' . $tmpFile . $suffix;
- $shellPipe = $this->which('echo') . ' ' . escapeshellarg($this->systemCommand) . ' | ' . $this->options['SHELL'];
- exec($shellPipe, $result, $returnVal);
-
- if ($returnVal !== 0) {
- // command returned nonzero; that's always an error
- $return = PEAR::raiseError(null, SYSTEM_COMMAND_NONZERO_EXIT, null, E_USER_WARNING, null, 'System_Command_Error', true);
- }
- else if (!$this->options['STDERR']) {
- // caller does not care about stderr; return success
- $return = implode("\n", $result);
- }
- else {
- // our caller cares about stderr; check stderr output
- clearstatcache();
- if (filesize($tmpFile) > 0) {
- // the command actually wrote to stderr
- $stderr_output = file_get_contents($tmpFile);
- $return = PEAR::raiseError(null, SYSTEM_COMMAND_STDERR, null, E_USER_WARNING, $stderr_output, 'System_Command_Error', true);
- } else {
- // total success; return stdout gathered by exec()
- $return = implode("\n", $result);
- }
- }
-
- unlink($tmpFile);
- return $return;
- }
- }
-
- // }}}
- // {{{ which()
-
- /**
- * Functionality similiar to unix 'which'. Searches the path
- * for the specified program.
- *
- * @param $cmd name of the executable to search for
- *
- * @access private
- * @return string returns the full path if found, false if not
- */
- function which($in_cmd)
- {
- // only pass non-empty strings to System::which()
- if (!is_string($in_cmd) || '' === $in_cmd) {
- return(false);
- }
-
- // explicitly pass false as fallback value
- return System::which($in_cmd, false);
- }
-
- // }}}
- // {{{ reset()
-
- /**
- * Prepare for a new command to be built
- *
- * @access public
- * @return void
- */
- function reset()
- {
- $this->previousElement = null;
- $this->systemCommand = null;
- $this->commandStatus = 0;
- }
-
- // }}}
- // {{{ errorMessage()
-
- /**
- * Return a textual error message for a System_Command error code
- *
- * @param integer error code
- *
- * @return string error message, or false if the error code was
- * not recognized
- */
- function errorMessage($in_value)
- {
- static $errorMessages;
- if (!isset($errorMessages)) {
- $errorMessages = array(
- SYSTEM_COMMAND_OK => 'no error',
- SYSTEM_COMMAND_ERROR => 'unknown error',
- SYSTEM_COMMAND_NO_SHELL => 'no shell found',
- SYSTEM_COMMAND_INVALID_SHELL => 'invalid shell',
- SYSTEM_COMMAND_TMPDIR_ERROR => 'could not create temporary directory',
- SYSTEM_COMMAND_INVALID_OPERATOR => 'control operator invalid',
- SYSTEM_COMMAND_INVALID_COMMAND => 'invalid system command',
- SYSTEM_COMMAND_OPERATOR_PLACEMENT => 'invalid placement of control operator',
- SYSTEM_COMMAND_COMMAND_PLACEMENT => 'invalid placement of command',
- SYSTEM_COMMAND_NOHUP_MISSING => 'nohup not found on system',
- SYSTEM_COMMAND_NO_OUTPUT => 'output not allowed',
- SYSTEM_COMMAND_STDERR => 'command wrote to stderr',
- SYSTEM_COMMAND_NONZERO_EXIT => 'non-zero exit value from command',
- );
- }
-
- if (System_Command::isError($in_value)) {
- $in_value = $in_value->getCode();
- }
-
- return isset($errorMessages[$in_value]) ? $errorMessages[$in_value] : $errorMessages[SYSTEM_COMMAND_ERROR];
- }
-
- // }}}
- // {{{ isError()
-
- /**
- * Tell whether a result code from a System_Command method is an error
- *
- * @param int result code
- *
- * @return bool whether $in_value is an error
- *
- * @access public
- */
- function isError($in_value)
- {
- return (is_object($in_value) &&
- (strtolower(get_class($in_value)) == 'system_command_error' ||
- is_subclass_of($in_value, 'system_command_error')));
- }
-
- // }}}
-}
-
-// {{{ class System_Command_Error
-
-/**
- * System_Command_Error constructor.
- *
- * @param mixed System_Command error code, or string with error message.
- * @param integer what "error mode" to operate in
- * @param integer what error level to use for $mode & PEAR_ERROR_TRIGGER
- * @param mixed additional debug info, such as the last query
- *
- * @access public
- *
- * @see PEAR_Error
- */
-
-// }}}
-class System_Command_Error extends PEAR_Error
-{
- // {{{ properties
-
- /**
- * Message in front of the error message
- * @var string $error_message_prefix
- */
- var $error_message_prefix = 'System_Command Error: ';
-
- // }}}
- // {{{ constructor
-
- function System_Command_Error($code = SYSTEM_COMMAND_ERROR, $mode = PEAR_ERROR_RETURN,
- $level = E_USER_NOTICE, $debuginfo = null)
- {
- if (is_int($code)) {
- $this->PEAR_Error(System_Command::errorMessage($code), $code, $mode, $level, $debuginfo);
- } else {
- $this->PEAR_Error("Invalid error code: $code", SYSTEM_COMMAND_ERROR, $mode, $level, $debuginfo);
- }
- }
-
- // }}}
-}
-?>
projects / quix0rs-gnu-social.git / commitdiff