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             // check if it needs unpack or if if configure is enough
 614             if (!List->IsFlag(Pkg,pkgOrderList::UnPacked))
 615             {
 616                if (Debug)
 617                   clog << OutputInDepth(Depth) << "Trying to SmartUnpack " << Pkg.Name() << endl;
 618                // SmartUnpack with the ImmediateFlag to ensure its really ready
 619                Bad = !SmartUnPack(Pkg, true, Depth + 1);
 620             } else {
 621                if (Debug)
 622                   clog << OutputInDepth(Depth) << "Trying to SmartConfigure " << Pkg.Name() << endl;
 623                Bad = !SmartConfigure(Pkg, Depth + 1);
 624             }
 625          }
 626
 627          /* If this or element did not match then continue on to the
 628             next or element until a matching element is found */
 629          if (Bad == true)
 630          {
 631             // This triggers if someone make a pre-depends/depend loop.
 632             if (Start == End)
 633                return _error->Error("Couldn't configure pre-depend %s for %s, "
 634                                     "probably a dependency cycle.",
 635                                     End.TargetPkg().Name(),Pkg.Name());
 636             ++Start;
 637          }
 638          else
 639             break;
 640       }
 641
 642       if (End->Type == pkgCache::Dep::Conflicts ||
 643           End->Type == pkgCache::Dep::Obsoletes)
 644       {
 645          /* Look for conflicts. Two packages that are both in the install
 646             state cannot conflict so we don't check.. */
 647          SPtrArray<Version *> VList = End.AllTargets();
 648          for (Version **I = VList; *I != 0; I++)
 649          {
 650             VerIterator Ver(Cache,*I);
 651             PkgIterator ConflictPkg = Ver.ParentPkg();
 652             VerIterator InstallVer(Cache,Cache[ConflictPkg].InstallVer);
 653
 654             // See if the current version is conflicting
 655             if (ConflictPkg.CurrentVer() == Ver && List->IsNow(ConflictPkg))
 656             {
 657                cout << OutputInDepth(Depth) << Pkg.Name() << " conflicts with " << ConflictPkg.Name() << endl;
 658                /* If a loop is not present or has not yet been detected, attempt to unpack packages
 659                   to resolve this conflict. If there is a loop present, remove packages to resolve this conflict */
 660                if (!List->IsFlag(ConflictPkg,pkgOrderList::Loop)) {
 661                   if (Cache[ConflictPkg].Keep() == 0 && Cache[ConflictPkg].InstallVer != 0) {
 662                       if (Debug)
 663                         cout << OutputInDepth(Depth) << OutputInDepth(Depth) << "Unpacking " << ConflictPkg.Name() << " to prevent conflict" << endl;
 664                       List->Flag(Pkg,pkgOrderList::Loop);
 665                       SmartUnPack(ConflictPkg,false, Depth + 1);
 666                       // Remove loop to allow it to be used later if needed
 667                       List->RmFlag(Pkg,pkgOrderList::Loop);
 668                   } else {
 669                       if (EarlyRemove(ConflictPkg) == false)
 670                          return _error->Error("Internal Error, Could not early remove %s",ConflictPkg.Name());
 671                   }
 672                } else {
 673                   if (!List->IsFlag(ConflictPkg,pkgOrderList::Removed)) {
 674                       if (Debug)
 675                          cout << OutputInDepth(Depth) << "Because of conficts knot, removing " << ConflictPkg.Name() << " to conflict violation" << endl;
 676                       if (EarlyRemove(ConflictPkg) == false)
 677                           return _error->Error("Internal Error, Could not early remove %s",ConflictPkg.Name());
 678                   }
 679                }
 680             }
 681          }
 682       }
 683
 684       // Check for breaks
 685       if (End->Type == pkgCache::Dep::DpkgBreaks) {
 686          SPtrArray<Version *> VList = End.AllTargets();
 687          for (Version **I = VList; *I != 0; I++)
 688          {
 689             VerIterator Ver(Cache,*I);
 690             PkgIterator BrokenPkg = Ver.ParentPkg();
 691             if (BrokenPkg.CurrentVer() != Ver)
 692             {
 693                if (Debug)
 694                   std::clog << OutputInDepth(Depth) << "  Ignore not-installed version " << Ver.VerStr() << " of " << Pkg.FullName() << " for " << End << std::endl;
 695                continue;
 696             }
 697
 698             // Check if it needs to be unpacked
 699             if (List->IsFlag(BrokenPkg,pkgOrderList::InList) && Cache[BrokenPkg].Delete() == false &&
 700                 List->IsNow(BrokenPkg)) {
 701                if (List->IsFlag(BrokenPkg,pkgOrderList::Loop) && PkgLoop) {
 702                   // This dependancy has already been dealt with by another SmartUnPack on Pkg
 703                   break;
 704                } else {
 705                   // Found a break, so see if we can unpack the package to avoid it
 706                   // but do not set loop if another SmartUnPack already deals with it
 707                   VerIterator InstallVer(Cache,Cache[BrokenPkg].InstallVer);
 708                   bool circle = false;
 709                   for (pkgCache::DepIterator D = InstallVer.DependsList(); D.end() == false; ++D)
 710                   {
 711                      if (D->Type != pkgCache::Dep::PreDepends)
 712                         continue;
 713                      SPtrArray<Version *> VL = D.AllTargets();
 714                      for (Version **I = VL; *I != 0; ++I)
 715                      {
 716                         VerIterator V(Cache,*I);
 717                         PkgIterator P = V.ParentPkg();
 718                         // we are checking for installation as an easy 'protection' against or-groups and (unchosen) providers
 719                         if (P->CurrentVer == 0 || P != Pkg || (P.CurrentVer() != V && Cache[P].InstallVer != V))
 720                            continue;
 721                         circle = true;
 722                         break;
 723                      }
 724                      if (circle == true)
 725                         break;
 726                   }
 727                   if (circle == true)
 728                   {
 729                      if (Debug)
 730                         cout << OutputInDepth(Depth) << "  Avoiding " << End << " avoided as " << BrokenPkg.FullName() << " has a pre-depends on " << Pkg.FullName() << std::endl;
 731                      continue;
 732                   }
 733                   else
 734                   {
 735                      if (Debug)
 736                      {
 737                         cout << OutputInDepth(Depth) << "  Unpacking " << BrokenPkg.FullName() << " to avoid " << End;
 738                         if (PkgLoop == true)
 739                            cout << " (Looping)";
 740                         cout << std::endl;
 741                      }
 742                      if (PkgLoop == false)
 743                         List->Flag(Pkg,pkgOrderList::Loop);
 744                      SmartUnPack(BrokenPkg, false, Depth + 1);
 745                      if (PkgLoop == false)
 746                         List->RmFlag(Pkg,pkgOrderList::Loop);
 747                   }
 748                }
 749             } else {
 750                // Check if a package needs to be removed
 751                if (Cache[BrokenPkg].Delete() == true && !List->IsFlag(BrokenPkg,pkgOrderList::Configured))
 752                {
 753                   if (Debug)
 754                      cout << OutputInDepth(Depth) << "  Removing " << BrokenPkg.Name() << " to avoid " << End << endl;
 755                   SmartRemove(BrokenPkg);
 756                }
 757             }
 758          }
 759       }
 760    }
 761
 762    // Check for reverse conflicts.
 763    if (CheckRConflicts(Pkg,Pkg.RevDependsList(),
 764                    instVer.VerStr()) == false)
 765                           return false;
 766
 767    for (PrvIterator P = instVer.ProvidesList();
 768         P.end() == false; ++P)
 769       if (Pkg->Group != P.OwnerPkg()->Group)
 770          CheckRConflicts(Pkg,P.ParentPkg().RevDependsList(),P.ProvideVersion());
 771
 772    if (PkgLoop)
 773       return true;
 774
 775    List->Flag(Pkg,pkgOrderList::UnPacked,pkgOrderList::States);
 776
 777    if (Immediate == true && (instVer->MultiArch & pkgCache::Version::Same) == pkgCache::Version::Same)
 778    {
 779       /* Do lockstep M-A:same unpacking in two phases:
 780          First unpack all installed architectures, then the not installed.
 781          This way we avoid that M-A: enabled packages are installed before
 782          their older non-M-A enabled packages are replaced by newer versions */
 783       bool const installed = Pkg->CurrentVer != 0;
 784       if (installed == true && Install(Pkg,FileNames[Pkg->ID]) == false)
 785          return false;
 786       for (PkgIterator P = Pkg.Group().PackageList();
 787            P.end() == false; P = Pkg.Group().NextPkg(P))
 788       {
 789          if (P->CurrentVer == 0 || P == Pkg || List->IsFlag(P,pkgOrderList::UnPacked) == true ||
 790              Cache[P].InstallVer == 0 || (P.CurrentVer() == Cache[P].InstallVer &&
 791               (Cache[Pkg].iFlags & pkgDepCache::ReInstall) != pkgDepCache::ReInstall))
 792             continue;
 793          if (SmartUnPack(P, false, Depth + 1) == false)
 794             return false;
 795       }
 796       if (installed == false && Install(Pkg,FileNames[Pkg->ID]) == false)
 797          return false;
 798       for (PkgIterator P = Pkg.Group().PackageList();
 799            P.end() == false; P = Pkg.Group().NextPkg(P))
 800       {
 801          if (P->CurrentVer != 0 || P == Pkg || List->IsFlag(P,pkgOrderList::UnPacked) == true ||
 802              Cache[P].InstallVer == 0 || (P.CurrentVer() == Cache[P].InstallVer &&
 803               (Cache[Pkg].iFlags & pkgDepCache::ReInstall) != pkgDepCache::ReInstall))
 804             continue;
 805          if (SmartUnPack(P, false, Depth + 1) == false)
 806             return false;
 807       }
 808    }
 809    // packages which are already unpacked don't need to be unpacked again
 810    else if (Pkg.State() != pkgCache::PkgIterator::NeedsConfigure && Install(Pkg,FileNames[Pkg->ID]) == false)
 811       return false;
 812
 813    if (Immediate == true) {
 814       // Perform immedate configuration of the package.
 815          if (SmartConfigure(Pkg, Depth + 1) == false)
 816             _error->Warning(_("Could not perform immediate configuration on '%s'. "
 817                "Please see man 5 apt.conf under APT::Immediate-Configure for details. (%d)"),Pkg.Name(),2);
 818    }
 819
 820    return true;
 821 }
 822                                                                         /*}}}*/
 823 // PM::OrderInstall - Installation ordering routine                     /*{{{*/
 824 // ---------------------------------------------------------------------
 825 /* */
 826 pkgPackageManager::OrderResult pkgPackageManager::OrderInstall()
 827 {
 828    if (CreateOrderList() == false)
 829       return Failed;
 830
 831    Reset();
 832
 833    if (Debug == true)
 834       clog << "Beginning to order" << endl;
 835
 836    bool const ordering =
 837         _config->FindB("PackageManager::UnpackAll",true) ?
 838                 List->OrderUnpack(FileNames) : List->OrderCritical();
 839    if (ordering == false)
 840    {
 841       _error->Error("Internal ordering error");
 842       return Failed;
 843    }
 844
 845    if (Debug == true)
 846       clog << "Done ordering" << endl;
 847
 848    bool DoneSomething = false;
 849    for (pkgOrderList::iterator I = List->begin(); I != List->end(); ++I)
 850    {
 851       PkgIterator Pkg(Cache,*I);
 852
 853       if (List->IsNow(Pkg) == false)
 854       {
 855          if (!List->IsFlag(Pkg,pkgOrderList::Configured) && !NoImmConfigure) {
 856             if (SmartConfigure(Pkg, 0) == false && Debug)
 857                _error->Warning("Internal Error, Could not configure %s",Pkg.Name());
 858             // FIXME: The above warning message might need changing
 859          } else {
 860             if (Debug == true)
 861                clog << "Skipping already done " << Pkg.Name() << endl;
 862          }
 863          continue;
 864
 865       }
 866
 867       if (List->IsMissing(Pkg) == true)
 868       {
 869          if (Debug == true)
 870             clog << "Sequence completed at " << Pkg.Name() << endl;
 871          if (DoneSomething == false)
 872          {
 873             _error->Error("Internal Error, ordering was unable to handle the media swap");
 874             return Failed;
 875          }
 876          return Incomplete;
 877       }
 878
 879       // Sanity check
 880       if (Cache[Pkg].Keep() == true &&
 881           Pkg.State() == pkgCache::PkgIterator::NeedsNothing &&
 882           (Cache[Pkg].iFlags & pkgDepCache::ReInstall) != pkgDepCache::ReInstall)
 883       {
 884          _error->Error("Internal Error, trying to manipulate a kept package (%s)",Pkg.Name());
 885          return Failed;
 886       }
 887
 888       // Perform a delete or an install
 889       if (Cache[Pkg].Delete() == true)
 890       {
 891          if (SmartRemove(Pkg) == false)
 892             return Failed;
 893       }
 894       else
 895          if (SmartUnPack(Pkg,List->IsFlag(Pkg,pkgOrderList::Immediate),0) == false)
 896             return Failed;
 897       DoneSomething = true;
 898
 899       if (ImmConfigureAll) {
 900          /* ConfigureAll here to pick up and packages left unconfigured becuase they were unpacked in the
 901             "PreUnpack Checks" section */
 902          if (!ConfigureAll())
 903             return Failed;
 904       }
 905    }
 906
 907    // Final run through the configure phase
 908    if (ConfigureAll() == false)
 909       return Failed;
 910
 911    // Sanity check
 912    for (pkgOrderList::iterator I = List->begin(); I != List->end(); ++I)
 913    {
 914       if (List->IsFlag(*I,pkgOrderList::Configured) == false)
 915       {
 916          _error->Error("Internal error, packages left unconfigured. %s",
 917                        PkgIterator(Cache,*I).Name());
 918          return Failed;
 919       }
 920    }
 921
 922    return Completed;
 923 }
 924                                                                         /*}}}*/
 925 // PM::DoInstallPostFork - Does install part that happens after the fork /*{{{*/
 926 // ---------------------------------------------------------------------
 927 pkgPackageManager::OrderResult
 928 pkgPackageManager::DoInstallPostFork(int statusFd)
 929 {
 930       if(statusFd > 0)
 931          // FIXME: use SetCloseExec here once it taught about throwing
 932          //        exceptions instead of doing _exit(100) on failure
 933          fcntl(statusFd,F_SETFD,FD_CLOEXEC);
 934       bool goResult = Go(statusFd);
 935       if(goResult == false)
 936          return Failed;
 937
 938       return Res;
 939 };
 940
 941 // PM::DoInstall - Does the installation                                /*{{{*/
 942 // ---------------------------------------------------------------------
 943 /* This uses the filenames in FileNames and the information in the
 944    DepCache to perform the installation of packages.*/
 945 pkgPackageManager::OrderResult pkgPackageManager::DoInstall(int statusFd)
 946 {
 947    if(DoInstallPreFork() == Failed)
 948       return Failed;
 949
 950    return DoInstallPostFork(statusFd);
 951 }
 952                                                                         /*}}}*/