apt-pkg/packagemanager.cc

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