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