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          // ignore dependencies if no instal/upgrade/remove is going to happen
 147          if (D.TargetPkg() == 0 || Cache[D.TargetPkg()].Keep())
 148               continue;
 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    static bool const NoImmConfigure = !_config->FindB("APT::Immediate-Configure",true);
 174
 175    // Generate the list of affected packages and sort it
 176    for (PkgIterator I = Cache.PkgBegin(); I.end() == false; I++)
 177    {
 178       // Ignore no-version packages
 179       if (I->VersionList == 0)
 180          continue;
 181
 182       // Mark the package and its dependends for immediate configuration
 183       if (((I->Flags & pkgCache::Flag::Essential) == pkgCache::Flag::Essential ||
 184            (I->Flags & pkgCache::Flag::Important) == pkgCache::Flag::Important) &&
 185           NoImmConfigure == false)
 186       {
 187          if(Debug)
 188             clog << "CreateOrderList(): Adding Immediate flag for " << I.Name() << endl;
 189          List->Flag(I,pkgOrderList::Immediate);
 190
 191          // Look for other install packages to make immediate configurea
 192          ImmediateAdd(I, true);
 193
 194          // And again with the current version.
 195          ImmediateAdd(I, false);
 196       }
 197
 198       // Not interesting
 199       if ((Cache[I].Keep() == true ||
 200           Cache[I].InstVerIter(Cache) == I.CurrentVer()) &&
 201           I.State() == pkgCache::PkgIterator::NeedsNothing &&
 202           (Cache[I].iFlags & pkgDepCache::ReInstall) != pkgDepCache::ReInstall &&
 203           (I.Purge() != false || Cache[I].Mode != pkgDepCache::ModeDelete ||
 204            (Cache[I].iFlags & pkgDepCache::Purge) != pkgDepCache::Purge))
 205          continue;
 206
 207       // Append it to the list
 208       List->push_back(I);
 209    }
 210
 211    return true;
 212 }
 213                                                                         /*}}}*/
 214 // PM::DepAlwaysTrue - Returns true if this dep is irrelevent           /*{{{*/
 215 // ---------------------------------------------------------------------
 216 /* The restriction on provides is to eliminate the case when provides
 217    are transitioning between valid states [ie exim to smail] */
 218 bool pkgPackageManager::DepAlwaysTrue(DepIterator D)
 219 {
 220    if (D.TargetPkg()->ProvidesList != 0)
 221       return false;
 222
 223    if ((Cache[D] & pkgDepCache::DepInstall) != 0 &&
 224        (Cache[D] & pkgDepCache::DepNow) != 0)
 225       return true;
 226    return false;
 227 }
 228                                                                         /*}}}*/
 229 // PM::CheckRConflicts - Look for reverse conflicts                     /*{{{*/
 230 // ---------------------------------------------------------------------
 231 /* This looks over the reverses for a conflicts line that needs early
 232    removal. */
 233 bool pkgPackageManager::CheckRConflicts(PkgIterator Pkg,DepIterator D,
 234                                         const char *Ver)
 235 {
 236    for (;D.end() == false; D++)
 237    {
 238       if (D->Type != pkgCache::Dep::Conflicts &&
 239           D->Type != pkgCache::Dep::Obsoletes)
 240          continue;
 241
 242       // The package hasnt been changed
 243       if (List->IsNow(Pkg) == false)
 244          continue;
 245
 246       // Ignore self conflicts, ignore conflicts from irrelevent versions
 247       if (D.ParentPkg() == Pkg || D.ParentVer() != D.ParentPkg().CurrentVer())
 248          continue;
 249
 250       if (Cache.VS().CheckDep(Ver,D->CompareOp,D.TargetVer()) == false)
 251          continue;
 252
 253       if (EarlyRemove(D.ParentPkg()) == false)
 254          return _error->Error("Reverse conflicts early remove for package '%s' failed",
 255                               Pkg.Name());
 256    }
 257    return true;
 258 }
 259                                                                         /*}}}*/
 260 // PM::ConfigureAll - Run the all out configuration                     /*{{{*/
 261 // ---------------------------------------------------------------------
 262 /* This configures every package. It is assumed they are all unpacked and
 263    that the final configuration is valid. */
 264 bool pkgPackageManager::ConfigureAll()
 265 {
 266    pkgOrderList OList(&Cache);
 267
 268    // Populate the order list
 269    for (pkgOrderList::iterator I = List->begin(); I != List->end(); I++)
 270       if (List->IsFlag(pkgCache::PkgIterator(Cache,*I),
 271                        pkgOrderList::UnPacked) == true)
 272          OList.push_back(*I);
 273
 274    if (OList.OrderConfigure() == false)
 275       return false;
 276
 277    std::string const conf = _config->Find("PackageManager::Configure","all");
 278    bool const ConfigurePkgs = (conf == "all");
 279
 280    // Perform the configuring
 281    for (pkgOrderList::iterator I = OList.begin(); I != OList.end(); I++)
 282    {
 283       PkgIterator Pkg(Cache,*I);
 284
 285       if (ConfigurePkgs == true && Configure(Pkg) == false)
 286          return false;
 287
 288       List->Flag(Pkg,pkgOrderList::Configured,pkgOrderList::States);
 289    }
 290
 291    return true;
 292 }
 293                                                                         /*}}}*/
 294 // PM::SmartConfigure - Perform immediate configuration of the pkg      /*{{{*/
 295 // ---------------------------------------------------------------------
 296 /* This routine scheduals the configuration of the given package and all
 297    of it's dependents. */
 298 bool pkgPackageManager::SmartConfigure(PkgIterator Pkg)
 299 {
 300    pkgOrderList OList(&Cache);
 301
 302    if (DepAdd(OList,Pkg) == false)
 303       return false;
 304
 305    static std::string const conf = _config->Find("PackageManager::Configure","all");
 306    static bool const ConfigurePkgs = (conf == "all" || conf == "smart");
 307
 308    if (ConfigurePkgs == true)
 309       if (OList.OrderConfigure() == false)
 310          return false;
 311
 312    // Perform the configuring
 313    for (pkgOrderList::iterator I = OList.begin(); I != OList.end(); I++)
 314    {
 315       PkgIterator Pkg(Cache,*I);
 316
 317       if (ConfigurePkgs == true && Configure(Pkg) == false)
 318          return false;
 319
 320       List->Flag(Pkg,pkgOrderList::Configured,pkgOrderList::States);
 321    }
 322
 323    // Sanity Check
 324    if (List->IsFlag(Pkg,pkgOrderList::Configured) == false)
 325       return _error->Error("Internal error, could not immediate configure %s",Pkg.Name());
 326
 327    return true;
 328 }
 329                                                                         /*}}}*/
 330 // PM::DepAdd - Add all dependents to the oder list                     /*{{{*/
 331 // ---------------------------------------------------------------------
 332 /* This recursively adds all dependents to the order list */
 333 bool pkgPackageManager::DepAdd(pkgOrderList &OList,PkgIterator Pkg,int Depth)
 334 {
 335    if (OList.IsFlag(Pkg,pkgOrderList::Added) == true)
 336       return true;
 337    if (List->IsFlag(Pkg,pkgOrderList::Configured) == true)
 338       return true;
 339    if (List->IsFlag(Pkg,pkgOrderList::UnPacked) == false)
 340       return false;
 341
 342    // Put the package on the list
 343    OList.push_back(Pkg);
 344    OList.Flag(Pkg,pkgOrderList::Added);
 345    Depth++;
 346
 347    // Check the dependencies to see if they are all satisfied.
 348    bool Bad = false;
 349    for (DepIterator D = Cache[Pkg].InstVerIter(Cache).DependsList(); D.end() == false;)
 350    {
 351       if (D->Type != pkgCache::Dep::Depends && D->Type != pkgCache::Dep::PreDepends)
 352       {
 353          D++;
 354          continue;
 355       }
 356
 357       // Grok or groups
 358       Bad = true;
 359       for (bool LastOR = true; D.end() == false && LastOR == true; D++)
 360       {
 361          LastOR = (D->CompareOp & pkgCache::Dep::Or) == pkgCache::Dep::Or;
 362
 363          if (Bad == false)
 364             continue;
 365
 366          SPtrArray<Version *> VList = D.AllTargets();
 367          for (Version **I = VList; *I != 0 && Bad == true; I++)
 368          {
 369             VerIterator Ver(Cache,*I);
 370             PkgIterator Pkg = Ver.ParentPkg();
 371
 372             // See if the current version is ok
 373             if (Pkg.CurrentVer() == Ver && List->IsNow(Pkg) == true &&
 374                 Pkg.State() == PkgIterator::NeedsNothing)
 375             {
 376                Bad = false;
 377                continue;
 378             }
 379
 380             // Not the install version
 381             if (Cache[Pkg].InstallVer != *I ||
 382                 (Cache[Pkg].Keep() == true && Pkg.State() == PkgIterator::NeedsNothing))
 383                continue;
 384
 385             if (List->IsFlag(Pkg,pkgOrderList::UnPacked) == true)
 386                Bad = !DepAdd(OList,Pkg,Depth);
 387             if (List->IsFlag(Pkg,pkgOrderList::Configured) == true)
 388                Bad = false;
 389          }
 390       }
 391
 392       if (Bad == true)
 393       {
 394          OList.Flag(Pkg,0,pkgOrderList::Added);
 395          OList.pop_back();
 396          Depth--;
 397          return false;
 398       }
 399    }
 400
 401    Depth--;
 402    return true;
 403 }
 404                                                                         /*}}}*/
 405 // PM::EarlyRemove - Perform removal of packages before their time      /*{{{*/
 406 // ---------------------------------------------------------------------
 407 /* This is called to deal with conflicts arising from unpacking */
 408 bool pkgPackageManager::EarlyRemove(PkgIterator Pkg)
 409 {
 410    if (List->IsNow(Pkg) == false)
 411       return true;
 412
 413    // Already removed it
 414    if (List->IsFlag(Pkg,pkgOrderList::Removed) == true)
 415       return true;
 416
 417    // Woops, it will not be re-installed!
 418    if (List->IsFlag(Pkg,pkgOrderList::InList) == false)
 419       return false;
 420
 421    // Essential packages get special treatment
 422    bool IsEssential = false;
 423    if ((Pkg->Flags & pkgCache::Flag::Essential) != 0)
 424       IsEssential = true;
 425
 426    /* Check for packages that are the dependents of essential packages and
 427       promote them too */
 428    if (Pkg->CurrentVer != 0)
 429    {
 430       for (DepIterator D = Pkg.RevDependsList(); D.end() == false &&
 431            IsEssential == false; D++)
 432          if (D->Type == pkgCache::Dep::Depends || D->Type == pkgCache::Dep::PreDepends)
 433             if ((D.ParentPkg()->Flags & pkgCache::Flag::Essential) != 0)
 434                IsEssential = true;
 435    }
 436
 437    if (IsEssential == true)
 438    {
 439       if (_config->FindB("APT::Force-LoopBreak",false) == false)
 440          return _error->Error(_("This installation run will require temporarily "
 441                                 "removing the essential package %s due to a "
 442                                 "Conflicts/Pre-Depends loop. This is often bad, "
 443                                 "but if you really want to do it, activate the "
 444                                 "APT::Force-LoopBreak option."),Pkg.Name());
 445    }
 446
 447    bool Res = SmartRemove(Pkg);
 448    if (Cache[Pkg].Delete() == false)
 449       List->Flag(Pkg,pkgOrderList::Removed,pkgOrderList::States);
 450
 451    return Res;
 452 }
 453                                                                         /*}}}*/
 454 // PM::SmartRemove - Removal Helper                                     /*{{{*/
 455 // ---------------------------------------------------------------------
 456 /* */
 457 bool pkgPackageManager::SmartRemove(PkgIterator Pkg)
 458 {
 459    if (List->IsNow(Pkg) == false)
 460       return true;
 461
 462    List->Flag(Pkg,pkgOrderList::Configured,pkgOrderList::States);
 463    return Remove(Pkg,(Cache[Pkg].iFlags & pkgDepCache::Purge) == pkgDepCache::Purge);
 464 }
 465                                                                         /*}}}*/
 466 // PM::SmartUnPack - Install helper                                     /*{{{*/
 467 // ---------------------------------------------------------------------
 468 /* This performs the task of handling pre-depends. */
 469 bool pkgPackageManager::SmartUnPack(PkgIterator Pkg)
 470 {
 471    // Check if it is already unpacked
 472    if (Pkg.State() == pkgCache::PkgIterator::NeedsConfigure &&
 473        Cache[Pkg].Keep() == true)
 474    {
 475       List->Flag(Pkg,pkgOrderList::UnPacked,pkgOrderList::States);
 476       if (List->IsFlag(Pkg,pkgOrderList::Immediate) == true)
 477          if (SmartConfigure(Pkg) == false)
 478             return _error->Error("Internal Error, Could not perform immediate configuration (1) on %s",Pkg.Name());
 479       return true;
 480    }
 481
 482    /* See if this packages install version has any predependencies
 483       that are not met by 'now' packages. */
 484    for (DepIterator D = Cache[Pkg].InstVerIter(Cache).DependsList();
 485         D.end() == false; )
 486    {
 487       // Compute a single dependency element (glob or)
 488       pkgCache::DepIterator Start;
 489       pkgCache::DepIterator End;
 490       D.GlobOr(Start,End);
 491
 492       while (End->Type == pkgCache::Dep::PreDepends)
 493       {
 494          // Look for possible ok targets.
 495          SPtrArray<Version *> VList = Start.AllTargets();
 496          bool Bad = true;
 497          for (Version **I = VList; *I != 0 && Bad == true; I++)
 498          {
 499             VerIterator Ver(Cache,*I);
 500             PkgIterator Pkg = Ver.ParentPkg();
 501
 502             // See if the current version is ok
 503             if (Pkg.CurrentVer() == Ver && List->IsNow(Pkg) == true &&
 504                 Pkg.State() == PkgIterator::NeedsNothing)
 505             {
 506                Bad = false;
 507                continue;
 508             }
 509          }
 510
 511          // Look for something that could be configured.
 512          for (Version **I = VList; *I != 0 && Bad == true; I++)
 513          {
 514             VerIterator Ver(Cache,*I);
 515             PkgIterator Pkg = Ver.ParentPkg();
 516
 517             // Not the install version
 518             if (Cache[Pkg].InstallVer != *I ||
 519                 (Cache[Pkg].Keep() == true && Pkg.State() == PkgIterator::NeedsNothing))
 520                continue;
 521
 522             Bad = !SmartConfigure(Pkg);
 523          }
 524
 525          /* If this or element did not match then continue on to the
 526             next or element until a matching element is found */
 527          if (Bad == true)
 528          {
 529             // This triggers if someone make a pre-depends/depend loop.
 530             if (Start == End)
 531                return _error->Error("Couldn't configure pre-depend %s for %s, "
 532                                     "probably a dependency cycle.",
 533                                     End.TargetPkg().Name(),Pkg.Name());
 534             Start++;
 535          }
 536          else
 537             break;
 538       }
 539
 540       if (End->Type == pkgCache::Dep::Conflicts ||
 541           End->Type == pkgCache::Dep::Obsoletes)
 542       {
 543          /* Look for conflicts. Two packages that are both in the install
 544             state cannot conflict so we don't check.. */
 545          SPtrArray<Version *> VList = End.AllTargets();
 546          for (Version **I = VList; *I != 0; I++)
 547          {
 548             VerIterator Ver(Cache,*I);
 549             PkgIterator Pkg = Ver.ParentPkg();
 550
 551             // See if the current version is conflicting
 552             if (Pkg.CurrentVer() == Ver && List->IsNow(Pkg) == true)
 553             {
 554                if (EarlyRemove(Pkg) == false)
 555                   return _error->Error("Internal Error, Could not early remove %s",Pkg.Name());
 556             }
 557          }
 558       }
 559    }
 560
 561    // Check for reverse conflicts.
 562    if (CheckRConflicts(Pkg,Pkg.RevDependsList(),
 563                    Cache[Pkg].InstVerIter(Cache).VerStr()) == false)
 564       return false;
 565
 566    for (PrvIterator P = Cache[Pkg].InstVerIter(Cache).ProvidesList();
 567         P.end() == false; P++)
 568       CheckRConflicts(Pkg,P.ParentPkg().RevDependsList(),P.ProvideVersion());
 569
 570    if (Install(Pkg,FileNames[Pkg->ID]) == false)
 571       return false;
 572
 573    List->Flag(Pkg,pkgOrderList::UnPacked,pkgOrderList::States);
 574
 575    // Perform immedate configuration of the package.
 576    if (List->IsFlag(Pkg,pkgOrderList::Immediate) == true)
 577       if (SmartConfigure(Pkg) == false)
 578          return _error->Error("Internal Error, Could not perform immediate configuration (2) on %s",Pkg.Name());
 579
 580    return true;
 581 }
 582                                                                         /*}}}*/
 583 // PM::OrderInstall - Installation ordering routine                     /*{{{*/
 584 // ---------------------------------------------------------------------
 585 /* */
 586 pkgPackageManager::OrderResult pkgPackageManager::OrderInstall()
 587 {
 588    if (CreateOrderList() == false)
 589       return Failed;
 590
 591    Reset();
 592
 593    if (Debug == true)
 594       clog << "Beginning to order" << endl;
 595
 596    bool const ordering =
 597         _config->FindB("PackageManager::UnpackAll",true) ?
 598                 List->OrderUnpack(FileNames) : List->OrderCritical();
 599    if (ordering == false)
 600    {
 601       _error->Error("Internal ordering error");
 602       return Failed;
 603    }
 604
 605    if (Debug == true)
 606       clog << "Done ordering" << endl;
 607
 608    bool DoneSomething = false;
 609    for (pkgOrderList::iterator I = List->begin(); I != List->end(); I++)
 610    {
 611       PkgIterator Pkg(Cache,*I);
 612
 613       if (List->IsNow(Pkg) == false)
 614       {
 615          if (Debug == true)
 616             clog << "Skipping already done " << Pkg.Name() << endl;
 617          continue;
 618       }
 619
 620       if (List->IsMissing(Pkg) == true)
 621       {
 622          if (Debug == true)
 623             clog << "Sequence completed at " << Pkg.Name() << endl;
 624          if (DoneSomething == false)
 625          {
 626             _error->Error("Internal Error, ordering was unable to handle the media swap");
 627             return Failed;
 628          }
 629          return Incomplete;
 630       }
 631
 632       // Sanity check
 633       if (Cache[Pkg].Keep() == true &&
 634           Pkg.State() == pkgCache::PkgIterator::NeedsNothing &&
 635           (Cache[Pkg].iFlags & pkgDepCache::ReInstall) != pkgDepCache::ReInstall)
 636       {
 637          _error->Error("Internal Error, trying to manipulate a kept package (%s)",Pkg.Name());
 638          return Failed;
 639       }
 640
 641       // Perform a delete or an install
 642       if (Cache[Pkg].Delete() == true)
 643       {
 644          if (SmartRemove(Pkg) == false)
 645             return Failed;
 646       }
 647       else
 648          if (SmartUnPack(Pkg) == false)
 649             return Failed;
 650       DoneSomething = true;
 651    }
 652
 653    // Final run through the configure phase
 654    if (ConfigureAll() == false)
 655       return Failed;
 656
 657    // Sanity check
 658    for (pkgOrderList::iterator I = List->begin(); I != List->end(); I++)
 659    {
 660       if (List->IsFlag(*I,pkgOrderList::Configured) == false)
 661       {
 662          _error->Error("Internal error, packages left unconfigured. %s",
 663                        PkgIterator(Cache,*I).Name());
 664          return Failed;
 665       }
 666    }
 667
 668    return Completed;
 669 }
 670                                                                         /*}}}*/
 671 // PM::DoInstallPostFork - Does install part that happens after the fork /*{{{*/
 672 // ---------------------------------------------------------------------
 673 pkgPackageManager::OrderResult
 674 pkgPackageManager::DoInstallPostFork(int statusFd)
 675 {
 676       if(statusFd > 0)
 677          // FIXME: use SetCloseExec here once it taught about throwing
 678          //        exceptions instead of doing _exit(100) on failure
 679          fcntl(statusFd,F_SETFD,FD_CLOEXEC);
 680       bool goResult = Go(statusFd);
 681       if(goResult == false)
 682          return Failed;
 683
 684       return Res;
 685 };
 686
 687 // PM::DoInstall - Does the installation                                /*{{{*/
 688 // ---------------------------------------------------------------------
 689 /* This uses the filenames in FileNames and the information in the
 690    DepCache to perform the installation of packages.*/
 691 pkgPackageManager::OrderResult pkgPackageManager::DoInstall(int statusFd)
 692 {
 693    if(DoInstallPreFork() == Failed)
 694       return Failed;
 695
 696    return DoInstallPostFork(statusFd);
 697 }
 698                                                                         /*}}}*/