apt-pkg/packagemanager.cc

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 // $Id: packagemanager.cc,v 1.30 2003/04/27 03:04:15 doogie Exp $
   4 /* ######################################################################
   5
   6    Package Manager - Abstacts the package manager
   7
   8    More work is needed in the area of transitioning provides, ie exim
   9    replacing smail. This can cause interesing side effects.
  10
  11    Other cases involving conflicts+replaces should be tested.
  12
  13    ##################################################################### */
  14                                                                         /*}}}*/
  15 // Include Files                                                        /*{{{*/
  16 #include<config.h>
  17
  18 #include <apt-pkg/packagemanager.h>
  19 #include <apt-pkg/orderlist.h>
  20 #include <apt-pkg/depcache.h>
  21 #include <apt-pkg/error.h>
  22 #include <apt-pkg/version.h>
  23 #include <apt-pkg/acquire-item.h>
  24 #include <apt-pkg/algorithms.h>
  25 #include <apt-pkg/configuration.h>
  26 #include <apt-pkg/sptr.h>
  27
  28 #include <apti18n.h>
  29 #include <iostream>
  30 #include <fcntl.h>
  31                                                                         /*}}}*/
  32 using namespace std;
  33
  34 bool pkgPackageManager::SigINTStop = false;
  35
  36 // PM::PackageManager - Constructor                                     /*{{{*/
  37 // ---------------------------------------------------------------------
  38 /* */
  39 pkgPackageManager::pkgPackageManager(pkgDepCache *pCache) : Cache(*pCache)
  40 {
  41    FileNames = new string[Cache.Head().PackageCount];
  42    List = 0;
  43    Debug = _config->FindB("Debug::pkgPackageManager",false);
  44 }
  45                                                                         /*}}}*/
  46 // PM::PackageManager - Destructor                                      /*{{{*/
  47 // ---------------------------------------------------------------------
  48 /* */
  49 pkgPackageManager::~pkgPackageManager()
  50 {
  51    delete List;
  52    delete [] FileNames;
  53 }
  54                                                                         /*}}}*/
  55 // PM::GetArchives - Queue the archives for download                    /*{{{*/
  56 // ---------------------------------------------------------------------
  57 /* */
  58 bool pkgPackageManager::GetArchives(pkgAcquire *Owner,pkgSourceList *Sources,
  59                                     pkgRecords *Recs)
  60 {
  61    if (CreateOrderList() == false)
  62       return false;
  63
  64    bool const ordering =
  65         _config->FindB("PackageManager::UnpackAll",true) ?
  66                 List->OrderUnpack() : List->OrderCritical();
  67    if (ordering == false)
  68       return _error->Error("Internal ordering error");
  69
  70    for (pkgOrderList::iterator I = List->begin(); I != List->end(); ++I)
  71    {
  72       PkgIterator Pkg(Cache,*I);
  73       FileNames[Pkg->ID] = string();
  74
  75       // Skip packages to erase
  76       if (Cache[Pkg].Delete() == true)
  77          continue;
  78
  79       // Skip Packages that need configure only.
  80       if (Pkg.State() == pkgCache::PkgIterator::NeedsConfigure &&
  81           Cache[Pkg].Keep() == true)
  82          continue;
  83
  84       // Skip already processed packages
  85       if (List->IsNow(Pkg) == false)
  86          continue;
  87
  88       new pkgAcqArchive(Owner,Sources,Recs,Cache[Pkg].InstVerIter(Cache),
  89                         FileNames[Pkg->ID]);
  90    }
  91
  92    return true;
  93 }
  94                                                                         /*}}}*/
  95 // PM::FixMissing - Keep all missing packages                           /*{{{*/
  96 // ---------------------------------------------------------------------
  97 /* This is called to correct the installation when packages could not
  98    be downloaded. */
  99 bool pkgPackageManager::FixMissing()
 100 {
 101    pkgDepCache::ActionGroup group(Cache);
 102    pkgProblemResolver Resolve(&Cache);
 103    List->SetFileList(FileNames);
 104
 105    bool Bad = false;
 106    for (PkgIterator I = Cache.PkgBegin(); I.end() == false; ++I)
 107    {
 108       if (List->IsMissing(I) == false)
 109          continue;
 110
 111       // Okay, this file is missing and we need it. Mark it for keep
 112       Bad = true;
 113       Cache.MarkKeep(I, false, false);
 114    }
 115
 116    // We have to empty the list otherwise it will not have the new changes
 117    delete List;
 118    List = 0;
 119
 120    if (Bad == false)
 121       return true;
 122
 123    // Now downgrade everything that is broken
 124    return Resolve.ResolveByKeep() == true && Cache.BrokenCount() == 0;
 125 }
 126                                                                         /*}}}*/
 127 // PM::ImmediateAdd - Add the immediate flag recursivly                 /*{{{*/
 128 // ---------------------------------------------------------------------
 129 /* This adds the immediate flag to the pkg and recursively to the
 130    dependendies
 131  */
 132 void pkgPackageManager::ImmediateAdd(PkgIterator I, bool UseInstallVer, unsigned const int &Depth)
 133 {
 134    DepIterator D;
 135
 136    if(UseInstallVer)
 137    {
 138       if(Cache[I].InstallVer == 0)
 139          return;
 140       D = Cache[I].InstVerIter(Cache).DependsList();
 141    } else {
 142       if (I->CurrentVer == 0)
 143          return;
 144       D = I.CurrentVer().DependsList();
 145    }
 146
 147    for ( /* nothing */  ; D.end() == false; ++D)
 148       if (D->Type == pkgCache::Dep::Depends || D->Type == pkgCache::Dep::PreDepends)
 149       {
 150          if(!List->IsFlag(D.TargetPkg(), pkgOrderList::Immediate))
 151          {
 152             if(Debug)
 153                clog << OutputInDepth(Depth) << "ImmediateAdd(): Adding Immediate flag to " << D.TargetPkg() << " cause of " << D.DepType() << " " << I.Name() << endl;
 154             List->Flag(D.TargetPkg(),pkgOrderList::Immediate);
 155             ImmediateAdd(D.TargetPkg(), UseInstallVer, Depth + 1);
 156          }
 157       }
 158    return;
 159 }
 160                                                                         /*}}}*/
 161 // PM::CreateOrderList - Create the ordering class                      /*{{{*/
 162 // ---------------------------------------------------------------------
 163 /* This populates the ordering list with all the packages that are
 164    going to change. */
 165 bool pkgPackageManager::CreateOrderList()
 166 {
 167    if (List != 0)
 168       return true;
 169
 170    delete List;
 171    List = new pkgOrderList(&Cache);
 172
 173    NoImmConfigure = !_config->FindB("APT::Immediate-Configure",true);
 174    ImmConfigureAll = _config->FindB("APT::Immediate-Configure-All",false);
 175
 176    if (Debug && ImmConfigureAll)
 177       clog << "CreateOrderList(): Adding Immediate flag for all packages because of APT::Immediate-Configure-All" << endl;
 178
 179    // Generate the list of affected packages and sort it
 180    for (PkgIterator I = Cache.PkgBegin(); I.end() == false; ++I)
 181    {
 182       // Ignore no-version packages
 183       if (I->VersionList == 0)
 184          continue;
 185
 186       // Mark the package and its dependends for immediate configuration
 187       if ((((I->Flags & pkgCache::Flag::Essential) == pkgCache::Flag::Essential) &&
 188           NoImmConfigure == false) || ImmConfigureAll)
 189       {
 190          if(Debug && !ImmConfigureAll)
 191             clog << "CreateOrderList(): Adding Immediate flag for " << I.Name() << endl;
 192          List->Flag(I,pkgOrderList::Immediate);
 193
 194          if (!ImmConfigureAll) {
 195             // Look for other install packages to make immediate configurea
 196             ImmediateAdd(I, true);
 197
 198             // And again with the current version.
 199             ImmediateAdd(I, false);
 200          }
 201       }
 202
 203       // Not interesting
 204       if ((Cache[I].Keep() == true ||
 205           Cache[I].InstVerIter(Cache) == I.CurrentVer()) &&
 206           I.State() == pkgCache::PkgIterator::NeedsNothing &&
 207           (Cache[I].iFlags & pkgDepCache::ReInstall) != pkgDepCache::ReInstall &&
 208           (I.Purge() != false || Cache[I].Mode != pkgDepCache::ModeDelete ||
 209            (Cache[I].iFlags & pkgDepCache::Purge) != pkgDepCache::Purge))
 210          continue;
 211
 212       // Append it to the list
 213       List->push_back(I);
 214    }
 215
 216    return true;
 217 }
 218                                                                         /*}}}*/
 219 // PM::DepAlwaysTrue - Returns true if this dep is irrelevent           /*{{{*/
 220 // ---------------------------------------------------------------------
 221 /* The restriction on provides is to eliminate the case when provides
 222    are transitioning between valid states [ie exim to smail] */
 223 bool pkgPackageManager::DepAlwaysTrue(DepIterator D)
 224 {
 225    if (D.TargetPkg()->ProvidesList != 0)
 226       return false;
 227
 228    if ((Cache[D] & pkgDepCache::DepInstall) != 0 &&
 229        (Cache[D] & pkgDepCache::DepNow) != 0)
 230       return true;
 231    return false;
 232 }
 233                                                                         /*}}}*/
 234 // PM::CheckRConflicts - Look for reverse conflicts                     /*{{{*/
 235 // ---------------------------------------------------------------------
 236 /* This looks over the reverses for a conflicts line that needs early
 237    removal. */
 238 bool pkgPackageManager::CheckRConflicts(PkgIterator Pkg,DepIterator D,
 239                                         const char *Ver)
 240 {
 241    for (;D.end() == false; ++D)
 242    {
 243       if (D->Type != pkgCache::Dep::Conflicts &&
 244           D->Type != pkgCache::Dep::Obsoletes)
 245          continue;
 246
 247       // The package hasnt been changed
 248       if (List->IsNow(Pkg) == false)
 249          continue;
 250
 251       // Ignore self conflicts, ignore conflicts from irrelevent versions
 252       if (D.IsIgnorable(Pkg) || D.ParentVer() != D.ParentPkg().CurrentVer())
 253          continue;
 254
 255       if (Cache.VS().CheckDep(Ver,D->CompareOp,D.TargetVer()) == false)
 256          continue;
 257
 258       if (EarlyRemove(D.ParentPkg()) == false)
 259          return _error->Error("Reverse conflicts early remove for package '%s' failed",
 260                               Pkg.Name());
 261    }
 262    return true;
 263 }
 264                                                                         /*}}}*/
 265 // PM::ConfigureAll - Run the all out configuration                     /*{{{*/
 266 // ---------------------------------------------------------------------
 267 /* This configures every package. It is assumed they are all unpacked and
 268    that the final configuration is valid. This is also used to catch packages
 269    that have not been configured when using ImmConfigureAll */
 270 bool pkgPackageManager::ConfigureAll()
 271 {
 272    pkgOrderList OList(&Cache);
 273
 274    // Populate the order list
 275    for (pkgOrderList::iterator I = List->begin(); I != List->end(); ++I)
 276       if (List->IsFlag(pkgCache::PkgIterator(Cache,*I),
 277                        pkgOrderList::UnPacked) == true)
 278          OList.push_back(*I);
 279
 280    if (OList.OrderConfigure() == false)
 281       return false;
 282
 283    std::string const conf = _config->Find("PackageManager::Configure","all");
 284    bool const ConfigurePkgs = (conf == "all");
 285
 286    // Perform the configuring
 287    for (pkgOrderList::iterator I = OList.begin(); I != OList.end(); ++I)
 288    {
 289       PkgIterator Pkg(Cache,*I);
 290
 291       /* Check if the package has been configured, this can happen if SmartConfigure
 292          calls its self */
 293       if (List->IsFlag(Pkg,pkgOrderList::Configured)) continue;
 294
 295       if (ConfigurePkgs == true && SmartConfigure(Pkg, 0) == false) {
 296          if (ImmConfigureAll)
 297             _error->Error(_("Could not perform immediate configuration on '%s'. "
 298                         "Please see man 5 apt.conf under APT::Immediate-Configure for details. (%d)"),Pkg.Name(),1);
 299          else
 300             _error->Error("Internal error, packages left unconfigured. %s",Pkg.Name());
 301          return false;
 302       }
 303
 304       List->Flag(Pkg,pkgOrderList::Configured,pkgOrderList::States);
 305    }
 306
 307    return true;
 308 }
 309                                                                         /*}}}*/
 310 // PM::SmartConfigure - Perform immediate configuration of the pkg      /*{{{*/
 311 // ---------------------------------------------------------------------
 312 /* This function tries to put the system in a state where Pkg can be configured.
 313    This involves checking each of Pkg's dependanies and unpacking and
 314    configuring packages where needed.
 315
 316    Note on failure: This method can fail, without causing any problems.
 317    This can happen when using Immediate-Configure-All, SmartUnPack may call
 318    SmartConfigure, it may fail because of a complex dependancy situation, but
 319    a error will only be reported if ConfigureAll fails. This is why some of the
 320    messages this function reports on failure (return false;) as just warnings
 321    only shown when debuging*/
 322 bool pkgPackageManager::SmartConfigure(PkgIterator Pkg, int const Depth)
 323 {
 324    // If this is true, only check and correct and dependencies without the Loop flag
 325    bool PkgLoop = List->IsFlag(Pkg,pkgOrderList::Loop);
 326
 327    if (Debug) {
 328       VerIterator InstallVer = VerIterator(Cache,Cache[Pkg].InstallVer);
 329       clog << OutputInDepth(Depth) << "SmartConfigure " << Pkg.Name() << " (" << InstallVer.VerStr() << ")";
 330       if (PkgLoop)
 331         clog << " (Only Correct Dependencies)";
 332       clog << endl;
 333    }
 334
 335    VerIterator const instVer = Cache[Pkg].InstVerIter(Cache);
 336
 337    /* Because of the ordered list, most dependencies should be unpacked,
 338       however if there is a loop (A depends on B, B depends on A) this will not
 339       be the case, so check for dependencies before configuring. */
 340    bool Bad = false;
 341    for (DepIterator D = instVer.DependsList();
 342         D.end() == false; )
 343    {
 344       // Compute a single dependency element (glob or)
 345       pkgCache::DepIterator Start;
 346       pkgCache::DepIterator End;
 347       D.GlobOr(Start,End);
 348
 349       if (End->Type == pkgCache::Dep::Depends)
 350           Bad = true;
 351
 352       // Check for dependanices that have not been unpacked, probably due to loops.
 353       while (End->Type == pkgCache::Dep::Depends) {
 354          PkgIterator DepPkg;
 355          VerIterator InstallVer;
 356          SPtrArray<Version *> VList = Start.AllTargets();
 357
 358          // Check through each version of each package that could satisfy this dependancy
 359          for (Version **I = VList; *I != 0; I++) {
 360             VerIterator Ver(Cache,*I);
 361             DepPkg = Ver.ParentPkg();
 362             InstallVer = VerIterator(Cache,Cache[DepPkg].InstallVer);
 363
 364             // Check if the current version of the package is avalible and will satisfy this dependancy
 365             if (DepPkg.CurrentVer() == Ver && List->IsNow(DepPkg) == true &&
 366                 !List->IsFlag(DepPkg,pkgOrderList::Removed) && DepPkg.State() == PkgIterator::NeedsNothing)
 367             {
 368                Bad = false;
 369                break;
 370             }
 371
 372             // Check if the version that is going to be installed will satisfy the dependancy
 373             if (Cache[DepPkg].InstallVer == *I) {
 374                if (List->IsFlag(DepPkg,pkgOrderList::UnPacked)) {
 375                   if (List->IsFlag(DepPkg,pkgOrderList::Loop) && PkgLoop) {
 376                     // This dependancy has already been dealt with by another SmartConfigure on Pkg
 377                     Bad = false;
 378                     break;
 379                   } else if (List->IsFlag(Pkg,pkgOrderList::Loop)) {
 380                     /* Check for a loop to prevent one forming
 381                        If A depends on B and B depends on A, SmartConfigure will
 382                        just hop between them if this is not checked. Dont remove the
 383                        loop flag after finishing however as loop is already set.
 384                        This means that there is another SmartConfigure call for this
 385                        package and it will remove the loop flag */
 386                      Bad = !SmartConfigure(DepPkg, Depth + 1);
 387                   } else {
 388                     /* Check for a loop to prevent one forming
 389                        If A depends on B and B depends on A, SmartConfigure will
 390                        just hop between them if this is not checked */
 391                     List->Flag(Pkg,pkgOrderList::Loop);
 392                     Bad = !SmartConfigure(DepPkg, Depth + 1);
 393                     List->RmFlag(Pkg,pkgOrderList::Loop);
 394                   }
 395                   // If SmartConfigure was succesfull, Bad is false, so break
 396                   if (!Bad) break;
 397                } else if (List->IsFlag(DepPkg,pkgOrderList::Configured)) {
 398                   Bad = false;
 399                   break;
 400                }
 401             }
 402          }
 403
 404          /* If the dependany is still not satisfied, try, if possible, unpacking a package to satisfy it */
 405          if (InstallVer != 0 && Bad) {
 406             if (List->IsNow(DepPkg)) {
 407                Bad = false;
 408                if (List->IsFlag(Pkg,pkgOrderList::Loop))
 409                {
 410                   if (Debug)
 411                      std::clog << OutputInDepth(Depth) << "Package " << Pkg << " loops in SmartConfigure" << std::endl;
 412                }
 413                else
 414                {
 415                   List->Flag(Pkg,pkgOrderList::Loop);
 416                   if (Debug)
 417                      cout << OutputInDepth(Depth) << "Unpacking " << DepPkg.Name() << " to avoid loop" << endl;
 418                   SmartUnPack(DepPkg, true, Depth + 1);
 419                   List->RmFlag(Pkg,pkgOrderList::Loop);
 420                }
 421             }
 422          }
 423
 424          if (Start==End) {
 425             if (Bad && Debug && List->IsFlag(DepPkg,pkgOrderList::Loop) == false)
 426                   std::clog << OutputInDepth(Depth) << "Could not satisfy dependencies for " << Pkg.Name() << std::endl;
 427             break;
 428          } else {
 429             Start++;
 430          }
 431       }
 432    }
 433
 434    if (Bad) {
 435       if (Debug)
 436          _error->Warning(_("Could not configure '%s'. "),Pkg.Name());
 437       return false;
 438    }
 439
 440    if (PkgLoop) return true;
 441
 442    static std::string const conf = _config->Find("PackageManager::Configure","all");
 443    static bool const ConfigurePkgs = (conf == "all" || conf == "smart");
 444
 445    if (List->IsFlag(Pkg,pkgOrderList::Configured))
 446       return _error->Error("Internal configure error on '%s'.", Pkg.Name());
 447
 448    if (ConfigurePkgs == true && Configure(Pkg) == false)
 449       return false;
 450
 451    List->Flag(Pkg,pkgOrderList::Configured,pkgOrderList::States);
 452
 453    if ((Cache[Pkg].InstVerIter(Cache)->MultiArch & pkgCache::Version::Same) == pkgCache::Version::Same)
 454       for (PkgIterator P = Pkg.Group().PackageList();
 455            P.end() == false; P = Pkg.Group().NextPkg(P))
 456       {
 457          if (Pkg == P || List->IsFlag(P,pkgOrderList::Configured) == true ||
 458              Cache[P].InstallVer == 0 || (P.CurrentVer() == Cache[P].InstallVer &&
 459               (Cache[Pkg].iFlags & pkgDepCache::ReInstall) != pkgDepCache::ReInstall))
 460             continue;
 461          SmartConfigure(P, (Depth +1));
 462       }
 463
 464    // Sanity Check
 465    if (List->IsFlag(Pkg,pkgOrderList::Configured) == false)
 466       return _error->Error(_("Could not configure '%s'. "),Pkg.Name());
 467
 468    return true;
 469 }
 470                                                                         /*}}}*/
 471 // PM::EarlyRemove - Perform removal of packages before their time      /*{{{*/
 472 // ---------------------------------------------------------------------
 473 /* This is called to deal with conflicts arising from unpacking */
 474 bool pkgPackageManager::EarlyRemove(PkgIterator Pkg)
 475 {
 476    if (List->IsNow(Pkg) == false)
 477       return true;
 478
 479    // Already removed it
 480    if (List->IsFlag(Pkg,pkgOrderList::Removed) == true)
 481       return true;
 482
 483    // Woops, it will not be re-installed!
 484    if (List->IsFlag(Pkg,pkgOrderList::InList) == false)
 485       return false;
 486
 487    // Essential packages get special treatment
 488    bool IsEssential = false;
 489    if ((Pkg->Flags & pkgCache::Flag::Essential) != 0)
 490       IsEssential = true;
 491
 492    /* Check for packages that are the dependents of essential packages and
 493       promote them too */
 494    if (Pkg->CurrentVer != 0)
 495    {
 496       for (DepIterator D = Pkg.RevDependsList(); D.end() == false &&
 497            IsEssential == false; ++D)
 498          if (D->Type == pkgCache::Dep::Depends || D->Type == pkgCache::Dep::PreDepends)
 499             if ((D.ParentPkg()->Flags & pkgCache::Flag::Essential) != 0)
 500                IsEssential = true;
 501    }
 502
 503    if (IsEssential == true)
 504    {
 505       if (_config->FindB("APT::Force-LoopBreak",false) == false)
 506          return _error->Error(_("This installation run will require temporarily "
 507                                 "removing the essential package %s due to a "
 508                                 "Conflicts/Pre-Depends loop. This is often bad, "
 509                                 "but if you really want to do it, activate the "
 510                                 "APT::Force-LoopBreak option."),Pkg.Name());
 511    }
 512
 513    bool Res = SmartRemove(Pkg);
 514    if (Cache[Pkg].Delete() == false)
 515       List->Flag(Pkg,pkgOrderList::Removed,pkgOrderList::States);
 516
 517    return Res;
 518 }
 519                                                                         /*}}}*/
 520 // PM::SmartRemove - Removal Helper                                     /*{{{*/
 521 // ---------------------------------------------------------------------
 522 /* */
 523 bool pkgPackageManager::SmartRemove(PkgIterator Pkg)
 524 {
 525    if (List->IsNow(Pkg) == false)
 526       return true;
 527
 528    List->Flag(Pkg,pkgOrderList::Configured,pkgOrderList::States);
 529
 530    return Remove(Pkg,(Cache[Pkg].iFlags & pkgDepCache::Purge) == pkgDepCache::Purge);
 531 }
 532                                                                         /*}}}*/
 533 // PM::SmartUnPack - Install helper                                     /*{{{*/
 534 // ---------------------------------------------------------------------
 535 /* This puts the system in a state where it can Unpack Pkg, if Pkg is allready
 536    unpacked, or when it has been unpacked, if Immediate==true it configures it. */
 537 bool pkgPackageManager::SmartUnPack(PkgIterator Pkg)
 538 {
 539    return SmartUnPack(Pkg, true, 0);
 540 }
 541 bool pkgPackageManager::SmartUnPack(PkgIterator Pkg, bool const Immediate, int const Depth)
 542 {
 543    bool PkgLoop = List->IsFlag(Pkg,pkgOrderList::Loop);
 544
 545    if (Debug) {
 546       clog << OutputInDepth(Depth) << "SmartUnPack " << Pkg.Name();
 547       VerIterator InstallVer = VerIterator(Cache,Cache[Pkg].InstallVer);
 548       if (Pkg.CurrentVer() == 0)
 549         cout << " (install version " << InstallVer.VerStr() << ")";
 550       else
 551         cout << " (replace version " << Pkg.CurrentVer().VerStr() << " with " << InstallVer.VerStr() << ")";
 552       if (PkgLoop)
 553         cout << " (Only Perform PreUnpack Checks)";
 554       cout << endl;
 555    }
 556
 557    VerIterator const instVer = Cache[Pkg].InstVerIter(Cache);
 558
 559    /* PreUnpack Checks: This loop checks and attempts to rectify and problems that would prevent the package being unpacked.
 560       It addresses: PreDepends, Conflicts, Obsoletes and Breaks (DpkgBreaks). Any resolutions that do not require it should
 561       avoid configuration (calling SmartUnpack with Immediate=true), this is because when unpacking some packages with
 562       complex dependancy structures, trying to configure some packages while breaking the loops can complicate things .
 563       This will be either dealt with if the package is configured as a dependency of Pkg (if and when Pkg is configured),
 564       or by the ConfigureAll call at the end of the for loop in OrderInstall. */
 565    for (DepIterator D = instVer.DependsList();
 566         D.end() == false; )
 567    {
 568       // Compute a single dependency element (glob or)
 569       pkgCache::DepIterator Start;
 570       pkgCache::DepIterator End;
 571       D.GlobOr(Start,End);
 572
 573       while (End->Type == pkgCache::Dep::PreDepends)
 574       {
 575          if (Debug)
 576             clog << OutputInDepth(Depth) << "PreDepends order for " << Pkg.Name() << std::endl;
 577
 578          // Look for possible ok targets.
 579          SPtrArray<Version *> VList = Start.AllTargets();
 580          bool Bad = true;
 581          for (Version **I = VList; *I != 0 && Bad == true; I++)
 582          {
 583             VerIterator Ver(Cache,*I);
 584             PkgIterator Pkg = Ver.ParentPkg();
 585
 586             // See if the current version is ok
 587             if (Pkg.CurrentVer() == Ver && List->IsNow(Pkg) == true &&
 588                 Pkg.State() == PkgIterator::NeedsNothing)
 589             {
 590                Bad = false;
 591                if (Debug)
 592                   clog << OutputInDepth(Depth) << "Found ok package " << Pkg.Name() << endl;
 593                continue;
 594             }
 595          }
 596
 597          // Look for something that could be configured.
 598          for (Version **I = VList; *I != 0 && Bad == true; I++)
 599          {
 600             VerIterator Ver(Cache,*I);
 601             PkgIterator Pkg = Ver.ParentPkg();
 602
 603             // Not the install version
 604             if (Cache[Pkg].InstallVer != *I ||
 605                 (Cache[Pkg].Keep() == true && Pkg.State() == PkgIterator::NeedsNothing))
 606                continue;
 607
 608             if (List->IsFlag(Pkg,pkgOrderList::Configured)) {
 609                Bad = false;
 610                continue;
 611             }
 612
 613             if (Debug)
 614                clog << OutputInDepth(Depth) << "Trying to SmartConfigure " << Pkg.Name() << endl;
 615             Bad = !SmartConfigure(Pkg, Depth + 1);
 616          }
 617
 618          /* If this or element did not match then continue on to the
 619             next or element until a matching element is found */
 620          if (Bad == true)
 621          {
 622             // This triggers if someone make a pre-depends/depend loop.
 623             if (Start == End)
 624                return _error->Error("Couldn't configure pre-depend %s for %s, "
 625                                     "probably a dependency cycle.",
 626                                     End.TargetPkg().Name(),Pkg.Name());
 627             ++Start;
 628          }
 629          else
 630             break;
 631       }
 632
 633       if (End->Type == pkgCache::Dep::Conflicts ||
 634           End->Type == pkgCache::Dep::Obsoletes)
 635       {
 636          /* Look for conflicts. Two packages that are both in the install
 637             state cannot conflict so we don't check.. */
 638          SPtrArray<Version *> VList = End.AllTargets();
 639          for (Version **I = VList; *I != 0; I++)
 640          {
 641             VerIterator Ver(Cache,*I);
 642             PkgIterator ConflictPkg = Ver.ParentPkg();
 643             VerIterator InstallVer(Cache,Cache[ConflictPkg].InstallVer);
 644
 645             // See if the current version is conflicting
 646             if (ConflictPkg.CurrentVer() == Ver && List->IsNow(ConflictPkg))
 647             {
 648                cout << OutputInDepth(Depth) << Pkg.Name() << " conflicts with " << ConflictPkg.Name() << endl;
 649                /* If a loop is not present or has not yet been detected, attempt to unpack packages
 650                   to resolve this conflict. If there is a loop present, remove packages to resolve this conflict */
 651                if (!List->IsFlag(ConflictPkg,pkgOrderList::Loop)) {
 652                   if (Cache[ConflictPkg].Keep() == 0 && Cache[ConflictPkg].InstallVer != 0) {
 653                       if (Debug)
 654                         cout << OutputInDepth(Depth) << OutputInDepth(Depth) << "Unpacking " << ConflictPkg.Name() << " to prevent conflict" << endl;
 655                       List->Flag(Pkg,pkgOrderList::Loop);
 656                       SmartUnPack(ConflictPkg,false, Depth + 1);
 657                       // Remove loop to allow it to be used later if needed
 658                       List->RmFlag(Pkg,pkgOrderList::Loop);
 659                   } else {
 660                       if (EarlyRemove(ConflictPkg) == false)
 661                          return _error->Error("Internal Error, Could not early remove %s",ConflictPkg.Name());
 662                   }
 663                } else {
 664                   if (!List->IsFlag(ConflictPkg,pkgOrderList::Removed)) {
 665                       if (Debug)
 666                          cout << OutputInDepth(Depth) << "Because of conficts knot, removing " << ConflictPkg.Name() << " to conflict violation" << endl;
 667                       if (EarlyRemove(ConflictPkg) == false)
 668                           return _error->Error("Internal Error, Could not early remove %s",ConflictPkg.Name());
 669                   }
 670                }
 671             }
 672          }
 673       }
 674
 675       // Check for breaks
 676       if (End->Type == pkgCache::Dep::DpkgBreaks) {
 677          SPtrArray<Version *> VList = End.AllTargets();
 678          for (Version **I = VList; *I != 0; I++)
 679          {
 680             VerIterator Ver(Cache,*I);
 681             PkgIterator BrokenPkg = Ver.ParentPkg();
 682             VerIterator InstallVer(Cache,Cache[BrokenPkg].InstallVer);
 683             if (BrokenPkg.CurrentVer() != Ver)
 684             {
 685                if (Debug)
 686                   std::clog << OutputInDepth(Depth) << "  Ignore not-installed version " << Ver.VerStr() << " of " << Pkg.FullName() << " for " << End << std::endl;
 687                continue;
 688             }
 689
 690             // Check if it needs to be unpacked
 691             if (List->IsFlag(BrokenPkg,pkgOrderList::InList) && Cache[BrokenPkg].Delete() == false &&
 692                 List->IsNow(BrokenPkg)) {
 693               if (List->IsFlag(BrokenPkg,pkgOrderList::Loop) && PkgLoop) {
 694                 // This dependancy has already been dealt with by another SmartUnPack on Pkg
 695                 break;
 696               } else if (List->IsFlag(Pkg,pkgOrderList::Loop)) {
 697                 /* Found a break, so unpack the package, but dont remove loop as already set.
 698                    This means that there is another SmartUnPack call for this
 699                    package and it will remove the loop flag. */
 700                 if (Debug)
 701                   cout << OutputInDepth(Depth) << "  Unpacking " << BrokenPkg.Name() << " to avoid break" << endl;
 702
 703                 SmartUnPack(BrokenPkg, false, Depth + 1);
 704               } else {
 705                 List->Flag(Pkg,pkgOrderList::Loop);
 706                 // Found a break, so unpack the package
 707                 if (Debug)
 708                   cout << OutputInDepth(Depth) << "  Unpacking " << BrokenPkg.Name() << " to avoid break" << endl;
 709
 710                 SmartUnPack(BrokenPkg, false, Depth + 1);
 711                 List->RmFlag(Pkg,pkgOrderList::Loop);
 712               }
 713             }
 714
 715             // Check if a package needs to be removed
 716             if (Cache[BrokenPkg].Delete() == true && !List->IsFlag(BrokenPkg,pkgOrderList::Configured)) {
 717               if (Debug)
 718                  cout << OutputInDepth(Depth) << "  Removing " << BrokenPkg.Name() << " to avoid break" << endl;
 719               SmartRemove(BrokenPkg);
 720             }
 721          }
 722       }
 723    }
 724
 725    // Check for reverse conflicts.
 726    if (CheckRConflicts(Pkg,Pkg.RevDependsList(),
 727                    instVer.VerStr()) == false)
 728                           return false;
 729
 730    for (PrvIterator P = instVer.ProvidesList();
 731         P.end() == false; ++P)
 732       if (Pkg->Group != P.OwnerPkg()->Group)
 733          CheckRConflicts(Pkg,P.ParentPkg().RevDependsList(),P.ProvideVersion());
 734
 735    if (PkgLoop)
 736       return true;
 737
 738    List->Flag(Pkg,pkgOrderList::UnPacked,pkgOrderList::States);
 739
 740    if (Immediate == true && (instVer->MultiArch & pkgCache::Version::Same) == pkgCache::Version::Same)
 741    {
 742       /* Do lockstep M-A:same unpacking in two phases:
 743          First unpack all installed architectures, then the not installed.
 744          This way we avoid that M-A: enabled packages are installed before
 745          their older non-M-A enabled packages are replaced by newer versions */
 746       bool const installed = Pkg->CurrentVer != 0;
 747       if (installed == true && Install(Pkg,FileNames[Pkg->ID]) == false)
 748          return false;
 749       for (PkgIterator P = Pkg.Group().PackageList();
 750            P.end() == false; P = Pkg.Group().NextPkg(P))
 751       {
 752          if (P->CurrentVer == 0 || P == Pkg || List->IsFlag(P,pkgOrderList::UnPacked) == true ||
 753              Cache[P].InstallVer == 0 || (P.CurrentVer() == Cache[P].InstallVer &&
 754               (Cache[Pkg].iFlags & pkgDepCache::ReInstall) != pkgDepCache::ReInstall))
 755             continue;
 756          if (SmartUnPack(P, false, Depth + 1) == false)
 757             return false;
 758       }
 759       if (installed == false && Install(Pkg,FileNames[Pkg->ID]) == false)
 760          return false;
 761       for (PkgIterator P = Pkg.Group().PackageList();
 762            P.end() == false; P = Pkg.Group().NextPkg(P))
 763       {
 764          if (P->CurrentVer != 0 || P == Pkg || List->IsFlag(P,pkgOrderList::UnPacked) == true ||
 765              Cache[P].InstallVer == 0 || (P.CurrentVer() == Cache[P].InstallVer &&
 766               (Cache[Pkg].iFlags & pkgDepCache::ReInstall) != pkgDepCache::ReInstall))
 767             continue;
 768          if (SmartUnPack(P, false, Depth + 1) == false)
 769             return false;
 770       }
 771    }
 772    // packages which are already unpacked don't need to be unpacked again
 773    else if (Pkg.State() != pkgCache::PkgIterator::NeedsConfigure && Install(Pkg,FileNames[Pkg->ID]) == false)
 774       return false;
 775
 776    if (Immediate == true) {
 777       // Perform immedate configuration of the package.
 778          if (SmartConfigure(Pkg, Depth + 1) == false)
 779             _error->Warning(_("Could not perform immediate configuration on '%s'. "
 780                "Please see man 5 apt.conf under APT::Immediate-Configure for details. (%d)"),Pkg.Name(),2);
 781    }
 782
 783    return true;
 784 }
 785                                                                         /*}}}*/
 786 // PM::OrderInstall - Installation ordering routine                     /*{{{*/
 787 // ---------------------------------------------------------------------
 788 /* */
 789 pkgPackageManager::OrderResult pkgPackageManager::OrderInstall()
 790 {
 791    if (CreateOrderList() == false)
 792       return Failed;
 793
 794    Reset();
 795
 796    if (Debug == true)
 797       clog << "Beginning to order" << endl;
 798
 799    bool const ordering =
 800         _config->FindB("PackageManager::UnpackAll",true) ?
 801                 List->OrderUnpack(FileNames) : List->OrderCritical();
 802    if (ordering == false)
 803    {
 804       _error->Error("Internal ordering error");
 805       return Failed;
 806    }
 807
 808    if (Debug == true)
 809       clog << "Done ordering" << endl;
 810
 811    bool DoneSomething = false;
 812    for (pkgOrderList::iterator I = List->begin(); I != List->end(); ++I)
 813    {
 814       PkgIterator Pkg(Cache,*I);
 815
 816       if (List->IsNow(Pkg) == false)
 817       {
 818          if (!List->IsFlag(Pkg,pkgOrderList::Configured) && !NoImmConfigure) {
 819             if (SmartConfigure(Pkg, 0) == false && Debug)
 820                _error->Warning("Internal Error, Could not configure %s",Pkg.Name());
 821             // FIXME: The above warning message might need changing
 822          } else {
 823             if (Debug == true)
 824                clog << "Skipping already done " << Pkg.Name() << endl;
 825          }
 826          continue;
 827
 828       }
 829
 830       if (List->IsMissing(Pkg) == true)
 831       {
 832          if (Debug == true)
 833             clog << "Sequence completed at " << Pkg.Name() << endl;
 834          if (DoneSomething == false)
 835          {
 836             _error->Error("Internal Error, ordering was unable to handle the media swap");
 837             return Failed;
 838          }
 839          return Incomplete;
 840       }
 841
 842       // Sanity check
 843       if (Cache[Pkg].Keep() == true &&
 844           Pkg.State() == pkgCache::PkgIterator::NeedsNothing &&
 845           (Cache[Pkg].iFlags & pkgDepCache::ReInstall) != pkgDepCache::ReInstall)
 846       {
 847          _error->Error("Internal Error, trying to manipulate a kept package (%s)",Pkg.Name());
 848          return Failed;
 849       }
 850
 851       // Perform a delete or an install
 852       if (Cache[Pkg].Delete() == true)
 853       {
 854          if (SmartRemove(Pkg) == false)
 855             return Failed;
 856       }
 857       else
 858          if (SmartUnPack(Pkg,List->IsFlag(Pkg,pkgOrderList::Immediate),0) == false)
 859             return Failed;
 860       DoneSomething = true;
 861
 862       if (ImmConfigureAll) {
 863          /* ConfigureAll here to pick up and packages left unconfigured becuase they were unpacked in the
 864             "PreUnpack Checks" section */
 865          if (!ConfigureAll())
 866             return Failed;
 867       }
 868    }
 869
 870    // Final run through the configure phase
 871    if (ConfigureAll() == false)
 872       return Failed;
 873
 874    // Sanity check
 875    for (pkgOrderList::iterator I = List->begin(); I != List->end(); ++I)
 876    {
 877       if (List->IsFlag(*I,pkgOrderList::Configured) == false)
 878       {
 879          _error->Error("Internal error, packages left unconfigured. %s",
 880                        PkgIterator(Cache,*I).Name());
 881          return Failed;
 882       }
 883    }
 884
 885    return Completed;
 886 }
 887                                                                         /*}}}*/
 888 // PM::DoInstallPostFork - Does install part that happens after the fork /*{{{*/
 889 // ---------------------------------------------------------------------
 890 pkgPackageManager::OrderResult
 891 pkgPackageManager::DoInstallPostFork(int statusFd)
 892 {
 893       if(statusFd > 0)
 894          // FIXME: use SetCloseExec here once it taught about throwing
 895          //        exceptions instead of doing _exit(100) on failure
 896          fcntl(statusFd,F_SETFD,FD_CLOEXEC);
 897       bool goResult = Go(statusFd);
 898       if(goResult == false)
 899          return Failed;
 900
 901       return Res;
 902 };
 903
 904 // PM::DoInstall - Does the installation                                /*{{{*/
 905 // ---------------------------------------------------------------------
 906 /* This uses the filenames in FileNames and the information in the
 907    DepCache to perform the installation of packages.*/
 908 pkgPackageManager::OrderResult pkgPackageManager::DoInstall(int statusFd)
 909 {
 910    if(DoInstallPreFork() == Failed)
 911       return Failed;
 912
 913    return DoInstallPostFork(statusFd);
 914 }
 915                                                                         /*}}}*/