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                      cout << 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         cout << " (install version " << InstallVer.VerStr() << ")";
 583       else
 584         cout << " (replace version " << Pkg.CurrentVer().VerStr() << " with " << InstallVer.VerStr() << ")";
 585       if (PkgLoop)
 586         cout << " (Only Perform PreUnpack Checks)";
 587       cout << 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    for (DepIterator D = instVer.DependsList();
 599         D.end() == false; )
 600    {
 601       // Compute a single dependency element (glob or)
 602       pkgCache::DepIterator Start;
 603       pkgCache::DepIterator End;
 604       D.GlobOr(Start,End);
 605
 606       while (End->Type == pkgCache::Dep::PreDepends)
 607       {
 608          if (Debug)
 609             clog << OutputInDepth(Depth) << "PreDepends order for " << Pkg.FullName() << std::endl;
 610
 611          // Look for possible ok targets.
 612          SPtrArray<Version *> VList = Start.AllTargets();
 613          bool Bad = true;
 614          for (Version **I = VList; *I != 0 && Bad == true; I++)
 615          {
 616             VerIterator Ver(Cache,*I);
 617             PkgIterator Pkg = Ver.ParentPkg();
 618
 619             // See if the current version is ok
 620             if (Pkg.CurrentVer() == Ver && List->IsNow(Pkg) == true &&
 621                 Pkg.State() == PkgIterator::NeedsNothing)
 622             {
 623                Bad = false;
 624                if (Debug)
 625                   clog << OutputInDepth(Depth) << "Found ok package " << Pkg.FullName() << endl;
 626                continue;
 627             }
 628          }
 629
 630          // Look for something that could be configured.
 631          for (Version **I = VList; *I != 0 && Bad == true; I++)
 632          {
 633             VerIterator Ver(Cache,*I);
 634             PkgIterator Pkg = Ver.ParentPkg();
 635
 636             // Not the install version
 637             if (Cache[Pkg].InstallVer != *I ||
 638                 (Cache[Pkg].Keep() == true && Pkg.State() == PkgIterator::NeedsNothing))
 639                continue;
 640
 641             if (List->IsFlag(Pkg,pkgOrderList::Configured)) {
 642                Bad = false;
 643                continue;
 644             }
 645
 646             // check if it needs unpack or if if configure is enough
 647             if (!List->IsFlag(Pkg,pkgOrderList::UnPacked))
 648             {
 649                if (Debug)
 650                   clog << OutputInDepth(Depth) << "Trying to SmartUnpack " << Pkg.FullName() << endl;
 651                // SmartUnpack with the ImmediateFlag to ensure its really ready
 652                Bad = !SmartUnPack(Pkg, true, Depth + 1);
 653             } else {
 654                if (Debug)
 655                   clog << OutputInDepth(Depth) << "Trying to SmartConfigure " << Pkg.FullName() << endl;
 656                Bad = !SmartConfigure(Pkg, Depth + 1);
 657             }
 658          }
 659
 660          /* If this or element did not match then continue on to the
 661             next or element until a matching element is found */
 662          if (Bad == true)
 663          {
 664             // This triggers if someone make a pre-depends/depend loop.
 665             if (Start == End)
 666                return _error->Error("Couldn't configure pre-depend %s for %s, "
 667                                     "probably a dependency cycle.",
 668                                     End.TargetPkg().FullName().c_str(),Pkg.FullName().c_str());
 669             ++Start;
 670          }
 671          else
 672             break;
 673       }
 674
 675       if (End->Type == pkgCache::Dep::Conflicts ||
 676           End->Type == pkgCache::Dep::Obsoletes)
 677       {
 678          /* Look for conflicts. Two packages that are both in the install
 679             state cannot conflict so we don't check.. */
 680          SPtrArray<Version *> VList = End.AllTargets();
 681          for (Version **I = VList; *I != 0; I++)
 682          {
 683             VerIterator Ver(Cache,*I);
 684             PkgIterator ConflictPkg = Ver.ParentPkg();
 685             VerIterator InstallVer(Cache,Cache[ConflictPkg].InstallVer);
 686
 687             // See if the current version is conflicting
 688             if (ConflictPkg.CurrentVer() == Ver && List->IsNow(ConflictPkg))
 689             {
 690                cout << OutputInDepth(Depth) << Pkg.FullName() << " conflicts with " << ConflictPkg.FullName() << endl;
 691                /* If a loop is not present or has not yet been detected, attempt to unpack packages
 692                   to resolve this conflict. If there is a loop present, remove packages to resolve this conflict */
 693                if (!List->IsFlag(ConflictPkg,pkgOrderList::Loop)) {
 694                   if (Cache[ConflictPkg].Keep() == 0 && Cache[ConflictPkg].InstallVer != 0) {
 695                       if (Debug)
 696                         cout << OutputInDepth(Depth) << OutputInDepth(Depth) << "Unpacking " << ConflictPkg.FullName() << " to prevent conflict" << endl;
 697                       List->Flag(Pkg,pkgOrderList::Loop);
 698                       SmartUnPack(ConflictPkg,false, Depth + 1);
 699                       // Remove loop to allow it to be used later if needed
 700                       List->RmFlag(Pkg,pkgOrderList::Loop);
 701                   } else {
 702                       if (EarlyRemove(ConflictPkg) == false)
 703                          return _error->Error("Internal Error, Could not early remove %s",ConflictPkg.FullName().c_str());
 704                   }
 705                } else {
 706                   if (!List->IsFlag(ConflictPkg,pkgOrderList::Removed)) {
 707                       if (Debug)
 708                          cout << OutputInDepth(Depth) << "Because of conficts knot, removing " << ConflictPkg.FullName() << " to conflict violation" << endl;
 709                       if (EarlyRemove(ConflictPkg) == false)
 710                           return _error->Error("Internal Error, Could not early remove %s",ConflictPkg.FullName().c_str());
 711                   }
 712                }
 713             }
 714          }
 715       }
 716
 717       // Check for breaks
 718       if (End->Type == pkgCache::Dep::DpkgBreaks) {
 719          SPtrArray<Version *> VList = End.AllTargets();
 720          for (Version **I = VList; *I != 0; I++)
 721          {
 722             VerIterator Ver(Cache,*I);
 723             PkgIterator BrokenPkg = Ver.ParentPkg();
 724             if (BrokenPkg.CurrentVer() != Ver)
 725             {
 726                if (Debug)
 727                   std::clog << OutputInDepth(Depth) << "  Ignore not-installed version " << Ver.VerStr() << " of " << Pkg.FullName() << " for " << End << std::endl;
 728                continue;
 729             }
 730
 731             // Check if it needs to be unpacked
 732             if (List->IsFlag(BrokenPkg,pkgOrderList::InList) && Cache[BrokenPkg].Delete() == false &&
 733                 List->IsNow(BrokenPkg)) {
 734                if (List->IsFlag(BrokenPkg,pkgOrderList::Loop) && PkgLoop) {
 735                   // This dependancy has already been dealt with by another SmartUnPack on Pkg
 736                   break;
 737                } else {
 738                   // Found a break, so see if we can unpack the package to avoid it
 739                   // but do not set loop if another SmartUnPack already deals with it
 740                   VerIterator InstallVer(Cache,Cache[BrokenPkg].InstallVer);
 741                   bool circle = false;
 742                   for (pkgCache::DepIterator D = InstallVer.DependsList(); D.end() == false; ++D)
 743                   {
 744                      if (D->Type != pkgCache::Dep::PreDepends)
 745                         continue;
 746                      SPtrArray<Version *> VL = D.AllTargets();
 747                      for (Version **I = VL; *I != 0; ++I)
 748                      {
 749                         VerIterator V(Cache,*I);
 750                         PkgIterator P = V.ParentPkg();
 751                         // we are checking for installation as an easy 'protection' against or-groups and (unchosen) providers
 752                         if (P->CurrentVer == 0 || P != Pkg || (P.CurrentVer() != V && Cache[P].InstallVer != V))
 753                            continue;
 754                         circle = true;
 755                         break;
 756                      }
 757                      if (circle == true)
 758                         break;
 759                   }
 760                   if (circle == true)
 761                   {
 762                      if (Debug)
 763                         cout << OutputInDepth(Depth) << "  Avoiding " << End << " avoided as " << BrokenPkg.FullName() << " has a pre-depends on " << Pkg.FullName() << std::endl;
 764                      continue;
 765                   }
 766                   else
 767                   {
 768                      if (Debug)
 769                      {
 770                         cout << OutputInDepth(Depth) << "  Unpacking " << BrokenPkg.FullName() << " to avoid " << End;
 771                         if (PkgLoop == true)
 772                            cout << " (Looping)";
 773                         cout << std::endl;
 774                      }
 775                      if (PkgLoop == false)
 776                         List->Flag(Pkg,pkgOrderList::Loop);
 777                      SmartUnPack(BrokenPkg, false, Depth + 1);
 778                      if (PkgLoop == false)
 779                         List->RmFlag(Pkg,pkgOrderList::Loop);
 780                   }
 781                }
 782             } else {
 783                // Check if a package needs to be removed
 784                if (Cache[BrokenPkg].Delete() == true && !List->IsFlag(BrokenPkg,pkgOrderList::Configured))
 785                {
 786                   if (Debug)
 787                      cout << OutputInDepth(Depth) << "  Removing " << BrokenPkg.FullName() << " to avoid " << End << endl;
 788                   SmartRemove(BrokenPkg);
 789                }
 790             }
 791          }
 792       }
 793    }
 794
 795    // Check for reverse conflicts.
 796    if (CheckRConflicts(Pkg,Pkg.RevDependsList(),
 797                    instVer.VerStr()) == false)
 798                           return false;
 799
 800    for (PrvIterator P = instVer.ProvidesList();
 801         P.end() == false; ++P)
 802       if (Pkg->Group != P.OwnerPkg()->Group)
 803          CheckRConflicts(Pkg,P.ParentPkg().RevDependsList(),P.ProvideVersion());
 804
 805    if (PkgLoop)
 806       return true;
 807
 808    List->Flag(Pkg,pkgOrderList::UnPacked,pkgOrderList::States);
 809
 810    if (Immediate == true && (instVer->MultiArch & pkgCache::Version::Same) == pkgCache::Version::Same)
 811    {
 812       /* Do lockstep M-A:same unpacking in two phases:
 813          First unpack all installed architectures, then the not installed.
 814          This way we avoid that M-A: enabled packages are installed before
 815          their older non-M-A enabled packages are replaced by newer versions */
 816       bool const installed = Pkg->CurrentVer != 0;
 817       if (installed == true && Install(Pkg,FileNames[Pkg->ID]) == false)
 818          return false;
 819       for (PkgIterator P = Pkg.Group().PackageList();
 820            P.end() == false; P = Pkg.Group().NextPkg(P))
 821       {
 822          if (P->CurrentVer == 0 || P == Pkg || List->IsFlag(P,pkgOrderList::UnPacked) == true ||
 823              Cache[P].InstallVer == 0 || (P.CurrentVer() == Cache[P].InstallVer &&
 824               (Cache[Pkg].iFlags & pkgDepCache::ReInstall) != pkgDepCache::ReInstall))
 825             continue;
 826          if (SmartUnPack(P, false, Depth + 1) == false)
 827             return false;
 828       }
 829       if (installed == false && Install(Pkg,FileNames[Pkg->ID]) == false)
 830          return false;
 831       for (PkgIterator P = Pkg.Group().PackageList();
 832            P.end() == false; P = Pkg.Group().NextPkg(P))
 833       {
 834          if (P->CurrentVer != 0 || P == Pkg || List->IsFlag(P,pkgOrderList::UnPacked) == true ||
 835              Cache[P].InstallVer == 0 || (P.CurrentVer() == Cache[P].InstallVer &&
 836               (Cache[Pkg].iFlags & pkgDepCache::ReInstall) != pkgDepCache::ReInstall))
 837             continue;
 838          if (SmartUnPack(P, false, Depth + 1) == false)
 839             return false;
 840       }
 841    }
 842    // packages which are already unpacked don't need to be unpacked again
 843    else if (Pkg.State() != pkgCache::PkgIterator::NeedsConfigure && Install(Pkg,FileNames[Pkg->ID]) == false)
 844       return false;
 845
 846    if (Immediate == true) {
 847       // Perform immedate configuration of the package.
 848          if (SmartConfigure(Pkg, Depth + 1) == false)
 849             _error->Warning(_("Could not perform immediate configuration on '%s'. "
 850                "Please see man 5 apt.conf under APT::Immediate-Configure for details. (%d)"),Pkg.FullName().c_str(),2);
 851    }
 852
 853    return true;
 854 }
 855                                                                         /*}}}*/
 856 // PM::OrderInstall - Installation ordering routine                     /*{{{*/
 857 // ---------------------------------------------------------------------
 858 /* */
 859 pkgPackageManager::OrderResult pkgPackageManager::OrderInstall()
 860 {
 861    if (CreateOrderList() == false)
 862       return Failed;
 863
 864    Reset();
 865
 866    if (Debug == true)
 867       clog << "Beginning to order" << endl;
 868
 869    bool const ordering =
 870         _config->FindB("PackageManager::UnpackAll",true) ?
 871                 List->OrderUnpack(FileNames) : List->OrderCritical();
 872    if (ordering == false)
 873    {
 874       _error->Error("Internal ordering error");
 875       return Failed;
 876    }
 877
 878    if (Debug == true)
 879       clog << "Done ordering" << endl;
 880
 881    bool DoneSomething = false;
 882    for (pkgOrderList::iterator I = List->begin(); I != List->end(); ++I)
 883    {
 884       PkgIterator Pkg(Cache,*I);
 885
 886       if (List->IsNow(Pkg) == false)
 887       {
 888          if (!List->IsFlag(Pkg,pkgOrderList::Configured) && !NoImmConfigure) {
 889             if (SmartConfigure(Pkg, 0) == false && Debug)
 890                _error->Warning("Internal Error, Could not configure %s",Pkg.FullName().c_str());
 891             // FIXME: The above warning message might need changing
 892          } else {
 893             if (Debug == true)
 894                clog << "Skipping already done " << Pkg.FullName() << endl;
 895          }
 896          continue;
 897
 898       }
 899
 900       if (List->IsMissing(Pkg) == true)
 901       {
 902          if (Debug == true)
 903             clog << "Sequence completed at " << Pkg.FullName() << endl;
 904          if (DoneSomething == false)
 905          {
 906             _error->Error("Internal Error, ordering was unable to handle the media swap");
 907             return Failed;
 908          }
 909          return Incomplete;
 910       }
 911
 912       // Sanity check
 913       if (Cache[Pkg].Keep() == true &&
 914           Pkg.State() == pkgCache::PkgIterator::NeedsNothing &&
 915           (Cache[Pkg].iFlags & pkgDepCache::ReInstall) != pkgDepCache::ReInstall)
 916       {
 917          _error->Error("Internal Error, trying to manipulate a kept package (%s)",Pkg.FullName().c_str());
 918          return Failed;
 919       }
 920
 921       // Perform a delete or an install
 922       if (Cache[Pkg].Delete() == true)
 923       {
 924          if (SmartRemove(Pkg) == false)
 925             return Failed;
 926       }
 927       else
 928          if (SmartUnPack(Pkg,List->IsFlag(Pkg,pkgOrderList::Immediate),0) == false)
 929             return Failed;
 930       DoneSomething = true;
 931
 932       if (ImmConfigureAll) {
 933          /* ConfigureAll here to pick up and packages left unconfigured becuase they were unpacked in the
 934             "PreUnpack Checks" section */
 935          if (!ConfigureAll())
 936             return Failed;
 937       }
 938    }
 939
 940    // Final run through the configure phase
 941    if (ConfigureAll() == false)
 942       return Failed;
 943
 944    // Sanity check
 945    for (pkgOrderList::iterator I = List->begin(); I != List->end(); ++I)
 946    {
 947       if (List->IsFlag(*I,pkgOrderList::Configured) == false)
 948       {
 949          _error->Error("Internal error, packages left unconfigured. %s",
 950                        PkgIterator(Cache,*I).FullName().c_str());
 951          return Failed;
 952       }
 953    }
 954
 955    return Completed;
 956 }
 957                                                                         /*}}}*/
 958 // PM::DoInstallPostFork - Does install part that happens after the fork /*{{{*/
 959 // ---------------------------------------------------------------------
 960 pkgPackageManager::OrderResult
 961 pkgPackageManager::DoInstallPostFork(int statusFd)
 962 {
 963       if(statusFd > 0)
 964          // FIXME: use SetCloseExec here once it taught about throwing
 965          //        exceptions instead of doing _exit(100) on failure
 966          fcntl(statusFd,F_SETFD,FD_CLOEXEC);
 967       bool goResult = Go(statusFd);
 968       if(goResult == false)
 969          return Failed;
 970
 971       return Res;
 972 };
 973
 974 // PM::DoInstall - Does the installation                                /*{{{*/
 975 // ---------------------------------------------------------------------
 976 /* This uses the filenames in FileNames and the information in the
 977    DepCache to perform the installation of packages.*/
 978 pkgPackageManager::OrderResult pkgPackageManager::DoInstall(int statusFd)
 979 {
 980    if(DoInstallPreFork() == Failed)
 981       return Failed;
 982
 983    return DoInstallPostFork(statusFd);
 984 }
 985                                                                         /*}}}*/