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