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