apt-pkg/packagemanager.cc

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