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