GNUsocial
/
gnu-social
4
0
Fork 1
Code Issues Releases Wiki Activity

[CORE] Remove PEAR Command as it is not used

This commit is contained in:
Diogo Cordeiro 2019-06-23 18:19:31 +01:00
parent b408208e4c
commit 966b00617e
1 changed files with 0 additions and 587 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

587
extlib/System/Command.php
View File

@ -1,587 +0,0 @@
<?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);
}
}
// }}}
}
?>