Issues in PEAR.php (master) - Issues in master - mambax7/references - Measure and Improve Code Quality continuously with Scrutinizer

Issues (407)

Security Analysis not enabled

Cross-Site Scripting
Cross-Site Scripting enables an attacker to inject code into the response of a web-request that is viewed by other users. It can for example be used to bypass access controls, or even to take over other users' accounts.
File Exposure
File Exposure allows an attacker to gain access to local files that he should not be able to access. These files can for example include database credentials, or other configuration files.
File Manipulation
File Manipulation enables an attacker to write custom data to files. This potentially leads to injection of arbitrary code on the server.
Object Injection
Object Injection enables an attacker to inject an object into PHP code, and can lead to arbitrary code execution, file exposure, or file manipulation attacks.
Code Injection
Code Injection enables an attacker to execute arbitrary code on the server.
Response Splitting
Response Splitting can be used to send arbitrary responses.
File Inclusion
File Inclusion enables an attacker to inject custom files into PHP's file loading mechanism, either explicitly passed to include, or for example via PHP's auto-loading mechanism.
Command Injection
Command Injection enables an attacker to inject a shell command that is execute with the privileges of the web-server. This can be used to expose sensitive data, or gain access of your server.
SQL Injection
SQL Injection enables an attacker to execute arbitrary SQL code on your database server gaining access to user data, or manipulating user data.
XPath Injection
XPath Injection enables an attacker to modify the parts of XML document that are read. If that XML document is for example used for authentication, this can lead to further vulnerabilities similar to SQL Injection.
LDAP Injection
LDAP Injection enables an attacker to inject LDAP statements potentially granting permission to run unauthorized queries, or modify content inside the LDAP tree.
Header Injection
Other Vulnerability
This category comprises other attack vectors such as manipulating the PHP runtime, loading custom extensions, freezing the runtime, or similar.
Regex Injection
Regex Injection enables an attacker to execute arbitrary code in your PHP process.
XML Injection
XML Injection enables an attacker to read files on your local filesystem including configuration files, or can be abused to freeze your web-server process.
Variable Injection
Variable Injection enables an attacker to overwrite program variables with custom data, and can lead to further vulnerabilities.
Unfortunately, the security analysis is currently not available for your project. If you are a non-commercial open-source project, please contact support to gain access.
class/PEAR.php (1 issue)

Labels

Severity

Minor 1
Upgrade to new PHP Analysis Engine

These results are based on our legacy PHP analysis, consider migrating to our new PHP analysis engine instead. Learn more
<?php
/**
 * PEAR, the PHP Extension and Application Repository
 *
 * PEAR class and PEAR_Error class
 *
 * PHP versions 4 and 5
 *
 * LICENSE: This source file is subject to version 3.0 of the PHP license
 * that is available through the world-wide-web at the following URI:
 * http://www.php.net/license/3_0.txt.  If you did not receive a copy of
 * the PHP License and are unable to obtain it through the web, please
 * send a note to [email protected] so we can mail you a copy immediately.
 *
 * @category   pear
 * @package    PEAR
 * @author     Sterling Hughes <[email protected]>
 * @author     Stig Bakken <[email protected]>
 * @author     Tomas V.V.Cox <[email protected]>
 * @author     Greg Beaver <[email protected]>
 * @copyright  1997-2006 The PHP Group
 * @license    http://www.php.net/license/3_0.txt  PHP License 3.0
 * @version    CVS: $Id: PEAR.php 2 2010-01-23 20:04:25Z hthouzard $
 * @link       http://pear.php.net/package/PEAR
 * @since      File available since Release 0.1
 */

/**#@+
 * ERROR constants
 */
define('references_PEAR_ERROR_RETURN', 1);
define('references_PEAR_ERROR_PRINT', 2);
define('references_PEAR_ERROR_TRIGGER', 4);
define('references_PEAR_ERROR_DIE', 8);
define('references_PEAR_ERROR_CALLBACK', 16);
/**
 * WARNING: obsolete
 * @deprecated
 */
define('references_PEAR_ERROR_EXCEPTION', 32);
/**#@-*/
define('references_PEAR_ZE2', function_exists('version_compare')
                              && version_compare(zend_version(), '2-dev', 'ge'));

if (substr(PHP_OS, 0, 3) == 'WIN') {
    define('references_OS_WINDOWS', true);
    define('references_OS_UNIX', false);
    define('references_PEAR_OS', 'Windows');
} else {
    define('references_OS_WINDOWS', false);
    define('references_OS_UNIX', true);
    define('references_PEAR_OS', 'Unix'); // blatant assumption
}

// instant backwards compatibility
if (!defined('PATH_SEPARATOR')) {
    if (references_OS_WINDOWS) {
        define('PATH_SEPARATOR', ';');
    } else {
        define('PATH_SEPARATOR', ':');
    }
}

$GLOBALS['_PEAR_default_error_mode']     = references_PEAR_ERROR_RETURN;
$GLOBALS['_PEAR_default_error_options']  = E_USER_NOTICE;
$GLOBALS['_PEAR_destructor_object_list'] = array();
$GLOBALS['_PEAR_shutdown_funcs']         = array();
$GLOBALS['_PEAR_error_handler_stack']    = array();

@ini_set('track_errors', true);

/**
 * Base class for other PEAR classes.  Provides rudimentary
 * emulation of destructors.
 *
 * If you want a destructor in your class, inherit PEAR and make a
 * destructor method called _yourclassname (same name as the
 * constructor, but with a "_" prefix).  Also, in your constructor you
 * have to call the PEAR constructor: $this->PEAR();.
 * The destructor method will be called without parameters.  Note that
 * at in some SAPI implementations (such as Apache), any output during
 * the request shutdown (in which destructors are called) seems to be
 * discarded.  If you need to get any debug information from your
 * destructor, use error_log(), syslog() or something similar.
 *
 * IMPORTANT! To use the emulated destructors you need to create the
 * objects by reference: $obj =& new PEAR_child;
 *
 * @category    pear
 * @package     PEAR
 * @author      Stig Bakken <[email protected]>
 * @author      Tomas V.V. Cox <[email protected]>
 * @author      Greg Beaver <[email protected]>
 * @copyright   1997-2006 The PHP Group
 * @license     http://www.php.net/license/3_0.txt  PHP License 3.0
 * @version     Release: 1.5.4
 * @link        http://pear.php.net/package/PEAR
 * @see         PEAR_Error
 * @since       Class available since PHP 4.0.2
 * @link        http://pear.php.net/manual/en/core.pear.php#core.pear.pear
 */
class references_PEAR
{
    // {{{ properties

    /**
     * Whether to enable internal debug messages.
     *
     * @var bool
     * @access  private
     */
    public $_debug = false;

    /**
     * Default error mode for this object.
     *
     * @var int
     * @access  private
     */
    public $_default_error_mode = null;

    /**
     * Default error options used for this object when error mode
     * is references_PEAR_ERROR_TRIGGER.
     *
     * @var int
     * @access  private
     */
    public $_default_error_options = null;

    /**
     * Default error handler (callback) for this object, if error mode is
     * references_PEAR_ERROR_CALLBACK.
     *
     * @var string
     * @access  private
     */
    public $_default_error_handler = '';

    /**
     * Which class to use for error objects.
     *
     * @var string
     * @access  private
     */
    public $_error_class = 'PEAR_Error';

    /**
     * An array of expected errors.
     *
     * @var array
     * @access  private
     */
    public $_expected_errors = array();

    // }}}

    // {{{ constructor

    /**
     * Constructor.  Registers this object in
     * $_PEAR_destructor_object_list for destructor emulation if a
     * destructor object exists.
     *
     * @param  string $error_class (optional) which class to use for
     *                             error objects, defaults to PEAR_Error.
     * @access public
     */
    public function __construct($error_class = null)
    {
        $classname = strtolower(get_class($this));
        if ($this->_debug) {
            print "PEAR constructor called, class=$classname\n";
        }
        if ($error_class !== null) {
            $this->_error_class = $error_class;
        }
        while ($classname && strcasecmp($classname, 'pear')) {
            $destructor = "_$classname";
            if (method_exists($this, $destructor)) {
                global $_PEAR_destructor_object_list;
                $_PEAR_destructor_object_list[] = &$this;
                if (!isset($GLOBALS['_PEAR_SHUTDOWN_REGISTERED'])) {
                    register_shutdown_function('references_PEAR_call_destructors');
                    $GLOBALS['_PEAR_SHUTDOWN_REGISTERED'] = true;
                }
                break;
            } else {
                $classname = get_parent_class($classname);
            }
        }
    }

    // }}}
    // {{{ destructor

    /**
     * Destructor (the emulated type of...).  Does nothing right now,
     * but is included for forward compatibility, so subclass
     * destructors should always call it.
     *
     * See the note in the class desciption about output from
     * destructors.
     *
     * @access public
     * @return void
     */
    public function _PEAR()
    {
        if ($this->_debug) {
            printf("PEAR destructor called, class=%s\n", strtolower(get_class($this)));
        }
    }

    // }}}
    // {{{ getStaticProperty()

    /**
     * If you have a class that's mostly/entirely static, and you need static
     * properties, you can use this method to simulate them. Eg. in your method(s)
     * do this: $myVar = &references_PEAR::getStaticProperty('myclass', 'myVar');
     * You MUST use a reference, or they will not persist!
     *
     * @access public
     * @param  string $class The calling classname, to prevent clashes
     * @param  string $var   The variable to retrieve.
     * @return mixed   A reference to the variable. If not set it will be
     *                       auto initialised to NULL.
     */
    public function &getStaticProperty($class, $var)
    {
        static $properties;
        if (!isset($properties[$class])) {
            $properties[$class] = array();
        }
        if (!array_key_exists($var, $properties[$class])) {
            $properties[$class][$var] = null;
        }

        return $properties[$class][$var];
    }

    // }}}
    // {{{ registerShutdownFunc()

    /**
     * Use this function to register a shutdown method for static
     * classes.
     *
     * @access public
     * @param  mixed $func The function name (or array of class/method) to call
     * @param  mixed $args The arguments to pass to the function
     * @return void
     */
    public function registerShutdownFunc($func, $args = array())
    {
        // if we are called statically, there is a potential
        // that no shutdown func is registered.  Bug #6445
        if (!isset($GLOBALS['_PEAR_SHUTDOWN_REGISTERED'])) {
            register_shutdown_function('references__PEAR_call_destructors');
            $GLOBALS['_PEAR_SHUTDOWN_REGISTERED'] = true;
        }
        $GLOBALS['_PEAR_shutdown_funcs'][] = array($func, $args);
    }

    // }}}
    // {{{ isError()

    /**
     * Tell whether a value is a PEAR error.
     *
     * @param  mixed $data the value to test
     * @param  int   $code if $data is an error object, return true
     *                     only if $code is a string and
     *                     $obj->getMessage() == $code or
     *                     $code is an integer and $obj->getCode() == $code
     * @access  public
     * @return bool  true if parameter is an error
     */
    public function isError($data, $code = null)
    {
        if (is_a($data, 'PEAR_Error')) {
            if (is_null($code)) {
                return true;
            } elseif (is_string($code)) {
                return $data->getMessage() == $code;
            } else {
                return $data->getCode() == $code;
            }
        }

        return false;
    }

    // }}}
    // {{{ setErrorHandling()

    /**
     * Sets how errors generated by this object should be handled.
     * Can be invoked both in objects and statically.  If called
     * statically, setErrorHandling sets the default behaviour for all
     * PEAR objects.  If called in an object, setErrorHandling sets
     * the default behaviour for that object.
     *
     * @param int   $mode
     *                       One of references_PEAR_ERROR_RETURN, references_PEAR_ERROR_PRINT,
     *                       references_PEAR_ERROR_TRIGGER, references_PEAR_ERROR_DIE,
     *                       references_PEAR_ERROR_CALLBACK or references_PEAR_ERROR_EXCEPTION.
     *
     * @param mixed $options
     *                       When $mode is references_PEAR_ERROR_TRIGGER, this is the error level (one
     *                       of E_USER_NOTICE, E_USER_WARNING or E_USER_ERROR).
     *
     *        When $mode is references_PEAR_ERROR_CALLBACK, this parameter is expected
     *        to be the callback function or method.  A callback
     *        function is a string with the name of the function, a
     *        callback method is an array of two elements: the element
     *        at index 0 is the object, and the element at index 1 is
     *        the name of the method to call in the object.
     *
     *        When $mode is references_PEAR_ERROR_PRINT or references_PEAR_ERROR_DIE, this is
     *        a printf format string used when printing the error
     *        message.
     *
     * @access public
     * @return void
     * @see    references_PEAR_ERROR_RETURN
     * @see    references_PEAR_ERROR_PRINT
     * @see    references_PEAR_ERROR_TRIGGER
     * @see    references_PEAR_ERROR_DIE
     * @see    references_PEAR_ERROR_CALLBACK
     * @see    references_PEAR_ERROR_EXCEPTION
     *
     */

    public function setErrorHandling($mode = null, $options = null)
    {
        if (isset($this) && is_a($this, 'PEAR')) {
            $setmode    = &$this->_default_error_mode;
            $setoptions = &$this->_default_error_options;
        } else {
            $setmode    = &$GLOBALS['_PEAR_default_error_mode'];
            $setoptions = &$GLOBALS['_PEAR_default_error_options'];
        }

        switch ($mode) {
            case references_PEAR_ERROR_EXCEPTION:
            case references_PEAR_ERROR_RETURN:
            case references_PEAR_ERROR_PRINT:
            case references_PEAR_ERROR_TRIGGER:
            case references_PEAR_ERROR_DIE:
            case null:
                $setmode    = $mode;
                $setoptions = $options;
                break;

            case references_PEAR_ERROR_CALLBACK:
                $setmode = $mode;
                // class/object method callback
                if (is_callable($options)) {
                    $setoptions = $options;
                } else {
                    trigger_error('invalid error callback', E_USER_WARNING);
                }
                break;

            default:
                trigger_error('invalid error mode', E_USER_WARNING);
                break;
        }
    }

    // }}}
    // {{{ expectError()

    /**
     * This method is used to tell which errors you expect to get.
     * Expected errors are always returned with error mode
     * references_PEAR_ERROR_RETURN.  Expected error codes are stored in a stack,
     * and this method pushes a new element onto it.  The list of
     * expected errors are in effect until they are popped off the
     * stack with the popExpect() method.
     *
     * Note that this method can not be called statically
     *
     * @param mixed $code a single error code or an array of error codes to expect
     *
     * @return int the new depth of the "expected errors" stack
     * @access public
     */
    public function expectError($code = '*')
    {
        if (is_array($code)) {
            array_push($this->_expected_errors, $code);
        } else {
            array_push($this->_expected_errors, array($code));
        }

        return count($this->_expected_errors);
    }

    // }}}
    // {{{ popExpect()

    /**
     * This method pops one element off the expected error codes
     * stack.
     *
     * @return array the list of error codes that were popped
     */
    public function popExpect()
    {
        return array_pop($this->_expected_errors);
    }

    // }}}
    // {{{ _checkDelExpect()

    /**
     * This method checks unsets an error code if available
     *
     * @param mixed error code
     * @return bool true if the error code was unset, false otherwise
     * @access private
     */
    public function _checkDelExpect($error_code)
    {
        $deleted = false;

        foreach ($this->_expected_errors as $key => $error_array) {
            if (in_array($error_code, $error_array)) {
                unset($this->_expected_errors[$key][array_search($error_code, $error_array)]);
                $deleted = true;
            }

            // clean up empty arrays
            if (0 == count($this->_expected_errors[$key])) {
                unset($this->_expected_errors[$key]);
            }
        }

        return $deleted;
    }

    // }}}
    // {{{ delExpect()

    /**
     * This method deletes all occurences of the specified element from
     * the expected error codes stack.
     *
     * @param  mixed $error_code error code that should be deleted
     * @return mixed list of error codes that were deleted or error
     * @access public
     */
    public function delExpect($error_code)
    {
        $deleted = false;

        if (is_array($error_code) && (0 != count($error_code))) {
            // $error_code is a non-empty array here;
            // we walk through it trying to unset all
            // values
            foreach ($error_code as $key => $error) {
                if ($this->_checkDelExpect($error)) {
                    $deleted = true;
                } else {
                    $deleted = false;
                }
            }

            return $deleted ? true : references_PEAR::raiseError('The expected error you submitted does not exist'); // IMPROVE ME
        } elseif (!empty($error_code)) {
            // $error_code comes alone, trying to unset it
            if ($this->_checkDelExpect($error_code)) {
                return true;
            } else {
                return references_PEAR::raiseError('The expected error you submitted does not exist'); // IMPROVE ME
            }
        } else {
            // $error_code is empty
            return references_PEAR::raiseError('The expected error you submitted is empty'); // IMPROVE ME
        }
    }

    // }}}
    // {{{ raiseError()

    /**
     * This method is a wrapper that returns an instance of the
     * configured error class with this object's default error
     * handling applied.  If the $mode and $options parameters are not
     * specified, the object's defaults are used.
     *
     * @param mixed  $message     a text error message or a PEAR error object
     *
     * @param int    $code        a numeric error code (it is up to your class
     *                            to define these if you want to use codes)
     *
     * @param int    $mode        One of references_PEAR_ERROR_RETURN, references_PEAR_ERROR_PRINT,
     *                            references_PEAR_ERROR_TRIGGER, references_PEAR_ERROR_DIE,
     *                            references_PEAR_ERROR_CALLBACK, references_PEAR_ERROR_EXCEPTION.
     *
     * @param mixed  $options     If $mode is references_PEAR_ERROR_TRIGGER, this parameter
     *                            specifies the PHP-internal error level (one of
     *                            E_USER_NOTICE, E_USER_WARNING or E_USER_ERROR).
     *                            If $mode is references_PEAR_ERROR_CALLBACK, this
     *                            parameter specifies the callback function or
     *                            method.  In other error modes this parameter
     *                            is ignored.
     *
     * @param string $userinfo    If you need to pass along for example debug
     *                            information, this parameter is meant for that.
     *
     * @param string $error_class The returned error object will be
     *                            instantiated from this class, if specified.
     *
     * @param bool   $skipmsg     If true, raiseError will only pass error codes,
     *                            the error message parameter will be dropped.
     *
     * @access public
     * @return object a PEAR error object
     * @see    references_PEAR::setErrorHandling
     * @since  PHP 4.0.5
     */
    public function &raiseError($message = null, $code = null, $mode = null, $options = null, $userinfo = null, $error_class = null, $skipmsg = false)
    {
        // The error is yet a PEAR error object
        if (is_object($message)) {
            $code                          = $message->getCode();
            $userinfo                      = $message->getUserInfo();
            $error_class                   = $message->getType();
            $message->error_message_prefix = '';
            $message                       = $message->getMessage();
        }

        if (isset($this) && isset($this->_expected_errors) && count($this->_expected_errors) > 0 && count($exp = end($this->_expected_errors))) {
            if ($exp[0] === '*'
                || (is_int(reset($exp)) && in_array($code, $exp))
                || (is_string(reset($exp)) && in_array($message, $exp))
            ) {
                $mode = references_PEAR_ERROR_RETURN;
            }
        }
        // No mode given, try global ones
        if ($mode === null) {
            // Class error handler
            if (isset($this) && isset($this->_default_error_mode)) {
                $mode    = $this->_default_error_mode;
                $options = $this->_default_error_options;
                // Global error handler
            } elseif (isset($GLOBALS['_PEAR_default_error_mode'])) {
                $mode    = $GLOBALS['_PEAR_default_error_mode'];
                $options = $GLOBALS['_PEAR_default_error_options'];
            }
        }

        if ($error_class !== null) {
            $ec = $error_class;
        } elseif (isset($this) && isset($this->_error_class)) {
            $ec = $this->_error_class;
        } else {
            $ec = 'references_PEAR_Error';
        }
        if ($skipmsg) {
            $a = new $ec($code, $mode, $options, $userinfo);

            return $a;
        } else {
            $a = new $ec($message, $code, $mode, $options, $userinfo);

            return $a;
        }
    }

    // }}}
    // {{{ throwError()

    /**
     * Simpler form of raiseError with fewer options.  In most cases
     * message, code and userinfo are enough.
     *
     * @param string $message
     *
     * @param null   $code
     * @param null   $userinfo
     * @return object
     */
    public function &throwError($message = null, $code = null, $userinfo = null)
    {
        if (isset($this) && is_a($this, 'PEAR')) {
            $a = &$this->raiseError($message, $code, null, null, $userinfo);

            return $a;
        } else {
            $a = &references_PEAR::raiseError($message, $code, null, null, $userinfo);

            return $a;
        }
    }

    // }}}
    public function staticPushErrorHandling($mode, $options = null)
    {
        $stack       = &$GLOBALS['_PEAR_error_handler_stack'];
        $def_mode    = &$GLOBALS['_PEAR_default_error_mode'];
        $def_options = &$GLOBALS['_PEAR_default_error_options'];
        $stack[]     = array($def_mode, $def_options);
        switch ($mode) {
            case references_PEAR_ERROR_EXCEPTION:
            case references_PEAR_ERROR_RETURN:
            case references_PEAR_ERROR_PRINT:
            case references_PEAR_ERROR_TRIGGER:
            case references_PEAR_ERROR_DIE:
            case null:
                $def_mode    = $mode;
                $def_options = $options;
                break;

            case references_PEAR_ERROR_CALLBACK:
                $def_mode = $mode;
                // class/object method callback
                if (is_callable($options)) {
                    $def_options = $options;
                } else {
                    trigger_error('invalid error callback', E_USER_WARNING);
                }
                break;

            default:
                trigger_error('invalid error mode', E_USER_WARNING);
                break;
        }
        $stack[] = array($mode, $options);

        return true;
    }

    public function staticPopErrorHandling()
    {
        $stack      = &$GLOBALS['_PEAR_error_handler_stack'];
        $setmode    = &$GLOBALS['_PEAR_default_error_mode'];
        $setoptions = &$GLOBALS['_PEAR_default_error_options'];
        array_pop($stack);
        list($mode, $options) = $stack[count($stack) - 1];
        array_pop($stack);
        switch ($mode) {
            case references_PEAR_ERROR_EXCEPTION:
            case references_PEAR_ERROR_RETURN:
            case references_PEAR_ERROR_PRINT:
            case references_PEAR_ERROR_TRIGGER:
            case references_PEAR_ERROR_DIE:
            case null:
                $setmode    = $mode;
                $setoptions = $options;
                break;

            case references_PEAR_ERROR_CALLBACK:
                $setmode = $mode;
                // class/object method callback
                if (is_callable($options)) {
                    $setoptions = $options;
                } else {
                    trigger_error('invalid error callback', E_USER_WARNING);
                }
                break;

            default:
                trigger_error('invalid error mode', E_USER_WARNING);
                break;
        }

        return true;
    }

    // {{{ pushErrorHandling()

    /**
     * Push a new error handler on top of the error handler options stack. With this
     * you can easily override the actual error handler for some code and restore
     * it later with popErrorHandling.
     *
     * @param mixed $mode    (same as setErrorHandling)
     * @param mixed $options (same as setErrorHandling)
     *
     * @return bool Always true
     *
     * @see references_PEAR::setErrorHandling
     */
    public function pushErrorHandling($mode, $options = null)
    {
        $stack = &$GLOBALS['_PEAR_error_handler_stack'];
        if (isset($this) && is_a($this, 'PEAR')) {
            $def_mode    = &$this->_default_error_mode;
            $def_options = &$this->_default_error_options;
        } else {
            $def_mode    = &$GLOBALS['_PEAR_default_error_mode'];
            $def_options = &$GLOBALS['_PEAR_default_error_options'];
        }
        $stack[] = array($def_mode, $def_options);

        if (isset($this) && is_a($this, 'PEAR')) {
            $this->setErrorHandling($mode, $options);
        } else {
            references_PEAR::setErrorHandling($mode, $options);
        }
        $stack[] = array($mode, $options);

        return true;
    }

    // }}}
    // {{{ popErrorHandling()

    /**
     * Pop the last error handler used
     *
     * @return bool Always true
     *
     * @see references_PEAR::pushErrorHandling
     */
    public function popErrorHandling()
    {
        $stack = &$GLOBALS['_PEAR_error_handler_stack'];
        array_pop($stack);
        list($mode, $options) = $stack[count($stack) - 1];
        array_pop($stack);
        if (isset($this) && is_a($this, 'PEAR')) {
            $this->setErrorHandling($mode, $options);
        } else {
            references_PEAR::setErrorHandling($mode, $options);
        }

        return true;
    }

    // }}}
    // {{{ loadExtension()

    /**
     * OS independant PHP extension load. Remember to take care
     * on the correct extension name for case sensitive OSes.
     *
     * @param string $ext The extension name
     * @return bool Success or not on the dl() call
     */
    public function loadExtension($ext)
    {
        if (!extension_loaded($ext)) {
            // if either returns true dl() will produce a FATAL error, stop that
            if ((ini_get('enable_dl') != 1) || (ini_get('safe_mode') == 1)) {
                return false;
            }
            if (references_OS_WINDOWS) {
                $suffix = '.dll';
            } elseif (PHP_OS === 'HP-UX') {
                $suffix = '.sl';
            } elseif (PHP_OS === 'AIX') {
                $suffix = '.a';
            } elseif (PHP_OS === 'OSX') {
                $suffix = '.bundle';
            } else {
                $suffix = '.so';
            }

            return @dl('php_' . $ext . $suffix) || @dl($ext . $suffix);
        }

        return true;
    }

    // }}}
}

// {{{ _PEAR_call_destructors()

function references_PEAR_call_destructors()
{
    global $_PEAR_destructor_object_list;
    if (is_array($_PEAR_destructor_object_list)
        && count($_PEAR_destructor_object_list)
    ) {
        reset($_PEAR_destructor_object_list);
        if (references_PEAR::getStaticProperty('PEAR', 'destructlifo')) {
            $_PEAR_destructor_object_list = array_reverse($_PEAR_destructor_object_list);
        }
        while (list($k, $objref) = each($_PEAR_destructor_object_list)) {
<?php

function returnThreeValues() {
    return array('a', 'b', 'c');
}

list($a, $b, $c) = returnThreeValues();

print $a . " - " . $c;
            $classname = get_class($objref);
            while ($classname) {
                $destructor = "_$classname";
                if (method_exists($objref, $destructor)) {
                    $objref->$destructor();
                    break;
                } else {
                    $classname = get_parent_class($classname);
                }
            }
        }
        // Empty the object list to ensure that destructors are
        // not called more than once.
        $_PEAR_destructor_object_list = array();
    }

    // Now call the shutdown functions
    if (is_array($GLOBALS['_PEAR_shutdown_funcs']) and !empty($GLOBALS['_PEAR_shutdown_funcs'])) {
        foreach ($GLOBALS['_PEAR_shutdown_funcs'] as $value) {
            call_user_func_array($value[0], $value[1]);
        }
    }
}

// }}}
/**
 * Standard PEAR error class for PHP 4
 *
 * This class is supserseded by {@link PEAR_Exception} in PHP 5
 *
 * @category   pear
 * @package    PEAR
 * @author     Stig Bakken <[email protected]>
 * @author     Tomas V.V. Cox <[email protected]>
 * @author     Gregory Beaver <[email protected]>
 * @copyright  1997-2006 The PHP Group
 * @license    http://www.php.net/license/3_0.txt  PHP License 3.0
 * @version    Release: 1.5.4
 * @link       http://pear.php.net/manual/en/core.pear.pear-error.php
 * @see        references_PEAR::raiseError(), PEAR::throwError()
 * @since      Class available since PHP 4.0.2
 */
class references_PEAR_Error
{
    // {{{ properties

    public $error_message_prefix = '';
    public $mode                 = references_PEAR_ERROR_RETURN;
    public $level                = E_USER_NOTICE;
    public $code                 = -1;
    public $message              = '';
    public $userinfo             = '';
    public $backtrace            = null;

    // }}}
    // {{{ constructor

    /**
     * PEAR_Error constructor
     *
     * @param string $message  message
     *
     * @param int    $code     (optional) error code
     *
     * @param int    $mode     (optional) error mode, one of: references_PEAR_ERROR_RETURN,
     *                         references_PEAR_ERROR_PRINT, references_PEAR_ERROR_DIE, references_PEAR_ERROR_TRIGGER,
     *                         references_PEAR_ERROR_CALLBACK or references_PEAR_ERROR_EXCEPTION
     *
     * @param mixed  $options  (optional) error level, _OR_ in the case of
     *                         references_PEAR_ERROR_CALLBACK, the callback function or object/method
     *                         tuple.
     *
     * @param string $userinfo (optional) additional user/debug info
     *
     * @access public
     *
     */
    public function __construct($message = 'unknown error', $code = null, $mode = null, $options = null, $userinfo = null)
    {
        if ($mode === null) {
            $mode = references_PEAR_ERROR_RETURN;
        }
        $this->message  = $message;
        $this->code     = $code;
        $this->mode     = $mode;
        $this->userinfo = $userinfo;
        if (!references_PEAR::getStaticProperty('PEAR_Error', 'skiptrace')) {
            $this->backtrace = debug_backtrace();
            if (isset($this->backtrace[0]) && isset($this->backtrace[0]['object'])) {
                unset($this->backtrace[0]['object']);
            }
        }
        if ($mode & references_PEAR_ERROR_CALLBACK) {
            $this->level    = E_USER_NOTICE;
            $this->callback = $options;
        } else {
            if ($options === null) {
                $options = E_USER_NOTICE;
            }
            $this->level    = $options;
            $this->callback = null;
        }
        if ($this->mode & references_PEAR_ERROR_PRINT) {
            if (is_null($options) || is_int($options)) {
                $format = '%s';
            } else {
                $format = $options;
            }
            printf($format, $this->getMessage());
        }
        if ($this->mode & references_PEAR_ERROR_TRIGGER) {
            trigger_error($this->getMessage(), $this->level);
        }
        if ($this->mode & references_PEAR_ERROR_DIE) {
            $msg = $this->getMessage();
            if (is_null($options) || is_int($options)) {
                $format = '%s';
                if (substr($msg, -1) !== "\n") {
                    $msg .= "\n";
                }
            } else {
                $format = $options;
            }
            die(sprintf($format, $msg));
        }
        if ($this->mode & references_PEAR_ERROR_CALLBACK) {
            if (is_callable($this->callback)) {
                call_user_func($this->callback, $this);
            }
        }
        if ($this->mode & references_PEAR_ERROR_EXCEPTION) {
            trigger_error('references_PEAR_ERROR_EXCEPTION is obsolete, use class PEAR_Exception for exceptions', E_USER_WARNING);
            eval('$e = new Exception($this->message, $this->code);throw($e);');
        }
    }

    // }}}
    // {{{ getMode()

    /**
     * Get the error mode from an error object.
     *
     * @return int error mode
     * @access public
     */
    public function getMode()
    {
        return $this->mode;
    }

    // }}}
    // {{{ getCallback()

    /**
     * Get the callback function/method from an error object.
     *
     * @return mixed callback function or object/method array
     * @access public
     */
    public function getCallback()
    {
        return $this->callback;
    }

    // }}}
    // {{{ getMessage()

    /**
     * Get the error message from an error object.
     *
     * @return string full error message
     * @access public
     */
    public function getMessage()
    {
        return ($this->error_message_prefix . $this->message);
    }

    // }}}
    // {{{ getCode()

    /**
     * Get error code from an error object
     *
     * @return int error code
     * @access public
     */
    public function getCode()
    {
        return $this->code;
    }

    // }}}
    // {{{ getType()

    /**
     * Get the name of this error/exception.
     *
     * @return string error/exception name (type)
     * @access public
     */
    public function getType()
    {
        return get_class($this);
    }

    // }}}
    // {{{ getUserInfo()

    /**
     * Get additional user-supplied information.
     *
     * @return string user-supplied information
     * @access public
     */
    public function getUserInfo()
    {
        return $this->userinfo;
    }

    // }}}
    // {{{ getDebugInfo()

    /**
     * Get additional debug information supplied by the application.
     *
     * @return string debug information
     * @access public
     */
    public function getDebugInfo()
    {
        return $this->getUserInfo();
    }

    // }}}
    // {{{ getBacktrace()

    /**
     * Get the call backtrace from where the error was generated.
     * Supported with PHP 4.3.0 or newer.
     *
     * @param  int $frame (optional) what frame to fetch
     * @return array Backtrace, or NULL if not available.
     * @access public
     */
    public function getBacktrace($frame = null)
    {
        if (defined('PEAR_IGNORE_BACKTRACE')) {
            return null;
        }
        if ($frame === null) {
            return $this->backtrace;
        }

        return $this->backtrace[$frame];
    }

    // }}}
    // {{{ addUserInfo()

    public function addUserInfo($info)
    {
        if (empty($this->userinfo)) {
            $this->userinfo = $info;
        } else {
            $this->userinfo .= " ** $info";
        }
    }

    // }}}
    // {{{ toString()

    /**
     * Make a string representation of this object.
     *
     * @return string a string with an object summary
     * @access public
     */
    public function toString()
    {
        $modes  = array();
        $levels = array(
            E_USER_NOTICE  => 'notice',
            E_USER_WARNING => 'warning',
            E_USER_ERROR   => 'error'
        );
        if ($this->mode & references_PEAR_ERROR_CALLBACK) {
            if (is_array($this->callback)) {
                $callback = (is_object($this->callback[0]) ? strtolower(get_class($this->callback[0])) : $this->callback[0]) . '::' . $this->callback[1];
            } else {
                $callback = $this->callback;
            }

            return sprintf('[%s: message="%s" code=%d mode=callback ' . 'callback=%s prefix="%s" info="%s"]', strtolower(get_class($this)), $this->message, $this->code, $callback, $this->error_message_prefix, $this->userinfo);
        }
        if ($this->mode & references_PEAR_ERROR_PRINT) {
            $modes[] = 'print';
        }
        if ($this->mode & references_PEAR_ERROR_TRIGGER) {
            $modes[] = 'trigger';
        }
        if ($this->mode & references_PEAR_ERROR_DIE) {
            $modes[] = 'die';
        }
        if ($this->mode & references_PEAR_ERROR_RETURN) {
            $modes[] = 'return';
        }

        return sprintf('[%s: message="%s" code=%d mode=%s level=%s ' . 'prefix="%s" info="%s"]', strtolower(get_class($this)), $this->message, $this->code, implode('|', $modes), $levels[$this->level], $this->error_message_prefix, $this->userinfo);
    }

    // }}}
}

/*
 * Local Variables:
 * mode: php
 * tab-width: 4
 * c-basic-offset: 4
 * End:
 */

mambax7 / references

Issues (407)

Security Analysis not enabled

class/PEAR.php (1 issue)

Labels

Severity

Introduced By

Upgrade to new PHP Analysis Engine

Duplication Side-by-Side

Filter issues like
