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