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    const unsigned int max_loops = _config->FindI("APT::pkgPackageManager::MaxLoopCount", 5000);
 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              Cache[P].InstallVer == 0 || (P.CurrentVer() == Cache[P].InstallVer &&
 496               (Cache[Pkg].iFlags & pkgDepCache::ReInstall) != pkgDepCache::ReInstall))
 497             continue;
 498          SmartConfigure(P, (Depth +1));
 499       }
 500
 501    // Sanity Check
 502    if (List->IsFlag(Pkg,pkgOrderList::Configured) == false)
 503       return _error->Error(_("Could not configure '%s'. "),Pkg.FullName().c_str());
 504
 505    return true;
 506 }
 507                                                                         /*}}}*/
 508 // PM::EarlyRemove - Perform removal of packages before their time      /*{{{*/
 509 // ---------------------------------------------------------------------
 510 /* This is called to deal with conflicts arising from unpacking */
 511 bool pkgPackageManager::EarlyRemove(PkgIterator Pkg)
 512 {
 513    if (List->IsNow(Pkg) == false)
 514       return true;
 515
 516    // Already removed it
 517    if (List->IsFlag(Pkg,pkgOrderList::Removed) == true)
 518       return true;
 519
 520    // Woops, it will not be re-installed!
 521    if (List->IsFlag(Pkg,pkgOrderList::InList) == false)
 522       return false;
 523
 524    // Essential packages get special treatment
 525    bool IsEssential = false;
 526    if ((Pkg->Flags & pkgCache::Flag::Essential) != 0)
 527       IsEssential = true;
 528
 529    /* Check for packages that are the dependents of essential packages and
 530       promote them too */
 531    if (Pkg->CurrentVer != 0)
 532    {
 533       for (DepIterator D = Pkg.RevDependsList(); D.end() == false &&
 534            IsEssential == false; ++D)
 535          if (D->Type == pkgCache::Dep::Depends || D->Type == pkgCache::Dep::PreDepends)
 536             if ((D.ParentPkg()->Flags & pkgCache::Flag::Essential) != 0)
 537                IsEssential = true;
 538    }
 539
 540    if (IsEssential == true)
 541    {
 542       if (_config->FindB("APT::Force-LoopBreak",false) == false)
 543          return _error->Error(_("This installation run will require temporarily "
 544                                 "removing the essential package %s due to a "
 545                                 "Conflicts/Pre-Depends loop. This is often bad, "
 546                                 "but if you really want to do it, activate the "
 547                                 "APT::Force-LoopBreak option."),Pkg.FullName().c_str());
 548    }
 549
 550    bool Res = SmartRemove(Pkg);
 551    if (Cache[Pkg].Delete() == false)
 552       List->Flag(Pkg,pkgOrderList::Removed,pkgOrderList::States);
 553
 554    return Res;
 555 }
 556                                                                         /*}}}*/
 557 // PM::SmartRemove - Removal Helper                                     /*{{{*/
 558 // ---------------------------------------------------------------------
 559 /* */
 560 bool pkgPackageManager::SmartRemove(PkgIterator Pkg)
 561 {
 562    if (List->IsNow(Pkg) == false)
 563       return true;
 564
 565    List->Flag(Pkg,pkgOrderList::Configured,pkgOrderList::States);
 566
 567    return Remove(Pkg,(Cache[Pkg].iFlags & pkgDepCache::Purge) == pkgDepCache::Purge);
 568 }
 569                                                                         /*}}}*/
 570 // PM::SmartUnPack - Install helper                                     /*{{{*/
 571 // ---------------------------------------------------------------------
 572 /* This puts the system in a state where it can Unpack Pkg, if Pkg is allready
 573    unpacked, or when it has been unpacked, if Immediate==true it configures it. */
 574 bool pkgPackageManager::SmartUnPack(PkgIterator Pkg)
 575 {
 576    return SmartUnPack(Pkg, true, 0);
 577 }
 578 bool pkgPackageManager::SmartUnPack(PkgIterator Pkg, bool const Immediate, int const Depth)
 579 {
 580    bool PkgLoop = List->IsFlag(Pkg,pkgOrderList::Loop);
 581
 582    if (Debug) {
 583       clog << OutputInDepth(Depth) << "SmartUnPack " << Pkg.FullName();
 584       VerIterator InstallVer = VerIterator(Cache,Cache[Pkg].InstallVer);
 585       if (Pkg.CurrentVer() == 0)
 586         clog << " (install version " << InstallVer.VerStr() << ")";
 587       else
 588         clog << " (replace version " << Pkg.CurrentVer().VerStr() << " with " << InstallVer.VerStr() << ")";
 589       if (PkgLoop)
 590         clog << " (Only Perform PreUnpack Checks)";
 591       clog << endl;
 592    }
 593
 594    VerIterator const instVer = Cache[Pkg].InstVerIter(Cache);
 595
 596    /* PreUnpack Checks: This loop checks and attempts to rectify and problems that would prevent the package being unpacked.
 597       It addresses: PreDepends, Conflicts, Obsoletes and Breaks (DpkgBreaks). Any resolutions that do not require it should
 598       avoid configuration (calling SmartUnpack with Immediate=true), this is because when unpacking some packages with
 599       complex dependancy structures, trying to configure some packages while breaking the loops can complicate things .
 600       This will be either dealt with if the package is configured as a dependency of Pkg (if and when Pkg is configured),
 601       or by the ConfigureAll call at the end of the for loop in OrderInstall. */
 602    bool Changed = false;
 603    const unsigned int max_loops = _config->FindI("APT::pkgPackageManager::MaxLoopCount", 5000);
 604    unsigned int i=0;
 605    do
 606    {
 607       Changed = false;
 608       for (DepIterator D = instVer.DependsList(); D.end() == false; )
 609       {
 610          // Compute a single dependency element (glob or)
 611          pkgCache::DepIterator Start, End;
 612          D.GlobOr(Start,End);
 613
 614          if (End->Type == pkgCache::Dep::PreDepends)
 615          {
 616             bool Bad = true;
 617             if (Debug)
 618                clog << OutputInDepth(Depth) << "PreDepends order for " << Pkg.FullName() << std::endl;
 619
 620             // Look for easy targets: packages that are already okay
 621             for (DepIterator Cur = Start; Bad == true; ++Cur)
 622             {
 623                SPtrArray<Version *> VList = Cur.AllTargets();
 624                for (Version **I = VList; *I != 0; ++I)
 625                {
 626                   VerIterator Ver(Cache,*I);
 627                   PkgIterator Pkg = Ver.ParentPkg();
 628
 629                   // See if the current version is ok
 630                   if (Pkg.CurrentVer() == Ver && List->IsNow(Pkg) == true &&
 631                       Pkg.State() == PkgIterator::NeedsNothing)
 632                   {
 633                      Bad = false;
 634                      if (Debug)
 635                         clog << OutputInDepth(Depth) << "Found ok package " << Pkg.FullName() << endl;
 636                      break;
 637                   }
 638                }
 639                if (Cur == End)
 640                   break;
 641             }
 642
 643             // Look for something that could be configured.
 644             for (DepIterator Cur = Start; Bad == true; ++Cur)
 645             {
 646                SPtrArray<Version *> VList = Cur.AllTargets();
 647                for (Version **I = VList; *I != 0; ++I)
 648                {
 649                   VerIterator Ver(Cache,*I);
 650                   PkgIterator Pkg = Ver.ParentPkg();
 651
 652                   // Not the install version
 653                   if (Cache[Pkg].InstallVer != *I ||
 654                       (Cache[Pkg].Keep() == true && Pkg.State() == PkgIterator::NeedsNothing))
 655                      continue;
 656
 657                   if (List->IsFlag(Pkg,pkgOrderList::Configured))
 658                   {
 659                      Bad = false;
 660                      break;
 661                   }
 662
 663                   // check if it needs unpack or if if configure is enough
 664                   if (List->IsFlag(Pkg,pkgOrderList::UnPacked) == false)
 665                   {
 666                      if (Debug)
 667                         clog << OutputInDepth(Depth) << "Trying to SmartUnpack " << Pkg.FullName() << endl;
 668                      // SmartUnpack with the ImmediateFlag to ensure its really ready
 669                      if (SmartUnPack(Pkg, true, Depth + 1) == true)
 670                      {
 671                         Bad = false;
 672                         if (List->IsFlag(Pkg,pkgOrderList::Loop) == false)
 673                            Changed = true;
 674                         break;
 675                      }
 676                   }
 677                   else
 678                   {
 679                      if (Debug)
 680                         clog << OutputInDepth(Depth) << "Trying to SmartConfigure " << Pkg.FullName() << endl;
 681                      if (SmartConfigure(Pkg, Depth + 1) == true)
 682                      {
 683                         Bad = false;
 684                         if (List->IsFlag(Pkg,pkgOrderList::Loop) == false)
 685                            Changed = true;
 686                         break;
 687                      }
 688                   }
 689                }
 690             }
 691
 692             if (Bad == true)
 693             {
 694                if (Start == End)
 695                   return _error->Error("Couldn't configure pre-depend %s for %s, "
 696                                         "probably a dependency cycle.",
 697                                         End.TargetPkg().FullName().c_str(),Pkg.FullName().c_str());
 698             }
 699             else
 700                continue;
 701          }
 702          else if (End->Type == pkgCache::Dep::Conflicts ||
 703                   End->Type == pkgCache::Dep::Obsoletes)
 704          {
 705             /* Look for conflicts. Two packages that are both in the install
 706                state cannot conflict so we don't check.. */
 707             SPtrArray<Version *> VList = End.AllTargets();
 708             for (Version **I = VList; *I != 0; I++)
 709             {
 710                VerIterator Ver(Cache,*I);
 711                PkgIterator ConflictPkg = Ver.ParentPkg();
 712                VerIterator InstallVer(Cache,Cache[ConflictPkg].InstallVer);
 713
 714                // See if the current version is conflicting
 715                if (ConflictPkg.CurrentVer() == Ver && List->IsNow(ConflictPkg))
 716                {
 717                   clog << OutputInDepth(Depth) << Pkg.FullName() << " conflicts with " << ConflictPkg.FullName() << endl;
 718                   /* If a loop is not present or has not yet been detected, attempt to unpack packages
 719                      to resolve this conflict. If there is a loop present, remove packages to resolve this conflict */
 720                   if (List->IsFlag(ConflictPkg,pkgOrderList::Loop) == false)
 721                   {
 722                      if (Cache[ConflictPkg].Keep() == 0 && Cache[ConflictPkg].InstallVer != 0)
 723                      {
 724                         if (Debug)
 725                            clog << OutputInDepth(Depth) << OutputInDepth(Depth) << "Unpacking " << ConflictPkg.FullName() << " to prevent conflict" << endl;
 726                         List->Flag(Pkg,pkgOrderList::Loop);
 727                         if (SmartUnPack(ConflictPkg,false, Depth + 1) == true)
 728                            if (List->IsFlag(ConflictPkg,pkgOrderList::Loop) == false)
 729                               Changed = true;
 730                         // Remove loop to allow it to be used later if needed
 731                         List->RmFlag(Pkg,pkgOrderList::Loop);
 732                      }
 733                      else if (EarlyRemove(ConflictPkg) == false)
 734                         return _error->Error("Internal Error, Could not early remove %s (1)",ConflictPkg.FullName().c_str());
 735                   }
 736                   else if (List->IsFlag(ConflictPkg,pkgOrderList::Removed) == false)
 737                   {
 738                      if (Debug)
 739                         clog << OutputInDepth(Depth) << "Because of conficts knot, removing " << ConflictPkg.FullName() << " to conflict violation" << endl;
 740                      if (EarlyRemove(ConflictPkg) == false)
 741                         return _error->Error("Internal Error, Could not early remove %s (2)",ConflictPkg.FullName().c_str());
 742                   }
 743                }
 744             }
 745          }
 746          else if (End->Type == pkgCache::Dep::DpkgBreaks)
 747          {
 748             SPtrArray<Version *> VList = End.AllTargets();
 749             for (Version **I = VList; *I != 0; ++I)
 750             {
 751                VerIterator Ver(Cache,*I);
 752                PkgIterator BrokenPkg = Ver.ParentPkg();
 753                if (BrokenPkg.CurrentVer() != Ver)
 754                {
 755                   if (Debug)
 756                      std::clog << OutputInDepth(Depth) << "  Ignore not-installed version " << Ver.VerStr() << " of " << Pkg.FullName() << " for " << End << std::endl;
 757                   continue;
 758                }
 759
 760                // Check if it needs to be unpacked
 761                if (List->IsFlag(BrokenPkg,pkgOrderList::InList) && Cache[BrokenPkg].Delete() == false &&
 762                    List->IsNow(BrokenPkg))
 763                {
 764                   if (List->IsFlag(BrokenPkg,pkgOrderList::Loop) && PkgLoop)
 765                   {
 766                      // This dependancy has already been dealt with by another SmartUnPack on Pkg
 767                      break;
 768                   }
 769                   else
 770                   {
 771                      // Found a break, so see if we can unpack the package to avoid it
 772                      // but do not set loop if another SmartUnPack already deals with it
 773                      // Also, avoid it if the package we would unpack pre-depends on this one
 774                      VerIterator InstallVer(Cache,Cache[BrokenPkg].InstallVer);
 775                      bool circle = false;
 776                      for (pkgCache::DepIterator D = InstallVer.DependsList(); D.end() == false; ++D)
 777                      {
 778                         if (D->Type != pkgCache::Dep::PreDepends)
 779                            continue;
 780                         SPtrArray<Version *> VL = D.AllTargets();
 781                         for (Version **I = VL; *I != 0; ++I)
 782                         {
 783                            VerIterator V(Cache,*I);
 784                            PkgIterator P = V.ParentPkg();
 785                            // we are checking for installation as an easy 'protection' against or-groups and (unchosen) providers
 786                            if (P->CurrentVer == 0 || P != Pkg || (P.CurrentVer() != V && Cache[P].InstallVer != V))
 787                               continue;
 788                            circle = true;
 789                            break;
 790                         }
 791                         if (circle == true)
 792                            break;
 793                      }
 794                      if (circle == true)
 795                      {
 796                         if (Debug)
 797                            clog << OutputInDepth(Depth) << "  Avoiding " << End << " avoided as " << BrokenPkg.FullName() << " has a pre-depends on " << Pkg.FullName() << std::endl;
 798                         continue;
 799                      }
 800                      else
 801                      {
 802                         if (Debug)
 803                         {
 804                            clog << OutputInDepth(Depth) << "  Unpacking " << BrokenPkg.FullName() << " to avoid " << End;
 805                            if (PkgLoop == true)
 806                               clog << " (Looping)";
 807                            clog << std::endl;
 808                         }
 809                         if (PkgLoop == false)
 810                            List->Flag(Pkg,pkgOrderList::Loop);
 811                         if (SmartUnPack(BrokenPkg, false, Depth + 1) == true)
 812                         {
 813                            if (List->IsFlag(BrokenPkg,pkgOrderList::Loop) == false)
 814                               Changed = true;
 815                         }
 816                         if (PkgLoop == false)
 817                            List->RmFlag(Pkg,pkgOrderList::Loop);
 818                      }
 819                   }
 820                }
 821                // Check if a package needs to be removed
 822                else if (Cache[BrokenPkg].Delete() == true && List->IsFlag(BrokenPkg,pkgOrderList::Configured) == false)
 823                {
 824                   if (Debug)
 825                      clog << OutputInDepth(Depth) << "  Removing " << BrokenPkg.FullName() << " to avoid " << End << endl;
 826                   SmartRemove(BrokenPkg);
 827                }
 828             }
 829          }
 830       }
 831       if (i++ > max_loops)
 832          return _error->Error("Internal error: APT::pkgPackageManager::MaxLoopCount reached in SmartConfigure for %s, aborting", Pkg.FullName().c_str());
 833    } while (Changed == true);
 834
 835    // Check for reverse conflicts.
 836    if (CheckRConflicts(Pkg,Pkg.RevDependsList(),
 837                    instVer.VerStr()) == false)
 838                           return false;
 839
 840    for (PrvIterator P = instVer.ProvidesList();
 841         P.end() == false; ++P)
 842       if (Pkg->Group != P.OwnerPkg()->Group)
 843          CheckRConflicts(Pkg,P.ParentPkg().RevDependsList(),P.ProvideVersion());
 844
 845    if (PkgLoop)
 846       return true;
 847
 848    List->Flag(Pkg,pkgOrderList::UnPacked,pkgOrderList::States);
 849
 850    if (Immediate == true && (instVer->MultiArch & pkgCache::Version::Same) == pkgCache::Version::Same)
 851    {
 852       /* Do lockstep M-A:same unpacking in two phases:
 853          First unpack all installed architectures, then the not installed.
 854          This way we avoid that M-A: enabled packages are installed before
 855          their older non-M-A enabled packages are replaced by newer versions */
 856       bool const installed = Pkg->CurrentVer != 0;
 857       if (installed == true && Install(Pkg,FileNames[Pkg->ID]) == false)
 858          return false;
 859       for (PkgIterator P = Pkg.Group().PackageList();
 860            P.end() == false; P = Pkg.Group().NextPkg(P))
 861       {
 862          if (P->CurrentVer == 0 || P == Pkg || List->IsFlag(P,pkgOrderList::UnPacked) == true ||
 863              Cache[P].InstallVer == 0 || (P.CurrentVer() == Cache[P].InstallVer &&
 864               (Cache[Pkg].iFlags & pkgDepCache::ReInstall) != pkgDepCache::ReInstall))
 865             continue;
 866          if (SmartUnPack(P, false, Depth + 1) == false)
 867             return false;
 868       }
 869       if (installed == false && Install(Pkg,FileNames[Pkg->ID]) == false)
 870          return false;
 871       for (PkgIterator P = Pkg.Group().PackageList();
 872            P.end() == false; P = Pkg.Group().NextPkg(P))
 873       {
 874          if (P->CurrentVer != 0 || P == Pkg || List->IsFlag(P,pkgOrderList::UnPacked) == true ||
 875              Cache[P].InstallVer == 0 || (P.CurrentVer() == Cache[P].InstallVer &&
 876               (Cache[Pkg].iFlags & pkgDepCache::ReInstall) != pkgDepCache::ReInstall))
 877             continue;
 878          if (SmartUnPack(P, false, Depth + 1) == false)
 879             return false;
 880       }
 881    }
 882    // packages which are already unpacked don't need to be unpacked again
 883    else if (Pkg.State() != pkgCache::PkgIterator::NeedsConfigure && Install(Pkg,FileNames[Pkg->ID]) == false)
 884       return false;
 885
 886    if (Immediate == true) {
 887       // Perform immedate configuration of the package.
 888          if (SmartConfigure(Pkg, Depth + 1) == false)
 889             _error->Warning(_("Could not perform immediate configuration on '%s'. "
 890                "Please see man 5 apt.conf under APT::Immediate-Configure for details. (%d)"),Pkg.FullName().c_str(),2);
 891    }
 892
 893    return true;
 894 }
 895                                                                         /*}}}*/
 896 // PM::OrderInstall - Installation ordering routine                     /*{{{*/
 897 // ---------------------------------------------------------------------
 898 /* */
 899 pkgPackageManager::OrderResult pkgPackageManager::OrderInstall()
 900 {
 901    if (CreateOrderList() == false)
 902       return Failed;
 903
 904    Reset();
 905
 906    if (Debug == true)
 907       clog << "Beginning to order" << endl;
 908
 909    bool const ordering =
 910         _config->FindB("PackageManager::UnpackAll",true) ?
 911                 List->OrderUnpack(FileNames) : List->OrderCritical();
 912    if (ordering == false)
 913    {
 914       _error->Error("Internal ordering error");
 915       return Failed;
 916    }
 917
 918    if (Debug == true)
 919       clog << "Done ordering" << endl;
 920
 921    bool DoneSomething = false;
 922    for (pkgOrderList::iterator I = List->begin(); I != List->end(); ++I)
 923    {
 924       PkgIterator Pkg(Cache,*I);
 925
 926       if (List->IsNow(Pkg) == false)
 927       {
 928          if (!List->IsFlag(Pkg,pkgOrderList::Configured) && !NoImmConfigure) {
 929             if (SmartConfigure(Pkg, 0) == false && Debug)
 930                _error->Warning("Internal Error, Could not configure %s",Pkg.FullName().c_str());
 931             // FIXME: The above warning message might need changing
 932          } else {
 933             if (Debug == true)
 934                clog << "Skipping already done " << Pkg.FullName() << endl;
 935          }
 936          continue;
 937
 938       }
 939
 940       if (List->IsMissing(Pkg) == true)
 941       {
 942          if (Debug == true)
 943             clog << "Sequence completed at " << Pkg.FullName() << endl;
 944          if (DoneSomething == false)
 945          {
 946             _error->Error("Internal Error, ordering was unable to handle the media swap");
 947             return Failed;
 948          }
 949          return Incomplete;
 950       }
 951
 952       // Sanity check
 953       if (Cache[Pkg].Keep() == true &&
 954           Pkg.State() == pkgCache::PkgIterator::NeedsNothing &&
 955           (Cache[Pkg].iFlags & pkgDepCache::ReInstall) != pkgDepCache::ReInstall)
 956       {
 957          _error->Error("Internal Error, trying to manipulate a kept package (%s)",Pkg.FullName().c_str());
 958          return Failed;
 959       }
 960
 961       // Perform a delete or an install
 962       if (Cache[Pkg].Delete() == true)
 963       {
 964          if (SmartRemove(Pkg) == false)
 965             return Failed;
 966       }
 967       else
 968          if (SmartUnPack(Pkg,List->IsFlag(Pkg,pkgOrderList::Immediate),0) == false)
 969             return Failed;
 970       DoneSomething = true;
 971
 972       if (ImmConfigureAll) {
 973          /* ConfigureAll here to pick up and packages left unconfigured becuase they were unpacked in the
 974             "PreUnpack Checks" section */
 975          if (!ConfigureAll())
 976             return Failed;
 977       }
 978    }
 979
 980    // Final run through the configure phase
 981    if (ConfigureAll() == false)
 982       return Failed;
 983
 984    // Sanity check
 985    for (pkgOrderList::iterator I = List->begin(); I != List->end(); ++I)
 986    {
 987       if (List->IsFlag(*I,pkgOrderList::Configured) == false)
 988       {
 989          _error->Error("Internal error, packages left unconfigured. %s",
 990                        PkgIterator(Cache,*I).FullName().c_str());
 991          return Failed;
 992       }
 993    }
 994
 995    return Completed;
 996 }
 997                                                                         /*}}}*/
 998 // PM::DoInstallPostFork - Does install part that happens after the fork /*{{{*/
 999 // ---------------------------------------------------------------------
1000 pkgPackageManager::OrderResult
1001 pkgPackageManager::DoInstallPostFork(int statusFd)
1002 {
1003       if(statusFd > 0)
1004          // FIXME: use SetCloseExec here once it taught about throwing
1005          //        exceptions instead of doing _exit(100) on failure
1006          fcntl(statusFd,F_SETFD,FD_CLOEXEC);
1007       bool goResult = Go(statusFd);
1008       if(goResult == false)
1009          return Failed;
1010
1011       return Res;
1012 };
1013
1014 // PM::DoInstall - Does the installation                                /*{{{*/
1015 // ---------------------------------------------------------------------
1016 /* This uses the filenames in FileNames and the information in the
1017    DepCache to perform the installation of packages.*/
1018 pkgPackageManager::OrderResult pkgPackageManager::DoInstall(int statusFd)
1019 {
1020    if(DoInstallPreFork() == Failed)
1021       return Failed;
1022
1023    return DoInstallPostFork(statusFd);
1024 }
1025                                                                         /*}}}*/