apt-pkg/packagemanager.cc

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