apt-pkg/packagemanager.cc

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 // $Id: packagemanager.cc,v 1.30 2003/04/27 03:04:15 doogie Exp $
   4 /* ######################################################################
   5
   6    Package Manager - Abstacts the package manager
   7
   8    More work is needed in the area of transitioning provides, ie exim
   9    replacing smail. This can cause interesing side effects.
  10
  11    Other cases involving conflicts+replaces should be tested.
  12
  13    ##################################################################### */
  14                                                                         /*}}}*/
  15 // Include Files                                                        /*{{{*/
  16 #include <apt-pkg/packagemanager.h>
  17 #include <apt-pkg/orderlist.h>
  18 #include <apt-pkg/depcache.h>
  19 #include <apt-pkg/error.h>
  20 #include <apt-pkg/version.h>
  21 #include <apt-pkg/acquire-item.h>
  22 #include <apt-pkg/algorithms.h>
  23 #include <apt-pkg/configuration.h>
  24 #include <apt-pkg/sptr.h>
  25
  26 #include <apti18n.h>
  27 #include <iostream>
  28 #include <fcntl.h>
  29                                                                         /*}}}*/
  30 using namespace std;
  31
  32 // PM::PackageManager - Constructor                                     /*{{{*/
  33 // ---------------------------------------------------------------------
  34 /* */
  35 pkgPackageManager::pkgPackageManager(pkgDepCache *pCache) : Cache(*pCache)
  36 {
  37    FileNames = new string[Cache.Head().PackageCount];
  38    List = 0;
  39    Debug = _config->FindB("Debug::pkgPackageManager",false);
  40 }
  41                                                                         /*}}}*/
  42 // PM::PackageManager - Destructor                                      /*{{{*/
  43 // ---------------------------------------------------------------------
  44 /* */
  45 pkgPackageManager::~pkgPackageManager()
  46 {
  47    delete List;
  48    delete [] FileNames;
  49 }
  50                                                                         /*}}}*/
  51 // PM::GetArchives - Queue the archives for download                    /*{{{*/
  52 // ---------------------------------------------------------------------
  53 /* */
  54 bool pkgPackageManager::GetArchives(pkgAcquire *Owner,pkgSourceList *Sources,
  55                                     pkgRecords *Recs)
  56 {
  57    if (CreateOrderList() == false)
  58       return false;
  59
  60    bool const ordering =
  61         _config->FindB("PackageManager::UnpackAll",true) ?
  62                 List->OrderUnpack() : List->OrderCritical();
  63    if (ordering == false)
  64       return _error->Error("Internal ordering error");
  65
  66    for (pkgOrderList::iterator I = List->begin(); I != List->end(); ++I)
  67    {
  68       PkgIterator Pkg(Cache,*I);
  69       FileNames[Pkg->ID] = string();
  70
  71       // Skip packages to erase
  72       if (Cache[Pkg].Delete() == true)
  73          continue;
  74
  75       // Skip Packages that need configure only.
  76       if (Pkg.State() == pkgCache::PkgIterator::NeedsConfigure &&
  77           Cache[Pkg].Keep() == true)
  78          continue;
  79
  80       // Skip already processed packages
  81       if (List->IsNow(Pkg) == false)
  82          continue;
  83
  84       new pkgAcqArchive(Owner,Sources,Recs,Cache[Pkg].InstVerIter(Cache),
  85                         FileNames[Pkg->ID]);
  86    }
  87
  88    return true;
  89 }
  90                                                                         /*}}}*/
  91 // PM::FixMissing - Keep all missing packages                           /*{{{*/
  92 // ---------------------------------------------------------------------
  93 /* This is called to correct the installation when packages could not
  94    be downloaded. */
  95 bool pkgPackageManager::FixMissing()
  96 {
  97    pkgDepCache::ActionGroup group(Cache);
  98    pkgProblemResolver Resolve(&Cache);
  99    List->SetFileList(FileNames);
 100
 101    bool Bad = false;
 102    for (PkgIterator I = Cache.PkgBegin(); I.end() == false; ++I)
 103    {
 104       if (List->IsMissing(I) == false)
 105          continue;
 106
 107       // Okay, this file is missing and we need it. Mark it for keep
 108       Bad = true;
 109       Cache.MarkKeep(I, false, false);
 110    }
 111
 112    // We have to empty the list otherwise it will not have the new changes
 113    delete List;
 114    List = 0;
 115
 116    if (Bad == false)
 117       return true;
 118
 119    // Now downgrade everything that is broken
 120    return Resolve.ResolveByKeep() == true && Cache.BrokenCount() == 0;
 121 }
 122                                                                         /*}}}*/
 123 // PM::ImmediateAdd - Add the immediate flag recursivly                 /*{{{*/
 124 // ---------------------------------------------------------------------
 125 /* This adds the immediate flag to the pkg and recursively to the
 126    dependendies
 127  */
 128 void pkgPackageManager::ImmediateAdd(PkgIterator I, bool UseInstallVer, unsigned const int &Depth)
 129 {
 130    DepIterator D;
 131
 132    if(UseInstallVer)
 133    {
 134       if(Cache[I].InstallVer == 0)
 135          return;
 136       D = Cache[I].InstVerIter(Cache).DependsList();
 137    } else {
 138       if (I->CurrentVer == 0)
 139          return;
 140       D = I.CurrentVer().DependsList();
 141    }
 142
 143    for ( /* nothing */  ; D.end() == false; ++D)
 144       if (D->Type == pkgCache::Dep::Depends || D->Type == pkgCache::Dep::PreDepends)
 145       {
 146          if(!List->IsFlag(D.TargetPkg(), pkgOrderList::Immediate))
 147          {
 148             if(Debug)
 149                clog << OutputInDepth(Depth) << "ImmediateAdd(): Adding Immediate flag to " << D.TargetPkg() << " cause of " << D.DepType() << " " << I.Name() << endl;
 150             List->Flag(D.TargetPkg(),pkgOrderList::Immediate);
 151             ImmediateAdd(D.TargetPkg(), UseInstallVer, Depth + 1);
 152          }
 153       }
 154    return;
 155 }
 156                                                                         /*}}}*/
 157 // PM::CreateOrderList - Create the ordering class                      /*{{{*/
 158 // ---------------------------------------------------------------------
 159 /* This populates the ordering list with all the packages that are
 160    going to change. */
 161 bool pkgPackageManager::CreateOrderList()
 162 {
 163    if (List != 0)
 164       return true;
 165
 166    delete List;
 167    List = new pkgOrderList(&Cache);
 168
 169    static bool const NoImmConfigure = !_config->FindB("APT::Immediate-Configure",true);
 170
 171    // Generate the list of affected packages and sort it
 172    for (PkgIterator I = Cache.PkgBegin(); I.end() == false; ++I)
 173    {
 174       // Ignore no-version packages
 175       if (I->VersionList == 0)
 176          continue;
 177
 178       // Mark the package and its dependends for immediate configuration
 179       if (((I->Flags & pkgCache::Flag::Essential) == pkgCache::Flag::Essential ||
 180            (I->Flags & pkgCache::Flag::Important) == pkgCache::Flag::Important) &&
 181           NoImmConfigure == false)
 182       {
 183          if(Debug)
 184             clog << "CreateOrderList(): Adding Immediate flag for " << I.Name() << endl;
 185          List->Flag(I,pkgOrderList::Immediate);
 186
 187          // Look for other install packages to make immediate configurea
 188          ImmediateAdd(I, true);
 189
 190          // And again with the current version.
 191          ImmediateAdd(I, false);
 192       }
 193
 194       // Not interesting
 195       if ((Cache[I].Keep() == true ||
 196           Cache[I].InstVerIter(Cache) == I.CurrentVer()) &&
 197           I.State() == pkgCache::PkgIterator::NeedsNothing &&
 198           (Cache[I].iFlags & pkgDepCache::ReInstall) != pkgDepCache::ReInstall &&
 199           (I.Purge() != false || Cache[I].Mode != pkgDepCache::ModeDelete ||
 200            (Cache[I].iFlags & pkgDepCache::Purge) != pkgDepCache::Purge))
 201          continue;
 202
 203       // Append it to the list
 204       List->push_back(I);
 205    }
 206
 207    return true;
 208 }
 209                                                                         /*}}}*/
 210 // PM::DepAlwaysTrue - Returns true if this dep is irrelevent           /*{{{*/
 211 // ---------------------------------------------------------------------
 212 /* The restriction on provides is to eliminate the case when provides
 213    are transitioning between valid states [ie exim to smail] */
 214 bool pkgPackageManager::DepAlwaysTrue(DepIterator D)
 215 {
 216    if (D.TargetPkg()->ProvidesList != 0)
 217       return false;
 218
 219    if ((Cache[D] & pkgDepCache::DepInstall) != 0 &&
 220        (Cache[D] & pkgDepCache::DepNow) != 0)
 221       return true;
 222    return false;
 223 }
 224                                                                         /*}}}*/
 225 // PM::CheckRConflicts - Look for reverse conflicts                     /*{{{*/
 226 // ---------------------------------------------------------------------
 227 /* This looks over the reverses for a conflicts line that needs early
 228    removal. */
 229 bool pkgPackageManager::CheckRConflicts(PkgIterator Pkg,DepIterator D,
 230                                         const char *Ver)
 231 {
 232    for (;D.end() == false; ++D)
 233    {
 234       if (D->Type != pkgCache::Dep::Conflicts &&
 235           D->Type != pkgCache::Dep::Obsoletes)
 236          continue;
 237
 238       // The package hasnt been changed
 239       if (List->IsNow(Pkg) == false)
 240          continue;
 241
 242       // Ignore self conflicts, ignore conflicts from irrelevent versions
 243       if (D.ParentPkg() == Pkg || D.ParentVer() != D.ParentPkg().CurrentVer())
 244          continue;
 245
 246       if (Cache.VS().CheckDep(Ver,D->CompareOp,D.TargetVer()) == false)
 247          continue;
 248
 249       if (EarlyRemove(D.ParentPkg()) == false)
 250          return _error->Error("Reverse conflicts early remove for package '%s' failed",
 251                               Pkg.Name());
 252    }
 253    return true;
 254 }
 255                                                                         /*}}}*/
 256 // PM::ConfigureAll - Run the all out configuration                     /*{{{*/
 257 // ---------------------------------------------------------------------
 258 /* This configures every package. It is assumed they are all unpacked and
 259    that the final configuration is valid. */
 260 bool pkgPackageManager::ConfigureAll()
 261 {
 262    pkgOrderList OList(&Cache);
 263
 264    // Populate the order list
 265    for (pkgOrderList::iterator I = List->begin(); I != List->end(); ++I)
 266       if (List->IsFlag(pkgCache::PkgIterator(Cache,*I),
 267                        pkgOrderList::UnPacked) == true)
 268          OList.push_back(*I);
 269
 270    if (OList.OrderConfigure() == false)
 271       return false;
 272
 273    std::string const conf = _config->Find("PackageManager::Configure","all");
 274    bool const ConfigurePkgs = (conf == "all");
 275
 276    // Perform the configuring
 277    for (pkgOrderList::iterator I = OList.begin(); I != OList.end(); ++I)
 278    {
 279       PkgIterator Pkg(Cache,*I);
 280
 281       if (ConfigurePkgs == true && Configure(Pkg) == false)
 282          return false;
 283
 284       List->Flag(Pkg,pkgOrderList::Configured,pkgOrderList::States);
 285    }
 286
 287    return true;
 288 }
 289                                                                         /*}}}*/
 290 // PM::SmartConfigure - Perform immediate configuration of the pkg      /*{{{*/
 291 // ---------------------------------------------------------------------
 292 /* This routine scheduals the configuration of the given package and all
 293    of it's dependents. */
 294 bool pkgPackageManager::SmartConfigure(PkgIterator Pkg)
 295 {
 296    if (Debug == true)
 297       clog << "SmartConfigure " << Pkg.Name() << endl;
 298
 299    pkgOrderList OList(&Cache);
 300
 301    if (DepAdd(OList,Pkg) == false)
 302       return false;
 303
 304    static std::string const conf = _config->Find("PackageManager::Configure","all");
 305    static bool const ConfigurePkgs = (conf == "all" || conf == "smart");
 306
 307    if (ConfigurePkgs == true)
 308       if (OList.OrderConfigure() == false)
 309          return false;
 310
 311    // Perform the configuring
 312    for (pkgOrderList::iterator I = OList.begin(); I != OList.end(); ++I)
 313    {
 314       PkgIterator Pkg(Cache,*I);
 315
 316       if (ConfigurePkgs == true && Configure(Pkg) == false)
 317          return false;
 318
 319       List->Flag(Pkg,pkgOrderList::Configured,pkgOrderList::States);
 320    }
 321
 322    if (Cache[Pkg].InstVerIter(Cache)->MultiArch == pkgCache::Version::Same)
 323       for (PkgIterator P = Pkg.Group().PackageList();
 324            P.end() == false; P = Pkg.Group().NextPkg(P))
 325       {
 326          if (Pkg == P || List->IsFlag(P,pkgOrderList::Configured) == true ||
 327              Cache[P].InstallVer == 0 || (P.CurrentVer() == Cache[P].InstallVer &&
 328               (Cache[Pkg].iFlags & pkgDepCache::ReInstall) != pkgDepCache::ReInstall))
 329             continue;
 330          SmartConfigure(P);
 331       }
 332
 333    // Sanity Check
 334    if (List->IsFlag(Pkg,pkgOrderList::Configured) == false)
 335       return _error->Error(_("Could not perform immediate configuration on '%s'. "
 336                         "Please see man 5 apt.conf under APT::Immediate-Configure for details. (%d)"),Pkg.Name(),1);
 337
 338    return true;
 339 }
 340                                                                         /*}}}*/
 341 // PM::DepAdd - Add all dependents to the oder list                     /*{{{*/
 342 // ---------------------------------------------------------------------
 343 /* This recursively adds all dependents to the order list */
 344 bool pkgPackageManager::DepAdd(pkgOrderList &OList,PkgIterator Pkg,int Depth)
 345 {
 346    if (OList.IsFlag(Pkg,pkgOrderList::Added) == true)
 347       return true;
 348    if (List->IsFlag(Pkg,pkgOrderList::Configured) == true)
 349       return true;
 350    if (List->IsFlag(Pkg,pkgOrderList::UnPacked) == false)
 351       return false;
 352
 353    if (Debug)
 354       std::clog << OutputInDepth(Depth) << "DepAdd: " << Pkg.Name() << std::endl;
 355
 356    // Put the package on the list
 357    OList.push_back(Pkg);
 358    OList.Flag(Pkg,pkgOrderList::Added);
 359    Depth++;
 360
 361    // Check the dependencies to see if they are all satisfied.
 362    bool Bad = false;
 363    for (DepIterator D = Cache[Pkg].InstVerIter(Cache).DependsList(); D.end() == false;)
 364    {
 365       if (D->Type != pkgCache::Dep::Depends && D->Type != pkgCache::Dep::PreDepends)
 366       {
 367          ++D;
 368          continue;
 369       }
 370
 371       // Grok or groups
 372       Bad = true;
 373       for (bool LastOR = true; D.end() == false && LastOR == true; ++D)
 374       {
 375          LastOR = (D->CompareOp & pkgCache::Dep::Or) == pkgCache::Dep::Or;
 376
 377          if (Bad == false)
 378             continue;
 379
 380          SPtrArray<Version *> VList = D.AllTargets();
 381          for (Version **I = VList; *I != 0 && Bad == true; ++I)
 382          {
 383             VerIterator Ver(Cache,*I);
 384             PkgIterator Pkg = Ver.ParentPkg();
 385
 386             // See if the current version is ok
 387             if (Pkg.CurrentVer() == Ver && List->IsNow(Pkg) == true &&
 388                 Pkg.State() == PkgIterator::NeedsNothing)
 389             {
 390                Bad = false;
 391                continue;
 392             }
 393
 394             // Not the install version
 395             if (Cache[Pkg].InstallVer != *I ||
 396                 (Cache[Pkg].Keep() == true && Pkg.State() == PkgIterator::NeedsNothing))
 397                continue;
 398
 399             if (List->IsFlag(Pkg,pkgOrderList::UnPacked) == true)
 400                Bad = !DepAdd(OList,Pkg,Depth);
 401             if (List->IsFlag(Pkg,pkgOrderList::Configured) == true)
 402                Bad = false;
 403          }
 404       }
 405
 406       if (Bad == true)
 407       {
 408          if (Debug)
 409             std::clog << OutputInDepth(Depth) << "DepAdd FAILS on: " << Pkg.Name() << std::endl;
 410          OList.Flag(Pkg,0,pkgOrderList::Added);
 411          OList.pop_back();
 412          Depth--;
 413          return false;
 414       }
 415    }
 416
 417    Depth--;
 418    return true;
 419 }
 420                                                                         /*}}}*/
 421 // PM::EarlyRemove - Perform removal of packages before their time      /*{{{*/
 422 // ---------------------------------------------------------------------
 423 /* This is called to deal with conflicts arising from unpacking */
 424 bool pkgPackageManager::EarlyRemove(PkgIterator Pkg)
 425 {
 426    if (List->IsNow(Pkg) == false)
 427       return true;
 428
 429    // Already removed it
 430    if (List->IsFlag(Pkg,pkgOrderList::Removed) == true)
 431       return true;
 432
 433    // Woops, it will not be re-installed!
 434    if (List->IsFlag(Pkg,pkgOrderList::InList) == false)
 435       return false;
 436
 437    // Essential packages get special treatment
 438    bool IsEssential = false;
 439    if ((Pkg->Flags & pkgCache::Flag::Essential) != 0)
 440       IsEssential = true;
 441
 442    /* Check for packages that are the dependents of essential packages and
 443       promote them too */
 444    if (Pkg->CurrentVer != 0)
 445    {
 446       for (DepIterator D = Pkg.RevDependsList(); D.end() == false &&
 447            IsEssential == false; ++D)
 448          if (D->Type == pkgCache::Dep::Depends || D->Type == pkgCache::Dep::PreDepends)
 449             if ((D.ParentPkg()->Flags & pkgCache::Flag::Essential) != 0)
 450                IsEssential = true;
 451    }
 452
 453    if (IsEssential == true)
 454    {
 455       if (_config->FindB("APT::Force-LoopBreak",false) == false)
 456          return _error->Error(_("This installation run will require temporarily "
 457                                 "removing the essential package %s due to a "
 458                                 "Conflicts/Pre-Depends loop. This is often bad, "
 459                                 "but if you really want to do it, activate the "
 460                                 "APT::Force-LoopBreak option."),Pkg.Name());
 461    }
 462
 463    bool Res = SmartRemove(Pkg);
 464    if (Cache[Pkg].Delete() == false)
 465       List->Flag(Pkg,pkgOrderList::Removed,pkgOrderList::States);
 466
 467    return Res;
 468 }
 469                                                                         /*}}}*/
 470 // PM::SmartRemove - Removal Helper                                     /*{{{*/
 471 // ---------------------------------------------------------------------
 472 /* */
 473 bool pkgPackageManager::SmartRemove(PkgIterator Pkg)
 474 {
 475    if (List->IsNow(Pkg) == false)
 476       return true;
 477
 478    List->Flag(Pkg,pkgOrderList::Configured,pkgOrderList::States);
 479
 480    return Remove(Pkg,(Cache[Pkg].iFlags & pkgDepCache::Purge) == pkgDepCache::Purge);
 481    return true;
 482 }
 483                                                                         /*}}}*/
 484 // PM::SmartUnPack - Install helper                                     /*{{{*/
 485 // ---------------------------------------------------------------------
 486 /* This performs the task of handling pre-depends. */
 487 bool pkgPackageManager::SmartUnPack(PkgIterator Pkg)
 488 {
 489    return SmartUnPack(Pkg, true);
 490 }
 491 bool pkgPackageManager::SmartUnPack(PkgIterator Pkg, bool const Immediate)
 492 {
 493    // Check if it is already unpacked
 494    if (Pkg.State() == pkgCache::PkgIterator::NeedsConfigure &&
 495        Cache[Pkg].Keep() == true)
 496    {
 497       List->Flag(Pkg,pkgOrderList::UnPacked,pkgOrderList::States);
 498       if (Immediate == true &&
 499           List->IsFlag(Pkg,pkgOrderList::Immediate) == true)
 500          if (SmartConfigure(Pkg) == false)
 501             return _error->Error(_("Could not perform immediate configuration on already unpacked '%s'. "
 502                         "Please see man 5 apt.conf under APT::Immediate-Configure for details."),Pkg.Name());
 503       return true;
 504    }
 505
 506    VerIterator const instVer = Cache[Pkg].InstVerIter(Cache);
 507
 508    /* See if this packages install version has any predependencies
 509       that are not met by 'now' packages. */
 510    for (DepIterator D = instVer.DependsList();
 511         D.end() == false; )
 512    {
 513       // Compute a single dependency element (glob or)
 514       pkgCache::DepIterator Start;
 515       pkgCache::DepIterator End;
 516       D.GlobOr(Start,End);
 517
 518       while (End->Type == pkgCache::Dep::PreDepends)
 519       {
 520          if (Debug == true)
 521             clog << "PreDepends order for " << Pkg.Name() << std::endl;
 522
 523          // Look for possible ok targets.
 524          SPtrArray<Version *> VList = Start.AllTargets();
 525          bool Bad = true;
 526          for (Version **I = VList; *I != 0 && Bad == true; I++)
 527          {
 528             VerIterator Ver(Cache,*I);
 529             PkgIterator Pkg = Ver.ParentPkg();
 530
 531             // See if the current version is ok
 532             if (Pkg.CurrentVer() == Ver && List->IsNow(Pkg) == true &&
 533                 Pkg.State() == PkgIterator::NeedsNothing)
 534             {
 535                Bad = false;
 536                if (Debug == true)
 537                   clog << "Found ok package " << Pkg.Name() << endl;
 538                continue;
 539             }
 540          }
 541
 542          // Look for something that could be configured.
 543          for (Version **I = VList; *I != 0 && Bad == true; I++)
 544          {
 545             VerIterator Ver(Cache,*I);
 546             PkgIterator Pkg = Ver.ParentPkg();
 547
 548             // Not the install version
 549             if (Cache[Pkg].InstallVer != *I ||
 550                 (Cache[Pkg].Keep() == true && Pkg.State() == PkgIterator::NeedsNothing))
 551                continue;
 552
 553             if (Debug == true)
 554                clog << "Trying to SmartConfigure " << Pkg.Name() << endl;
 555             Bad = !SmartConfigure(Pkg);
 556          }
 557
 558          /* If this or element did not match then continue on to the
 559             next or element until a matching element is found */
 560          if (Bad == true)
 561          {
 562             // This triggers if someone make a pre-depends/depend loop.
 563             if (Start == End)
 564                return _error->Error("Couldn't configure pre-depend %s for %s, "
 565                                     "probably a dependency cycle.",
 566                                     End.TargetPkg().Name(),Pkg.Name());
 567             ++Start;
 568          }
 569          else
 570             break;
 571       }
 572
 573       if (End->Type == pkgCache::Dep::Conflicts ||
 574           End->Type == pkgCache::Dep::Obsoletes)
 575       {
 576          /* Look for conflicts. Two packages that are both in the install
 577             state cannot conflict so we don't check.. */
 578          SPtrArray<Version *> VList = End.AllTargets();
 579          for (Version **I = VList; *I != 0; I++)
 580          {
 581             VerIterator Ver(Cache,*I);
 582             PkgIterator Pkg = Ver.ParentPkg();
 583
 584             // See if the current version is conflicting
 585             if (Pkg.CurrentVer() == Ver && List->IsNow(Pkg) == true)
 586             {
 587                if (EarlyRemove(Pkg) == false)
 588                   return _error->Error("Internal Error, Could not early remove %s",Pkg.Name());
 589             }
 590          }
 591       }
 592    }
 593
 594    // Check for reverse conflicts.
 595    if (CheckRConflicts(Pkg,Pkg.RevDependsList(),
 596                    instVer.VerStr()) == false)
 597       return false;
 598
 599    for (PrvIterator P = instVer.ProvidesList();
 600         P.end() == false; ++P)
 601       if (Pkg->Group != P.OwnerPkg()->Group)
 602          CheckRConflicts(Pkg,P.ParentPkg().RevDependsList(),P.ProvideVersion());
 603
 604    List->Flag(Pkg,pkgOrderList::UnPacked,pkgOrderList::States);
 605
 606    if (Immediate == true && instVer->MultiArch == pkgCache::Version::Same)
 607    {
 608       /* Do lockstep M-A:same unpacking in two phases:
 609          First unpack all installed architectures, then the not installed.
 610          This way we avoid that M-A: enabled packages are installed before
 611          their older non-M-A enabled packages are replaced by newer versions */
 612       bool const installed = Pkg->CurrentVer != 0;
 613       if (installed == true && Install(Pkg,FileNames[Pkg->ID]) == false)
 614          return false;
 615       for (PkgIterator P = Pkg.Group().PackageList();
 616            P.end() == false; P = Pkg.Group().NextPkg(P))
 617       {
 618          if (P->CurrentVer == 0 || P == Pkg || List->IsFlag(P,pkgOrderList::UnPacked) == true ||
 619              Cache[P].InstallVer == 0 || (P.CurrentVer() == Cache[P].InstallVer &&
 620               (Cache[Pkg].iFlags & pkgDepCache::ReInstall) != pkgDepCache::ReInstall))
 621             continue;
 622          if (SmartUnPack(P, false) == false)
 623             return false;
 624       }
 625       if (installed == false && Install(Pkg,FileNames[Pkg->ID]) == false)
 626          return false;
 627       for (PkgIterator P = Pkg.Group().PackageList();
 628            P.end() == false; P = Pkg.Group().NextPkg(P))
 629       {
 630          if (P->CurrentVer != 0 || P == Pkg || List->IsFlag(P,pkgOrderList::UnPacked) == true ||
 631              Cache[P].InstallVer == 0 || (P.CurrentVer() == Cache[P].InstallVer &&
 632               (Cache[Pkg].iFlags & pkgDepCache::ReInstall) != pkgDepCache::ReInstall))
 633             continue;
 634          if (SmartUnPack(P, false) == false)
 635             return false;
 636       }
 637    }
 638    else if (Install(Pkg,FileNames[Pkg->ID]) == false)
 639       return false;
 640
 641    // Perform immedate configuration of the package.
 642    if (Immediate == true &&
 643        List->IsFlag(Pkg,pkgOrderList::Immediate) == true)
 644       if (SmartConfigure(Pkg) == false)
 645          return _error->Error(_("Could not perform immediate configuration on '%s'. "
 646                         "Please see man 5 apt.conf under APT::Immediate-Configure for details. (%d)"),Pkg.Name(),2);
 647
 648    return true;
 649 }
 650                                                                         /*}}}*/
 651 // PM::OrderInstall - Installation ordering routine                     /*{{{*/
 652 // ---------------------------------------------------------------------
 653 /* */
 654 pkgPackageManager::OrderResult pkgPackageManager::OrderInstall()
 655 {
 656    if (CreateOrderList() == false)
 657       return Failed;
 658
 659    Reset();
 660
 661    if (Debug == true)
 662       clog << "Beginning to order" << endl;
 663
 664    bool const ordering =
 665         _config->FindB("PackageManager::UnpackAll",true) ?
 666                 List->OrderUnpack(FileNames) : List->OrderCritical();
 667    if (ordering == false)
 668    {
 669       _error->Error("Internal ordering error");
 670       return Failed;
 671    }
 672
 673    if (Debug == true)
 674       clog << "Done ordering" << endl;
 675
 676    bool DoneSomething = false;
 677    for (pkgOrderList::iterator I = List->begin(); I != List->end(); ++I)
 678    {
 679       PkgIterator Pkg(Cache,*I);
 680
 681       if (List->IsNow(Pkg) == false)
 682       {
 683          if (Debug == true)
 684             clog << "Skipping already done " << Pkg.Name() << endl;
 685          continue;
 686       }
 687
 688       if (List->IsMissing(Pkg) == true)
 689       {
 690          if (Debug == true)
 691             clog << "Sequence completed at " << Pkg.Name() << endl;
 692          if (DoneSomething == false)
 693          {
 694             _error->Error("Internal Error, ordering was unable to handle the media swap");
 695             return Failed;
 696          }
 697          return Incomplete;
 698       }
 699
 700       // Sanity check
 701       if (Cache[Pkg].Keep() == true &&
 702           Pkg.State() == pkgCache::PkgIterator::NeedsNothing &&
 703           (Cache[Pkg].iFlags & pkgDepCache::ReInstall) != pkgDepCache::ReInstall)
 704       {
 705          _error->Error("Internal Error, trying to manipulate a kept package (%s)",Pkg.Name());
 706          return Failed;
 707       }
 708
 709       // Perform a delete or an install
 710       if (Cache[Pkg].Delete() == true)
 711       {
 712          if (SmartRemove(Pkg) == false)
 713             return Failed;
 714       }
 715       else
 716          if (SmartUnPack(Pkg) == false)
 717             return Failed;
 718       DoneSomething = true;
 719    }
 720
 721    // Final run through the configure phase
 722    if (ConfigureAll() == false)
 723       return Failed;
 724
 725    // Sanity check
 726    for (pkgOrderList::iterator I = List->begin(); I != List->end(); ++I)
 727    {
 728       if (List->IsFlag(*I,pkgOrderList::Configured) == false)
 729       {
 730          _error->Error("Internal error, packages left unconfigured. %s",
 731                        PkgIterator(Cache,*I).Name());
 732          return Failed;
 733       }
 734    }
 735
 736    return Completed;
 737 }
 738                                                                         /*}}}*/
 739 // PM::DoInstallPostFork - Does install part that happens after the fork /*{{{*/
 740 // ---------------------------------------------------------------------
 741 pkgPackageManager::OrderResult
 742 pkgPackageManager::DoInstallPostFork(int statusFd)
 743 {
 744       if(statusFd > 0)
 745          // FIXME: use SetCloseExec here once it taught about throwing
 746          //        exceptions instead of doing _exit(100) on failure
 747          fcntl(statusFd,F_SETFD,FD_CLOEXEC);
 748       bool goResult = Go(statusFd);
 749       if(goResult == false)
 750          return Failed;
 751
 752       return Res;
 753 };
 754
 755 // PM::DoInstall - Does the installation                                /*{{{*/
 756 // ---------------------------------------------------------------------
 757 /* This uses the filenames in FileNames and the information in the
 758    DepCache to perform the installation of packages.*/
 759 pkgPackageManager::OrderResult pkgPackageManager::DoInstall(int statusFd)
 760 {
 761    if(DoInstallPreFork() == Failed)
 762       return Failed;
 763
 764    return DoInstallPostFork(statusFd);
 765 }
 766                                                                         /*}}}*/