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