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 interesting 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/macros.h>
  27 #include <apt-pkg/pkgcache.h>
  28 #include <apt-pkg/cacheiterators.h>
  29 #include <apt-pkg/strutl.h>
  30 #include <apt-pkg/install-progress.h>
  31 #include <apt-pkg/prettyprinters.h>
  32
  33 #include <stddef.h>
  34 #include <list>
  35 #include <string>
  36 #include <iostream>
  37
  38 #include <apti18n.h>
  39                                                                         /*}}}*/
  40 using namespace std;
  41
  42 bool pkgPackageManager::SigINTStop = false;
  43
  44 // PM::PackageManager - Constructor                                     /*{{{*/
  45 // ---------------------------------------------------------------------
  46 /* */
  47 pkgPackageManager::pkgPackageManager(pkgDepCache *pCache) : Cache(*pCache),
  48                                                             List(NULL), Res(Incomplete), d(NULL)
  49 {
  50    FileNames = new string[Cache.Head().PackageCount];
  51    Debug = _config->FindB("Debug::pkgPackageManager",false);
  52    NoImmConfigure = !_config->FindB("APT::Immediate-Configure",true);
  53    ImmConfigureAll = _config->FindB("APT::Immediate-Configure-All",false);
  54 }
  55                                                                         /*}}}*/
  56 // PM::PackageManager - Destructor                                      /*{{{*/
  57 // ---------------------------------------------------------------------
  58 /* */
  59 pkgPackageManager::~pkgPackageManager()
  60 {
  61    delete List;
  62    delete [] FileNames;
  63 }
  64                                                                         /*}}}*/
  65 // PM::GetArchives - Queue the archives for download                    /*{{{*/
  66 // ---------------------------------------------------------------------
  67 /* */
  68 bool pkgPackageManager::GetArchives(pkgAcquire *Owner,pkgSourceList *Sources,
  69                                     pkgRecords *Recs)
  70 {
  71    if (CreateOrderList() == false)
  72       return false;
  73
  74    bool const ordering =
  75         _config->FindB("PackageManager::UnpackAll",true) ?
  76                 List->OrderUnpack() : List->OrderCritical();
  77    if (ordering == false)
  78       return _error->Error("Internal ordering error");
  79
  80    for (pkgOrderList::iterator I = List->begin(); I != List->end(); ++I)
  81    {
  82       PkgIterator Pkg(Cache,*I);
  83       FileNames[Pkg->ID] = string();
  84
  85       // Skip packages to erase
  86       if (Cache[Pkg].Delete() == true)
  87          continue;
  88
  89       // Skip Packages that need configure only.
  90       if (Pkg.State() == pkgCache::PkgIterator::NeedsConfigure &&
  91           Cache[Pkg].Keep() == true)
  92          continue;
  93
  94       // Skip already processed packages
  95       if (List->IsNow(Pkg) == false)
  96          continue;
  97
  98       new pkgAcqArchive(Owner,Sources,Recs,Cache[Pkg].InstVerIter(Cache),
  99                         FileNames[Pkg->ID]);
 100    }
 101
 102    return true;
 103 }
 104                                                                         /*}}}*/
 105 // PM::FixMissing - Keep all missing packages                           /*{{{*/
 106 // ---------------------------------------------------------------------
 107 /* This is called to correct the installation when packages could not
 108    be downloaded. */
 109 bool pkgPackageManager::FixMissing()
 110 {
 111    pkgDepCache::ActionGroup group(Cache);
 112    pkgProblemResolver Resolve(&Cache);
 113    List->SetFileList(FileNames);
 114
 115    bool Bad = false;
 116    for (PkgIterator I = Cache.PkgBegin(); I.end() == false; ++I)
 117    {
 118       if (List->IsMissing(I) == false)
 119          continue;
 120
 121       // Okay, this file is missing and we need it. Mark it for keep
 122       Bad = true;
 123       Cache.MarkKeep(I, false, false);
 124    }
 125
 126    // We have to empty the list otherwise it will not have the new changes
 127    delete List;
 128    List = 0;
 129
 130    if (Bad == false)
 131       return true;
 132
 133    // Now downgrade everything that is broken
 134    return Resolve.ResolveByKeep() == true && Cache.BrokenCount() == 0;
 135 }
 136                                                                         /*}}}*/
 137 // PM::ImmediateAdd - Add the immediate flag recursivly                 /*{{{*/
 138 // ---------------------------------------------------------------------
 139 /* This adds the immediate flag to the pkg and recursively to the
 140    dependencies
 141  */
 142 void pkgPackageManager::ImmediateAdd(PkgIterator I, bool UseInstallVer, unsigned const int &Depth)
 143 {
 144    DepIterator D;
 145
 146    if(UseInstallVer)
 147    {
 148       if(Cache[I].InstallVer == 0)
 149          return;
 150       D = Cache[I].InstVerIter(Cache).DependsList();
 151    } else {
 152       if (I->CurrentVer == 0)
 153          return;
 154       D = I.CurrentVer().DependsList();
 155    }
 156
 157    for ( /* nothing */  ; D.end() == false; ++D)
 158       if (D->Type == pkgCache::Dep::Depends || D->Type == pkgCache::Dep::PreDepends)
 159       {
 160          if(!List->IsFlag(D.TargetPkg(), pkgOrderList::Immediate))
 161          {
 162             if(Debug)
 163                clog << OutputInDepth(Depth) << "ImmediateAdd(): Adding Immediate flag to " << APT::PrettyPkg(&Cache, D.TargetPkg()) << " cause of " << D.DepType() << " " << I.FullName() << endl;
 164             List->Flag(D.TargetPkg(),pkgOrderList::Immediate);
 165             ImmediateAdd(D.TargetPkg(), UseInstallVer, Depth + 1);
 166          }
 167       }
 168    return;
 169 }
 170                                                                         /*}}}*/
 171 // PM::CreateOrderList - Create the ordering class                      /*{{{*/
 172 // ---------------------------------------------------------------------
 173 /* This populates the ordering list with all the packages that are
 174    going to change. */
 175 bool pkgPackageManager::CreateOrderList()
 176 {
 177    if (List != 0)
 178       return true;
 179
 180    delete List;
 181    List = new pkgOrderList(&Cache);
 182
 183    if (Debug && ImmConfigureAll)
 184       clog << "CreateOrderList(): Adding Immediate flag for all packages because of APT::Immediate-Configure-All" << endl;
 185
 186    // Generate the list of affected packages and sort it
 187    for (PkgIterator I = Cache.PkgBegin(); I.end() == false; ++I)
 188    {
 189       // Ignore no-version packages
 190       if (I->VersionList == 0)
 191          continue;
 192
 193       // Mark the package and its dependents for immediate configuration
 194       if ((((I->Flags & pkgCache::Flag::Essential) == pkgCache::Flag::Essential) &&
 195           NoImmConfigure == false) || ImmConfigureAll)
 196       {
 197          if(Debug && !ImmConfigureAll)
 198             clog << "CreateOrderList(): Adding Immediate flag for " << I.FullName() << endl;
 199          List->Flag(I,pkgOrderList::Immediate);
 200
 201          if (!ImmConfigureAll) {
 202             // Look for other install packages to make immediate configurea
 203             ImmediateAdd(I, true);
 204
 205             // And again with the current version.
 206             ImmediateAdd(I, false);
 207          }
 208       }
 209
 210       // Not interesting
 211       if ((Cache[I].Keep() == true ||
 212           Cache[I].InstVerIter(Cache) == I.CurrentVer()) &&
 213           I.State() == pkgCache::PkgIterator::NeedsNothing &&
 214           (Cache[I].iFlags & pkgDepCache::ReInstall) != pkgDepCache::ReInstall &&
 215           (I.Purge() != false || Cache[I].Mode != pkgDepCache::ModeDelete ||
 216            (Cache[I].iFlags & pkgDepCache::Purge) != pkgDepCache::Purge))
 217          continue;
 218
 219       // Append it to the list
 220       List->push_back(I);
 221    }
 222
 223    return true;
 224 }
 225                                                                         /*}}}*/
 226 // PM::DepAlwaysTrue - Returns true if this dep is irrelevant           /*{{{*/
 227 // ---------------------------------------------------------------------
 228 /* The restriction on provides is to eliminate the case when provides
 229    are transitioning between valid states [ie exim to smail] */
 230 bool pkgPackageManager::DepAlwaysTrue(DepIterator D)
 231 {
 232    if (D.TargetPkg()->ProvidesList != 0)
 233       return false;
 234
 235    if ((Cache[D] & pkgDepCache::DepInstall) != 0 &&
 236        (Cache[D] & pkgDepCache::DepNow) != 0)
 237       return true;
 238    return false;
 239 }
 240                                                                         /*}}}*/
 241 // PM::CheckRConflicts - Look for reverse conflicts                     /*{{{*/
 242 // ---------------------------------------------------------------------
 243 /* This looks over the reverses for a conflicts line that needs early
 244    removal. */
 245 bool pkgPackageManager::CheckRConflicts(PkgIterator Pkg,DepIterator D,
 246                                         const char *Ver)
 247 {
 248    for (;D.end() == false; ++D)
 249    {
 250       if (D->Type != pkgCache::Dep::Conflicts &&
 251           D->Type != pkgCache::Dep::Obsoletes)
 252          continue;
 253
 254       // The package hasn't been changed
 255       if (List->IsNow(Pkg) == false)
 256          continue;
 257
 258       // Ignore self conflicts, ignore conflicts from irrelevant versions
 259       if (D.IsIgnorable(Pkg) || D.ParentVer() != D.ParentPkg().CurrentVer())
 260          continue;
 261
 262       if (Cache.VS().CheckDep(Ver,D->CompareOp,D.TargetVer()) == false)
 263          continue;
 264
 265       if (EarlyRemove(D.ParentPkg(), &D) == false)
 266          return _error->Error("Reverse conflicts early remove for package '%s' failed",
 267                               Pkg.FullName().c_str());
 268    }
 269    return true;
 270 }
 271                                                                         /*}}}*/
 272 // PM::CheckRBreaks - Look for reverse breaks                           /*{{{*/
 273 bool pkgPackageManager::CheckRBreaks(PkgIterator const &Pkg, DepIterator D,
 274                                      const char * const Ver)
 275 {
 276    for (;D.end() == false; ++D)
 277    {
 278       if (D->Type != pkgCache::Dep::DpkgBreaks)
 279          continue;
 280
 281       PkgIterator const DP = D.ParentPkg();
 282       if (Cache[DP].Delete() == false)
 283          continue;
 284
 285       // Ignore self conflicts, ignore conflicts from irrelevant versions
 286       if (D.IsIgnorable(Pkg) || D.ParentVer() != DP.CurrentVer())
 287          continue;
 288
 289       if (Cache.VS().CheckDep(Ver, D->CompareOp, D.TargetVer()) == false)
 290          continue;
 291
 292       // no earlyremove() here as user has already agreed to the permanent removal
 293       if (SmartRemove(DP) == false)
 294          return _error->Error("Internal Error, Could not early remove %s (%d)",DP.FullName().c_str(), 4);
 295    }
 296    return true;
 297 }
 298                                                                         /*}}}*/
 299 // PM::ConfigureAll - Run the all out configuration                     /*{{{*/
 300 // ---------------------------------------------------------------------
 301 /* This configures every package. It is assumed they are all unpacked and
 302    that the final configuration is valid. This is also used to catch packages
 303    that have not been configured when using ImmConfigureAll */
 304 bool pkgPackageManager::ConfigureAll()
 305 {
 306    pkgOrderList OList(&Cache);
 307
 308    // Populate the order list
 309    for (pkgOrderList::iterator I = List->begin(); I != List->end(); ++I)
 310       if (List->IsFlag(pkgCache::PkgIterator(Cache,*I),
 311                        pkgOrderList::UnPacked) == true)
 312          OList.push_back(*I);
 313
 314    if (OList.OrderConfigure() == false)
 315       return false;
 316
 317    std::string const conf = _config->Find("PackageManager::Configure","all");
 318    bool const ConfigurePkgs = (conf == "all");
 319
 320    // Perform the configuring
 321    for (pkgOrderList::iterator I = OList.begin(); I != OList.end(); ++I)
 322    {
 323       PkgIterator Pkg(Cache,*I);
 324
 325       /* Check if the package has been configured, this can happen if SmartConfigure
 326          calls its self */
 327       if (List->IsFlag(Pkg,pkgOrderList::Configured)) continue;
 328
 329       if (ConfigurePkgs == true && SmartConfigure(Pkg, 0) == false) {
 330          if (ImmConfigureAll)
 331             _error->Error(_("Could not perform immediate configuration on '%s'. "
 332                         "Please see man 5 apt.conf under APT::Immediate-Configure for details. (%d)"),Pkg.FullName().c_str(),1);
 333          else
 334             _error->Error("Internal error, packages left unconfigured. %s",Pkg.FullName().c_str());
 335          return false;
 336       }
 337
 338       List->Flag(Pkg,pkgOrderList::Configured,pkgOrderList::States);
 339    }
 340
 341    return true;
 342 }
 343                                                                         /*}}}*/
 344 // PM::NonLoopingSmart - helper to avoid loops while calling Smart methods /*{{{*/
 345 // -----------------------------------------------------------------------
 346 /* ensures that a loop of the form A depends B, B depends A (and similar)
 347    is not leading us down into infinite recursion segfault land */
 348 bool pkgPackageManager::NonLoopingSmart(SmartAction const action, pkgCache::PkgIterator &Pkg,
 349       pkgCache::PkgIterator DepPkg, int const Depth, bool const PkgLoop,
 350       bool * const Bad, bool * const Changed)
 351 {
 352    if (PkgLoop == false)
 353       List->Flag(Pkg,pkgOrderList::Loop);
 354    bool success = false;
 355    switch(action)
 356    {
 357       case UNPACK_IMMEDIATE: success = SmartUnPack(DepPkg, true, Depth + 1); break;
 358       case UNPACK: success = SmartUnPack(DepPkg, false, Depth + 1); break;
 359       case CONFIGURE: success = SmartConfigure(DepPkg, Depth + 1); break;
 360    }
 361    if (PkgLoop == false)
 362       List->RmFlag(Pkg,pkgOrderList::Loop);
 363
 364    if (success == false)
 365       return false;
 366
 367    if (Bad != NULL)
 368       *Bad = false;
 369    if (Changed != NULL && List->IsFlag(DepPkg,pkgOrderList::Loop) == false)
 370       *Changed = true;
 371    return true;
 372 }
 373                                                                         /*}}}*/
 374 // PM::SmartConfigure - Perform immediate configuration of the pkg      /*{{{*/
 375 // ---------------------------------------------------------------------
 376 /* This function tries to put the system in a state where Pkg can be configured.
 377    This involves checking each of Pkg's dependencies and unpacking and
 378    configuring packages where needed. */
 379 bool pkgPackageManager::SmartConfigure(PkgIterator Pkg, int const Depth)
 380 {
 381    // If this is true, only check and correct and dependencies without the Loop flag
 382    bool const PkgLoop = List->IsFlag(Pkg,pkgOrderList::Loop);
 383
 384    if (Debug) {
 385       VerIterator InstallVer = VerIterator(Cache,Cache[Pkg].InstallVer);
 386       clog << OutputInDepth(Depth) << "SmartConfigure " << Pkg.FullName() << " (" << InstallVer.VerStr() << ")";
 387       if (PkgLoop)
 388         clog << " (Only Correct Dependencies)";
 389       clog << endl;
 390    }
 391
 392    VerIterator const instVer = Cache[Pkg].InstVerIter(Cache);
 393
 394    /* Because of the ordered list, most dependencies should be unpacked,
 395       however if there is a loop (A depends on B, B depends on A) this will not
 396       be the case, so check for dependencies before configuring. */
 397    bool Bad = false, Changed = false;
 398    const unsigned int max_loops = _config->FindI("APT::pkgPackageManager::MaxLoopCount", 5000);
 399    unsigned int i=0;
 400    std::list<DepIterator> needConfigure;
 401    do
 402    {
 403       // Check each dependency and see if anything needs to be done
 404       // so that it can be configured
 405       Changed = false;
 406       for (DepIterator D = instVer.DependsList(); D.end() == false; )
 407       {
 408          // Compute a single dependency element (glob or)
 409          pkgCache::DepIterator Start, End;
 410          D.GlobOr(Start,End);
 411
 412          if (End->Type != pkgCache::Dep::Depends && End->Type != pkgCache::Dep::PreDepends)
 413             continue;
 414          Bad = true;
 415
 416          // the first pass checks if we its all good, i.e. if we have
 417          // to do anything at all
 418          for (DepIterator Cur = Start; true; ++Cur)
 419          {
 420             std::unique_ptr<Version *[]> VList(Cur.AllTargets());
 421
 422             for (Version **I = VList.get(); *I != 0; ++I)
 423             {
 424                VerIterator Ver(Cache,*I);
 425                PkgIterator DepPkg = Ver.ParentPkg();
 426
 427                // Check if the current version of the package is available and will satisfy this dependency
 428                if (DepPkg.CurrentVer() == Ver && List->IsNow(DepPkg) == true &&
 429                    List->IsFlag(DepPkg,pkgOrderList::Removed) == false &&
 430                    DepPkg.State() == PkgIterator::NeedsNothing &&
 431                    (Cache[DepPkg].iFlags & pkgDepCache::ReInstall) != pkgDepCache::ReInstall)
 432                {
 433                   Bad = false;
 434                   break;
 435                }
 436
 437                // Check if the version that is going to be installed will satisfy the dependency
 438                if (Cache[DepPkg].InstallVer != *I || List->IsNow(DepPkg) == false)
 439                   continue;
 440
 441                if (PkgLoop == true)
 442                {
 443                   if (Debug)
 444                      std::clog << OutputInDepth(Depth) << "Package " << APT::PrettyPkg(&Cache, Pkg) << " loops in SmartConfigure";
 445                   if (List->IsFlag(DepPkg,pkgOrderList::UnPacked))
 446                      Bad = false;
 447                   else if (Debug)
 448                      std::clog << ", but it isn't unpacked yet";
 449                   if (Debug)
 450                      std::clog << std::endl;
 451                }
 452             }
 453
 454             if (Cur == End || Bad == false)
 455                break;
 456          }
 457
 458          // this dependency is in a good state, so we can stop
 459          if (Bad == false)
 460          {
 461             if (Debug)
 462                std::clog << OutputInDepth(Depth) << "Found ok dep " << APT::PrettyPkg(&Cache, Start.TargetPkg()) << std::endl;
 463             continue;
 464          }
 465
 466          // Check for dependencies that have not been unpacked,
 467          // probably due to loops.
 468          for (DepIterator Cur = Start; true; ++Cur)
 469          {
 470             std::unique_ptr<Version *[]> VList(Cur.AllTargets());
 471
 472             for (Version **I = VList.get(); *I != 0; ++I)
 473             {
 474                VerIterator Ver(Cache,*I);
 475                PkgIterator DepPkg = Ver.ParentPkg();
 476
 477                // Check if the current version of the package is available and will satisfy this dependency
 478                if (DepPkg.CurrentVer() == Ver && List->IsNow(DepPkg) == true &&
 479                    List->IsFlag(DepPkg,pkgOrderList::Removed) == false &&
 480                    DepPkg.State() == PkgIterator::NeedsNothing &&
 481                    (Cache[DepPkg].iFlags & pkgDepCache::ReInstall) != pkgDepCache::ReInstall)
 482                   continue;
 483
 484                // Check if the version that is going to be installed will satisfy the dependency
 485                if (Cache[DepPkg].InstallVer != *I || List->IsNow(DepPkg) == false)
 486                   continue;
 487
 488                if (PkgLoop == true)
 489                {
 490                   if (Debug)
 491                      std::clog << OutputInDepth(Depth) << "Package " << APT::PrettyPkg(&Cache, Pkg) << " loops in SmartConfigure";
 492                   if (List->IsFlag(DepPkg,pkgOrderList::UnPacked))
 493                      Bad = false;
 494                   else if (Debug)
 495                      std::clog << ", but it isn't unpacked yet";
 496                   if (Debug)
 497                      std::clog << std::endl;
 498                }
 499                else
 500                {
 501                   if (Debug)
 502                      clog << OutputInDepth(Depth) << "Unpacking " << DepPkg.FullName() << " to avoid loop " << APT::PrettyDep(&Cache, Cur) << endl;
 503                   if (NonLoopingSmart(UNPACK_IMMEDIATE, Pkg, DepPkg, Depth, PkgLoop, &Bad, &Changed) == false)
 504                      return false;
 505                }
 506                // at this point we either unpacked a Dep or we are in a loop,
 507                // no need to unpack a second one
 508                break;
 509             }
 510
 511             if (Cur == End || Bad == false)
 512                break;
 513          }
 514
 515          if (Bad == false)
 516             continue;
 517
 518          needConfigure.push_back(Start);
 519       }
 520       if (i++ > max_loops)
 521          return _error->Error("Internal error: MaxLoopCount reached in SmartUnPack (1) for %s, aborting", Pkg.FullName().c_str());
 522    } while (Changed == true);
 523
 524    // now go over anything that needs configuring
 525    Bad = false, Changed = false, i = 0;
 526    do
 527    {
 528       Changed = false;
 529       for (std::list<DepIterator>::const_iterator D = needConfigure.begin(); D != needConfigure.end(); ++D)
 530       {
 531          // Compute a single dependency element (glob or) without modifying D
 532          pkgCache::DepIterator Start, End;
 533          {
 534             pkgCache::DepIterator Discard = *D;
 535             Discard.GlobOr(Start,End);
 536          }
 537
 538          if (End->Type != pkgCache::Dep::Depends && End->Type != pkgCache::Dep::PreDepends)
 539             continue;
 540          Bad = true;
 541
 542          // Search for dependencies which are unpacked but aren't configured yet (maybe loops)
 543          for (DepIterator Cur = Start; true; ++Cur)
 544          {
 545             std::unique_ptr<Version *[]> VList(Cur.AllTargets());
 546
 547             for (Version **I = VList.get(); *I != 0; ++I)
 548             {
 549                VerIterator Ver(Cache,*I);
 550                PkgIterator DepPkg = Ver.ParentPkg();
 551
 552                // Check if the version that is going to be installed will satisfy the dependency
 553                if (Cache[DepPkg].InstallVer != *I)
 554                   continue;
 555
 556                if (List->IsFlag(DepPkg,pkgOrderList::UnPacked))
 557                {
 558                   if (List->IsFlag(DepPkg,pkgOrderList::Loop) && PkgLoop)
 559                   {
 560                     // This dependency has already been dealt with by another SmartConfigure on Pkg
 561                     Bad = false;
 562                     break;
 563                   }
 564                   if (Debug)
 565                      std::clog << OutputInDepth(Depth) << "Configure already unpacked " << APT::PrettyPkg(&Cache, DepPkg) << std::endl;
 566                   if (NonLoopingSmart(CONFIGURE, Pkg, DepPkg, Depth, PkgLoop, &Bad, &Changed) == false)
 567                      return false;
 568                   break;
 569
 570                }
 571                else if (List->IsFlag(DepPkg,pkgOrderList::Configured))
 572                {
 573                   Bad = false;
 574                   break;
 575                }
 576             }
 577             if (Cur == End || Bad == false)
 578                break;
 579          }
 580
 581
 582          if (Bad == true && Changed == false && Debug == true)
 583             std::clog << OutputInDepth(Depth) << "Could not satisfy " << APT::PrettyDep(&Cache, *D) << std::endl;
 584       }
 585       if (i++ > max_loops)
 586          return _error->Error("Internal error: MaxLoopCount reached in SmartUnPack (2) for %s, aborting", Pkg.FullName().c_str());
 587    } while (Changed == true);
 588
 589    if (Bad == true)
 590       return _error->Error(_("Could not configure '%s'. "),Pkg.FullName().c_str());
 591
 592    // Check for reverse conflicts.
 593    if (CheckRBreaks(Pkg,Pkg.RevDependsList(), instVer.VerStr()) == false)
 594       return false;
 595
 596    for (PrvIterator P = instVer.ProvidesList(); P.end() == false; ++P)
 597       if (Pkg->Group != P.OwnerPkg()->Group)
 598          CheckRBreaks(Pkg,P.ParentPkg().RevDependsList(),P.ProvideVersion());
 599
 600    if (PkgLoop) return true;
 601
 602    static std::string const conf = _config->Find("PackageManager::Configure","all");
 603    static bool const ConfigurePkgs = (conf == "all" || conf == "smart");
 604
 605    if (List->IsFlag(Pkg,pkgOrderList::Configured))
 606       return _error->Error("Internal configure error on '%s'.", Pkg.FullName().c_str());
 607
 608    if (ConfigurePkgs == true && Configure(Pkg) == false)
 609       return false;
 610
 611    List->Flag(Pkg,pkgOrderList::Configured,pkgOrderList::States);
 612
 613    if ((Cache[Pkg].InstVerIter(Cache)->MultiArch & pkgCache::Version::Same) == pkgCache::Version::Same)
 614       for (PkgIterator P = Pkg.Group().PackageList();
 615            P.end() == false; P = Pkg.Group().NextPkg(P))
 616       {
 617          if (Pkg == P || List->IsFlag(P,pkgOrderList::Configured) == true ||
 618              List->IsFlag(P,pkgOrderList::UnPacked) == false ||
 619              Cache[P].InstallVer == 0 || (P.CurrentVer() == Cache[P].InstallVer &&
 620               (Cache[Pkg].iFlags & pkgDepCache::ReInstall) != pkgDepCache::ReInstall))
 621             continue;
 622          if (SmartConfigure(P, (Depth +1)) == false)
 623             return false;
 624       }
 625
 626    // Sanity Check
 627    if (List->IsFlag(Pkg,pkgOrderList::Configured) == false)
 628       return _error->Error(_("Could not configure '%s'. "),Pkg.FullName().c_str());
 629
 630    return true;
 631 }
 632                                                                         /*}}}*/
 633 // PM::EarlyRemove - Perform removal of packages before their time      /*{{{*/
 634 // ---------------------------------------------------------------------
 635 /* This is called to deal with conflicts arising from unpacking */
 636 bool pkgPackageManager::EarlyRemove(PkgIterator Pkg)
 637 {
 638    return EarlyRemove(Pkg, NULL);
 639 }
 640 bool pkgPackageManager::EarlyRemove(PkgIterator Pkg, DepIterator const * const Dep)
 641 {
 642    if (List->IsNow(Pkg) == false)
 643       return true;
 644
 645    // Already removed it
 646    if (List->IsFlag(Pkg,pkgOrderList::Removed) == true)
 647       return true;
 648
 649    // Woops, it will not be re-installed!
 650    if (List->IsFlag(Pkg,pkgOrderList::InList) == false)
 651       return false;
 652
 653    // these breaks on M-A:same packages can be dealt with. They 'loop' by design
 654    if (Dep != NULL && (*Dep)->Type == pkgCache::Dep::DpkgBreaks && Dep->IsMultiArchImplicit() == true)
 655       return true;
 656
 657    // Essential packages get special treatment
 658    bool IsEssential = false;
 659    if ((Pkg->Flags & pkgCache::Flag::Essential) != 0 ||
 660        (Pkg->Flags & pkgCache::Flag::Important) != 0)
 661       IsEssential = true;
 662
 663    /* Check for packages that are the dependents of essential packages and
 664       promote them too */
 665    if (Pkg->CurrentVer != 0)
 666    {
 667       for (pkgCache::DepIterator D = Pkg.RevDependsList(); D.end() == false &&
 668            IsEssential == false; ++D)
 669          if (D->Type == pkgCache::Dep::Depends || D->Type == pkgCache::Dep::PreDepends)
 670             if ((D.ParentPkg()->Flags & pkgCache::Flag::Essential) != 0 ||
 671                 (D.ParentPkg()->Flags & pkgCache::Flag::Important) != 0)
 672                IsEssential = true;
 673    }
 674
 675    if (IsEssential == true)
 676    {
 677       if (_config->FindB("APT::Force-LoopBreak",false) == false)
 678          return _error->Error(_("This installation run will require temporarily "
 679                                 "removing the essential package %s due to a "
 680                                 "Conflicts/Pre-Depends loop. This is often bad, "
 681                                 "but if you really want to do it, activate the "
 682                                 "APT::Force-LoopBreak option."),Pkg.FullName().c_str());
 683    }
 684    // dpkg will auto-deconfigure it, no need for the big remove hammer
 685    else if (Dep != NULL && (*Dep)->Type == pkgCache::Dep::DpkgBreaks)
 686       return true;
 687
 688    bool Res = SmartRemove(Pkg);
 689    if (Cache[Pkg].Delete() == false)
 690       List->Flag(Pkg,pkgOrderList::Removed,pkgOrderList::States);
 691
 692    return Res;
 693 }
 694                                                                         /*}}}*/
 695 // PM::SmartRemove - Removal Helper                                     /*{{{*/
 696 // ---------------------------------------------------------------------
 697 /* */
 698 bool pkgPackageManager::SmartRemove(PkgIterator Pkg)
 699 {
 700    if (List->IsNow(Pkg) == false)
 701       return true;
 702
 703    List->Flag(Pkg,pkgOrderList::Configured,pkgOrderList::States);
 704
 705    return Remove(Pkg,(Cache[Pkg].iFlags & pkgDepCache::Purge) == pkgDepCache::Purge);
 706 }
 707                                                                         /*}}}*/
 708 // PM::SmartUnPack - Install helper                                     /*{{{*/
 709 // ---------------------------------------------------------------------
 710 /* This puts the system in a state where it can Unpack Pkg, if Pkg is already
 711    unpacked, or when it has been unpacked, if Immediate==true it configures it. */
 712 bool pkgPackageManager::SmartUnPack(PkgIterator Pkg)
 713 {
 714    return SmartUnPack(Pkg, true, 0);
 715 }
 716 bool pkgPackageManager::SmartUnPack(PkgIterator Pkg, bool const Immediate, int const Depth)
 717 {
 718    bool PkgLoop = List->IsFlag(Pkg,pkgOrderList::Loop);
 719
 720    if (Debug) {
 721       clog << OutputInDepth(Depth) << "SmartUnPack " << Pkg.FullName();
 722       VerIterator InstallVer = VerIterator(Cache,Cache[Pkg].InstallVer);
 723       if (Pkg.CurrentVer() == 0)
 724         clog << " (install version " << InstallVer.VerStr() << ")";
 725       else
 726         clog << " (replace version " << Pkg.CurrentVer().VerStr() << " with " << InstallVer.VerStr() << ")";
 727       if (PkgLoop)
 728         clog << " (Only Perform PreUnpack Checks)";
 729       if (Immediate)
 730          clog << " immediately";
 731       clog << endl;
 732    }
 733
 734    VerIterator const instVer = Cache[Pkg].InstVerIter(Cache);
 735
 736    /* PreUnpack Checks: This loop checks and attempts to rectify any problems that would prevent the package being unpacked.
 737       It addresses: PreDepends, Conflicts, Obsoletes and Breaks (DpkgBreaks). Any resolutions that do not require it should
 738       avoid configuration (calling SmartUnpack with Immediate=true), this is because when unpacking some packages with
 739       complex dependency structures, trying to configure some packages while breaking the loops can complicate things.
 740       This will be either dealt with if the package is configured as a dependency of Pkg (if and when Pkg is configured),
 741       or by the ConfigureAll call at the end of the for loop in OrderInstall. */
 742    bool SomethingBad = false, Changed = false;
 743    bool couldBeTemporaryRemoved = Depth != 0 && List->IsFlag(Pkg,pkgOrderList::Removed) == false;
 744    const unsigned int max_loops = _config->FindI("APT::pkgPackageManager::MaxLoopCount", 5000);
 745    unsigned int i = 0;
 746    do
 747    {
 748       Changed = false;
 749       for (DepIterator D = instVer.DependsList(); D.end() == false; )
 750       {
 751          // Compute a single dependency element (glob or)
 752          pkgCache::DepIterator Start, End;
 753          D.GlobOr(Start,End);
 754
 755          if (End->Type == pkgCache::Dep::PreDepends)
 756          {
 757             bool Bad = true;
 758             if (Debug)
 759                clog << OutputInDepth(Depth) << "PreDepends order for " << Pkg.FullName() << std::endl;
 760
 761             // Look for easy targets: packages that are already okay
 762             for (DepIterator Cur = Start; Bad == true; ++Cur)
 763             {
 764                std::unique_ptr<Version *[]> VList(Cur.AllTargets());
 765                for (Version **I = VList.get(); *I != 0; ++I)
 766                {
 767                   VerIterator Ver(Cache,*I);
 768                   PkgIterator Pkg = Ver.ParentPkg();
 769
 770                   // See if the current version is ok
 771                   if (Pkg.CurrentVer() == Ver && List->IsNow(Pkg) == true &&
 772                       Pkg.State() == PkgIterator::NeedsNothing &&
 773                       (Cache[Pkg].iFlags & pkgDepCache::ReInstall) != pkgDepCache::ReInstall)
 774                   {
 775                      Bad = false;
 776                      if (Debug)
 777                         clog << OutputInDepth(Depth) << "Found ok package " << Pkg.FullName() << endl;
 778                      break;
 779                   }
 780                }
 781                if (Cur == End)
 782                   break;
 783             }
 784
 785             // Look for something that could be configured.
 786             for (DepIterator Cur = Start; Bad == true && Cur.end() == false; ++Cur)
 787             {
 788                std::unique_ptr<Version *[]> VList(Cur.AllTargets());
 789                for (Version **I = VList.get(); *I != 0; ++I)
 790                {
 791                   VerIterator Ver(Cache,*I);
 792                   PkgIterator DepPkg = Ver.ParentPkg();
 793
 794                   // Not the install version
 795                   if (Cache[DepPkg].InstallVer != *I)
 796                      continue;
 797
 798                   if (Cache[DepPkg].Keep() == true && DepPkg.State() == PkgIterator::NeedsNothing &&
 799                         (Cache[DepPkg].iFlags & pkgDepCache::ReInstall) != pkgDepCache::ReInstall)
 800                      continue;
 801
 802                   if (List->IsFlag(DepPkg,pkgOrderList::Configured))
 803                   {
 804                      Bad = false;
 805                      break;
 806                   }
 807
 808                   // check if it needs unpack or if if configure is enough
 809                   if (List->IsFlag(DepPkg,pkgOrderList::UnPacked) == false)
 810                   {
 811                      // two packages pre-depending on each other can't be handled sanely
 812                      if (List->IsFlag(DepPkg,pkgOrderList::Loop) && PkgLoop)
 813                      {
 814                         // this isn't an error as there is potential for something else to satisfy it
 815                         // (like a provides or an or-group member)
 816                         if (Debug)
 817                            clog << OutputInDepth(Depth) << "Unpack loop detected between " << DepPkg.FullName() << " and " << Pkg.FullName() << endl;
 818                         continue;
 819                      }
 820
 821                      if (Debug)
 822                         clog << OutputInDepth(Depth) << "Trying to SmartUnpack " << DepPkg.FullName() << endl;
 823                      if (NonLoopingSmart(UNPACK_IMMEDIATE, Pkg, DepPkg, Depth, PkgLoop, &Bad, &Changed) == false)
 824                         return false;
 825                   }
 826                   else
 827                   {
 828                      if (Debug)
 829                         clog << OutputInDepth(Depth) << "Trying to SmartConfigure " << DepPkg.FullName() << endl;
 830                      if (NonLoopingSmart(CONFIGURE, Pkg, DepPkg, Depth, PkgLoop, &Bad, &Changed) == false)
 831                         return false;
 832                   }
 833                   break;
 834                }
 835             }
 836
 837             if (Bad == true)
 838                SomethingBad = true;
 839          }
 840          else if (End->Type == pkgCache::Dep::Conflicts ||
 841                   End->Type == pkgCache::Dep::Obsoletes ||
 842                   End->Type == pkgCache::Dep::DpkgBreaks)
 843          {
 844             std::unique_ptr<Version *[]> VList(End.AllTargets());
 845             for (Version **I = VList.get(); *I != 0; ++I)
 846             {
 847                VerIterator Ver(Cache,*I);
 848                PkgIterator ConflictPkg = Ver.ParentPkg();
 849                if (ConflictPkg.CurrentVer() != Ver)
 850                {
 851                   if (Debug)
 852                      std::clog << OutputInDepth(Depth) << "Ignore not-installed version " << Ver.VerStr() << " of " << ConflictPkg.FullName() << " for " << APT::PrettyDep(&Cache, End) << std::endl;
 853                   continue;
 854                }
 855
 856                if (List->IsNow(ConflictPkg) == false)
 857                {
 858                   if (Debug)
 859                      std::clog << OutputInDepth(Depth) << "Ignore already dealt-with version " << Ver.VerStr() << " of " << ConflictPkg.FullName() << " for " << APT::PrettyDep(&Cache, End) << std::endl;
 860                   continue;
 861                }
 862
 863                if (List->IsFlag(ConflictPkg,pkgOrderList::Removed) == true)
 864                {
 865                   if (Debug)
 866                      clog << OutputInDepth(Depth) << "Ignoring " << APT::PrettyDep(&Cache, End) << " as " << ConflictPkg.FullName() << "was temporarily removed" << endl;
 867                   continue;
 868                }
 869
 870                if (List->IsFlag(ConflictPkg,pkgOrderList::Loop) && PkgLoop)
 871                {
 872                   if (End->Type == pkgCache::Dep::DpkgBreaks && End.IsMultiArchImplicit() == true)
 873                   {
 874                      if (Debug)
 875                         clog << OutputInDepth(Depth) << "Because dependency is MultiArchImplicit we ignored looping on: " << APT::PrettyPkg(&Cache, ConflictPkg) << endl;
 876                      continue;
 877                   }
 878                   if (Debug)
 879                   {
 880                      if (End->Type == pkgCache::Dep::DpkgBreaks)
 881                         clog << OutputInDepth(Depth) << "Because of breaks knot, deconfigure " << ConflictPkg.FullName() << " temporarily" << endl;
 882                      else
 883                         clog << OutputInDepth(Depth) << "Because of conflict knot, removing " << ConflictPkg.FullName() << " temporarily" << endl;
 884                   }
 885                   if (EarlyRemove(ConflictPkg, &End) == false)
 886                      return _error->Error("Internal Error, Could not early remove %s (%d)",ConflictPkg.FullName().c_str(), 3);
 887                   SomethingBad = true;
 888                   continue;
 889                }
 890
 891                if (Cache[ConflictPkg].Delete() == false)
 892                {
 893                   if (Debug)
 894                   {
 895                      clog << OutputInDepth(Depth) << "Unpacking " << ConflictPkg.FullName() << " to avoid " << APT::PrettyDep(&Cache, End);
 896                      if (PkgLoop == true)
 897                         clog << " (Looping)";
 898                      clog << std::endl;
 899                   }
 900                   // we would like to avoid temporary removals and all that at best via a simple unpack
 901                   _error->PushToStack();
 902                   if (NonLoopingSmart(UNPACK, Pkg, ConflictPkg, Depth, PkgLoop, NULL, &Changed) == false)
 903                   {
 904                      // but if it fails ignore this failure and look for alternative ways of solving
 905                      if (Debug)
 906                      {
 907                         clog << OutputInDepth(Depth) << "Avoidance unpack of " << ConflictPkg.FullName() << " failed for " << APT::PrettyDep(&Cache, End) << " ignoring:" << std::endl;
 908                         _error->DumpErrors(std::clog, GlobalError::DEBUG, false);
 909                      }
 910                      _error->RevertToStack();
 911                      // ignorance can only happen if a) one of the offenders is already gone
 912                      if (List->IsFlag(ConflictPkg,pkgOrderList::Removed) == true)
 913                      {
 914                         if (Debug)
 915                            clog << OutputInDepth(Depth) << "But " << ConflictPkg.FullName() << " was temporarily removed in the meantime to satisfy " << APT::PrettyDep(&Cache, End) << endl;
 916                      }
 917                      else if (List->IsFlag(Pkg,pkgOrderList::Removed) == true)
 918                      {
 919                         if (Debug)
 920                            clog << OutputInDepth(Depth) << "But " << Pkg.FullName() << " was temporarily removed in the meantime to satisfy " <<  APT::PrettyDep(&Cache, End) << endl;
 921                      }
 922                      // or b) we can make one go (removal or dpkg auto-deconfigure)
 923                      else
 924                      {
 925                         if (Debug)
 926                            clog << OutputInDepth(Depth) << "So temprorary remove/deconfigure " << ConflictPkg.FullName() << " to satisfy " <<  APT::PrettyDep(&Cache, End) << endl;
 927                         if (EarlyRemove(ConflictPkg, &End) == false)
 928                            return _error->Error("Internal Error, Could not early remove %s (%d)",ConflictPkg.FullName().c_str(), 2);
 929                      }
 930                   }
 931                   else
 932                      _error->MergeWithStack();
 933                }
 934                else
 935                {
 936                   if (Debug)
 937                      clog << OutputInDepth(Depth) << "Removing " << ConflictPkg.FullName() << " now to avoid " << APT::PrettyDep(&Cache, End) << endl;
 938                   // no earlyremove() here as user has already agreed to the permanent removal
 939                   if (SmartRemove(Pkg) == false)
 940                      return _error->Error("Internal Error, Could not early remove %s (%d)",ConflictPkg.FullName().c_str(), 1);
 941                }
 942             }
 943          }
 944       }
 945       if (i++ > max_loops)
 946          return _error->Error("Internal error: APT::pkgPackageManager::MaxLoopCount reached in SmartConfigure for %s, aborting", Pkg.FullName().c_str());
 947    } while (Changed == true);
 948
 949    if (SomethingBad == true)
 950       return _error->Error("Couldn't configure %s, probably a dependency cycle.", Pkg.FullName().c_str());
 951
 952    if (couldBeTemporaryRemoved == true && List->IsFlag(Pkg,pkgOrderList::Removed) == true)
 953    {
 954       if (Debug)
 955          std::clog << OutputInDepth(Depth) << "Prevent unpack as " << APT::PrettyPkg(&Cache, Pkg) << " is currently temporarily removed" << std::endl;
 956       return true;
 957    }
 958
 959    // Check for reverse conflicts.
 960    if (CheckRConflicts(Pkg,Pkg.RevDependsList(),
 961                    instVer.VerStr()) == false)
 962                           return false;
 963
 964    for (PrvIterator P = instVer.ProvidesList();
 965         P.end() == false; ++P)
 966       if (Pkg->Group != P.OwnerPkg()->Group)
 967          CheckRConflicts(Pkg,P.ParentPkg().RevDependsList(),P.ProvideVersion());
 968
 969    if (PkgLoop)
 970       return true;
 971
 972    List->Flag(Pkg,pkgOrderList::UnPacked,pkgOrderList::States);
 973
 974    if (Immediate == true && (instVer->MultiArch & pkgCache::Version::Same) == pkgCache::Version::Same)
 975    {
 976       /* Do lockstep M-A:same unpacking in two phases:
 977          First unpack all installed architectures, then the not installed.
 978          This way we avoid that M-A: enabled packages are installed before
 979          their older non-M-A enabled packages are replaced by newer versions */
 980       bool const installed = Pkg->CurrentVer != 0;
 981       if (installed == true &&
 982           (instVer != Pkg.CurrentVer() ||
 983            ((Cache[Pkg].iFlags & pkgDepCache::ReInstall) == pkgDepCache::ReInstall)) &&
 984           Install(Pkg,FileNames[Pkg->ID]) == false)
 985          return false;
 986       for (PkgIterator P = Pkg.Group().PackageList();
 987            P.end() == false; P = Pkg.Group().NextPkg(P))
 988       {
 989          if (P->CurrentVer == 0 || P == Pkg || List->IsFlag(P,pkgOrderList::UnPacked) == true ||
 990              Cache[P].InstallVer == 0 || (P.CurrentVer() == Cache[P].InstallVer &&
 991               (Cache[Pkg].iFlags & pkgDepCache::ReInstall) != pkgDepCache::ReInstall))
 992             continue;
 993          if (SmartUnPack(P, false, Depth + 1) == false)
 994             return false;
 995       }
 996       if (installed == false && Install(Pkg,FileNames[Pkg->ID]) == false)
 997          return false;
 998       for (PkgIterator P = Pkg.Group().PackageList();
 999            P.end() == false; P = Pkg.Group().NextPkg(P))
1000       {
1001          if (P->CurrentVer != 0 || P == Pkg || List->IsFlag(P,pkgOrderList::UnPacked) == true ||
1002              List->IsFlag(P,pkgOrderList::Configured) == true ||
1003              Cache[P].InstallVer == 0 || (P.CurrentVer() == Cache[P].InstallVer &&
1004               (Cache[Pkg].iFlags & pkgDepCache::ReInstall) != pkgDepCache::ReInstall))
1005             continue;
1006          if (SmartUnPack(P, false, Depth + 1) == false)
1007             return false;
1008       }
1009    }
1010    // packages which are already unpacked don't need to be unpacked again
1011    else if ((instVer != Pkg.CurrentVer() ||
1012              ((Cache[Pkg].iFlags & pkgDepCache::ReInstall) == pkgDepCache::ReInstall)) &&
1013             Install(Pkg,FileNames[Pkg->ID]) == false)
1014       return false;
1015
1016    if (Immediate == true) {
1017       // Perform immedate configuration of the package.
1018          if (SmartConfigure(Pkg, Depth + 1) == false)
1019             _error->Error(_("Could not perform immediate configuration on '%s'. "
1020                "Please see man 5 apt.conf under APT::Immediate-Configure for details. (%d)"),Pkg.FullName().c_str(),2);
1021    }
1022
1023    return true;
1024 }
1025                                                                         /*}}}*/
1026 // PM::OrderInstall - Installation ordering routine                     /*{{{*/
1027 // ---------------------------------------------------------------------
1028 /* */
1029 pkgPackageManager::OrderResult pkgPackageManager::OrderInstall()
1030 {
1031    if (CreateOrderList() == false)
1032       return Failed;
1033
1034    Reset();
1035
1036    if (Debug == true)
1037       clog << "Beginning to order" << endl;
1038
1039    bool const ordering =
1040         _config->FindB("PackageManager::UnpackAll",true) ?
1041                 List->OrderUnpack(FileNames) : List->OrderCritical();
1042    if (ordering == false)
1043    {
1044       _error->Error("Internal ordering error");
1045       return Failed;
1046    }
1047
1048    if (Debug == true)
1049       clog << "Done ordering" << endl;
1050
1051    bool DoneSomething = false;
1052    for (pkgOrderList::iterator I = List->begin(); I != List->end(); ++I)
1053    {
1054       PkgIterator Pkg(Cache,*I);
1055
1056       if (List->IsNow(Pkg) == false)
1057       {
1058          if (Debug == true)
1059             clog << "Skipping already done " << Pkg.FullName() << endl;
1060          continue;
1061       }
1062
1063       if (List->IsMissing(Pkg) == true)
1064       {
1065          if (Debug == true)
1066             clog << "Sequence completed at " << Pkg.FullName() << endl;
1067          if (DoneSomething == false)
1068          {
1069             _error->Error("Internal Error, ordering was unable to handle the media swap");
1070             return Failed;
1071          }
1072          return Incomplete;
1073       }
1074
1075       // Sanity check
1076       if (Cache[Pkg].Keep() == true &&
1077           Pkg.State() == pkgCache::PkgIterator::NeedsNothing &&
1078           (Cache[Pkg].iFlags & pkgDepCache::ReInstall) != pkgDepCache::ReInstall)
1079       {
1080          _error->Error("Internal Error, trying to manipulate a kept package (%s)",Pkg.FullName().c_str());
1081          return Failed;
1082       }
1083
1084       // Perform a delete or an install
1085       if (Cache[Pkg].Delete() == true)
1086       {
1087          if (SmartRemove(Pkg) == false)
1088             return Failed;
1089       }
1090       else
1091          if (SmartUnPack(Pkg,List->IsFlag(Pkg,pkgOrderList::Immediate),0) == false)
1092             return Failed;
1093       DoneSomething = true;
1094
1095       if (ImmConfigureAll) {
1096          /* ConfigureAll here to pick up and packages left unconfigured because they were unpacked in the
1097             "PreUnpack Checks" section */
1098          if (!ConfigureAll())
1099             return Failed;
1100       }
1101    }
1102
1103    // Final run through the configure phase
1104    if (ConfigureAll() == false)
1105       return Failed;
1106
1107    // Sanity check
1108    for (pkgOrderList::iterator I = List->begin(); I != List->end(); ++I)
1109    {
1110       if (List->IsFlag(*I,pkgOrderList::Configured) == false)
1111       {
1112          _error->Error("Internal error, packages left unconfigured. %s",
1113                        PkgIterator(Cache,*I).FullName().c_str());
1114          return Failed;
1115       }
1116    }
1117
1118    return Completed;
1119 }
1120 // PM::DoInstallPostFork - compat /*{{{*/
1121 // ---------------------------------------------------------------------
1122                                                                         /*}}}*/
1123 pkgPackageManager::OrderResult
1124 pkgPackageManager::DoInstallPostFork(int statusFd)
1125 {
1126    APT::Progress::PackageManager *progress = new
1127       APT::Progress::PackageManagerProgressFd(statusFd);
1128    pkgPackageManager::OrderResult res = DoInstallPostFork(progress);
1129    delete progress;
1130    return res;
1131 }
1132                                                                         /*}}}*/
1133 // PM::DoInstallPostFork - Does install part that happens after the fork /*{{{*/
1134 // ---------------------------------------------------------------------
1135 pkgPackageManager::OrderResult
1136 pkgPackageManager::DoInstallPostFork(APT::Progress::PackageManager *progress)
1137 {
1138    bool goResult = Go(progress);
1139    if(goResult == false)
1140       return Failed;
1141
1142    return Res;
1143 }
1144                                                                         /*}}}*/
1145 // PM::DoInstall - Does the installation                                /*{{{*/
1146 // ---------------------------------------------------------------------
1147 /* compat */
1148 pkgPackageManager::OrderResult
1149 pkgPackageManager::DoInstall(int statusFd)
1150 {
1151     APT::Progress::PackageManager *progress = new
1152        APT::Progress::PackageManagerProgressFd(statusFd);
1153     OrderResult res = DoInstall(progress);
1154     delete progress;
1155     return res;
1156  }
1157                                                                         /*}}}*/
1158 // PM::DoInstall - Does the installation                                /*{{{*/
1159 // ---------------------------------------------------------------------
1160 /* This uses the filenames in FileNames and the information in the
1161    DepCache to perform the installation of packages.*/
1162 pkgPackageManager::OrderResult
1163 pkgPackageManager::DoInstall(APT::Progress::PackageManager *progress)
1164 {
1165    if(DoInstallPreFork() == Failed)
1166       return Failed;
1167
1168    return DoInstallPostFork(progress);
1169 }
1170                                                                         /*}}}*/