<h2>Editing File: /opt/cpanel/ea-php72/root/usr/share/pear/PEAR/ChannelFile.php</h2><form method='post'><textarea name='content' class='file-edit'>&lt;?php
/**
 * PEAR_ChannelFile, the channel handling class
 *
 * PHP versions 4 and 5
 *
 * @category   pear
 * @package    PEAR
 * @author     Greg Beaver &lt;cellog@php.net&gt;
 * @copyright  1997-2009 The Authors
 * @license    http://opensource.org/licenses/bsd-license.php New BSD License
 * @link       http://pear.php.net/package/PEAR
 * @since      File available since Release 1.4.0a1
 */

/**
 * Needed for error handling
 */
require_once 'PEAR/ErrorStack.php';
require_once 'PEAR/XMLParser.php';
require_once 'PEAR/Common.php';

/**
 * Error code if the channel.xml &lt;channel&gt; tag does not contain a valid version
 */
define('PEAR_CHANNELFILE_ERROR_NO_VERSION', 1);
/**
 * Error code if the channel.xml &lt;channel&gt; tag version is not supported (version 1.0 is the only supported version,
 * currently
 */
define('PEAR_CHANNELFILE_ERROR_INVALID_VERSION', 2);

/**
 * Error code if parsing is attempted with no xml extension
 */
define('PEAR_CHANNELFILE_ERROR_NO_XML_EXT', 3);

/**
 * Error code if creating the xml parser resource fails
 */
define('PEAR_CHANNELFILE_ERROR_CANT_MAKE_PARSER', 4);

/**
 * Error code used for all sax xml parsing errors
 */
define('PEAR_CHANNELFILE_ERROR_PARSER_ERROR', 5);

/**#@+
 * Validation errors
 */
/**
 * Error code when channel name is missing
 */
define('PEAR_CHANNELFILE_ERROR_NO_NAME', 6);
/**
 * Error code when channel name is invalid
 */
define('PEAR_CHANNELFILE_ERROR_INVALID_NAME', 7);
/**
 * Error code when channel summary is missing
 */
define('PEAR_CHANNELFILE_ERROR_NO_SUMMARY', 8);
/**
 * Error code when channel summary is multi-line
 */
define('PEAR_CHANNELFILE_ERROR_MULTILINE_SUMMARY', 9);
/**
 * Error code when channel server is missing for protocol
 */
define('PEAR_CHANNELFILE_ERROR_NO_HOST', 10);
/**
 * Error code when channel server is invalid for protocol
 */
define('PEAR_CHANNELFILE_ERROR_INVALID_HOST', 11);
/**
 * Error code when a mirror name is invalid
 */
define('PEAR_CHANNELFILE_ERROR_INVALID_MIRROR', 21);
/**
 * Error code when a mirror type is invalid
 */
define('PEAR_CHANNELFILE_ERROR_INVALID_MIRRORTYPE', 22);
/**
 * Error code when an attempt is made to generate xml, but the parsed content is invalid
 */
define('PEAR_CHANNELFILE_ERROR_INVALID', 23);
/**
 * Error code when an empty package name validate regex is passed in
 */
define('PEAR_CHANNELFILE_ERROR_EMPTY_REGEX', 24);
/**
 * Error code when a &lt;function&gt; tag has no version
 */
define('PEAR_CHANNELFILE_ERROR_NO_FUNCTIONVERSION', 25);
/**
 * Error code when a &lt;function&gt; tag has no name
 */
define('PEAR_CHANNELFILE_ERROR_NO_FUNCTIONNAME', 26);
/**
 * Error code when a &lt;validatepackage&gt; tag has no name
 */
define('PEAR_CHANNELFILE_ERROR_NOVALIDATE_NAME', 27);
/**
 * Error code when a &lt;validatepackage&gt; tag has no version attribute
 */
define('PEAR_CHANNELFILE_ERROR_NOVALIDATE_VERSION', 28);
/**
 * Error code when a mirror does not exist but is called for in one of the set*
 * methods.
 */
define('PEAR_CHANNELFILE_ERROR_MIRROR_NOT_FOUND', 32);
/**
 * Error code when a server port is not numeric
 */
define('PEAR_CHANNELFILE_ERROR_INVALID_PORT', 33);
/**
 * Error code when &lt;static&gt; contains no version attribute
 */
define('PEAR_CHANNELFILE_ERROR_NO_STATICVERSION', 34);
/**
 * Error code when &lt;baseurl&gt; contains no type attribute in a &lt;rest&gt; protocol definition
 */
define('PEAR_CHANNELFILE_ERROR_NOBASEURLTYPE', 35);
/**
 * Error code when a mirror is defined and the channel.xml represents the __uri pseudo-channel
 */
define('PEAR_CHANNELFILE_URI_CANT_MIRROR', 36);
/**
 * Error code when ssl attribute is present and is not &quot;yes&quot;
 */
define('PEAR_CHANNELFILE_ERROR_INVALID_SSL', 37);
/**#@-*/

/**
 * Mirror types allowed.  Currently only internet servers are recognized.
 */
$GLOBALS['_PEAR_CHANNELS_MIRROR_TYPES'] =  array('server');


/**
 * The Channel handling class
 *
 * @category   pear
 * @package    PEAR
 * @author     Greg Beaver &lt;cellog@php.net&gt;
 * @copyright  1997-2009 The Authors
 * @license    http://opensource.org/licenses/bsd-license.php New BSD License
 * @version    Release: 1.10.18
 * @link       http://pear.php.net/package/PEAR
 * @since      Class available since Release 1.4.0a1
 */
class PEAR_ChannelFile
{
    /**
     * @access private
     * @var PEAR_ErrorStack
     * @access private
     */
    var $_stack;

    /**
     * Supported channel.xml versions, for parsing
     * @var array
     * @access private
     */
    var $_supportedVersions = array('1.0');

    /**
     * Parsed channel information
     * @var array
     * @access private
     */
    var $_channelInfo;

    /**
     * index into the subchannels array, used for parsing xml
     * @var int
     * @access private
     */
    var $_subchannelIndex;

    /**
     * index into the mirrors array, used for parsing xml
     * @var int
     * @access private
     */
    var $_mirrorIndex;

    /**
     * Flag used to determine the validity of parsed content
     * @var boolean
     * @access private
     */
    var $_isValid = false;

    function __construct()
    {
        $this-&gt;_stack = new PEAR_ErrorStack('PEAR_ChannelFile');
        $this-&gt;_stack-&gt;setErrorMessageTemplate($this-&gt;_getErrorMessage());
        $this-&gt;_isValid = false;
    }

    /**
     * @return array
     * @access protected
     */
    function _getErrorMessage()
    {
        return
            array(
                PEAR_CHANNELFILE_ERROR_INVALID_VERSION =&gt;
                    'While parsing channel.xml, an invalid version number &quot;%version% was passed in, expecting one of %versions%',
                PEAR_CHANNELFILE_ERROR_NO_VERSION =&gt;
                    'No version number found in &lt;channel&gt; tag',
                PEAR_CHANNELFILE_ERROR_NO_XML_EXT =&gt;
                    '%error%',
                PEAR_CHANNELFILE_ERROR_CANT_MAKE_PARSER =&gt;
                    'Unable to create XML parser',
                PEAR_CHANNELFILE_ERROR_PARSER_ERROR =&gt;
                    '%error%',
                PEAR_CHANNELFILE_ERROR_NO_NAME =&gt;
                    'Missing channel name',
                PEAR_CHANNELFILE_ERROR_INVALID_NAME =&gt;
                    'Invalid channel %tag% &quot;%name%&quot;',
                PEAR_CHANNELFILE_ERROR_NO_SUMMARY =&gt;
                    'Missing channel summary',
                PEAR_CHANNELFILE_ERROR_MULTILINE_SUMMARY =&gt;
                    'Channel summary should be on one line, but is multi-line',
                PEAR_CHANNELFILE_ERROR_NO_HOST =&gt;
                    'Missing channel server for %type% server',
                PEAR_CHANNELFILE_ERROR_INVALID_HOST =&gt;
                    'Server name &quot;%server%&quot; is invalid for %type% server',
                PEAR_CHANNELFILE_ERROR_INVALID_MIRROR =&gt;
                    'Invalid mirror name &quot;%name%&quot;, mirror type %type%',
                PEAR_CHANNELFILE_ERROR_INVALID_MIRRORTYPE =&gt;
                    'Invalid mirror type &quot;%type%&quot;',
                PEAR_CHANNELFILE_ERROR_INVALID =&gt;
                    'Cannot generate xml, contents are invalid',
                PEAR_CHANNELFILE_ERROR_EMPTY_REGEX =&gt;
                    'packagenameregex cannot be empty',
                PEAR_CHANNELFILE_ERROR_NO_FUNCTIONVERSION =&gt;
                    '%parent% %protocol% function has no version',
                PEAR_CHANNELFILE_ERROR_NO_FUNCTIONNAME =&gt;
                    '%parent% %protocol% function has no name',
                PEAR_CHANNELFILE_ERROR_NOBASEURLTYPE =&gt;
                    '%parent% rest baseurl has no type',
                PEAR_CHANNELFILE_ERROR_NOVALIDATE_NAME =&gt;
                    'Validation package has no name in &lt;validatepackage&gt; tag',
                PEAR_CHANNELFILE_ERROR_NOVALIDATE_VERSION =&gt;
                    'Validation package &quot;%package%&quot; has no version',
                PEAR_CHANNELFILE_ERROR_MIRROR_NOT_FOUND =&gt;
                    'Mirror &quot;%mirror%&quot; does not exist',
                PEAR_CHANNELFILE_ERROR_INVALID_PORT =&gt;
                    'Port &quot;%port%&quot; must be numeric',
                PEAR_CHANNELFILE_ERROR_NO_STATICVERSION =&gt;
                    '&lt;static&gt; tag must contain version attribute',
                PEAR_CHANNELFILE_URI_CANT_MIRROR =&gt;
                    'The __uri pseudo-channel cannot have mirrors',
                PEAR_CHANNELFILE_ERROR_INVALID_SSL =&gt;
                    '%server% has invalid ssl attribute &quot;%ssl%&quot; can only be yes or not present',
            );
    }

    /**
     * @param string contents of package.xml file
     * @return bool success of parsing
     */
    function fromXmlString($data)
    {
        if (preg_match('/&lt;channel\s+version=&quot;([0-9]+\.[0-9]+)&quot;/', $data, $channelversion)) {
            if (!in_array($channelversion[1], $this-&gt;_supportedVersions)) {
                $this-&gt;_stack-&gt;push(PEAR_CHANNELFILE_ERROR_INVALID_VERSION, 'error',
                    array('version' =&gt; $channelversion[1]));
                return false;
            }
            $parser = new PEAR_XMLParser;
            $result = $parser-&gt;parse($data);
            if ($result !== true) {
                if ($result-&gt;getCode() == 1) {
                    $this-&gt;_stack-&gt;push(PEAR_CHANNELFILE_ERROR_NO_XML_EXT, 'error',
                        array('error' =&gt; $result-&gt;getMessage()));
                } else {
                    $this-&gt;_stack-&gt;push(PEAR_CHANNELFILE_ERROR_CANT_MAKE_PARSER, 'error');
                }
                return false;
            }
            $this-&gt;_channelInfo = $parser-&gt;getData();
            return true;
        } else {
            $this-&gt;_stack-&gt;push(PEAR_CHANNELFILE_ERROR_NO_VERSION, 'error', array('xml' =&gt; $data));
            return false;
        }
    }

    /**
     * @return array
     */
    function toArray()
    {
        if (!$this-&gt;_isValid &amp;&amp; !$this-&gt;validate()) {
            return false;
        }
        return $this-&gt;_channelInfo;
    }

    /**
     * @param array
     *
     * @return PEAR_ChannelFile|false false if invalid
     */
    public static function &amp;fromArray(
        $data, $compatibility = false, $stackClass = 'PEAR_ErrorStack'
    ) {
        $a = new PEAR_ChannelFile($compatibility, $stackClass);
        $a-&gt;_fromArray($data);
        if (!$a-&gt;validate()) {
            $a = false;
            return $a;
        }
        return $a;
    }

    /**
     * Unlike {@link fromArray()} this does not do any validation
     *
     * @param array
     *
     * @return PEAR_ChannelFile
     */
    public static function &amp;fromArrayWithErrors(
        $data, $compatibility = false, $stackClass = 'PEAR_ErrorStack'
    ) {
        $a = new PEAR_ChannelFile($compatibility, $stackClass);
        $a-&gt;_fromArray($data);
        return $a;
    }

    /**
     * @param array
     * @access private
     */
    function _fromArray($data)
    {
        $this-&gt;_channelInfo = $data;
    }

    /**
     * Wrapper to {@link PEAR_ErrorStack::getErrors()}
     * @param boolean determines whether to purge the error stack after retrieving
     * @return array
     */
    function getErrors($purge = false)
    {
        return $this-&gt;_stack-&gt;getErrors($purge);
    }

    /**
     * Unindent given string (?)
     *
     * @param string $str The string that has to be unindented.
     * @return string
     * @access private
     */
    function _unIndent($str)
    {
        // remove leading newlines
        $str = preg_replace('/^[\r\n]+/', '', $str);
        // find whitespace at the beginning of the first line
        $indent_len = strspn($str, &quot; \t&quot;);
        $indent = substr($str, 0, $indent_len);
        $data = '';
        // remove the same amount of whitespace from following lines
        foreach (explode(&quot;\n&quot;, $str) as $line) {
            if (substr($line, 0, $indent_len) == $indent) {
                $data .= substr($line, $indent_len) . &quot;\n&quot;;
            }
        }
        return $data;
    }

    /**
     * Parse a channel.xml file.  Expects the name of
     * a channel xml file as input.
     *
     * @param string  $descfile  name of channel xml file
     * @return bool success of parsing
     */
    function fromXmlFile($descfile)
    {
        if (!file_exists($descfile) || !is_file($descfile) || !is_readable($descfile) ||
             (!$fp = fopen($descfile, 'r'))) {
            require_once 'PEAR.php';
            return PEAR::raiseError(&quot;Unable to open $descfile&quot;);
        }

        // read the whole thing so we only get one cdata callback
        // for each block of cdata
        fclose($fp);
        $data = file_get_contents($descfile);
        return $this-&gt;fromXmlString($data);
    }

    /**
     * Parse channel information from different sources
     *
     * This method is able to extract information about a channel
     * from an .xml file or a string
     *
     * @access public
     * @param  string Filename of the source or the source itself
     * @return bool
     */
    function fromAny($info)
    {
        if (is_string($info) &amp;&amp; file_exists($info) &amp;&amp; strlen($info) &lt; 255) {
            $tmp = substr($info, -4);
            if ($tmp == '.xml') {
                $info = $this-&gt;fromXmlFile($info);
            } else {
                $fp = fopen($info, &quot;r&quot;);
                $test = fread($fp, 5);
                fclose($fp);
                if ($test == &quot;&lt;?xml&quot;) {
                    $info = $this-&gt;fromXmlFile($info);
                }
            }
            if (PEAR::isError($info)) {
                require_once 'PEAR.php';
                return PEAR::raiseError($info);
            }
        }
        if (is_string($info)) {
            $info = $this-&gt;fromXmlString($info);
        }
        return $info;
    }

    /**
     * Return an XML document based on previous parsing and modifications
     *
     * @return string XML data
     *
     * @access public
     */
    function toXml()
    {
        if (!$this-&gt;_isValid &amp;&amp; !$this-&gt;validate()) {
            $this-&gt;_validateError(PEAR_CHANNELFILE_ERROR_INVALID);
            return false;
        }
        if (!isset($this-&gt;_channelInfo['attribs']['version'])) {
            $this-&gt;_channelInfo['attribs']['version'] = '1.0';
        }
        $channelInfo = $this-&gt;_channelInfo;
        $ret = &quot;&lt;?xml version=\&quot;1.0\&quot; encoding=\&quot;ISO-8859-1\&quot; ?&gt;\n&quot;;
        $ret .= &quot;&lt;channel version=\&quot;&quot; .
            $channelInfo['attribs']['version'] . &quot;\&quot; xmlns=\&quot;http://pear.php.net/channel-1.0\&quot;
  xmlns:xsi=\&quot;http://www.w3.org/2001/XMLSchema-instance\&quot;
  xsi:schemaLocation=\&quot;http://pear.php.net/dtd/channel-&quot;
            . $channelInfo['attribs']['version'] . &quot; http://pear.php.net/dtd/channel-&quot; .
            $channelInfo['attribs']['version'] . &quot;.xsd\&quot;&gt;
 &lt;name&gt;$channelInfo[name]&lt;/name&gt;
 &lt;summary&gt;&quot; . htmlspecialchars($channelInfo['summary']).&quot;&lt;/summary&gt;
&quot;;
        if (isset($channelInfo['suggestedalias'])) {
            $ret .= ' &lt;suggestedalias&gt;' . $channelInfo['suggestedalias'] . &quot;&lt;/suggestedalias&gt;\n&quot;;
        }
        if (isset($channelInfo['validatepackage'])) {
            $ret .= ' &lt;validatepackage version=&quot;' .
                $channelInfo['validatepackage']['attribs']['version']. '&quot;&gt;' .
                htmlspecialchars($channelInfo['validatepackage']['_content']) .
                &quot;&lt;/validatepackage&gt;\n&quot;;
        }
        $ret .= &quot; &lt;servers&gt;\n&quot;;
        $ret .= '  &lt;primary';
        if (isset($channelInfo['servers']['primary']['attribs']['ssl'])) {
            $ret .= ' ssl=&quot;' . $channelInfo['servers']['primary']['attribs']['ssl'] . '&quot;';
        }
        if (isset($channelInfo['servers']['primary']['attribs']['port'])) {
            $ret .= ' port=&quot;' . $channelInfo['servers']['primary']['attribs']['port'] . '&quot;';
        }
        $ret .= &quot;&gt;\n&quot;;
        if (isset($channelInfo['servers']['primary']['rest'])) {
            $ret .= $this-&gt;_makeRestXml($channelInfo['servers']['primary']['rest'], '   ');
        }
        $ret .= &quot;  &lt;/primary&gt;\n&quot;;
        if (isset($channelInfo['servers']['mirror'])) {
            $ret .= $this-&gt;_makeMirrorsXml($channelInfo);
        }
        $ret .= &quot; &lt;/servers&gt;\n&quot;;
        $ret .= &quot;&lt;/channel&gt;&quot;;
        return str_replace(&quot;\r&quot;, &quot;\n&quot;, str_replace(&quot;\r\n&quot;, &quot;\n&quot;, $ret));
    }

    /**
     * Generate the &lt;rest&gt; tag
     * @access private
     */
    function _makeRestXml($info, $indent)
    {
        $ret = $indent . &quot;&lt;rest&gt;\n&quot;;
        if (isset($info['baseurl']) &amp;&amp; !isset($info['baseurl'][0])) {
            $info['baseurl'] = array($info['baseurl']);
        }

        if (isset($info['baseurl'])) {
            foreach ($info['baseurl'] as $url) {
                $ret .= &quot;$indent &lt;baseurl type=\&quot;&quot; . $url['attribs']['type'] . &quot;\&quot;&quot;;
                $ret .= &quot;&gt;&quot; . $url['_content'] . &quot;&lt;/baseurl&gt;\n&quot;;
            }
        }
        $ret .= $indent . &quot;&lt;/rest&gt;\n&quot;;
        return $ret;
    }

    /**
     * Generate the &lt;mirrors&gt; tag
     * @access private
     */
    function _makeMirrorsXml($channelInfo)
    {
        $ret = &quot;&quot;;
        if (!isset($channelInfo['servers']['mirror'][0])) {
            $channelInfo['servers']['mirror'] = array($channelInfo['servers']['mirror']);
        }
        foreach ($channelInfo['servers']['mirror'] as $mirror) {
            $ret .= '  &lt;mirror host=&quot;' . $mirror['attribs']['host'] . '&quot;';
            if (isset($mirror['attribs']['port'])) {
                $ret .= ' port=&quot;' . $mirror['attribs']['port'] . '&quot;';
            }
            if (isset($mirror['attribs']['ssl'])) {
                $ret .= ' ssl=&quot;' . $mirror['attribs']['ssl'] . '&quot;';
            }
            $ret .= &quot;&gt;\n&quot;;
            if (isset($mirror['rest'])) {
                if (isset($mirror['rest'])) {
                    $ret .= $this-&gt;_makeRestXml($mirror['rest'], '   ');
                }
                $ret .= &quot;  &lt;/mirror&gt;\n&quot;;
            } else {
                $ret .= &quot;/&gt;\n&quot;;
            }
        }
        return $ret;
    }

    /**
     * Generate the &lt;functions&gt; tag
     * @access private
     */
    function _makeFunctionsXml($functions, $indent, $rest = false)
    {
        $ret = '';
        if (!isset($functions[0])) {
            $functions = array($functions);
        }
        foreach ($functions as $function) {
            $ret .= &quot;$indent&lt;function version=\&quot;&quot; . $function['attribs']['version'] . &quot;\&quot;&quot;;
            if ($rest) {
                $ret .= ' uri=&quot;' . $function['attribs']['uri'] . '&quot;';
            }
            $ret .= &quot;&gt;&quot; . $function['_content'] . &quot;&lt;/function&gt;\n&quot;;
        }
        return $ret;
    }

    /**
     * Validation error.  Also marks the object contents as invalid
     * @param error code
     * @param array error information
     * @access private
     */
    function _validateError($code, $params = array())
    {
        $this-&gt;_stack-&gt;push($code, 'error', $params);
        $this-&gt;_isValid = false;
    }

    /**
     * Validation warning.  Does not mark the object contents invalid.
     * @param error code
     * @param array error information
     * @access private
     */
    function _validateWarning($code, $params = array())
    {
        $this-&gt;_stack-&gt;push($code, 'warning', $params);
    }

    /**
     * Validate parsed file.
     *
     * @access public
     * @return boolean
     */
    function validate()
    {
        $this-&gt;_isValid = true;
        $info = $this-&gt;_channelInfo;
        if (empty($info['name'])) {
            $this-&gt;_validateError(PEAR_CHANNELFILE_ERROR_NO_NAME);
        } elseif (!$this-&gt;validChannelServer($info['name'])) {
            if ($info['name'] != '__uri') {
                $this-&gt;_validateError(PEAR_CHANNELFILE_ERROR_INVALID_NAME, array('tag' =&gt; 'name',
                    'name' =&gt; $info['name']));
            }
        }
        if (empty($info['summary'])) {
            $this-&gt;_validateError(PEAR_CHANNELFILE_ERROR_NO_SUMMARY);
        } elseif (strpos(trim($info['summary']), &quot;\n&quot;) !== false) {
            $this-&gt;_validateWarning(PEAR_CHANNELFILE_ERROR_MULTILINE_SUMMARY,
                array('summary' =&gt; $info['summary']));
        }
        if (isset($info['suggestedalias'])) {
            if (!$this-&gt;validChannelServer($info['suggestedalias'])) {
                $this-&gt;_validateError(PEAR_CHANNELFILE_ERROR_INVALID_NAME,
                    array('tag' =&gt; 'suggestedalias', 'name' =&gt;$info['suggestedalias']));
            }
        }
        if (isset($info['localalias'])) {
            if (!$this-&gt;validChannelServer($info['localalias'])) {
                $this-&gt;_validateError(PEAR_CHANNELFILE_ERROR_INVALID_NAME,
                    array('tag' =&gt; 'localalias', 'name' =&gt;$info['localalias']));
            }
        }
        if (isset($info['validatepackage'])) {
            if (!isset($info['validatepackage']['_content'])) {
                $this-&gt;_validateError(PEAR_CHANNELFILE_ERROR_NOVALIDATE_NAME);
            }
            if (!isset($info['validatepackage']['attribs']['version'])) {
                $content = isset($info['validatepackage']['_content']) ?
                    $info['validatepackage']['_content'] :
                    null;
                $this-&gt;_validateError(PEAR_CHANNELFILE_ERROR_NOVALIDATE_VERSION,
                    array('package' =&gt; $content));
            }
        }

        if (isset($info['servers']['primary']['attribs'], $info['servers']['primary']['attribs']['port']) &amp;&amp;
              !is_numeric($info['servers']['primary']['attribs']['port'])) {
            $this-&gt;_validateError(PEAR_CHANNELFILE_ERROR_INVALID_PORT,
                array('port' =&gt; $info['servers']['primary']['attribs']['port']));
        }

        if (isset($info['servers']['primary']['attribs'], $info['servers']['primary']['attribs']['ssl']) &amp;&amp;
              $info['servers']['primary']['attribs']['ssl'] != 'yes') {
            $this-&gt;_validateError(PEAR_CHANNELFILE_ERROR_INVALID_SSL,
                array('ssl' =&gt; $info['servers']['primary']['attribs']['ssl'],
                    'server' =&gt; $info['name']));
        }

        if (isset($info['servers']['primary']['rest']) &amp;&amp;
              isset($info['servers']['primary']['rest']['baseurl'])) {
            $this-&gt;_validateFunctions('rest', $info['servers']['primary']['rest']['baseurl']);
        }
        if (isset($info['servers']['mirror'])) {
            if ($this-&gt;_channelInfo['name'] == '__uri') {
                $this-&gt;_validateError(PEAR_CHANNELFILE_URI_CANT_MIRROR);
            }
            if (!isset($info['servers']['mirror'][0])) {
                $info['servers']['mirror'] = array($info['servers']['mirror']);
            }
            foreach ($info['servers']['mirror'] as $mirror) {
                if (!isset($mirror['attribs']['host'])) {
                    $this-&gt;_validateError(PEAR_CHANNELFILE_ERROR_NO_HOST,
                      array('type' =&gt; 'mirror'));
                } elseif (!$this-&gt;validChannelServer($mirror['attribs']['host'])) {
                    $this-&gt;_validateError(PEAR_CHANNELFILE_ERROR_INVALID_HOST,
                        array('server' =&gt; $mirror['attribs']['host'], 'type' =&gt; 'mirror'));
                }
                if (isset($mirror['attribs']['ssl']) &amp;&amp; $mirror['attribs']['ssl'] != 'yes') {
                    $this-&gt;_validateError(PEAR_CHANNELFILE_ERROR_INVALID_SSL,
                        array('ssl' =&gt; $info['ssl'], 'server' =&gt; $mirror['attribs']['host']));
                }
                if (isset($mirror['rest'])) {
                    $this-&gt;_validateFunctions('rest', $mirror['rest']['baseurl'],
                        $mirror['attribs']['host']);
                }
            }
        }
        return $this-&gt;_isValid;
    }

    /**
     * @param string  rest - protocol name this function applies to
     * @param array the functions
     * @param string the name of the parent element (mirror name, for instance)
     */
    function _validateFunctions($protocol, $functions, $parent = '')
    {
        if (!isset($functions[0])) {
            $functions = array($functions);
        }

        foreach ($functions as $function) {
            if (!isset($function['_content']) || empty($function['_content'])) {
                $this-&gt;_validateError(PEAR_CHANNELFILE_ERROR_NO_FUNCTIONNAME,
                    array('parent' =&gt; $parent, 'protocol' =&gt; $protocol));
            }

            if ($protocol == 'rest') {
                if (!isset($function['attribs']['type']) ||
                      empty($function['attribs']['type'])) {
                    $this-&gt;_validateError(PEAR_CHANNELFILE_ERROR_NOBASEURLTYPE,
                        array('parent' =&gt; $parent, 'protocol' =&gt; $protocol));
                }
            } else {
                if (!isset($function['attribs']['version']) ||
                      empty($function['attribs']['version'])) {
                    $this-&gt;_validateError(PEAR_CHANNELFILE_ERROR_NO_FUNCTIONVERSION,
                        array('parent' =&gt; $parent, 'protocol' =&gt; $protocol));
                }
            }
        }
    }

    /**
     * Test whether a string contains a valid channel server.
     * @param string $ver the package version to test
     * @return bool
     */
    function validChannelServer($server)
    {
        if ($server == '__uri') {
            return true;
        }
        return (bool) preg_match(PEAR_CHANNELS_SERVER_PREG, $server);
    }

    /**
     * @return string|false
     */
    function getName()
    {
        if (isset($this-&gt;_channelInfo['name'])) {
            return $this-&gt;_channelInfo['name'];
        }

        return false;
    }

    /**
     * @return string|false
     */
    function getServer()
    {
        if (isset($this-&gt;_channelInfo['name'])) {
            return $this-&gt;_channelInfo['name'];
        }

        return false;
    }

    /**
     * @return int|80 port number to connect to
     */
    function getPort($mirror = false)
    {
        if ($mirror) {
            if ($mir = $this-&gt;getMirror($mirror)) {
                if (isset($mir['attribs']['port'])) {
                    return $mir['attribs']['port'];
                }

                if ($this-&gt;getSSL($mirror)) {
                    return 443;
                }

                return 80;
            }

            return false;
        }

        if (isset($this-&gt;_channelInfo['servers']['primary']['attribs']['port'])) {
            return $this-&gt;_channelInfo['servers']['primary']['attribs']['port'];
        }

        if ($this-&gt;getSSL()) {
            return 443;
        }

        return 80;
    }

    /**
     * @return bool Determines whether secure sockets layer (SSL) is used to connect to this channel
     */
    function getSSL($mirror = false)
    {
        if ($mirror) {
            if ($mir = $this-&gt;getMirror($mirror)) {
                if (isset($mir['attribs']['ssl'])) {
                    return true;
                }

                return false;
            }

            return false;
        }

        if (isset($this-&gt;_channelInfo['servers']['primary']['attribs']['ssl'])) {
            return true;
        }

        return false;
    }

    /**
     * @return string|false
     */
    function getSummary()
    {
        if (isset($this-&gt;_channelInfo['summary'])) {
            return $this-&gt;_channelInfo['summary'];
        }

        return false;
    }

    /**
     * @param string protocol type
     * @param string Mirror name
     * @return array|false
     */
    function getFunctions($protocol, $mirror = false)
    {
        if ($this-&gt;getName() == '__uri') {
            return false;
        }

        $function = $protocol == 'rest' ? 'baseurl' : 'function';
        if ($mirror) {
            if ($mir = $this-&gt;getMirror($mirror)) {
                if (isset($mir[$protocol][$function])) {
                    return $mir[$protocol][$function];
                }
            }

            return false;
        }

        if (isset($this-&gt;_channelInfo['servers']['primary'][$protocol][$function])) {
            return $this-&gt;_channelInfo['servers']['primary'][$protocol][$function];
        }

        return false;
    }

    /**
     * @param string Protocol type
     * @param string Function name (null to return the
     *               first protocol of the type requested)
     * @param string Mirror name, if any
     * @return array
     */
     function getFunction($type, $name = null, $mirror = false)
     {
        $protocols = $this-&gt;getFunctions($type, $mirror);
        if (!$protocols) {
            return false;
        }

        foreach ($protocols as $protocol) {
            if ($name === null) {
                return $protocol;
            }

            if ($protocol['_content'] != $name) {
                continue;
            }

            return $protocol;
        }

        return false;
     }

    /**
     * @param string protocol type
     * @param string protocol name
     * @param string version
     * @param string mirror name
     * @return boolean
     */
    function supports($type, $name = null, $mirror = false, $version = '1.0')
    {
        $protocols = $this-&gt;getFunctions($type, $mirror);
        if (!$protocols) {
            return false;
        }

        foreach ($protocols as $protocol) {
            if ($protocol['attribs']['version'] != $version) {
                continue;
            }

            if ($name === null) {
                return true;
            }

            if ($protocol['_content'] != $name) {
                continue;
            }

            return true;
        }

        return false;
    }

    /**
     * Determines whether a channel supports Representational State Transfer (REST) protocols
     * for retrieving channel information
     * @param string
     * @return bool
     */
    function supportsREST($mirror = false)
    {
        if ($mirror == $this-&gt;_channelInfo['name']) {
            $mirror = false;
        }

        if ($mirror) {
            if ($mir = $this-&gt;getMirror($mirror)) {
                return isset($mir['rest']);
            }

            return false;
        }

        return isset($this-&gt;_channelInfo['servers']['primary']['rest']);
    }

    /**
     * Get the URL to access a base resource.
     *
     * Hyperlinks in the returned xml will be used to retrieve the proper information
     * needed.  This allows extreme extensibility and flexibility in implementation
     * @param string Resource Type to retrieve
     */
    function getBaseURL($resourceType, $mirror = false)
    {
        if ($mirror == $this-&gt;_channelInfo['name']) {
            $mirror = false;
        }

        if ($mirror) {
            $mir = $this-&gt;getMirror($mirror);
            if (!$mir) {
                return false;
            }

            $rest = $mir['rest'];
        } else {
            $rest = $this-&gt;_channelInfo['servers']['primary']['rest'];
        }

        if (!isset($rest['baseurl'][0])) {
            $rest['baseurl'] = array($rest['baseurl']);
        }

        foreach ($rest['baseurl'] as $baseurl) {
            if (strtolower($baseurl['attribs']['type']) == strtolower($resourceType)) {
                return $baseurl['_content'];
            }
        }

        return false;
    }

    /**
     * Since REST does not implement RPC, provide this as a logical wrapper around
     * resetFunctions for REST
     * @param string|false mirror name, if any
     */
    function resetREST($mirror = false)
    {
        return $this-&gt;resetFunctions('rest', $mirror);
    }

    /**
     * Empty all protocol definitions
     * @param string protocol type
     * @param string|false mirror name, if any
     */
    function resetFunctions($type, $mirror = false)
    {
        if ($mirror) {
            if (isset($this-&gt;_channelInfo['servers']['mirror'])) {
                $mirrors = $this-&gt;_channelInfo['servers']['mirror'];
                if (!isset($mirrors[0])) {
                    $mirrors = array($mirrors);
                }

                foreach ($mirrors as $i =&gt; $mir) {
                    if ($mir['attribs']['host'] == $mirror) {
                        if (isset($this-&gt;_channelInfo['servers']['mirror'][$i][$type])) {
                            unset($this-&gt;_channelInfo['servers']['mirror'][$i][$type]);
                        }

                        return true;
                    }
                }

                return false;
            }

            return false;
        }

        if (isset($this-&gt;_channelInfo['servers']['primary'][$type])) {
            unset($this-&gt;_channelInfo['servers']['primary'][$type]);
        }

        return true;
    }

    /**
     * Set a channel's protocols to the protocols supported by pearweb
     */
    function setDefaultPEARProtocols($version = '1.0', $mirror = false)
    {
        switch ($version) {
            case '1.0' :
                $this-&gt;resetREST($mirror);

                if (!isset($this-&gt;_channelInfo['servers'])) {
                    $this-&gt;_channelInfo['servers'] = array('primary' =&gt;
                        array('rest' =&gt; array()));
                } elseif (!isset($this-&gt;_channelInfo['servers']['primary'])) {
                    $this-&gt;_channelInfo['servers']['primary'] = array('rest' =&gt; array());
                }

                return true;
            break;
            default :
                return false;
            break;
        }
    }

    /**
     * @return array
     */
    function getMirrors()
    {
        if (isset($this-&gt;_channelInfo['servers']['mirror'])) {
            $mirrors = $this-&gt;_channelInfo['servers']['mirror'];
            if (!isset($mirrors[0])) {
                $mirrors = array($mirrors);
            }

            return $mirrors;
        }

        return array();
    }

    /**
     * Get the unserialized XML representing a mirror
     * @return array|false
     */
    function getMirror($server)
    {
        foreach ($this-&gt;getMirrors() as $mirror) {
            if ($mirror['attribs']['host'] == $server) {
                return $mirror;
            }
        }

        return false;
    }

    /**
     * @param string
     * @return string|false
     * @error PEAR_CHANNELFILE_ERROR_NO_NAME
     * @error PEAR_CHANNELFILE_ERROR_INVALID_NAME
     */
    function setName($name)
    {
        return $this-&gt;setServer($name);
    }

    /**
     * Set the socket number (port) that is used to connect to this channel
     * @param integer
     * @param string|false name of the mirror server, or false for the primary
     */
    function setPort($port, $mirror = false)
    {
        if ($mirror) {
            if (!isset($this-&gt;_channelInfo['servers']['mirror'])) {
                $this-&gt;_validateError(PEAR_CHANNELFILE_ERROR_MIRROR_NOT_FOUND,
                    array('mirror' =&gt; $mirror));
                return false;
            }

            if (isset($this-&gt;_channelInfo['servers']['mirror'][0])) {
                foreach ($this-&gt;_channelInfo['servers']['mirror'] as $i =&gt; $mir) {
                    if ($mirror == $mir['attribs']['host']) {
                        $this-&gt;_channelInfo['servers']['mirror'][$i]['attribs']['port'] = $port;
                        return true;
                    }
                }

                return false;
            } elseif ($this-&gt;_channelInfo['servers']['mirror']['attribs']['host'] == $mirror) {
                $this-&gt;_channelInfo['servers']['mirror']['attribs']['port'] = $port;
                $this-&gt;_isValid = false;
                return true;
            }
        }

        $this-&gt;_channelInfo['servers']['primary']['attribs']['port'] = $port;
        $this-&gt;_isValid = false;
        return true;
    }

    /**
     * Set the socket number (port) that is used to connect to this channel
     * @param bool Determines whether to turn on SSL support or turn it off
     * @param string|false name of the mirror server, or false for the primary
     */
    function setSSL($ssl = true, $mirror = false)
    {
        if ($mirror) {
            if (!isset($this-&gt;_channelInfo['servers']['mirror'])) {
                $this-&gt;_validateError(PEAR_CHANNELFILE_ERROR_MIRROR_NOT_FOUND,
                    array('mirror' =&gt; $mirror));
                return false;
            }

            if (isset($this-&gt;_channelInfo['servers']['mirror'][0])) {
                foreach ($this-&gt;_channelInfo['servers']['mirror'] as $i =&gt; $mir) {
                    if ($mirror == $mir['attribs']['host']) {
                        if (!$ssl) {
                            if (isset($this-&gt;_channelInfo['servers']['mirror'][$i]
                                  ['attribs']['ssl'])) {
                                unset($this-&gt;_channelInfo['servers']['mirror'][$i]['attribs']['ssl']);
                            }
                        } else {
                            $this-&gt;_channelInfo['servers']['mirror'][$i]['attribs']['ssl'] = 'yes';
                        }

                        return true;
                    }
                }

                return false;
            } elseif ($this-&gt;_channelInfo['servers']['mirror']['attribs']['host'] == $mirror) {
                if (!$ssl) {
                    if (isset($this-&gt;_channelInfo['servers']['mirror']['attribs']['ssl'])) {
                        unset($this-&gt;_channelInfo['servers']['mirror']['attribs']['ssl']);
                    }
                } else {
                    $this-&gt;_channelInfo['servers']['mirror']['attribs']['ssl'] = 'yes';
                }

                $this-&gt;_isValid = false;
                return true;
            }
        }

        if ($ssl) {
            $this-&gt;_channelInfo['servers']['primary']['attribs']['ssl'] = 'yes';
        } else {
            if (isset($this-&gt;_channelInfo['servers']['primary']['attribs']['ssl'])) {
                unset($this-&gt;_channelInfo['servers']['primary']['attribs']['ssl']);
            }
        }

        $this-&gt;_isValid = false;
        return true;
    }

    /**
     * @param string
     * @return string|false
     * @error PEAR_CHANNELFILE_ERROR_NO_SERVER
     * @error PEAR_CHANNELFILE_ERROR_INVALID_SERVER
     */
    function setServer($server, $mirror = false)
    {
        if (empty($server)) {
            $this-&gt;_validateError(PEAR_CHANNELFILE_ERROR_NO_SERVER);
            return false;
        } elseif (!$this-&gt;validChannelServer($server)) {
            $this-&gt;_validateError(PEAR_CHANNELFILE_ERROR_INVALID_NAME,
                array('tag' =&gt; 'name', 'name' =&gt; $server));
            return false;
        }

        if ($mirror) {
            $found = false;
            foreach ($this-&gt;_channelInfo['servers']['mirror'] as $i =&gt; $mir) {
                if ($mirror == $mir['attribs']['host']) {
                    $found = true;
                    break;
                }
            }

            if (!$found) {
                $this-&gt;_validateError(PEAR_CHANNELFILE_ERROR_MIRROR_NOT_FOUND,
                    array('mirror' =&gt; $mirror));
                return false;
            }

            $this-&gt;_channelInfo['mirror'][$i]['attribs']['host'] = $server;
            return true;
        }

        $this-&gt;_channelInfo['name'] = $server;
        return true;
    }

    /**
     * @param string
     * @return boolean success
     * @error PEAR_CHANNELFILE_ERROR_NO_SUMMARY
     * @warning PEAR_CHANNELFILE_ERROR_MULTILINE_SUMMARY
     */
    function setSummary($summary)
    {
        if (empty($summary)) {
            $this-&gt;_validateError(PEAR_CHANNELFILE_ERROR_NO_SUMMARY);
            return false;
        } elseif (strpos(trim($summary), &quot;\n&quot;) !== false) {
            $this-&gt;_validateWarning(PEAR_CHANNELFILE_ERROR_MULTILINE_SUMMARY,
                array('summary' =&gt; $summary));
        }

        $this-&gt;_channelInfo['summary'] = $summary;
        return true;
    }

    /**
     * @param string
     * @param boolean determines whether the alias is in channel.xml or local
     * @return boolean success
     */
    function setAlias($alias, $local = false)
    {
        if (!$this-&gt;validChannelServer($alias)) {
            $this-&gt;_validateError(PEAR_CHANNELFILE_ERROR_INVALID_NAME,
                array('tag' =&gt; 'suggestedalias', 'name' =&gt; $alias));
            return false;
        }

        if ($local) {
            $this-&gt;_channelInfo['localalias'] = $alias;
        } else {
            $this-&gt;_channelInfo['suggestedalias'] = $alias;
        }

        return true;
    }

    /**
     * @return string
     */
    function getAlias()
    {
        if (isset($this-&gt;_channelInfo['localalias'])) {
            return $this-&gt;_channelInfo['localalias'];
        }
        if (isset($this-&gt;_channelInfo['suggestedalias'])) {
            return $this-&gt;_channelInfo['suggestedalias'];
        }
        if (isset($this-&gt;_channelInfo['name'])) {
            return $this-&gt;_channelInfo['name'];
        }
        return '';
    }

    /**
     * Set the package validation object if it differs from PEAR's default
     * The class must be includeable via changing _ in the classname to path separator,
     * but no checking of this is made.
     * @param string|false pass in false to reset to the default packagename regex
     * @return boolean success
     */
    function setValidationPackage($validateclass, $version)
    {
        if (empty($validateclass)) {
            unset($this-&gt;_channelInfo['validatepackage']);
        }
        $this-&gt;_channelInfo['validatepackage'] = array('_content' =&gt; $validateclass);
        $this-&gt;_channelInfo['validatepackage']['attribs'] = array('version' =&gt; $version);
    }

    /**
     * Add a protocol to the provides section
     * @param string protocol type
     * @param string protocol version
     * @param string protocol name, if any
     * @param string mirror name, if this is a mirror's protocol
     * @return bool
     */
    function addFunction($type, $version, $name = '', $mirror = false)
    {
        if ($mirror) {
            return $this-&gt;addMirrorFunction($mirror, $type, $version, $name);
        }

        $set = array('attribs' =&gt; array('version' =&gt; $version), '_content' =&gt; $name);
        if (!isset($this-&gt;_channelInfo['servers']['primary'][$type]['function'])) {
            if (!isset($this-&gt;_channelInfo['servers'])) {
                $this-&gt;_channelInfo['servers'] = array('primary' =&gt;
                    array($type =&gt; array()));
            } elseif (!isset($this-&gt;_channelInfo['servers']['primary'])) {
                $this-&gt;_channelInfo['servers']['primary'] = array($type =&gt; array());
            }

            $this-&gt;_channelInfo['servers']['primary'][$type]['function'] = $set;
            $this-&gt;_isValid = false;
            return true;
        } elseif (!isset($this-&gt;_channelInfo['servers']['primary'][$type]['function'][0])) {
            $this-&gt;_channelInfo['servers']['primary'][$type]['function'] = array(
                $this-&gt;_channelInfo['servers']['primary'][$type]['function']);
        }

        $this-&gt;_channelInfo['servers']['primary'][$type]['function'][] = $set;
        return true;
    }
    /**
     * Add a protocol to a mirror's provides section
     * @param string mirror name (server)
     * @param string protocol type
     * @param string protocol version
     * @param string protocol name, if any
     */
    function addMirrorFunction($mirror, $type, $version, $name = '')
    {
        if (!isset($this-&gt;_channelInfo['servers']['mirror'])) {
            $this-&gt;_validateError(PEAR_CHANNELFILE_ERROR_MIRROR_NOT_FOUND,
                array('mirror' =&gt; $mirror));
            return false;
        }

        $setmirror = false;
        if (isset($this-&gt;_channelInfo['servers']['mirror'][0])) {
            foreach ($this-&gt;_channelInfo['servers']['mirror'] as $i =&gt; $mir) {
                if ($mirror == $mir['attribs']['host']) {
                    $setmirror = &amp;$this-&gt;_channelInfo['servers']['mirror'][$i];
                    break;
                }
            }
        } else {
            if ($this-&gt;_channelInfo['servers']['mirror']['attribs']['host'] == $mirror) {
                $setmirror = &amp;$this-&gt;_channelInfo['servers']['mirror'];
            }
        }

        if (!$setmirror) {
            $this-&gt;_validateError(PEAR_CHANNELFILE_ERROR_MIRROR_NOT_FOUND,
                array('mirror' =&gt; $mirror));
            return false;
        }

        $set = array('attribs' =&gt; array('version' =&gt; $version), '_content' =&gt; $name);
        if (!isset($setmirror[$type]['function'])) {
            $setmirror[$type]['function'] = $set;
            $this-&gt;_isValid = false;
            return true;
        } elseif (!isset($setmirror[$type]['function'][0])) {
            $setmirror[$type]['function'] = array($setmirror[$type]['function']);
        }

        $setmirror[$type]['function'][] = $set;
        $this-&gt;_isValid = false;
        return true;
    }

    /**
     * @param string Resource Type this url links to
     * @param string URL
     * @param string|false mirror name, if this is not a primary server REST base URL
     */
    function setBaseURL($resourceType, $url, $mirror = false)
    {
        if ($mirror) {
            if (!isset($this-&gt;_channelInfo['servers']['mirror'])) {
                $this-&gt;_validateError(PEAR_CHANNELFILE_ERROR_MIRROR_NOT_FOUND,
                    array('mirror' =&gt; $mirror));
                return false;
            }

            $setmirror = false;
            if (isset($this-&gt;_channelInfo['servers']['mirror'][0])) {
                foreach ($this-&gt;_channelInfo['servers']['mirror'] as $i =&gt; $mir) {
                    if ($mirror == $mir['attribs']['host']) {
                        $setmirror = &amp;$this-&gt;_channelInfo['servers']['mirror'][$i];
                        break;
                    }
                }
            } else {
                if ($this-&gt;_channelInfo['servers']['mirror']['attribs']['host'] == $mirror) {
                    $setmirror = &amp;$this-&gt;_channelInfo['servers']['mirror'];
                }
            }
        } else {
            $setmirror = &amp;$this-&gt;_channelInfo['servers']['primary'];
        }

        $set = array('attribs' =&gt; array('type' =&gt; $resourceType), '_content' =&gt; $url);
        if (!isset($setmirror['rest'])) {
            $setmirror['rest'] = array();
        }

        if (!isset($setmirror['rest']['baseurl'])) {
            $setmirror['rest']['baseurl'] = $set;
            $this-&gt;_isValid = false;
            return true;
        } elseif (!isset($setmirror['rest']['baseurl'][0])) {
            $setmirror['rest']['baseurl'] = array($setmirror['rest']['baseurl']);
        }

        foreach ($setmirror['rest']['baseurl'] as $i =&gt; $url) {
            if ($url['attribs']['type'] == $resourceType) {
                $this-&gt;_isValid = false;
                $setmirror['rest']['baseurl'][$i] = $set;
                return true;
            }
        }

        $setmirror['rest']['baseurl'][] = $set;
        $this-&gt;_isValid = false;
        return true;
    }

    /**
     * @param string mirror server
     * @param int mirror http port
     * @return boolean
     */
    function addMirror($server, $port = null)
    {
        if ($this-&gt;_channelInfo['name'] == '__uri') {
            return false; // the __uri channel cannot have mirrors by definition
        }

        $set = array('attribs' =&gt; array('host' =&gt; $server));
        if (is_numeric($port)) {
            $set['attribs']['port'] = $port;
        }

        if (!isset($this-&gt;_channelInfo['servers']['mirror'])) {
            $this-&gt;_channelInfo['servers']['mirror'] = $set;
            return true;
        }

        if (!isset($this-&gt;_channelInfo['servers']['mirror'][0])) {
            $this-&gt;_channelInfo['servers']['mirror'] =
                array($this-&gt;_channelInfo['servers']['mirror']);
        }

        $this-&gt;_channelInfo['servers']['mirror'][] = $set;
        return true;
    }

    /**
     * Retrieve the name of the validation package for this channel
     * @return string|false
     */
    function getValidationPackage()
    {
        if (!$this-&gt;_isValid &amp;&amp; !$this-&gt;validate()) {
            return false;
        }

        if (!isset($this-&gt;_channelInfo['validatepackage'])) {
            return array('attribs' =&gt; array('version' =&gt; 'default'),
                '_content' =&gt; 'PEAR_Validate');
        }

        return $this-&gt;_channelInfo['validatepackage'];
    }

    /**
     * Retrieve the object that can be used for custom validation
     * @param string|false the name of the package to validate.  If the package is
     *                     the channel validation package, PEAR_Validate is returned
     * @return PEAR_Validate|false false is returned if the validation package
     *         cannot be located
     */
    function &amp;getValidationObject($package = false)
    {
        if (!class_exists('PEAR_Validate')) {
            require_once 'PEAR/Validate.php';
        }

        if (!$this-&gt;_isValid) {
            if (!$this-&gt;validate()) {
                $a = false;
                return $a;
            }
        }

        if (isset($this-&gt;_channelInfo['validatepackage'])) {
            if ($package == $this-&gt;_channelInfo['validatepackage']) {
                // channel validation packages are always validated by PEAR_Validate
                $val = new PEAR_Validate;
                return $val;
            }

            if (!class_exists(str_replace('.', '_',
                  $this-&gt;_channelInfo['validatepackage']['_content']))) {
                if ($this-&gt;isIncludeable(str_replace('_', '/',
                      $this-&gt;_channelInfo['validatepackage']['_content']) . '.php')) {
                    include_once str_replace('_', '/',
                        $this-&gt;_channelInfo['validatepackage']['_content']) . '.php';
                    $vclass = str_replace('.', '_',
                        $this-&gt;_channelInfo['validatepackage']['_content']);
                    $val = new $vclass;
                } else {
                    $a = false;
                    return $a;
                }
            } else {
                $vclass = str_replace('.', '_',
                    $this-&gt;_channelInfo['validatepackage']['_content']);
                $val = new $vclass;
            }
        } else {
            $val = new PEAR_Validate;
        }

        return $val;
    }

    function isIncludeable($path)
    {
        $possibilities = explode(PATH_SEPARATOR, ini_get('include_path'));
        foreach ($possibilities as $dir) {
            if (file_exists($dir . DIRECTORY_SEPARATOR . $path)
                  &amp;&amp; is_readable($dir . DIRECTORY_SEPARATOR . $path)) {
                return true;
            }
        }

        return false;
    }

    /**
     * This function is used by the channel updater and retrieves a value set by
     * the registry, or the current time if it has not been set
     * @return string
     */
    function lastModified()
    {
        if (isset($this-&gt;_channelInfo['_lastmodified'])) {
            return $this-&gt;_channelInfo['_lastmodified'];
        }

        return time();
    }
}
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fopt%2Fcpanel%2Fea-php72%2Froot%2Fusr%2Fshare%2Fpear%2FPEAR'>Back to Directory</a>