X-Git-Url: https://git.saurik.com/apt.git/blobdiff_plain/649d3c5b7df830a67ad946921233da349c13a826..7a3b00b10b6a5a740e07fc1b68a4f3fb3bcdac23:/apt-pkg/depcache.cc diff --git a/apt-pkg/depcache.cc b/apt-pkg/depcache.cc index a06789cdf..3925d2e7c 100644 --- a/apt-pkg/depcache.cc +++ b/apt-pkg/depcache.cc @@ -11,23 +11,30 @@ #include #include -#include #include +#include #include -#include -#include #include #include #include #include -#include #include #include #include - +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include #include #include -#include #include #include @@ -58,7 +65,7 @@ ConfigValueInSubTree(const char* SubTree, const char *needle) } /*}}}*/ pkgDepCache::ActionGroup::ActionGroup(pkgDepCache &cache) : /*{{{*/ - cache(cache), released(false) + d(NULL), cache(cache), released(false) { ++cache.group_level; } @@ -89,8 +96,10 @@ pkgDepCache::ActionGroup::~ActionGroup() // DepCache::pkgDepCache - Constructors /*{{{*/ // --------------------------------------------------------------------- /* */ -pkgDepCache::pkgDepCache(pkgCache *pCache,Policy *Plcy) : - group_level(0), Cache(pCache), PkgState(0), DepState(0) +pkgDepCache::pkgDepCache(pkgCache * const pCache,Policy * const Plcy) : + group_level(0), Cache(pCache), PkgState(0), DepState(0), + iUsrSize(0), iDownloadSize(0), iInstCount(0), iDelCount(0), iKeepCount(0), + iBrokenCount(0), iPolicyBrokenCount(0), iBadCount(0), d(NULL) { DebugMarker = _config->FindB("Debug::pkgDepCache::Marker", false); DebugAutoInstall = _config->FindB("Debug::pkgDepCache::AutoInstall", false); @@ -113,7 +122,7 @@ pkgDepCache::~pkgDepCache() // DepCache::Init - Generate the initial extra structures. /*{{{*/ // --------------------------------------------------------------------- /* This allocats the extension buffers and initializes them. */ -bool pkgDepCache::Init(OpProgress *Prog) +bool pkgDepCache::Init(OpProgress * const Prog) { // Suppress mark updates during this operation (just in case) and // run a mark operation when Init terminates. @@ -124,7 +133,7 @@ bool pkgDepCache::Init(OpProgress *Prog) PkgState = new StateCache[Head().PackageCount]; DepState = new unsigned char[Head().DependsCount]; memset(PkgState,0,sizeof(*PkgState)*Head().PackageCount); - memset(DepState,0,sizeof(*DepState)*Head().DependsCount); + memset(DepState,0,sizeof(*DepState)*Head().DependsCount); if (Prog != 0) { @@ -132,7 +141,7 @@ bool pkgDepCache::Init(OpProgress *Prog) _("Building dependency tree")); Prog->SubProgress(Head().PackageCount,_("Candidate versions")); } - + /* Set the current state of everything. In this state all of the packages are kept exactly as is. See AllUpgrade */ int Done = 0; @@ -140,37 +149,36 @@ bool pkgDepCache::Init(OpProgress *Prog) { if (Prog != 0 && Done%20 == 0) Prog->Progress(Done); - + // Find the proper cache slot StateCache &State = PkgState[I->ID]; State.iFlags = 0; // Figure out the install version - State.CandidateVer = GetCandidateVer(I); + State.CandidateVer = LocalPolicy->GetCandidateVer(I); State.InstallVer = I.CurrentVer(); State.Mode = ModeKeep; - + State.Update(I,*this); - } - + } + if (Prog != 0) { - Prog->OverallProgress(Head().PackageCount,2*Head().PackageCount, Head().PackageCount, _("Building dependency tree")); Prog->SubProgress(Head().PackageCount,_("Dependency generation")); } - + Update(Prog); if(Prog != 0) Prog->Done(); return true; -} +} /*}}}*/ -bool pkgDepCache::readStateFile(OpProgress *Prog) /*{{{*/ +bool pkgDepCache::readStateFile(OpProgress * const Prog) /*{{{*/ { FileFd state_file; string const state = _config->FindFile("Dir::State::extended_states"); @@ -178,7 +186,7 @@ bool pkgDepCache::readStateFile(OpProgress *Prog) /*{{{*/ state_file.Open(state, FileFd::ReadOnly); off_t const file_size = state_file.Size(); if(Prog != NULL) - Prog->OverallProgress(0, file_size, 1, + Prog->OverallProgress(0, file_size, 1, _("Reading state information")); pkgTagFile tagfile(&state_file); @@ -222,7 +230,7 @@ bool pkgDepCache::readStateFile(OpProgress *Prog) /*{{{*/ return true; } /*}}}*/ -bool pkgDepCache::writeStateFile(OpProgress *prog, bool InstalledOnly) /*{{{*/ +bool pkgDepCache::writeStateFile(OpProgress * const /*prog*/, bool const InstalledOnly) /*{{{*/ { bool const debug_autoremove = _config->FindB("Debug::pkgAutoRemove",false); @@ -231,9 +239,11 @@ bool pkgDepCache::writeStateFile(OpProgress *prog, bool InstalledOnly) /*{{{*/ FileFd StateFile; string const state = _config->FindFile("Dir::State::extended_states"); + if (CreateAPTDirectoryIfNeeded(_config->FindDir("Dir::State"), flNotFile(state)) == false) + return false; // if it does not exist, create a empty one - if(!RealFileExists(state)) + if(!RealFileExists(state)) { StateFile.Open(state, FileFd::WriteAtomic); StateFile.Close(); @@ -244,17 +254,14 @@ bool pkgDepCache::writeStateFile(OpProgress *prog, bool InstalledOnly) /*{{{*/ return _error->Error(_("Failed to open StateFile %s"), state.c_str()); - FILE *OutFile; - string const outfile = state + ".tmp"; - if((OutFile = fopen(outfile.c_str(),"w")) == NULL) - return _error->Error(_("Failed to write temporary StateFile %s"), - outfile.c_str()); + FileFd OutFile(state, FileFd::ReadWrite | FileFd::Atomic); + if (OutFile.IsOpen() == false || OutFile.Failed() == true) + return _error->Error(_("Failed to write temporary StateFile %s"), state.c_str()); // first merge with the existing sections pkgTagFile tagfile(&StateFile); pkgTagSection section; std::set pkgs_seen; - const char *nullreorderlist[] = {0}; while(tagfile.Step(section)) { string const pkgname = section.FindS("Package"); string pkgarch = section.FindS("Architecture"); @@ -263,48 +270,48 @@ bool pkgDepCache::writeStateFile(OpProgress *prog, bool InstalledOnly) /*{{{*/ // Silently ignore unknown packages and packages with no actual // version. pkgCache::PkgIterator pkg = Cache->FindPkg(pkgname, pkgarch); - if(pkg.end() || pkg.VersionList().end()) + if(pkg.end() || pkg.VersionList().end()) continue; StateCache const &P = PkgState[pkg->ID]; bool newAuto = (P.Flags & Flag::Auto); - // skip not installed or now-removed ones if requested + // reset to default (=manual) not installed or now-removed ones if requested if (InstalledOnly && ( (pkg->CurrentVer == 0 && P.Mode != ModeInstall) || (pkg->CurrentVer != 0 && P.Mode == ModeDelete))) + newAuto = false; + if (newAuto == false) { // The section is obsolete if it contains no other tag - unsigned int const count = section.Count(); + auto const count = section.Count(); if (count < 2 || (count == 2 && section.Exists("Auto-Installed")) || (count == 3 && section.Exists("Auto-Installed") && section.Exists("Architecture"))) + { + if(debug_autoremove) + std::clog << "Drop obsolete section with " << count << " fields for " << APT::PrettyPkg(this, pkg) << std::endl; continue; - else - newAuto = false; + } } - if(_config->FindB("Debug::pkgAutoRemove",false)) - std::clog << "Update existing AutoInstall info: " - << pkg.FullName() << std::endl; - TFRewriteData rewrite[3]; - rewrite[0].Tag = "Architecture"; - rewrite[0].Rewrite = pkg.Arch(); - rewrite[0].NewTag = 0; - rewrite[1].Tag = "Auto-Installed"; - rewrite[1].Rewrite = newAuto ? "1" : "0"; - rewrite[1].NewTag = 0; - rewrite[2].Tag = 0; - TFRewrite(OutFile, section, nullreorderlist, rewrite); - fprintf(OutFile,"\n"); + + if(debug_autoremove) + std::clog << "Update existing AutoInstall to " << newAuto << " for " << APT::PrettyPkg(this, pkg) << std::endl; + + std::vector rewrite; + rewrite.push_back(pkgTagSection::Tag::Rewrite("Architecture", pkg.Arch())); + rewrite.push_back(pkgTagSection::Tag::Rewrite("Auto-Installed", newAuto ? "1" : "0")); + section.Write(OutFile, NULL, rewrite); + if (OutFile.Write("\n", 1) == false) + return false; pkgs_seen.insert(pkg.FullName()); } - + // then write the ones we have not seen yet - std::ostringstream ostr; for(pkgCache::PkgIterator pkg=Cache->PkgBegin(); !pkg.end(); ++pkg) { StateCache const &P = PkgState[pkg->ID]; if(P.Flags & Flag::Auto) { if (pkgs_seen.find(pkg.FullName()) != pkgs_seen.end()) { if(debug_autoremove) - std::clog << "Skipping already written " << pkg.FullName() << std::endl; + std::clog << "Skipping already written " << APT::PrettyPkg(this, pkg) << std::endl; continue; } // skip not installed ones if requested @@ -312,24 +319,24 @@ bool pkgDepCache::writeStateFile(OpProgress *prog, bool InstalledOnly) /*{{{*/ (pkg->CurrentVer == 0 && P.Mode != ModeInstall) || (pkg->CurrentVer != 0 && P.Mode == ModeDelete))) continue; - const char* const pkgarch = pkg.Arch(); - if (strcmp(pkgarch, "all") == 0) - continue; if(debug_autoremove) - std::clog << "Writing new AutoInstall: " << pkg.FullName() << std::endl; - ostr.str(string("")); - ostr << "Package: " << pkg.Name() - << "\nArchitecture: " << pkgarch - << "\nAuto-Installed: 1\n\n"; - fprintf(OutFile,"%s",ostr.str().c_str()); + std::clog << "Writing new AutoInstall: " << APT::PrettyPkg(this, pkg) << std::endl; + std::string stanza = "Package: "; + stanza.append(pkg.Name()) + .append("\nArchitecture: ").append(pkg.Arch()) + .append("\nAuto-Installed: 1\n\n"); + if (OutFile.Write(stanza.c_str(), stanza.length()) == false) + return false; } } - fclose(OutFile); - - // move the outfile over the real file and set permissions - rename(outfile.c_str(), state.c_str()); + if (StateFile.Failed()) + { + OutFile.OpFail(); + return false; + } + if (OutFile.Close() == false) + return false; chmod(state.c_str(), 0644); - return true; } /*}}}*/ @@ -339,7 +346,7 @@ bool pkgDepCache::writeStateFile(OpProgress *prog, bool InstalledOnly) /*{{{*/ then walks along the package provides list and checks if each provides will be installed then checks the provides against the dep. Res will be set to the package which was used to satisfy the dep. */ -bool pkgDepCache::CheckDep(DepIterator Dep,int Type,PkgIterator &Res) +bool pkgDepCache::CheckDep(DepIterator const &Dep,int const Type,PkgIterator &Res) { Res = Dep.TargetPkg(); @@ -348,24 +355,27 @@ bool pkgDepCache::CheckDep(DepIterator Dep,int Type,PkgIterator &Res) bug. Conflicts may never self match */ if (Dep.IsIgnorable(Res) == false) { - PkgIterator Pkg = Dep.TargetPkg(); // Check the base package - if (Type == NowVersion && Pkg->CurrentVer != 0) - if (Dep.IsSatisfied(Pkg.CurrentVer()) == true) + if (Type == NowVersion) + { + if (Res->CurrentVer != 0 && Dep.IsSatisfied(Res.CurrentVer()) == true) return true; - - if (Type == InstallVersion && PkgState[Pkg->ID].InstallVer != 0) - if (Dep.IsSatisfied(PkgState[Pkg->ID].InstVerIter(*this)) == true) + } + else if (Type == InstallVersion) + { + if (PkgState[Res->ID].InstallVer != 0 && + Dep.IsSatisfied(PkgState[Res->ID].InstVerIter(*this)) == true) return true; - - if (Type == CandidateVersion && PkgState[Pkg->ID].CandidateVer != 0) - if (Dep.IsSatisfied(PkgState[Pkg->ID].CandidateVerIter(*this)) == true) + } + else if (Type == CandidateVersion) + if (PkgState[Res->ID].CandidateVer != 0 && + Dep.IsSatisfied(PkgState[Res->ID].CandidateVerIter(*this)) == true) return true; } - + if (Dep->Type == Dep::Obsoletes) return false; - + // Check the providing packages PrvIterator P = Dep.TargetPkg().ProvidesList(); for (; P.end() != true; ++P) @@ -379,21 +389,19 @@ bool pkgDepCache::CheckDep(DepIterator Dep,int Type,PkgIterator &Res) if (P.OwnerPkg().CurrentVer() != P.OwnerVer()) continue; } - - if (Type == InstallVersion) + else if (Type == InstallVersion) { StateCache &State = PkgState[P.OwnerPkg()->ID]; if (State.InstallVer != (Version *)P.OwnerVer()) continue; } - - if (Type == CandidateVersion) + else if (Type == CandidateVersion) { StateCache &State = PkgState[P.OwnerPkg()->ID]; if (State.CandidateVer != (Version *)P.OwnerVer()) continue; } - + // Compare the versions. if (Dep.IsSatisfied(P) == true) { @@ -401,7 +409,7 @@ bool pkgDepCache::CheckDep(DepIterator Dep,int Type,PkgIterator &Res) return true; } } - + return false; } /*}}}*/ @@ -483,47 +491,46 @@ void pkgDepCache::AddStates(const PkgIterator &Pkg, bool const Invert) { signed char const Add = (Invert == false) ? 1 : -1; StateCache &State = PkgState[Pkg->ID]; - + // The Package is broken (either minimal dep or policy dep) if ((State.DepState & DepInstMin) != DepInstMin) iBrokenCount += Add; if ((State.DepState & DepInstPolicy) != DepInstPolicy) iPolicyBrokenCount += Add; - + // Bad state if (Pkg.State() != PkgIterator::NeedsNothing) iBadCount += Add; - + // Not installed if (Pkg->CurrentVer == 0) { if (State.Mode == ModeDelete && (State.iFlags & Purge) == Purge && Pkg.Purge() == false) iDelCount += Add; - + if (State.Mode == ModeInstall) iInstCount += Add; return; } - + // Installed, no upgrade if (State.Status == 0) - { + { if (State.Mode == ModeDelete) iDelCount += Add; else if ((State.iFlags & ReInstall) == ReInstall) iInstCount += Add; - return; } - + // Alll 3 are possible if (State.Mode == ModeDelete) - iDelCount += Add; - if (State.Mode == ModeKeep) + iDelCount += Add; + else if (State.Mode == ModeKeep) iKeepCount += Add; - if (State.Mode == ModeInstall) + else if (State.Mode == ModeInstall) iInstCount += Add; } /*}}}*/ @@ -534,7 +541,6 @@ void pkgDepCache::AddStates(const PkgIterator &Pkg, bool const Invert) void pkgDepCache::BuildGroupOrs(VerIterator const &V) { unsigned char Group = 0; - for (DepIterator D = V.DependsList(); D.end() != true; ++D) { // Build the dependency state. @@ -544,18 +550,18 @@ void pkgDepCache::BuildGroupOrs(VerIterator const &V) right sense for a conflicts group */ if (D.IsNegative() == true) State = ~State; - + // Add to the group if we are within an or.. State &= 0x7; Group |= State; State |= Group << 3; if ((D->CompareOp & Dep::Or) != Dep::Or) Group = 0; - + // Invert for Conflicts if (D.IsNegative() == true) State = ~State; - } + } } /*}}}*/ // DepCache::VersionState - Perform a pass over a dependency list /*{{{*/ @@ -564,34 +570,31 @@ void pkgDepCache::BuildGroupOrs(VerIterator const &V) state of the list, filtering it through both a Min check and a Policy check. The return result will have SetMin/SetPolicy low if a check fails. It uses the DepState cache for it's computations. */ -unsigned char pkgDepCache::VersionState(DepIterator D,unsigned char Check, - unsigned char SetMin, - unsigned char SetPolicy) +unsigned char pkgDepCache::VersionState(DepIterator D, unsigned char const Check, + unsigned char const SetMin, + unsigned char const SetPolicy) const { unsigned char Dep = 0xFF; - while (D.end() != true) { - // Compute a single dependency element (glob or) - DepIterator Start = D; - unsigned char State = 0; - for (bool LastOR = true; D.end() == false && LastOR == true; ++D) - { - State |= DepState[D->ID]; - LastOR = (D->CompareOp & Dep::Or) == Dep::Or; - } - + // the last or-dependency has the state of all previous or'ed + DepIterator Start, End; + D.GlobOr(Start, End); + // ignore if we are called with Dep{Install,…} or DepG{Install,…} + // the later would be more correct, but the first is what we get + unsigned char const State = DepState[End->ID] | (DepState[End->ID] >> 3); + // Minimum deps that must be satisfied to have a working package if (Start.IsCritical() == true) + { if ((State & Check) != Check) - Dep &= ~SetMin; - + return Dep &= ~(SetMin | SetPolicy); + } // Policy deps that must be satisfied to install the package - if (IsImportantDep(Start) == true && + else if (IsImportantDep(Start) == true && (State & Check) != Check) Dep &= ~SetPolicy; } - return Dep; } /*}}}*/ @@ -600,17 +603,17 @@ unsigned char pkgDepCache::VersionState(DepIterator D,unsigned char Check, /* This is the main dependency computation bit. It computes the 3 main results for a dependencys, Now, Install and Candidate. Callers must invert the result if dealing with conflicts. */ -unsigned char pkgDepCache::DependencyState(DepIterator &D) +unsigned char pkgDepCache::DependencyState(DepIterator const &D) { unsigned char State = 0; - + if (CheckDep(D,NowVersion) == true) State |= DepNow; if (CheckDep(D,InstallVersion) == true) State |= DepInstall; if (CheckDep(D,CandidateVersion) == true) State |= DepCVer; - + return State; } /*}}}*/ @@ -619,7 +622,7 @@ unsigned char pkgDepCache::DependencyState(DepIterator &D) /* This determines the combined dependency representation of a package for its two states now and install. This is done by using the pre-generated dependency information. */ -void pkgDepCache::UpdateVerState(PkgIterator Pkg) +void pkgDepCache::UpdateVerState(PkgIterator const &Pkg) { // Empty deps are always true StateCache &State = PkgState[Pkg->ID]; @@ -653,14 +656,15 @@ void pkgDepCache::UpdateVerState(PkgIterator Pkg) // --------------------------------------------------------------------- /* This will figure out the state of all the packages and all the dependencies based on the current policy. */ -void pkgDepCache::Update(OpProgress *Prog) +void pkgDepCache::Update(OpProgress * const Prog) { iUsrSize = 0; iDownloadSize = 0; - iDelCount = 0; iInstCount = 0; + iDelCount = 0; iKeepCount = 0; iBrokenCount = 0; + iPolicyBrokenCount = 0; iBadCount = 0; // Perform the depends pass @@ -789,13 +793,13 @@ bool pkgDepCache::MarkKeep(PkgIterator const &Pkg, bool Soft, bool FromUser, // - this makes sense as default when all Garbage dependencies // are automatically marked for removal (as aptitude does). // setting a package for keep then makes it no longer autoinstalled - // for all other use-case this action is rather suprising + // for all other use-case this action is rather surprising if(FromUser && !P.Marked) P.Flags &= ~Flag::Auto; #endif if (DebugMarker == true) - std::clog << OutputInDepth(Depth) << "MarkKeep " << Pkg << " FU=" << FromUser << std::endl; + std::clog << OutputInDepth(Depth) << "MarkKeep " << APT::PrettyPkg(this, Pkg) << " FU=" << FromUser << std::endl; RemoveSizes(Pkg); RemoveStates(Pkg); @@ -839,8 +843,43 @@ bool pkgDepCache::MarkDelete(PkgIterator const &Pkg, bool rPurge, ActionGroup group(*this); + if (FromUser == false) + { + VerIterator const PV = P.InstVerIter(*this); + if (PV.end() == false) + { + // removed metapackages mark their dependencies as manual to prevent in "desktop depends browser, texteditor" + // the removal of browser to suggest the removal of desktop and texteditor. + // We ignore the auto-bit here as we can't deal with metapackage cascardes otherwise. + // We do not check for or-groups here as we don't know which package takes care of + // providing the feature the user likes e.g.: browser1 | browser2 | browser3 + // Temporary removals are effected by this as well, which is bad, but unlikely in practice + bool const PinNeverMarkAutoSection = (PV->Section != 0 && ConfigValueInSubTree("APT::Never-MarkAuto-Sections", PV.Section())); + if (PinNeverMarkAutoSection) + { + for (DepIterator D = PV.DependsList(); D.end() != true; ++D) + { + if (D.IsMultiArchImplicit() == true || D.IsNegative() == true || IsImportantDep(D) == false) + continue; + + pkgCacheFile CacheFile(this); + APT::VersionList verlist = APT::VersionList::FromDependency(CacheFile, D, APT::CacheSetHelper::INSTALLED); + for (auto const &V : verlist) + { + PkgIterator const DP = V.ParentPkg(); + if(DebugAutoInstall == true) + std::clog << OutputInDepth(Depth) << "Setting " << DP.FullName(false) << " NOT as auto-installed (direct " + << D.DepType() << " of " << Pkg.FullName(false) << " which is in APT::Never-MarkAuto-Sections)" << std::endl; + + MarkAuto(DP, false); + } + } + } + } + } + if (DebugMarker == true) - std::clog << OutputInDepth(Depth) << (rPurge ? "MarkPurge " : "MarkDelete ") << Pkg << " FU=" << FromUser << std::endl; + std::clog << OutputInDepth(Depth) << (rPurge ? "MarkPurge " : "MarkDelete ") << APT::PrettyPkg(this, Pkg) << " FU=" << FromUser << std::endl; RemoveSizes(Pkg); RemoveStates(Pkg); @@ -868,7 +907,7 @@ bool pkgDepCache::IsDeleteOk(PkgIterator const &Pkg,bool rPurge, return IsDeleteOkProtectInstallRequests(Pkg, rPurge, Depth, FromUser); } bool pkgDepCache::IsDeleteOkProtectInstallRequests(PkgIterator const &Pkg, - bool const rPurge, unsigned long const Depth, bool const FromUser) + bool const /*rPurge*/, unsigned long const Depth, bool const FromUser) { if (FromUser == false && Pkg->CurrentVer == 0) { @@ -876,7 +915,7 @@ bool pkgDepCache::IsDeleteOkProtectInstallRequests(PkgIterator const &Pkg, if (P.InstallVer != 0 && P.Status == 2 && (P.Flags & Flag::Auto) != Flag::Auto) { if (DebugMarker == true) - std::clog << OutputInDepth(Depth) << "Manual install request prevents MarkDelete of " << Pkg << std::endl; + std::clog << OutputInDepth(Depth) << "Manual install request prevents MarkDelete of " << APT::PrettyPkg(this, Pkg) << std::endl; return false; } } @@ -889,7 +928,7 @@ bool pkgDepCache::IsDeleteOkProtectInstallRequests(PkgIterator const &Pkg, and prevents mode changes for packages on hold for example. If you want to check Mode specific stuff you can use the virtual public IsOk methods instead */ -char const* PrintMode(char const mode) +static char const* PrintMode(char const mode) { switch (mode) { @@ -926,7 +965,7 @@ bool pkgDepCache::IsModeChangeOk(ModeList const mode, PkgIterator const &Pkg, { if (unlikely(DebugMarker == true)) std::clog << OutputInDepth(Depth) << "Ignore Mark" << PrintMode(mode) - << " of " << Pkg << " as its mode (" << PrintMode(P.Mode) + << " of " << APT::PrettyPkg(this, Pkg) << " as its mode (" << PrintMode(P.Mode) << ") is protected" << std::endl; return false; } @@ -936,7 +975,7 @@ bool pkgDepCache::IsModeChangeOk(ModeList const mode, PkgIterator const &Pkg, { if (unlikely(DebugMarker == true)) std::clog << OutputInDepth(Depth) << "Hold prevents Mark" << PrintMode(mode) - << " of " << Pkg << std::endl; + << " of " << APT::PrettyPkg(this, Pkg) << std::endl; return false; } @@ -948,7 +987,7 @@ bool pkgDepCache::IsModeChangeOk(ModeList const mode, PkgIterator const &Pkg, /* */ struct CompareProviders { pkgCache::PkgIterator const Pkg; - CompareProviders(pkgCache::DepIterator const &Dep) : Pkg(Dep.TargetPkg()) {}; + explicit CompareProviders(pkgCache::DepIterator const &Dep) : Pkg(Dep.TargetPkg()) {}; //bool operator() (APT::VersionList::iterator const &AV, APT::VersionList::iterator const &BV) bool operator() (pkgCache::VerIterator const &AV, pkgCache::VerIterator const &BV) { @@ -985,6 +1024,8 @@ struct CompareProviders { if (instA != instB) return instA == false; } + if ((A->CurrentVer == 0 || B->CurrentVer == 0) && A->CurrentVer != B->CurrentVer) + return A->CurrentVer == 0; // Prefer packages in the same group as the target; e.g. foo:i386, foo:amd64 if (A->Group != B->Group) { @@ -1053,10 +1094,9 @@ bool pkgDepCache::MarkInstall(PkgIterator const &Pkg,bool AutoInst, return true; } - // check if we are allowed to install the package (if we haven't already) - if (P.Mode != ModeInstall || P.InstallVer != P.CandidateVer) - if (IsInstallOk(Pkg,AutoInst,Depth,FromUser) == false) - return false; + // check if we are allowed to install the package + if (IsInstallOk(Pkg,AutoInst,Depth,FromUser) == false) + return false; ActionGroup group(*this); P.iFlags &= ~AutoKept; @@ -1095,9 +1135,30 @@ bool pkgDepCache::MarkInstall(PkgIterator const &Pkg,bool AutoInst, return true; if (DebugMarker == true) - std::clog << OutputInDepth(Depth) << "MarkInstall " << Pkg << " FU=" << FromUser << std::endl; + std::clog << OutputInDepth(Depth) << "MarkInstall " << APT::PrettyPkg(this, Pkg) << " FU=" << FromUser << std::endl; - DepIterator Dep = P.InstVerIter(*this).DependsList(); + bool MoveAutoBitToDependencies = false; + VerIterator const PV = P.InstVerIter(*this); + if (unlikely(PV.end() == true)) + return false; + else if (PV->Section != 0 && (P.Flags & Flag::Auto) != Flag::Auto) + { + VerIterator const CurVer = Pkg.CurrentVer(); + if (CurVer.end() == false && CurVer->Section != 0 && strcmp(CurVer.Section(), PV.Section()) != 0) + { + bool const CurVerInMoveSection = ConfigValueInSubTree("APT::Move-Autobit-Sections", CurVer.Section()); + bool const InstVerInMoveSection = ConfigValueInSubTree("APT::Move-Autobit-Sections", PV.Section()); + MoveAutoBitToDependencies = (CurVerInMoveSection == false && InstVerInMoveSection == true); + if (MoveAutoBitToDependencies == true) + { + if(DebugAutoInstall == true) + std::clog << OutputInDepth(Depth) << "Setting " << Pkg.FullName(false) << " as auto-installed, moving manual to its dependencies" << std::endl; + MarkAuto(Pkg, true); + } + } + } + + DepIterator Dep = PV.DependsList(); for (; Dep.end() != true;) { // Grok or groups @@ -1117,27 +1178,22 @@ bool pkgDepCache::MarkInstall(PkgIterator const &Pkg,bool AutoInst, continue; /* Check if this dep should be consider for install. If it is a user - defined important dep and we are installed a new package then + defined important dep and we are installed a new package then it will be installed. Otherwise we only check for important - deps that have changed from the installed version - */ + deps that have changed from the installed version */ if (IsImportantDep(Start) == false) continue; - /* If we are in an or group locate the first or that can - succeed. We have already cached this.. */ + /* If we are in an or group locate the first or that can + succeed. We have already cached this… */ for (; Ors > 1 && (DepState[Start->ID] & DepCVer) != DepCVer; --Ors) ++Start; + + /* unsatisfiable dependency: IsInstallOkDependenciesSatisfiableByCandidates + would have prevented us to get here if not overridden, so just skip + over the problem here as the front-end will know what it is doing */ if (Ors == 1 && (DepState[Start->ID] &DepCVer) != DepCVer && Start.IsNegative() == false) - { - if(DebugAutoInstall == true) - std::clog << OutputInDepth(Depth) << Start << " can't be satisfied!" << std::endl; - if (Start.IsCritical() == false) - continue; - // if the dependency was critical, we can't install it, so remove it again - MarkDelete(Pkg,false,Depth + 1, false); - return false; - } + continue; /* Check if any ImportantDep() (but not Critical) were added * since we installed the package. Also check for deps that @@ -1190,22 +1246,12 @@ bool pkgDepCache::MarkInstall(PkgIterator const &Pkg,bool AutoInst, } } - /* This bit is for processing the possibilty of an install/upgrade + /* This bit is for processing the possibility of an install/upgrade fixing the problem for "positive" dependencies */ if (Start.IsNegative() == false && (DepState[Start->ID] & DepCVer) == DepCVer) { - APT::VersionList verlist; - pkgCache::VerIterator Cand = PkgState[Start.TargetPkg()->ID].CandidateVerIter(*this); - if (Cand.end() == false && Start.IsSatisfied(Cand) == true) - verlist.insert(Cand); - for (PrvIterator Prv = Start.TargetPkg().ProvidesList(); Prv.end() != true; ++Prv) - { - pkgCache::VerIterator V = Prv.OwnerVer(); - pkgCache::VerIterator Cand = PkgState[Prv.OwnerPkg()->ID].CandidateVerIter(*this); - if (Cand.end() == true || V != Cand || Start.IsSatisfied(Prv) == false) - continue; - verlist.insert(Cand); - } + pkgCacheFile CacheFile(this); + APT::VersionList verlist = APT::VersionList::FromDependency(CacheFile, Start, APT::CacheSetHelper::CANDIDATE); CompareProviders comp(Start); do { @@ -1224,14 +1270,17 @@ bool pkgDepCache::MarkInstall(PkgIterator const &Pkg,bool AutoInst, verlist.erase(InstVer); continue; } + // now check if we should consider it a automatic dependency or not - if(InstPkg->CurrentVer == 0 && Pkg->Section != 0 && ConfigValueInSubTree("APT::Never-MarkAuto-Sections", Pkg.Section())) + if(InstPkg->CurrentVer == 0 && MoveAutoBitToDependencies) { if(DebugAutoInstall == true) - std::clog << OutputInDepth(Depth) << "Setting NOT as auto-installed (direct " - << Start.DepType() << " of pkg in APT::Never-MarkAuto-Sections)" << std::endl; + std::clog << OutputInDepth(Depth) << "Setting " << InstPkg.FullName(false) << " NOT as auto-installed (direct " + << Start.DepType() << " of " << Pkg.FullName(false) << " which is manual and in APT::Move-Autobit-Sections)" << std::endl; MarkAuto(InstPkg, false); } + + break; } while(true); continue; @@ -1241,9 +1290,9 @@ bool pkgDepCache::MarkInstall(PkgIterator const &Pkg,bool AutoInst, Otherwise we remove the offender if needed */ else if (Start.IsNegative() == true && Start->Type != pkgCache::Dep::Obsoletes) { - SPtrArray List = Start.AllTargets(); + std::unique_ptr List(Start.AllTargets()); pkgCache::PkgIterator TrgPkg = Start.TargetPkg(); - for (Version **I = List; *I != 0; I++) + for (Version **I = List.get(); *I != 0; I++) { VerIterator Ver(*this,*I); PkgIterator Pkg = Ver.ParentPkg(); @@ -1253,6 +1302,11 @@ bool pkgDepCache::MarkInstall(PkgIterator const &Pkg,bool AutoInst, if (PkgState[Pkg->ID].InstallVer == 0) continue; + /* Ignore negative dependencies that we are not going to + get installed */ + if (PkgState[Pkg->ID].InstallVer != *I) + continue; + if ((Start->Version != 0 || TrgPkg != Pkg) && PkgState[Pkg->ID].CandidateVer != PkgState[Pkg->ID].InstallVer && PkgState[Pkg->ID].CandidateVer != *I && @@ -1284,14 +1338,20 @@ bool pkgDepCache::MarkInstall(PkgIterator const &Pkg,bool AutoInst, bool pkgDepCache::IsInstallOk(PkgIterator const &Pkg,bool AutoInst, unsigned long Depth, bool FromUser) { - return IsInstallOkMultiArchSameVersionSynced(Pkg,AutoInst, Depth, FromUser); + return IsInstallOkMultiArchSameVersionSynced(Pkg,AutoInst, Depth, FromUser) && + IsInstallOkDependenciesSatisfiableByCandidates(Pkg,AutoInst, Depth, FromUser); } bool pkgDepCache::IsInstallOkMultiArchSameVersionSynced(PkgIterator const &Pkg, - bool const AutoInst, unsigned long const Depth, bool const FromUser) + bool const /*AutoInst*/, unsigned long const Depth, bool const FromUser) { if (FromUser == true) // as always: user is always right return true; + // if we have checked before and it was okay, it will still be okay + if (PkgState[Pkg->ID].Mode == ModeInstall && + PkgState[Pkg->ID].InstallVer == PkgState[Pkg->ID].CandidateVer) + return true; + // ignore packages with none-M-A:same candidates VerIterator const CandVer = PkgState[Pkg->ID].CandidateVerIter(*this); if (unlikely(CandVer.end() == true) || CandVer == Pkg.CurrentVer() || @@ -1301,14 +1361,18 @@ bool pkgDepCache::IsInstallOkMultiArchSameVersionSynced(PkgIterator const &Pkg, GrpIterator const Grp = Pkg.Group(); for (PkgIterator P = Grp.PackageList(); P.end() == false; P = Grp.NextPkg(P)) { - // not installed or version synced: fine by definition - // (simple string-compare as stuff like '1' == '0:1-0' can't happen here) - if (P->CurrentVer == 0 || strcmp(Pkg.CandVersion(), P.CandVersion()) == 0) + // not installed or self-check: fine by definition + if (P->CurrentVer == 0 || P == Pkg) continue; - // packages loosing M-A:same can be out-of-sync + + // not having a candidate or being in sync + // (simple string-compare as stuff like '1' == '0:1-0' can't happen here) VerIterator CV = PkgState[P->ID].CandidateVerIter(*this); - if (unlikely(CV.end() == true) || - (CV->MultiArch & pkgCache::Version::Same) != pkgCache::Version::Same) + if (CV.end() == true || strcmp(CandVer.VerStr(), CV.VerStr()) == 0) + continue; + + // packages losing M-A:same can be out-of-sync + if ((CV->MultiArch & pkgCache::Version::Same) != pkgCache::Version::Same) continue; // not downloadable means the package is obsolete, so allow out-of-sync @@ -1317,11 +1381,67 @@ bool pkgDepCache::IsInstallOkMultiArchSameVersionSynced(PkgIterator const &Pkg, PkgState[Pkg->ID].iFlags |= AutoKept; if (unlikely(DebugMarker == true)) - std::clog << OutputInDepth(Depth) << "Ignore MarkInstall of " << Pkg - << " as its M-A:same siblings are not version-synced" << std::endl; + std::clog << OutputInDepth(Depth) << "Ignore MarkInstall of " << APT::PrettyPkg(this, Pkg) + << " as it is not in sync with its M-A:same sibling " << APT::PrettyPkg(this, P) + << " (" << CandVer.VerStr() << " != " << CV.VerStr() << ")" << std::endl; return false; } + return true; +} +bool pkgDepCache::IsInstallOkDependenciesSatisfiableByCandidates(PkgIterator const &Pkg, + bool const AutoInst, unsigned long const Depth, bool const /*FromUser*/) +{ + if (AutoInst == false) + return true; + + VerIterator const CandVer = PkgState[Pkg->ID].CandidateVerIter(*this); + if (unlikely(CandVer.end() == true) || CandVer == Pkg.CurrentVer()) + return true; + + for (DepIterator Dep = CandVer.DependsList(); Dep.end() != true;) + { + // Grok or groups + DepIterator Start = Dep; + bool Result = true; + unsigned Ors = 0; + for (bool LastOR = true; Dep.end() == false && LastOR == true; ++Dep, ++Ors) + { + LastOR = (Dep->CompareOp & Dep::Or) == Dep::Or; + + if ((DepState[Dep->ID] & DepInstall) == DepInstall) + Result = false; + } + + if (Start.IsCritical() == false || Start.IsNegative() == true || Result == false) + continue; + + /* If we are in an or group locate the first or that can succeed. + We have already cached this… */ + for (; Ors > 1 && (DepState[Start->ID] & DepCVer) != DepCVer; --Ors) + ++Start; + + if (Ors == 1 && (DepState[Start->ID] &DepCVer) != DepCVer) + { + if (DebugAutoInstall == true) + std::clog << OutputInDepth(Depth) << APT::PrettyDep(this, Start) << " can't be satisfied!" << std::endl; + + // the dependency is critical, but can't be installed, so discard the candidate + // as the problemresolver will trip over it otherwise trying to install it (#735967) + if (Pkg->CurrentVer != 0 && (PkgState[Pkg->ID].iFlags & Protected) != Protected) + { + SetCandidateVersion(Pkg.CurrentVer()); + StateCache &State = PkgState[Pkg->ID]; + if (State.Mode != ModeDelete) + { + State.Mode = ModeKeep; + State.Update(Pkg, *this); + } + } + return false; + } + } + return true; } /*}}}*/ @@ -1365,6 +1485,11 @@ void pkgDepCache::SetReInstall(PkgIterator const &Pkg,bool To) } } /*}}}*/ +pkgCache::VerIterator pkgDepCache::GetCandidateVersion(PkgIterator const &Pkg)/*{{{*/ +{ + return PkgState[Pkg->ID].CandidateVerIter(*this); +} + /*}}}*/ // DepCache::SetCandidateVersion - Change the candidate version /*{{{*/ // --------------------------------------------------------------------- /* */ @@ -1522,7 +1647,7 @@ bool pkgDepCache::SetCandidateRelease(pkgCache::VerIterator TargetVer, if (itsFine == false) { // change the candidate - Changed.push_back(make_pair(oldCand, TargetVer)); + Changed.push_back(make_pair(V, TargetVer)); if (SetCandidateRelease(V, TargetRel, Changed) == false) { if (stillOr == false) @@ -1586,11 +1711,7 @@ void pkgDepCache::StateCache::Update(PkgIterator Pkg,pkgCache &Cache) CurVersion = ""; if (Pkg->CurrentVer != 0) CurVersion = Pkg.CurrentVer().VerStr(); - - // Strip off the epochs for display - CurVersion = StripEpoch(CurVersion); - CandVersion = StripEpoch(CandVersion); - + // Figure out if its up or down or equal Status = Ver.CompareVer(Pkg.CurrentVer()); if (Pkg->CurrentVer == 0 || Pkg->VersionList == 0 || CandidateVer == 0) @@ -1606,10 +1727,10 @@ const char *pkgDepCache::StateCache::StripEpoch(const char *Ver) return 0; // Strip any epoch - for (const char *I = Ver; *I != 0; I++) - if (*I == ':') - return I + 1; - return Ver; + char const * const I = strchr(Ver, ':'); + if (I == nullptr) + return Ver; + return I + 1; } /*}}}*/ // Policy::GetCandidateVer - Returns the Candidate install version /*{{{*/ @@ -1620,7 +1741,7 @@ pkgCache::VerIterator pkgDepCache::Policy::GetCandidateVer(PkgIterator const &Pk { /* Not source/not automatic versions cannot be a candidate version unless they are already installed */ - VerIterator Last(*(pkgCache *)this,0); + VerIterator Last; for (VerIterator I = Pkg.VersionList(); I.end() == false; ++I) { @@ -1629,13 +1750,13 @@ pkgCache::VerIterator pkgDepCache::Policy::GetCandidateVer(PkgIterator const &Pk for (VerFileIterator J = I.FileList(); J.end() == false; ++J) { - if ((J.File()->Flags & Flag::NotSource) != 0) + if (J.File().Flagged(Flag::NotSource)) continue; /* Stash the highest version of a not-automatic source, we use it if there is nothing better */ - if ((J.File()->Flags & Flag::NotAutomatic) != 0 || - (J.File()->Flags & Flag::ButAutomaticUpgrades) != 0) + if (J.File().Flagged(Flag::NotAutomatic) || + J.File().Flagged(Flag::ButAutomaticUpgrades)) { if (Last.end() == true) Last = I; @@ -1652,17 +1773,17 @@ pkgCache::VerIterator pkgDepCache::Policy::GetCandidateVer(PkgIterator const &Pk // Policy::IsImportantDep - True if the dependency is important /*{{{*/ // --------------------------------------------------------------------- /* */ -bool pkgDepCache::Policy::IsImportantDep(DepIterator const &Dep) +bool pkgDepCache::Policy::IsImportantDep(DepIterator const &Dep) const { if(Dep.IsCritical()) return true; - else if(Dep->Type == pkgCache::Dep::Recommends) + else if(Dep->Type == pkgCache::Dep::Recommends) { if (InstallRecommends) return true; // we suport a special mode to only install-recommends for certain // sections - // FIXME: this is a meant as a temporarly solution until the + // FIXME: this is a meant as a temporarly solution until the // recommends are cleaned up const char *sec = Dep.ParentVer().Section(); if (sec && ConfigValueInSubTree("APT::Install-Recommends-Sections", sec)) @@ -1675,10 +1796,12 @@ bool pkgDepCache::Policy::IsImportantDep(DepIterator const &Dep) } /*}}}*/ // Policy::GetPriority - Get the priority of the package pin /*{{{*/ -signed short pkgDepCache::Policy::GetPriority(pkgCache::PkgIterator const &Pkg) -{ return 0; }; -signed short pkgDepCache::Policy::GetPriority(pkgCache::PkgFileIterator const &File) -{ return 0; }; +APT_CONST signed short pkgDepCache::Policy::GetPriority(pkgCache::PkgIterator const &/*Pkg*/) +{ return 0; } +APT_CONST signed short pkgDepCache::Policy::GetPriority(pkgCache::VerIterator const &/*Ver*/, bool /*ConsiderFiles*/) +{ return 0; } +APT_CONST signed short pkgDepCache::Policy::GetPriority(pkgCache::PkgFileIterator const &/*File*/) +{ return 0; } /*}}}*/ pkgDepCache::InRootSetFunc *pkgDepCache::GetRootSetFunc() /*{{{*/ { @@ -1703,177 +1826,168 @@ bool pkgDepCache::MarkFollowsSuggests() } // pkgDepCache::MarkRequired - the main mark algorithm /*{{{*/ +static bool IsPkgInBoringState(pkgCache::PkgIterator const &Pkg, pkgDepCache::StateCache const * const PkgState) +{ + if (Pkg->CurrentVer == 0) + { + if (PkgState[Pkg->ID].Keep()) + return true; + } + else + { + if (PkgState[Pkg->ID].Delete()) + return true; + } + return false; +} bool pkgDepCache::MarkRequired(InRootSetFunc &userFunc) { if (_config->Find("APT::Solver", "internal") != "internal") return true; - bool follow_recommends; - bool follow_suggests; - bool debug_autoremove = _config->FindB("Debug::pkgAutoRemove",false); + bool const debug_autoremove = _config->FindB("Debug::pkgAutoRemove",false); // init the states - for(PkgIterator p = PkgBegin(); !p.end(); ++p) + auto const PackagesCount = Head().PackageCount; + for(auto i = decltype(PackagesCount){0}; i < PackagesCount; ++i) { - PkgState[p->ID].Marked = false; - PkgState[p->ID].Garbage = false; - - // debug output - if(debug_autoremove && PkgState[p->ID].Flags & Flag::Auto) - std::clog << "AutoDep: " << p.FullName() << std::endl; + PkgState[i].Marked = false; + PkgState[i].Garbage = false; } + if (debug_autoremove) + for(PkgIterator p = PkgBegin(); !p.end(); ++p) + if(PkgState[p->ID].Flags & Flag::Auto) + std::clog << "AutoDep: " << p.FullName() << std::endl; - // init vars - follow_recommends = MarkFollowsRecommends(); - follow_suggests = MarkFollowsSuggests(); + bool const follow_recommends = MarkFollowsRecommends(); + bool const follow_suggests = MarkFollowsSuggests(); // do the mark part, this is the core bit of the algorithm - for(PkgIterator p = PkgBegin(); !p.end(); ++p) + for (PkgIterator P = PkgBegin(); !P.end(); ++P) { - if(!(PkgState[p->ID].Flags & Flag::Auto) || - (p->Flags & Flag::Essential) || - (p->Flags & Flag::Important) || - userFunc.InRootSet(p) || - // be nice even then a required package violates the policy (#583517) - // and do the full mark process also for required packages - (p.CurrentVer().end() != true && - p.CurrentVer()->Priority == pkgCache::State::Required) || - // packages which can't be changed (like holds) can't be garbage - (IsModeChangeOk(ModeGarbage, p, 0, false) == false)) - { - // the package is installed (and set to keep) - if(PkgState[p->ID].Keep() && !p.CurrentVer().end()) - MarkPackage(p, p.CurrentVer(), - follow_recommends, follow_suggests); - // the package is to be installed - else if(PkgState[p->ID].Install()) - MarkPackage(p, PkgState[p->ID].InstVerIter(*this), - follow_recommends, follow_suggests); - } + if (PkgState[P->ID].Marked || IsPkgInBoringState(P, PkgState)) + continue; + + if ((PkgState[P->ID].Flags & Flag::Auto) == 0) + ; + else if ((P->Flags & Flag::Essential) || (P->Flags & Flag::Important)) + ; + // be nice even then a required package violates the policy (#583517) + // and do the full mark process also for required packages + else if (P->CurrentVer != 0 && P.CurrentVer()->Priority == pkgCache::State::Required) + ; + else if (userFunc.InRootSet(P)) + ; + // packages which can't be changed (like holds) can't be garbage + else if (IsModeChangeOk(ModeGarbage, P, 0, false) == false) + ; + else + continue; + + if (PkgState[P->ID].Install()) + MarkPackage(P, PkgState[P->ID].InstVerIter(*this), + follow_recommends, follow_suggests); + else + MarkPackage(P, P.CurrentVer(), + follow_recommends, follow_suggests); } return true; } /*}}}*/ // MarkPackage - mark a single package in Mark-and-Sweep /*{{{*/ -void pkgDepCache::MarkPackage(const pkgCache::PkgIterator &pkg, - const pkgCache::VerIterator &ver, +void pkgDepCache::MarkPackage(const pkgCache::PkgIterator &Pkg, + const pkgCache::VerIterator &Ver, bool const &follow_recommends, bool const &follow_suggests) { - pkgDepCache::StateCache &state = PkgState[pkg->ID]; + { + pkgDepCache::StateCache &state = PkgState[Pkg->ID]; + // if we are marked already we are done + if(state.Marked || unlikely(Ver.end())) + return; + state.Marked=true; + } - // if we are marked already we are done - if(state.Marked) + if (IsPkgInBoringState(Pkg, PkgState)) return; - VerIterator const currver = pkg.CurrentVer(); - VerIterator const instver = state.InstVerIter(*this); - -#if 0 - VerIterator const candver = state.CandidateVerIter(*this); + bool const debug_autoremove = _config->FindB("Debug::pkgAutoRemove", false); + if(debug_autoremove) + std::clog << "Marking: " << Pkg.FullName() << " " << Ver.VerStr() << std::endl; - // If a package was garbage-collected but is now being marked, we - // should re-select it - // For cases when a pkg is set to upgrade and this trigger the - // removal of a no-longer used dependency. if the pkg is set to - // keep again later it will result in broken deps - if(state.Delete() && state.RemoveReason = Unused) + for (auto D = Ver.DependsList(); D.end() == false; ++D) { - if(ver==candver) - mark_install(pkg, false, false, NULL); - else if(ver==pkg.CurrentVer()) - MarkKeep(pkg, false, false); - - instver=state.InstVerIter(*this); - } -#endif + auto const T = D.TargetPkg(); + if (PkgState[T->ID].Marked) + continue; - // For packages that are not going to be removed, ignore versions - // other than the InstVer. For packages that are going to be - // removed, ignore versions other than the current version. - if(!(ver == instver && !instver.end()) && - !(ver == currver && instver.end() && !ver.end())) - return; + if (D->Type != Dep::Depends && + D->Type != Dep::PreDepends && + (follow_recommends == false || D->Type != Dep::Recommends) && + (follow_suggests == false || D->Type != Dep::Suggests)) + continue; - bool const debug_autoremove = _config->FindB("Debug::pkgAutoRemove", false); + // handle the virtual part first + APT::VersionVector providers; + for(auto Prv = T.ProvidesList(); Prv.end() == false; ++Prv) + { + auto PP = Prv.OwnerPkg(); + if (IsPkgInBoringState(PP, PkgState)) + continue; - if(debug_autoremove) - { - std::clog << "Marking: " << pkg.FullName(); - if(!ver.end()) - std::clog << " " << ver.VerStr(); - if(!currver.end()) - std::clog << ", Curr=" << currver.VerStr(); - if(!instver.end()) - std::clog << ", Inst=" << instver.VerStr(); - std::clog << std::endl; - } + // we want to ignore provides from uninteresting versions + auto const PV = (PkgState[PP->ID].Install()) ? + PkgState[PP->ID].InstVerIter(*this) : PP.CurrentVer(); + if (unlikely(PV.end()) || PV != Prv.OwnerVer() || D.IsSatisfied(Prv) == false) + continue; - state.Marked=true; + providers.emplace_back(PV); + } + if (providers.empty() == false) + { + // sort providers by source version so that only the latest versioned + // binary package of a source package is marked instead of all + std::sort(providers.begin(), providers.end(), + [](pkgCache::VerIterator const &A, pkgCache::VerIterator const &B) { + auto const nameret = strcmp(A.SourcePkgName(), B.SourcePkgName()); + if (nameret != 0) + return nameret < 0; + auto const verret = A.Cache()->VS->CmpVersion(A.SourceVerStr(), B.SourceVerStr()); + if (verret != 0) + return verret > 0; + return strcmp(A.ParentPkg().Name(), B.ParentPkg().Name()) < 0; + }); + auto const prvsize = providers.size(); + providers.erase(std::unique(providers.begin(), providers.end(), + [](pkgCache::VerIterator const &A, pkgCache::VerIterator const &B) { + return strcmp(A.SourcePkgName(), B.SourcePkgName()) == 0 && + strcmp(A.SourceVerStr(), B.SourceVerStr()) != 0; + }), providers.end()); + for (auto && PV: providers) + { + auto const PP = PV.ParentPkg(); + if (debug_autoremove) + std::clog << "Following dep: " << APT::PrettyDep(this, D) + << ", provided by " << PP.FullName() << " " << PV.VerStr() + << " (" << providers.size() << "/" << prvsize << ")"<< std::endl; + MarkPackage(PP, PV, follow_recommends, follow_suggests); + } + } - if(ver.end() == true) - return; + // now deal with the real part of the package + if (IsPkgInBoringState(T, PkgState)) + continue; - for(DepIterator d = ver.DependsList(); !d.end(); ++d) - { - if(d->Type == Dep::Depends || - d->Type == Dep::PreDepends || - (follow_recommends && - d->Type == Dep::Recommends) || - (follow_suggests && - d->Type == Dep::Suggests)) - { - // Try all versions of this package. - for(VerIterator V = d.TargetPkg().VersionList(); - !V.end(); ++V) - { - if(d.IsSatisfied(V)) - { - if(debug_autoremove) - { - std::clog << "Following dep: " << d.ParentPkg().FullName() - << " " << d.ParentVer().VerStr() << " " - << d.DepType() << " " << d.TargetPkg().FullName(); - if((d->CompareOp & ~pkgCache::Dep::Or) != pkgCache::Dep::NoOp) - { - std::clog << " (" << d.CompType() << " " - << d.TargetVer() << ")"; - } - std::clog << std::endl; - } - MarkPackage(V.ParentPkg(), V, - follow_recommends, follow_suggests); - } - } - // Now try virtual packages - for(PrvIterator prv=d.TargetPkg().ProvidesList(); - !prv.end(); ++prv) - { - if(d.IsSatisfied(prv)) - { - if(debug_autoremove) - { - std::clog << "Following dep: " << d.ParentPkg().FullName() << " " - << d.ParentVer().VerStr() << " " - << d.DepType() << " " << d.TargetPkg().FullName() << " "; - if((d->CompareOp & ~pkgCache::Dep::Or) != pkgCache::Dep::NoOp) - { - std::clog << " (" << d.CompType() << " " - << d.TargetVer() << ")"; - } - std::clog << ", provided by " - << prv.OwnerPkg().FullName() << " " - << prv.OwnerVer().VerStr() - << std::endl; - } - - MarkPackage(prv.OwnerPkg(), prv.OwnerVer(), - follow_recommends, follow_suggests); - } - } - } - } + auto const TV = (PkgState[T->ID].Install()) ? + PkgState[T->ID].InstVerIter(*this) : T.CurrentVer(); + if (unlikely(TV.end()) || D.IsSatisfied(TV) == false) + continue; + + if (debug_autoremove) + std::clog << "Following dep: " << APT::PrettyDep(this, D) << std::endl; + MarkPackage(T, TV, follow_recommends, follow_suggests); + } } /*}}}*/ bool pkgDepCache::Sweep() /*{{{*/ @@ -1902,3 +2016,17 @@ bool pkgDepCache::Sweep() /*{{{*/ return true; } /*}}}*/ +// DepCache::MarkAndSweep /*{{{*/ +bool pkgDepCache::MarkAndSweep(InRootSetFunc &rootFunc) +{ + return MarkRequired(rootFunc) && Sweep(); +} +bool pkgDepCache::MarkAndSweep() +{ + std::unique_ptr f(GetRootSetFunc()); + if(f.get() != NULL) + return MarkAndSweep(*f.get()); + else + return false; +} + /*}}}*/