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