#include <apt-pkg/depcache.h>
#include <apt-pkg/versionmatch.h>
#include <apt-pkg/error.h>
-#include <apt-pkg/sptr.h>
#include <apt-pkg/fileutl.h>
#include <apt-pkg/strutl.h>
#include <apt-pkg/configuration.h>
#include <apt-pkg/cacheset.h>
#include <apt-pkg/pkgcache.h>
#include <apt-pkg/cacheiterators.h>
+#include <apt-pkg/cachefile.h>
#include <apt-pkg/macros.h>
#include <stdio.h>
}
/*}}}*/
pkgDepCache::ActionGroup::ActionGroup(pkgDepCache &cache) : /*{{{*/
- cache(cache), released(false)
+ d(NULL), cache(cache), released(false)
{
++cache.group_level;
}
// 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);
// 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.
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)
{
_("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;
{
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");
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);
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);
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();
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)
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)
{
return true;
}
}
-
+
return false;
}
/*}}}*/
{
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;
}
/*}}}*/
void pkgDepCache::BuildGroupOrs(VerIterator const &V)
{
unsigned char Group = 0;
-
for (DepIterator D = V.DependsList(); D.end() != true; ++D)
{
// Build the dependency state.
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 /*{{{*/
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;
}
/*}}}*/
/* 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;
}
/*}}}*/
/* 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];
// ---------------------------------------------------------------------
/* 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;
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;
/* */
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)
{
if (DebugMarker == true)
std::clog << OutputInDepth(Depth) << "MarkInstall " << 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
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 {
verlist.erase(InstVer);
continue;
}
+
// now check if we should consider it a automatic dependency or not
- if(InstPkg->CurrentVer == 0 && InstVer->Section != 0 && ConfigValueInSubTree("APT::Never-MarkAuto-Sections", InstVer.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;
Otherwise we remove the offender if needed */
else if (Start.IsNegative() == true && Start->Type != pkgCache::Dep::Obsoletes)
{
- SPtrArray<Version *> List = Start.AllTargets();
+ std::unique_ptr<Version *[]> 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();
}
}
/*}}}*/
+pkgCache::VerIterator pkgDepCache::GetCandidateVersion(PkgIterator const &Pkg)/*{{{*/
+{
+ return PkgState[Pkg->ID].CandidateVerIter(*this);
+}
+ /*}}}*/
// DepCache::SetCandidateVersion - Change the candidate version /*{{{*/
// ---------------------------------------------------------------------
/* */
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 /*{{{*/
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;
// 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))
// Policy::GetPriority - Get the priority of the package pin /*{{{*/
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; }
/*}}}*/
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)
+ map_id_t const PackagesCount = Head().PackageCount;
+ for(map_id_t i = 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)
}
bool pkgDepCache::MarkAndSweep()
{
- std::auto_ptr<InRootSetFunc> f(GetRootSetFunc());
+ std::unique_ptr<InRootSetFunc> f(GetRootSetFunc());
if(f.get() != NULL)
return MarkAndSweep(*f.get());
else
projects / apt.git / blobdiff