apt-pkg/packagemanager.cc

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