WebSVN – Applications.gtt – Diff – /trunk/bibliotheque/pear/PEAR/ChannelFile.php


<?php
/**
 * PEAR_ChannelFile, the channel handling class
 *
 * PHP versions 4 and 5
 *
 
 
 
 
 
 
 * @category   pear
 * @package    PEAR
 * @author     Greg Beaver <cellog@php.net>
 * @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 <channel> tag does not contain a valid version
 */
define('PEAR_CHANNELFILE_ERROR_NO_VERSION', 1);
/**
 * Error code if the channel.xml <channel> 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 <function> tag has no version
 */
define('PEAR_CHANNELFILE_ERROR_NO_FUNCTIONVERSION', 25);
/**
 * Error code when a <function> tag has no name
 */
define('PEAR_CHANNELFILE_ERROR_NO_FUNCTIONNAME', 26);
/**
 * Error code when a <validatepackage> tag has no name
 */
define('PEAR_CHANNELFILE_ERROR_NOVALIDATE_NAME', 27);
/**
 * Error code when a <validatepackage> 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 <static> contains no version attribute
 */
define('PEAR_CHANNELFILE_ERROR_NO_STATICVERSION', 34);
/**
 * Error code when <baseurl> contains no type attribute in a <rest> 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 "yes"
 */
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 <cellog@php.net>
 * @copyright  1997-2009 The Authors
 * @license    http://opensource.org/licenses/bsd-license.php New BSD License
 * @version    Release: 1.10.1
 * @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->_stack = new PEAR_ErrorStack('PEAR_ChannelFile');
        $this->_stack->setErrorMessageTemplate($this->_getErrorMessage());
        $this->_isValid = false;
    }
 
    /**
     * @return array
     * @access protected
     */
    function _getErrorMessage()
    {
        return
            array(
                PEAR_CHANNELFILE_ERROR_INVALID_VERSION =>
                    'While parsing channel.xml, an invalid version number "%version% was passed in, expecting one of %versions%',
                PEAR_CHANNELFILE_ERROR_NO_VERSION =>
                    'No version number found in <channel> tag',
                PEAR_CHANNELFILE_ERROR_NO_XML_EXT =>
                    '%error%',
                PEAR_CHANNELFILE_ERROR_CANT_MAKE_PARSER =>
                    'Unable to create XML parser',
                PEAR_CHANNELFILE_ERROR_PARSER_ERROR =>
                    '%error%',
                PEAR_CHANNELFILE_ERROR_NO_NAME =>
                    'Missing channel name',
                PEAR_CHANNELFILE_ERROR_INVALID_NAME =>
                    'Invalid channel %tag% "%name%"',
                PEAR_CHANNELFILE_ERROR_NO_SUMMARY =>
                    'Missing channel summary',
                PEAR_CHANNELFILE_ERROR_MULTILINE_SUMMARY =>
                    'Channel summary should be on one line, but is multi-line',
                PEAR_CHANNELFILE_ERROR_NO_HOST =>
                    'Missing channel server for %type% server',
                PEAR_CHANNELFILE_ERROR_INVALID_HOST =>
                    'Server name "%server%" is invalid for %type% server',
                PEAR_CHANNELFILE_ERROR_INVALID_MIRROR =>
                    'Invalid mirror name "%name%", mirror type %type%',
                PEAR_CHANNELFILE_ERROR_INVALID_MIRRORTYPE =>
                    'Invalid mirror type "%type%"',
                PEAR_CHANNELFILE_ERROR_INVALID =>
                    'Cannot generate xml, contents are invalid',
                PEAR_CHANNELFILE_ERROR_EMPTY_REGEX =>
                    'packagenameregex cannot be empty',
                PEAR_CHANNELFILE_ERROR_NO_FUNCTIONVERSION =>
                    '%parent% %protocol% function has no version',
                PEAR_CHANNELFILE_ERROR_NO_FUNCTIONNAME =>
                    '%parent% %protocol% function has no name',
                PEAR_CHANNELFILE_ERROR_NOBASEURLTYPE =>
                    '%parent% rest baseurl has no type',
                PEAR_CHANNELFILE_ERROR_NOVALIDATE_NAME =>
                    'Validation package has no name in <validatepackage> tag',
                PEAR_CHANNELFILE_ERROR_NOVALIDATE_VERSION =>
                    'Validation package "%package%" has no version',
                PEAR_CHANNELFILE_ERROR_MIRROR_NOT_FOUND =>
                    'Mirror "%mirror%" does not exist',
                PEAR_CHANNELFILE_ERROR_INVALID_PORT =>
                    'Port "%port%" must be numeric',
                PEAR_CHANNELFILE_ERROR_NO_STATICVERSION =>
                    '<static> tag must contain version attribute',
                PEAR_CHANNELFILE_URI_CANT_MIRROR =>
                    'The __uri pseudo-channel cannot have mirrors',
                PEAR_CHANNELFILE_ERROR_INVALID_SSL =>
                    '%server% has invalid ssl attribute "%ssl%" 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('/<channel\s+version="([0-9]+\.[0-9]+)"/', $data, $channelversion)) {
            if (!in_array($channelversion[1], $this->_supportedVersions)) {
                $this->_stack->push(PEAR_CHANNELFILE_ERROR_INVALID_VERSION, 'error',
                    array('version' => $channelversion[1]));
                return false;
            }
            $parser = new PEAR_XMLParser;
            $result = $parser->parse($data);
            if ($result !== true) {
                if ($result->getCode() == 1) {
                    $this->_stack->push(PEAR_CHANNELFILE_ERROR_NO_XML_EXT, 'error',
                        array('error' => $result->getMessage()));
                } else {
                    $this->_stack->push(PEAR_CHANNELFILE_ERROR_CANT_MAKE_PARSER, 'error');
                }
                return false;
            }
            $this->_channelInfo = $parser->getData();
            return true;
        } else {
            $this->_stack->push(PEAR_CHANNELFILE_ERROR_NO_VERSION, 'error', array('xml' => $data));
            return false;
        }
    }
 
    /**
     * @return array
     */
    function toArray()
    {
        if (!$this->_isValid && !$this->validate()) {
            return false;
        }
        return $this->_channelInfo;
    }
 
    /**
     * @param array
     *
     * @return PEAR_ChannelFile|false false if invalid
     */
    public static function &fromArray(
        $data, $compatibility = false, $stackClass = 'PEAR_ErrorStack'
    ) {
        $a = new PEAR_ChannelFile($compatibility, $stackClass);
        $a->_fromArray($data);
        if (!$a->validate()) {
            $a = false;
            return $a;
        }
        return $a;
    }
 
    /**
     * Unlike {@link fromArray()} this does not do any validation
     *
     * @param array
     *
     * @return PEAR_ChannelFile
     */
    public static function &fromArrayWithErrors(
        $data, $compatibility = false, $stackClass = 'PEAR_ErrorStack'
    ) {
        $a = new PEAR_ChannelFile($compatibility, $stackClass);
        $a->_fromArray($data);
        return $a;
    }
 
    /**
     * @param array
     * @access private
     */
    function _fromArray($data)
    {
        $this->_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->_stack->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, " \t");
        $indent = substr($str, 0, $indent_len);
        $data = '';
        // remove the same amount of whitespace from following lines
        foreach (explode("\n", $str) as $line) {
            if (substr($line, 0, $indent_len) == $indent) {
                $data .= substr($line, $indent_len) . "\n";
            }
        }
        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("Unable to open $descfile");
        }
 
        // 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->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) && file_exists($info) && strlen($info) < 255) {
            $tmp = substr($info, -4);
            if ($tmp == '.xml') {
                $info = $this->fromXmlFile($info);
            } else {
                $fp = fopen($info, "r");
                $test = fread($fp, 5);
                fclose($fp);
                if ($test == "<?xml") {
                    $info = $this->fromXmlFile($info);
                }
            }
            if (PEAR::isError($info)) {
                require_once 'PEAR.php';
                return PEAR::raiseError($info);
            }
        }
        if (is_string($info)) {
            $info = $this->fromXmlString($info);
        }
        return $info;
    }
 
    /**
     * Return an XML document based on previous parsing and modifications
     *
     * @return string XML data
     *
     * @access public
     */
    function toXml()
    {
        if (!$this->_isValid && !$this->validate()) {
            $this->_validateError(PEAR_CHANNELFILE_ERROR_INVALID);
            return false;
        }
        if (!isset($this->_channelInfo['attribs']['version'])) {
            $this->_channelInfo['attribs']['version'] = '1.0';
        }
        $channelInfo = $this->_channelInfo;
        $ret = "<?xml version=\"1.0\" encoding=\"ISO-8859-1\" ?>\n";
        $ret .= "<channel version=\"" .
            $channelInfo['attribs']['version'] . "\" xmlns=\"http://pear.php.net/channel-1.0\"
  xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"
  xsi:schemaLocation=\"http://pear.php.net/dtd/channel-"
            . $channelInfo['attribs']['version'] . " http://pear.php.net/dtd/channel-" .
            $channelInfo['attribs']['version'] . ".xsd\">
 <name>$channelInfo[name]</name>
 <summary>" . htmlspecialchars($channelInfo['summary'])."</summary>
";
        if (isset($channelInfo['suggestedalias'])) {
            $ret .= ' <suggestedalias>' . $channelInfo['suggestedalias'] . "</suggestedalias>\n";
        }
        if (isset($channelInfo['validatepackage'])) {
            $ret .= ' <validatepackage version="' .
                $channelInfo['validatepackage']['attribs']['version']. '">' .
                htmlspecialchars($channelInfo['validatepackage']['_content']) .
                "</validatepackage>\n";
        }
        $ret .= " <servers>\n";
        $ret .= '  <primary';
        if (isset($channelInfo['servers']['primary']['attribs']['ssl'])) {
            $ret .= ' ssl="' . $channelInfo['servers']['primary']['attribs']['ssl'] . '"';
        }
        if (isset($channelInfo['servers']['primary']['attribs']['port'])) {
            $ret .= ' port="' . $channelInfo['servers']['primary']['attribs']['port'] . '"';
        }
        $ret .= ">\n";
 
 
 
        if (isset($channelInfo['servers']['primary']['rest'])) {
            $ret .= $this->_makeRestXml($channelInfo['servers']['primary']['rest'], '   ');
        }
 
 
 
        $ret .= "  </primary>\n";
        if (isset($channelInfo['servers']['mirror'])) {
            $ret .= $this->_makeMirrorsXml($channelInfo);
        }
        $ret .= " </servers>\n";
        $ret .= "</channel>";
        return str_replace("\r", "\n", str_replace("\r\n", "\n", $ret));
    }
 
    /**
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
     * Generate the <rest> tag
     * @access private
     */
    function _makeRestXml($info, $indent)
    {
        $ret = $indent . "<rest>\n";
        if (isset($info['baseurl']) && !isset($info['baseurl'][0])) {
            $info['baseurl'] = array($info['baseurl']);
        }
 
        if (isset($info['baseurl'])) {
            foreach ($info['baseurl'] as $url) {
                $ret .= "$indent <baseurl type=\"" . $url['attribs']['type'] . "\"";
                $ret .= ">" . $url['_content'] . "</baseurl>\n";
            }
        }
        $ret .= $indent . "</rest>\n";
        return $ret;
    }
 
    /**
     * Generate the <mirrors> tag
     * @access private
     */
    function _makeMirrorsXml($channelInfo)
    {
        $ret = "";
        if (!isset($channelInfo['servers']['mirror'][0])) {
            $channelInfo['servers']['mirror'] = array($channelInfo['servers']['mirror']);
        }
        foreach ($channelInfo['servers']['mirror'] as $mirror) {
            $ret .= '  <mirror host="' . $mirror['attribs']['host'] . '"';
            if (isset($mirror['attribs']['port'])) {
                $ret .= ' port="' . $mirror['attribs']['port'] . '"';
            }
            if (isset($mirror['attribs']['ssl'])) {
                $ret .= ' ssl="' . $mirror['attribs']['ssl'] . '"';
            }
            $ret .= ">\n";
 
            if (isset($mirror['rest'])) {
 
 
                if (isset($mirror['rest'])) {
                    $ret .= $this->_makeRestXml($mirror['rest'], '   ');
                }
 
 
 
                $ret .= "  </mirror>\n";
            } else {
                $ret .= "/>\n";
            }
        }
        return $ret;
    }
 
    /**
     * Generate the <functions> tag
     * @access private
     */
    function _makeFunctionsXml($functions, $indent, $rest = false)
    {
        $ret = '';
        if (!isset($functions[0])) {
            $functions = array($functions);
        }
        foreach ($functions as $function) {
            $ret .= "$indent<function version=\"" . $function['attribs']['version'] . "\"";
            if ($rest) {
                $ret .= ' uri="' . $function['attribs']['uri'] . '"';
            }
            $ret .= ">" . $function['_content'] . "</function>\n";
        }
        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->_stack->push($code, 'error', $params);
        $this->_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->_stack->push($code, 'warning', $params);
    }
 
    /**
     * Validate parsed file.
     *
     * @access public
     * @return boolean
     */
    function validate()
    {
        $this->_isValid = true;
        $info = $this->_channelInfo;
        if (empty($info['name'])) {
            $this->_validateError(PEAR_CHANNELFILE_ERROR_NO_NAME);
        } elseif (!$this->validChannelServer($info['name'])) {
            if ($info['name'] != '__uri') {
                $this->_validateError(PEAR_CHANNELFILE_ERROR_INVALID_NAME, array('tag' => 'name',
                    'name' => $info['name']));
            }
        }
        if (empty($info['summary'])) {
            $this->_validateError(PEAR_CHANNELFILE_ERROR_NO_SUMMARY);
        } elseif (strpos(trim($info['summary']), "\n") !== false) {
            $this->_validateWarning(PEAR_CHANNELFILE_ERROR_MULTILINE_SUMMARY,
                array('summary' => $info['summary']));
        }
        if (isset($info['suggestedalias'])) {
            if (!$this->validChannelServer($info['suggestedalias'])) {
                $this->_validateError(PEAR_CHANNELFILE_ERROR_INVALID_NAME,
                    array('tag' => 'suggestedalias', 'name' =>$info['suggestedalias']));
            }
        }
        if (isset($info['localalias'])) {
            if (!$this->validChannelServer($info['localalias'])) {
                $this->_validateError(PEAR_CHANNELFILE_ERROR_INVALID_NAME,
                    array('tag' => 'localalias', 'name' =>$info['localalias']));
            }
        }
        if (isset($info['validatepackage'])) {
            if (!isset($info['validatepackage']['_content'])) {
                $this->_validateError(PEAR_CHANNELFILE_ERROR_NOVALIDATE_NAME);
            }
            if (!isset($info['validatepackage']['attribs']['version'])) {
                $content = isset($info['validatepackage']['_content']) ?
                    $info['validatepackage']['_content'] :
                    null;
                $this->_validateError(PEAR_CHANNELFILE_ERROR_NOVALIDATE_VERSION,
                    array('package' => $content));
            }
        }
 
        if (isset($info['servers']['primary']['attribs'], $info['servers']['primary']['attribs']['port']) &&
              !is_numeric($info['servers']['primary']['attribs']['port'])) {
            $this->_validateError(PEAR_CHANNELFILE_ERROR_INVALID_PORT,
                array('port' => $info['servers']['primary']['attribs']['port']));
        }
 
        if (isset($info['servers']['primary']['attribs'], $info['servers']['primary']['attribs']['ssl']) &&
              $info['servers']['primary']['attribs']['ssl'] != 'yes') {
            $this->_validateError(PEAR_CHANNELFILE_ERROR_INVALID_SSL,
                array('ssl' => $info['servers']['primary']['attribs']['ssl'],
                    'server' => $info['name']));
        }
 
 
 
 
 
 
 
 
 
        if (isset($info['servers']['primary']['rest']) &&
              isset($info['servers']['primary']['rest']['baseurl'])) {
            $this->_validateFunctions('rest', $info['servers']['primary']['rest']['baseurl']);
        }
        if (isset($info['servers']['mirror'])) {
            if ($this->_channelInfo['name'] == '__uri') {
                $this->_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->_validateError(PEAR_CHANNELFILE_ERROR_NO_HOST,
                      array('type' => 'mirror'));
                } elseif (!$this->validChannelServer($mirror['attribs']['host'])) {
                    $this->_validateError(PEAR_CHANNELFILE_ERROR_INVALID_HOST,
                        array('server' => $mirror['attribs']['host'], 'type' => 'mirror'));
                }
                if (isset($mirror['attribs']['ssl']) && $mirror['attribs']['ssl'] != 'yes') {
                    $this->_validateError(PEAR_CHANNELFILE_ERROR_INVALID_SSL,
                        array('ssl' => $info['ssl'], 'server' => $mirror['attribs']['host']));
                }
 
 
 
 
 
 
 
 
                if (isset($mirror['rest'])) {
                    $this->_validateFunctions('rest', $mirror['rest']['baseurl'],
                        $mirror['attribs']['host']);
                }
            }
        }
        return $this->_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->_validateError(PEAR_CHANNELFILE_ERROR_NO_FUNCTIONNAME,
                    array('parent' => $parent, 'protocol' => $protocol));
            }
 
            if ($protocol == 'rest') {
                if (!isset($function['attribs']['type']) ||
                      empty($function['attribs']['type'])) {
                    $this->_validateError(PEAR_CHANNELFILE_ERROR_NOBASEURLTYPE,
                        array('parent' => $parent, 'protocol' => $protocol));
                }
            } else {
                if (!isset($function['attribs']['version']) ||
                      empty($function['attribs']['version'])) {
                    $this->_validateError(PEAR_CHANNELFILE_ERROR_NO_FUNCTIONVERSION,
                        array('parent' => $parent, 'protocol' => $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->_channelInfo['name'])) {
            return $this->_channelInfo['name'];
 
 
        }
 
        return false;
    }
 
    /**
     * @return string|false
     */
    function getServer()
    {
        if (isset($this->_channelInfo['name'])) {
            return $this->_channelInfo['name'];
 
 
        }
 
        return false;
    }
 
    /**
     * @return int|80 port number to connect to
     */
    function getPort($mirror = false)
    {
        if ($mirror) {
            if ($mir = $this->getMirror($mirror)) {
                if (isset($mir['attribs']['port'])) {
                    return $mir['attribs']['port'];
 
 
 
 
 
                }
 
                if ($this->getSSL($mirror)) {
                    return 443;
                }
 
                return 80;
            }
 
            return false;
        }
 
        if (isset($this->_channelInfo['servers']['primary']['attribs']['port'])) {
            return $this->_channelInfo['servers']['primary']['attribs']['port'];
        }
 
        if ($this->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->getMirror($mirror)) {
                if (isset($mir['attribs']['ssl'])) {
                    return true;
 
 
                }
 
                return false;
            }
 
            return false;
        }
 
        if (isset($this->_channelInfo['servers']['primary']['attribs']['ssl'])) {
            return true;
        }
 
        return false;
    }
 
    /**
     * @return string|false
     */
    function getSummary()
    {
        if (isset($this->_channelInfo['summary'])) {
            return $this->_channelInfo['summary'];
 
 
        }
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
        return false;
    }
 
    /**
     * @param string protocol type
     * @param string Mirror name
     * @return array|false
     */
    function getFunctions($protocol, $mirror = false)
    {
        if ($this->getName() == '__uri') {
            return false;
        }
 
        $function = $protocol == 'rest' ? 'baseurl' : 'function';
 
 
 
 
        if ($mirror) {
            if ($mir = $this->getMirror($mirror)) {
                if (isset($mir[$protocol][$function])) {
                    return $mir[$protocol][$function];
                }
            }
 
            return false;
        }
 
        if (isset($this->_channelInfo['servers']['primary'][$protocol][$function])) {
            return $this->_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->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->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->_channelInfo['name']) {
            $mirror = false;
        }
 
        if ($mirror) {
            if ($mir = $this->getMirror($mirror)) {
                return isset($mir['rest']);
            }
 
            return false;
        }
 
        return isset($this->_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->_channelInfo['name']) {
            $mirror = false;
        }
 
        if ($mirror) {
            $mir = $this->getMirror($mirror);
 
            if (!$mir) {
                return false;
            }
 
            $rest = $mir['rest'];
        } else {
            $rest = $this->_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->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->_channelInfo['servers']['mirror'])) {
                $mirrors = $this->_channelInfo['servers']['mirror'];
                if (!isset($mirrors[0])) {
                    $mirrors = array($mirrors);
                }
 
                foreach ($mirrors as $i => $mir) {
                    if ($mir['attribs']['host'] == $mirror) {
                        if (isset($this->_channelInfo['servers']['mirror'][$i][$type])) {
                            unset($this->_channelInfo['servers']['mirror'][$i][$type]);
                        }
 
                        return true;
                    }
                }
 
                return false;
 
 
 
 
 
 
            }
 
            return false;
        }
 
        if (isset($this->_channelInfo['servers']['primary'][$type])) {
            unset($this->_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->resetREST($mirror);
 
                if (!isset($this->_channelInfo['servers'])) {
 
                    $this->_channelInfo['servers'] = array('primary' =>
                        array('rest' => array()));
 
                } elseif (!isset($this->_channelInfo['servers']['primary'])) {
 
 
                    $this->_channelInfo['servers']['primary'] = array('rest' => array());
                }
 
                return true;
            break;
            default :
                return false;
            break;
        }
    }
 
    /**
     * @return array
     */
    function getMirrors()
    {
        if (isset($this->_channelInfo['servers']['mirror'])) {
            $mirrors = $this->_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->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->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->_channelInfo['servers']['mirror'])) {
                $this->_validateError(PEAR_CHANNELFILE_ERROR_MIRROR_NOT_FOUND,
                    array('mirror' => $mirror));
                return false;
            }
 
 
            if (isset($this->_channelInfo['servers']['mirror'][0])) {
                foreach ($this->_channelInfo['servers']['mirror'] as $i => $mir) {
                    if ($mirror == $mir['attribs']['host']) {
                        $this->_channelInfo['servers']['mirror'][$i]['attribs']['port'] = $port;
                        return true;
                    }
                }
 
                return false;
            } elseif ($this->_channelInfo['servers']['mirror']['attribs']['host'] == $mirror) {
                $this->_channelInfo['servers']['mirror']['attribs']['port'] = $port;
                $this->_isValid = false;
                return true;
            }
        }
 
        $this->_channelInfo['servers']['primary']['attribs']['port'] = $port;
        $this->_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->_channelInfo['servers']['mirror'])) {
                $this->_validateError(PEAR_CHANNELFILE_ERROR_MIRROR_NOT_FOUND,
                    array('mirror' => $mirror));
                return false;
            }
 
 
            if (isset($this->_channelInfo['servers']['mirror'][0])) {
                foreach ($this->_channelInfo['servers']['mirror'] as $i => $mir) {
                    if ($mirror == $mir['attribs']['host']) {
                        if (!$ssl) {
                            if (isset($this->_channelInfo['servers']['mirror'][$i]
                                  ['attribs']['ssl'])) {
                                unset($this->_channelInfo['servers']['mirror'][$i]['attribs']['ssl']);
                            }
                        } else {
                            $this->_channelInfo['servers']['mirror'][$i]['attribs']['ssl'] = 'yes';
                        }
 
                        return true;
                    }
                }
 
                return false;
            } elseif ($this->_channelInfo['servers']['mirror']['attribs']['host'] == $mirror) {
                if (!$ssl) {
                    if (isset($this->_channelInfo['servers']['mirror']['attribs']['ssl'])) {
                        unset($this->_channelInfo['servers']['mirror']['attribs']['ssl']);
                    }
                } else {
                    $this->_channelInfo['servers']['mirror']['attribs']['ssl'] = 'yes';
                }
 
                $this->_isValid = false;
                return true;
            }
        }
 
        if ($ssl) {
            $this->_channelInfo['servers']['primary']['attribs']['ssl'] = 'yes';
        } else {
            if (isset($this->_channelInfo['servers']['primary']['attribs']['ssl'])) {
                unset($this->_channelInfo['servers']['primary']['attribs']['ssl']);
            }
        }
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
        $this->_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->_validateError(PEAR_CHANNELFILE_ERROR_NO_SERVER);
            return false;
        } elseif (!$this->validChannelServer($server)) {
            $this->_validateError(PEAR_CHANNELFILE_ERROR_INVALID_NAME,
                array('tag' => 'name', 'name' => $server));
            return false;
        }
 
        if ($mirror) {
            $found = false;
            foreach ($this->_channelInfo['servers']['mirror'] as $i => $mir) {
                if ($mirror == $mir['attribs']['host']) {
                    $found = true;
                    break;
                }
            }
 
            if (!$found) {
                $this->_validateError(PEAR_CHANNELFILE_ERROR_MIRROR_NOT_FOUND,
                    array('mirror' => $mirror));
                return false;
            }
 
            $this->_channelInfo['mirror'][$i]['attribs']['host'] = $server;
            return true;
        }
 
        $this->_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->_validateError(PEAR_CHANNELFILE_ERROR_NO_SUMMARY);
            return false;
        } elseif (strpos(trim($summary), "\n") !== false) {
            $this->_validateWarning(PEAR_CHANNELFILE_ERROR_MULTILINE_SUMMARY,
                array('summary' => $summary));
        }
 
        $this->_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->validChannelServer($alias)) {
            $this->_validateError(PEAR_CHANNELFILE_ERROR_INVALID_NAME,
                array('tag' => 'suggestedalias', 'name' => $alias));
            return false;
        }
 
        if ($local) {
            $this->_channelInfo['localalias'] = $alias;
        } else {
            $this->_channelInfo['suggestedalias'] = $alias;
        }
 
        return true;
    }
 
    /**
     * @return string
     */
    function getAlias()
    {
        if (isset($this->_channelInfo['localalias'])) {
            return $this->_channelInfo['localalias'];
        }
        if (isset($this->_channelInfo['suggestedalias'])) {
            return $this->_channelInfo['suggestedalias'];
        }
        if (isset($this->_channelInfo['name'])) {
            return $this->_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->_channelInfo['validatepackage']);
        }
        $this->_channelInfo['validatepackage'] = array('_content' => $validateclass);
        $this->_channelInfo['validatepackage']['attribs'] = array('version' => $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->addMirrorFunction($mirror, $type, $version, $name);
        }
 
        $set = array('attribs' => array('version' => $version), '_content' => $name);
        if (!isset($this->_channelInfo['servers']['primary'][$type]['function'])) {
            if (!isset($this->_channelInfo['servers'])) {
                $this->_channelInfo['servers'] = array('primary' =>
                    array($type => array()));
            } elseif (!isset($this->_channelInfo['servers']['primary'])) {
                $this->_channelInfo['servers']['primary'] = array($type => array());
            }
 
            $this->_channelInfo['servers']['primary'][$type]['function'] = $set;
            $this->_isValid = false;
            return true;
        } elseif (!isset($this->_channelInfo['servers']['primary'][$type]['function'][0])) {
            $this->_channelInfo['servers']['primary'][$type]['function'] = array(
                $this->_channelInfo['servers']['primary'][$type]['function']);
        }
 
        $this->_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->_channelInfo['servers']['mirror'])) {
            $this->_validateError(PEAR_CHANNELFILE_ERROR_MIRROR_NOT_FOUND,
                array('mirror' => $mirror));
            return false;
        }
 
        $setmirror = false;
        if (isset($this->_channelInfo['servers']['mirror'][0])) {
            foreach ($this->_channelInfo['servers']['mirror'] as $i => $mir) {
                if ($mirror == $mir['attribs']['host']) {
                    $setmirror = &$this->_channelInfo['servers']['mirror'][$i];
                    break;
                }
            }
        } else {
            if ($this->_channelInfo['servers']['mirror']['attribs']['host'] == $mirror) {
                $setmirror = &$this->_channelInfo['servers']['mirror'];
            }
        }
 
        if (!$setmirror) {
            $this->_validateError(PEAR_CHANNELFILE_ERROR_MIRROR_NOT_FOUND,
                array('mirror' => $mirror));
            return false;
        }
 
        $set = array('attribs' => array('version' => $version), '_content' => $name);
        if (!isset($setmirror[$type]['function'])) {
            $setmirror[$type]['function'] = $set;
            $this->_isValid = false;
            return true;
        } elseif (!isset($setmirror[$type]['function'][0])) {
            $setmirror[$type]['function'] = array($setmirror[$type]['function']);
        }
 
        $setmirror[$type]['function'][] = $set;
        $this->_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->_channelInfo['servers']['mirror'])) {
                $this->_validateError(PEAR_CHANNELFILE_ERROR_MIRROR_NOT_FOUND,
                    array('mirror' => $mirror));
                return false;
            }
 
            $setmirror = false;
            if (isset($this->_channelInfo['servers']['mirror'][0])) {
                foreach ($this->_channelInfo['servers']['mirror'] as $i => $mir) {
                    if ($mirror == $mir['attribs']['host']) {
                        $setmirror = &$this->_channelInfo['servers']['mirror'][$i];
                        break;
                    }
                }
            } else {
                if ($this->_channelInfo['servers']['mirror']['attribs']['host'] == $mirror) {
                    $setmirror = &$this->_channelInfo['servers']['mirror'];
                }
            }
        } else {
            $setmirror = &$this->_channelInfo['servers']['primary'];
        }
 
        $set = array('attribs' => array('type' => $resourceType), '_content' => $url);
        if (!isset($setmirror['rest'])) {
            $setmirror['rest'] = array();
        }
 
        if (!isset($setmirror['rest']['baseurl'])) {
            $setmirror['rest']['baseurl'] = $set;
            $this->_isValid = false;
            return true;
        } elseif (!isset($setmirror['rest']['baseurl'][0])) {
            $setmirror['rest']['baseurl'] = array($setmirror['rest']['baseurl']);
        }
 
        foreach ($setmirror['rest']['baseurl'] as $i => $url) {
            if ($url['attribs']['type'] == $resourceType) {
                $this->_isValid = false;
                $setmirror['rest']['baseurl'][$i] = $set;
                return true;
            }
        }
 
        $setmirror['rest']['baseurl'][] = $set;
        $this->_isValid = false;
        return true;
    }
 
    /**
     * @param string mirror server
     * @param int mirror http port
     * @return boolean
     */
    function addMirror($server, $port = null)
    {
        if ($this->_channelInfo['name'] == '__uri') {
            return false; // the __uri channel cannot have mirrors by definition
        }
 
        $set = array('attribs' => array('host' => $server));
        if (is_numeric($port)) {
            $set['attribs']['port'] = $port;
        }
 
        if (!isset($this->_channelInfo['servers']['mirror'])) {
            $this->_channelInfo['servers']['mirror'] = $set;
            return true;
 
 
 
 
 
        }
 
        if (!isset($this->_channelInfo['servers']['mirror'][0])) {
            $this->_channelInfo['servers']['mirror'] =
                array($this->_channelInfo['servers']['mirror']);
        }
 
        $this->_channelInfo['servers']['mirror'][] = $set;
        return true;
    }
 
    /**
     * Retrieve the name of the validation package for this channel
     * @return string|false
     */
    function getValidationPackage()
    {
        if (!$this->_isValid && !$this->validate()) {
            return false;
        }
 
        if (!isset($this->_channelInfo['validatepackage'])) {
            return array('attribs' => array('version' => 'default'),
                '_content' => 'PEAR_Validate');
        }
 
        return $this->_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 &getValidationObject($package = false)
    {
        if (!class_exists('PEAR_Validate')) {
            require_once 'PEAR/Validate.php';
        }
 
        if (!$this->_isValid) {
            if (!$this->validate()) {
                $a = false;
                return $a;
            }
        }
 
        if (isset($this->_channelInfo['validatepackage'])) {
            if ($package == $this->_channelInfo['validatepackage']) {
                // channel validation packages are always validated by PEAR_Validate
                $val = new PEAR_Validate;
                return $val;
            }
 
            if (!class_exists(str_replace('.', '_',
                  $this->_channelInfo['validatepackage']['_content']))) {
                if ($this->isIncludeable(str_replace('_', '/',
                      $this->_channelInfo['validatepackage']['_content']) . '.php')) {
                    include_once str_replace('_', '/',
                        $this->_channelInfo['validatepackage']['_content']) . '.php';
                    $vclass = str_replace('.', '_',
                        $this->_channelInfo['validatepackage']['_content']);
                    $val = new $vclass;
                } else {
                    $a = false;
                    return $a;
                }
            } else {
                $vclass = str_replace('.', '_',
                    $this->_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)
                  && 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->_channelInfo['_lastmodified'])) {
            return $this->_channelInfo['_lastmodified'];
        }
 
        return time();
    }
}
 

Rev 94	Rev 187
1	`<?php`	1	`<?php`
2	`/**`	2	`/**`
3	`* PEAR_ChannelFile, the channel handling class`	3	`* PEAR_ChannelFile, the channel handling class`
4	`*`	4	`*`
5	`* PHP versions 4 and 5`	5	`* PHP versions 4 and 5`
6	`*`	6	`*`
7	`* LICENSE: This source file is subject to version 3.0 of the PHP license`	-
8	`* that is available through the world-wide-web at the following URI:`	-
9	`* http://www.php.net/license/3_0.txt. If you did not receive a copy of`	-
10	`* the PHP License and are unable to obtain it through the web, please`	-
11	`* send a note to license@php.net so we can mail you a copy immediately.`	-
12	`*`	-
13	`* @category pear`	7	`* @category pear`
14	`* @package PEAR`	8	`* @package PEAR`
15	`* @author Greg Beaver <cellog@php.net>`	9	`* @author Greg Beaver <cellog@php.net>`
16	`* @copyright 1997-2006 The PHP Group`	10	`* @copyright 1997-2009 The Authors`
17	`* @license http://www.php.net/license/3_0.txt PHP License 3.0`	11	`* @license http://opensource.org/licenses/bsd-license.php New BSD License`
18	`* @version CVS: $Id: ChannelFile.php,v 1.78 2006/10/31 02:54:40 cellog Exp $`	-
19	`* @link http://pear.php.net/package/PEAR`	12	`* @link http://pear.php.net/package/PEAR`
20	`* @since File available since Release 1.4.0a1`	13	`* @since File available since Release 1.4.0a1`
21	`*/`	14	`*/`
22		15
23	`/**`	16	`/**`
24	`* Needed for error handling`	17	`* Needed for error handling`
25	`*/`	18	`*/`
26	`require_once 'PEAR/ErrorStack.php';`	19	`require_once 'PEAR/ErrorStack.php';`
27	`require_once 'PEAR/XMLParser.php';`	20	`require_once 'PEAR/XMLParser.php';`
28	`require_once 'PEAR/Common.php';`	21	`require_once 'PEAR/Common.php';`
29		22
30	`/**`	23	`/**`
31	`* Error code if the channel.xml <channel> tag does not contain a valid version`	24	`* Error code if the channel.xml <channel> tag does not contain a valid version`
32	`*/`	25	`*/`
33	`define('PEAR_CHANNELFILE_ERROR_NO_VERSION', 1);`	26	`define('PEAR_CHANNELFILE_ERROR_NO_VERSION', 1);`
34	`/**`	27	`/**`
35	`* Error code if the channel.xml <channel> tag version is not supported (version 1.0 is the only supported version,`	28	`* Error code if the channel.xml <channel> tag version is not supported (version 1.0 is the only supported version,`
36	`* currently`	29	`* currently`
37	`*/`	30	`*/`
38	`define('PEAR_CHANNELFILE_ERROR_INVALID_VERSION', 2);`	31	`define('PEAR_CHANNELFILE_ERROR_INVALID_VERSION', 2);`
39		32
40	`/**`	33	`/**`
41	`* Error code if parsing is attempted with no xml extension`	34	`* Error code if parsing is attempted with no xml extension`
42	`*/`	35	`*/`
43	`define('PEAR_CHANNELFILE_ERROR_NO_XML_EXT', 3);`	36	`define('PEAR_CHANNELFILE_ERROR_NO_XML_EXT', 3);`
44		37
45	`/**`	38	`/**`
46	`* Error code if creating the xml parser resource fails`	39	`* Error code if creating the xml parser resource fails`
47	`*/`	40	`*/`
48	`define('PEAR_CHANNELFILE_ERROR_CANT_MAKE_PARSER', 4);`	41	`define('PEAR_CHANNELFILE_ERROR_CANT_MAKE_PARSER', 4);`
49		42
50	`/**`	43	`/**`
51	`* Error code used for all sax xml parsing errors`	44	`* Error code used for all sax xml parsing errors`
52	`*/`	45	`*/`
53	`define('PEAR_CHANNELFILE_ERROR_PARSER_ERROR', 5);`	46	`define('PEAR_CHANNELFILE_ERROR_PARSER_ERROR', 5);`
54		47
55	`/**#@+`	48	`/**#@+`
56	`* Validation errors`	49	`* Validation errors`
57	`*/`	50	`*/`
58	`/**`	51	`/**`
59	`* Error code when channel name is missing`	52	`* Error code when channel name is missing`
60	`*/`	53	`*/`
61	`define('PEAR_CHANNELFILE_ERROR_NO_NAME', 6);`	54	`define('PEAR_CHANNELFILE_ERROR_NO_NAME', 6);`
62	`/**`	55	`/**`
63	`* Error code when channel name is invalid`	56	`* Error code when channel name is invalid`
64	`*/`	57	`*/`
65	`define('PEAR_CHANNELFILE_ERROR_INVALID_NAME', 7);`	58	`define('PEAR_CHANNELFILE_ERROR_INVALID_NAME', 7);`
66	`/**`	59	`/**`
67	`* Error code when channel summary is missing`	60	`* Error code when channel summary is missing`
68	`*/`	61	`*/`
69	`define('PEAR_CHANNELFILE_ERROR_NO_SUMMARY', 8);`	62	`define('PEAR_CHANNELFILE_ERROR_NO_SUMMARY', 8);`
70	`/**`	63	`/**`
71	`* Error code when channel summary is multi-line`	64	`* Error code when channel summary is multi-line`
72	`*/`	65	`*/`
73	`define('PEAR_CHANNELFILE_ERROR_MULTILINE_SUMMARY', 9);`	66	`define('PEAR_CHANNELFILE_ERROR_MULTILINE_SUMMARY', 9);`
74	`/**`	67	`/**`
75	`* Error code when channel server is missing for xmlrpc or soap protocol`	68	`* Error code when channel server is missing for protocol`
76	`*/`	69	`*/`
77	`define('PEAR_CHANNELFILE_ERROR_NO_HOST', 10);`	70	`define('PEAR_CHANNELFILE_ERROR_NO_HOST', 10);`
78	`/**`	71	`/**`
79	`* Error code when channel server is invalid for xmlrpc or soap protocol`	72	`* Error code when channel server is invalid for protocol`
80	`*/`	73	`*/`
81	`define('PEAR_CHANNELFILE_ERROR_INVALID_HOST', 11);`	74	`define('PEAR_CHANNELFILE_ERROR_INVALID_HOST', 11);`
82	`/**`	75	`/**`
83	`* Error code when a mirror name is invalid`	76	`* Error code when a mirror name is invalid`
84	`*/`	77	`*/`
85	`define('PEAR_CHANNELFILE_ERROR_INVALID_MIRROR', 21);`	78	`define('PEAR_CHANNELFILE_ERROR_INVALID_MIRROR', 21);`
86	`/**`	79	`/**`
87	`* Error code when a mirror type is invalid`	80	`* Error code when a mirror type is invalid`
88	`*/`	81	`*/`
89	`define('PEAR_CHANNELFILE_ERROR_INVALID_MIRRORTYPE', 22);`	82	`define('PEAR_CHANNELFILE_ERROR_INVALID_MIRRORTYPE', 22);`
90	`/**`	83	`/**`
91	`* Error code when an attempt is made to generate xml, but the parsed content is invalid`	84	`* Error code when an attempt is made to generate xml, but the parsed content is invalid`
92	`*/`	85	`*/`
93	`define('PEAR_CHANNELFILE_ERROR_INVALID', 23);`	86	`define('PEAR_CHANNELFILE_ERROR_INVALID', 23);`
94	`/**`	87	`/**`
95	`* Error code when an empty package name validate regex is passed in`	88	`* Error code when an empty package name validate regex is passed in`
96	`*/`	89	`*/`
97	`define('PEAR_CHANNELFILE_ERROR_EMPTY_REGEX', 24);`	90	`define('PEAR_CHANNELFILE_ERROR_EMPTY_REGEX', 24);`
98	`/**`	91	`/**`
99	`* Error code when a <function> tag has no version`	92	`* Error code when a <function> tag has no version`
100	`*/`	93	`*/`
101	`define('PEAR_CHANNELFILE_ERROR_NO_FUNCTIONVERSION', 25);`	94	`define('PEAR_CHANNELFILE_ERROR_NO_FUNCTIONVERSION', 25);`
102	`/**`	95	`/**`
103	`* Error code when a <function> tag has no name`	96	`* Error code when a <function> tag has no name`
104	`*/`	97	`*/`
105	`define('PEAR_CHANNELFILE_ERROR_NO_FUNCTIONNAME', 26);`	98	`define('PEAR_CHANNELFILE_ERROR_NO_FUNCTIONNAME', 26);`
106	`/**`	99	`/**`
107	`* Error code when a <validatepackage> tag has no name`	100	`* Error code when a <validatepackage> tag has no name`
108	`*/`	101	`*/`
109	`define('PEAR_CHANNELFILE_ERROR_NOVALIDATE_NAME', 27);`	102	`define('PEAR_CHANNELFILE_ERROR_NOVALIDATE_NAME', 27);`
110	`/**`	103	`/**`
111	`* Error code when a <validatepackage> tag has no version attribute`	104	`* Error code when a <validatepackage> tag has no version attribute`
112	`*/`	105	`*/`
113	`define('PEAR_CHANNELFILE_ERROR_NOVALIDATE_VERSION', 28);`	106	`define('PEAR_CHANNELFILE_ERROR_NOVALIDATE_VERSION', 28);`
114	`/**`	107	`/**`
115	`* Error code when a mirror does not exist but is called for in one of the set*`	108	`* Error code when a mirror does not exist but is called for in one of the set*`
116	`* methods.`	109	`* methods.`
117	`*/`	110	`*/`
118	`define('PEAR_CHANNELFILE_ERROR_MIRROR_NOT_FOUND', 32);`	111	`define('PEAR_CHANNELFILE_ERROR_MIRROR_NOT_FOUND', 32);`
119	`/**`	112	`/**`
120	`* Error code when a server port is not numeric`	113	`* Error code when a server port is not numeric`
121	`*/`	114	`*/`
122	`define('PEAR_CHANNELFILE_ERROR_INVALID_PORT', 33);`	115	`define('PEAR_CHANNELFILE_ERROR_INVALID_PORT', 33);`
123	`/**`	116	`/**`
124	`* Error code when <static> contains no version attribute`	117	`* Error code when <static> contains no version attribute`
125	`*/`	118	`*/`
126	`define('PEAR_CHANNELFILE_ERROR_NO_STATICVERSION', 34);`	119	`define('PEAR_CHANNELFILE_ERROR_NO_STATICVERSION', 34);`
127	`/**`	120	`/**`
128	`* Error code when <baseurl> contains no type attribute in a <rest> protocol definition`	121	`* Error code when <baseurl> contains no type attribute in a <rest> protocol definition`
129	`*/`	122	`*/`
130	`define('PEAR_CHANNELFILE_ERROR_NOBASEURLTYPE', 35);`	123	`define('PEAR_CHANNELFILE_ERROR_NOBASEURLTYPE', 35);`
131	`/**`	124	`/**`
132	`* Error code when a mirror is defined and the channel.xml represents the __uri pseudo-channel`	125	`* Error code when a mirror is defined and the channel.xml represents the __uri pseudo-channel`
133	`*/`	126	`*/`
134	`define('PEAR_CHANNELFILE_URI_CANT_MIRROR', 36);`	127	`define('PEAR_CHANNELFILE_URI_CANT_MIRROR', 36);`
135	`/**`	128	`/**`
136	`* Error code when ssl attribute is present and is not "yes"`	129	`* Error code when ssl attribute is present and is not "yes"`
137	`*/`	130	`*/`
138	`define('PEAR_CHANNELFILE_ERROR_INVALID_SSL', 37);`	131	`define('PEAR_CHANNELFILE_ERROR_INVALID_SSL', 37);`
139	`/*#@-/`	132	`/*#@-/`
140		133
141	`/**`	134	`/**`
142	`* Mirror types allowed. Currently only internet servers are recognized.`	135	`* Mirror types allowed. Currently only internet servers are recognized.`
143	`*/`	136	`*/`
144	`$GLOBALS['_PEAR_CHANNELS_MIRROR_TYPES'] = array('server');`	137	`$GLOBALS['_PEAR_CHANNELS_MIRROR_TYPES'] = array('server');`
145		138
146		139
147	`/**`	140	`/**`
148	`* The Channel handling class`	141	`* The Channel handling class`
149	`*`	142	`*`
150	`* @category pear`	143	`* @category pear`
151	`* @package PEAR`	144	`* @package PEAR`
152	`* @author Greg Beaver <cellog@php.net>`	145	`* @author Greg Beaver <cellog@php.net>`
153	`* @copyright 1997-2006 The PHP Group`	146	`* @copyright 1997-2009 The Authors`
154	`* @license http://www.php.net/license/3_0.txt PHP License 3.0`	147	`* @license http://opensource.org/licenses/bsd-license.php New BSD License`
155	`* @version Release: 1.5.1`	148	`* @version Release: 1.10.1`
156	`* @link http://pear.php.net/package/PEAR`	149	`* @link http://pear.php.net/package/PEAR`
157	`* @since Class available since Release 1.4.0a1`	150	`* @since Class available since Release 1.4.0a1`
158	`*/`	151	`*/`
159	`class PEAR_ChannelFile {`	152	`class PEAR_ChannelFile`
-		153	`{`
160	`/**`	154	`/**`
161	`* @access private`	155	`* @access private`
162	`* @var PEAR_ErrorStack`	156	`* @var PEAR_ErrorStack`
163	`* @access private`	157	`* @access private`
164	`*/`	158	`*/`
165	`var $_stack;`	159	`var $_stack;`
166		160
167	`/**`	161	`/**`
168	`* Supported channel.xml versions, for parsing`	162	`* Supported channel.xml versions, for parsing`
169	`* @var array`	163	`* @var array`
170	`* @access private`	164	`* @access private`
171	`*/`	165	`*/`
172	`var $_supportedVersions = array('1.0');`	166	`var $_supportedVersions = array('1.0');`
173		167
174	`/**`	168	`/**`
175	`* Parsed channel information`	169	`* Parsed channel information`
176	`* @var array`	170	`* @var array`
177	`* @access private`	171	`* @access private`
178	`*/`	172	`*/`
179	`var $_channelInfo;`	173	`var $_channelInfo;`
180		174
181	`/**`	175	`/**`
182	`* index into the subchannels array, used for parsing xml`	176	`* index into the subchannels array, used for parsing xml`
183	`* @var int`	177	`* @var int`
184	`* @access private`	178	`* @access private`
185	`*/`	179	`*/`
186	`var $_subchannelIndex;`	180	`var $_subchannelIndex;`
187		181
188	`/**`	182	`/**`
189	`* index into the mirrors array, used for parsing xml`	183	`* index into the mirrors array, used for parsing xml`
190	`* @var int`	184	`* @var int`
191	`* @access private`	185	`* @access private`
192	`*/`	186	`*/`
193	`var $_mirrorIndex;`	187	`var $_mirrorIndex;`
194		188
195	`/**`	189	`/**`
196	`* Flag used to determine the validity of parsed content`	190	`* Flag used to determine the validity of parsed content`
197	`* @var boolean`	191	`* @var boolean`
198	`* @access private`	192	`* @access private`
199	`*/`	193	`*/`
200	`var $_isValid = false;`	194	`var $_isValid = false;`
201		195
202	`function PEAR_ChannelFile()`	196	`function __construct()`
203	`{`	197	`{`
204	`$this->_stack = &new PEAR_ErrorStack('PEAR_ChannelFile');`	198	`$this->_stack = new PEAR_ErrorStack('PEAR_ChannelFile');`
205	`$this->_stack->setErrorMessageTemplate($this->_getErrorMessage());`	199	`$this->_stack->setErrorMessageTemplate($this->_getErrorMessage());`
206	`$this->_isValid = false;`	200	`$this->_isValid = false;`
207	`}`	201	`}`
208		202
209	`/**`	203	`/**`
210	`* @return array`	204	`* @return array`
211	`* @access protected`	205	`* @access protected`
212	`*/`	206	`*/`
213	`function _getErrorMessage()`	207	`function _getErrorMessage()`
214	`{`	208	`{`
215	`return`	209	`return`
216	`array(`	210	`array(`
217	`PEAR_CHANNELFILE_ERROR_INVALID_VERSION =>`	211	`PEAR_CHANNELFILE_ERROR_INVALID_VERSION =>`
218	`'While parsing channel.xml, an invalid version number "%version% was passed in, expecting one of %versions%',`	212	`'While parsing channel.xml, an invalid version number "%version% was passed in, expecting one of %versions%',`
219	`PEAR_CHANNELFILE_ERROR_NO_VERSION =>`	213	`PEAR_CHANNELFILE_ERROR_NO_VERSION =>`
220	`'No version number found in <channel> tag',`	214	`'No version number found in <channel> tag',`
221	`PEAR_CHANNELFILE_ERROR_NO_XML_EXT =>`	215	`PEAR_CHANNELFILE_ERROR_NO_XML_EXT =>`
222	`'%error%',`	216	`'%error%',`
223	`PEAR_CHANNELFILE_ERROR_CANT_MAKE_PARSER =>`	217	`PEAR_CHANNELFILE_ERROR_CANT_MAKE_PARSER =>`
224	`'Unable to create XML parser',`	218	`'Unable to create XML parser',`
225	`PEAR_CHANNELFILE_ERROR_PARSER_ERROR =>`	219	`PEAR_CHANNELFILE_ERROR_PARSER_ERROR =>`
226	`'%error%',`	220	`'%error%',`
227	`PEAR_CHANNELFILE_ERROR_NO_NAME =>`	221	`PEAR_CHANNELFILE_ERROR_NO_NAME =>`
228	`'Missing channel name',`	222	`'Missing channel name',`
229	`PEAR_CHANNELFILE_ERROR_INVALID_NAME =>`	223	`PEAR_CHANNELFILE_ERROR_INVALID_NAME =>`
230	`'Invalid channel %tag% "%name%"',`	224	`'Invalid channel %tag% "%name%"',`
231	`PEAR_CHANNELFILE_ERROR_NO_SUMMARY =>`	225	`PEAR_CHANNELFILE_ERROR_NO_SUMMARY =>`
232	`'Missing channel summary',`	226	`'Missing channel summary',`
233	`PEAR_CHANNELFILE_ERROR_MULTILINE_SUMMARY =>`	227	`PEAR_CHANNELFILE_ERROR_MULTILINE_SUMMARY =>`
234	`'Channel summary should be on one line, but is multi-line',`	228	`'Channel summary should be on one line, but is multi-line',`
235	`PEAR_CHANNELFILE_ERROR_NO_HOST =>`	229	`PEAR_CHANNELFILE_ERROR_NO_HOST =>`
236	`'Missing channel server for %type% server',`	230	`'Missing channel server for %type% server',`
237	`PEAR_CHANNELFILE_ERROR_INVALID_HOST =>`	231	`PEAR_CHANNELFILE_ERROR_INVALID_HOST =>`
238	`'Server name "%server%" is invalid for %type% server',`	232	`'Server name "%server%" is invalid for %type% server',`
239	`PEAR_CHANNELFILE_ERROR_INVALID_MIRROR =>`	233	`PEAR_CHANNELFILE_ERROR_INVALID_MIRROR =>`
240	`'Invalid mirror name "%name%", mirror type %type%',`	234	`'Invalid mirror name "%name%", mirror type %type%',`
241	`PEAR_CHANNELFILE_ERROR_INVALID_MIRRORTYPE =>`	235	`PEAR_CHANNELFILE_ERROR_INVALID_MIRRORTYPE =>`
242	`'Invalid mirror type "%type%"',`	236	`'Invalid mirror type "%type%"',`
243	`PEAR_CHANNELFILE_ERROR_INVALID =>`	237	`PEAR_CHANNELFILE_ERROR_INVALID =>`
244	`'Cannot generate xml, contents are invalid',`	238	`'Cannot generate xml, contents are invalid',`
245	`PEAR_CHANNELFILE_ERROR_EMPTY_REGEX =>`	239	`PEAR_CHANNELFILE_ERROR_EMPTY_REGEX =>`
246	`'packagenameregex cannot be empty',`	240	`'packagenameregex cannot be empty',`
247	`PEAR_CHANNELFILE_ERROR_NO_FUNCTIONVERSION =>`	241	`PEAR_CHANNELFILE_ERROR_NO_FUNCTIONVERSION =>`
248	`'%parent% %protocol% function has no version',`	242	`'%parent% %protocol% function has no version',`
249	`PEAR_CHANNELFILE_ERROR_NO_FUNCTIONNAME =>`	243	`PEAR_CHANNELFILE_ERROR_NO_FUNCTIONNAME =>`
250	`'%parent% %protocol% function has no name',`	244	`'%parent% %protocol% function has no name',`
251	`PEAR_CHANNELFILE_ERROR_NOBASEURLTYPE =>`	245	`PEAR_CHANNELFILE_ERROR_NOBASEURLTYPE =>`
252	`'%parent% rest baseurl has no type',`	246	`'%parent% rest baseurl has no type',`
253	`PEAR_CHANNELFILE_ERROR_NOVALIDATE_NAME =>`	247	`PEAR_CHANNELFILE_ERROR_NOVALIDATE_NAME =>`
254	`'Validation package has no name in <validatepackage> tag',`	248	`'Validation package has no name in <validatepackage> tag',`
255	`PEAR_CHANNELFILE_ERROR_NOVALIDATE_VERSION =>`	249	`PEAR_CHANNELFILE_ERROR_NOVALIDATE_VERSION =>`
256	`'Validation package "%package%" has no version',`	250	`'Validation package "%package%" has no version',`
257	`PEAR_CHANNELFILE_ERROR_MIRROR_NOT_FOUND =>`	251	`PEAR_CHANNELFILE_ERROR_MIRROR_NOT_FOUND =>`
258	`'Mirror "%mirror%" does not exist',`	252	`'Mirror "%mirror%" does not exist',`
259	`PEAR_CHANNELFILE_ERROR_INVALID_PORT =>`	253	`PEAR_CHANNELFILE_ERROR_INVALID_PORT =>`
260	`'Port "%port%" must be numeric',`	254	`'Port "%port%" must be numeric',`
261	`PEAR_CHANNELFILE_ERROR_NO_STATICVERSION =>`	255	`PEAR_CHANNELFILE_ERROR_NO_STATICVERSION =>`
262	`'<static> tag must contain version attribute',`	256	`'<static> tag must contain version attribute',`
263	`PEAR_CHANNELFILE_URI_CANT_MIRROR =>`	257	`PEAR_CHANNELFILE_URI_CANT_MIRROR =>`
264	`'The __uri pseudo-channel cannot have mirrors',`	258	`'The __uri pseudo-channel cannot have mirrors',`
265	`PEAR_CHANNELFILE_ERROR_INVALID_SSL =>`	259	`PEAR_CHANNELFILE_ERROR_INVALID_SSL =>`
266	`'%server% has invalid ssl attribute "%ssl%" can only be yes or not present',`	260	`'%server% has invalid ssl attribute "%ssl%" can only be yes or not present',`
267	`);`	261	`);`
268	`}`	262	`}`
269		263
270	`/**`	264	`/**`
271	`* @param string contents of package.xml file`	265	`* @param string contents of package.xml file`
272	`* @return bool success of parsing`	266	`* @return bool success of parsing`
273	`*/`	267	`*/`
274	`function fromXmlString($data)`	268	`function fromXmlString($data)`
275	`{`	269	`{`
276	`if (preg_match('/<channel\s+version="([0-9]+\.[0-9]+)"/', $data, $channelversion)) {`	270	`if (preg_match('/<channel\s+version="([0-9]+\.[0-9]+)"/', $data, $channelversion)) {`
277	`if (!in_array($channelversion[1], $this->_supportedVersions)) {`	271	`if (!in_array($channelversion[1], $this->_supportedVersions)) {`
278	`$this->_stack->push(PEAR_CHANNELFILE_ERROR_INVALID_VERSION, 'error',`	272	`$this->_stack->push(PEAR_CHANNELFILE_ERROR_INVALID_VERSION, 'error',`
279	`array('version' => $channelversion[1]));`	273	`array('version' => $channelversion[1]));`
280	`return false;`	274	`return false;`
281	`}`	275	`}`
282	`$parser = new PEAR_XMLParser;`	276	`$parser = new PEAR_XMLParser;`
283	`$result = $parser->parse($data);`	277	`$result = $parser->parse($data);`
284	`if ($result !== true) {`	278	`if ($result !== true) {`
285	`if ($result->getCode() == 1) {`	279	`if ($result->getCode() == 1) {`
286	`$this->_stack->push(PEAR_CHANNELFILE_ERROR_NO_XML_EXT, 'error',`	280	`$this->_stack->push(PEAR_CHANNELFILE_ERROR_NO_XML_EXT, 'error',`
287	`array('error' => $error));`	281	`array('error' => $result->getMessage()));`
288	`} else {`	282	`} else {`
289	`$this->_stack->push(PEAR_CHANNELFILE_ERROR_CANT_MAKE_PARSER, 'error');`	283	`$this->_stack->push(PEAR_CHANNELFILE_ERROR_CANT_MAKE_PARSER, 'error');`
290	`}`	284	`}`
291	`return false;`	285	`return false;`
292	`}`	286	`}`
293	`$this->_channelInfo = $parser->getData();`	287	`$this->_channelInfo = $parser->getData();`
294	`return true;`	288	`return true;`
295	`} else {`	289	`} else {`
296	`$this->_stack->push(PEAR_CHANNELFILE_ERROR_NO_VERSION, 'error', array('xml' => $data));`	290	`$this->_stack->push(PEAR_CHANNELFILE_ERROR_NO_VERSION, 'error', array('xml' => $data));`
297	`return false;`	291	`return false;`
298	`}`	292	`}`
299	`}`	293	`}`
300		294
301	`/**`	295	`/**`
302	`* @return array`	296	`* @return array`
303	`*/`	297	`*/`
304	`function toArray()`	298	`function toArray()`
305	`{`	299	`{`
306	`if (!$this->_isValid && !$this->validate()) {`	300	`if (!$this->_isValid && !$this->validate()) {`
307	`return false;`	301	`return false;`
308	`}`	302	`}`
309	`return $this->_channelInfo;`	303	`return $this->_channelInfo;`
310	`}`	304	`}`
311		305
312	`/**`	306	`/**`
313	`* @param array`	307	`* @param array`
314	`* @static`	308	`*`
315	`* @return PEAR_ChannelFile\|false false if invalid`	309	`* @return PEAR_ChannelFile\|false false if invalid`
316	`*/`	310	`*/`
-		311	`public static function &fromArray(`
317	`function &fromArray($data, $compatibility = false, $stackClass = 'PEAR_ErrorStack')`	312	`$data, $compatibility = false, $stackClass = 'PEAR_ErrorStack'`
318	`{`	313	`) {`
319	`$a = new PEAR_ChannelFile($compatibility, $stackClass);`	314	`$a = new PEAR_ChannelFile($compatibility, $stackClass);`
320	`$a->_fromArray($data);`	315	`$a->_fromArray($data);`
321	`if (!$a->validate()) {`	316	`if (!$a->validate()) {`
322	`$a = false;`	317	`$a = false;`
323	`return $a;`	318	`return $a;`
324	`}`	319	`}`
325	`return $a;`	320	`return $a;`
326	`}`	321	`}`
327		322
328	`/**`	323	`/**`
329	`* Unlike {@link fromArray()} this does not do any validation`	324	`* Unlike {@link fromArray()} this does not do any validation`
-		325	`*`
330	`* @param array`	326	`* @param array`
331	`* @static`	327	`*`
332	`* @return PEAR_ChannelFile`	328	`* @return PEAR_ChannelFile`
333	`*/`	329	`*/`
334	`function &fromArrayWithErrors($data, $compatibility = false,`	330	`public static function &fromArrayWithErrors(`
335	`$stackClass = 'PEAR_ErrorStack')`	331	`$data, $compatibility = false, $stackClass = 'PEAR_ErrorStack'`
336	`{`	332	`) {`
337	`$a = new PEAR_ChannelFile($compatibility, $stackClass);`	333	`$a = new PEAR_ChannelFile($compatibility, $stackClass);`
338	`$a->_fromArray($data);`	334	`$a->_fromArray($data);`
339	`return $a;`	335	`return $a;`
340	`}`	336	`}`
341		337
342	`/**`	338	`/**`
343	`* @param array`	339	`* @param array`
344	`* @access private`	340	`* @access private`
345	`*/`	341	`*/`
346	`function _fromArray($data)`	342	`function _fromArray($data)`
347	`{`	343	`{`
348	`$this->_channelInfo = $data;`	344	`$this->_channelInfo = $data;`
349	`}`	345	`}`
350		346
351	`/**`	347	`/**`
352	`* Wrapper to {@link PEAR_ErrorStack::getErrors()}`	348	`* Wrapper to {@link PEAR_ErrorStack::getErrors()}`
353	`* @param boolean determines whether to purge the error stack after retrieving`	349	`* @param boolean determines whether to purge the error stack after retrieving`
354	`* @return array`	350	`* @return array`
355	`*/`	351	`*/`
356	`function getErrors($purge = false)`	352	`function getErrors($purge = false)`
357	`{`	353	`{`
358	`return $this->_stack->getErrors($purge);`	354	`return $this->_stack->getErrors($purge);`
359	`}`	355	`}`
360		356
361	`/**`	357	`/**`
362	`* Unindent given string (?)`	358	`* Unindent given string (?)`
363	`*`	359	`*`
364	`* @param string $str The string that has to be unindented.`	360	`* @param string $str The string that has to be unindented.`
365	`* @return string`	361	`* @return string`
366	`* @access private`	362	`* @access private`
367	`*/`	363	`*/`
368	`function _unIndent($str)`	364	`function _unIndent($str)`
369	`{`	365	`{`
370	`// remove leading newlines`	366	`// remove leading newlines`
371	`$str = preg_replace('/^[\r\n]+/', '', $str);`	367	`$str = preg_replace('/^[\r\n]+/', '', $str);`
372	`// find whitespace at the beginning of the first line`	368	`// find whitespace at the beginning of the first line`
373	`$indent_len = strspn($str, " \t");`	369	`$indent_len = strspn($str, " \t");`
374	`$indent = substr($str, 0, $indent_len);`	370	`$indent = substr($str, 0, $indent_len);`
375	`$data = '';`	371	`$data = '';`
376	`// remove the same amount of whitespace from following lines`	372	`// remove the same amount of whitespace from following lines`
377	`foreach (explode("\n", $str) as $line) {`	373	`foreach (explode("\n", $str) as $line) {`
378	`if (substr($line, 0, $indent_len) == $indent) {`	374	`if (substr($line, 0, $indent_len) == $indent) {`
379	`$data .= substr($line, $indent_len) . "\n";`	375	`$data .= substr($line, $indent_len) . "\n";`
380	`}`	376	`}`
381	`}`	377	`}`
382	`return $data;`	378	`return $data;`
383	`}`	379	`}`
384		380
385	`/**`	381	`/**`
386	`* Parse a channel.xml file. Expects the name of`	382	`* Parse a channel.xml file. Expects the name of`
387	`* a channel xml file as input.`	383	`* a channel xml file as input.`
388	`*`	384	`*`
389	`* @param string $descfile name of channel xml file`	385	`* @param string $descfile name of channel xml file`
390	`* @return bool success of parsing`	386	`* @return bool success of parsing`
391	`*/`	387	`*/`
392	`function fromXmlFile($descfile)`	388	`function fromXmlFile($descfile)`
393	`{`	389	`{`
394	`if (!file_exists($descfile) \|\| !is_file($descfile) \|\| !is_readable($descfile) \|\|`	390	`if (!file_exists($descfile) \|\| !is_file($descfile) \|\| !is_readable($descfile) \|\|`
395	`(!$fp = fopen($descfile, 'r'))) {`	391	`(!$fp = fopen($descfile, 'r'))) {`
396	`require_once 'PEAR.php';`	392	`require_once 'PEAR.php';`
397	`return PEAR::raiseError("Unable to open $descfile");`	393	`return PEAR::raiseError("Unable to open $descfile");`
398	`}`	394	`}`
399		395
400	`// read the whole thing so we only get one cdata callback`	396	`// read the whole thing so we only get one cdata callback`
401	`// for each block of cdata`	397	`// for each block of cdata`
402	`fclose($fp);`	398	`fclose($fp);`
403	`$data = file_get_contents($descfile);`	399	`$data = file_get_contents($descfile);`
404	`return $this->fromXmlString($data);`	400	`return $this->fromXmlString($data);`
405	`}`	401	`}`
406		402
407	`/**`	403	`/**`
408	`* Parse channel information from different sources`	404	`* Parse channel information from different sources`
409	`*`	405	`*`
410	`* This method is able to extract information about a channel`	406	`* This method is able to extract information about a channel`
411	`* from an .xml file or a string`	407	`* from an .xml file or a string`
412	`*`	408	`*`
413	`* @access public`	409	`* @access public`
414	`* @param string Filename of the source or the source itself`	410	`* @param string Filename of the source or the source itself`
415	`* @return bool`	411	`* @return bool`
416	`*/`	412	`*/`
417	`function fromAny($info)`	413	`function fromAny($info)`
418	`{`	414	`{`
419	`if (is_string($info) && file_exists($info) && strlen($info) < 255) {`	415	`if (is_string($info) && file_exists($info) && strlen($info) < 255) {`
420	`$tmp = substr($info, -4);`	416	`$tmp = substr($info, -4);`
421	`if ($tmp == '.xml') {`	417	`if ($tmp == '.xml') {`
422	`$info = $this->fromXmlFile($info);`	418	`$info = $this->fromXmlFile($info);`
423	`} else {`	419	`} else {`
424	`$fp = fopen($info, "r");`	420	`$fp = fopen($info, "r");`
425	`$test = fread($fp, 5);`	421	`$test = fread($fp, 5);`
426	`fclose($fp);`	422	`fclose($fp);`
427	`if ($test == "<?xml") {`	423	`if ($test == "<?xml") {`
428	`$info = $this->fromXmlFile($info);`	424	`$info = $this->fromXmlFile($info);`
429	`}`	425	`}`
430	`}`	426	`}`
431	`if (PEAR::isError($info)) {`	427	`if (PEAR::isError($info)) {`
432	`require_once 'PEAR.php';`	428	`require_once 'PEAR.php';`
433	`return PEAR::raiseError($info);`	429	`return PEAR::raiseError($info);`
434	`}`	430	`}`
435	`}`	431	`}`
436	`if (is_string($info)) {`	432	`if (is_string($info)) {`
437	`$info = $this->fromXmlString($info);`	433	`$info = $this->fromXmlString($info);`
438	`}`	434	`}`
439	`return $info;`	435	`return $info;`
440	`}`	436	`}`
441		437
442	`/**`	438	`/**`
443	`* Return an XML document based on previous parsing and modifications`	439	`* Return an XML document based on previous parsing and modifications`
444	`*`	440	`*`
445	`* @return string XML data`	441	`* @return string XML data`
446	`*`	442	`*`
447	`* @access public`	443	`* @access public`
448	`*/`	444	`*/`
449	`function toXml()`	445	`function toXml()`
450	`{`	446	`{`
451	`if (!$this->_isValid && !$this->validate()) {`	447	`if (!$this->_isValid && !$this->validate()) {`
452	`$this->_validateError(PEAR_CHANNELFILE_ERROR_INVALID);`	448	`$this->_validateError(PEAR_CHANNELFILE_ERROR_INVALID);`
453	`return false;`	449	`return false;`
454	`}`	450	`}`
455	`if (!isset($this->_channelInfo['attribs']['version'])) {`	451	`if (!isset($this->_channelInfo['attribs']['version'])) {`
456	`$this->_channelInfo['attribs']['version'] = '1.0';`	452	`$this->_channelInfo['attribs']['version'] = '1.0';`
457	`}`	453	`}`
458	`$channelInfo = $this->_channelInfo;`	454	`$channelInfo = $this->_channelInfo;`
459	`$ret = "<?xml version=\"1.0\" encoding=\"ISO-8859-1\" ?>\n";`	455	`$ret = "<?xml version=\"1.0\" encoding=\"ISO-8859-1\" ?>\n";`
460	`$ret .= "<channel version=\"" .`	456	`$ret .= "<channel version=\"" .`
461	`$channelInfo['attribs']['version'] . "\" xmlns=\"http://pear.php.net/channel-1.0\"`	457	`$channelInfo['attribs']['version'] . "\" xmlns=\"http://pear.php.net/channel-1.0\"`
462	`xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"`	458	`xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"`
463	`xsi:schemaLocation=\"http://pear.php.net/dtd/channel-"`	459	`xsi:schemaLocation=\"http://pear.php.net/dtd/channel-"`
464	`. $channelInfo['attribs']['version'] . " http://pear.php.net/dtd/channel-" .`	460	`. $channelInfo['attribs']['version'] . " http://pear.php.net/dtd/channel-" .`
465	`$channelInfo['attribs']['version'] . ".xsd\">`	461	`$channelInfo['attribs']['version'] . ".xsd\">`
466	`<name>$channelInfo[name]</name>`	462	`<name>$channelInfo[name]</name>`
467	`<summary>" . htmlspecialchars($channelInfo['summary'])."</summary>`	463	`<summary>" . htmlspecialchars($channelInfo['summary'])."</summary>`
468	`";`	464	`";`
469	`if (isset($channelInfo['suggestedalias'])) {`	465	`if (isset($channelInfo['suggestedalias'])) {`
470	`$ret .= ' <suggestedalias>' . $channelInfo['suggestedalias'] . "</suggestedalias>\n";`	466	`$ret .= ' <suggestedalias>' . $channelInfo['suggestedalias'] . "</suggestedalias>\n";`
471	`}`	467	`}`
472	`if (isset($channelInfo['validatepackage'])) {`	468	`if (isset($channelInfo['validatepackage'])) {`
473	`$ret .= ' <validatepackage version="' .`	469	`$ret .= ' <validatepackage version="' .`
474	`$channelInfo['validatepackage']['attribs']['version']. '">' .`	470	`$channelInfo['validatepackage']['attribs']['version']. '">' .`
475	`htmlspecialchars($channelInfo['validatepackage']['_content']) .`	471	`htmlspecialchars($channelInfo['validatepackage']['_content']) .`
476	`"</validatepackage>\n";`	472	`"</validatepackage>\n";`
477	`}`	473	`}`
478	`$ret .= " <servers>\n";`	474	`$ret .= " <servers>\n";`
479	`$ret .= ' <primary';`	475	`$ret .= ' <primary';`
480	`if (isset($channelInfo['servers']['primary']['attribs']['ssl'])) {`	476	`if (isset($channelInfo['servers']['primary']['attribs']['ssl'])) {`
481	`$ret .= ' ssl="' . $channelInfo['servers']['primary']['attribs']['ssl'] . '"';`	477	`$ret .= ' ssl="' . $channelInfo['servers']['primary']['attribs']['ssl'] . '"';`
482	`}`	478	`}`
483	`if (isset($channelInfo['servers']['primary']['attribs']['port'])) {`	479	`if (isset($channelInfo['servers']['primary']['attribs']['port'])) {`
484	`$ret .= ' port="' . $channelInfo['servers']['primary']['attribs']['port'] . '"';`	480	`$ret .= ' port="' . $channelInfo['servers']['primary']['attribs']['port'] . '"';`
485	`}`	481	`}`
486	`$ret .= ">\n";`	482	`$ret .= ">\n";`
487	`if (isset($channelInfo['servers']['primary']['xmlrpc'])) {`	-
488	`$ret .= $this->_makeXmlrpcXml($channelInfo['servers']['primary']['xmlrpc'], ' ');`	-
489	`}`	-
490	`if (isset($channelInfo['servers']['primary']['rest'])) {`	483	`if (isset($channelInfo['servers']['primary']['rest'])) {`
491	`$ret .= $this->_makeRestXml($channelInfo['servers']['primary']['rest'], ' ');`	484	`$ret .= $this->_makeRestXml($channelInfo['servers']['primary']['rest'], ' ');`
492	`}`	485	`}`
493	`if (isset($channelInfo['servers']['primary']['soap'])) {`	-
494	`$ret .= $this->_makeSoapXml($channelInfo['servers']['primary']['soap'], ' ');`	-
495	`}`	-
496	`$ret .= " </primary>\n";`	486	`$ret .= " </primary>\n";`
497	`if (isset($channelInfo['servers']['mirror'])) {`	487	`if (isset($channelInfo['servers']['mirror'])) {`

Subversion Repositories Applications.gtt

(root)/trunk/bibliotheque/pear/PEAR/ChannelFile.php – Rev 94 → 187