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