1 // -*- mode: cpp; mode: fold -*-
3 // $Id: depcache.cc,v 1.25 2001/05/27 05:36:04 jgg Exp $
4 /* ######################################################################
6 Dependency Cache - Caches Dependency information.
8 ##################################################################### */
10 // Include Files /*{{{*/
11 #include <apt-pkg/depcache.h>
12 #include <apt-pkg/version.h>
13 #include <apt-pkg/versionmatch.h>
14 #include <apt-pkg/error.h>
15 #include <apt-pkg/sptr.h>
16 #include <apt-pkg/algorithms.h>
18 #include <apt-pkg/fileutl.h>
19 #include <apt-pkg/strutl.h>
20 #include <apt-pkg/configuration.h>
21 #include <apt-pkg/aptconfiguration.h>
22 #include <apt-pkg/pkgsystem.h>
23 #include <apt-pkg/tagfile.h>
33 // helper for Install-Recommends-Sections and Never-MarkAuto-Sections /*{{{*/
35 ConfigValueInSubTree(const char* SubTree
, const char *needle
)
37 Configuration::Item
const *Opts
;
38 Opts
= _config
->Tree(SubTree
);
39 if (Opts
!= 0 && Opts
->Child
!= 0)
42 for (; Opts
!= 0; Opts
= Opts
->Next
)
44 if (Opts
->Value
.empty() == true)
46 if (strcmp(needle
, Opts
->Value
.c_str()) == 0)
53 pkgDepCache::ActionGroup::ActionGroup(pkgDepCache
&cache
) : /*{{{*/
54 cache(cache
), released(false)
59 void pkgDepCache::ActionGroup::release()
63 if(cache
.group_level
== 0)
64 std::cerr
<< "W: Unbalanced action groups, expect badness" << std::endl
;
69 if(cache
.group_level
== 0)
77 pkgDepCache::ActionGroup::~ActionGroup()
82 // DepCache::pkgDepCache - Constructors /*{{{*/
83 // ---------------------------------------------------------------------
85 pkgDepCache::pkgDepCache(pkgCache
*pCache
,Policy
*Plcy
) :
86 group_level(0), Cache(pCache
), PkgState(0), DepState(0)
88 DebugMarker
= _config
->FindB("Debug::pkgDepCache::Marker", false);
89 DebugAutoInstall
= _config
->FindB("Debug::pkgDepCache::AutoInstall", false);
93 delLocalPolicy
= LocalPolicy
= new Policy
;
96 // DepCache::~pkgDepCache - Destructor /*{{{*/
97 // ---------------------------------------------------------------------
99 pkgDepCache::~pkgDepCache()
103 delete delLocalPolicy
;
106 // DepCache::Init - Generate the initial extra structures. /*{{{*/
107 // ---------------------------------------------------------------------
108 /* This allocats the extension buffers and initializes them. */
109 bool pkgDepCache::Init(OpProgress
*Prog
)
111 // Suppress mark updates during this operation (just in case) and
112 // run a mark operation when Init terminates.
113 ActionGroup
actions(*this);
117 PkgState
= new StateCache
[Head().PackageCount
];
118 DepState
= new unsigned char[Head().DependsCount
];
119 memset(PkgState
,0,sizeof(*PkgState
)*Head().PackageCount
);
120 memset(DepState
,0,sizeof(*DepState
)*Head().DependsCount
);
124 Prog
->OverallProgress(0,2*Head().PackageCount
,Head().PackageCount
,
125 _("Building dependency tree"));
126 Prog
->SubProgress(Head().PackageCount
,_("Candidate versions"));
129 /* Set the current state of everything. In this state all of the
130 packages are kept exactly as is. See AllUpgrade */
132 for (PkgIterator I
= PkgBegin(); I
.end() != true; I
++,Done
++)
134 if (Prog
!= 0 && Done%20
== 0)
135 Prog
->Progress(Done
);
137 // Find the proper cache slot
138 StateCache
&State
= PkgState
[I
->ID
];
141 // Figure out the install version
142 State
.CandidateVer
= GetCandidateVer(I
);
143 State
.InstallVer
= I
.CurrentVer();
144 State
.Mode
= ModeKeep
;
146 State
.Update(I
,*this);
152 Prog
->OverallProgress(Head().PackageCount
,2*Head().PackageCount
,
154 _("Building dependency tree"));
155 Prog
->SubProgress(Head().PackageCount
,_("Dependency generation"));
166 bool pkgDepCache::readStateFile(OpProgress
*Prog
) /*{{{*/
169 string
const state
= _config
->FindFile("Dir::State::extended_states");
170 if(RealFileExists(state
)) {
171 state_file
.Open(state
, FileFd::ReadOnly
);
172 int const file_size
= state_file
.Size();
174 Prog
->OverallProgress(0, file_size
, 1,
175 _("Reading state information"));
177 pkgTagFile
tagfile(&state_file
);
178 pkgTagSection section
;
180 bool const debug_autoremove
= _config
->FindB("Debug::pkgAutoRemove",false);
181 while(tagfile
.Step(section
)) {
182 string
const pkgname
= section
.FindS("Package");
183 string pkgarch
= section
.FindS("Architecture");
184 if (pkgarch
.empty() == true)
186 pkgCache::PkgIterator pkg
= Cache
->FindPkg(pkgname
, pkgarch
);
187 // Silently ignore unknown packages and packages with no actual version.
188 if(pkg
.end() == true || pkg
->VersionList
== 0)
191 short const reason
= section
.FindI("Auto-Installed", 0);
194 PkgState
[pkg
->ID
].Flags
|= Flag::Auto
;
195 if (unlikely(debug_autoremove
))
196 std::clog
<< "Auto-Installed : " << pkg
.FullName() << std::endl
;
197 if (pkgarch
== "any")
199 pkgCache::GrpIterator G
= pkg
.Group();
200 for (pkg
= G
.NextPkg(pkg
); pkg
.end() != true; pkg
= G
.NextPkg(pkg
))
201 if (pkg
->VersionList
!= 0)
202 PkgState
[pkg
->ID
].Flags
|= Flag::Auto
;
205 amt
+= section
.size();
207 Prog
->OverallProgress(amt
, file_size
, 1,
208 _("Reading state information"));
211 Prog
->OverallProgress(file_size
, file_size
, 1,
212 _("Reading state information"));
218 bool pkgDepCache::writeStateFile(OpProgress
*prog
, bool InstalledOnly
) /*{{{*/
220 bool const debug_autoremove
= _config
->FindB("Debug::pkgAutoRemove",false);
223 std::clog
<< "pkgDepCache::writeStateFile()" << std::endl
;
226 string
const state
= _config
->FindFile("Dir::State::extended_states");
228 // if it does not exist, create a empty one
229 if(!RealFileExists(state
))
231 StateFile
.Open(state
, FileFd::WriteAtomic
);
236 if(!StateFile
.Open(state
, FileFd::ReadOnly
))
237 return _error
->Error(_("Failed to open StateFile %s"),
241 string
const outfile
= state
+ ".tmp";
242 if((OutFile
= fopen(outfile
.c_str(),"w")) == NULL
)
243 return _error
->Error(_("Failed to write temporary StateFile %s"),
246 // first merge with the existing sections
247 pkgTagFile
tagfile(&StateFile
);
248 pkgTagSection section
;
249 std::set
<string
> pkgs_seen
;
250 const char *nullreorderlist
[] = {0};
251 while(tagfile
.Step(section
)) {
252 string
const pkgname
= section
.FindS("Package");
253 string pkgarch
= section
.FindS("Architecture");
254 if (pkgarch
.empty() == true)
256 // Silently ignore unknown packages and packages with no actual
258 pkgCache::PkgIterator pkg
= Cache
->FindPkg(pkgname
, pkgarch
);
259 if(pkg
.end() || pkg
.VersionList().end())
261 StateCache
const &P
= PkgState
[pkg
->ID
];
262 bool newAuto
= (P
.Flags
& Flag::Auto
);
263 // skip not installed or now-removed ones if requested
264 if (InstalledOnly
&& (
265 (pkg
->CurrentVer
== 0 && P
.Mode
!= ModeInstall
) ||
266 (pkg
->CurrentVer
!= 0 && P
.Mode
== ModeDelete
)))
268 // The section is obsolete if it contains no other tag
269 unsigned int const count
= section
.Count();
271 (count
== 2 && section
.Exists("Auto-Installed")) ||
272 (count
== 3 && section
.Exists("Auto-Installed") && section
.Exists("Architecture")))
277 if(_config
->FindB("Debug::pkgAutoRemove",false))
278 std::clog
<< "Update existing AutoInstall info: "
279 << pkg
.FullName() << std::endl
;
280 TFRewriteData rewrite
[3];
281 rewrite
[0].Tag
= "Architecture";
282 rewrite
[0].Rewrite
= pkg
.Arch();
283 rewrite
[0].NewTag
= 0;
284 rewrite
[1].Tag
= "Auto-Installed";
285 rewrite
[1].Rewrite
= newAuto
? "1" : "0";
286 rewrite
[1].NewTag
= 0;
288 TFRewrite(OutFile
, section
, nullreorderlist
, rewrite
);
289 fprintf(OutFile
,"\n");
290 pkgs_seen
.insert(pkg
.FullName());
293 // then write the ones we have not seen yet
294 std::ostringstream ostr
;
295 for(pkgCache::PkgIterator pkg
=Cache
->PkgBegin(); !pkg
.end(); pkg
++) {
296 StateCache
const &P
= PkgState
[pkg
->ID
];
297 if(P
.Flags
& Flag::Auto
) {
298 if (pkgs_seen
.find(pkg
.FullName()) != pkgs_seen
.end()) {
300 std::clog
<< "Skipping already written " << pkg
.FullName() << std::endl
;
303 // skip not installed ones if requested
304 if (InstalledOnly
&& (
305 (pkg
->CurrentVer
== 0 && P
.Mode
!= ModeInstall
) ||
306 (pkg
->CurrentVer
!= 0 && P
.Mode
== ModeDelete
)))
308 const char* const pkgarch
= pkg
.Arch();
309 if (strcmp(pkgarch
, "all") == 0)
312 std::clog
<< "Writing new AutoInstall: " << pkg
.FullName() << std::endl
;
313 ostr
.str(string(""));
314 ostr
<< "Package: " << pkg
.Name()
315 << "\nArchitecture: " << pkgarch
316 << "\nAuto-Installed: 1\n\n";
317 fprintf(OutFile
,"%s",ostr
.str().c_str());
322 // move the outfile over the real file and set permissions
323 rename(outfile
.c_str(), state
.c_str());
324 chmod(state
.c_str(), 0644);
329 // DepCache::CheckDep - Checks a single dependency /*{{{*/
330 // ---------------------------------------------------------------------
331 /* This first checks the dependency against the main target package and
332 then walks along the package provides list and checks if each provides
333 will be installed then checks the provides against the dep. Res will be
334 set to the package which was used to satisfy the dep. */
335 bool pkgDepCache::CheckDep(DepIterator Dep
,int Type
,PkgIterator
&Res
)
337 Res
= Dep
.TargetPkg();
339 /* Check simple depends. A depends -should- never self match but
340 we allow it anyhow because dpkg does. Technically it is a packaging
341 bug. Conflicts may never self match */
342 if (Dep
.TargetPkg() != Dep
.ParentPkg() ||
343 (Dep
->Type
!= Dep::Conflicts
&& Dep
->Type
!= Dep::DpkgBreaks
&& Dep
->Type
!= Dep::Obsoletes
))
345 PkgIterator Pkg
= Dep
.TargetPkg();
346 // Check the base package
347 if (Type
== NowVersion
&& Pkg
->CurrentVer
!= 0)
348 if (VS().CheckDep(Pkg
.CurrentVer().VerStr(),Dep
->CompareOp
,
349 Dep
.TargetVer()) == true)
352 if (Type
== InstallVersion
&& PkgState
[Pkg
->ID
].InstallVer
!= 0)
353 if (VS().CheckDep(PkgState
[Pkg
->ID
].InstVerIter(*this).VerStr(),
354 Dep
->CompareOp
,Dep
.TargetVer()) == true)
357 if (Type
== CandidateVersion
&& PkgState
[Pkg
->ID
].CandidateVer
!= 0)
358 if (VS().CheckDep(PkgState
[Pkg
->ID
].CandidateVerIter(*this).VerStr(),
359 Dep
->CompareOp
,Dep
.TargetVer()) == true)
363 if (Dep
->Type
== Dep::Obsoletes
)
366 // Check the providing packages
367 PrvIterator P
= Dep
.TargetPkg().ProvidesList();
368 PkgIterator Pkg
= Dep
.ParentPkg();
369 for (; P
.end() != true; P
++)
371 /* Provides may never be applied against the same package (or group)
372 if it is a conflicts. See the comment above. */
373 if (P
.OwnerPkg()->Group
== Pkg
->Group
&&
374 (Dep
->Type
== Dep::Conflicts
|| Dep
->Type
== Dep::DpkgBreaks
))
377 // Check if the provides is a hit
378 if (Type
== NowVersion
)
380 if (P
.OwnerPkg().CurrentVer() != P
.OwnerVer())
384 if (Type
== InstallVersion
)
386 StateCache
&State
= PkgState
[P
.OwnerPkg()->ID
];
387 if (State
.InstallVer
!= (Version
*)P
.OwnerVer())
391 if (Type
== CandidateVersion
)
393 StateCache
&State
= PkgState
[P
.OwnerPkg()->ID
];
394 if (State
.CandidateVer
!= (Version
*)P
.OwnerVer())
398 // Compare the versions.
399 if (VS().CheckDep(P
.ProvideVersion(),Dep
->CompareOp
,Dep
.TargetVer()) == true)
409 // DepCache::AddSizes - Add the packages sizes to the counters /*{{{*/
410 // ---------------------------------------------------------------------
411 /* Call with Mult = -1 to preform the inverse opration
412 The Mult increases the complexity of the calulations here and is unused -
413 or do we really have a usecase for removing the size of a package two
414 times? So let us replace it with a simple bool and be done with it… */
415 __deprecated
void pkgDepCache::AddSizes(const PkgIterator
&Pkg
,signed long Mult
)
417 StateCache
&P
= PkgState
[Pkg
->ID
];
419 if (Pkg
->VersionList
== 0)
422 if (Pkg
.State() == pkgCache::PkgIterator::NeedsConfigure
&&
426 // Compute the size data
427 if (P
.NewInstall() == true)
429 iUsrSize
+= (signed long long)(Mult
*P
.InstVerIter(*this)->InstalledSize
);
430 iDownloadSize
+= (signed long long)(Mult
*P
.InstVerIter(*this)->Size
);
435 if (Pkg
->CurrentVer
!= 0 &&
436 (P
.InstallVer
!= (Version
*)Pkg
.CurrentVer() ||
437 (P
.iFlags
& ReInstall
) == ReInstall
) && P
.InstallVer
!= 0)
439 iUsrSize
+= (signed long long)(Mult
*((signed long long)P
.InstVerIter(*this)->InstalledSize
-
440 (signed long long)Pkg
.CurrentVer()->InstalledSize
));
441 iDownloadSize
+= (signed long long)(Mult
*P
.InstVerIter(*this)->Size
);
446 if (Pkg
.State() == pkgCache::PkgIterator::NeedsUnpack
&&
449 iDownloadSize
+= (signed long long)(Mult
*P
.InstVerIter(*this)->Size
);
454 if (Pkg
->CurrentVer
!= 0 && P
.InstallVer
== 0)
456 iUsrSize
-= (signed long long)(Mult
*Pkg
.CurrentVer()->InstalledSize
);
461 // DepCache::AddSizes - Add the packages sizes to the counters /*{{{*/
462 // ---------------------------------------------------------------------
463 /* Call with Inverse = true to preform the inverse opration */
464 void pkgDepCache::AddSizes(const PkgIterator
&Pkg
, bool const &Inverse
)
466 StateCache
&P
= PkgState
[Pkg
->ID
];
468 if (Pkg
->VersionList
== 0)
471 if (Pkg
.State() == pkgCache::PkgIterator::NeedsConfigure
&&
475 // Compute the size data
476 if (P
.NewInstall() == true)
478 if (Inverse
== false) {
479 iUsrSize
+= P
.InstVerIter(*this)->InstalledSize
;
480 iDownloadSize
+= P
.InstVerIter(*this)->Size
;
482 iUsrSize
-= P
.InstVerIter(*this)->InstalledSize
;
483 iDownloadSize
-= P
.InstVerIter(*this)->Size
;
489 if (Pkg
->CurrentVer
!= 0 &&
490 (P
.InstallVer
!= (Version
*)Pkg
.CurrentVer() ||
491 (P
.iFlags
& ReInstall
) == ReInstall
) && P
.InstallVer
!= 0)
493 if (Inverse
== false) {
494 iUsrSize
-= Pkg
.CurrentVer()->InstalledSize
;
495 iUsrSize
+= P
.InstVerIter(*this)->InstalledSize
;
496 iDownloadSize
+= P
.InstVerIter(*this)->Size
;
498 iUsrSize
-= P
.InstVerIter(*this)->InstalledSize
;
499 iUsrSize
+= Pkg
.CurrentVer()->InstalledSize
;
500 iDownloadSize
-= P
.InstVerIter(*this)->Size
;
506 if (Pkg
.State() == pkgCache::PkgIterator::NeedsUnpack
&&
509 if (Inverse
== false)
510 iDownloadSize
+= P
.InstVerIter(*this)->Size
;
512 iDownloadSize
-= P
.InstVerIter(*this)->Size
;
517 if (Pkg
->CurrentVer
!= 0 && P
.InstallVer
== 0)
519 if (Inverse
== false)
520 iUsrSize
-= Pkg
.CurrentVer()->InstalledSize
;
522 iUsrSize
+= Pkg
.CurrentVer()->InstalledSize
;
527 // DepCache::AddStates - Add the package to the state counter /*{{{*/
528 // ---------------------------------------------------------------------
529 /* This routine is tricky to use, you must make sure that it is never
530 called twice for the same package. This means the Remove/Add section
531 should be as short as possible and not encompass any code that will
532 calld Remove/Add itself. Remember, dependencies can be circular so
533 while processing a dep for Pkg it is possible that Add/Remove
534 will be called on Pkg */
535 void pkgDepCache::AddStates(const PkgIterator
&Pkg
,int Add
)
537 StateCache
&State
= PkgState
[Pkg
->ID
];
539 // The Package is broken (either minimal dep or policy dep)
540 if ((State
.DepState
& DepInstMin
) != DepInstMin
)
542 if ((State
.DepState
& DepInstPolicy
) != DepInstPolicy
)
543 iPolicyBrokenCount
+= Add
;
546 if (Pkg
.State() != PkgIterator::NeedsNothing
)
550 if (Pkg
->CurrentVer
== 0)
552 if (State
.Mode
== ModeDelete
&&
553 (State
.iFlags
| Purge
) == Purge
&& Pkg
.Purge() == false)
556 if (State
.Mode
== ModeInstall
)
561 // Installed, no upgrade
562 if (State
.Status
== 0)
564 if (State
.Mode
== ModeDelete
)
567 if ((State
.iFlags
& ReInstall
) == ReInstall
)
573 // Alll 3 are possible
574 if (State
.Mode
== ModeDelete
)
576 if (State
.Mode
== ModeKeep
)
578 if (State
.Mode
== ModeInstall
)
582 // DepCache::BuildGroupOrs - Generate the Or group dep data /*{{{*/
583 // ---------------------------------------------------------------------
584 /* The or group results are stored in the last item of the or group. This
585 allows easy detection of the state of a whole or'd group. */
586 void pkgDepCache::BuildGroupOrs(VerIterator
const &V
)
588 unsigned char Group
= 0;
590 for (DepIterator D
= V
.DependsList(); D
.end() != true; D
++)
592 // Build the dependency state.
593 unsigned char &State
= DepState
[D
->ID
];
595 /* Invert for Conflicts. We have to do this twice to get the
596 right sense for a conflicts group */
597 if (D
->Type
== Dep::Conflicts
||
598 D
->Type
== Dep::DpkgBreaks
||
599 D
->Type
== Dep::Obsoletes
)
602 // Add to the group if we are within an or..
606 if ((D
->CompareOp
& Dep::Or
) != Dep::Or
)
609 // Invert for Conflicts
610 if (D
->Type
== Dep::Conflicts
||
611 D
->Type
== Dep::DpkgBreaks
||
612 D
->Type
== Dep::Obsoletes
)
617 // DepCache::VersionState - Perform a pass over a dependency list /*{{{*/
618 // ---------------------------------------------------------------------
619 /* This is used to run over a dependency list and determine the dep
620 state of the list, filtering it through both a Min check and a Policy
621 check. The return result will have SetMin/SetPolicy low if a check
622 fails. It uses the DepState cache for it's computations. */
623 unsigned char pkgDepCache::VersionState(DepIterator D
,unsigned char Check
,
624 unsigned char SetMin
,
625 unsigned char SetPolicy
)
627 unsigned char Dep
= 0xFF;
629 while (D
.end() != true)
631 // Compute a single dependency element (glob or)
632 DepIterator Start
= D
;
633 unsigned char State
= 0;
634 for (bool LastOR
= true; D
.end() == false && LastOR
== true; D
++)
636 State
|= DepState
[D
->ID
];
637 LastOR
= (D
->CompareOp
& Dep::Or
) == Dep::Or
;
640 // Minimum deps that must be satisfied to have a working package
641 if (Start
.IsCritical() == true)
642 if ((State
& Check
) != Check
)
645 // Policy deps that must be satisfied to install the package
646 if (IsImportantDep(Start
) == true &&
647 (State
& Check
) != Check
)
654 // DepCache::DependencyState - Compute the 3 results for a dep /*{{{*/
655 // ---------------------------------------------------------------------
656 /* This is the main dependency computation bit. It computes the 3 main
657 results for a dependencys, Now, Install and Candidate. Callers must
658 invert the result if dealing with conflicts. */
659 unsigned char pkgDepCache::DependencyState(DepIterator
&D
)
661 unsigned char State
= 0;
663 if (CheckDep(D
,NowVersion
) == true)
665 if (CheckDep(D
,InstallVersion
) == true)
667 if (CheckDep(D
,CandidateVersion
) == true)
673 // DepCache::UpdateVerState - Compute the Dep member of the state /*{{{*/
674 // ---------------------------------------------------------------------
675 /* This determines the combined dependency representation of a package
676 for its two states now and install. This is done by using the pre-generated
677 dependency information. */
678 void pkgDepCache::UpdateVerState(PkgIterator Pkg
)
680 // Empty deps are always true
681 StateCache
&State
= PkgState
[Pkg
->ID
];
682 State
.DepState
= 0xFF;
684 // Check the Current state
685 if (Pkg
->CurrentVer
!= 0)
687 DepIterator D
= Pkg
.CurrentVer().DependsList();
688 State
.DepState
&= VersionState(D
,DepNow
,DepNowMin
,DepNowPolicy
);
691 /* Check the candidate state. We do not compare against the whole as
692 a candidate state but check the candidate version against the
694 if (State
.CandidateVer
!= 0)
696 DepIterator D
= State
.CandidateVerIter(*this).DependsList();
697 State
.DepState
&= VersionState(D
,DepInstall
,DepCandMin
,DepCandPolicy
);
700 // Check target state which can only be current or installed
701 if (State
.InstallVer
!= 0)
703 DepIterator D
= State
.InstVerIter(*this).DependsList();
704 State
.DepState
&= VersionState(D
,DepInstall
,DepInstMin
,DepInstPolicy
);
708 // DepCache::RemovePseudoInstalledPkg - MultiArch helper for Update() /*{{{*/
709 // ---------------------------------------------------------------------
710 /* We "install" arch all packages for all archs if it is installed. Many
711 of these will be broken. This method will look at these broken Pkg and
713 bool pkgDepCache::RemovePseudoInstalledPkg(PkgIterator
&Pkg
, std::set
<unsigned long> &recheck
) {
714 if (unlikely(Pkg
->CurrentVer
== 0))
717 VerIterator V
= Pkg
.CurrentVer();
718 if (V
->MultiArch
!= Version::All
)
721 // Never ever kill an "all" package - they have no dependency so they can't be broken
722 if (strcmp(Pkg
.Arch(),"all") == 0)
725 unsigned char const CurDepState
= VersionState(V
.DependsList(),DepInstall
,DepInstMin
,DepInstPolicy
);
726 if ((CurDepState
& DepInstMin
) == DepInstMin
) {
727 // okay, the package isn't broken, but is the package also required?
728 // If it has no real dependencies, no installed rdepends and doesn't
729 // provide something of value, we will kill it as not required.
730 // These pseudopackages have otherwise interesting effects if they get
731 // a new dependency in a newer version…
732 for (pkgCache::DepIterator D
= V
.DependsList();
733 D
.end() != true; ++D
)
734 if (D
.IsCritical() == true && D
.ParentPkg()->Group
!= Pkg
->Group
)
736 for (DepIterator D
= Pkg
.RevDependsList(); D
.end() != true; ++D
)
738 if (D
.IsCritical() == false)
740 PkgIterator
const P
= D
.ParentPkg();
741 if (P
->Group
== Pkg
->Group
)
743 if (P
->CurrentVer
!= 0)
746 for (PrvIterator Prv
= V
.ProvidesList(); Prv
.end() != true; Prv
++)
747 for (DepIterator d
= Prv
.ParentPkg().RevDependsList();
748 d
.end() != true; ++d
)
750 PkgIterator
const P
= d
.ParentPkg();
751 if (P
->CurrentVer
!= 0 &&
752 P
->Group
!= Pkg
->Group
)
757 // Dependencies for this arch all package are not statisfied
758 // so we installed it only for our convenience: get right of it now.
763 PkgState
[Pkg
->ID
].InstallVer
= 0;
769 // After the remove previously satisfied pseudo pkg could be now
770 // no longer satisfied, so we need to recheck the reverse dependencies
771 for (DepIterator d
= Pkg
.RevDependsList(); d
.end() != true; ++d
)
773 PkgIterator
const P
= d
.ParentPkg();
774 if (P
->CurrentVer
!= 0)
775 recheck
.insert(P
.Index());
778 for (DepIterator d
= V
.DependsList(); d
.end() != true; ++d
)
780 PkgIterator
const P
= d
.TargetPkg();
781 for (PrvIterator Prv
= P
.ProvidesList(); Prv
.end() != true; ++Prv
)
783 PkgIterator
const O
= Prv
.OwnerPkg();
784 if (O
->CurrentVer
!= 0)
785 recheck
.insert(O
.Index());
788 if (P
->CurrentVer
!= 0)
789 recheck
.insert(P
.Index());
792 for (PrvIterator Prv
= V
.ProvidesList(); Prv
.end() != true; Prv
++)
794 for (DepIterator d
= Prv
.ParentPkg().RevDependsList();
795 d
.end() != true; ++d
)
797 PkgIterator
const P
= d
.ParentPkg();
798 if (P
->CurrentVer
== 0)
801 recheck
.insert(P
.Index());
809 // DepCache::Update - Figure out all the state information /*{{{*/
810 // ---------------------------------------------------------------------
811 /* This will figure out the state of all the packages and all the
812 dependencies based on the current policy. */
813 void pkgDepCache::Update(OpProgress
*Prog
)
823 std::set
<unsigned long> recheck
;
825 // Perform the depends pass
827 bool const checkMultiArch
= APT::Configuration::getArchitectures().size() > 1;
828 unsigned long killed
= 0;
829 for (PkgIterator I
= PkgBegin(); I
.end() != true; I
++,Done
++)
831 if (Prog
!= 0 && Done%20
== 0)
832 Prog
->Progress(Done
);
833 for (VerIterator V
= I
.VersionList(); V
.end() != true; V
++)
835 unsigned char Group
= 0;
837 for (DepIterator D
= V
.DependsList(); D
.end() != true; D
++)
839 // Build the dependency state.
840 unsigned char &State
= DepState
[D
->ID
];
841 State
= DependencyState(D
);
843 // Add to the group if we are within an or..
846 if ((D
->CompareOp
& Dep::Or
) != Dep::Or
)
849 // Invert for Conflicts
850 if (D
->Type
== Dep::Conflicts
||
851 D
->Type
== Dep::DpkgBreaks
||
852 D
->Type
== Dep::Obsoletes
)
857 // Compute the package dependency state and size additions
862 if (checkMultiArch
!= true || I
->CurrentVer
== 0)
865 VerIterator
const V
= I
.CurrentVer();
866 if (V
->MultiArch
!= Version::All
)
869 recheck
.insert(I
.Index());
870 --Done
; // no progress if we need to recheck the package
873 if (checkMultiArch
== true) {
874 /* FIXME: recheck breaks proper progress reporting as we don't know
875 how many packages we need to recheck. To lower the effect
876 a bit we increase with a kill, but we should do something more clever… */
877 while(recheck
.empty() == false)
878 for (std::set
<unsigned long>::const_iterator p
= recheck
.begin();
879 p
!= recheck
.end();) {
880 if (Prog
!= 0 && Done%20
== 0)
881 Prog
->Progress(Done
);
882 PkgIterator P
= PkgIterator(*Cache
, Cache
->PkgP
+ *p
);
883 if (RemovePseudoInstalledPkg(P
, recheck
) == true) {
890 /* Okay, we have killed a great amount of pseudopackages -
891 we have killed so many that we have now arch "all" packages
892 without an installed pseudo package, but we NEED an installed
893 pseudo package, so we will search now for a pseudo package
894 we can install without breaking everything. */
895 for (GrpIterator G
= Cache
->GrpBegin(); G
.end() != true; ++G
)
897 PkgIterator P
= G
.FindPkg("all");
900 if (P
->CurrentVer
== 0)
902 bool installed
= false;
903 for (P
= G
.FindPkg("any"); P
.end() != true; P
= G
.NextPkg(P
))
905 if (strcmp(P
.Arch(), "all") == 0)
907 if (P
->CurrentVer
== 0)
912 if (installed
== false)
913 recheck
.insert(G
.Index());
916 while (recheck
.empty() != true)
918 std::set
<unsigned long>::const_iterator g
= recheck
.begin();
919 unsigned long const G
= *g
;
921 if (unlikely(ReInstallPseudoForGroup(G
, recheck
) == false))
922 _error
->Warning(_("Internal error, group '%s' has no installable pseudo package"), GrpIterator(*Cache
, Cache
->GrpP
+ G
).Name());
927 Prog
->Progress(Done
);
932 // DepCache::ReInstallPseudoForGroup - MultiArch helper for Update() /*{{{*/
933 // ---------------------------------------------------------------------
934 /* RemovePseudoInstalledPkg() is very successful. It even kills packages
935 to an amount that no pseudo package is left, but we need a pseudo package
936 for upgrading senarios so we need to reinstall one pseudopackage which
937 doesn't break everything. Thankfully we can't have architecture depending
938 negative dependencies so this problem is already eliminated */
939 bool pkgDepCache::ReInstallPseudoForGroup(pkgCache::PkgIterator
const &P
, std::set
<unsigned long> &recheck
)
941 if (P
->CurrentVer
!= 0)
943 // recursive call for packages which provide this package
944 for (pkgCache::PrvIterator Prv
= P
.ProvidesList(); Prv
.end() != true; ++Prv
)
945 ReInstallPseudoForGroup(Prv
.OwnerPkg(), recheck
);
946 // check if we actually need to look at this group
947 unsigned long const G
= P
->Group
;
948 std::set
<unsigned long>::const_iterator Pi
= recheck
.find(G
);
949 if (Pi
== recheck
.end())
951 recheck
.erase(Pi
); // remove here, so we can't fall into an endless loop
952 if (unlikely(ReInstallPseudoForGroup(G
, recheck
) == false))
959 bool pkgDepCache::ReInstallPseudoForGroup(unsigned long const &G
, std::set
<unsigned long> &recheck
)
961 std::vector
<std::string
> static const Archs
= APT::Configuration::getArchitectures();
962 pkgCache::GrpIterator
Grp(*Cache
, Cache
->GrpP
+ G
);
963 if (unlikely(Grp
.end() == true))
965 for (std::vector
<std::string
>::const_iterator a
= Archs
.begin();
966 a
!= Archs
.end(); ++a
)
968 pkgCache::PkgIterator P
= Grp
.FindPkg(*a
);
971 pkgCache::VerIterator allV
= Grp
.FindPkg("all").CurrentVer();
972 for (VerIterator V
= P
.VersionList(); V
.end() != true; ++V
)
974 // search for the same version as the all package
975 if (allV
->Hash
!= V
->Hash
|| strcmp(allV
.VerStr(),V
.VerStr()) != 0)
977 unsigned char const CurDepState
= VersionState(V
.DependsList(),DepInstall
,DepInstMin
,DepInstPolicy
);
978 // If it is broken, try to install dependencies first before retry
979 if ((CurDepState
& DepInstMin
) != DepInstMin
)
981 for (pkgCache::DepIterator D
= V
.DependsList(); D
.end() != true; ++D
)
983 if (D
->Type
!= pkgCache::Dep::PreDepends
&& D
->Type
!= pkgCache::Dep::Depends
)
985 ReInstallPseudoForGroup(D
.TargetPkg(), recheck
);
987 unsigned char const CurDepState
= VersionState(V
.DependsList(),DepInstall
,DepInstMin
,DepInstPolicy
);
988 // if package ist still broken… try another arch
989 if ((CurDepState
& DepInstMin
) != DepInstMin
)
992 // dependencies satisfied: reinstall the package
995 P
->CurrentVer
= V
.Index();
996 PkgState
[P
->ID
].InstallVer
= V
;
1006 // DepCache::Update - Update the deps list of a package /*{{{*/
1007 // ---------------------------------------------------------------------
1008 /* This is a helper for update that only does the dep portion of the scan.
1009 It is mainly meant to scan reverse dependencies. */
1010 void pkgDepCache::Update(DepIterator D
)
1012 // Update the reverse deps
1013 for (;D
.end() != true; D
++)
1015 unsigned char &State
= DepState
[D
->ID
];
1016 State
= DependencyState(D
);
1018 // Invert for Conflicts
1019 if (D
->Type
== Dep::Conflicts
||
1020 D
->Type
== Dep::DpkgBreaks
||
1021 D
->Type
== Dep::Obsoletes
)
1024 RemoveStates(D
.ParentPkg());
1025 BuildGroupOrs(D
.ParentVer());
1026 UpdateVerState(D
.ParentPkg());
1027 AddStates(D
.ParentPkg());
1031 // DepCache::Update - Update the related deps of a package /*{{{*/
1032 // ---------------------------------------------------------------------
1033 /* This is called whenever the state of a package changes. It updates
1034 all cached dependencies related to this package. */
1035 void pkgDepCache::Update(PkgIterator
const &Pkg
)
1037 // Recompute the dep of the package
1039 UpdateVerState(Pkg
);
1042 // Update the reverse deps
1043 Update(Pkg
.RevDependsList());
1045 // Update the provides map for the current ver
1046 if (Pkg
->CurrentVer
!= 0)
1047 for (PrvIterator P
= Pkg
.CurrentVer().ProvidesList();
1048 P
.end() != true; P
++)
1049 Update(P
.ParentPkg().RevDependsList());
1051 // Update the provides map for the candidate ver
1052 if (PkgState
[Pkg
->ID
].CandidateVer
!= 0)
1053 for (PrvIterator P
= PkgState
[Pkg
->ID
].CandidateVerIter(*this).ProvidesList();
1054 P
.end() != true; P
++)
1055 Update(P
.ParentPkg().RevDependsList());
1058 // DepCache::MarkKeep - Put the package in the keep state /*{{{*/
1059 // ---------------------------------------------------------------------
1061 void pkgDepCache::MarkKeep(PkgIterator
const &Pkg
, bool Soft
, bool FromUser
,
1062 unsigned long Depth
)
1064 // Simplifies other routines.
1065 if (Pkg
.end() == true)
1068 /* Reject an attempt to keep a non-source broken installed package, those
1070 if (Pkg
.State() == PkgIterator::NeedsUnpack
&&
1071 Pkg
.CurrentVer().Downloadable() == false)
1074 /** \todo Can this be moved later in the method? */
1075 ActionGroup
group(*this);
1077 /* We changed the soft state all the time so the UI is a bit nicer
1079 StateCache
&P
= PkgState
[Pkg
->ID
];
1081 P
.iFlags
|= AutoKept
;
1083 P
.iFlags
&= ~AutoKept
;
1085 // Check that it is not already kept
1086 if (P
.Mode
== ModeKeep
)
1089 // We dont even try to keep virtual packages..
1090 if (Pkg
->VersionList
== 0)
1092 #if 0 // reseting the autoflag here means we lose the
1093 // auto-mark information if a user selects a package for removal
1094 // but changes his mind then and sets it for keep again
1095 // - this makes sense as default when all Garbage dependencies
1096 // are automatically marked for removal (as aptitude does).
1097 // setting a package for keep then makes it no longer autoinstalled
1098 // for all other use-case this action is rather suprising
1099 if(FromUser
&& !P
.Marked
)
1100 P
.Flags
&= ~Flag::Auto
;
1103 if (DebugMarker
== true)
1104 std::clog
<< OutputInDepth(Depth
) << "MarkKeep " << Pkg
<< " FU=" << FromUser
<< std::endl
;
1110 if (Pkg
->CurrentVer
== 0)
1113 P
.InstallVer
= Pkg
.CurrentVer();
1122 // DepCache::MarkDelete - Put the package in the delete state /*{{{*/
1123 // ---------------------------------------------------------------------
1125 void pkgDepCache::MarkDelete(PkgIterator
const &Pkg
, bool rPurge
,
1126 unsigned long Depth
, bool FromUser
)
1128 // Simplifies other routines.
1129 if (Pkg
.end() == true)
1132 ActionGroup
group(*this);
1134 // Check that it is not already marked for delete
1135 StateCache
&P
= PkgState
[Pkg
->ID
];
1136 P
.iFlags
&= ~(AutoKept
| Purge
);
1140 if ((P
.Mode
== ModeDelete
|| P
.InstallVer
== 0) &&
1141 (Pkg
.Purge() == true || rPurge
== false))
1144 // We dont even try to delete virtual packages..
1145 if (Pkg
->VersionList
== 0)
1148 // check if we are allowed to install the package
1149 if (IsDeleteOk(Pkg
,rPurge
,Depth
,FromUser
) == false)
1152 if (DebugMarker
== true)
1153 std::clog
<< OutputInDepth(Depth
) << (rPurge
? "MarkPurge " : "MarkDelete ") << Pkg
<< " FU=" << FromUser
<< std::endl
;
1158 if (Pkg
->CurrentVer
== 0 && (Pkg
.Purge() == true || rPurge
== false))
1161 P
.Mode
= ModeDelete
;
1168 // if we remove the pseudo package, we also need to remove the "real"
1169 if (Pkg
->CurrentVer
!= 0 && Pkg
.CurrentVer().Pseudo() == true)
1170 MarkDelete(Pkg
.Group().FindPkg("all"), rPurge
, Depth
+1, FromUser
);
1171 else if (rPurge
== true && Pkg
->CurrentVer
== 0 &&
1172 Pkg
->CurrentState
!= pkgCache::State::NotInstalled
&&
1173 strcmp(Pkg
.Arch(), "all") != 0)
1175 PkgIterator
const allPkg
= Pkg
.Group().FindPkg("all");
1176 if (allPkg
.end() == false && allPkg
->CurrentVer
== 0 &&
1177 allPkg
->CurrentState
!= pkgCache::State::NotInstalled
)
1178 MarkDelete(allPkg
, rPurge
, Depth
+1, FromUser
);
1182 // DepCache::IsDeleteOk - check if it is ok to remove this package /*{{{*/
1183 // ---------------------------------------------------------------------
1184 /* The default implementation just honors dpkg hold
1185 But an application using this library can override this method
1186 to control the MarkDelete behaviour */
1187 bool pkgDepCache::IsDeleteOk(PkgIterator
const &Pkg
,bool rPurge
,
1188 unsigned long Depth
, bool FromUser
)
1190 if (FromUser
== false && Pkg
->SelectedState
== pkgCache::State::Hold
&& _config
->FindB("APT::Ignore-Hold",false) == false)
1192 if (DebugMarker
== true)
1193 std::clog
<< OutputInDepth(Depth
) << "Hold prevents MarkDelete of " << Pkg
<< " FU=" << FromUser
<< std::endl
;
1196 // if the removal is not explictely requested by the user, protect
1197 // explicit new-install package from accidental removal by the
1199 else if (FromUser
== false && Pkg
->CurrentVer
== 0)
1201 StateCache
&P
= PkgState
[Pkg
->ID
];
1202 // Status == 2 means this applies for new installs only
1203 if (P
.InstallVer
!= 0 && P
.Status
== 2 && (P
.Flags
& Flag::Auto
) != Flag::Auto
)
1205 if (DebugMarker
== true)
1206 std::clog
<< OutputInDepth(Depth
) << "Manual install request prevents MarkDelete of " << Pkg
<< std::endl
;
1213 // DepCache::MarkInstall - Put the package in the install state /*{{{*/
1214 // ---------------------------------------------------------------------
1216 void pkgDepCache::MarkInstall(PkgIterator
const &Pkg
,bool AutoInst
,
1217 unsigned long Depth
, bool FromUser
,
1218 bool ForceImportantDeps
)
1223 // Simplifies other routines.
1224 if (Pkg
.end() == true)
1227 ActionGroup
group(*this);
1229 /* Check that it is not already marked for install and that it can be
1231 StateCache
&P
= PkgState
[Pkg
->ID
];
1232 P
.iFlags
&= ~AutoKept
;
1233 if ((P
.InstPolicyBroken() == false && P
.InstBroken() == false) &&
1234 (P
.Mode
== ModeInstall
||
1235 P
.CandidateVer
== (Version
*)Pkg
.CurrentVer()))
1237 if (P
.CandidateVer
== (Version
*)Pkg
.CurrentVer() && P
.InstallVer
== 0)
1238 MarkKeep(Pkg
, false, FromUser
, Depth
+1);
1242 // See if there is even any possible instalation candidate
1243 if (P
.CandidateVer
== 0)
1245 // We dont even try to install virtual packages..
1246 if (Pkg
->VersionList
== 0)
1249 // check if we are allowed to install the package
1250 if (IsInstallOk(Pkg
,AutoInst
,Depth
,FromUser
) == false)
1253 /* Target the candidate version and remove the autoflag. We reset the
1254 autoflag below if this was called recursively. Otherwise the user
1255 should have the ability to de-auto a package by changing its state */
1259 P
.Mode
= ModeInstall
;
1260 P
.InstallVer
= P
.CandidateVer
;
1264 // Set it to manual if it's a new install or already installed
1265 if(P
.Status
== 2 || Pkg
->CurrentVer
!= 0)
1266 P
.Flags
&= ~Flag::Auto
;
1270 // Set it to auto if this is a new install.
1272 P
.Flags
|= Flag::Auto
;
1274 if (P
.CandidateVer
== (Version
*)Pkg
.CurrentVer())
1281 // always trigger the install of the all package for a pseudo package
1282 if (P
.CandidateVerIter(*Cache
).Pseudo() == true)
1283 MarkInstall(Pkg
.Group().FindPkg("all"), AutoInst
, Depth
, FromUser
, ForceImportantDeps
);
1285 if (AutoInst
== false)
1288 if (DebugMarker
== true)
1289 std::clog
<< OutputInDepth(Depth
) << "MarkInstall " << Pkg
<< " FU=" << FromUser
<< std::endl
;
1291 DepIterator Dep
= P
.InstVerIter(*this).DependsList();
1292 for (; Dep
.end() != true;)
1295 DepIterator Start
= Dep
;
1298 for (bool LastOR
= true; Dep
.end() == false && LastOR
== true; Dep
++,Ors
++)
1300 LastOR
= (Dep
->CompareOp
& Dep::Or
) == Dep::Or
;
1302 if ((DepState
[Dep
->ID
] & DepInstall
) == DepInstall
)
1306 // Dep is satisfied okay.
1307 if (Result
== false)
1310 /* Check if this dep should be consider for install. If it is a user
1311 defined important dep and we are installed a new package then
1312 it will be installed. Otherwise we only check for important
1313 deps that have changed from the installed version
1315 if (IsImportantDep(Start
) == false)
1318 /* Check if any ImportantDep() (but not Critical) were added
1319 * since we installed the package. Also check for deps that
1320 * were satisfied in the past: for instance, if a version
1321 * restriction in a Recommends was tightened, upgrading the
1322 * package should follow that Recommends rather than causing the
1323 * dependency to be removed. (bug #470115)
1325 bool isNewImportantDep
= false;
1326 bool isPreviouslySatisfiedImportantDep
= false;
1327 if(!ForceImportantDeps
&& !Start
.IsCritical())
1330 VerIterator instVer
= Pkg
.CurrentVer();
1333 for (DepIterator D
= instVer
.DependsList(); D
.end() != true; D
++)
1335 //FIXME: deal better with or-groups(?)
1336 if(IsImportantDep(D
) && !D
.IsCritical() &&
1337 Start
.TargetPkg() == D
.TargetPkg())
1339 if(!isPreviouslySatisfiedImportantDep
)
1342 while((D2
->CompareOp
& Dep::Or
) != 0)
1345 isPreviouslySatisfiedImportantDep
=
1346 (((*this)[D2
] & DepGNow
) != 0);
1352 // this is a new dep if it was not found to be already
1353 // a important dep of the installed pacakge
1354 isNewImportantDep
= !found
;
1357 if(isNewImportantDep
)
1358 if(DebugAutoInstall
== true)
1359 std::clog
<< OutputInDepth(Depth
) << "new important dependency: "
1360 << Start
.TargetPkg().Name() << std::endl
;
1361 if(isPreviouslySatisfiedImportantDep
)
1362 if(DebugAutoInstall
== true)
1363 std::clog
<< OutputInDepth(Depth
) << "previously satisfied important dependency on "
1364 << Start
.TargetPkg().Name() << std::endl
;
1366 // skip important deps if the package is already installed
1367 if (Pkg
->CurrentVer
!= 0 && Start
.IsCritical() == false
1368 && !isNewImportantDep
&& !isPreviouslySatisfiedImportantDep
1369 && !ForceImportantDeps
)
1372 /* If we are in an or group locate the first or that can
1373 succeed. We have already cached this.. */
1374 for (; Ors
> 1 && (DepState
[Start
->ID
] & DepCVer
) != DepCVer
; Ors
--)
1377 /* This bit is for processing the possibilty of an install/upgrade
1378 fixing the problem */
1379 SPtrArray
<Version
*> List
= Start
.AllTargets();
1380 if (Start
->Type
!= Dep::DpkgBreaks
&&
1381 (DepState
[Start
->ID
] & DepCVer
) == DepCVer
)
1383 // Right, find the best version to install..
1384 Version
**Cur
= List
;
1385 PkgIterator P
= Start
.TargetPkg();
1386 PkgIterator
InstPkg(*Cache
,0);
1388 // See if there are direct matches (at the start of the list)
1389 for (; *Cur
!= 0 && (*Cur
)->ParentPkg
== P
.Index(); Cur
++)
1391 PkgIterator
Pkg(*Cache
,Cache
->PkgP
+ (*Cur
)->ParentPkg
);
1392 if (PkgState
[Pkg
->ID
].CandidateVer
!= *Cur
)
1398 // Select the highest priority providing package
1399 if (InstPkg
.end() == true)
1401 pkgPrioSortList(*Cache
,Cur
);
1402 for (; *Cur
!= 0; Cur
++)
1404 PkgIterator
Pkg(*Cache
,Cache
->PkgP
+ (*Cur
)->ParentPkg
);
1405 if (PkgState
[Pkg
->ID
].CandidateVer
!= *Cur
)
1412 if (InstPkg
.end() == false)
1414 if(DebugAutoInstall
== true)
1415 std::clog
<< OutputInDepth(Depth
) << "Installing " << InstPkg
.Name()
1416 << " as " << Start
.DepType() << " of " << Pkg
.Name()
1418 // now check if we should consider it a automatic dependency or not
1419 if(Pkg
.Section() && ConfigValueInSubTree("APT::Never-MarkAuto-Sections", Pkg
.Section()))
1421 if(DebugAutoInstall
== true)
1422 std::clog
<< OutputInDepth(Depth
) << "Setting NOT as auto-installed (direct "
1423 << Start
.DepType() << " of pkg in APT::Never-MarkAuto-Sections)" << std::endl
;
1424 MarkInstall(InstPkg
,true,Depth
+ 1, true);
1428 // mark automatic dependency
1429 MarkInstall(InstPkg
,true,Depth
+ 1, false, ForceImportantDeps
);
1430 // Set the autoflag, after MarkInstall because MarkInstall unsets it
1431 if (P
->CurrentVer
== 0)
1432 PkgState
[InstPkg
->ID
].Flags
|= Flag::Auto
;
1438 /* For conflicts we just de-install the package and mark as auto,
1439 Conflicts may not have or groups. For dpkg's Breaks we try to
1440 upgrade the package. */
1441 if (Start
->Type
== Dep::Conflicts
|| Start
->Type
== Dep::Obsoletes
||
1442 Start
->Type
== Dep::DpkgBreaks
)
1444 for (Version
**I
= List
; *I
!= 0; I
++)
1446 VerIterator
Ver(*this,*I
);
1447 PkgIterator Pkg
= Ver
.ParentPkg();
1449 /* The List includes all packages providing this dependency,
1450 even providers which are not installed, so skip them. */
1451 if (PkgState
[Pkg
->ID
].InstallVer
== 0)
1454 if (PkgState
[Pkg
->ID
].CandidateVer
!= *I
&&
1455 Start
->Type
== Dep::DpkgBreaks
)
1456 MarkInstall(Pkg
,true,Depth
+ 1, false, ForceImportantDeps
);
1458 MarkDelete(Pkg
,false,Depth
+ 1, false);
1465 // DepCache::IsInstallOk - check if it is ok to install this package /*{{{*/
1466 // ---------------------------------------------------------------------
1467 /* The default implementation just honors dpkg hold
1468 But an application using this library can override this method
1469 to control the MarkInstall behaviour */
1470 bool pkgDepCache::IsInstallOk(PkgIterator
const &Pkg
,bool AutoInst
,
1471 unsigned long Depth
, bool FromUser
)
1473 if (FromUser
== false && Pkg
->SelectedState
== pkgCache::State::Hold
&& _config
->FindB("APT::Ignore-Hold",false) == false)
1475 if (DebugMarker
== true)
1476 std::clog
<< OutputInDepth(Depth
) << "Hold prevents MarkInstall of " << Pkg
<< " FU=" << FromUser
<< std::endl
;
1482 // DepCache::SetReInstall - Set the reinstallation flag /*{{{*/
1483 // ---------------------------------------------------------------------
1485 void pkgDepCache::SetReInstall(PkgIterator
const &Pkg
,bool To
)
1487 if (unlikely(Pkg
.end() == true))
1490 ActionGroup
group(*this);
1495 StateCache
&P
= PkgState
[Pkg
->ID
];
1497 P
.iFlags
|= ReInstall
;
1499 P
.iFlags
&= ~ReInstall
;
1504 if (unlikely(Pkg
.CurrentVer().end() == true) || Pkg
.CurrentVer().Pseudo() == false)
1507 SetReInstall(Pkg
.Group().FindPkg("all"), To
);
1510 // DepCache::SetCandidateVersion - Change the candidate version /*{{{*/
1511 // ---------------------------------------------------------------------
1513 void pkgDepCache::SetCandidateVersion(VerIterator TargetVer
, bool const &Pseudo
)
1516 pkgCache::PkgIterator Pkg
= TargetVer
.ParentPkg();
1517 StateCache
&P
= PkgState
[Pkg
->ID
];
1519 if (P
.CandidateVer
== TargetVer
)
1522 ActionGroup
group(*this);
1527 if (P
.CandidateVer
== P
.InstallVer
&& P
.Install() == true)
1528 P
.InstallVer
= (Version
*)TargetVer
;
1529 P
.CandidateVer
= (Version
*)TargetVer
;
1530 P
.Update(Pkg
,*this);
1536 if (TargetVer
.Pseudo() == false || Pseudo
== false)
1539 // the version was pseudo: set all other pseudos also
1540 pkgCache::GrpIterator Grp
= Pkg
.Group();
1541 for (Pkg
= Grp
.FindPkg("any"); Pkg
.end() == false; ++Pkg
)
1543 StateCache
&P
= PkgState
[Pkg
->ID
];
1544 if (TargetVer
.SimilarVer(P
.CandidateVerIter(*this)) == true ||
1545 (P
.CandidateVerIter(*this).Pseudo() == false &&
1546 strcmp(Pkg
.Arch(), "all") != 0))
1549 for (pkgCache::VerIterator Ver
= Pkg
.VersionList(); Ver
.end() == false; ++Ver
)
1551 if (TargetVer
.SimilarVer(Ver
) == false)
1553 SetCandidateVersion(Ver
, false);
1559 // DepCache::SetCandidateRelease - Change the candidate version /*{{{*/
1560 // ---------------------------------------------------------------------
1561 /* changes the candidate of a package and walks over all its dependencies
1562 to check if it needs to change the candidate of the dependency, too,
1563 to reach a installable versionstate */
1564 bool pkgDepCache::SetCandidateRelease(pkgCache::VerIterator TargetVer
,
1565 std::string
const &TargetRel
)
1567 std::list
<std::pair
<pkgCache::VerIterator
, pkgCache::VerIterator
> > Changed
;
1568 return SetCandidateRelease(TargetVer
, TargetRel
, Changed
);
1570 bool pkgDepCache::SetCandidateRelease(pkgCache::VerIterator TargetVer
,
1571 std::string
const &TargetRel
,
1572 std::list
<std::pair
<pkgCache::VerIterator
, pkgCache::VerIterator
> > &Changed
)
1574 ActionGroup
group(*this);
1575 SetCandidateVersion(TargetVer
);
1577 if (TargetRel
== "installed" || TargetRel
== "candidate") // both doesn't make sense in this context
1580 pkgVersionMatch
Match(TargetRel
, pkgVersionMatch::Release
);
1581 // save the position of the last element we will not undo - if we have to
1582 std::list
<std::pair
<pkgCache::VerIterator
, pkgCache::VerIterator
> >::iterator newChanged
= --(Changed
.end());
1584 for (pkgCache::DepIterator D
= TargetVer
.DependsList(); D
.end() == false; ++D
)
1586 if (D
->Type
!= pkgCache::Dep::PreDepends
&& D
->Type
!= pkgCache::Dep::Depends
&&
1587 ((D
->Type
!= pkgCache::Dep::Recommends
&& D
->Type
!= pkgCache::Dep::Suggests
) ||
1588 IsImportantDep(D
) == false))
1591 // walk over an or-group and check if we need to do anything
1592 // for simpilicity no or-group is handled as a or-group including one dependency
1593 pkgCache::DepIterator Start
= D
;
1594 bool itsFine
= false;
1595 for (bool stillOr
= true; stillOr
== true; ++Start
)
1597 stillOr
= (Start
->CompareOp
& Dep::Or
) == Dep::Or
;
1598 pkgCache::PkgIterator
const P
= Start
.TargetPkg();
1599 // virtual packages can't be a solution
1600 if (P
.end() == true || (P
->ProvidesList
== 0 && P
->VersionList
== 0))
1602 pkgCache::VerIterator
const Cand
= PkgState
[P
->ID
].CandidateVerIter(*this);
1603 // no versioned dependency - but is it installable?
1604 if (Start
.TargetVer() == 0 || Start
.TargetVer()[0] == '\0')
1606 // Check if one of the providers is installable
1607 if (P
->ProvidesList
!= 0)
1609 pkgCache::PrvIterator Prv
= P
.ProvidesList();
1610 for (; Prv
.end() == false; ++Prv
)
1612 pkgCache::VerIterator
const C
= PkgState
[Prv
.OwnerPkg()->ID
].CandidateVerIter(*this);
1613 if (C
.end() == true || C
!= Prv
.OwnerVer() ||
1614 (VersionState(C
.DependsList(), DepInstall
, DepCandMin
, DepCandPolicy
) & DepCandMin
) != DepCandMin
)
1618 if (Prv
.end() == true)
1621 // no providers, so check if we have an installable candidate version
1622 else if (Cand
.end() == true ||
1623 (VersionState(Cand
.DependsList(), DepInstall
, DepCandMin
, DepCandPolicy
) & DepCandMin
) != DepCandMin
)
1628 if (Cand
.end() == true)
1630 // check if the current candidate is enough for the versioned dependency - and installable?
1631 if (VS().CheckDep(P
.CandVersion(), Start
->CompareOp
, Start
.TargetVer()) == true &&
1632 (VersionState(Cand
.DependsList(), DepInstall
, DepCandMin
, DepCandPolicy
) & DepCandMin
) == DepCandMin
)
1639 if (itsFine
== true) {
1640 // something in the or-group was fine, skip all other members
1641 for (; (D
->CompareOp
& Dep::Or
) == Dep::Or
; ++D
);
1645 // walk again over the or-group and check each if a candidate switch would help
1647 for (bool stillOr
= true; stillOr
== true; ++D
)
1649 stillOr
= (D
->CompareOp
& Dep::Or
) == Dep::Or
;
1650 // changing candidate will not help if the dependency is not versioned
1651 if (D
.TargetVer() == 0 || D
.TargetVer()[0] == '\0')
1653 if (stillOr
== true)
1658 pkgCache::VerIterator V
;
1659 if (TargetRel
== "newest")
1660 V
= D
.TargetPkg().VersionList();
1662 V
= Match
.Find(D
.TargetPkg());
1664 // check if the version from this release could satisfy the dependency
1665 if (V
.end() == true || VS().CheckDep(V
.VerStr(), D
->CompareOp
, D
.TargetVer()) == false)
1667 if (stillOr
== true)
1672 pkgCache::VerIterator oldCand
= PkgState
[D
.TargetPkg()->ID
].CandidateVerIter(*this);
1675 // Do we already touched this Version? If so, their versioned dependencies are okay, no need to check again
1676 for (std::list
<std::pair
<pkgCache::VerIterator
, pkgCache::VerIterator
> >::const_iterator c
= Changed
.begin();
1677 c
!= Changed
.end(); ++c
)
1679 if (c
->first
->ParentPkg
!= V
->ParentPkg
)
1686 if (itsFine
== false)
1688 // change the candidate
1689 Changed
.push_back(make_pair(oldCand
, TargetVer
));
1690 if (SetCandidateRelease(V
, TargetRel
, Changed
) == false)
1692 if (stillOr
== false)
1694 // undo the candidate changing
1695 SetCandidateVersion(oldCand
);
1702 // something in the or-group was fine, skip all other members
1703 for (; (D
->CompareOp
& Dep::Or
) == Dep::Or
; ++D
);
1707 if (itsFine
== false && (D
->Type
== pkgCache::Dep::PreDepends
|| D
->Type
== pkgCache::Dep::Depends
))
1709 // undo all changes which aren't lead to a solution
1710 for (std::list
<std::pair
<pkgCache::VerIterator
, pkgCache::VerIterator
> >::const_iterator c
= ++newChanged
;
1711 c
!= Changed
.end(); ++c
)
1712 SetCandidateVersion(c
->first
);
1713 Changed
.erase(newChanged
, Changed
.end());
1720 // DepCache::MarkAuto - set the Auto flag for a package /*{{{*/
1721 // ---------------------------------------------------------------------
1723 void pkgDepCache::MarkAuto(const PkgIterator
&Pkg
, bool Auto
)
1725 StateCache
&state
= PkgState
[Pkg
->ID
];
1727 ActionGroup
group(*this);
1730 state
.Flags
|= Flag::Auto
;
1732 state
.Flags
&= ~Flag::Auto
;
1735 // StateCache::Update - Compute the various static display things /*{{{*/
1736 // ---------------------------------------------------------------------
1737 /* This is called whenever the Candidate version changes. */
1738 void pkgDepCache::StateCache::Update(PkgIterator Pkg
,pkgCache
&Cache
)
1741 VerIterator Ver
= CandidateVerIter(Cache
);
1743 // Use a null string or the version string
1744 if (Ver
.end() == true)
1747 CandVersion
= Ver
.VerStr();
1749 // Find the current version
1751 if (Pkg
->CurrentVer
!= 0)
1752 CurVersion
= Pkg
.CurrentVer().VerStr();
1754 // Strip off the epochs for display
1755 CurVersion
= StripEpoch(CurVersion
);
1756 CandVersion
= StripEpoch(CandVersion
);
1758 // Figure out if its up or down or equal
1759 Status
= Ver
.CompareVer(Pkg
.CurrentVer());
1760 if (Pkg
->CurrentVer
== 0 || Pkg
->VersionList
== 0 || CandidateVer
== 0)
1764 // StateCache::StripEpoch - Remove the epoch specifier from the version /*{{{*/
1765 // ---------------------------------------------------------------------
1767 const char *pkgDepCache::StateCache::StripEpoch(const char *Ver
)
1773 for (const char *I
= Ver
; *I
!= 0; I
++)
1779 // Policy::GetCandidateVer - Returns the Candidate install version /*{{{*/
1780 // ---------------------------------------------------------------------
1781 /* The default just returns the highest available version that is not
1782 a source and automatic. */
1783 pkgCache::VerIterator
pkgDepCache::Policy::GetCandidateVer(PkgIterator
const &Pkg
)
1785 /* Not source/not automatic versions cannot be a candidate version
1786 unless they are already installed */
1787 VerIterator
Last(*(pkgCache
*)this,0);
1789 for (VerIterator I
= Pkg
.VersionList(); I
.end() == false; I
++)
1791 if (Pkg
.CurrentVer() == I
)
1794 for (VerFileIterator J
= I
.FileList(); J
.end() == false; J
++)
1796 if ((J
.File()->Flags
& Flag::NotSource
) != 0)
1799 /* Stash the highest version of a not-automatic source, we use it
1800 if there is nothing better */
1801 if ((J
.File()->Flags
& Flag::NotAutomatic
) != 0 ||
1802 (J
.File()->Flags
& Flag::ButAutomaticUpgrades
) != 0)
1804 if (Last
.end() == true)
1816 // Policy::IsImportantDep - True if the dependency is important /*{{{*/
1817 // ---------------------------------------------------------------------
1819 bool pkgDepCache::Policy::IsImportantDep(DepIterator
const &Dep
)
1821 if(Dep
.IsCritical())
1823 else if(Dep
->Type
== pkgCache::Dep::Recommends
)
1825 if ( _config
->FindB("APT::Install-Recommends", false))
1827 // we suport a special mode to only install-recommends for certain
1829 // FIXME: this is a meant as a temporarly solution until the
1830 // recommends are cleaned up
1831 const char *sec
= Dep
.ParentVer().Section();
1832 if (sec
&& ConfigValueInSubTree("APT::Install-Recommends-Sections", sec
))
1835 else if(Dep
->Type
== pkgCache::Dep::Suggests
)
1836 return _config
->FindB("APT::Install-Suggests", false);
1841 pkgDepCache::InRootSetFunc
*pkgDepCache::GetRootSetFunc() /*{{{*/
1843 DefaultRootSetFunc
*f
= new DefaultRootSetFunc
;
1844 if(f
->wasConstructedSuccessfully())
1853 bool pkgDepCache::MarkFollowsRecommends()
1855 return _config
->FindB("APT::AutoRemove::RecommendsImportant", true);
1858 bool pkgDepCache::MarkFollowsSuggests()
1860 return _config
->FindB("APT::AutoRemove::SuggestsImportant", false);
1863 // pkgDepCache::MarkRequired - the main mark algorithm /*{{{*/
1864 bool pkgDepCache::MarkRequired(InRootSetFunc
&userFunc
)
1866 bool follow_recommends
;
1867 bool follow_suggests
;
1868 bool debug_autoremove
= _config
->FindB("Debug::pkgAutoRemove",false);
1871 for(PkgIterator p
= PkgBegin(); !p
.end(); ++p
)
1873 PkgState
[p
->ID
].Marked
= false;
1874 PkgState
[p
->ID
].Garbage
= false;
1877 if(debug_autoremove
&& PkgState
[p
->ID
].Flags
& Flag::Auto
)
1878 std::clog
<< "AutoDep: " << p
.FullName() << std::endl
;
1882 follow_recommends
= MarkFollowsRecommends();
1883 follow_suggests
= MarkFollowsSuggests();
1887 // do the mark part, this is the core bit of the algorithm
1888 for(PkgIterator p
= PkgBegin(); !p
.end(); ++p
)
1890 if(!(PkgState
[p
->ID
].Flags
& Flag::Auto
) ||
1891 (p
->Flags
& Flag::Essential
) ||
1892 userFunc
.InRootSet(p
) ||
1893 // be nice even then a required package violates the policy (#583517)
1894 // and do the full mark process also for required packages
1895 (p
.CurrentVer().end() != true &&
1896 p
.CurrentVer()->Priority
== pkgCache::State::Required
))
1898 // the package is installed (and set to keep)
1899 if(PkgState
[p
->ID
].Keep() && !p
.CurrentVer().end())
1900 MarkPackage(p
, p
.CurrentVer(),
1901 follow_recommends
, follow_suggests
);
1902 // the package is to be installed
1903 else if(PkgState
[p
->ID
].Install())
1904 MarkPackage(p
, PkgState
[p
->ID
].InstVerIter(*this),
1905 follow_recommends
, follow_suggests
);
1912 // MarkPackage - mark a single package in Mark-and-Sweep /*{{{*/
1913 void pkgDepCache::MarkPackage(const pkgCache::PkgIterator
&pkg
,
1914 const pkgCache::VerIterator
&ver
,
1915 bool const &follow_recommends
,
1916 bool const &follow_suggests
)
1918 pkgDepCache::StateCache
&state
= PkgState
[pkg
->ID
];
1920 // if we are marked already we are done
1924 VerIterator
const currver
= pkg
.CurrentVer();
1925 VerIterator
const instver
= state
.InstVerIter(*this);
1928 VerIterator
const candver
= state
.CandidateVerIter(*this);
1930 // If a package was garbage-collected but is now being marked, we
1931 // should re-select it
1932 // For cases when a pkg is set to upgrade and this trigger the
1933 // removal of a no-longer used dependency. if the pkg is set to
1934 // keep again later it will result in broken deps
1935 if(state
.Delete() && state
.RemoveReason
= Unused
)
1938 mark_install(pkg
, false, false, NULL
);
1939 else if(ver
==pkg
.CurrentVer())
1940 MarkKeep(pkg
, false, false);
1942 instver
=state
.InstVerIter(*this);
1946 // For packages that are not going to be removed, ignore versions
1947 // other than the InstVer. For packages that are going to be
1948 // removed, ignore versions other than the current version.
1949 if(!(ver
== instver
&& !instver
.end()) &&
1950 !(ver
== currver
&& instver
.end() && !ver
.end()))
1953 bool const debug_autoremove
= _config
->FindB("Debug::pkgAutoRemove", false);
1955 if(debug_autoremove
)
1957 std::clog
<< "Marking: " << pkg
.FullName();
1959 std::clog
<< " " << ver
.VerStr();
1961 std::clog
<< ", Curr=" << currver
.VerStr();
1963 std::clog
<< ", Inst=" << instver
.VerStr();
1964 std::clog
<< std::endl
;
1969 if(ver
.end() == true)
1972 // If the version belongs to a Multi-Arch all package
1973 // we will mark all others in this Group with this version also
1974 if (ver
->MultiArch
== pkgCache::Version::All
&&
1975 strcmp(ver
.Arch(true), "all") == 0)
1977 GrpIterator G
= pkg
.Group();
1978 const char* const VerStr
= ver
.VerStr();
1979 for (PkgIterator P
= G
.FindPkg("any");
1980 P
.end() != true; P
= G
.NextPkg(P
))
1982 for (VerIterator V
= P
.VersionList();
1983 V
.end() != true; ++V
)
1985 if (ver
->Hash
!= V
->Hash
||
1986 strcmp(VerStr
, V
.VerStr()) != 0)
1988 MarkPackage(P
, V
, follow_recommends
, follow_suggests
);
1994 for(DepIterator d
= ver
.DependsList(); !d
.end(); ++d
)
1996 if(d
->Type
== Dep::Depends
||
1997 d
->Type
== Dep::PreDepends
||
1998 (follow_recommends
&&
1999 d
->Type
== Dep::Recommends
) ||
2001 d
->Type
== Dep::Suggests
))
2003 // Try all versions of this package.
2004 for(VerIterator V
= d
.TargetPkg().VersionList();
2007 if(_system
->VS
->CheckDep(V
.VerStr(), d
->CompareOp
, d
.TargetVer()))
2009 if(debug_autoremove
)
2011 std::clog
<< "Following dep: " << d
.ParentPkg().FullName()
2012 << " " << d
.ParentVer().VerStr() << " "
2013 << d
.DepType() << " " << d
.TargetPkg().FullName();
2014 if((d
->CompareOp
& ~pkgCache::Dep::Or
) != pkgCache::Dep::NoOp
)
2016 std::clog
<< " (" << d
.CompType() << " "
2017 << d
.TargetVer() << ")";
2019 std::clog
<< std::endl
;
2021 MarkPackage(V
.ParentPkg(), V
,
2022 follow_recommends
, follow_suggests
);
2025 // Now try virtual packages
2026 for(PrvIterator prv
=d
.TargetPkg().ProvidesList();
2029 if(_system
->VS
->CheckDep(prv
.ProvideVersion(), d
->CompareOp
,
2032 if(debug_autoremove
)
2034 std::clog
<< "Following dep: " << d
.ParentPkg().FullName() << " "
2035 << d
.ParentVer().VerStr() << " "
2036 << d
.DepType() << " " << d
.TargetPkg().FullName() << " ";
2037 if((d
->CompareOp
& ~pkgCache::Dep::Or
) != pkgCache::Dep::NoOp
)
2039 std::clog
<< " (" << d
.CompType() << " "
2040 << d
.TargetVer() << ")";
2042 std::clog
<< ", provided by "
2043 << prv
.OwnerPkg().FullName() << " "
2044 << prv
.OwnerVer().VerStr()
2048 MarkPackage(prv
.OwnerPkg(), prv
.OwnerVer(),
2049 follow_recommends
, follow_suggests
);
2056 bool pkgDepCache::Sweep() /*{{{*/
2058 bool debug_autoremove
= _config
->FindB("Debug::pkgAutoRemove",false);
2061 for(PkgIterator p
=PkgBegin(); !p
.end(); ++p
)
2063 StateCache
&state
=PkgState
[p
->ID
];
2065 // skip required packages
2066 if (!p
.CurrentVer().end() &&
2067 (p
.CurrentVer()->Priority
== pkgCache::State::Required
))
2070 // if it is not marked and it is installed, it's garbage
2071 if(!state
.Marked
&& (!p
.CurrentVer().end() || state
.Install()))
2074 if(debug_autoremove
)
2075 std::clog
<< "Garbage: " << p
.FullName() << std::endl
;