apt-pkg/packagemanager.cc

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 // $Id: packagemanager.cc,v 1.30 2003/04/27 03:04:15 doogie Exp $
   4 /* ######################################################################
   5
   6    Package Manager - Abstacts the package manager
   7
   8    More work is needed in the area of transitioning provides, ie exim
   9    replacing smail. This can cause interesing side effects.
  10
  11    Other cases involving conflicts+replaces should be tested.
  12
  13    ##################################################################### */
  14                                                                         /*}}}*/
  15 // Include Files                                                        /*{{{*/
  16 #include <apt-pkg/packagemanager.h>
  17 #include <apt-pkg/orderlist.h>
  18 #include <apt-pkg/depcache.h>
  19 #include <apt-pkg/error.h>
  20 #include <apt-pkg/version.h>
  21 #include <apt-pkg/acquire-item.h>
  22 #include <apt-pkg/algorithms.h>
  23 #include <apt-pkg/configuration.h>
  24 #include <apt-pkg/sptr.h>
  25
  26 #include <apti18n.h>
  27 #include <iostream>
  28 #include <fcntl.h>
  29                                                                         /*}}}*/
  30 using namespace std;
  31
  32 // PM::PackageManager - Constructor                                     /*{{{*/
  33 // ---------------------------------------------------------------------
  34 /* */
  35 pkgPackageManager::pkgPackageManager(pkgDepCache *pCache) : Cache(*pCache)
  36 {
  37    FileNames = new string[Cache.Head().PackageCount];
  38    List = 0;
  39    Debug = _config->FindB("Debug::pkgPackageManager",false);
  40 }
  41                                                                         /*}}}*/
  42 // PM::PackageManager - Destructor                                      /*{{{*/
  43 // ---------------------------------------------------------------------
  44 /* */
  45 pkgPackageManager::~pkgPackageManager()
  46 {
  47    delete List;
  48    delete [] FileNames;
  49 }
  50                                                                         /*}}}*/
  51 // PM::GetArchives - Queue the archives for download                    /*{{{*/
  52 // ---------------------------------------------------------------------
  53 /* */
  54 bool pkgPackageManager::GetArchives(pkgAcquire *Owner,pkgSourceList *Sources,
  55                                     pkgRecords *Recs)
  56 {
  57    if (CreateOrderList() == false)
  58       return false;
  59
  60    bool const ordering =
  61         _config->FindB("PackageManager::UnpackAll",true) ?
  62                 List->OrderUnpack() : List->OrderCritical();
  63    if (ordering == false)
  64       return _error->Error("Internal ordering error");
  65
  66    for (pkgOrderList::iterator I = List->begin(); I != List->end(); I++)
  67    {
  68       PkgIterator Pkg(Cache,*I);
  69       FileNames[Pkg->ID] = string();
  70
  71       // Skip packages to erase
  72       if (Cache[Pkg].Delete() == true)
  73          continue;
  74
  75       // Skip Packages that need configure only.
  76       if (Pkg.State() == pkgCache::PkgIterator::NeedsConfigure &&
  77           Cache[Pkg].Keep() == true)
  78          continue;
  79
  80       // Skip already processed packages
  81       if (List->IsNow(Pkg) == false)
  82          continue;
  83
  84       new pkgAcqArchive(Owner,Sources,Recs,Cache[Pkg].InstVerIter(Cache),
  85                         FileNames[Pkg->ID]);
  86    }
  87
  88    return true;
  89 }
  90                                                                         /*}}}*/
  91 // PM::FixMissing - Keep all missing packages                           /*{{{*/
  92 // ---------------------------------------------------------------------
  93 /* This is called to correct the installation when packages could not
  94    be downloaded. */
  95 bool pkgPackageManager::FixMissing()
  96 {
  97    pkgDepCache::ActionGroup group(Cache);
  98    pkgProblemResolver Resolve(&Cache);
  99    List->SetFileList(FileNames);
 100
 101    bool Bad = false;
 102    for (PkgIterator I = Cache.PkgBegin(); I.end() == false; I++)
 103    {
 104       if (List->IsMissing(I) == false)
 105          continue;
 106
 107       // Okay, this file is missing and we need it. Mark it for keep
 108       Bad = true;
 109       Cache.MarkKeep(I, false, false);
 110    }
 111
 112    // We have to empty the list otherwise it will not have the new changes
 113    delete List;
 114    List = 0;
 115
 116    if (Bad == false)
 117       return true;
 118
 119    // Now downgrade everything that is broken
 120    return Resolve.ResolveByKeep() == true && Cache.BrokenCount() == 0;
 121 }
 122                                                                         /*}}}*/
 123 // PM::ImmediateAdd - Add the immediate flag recursivly                 /*{{{*/
 124 // ---------------------------------------------------------------------
 125 /* This adds the immediate flag to the pkg and recursively to the
 126    dependendies
 127  */
 128 void pkgPackageManager::ImmediateAdd(PkgIterator I, bool UseInstallVer, unsigned const int &Depth)
 129 {
 130    DepIterator D;
 131
 132    if(UseInstallVer)
 133    {
 134       if(Cache[I].InstallVer == 0)
 135          return;
 136       D = Cache[I].InstVerIter(Cache).DependsList();
 137    } else {
 138       if (I->CurrentVer == 0)
 139          return;
 140       D = I.CurrentVer().DependsList();
 141    }
 142
 143    for ( /* nothing */  ; D.end() == false; D++)
 144       if (D->Type == pkgCache::Dep::Depends || D->Type == pkgCache::Dep::PreDepends)
 145       {
 146          if(!List->IsFlag(D.TargetPkg(), pkgOrderList::Immediate))
 147          {
 148             if(Debug)
 149                clog << OutputInDepth(Depth) << "ImmediateAdd(): Adding Immediate flag to " << D.TargetPkg() << " cause of " << D.DepType() << " " << I.Name() << endl;
 150             List->Flag(D.TargetPkg(),pkgOrderList::Immediate);
 151             ImmediateAdd(D.TargetPkg(), UseInstallVer, Depth + 1);
 152          }
 153       }
 154    return;
 155 }
 156                                                                         /*}}}*/
 157 // PM::CreateOrderList - Create the ordering class                      /*{{{*/
 158 // ---------------------------------------------------------------------
 159 /* This populates the ordering list with all the packages that are
 160    going to change. */
 161 bool pkgPackageManager::CreateOrderList()
 162 {
 163    if (List != 0)
 164       return true;
 165
 166    delete List;
 167    List = new pkgOrderList(&Cache);
 168
 169    static bool const NoImmConfigure = !_config->FindB("APT::Immediate-Configure",true);
 170    ImmConfigureAll = _config->FindB("APT::Immediate-Configure-All",true);
 171
 172    if (Debug && ImmConfigureAll)
 173       clog << "CreateOrderList(): Adding Immediate flag for all packages because of APT::Immediate-Configure-All" << endl;
 174
 175    // Generate the list of affected packages and sort it
 176    for (PkgIterator I = Cache.PkgBegin(); I.end() == false; I++)
 177    {
 178       // Ignore no-version packages
 179       if (I->VersionList == 0)
 180          continue;
 181
 182       // Mark the package and its dependends for immediate configuration
 183       if ((((I->Flags & pkgCache::Flag::Essential) == pkgCache::Flag::Essential ||
 184            (I->Flags & pkgCache::Flag::Important) == pkgCache::Flag::Important) &&
 185           NoImmConfigure == false) || ImmConfigureAll)
 186       {
 187          if(Debug && !ImmConfigureAll)
 188             clog << "CreateOrderList(): Adding Immediate flag for " << I.Name() << endl;
 189          List->Flag(I,pkgOrderList::Immediate);
 190
 191          if (!ImmConfigureAll) {
 192             continue;
 193
 194             // Look for other install packages to make immediate configurea
 195             ImmediateAdd(I, true);
 196
 197             // And again with the current version.
 198             ImmediateAdd(I, false);
 199          }
 200       }
 201
 202       // Not interesting
 203       if ((Cache[I].Keep() == true ||
 204           Cache[I].InstVerIter(Cache) == I.CurrentVer()) &&
 205           I.State() == pkgCache::PkgIterator::NeedsNothing &&
 206           (Cache[I].iFlags & pkgDepCache::ReInstall) != pkgDepCache::ReInstall &&
 207           (I.Purge() != false || Cache[I].Mode != pkgDepCache::ModeDelete ||
 208            (Cache[I].iFlags & pkgDepCache::Purge) != pkgDepCache::Purge))
 209          continue;
 210
 211       // Append it to the list
 212       List->push_back(I);
 213    }
 214
 215    return true;
 216 }
 217                                                                         /*}}}*/
 218 // PM::DepAlwaysTrue - Returns true if this dep is irrelevent           /*{{{*/
 219 // ---------------------------------------------------------------------
 220 /* The restriction on provides is to eliminate the case when provides
 221    are transitioning between valid states [ie exim to smail] */
 222 bool pkgPackageManager::DepAlwaysTrue(DepIterator D)
 223 {
 224    if (D.TargetPkg()->ProvidesList != 0)
 225       return false;
 226
 227    if ((Cache[D] & pkgDepCache::DepInstall) != 0 &&
 228        (Cache[D] & pkgDepCache::DepNow) != 0)
 229       return true;
 230    return false;
 231 }
 232                                                                         /*}}}*/
 233 // PM::CheckRConflicts - Look for reverse conflicts                     /*{{{*/
 234 // ---------------------------------------------------------------------
 235 /* This looks over the reverses for a conflicts line that needs early
 236    removal. */
 237 bool pkgPackageManager::CheckRConflicts(PkgIterator Pkg,DepIterator D,
 238                                         const char *Ver)
 239 {
 240    for (;D.end() == false; D++)
 241    {
 242       if (D->Type != pkgCache::Dep::Conflicts &&
 243           D->Type != pkgCache::Dep::Obsoletes)
 244          continue;
 245
 246       // The package hasnt been changed
 247       if (List->IsNow(Pkg) == false)
 248          continue;
 249
 250       // Ignore self conflicts, ignore conflicts from irrelevent versions
 251       if (D.ParentPkg() == Pkg || D.ParentVer() != D.ParentPkg().CurrentVer())
 252          continue;
 253
 254       if (Cache.VS().CheckDep(Ver,D->CompareOp,D.TargetVer()) == false)
 255          continue;
 256
 257       if (EarlyRemove(D.ParentPkg()) == false)
 258          return _error->Error("Reverse conflicts early remove for package '%s' failed",
 259                               Pkg.Name());
 260    }
 261    return true;
 262 }
 263                                                                         /*}}}*/
 264 // PM::ConfigureAll - Run the all out configuration                     /*{{{*/
 265 // ---------------------------------------------------------------------
 266 /* This configures every package. It is assumed they are all unpacked and
 267    that the final configuration is valid. */
 268 bool pkgPackageManager::ConfigureAll()
 269 {
 270    pkgOrderList OList(&Cache);
 271
 272    // Populate the order list
 273    for (pkgOrderList::iterator I = List->begin(); I != List->end(); I++)
 274       if (List->IsFlag(pkgCache::PkgIterator(Cache,*I),
 275                        pkgOrderList::UnPacked) == true)
 276          OList.push_back(*I);
 277
 278    if (OList.OrderConfigure() == false)
 279       return false;
 280
 281    std::string const conf = _config->Find("PackageManager::Configure","all");
 282    bool const ConfigurePkgs = (conf == "all");
 283
 284    // Perform the configuring
 285    for (pkgOrderList::iterator I = OList.begin(); I != OList.end(); I++)
 286    {
 287       PkgIterator Pkg(Cache,*I);
 288
 289       if (ConfigurePkgs == true && VerifyAndConfigure(Pkg,OList) == false)
 290          return false;
 291
 292       List->Flag(Pkg,pkgOrderList::Configured,pkgOrderList::States);
 293    }
 294
 295    return true;
 296 }
 297                                                                         /*}}}*/
 298 // PM::SmartConfigure - Perform immediate configuration of the pkg      /*{{{*/
 299 // ---------------------------------------------------------------------
 300 /* This routine scheduals the configuration of the given package and all
 301    of it's dependents. */
 302 bool pkgPackageManager::SmartConfigure(PkgIterator Pkg)
 303 {
 304    if (Debug == true)
 305       clog << "SmartConfigure " << Pkg.Name() << endl;
 306
 307    pkgOrderList OList(&Cache);
 308
 309    if (DepAdd(OList,Pkg) == false)
 310       return false;
 311
 312    static std::string const conf = _config->Find("PackageManager::Configure","all");
 313    static bool const ConfigurePkgs = (conf == "all" || conf == "smart");
 314
 315    if (ConfigurePkgs == true)
 316       if (OList.OrderConfigure() == false)
 317          return false;
 318
 319    // Perform the configuring
 320    for (pkgOrderList::iterator I = OList.begin(); I != OList.end(); I++)
 321    {
 322       PkgIterator Pkg(Cache,*I);
 323
 324       if (ConfigurePkgs == true && VerifyAndConfigure(Pkg,OList) == false)
 325          return false;
 326
 327       List->Flag(Pkg,pkgOrderList::Configured,pkgOrderList::States);
 328    }
 329
 330    if (Cache[Pkg].InstVerIter(Cache)->MultiArch == pkgCache::Version::Same)
 331       for (PkgIterator P = Pkg.Group().PackageList();
 332            P.end() == false; P = Pkg.Group().NextPkg(P))
 333       {
 334          if (Pkg == P || List->IsFlag(P,pkgOrderList::Configured) == true ||
 335              Cache[P].InstallVer == 0 || (P.CurrentVer() == Cache[P].InstallVer &&
 336               (Cache[Pkg].iFlags & pkgDepCache::ReInstall) != pkgDepCache::ReInstall))
 337             continue;
 338          SmartConfigure(P);
 339       }
 340
 341    // Sanity Check
 342    if (List->IsFlag(Pkg,pkgOrderList::Configured) == false)
 343       return _error->Error(_("Could not perform immediate configuration on '%s'. "
 344                         "Please see man 5 apt.conf under APT::Immediate-Configure for details. (%d)"),Pkg.Name(),1);
 345
 346    return true;
 347 }
 348
 349 // PM::VerifyConfigure - Check configuration of dependancies     /*{{{*/
 350 // ---------------------------------------------------------------------
 351 /* This routine checks that all a packages dependancies have been
 352    configured, before it is going to be configured. If this gives a warning
 353    on a virtual package, it means that the package thats providing it is not
 354    configured*/
 355 bool pkgPackageManager::VerifyConfigure(PkgIterator Pkg, pkgOrderList &OList)
 356 {
 357    // If this is true at the end, then the package should not be configured
 358    bool error=true;
 359    // This holds the the OR status of the previous dependancy
 360    bool previousOr=false;
 361
 362    // First iterate through the dependancies of Pkg
 363    for (DepIterator D = Cache[Pkg].InstVerIter(Cache).DependsList(); D.end() == false; D++)
 364    {
 365
 366       /* If the dependancy is of type Depends or PreDepends, we need to check it, but only if it is going to be
 367          configured at some point */
 368       if (D->Type == pkgCache::Dep::Depends || D->Type == pkgCache::Dep::PreDepends) {
 369
 370          /* If the previous package and this package are OR dependancies, and the previous package satisfied the dependancy
 371             then skip this dependancy as it is not relevent, this will repeat for the next package if the situation is the
 372             same */
 373          if (previousOr && !error) { // As error has not been reset, this refers to the previous dependancy
 374             previousOr = (D->CompareOp & pkgCache::Dep::Or) == pkgCache::Dep::Or;
 375             continue;
 376          }
 377
 378          // Reset error
 379          error = true;
 380
 381          // Check thorugh all possible versions of this dependancy (D)
 382          SPtrArray<Version *> VList = D.AllTargets();
 383          for (Version **I = VList; *I != 0; I++)
 384          {
 385             VerIterator DepVer(Cache,*I);
 386             PkgIterator DepPkg = DepVer.ParentPkg();
 387             VerIterator DepInstallVer(Cache,Cache[DepPkg].InstallVer);
 388
 389             if (DepPkg.CurrentVer() == DepVer && !List->IsFlag(DepPkg,pkgOrderList::UnPacked)) {
 390                error=false;
 391                break;
 392             }
 393
 394             if (Cache[DepPkg].InstallVer == DepVer &&
 395                (List->IsFlag(DepPkg,pkgOrderList::Configured) || OList.IsFlag(DepPkg,pkgOrderList::InList))) {
 396                error=false;
 397                break;
 398             }
 399          }
 400
 401          /* Only worry here if this package is a OR with the next, as even though this package does not satisfy the OR
 402             the next one might */
 403          if (error && !((D->CompareOp & pkgCache::Dep::Or) == pkgCache::Dep::Or)) {
 404              _error->Error("Package %s should not be configured because package %s is not configured",Pkg.Name(),D.TargetPkg().Name());
 405              return false;
 406          /* If the previous package is a OR but not this package, but there is still an error then fail as it will not
 407             be satisfied */
 408          } else if (error && previousOr && !((D->CompareOp & pkgCache::Dep::Or) == pkgCache::Dep::Or)) {
 409              _error->Error("Package %s should not be configured because package %s (or any alternatives) are not configured",Pkg.Name(),D.TargetPkg().Name());
 410              return false;
 411          }
 412
 413          previousOr = (D->CompareOp & pkgCache::Dep::Or) == pkgCache::Dep::Or;
 414       } else {
 415          previousOr=false;
 416       }
 417    }
 418    return true;
 419 }
 420
 421 // PM::VerifyAndConfigure - Check configuration of dependancies     /*{{{*/
 422 // ---------------------------------------------------------------------
 423 /* This routine verifies if a package can be configured and if so
 424    configures it  */
 425 bool pkgPackageManager::VerifyAndConfigure(PkgIterator Pkg, pkgOrderList &OList)
 426 {
 427    if (VerifyConfigure(Pkg, OList))
 428       return Configure(Pkg);
 429    else
 430       return false;
 431
 432 }
 433                                                                         /*}}}*/
 434 // PM::DepAdd - Add all dependents to the oder list                     /*{{{*/
 435 // ---------------------------------------------------------------------
 436 /* This recursively adds all dependents to the order list */
 437 bool pkgPackageManager::DepAdd(pkgOrderList &OList,PkgIterator Pkg,int Depth)
 438 {
 439    if (OList.IsFlag(Pkg,pkgOrderList::Added) == true)
 440       return true;
 441    if (List->IsFlag(Pkg,pkgOrderList::Configured) == true)
 442       return true;
 443    if (List->IsFlag(Pkg,pkgOrderList::UnPacked) == false)
 444       return false;
 445
 446    if (Debug)
 447       std::clog << OutputInDepth(Depth) << "DepAdd: " << Pkg.Name() << std::endl;
 448
 449    // Put the package on the list
 450    OList.push_back(Pkg);
 451    OList.Flag(Pkg,pkgOrderList::Added);
 452    Depth++;
 453
 454    // Check the dependencies to see if they are all satisfied.
 455    bool Bad = false;
 456    for (DepIterator D = Cache[Pkg].InstVerIter(Cache).DependsList(); D.end() == false;)
 457    {
 458       if (D->Type != pkgCache::Dep::Depends && D->Type != pkgCache::Dep::PreDepends)
 459       {
 460          D++;
 461          continue;
 462       }
 463
 464       // Grok or groups
 465       Bad = true;
 466       for (bool LastOR = true; D.end() == false && LastOR == true; D++)
 467       {
 468          LastOR = (D->CompareOp & pkgCache::Dep::Or) == pkgCache::Dep::Or;
 469
 470          if (Bad == false)
 471             continue;
 472
 473          SPtrArray<Version *> VList = D.AllTargets();
 474          for (Version **I = VList; *I != 0 && Bad == true; I++)
 475          {
 476             VerIterator Ver(Cache,*I);
 477             PkgIterator Pkg = Ver.ParentPkg();
 478             VerIterator InstallVer(Cache,Cache[Pkg].InstallVer);
 479             VerIterator CandVer(Cache,Cache[Pkg].CandidateVer);
 480
 481             if (Debug && false) {
 482                if (Ver==0) {
 483                   cout << OutputInDepth(Depth) << "Checking if " << Ver << " of " << Pkg.Name() << " satisfies this dependancy" << endl;
 484                } else {
 485                   cout << OutputInDepth(Depth) << "Checking if " << Ver.VerStr() << " of " << Pkg.Name() << " satisfies this dependancy" << endl;
 486                }
 487
 488                if (Pkg.CurrentVer()==0) {
 489                   cout << OutputInDepth(Depth) << "  CurrentVer " << Pkg.CurrentVer() << " IsNow " << List->IsNow(Pkg) << " NeedsNothing " << (Pkg.State() == PkgIterator::NeedsNothing) << endl;
 490                } else {
 491                   cout << OutputInDepth(Depth) << "  CurrentVer " << Pkg.CurrentVer().VerStr() << " IsNow " << List->IsNow(Pkg) << " NeedsNothing " << (Pkg.State() == PkgIterator::NeedsNothing) << endl;
 492                }
 493
 494                if (InstallVer==0) {
 495                   cout << OutputInDepth(Depth )<< "  InstallVer " << InstallVer << endl;
 496                } else {
 497                   cout << OutputInDepth(Depth )<< "  InstallVer " << InstallVer.VerStr() << endl;
 498                }
 499                               if (CandVer != 0)
 500                   cout << "    CandVer " << CandVer.VerStr() << endl;
 501
 502                cout << OutputInDepth(Depth) << "  Keep " << Cache[Pkg].Keep() << " Unpacked " << List->IsFlag(Pkg,pkgOrderList::UnPacked) << " Configured " << List->IsFlag(Pkg,pkgOrderList::Configured) << endl;
 503
 504             }
 505             // See if the current version is ok
 506             if (Pkg.CurrentVer() == Ver && List->IsNow(Pkg) == true &&
 507                 Pkg.State() == PkgIterator::NeedsNothing)
 508             {
 509                Bad = false;
 510                continue;
 511             }
 512
 513             // Not the install version
 514             if ((Cache[Pkg].InstallVer != *I && Cache[Pkg].CandidateVer != *I) ||
 515                 (Cache[Pkg].Keep() == true && Pkg.State() == PkgIterator::NeedsNothing &&
 516                 (Cache[Pkg].iFlags & pkgDepCache::ReInstall) != pkgDepCache::ReInstall))
 517                continue;
 518
 519             if (List->IsFlag(Pkg,pkgOrderList::UnPacked) == true)
 520                Bad = !DepAdd(OList,Pkg,Depth);
 521             if (List->IsFlag(Pkg,pkgOrderList::Configured) == true)
 522                Bad = false;
 523          }
 524       }
 525
 526       if (Bad == true)
 527       {
 528          if (Debug)
 529             std::clog << OutputInDepth(Depth) << "DepAdd FAILS on: " << Pkg.Name() << std::endl;
 530          OList.Flag(Pkg,0,pkgOrderList::Added);
 531          OList.pop_back();
 532          Depth--;
 533          return false;
 534       }
 535    }
 536
 537    Depth--;
 538    return true;
 539 }
 540                                                                         /*}}}*/
 541 // PM::EarlyRemove - Perform removal of packages before their time      /*{{{*/
 542 // ---------------------------------------------------------------------
 543 /* This is called to deal with conflicts arising from unpacking */
 544 bool pkgPackageManager::EarlyRemove(PkgIterator Pkg)
 545 {
 546    if (List->IsNow(Pkg) == false)
 547       return true;
 548
 549    // Already removed it
 550    if (List->IsFlag(Pkg,pkgOrderList::Removed) == true)
 551       return true;
 552
 553    // Woops, it will not be re-installed!
 554    if (List->IsFlag(Pkg,pkgOrderList::InList) == false)
 555       return false;
 556
 557    // Essential packages get special treatment
 558    bool IsEssential = false;
 559    if ((Pkg->Flags & pkgCache::Flag::Essential) != 0)
 560       IsEssential = true;
 561
 562    /* Check for packages that are the dependents of essential packages and
 563       promote them too */
 564    if (Pkg->CurrentVer != 0)
 565    {
 566       for (DepIterator D = Pkg.RevDependsList(); D.end() == false &&
 567            IsEssential == false; D++)
 568          if (D->Type == pkgCache::Dep::Depends || D->Type == pkgCache::Dep::PreDepends)
 569             if ((D.ParentPkg()->Flags & pkgCache::Flag::Essential) != 0)
 570                IsEssential = true;
 571    }
 572
 573    if (IsEssential == true)
 574    {
 575       if (_config->FindB("APT::Force-LoopBreak",false) == false)
 576          return _error->Error(_("This installation run will require temporarily "
 577                                 "removing the essential package %s due to a "
 578                                 "Conflicts/Pre-Depends loop. This is often bad, "
 579                                 "but if you really want to do it, activate the "
 580                                 "APT::Force-LoopBreak option."),Pkg.Name());
 581    }
 582
 583    bool Res = SmartRemove(Pkg);
 584    if (Cache[Pkg].Delete() == false)
 585       List->Flag(Pkg,pkgOrderList::Removed,pkgOrderList::States);
 586
 587    return Res;
 588 }
 589                                                                         /*}}}*/
 590 // PM::SmartRemove - Removal Helper                                     /*{{{*/
 591 // ---------------------------------------------------------------------
 592 /* */
 593 bool pkgPackageManager::SmartRemove(PkgIterator Pkg)
 594 {
 595    if (List->IsNow(Pkg) == false)
 596       return true;
 597
 598    List->Flag(Pkg,pkgOrderList::Configured,pkgOrderList::States);
 599
 600    return Remove(Pkg,(Cache[Pkg].iFlags & pkgDepCache::Purge) == pkgDepCache::Purge);
 601    return true;
 602 }
 603                                                                         /*}}}*/
 604 // PM::SmartUnPack - Install helper                                     /*{{{*/
 605 // ---------------------------------------------------------------------
 606 /* This performs the task of handling pre-depends. */
 607 bool pkgPackageManager::SmartUnPack(PkgIterator Pkg)
 608 {
 609    return SmartUnPack(Pkg, true);
 610 }
 611 bool pkgPackageManager::SmartUnPack(PkgIterator Pkg, bool const Immediate)
 612 {
 613    if (Debug == true)
 614       clog << "SmartUnPack " << Pkg.Name() << endl;
 615
 616    // Check if it is already unpacked
 617    if (Pkg.State() == pkgCache::PkgIterator::NeedsConfigure &&
 618        Cache[Pkg].Keep() == true)
 619    {
 620       List->Flag(Pkg,pkgOrderList::UnPacked,pkgOrderList::States);
 621       if (Immediate == true &&
 622           List->IsFlag(Pkg,pkgOrderList::Immediate) == true)
 623          if (SmartConfigure(Pkg) == false)
 624             return _error->Error(_("Could not perform immediate configuration on already unpacked '%s'. "
 625                         "Please see man 5 apt.conf under APT::Immediate-Configure for details."),Pkg.Name());
 626       return true;
 627    }
 628
 629    VerIterator const instVer = Cache[Pkg].InstVerIter(Cache);
 630
 631    /* See if this packages install version has any predependencies
 632       that are not met by 'now' packages. */
 633    for (DepIterator D = instVer.DependsList();
 634         D.end() == false; )
 635    {
 636       // Compute a single dependency element (glob or)
 637       pkgCache::DepIterator Start;
 638       pkgCache::DepIterator End;
 639       D.GlobOr(Start,End);
 640
 641       while (End->Type == pkgCache::Dep::PreDepends)
 642       {
 643          if (Debug)
 644             clog << "PreDepends order for " << Pkg.Name() << std::endl;
 645
 646          // Look for possible ok targets.
 647          SPtrArray<Version *> VList = Start.AllTargets();
 648          bool Bad = true;
 649          for (Version **I = VList; *I != 0 && Bad == true; I++)
 650          {
 651             VerIterator Ver(Cache,*I);
 652             PkgIterator Pkg = Ver.ParentPkg();
 653
 654             // See if the current version is ok
 655             if (Pkg.CurrentVer() == Ver && List->IsNow(Pkg) == true &&
 656                 Pkg.State() == PkgIterator::NeedsNothing)
 657             {
 658                Bad = false;
 659                if (Debug)
 660                   clog << "Found ok package " << Pkg.Name() << endl;
 661                continue;
 662             }
 663          }
 664
 665          // Look for something that could be configured.
 666          for (Version **I = VList; *I != 0 && Bad == true; I++)
 667          {
 668             VerIterator Ver(Cache,*I);
 669             PkgIterator Pkg = Ver.ParentPkg();
 670
 671             // Not the install version
 672             if (Cache[Pkg].InstallVer != *I ||
 673                 (Cache[Pkg].Keep() == true && Pkg.State() == PkgIterator::NeedsNothing))
 674                continue;
 675
 676             if (Debug)
 677                clog << "Trying to SmartConfigure " << Pkg.Name() << endl;
 678             Bad = !SmartConfigure(Pkg);
 679          }
 680
 681          /* If this or element did not match then continue on to the
 682             next or element until a matching element is found */
 683          if (Bad == true)
 684          {
 685             // This triggers if someone make a pre-depends/depend loop.
 686             if (Start == End)
 687                return _error->Error("Couldn't configure pre-depend %s for %s, "
 688                                     "probably a dependency cycle.",
 689                                     End.TargetPkg().Name(),Pkg.Name());
 690             Start++;
 691          }
 692          else
 693             break;
 694       }
 695
 696       if (End->Type == pkgCache::Dep::Conflicts ||
 697           End->Type == pkgCache::Dep::Obsoletes)
 698       {
 699          /* Look for conflicts. Two packages that are both in the install
 700             state cannot conflict so we don't check.. */
 701          SPtrArray<Version *> VList = End.AllTargets();
 702          for (Version **I = VList; *I != 0; I++)
 703          {
 704             VerIterator Ver(Cache,*I);
 705             PkgIterator ConflictPkg = Ver.ParentPkg();
 706             VerIterator InstallVer(Cache,Cache[ConflictPkg].InstallVer);
 707
 708            if (Debug)
 709                  cout << Pkg.Name() << " conflicts with " << ConflictPkg.Name() << endl;
 710
 711            if (Debug && false) {
 712                if (Ver==0) {
 713                   cout << "  Checking if " << Ver << " of " << ConflictPkg.Name() << " satisfies this dependancy" << endl;
 714                } else {
 715                   cout << "  Checking if " << Ver.VerStr() << " of " << ConflictPkg.Name() << " satisfies this dependancy" << endl;
 716                }
 717
 718                if (ConflictPkg.CurrentVer()==0) {
 719                   cout << "    CurrentVer " << ConflictPkg.CurrentVer() << " IsNow " << List->IsNow(ConflictPkg) << " NeedsNothing " << (ConflictPkg.State() == PkgIterator::NeedsNothing) << endl;
 720                } else {
 721                   cout << "    CurrentVer " << ConflictPkg.CurrentVer().VerStr() << " IsNow " << List->IsNow(ConflictPkg) << " NeedsNothing " << (ConflictPkg.State() == PkgIterator::NeedsNothing) << endl;
 722                }
 723
 724                if (InstallVer==0) {
 725                   cout << "    InstallVer " << InstallVer << endl;
 726                } else {
 727                   cout << "    InstallVer " << InstallVer.VerStr() << endl;
 728                }
 729
 730                cout << "    Keep " << Cache[ConflictPkg].Keep() << " Unpacked " << List->IsFlag(ConflictPkg,pkgOrderList::UnPacked) << " Configured " << List->IsFlag(ConflictPkg,pkgOrderList::Configured) << endl;
 731                cout << "    Delete " << Cache[ConflictPkg].Delete() << endl;
 732             }
 733
 734             // See if the current version is conflicting
 735             if (ConflictPkg.CurrentVer() == Ver && List->IsNow(ConflictPkg))
 736             {
 737                if (Cache[ConflictPkg].Keep() == 0 && Cache[ConflictPkg].InstallVer != 0) {
 738                    cout << "Unpacking " << ConflictPkg.Name() << " to prevent conflict" << endl;
 739                   /* FIXME Setting the flag here prevents breakage loops, that can occur if BrokenPkg (or one of the
 740                  packages it breaks) breaks Pkg */
 741                   List->Flag(Pkg,pkgOrderList::UnPacked,pkgOrderList::States);
 742                   SmartUnPack(ConflictPkg,false);
 743                } else {
 744                    if (EarlyRemove(ConflictPkg) == false)
 745                       return _error->Error("Internal Error, Could not early remove %s",ConflictPkg.Name());
 746                }
 747             }
 748          }
 749       }
 750
 751       // Check for breaks
 752       if (End->Type == pkgCache::Dep::DpkgBreaks) {
 753          SPtrArray<Version *> VList = End.AllTargets();
 754          for (Version **I = VList; *I != 0; I++)
 755          {
 756             VerIterator Ver(Cache,*I);
 757             PkgIterator BrokenPkg = Ver.ParentPkg();
 758             // Check if it needs to be unpacked
 759             if (List->IsFlag(BrokenPkg,pkgOrderList::InList) && Cache[BrokenPkg].Delete() == false &&
 760                 !List->IsFlag(BrokenPkg,pkgOrderList::UnPacked)) {
 761               /* FIXME Setting the flag here prevents breakage loops, that can occur if BrokenPkg (or one of the
 762                  packages it breaks) breaks Pkg */
 763               List->Flag(Pkg,pkgOrderList::UnPacked,pkgOrderList::States);
 764               // Found a break, so unpack the package
 765               if (Debug)
 766                  cout << "  Unpacking " << BrokenPkg.Name() << " to avoid break" << endl;
 767               SmartUnPack(BrokenPkg, false);
 768             }
 769             // Check if a package needs to be removed
 770             if (Cache[BrokenPkg].Delete() == true) {
 771               if (Debug)
 772                  cout << "  Removing " << BrokenPkg.Name() << " to avoid break" << endl;
 773               SmartRemove(BrokenPkg);
 774             }
 775          }
 776       }
 777    }
 778
 779    // FIXME: Crude but effective fix, allows the SmartUnPack method to be used for packages that new to the system
 780    if (instVer != 0) {
 781      //cout << "Check for reverse conflicts on " << Pkg.Name() << " " << instVer.VerStr() << endl;
 782
 783      // Check for reverse conflicts.
 784      if (CheckRConflicts(Pkg,Pkg.RevDependsList(),
 785                    instVer.VerStr()) == false)
 786         return false;
 787
 788      for (PrvIterator P = instVer.ProvidesList();
 789           P.end() == false; P++)
 790         CheckRConflicts(Pkg,P.ParentPkg().RevDependsList(),P.ProvideVersion());
 791
 792      List->Flag(Pkg,pkgOrderList::UnPacked,pkgOrderList::States);
 793
 794      if (instVer->MultiArch == pkgCache::Version::Same)
 795         for (PkgIterator P = Pkg.Group().PackageList();
 796              P.end() == false; P = Pkg.Group().NextPkg(P))
 797         {
 798            if (Pkg == P || List->IsFlag(P,pkgOrderList::UnPacked) == true ||
 799                Cache[P].InstallVer == 0 || (P.CurrentVer() == Cache[P].InstallVer &&
 800                 (Cache[Pkg].iFlags & pkgDepCache::ReInstall) != pkgDepCache::ReInstall))
 801               continue;
 802            SmartUnPack(P, false);
 803         }
 804
 805    } else {
 806        VerIterator InstallVer(Cache,Cache[Pkg].InstallVer);
 807        //cout << "Check for reverse conflicts on " << Pkg.Name() << " " << InstallVer.VerStr() << endl;
 808
 809        // Check for reverse conflicts.
 810        if (CheckRConflicts(Pkg,Pkg.RevDependsList(),
 811                    InstallVer.VerStr()) == false)
 812         return false;
 813
 814       List->Flag(Pkg,pkgOrderList::UnPacked,pkgOrderList::States);
 815    }
 816
 817    if(Install(Pkg,FileNames[Pkg->ID]) == false)
 818       return false;
 819
 820    /* Because of the ordered list, most dependancies should be unpacked,
 821       however if there is a loop this is not the case, so check for dependancies before configuring.
 822       This is done after the package installation as it makes it easier to deal with conflicts problems */
 823    for (DepIterator D = instVer.DependsList();
 824         D.end() == false; )
 825    {
 826       // Compute a single dependency element (glob or)
 827       pkgCache::DepIterator Start;
 828       pkgCache::DepIterator End;
 829       D.GlobOr(Start,End);
 830
 831       // Check for dependanices that have not been unpacked, probably due to loops.
 832       bool Bad = true;
 833       while (End->Type == pkgCache::Dep::Depends) {
 834          PkgIterator DepPkg;
 835          VerIterator InstallVer;
 836          SPtrArray<Version *> VList = Start.AllTargets();
 837
 838          for (Version **I = VList; *I != 0; I++) {
 839             VerIterator Ver(Cache,*I);
 840             DepPkg = Ver.ParentPkg();
 841
 842             if (!Bad) continue;
 843
 844             InstallVer = VerIterator(Cache,Cache[DepPkg].InstallVer);
 845             VerIterator CandVer(Cache,Cache[DepPkg].CandidateVer);
 846
 847             if (Debug && false) {
 848                if (Ver==0) {
 849                   cout << "  Checking if " << Ver << " of " << DepPkg.Name() << " satisfies this dependancy" << endl;
 850                } else {
 851                   cout << "  Checking if " << Ver.VerStr() << " of " << DepPkg.Name() << " satisfies this dependancy" << endl;
 852                }
 853
 854                if (DepPkg.CurrentVer()==0) {
 855                   cout << "    CurrentVer " << DepPkg.CurrentVer() << " IsNow " << List->IsNow(DepPkg) << " NeedsNothing " << (DepPkg.State() == PkgIterator::NeedsNothing) << endl;
 856                } else {
 857                   cout << "    CurrentVer " << DepPkg.CurrentVer().VerStr() << " IsNow " << List->IsNow(DepPkg) << " NeedsNothing " << (DepPkg.State() == PkgIterator::NeedsNothing) << endl;
 858                }
 859
 860                if (InstallVer==0) {
 861                   cout << "    InstallVer " << InstallVer << endl;
 862                } else {
 863                   cout << "    InstallVer " << InstallVer.VerStr() << endl;
 864                }
 865                if (CandVer != 0)
 866                   cout << "    CandVer " << CandVer.VerStr() << endl;
 867
 868                cout << "    Keep " << Cache[DepPkg].Keep() << " Unpacked " << List->IsFlag(DepPkg,pkgOrderList::UnPacked) << " Configured " << List->IsFlag(DepPkg,pkgOrderList::Configured) << endl;
 869
 870             }
 871
 872             // Check if it satisfies this dependancy
 873             if (DepPkg.CurrentVer() == Ver && List->IsNow(DepPkg) == true &&
 874                 DepPkg.State() == PkgIterator::NeedsNothing)
 875             {
 876                Bad = false;
 877                continue;
 878             }
 879
 880             if (Cache[DepPkg].InstallVer == *I && !List->IsNow(DepPkg)) {
 881                Bad = false;
 882                continue;
 883             }
 884
 885          }
 886
 887          if (InstallVer != 0 && Bad) {
 888             Bad = false;
 889             // FIXME Setting the flag here prevents a loop forming
 890             List->Flag(Pkg,pkgOrderList::UnPacked,pkgOrderList::States);
 891             // Found a break, so unpack the package
 892             if (Debug)
 893                cout << "  Unpacking " << DepPkg.Name() << " to avoid loop" << endl;
 894             SmartUnPack(DepPkg, false);
 895          }
 896
 897          if (Start==End) {
 898             if (Bad) {
 899                //return
 900                _error->Error("Could not satisfy dependancies for %s",Pkg.Name());
 901             }
 902             break;
 903
 904          } else {
 905             Start++;
 906          }
 907       }
 908    }
 909
 910    // Perform immedate configuration of the package.
 911    if (Immediate == true &&
 912        List->IsFlag(Pkg,pkgOrderList::Immediate) == true)
 913       if (SmartConfigure(Pkg) == false)
 914          //return
 915          _error->Error(_("Could not perform immediate configuration on '%s'. "
 916                         "Please see man 5 apt.conf under APT::Immediate-Configure for details. (%d)"),Pkg.Name(),2);
 917
 918    return true;
 919 }
 920                                                                         /*}}}*/
 921 // PM::OrderInstall - Installation ordering routine                     /*{{{*/
 922 // ---------------------------------------------------------------------
 923 /* */
 924 pkgPackageManager::OrderResult pkgPackageManager::OrderInstall()
 925 {
 926    if (CreateOrderList() == false)
 927       return Failed;
 928
 929    Reset();
 930
 931    if (Debug == true)
 932       clog << "Beginning to order" << endl;
 933
 934    bool const ordering =
 935         _config->FindB("PackageManager::UnpackAll",true) ?
 936                 List->OrderUnpack(FileNames) : List->OrderCritical();
 937    if (ordering == false)
 938    {
 939       _error->Error("Internal ordering error");
 940       return Failed;
 941    }
 942
 943    if (Debug == true)
 944       clog << "Done ordering" << endl;
 945
 946    bool DoneSomething = false;
 947    for (pkgOrderList::iterator I = List->begin(); I != List->end(); I++)
 948    {
 949       PkgIterator Pkg(Cache,*I);
 950
 951       if (List->IsNow(Pkg) == false)
 952       {
 953          if (Debug == true)
 954             clog << "Skipping already done " << Pkg.Name() << endl;
 955          continue;
 956       }
 957
 958       if (List->IsMissing(Pkg) == true)
 959       {
 960          if (Debug == true)
 961             clog << "Sequence completed at " << Pkg.Name() << endl;
 962          if (DoneSomething == false)
 963          {
 964             _error->Error("Internal Error, ordering was unable to handle the media swap");
 965             return Failed;
 966          }
 967          return Incomplete;
 968       }
 969
 970       // Sanity check
 971       if (Cache[Pkg].Keep() == true &&
 972           Pkg.State() == pkgCache::PkgIterator::NeedsNothing &&
 973           (Cache[Pkg].iFlags & pkgDepCache::ReInstall) != pkgDepCache::ReInstall)
 974       {
 975          _error->Error("Internal Error, trying to manipulate a kept package (%s)",Pkg.Name());
 976          return Failed;
 977       }
 978
 979       // Perform a delete or an install
 980       if (Cache[Pkg].Delete() == true)
 981       {
 982          if (SmartRemove(Pkg) == false)
 983             return Failed;
 984       }
 985       else
 986          if (SmartUnPack(Pkg) == false)
 987             return Failed;
 988       DoneSomething = true;
 989    }
 990
 991    // Final run through the configure phase
 992    if (ConfigureAll() == false)
 993       return Failed;
 994
 995    // Sanity check
 996    for (pkgOrderList::iterator I = List->begin(); I != List->end(); I++)
 997    {
 998       if (List->IsFlag(*I,pkgOrderList::Configured) == false)
 999       {
1000          _error->Error("Internal error, packages left unconfigured. %s",
1001                        PkgIterator(Cache,*I).Name());
1002          return Failed;
1003       }
1004    }
1005
1006    return Completed;
1007 }
1008                                                                         /*}}}*/
1009 // PM::DoInstallPostFork - Does install part that happens after the fork /*{{{*/
1010 // ---------------------------------------------------------------------
1011 pkgPackageManager::OrderResult
1012 pkgPackageManager::DoInstallPostFork(int statusFd)
1013 {
1014       if(statusFd > 0)
1015          // FIXME: use SetCloseExec here once it taught about throwing
1016          //        exceptions instead of doing _exit(100) on failure
1017          fcntl(statusFd,F_SETFD,FD_CLOEXEC);
1018       bool goResult = Go(statusFd);
1019       if(goResult == false)
1020          return Failed;
1021
1022       return Res;
1023 };
1024
1025 // PM::DoInstall - Does the installation                                /*{{{*/
1026 // ---------------------------------------------------------------------
1027 /* This uses the filenames in FileNames and the information in the
1028    DepCache to perform the installation of packages.*/
1029 pkgPackageManager::OrderResult pkgPackageManager::DoInstall(int statusFd)
1030 {
1031    if(DoInstallPreFork() == Failed)
1032       return Failed;
1033
1034    return DoInstallPostFork(statusFd);
1035 }
1036                                                                         /*}}}*/