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