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       VerIterator InstallVer = VerIterator(Cache,Cache[Pkg].InstallVer);
 325       clog << "SmartConfigure " << Pkg.Name() << InstallVer.VerStr() << endl;
 326    }
 327
 328    VerIterator const instVer = Cache[Pkg].InstVerIter(Cache);
 329
 330    /* Because of the ordered list, most dependancies should be unpacked,
 331       however if there is a loop (A depends on B, B depends on A) this will not
 332       be the case, so check for dependancies before configuring. */
 333    bool Bad = false;
 334    for (DepIterator D = instVer.DependsList();
 335         D.end() == false; )
 336    {
 337       // Compute a single dependency element (glob or)
 338       pkgCache::DepIterator Start;
 339       pkgCache::DepIterator End;
 340       D.GlobOr(Start,End);
 341
 342       if (End->Type == pkgCache::Dep::Depends)
 343           Bad = true;
 344
 345       // Check for dependanices that have not been unpacked, probably due to loops.
 346       while (End->Type == pkgCache::Dep::Depends) {
 347          PkgIterator DepPkg;
 348          VerIterator InstallVer;
 349          SPtrArray<Version *> VList = Start.AllTargets();
 350
 351          // Check through each version of each package that could satisfy this dependancy
 352          for (Version **I = VList; *I != 0; I++) {
 353             VerIterator Ver(Cache,*I);
 354             DepPkg = Ver.ParentPkg();
 355             InstallVer = VerIterator(Cache,Cache[DepPkg].InstallVer);
 356
 357             // Check if the current version of the package is avalible and will satisfy this dependancy
 358             if (DepPkg.CurrentVer() == Ver && List->IsNow(DepPkg) == true &&
 359                 !List->IsFlag(DepPkg,pkgOrderList::Removed) && DepPkg.State() == PkgIterator::NeedsNothing)
 360             {
 361                Bad = false;
 362                break;
 363             }
 364
 365             // Check if the version that is going to be installed will satisfy the dependancy
 366             if (Cache[DepPkg].InstallVer == *I) {
 367                if (List->IsFlag(DepPkg,pkgOrderList::UnPacked)) {
 368                   /* Check for a loop to prevent one forming
 369                      If A depends on B and B depends on A, SmartConfigure will
 370                      just hop between them if this is not checked */
 371                   if (!List->IsFlag(DepPkg,pkgOrderList::Loop)) {
 372                      List->Flag(Pkg,pkgOrderList::Loop);
 373                      // If SmartConfigure was succesfull, Bad is false, so break
 374                      Bad = !SmartConfigure(DepPkg);
 375                      List->RmFlag(Pkg,pkgOrderList::Loop);
 376                      if (!Bad) break;
 377                   }
 378                } else if (List->IsFlag(DepPkg,pkgOrderList::Configured)) {
 379                   Bad = false;
 380                   break;
 381                }
 382             }
 383          }
 384
 385          /* If the dependany is still not satisfied, try, if possible, unpacking a package to satisfy it */
 386          if (InstallVer != 0 && Bad) {
 387             Bad = false;
 388             if (!List->IsFlag(DepPkg,pkgOrderList::Loop)) {
 389                List->Flag(Pkg,pkgOrderList::Loop);
 390                if (Debug)
 391                   cout << "  Unpacking " << DepPkg.Name() << " to avoid loop" << endl;
 392                SmartUnPack(DepPkg, true);
 393                List->RmFlag(Pkg,pkgOrderList::Loop);
 394             }
 395          }
 396
 397          if (Start==End) {
 398             if (Bad && Debug) {
 399                if (!List->IsFlag(DepPkg,pkgOrderList::Loop)) {
 400                   _error->Warning("Could not satisfy dependancies for %s",Pkg.Name());
 401                }
 402             }
 403             break;
 404          } else {
 405             Start++;
 406          }
 407       }
 408    }
 409
 410    if (Bad) {
 411       if (Debug)
 412          _error->Warning(_("Could not configure '%s'. "),Pkg.Name());
 413       return false;
 414    }
 415
 416    static std::string const conf = _config->Find("PackageManager::Configure","all");
 417    static bool const ConfigurePkgs = (conf == "all" || conf == "smart");
 418
 419    if (List->IsFlag(Pkg,pkgOrderList::Configured))
 420       return _error->Error("Internal configure error on '%s'. ",Pkg.Name(),1);
 421
 422    if (ConfigurePkgs == true && Configure(Pkg) == false)
 423       return false;
 424
 425    List->Flag(Pkg,pkgOrderList::Configured,pkgOrderList::States);
 426
 427    if (Cache[Pkg].InstVerIter(Cache)->MultiArch == pkgCache::Version::Same)
 428       for (PkgIterator P = Pkg.Group().PackageList();
 429            P.end() == false; P = Pkg.Group().NextPkg(P))
 430       {
 431          if (Pkg == P || List->IsFlag(P,pkgOrderList::Configured) == true ||
 432              Cache[P].InstallVer == 0 || (P.CurrentVer() == Cache[P].InstallVer &&
 433               (Cache[Pkg].iFlags & pkgDepCache::ReInstall) != pkgDepCache::ReInstall))
 434             continue;
 435          SmartConfigure(P);
 436       }
 437
 438    // Sanity Check
 439    if (List->IsFlag(Pkg,pkgOrderList::Configured) == false)
 440       return _error->Error(_("Could not configure '%s'. "),Pkg.Name());
 441
 442    return true;
 443 }
 444                                                                         /*}}}*/
 445 // PM::EarlyRemove - Perform removal of packages before their time      /*{{{*/
 446 // ---------------------------------------------------------------------
 447 /* This is called to deal with conflicts arising from unpacking */
 448 bool pkgPackageManager::EarlyRemove(PkgIterator Pkg)
 449 {
 450    if (List->IsNow(Pkg) == false)
 451       return true;
 452
 453    // Already removed it
 454    if (List->IsFlag(Pkg,pkgOrderList::Removed) == true)
 455       return true;
 456
 457    // Woops, it will not be re-installed!
 458    if (List->IsFlag(Pkg,pkgOrderList::InList) == false)
 459       return false;
 460
 461    // Essential packages get special treatment
 462    bool IsEssential = false;
 463    if ((Pkg->Flags & pkgCache::Flag::Essential) != 0)
 464       IsEssential = true;
 465
 466    /* Check for packages that are the dependents of essential packages and
 467       promote them too */
 468    if (Pkg->CurrentVer != 0)
 469    {
 470       for (DepIterator D = Pkg.RevDependsList(); D.end() == false &&
 471            IsEssential == false; D++)
 472          if (D->Type == pkgCache::Dep::Depends || D->Type == pkgCache::Dep::PreDepends)
 473             if ((D.ParentPkg()->Flags & pkgCache::Flag::Essential) != 0)
 474                IsEssential = true;
 475    }
 476
 477    if (IsEssential == true)
 478    {
 479       if (_config->FindB("APT::Force-LoopBreak",false) == false)
 480          return _error->Error(_("This installation run will require temporarily "
 481                                 "removing the essential package %s due to a "
 482                                 "Conflicts/Pre-Depends loop. This is often bad, "
 483                                 "but if you really want to do it, activate the "
 484                                 "APT::Force-LoopBreak option."),Pkg.Name());
 485    }
 486
 487    bool Res = SmartRemove(Pkg);
 488    if (Cache[Pkg].Delete() == false)
 489       List->Flag(Pkg,pkgOrderList::Removed,pkgOrderList::States);
 490
 491    return Res;
 492 }
 493                                                                         /*}}}*/
 494 // PM::SmartRemove - Removal Helper                                     /*{{{*/
 495 // ---------------------------------------------------------------------
 496 /* */
 497 bool pkgPackageManager::SmartRemove(PkgIterator Pkg)
 498 {
 499    if (List->IsNow(Pkg) == false)
 500       return true;
 501
 502    List->Flag(Pkg,pkgOrderList::Configured,pkgOrderList::States);
 503
 504    return Remove(Pkg,(Cache[Pkg].iFlags & pkgDepCache::Purge) == pkgDepCache::Purge);
 505    return true;
 506 }
 507                                                                         /*}}}*/
 508 // PM::SmartUnPack - Install helper                                     /*{{{*/
 509 // ---------------------------------------------------------------------
 510 /* This puts the system in a state where it can Unpack Pkg, if Pkg is allready
 511    unpacked, or when it has been unpacked, if Immediate==true it configures it. */
 512 bool pkgPackageManager::SmartUnPack(PkgIterator Pkg)
 513 {
 514    return SmartUnPack(Pkg, true);
 515 }
 516 bool pkgPackageManager::SmartUnPack(PkgIterator Pkg, bool const Immediate)
 517 {
 518    if (Debug) {
 519       clog << "SmartUnPack " << Pkg.Name();
 520       VerIterator InstallVer = VerIterator(Cache,Cache[Pkg].InstallVer);
 521       if (Pkg.CurrentVer() == 0)
 522         cout << "(install version " << InstallVer.VerStr() << ")" << endl;
 523       else
 524         cout << "(replace version " << Pkg.CurrentVer().VerStr() << " with " << InstallVer.VerStr() << ")" << endl;
 525    }
 526
 527    // Check if it is already unpacked
 528    if (Pkg.State() == pkgCache::PkgIterator::NeedsConfigure &&
 529        Cache[Pkg].Keep() == true)
 530    {
 531       List->Flag(Pkg,pkgOrderList::UnPacked,pkgOrderList::States);
 532       if (Immediate == true &&
 533           List->IsFlag(Pkg,pkgOrderList::Immediate) == true)
 534          if (SmartConfigure(Pkg) == false)
 535             _error->Warning(_("Could not perform immediate configuration on already unpacked '%s'. "
 536                         "Please see man 5 apt.conf under APT::Immediate-Configure for details."),Pkg.Name());
 537       return true;
 538    }
 539
 540    VerIterator const instVer = Cache[Pkg].InstVerIter(Cache);
 541
 542    /* PreUnpack Checks: This loop checks and attempts to rectify and problems that would prevent the package being unpacked.
 543       It addresses: PreDepends, Conflicts, Obsoletes and Breaks (DpkgBreaks). Any resolutions that do not require it should
 544       avoid configuration (calling SmartUnpack with Immediate=true), this is because when unpacking some packages with
 545       complex dependancy structures, trying to configure some packages while breaking the loops can complicate things .
 546       This will be either dealt with if the package is configured as a dependency of Pkg (if and when Pkg is configured),
 547       or by the ConfigureAll call at the end of the for loop in OrderInstall. */
 548    for (DepIterator D = instVer.DependsList();
 549         D.end() == false; )
 550    {
 551       // Compute a single dependency element (glob or)
 552       pkgCache::DepIterator Start;
 553       pkgCache::DepIterator End;
 554       D.GlobOr(Start,End);
 555
 556       while (End->Type == pkgCache::Dep::PreDepends)
 557       {
 558          if (Debug)
 559             clog << "PreDepends order for " << Pkg.Name() << std::endl;
 560
 561          // Look for possible ok targets.
 562          SPtrArray<Version *> VList = Start.AllTargets();
 563          bool Bad = true;
 564          for (Version **I = VList; *I != 0 && Bad == true; I++)
 565          {
 566             VerIterator Ver(Cache,*I);
 567             PkgIterator Pkg = Ver.ParentPkg();
 568
 569             // See if the current version is ok
 570             if (Pkg.CurrentVer() == Ver && List->IsNow(Pkg) == true &&
 571                 Pkg.State() == PkgIterator::NeedsNothing)
 572             {
 573                Bad = false;
 574                if (Debug)
 575                   clog << "Found ok package " << Pkg.Name() << endl;
 576                continue;
 577             }
 578          }
 579
 580          // Look for something that could be configured.
 581          for (Version **I = VList; *I != 0 && Bad == true; I++)
 582          {
 583             VerIterator Ver(Cache,*I);
 584             PkgIterator Pkg = Ver.ParentPkg();
 585
 586             // Not the install version
 587             if (Cache[Pkg].InstallVer != *I ||
 588                 (Cache[Pkg].Keep() == true && Pkg.State() == PkgIterator::NeedsNothing))
 589                continue;
 590
 591             if (List->IsFlag(Pkg,pkgOrderList::Configured)) {
 592                Bad = false;
 593                continue;
 594             }
 595
 596             if (Debug)
 597                clog << "Trying to SmartConfigure " << Pkg.Name() << endl;
 598             Bad = !SmartConfigure(Pkg);
 599          }
 600
 601          /* If this or element did not match then continue on to the
 602             next or element until a matching element is found */
 603          if (Bad == true)
 604          {
 605             // This triggers if someone make a pre-depends/depend loop.
 606             if (Start == End)
 607                return _error->Error("Couldn't configure pre-depend %s for %s, "
 608                                     "probably a dependency cycle.",
 609                                     End.TargetPkg().Name(),Pkg.Name());
 610             Start++;
 611          }
 612          else
 613             break;
 614       }
 615
 616       if (End->Type == pkgCache::Dep::Conflicts ||
 617           End->Type == pkgCache::Dep::Obsoletes)
 618       {
 619          /* Look for conflicts. Two packages that are both in the install
 620             state cannot conflict so we don't check.. */
 621          SPtrArray<Version *> VList = End.AllTargets();
 622          for (Version **I = VList; *I != 0; I++)
 623          {
 624             VerIterator Ver(Cache,*I);
 625             PkgIterator ConflictPkg = Ver.ParentPkg();
 626             VerIterator InstallVer(Cache,Cache[ConflictPkg].InstallVer);
 627
 628             // See if the current version is conflicting
 629             if (ConflictPkg.CurrentVer() == Ver && List->IsNow(ConflictPkg))
 630             {
 631                cout << Pkg.Name() << " conflicts with " << ConflictPkg.Name() << endl;
 632                /* If a loop is not present or has not yet been detected, attempt to unpack packages
 633                   to resolve this conflict. If there is a loop present, remove packages to resolve this conflict */
 634                if (!List->IsFlag(ConflictPkg,pkgOrderList::Loop)) {
 635                   if (Cache[ConflictPkg].Keep() == 0 && Cache[ConflictPkg].InstallVer != 0) {
 636                       if (Debug)
 637                         cout << "Unpacking " << ConflictPkg.Name() << " to prevent conflict" << endl;
 638                       List->Flag(Pkg,pkgOrderList::Loop);
 639                       SmartUnPack(ConflictPkg,false);
 640                       // Remove loop to allow it to be used later if needed
 641                       List->RmFlag(Pkg,pkgOrderList::Loop);
 642                   } else {
 643                       if (EarlyRemove(ConflictPkg) == false)
 644                          return _error->Error("Internal Error, Could not early remove %s",ConflictPkg.Name());
 645                   }
 646                } else {
 647                   if (!List->IsFlag(ConflictPkg,pkgOrderList::Removed)) {
 648                       if (Debug)
 649                          cout << "Because of conficts knot, removing " << ConflictPkg.Name() << " to conflict violation" << endl;
 650                       if (EarlyRemove(ConflictPkg) == false)
 651                           return _error->Error("Internal Error, Could not early remove %s",ConflictPkg.Name());
 652                   }
 653                }
 654             }
 655          }
 656       }
 657
 658       // Check for breaks
 659       if (End->Type == pkgCache::Dep::DpkgBreaks) {
 660          SPtrArray<Version *> VList = End.AllTargets();
 661          for (Version **I = VList; *I != 0; I++)
 662          {
 663             VerIterator Ver(Cache,*I);
 664             PkgIterator BrokenPkg = Ver.ParentPkg();
 665             VerIterator InstallVer(Cache,Cache[BrokenPkg].InstallVer);
 666
 667             // Check if it needs to be unpacked
 668             if (List->IsFlag(BrokenPkg,pkgOrderList::InList) && Cache[BrokenPkg].Delete() == false &&
 669                 !List->IsFlag(BrokenPkg,pkgOrderList::Loop) && List->IsNow(BrokenPkg)) {
 670               List->Flag(Pkg,pkgOrderList::Loop);
 671               // Found a break, so unpack the package
 672               if (Debug)
 673                  cout << "  Unpacking " << BrokenPkg.Name() << " to avoid break" << endl;
 674
 675               SmartUnPack(BrokenPkg, false);
 676               List->RmFlag(Pkg,pkgOrderList::Loop);
 677             }
 678             // Check if a package needs to be removed
 679             if (Cache[BrokenPkg].Delete() == true && !List->IsFlag(BrokenPkg,pkgOrderList::Configured)) {
 680               if (Debug)
 681                  cout << "  Removing " << BrokenPkg.Name() << " to avoid break" << endl;
 682               SmartRemove(BrokenPkg);
 683             }
 684          }
 685       }
 686    }
 687
 688    // Check for reverse conflicts.
 689    if (CheckRConflicts(Pkg,Pkg.RevDependsList(),
 690                    instVer.VerStr()) == false)
 691                           return false;
 692
 693    for (PrvIterator P = instVer.ProvidesList();
 694           P.end() == false; P++)
 695         CheckRConflicts(Pkg,P.ParentPkg().RevDependsList(),P.ProvideVersion());
 696
 697    List->Flag(Pkg,pkgOrderList::UnPacked,pkgOrderList::States);
 698
 699    if (instVer->MultiArch == pkgCache::Version::Same)
 700       for (PkgIterator P = Pkg.Group().PackageList();
 701          P.end() == false; P = Pkg.Group().NextPkg(P))
 702       {
 703          if (Pkg == P || List->IsFlag(P,pkgOrderList::UnPacked) == true ||
 704                Cache[P].InstallVer == 0 || (P.CurrentVer() == Cache[P].InstallVer &&
 705                 (Cache[Pkg].iFlags & pkgDepCache::ReInstall) != pkgDepCache::ReInstall))
 706            continue;
 707            SmartUnPack(P, false);
 708       }
 709
 710    if(Install(Pkg,FileNames[Pkg->ID]) == false)
 711       return false;
 712
 713    if (Immediate == true && List->IsFlag(Pkg,pkgOrderList::Immediate) == true) {
 714
 715       // Perform immedate configuration of the package.
 716          if (SmartConfigure(Pkg) == false)
 717             _error->Warning(_("Could not perform immediate configuration on '%s'. "
 718                "Please see man 5 apt.conf under APT::Immediate-Configure for details. (%d)"),Pkg.Name(),2);
 719    }
 720
 721    return true;
 722 }
 723                                                                         /*}}}*/
 724 // PM::OrderInstall - Installation ordering routine                     /*{{{*/
 725 // ---------------------------------------------------------------------
 726 /* */
 727 pkgPackageManager::OrderResult pkgPackageManager::OrderInstall()
 728 {
 729    if (CreateOrderList() == false)
 730       return Failed;
 731
 732    Reset();
 733
 734    if (Debug == true)
 735       clog << "Beginning to order" << endl;
 736
 737    bool const ordering =
 738         _config->FindB("PackageManager::UnpackAll",true) ?
 739                 List->OrderUnpack(FileNames) : List->OrderCritical();
 740    if (ordering == false)
 741    {
 742       _error->Error("Internal ordering error");
 743       return Failed;
 744    }
 745
 746    if (Debug == true)
 747       clog << "Done ordering" << endl;
 748
 749    bool DoneSomething = false;
 750    for (pkgOrderList::iterator I = List->begin(); I != List->end(); I++)
 751    {
 752       PkgIterator Pkg(Cache,*I);
 753
 754       if (List->IsNow(Pkg) == false)
 755       {
 756          if (!List->IsFlag(Pkg,pkgOrderList::Configured) && !NoImmConfigure) {
 757             if (SmartConfigure(Pkg) == false && Debug)
 758                _error->Warning("Internal Error, Could not configure %s",Pkg.Name());
 759             // FIXME: The above warning message might need changing
 760          } else {
 761             if (Debug == true)
 762                clog << "Skipping already done " << Pkg.Name() << endl;
 763          }
 764          continue;
 765
 766       }
 767
 768       if (List->IsMissing(Pkg) == true)
 769       {
 770          if (Debug == true)
 771             clog << "Sequence completed at " << Pkg.Name() << endl;
 772          if (DoneSomething == false)
 773          {
 774             _error->Error("Internal Error, ordering was unable to handle the media swap");
 775             return Failed;
 776          }
 777          return Incomplete;
 778       }
 779
 780       // Sanity check
 781       if (Cache[Pkg].Keep() == true &&
 782           Pkg.State() == pkgCache::PkgIterator::NeedsNothing &&
 783           (Cache[Pkg].iFlags & pkgDepCache::ReInstall) != pkgDepCache::ReInstall)
 784       {
 785          _error->Error("Internal Error, trying to manipulate a kept package (%s)",Pkg.Name());
 786          return Failed;
 787       }
 788
 789       // Perform a delete or an install
 790       if (Cache[Pkg].Delete() == true)
 791       {
 792          if (SmartRemove(Pkg) == false)
 793             return Failed;
 794       }
 795       else
 796          if (SmartUnPack(Pkg) == false)
 797             return Failed;
 798       DoneSomething = true;
 799
 800       if (ImmConfigureAll) {
 801          /* ConfigureAll here to pick up and packages left unconfigured becuase they were unpacked in the
 802             "PreUnpack Checks" section */
 803          if (!ConfigureAll())
 804             return Failed;
 805       }
 806    }
 807
 808    // Final run through the configure phase
 809    if (ConfigureAll() == false)
 810       return Failed;
 811
 812    // Sanity check
 813    for (pkgOrderList::iterator I = List->begin(); I != List->end(); I++)
 814    {
 815       if (List->IsFlag(*I,pkgOrderList::Configured) == false)
 816       {
 817          _error->Error("Internal error, packages left unconfigured. %s",
 818                        PkgIterator(Cache,*I).Name());
 819          return Failed;
 820       }
 821    }
 822
 823    return Completed;
 824 }
 825                                                                         /*}}}*/
 826 // PM::DoInstallPostFork - Does install part that happens after the fork /*{{{*/
 827 // ---------------------------------------------------------------------
 828 pkgPackageManager::OrderResult
 829 pkgPackageManager::DoInstallPostFork(int statusFd)
 830 {
 831       if(statusFd > 0)
 832          // FIXME: use SetCloseExec here once it taught about throwing
 833          //        exceptions instead of doing _exit(100) on failure
 834          fcntl(statusFd,F_SETFD,FD_CLOEXEC);
 835       bool goResult = Go(statusFd);
 836       if(goResult == false)
 837          return Failed;
 838
 839       return Res;
 840 };
 841
 842 // PM::DoInstall - Does the installation                                /*{{{*/
 843 // ---------------------------------------------------------------------
 844 /* This uses the filenames in FileNames and the information in the
 845    DepCache to perform the installation of packages.*/
 846 pkgPackageManager::OrderResult pkgPackageManager::DoInstall(int statusFd)
 847 {
 848    if(DoInstallPreFork() == Failed)
 849       return Failed;
 850
 851    return DoInstallPostFork(statusFd);
 852 }
 853                                                                         /*}}}*/