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