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 #include <apt-pkg/install-progress.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)
  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    dependendies
 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 " << 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 dependends 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::ConfigureAll - Run the all out configuration                     /*{{{*/
 273 // ---------------------------------------------------------------------
 274 /* This configures every package. It is assumed they are all unpacked and
 275    that the final configuration is valid. This is also used to catch packages
 276    that have not been configured when using ImmConfigureAll */
 277 bool pkgPackageManager::ConfigureAll()
 278 {
 279    pkgOrderList OList(&Cache);
 280
 281    // Populate the order list
 282    for (pkgOrderList::iterator I = List->begin(); I != List->end(); ++I)
 283       if (List->IsFlag(pkgCache::PkgIterator(Cache,*I),
 284                        pkgOrderList::UnPacked) == true)
 285          OList.push_back(*I);
 286
 287    if (OList.OrderConfigure() == false)
 288       return false;
 289
 290    std::string const conf = _config->Find("PackageManager::Configure","all");
 291    bool const ConfigurePkgs = (conf == "all");
 292
 293    // Perform the configuring
 294    for (pkgOrderList::iterator I = OList.begin(); I != OList.end(); ++I)
 295    {
 296       PkgIterator Pkg(Cache,*I);
 297
 298       /* Check if the package has been configured, this can happen if SmartConfigure
 299          calls its self */
 300       if (List->IsFlag(Pkg,pkgOrderList::Configured)) continue;
 301
 302       if (ConfigurePkgs == true && SmartConfigure(Pkg, 0) == false) {
 303          if (ImmConfigureAll)
 304             _error->Error(_("Could not perform immediate configuration on '%s'. "
 305                         "Please see man 5 apt.conf under APT::Immediate-Configure for details. (%d)"),Pkg.FullName().c_str(),1);
 306          else
 307             _error->Error("Internal error, packages left unconfigured. %s",Pkg.FullName().c_str());
 308          return false;
 309       }
 310
 311       List->Flag(Pkg,pkgOrderList::Configured,pkgOrderList::States);
 312    }
 313
 314    return true;
 315 }
 316                                                                         /*}}}*/
 317 // PM::NonLoopingSmart - helper to avoid loops while calling Smart methods /*{{{*/
 318 // -----------------------------------------------------------------------
 319 /* ensures that a loop of the form A depends B, B depends A (and similar)
 320    is not leading us down into infinite recursion segfault land */
 321 bool pkgPackageManager::NonLoopingSmart(SmartAction const action, pkgCache::PkgIterator &Pkg,
 322       pkgCache::PkgIterator DepPkg, int const Depth, bool const PkgLoop,
 323       bool * const Bad, bool * const Changed)
 324 {
 325    if (PkgLoop == false)
 326       List->Flag(Pkg,pkgOrderList::Loop);
 327    bool success = false;
 328    switch(action)
 329    {
 330       case UNPACK_IMMEDIATE: success = SmartUnPack(DepPkg, true, Depth + 1); break;
 331       case UNPACK: success = SmartUnPack(DepPkg, false, Depth + 1); break;
 332       case CONFIGURE: success = SmartConfigure(DepPkg, Depth + 1); break;
 333    }
 334    if (PkgLoop == false)
 335       List->RmFlag(Pkg,pkgOrderList::Loop);
 336
 337    if (success == false)
 338       return false;
 339
 340    if (Bad != NULL)
 341       *Bad = false;
 342    if (Changed != NULL && List->IsFlag(DepPkg,pkgOrderList::Loop) == false)
 343       *Changed = true;
 344    return true;
 345 }
 346                                                                         /*}}}*/
 347 // PM::SmartConfigure - Perform immediate configuration of the pkg      /*{{{*/
 348 // ---------------------------------------------------------------------
 349 /* This function tries to put the system in a state where Pkg can be configured.
 350    This involves checking each of Pkg's dependencies and unpacking and
 351    configuring packages where needed. */
 352 bool pkgPackageManager::SmartConfigure(PkgIterator Pkg, int const Depth)
 353 {
 354    // If this is true, only check and correct and dependencies without the Loop flag
 355    bool const PkgLoop = List->IsFlag(Pkg,pkgOrderList::Loop);
 356
 357    if (Debug) {
 358       VerIterator InstallVer = VerIterator(Cache,Cache[Pkg].InstallVer);
 359       clog << OutputInDepth(Depth) << "SmartConfigure " << Pkg.FullName() << " (" << InstallVer.VerStr() << ")";
 360       if (PkgLoop)
 361         clog << " (Only Correct Dependencies)";
 362       clog << endl;
 363    }
 364
 365    VerIterator const instVer = Cache[Pkg].InstVerIter(Cache);
 366
 367    /* Because of the ordered list, most dependencies should be unpacked,
 368       however if there is a loop (A depends on B, B depends on A) this will not
 369       be the case, so check for dependencies before configuring. */
 370    bool Bad = false, Changed = false;
 371    const unsigned int max_loops = _config->FindI("APT::pkgPackageManager::MaxLoopCount", 5000);
 372    unsigned int i=0;
 373    std::list<DepIterator> needConfigure;
 374    do
 375    {
 376       Changed = false;
 377       for (DepIterator D = instVer.DependsList(); D.end() == false; )
 378       {
 379          // Compute a single dependency element (glob or)
 380          pkgCache::DepIterator Start, End;
 381          D.GlobOr(Start,End);
 382
 383          if (End->Type != pkgCache::Dep::Depends)
 384             continue;
 385          Bad = true;
 386
 387          // Check for dependencies that have not been unpacked, probably due to loops.
 388          for (DepIterator Cur = Start; true; ++Cur)
 389          {
 390             SPtrArray<Version *> VList = Cur.AllTargets();
 391
 392             for (Version **I = VList; *I != 0; ++I)
 393             {
 394                VerIterator Ver(Cache,*I);
 395                PkgIterator DepPkg = Ver.ParentPkg();
 396
 397                // Check if the current version of the package is available and will satisfy this dependency
 398                if (DepPkg.CurrentVer() == Ver && List->IsNow(DepPkg) == true &&
 399                    List->IsFlag(DepPkg,pkgOrderList::Removed) == false &&
 400                    DepPkg.State() == PkgIterator::NeedsNothing)
 401                {
 402                   Bad = false;
 403                   break;
 404                }
 405
 406                // Check if the version that is going to be installed will satisfy the dependency
 407                if (Cache[DepPkg].InstallVer != *I || List->IsNow(DepPkg) == false)
 408                   continue;
 409
 410                if (PkgLoop == true)
 411                {
 412                   if (Debug)
 413                      std::clog << OutputInDepth(Depth) << "Package " << Pkg << " loops in SmartConfigure" << std::endl;
 414                   Bad = false;
 415                }
 416                else
 417                {
 418                   if (Debug)
 419                      clog << OutputInDepth(Depth) << "Unpacking " << DepPkg.FullName() << " to avoid loop " << Cur << endl;
 420                   if (NonLoopingSmart(UNPACK_IMMEDIATE, Pkg, DepPkg, Depth, PkgLoop, &Bad, &Changed) == false)
 421                      return false;
 422                }
 423                break;
 424             }
 425
 426             if (Cur == End || Bad == false)
 427                break;
 428          }
 429
 430          if (Bad == false)
 431             continue;
 432
 433          needConfigure.push_back(Start);
 434       }
 435       if (i++ > max_loops)
 436          return _error->Error("Internal error: MaxLoopCount reached in SmartUnPack (1) for %s, aborting", Pkg.FullName().c_str());
 437    } while (Changed == true);
 438
 439    Bad = false, Changed = false, i = 0;
 440    do
 441    {
 442       Changed = false;
 443       for (std::list<DepIterator>::const_iterator D = needConfigure.begin(); D != needConfigure.end(); ++D)
 444       {
 445          // Compute a single dependency element (glob or) without modifying D
 446          pkgCache::DepIterator Start, End;
 447          {
 448             pkgCache::DepIterator Discard = *D;
 449             Discard.GlobOr(Start,End);
 450          }
 451
 452          if (End->Type != pkgCache::Dep::Depends)
 453             continue;
 454          Bad = true;
 455
 456          // Search for dependencies which are unpacked but aren't configured yet (maybe loops)
 457          for (DepIterator Cur = Start; true; ++Cur)
 458          {
 459             SPtrArray<Version *> VList = Cur.AllTargets();
 460
 461             for (Version **I = VList; *I != 0; ++I)
 462             {
 463                VerIterator Ver(Cache,*I);
 464                PkgIterator DepPkg = Ver.ParentPkg();
 465
 466                // Check if the version that is going to be installed will satisfy the dependency
 467                if (Cache[DepPkg].InstallVer != *I)
 468                   continue;
 469
 470                if (List->IsFlag(DepPkg,pkgOrderList::UnPacked))
 471                {
 472                   if (List->IsFlag(DepPkg,pkgOrderList::Loop) && PkgLoop)
 473                   {
 474                     // This dependency has already been dealt with by another SmartConfigure on Pkg
 475                     Bad = false;
 476                     break;
 477                   }
 478                   if (Debug)
 479                      std::clog << OutputInDepth(Depth) << "Configure already unpacked " << DepPkg << std::endl;
 480                   if (NonLoopingSmart(CONFIGURE, Pkg, DepPkg, Depth, PkgLoop, &Bad, &Changed) == false)
 481                      return false;
 482                   break;
 483
 484                }
 485                else if (List->IsFlag(DepPkg,pkgOrderList::Configured))
 486                {
 487                   Bad = false;
 488                   break;
 489                }
 490             }
 491             if (Cur == End || Bad == false)
 492                break;
 493          }
 494
 495
 496          if (Bad == true && Changed == false && Debug == true)
 497             std::clog << OutputInDepth(Depth) << "Could not satisfy " << *D << std::endl;
 498       }
 499       if (i++ > max_loops)
 500          return _error->Error("Internal error: MaxLoopCount reached in SmartUnPack (2) for %s, aborting", Pkg.FullName().c_str());
 501    } while (Changed == true);
 502
 503    if (Bad == true)
 504       return _error->Error(_("Could not configure '%s'. "),Pkg.FullName().c_str());
 505
 506    if (PkgLoop) return true;
 507
 508    static std::string const conf = _config->Find("PackageManager::Configure","all");
 509    static bool const ConfigurePkgs = (conf == "all" || conf == "smart");
 510
 511    if (List->IsFlag(Pkg,pkgOrderList::Configured))
 512       return _error->Error("Internal configure error on '%s'.", Pkg.FullName().c_str());
 513
 514    if (ConfigurePkgs == true && Configure(Pkg) == false)
 515       return false;
 516
 517    List->Flag(Pkg,pkgOrderList::Configured,pkgOrderList::States);
 518
 519    if ((Cache[Pkg].InstVerIter(Cache)->MultiArch & pkgCache::Version::Same) == pkgCache::Version::Same)
 520       for (PkgIterator P = Pkg.Group().PackageList();
 521            P.end() == false; P = Pkg.Group().NextPkg(P))
 522       {
 523          if (Pkg == P || List->IsFlag(P,pkgOrderList::Configured) == true ||
 524              List->IsFlag(P,pkgOrderList::UnPacked) == false ||
 525              Cache[P].InstallVer == 0 || (P.CurrentVer() == Cache[P].InstallVer &&
 526               (Cache[Pkg].iFlags & pkgDepCache::ReInstall) != pkgDepCache::ReInstall))
 527             continue;
 528          if (SmartConfigure(P, (Depth +1)) == false)
 529             return false;
 530       }
 531
 532    // Sanity Check
 533    if (List->IsFlag(Pkg,pkgOrderList::Configured) == false)
 534       return _error->Error(_("Could not configure '%s'. "),Pkg.FullName().c_str());
 535
 536    return true;
 537 }
 538                                                                         /*}}}*/
 539 // PM::EarlyRemove - Perform removal of packages before their time      /*{{{*/
 540 // ---------------------------------------------------------------------
 541 /* This is called to deal with conflicts arising from unpacking */
 542 bool pkgPackageManager::EarlyRemove(PkgIterator Pkg)
 543 {
 544    return EarlyRemove(Pkg, NULL);
 545 }
 546 bool pkgPackageManager::EarlyRemove(PkgIterator Pkg, DepIterator const * const Dep)
 547 {
 548    if (List->IsNow(Pkg) == false)
 549       return true;
 550
 551    // Already removed it
 552    if (List->IsFlag(Pkg,pkgOrderList::Removed) == true)
 553       return true;
 554
 555    // Woops, it will not be re-installed!
 556    if (List->IsFlag(Pkg,pkgOrderList::InList) == false)
 557       return false;
 558
 559    // these breaks on M-A:same packages can be dealt with. They 'loop' by design
 560    if (Dep != NULL && (*Dep)->Type == pkgCache::Dep::DpkgBreaks && Dep->IsMultiArchImplicit() == true)
 561       return true;
 562
 563    // Essential packages get special treatment
 564    bool IsEssential = false;
 565    if ((Pkg->Flags & pkgCache::Flag::Essential) != 0 ||
 566        (Pkg->Flags & pkgCache::Flag::Important) != 0)
 567       IsEssential = true;
 568
 569    /* Check for packages that are the dependents of essential packages and
 570       promote them too */
 571    if (Pkg->CurrentVer != 0)
 572    {
 573       for (pkgCache::DepIterator D = Pkg.RevDependsList(); D.end() == false &&
 574            IsEssential == false; ++D)
 575          if (D->Type == pkgCache::Dep::Depends || D->Type == pkgCache::Dep::PreDepends)
 576             if ((D.ParentPkg()->Flags & pkgCache::Flag::Essential) != 0 ||
 577                 (D.ParentPkg()->Flags & pkgCache::Flag::Important) != 0)
 578                IsEssential = true;
 579    }
 580
 581    if (IsEssential == true)
 582    {
 583       if (_config->FindB("APT::Force-LoopBreak",false) == false)
 584          return _error->Error(_("This installation run will require temporarily "
 585                                 "removing the essential package %s due to a "
 586                                 "Conflicts/Pre-Depends loop. This is often bad, "
 587                                 "but if you really want to do it, activate the "
 588                                 "APT::Force-LoopBreak option."),Pkg.FullName().c_str());
 589    }
 590    // dpkg will auto-deconfigure it, no need for the big remove hammer
 591    else if (Dep != NULL && (*Dep)->Type == pkgCache::Dep::DpkgBreaks)
 592       return true;
 593
 594    bool Res = SmartRemove(Pkg);
 595    if (Cache[Pkg].Delete() == false)
 596       List->Flag(Pkg,pkgOrderList::Removed,pkgOrderList::States);
 597
 598    return Res;
 599 }
 600                                                                         /*}}}*/
 601 // PM::SmartRemove - Removal Helper                                     /*{{{*/
 602 // ---------------------------------------------------------------------
 603 /* */
 604 bool pkgPackageManager::SmartRemove(PkgIterator Pkg)
 605 {
 606    if (List->IsNow(Pkg) == false)
 607       return true;
 608
 609    List->Flag(Pkg,pkgOrderList::Configured,pkgOrderList::States);
 610
 611    return Remove(Pkg,(Cache[Pkg].iFlags & pkgDepCache::Purge) == pkgDepCache::Purge);
 612 }
 613                                                                         /*}}}*/
 614 // PM::SmartUnPack - Install helper                                     /*{{{*/
 615 // ---------------------------------------------------------------------
 616 /* This puts the system in a state where it can Unpack Pkg, if Pkg is already
 617    unpacked, or when it has been unpacked, if Immediate==true it configures it. */
 618 bool pkgPackageManager::SmartUnPack(PkgIterator Pkg)
 619 {
 620    return SmartUnPack(Pkg, true, 0);
 621 }
 622 bool pkgPackageManager::SmartUnPack(PkgIterator Pkg, bool const Immediate, int const Depth)
 623 {
 624    bool PkgLoop = List->IsFlag(Pkg,pkgOrderList::Loop);
 625
 626    if (Debug) {
 627       clog << OutputInDepth(Depth) << "SmartUnPack " << Pkg.FullName();
 628       VerIterator InstallVer = VerIterator(Cache,Cache[Pkg].InstallVer);
 629       if (Pkg.CurrentVer() == 0)
 630         clog << " (install version " << InstallVer.VerStr() << ")";
 631       else
 632         clog << " (replace version " << Pkg.CurrentVer().VerStr() << " with " << InstallVer.VerStr() << ")";
 633       if (PkgLoop)
 634         clog << " (Only Perform PreUnpack Checks)";
 635       if (Immediate)
 636          clog << " immediately";
 637       clog << endl;
 638    }
 639
 640    VerIterator const instVer = Cache[Pkg].InstVerIter(Cache);
 641
 642    /* PreUnpack Checks: This loop checks and attempts to rectify any problems that would prevent the package being unpacked.
 643       It addresses: PreDepends, Conflicts, Obsoletes and Breaks (DpkgBreaks). Any resolutions that do not require it should
 644       avoid configuration (calling SmartUnpack with Immediate=true), this is because when unpacking some packages with
 645       complex dependency structures, trying to configure some packages while breaking the loops can complicate things.
 646       This will be either dealt with if the package is configured as a dependency of Pkg (if and when Pkg is configured),
 647       or by the ConfigureAll call at the end of the for loop in OrderInstall. */
 648    bool SomethingBad = false, Changed = false;
 649    bool couldBeTemporaryRemoved = Depth != 0 && List->IsFlag(Pkg,pkgOrderList::Removed) == false;
 650    const unsigned int max_loops = _config->FindI("APT::pkgPackageManager::MaxLoopCount", 5000);
 651    unsigned int i = 0;
 652    do
 653    {
 654       Changed = false;
 655       for (DepIterator D = instVer.DependsList(); D.end() == false; )
 656       {
 657          // Compute a single dependency element (glob or)
 658          pkgCache::DepIterator Start, End;
 659          D.GlobOr(Start,End);
 660
 661          if (End->Type == pkgCache::Dep::PreDepends)
 662          {
 663             bool Bad = true;
 664             if (Debug)
 665                clog << OutputInDepth(Depth) << "PreDepends order for " << Pkg.FullName() << std::endl;
 666
 667             // Look for easy targets: packages that are already okay
 668             for (DepIterator Cur = Start; Bad == true; ++Cur)
 669             {
 670                SPtrArray<Version *> VList = Cur.AllTargets();
 671                for (Version **I = VList; *I != 0; ++I)
 672                {
 673                   VerIterator Ver(Cache,*I);
 674                   PkgIterator Pkg = Ver.ParentPkg();
 675
 676                   // See if the current version is ok
 677                   if (Pkg.CurrentVer() == Ver && List->IsNow(Pkg) == true &&
 678                       Pkg.State() == PkgIterator::NeedsNothing)
 679                   {
 680                      Bad = false;
 681                      if (Debug)
 682                         clog << OutputInDepth(Depth) << "Found ok package " << Pkg.FullName() << endl;
 683                      break;
 684                   }
 685                }
 686                if (Cur == End)
 687                   break;
 688             }
 689
 690             // Look for something that could be configured.
 691             for (DepIterator Cur = Start; Bad == true && Cur.end() == false; ++Cur)
 692             {
 693                SPtrArray<Version *> VList = Cur.AllTargets();
 694                for (Version **I = VList; *I != 0; ++I)
 695                {
 696                   VerIterator Ver(Cache,*I);
 697                   PkgIterator DepPkg = Ver.ParentPkg();
 698
 699                   // Not the install version
 700                   if (Cache[DepPkg].InstallVer != *I ||
 701                       (Cache[DepPkg].Keep() == true && DepPkg.State() == PkgIterator::NeedsNothing))
 702                      continue;
 703
 704                   if (List->IsFlag(DepPkg,pkgOrderList::Configured))
 705                   {
 706                      Bad = false;
 707                      break;
 708                   }
 709
 710                   // check if it needs unpack or if if configure is enough
 711                   if (List->IsFlag(DepPkg,pkgOrderList::UnPacked) == false)
 712                   {
 713                      if (Debug)
 714                         clog << OutputInDepth(Depth) << "Trying to SmartUnpack " << DepPkg.FullName() << endl;
 715                      if (NonLoopingSmart(UNPACK_IMMEDIATE, Pkg, DepPkg, Depth, PkgLoop, &Bad, &Changed) == false)
 716                         return false;
 717                   }
 718                   else
 719                   {
 720                      if (Debug)
 721                         clog << OutputInDepth(Depth) << "Trying to SmartConfigure " << DepPkg.FullName() << endl;
 722                      if (NonLoopingSmart(CONFIGURE, Pkg, DepPkg, Depth, PkgLoop, &Bad, &Changed) == false)
 723                         return false;
 724                   }
 725                   break;
 726                }
 727             }
 728
 729             if (Bad == true)
 730                SomethingBad = true;
 731          }
 732          else if (End->Type == pkgCache::Dep::Conflicts ||
 733                   End->Type == pkgCache::Dep::Obsoletes ||
 734                   End->Type == pkgCache::Dep::DpkgBreaks)
 735          {
 736             SPtrArray<Version *> VList = End.AllTargets();
 737             for (Version **I = VList; *I != 0; ++I)
 738             {
 739                VerIterator Ver(Cache,*I);
 740                PkgIterator ConflictPkg = Ver.ParentPkg();
 741                if (ConflictPkg.CurrentVer() != Ver)
 742                {
 743                   if (Debug)
 744                      std::clog << OutputInDepth(Depth) << "Ignore not-installed version " << Ver.VerStr() << " of " << ConflictPkg.FullName() << " for " << End << std::endl;
 745                   continue;
 746                }
 747
 748                if (List->IsNow(ConflictPkg) == false)
 749                {
 750                   if (Debug)
 751                      std::clog << OutputInDepth(Depth) << "Ignore already dealt-with version " << Ver.VerStr() << " of " << ConflictPkg.FullName() << " for " << End << std::endl;
 752                   continue;
 753                }
 754
 755                if (List->IsFlag(ConflictPkg,pkgOrderList::Removed) == true)
 756                {
 757                   if (Debug)
 758                      clog << OutputInDepth(Depth) << "Ignoring " << End << " as " << ConflictPkg.FullName() << "was temporarily removed" << endl;
 759                   continue;
 760                }
 761
 762                if (List->IsFlag(ConflictPkg,pkgOrderList::Loop) && PkgLoop)
 763                {
 764                   if (End->Type == pkgCache::Dep::DpkgBreaks && End.IsMultiArchImplicit() == true)
 765                   {
 766                      if (Debug)
 767                         clog << OutputInDepth(Depth) << "Because dependency is MultiArchImplicit we ignored looping on: " << ConflictPkg << endl;
 768                      continue;
 769                   }
 770                   if (Debug)
 771                   {
 772                      if (End->Type == pkgCache::Dep::DpkgBreaks)
 773                         clog << OutputInDepth(Depth) << "Because of breaks knot, deconfigure " << ConflictPkg.FullName() << " temporarily" << endl;
 774                      else
 775                         clog << OutputInDepth(Depth) << "Because of conflict knot, removing " << ConflictPkg.FullName() << " temporarily" << endl;
 776                   }
 777                   if (EarlyRemove(ConflictPkg, &End) == false)
 778                      return _error->Error("Internal Error, Could not early remove %s (2)",ConflictPkg.FullName().c_str());
 779                   SomethingBad = true;
 780                   continue;
 781                }
 782
 783                if (Cache[ConflictPkg].Delete() == false)
 784                {
 785                   if (Debug)
 786                   {
 787                      clog << OutputInDepth(Depth) << "Unpacking " << ConflictPkg.FullName() << " to avoid " << End;
 788                      if (PkgLoop == true)
 789                         clog << " (Looping)";
 790                      clog << std::endl;
 791                   }
 792                   // we would like to avoid temporary removals and all that at best via a simple unpack
 793                   _error->PushToStack();
 794                   if (NonLoopingSmart(UNPACK, Pkg, ConflictPkg, Depth, PkgLoop, NULL, &Changed) == false)
 795                   {
 796                      // but if it fails ignore this failure and look for alternative ways of solving
 797                      if (Debug)
 798                      {
 799                         clog << OutputInDepth(Depth) << "Avoidance unpack of " << ConflictPkg.FullName() << " failed for " << End << std::endl;
 800                         _error->DumpErrors(std::clog);
 801                      }
 802                      _error->RevertToStack();
 803                      // ignorance can only happen if a) one of the offenders is already gone
 804                      if (List->IsFlag(ConflictPkg,pkgOrderList::Removed) == true)
 805                      {
 806                         if (Debug)
 807                            clog << OutputInDepth(Depth) << "But " << ConflictPkg.FullName() << " was temporarily removed in the meantime to satisfy " << End << endl;
 808                      }
 809                      else if (List->IsFlag(Pkg,pkgOrderList::Removed) == true)
 810                      {
 811                         if (Debug)
 812                            clog << OutputInDepth(Depth) << "But " << Pkg.FullName() << " was temporarily removed in the meantime to satisfy " << End << endl;
 813                      }
 814                      // or b) we can make one go (removal or dpkg auto-deconfigure)
 815                      else
 816                      {
 817                         if (Debug)
 818                            clog << OutputInDepth(Depth) << "So temprorary remove/deconfigure " << ConflictPkg.FullName() << " to satisfy " << End << endl;
 819                         if (EarlyRemove(ConflictPkg, &End) == false)
 820                            return _error->Error("Internal Error, Could not early remove %s (2)",ConflictPkg.FullName().c_str());
 821                      }
 822                   }
 823                   else
 824                      _error->MergeWithStack();
 825                }
 826                else
 827                {
 828                   if (Debug)
 829                      clog << OutputInDepth(Depth) << "Removing " << ConflictPkg.FullName() << " now to avoid " << End << endl;
 830                   // no earlyremove() here as user has already agreed to the permanent removal
 831                   if (SmartRemove(Pkg) == false)
 832                      return _error->Error("Internal Error, Could not early remove %s (1)",ConflictPkg.FullName().c_str());
 833                }
 834             }
 835          }
 836       }
 837       if (i++ > max_loops)
 838          return _error->Error("Internal error: APT::pkgPackageManager::MaxLoopCount reached in SmartConfigure for %s, aborting", Pkg.FullName().c_str());
 839    } while (Changed == true);
 840
 841    if (SomethingBad == true)
 842       return _error->Error("Couldn't configure %s, probably a dependency cycle.", Pkg.FullName().c_str());
 843
 844    if (couldBeTemporaryRemoved == true && List->IsFlag(Pkg,pkgOrderList::Removed) == true)
 845    {
 846       if (Debug)
 847          std::clog << OutputInDepth(Depth) << "Prevent unpack as " << Pkg << " is currently temporarily removed" << std::endl;
 848       return true;
 849    }
 850
 851    // Check for reverse conflicts.
 852    if (CheckRConflicts(Pkg,Pkg.RevDependsList(),
 853                    instVer.VerStr()) == false)
 854                           return false;
 855
 856    for (PrvIterator P = instVer.ProvidesList();
 857         P.end() == false; ++P)
 858       if (Pkg->Group != P.OwnerPkg()->Group)
 859          CheckRConflicts(Pkg,P.ParentPkg().RevDependsList(),P.ProvideVersion());
 860
 861    if (PkgLoop)
 862       return true;
 863
 864    List->Flag(Pkg,pkgOrderList::UnPacked,pkgOrderList::States);
 865
 866    if (Immediate == true && (instVer->MultiArch & pkgCache::Version::Same) == pkgCache::Version::Same)
 867    {
 868       /* Do lockstep M-A:same unpacking in two phases:
 869          First unpack all installed architectures, then the not installed.
 870          This way we avoid that M-A: enabled packages are installed before
 871          their older non-M-A enabled packages are replaced by newer versions */
 872       bool const installed = Pkg->CurrentVer != 0;
 873       if (installed == true &&
 874           (instVer != Pkg.CurrentVer() ||
 875            ((Cache[Pkg].iFlags & pkgDepCache::ReInstall) == pkgDepCache::ReInstall)) &&
 876           Install(Pkg,FileNames[Pkg->ID]) == false)
 877          return false;
 878       for (PkgIterator P = Pkg.Group().PackageList();
 879            P.end() == false; P = Pkg.Group().NextPkg(P))
 880       {
 881          if (P->CurrentVer == 0 || P == Pkg || List->IsFlag(P,pkgOrderList::UnPacked) == true ||
 882              Cache[P].InstallVer == 0 || (P.CurrentVer() == Cache[P].InstallVer &&
 883               (Cache[Pkg].iFlags & pkgDepCache::ReInstall) != pkgDepCache::ReInstall))
 884             continue;
 885          if (SmartUnPack(P, false, Depth + 1) == false)
 886             return false;
 887       }
 888       if (installed == false && Install(Pkg,FileNames[Pkg->ID]) == false)
 889          return false;
 890       for (PkgIterator P = Pkg.Group().PackageList();
 891            P.end() == false; P = Pkg.Group().NextPkg(P))
 892       {
 893          if (P->CurrentVer != 0 || P == Pkg || List->IsFlag(P,pkgOrderList::UnPacked) == true ||
 894              List->IsFlag(P,pkgOrderList::Configured) == true ||
 895              Cache[P].InstallVer == 0 || (P.CurrentVer() == Cache[P].InstallVer &&
 896               (Cache[Pkg].iFlags & pkgDepCache::ReInstall) != pkgDepCache::ReInstall))
 897             continue;
 898          if (SmartUnPack(P, false, Depth + 1) == false)
 899             return false;
 900       }
 901    }
 902    // packages which are already unpacked don't need to be unpacked again
 903    else if ((instVer != Pkg.CurrentVer() ||
 904              ((Cache[Pkg].iFlags & pkgDepCache::ReInstall) == pkgDepCache::ReInstall)) &&
 905             Install(Pkg,FileNames[Pkg->ID]) == false)
 906       return false;
 907
 908    if (Immediate == true) {
 909       // Perform immedate configuration of the package.
 910          if (SmartConfigure(Pkg, Depth + 1) == false)
 911             _error->Error(_("Could not perform immediate configuration on '%s'. "
 912                "Please see man 5 apt.conf under APT::Immediate-Configure for details. (%d)"),Pkg.FullName().c_str(),2);
 913    }
 914
 915    return true;
 916 }
 917                                                                         /*}}}*/
 918 // PM::OrderInstall - Installation ordering routine                     /*{{{*/
 919 // ---------------------------------------------------------------------
 920 /* */
 921 pkgPackageManager::OrderResult pkgPackageManager::OrderInstall()
 922 {
 923    if (CreateOrderList() == false)
 924       return Failed;
 925
 926    Reset();
 927
 928    if (Debug == true)
 929       clog << "Beginning to order" << endl;
 930
 931    bool const ordering =
 932         _config->FindB("PackageManager::UnpackAll",true) ?
 933                 List->OrderUnpack(FileNames) : List->OrderCritical();
 934    if (ordering == false)
 935    {
 936       _error->Error("Internal ordering error");
 937       return Failed;
 938    }
 939
 940    if (Debug == true)
 941       clog << "Done ordering" << endl;
 942
 943    bool DoneSomething = false;
 944    for (pkgOrderList::iterator I = List->begin(); I != List->end(); ++I)
 945    {
 946       PkgIterator Pkg(Cache,*I);
 947
 948       if (List->IsNow(Pkg) == false)
 949       {
 950          if (Debug == true)
 951             clog << "Skipping already done " << Pkg.FullName() << endl;
 952          continue;
 953       }
 954
 955       if (List->IsMissing(Pkg) == true)
 956       {
 957          if (Debug == true)
 958             clog << "Sequence completed at " << Pkg.FullName() << endl;
 959          if (DoneSomething == false)
 960          {
 961             _error->Error("Internal Error, ordering was unable to handle the media swap");
 962             return Failed;
 963          }
 964          return Incomplete;
 965       }
 966
 967       // Sanity check
 968       if (Cache[Pkg].Keep() == true &&
 969           Pkg.State() == pkgCache::PkgIterator::NeedsNothing &&
 970           (Cache[Pkg].iFlags & pkgDepCache::ReInstall) != pkgDepCache::ReInstall)
 971       {
 972          _error->Error("Internal Error, trying to manipulate a kept package (%s)",Pkg.FullName().c_str());
 973          return Failed;
 974       }
 975
 976       // Perform a delete or an install
 977       if (Cache[Pkg].Delete() == true)
 978       {
 979          if (SmartRemove(Pkg) == false)
 980             return Failed;
 981       }
 982       else
 983          if (SmartUnPack(Pkg,List->IsFlag(Pkg,pkgOrderList::Immediate),0) == false)
 984             return Failed;
 985       DoneSomething = true;
 986
 987       if (ImmConfigureAll) {
 988          /* ConfigureAll here to pick up and packages left unconfigured because they were unpacked in the
 989             "PreUnpack Checks" section */
 990          if (!ConfigureAll())
 991             return Failed;
 992       }
 993    }
 994
 995    // Final run through the configure phase
 996    if (ConfigureAll() == false)
 997       return Failed;
 998
 999    // Sanity check
1000    for (pkgOrderList::iterator I = List->begin(); I != List->end(); ++I)
1001    {
1002       if (List->IsFlag(*I,pkgOrderList::Configured) == false)
1003       {
1004          _error->Error("Internal error, packages left unconfigured. %s",
1005                        PkgIterator(Cache,*I).FullName().c_str());
1006          return Failed;
1007       }
1008    }
1009
1010    return Completed;
1011 }
1012 // PM::DoInstallPostFork - compat /*{{{*/
1013 // ---------------------------------------------------------------------
1014                                                                         /*}}}*/
1015 #if (APT_PKG_MAJOR >= 4 && APT_PKG_MINOR >= 13)
1016 pkgPackageManager::OrderResult
1017 pkgPackageManager::DoInstallPostFork(int statusFd)
1018 {
1019    APT::Progress::PackageManager *progress = new
1020       APT::Progress::PackageManagerProgressFd(statusFd);
1021    pkgPackageManager::OrderResult res = DoInstallPostFork(progress);
1022    delete progress;
1023    return res;
1024 }
1025                                                                         /*}}}*/
1026 // PM::DoInstallPostFork - Does install part that happens after the fork /*{{{*/
1027 // ---------------------------------------------------------------------
1028 pkgPackageManager::OrderResult
1029 pkgPackageManager::DoInstallPostFork(APT::Progress::PackageManager *progress)
1030 {
1031    bool goResult = Go(progress);
1032    if(goResult == false)
1033       return Failed;
1034
1035    return Res;
1036 };
1037 #else
1038 pkgPackageManager::OrderResult
1039 pkgPackageManager::DoInstallPostFork(int statusFd)
1040 {
1041    bool goResult = Go(statusFd);
1042    if(goResult == false)
1043       return Failed;
1044
1045    return Res;
1046 }
1047 #endif
1048                                                                         /*}}}*/
1049 // PM::DoInstall - Does the installation                                /*{{{*/
1050 // ---------------------------------------------------------------------
1051 /* compat */
1052 #if (APT_PKG_MAJOR >= 4 && APT_PKG_MINOR >= 13)
1053 pkgPackageManager::OrderResult
1054 pkgPackageManager::DoInstall(int statusFd)
1055 {
1056     APT::Progress::PackageManager *progress = new
1057        APT::Progress::PackageManagerProgressFd(statusFd);
1058     OrderResult res = DoInstall(progress);
1059     delete progress;
1060     return res;
1061  }
1062 #else
1063 pkgPackageManager::OrderResult pkgPackageManager::DoInstall(int statusFd)
1064 {
1065    if(DoInstallPreFork() == Failed)
1066       return Failed;
1067
1068    return DoInstallPostFork(statusFd);
1069 }
1070 #endif
1071                                                                         /*}}}*/
1072 // PM::DoInstall - Does the installation                                /*{{{*/
1073 // ---------------------------------------------------------------------
1074 /* This uses the filenames in FileNames and the information in the
1075    DepCache to perform the installation of packages.*/
1076 #if (APT_PKG_MAJOR >= 4 && APT_PKG_MINOR >= 13)
1077 pkgPackageManager::OrderResult
1078 pkgPackageManager::DoInstall(APT::Progress::PackageManager *progress)
1079 {
1080    if(DoInstallPreFork() == Failed)
1081       return Failed;
1082
1083    return DoInstallPostFork(progress);
1084 }
1085 #endif
1086                                                                         /*}}}*/