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           NoImmConfigure == false) || ImmConfigureAll)
 188       {
 189          if(Debug && !ImmConfigureAll)
 190             clog << "CreateOrderList(): Adding Immediate flag for " << I.Name() << endl;
 191          List->Flag(I,pkgOrderList::Immediate);
 192
 193          if (!ImmConfigureAll) {
 194             // Look for other install packages to make immediate configurea
 195             ImmediateAdd(I, true);
 196
 197             // And again with the current version.
 198             ImmediateAdd(I, false);
 199          }
 200       }
 201
 202       // Not interesting
 203       if ((Cache[I].Keep() == true ||
 204           Cache[I].InstVerIter(Cache) == I.CurrentVer()) &&
 205           I.State() == pkgCache::PkgIterator::NeedsNothing &&
 206           (Cache[I].iFlags & pkgDepCache::ReInstall) != pkgDepCache::ReInstall &&
 207           (I.Purge() != false || Cache[I].Mode != pkgDepCache::ModeDelete ||
 208            (Cache[I].iFlags & pkgDepCache::Purge) != pkgDepCache::Purge))
 209          continue;
 210
 211       // Append it to the list
 212       List->push_back(I);
 213    }
 214
 215    return true;
 216 }
 217                                                                         /*}}}*/
 218 // PM::DepAlwaysTrue - Returns true if this dep is irrelevent           /*{{{*/
 219 // ---------------------------------------------------------------------
 220 /* The restriction on provides is to eliminate the case when provides
 221    are transitioning between valid states [ie exim to smail] */
 222 bool pkgPackageManager::DepAlwaysTrue(DepIterator D)
 223 {
 224    if (D.TargetPkg()->ProvidesList != 0)
 225       return false;
 226
 227    if ((Cache[D] & pkgDepCache::DepInstall) != 0 &&
 228        (Cache[D] & pkgDepCache::DepNow) != 0)
 229       return true;
 230    return false;
 231 }
 232                                                                         /*}}}*/
 233 // PM::CheckRConflicts - Look for reverse conflicts                     /*{{{*/
 234 // ---------------------------------------------------------------------
 235 /* This looks over the reverses for a conflicts line that needs early
 236    removal. */
 237 bool pkgPackageManager::CheckRConflicts(PkgIterator Pkg,DepIterator D,
 238                                         const char *Ver)
 239 {
 240    for (;D.end() == false; ++D)
 241    {
 242       if (D->Type != pkgCache::Dep::Conflicts &&
 243           D->Type != pkgCache::Dep::Obsoletes)
 244          continue;
 245
 246       // The package hasnt been changed
 247       if (List->IsNow(Pkg) == false)
 248          continue;
 249
 250       // Ignore self conflicts, ignore conflicts from irrelevent versions
 251       if (D.IsIgnorable(Pkg) || D.ParentVer() != D.ParentPkg().CurrentVer())
 252          continue;
 253
 254       if (Cache.VS().CheckDep(Ver,D->CompareOp,D.TargetVer()) == false)
 255          continue;
 256
 257       if (EarlyRemove(D.ParentPkg()) == false)
 258          return _error->Error("Reverse conflicts early remove for package '%s' failed",
 259                               Pkg.Name());
 260    }
 261    return true;
 262 }
 263                                                                         /*}}}*/
 264 // PM::ConfigureAll - Run the all out configuration                     /*{{{*/
 265 // ---------------------------------------------------------------------
 266 /* This configures every package. It is assumed they are all unpacked and
 267    that the final configuration is valid. This is also used to catch packages
 268    that have not been configured when using ImmConfigureAll */
 269 bool pkgPackageManager::ConfigureAll()
 270 {
 271    pkgOrderList OList(&Cache);
 272
 273    // Populate the order list
 274    for (pkgOrderList::iterator I = List->begin(); I != List->end(); ++I)
 275       if (List->IsFlag(pkgCache::PkgIterator(Cache,*I),
 276                        pkgOrderList::UnPacked) == true)
 277          OList.push_back(*I);
 278
 279    if (OList.OrderConfigure() == false)
 280       return false;
 281
 282    std::string const conf = _config->Find("PackageManager::Configure","all");
 283    bool const ConfigurePkgs = (conf == "all");
 284
 285    // Perform the configuring
 286    for (pkgOrderList::iterator I = OList.begin(); I != OList.end(); ++I)
 287    {
 288       PkgIterator Pkg(Cache,*I);
 289
 290       /* Check if the package has been configured, this can happen if SmartConfigure
 291          calls its self */
 292       if (List->IsFlag(Pkg,pkgOrderList::Configured)) continue;
 293
 294       if (ConfigurePkgs == true && SmartConfigure(Pkg, 0) == false) {
 295          if (ImmConfigureAll)
 296             _error->Error(_("Could not perform immediate configuration on '%s'. "
 297                         "Please see man 5 apt.conf under APT::Immediate-Configure for details. (%d)"),Pkg.Name(),1);
 298          else
 299             _error->Error("Internal error, packages left unconfigured. %s",Pkg.Name());
 300          return false;
 301       }
 302
 303       List->Flag(Pkg,pkgOrderList::Configured,pkgOrderList::States);
 304    }
 305
 306    return true;
 307 }
 308                                                                         /*}}}*/
 309 // PM::SmartConfigure - Perform immediate configuration of the pkg      /*{{{*/
 310 // ---------------------------------------------------------------------
 311 /* This function tries to put the system in a state where Pkg can be configured.
 312    This involves checking each of Pkg's dependanies and unpacking and
 313    configuring packages where needed.
 314
 315    Note on failure: This method can fail, without causing any problems.
 316    This can happen when using Immediate-Configure-All, SmartUnPack may call
 317    SmartConfigure, it may fail because of a complex dependancy situation, but
 318    a error will only be reported if ConfigureAll fails. This is why some of the
 319    messages this function reports on failure (return false;) as just warnings
 320    only shown when debuging*/
 321 bool pkgPackageManager::SmartConfigure(PkgIterator Pkg, int const Depth)
 322 {
 323    // If this is true, only check and correct and dependencies without the Loop flag
 324    bool PkgLoop = List->IsFlag(Pkg,pkgOrderList::Loop);
 325
 326    if (Debug) {
 327       VerIterator InstallVer = VerIterator(Cache,Cache[Pkg].InstallVer);
 328       clog << OutputInDepth(Depth) << "SmartConfigure " << Pkg.Name() << " (" << InstallVer.VerStr() << ")";
 329       if (PkgLoop)
 330         clog << " (Only Correct Dependencies)";
 331       clog << endl;
 332    }
 333
 334    VerIterator const instVer = Cache[Pkg].InstVerIter(Cache);
 335
 336    /* Because of the ordered list, most dependencies should be unpacked,
 337       however if there is a loop (A depends on B, B depends on A) this will not
 338       be the case, so check for dependencies before configuring. */
 339    bool Bad = false;
 340    for (DepIterator D = instVer.DependsList();
 341         D.end() == false; )
 342    {
 343       // Compute a single dependency element (glob or)
 344       pkgCache::DepIterator Start;
 345       pkgCache::DepIterator End;
 346       D.GlobOr(Start,End);
 347
 348       if (End->Type == pkgCache::Dep::Depends)
 349           Bad = true;
 350
 351       // Check for dependanices that have not been unpacked, probably due to loops.
 352       while (End->Type == pkgCache::Dep::Depends) {
 353          PkgIterator DepPkg;
 354          VerIterator InstallVer;
 355          SPtrArray<Version *> VList = Start.AllTargets();
 356
 357          // Check through each version of each package that could satisfy this dependancy
 358          for (Version **I = VList; *I != 0; I++) {
 359             VerIterator Ver(Cache,*I);
 360             DepPkg = Ver.ParentPkg();
 361             InstallVer = VerIterator(Cache,Cache[DepPkg].InstallVer);
 362
 363             // Check if the current version of the package is avalible and will satisfy this dependancy
 364             if (DepPkg.CurrentVer() == Ver && List->IsNow(DepPkg) == true &&
 365                 !List->IsFlag(DepPkg,pkgOrderList::Removed) && DepPkg.State() == PkgIterator::NeedsNothing)
 366             {
 367                Bad = false;
 368                break;
 369             }
 370
 371             // Check if the version that is going to be installed will satisfy the dependancy
 372             if (Cache[DepPkg].InstallVer == *I) {
 373                if (List->IsFlag(DepPkg,pkgOrderList::UnPacked)) {
 374                   if (List->IsFlag(DepPkg,pkgOrderList::Loop) && PkgLoop) {
 375                     // This dependancy has already been dealt with by another SmartConfigure on Pkg
 376                     Bad = false;
 377                     break;
 378                   } else if (List->IsFlag(Pkg,pkgOrderList::Loop)) {
 379                     /* Check for a loop to prevent one forming
 380                        If A depends on B and B depends on A, SmartConfigure will
 381                        just hop between them if this is not checked. Dont remove the
 382                        loop flag after finishing however as loop is already set.
 383                        This means that there is another SmartConfigure call for this
 384                        package and it will remove the loop flag */
 385                      Bad = !SmartConfigure(DepPkg, Depth + 1);
 386                   } else {
 387                     /* Check for a loop to prevent one forming
 388                        If A depends on B and B depends on A, SmartConfigure will
 389                        just hop between them if this is not checked */
 390                     List->Flag(Pkg,pkgOrderList::Loop);
 391                     Bad = !SmartConfigure(DepPkg, Depth + 1);
 392                     List->RmFlag(Pkg,pkgOrderList::Loop);
 393                   }
 394                   // If SmartConfigure was succesfull, Bad is false, so break
 395                   if (!Bad) break;
 396                } else if (List->IsFlag(DepPkg,pkgOrderList::Configured)) {
 397                   Bad = false;
 398                   break;
 399                }
 400             }
 401          }
 402
 403          /* If the dependany is still not satisfied, try, if possible, unpacking a package to satisfy it */
 404          if (InstallVer != 0 && Bad) {
 405             if (List->IsNow(DepPkg)) {
 406                Bad = false;
 407                if (List->IsFlag(Pkg,pkgOrderList::Loop))
 408                {
 409                   if (Debug)
 410                      std::clog << OutputInDepth(Depth) << "Package " << Pkg << " loops in SmartConfigure" << std::endl;
 411                }
 412                else
 413                {
 414                   List->Flag(Pkg,pkgOrderList::Loop);
 415                   if (Debug)
 416                      clog << OutputInDepth(Depth) << "Unpacking " << DepPkg.Name() << " to avoid loop" << endl;
 417                   SmartUnPack(DepPkg, true, Depth + 1);
 418                   List->RmFlag(Pkg,pkgOrderList::Loop);
 419                }
 420             }
 421          }
 422
 423          if (Start==End) {
 424             if (Bad && Debug && List->IsFlag(DepPkg,pkgOrderList::Loop) == false)
 425                   std::clog << OutputInDepth(Depth) << "Could not satisfy dependencies for " << Pkg.Name() << std::endl;
 426             break;
 427          } else {
 428             Start++;
 429          }
 430       }
 431    }
 432
 433    if (Bad) {
 434       if (Debug)
 435          _error->Warning(_("Could not configure '%s'. "),Pkg.Name());
 436       return false;
 437    }
 438
 439    if (PkgLoop) return true;
 440
 441    static std::string const conf = _config->Find("PackageManager::Configure","all");
 442    static bool const ConfigurePkgs = (conf == "all" || conf == "smart");
 443
 444    if (List->IsFlag(Pkg,pkgOrderList::Configured))
 445       return _error->Error("Internal configure error on '%s'.", Pkg.Name());
 446
 447    if (ConfigurePkgs == true && Configure(Pkg) == false)
 448       return false;
 449
 450    List->Flag(Pkg,pkgOrderList::Configured,pkgOrderList::States);
 451
 452    if ((Cache[Pkg].InstVerIter(Cache)->MultiArch & pkgCache::Version::Same) == pkgCache::Version::Same)
 453       for (PkgIterator P = Pkg.Group().PackageList();
 454            P.end() == false; P = Pkg.Group().NextPkg(P))
 455       {
 456          if (Pkg == P || List->IsFlag(P,pkgOrderList::Configured) == true ||
 457              Cache[P].InstallVer == 0 || (P.CurrentVer() == Cache[P].InstallVer &&
 458               (Cache[Pkg].iFlags & pkgDepCache::ReInstall) != pkgDepCache::ReInstall))
 459             continue;
 460          SmartConfigure(P, (Depth +1));
 461       }
 462
 463    // Sanity Check
 464    if (List->IsFlag(Pkg,pkgOrderList::Configured) == false)
 465       return _error->Error(_("Could not configure '%s'. "),Pkg.Name());
 466
 467    return true;
 468 }
 469                                                                         /*}}}*/
 470 // PM::EarlyRemove - Perform removal of packages before their time      /*{{{*/
 471 // ---------------------------------------------------------------------
 472 /* This is called to deal with conflicts arising from unpacking */
 473 bool pkgPackageManager::EarlyRemove(PkgIterator Pkg)
 474 {
 475    if (List->IsNow(Pkg) == false)
 476       return true;
 477
 478    // Already removed it
 479    if (List->IsFlag(Pkg,pkgOrderList::Removed) == true)
 480       return true;
 481
 482    // Woops, it will not be re-installed!
 483    if (List->IsFlag(Pkg,pkgOrderList::InList) == false)
 484       return false;
 485
 486    // Essential packages get special treatment
 487    bool IsEssential = false;
 488    if ((Pkg->Flags & pkgCache::Flag::Essential) != 0 ||
 489        (Pkg->Flags & pkgCache::Flag::Important) != 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                 (D.ParentPkg()->Flags & pkgCache::Flag::Important) != 0)
 501                IsEssential = true;
 502    }
 503
 504    if (IsEssential == true)
 505    {
 506       if (_config->FindB("APT::Force-LoopBreak",false) == false)
 507          return _error->Error(_("This installation run will require temporarily "
 508                                 "removing the essential package %s due to a "
 509                                 "Conflicts/Pre-Depends loop. This is often bad, "
 510                                 "but if you really want to do it, activate the "
 511                                 "APT::Force-LoopBreak option."),Pkg.Name());
 512    }
 513
 514    bool Res = SmartRemove(Pkg);
 515    if (Cache[Pkg].Delete() == false)
 516       List->Flag(Pkg,pkgOrderList::Removed,pkgOrderList::States);
 517
 518    return Res;
 519 }
 520                                                                         /*}}}*/
 521 // PM::SmartRemove - Removal Helper                                     /*{{{*/
 522 // ---------------------------------------------------------------------
 523 /* */
 524 bool pkgPackageManager::SmartRemove(PkgIterator Pkg)
 525 {
 526    if (List->IsNow(Pkg) == false)
 527       return true;
 528
 529    List->Flag(Pkg,pkgOrderList::Configured,pkgOrderList::States);
 530
 531    return Remove(Pkg,(Cache[Pkg].iFlags & pkgDepCache::Purge) == pkgDepCache::Purge);
 532 }
 533                                                                         /*}}}*/
 534 // PM::SmartUnPack - Install helper                                     /*{{{*/
 535 // ---------------------------------------------------------------------
 536 /* This puts the system in a state where it can Unpack Pkg, if Pkg is allready
 537    unpacked, or when it has been unpacked, if Immediate==true it configures it. */
 538 bool pkgPackageManager::SmartUnPack(PkgIterator Pkg)
 539 {
 540    return SmartUnPack(Pkg, true, 0);
 541 }
 542 bool pkgPackageManager::SmartUnPack(PkgIterator Pkg, bool const Immediate, int const Depth)
 543 {
 544    bool PkgLoop = List->IsFlag(Pkg,pkgOrderList::Loop);
 545
 546    if (Debug) {
 547       clog << OutputInDepth(Depth) << "SmartUnPack " << Pkg.Name();
 548       VerIterator InstallVer = VerIterator(Cache,Cache[Pkg].InstallVer);
 549       if (Pkg.CurrentVer() == 0)
 550         clog << " (install version " << InstallVer.VerStr() << ")";
 551       else
 552         clog << " (replace version " << Pkg.CurrentVer().VerStr() << " with " << InstallVer.VerStr() << ")";
 553       if (PkgLoop)
 554         clog << " (Only Perform PreUnpack Checks)";
 555       clog << endl;
 556    }
 557
 558    VerIterator const instVer = Cache[Pkg].InstVerIter(Cache);
 559
 560    /* PreUnpack Checks: This loop checks and attempts to rectify and problems that would prevent the package being unpacked.
 561       It addresses: PreDepends, Conflicts, Obsoletes and Breaks (DpkgBreaks). Any resolutions that do not require it should
 562       avoid configuration (calling SmartUnpack with Immediate=true), this is because when unpacking some packages with
 563       complex dependancy structures, trying to configure some packages while breaking the loops can complicate things .
 564       This will be either dealt with if the package is configured as a dependency of Pkg (if and when Pkg is configured),
 565       or by the ConfigureAll call at the end of the for loop in OrderInstall. */
 566    for (DepIterator D = instVer.DependsList();
 567         D.end() == false; )
 568    {
 569       // Compute a single dependency element (glob or)
 570       pkgCache::DepIterator Start;
 571       pkgCache::DepIterator End;
 572       D.GlobOr(Start,End);
 573
 574       while (End->Type == pkgCache::Dep::PreDepends)
 575       {
 576          if (Debug)
 577             clog << OutputInDepth(Depth) << "PreDepends order for " << Pkg.Name() << std::endl;
 578
 579          // Look for possible ok targets.
 580          SPtrArray<Version *> VList = Start.AllTargets();
 581          bool Bad = true;
 582          for (Version **I = VList; *I != 0 && Bad == true; I++)
 583          {
 584             VerIterator Ver(Cache,*I);
 585             PkgIterator Pkg = Ver.ParentPkg();
 586
 587             // See if the current version is ok
 588             if (Pkg.CurrentVer() == Ver && List->IsNow(Pkg) == true &&
 589                 Pkg.State() == PkgIterator::NeedsNothing)
 590             {
 591                Bad = false;
 592                if (Debug)
 593                   clog << OutputInDepth(Depth) << "Found ok package " << Pkg.Name() << endl;
 594                continue;
 595             }
 596          }
 597
 598          // Look for something that could be configured.
 599          for (Version **I = VList; *I != 0 && Bad == true; I++)
 600          {
 601             VerIterator Ver(Cache,*I);
 602             PkgIterator Pkg = Ver.ParentPkg();
 603
 604             // Not the install version
 605             if (Cache[Pkg].InstallVer != *I ||
 606                 (Cache[Pkg].Keep() == true && Pkg.State() == PkgIterator::NeedsNothing))
 607                continue;
 608
 609             if (List->IsFlag(Pkg,pkgOrderList::Configured)) {
 610                Bad = false;
 611                continue;
 612             }
 613
 614             // check if it needs unpack or if if configure is enough
 615             if (!List->IsFlag(Pkg,pkgOrderList::UnPacked))
 616             {
 617                if (Debug)
 618                   clog << OutputInDepth(Depth) << "Trying to SmartUnpack " << Pkg.Name() << endl;
 619                // SmartUnpack with the ImmediateFlag to ensure its really ready
 620                Bad = !SmartUnPack(Pkg, true, Depth + 1);
 621             } else {
 622                if (Debug)
 623                   clog << OutputInDepth(Depth) << "Trying to SmartConfigure " << Pkg.Name() << endl;
 624                Bad = !SmartConfigure(Pkg, Depth + 1);
 625             }
 626          }
 627
 628          /* If this or element did not match then continue on to the
 629             next or element until a matching element is found */
 630          if (Bad == true)
 631          {
 632             // This triggers if someone make a pre-depends/depend loop.
 633             if (Start == End)
 634                return _error->Error("Couldn't configure pre-depend %s for %s, "
 635                                     "probably a dependency cycle.",
 636                                     End.TargetPkg().Name(),Pkg.Name());
 637             ++Start;
 638          }
 639          else
 640             break;
 641       }
 642
 643       if (End->Type == pkgCache::Dep::Conflicts ||
 644           End->Type == pkgCache::Dep::Obsoletes)
 645       {
 646          /* Look for conflicts. Two packages that are both in the install
 647             state cannot conflict so we don't check.. */
 648          SPtrArray<Version *> VList = End.AllTargets();
 649          for (Version **I = VList; *I != 0; I++)
 650          {
 651             VerIterator Ver(Cache,*I);
 652             PkgIterator ConflictPkg = Ver.ParentPkg();
 653             VerIterator InstallVer(Cache,Cache[ConflictPkg].InstallVer);
 654
 655             // See if the current version is conflicting
 656             if (ConflictPkg.CurrentVer() == Ver && List->IsNow(ConflictPkg))
 657             {
 658                clog << OutputInDepth(Depth) << Pkg.Name() << " conflicts with " << ConflictPkg.Name() << endl;
 659                /* If a loop is not present or has not yet been detected, attempt to unpack packages
 660                   to resolve this conflict. If there is a loop present, remove packages to resolve this conflict */
 661                if (!List->IsFlag(ConflictPkg,pkgOrderList::Loop)) {
 662                   if (Cache[ConflictPkg].Keep() == 0 && Cache[ConflictPkg].InstallVer != 0) {
 663                       if (Debug)
 664                         clog << OutputInDepth(Depth) << OutputInDepth(Depth) << "Unpacking " << ConflictPkg.Name() << " to prevent conflict" << endl;
 665                       List->Flag(Pkg,pkgOrderList::Loop);
 666                       SmartUnPack(ConflictPkg,false, Depth + 1);
 667                       // Remove loop to allow it to be used later if needed
 668                       List->RmFlag(Pkg,pkgOrderList::Loop);
 669                   } else {
 670                       if (EarlyRemove(ConflictPkg) == false)
 671                          return _error->Error("Internal Error, Could not early remove %s",ConflictPkg.Name());
 672                   }
 673                } else {
 674                   if (!List->IsFlag(ConflictPkg,pkgOrderList::Removed)) {
 675                       if (Debug)
 676                          clog << OutputInDepth(Depth) << "Because of conficts knot, removing " << ConflictPkg.Name() << " to conflict violation" << endl;
 677                       if (EarlyRemove(ConflictPkg) == false)
 678                           return _error->Error("Internal Error, Could not early remove %s",ConflictPkg.Name());
 679                   }
 680                }
 681             }
 682          }
 683       }
 684
 685       // Check for breaks
 686       if (End->Type == pkgCache::Dep::DpkgBreaks) {
 687          SPtrArray<Version *> VList = End.AllTargets();
 688          for (Version **I = VList; *I != 0; I++)
 689          {
 690             VerIterator Ver(Cache,*I);
 691             PkgIterator BrokenPkg = Ver.ParentPkg();
 692             if (BrokenPkg.CurrentVer() != Ver)
 693             {
 694                if (Debug)
 695                   std::clog << OutputInDepth(Depth) << "  Ignore not-installed version " << Ver.VerStr() << " of " << Pkg.FullName() << " for " << End << std::endl;
 696                continue;
 697             }
 698
 699             // Check if it needs to be unpacked
 700             if (List->IsFlag(BrokenPkg,pkgOrderList::InList) && Cache[BrokenPkg].Delete() == false &&
 701                 List->IsNow(BrokenPkg)) {
 702                if (List->IsFlag(BrokenPkg,pkgOrderList::Loop) && PkgLoop) {
 703                   // This dependancy has already been dealt with by another SmartUnPack on Pkg
 704                   break;
 705                } else {
 706                   // Found a break, so see if we can unpack the package to avoid it
 707                   // but do not set loop if another SmartUnPack already deals with it
 708                   VerIterator InstallVer(Cache,Cache[BrokenPkg].InstallVer);
 709                   bool circle = false;
 710                   for (pkgCache::DepIterator D = InstallVer.DependsList(); D.end() == false; ++D)
 711                   {
 712                      if (D->Type != pkgCache::Dep::PreDepends)
 713                         continue;
 714                      SPtrArray<Version *> VL = D.AllTargets();
 715                      for (Version **I = VL; *I != 0; ++I)
 716                      {
 717                         VerIterator V(Cache,*I);
 718                         PkgIterator P = V.ParentPkg();
 719                         // we are checking for installation as an easy 'protection' against or-groups and (unchosen) providers
 720                         if (P->CurrentVer == 0 || P != Pkg || (P.CurrentVer() != V && Cache[P].InstallVer != V))
 721                            continue;
 722                         circle = true;
 723                         break;
 724                      }
 725                      if (circle == true)
 726                         break;
 727                   }
 728                   if (circle == true)
 729                   {
 730                      if (Debug)
 731                         clog << OutputInDepth(Depth) << "  Avoiding " << End << " avoided as " << BrokenPkg.FullName() << " has a pre-depends on " << Pkg.FullName() << std::endl;
 732                      continue;
 733                   }
 734                   else
 735                   {
 736                      if (Debug)
 737                      {
 738                         clog << OutputInDepth(Depth) << "  Unpacking " << BrokenPkg.FullName() << " to avoid " << End;
 739                         if (PkgLoop == true)
 740                            clog << " (Looping)";
 741                         clog << std::endl;
 742                      }
 743                      if (PkgLoop == false)
 744                         List->Flag(Pkg,pkgOrderList::Loop);
 745                      SmartUnPack(BrokenPkg, false, Depth + 1);
 746                      if (PkgLoop == false)
 747                         List->RmFlag(Pkg,pkgOrderList::Loop);
 748                   }
 749                }
 750             } else {
 751                // Check if a package needs to be removed
 752                if (Cache[BrokenPkg].Delete() == true && !List->IsFlag(BrokenPkg,pkgOrderList::Configured))
 753                {
 754                   if (Debug)
 755                      clog << OutputInDepth(Depth) << "  Removing " << BrokenPkg.Name() << " to avoid " << End << endl;
 756                   SmartRemove(BrokenPkg);
 757                }
 758             }
 759          }
 760       }
 761    }
 762
 763    // Check for reverse conflicts.
 764    if (CheckRConflicts(Pkg,Pkg.RevDependsList(),
 765                    instVer.VerStr()) == false)
 766                           return false;
 767
 768    for (PrvIterator P = instVer.ProvidesList();
 769         P.end() == false; ++P)
 770       if (Pkg->Group != P.OwnerPkg()->Group)
 771          CheckRConflicts(Pkg,P.ParentPkg().RevDependsList(),P.ProvideVersion());
 772
 773    if (PkgLoop)
 774       return true;
 775
 776    List->Flag(Pkg,pkgOrderList::UnPacked,pkgOrderList::States);
 777
 778    if (Immediate == true && (instVer->MultiArch & pkgCache::Version::Same) == pkgCache::Version::Same)
 779    {
 780       /* Do lockstep M-A:same unpacking in two phases:
 781          First unpack all installed architectures, then the not installed.
 782          This way we avoid that M-A: enabled packages are installed before
 783          their older non-M-A enabled packages are replaced by newer versions */
 784       bool const installed = Pkg->CurrentVer != 0;
 785       if (installed == true && Install(Pkg,FileNames[Pkg->ID]) == false)
 786          return false;
 787       for (PkgIterator P = Pkg.Group().PackageList();
 788            P.end() == false; P = Pkg.Group().NextPkg(P))
 789       {
 790          if (P->CurrentVer == 0 || P == Pkg || List->IsFlag(P,pkgOrderList::UnPacked) == true ||
 791              Cache[P].InstallVer == 0 || (P.CurrentVer() == Cache[P].InstallVer &&
 792               (Cache[Pkg].iFlags & pkgDepCache::ReInstall) != pkgDepCache::ReInstall))
 793             continue;
 794          if (SmartUnPack(P, false, Depth + 1) == false)
 795             return false;
 796       }
 797       if (installed == false && Install(Pkg,FileNames[Pkg->ID]) == false)
 798          return false;
 799       for (PkgIterator P = Pkg.Group().PackageList();
 800            P.end() == false; P = Pkg.Group().NextPkg(P))
 801       {
 802          if (P->CurrentVer != 0 || P == Pkg || List->IsFlag(P,pkgOrderList::UnPacked) == true ||
 803              Cache[P].InstallVer == 0 || (P.CurrentVer() == Cache[P].InstallVer &&
 804               (Cache[Pkg].iFlags & pkgDepCache::ReInstall) != pkgDepCache::ReInstall))
 805             continue;
 806          if (SmartUnPack(P, false, Depth + 1) == false)
 807             return false;
 808       }
 809    }
 810    // packages which are already unpacked don't need to be unpacked again
 811    else if (Pkg.State() != pkgCache::PkgIterator::NeedsConfigure && Install(Pkg,FileNames[Pkg->ID]) == false)
 812       return false;
 813
 814    if (Immediate == true) {
 815       // Perform immedate configuration of the package.
 816          if (SmartConfigure(Pkg, Depth + 1) == false)
 817             _error->Warning(_("Could not perform immediate configuration on '%s'. "
 818                "Please see man 5 apt.conf under APT::Immediate-Configure for details. (%d)"),Pkg.Name(),2);
 819    }
 820
 821    return true;
 822 }
 823                                                                         /*}}}*/
 824 // PM::OrderInstall - Installation ordering routine                     /*{{{*/
 825 // ---------------------------------------------------------------------
 826 /* */
 827 pkgPackageManager::OrderResult pkgPackageManager::OrderInstall()
 828 {
 829    if (CreateOrderList() == false)
 830       return Failed;
 831
 832    Reset();
 833
 834    if (Debug == true)
 835       clog << "Beginning to order" << endl;
 836
 837    bool const ordering =
 838         _config->FindB("PackageManager::UnpackAll",true) ?
 839                 List->OrderUnpack(FileNames) : List->OrderCritical();
 840    if (ordering == false)
 841    {
 842       _error->Error("Internal ordering error");
 843       return Failed;
 844    }
 845
 846    if (Debug == true)
 847       clog << "Done ordering" << endl;
 848
 849    bool DoneSomething = false;
 850    for (pkgOrderList::iterator I = List->begin(); I != List->end(); ++I)
 851    {
 852       PkgIterator Pkg(Cache,*I);
 853
 854       if (List->IsNow(Pkg) == false)
 855       {
 856          if (!List->IsFlag(Pkg,pkgOrderList::Configured) && !NoImmConfigure) {
 857             if (SmartConfigure(Pkg, 0) == false && Debug)
 858                _error->Warning("Internal Error, Could not configure %s",Pkg.Name());
 859             // FIXME: The above warning message might need changing
 860          } else {
 861             if (Debug == true)
 862                clog << "Skipping already done " << Pkg.Name() << endl;
 863          }
 864          continue;
 865
 866       }
 867
 868       if (List->IsMissing(Pkg) == true)
 869       {
 870          if (Debug == true)
 871             clog << "Sequence completed at " << Pkg.Name() << endl;
 872          if (DoneSomething == false)
 873          {
 874             _error->Error("Internal Error, ordering was unable to handle the media swap");
 875             return Failed;
 876          }
 877          return Incomplete;
 878       }
 879
 880       // Sanity check
 881       if (Cache[Pkg].Keep() == true &&
 882           Pkg.State() == pkgCache::PkgIterator::NeedsNothing &&
 883           (Cache[Pkg].iFlags & pkgDepCache::ReInstall) != pkgDepCache::ReInstall)
 884       {
 885          _error->Error("Internal Error, trying to manipulate a kept package (%s)",Pkg.Name());
 886          return Failed;
 887       }
 888
 889       // Perform a delete or an install
 890       if (Cache[Pkg].Delete() == true)
 891       {
 892          if (SmartRemove(Pkg) == false)
 893             return Failed;
 894       }
 895       else
 896          if (SmartUnPack(Pkg,List->IsFlag(Pkg,pkgOrderList::Immediate),0) == false)
 897             return Failed;
 898       DoneSomething = true;
 899
 900       if (ImmConfigureAll) {
 901          /* ConfigureAll here to pick up and packages left unconfigured becuase they were unpacked in the
 902             "PreUnpack Checks" section */
 903          if (!ConfigureAll())
 904             return Failed;
 905       }
 906    }
 907
 908    // Final run through the configure phase
 909    if (ConfigureAll() == false)
 910       return Failed;
 911
 912    // Sanity check
 913    for (pkgOrderList::iterator I = List->begin(); I != List->end(); ++I)
 914    {
 915       if (List->IsFlag(*I,pkgOrderList::Configured) == false)
 916       {
 917          _error->Error("Internal error, packages left unconfigured. %s",
 918                        PkgIterator(Cache,*I).Name());
 919          return Failed;
 920       }
 921    }
 922
 923    return Completed;
 924 }
 925                                                                         /*}}}*/
 926 // PM::DoInstallPostFork - Does install part that happens after the fork /*{{{*/
 927 // ---------------------------------------------------------------------
 928 pkgPackageManager::OrderResult
 929 pkgPackageManager::DoInstallPostFork(int statusFd)
 930 {
 931       if(statusFd > 0)
 932          // FIXME: use SetCloseExec here once it taught about throwing
 933          //        exceptions instead of doing _exit(100) on failure
 934          fcntl(statusFd,F_SETFD,FD_CLOEXEC);
 935       bool goResult = Go(statusFd);
 936       if(goResult == false)
 937          return Failed;
 938
 939       return Res;
 940 };
 941
 942 // PM::DoInstall - Does the installation                                /*{{{*/
 943 // ---------------------------------------------------------------------
 944 /* This uses the filenames in FileNames and the information in the
 945    DepCache to perform the installation of packages.*/
 946 pkgPackageManager::OrderResult pkgPackageManager::DoInstall(int statusFd)
 947 {
 948    if(DoInstallPreFork() == Failed)
 949       return Failed;
 950
 951    return DoInstallPostFork(statusFd);
 952 }
 953                                                                         /*}}}*/