WEB-INF/lib/pear/PEAR/Downloader/Package.php

   1 <?php
   2 /**
   3  * PEAR_Downloader_Package
   4  *
   5  * PHP versions 4 and 5
   6  *
   7  * @category   pear
   8  * @package    PEAR
   9  * @author     Greg Beaver <cellog@php.net>
  10  * @copyright  1997-2009 The Authors
  11  * @license    http://opensource.org/licenses/bsd-license.php New BSD License
  12  * @version    CVS: $Id: Package.php 313023 2011-07-06 19:17:11Z dufuz $
  13  * @link       http://pear.php.net/package/PEAR
  14  * @since      File available since Release 1.4.0a1
  15  */
  16
  17 /**
  18  * Error code when parameter initialization fails because no releases
  19  * exist within preferred_state, but releases do exist
  20  */
  21 define('PEAR_DOWNLOADER_PACKAGE_STATE', -1003);
  22 /**
  23  * Error code when parameter initialization fails because no releases
  24  * exist that will work with the existing PHP version
  25  */
  26 define('PEAR_DOWNLOADER_PACKAGE_PHPVERSION', -1004);
  27
  28 /**
  29  * Coordinates download parameters and manages their dependencies
  30  * prior to downloading them.
  31  *
  32  * Input can come from three sources:
  33  *
  34  * - local files (archives or package.xml)
  35  * - remote files (downloadable urls)
  36  * - abstract package names
  37  *
  38  * The first two elements are handled cleanly by PEAR_PackageFile, but the third requires
  39  * accessing pearweb's xml-rpc interface to determine necessary dependencies, and the
  40  * format returned of dependencies is slightly different from that used in package.xml.
  41  *
  42  * This class hides the differences between these elements, and makes automatic
  43  * dependency resolution a piece of cake.  It also manages conflicts when
  44  * two classes depend on incompatible dependencies, or differing versions of the same
  45  * package dependency.  In addition, download will not be attempted if the php version is
  46  * not supported, PEAR installer version is not supported, or non-PECL extensions are not
  47  * installed.
  48  * @category   pear
  49  * @package    PEAR
  50  * @author     Greg Beaver <cellog@php.net>
  51  * @copyright  1997-2009 The Authors
  52  * @license    http://opensource.org/licenses/bsd-license.php New BSD License
  53  * @version    Release: 1.9.4
  54  * @link       http://pear.php.net/package/PEAR
  55  * @since      Class available since Release 1.4.0a1
  56  */
  57 class PEAR_Downloader_Package
  58 {
  59     /**
  60      * @var PEAR_Downloader
  61      */
  62     var $_downloader;
  63     /**
  64      * @var PEAR_Config
  65      */
  66     var $_config;
  67     /**
  68      * @var PEAR_Registry
  69      */
  70     var $_registry;
  71     /**
  72      * Used to implement packagingroot properly
  73      * @var PEAR_Registry
  74      */
  75     var $_installRegistry;
  76     /**
  77      * @var PEAR_PackageFile_v1|PEAR_PackageFile|v2
  78      */
  79     var $_packagefile;
  80     /**
  81      * @var array
  82      */
  83     var $_parsedname;
  84     /**
  85      * @var array
  86      */
  87     var $_downloadURL;
  88     /**
  89      * @var array
  90      */
  91     var $_downloadDeps = array();
  92     /**
  93      * @var boolean
  94      */
  95     var $_valid = false;
  96     /**
  97      * @var boolean
  98      */
  99     var $_analyzed = false;
 100     /**
 101      * if this or a parent package was invoked with Package-state, this is set to the
 102      * state variable.
 103      *
 104      * This allows temporary reassignment of preferred_state for a parent package and all of
 105      * its dependencies.
 106      * @var string|false
 107      */
 108     var $_explicitState = false;
 109     /**
 110      * If this package is invoked with Package#group, this variable will be true
 111      */
 112     var $_explicitGroup = false;
 113     /**
 114      * Package type local|url
 115      * @var string
 116      */
 117     var $_type;
 118     /**
 119      * Contents of package.xml, if downloaded from a remote channel
 120      * @var string|false
 121      * @access private
 122      */
 123     var $_rawpackagefile;
 124     /**
 125      * @var boolean
 126      * @access private
 127      */
 128     var $_validated = false;
 129
 130     /**
 131      * @param PEAR_Downloader
 132      */
 133     function PEAR_Downloader_Package(&$downloader)
 134     {
 135         $this->_downloader = &$downloader;
 136         $this->_config = &$this->_downloader->config;
 137         $this->_registry = &$this->_config->getRegistry();
 138         $options = $downloader->getOptions();
 139         if (isset($options['packagingroot'])) {
 140             $this->_config->setInstallRoot($options['packagingroot']);
 141             $this->_installRegistry = &$this->_config->getRegistry();
 142             $this->_config->setInstallRoot(false);
 143         } else {
 144             $this->_installRegistry = &$this->_registry;
 145         }
 146         $this->_valid = $this->_analyzed = false;
 147     }
 148
 149     /**
 150      * Parse the input and determine whether this is a local file, a remote uri, or an
 151      * abstract package name.
 152      *
 153      * This is the heart of the PEAR_Downloader_Package(), and is used in
 154      * {@link PEAR_Downloader::download()}
 155      * @param string
 156      * @return bool|PEAR_Error
 157      */
 158     function initialize($param)
 159     {
 160         $origErr = $this->_fromFile($param);
 161         if ($this->_valid) {
 162             return true;
 163         }
 164
 165         $options = $this->_downloader->getOptions();
 166         if (isset($options['offline'])) {
 167             if (PEAR::isError($origErr) && !isset($options['soft'])) {
 168                 foreach ($origErr->getUserInfo() as $userInfo) {
 169                     if (isset($userInfo['message'])) {
 170                         $this->_downloader->log(0, $userInfo['message']);
 171                     }
 172                 }
 173
 174                 $this->_downloader->log(0, $origErr->getMessage());
 175             }
 176
 177             return PEAR::raiseError('Cannot download non-local package "' . $param . '"');
 178         }
 179
 180         $err = $this->_fromUrl($param);
 181         if (PEAR::isError($err) || !$this->_valid) {
 182             if ($this->_type == 'url') {
 183                 if (PEAR::isError($err) && !isset($options['soft'])) {
 184                     $this->_downloader->log(0, $err->getMessage());
 185                 }
 186
 187                 return PEAR::raiseError("Invalid or missing remote package file");
 188             }
 189
 190             $err = $this->_fromString($param);
 191             if (PEAR::isError($err) || !$this->_valid) {
 192                 if (PEAR::isError($err) && $err->getCode() == PEAR_DOWNLOADER_PACKAGE_STATE) {
 193                     return false; // instruct the downloader to silently skip
 194                 }
 195
 196                 if (isset($this->_type) && $this->_type == 'local' && PEAR::isError($origErr)) {
 197                     if (is_array($origErr->getUserInfo())) {
 198                         foreach ($origErr->getUserInfo() as $err) {
 199                             if (is_array($err)) {
 200                                 $err = $err['message'];
 201                             }
 202
 203                             if (!isset($options['soft'])) {
 204                                 $this->_downloader->log(0, $err);
 205                             }
 206                         }
 207                     }
 208
 209                     if (!isset($options['soft'])) {
 210                         $this->_downloader->log(0, $origErr->getMessage());
 211                     }
 212
 213                     if (is_array($param)) {
 214                         $param = $this->_registry->parsedPackageNameToString($param, true);
 215                     }
 216
 217                     if (!isset($options['soft'])) {
 218                         $this->_downloader->log(2, "Cannot initialize '$param', invalid or missing package file");
 219                     }
 220
 221                     // Passing no message back - already logged above
 222                     return PEAR::raiseError();
 223                 }
 224
 225                 if (PEAR::isError($err) && !isset($options['soft'])) {
 226                     $this->_downloader->log(0, $err->getMessage());
 227                 }
 228
 229                 if (is_array($param)) {
 230                     $param = $this->_registry->parsedPackageNameToString($param, true);
 231                 }
 232
 233                 if (!isset($options['soft'])) {
 234                     $this->_downloader->log(2, "Cannot initialize '$param', invalid or missing package file");
 235                 }
 236
 237                 // Passing no message back - already logged above
 238                 return PEAR::raiseError();
 239             }
 240         }
 241
 242         return true;
 243     }
 244
 245     /**
 246      * Retrieve any non-local packages
 247      * @return PEAR_PackageFile_v1|PEAR_PackageFile_v2|PEAR_Error
 248      */
 249     function &download()
 250     {
 251         if (isset($this->_packagefile)) {
 252             return $this->_packagefile;
 253         }
 254
 255         if (isset($this->_downloadURL['url'])) {
 256             $this->_isvalid = false;
 257             $info = $this->getParsedPackage();
 258             foreach ($info as $i => $p) {
 259                 $info[$i] = strtolower($p);
 260             }
 261
 262             $err = $this->_fromUrl($this->_downloadURL['url'],
 263                 $this->_registry->parsedPackageNameToString($this->_parsedname, true));
 264             $newinfo = $this->getParsedPackage();
 265             foreach ($newinfo as $i => $p) {
 266                 $newinfo[$i] = strtolower($p);
 267             }
 268
 269             if ($info != $newinfo) {
 270                 do {
 271                     if ($info['channel'] == 'pecl.php.net' && $newinfo['channel'] == 'pear.php.net') {
 272                         $info['channel'] = 'pear.php.net';
 273                         if ($info == $newinfo) {
 274                             // skip the channel check if a pecl package says it's a PEAR package
 275                             break;
 276                         }
 277                     }
 278                     if ($info['channel'] == 'pear.php.net' && $newinfo['channel'] == 'pecl.php.net') {
 279                         $info['channel'] = 'pecl.php.net';
 280                         if ($info == $newinfo) {
 281                             // skip the channel check if a pecl package says it's a PEAR package
 282                             break;
 283                         }
 284                     }
 285
 286                     return PEAR::raiseError('CRITICAL ERROR: We are ' .
 287                         $this->_registry->parsedPackageNameToString($info) . ', but the file ' .
 288                         'downloaded claims to be ' .
 289                         $this->_registry->parsedPackageNameToString($this->getParsedPackage()));
 290                 } while (false);
 291             }
 292
 293             if (PEAR::isError($err) || !$this->_valid) {
 294                 return $err;
 295             }
 296         }
 297
 298         $this->_type = 'local';
 299         return $this->_packagefile;
 300     }
 301
 302     function &getPackageFile()
 303     {
 304         return $this->_packagefile;
 305     }
 306
 307     function &getDownloader()
 308     {
 309         return $this->_downloader;
 310     }
 311
 312     function getType()
 313     {
 314         return $this->_type;
 315     }
 316
 317     /**
 318      * Like {@link initialize()}, but operates on a dependency
 319      */
 320     function fromDepURL($dep)
 321     {
 322         $this->_downloadURL = $dep;
 323         if (isset($dep['uri'])) {
 324             $options = $this->_downloader->getOptions();
 325             if (!extension_loaded("zlib") || isset($options['nocompress'])) {
 326                 $ext = '.tar';
 327             } else {
 328                 $ext = '.tgz';
 329             }
 330
 331             PEAR::pushErrorHandling(PEAR_ERROR_RETURN);
 332             $err = $this->_fromUrl($dep['uri'] . $ext);
 333             PEAR::popErrorHandling();
 334             if (PEAR::isError($err)) {
 335                 if (!isset($options['soft'])) {
 336                     $this->_downloader->log(0, $err->getMessage());
 337                 }
 338
 339                 return PEAR::raiseError('Invalid uri dependency "' . $dep['uri'] . $ext . '", ' .
 340                     'cannot download');
 341             }
 342         } else {
 343             $this->_parsedname =
 344                 array(
 345                     'package' => $dep['info']->getPackage(),
 346                     'channel' => $dep['info']->getChannel(),
 347                     'version' => $dep['version']
 348                 );
 349             if (!isset($dep['nodefault'])) {
 350                 $this->_parsedname['group'] = 'default'; // download the default dependency group
 351                 $this->_explicitGroup = false;
 352             }
 353
 354             $this->_rawpackagefile = $dep['raw'];
 355         }
 356     }
 357
 358     function detectDependencies($params)
 359     {
 360         $options = $this->_downloader->getOptions();
 361         if (isset($options['downloadonly'])) {
 362             return;
 363         }
 364
 365         if (isset($options['offline'])) {
 366             $this->_downloader->log(3, 'Skipping dependency download check, --offline specified');
 367             return;
 368         }
 369
 370         $pname = $this->getParsedPackage();
 371         if (!$pname) {
 372             return;
 373         }
 374
 375         $deps = $this->getDeps();
 376         if (!$deps) {
 377             return;
 378         }
 379
 380         if (isset($deps['required'])) { // package.xml 2.0
 381             return $this->_detect2($deps, $pname, $options, $params);
 382         }
 383
 384         return $this->_detect1($deps, $pname, $options, $params);
 385     }
 386
 387     function setValidated()
 388     {
 389         $this->_validated = true;
 390     }
 391
 392     function alreadyValidated()
 393     {
 394         return $this->_validated;
 395     }
 396
 397     /**
 398      * Remove packages to be downloaded that are already installed
 399      * @param array of PEAR_Downloader_Package objects
 400      * @static
 401      */
 402     function removeInstalled(&$params)
 403     {
 404         if (!isset($params[0])) {
 405             return;
 406         }
 407
 408         $options = $params[0]->_downloader->getOptions();
 409         if (!isset($options['downloadonly'])) {
 410             foreach ($params as $i => $param) {
 411                 $package = $param->getPackage();
 412                 $channel = $param->getChannel();
 413                 // remove self if already installed with this version
 414                 // this does not need any pecl magic - we only remove exact matches
 415                 if ($param->_installRegistry->packageExists($package, $channel)) {
 416                     $packageVersion = $param->_installRegistry->packageInfo($package, 'version', $channel);
 417                     if (version_compare($packageVersion, $param->getVersion(), '==')) {
 418                         if (!isset($options['force'])) {
 419                             $info = $param->getParsedPackage();
 420                             unset($info['version']);
 421                             unset($info['state']);
 422                             if (!isset($options['soft'])) {
 423                                 $param->_downloader->log(1, 'Skipping package "' .
 424                                     $param->getShortName() .
 425                                     '", already installed as version ' . $packageVersion);
 426                             }
 427                             $params[$i] = false;
 428                         }
 429                     } elseif (!isset($options['force']) && !isset($options['upgrade']) &&
 430                           !isset($options['soft'])) {
 431                         $info = $param->getParsedPackage();
 432                         $param->_downloader->log(1, 'Skipping package "' .
 433                             $param->getShortName() .
 434                             '", already installed as version ' . $packageVersion);
 435                         $params[$i] = false;
 436                     }
 437                 }
 438             }
 439         }
 440
 441         PEAR_Downloader_Package::removeDuplicates($params);
 442     }
 443
 444     function _detect2($deps, $pname, $options, $params)
 445     {
 446         $this->_downloadDeps = array();
 447         $groupnotfound = false;
 448         foreach (array('package', 'subpackage') as $packagetype) {
 449             // get required dependency group
 450             if (isset($deps['required'][$packagetype])) {
 451                 if (isset($deps['required'][$packagetype][0])) {
 452                     foreach ($deps['required'][$packagetype] as $dep) {
 453                         if (isset($dep['conflicts'])) {
 454                             // skip any package that this package conflicts with
 455                             continue;
 456                         }
 457                         $ret = $this->_detect2Dep($dep, $pname, 'required', $params);
 458                         if (is_array($ret)) {
 459                             $this->_downloadDeps[] = $ret;
 460                         } elseif (PEAR::isError($ret) && !isset($options['soft'])) {
 461                             $this->_downloader->log(0, $ret->getMessage());
 462                         }
 463                     }
 464                 } else {
 465                     $dep = $deps['required'][$packagetype];
 466                     if (!isset($dep['conflicts'])) {
 467                         // skip any package that this package conflicts with
 468                         $ret = $this->_detect2Dep($dep, $pname, 'required', $params);
 469                         if (is_array($ret)) {
 470                             $this->_downloadDeps[] = $ret;
 471                         } elseif (PEAR::isError($ret) && !isset($options['soft'])) {
 472                             $this->_downloader->log(0, $ret->getMessage());
 473                         }
 474                     }
 475                 }
 476             }
 477
 478             // get optional dependency group, if any
 479             if (isset($deps['optional'][$packagetype])) {
 480                 $skipnames = array();
 481                 if (!isset($deps['optional'][$packagetype][0])) {
 482                     $deps['optional'][$packagetype] = array($deps['optional'][$packagetype]);
 483                 }
 484
 485                 foreach ($deps['optional'][$packagetype] as $dep) {
 486                     $skip = false;
 487                     if (!isset($options['alldeps'])) {
 488                         $dep['package'] = $dep['name'];
 489                         if (!isset($options['soft'])) {
 490                             $this->_downloader->log(3, 'Notice: package "' .
 491                               $this->_registry->parsedPackageNameToString($this->getParsedPackage(),
 492                                     true) . '" optional dependency "' .
 493                                 $this->_registry->parsedPackageNameToString(array('package' =>
 494                                     $dep['name'], 'channel' => 'pear.php.net'), true) .
 495                                 '" will not be automatically downloaded');
 496                         }
 497                         $skipnames[] = $this->_registry->parsedPackageNameToString($dep, true);
 498                         $skip = true;
 499                         unset($dep['package']);
 500                     }
 501
 502                     $ret = $this->_detect2Dep($dep, $pname, 'optional', $params);
 503                     if (PEAR::isError($ret) && !isset($options['soft'])) {
 504                         $this->_downloader->log(0, $ret->getMessage());
 505                     }
 506
 507                     if (!$ret) {
 508                         $dep['package'] = $dep['name'];
 509                         $skip = count($skipnames) ?
 510                             $skipnames[count($skipnames) - 1] : '';
 511                         if ($skip ==
 512                               $this->_registry->parsedPackageNameToString($dep, true)) {
 513                             array_pop($skipnames);
 514                         }
 515                     }
 516
 517                     if (!$skip && is_array($ret)) {
 518                         $this->_downloadDeps[] = $ret;
 519                     }
 520                 }
 521
 522                 if (count($skipnames)) {
 523                     if (!isset($options['soft'])) {
 524                         $this->_downloader->log(1, 'Did not download optional dependencies: ' .
 525                             implode(', ', $skipnames) .
 526                             ', use --alldeps to download automatically');
 527                     }
 528                 }
 529             }
 530
 531             // get requested dependency group, if any
 532             $groupname = $this->getGroup();
 533             $explicit  = $this->_explicitGroup;
 534             if (!$groupname) {
 535                 if (!$this->canDefault()) {
 536                     continue;
 537                 }
 538
 539                 $groupname = 'default'; // try the default dependency group
 540             }
 541
 542             if ($groupnotfound) {
 543                 continue;
 544             }
 545
 546             if (isset($deps['group'])) {
 547                 if (isset($deps['group']['attribs'])) {
 548                     if (strtolower($deps['group']['attribs']['name']) == strtolower($groupname)) {
 549                         $group = $deps['group'];
 550                     } elseif ($explicit) {
 551                         if (!isset($options['soft'])) {
 552                             $this->_downloader->log(0, 'Warning: package "' .
 553                                 $this->_registry->parsedPackageNameToString($pname, true) .
 554                                 '" has no dependency ' . 'group named "' . $groupname . '"');
 555                         }
 556
 557                         $groupnotfound = true;
 558                         continue;
 559                     }
 560                 } else {
 561                     $found = false;
 562                     foreach ($deps['group'] as $group) {
 563                         if (strtolower($group['attribs']['name']) == strtolower($groupname)) {
 564                             $found = true;
 565                             break;
 566                         }
 567                     }
 568
 569                     if (!$found) {
 570                         if ($explicit) {
 571                             if (!isset($options['soft'])) {
 572                                 $this->_downloader->log(0, 'Warning: package "' .
 573                                     $this->_registry->parsedPackageNameToString($pname, true) .
 574                                     '" has no dependency ' . 'group named "' . $groupname . '"');
 575                             }
 576                         }
 577
 578                         $groupnotfound = true;
 579                         continue;
 580                     }
 581                 }
 582             }
 583
 584             if (isset($group) && isset($group[$packagetype])) {
 585                 if (isset($group[$packagetype][0])) {
 586                     foreach ($group[$packagetype] as $dep) {
 587                         $ret = $this->_detect2Dep($dep, $pname, 'dependency group "' .
 588                             $group['attribs']['name'] . '"', $params);
 589                         if (is_array($ret)) {
 590                             $this->_downloadDeps[] = $ret;
 591                         } elseif (PEAR::isError($ret) && !isset($options['soft'])) {
 592                             $this->_downloader->log(0, $ret->getMessage());
 593                         }
 594                     }
 595                 } else {
 596                     $ret = $this->_detect2Dep($group[$packagetype], $pname,
 597                         'dependency group "' .
 598                         $group['attribs']['name'] . '"', $params);
 599                     if (is_array($ret)) {
 600                         $this->_downloadDeps[] = $ret;
 601                     } elseif (PEAR::isError($ret) && !isset($options['soft'])) {
 602                         $this->_downloader->log(0, $ret->getMessage());
 603                     }
 604                 }
 605             }
 606         }
 607     }
 608
 609     function _detect2Dep($dep, $pname, $group, $params)
 610     {
 611         if (isset($dep['conflicts'])) {
 612             return true;
 613         }
 614
 615         $options = $this->_downloader->getOptions();
 616         if (isset($dep['uri'])) {
 617             return array('uri' => $dep['uri'], 'dep' => $dep);;
 618         }
 619
 620         $testdep = $dep;
 621         $testdep['package'] = $dep['name'];
 622         if (PEAR_Downloader_Package::willDownload($testdep, $params)) {
 623             $dep['package'] = $dep['name'];
 624             if (!isset($options['soft'])) {
 625                 $this->_downloader->log(2, $this->getShortName() . ': Skipping ' . $group .
 626                     ' dependency "' .
 627                     $this->_registry->parsedPackageNameToString($dep, true) .
 628                     '", will be installed');
 629             }
 630             return false;
 631         }
 632
 633         $options = $this->_downloader->getOptions();
 634         PEAR::pushErrorHandling(PEAR_ERROR_RETURN);
 635         if ($this->_explicitState) {
 636             $pname['state'] = $this->_explicitState;
 637         }
 638
 639         $url = $this->_downloader->_getDepPackageDownloadUrl($dep, $pname);
 640         if (PEAR::isError($url)) {
 641             PEAR::popErrorHandling();
 642             return $url;
 643         }
 644
 645         $dep['package'] = $dep['name'];
 646         $ret = $this->_analyzeDownloadURL($url, 'dependency', $dep, $params, $group == 'optional' &&
 647             !isset($options['alldeps']), true);
 648         PEAR::popErrorHandling();
 649         if (PEAR::isError($ret)) {
 650             if (!isset($options['soft'])) {
 651                 $this->_downloader->log(0, $ret->getMessage());
 652             }
 653
 654             return false;
 655         }
 656
 657         // check to see if a dep is already installed and is the same or newer
 658         if (!isset($dep['min']) && !isset($dep['max']) && !isset($dep['recommended'])) {
 659             $oper = 'has';
 660         } else {
 661             $oper = 'gt';
 662         }
 663
 664         // do not try to move this before getDepPackageDownloadURL
 665         // we can't determine whether upgrade is necessary until we know what
 666         // version would be downloaded
 667         if (!isset($options['force']) && $this->isInstalled($ret, $oper)) {
 668             $version = $this->_installRegistry->packageInfo($dep['name'], 'version', $dep['channel']);
 669             $dep['package'] = $dep['name'];
 670             if (!isset($options['soft'])) {
 671                 $this->_downloader->log(3, $this->getShortName() . ': Skipping ' . $group .
 672                     ' dependency "' .
 673                 $this->_registry->parsedPackageNameToString($dep, true) .
 674                     '" version ' . $url['version'] . ', already installed as version ' .
 675                     $version);
 676             }
 677
 678             return false;
 679         }
 680
 681         if (isset($dep['nodefault'])) {
 682             $ret['nodefault'] = true;
 683         }
 684
 685         return $ret;
 686     }
 687
 688     function _detect1($deps, $pname, $options, $params)
 689     {
 690         $this->_downloadDeps = array();
 691         $skipnames = array();
 692         foreach ($deps as $dep) {
 693             $nodownload = false;
 694             if (isset ($dep['type']) && $dep['type'] === 'pkg') {
 695                 $dep['channel'] = 'pear.php.net';
 696                 $dep['package'] = $dep['name'];
 697                 switch ($dep['rel']) {
 698                     case 'not' :
 699                         continue 2;
 700                     case 'ge' :
 701                     case 'eq' :
 702                     case 'gt' :
 703                     case 'has' :
 704                         $group = (!isset($dep['optional']) || $dep['optional'] == 'no') ?
 705                             'required' :
 706                             'optional';
 707                         if (PEAR_Downloader_Package::willDownload($dep, $params)) {
 708                             $this->_downloader->log(2, $this->getShortName() . ': Skipping ' . $group
 709                                 . ' dependency "' .
 710                                 $this->_registry->parsedPackageNameToString($dep, true) .
 711                                 '", will be installed');
 712                             continue 2;
 713                         }
 714                         $fakedp = new PEAR_PackageFile_v1;
 715                         $fakedp->setPackage($dep['name']);
 716                         // skip internet check if we are not upgrading (bug #5810)
 717                         if (!isset($options['upgrade']) && $this->isInstalled(
 718                               $fakedp, $dep['rel'])) {
 719                             $this->_downloader->log(2, $this->getShortName() . ': Skipping ' . $group
 720                                 . ' dependency "' .
 721                                 $this->_registry->parsedPackageNameToString($dep, true) .
 722                                 '", is already installed');
 723                             continue 2;
 724                         }
 725                 }
 726
 727                 PEAR::pushErrorHandling(PEAR_ERROR_RETURN);
 728                 if ($this->_explicitState) {
 729                     $pname['state'] = $this->_explicitState;
 730                 }
 731
 732                 $url = $this->_downloader->_getDepPackageDownloadUrl($dep, $pname);
 733                 $chan = 'pear.php.net';
 734                 if (PEAR::isError($url)) {
 735                     // check to see if this is a pecl package that has jumped
 736                     // from pear.php.net to pecl.php.net channel
 737                     if (!class_exists('PEAR_Dependency2')) {
 738                         require_once 'PEAR/Dependency2.php';
 739                     }
 740
 741                     $newdep = PEAR_Dependency2::normalizeDep($dep);
 742                     $newdep = $newdep[0];
 743                     $newdep['channel'] = 'pecl.php.net';
 744                     $chan = 'pecl.php.net';
 745                     $url = $this->_downloader->_getDepPackageDownloadUrl($newdep, $pname);
 746                     $obj = &$this->_installRegistry->getPackage($dep['name']);
 747                     if (PEAR::isError($url)) {
 748                         PEAR::popErrorHandling();
 749                         if ($obj !== null && $this->isInstalled($obj, $dep['rel'])) {
 750                             $group = (!isset($dep['optional']) || $dep['optional'] == 'no') ?
 751                                 'required' :
 752                                 'optional';
 753                             $dep['package'] = $dep['name'];
 754                             if (!isset($options['soft'])) {
 755                                 $this->_downloader->log(3, $this->getShortName() .
 756                                     ': Skipping ' . $group . ' dependency "' .
 757                                     $this->_registry->parsedPackageNameToString($dep, true) .
 758                                     '", already installed as version ' . $obj->getVersion());
 759                             }
 760                             $skip = count($skipnames) ?
 761                                 $skipnames[count($skipnames) - 1] : '';
 762                             if ($skip ==
 763                                   $this->_registry->parsedPackageNameToString($dep, true)) {
 764                                 array_pop($skipnames);
 765                             }
 766                             continue;
 767                         } else {
 768                             if (isset($dep['optional']) && $dep['optional'] == 'yes') {
 769                                 $this->_downloader->log(2, $this->getShortName() .
 770                                     ': Skipping optional dependency "' .
 771                                     $this->_registry->parsedPackageNameToString($dep, true) .
 772                                     '", no releases exist');
 773                                 continue;
 774                             } else {
 775                                 return $url;
 776                             }
 777                         }
 778                     }
 779                 }
 780
 781                 PEAR::popErrorHandling();
 782                 if (!isset($options['alldeps'])) {
 783                     if (isset($dep['optional']) && $dep['optional'] == 'yes') {
 784                         if (!isset($options['soft'])) {
 785                             $this->_downloader->log(3, 'Notice: package "' .
 786                                 $this->getShortName() .
 787                                 '" optional dependency "' .
 788                                 $this->_registry->parsedPackageNameToString(
 789                                     array('channel' => $chan, 'package' =>
 790                                     $dep['name']), true) .
 791                                 '" will not be automatically downloaded');
 792                         }
 793                         $skipnames[] = $this->_registry->parsedPackageNameToString(
 794                                 array('channel' => $chan, 'package' =>
 795                                 $dep['name']), true);
 796                         $nodownload = true;
 797                     }
 798                 }
 799
 800                 if (!isset($options['alldeps']) && !isset($options['onlyreqdeps'])) {
 801                     if (!isset($dep['optional']) || $dep['optional'] == 'no') {
 802                         if (!isset($options['soft'])) {
 803                             $this->_downloader->log(3, 'Notice: package "' .
 804                                 $this->getShortName() .
 805                                 '" required dependency "' .
 806                                 $this->_registry->parsedPackageNameToString(
 807                                     array('channel' => $chan, 'package' =>
 808                                     $dep['name']), true) .
 809                                 '" will not be automatically downloaded');
 810                         }
 811                         $skipnames[] = $this->_registry->parsedPackageNameToString(
 812                                 array('channel' => $chan, 'package' =>
 813                                 $dep['name']), true);
 814                         $nodownload = true;
 815                     }
 816                 }
 817
 818                 // check to see if a dep is already installed
 819                 // do not try to move this before getDepPackageDownloadURL
 820                 // we can't determine whether upgrade is necessary until we know what
 821                 // version would be downloaded
 822                 if (!isset($options['force']) && $this->isInstalled(
 823                         $url, $dep['rel'])) {
 824                     $group = (!isset($dep['optional']) || $dep['optional'] == 'no') ?
 825                         'required' :
 826                         'optional';
 827                     $dep['package'] = $dep['name'];
 828                     if (isset($newdep)) {
 829                         $version = $this->_installRegistry->packageInfo($newdep['name'], 'version', $newdep['channel']);
 830                     } else {
 831                         $version = $this->_installRegistry->packageInfo($dep['name'], 'version');
 832                     }
 833
 834                     $dep['version'] = $url['version'];
 835                     if (!isset($options['soft'])) {
 836                         $this->_downloader->log(3, $this->getShortName() . ': Skipping ' . $group .
 837                             ' dependency "' .
 838                             $this->_registry->parsedPackageNameToString($dep, true) .
 839                             '", already installed as version ' . $version);
 840                     }
 841
 842                     $skip = count($skipnames) ?
 843                         $skipnames[count($skipnames) - 1] : '';
 844                     if ($skip ==
 845                           $this->_registry->parsedPackageNameToString($dep, true)) {
 846                         array_pop($skipnames);
 847                     }
 848
 849                     continue;
 850                 }
 851
 852                 if ($nodownload) {
 853                     continue;
 854                 }
 855
 856                 PEAR::pushErrorHandling(PEAR_ERROR_RETURN);
 857                 if (isset($newdep)) {
 858                     $dep = $newdep;
 859                 }
 860
 861                 $dep['package'] = $dep['name'];
 862                 $ret = $this->_analyzeDownloadURL($url, 'dependency', $dep, $params,
 863                     isset($dep['optional']) && $dep['optional'] == 'yes' &&
 864                     !isset($options['alldeps']), true);
 865                 PEAR::popErrorHandling();
 866                 if (PEAR::isError($ret)) {
 867                     if (!isset($options['soft'])) {
 868                         $this->_downloader->log(0, $ret->getMessage());
 869                     }
 870                     continue;
 871                 }
 872
 873                 $this->_downloadDeps[] = $ret;
 874             }
 875         }
 876
 877         if (count($skipnames)) {
 878             if (!isset($options['soft'])) {
 879                 $this->_downloader->log(1, 'Did not download dependencies: ' .
 880                     implode(', ', $skipnames) .
 881                     ', use --alldeps or --onlyreqdeps to download automatically');
 882             }
 883         }
 884     }
 885
 886     function setDownloadURL($pkg)
 887     {
 888         $this->_downloadURL = $pkg;
 889     }
 890
 891     /**
 892      * Set the package.xml object for this downloaded package
 893      *
 894      * @param PEAR_PackageFile_v1|PEAR_PackageFile_v2 $pkg
 895      */
 896     function setPackageFile(&$pkg)
 897     {
 898         $this->_packagefile = &$pkg;
 899     }
 900
 901     function getShortName()
 902     {
 903         return $this->_registry->parsedPackageNameToString(array('channel' => $this->getChannel(),
 904             'package' => $this->getPackage()), true);
 905     }
 906
 907     function getParsedPackage()
 908     {
 909         if (isset($this->_packagefile) || isset($this->_parsedname)) {
 910             return array('channel' => $this->getChannel(),
 911                 'package' => $this->getPackage(),
 912                 'version' => $this->getVersion());
 913         }
 914
 915         return false;
 916     }
 917
 918     function getDownloadURL()
 919     {
 920         return $this->_downloadURL;
 921     }
 922
 923     function canDefault()
 924     {
 925         if (isset($this->_downloadURL) && isset($this->_downloadURL['nodefault'])) {
 926             return false;
 927         }
 928
 929         return true;
 930     }
 931
 932     function getPackage()
 933     {
 934         if (isset($this->_packagefile)) {
 935             return $this->_packagefile->getPackage();
 936         } elseif (isset($this->_downloadURL['info'])) {
 937             return $this->_downloadURL['info']->getPackage();
 938         }
 939
 940         return false;
 941     }
 942
 943     /**
 944      * @param PEAR_PackageFile_v1|PEAR_PackageFile_v2
 945      */
 946     function isSubpackage(&$pf)
 947     {
 948         if (isset($this->_packagefile)) {
 949             return $this->_packagefile->isSubpackage($pf);
 950         } elseif (isset($this->_downloadURL['info'])) {
 951             return $this->_downloadURL['info']->isSubpackage($pf);
 952         }
 953
 954         return false;
 955     }
 956
 957     function getPackageType()
 958     {
 959         if (isset($this->_packagefile)) {
 960             return $this->_packagefile->getPackageType();
 961         } elseif (isset($this->_downloadURL['info'])) {
 962             return $this->_downloadURL['info']->getPackageType();
 963         }
 964
 965         return false;
 966     }
 967
 968     function isBundle()
 969     {
 970         if (isset($this->_packagefile)) {
 971             return $this->_packagefile->getPackageType() == 'bundle';
 972         }
 973
 974         return false;
 975     }
 976
 977     function getPackageXmlVersion()
 978     {
 979         if (isset($this->_packagefile)) {
 980             return $this->_packagefile->getPackagexmlVersion();
 981         } elseif (isset($this->_downloadURL['info'])) {
 982             return $this->_downloadURL['info']->getPackagexmlVersion();
 983         }
 984
 985         return '1.0';
 986     }
 987
 988     function getChannel()
 989     {
 990         if (isset($this->_packagefile)) {
 991             return $this->_packagefile->getChannel();
 992         } elseif (isset($this->_downloadURL['info'])) {
 993             return $this->_downloadURL['info']->getChannel();
 994         }
 995
 996         return false;
 997     }
 998
 999     function getURI()
1000     {
1001         if (isset($this->_packagefile)) {
1002             return $this->_packagefile->getURI();
1003         } elseif (isset($this->_downloadURL['info'])) {
1004             return $this->_downloadURL['info']->getURI();
1005         }
1006
1007         return false;
1008     }
1009
1010     function getVersion()
1011     {
1012         if (isset($this->_packagefile)) {
1013             return $this->_packagefile->getVersion();
1014         } elseif (isset($this->_downloadURL['version'])) {
1015             return $this->_downloadURL['version'];
1016         }
1017
1018         return false;
1019     }
1020
1021     function isCompatible($pf)
1022     {
1023         if (isset($this->_packagefile)) {
1024             return $this->_packagefile->isCompatible($pf);
1025         } elseif (isset($this->_downloadURL['info'])) {
1026             return $this->_downloadURL['info']->isCompatible($pf);
1027         }
1028
1029         return true;
1030     }
1031
1032     function setGroup($group)
1033     {
1034         $this->_parsedname['group'] = $group;
1035     }
1036
1037     function getGroup()
1038     {
1039         if (isset($this->_parsedname['group'])) {
1040             return $this->_parsedname['group'];
1041         }
1042
1043         return '';
1044     }
1045
1046     function isExtension($name)
1047     {
1048         if (isset($this->_packagefile)) {
1049             return $this->_packagefile->isExtension($name);
1050         } elseif (isset($this->_downloadURL['info'])) {
1051             if ($this->_downloadURL['info']->getPackagexmlVersion() == '2.0') {
1052                 return $this->_downloadURL['info']->getProvidesExtension() == $name;
1053             }
1054
1055             return false;
1056         }
1057
1058         return false;
1059     }
1060
1061     function getDeps()
1062     {
1063         if (isset($this->_packagefile)) {
1064             $ver = $this->_packagefile->getPackagexmlVersion();
1065             if (version_compare($ver, '2.0', '>=')) {
1066                 return $this->_packagefile->getDeps(true);
1067             }
1068
1069             return $this->_packagefile->getDeps();
1070         } elseif (isset($this->_downloadURL['info'])) {
1071             $ver = $this->_downloadURL['info']->getPackagexmlVersion();
1072             if (version_compare($ver, '2.0', '>=')) {
1073                 return $this->_downloadURL['info']->getDeps(true);
1074             }
1075
1076             return $this->_downloadURL['info']->getDeps();
1077         }
1078
1079         return array();
1080     }
1081
1082     /**
1083      * @param array Parsed array from {@link PEAR_Registry::parsePackageName()} or a dependency
1084      *                     returned from getDepDownloadURL()
1085      */
1086     function isEqual($param)
1087     {
1088         if (is_object($param)) {
1089             $channel = $param->getChannel();
1090             $package = $param->getPackage();
1091             if ($param->getURI()) {
1092                 $param = array(
1093                     'channel' => $param->getChannel(),
1094                     'package' => $param->getPackage(),
1095                     'version' => $param->getVersion(),
1096                     'uri' => $param->getURI(),
1097                 );
1098             } else {
1099                 $param = array(
1100                     'channel' => $param->getChannel(),
1101                     'package' => $param->getPackage(),
1102                     'version' => $param->getVersion(),
1103                 );
1104             }
1105         } else {
1106             if (isset($param['uri'])) {
1107                 if ($this->getChannel() != '__uri') {
1108                     return false;
1109                 }
1110                 return $param['uri'] == $this->getURI();
1111             }
1112
1113             $package = isset($param['package']) ? $param['package'] : $param['info']->getPackage();
1114             $channel = isset($param['channel']) ? $param['channel'] : $param['info']->getChannel();
1115             if (isset($param['rel'])) {
1116                 if (!class_exists('PEAR_Dependency2')) {
1117                     require_once 'PEAR/Dependency2.php';
1118                 }
1119
1120                 $newdep = PEAR_Dependency2::normalizeDep($param);
1121                 $newdep = $newdep[0];
1122             } elseif (isset($param['min'])) {
1123                 $newdep = $param;
1124             }
1125         }
1126
1127         if (isset($newdep)) {
1128             if (!isset($newdep['min'])) {
1129                 $newdep['min'] = '0';
1130             }
1131
1132             if (!isset($newdep['max'])) {
1133                 $newdep['max'] = '100000000000000000000';
1134             }
1135
1136             // use magic to support pecl packages suddenly jumping to the pecl channel
1137             // we need to support both dependency possibilities
1138             if ($channel == 'pear.php.net' && $this->getChannel() == 'pecl.php.net') {
1139                 if ($package == $this->getPackage()) {
1140                     $channel = 'pecl.php.net';
1141                 }
1142             }
1143             if ($channel == 'pecl.php.net' && $this->getChannel() == 'pear.php.net') {
1144                 if ($package == $this->getPackage()) {
1145                     $channel = 'pear.php.net';
1146                 }
1147             }
1148
1149             return (strtolower($package) == strtolower($this->getPackage()) &&
1150                 $channel == $this->getChannel() &&
1151                 version_compare($newdep['min'], $this->getVersion(), '<=') &&
1152                 version_compare($newdep['max'], $this->getVersion(), '>='));
1153         }
1154
1155         // use magic to support pecl packages suddenly jumping to the pecl channel
1156         if ($channel == 'pecl.php.net' && $this->getChannel() == 'pear.php.net') {
1157             if (strtolower($package) == strtolower($this->getPackage())) {
1158                 $channel = 'pear.php.net';
1159             }
1160         }
1161
1162         if (isset($param['version'])) {
1163             return (strtolower($package) == strtolower($this->getPackage()) &&
1164                 $channel == $this->getChannel() &&
1165                 $param['version'] == $this->getVersion());
1166         }
1167
1168         return strtolower($package) == strtolower($this->getPackage()) &&
1169             $channel == $this->getChannel();
1170     }
1171
1172     function isInstalled($dep, $oper = '==')
1173     {
1174         if (!$dep) {
1175             return false;
1176         }
1177
1178         if ($oper != 'ge' && $oper != 'gt' && $oper != 'has' && $oper != '==') {
1179             return false;
1180         }
1181
1182         if (is_object($dep)) {
1183             $package = $dep->getPackage();
1184             $channel = $dep->getChannel();
1185             if ($dep->getURI()) {
1186                 $dep = array(
1187                     'uri' => $dep->getURI(),
1188                     'version' => $dep->getVersion(),
1189                 );
1190             } else {
1191                 $dep = array(
1192                     'version' => $dep->getVersion(),
1193                 );
1194             }
1195         } else {
1196             if (isset($dep['uri'])) {
1197                 $channel = '__uri';
1198                 $package = $dep['dep']['name'];
1199             } else {
1200                 $channel = $dep['info']->getChannel();
1201                 $package = $dep['info']->getPackage();
1202             }
1203         }
1204
1205         $options = $this->_downloader->getOptions();
1206         $test    = $this->_installRegistry->packageExists($package, $channel);
1207         if (!$test && $channel == 'pecl.php.net') {
1208             // do magic to allow upgrading from old pecl packages to new ones
1209             $test = $this->_installRegistry->packageExists($package, 'pear.php.net');
1210             $channel = 'pear.php.net';
1211         }
1212
1213         if ($test) {
1214             if (isset($dep['uri'])) {
1215                 if ($this->_installRegistry->packageInfo($package, 'uri', '__uri') == $dep['uri']) {
1216                     return true;
1217                 }
1218             }
1219
1220             if (isset($options['upgrade'])) {
1221                 $packageVersion = $this->_installRegistry->packageInfo($package, 'version', $channel);
1222                 if (version_compare($packageVersion, $dep['version'], '>=')) {
1223                     return true;
1224                 }
1225
1226                 return false;
1227             }
1228
1229             return true;
1230         }
1231
1232         return false;
1233     }
1234
1235     /**
1236      * Detect duplicate package names with differing versions
1237      *
1238      * If a user requests to install Date 1.4.6 and Date 1.4.7,
1239      * for instance, this is a logic error.  This method
1240      * detects this situation.
1241      *
1242      * @param array $params array of PEAR_Downloader_Package objects
1243      * @param array $errorparams empty array
1244      * @return array array of stupid duplicated packages in PEAR_Downloader_Package obejcts
1245      */
1246     function detectStupidDuplicates($params, &$errorparams)
1247     {
1248         $existing = array();
1249         foreach ($params as $i => $param) {
1250             $package = $param->getPackage();
1251             $channel = $param->getChannel();
1252             $group   = $param->getGroup();
1253             if (!isset($existing[$channel . '/' . $package])) {
1254                 $existing[$channel . '/' . $package] = array();
1255             }
1256
1257             if (!isset($existing[$channel . '/' . $package][$group])) {
1258                 $existing[$channel . '/' . $package][$group] = array();
1259             }
1260
1261             $existing[$channel . '/' . $package][$group][] = $i;
1262         }
1263
1264         $indices = array();
1265         foreach ($existing as $package => $groups) {
1266             foreach ($groups as $group => $dupes) {
1267                 if (count($dupes) > 1) {
1268                     $indices = $indices + $dupes;
1269                 }
1270             }
1271         }
1272
1273         $indices = array_unique($indices);
1274         foreach ($indices as $index) {
1275             $errorparams[] = $params[$index];
1276         }
1277
1278         return count($errorparams);
1279     }
1280
1281     /**
1282      * @param array
1283      * @param bool ignore install groups - for final removal of dupe packages
1284      * @static
1285      */
1286     function removeDuplicates(&$params, $ignoreGroups = false)
1287     {
1288         $pnames = array();
1289         foreach ($params as $i => $param) {
1290             if (!$param) {
1291                 continue;
1292             }
1293
1294             if ($param->getPackage()) {
1295                 $group = $ignoreGroups ? '' : $param->getGroup();
1296                 $pnames[$i] = $param->getChannel() . '/' .
1297                     $param->getPackage() . '-' . $param->getVersion() . '#' . $group;
1298             }
1299         }
1300
1301         $pnames = array_unique($pnames);
1302         $unset  = array_diff(array_keys($params), array_keys($pnames));
1303         $testp  = array_flip($pnames);
1304         foreach ($params as $i => $param) {
1305             if (!$param) {
1306                 $unset[] = $i;
1307                 continue;
1308             }
1309
1310             if (!is_a($param, 'PEAR_Downloader_Package')) {
1311                 $unset[] = $i;
1312                 continue;
1313             }
1314
1315             $group = $ignoreGroups ? '' : $param->getGroup();
1316             if (!isset($testp[$param->getChannel() . '/' . $param->getPackage() . '-' .
1317                   $param->getVersion() . '#' . $group])) {
1318                 $unset[] = $i;
1319             }
1320         }
1321
1322         foreach ($unset as $i) {
1323             unset($params[$i]);
1324         }
1325
1326         $ret = array();
1327         foreach ($params as $i => $param) {
1328             $ret[] = &$params[$i];
1329         }
1330
1331         $params = array();
1332         foreach ($ret as $i => $param) {
1333             $params[] = &$ret[$i];
1334         }
1335     }
1336
1337     function explicitState()
1338     {
1339         return $this->_explicitState;
1340     }
1341
1342     function setExplicitState($s)
1343     {
1344         $this->_explicitState = $s;
1345     }
1346
1347     /**
1348      * @static
1349      */
1350     function mergeDependencies(&$params)
1351     {
1352         $bundles = $newparams = array();
1353         foreach ($params as $i => $param) {
1354             if (!$param->isBundle()) {
1355                 continue;
1356             }
1357
1358             $bundles[] = $i;
1359             $pf = &$param->getPackageFile();
1360             $newdeps = array();
1361             $contents = $pf->getBundledPackages();
1362             if (!is_array($contents)) {
1363                 $contents = array($contents);
1364             }
1365
1366             foreach ($contents as $file) {
1367                 $filecontents = $pf->getFileContents($file);
1368                 $dl = &$param->getDownloader();
1369                 $options = $dl->getOptions();
1370                 if (PEAR::isError($dir = $dl->getDownloadDir())) {
1371                     return $dir;
1372                 }
1373
1374                 $fp = @fopen($dir . DIRECTORY_SEPARATOR . $file, 'wb');
1375                 if (!$fp) {
1376                     continue;
1377                 }
1378
1379                 // FIXME do symlink check
1380
1381                 fwrite($fp, $filecontents, strlen($filecontents));
1382                 fclose($fp);
1383                 if ($s = $params[$i]->explicitState()) {
1384                     $obj->setExplicitState($s);
1385                 }
1386
1387                 $obj = &new PEAR_Downloader_Package($params[$i]->getDownloader());
1388                 PEAR::pushErrorHandling(PEAR_ERROR_RETURN);
1389                 if (PEAR::isError($dir = $dl->getDownloadDir())) {
1390                     PEAR::popErrorHandling();
1391                     return $dir;
1392                 }
1393
1394                 $e = $obj->_fromFile($a = $dir . DIRECTORY_SEPARATOR . $file);
1395                 PEAR::popErrorHandling();
1396                 if (PEAR::isError($e)) {
1397                     if (!isset($options['soft'])) {
1398                         $dl->log(0, $e->getMessage());
1399                     }
1400                     continue;
1401                 }
1402
1403                 $j = &$obj;
1404                 if (!PEAR_Downloader_Package::willDownload($j,
1405                       array_merge($params, $newparams)) && !$param->isInstalled($j)) {
1406                     $newparams[] = &$j;
1407                 }
1408             }
1409         }
1410
1411         foreach ($bundles as $i) {
1412             unset($params[$i]); // remove bundles - only their contents matter for installation
1413         }
1414
1415         PEAR_Downloader_Package::removeDuplicates($params); // strip any unset indices
1416         if (count($newparams)) { // add in bundled packages for install
1417             foreach ($newparams as $i => $unused) {
1418                 $params[] = &$newparams[$i];
1419             }
1420             $newparams = array();
1421         }
1422
1423         foreach ($params as $i => $param) {
1424             $newdeps = array();
1425             foreach ($param->_downloadDeps as $dep) {
1426                 $merge = array_merge($params, $newparams);
1427                 if (!PEAR_Downloader_Package::willDownload($dep, $merge)
1428                     && !$param->isInstalled($dep)
1429                 ) {
1430                     $newdeps[] = $dep;
1431                 } else {
1432                     //var_dump($dep);
1433                     // detect versioning conflicts here
1434                 }
1435             }
1436
1437             // convert the dependencies into PEAR_Downloader_Package objects for the next time around
1438             $params[$i]->_downloadDeps = array();
1439             foreach ($newdeps as $dep) {
1440                 $obj = &new PEAR_Downloader_Package($params[$i]->getDownloader());
1441                 if ($s = $params[$i]->explicitState()) {
1442                     $obj->setExplicitState($s);
1443                 }
1444
1445                 PEAR::pushErrorHandling(PEAR_ERROR_RETURN);
1446                 $e = $obj->fromDepURL($dep);
1447                 PEAR::popErrorHandling();
1448                 if (PEAR::isError($e)) {
1449                     if (!isset($options['soft'])) {
1450                         $obj->_downloader->log(0, $e->getMessage());
1451                     }
1452                     continue;
1453                 }
1454
1455                 $e = $obj->detectDependencies($params);
1456                 if (PEAR::isError($e)) {
1457                     if (!isset($options['soft'])) {
1458                         $obj->_downloader->log(0, $e->getMessage());
1459                     }
1460                 }
1461
1462                 $j = &$obj;
1463                 $newparams[] = &$j;
1464             }
1465         }
1466
1467         if (count($newparams)) {
1468             foreach ($newparams as $i => $unused) {
1469                 $params[] = &$newparams[$i];
1470             }
1471             return true;
1472         }
1473
1474         return false;
1475     }
1476
1477
1478     /**
1479      * @static
1480      */
1481     function willDownload($param, $params)
1482     {
1483         if (!is_array($params)) {
1484             return false;
1485         }
1486
1487         foreach ($params as $obj) {
1488             if ($obj->isEqual($param)) {
1489                 return true;
1490             }
1491         }
1492
1493         return false;
1494     }
1495
1496     /**
1497      * For simpler unit-testing
1498      * @param PEAR_Config
1499      * @param int
1500      * @param string
1501      */
1502     function &getPackagefileObject(&$c, $d)
1503     {
1504         $a = &new PEAR_PackageFile($c, $d);
1505         return $a;
1506     }
1507
1508     /**
1509      * This will retrieve from a local file if possible, and parse out
1510      * a group name as well.  The original parameter will be modified to reflect this.
1511      * @param string|array can be a parsed package name as well
1512      * @access private
1513      */
1514     function _fromFile(&$param)
1515     {
1516         $saveparam = $param;
1517         if (is_string($param)) {
1518             if (!@file_exists($param)) {
1519                 $test = explode('#', $param);
1520                 $group = array_pop($test);
1521                 if (@file_exists(implode('#', $test))) {
1522                     $this->setGroup($group);
1523                     $param = implode('#', $test);
1524                     $this->_explicitGroup = true;
1525                 }
1526             }
1527
1528             if (@is_file($param)) {
1529                 $this->_type = 'local';
1530                 $options = $this->_downloader->getOptions();
1531                 $pkg = &$this->getPackagefileObject($this->_config, $this->_downloader->_debug);
1532                 PEAR::pushErrorHandling(PEAR_ERROR_RETURN);
1533                 $pf = &$pkg->fromAnyFile($param, PEAR_VALIDATE_INSTALLING);
1534                 PEAR::popErrorHandling();
1535                 if (PEAR::isError($pf)) {
1536                     $this->_valid = false;
1537                     $param = $saveparam;
1538                     return $pf;
1539                 }
1540                 $this->_packagefile = &$pf;
1541                 if (!$this->getGroup()) {
1542                     $this->setGroup('default'); // install the default dependency group
1543                 }
1544                 return $this->_valid = true;
1545             }
1546         }
1547         $param = $saveparam;
1548         return $this->_valid = false;
1549     }
1550
1551     function _fromUrl($param, $saveparam = '')
1552     {
1553         if (!is_array($param) && (preg_match('#^(http|https|ftp)://#', $param))) {
1554             $options = $this->_downloader->getOptions();
1555             $this->_type = 'url';
1556             $callback = $this->_downloader->ui ?
1557                 array(&$this->_downloader, '_downloadCallback') : null;
1558             $this->_downloader->pushErrorHandling(PEAR_ERROR_RETURN);
1559             if (PEAR::isError($dir = $this->_downloader->getDownloadDir())) {
1560                 $this->_downloader->popErrorHandling();
1561                 return $dir;
1562             }
1563
1564             $this->_downloader->log(3, 'Downloading "' . $param . '"');
1565             $file = $this->_downloader->downloadHttp($param, $this->_downloader->ui,
1566                 $dir, $callback, null, false, $this->getChannel());
1567             $this->_downloader->popErrorHandling();
1568             if (PEAR::isError($file)) {
1569                 if (!empty($saveparam)) {
1570                     $saveparam = ", cannot download \"$saveparam\"";
1571                 }
1572                 $err = PEAR::raiseError('Could not download from "' . $param .
1573                     '"' . $saveparam . ' (' . $file->getMessage() . ')');
1574                     return $err;
1575             }
1576
1577             if ($this->_rawpackagefile) {
1578                 require_once 'Archive/Tar.php';
1579                 $tar = &new Archive_Tar($file);
1580                 $packagexml = $tar->extractInString('package2.xml');
1581                 if (!$packagexml) {
1582                     $packagexml = $tar->extractInString('package.xml');
1583                 }
1584
1585                 if (str_replace(array("\n", "\r"), array('',''), $packagexml) !=
1586                       str_replace(array("\n", "\r"), array('',''), $this->_rawpackagefile)) {
1587                     if ($this->getChannel() != 'pear.php.net') {
1588                         return PEAR::raiseError('CRITICAL ERROR: package.xml downloaded does ' .
1589                             'not match value returned from xml-rpc');
1590                     }
1591
1592                     // be more lax for the existing PEAR packages that have not-ok
1593                     // characters in their package.xml
1594                     $this->_downloader->log(0, 'CRITICAL WARNING: The "' .
1595                         $this->getPackage() . '" package has invalid characters in its ' .
1596                         'package.xml.  The next version of PEAR may not be able to install ' .
1597                         'this package for security reasons.  Please open a bug report at ' .
1598                         'http://pear.php.net/package/' . $this->getPackage() . '/bugs');
1599                 }
1600             }
1601
1602             // whew, download worked!
1603             $pkg = &$this->getPackagefileObject($this->_config, $this->_downloader->debug);
1604
1605             PEAR::pushErrorHandling(PEAR_ERROR_RETURN);
1606             $pf = &$pkg->fromAnyFile($file, PEAR_VALIDATE_INSTALLING);
1607             PEAR::popErrorHandling();
1608             if (PEAR::isError($pf)) {
1609                 if (is_array($pf->getUserInfo())) {
1610                     foreach ($pf->getUserInfo() as $err) {
1611                         if (is_array($err)) {
1612                             $err = $err['message'];
1613                         }
1614
1615                         if (!isset($options['soft'])) {
1616                             $this->_downloader->log(0, "Validation Error: $err");
1617                         }
1618                     }
1619                 }
1620
1621                 if (!isset($options['soft'])) {
1622                     $this->_downloader->log(0, $pf->getMessage());
1623                 }
1624
1625                 ///FIXME need to pass back some error code that we can use to match with to cancel all further operations
1626                 /// At least stop all deps of this package from being installed
1627                 $out = $saveparam ? $saveparam : $param;
1628                 $err = PEAR::raiseError('Download of "' . $out . '" succeeded, but it is not a valid package archive');
1629                 $this->_valid = false;
1630                 return $err;
1631             }
1632
1633             $this->_packagefile = &$pf;
1634             $this->setGroup('default'); // install the default dependency group
1635             return $this->_valid = true;
1636         }
1637
1638         return $this->_valid = false;
1639     }
1640
1641     /**
1642      *
1643      * @param string|array pass in an array of format
1644      *                     array(
1645      *                      'package' => 'pname',
1646      *                     ['channel' => 'channame',]
1647      *                     ['version' => 'version',]
1648      *                     ['state' => 'state',])
1649      *                     or a string of format [channame/]pname[-version|-state]
1650      */
1651     function _fromString($param)
1652     {
1653         $options = $this->_downloader->getOptions();
1654         $channel = $this->_config->get('default_channel');
1655         PEAR::pushErrorHandling(PEAR_ERROR_RETURN);
1656         $pname = $this->_registry->parsePackageName($param, $channel);
1657         PEAR::popErrorHandling();
1658         if (PEAR::isError($pname)) {
1659             if ($pname->getCode() == 'invalid') {
1660                 $this->_valid = false;
1661                 return false;
1662             }
1663
1664             if ($pname->getCode() == 'channel') {
1665                 $parsed = $pname->getUserInfo();
1666                 if ($this->_downloader->discover($parsed['channel'])) {
1667                     if ($this->_config->get('auto_discover')) {
1668                         PEAR::pushErrorHandling(PEAR_ERROR_RETURN);
1669                         $pname = $this->_registry->parsePackageName($param, $channel);
1670                         PEAR::popErrorHandling();
1671                     } else {
1672                         if (!isset($options['soft'])) {
1673                             $this->_downloader->log(0, 'Channel "' . $parsed['channel'] .
1674                                 '" is not initialized, use ' .
1675                                 '"pear channel-discover ' . $parsed['channel'] . '" to initialize' .
1676                                 'or pear config-set auto_discover 1');
1677                         }
1678                     }
1679                 }
1680
1681                 if (PEAR::isError($pname)) {
1682                     if (!isset($options['soft'])) {
1683                         $this->_downloader->log(0, $pname->getMessage());
1684                     }
1685
1686                     if (is_array($param)) {
1687                         $param = $this->_registry->parsedPackageNameToString($param);
1688                     }
1689
1690                     $err = PEAR::raiseError('invalid package name/package file "' . $param . '"');
1691                     $this->_valid = false;
1692                     return $err;
1693                 }
1694             } else {
1695                 if (!isset($options['soft'])) {
1696                     $this->_downloader->log(0, $pname->getMessage());
1697                 }
1698
1699                 $err = PEAR::raiseError('invalid package name/package file "' . $param . '"');
1700                 $this->_valid = false;
1701                 return $err;
1702             }
1703         }
1704
1705         if (!isset($this->_type)) {
1706             $this->_type = 'rest';
1707         }
1708
1709         $this->_parsedname    = $pname;
1710         $this->_explicitState = isset($pname['state']) ? $pname['state'] : false;
1711         $this->_explicitGroup = isset($pname['group']) ? true : false;
1712
1713         $info = $this->_downloader->_getPackageDownloadUrl($pname);
1714         if (PEAR::isError($info)) {
1715             if ($info->getCode() != -976 && $pname['channel'] == 'pear.php.net') {
1716                 // try pecl
1717                 $pname['channel'] = 'pecl.php.net';
1718                 if ($test = $this->_downloader->_getPackageDownloadUrl($pname)) {
1719                     if (!PEAR::isError($test)) {
1720                         $info = PEAR::raiseError($info->getMessage() . ' - package ' .
1721                             $this->_registry->parsedPackageNameToString($pname, true) .
1722                             ' can be installed with "pecl install ' . $pname['package'] .
1723                             '"');
1724                     } else {
1725                         $pname['channel'] = 'pear.php.net';
1726                     }
1727                 } else {
1728                     $pname['channel'] = 'pear.php.net';
1729                 }
1730             }
1731
1732             return $info;
1733         }
1734
1735         $this->_rawpackagefile = $info['raw'];
1736         $ret = $this->_analyzeDownloadURL($info, $param, $pname);
1737         if (PEAR::isError($ret)) {
1738             return $ret;
1739         }
1740
1741         if ($ret) {
1742             $this->_downloadURL = $ret;
1743             return $this->_valid = (bool) $ret;
1744         }
1745     }
1746
1747     /**
1748      * @param array output of package.getDownloadURL
1749      * @param string|array|object information for detecting packages to be downloaded, and
1750      *                            for errors
1751      * @param array name information of the package
1752      * @param array|null packages to be downloaded
1753      * @param bool is this an optional dependency?
1754      * @param bool is this any kind of dependency?
1755      * @access private
1756      */
1757     function _analyzeDownloadURL($info, $param, $pname, $params = null, $optional = false,
1758                                  $isdependency = false)
1759     {
1760         if (!is_string($param) && PEAR_Downloader_Package::willDownload($param, $params)) {
1761             return false;
1762         }
1763
1764         if ($info === false) {
1765             $saveparam = !is_string($param) ? ", cannot download \"$param\"" : '';
1766
1767             // no releases exist
1768             return PEAR::raiseError('No releases for package "' .
1769                 $this->_registry->parsedPackageNameToString($pname, true) . '" exist' . $saveparam);
1770         }
1771
1772         if (strtolower($info['info']->getChannel()) != strtolower($pname['channel'])) {
1773             $err = false;
1774             if ($pname['channel'] == 'pecl.php.net') {
1775                 if ($info['info']->getChannel() != 'pear.php.net') {
1776                     $err = true;
1777                 }
1778             } elseif ($info['info']->getChannel() == 'pecl.php.net') {
1779                 if ($pname['channel'] != 'pear.php.net') {
1780                     $err = true;
1781                 }
1782             } else {
1783                 $err = true;
1784             }
1785
1786             if ($err) {
1787                 return PEAR::raiseError('SECURITY ERROR: package in channel "' . $pname['channel'] .
1788                     '" retrieved another channel\'s name for download! ("' .
1789                     $info['info']->getChannel() . '")');
1790             }
1791         }
1792
1793         $preferred_state = $this->_config->get('preferred_state');
1794         if (!isset($info['url'])) {
1795             $package_version = $this->_registry->packageInfo($info['info']->getPackage(),
1796             'version', $info['info']->getChannel());
1797             if ($this->isInstalled($info)) {
1798                 if ($isdependency && version_compare($info['version'], $package_version, '<=')) {
1799                     // ignore bogus errors of "failed to download dependency"
1800                     // if it is already installed and the one that would be
1801                     // downloaded is older or the same version (Bug #7219)
1802                     return false;
1803                 }
1804             }
1805
1806             if ($info['version'] === $package_version) {
1807                 if (!isset($options['soft'])) {
1808                     $this->_downloader->log(1, 'WARNING: failed to download ' . $pname['channel'] .
1809                         '/' . $pname['package'] . '-' . $package_version. ', additionally the suggested version' .
1810                         ' (' . $package_version . ') is the same as the locally installed one.');
1811                 }
1812
1813                 return false;
1814             }
1815
1816             if (version_compare($info['version'], $package_version, '<=')) {
1817                 if (!isset($options['soft'])) {
1818                     $this->_downloader->log(1, 'WARNING: failed to download ' . $pname['channel'] .
1819                         '/' . $pname['package'] . '-' . $package_version . ', additionally the suggested version' .
1820                         ' (' . $info['version'] . ') is a lower version than the locally installed one (' . $package_version . ').');
1821                 }
1822
1823                 return false;
1824             }
1825
1826             $instead =  ', will instead download version ' . $info['version'] .
1827                         ', stability "' . $info['info']->getState() . '"';
1828             // releases exist, but we failed to get any
1829             if (isset($this->_downloader->_options['force'])) {
1830                 if (isset($pname['version'])) {
1831                     $vs = ', version "' . $pname['version'] . '"';
1832                 } elseif (isset($pname['state'])) {
1833                     $vs = ', stability "' . $pname['state'] . '"';
1834                 } elseif ($param == 'dependency') {
1835                     if (!class_exists('PEAR_Common')) {
1836                         require_once 'PEAR/Common.php';
1837                     }
1838
1839                     if (!in_array($info['info']->getState(),
1840                           PEAR_Common::betterStates($preferred_state, true))) {
1841                         if ($optional) {
1842                             // don't spit out confusing error message
1843                             return $this->_downloader->_getPackageDownloadUrl(
1844                                 array('package' => $pname['package'],
1845                                       'channel' => $pname['channel'],
1846                                       'version' => $info['version']));
1847                         }
1848                         $vs = ' within preferred state "' . $preferred_state .
1849                             '"';
1850                     } else {
1851                         if (!class_exists('PEAR_Dependency2')) {
1852                             require_once 'PEAR/Dependency2.php';
1853                         }
1854
1855                         if ($optional) {
1856                             // don't spit out confusing error message
1857                             return $this->_downloader->_getPackageDownloadUrl(
1858                                 array('package' => $pname['package'],
1859                                       'channel' => $pname['channel'],
1860                                       'version' => $info['version']));
1861                         }
1862                         $vs = PEAR_Dependency2::_getExtraString($pname);
1863                         $instead = '';
1864                     }
1865                 } else {
1866                     $vs = ' within preferred state "' . $preferred_state . '"';
1867                 }
1868
1869                 if (!isset($options['soft'])) {
1870                     $this->_downloader->log(1, 'WARNING: failed to download ' . $pname['channel'] .
1871                         '/' . $pname['package'] . $vs . $instead);
1872                 }
1873
1874                 // download the latest release
1875                 return $this->_downloader->_getPackageDownloadUrl(
1876                     array('package' => $pname['package'],
1877                           'channel' => $pname['channel'],
1878                           'version' => $info['version']));
1879             } else {
1880                 if (isset($info['php']) && $info['php']) {
1881                     $err = PEAR::raiseError('Failed to download ' .
1882                         $this->_registry->parsedPackageNameToString(
1883                             array('channel' => $pname['channel'],
1884                                   'package' => $pname['package']),
1885                                 true) .
1886                         ', latest release is version ' . $info['php']['v'] .
1887                         ', but it requires PHP version "' .
1888                         $info['php']['m'] . '", use "' .
1889                         $this->_registry->parsedPackageNameToString(
1890                             array('channel' => $pname['channel'], 'package' => $pname['package'],
1891                             'version' => $info['php']['v'])) . '" to install',
1892                             PEAR_DOWNLOADER_PACKAGE_PHPVERSION);
1893                     return $err;
1894                 }
1895
1896                 // construct helpful error message
1897                 if (isset($pname['version'])) {
1898                     $vs = ', version "' . $pname['version'] . '"';
1899                 } elseif (isset($pname['state'])) {
1900                     $vs = ', stability "' . $pname['state'] . '"';
1901                 } elseif ($param == 'dependency') {
1902                     if (!class_exists('PEAR_Common')) {
1903                         require_once 'PEAR/Common.php';
1904                     }
1905
1906                     if (!in_array($info['info']->getState(),
1907                           PEAR_Common::betterStates($preferred_state, true))) {
1908                         if ($optional) {
1909                             // don't spit out confusing error message, and don't die on
1910                             // optional dep failure!
1911                             return $this->_downloader->_getPackageDownloadUrl(
1912                                 array('package' => $pname['package'],
1913                                       'channel' => $pname['channel'],
1914                                       'version' => $info['version']));
1915                         }
1916                         $vs = ' within preferred state "' . $preferred_state . '"';
1917                     } else {
1918                         if (!class_exists('PEAR_Dependency2')) {
1919                             require_once 'PEAR/Dependency2.php';
1920                         }
1921
1922                         if ($optional) {
1923                             // don't spit out confusing error message, and don't die on
1924                             // optional dep failure!
1925                             return $this->_downloader->_getPackageDownloadUrl(
1926                                 array('package' => $pname['package'],
1927                                       'channel' => $pname['channel'],
1928                                       'version' => $info['version']));
1929                         }
1930                         $vs = PEAR_Dependency2::_getExtraString($pname);
1931                     }
1932                 } else {
1933                     $vs = ' within preferred state "' . $this->_downloader->config->get('preferred_state') . '"';
1934                 }
1935
1936                 $options = $this->_downloader->getOptions();
1937                 // this is only set by the "download-all" command
1938                 if (isset($options['ignorepreferred_state'])) {
1939                     $err = PEAR::raiseError(
1940                         'Failed to download ' . $this->_registry->parsedPackageNameToString(
1941                             array('channel' => $pname['channel'], 'package' => $pname['package']),
1942                                 true)
1943                          . $vs .
1944                         ', latest release is version ' . $info['version'] .
1945                         ', stability "' . $info['info']->getState() . '", use "' .
1946                         $this->_registry->parsedPackageNameToString(
1947                             array('channel' => $pname['channel'], 'package' => $pname['package'],
1948                             'version' => $info['version'])) . '" to install',
1949                             PEAR_DOWNLOADER_PACKAGE_STATE);
1950                     return $err;
1951                 }
1952
1953                 // Checks if the user has a package installed already and checks the release against
1954                 // the state against the installed package, this allows upgrades for packages
1955                 // with lower stability than the preferred_state
1956                 $stability = $this->_registry->packageInfo($pname['package'], 'stability', $pname['channel']);
1957                 if (!$this->isInstalled($info)
1958                     || !in_array($info['info']->getState(), PEAR_Common::betterStates($stability['release'], true))
1959                 ) {
1960                     $err = PEAR::raiseError(
1961                         'Failed to download ' . $this->_registry->parsedPackageNameToString(
1962                             array('channel' => $pname['channel'], 'package' => $pname['package']),
1963                                 true)
1964                          . $vs .
1965                         ', latest release is version ' . $info['version'] .
1966                         ', stability "' . $info['info']->getState() . '", use "' .
1967                         $this->_registry->parsedPackageNameToString(
1968                             array('channel' => $pname['channel'], 'package' => $pname['package'],
1969                             'version' => $info['version'])) . '" to install');
1970                     return $err;
1971                 }
1972             }
1973         }
1974
1975         if (isset($info['deprecated']) && $info['deprecated']) {
1976             $this->_downloader->log(0,
1977                 'WARNING: "' .
1978                     $this->_registry->parsedPackageNameToString(
1979                             array('channel' => $info['info']->getChannel(),
1980                                   'package' => $info['info']->getPackage()), true) .
1981                 '" is deprecated in favor of "' .
1982                     $this->_registry->parsedPackageNameToString($info['deprecated'], true) .
1983                 '"');
1984         }
1985
1986         return $info;
1987     }
1988 }