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