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