PHP PEAR_Installer_Role类代码示例

 /**
  * @param PEAR_PackageFile_v1|PEAR_PackageFile_v2
  * @param string filename
  * @param array attributes from <file> tag in package.xml
  * @param string path to install the file in
  * @param array options from command-line
  * @access private
  */
 function _installFile2(&$pkg, $file, $atts, $tmp_path, $options)
 {
     if (!isset($this->_registry)) {
         $this->_registry =& $this->config->getRegistry();
     }
     $channel = $pkg->getChannel();
     // {{{ assemble the destination paths
     if (!in_array($atts['attribs']['role'], PEAR_Installer_Role::getValidRoles($pkg->getPackageType()))) {
         return $this->raiseError('Invalid role `' . $atts['attribs']['role'] . "' for file {$file}");
     }
     $role =& PEAR_Installer_Role::factory($pkg, $atts['attribs']['role'], $this->config);
     $err = $role->setup($this, $pkg, $atts['attribs'], $file);
     if (PEAR::isError($err)) {
         return $err;
     }
     if (!$role->isInstallable()) {
         return;
     }
     $info = $role->processInstallation($pkg, $atts['attribs'], $file, $tmp_path);
     if (PEAR::isError($info)) {
         return $info;
     } else {
         list($save_destdir, $dest_dir, $dest_file, $orig_file) = $info;
     }
     $final_dest_file = $installed_as = $dest_file;
     if (isset($this->_options['packagingroot'])) {
         $final_dest_file = $this->_prependPath($final_dest_file, $this->_options['packagingroot']);
     }
     $dest_dir = dirname($final_dest_file);
     $dest_file = $dest_dir . DIRECTORY_SEPARATOR . '.tmp' . basename($final_dest_file);
     // }}}
     if (empty($this->_options['register-only'])) {
         if (!@is_dir($dest_dir)) {
             if (!$this->mkDirHier($dest_dir)) {
                 return $this->raiseError("failed to mkdir {$dest_dir}", PEAR_INSTALLER_FAILED);
             }
             $this->log(3, "+ mkdir {$dest_dir}");
         }
     }
     $attribs = $atts['attribs'];
     unset($atts['attribs']);
     // pretty much nothing happens if we are only registering the install
     if (empty($this->_options['register-only'])) {
         if (!count($atts)) {
             // no tasks
             if (!file_exists($orig_file)) {
                 return $this->raiseError("file {$orig_file} does not exist", PEAR_INSTALLER_FAILED);
             }
             if (!@copy($orig_file, $dest_file)) {
                 return $this->raiseError("failed to write {$dest_file}", PEAR_INSTALLER_FAILED);
             }
             $this->log(3, "+ cp {$orig_file} {$dest_file}");
             if (isset($attribs['md5sum'])) {
                 $md5sum = md5_file($dest_file);
             }
         } else {
             // file with tasks
             if (!file_exists($orig_file)) {
                 return $this->raiseError("file {$orig_file} does not exist", PEAR_INSTALLER_FAILED);
             }
             if (function_exists('file_get_contents')) {
                 $contents = file_get_contents($orig_file);
             } else {
                 $fp = fopen($orig_file, "r");
                 $contents = @fread($fp, filesize($orig_file));
                 // filesize can be 0
                 fclose($fp);
             }
             if ($contents === false) {
                 $contents = '';
             }
             if (isset($attribs['md5sum'])) {
                 $md5sum = md5($contents);
             }
             foreach ($atts as $tag => $raw) {
                 $tag = str_replace($pkg->getTasksNs() . ':', '', $tag);
                 $task = "PEAR_Task_{$tag}";
                 $task =& new $task($this->config, $this, PEAR_TASK_INSTALL);
                 if (!$task->isScript()) {
                     // scripts are only handled after installation
                     $task->init($raw, $attribs, $pkg->getLastInstalledVersion());
                     $res = $task->startSession($pkg, $contents, $final_dest_file);
                     if ($res === false) {
                         continue;
                         // skip this file
                     }
                     if (PEAR::isError($res)) {
                         return $res;
                     }
                     $contents = $res;
                     // save changes
                 }
//.........这里部分代码省略.........

 /**
  * Scan through the Command directory looking for classes
  * and see what commands they implement.
  * @param string which directory to look for classes, defaults to
  *               the Installer/Roles subdirectory of
  *               the directory from where this file (__FILE__) is
  *               included.
  *
  * @return bool TRUE on success, a PEAR error on failure
  * @access public
  * @static
  */
 function registerRoles($dir = null)
 {
     $GLOBALS['_PEAR_INSTALLER_ROLES'] = array();
     $parser = new PEAR_XMLParser();
     if ($dir === null) {
         $dir = dirname(__FILE__) . '/Role';
     }
     if (!file_exists($dir) || !is_dir($dir)) {
         return PEAR::raiseError("registerRoles: opendir({$dir}) failed");
     }
     $dp = @opendir($dir);
     if (empty($dp)) {
         return PEAR::raiseError("registerRoles: opendir({$dir}) failed");
     }
     while ($entry = readdir($dp)) {
         if ($entry[0] == '.' || substr($entry, -4) != '.xml') {
             continue;
         }
         $class = "PEAR_Installer_Role_" . substr($entry, 0, -4);
         // List of roles
         if (!isset($GLOBALS['_PEAR_INSTALLER_ROLES'][$class])) {
             $file = "{$dir}/{$entry}";
             $parser->parse(file_get_contents($file));
             $data = $parser->getData();
             if (!is_array($data['releasetypes'])) {
                 $data['releasetypes'] = array($data['releasetypes']);
             }
             $GLOBALS['_PEAR_INSTALLER_ROLES'][$class] = $data;
         }
     }
     closedir($dp);
     ksort($GLOBALS['_PEAR_INSTALLER_ROLES']);
     PEAR_Installer_Role::getBaseinstallRoles(true);
     PEAR_Installer_Role::getInstallableRoles(true);
     PEAR_Installer_Role::getPhpRoles(true);
     PEAR_Installer_Role::getValidRoles('****', true);
     return true;
 }

 function _analyzePhpFiles()
 {
     if (!$this->_isValid) {
         return false;
     }
     if (!isset($this->_pf->_packageFile)) {
         $this->_cannotValidateNoPathSet();
         return false;
     }
     $dir_prefix = dirname($this->_pf->_packageFile);
     $common = new PEAR_Common();
     $log = isset($this->_pf->_logger) ? array(&$this->_pf->_logger, 'log') : array(&$common, 'log');
     $info = $this->_pf->getContents();
     if (!$info || !isset($info['dir']['file'])) {
         $this->_tagCannotBeEmpty('contents><dir');
         return false;
     }
     $info = $info['dir']['file'];
     if (isset($info['attribs'])) {
         $info = array($info);
     }
     $provides = array();
     foreach ($info as $fa) {
         $fa = $fa['attribs'];
         $file = $fa['name'];
         if (!file_exists($dir_prefix . DIRECTORY_SEPARATOR . $file)) {
             $this->_fileNotFound($dir_prefix . DIRECTORY_SEPARATOR . $file);
             $this->_isValid = 0;
             continue;
         }
         if (in_array($fa['role'], PEAR_Installer_Role::getPhpRoles()) && $dir_prefix) {
             call_user_func_array($log, array(1, "Analyzing {$file}"));
             $srcinfo = $this->analyzeSourceCode($dir_prefix . DIRECTORY_SEPARATOR . $file);
             if ($srcinfo) {
                 $provides = array_merge($provides, $this->_buildProvidesArray($srcinfo));
             }
         }
     }
     $this->_packageName = $pn = $this->_pf->getPackage();
     $pnl = strlen($pn);
     foreach ($provides as $key => $what) {
         if (isset($what['explicit']) || !$what) {
             // skip conformance checks if the provides entry is
             // specified in the package.xml file
             continue;
         }
         extract($what);
         if ($type == 'class') {
             if (!strncasecmp($name, $pn, $pnl)) {
                 continue;
             }
             $this->_stack->push(__FUNCTION__, 'warning', array('file' => $file, 'type' => $type, 'name' => $name, 'package' => $pn), 'in %file%: %type% "%name%" not prefixed with package name "%package%"');
         } elseif ($type == 'function') {
             if (strstr($name, '::') || !strncasecmp($name, $pn, $pnl)) {
                 continue;
             }
             $this->_stack->push(__FUNCTION__, 'warning', array('file' => $file, 'type' => $type, 'name' => $name, 'package' => $pn), 'in %file%: %type% "%name%" not prefixed with package name "%package%"');
         }
     }
     return $this->_isValid;
 }

 /**
  * Test whether a file or set of files belongs to a package.
  *
  * If an array is passed in
  * @param string|array file path, absolute or relative to the pear
  *                     install dir
  * @param string|array name of PEAR package or array('package' => name, 'channel' =>
  *                     channel) of a package that will be ignored
  * @param string API version - 1.1 will exclude any files belonging to a package
  * @param array private recursion variable
  * @return array|false which package and channel the file belongs to, or an empty
  *                     string if the file does not belong to an installed package,
  *                     or belongs to the second parameter's package
  */
 function checkFileMap($path, $package = false, $api = '1.0', $attrs = false)
 {
     if (is_array($path)) {
         static $notempty;
         if (empty($notempty)) {
             if (!class_exists('PEAR_Installer_Role')) {
                 require_once 'PEAR/Installer/Role.php';
             }
             $notempty = create_function('$a', 'return !empty($a);');
         }
         $package = is_array($package) ? array(strtolower($package[0]), strtolower($package[1])) : strtolower($package);
         $pkgs = array();
         foreach ($path as $name => $attrs) {
             if (is_array($attrs)) {
                 if (isset($attrs['install-as'])) {
                     $name = $attrs['install-as'];
                 }
                 if (!in_array($attrs['role'], PEAR_Installer_Role::getInstallableRoles())) {
                     // these are not installed
                     continue;
                 }
                 if (!in_array($attrs['role'], PEAR_Installer_Role::getBaseinstallRoles())) {
                     $attrs['baseinstalldir'] = is_array($package) ? $package[1] : $package;
                 }
                 if (isset($attrs['baseinstalldir'])) {
                     $name = $attrs['baseinstalldir'] . DIRECTORY_SEPARATOR . $name;
                 }
             }
             $pkgs[$name] = $this->checkFileMap($name, $package, $api, $attrs);
             if (PEAR::isError($pkgs[$name])) {
                 return $pkgs[$name];
             }
         }
         return array_filter($pkgs, $notempty);
     }
     if (empty($this->filemap_cache)) {
         if (PEAR::isError($e = $this->_lock(LOCK_SH))) {
             return $e;
         }
         $err = $this->_readFileMap();
         $this->_unlock();
         if (PEAR::isError($err)) {
             return $err;
         }
     }
     if (!$attrs) {
         $attrs = array('role' => 'php');
         // any old call would be for PHP role only
     }
     if (isset($this->filemap_cache[$attrs['role']][$path])) {
         if ($api >= '1.1' && $this->filemap_cache[$attrs['role']][$path] == $package) {
             return false;
         }
         return $this->filemap_cache[$attrs['role']][$path];
     }
     $l = strlen($this->install_dir);
     if (substr($path, 0, $l) == $this->install_dir) {
         $path = preg_replace('!^' . DIRECTORY_SEPARATOR . '+!', '', substr($path, $l));
     }
     if (isset($this->filemap_cache[$attrs['role']][$path])) {
         if ($api >= '1.1' && $this->filemap_cache[$attrs['role']][$path] == $package) {
             return false;
         }
         return $this->filemap_cache[$attrs['role']][$path];
     }
     return false;
 }

 function doFileList($command, $options, $params)
 {
     if (count($params) !== 1) {
         return $this->raiseError('list-files expects 1 parameter');
     }
     $reg =& $this->config->getRegistry();
     $fp = false;
     if (!is_dir($params[0]) && (file_exists($params[0]) || ($fp = @fopen($params[0], 'r')))) {
         if ($fp) {
             fclose($fp);
         }
         if (!class_exists('PEAR_PackageFile')) {
             require_once 'PEAR/PackageFile.php';
         }
         $pkg =& new PEAR_PackageFile($this->config, $this->_debug);
         PEAR::staticPushErrorHandling(PEAR_ERROR_RETURN);
         $info =& $pkg->fromAnyFile($params[0], PEAR_VALIDATE_NORMAL);
         PEAR::staticPopErrorHandling();
         $headings = array('Package File', 'Install Path');
         $installed = false;
     } else {
         PEAR::staticPushErrorHandling(PEAR_ERROR_RETURN);
         $parsed = $reg->parsePackageName($params[0], $this->config->get('default_channel'));
         PEAR::staticPopErrorHandling();
         if (PEAR::isError($parsed)) {
             return $this->raiseError($parsed);
         }
         $info =& $reg->getPackage($parsed['package'], $parsed['channel']);
         $headings = array('Type', 'Install Path');
         $installed = true;
     }
     if (PEAR::isError($info)) {
         return $this->raiseError($info);
     }
     if ($info === null) {
         return $this->raiseError("`{$params['0']}' not installed");
     }
     $list = $info->getPackagexmlVersion() == '1.0' || $installed ? $info->getFilelist() : $info->getContents();
     if ($installed) {
         $caption = 'Installed Files For ' . $params[0];
     } else {
         $caption = 'Contents of ' . basename($params[0]);
     }
     $data = array('caption' => $caption, 'border' => true, 'headline' => $headings);
     if ($info->getPackagexmlVersion() == '1.0' || $installed) {
         foreach ($list as $file => $att) {
             if ($installed) {
                 if (empty($att['installed_as'])) {
                     continue;
                 }
                 $data['data'][] = array($att['role'], $att['installed_as']);
             } else {
                 if (isset($att['baseinstalldir']) && !in_array($att['role'], array('test', 'data', 'doc'))) {
                     $dest = $att['baseinstalldir'] . DIRECTORY_SEPARATOR . $file;
                 } else {
                     $dest = $file;
                 }
                 switch ($att['role']) {
                     case 'test':
                     case 'data':
                     case 'doc':
                         $role = $att['role'];
                         if ($role == 'test') {
                             $role .= 's';
                         }
                         $dest = $this->config->get($role . '_dir') . DIRECTORY_SEPARATOR . $info->getPackage() . DIRECTORY_SEPARATOR . $dest;
                         break;
                     case 'php':
                     default:
                         $dest = $this->config->get('php_dir') . DIRECTORY_SEPARATOR . $dest;
                 }
                 $ds2 = DIRECTORY_SEPARATOR . DIRECTORY_SEPARATOR;
                 $dest = preg_replace(array('!\\\\+!', '!/!', "!{$ds2}+!"), array(DIRECTORY_SEPARATOR, DIRECTORY_SEPARATOR, DIRECTORY_SEPARATOR), $dest);
                 $file = preg_replace('!/+!', '/', $file);
                 $data['data'][] = array($file, $dest);
             }
         }
     } else {
         // package.xml 2.0, not installed
         if (!isset($list['dir']['file'][0])) {
             $list['dir']['file'] = array($list['dir']['file']);
         }
         foreach ($list['dir']['file'] as $att) {
             $att = $att['attribs'];
             $file = $att['name'];
             $role =& PEAR_Installer_Role::factory($info, $att['role'], $this->config);
             $role->setup($this, $info, $att, $file);
             if (!$role->isInstallable()) {
                 $dest = '(not installable)';
             } else {
                 $dest = $role->processInstallation($info, $att, $file, '');
                 if (PEAR::isError($dest)) {
                     $dest = '(Unknown role "' . $att['role'] . ')';
                 } else {
                     list(, , $dest) = $dest;
                 }
             }
             $data['data'][] = array($file, $dest);
         }
     }
//.........这里部分代码省略.........

 /**
  * Scan through the Command directory looking for classes
  * and see what commands they implement.
  * @param string which directory to look for classes, defaults to
  *               the Installer/Roles subdirectory of
  *               the directory from where this file (__FILE__) is
  *               included.
  *
  * @return bool TRUE on success, a PEAR error on failure
  * @access public
  * @static
  */
 function registerRoles($dir = null)
 {
     if ($dir === null) {
         $dir = dirname(__FILE__) . '/Role';
     }
     $dp = @opendir($dir);
     if (empty($dp)) {
         return PEAR::raiseError("registerRoles: opendir({$dir}) failed");
     }
     while ($entry = readdir($dp)) {
         if ($entry[0] == '.' || substr($entry, -4) != '.php' || $entry == 'Common.php') {
             continue;
         }
         $class = "PEAR_Installer_Role_" . substr($entry, 0, -4);
         $file = "{$dir}/{$entry}";
         include_once $file;
         // List of roles
         if (empty($GLOBALS['_PEAR_INSTALLER_ROLES'][$class])) {
             $GLOBALS['_PEAR_INSTALLER_ROLES'][$class] = call_user_func(array($class, 'getInfo'));
         }
     }
     @closedir($dp);
     ksort($GLOBALS['_PEAR_INSTALLER_ROLES']);
     PEAR_Installer_Role::getBaseinstallRoles(true);
     PEAR_Installer_Role::getInstallableRoles(true);
     PEAR_Installer_Role::getPhpRoles(true);
     PEAR_Installer_Role::getValidRoles('****', true);
     return true;
 }

 /**
  * @param PEAR_PackageFile_v1|PEAR_PackageFile_v2
  * @param string filename
  * @param array attributes from <file> tag in package.xml
  * @param string path to install the file in
  * @param array options from command-line
  * @access private
  */
 function _installFile2(&$pkg, $file, &$real_atts, $tmp_path, $options)
 {
     $atts = $real_atts;
     if (!isset($this->_registry)) {
         $this->_registry =& $this->config->getRegistry();
     }
     $channel = $pkg->getChannel();
     // assemble the destination paths
     $roles = PEAR_Installer_Role::getValidRoles($pkg->getPackageType());
     if (!in_array($atts['attribs']['role'], $roles)) {
         return $this->raiseError('Invalid role `' . $atts['attribs']['role'] . "' for file {$file}");
     }
     $role =& PEAR_Installer_Role::factory($pkg, $atts['attribs']['role'], $this->config);
     $err = $role->setup($this, $pkg, $atts['attribs'], $file);
     if (PEAR::isError($err)) {
         return $err;
     }
     if (!$role->isInstallable()) {
         return;
     }
     $info = $role->processInstallation($pkg, $atts['attribs'], $file, $tmp_path);
     if (PEAR::isError($info)) {
         return $info;
     }
     list($save_destdir, $dest_dir, $dest_file, $orig_file) = $info;
     if (preg_match('~/\\.\\.(/|\\z)|^\\.\\./~', str_replace('\\', '/', $dest_file))) {
         return $this->raiseError("SECURITY ERROR: file {$file} (installed to {$dest_file}) contains parent directory reference ..", PEAR_INSTALLER_FAILED);
     }
     $final_dest_file = $installed_as = $dest_file;
     if (isset($this->_options['packagingroot'])) {
         $final_dest_file = $this->_prependPath($final_dest_file, $this->_options['packagingroot']);
     }
     $dest_dir = dirname($final_dest_file);
     $dest_file = $dest_dir . DIRECTORY_SEPARATOR . '.tmp' . basename($final_dest_file);
     if (empty($this->_options['register-only'])) {
         if (!file_exists($dest_dir) || !is_dir($dest_dir)) {
             if (!$this->mkDirHier($dest_dir)) {
                 return $this->raiseError("failed to mkdir {$dest_dir}", PEAR_INSTALLER_FAILED);
             }
             $this->log(3, "+ mkdir {$dest_dir}");
         }
     }
     $attribs = $atts['attribs'];
     unset($atts['attribs']);
     // pretty much nothing happens if we are only registering the install
     $htype = 'md5sum';
     if (empty($this->_options['register-only'])) {
         if (!count($atts)) {
             // no tasks
             if (!file_exists($orig_file)) {
                 return $this->raiseError("file {$orig_file} does not exist", PEAR_INSTALLER_FAILED);
             }
             if (!@copy($orig_file, $dest_file)) {
                 return $this->raiseError("failed to write {$dest_file}: {$php_errormsg}", PEAR_INSTALLER_FAILED);
             }
             $this->log(3, "+ cp {$orig_file} {$dest_file}");
             if (isset($attribs['sha1sum'])) {
                 $hash = sha1_file($dest_file);
                 $htype = 'sha1sum';
             } elseif (isset($attribs['md5sum'])) {
                 $hash = md5_file($dest_file);
                 $htype = 'md5sum';
             }
         } else {
             // file with tasks
             if (!file_exists($orig_file)) {
                 return $this->raiseError("file {$orig_file} does not exist", PEAR_INSTALLER_FAILED);
             }
             $contents = file_get_contents($orig_file);
             if ($contents === false) {
                 $contents = '';
             }
             if (isset($attribs['sha1sum'])) {
                 $hash = sha1($contents);
                 $htype = 'sha1sum';
             } elseif (isset($attribs['md5sum'])) {
                 $hash = md5($contents);
                 $htype = 'md5sum';
             }
             foreach ($atts as $tag => $raw) {
                 $tag = str_replace(array($pkg->getTasksNs() . ':', '-'), array('', '_'), $tag);
                 $task = "PEAR_Task_{$tag}";
                 $task =& new $task($this->config, $this, PEAR_TASK_INSTALL);
                 if (!$task->isScript()) {
                     // scripts are only handled after installation
                     $task->init($raw, $attribs, $pkg->getLastInstalledVersion());
                     $res = $task->startSession($pkg, $contents, $final_dest_file);
                     if ($res === false) {
                         continue;
                         // skip this file
                     }
                     if (PEAR::isError($res)) {
//.........这里部分代码省略.........

 /**
  * Constructor.
  *
  * @param string file to read user-defined options from
  * @param string file to read system-wide defaults from
  * @param bool   determines whether a registry object "follows"
  *               the value of php_dir (is automatically created
  *               and moved when php_dir is changed)
  * @param bool   if true, fails if configuration files cannot be loaded
  *
  * @access public
  *
  * @see PEAR_Config::singleton
  */
 function PEAR_Config($user_file = '', $system_file = '', $ftp_file = false, $strict = true)
 {
     $this->PEAR();
     PEAR_Installer_Role::initializeConfig($this);
     $sl = DIRECTORY_SEPARATOR;
     if (empty($user_file)) {
         if (OS_WINDOWS) {
             $user_file = PEAR_CONFIG_SYSCONFDIR . $sl . 'pear.ini';
         } else {
             $user_file = getenv('HOME') . $sl . '.pearrc';
         }
     }
     if (empty($system_file)) {
         $system_file = PEAR_CONFIG_SYSCONFDIR . $sl;
         if (OS_WINDOWS) {
             $system_file .= 'pearsys.ini';
         } else {
             $system_file .= 'pear.conf';
         }
     }
     $this->layers = array_keys($this->configuration);
     $this->files['user'] = $user_file;
     $this->files['system'] = $system_file;
     if ($user_file && file_exists($user_file)) {
         $this->pushErrorHandling(PEAR_ERROR_RETURN);
         $this->readConfigFile($user_file, 'user', $strict);
         $this->popErrorHandling();
         if ($this->_errorsFound > 0) {
             return;
         }
     }
     if ($system_file && @file_exists($system_file)) {
         $this->mergeConfigFile($system_file, false, 'system', $strict);
         if ($this->_errorsFound > 0) {
             return;
         }
     }
     if (!$ftp_file) {
         $ftp_file = $this->get('remote_config');
     }
     if ($ftp_file && defined('PEAR_REMOTEINSTALL_OK')) {
         $this->readFTPConfigFile($ftp_file);
     }
     foreach ($this->configuration_info as $key => $info) {
         $this->configuration['default'][$key] = $info['default'];
     }
     $this->_registry['default'] =& new PEAR_Registry($this->configuration['default']['php_dir'], false, false, $this->configuration['default']['metadata_dir']);
     $this->_registry['default']->setConfig($this, false);
     $this->_regInitialized['default'] = false;
     //$GLOBALS['_PEAR_Config_instance'] = &$this;
 }

 /**
  * Add an extension/role mapping to the role mapping option
  *
  * Roles influence both where a file is installed and how it is installed.
  * Files with role="data" are in a completely different directory hierarchy
  * from the program files of role="php"
  *
  * In PEAR 1.3b2, these roles are
  * - php (most common)
  * - data
  * - doc
  * - test
  * - script (gives the file an executable attribute)
  * - src
  *
  * @param string $extension file extension
  * @param string $role      file role
  *
  * @return void|PEAR_Error
  * @throws PEAR_PACKAGEFILEMANAGER2_INVALID_ROLE
  * @access public
  * @since  1.6.0a1
  */
 function addRole($extension, $role)
 {
     include_once 'PEAR/Installer/Role.php';
     $roles = PEAR_Installer_Role::getValidRoles($this->getPackageType());
     if (!in_array($role, $roles)) {
         return $this->raiseError(PEAR_PACKAGEFILEMANAGER2_INVALID_ROLE, implode($roles, ', '), $role);
     }
     $this->_options['roles'][$extension] = $role;
 }

 /**
  * Constructor.
  *
  * @param string file to read user-defined options from
  * @param string file to read system-wide defaults from
  * @param bool   determines whether a registry object "follows"
  *               the value of php_dir (is automatically created
  *               and moved when php_dir is changed)
  *
  * @access public
  *
  * @see PEAR_Config::singleton
  */
 function PEAR_Config($user_file = '', $system_file = '', $ftp_file = false)
 {
     $this->PEAR();
     PEAR_Installer_Role::initializeConfig($this);
     $sl = DIRECTORY_SEPARATOR;
     if (empty($user_file)) {
         if (OS_WINDOWS) {
             $user_file = PEAR_CONFIG_SYSCONFDIR . $sl . 'pear.ini';
         } else {
             $user_file = getenv('HOME') . $sl . '.pearrc';
         }
     }
     if (empty($system_file)) {
         if (OS_WINDOWS) {
             $system_file = PEAR_CONFIG_SYSCONFDIR . $sl . 'pearsys.ini';
         } else {
             $system_file = PEAR_CONFIG_SYSCONFDIR . $sl . 'pear.conf';
         }
     }
     $this->layers = array_keys($this->configuration);
     $this->files['user'] = $user_file;
     $this->files['system'] = $system_file;
     if ($user_file && @file_exists($user_file)) {
         $this->readConfigFile($user_file);
     }
     if ($system_file && @file_exists($system_file)) {
         $this->mergeConfigFile($system_file, false, 'system');
     }
     if (!$ftp_file) {
         $ftp_file = $this->get('remote_config');
     }
     if ($ftp_file) {
         $this->readFTPConfigFile($ftp_file);
     }
     foreach ($this->configuration_info as $key => $info) {
         $this->configuration['default'][$key] = $info['default'];
     }
     $this->_registry['default'] =& new PEAR_Registry($this->configuration['default']['php_dir']);
     $this->_registry['default']->setConfig($this);
     $this->_regInitialized['default'] = false;
     //$GLOBALS['_PEAR_Config_instance'] = &$this;
 }

 /**
  * Upload an installed package - does not work with register-only packages!
  * @param PEAR_PackageFile_v1|PEAR_PackageFile_v2
  */
 public function ftpInstall($pkg)
 {
     if ($pkg->getPackageType() != 'php') {
         return PEAR::raiseError('Error: can only install PHP scripts remotely,' . ' no PHP extensions can be compiled remotely');
     }
     $ftp =& $this->config->getFTP();
     if (!$ftp) {
         return PEAR::raiseError('FTP client not initialized');
     }
     $this->log(2, 'Connect to FTP server');
     $e = $ftp->init();
     if (PEAR::isError($e)) {
         return $e;
     }
     $pf =& $this->_registry->getPackage($pkg->getPackage(), $pkg->getChannel());
     foreach ($pf->getFilelist() as $file => $atts) {
         if ($pf->getPackagexmlVersion() == '1.0') {
             $channel = 'pear.php.net';
             switch ($atts['role']) {
                 case 'doc':
                 case 'data':
                 case 'test':
                     $dest_dir = $this->config->get($atts['role'] . '_dir', 'ftp', $channel) . DIRECTORY_SEPARATOR . $pf->getPackage();
                     unset($atts['baseinstalldir']);
                     break;
                 case 'ext':
                 case 'php':
                     $dest_dir = $this->config->get($atts['role'] . '_dir', 'ftp', $channel);
                     break;
                 case 'script':
                     $dest_dir = $this->config->get('bin_dir', 'ftp', $channel);
                     break;
                 default:
                     continue 2;
             }
             $save_destdir = $dest_dir;
             if (!empty($atts['baseinstalldir'])) {
                 $dest_dir .= DIRECTORY_SEPARATOR . $atts['baseinstalldir'];
             }
             if (dirname($file) != '.' && empty($atts['install-as'])) {
                 $dest_dir .= DIRECTORY_SEPARATOR . dirname($file);
             }
             if (empty($atts['install-as'])) {
                 $dest_file = $dest_dir . DIRECTORY_SEPARATOR . basename($file);
             } else {
                 $dest_file = $dest_dir . DIRECTORY_SEPARATOR . $atts['install-as'];
             }
             // Clean up the DIRECTORY_SEPARATOR mess
             $ds2 = DIRECTORY_SEPARATOR . DIRECTORY_SEPARATOR;
             $dest_file = preg_replace(array('!\\+!', '!/!', "!{$ds2}+!"), array('/', '/', '/'), $dest_file);
         } else {
             $role =& PEAR_Installer_Role::factory($pf, $atts['role'], $this->config);
             $role->setup($this, $pf, $atts, $file);
             if (!$role->isInstallable()) {
                 continue;
                 // this shouldn't happen
             }
             list($save_destdir, $dest_dir, $dest_file, $orig_file) = $role->processInstallation($pkg, $atts, $file, $file, 'ftp');
             $dest_file = str_replace(DIRECTORY_SEPARATOR, '/', $dest_file);
         }
         $installedas = $atts['installed_as'];
         $this->log(2, 'Uploading "' . $installedas . '" to "' . $dest_file . '"');
         if (PEAR::isError($e = $ftp->installFile($installedas, $dest_file))) {
             return $e;
         }
     }
     $this->log(2, 'Disconnect from FTP server');
     return $ftp->disconnect();
 }