]> git.saurik.com Git - apt.git/blame_incremental - apt-pkg/depcache.cc
do IsInstallOk call in MarkInstall unconditionally
[apt.git] / apt-pkg / depcache.cc
... / ...
CommitLineData
1// -*- mode: cpp; mode: fold -*-
2// Description /*{{{*/
3// $Id: depcache.cc,v 1.25 2001/05/27 05:36:04 jgg Exp $
4/* ######################################################################
5
6 Dependency Cache - Caches Dependency information.
7
8 ##################################################################### */
9 /*}}}*/
10// Include Files /*{{{*/
11#include<config.h>
12
13#include <apt-pkg/depcache.h>
14#include <apt-pkg/versionmatch.h>
15#include <apt-pkg/error.h>
16#include <apt-pkg/sptr.h>
17#include <apt-pkg/fileutl.h>
18#include <apt-pkg/strutl.h>
19#include <apt-pkg/configuration.h>
20#include <apt-pkg/aptconfiguration.h>
21#include <apt-pkg/tagfile.h>
22#include <apt-pkg/progress.h>
23#include <apt-pkg/cacheset.h>
24#include <apt-pkg/pkgcache.h>
25#include <apt-pkg/cacheiterators.h>
26#include <apt-pkg/macros.h>
27
28#include <stdio.h>
29#include <string.h>
30#include <list>
31#include <string>
32#include <utility>
33#include <vector>
34#include <algorithm>
35#include <iostream>
36#include <sstream>
37#include <set>
38
39#include <sys/stat.h>
40
41#include <apti18n.h>
42 /*}}}*/
43
44using std::string;
45
46// helper for Install-Recommends-Sections and Never-MarkAuto-Sections /*{{{*/
47static bool
48ConfigValueInSubTree(const char* SubTree, const char *needle)
49{
50 Configuration::Item const *Opts;
51 Opts = _config->Tree(SubTree);
52 if (Opts != 0 && Opts->Child != 0)
53 {
54 Opts = Opts->Child;
55 for (; Opts != 0; Opts = Opts->Next)
56 {
57 if (Opts->Value.empty() == true)
58 continue;
59 if (strcmp(needle, Opts->Value.c_str()) == 0)
60 return true;
61 }
62 }
63 return false;
64}
65 /*}}}*/
66pkgDepCache::ActionGroup::ActionGroup(pkgDepCache &cache) : /*{{{*/
67 cache(cache), released(false)
68{
69 ++cache.group_level;
70}
71
72void pkgDepCache::ActionGroup::release()
73{
74 if(!released)
75 {
76 if(cache.group_level == 0)
77 std::cerr << "W: Unbalanced action groups, expect badness" << std::endl;
78 else
79 {
80 --cache.group_level;
81
82 if(cache.group_level == 0)
83 cache.MarkAndSweep();
84 }
85
86 released = true;
87 }
88}
89
90pkgDepCache::ActionGroup::~ActionGroup()
91{
92 release();
93}
94 /*}}}*/
95// DepCache::pkgDepCache - Constructors /*{{{*/
96// ---------------------------------------------------------------------
97/* */
98pkgDepCache::pkgDepCache(pkgCache *pCache,Policy *Plcy) :
99 group_level(0), Cache(pCache), PkgState(0), DepState(0)
100{
101 DebugMarker = _config->FindB("Debug::pkgDepCache::Marker", false);
102 DebugAutoInstall = _config->FindB("Debug::pkgDepCache::AutoInstall", false);
103 delLocalPolicy = 0;
104 LocalPolicy = Plcy;
105 if (LocalPolicy == 0)
106 delLocalPolicy = LocalPolicy = new Policy;
107}
108 /*}}}*/
109// DepCache::~pkgDepCache - Destructor /*{{{*/
110// ---------------------------------------------------------------------
111/* */
112pkgDepCache::~pkgDepCache()
113{
114 delete [] PkgState;
115 delete [] DepState;
116 delete delLocalPolicy;
117}
118 /*}}}*/
119// DepCache::Init - Generate the initial extra structures. /*{{{*/
120// ---------------------------------------------------------------------
121/* This allocats the extension buffers and initializes them. */
122bool pkgDepCache::Init(OpProgress *Prog)
123{
124 // Suppress mark updates during this operation (just in case) and
125 // run a mark operation when Init terminates.
126 ActionGroup actions(*this);
127
128 delete [] PkgState;
129 delete [] DepState;
130 PkgState = new StateCache[Head().PackageCount];
131 DepState = new unsigned char[Head().DependsCount];
132 memset(PkgState,0,sizeof(*PkgState)*Head().PackageCount);
133 memset(DepState,0,sizeof(*DepState)*Head().DependsCount);
134
135 if (Prog != 0)
136 {
137 Prog->OverallProgress(0,2*Head().PackageCount,Head().PackageCount,
138 _("Building dependency tree"));
139 Prog->SubProgress(Head().PackageCount,_("Candidate versions"));
140 }
141
142 /* Set the current state of everything. In this state all of the
143 packages are kept exactly as is. See AllUpgrade */
144 int Done = 0;
145 for (PkgIterator I = PkgBegin(); I.end() != true; ++I, ++Done)
146 {
147 if (Prog != 0 && Done%20 == 0)
148 Prog->Progress(Done);
149
150 // Find the proper cache slot
151 StateCache &State = PkgState[I->ID];
152 State.iFlags = 0;
153
154 // Figure out the install version
155 State.CandidateVer = GetCandidateVer(I);
156 State.InstallVer = I.CurrentVer();
157 State.Mode = ModeKeep;
158
159 State.Update(I,*this);
160 }
161
162 if (Prog != 0)
163 {
164
165 Prog->OverallProgress(Head().PackageCount,2*Head().PackageCount,
166 Head().PackageCount,
167 _("Building dependency tree"));
168 Prog->SubProgress(Head().PackageCount,_("Dependency generation"));
169 }
170
171 Update(Prog);
172
173 if(Prog != 0)
174 Prog->Done();
175
176 return true;
177}
178 /*}}}*/
179bool pkgDepCache::readStateFile(OpProgress *Prog) /*{{{*/
180{
181 FileFd state_file;
182 string const state = _config->FindFile("Dir::State::extended_states");
183 if(RealFileExists(state)) {
184 state_file.Open(state, FileFd::ReadOnly);
185 off_t const file_size = state_file.Size();
186 if(Prog != NULL)
187 Prog->OverallProgress(0, file_size, 1,
188 _("Reading state information"));
189
190 pkgTagFile tagfile(&state_file);
191 pkgTagSection section;
192 off_t amt = 0;
193 bool const debug_autoremove = _config->FindB("Debug::pkgAutoRemove",false);
194 while(tagfile.Step(section)) {
195 string const pkgname = section.FindS("Package");
196 string pkgarch = section.FindS("Architecture");
197 if (pkgarch.empty() == true)
198 pkgarch = "any";
199 pkgCache::PkgIterator pkg = Cache->FindPkg(pkgname, pkgarch);
200 // Silently ignore unknown packages and packages with no actual version.
201 if(pkg.end() == true || pkg->VersionList == 0)
202 continue;
203
204 short const reason = section.FindI("Auto-Installed", 0);
205 if(reason > 0)
206 {
207 PkgState[pkg->ID].Flags |= Flag::Auto;
208 if (unlikely(debug_autoremove))
209 std::clog << "Auto-Installed : " << pkg.FullName() << std::endl;
210 if (pkgarch == "any")
211 {
212 pkgCache::GrpIterator G = pkg.Group();
213 for (pkg = G.NextPkg(pkg); pkg.end() != true; pkg = G.NextPkg(pkg))
214 if (pkg->VersionList != 0)
215 PkgState[pkg->ID].Flags |= Flag::Auto;
216 }
217 }
218 amt += section.size();
219 if(Prog != NULL)
220 Prog->OverallProgress(amt, file_size, 1,
221 _("Reading state information"));
222 }
223 if(Prog != NULL)
224 Prog->OverallProgress(file_size, file_size, 1,
225 _("Reading state information"));
226 }
227
228 return true;
229}
230 /*}}}*/
231bool pkgDepCache::writeStateFile(OpProgress * /*prog*/, bool InstalledOnly) /*{{{*/
232{
233 bool const debug_autoremove = _config->FindB("Debug::pkgAutoRemove",false);
234
235 if(debug_autoremove)
236 std::clog << "pkgDepCache::writeStateFile()" << std::endl;
237
238 FileFd StateFile;
239 string const state = _config->FindFile("Dir::State::extended_states");
240
241 // if it does not exist, create a empty one
242 if(!RealFileExists(state))
243 {
244 StateFile.Open(state, FileFd::WriteAtomic);
245 StateFile.Close();
246 }
247
248 // open it
249 if(!StateFile.Open(state, FileFd::ReadOnly))
250 return _error->Error(_("Failed to open StateFile %s"),
251 state.c_str());
252
253 FILE *OutFile;
254 string const outfile = state + ".tmp";
255 if((OutFile = fopen(outfile.c_str(),"w")) == NULL)
256 return _error->Error(_("Failed to write temporary StateFile %s"),
257 outfile.c_str());
258
259 // first merge with the existing sections
260 pkgTagFile tagfile(&StateFile);
261 pkgTagSection section;
262 std::set<string> pkgs_seen;
263 const char *nullreorderlist[] = {0};
264 while(tagfile.Step(section)) {
265 string const pkgname = section.FindS("Package");
266 string pkgarch = section.FindS("Architecture");
267 if (pkgarch.empty() == true)
268 pkgarch = "native";
269 // Silently ignore unknown packages and packages with no actual
270 // version.
271 pkgCache::PkgIterator pkg = Cache->FindPkg(pkgname, pkgarch);
272 if(pkg.end() || pkg.VersionList().end())
273 continue;
274 StateCache const &P = PkgState[pkg->ID];
275 bool newAuto = (P.Flags & Flag::Auto);
276 // skip not installed or now-removed ones if requested
277 if (InstalledOnly && (
278 (pkg->CurrentVer == 0 && P.Mode != ModeInstall) ||
279 (pkg->CurrentVer != 0 && P.Mode == ModeDelete)))
280 {
281 // The section is obsolete if it contains no other tag
282 unsigned int const count = section.Count();
283 if (count < 2 ||
284 (count == 2 && section.Exists("Auto-Installed")) ||
285 (count == 3 && section.Exists("Auto-Installed") && section.Exists("Architecture")))
286 continue;
287 else
288 newAuto = false;
289 }
290 if(_config->FindB("Debug::pkgAutoRemove",false))
291 std::clog << "Update existing AutoInstall info: "
292 << pkg.FullName() << std::endl;
293 TFRewriteData rewrite[3];
294 rewrite[0].Tag = "Architecture";
295 rewrite[0].Rewrite = pkg.Arch();
296 rewrite[0].NewTag = 0;
297 rewrite[1].Tag = "Auto-Installed";
298 rewrite[1].Rewrite = newAuto ? "1" : "0";
299 rewrite[1].NewTag = 0;
300 rewrite[2].Tag = 0;
301 TFRewrite(OutFile, section, nullreorderlist, rewrite);
302 fprintf(OutFile,"\n");
303 pkgs_seen.insert(pkg.FullName());
304 }
305
306 // then write the ones we have not seen yet
307 std::ostringstream ostr;
308 for(pkgCache::PkgIterator pkg=Cache->PkgBegin(); !pkg.end(); ++pkg) {
309 StateCache const &P = PkgState[pkg->ID];
310 if(P.Flags & Flag::Auto) {
311 if (pkgs_seen.find(pkg.FullName()) != pkgs_seen.end()) {
312 if(debug_autoremove)
313 std::clog << "Skipping already written " << pkg.FullName() << std::endl;
314 continue;
315 }
316 // skip not installed ones if requested
317 if (InstalledOnly && (
318 (pkg->CurrentVer == 0 && P.Mode != ModeInstall) ||
319 (pkg->CurrentVer != 0 && P.Mode == ModeDelete)))
320 continue;
321 const char* const pkgarch = pkg.Arch();
322 if (strcmp(pkgarch, "all") == 0)
323 continue;
324 if(debug_autoremove)
325 std::clog << "Writing new AutoInstall: " << pkg.FullName() << std::endl;
326 ostr.str(string(""));
327 ostr << "Package: " << pkg.Name()
328 << "\nArchitecture: " << pkgarch
329 << "\nAuto-Installed: 1\n\n";
330 fprintf(OutFile,"%s",ostr.str().c_str());
331 }
332 }
333 fclose(OutFile);
334
335 // move the outfile over the real file and set permissions
336 rename(outfile.c_str(), state.c_str());
337 chmod(state.c_str(), 0644);
338
339 return true;
340}
341 /*}}}*/
342// DepCache::CheckDep - Checks a single dependency /*{{{*/
343// ---------------------------------------------------------------------
344/* This first checks the dependency against the main target package and
345 then walks along the package provides list and checks if each provides
346 will be installed then checks the provides against the dep. Res will be
347 set to the package which was used to satisfy the dep. */
348bool pkgDepCache::CheckDep(DepIterator Dep,int Type,PkgIterator &Res)
349{
350 Res = Dep.TargetPkg();
351
352 /* Check simple depends. A depends -should- never self match but
353 we allow it anyhow because dpkg does. Technically it is a packaging
354 bug. Conflicts may never self match */
355 if (Dep.IsIgnorable(Res) == false)
356 {
357 PkgIterator Pkg = Dep.TargetPkg();
358 // Check the base package
359 if (Type == NowVersion && Pkg->CurrentVer != 0)
360 if (Dep.IsSatisfied(Pkg.CurrentVer()) == true)
361 return true;
362
363 if (Type == InstallVersion && PkgState[Pkg->ID].InstallVer != 0)
364 if (Dep.IsSatisfied(PkgState[Pkg->ID].InstVerIter(*this)) == true)
365 return true;
366
367 if (Type == CandidateVersion && PkgState[Pkg->ID].CandidateVer != 0)
368 if (Dep.IsSatisfied(PkgState[Pkg->ID].CandidateVerIter(*this)) == true)
369 return true;
370 }
371
372 if (Dep->Type == Dep::Obsoletes)
373 return false;
374
375 // Check the providing packages
376 PrvIterator P = Dep.TargetPkg().ProvidesList();
377 for (; P.end() != true; ++P)
378 {
379 if (Dep.IsIgnorable(P) == true)
380 continue;
381
382 // Check if the provides is a hit
383 if (Type == NowVersion)
384 {
385 if (P.OwnerPkg().CurrentVer() != P.OwnerVer())
386 continue;
387 }
388
389 if (Type == InstallVersion)
390 {
391 StateCache &State = PkgState[P.OwnerPkg()->ID];
392 if (State.InstallVer != (Version *)P.OwnerVer())
393 continue;
394 }
395
396 if (Type == CandidateVersion)
397 {
398 StateCache &State = PkgState[P.OwnerPkg()->ID];
399 if (State.CandidateVer != (Version *)P.OwnerVer())
400 continue;
401 }
402
403 // Compare the versions.
404 if (Dep.IsSatisfied(P) == true)
405 {
406 Res = P.OwnerPkg();
407 return true;
408 }
409 }
410
411 return false;
412}
413 /*}}}*/
414// DepCache::AddSizes - Add the packages sizes to the counters /*{{{*/
415// ---------------------------------------------------------------------
416/* Call with Inverse = true to preform the inverse opration */
417void pkgDepCache::AddSizes(const PkgIterator &Pkg, bool const Inverse)
418{
419 StateCache &P = PkgState[Pkg->ID];
420
421 if (Pkg->VersionList == 0)
422 return;
423
424 if (Pkg.State() == pkgCache::PkgIterator::NeedsConfigure &&
425 P.Keep() == true)
426 return;
427
428 // Compute the size data
429 if (P.NewInstall() == true)
430 {
431 if (Inverse == false) {
432 iUsrSize += P.InstVerIter(*this)->InstalledSize;
433 iDownloadSize += P.InstVerIter(*this)->Size;
434 } else {
435 iUsrSize -= P.InstVerIter(*this)->InstalledSize;
436 iDownloadSize -= P.InstVerIter(*this)->Size;
437 }
438 return;
439 }
440
441 // Upgrading
442 if (Pkg->CurrentVer != 0 &&
443 (P.InstallVer != (Version *)Pkg.CurrentVer() ||
444 (P.iFlags & ReInstall) == ReInstall) && P.InstallVer != 0)
445 {
446 if (Inverse == false) {
447 iUsrSize -= Pkg.CurrentVer()->InstalledSize;
448 iUsrSize += P.InstVerIter(*this)->InstalledSize;
449 iDownloadSize += P.InstVerIter(*this)->Size;
450 } else {
451 iUsrSize -= P.InstVerIter(*this)->InstalledSize;
452 iUsrSize += Pkg.CurrentVer()->InstalledSize;
453 iDownloadSize -= P.InstVerIter(*this)->Size;
454 }
455 return;
456 }
457
458 // Reinstall
459 if (Pkg.State() == pkgCache::PkgIterator::NeedsUnpack &&
460 P.Delete() == false)
461 {
462 if (Inverse == false)
463 iDownloadSize += P.InstVerIter(*this)->Size;
464 else
465 iDownloadSize -= P.InstVerIter(*this)->Size;
466 return;
467 }
468
469 // Removing
470 if (Pkg->CurrentVer != 0 && P.InstallVer == 0)
471 {
472 if (Inverse == false)
473 iUsrSize -= Pkg.CurrentVer()->InstalledSize;
474 else
475 iUsrSize += Pkg.CurrentVer()->InstalledSize;
476 return;
477 }
478}
479 /*}}}*/
480// DepCache::AddStates - Add the package to the state counter /*{{{*/
481// ---------------------------------------------------------------------
482/* This routine is tricky to use, you must make sure that it is never
483 called twice for the same package. This means the Remove/Add section
484 should be as short as possible and not encompass any code that will
485 calld Remove/Add itself. Remember, dependencies can be circular so
486 while processing a dep for Pkg it is possible that Add/Remove
487 will be called on Pkg */
488void pkgDepCache::AddStates(const PkgIterator &Pkg, bool const Invert)
489{
490 signed char const Add = (Invert == false) ? 1 : -1;
491 StateCache &State = PkgState[Pkg->ID];
492
493 // The Package is broken (either minimal dep or policy dep)
494 if ((State.DepState & DepInstMin) != DepInstMin)
495 iBrokenCount += Add;
496 if ((State.DepState & DepInstPolicy) != DepInstPolicy)
497 iPolicyBrokenCount += Add;
498
499 // Bad state
500 if (Pkg.State() != PkgIterator::NeedsNothing)
501 iBadCount += Add;
502
503 // Not installed
504 if (Pkg->CurrentVer == 0)
505 {
506 if (State.Mode == ModeDelete &&
507 (State.iFlags & Purge) == Purge && Pkg.Purge() == false)
508 iDelCount += Add;
509
510 if (State.Mode == ModeInstall)
511 iInstCount += Add;
512 return;
513 }
514
515 // Installed, no upgrade
516 if (State.Status == 0)
517 {
518 if (State.Mode == ModeDelete)
519 iDelCount += Add;
520 else
521 if ((State.iFlags & ReInstall) == ReInstall)
522 iInstCount += Add;
523
524 return;
525 }
526
527 // Alll 3 are possible
528 if (State.Mode == ModeDelete)
529 iDelCount += Add;
530 if (State.Mode == ModeKeep)
531 iKeepCount += Add;
532 if (State.Mode == ModeInstall)
533 iInstCount += Add;
534}
535 /*}}}*/
536// DepCache::BuildGroupOrs - Generate the Or group dep data /*{{{*/
537// ---------------------------------------------------------------------
538/* The or group results are stored in the last item of the or group. This
539 allows easy detection of the state of a whole or'd group. */
540void pkgDepCache::BuildGroupOrs(VerIterator const &V)
541{
542 unsigned char Group = 0;
543
544 for (DepIterator D = V.DependsList(); D.end() != true; ++D)
545 {
546 // Build the dependency state.
547 unsigned char &State = DepState[D->ID];
548
549 /* Invert for Conflicts. We have to do this twice to get the
550 right sense for a conflicts group */
551 if (D.IsNegative() == true)
552 State = ~State;
553
554 // Add to the group if we are within an or..
555 State &= 0x7;
556 Group |= State;
557 State |= Group << 3;
558 if ((D->CompareOp & Dep::Or) != Dep::Or)
559 Group = 0;
560
561 // Invert for Conflicts
562 if (D.IsNegative() == true)
563 State = ~State;
564 }
565}
566 /*}}}*/
567// DepCache::VersionState - Perform a pass over a dependency list /*{{{*/
568// ---------------------------------------------------------------------
569/* This is used to run over a dependency list and determine the dep
570 state of the list, filtering it through both a Min check and a Policy
571 check. The return result will have SetMin/SetPolicy low if a check
572 fails. It uses the DepState cache for it's computations. */
573unsigned char pkgDepCache::VersionState(DepIterator D,unsigned char Check,
574 unsigned char SetMin,
575 unsigned char SetPolicy)
576{
577 unsigned char Dep = 0xFF;
578
579 while (D.end() != true)
580 {
581 // Compute a single dependency element (glob or)
582 DepIterator Start = D;
583 unsigned char State = 0;
584 for (bool LastOR = true; D.end() == false && LastOR == true; ++D)
585 {
586 State |= DepState[D->ID];
587 LastOR = (D->CompareOp & Dep::Or) == Dep::Or;
588 }
589
590 // Minimum deps that must be satisfied to have a working package
591 if (Start.IsCritical() == true)
592 if ((State & Check) != Check)
593 Dep &= ~SetMin;
594
595 // Policy deps that must be satisfied to install the package
596 if (IsImportantDep(Start) == true &&
597 (State & Check) != Check)
598 Dep &= ~SetPolicy;
599 }
600
601 return Dep;
602}
603 /*}}}*/
604// DepCache::DependencyState - Compute the 3 results for a dep /*{{{*/
605// ---------------------------------------------------------------------
606/* This is the main dependency computation bit. It computes the 3 main
607 results for a dependencys, Now, Install and Candidate. Callers must
608 invert the result if dealing with conflicts. */
609unsigned char pkgDepCache::DependencyState(DepIterator &D)
610{
611 unsigned char State = 0;
612
613 if (CheckDep(D,NowVersion) == true)
614 State |= DepNow;
615 if (CheckDep(D,InstallVersion) == true)
616 State |= DepInstall;
617 if (CheckDep(D,CandidateVersion) == true)
618 State |= DepCVer;
619
620 return State;
621}
622 /*}}}*/
623// DepCache::UpdateVerState - Compute the Dep member of the state /*{{{*/
624// ---------------------------------------------------------------------
625/* This determines the combined dependency representation of a package
626 for its two states now and install. This is done by using the pre-generated
627 dependency information. */
628void pkgDepCache::UpdateVerState(PkgIterator Pkg)
629{
630 // Empty deps are always true
631 StateCache &State = PkgState[Pkg->ID];
632 State.DepState = 0xFF;
633
634 // Check the Current state
635 if (Pkg->CurrentVer != 0)
636 {
637 DepIterator D = Pkg.CurrentVer().DependsList();
638 State.DepState &= VersionState(D,DepNow,DepNowMin,DepNowPolicy);
639 }
640
641 /* Check the candidate state. We do not compare against the whole as
642 a candidate state but check the candidate version against the
643 install states */
644 if (State.CandidateVer != 0)
645 {
646 DepIterator D = State.CandidateVerIter(*this).DependsList();
647 State.DepState &= VersionState(D,DepInstall,DepCandMin,DepCandPolicy);
648 }
649
650 // Check target state which can only be current or installed
651 if (State.InstallVer != 0)
652 {
653 DepIterator D = State.InstVerIter(*this).DependsList();
654 State.DepState &= VersionState(D,DepInstall,DepInstMin,DepInstPolicy);
655 }
656}
657 /*}}}*/
658// DepCache::Update - Figure out all the state information /*{{{*/
659// ---------------------------------------------------------------------
660/* This will figure out the state of all the packages and all the
661 dependencies based on the current policy. */
662void pkgDepCache::Update(OpProgress *Prog)
663{
664 iUsrSize = 0;
665 iDownloadSize = 0;
666 iDelCount = 0;
667 iInstCount = 0;
668 iKeepCount = 0;
669 iBrokenCount = 0;
670 iBadCount = 0;
671
672 // Perform the depends pass
673 int Done = 0;
674 for (PkgIterator I = PkgBegin(); I.end() != true; ++I, ++Done)
675 {
676 if (Prog != 0 && Done%20 == 0)
677 Prog->Progress(Done);
678 for (VerIterator V = I.VersionList(); V.end() != true; ++V)
679 {
680 unsigned char Group = 0;
681
682 for (DepIterator D = V.DependsList(); D.end() != true; ++D)
683 {
684 // Build the dependency state.
685 unsigned char &State = DepState[D->ID];
686 State = DependencyState(D);
687
688 // Add to the group if we are within an or..
689 Group |= State;
690 State |= Group << 3;
691 if ((D->CompareOp & Dep::Or) != Dep::Or)
692 Group = 0;
693
694 // Invert for Conflicts
695 if (D.IsNegative() == true)
696 State = ~State;
697 }
698 }
699
700 // Compute the package dependency state and size additions
701 AddSizes(I);
702 UpdateVerState(I);
703 AddStates(I);
704 }
705
706 if (Prog != 0)
707 Prog->Progress(Done);
708
709 readStateFile(Prog);
710}
711 /*}}}*/
712// DepCache::Update - Update the deps list of a package /*{{{*/
713// ---------------------------------------------------------------------
714/* This is a helper for update that only does the dep portion of the scan.
715 It is mainly meant to scan reverse dependencies. */
716void pkgDepCache::Update(DepIterator D)
717{
718 // Update the reverse deps
719 for (;D.end() != true; ++D)
720 {
721 unsigned char &State = DepState[D->ID];
722 State = DependencyState(D);
723
724 // Invert for Conflicts
725 if (D.IsNegative() == true)
726 State = ~State;
727
728 RemoveStates(D.ParentPkg());
729 BuildGroupOrs(D.ParentVer());
730 UpdateVerState(D.ParentPkg());
731 AddStates(D.ParentPkg());
732 }
733}
734 /*}}}*/
735// DepCache::Update - Update the related deps of a package /*{{{*/
736// ---------------------------------------------------------------------
737/* This is called whenever the state of a package changes. It updates
738 all cached dependencies related to this package. */
739void pkgDepCache::Update(PkgIterator const &Pkg)
740{
741 // Recompute the dep of the package
742 RemoveStates(Pkg);
743 UpdateVerState(Pkg);
744 AddStates(Pkg);
745
746 // Update the reverse deps
747 Update(Pkg.RevDependsList());
748
749 // Update the provides map for the current ver
750 if (Pkg->CurrentVer != 0)
751 for (PrvIterator P = Pkg.CurrentVer().ProvidesList();
752 P.end() != true; ++P)
753 Update(P.ParentPkg().RevDependsList());
754
755 // Update the provides map for the candidate ver
756 if (PkgState[Pkg->ID].CandidateVer != 0)
757 for (PrvIterator P = PkgState[Pkg->ID].CandidateVerIter(*this).ProvidesList();
758 P.end() != true; ++P)
759 Update(P.ParentPkg().RevDependsList());
760}
761 /*}}}*/
762// DepCache::MarkKeep - Put the package in the keep state /*{{{*/
763// ---------------------------------------------------------------------
764/* */
765bool pkgDepCache::MarkKeep(PkgIterator const &Pkg, bool Soft, bool FromUser,
766 unsigned long Depth)
767{
768 if (IsModeChangeOk(ModeKeep, Pkg, Depth, FromUser) == false)
769 return false;
770
771 /* Reject an attempt to keep a non-source broken installed package, those
772 must be upgraded */
773 if (Pkg.State() == PkgIterator::NeedsUnpack &&
774 Pkg.CurrentVer().Downloadable() == false)
775 return false;
776
777 /* We changed the soft state all the time so the UI is a bit nicer
778 to use */
779 StateCache &P = PkgState[Pkg->ID];
780
781 // Check that it is not already kept
782 if (P.Mode == ModeKeep)
783 return true;
784
785 if (Soft == true)
786 P.iFlags |= AutoKept;
787 else
788 P.iFlags &= ~AutoKept;
789
790 ActionGroup group(*this);
791
792#if 0 // reseting the autoflag here means we lose the
793 // auto-mark information if a user selects a package for removal
794 // but changes his mind then and sets it for keep again
795 // - this makes sense as default when all Garbage dependencies
796 // are automatically marked for removal (as aptitude does).
797 // setting a package for keep then makes it no longer autoinstalled
798 // for all other use-case this action is rather surprising
799 if(FromUser && !P.Marked)
800 P.Flags &= ~Flag::Auto;
801#endif
802
803 if (DebugMarker == true)
804 std::clog << OutputInDepth(Depth) << "MarkKeep " << Pkg << " FU=" << FromUser << std::endl;
805
806 RemoveSizes(Pkg);
807 RemoveStates(Pkg);
808
809 P.Mode = ModeKeep;
810 if (Pkg->CurrentVer == 0)
811 P.InstallVer = 0;
812 else
813 P.InstallVer = Pkg.CurrentVer();
814
815 AddStates(Pkg);
816 Update(Pkg);
817 AddSizes(Pkg);
818
819 return true;
820}
821 /*}}}*/
822// DepCache::MarkDelete - Put the package in the delete state /*{{{*/
823// ---------------------------------------------------------------------
824/* */
825bool pkgDepCache::MarkDelete(PkgIterator const &Pkg, bool rPurge,
826 unsigned long Depth, bool FromUser)
827{
828 if (IsModeChangeOk(ModeDelete, Pkg, Depth, FromUser) == false)
829 return false;
830
831 StateCache &P = PkgState[Pkg->ID];
832
833 // Check that it is not already marked for delete
834 if ((P.Mode == ModeDelete || P.InstallVer == 0) &&
835 (Pkg.Purge() == true || rPurge == false))
836 return true;
837
838 // check if we are allowed to remove the package
839 if (IsDeleteOk(Pkg,rPurge,Depth,FromUser) == false)
840 return false;
841
842 P.iFlags &= ~(AutoKept | Purge);
843 if (rPurge == true)
844 P.iFlags |= Purge;
845
846 ActionGroup group(*this);
847
848 if (DebugMarker == true)
849 std::clog << OutputInDepth(Depth) << (rPurge ? "MarkPurge " : "MarkDelete ") << Pkg << " FU=" << FromUser << std::endl;
850
851 RemoveSizes(Pkg);
852 RemoveStates(Pkg);
853
854 if (Pkg->CurrentVer == 0 && (Pkg.Purge() == true || rPurge == false))
855 P.Mode = ModeKeep;
856 else
857 P.Mode = ModeDelete;
858 P.InstallVer = 0;
859
860 AddStates(Pkg);
861 Update(Pkg);
862 AddSizes(Pkg);
863
864 return true;
865}
866 /*}}}*/
867// DepCache::IsDeleteOk - check if it is ok to remove this package /*{{{*/
868// ---------------------------------------------------------------------
869/* The default implementation tries to prevent deletion of install requests.
870 dpkg holds are enforced by the private IsModeChangeOk */
871bool pkgDepCache::IsDeleteOk(PkgIterator const &Pkg,bool rPurge,
872 unsigned long Depth, bool FromUser)
873{
874 return IsDeleteOkProtectInstallRequests(Pkg, rPurge, Depth, FromUser);
875}
876bool pkgDepCache::IsDeleteOkProtectInstallRequests(PkgIterator const &Pkg,
877 bool const /*rPurge*/, unsigned long const Depth, bool const FromUser)
878{
879 if (FromUser == false && Pkg->CurrentVer == 0)
880 {
881 StateCache &P = PkgState[Pkg->ID];
882 if (P.InstallVer != 0 && P.Status == 2 && (P.Flags & Flag::Auto) != Flag::Auto)
883 {
884 if (DebugMarker == true)
885 std::clog << OutputInDepth(Depth) << "Manual install request prevents MarkDelete of " << Pkg << std::endl;
886 return false;
887 }
888 }
889 return true;
890}
891 /*}}}*/
892// DepCache::IsModeChangeOk - check if it is ok to change the mode /*{{{*/
893// ---------------------------------------------------------------------
894/* this is used by all Mark methods on the very first line to check sanity
895 and prevents mode changes for packages on hold for example.
896 If you want to check Mode specific stuff you can use the virtual public
897 Is<Mode>Ok methods instead */
898static char const* PrintMode(char const mode)
899{
900 switch (mode)
901 {
902 case pkgDepCache::ModeInstall: return "Install";
903 case pkgDepCache::ModeKeep: return "Keep";
904 case pkgDepCache::ModeDelete: return "Delete";
905 case pkgDepCache::ModeGarbage: return "Garbage";
906 default: return "UNKNOWN";
907 }
908}
909bool pkgDepCache::IsModeChangeOk(ModeList const mode, PkgIterator const &Pkg,
910 unsigned long const Depth, bool const FromUser)
911{
912 // we are not trying to hard…
913 if (unlikely(Depth > 100))
914 return false;
915
916 // general sanity
917 if (unlikely(Pkg.end() == true || Pkg->VersionList == 0))
918 return false;
919
920 // the user is always right
921 if (FromUser == true)
922 return true;
923
924 StateCache &P = PkgState[Pkg->ID];
925 // not changing the mode is obviously also fine as we might want to call
926 // e.g. MarkInstall multiple times with different arguments for the same package
927 if (P.Mode == mode)
928 return true;
929
930 // if previous state was set by user only user can reset it
931 if ((P.iFlags & Protected) == Protected)
932 {
933 if (unlikely(DebugMarker == true))
934 std::clog << OutputInDepth(Depth) << "Ignore Mark" << PrintMode(mode)
935 << " of " << Pkg << " as its mode (" << PrintMode(P.Mode)
936 << ") is protected" << std::endl;
937 return false;
938 }
939 // enforce dpkg holds
940 else if (mode != ModeKeep && Pkg->SelectedState == pkgCache::State::Hold &&
941 _config->FindB("APT::Ignore-Hold",false) == false)
942 {
943 if (unlikely(DebugMarker == true))
944 std::clog << OutputInDepth(Depth) << "Hold prevents Mark" << PrintMode(mode)
945 << " of " << Pkg << std::endl;
946 return false;
947 }
948
949 return true;
950}
951 /*}}}*/
952// DepCache::MarkInstall - Put the package in the install state /*{{{*/
953// ---------------------------------------------------------------------
954/* */
955struct CompareProviders {
956 pkgCache::PkgIterator const Pkg;
957 CompareProviders(pkgCache::DepIterator const &Dep) : Pkg(Dep.TargetPkg()) {};
958 //bool operator() (APT::VersionList::iterator const &AV, APT::VersionList::iterator const &BV)
959 bool operator() (pkgCache::VerIterator const &AV, pkgCache::VerIterator const &BV)
960 {
961 pkgCache::PkgIterator const A = AV.ParentPkg();
962 pkgCache::PkgIterator const B = BV.ParentPkg();
963 // Prefer MA:same packages if other architectures for it are installed
964 if ((AV->MultiArch & pkgCache::Version::Same) == pkgCache::Version::Same ||
965 (BV->MultiArch & pkgCache::Version::Same) == pkgCache::Version::Same)
966 {
967 bool instA = false;
968 if ((AV->MultiArch & pkgCache::Version::Same) == pkgCache::Version::Same)
969 {
970 pkgCache::GrpIterator Grp = A.Group();
971 for (pkgCache::PkgIterator P = Grp.PackageList(); P.end() == false; P = Grp.NextPkg(P))
972 if (P->CurrentVer != 0)
973 {
974 instA = true;
975 break;
976 }
977 }
978 bool instB = false;
979 if ((BV->MultiArch & pkgCache::Version::Same) == pkgCache::Version::Same)
980 {
981 pkgCache::GrpIterator Grp = B.Group();
982 for (pkgCache::PkgIterator P = Grp.PackageList(); P.end() == false; P = Grp.NextPkg(P))
983 {
984 if (P->CurrentVer != 0)
985 {
986 instB = true;
987 break;
988 }
989 }
990 }
991 if (instA != instB)
992 return instA == false;
993 }
994 // Prefer packages in the same group as the target; e.g. foo:i386, foo:amd64
995 if (A->Group != B->Group)
996 {
997 if (A->Group == Pkg->Group && B->Group != Pkg->Group)
998 return false;
999 else if (B->Group == Pkg->Group && A->Group != Pkg->Group)
1000 return true;
1001 }
1002 // we like essentials
1003 if ((A->Flags & pkgCache::Flag::Essential) != (B->Flags & pkgCache::Flag::Essential))
1004 {
1005 if ((A->Flags & pkgCache::Flag::Essential) == pkgCache::Flag::Essential)
1006 return false;
1007 else if ((B->Flags & pkgCache::Flag::Essential) == pkgCache::Flag::Essential)
1008 return true;
1009 }
1010 if ((A->Flags & pkgCache::Flag::Important) != (B->Flags & pkgCache::Flag::Important))
1011 {
1012 if ((A->Flags & pkgCache::Flag::Important) == pkgCache::Flag::Important)
1013 return false;
1014 else if ((B->Flags & pkgCache::Flag::Important) == pkgCache::Flag::Important)
1015 return true;
1016 }
1017 // prefer native architecture
1018 if (strcmp(A.Arch(), B.Arch()) != 0)
1019 {
1020 if (strcmp(A.Arch(), A.Cache()->NativeArch()) == 0)
1021 return false;
1022 else if (strcmp(B.Arch(), B.Cache()->NativeArch()) == 0)
1023 return true;
1024 std::vector<std::string> archs = APT::Configuration::getArchitectures();
1025 for (std::vector<std::string>::const_iterator a = archs.begin(); a != archs.end(); ++a)
1026 if (*a == A.Arch())
1027 return false;
1028 else if (*a == B.Arch())
1029 return true;
1030 }
1031 // higher priority seems like a good idea
1032 if (AV->Priority != BV->Priority)
1033 return AV->Priority > BV->Priority;
1034 // unable to decide…
1035 return A->ID < B->ID;
1036 }
1037};
1038bool pkgDepCache::MarkInstall(PkgIterator const &Pkg,bool AutoInst,
1039 unsigned long Depth, bool FromUser,
1040 bool ForceImportantDeps)
1041{
1042 if (IsModeChangeOk(ModeInstall, Pkg, Depth, FromUser) == false)
1043 return false;
1044
1045 StateCache &P = PkgState[Pkg->ID];
1046
1047 // See if there is even any possible instalation candidate
1048 if (P.CandidateVer == 0)
1049 return false;
1050
1051 /* Check that it is not already marked for install and that it can be
1052 installed */
1053 if ((P.InstPolicyBroken() == false && P.InstBroken() == false) &&
1054 (P.Mode == ModeInstall ||
1055 P.CandidateVer == (Version *)Pkg.CurrentVer()))
1056 {
1057 if (P.CandidateVer == (Version *)Pkg.CurrentVer() && P.InstallVer == 0)
1058 return MarkKeep(Pkg, false, FromUser, Depth+1);
1059 return true;
1060 }
1061
1062 // check if we are allowed to install the package
1063 if (IsInstallOk(Pkg,AutoInst,Depth,FromUser) == false)
1064 return false;
1065
1066 ActionGroup group(*this);
1067 P.iFlags &= ~AutoKept;
1068
1069 /* Target the candidate version and remove the autoflag. We reset the
1070 autoflag below if this was called recursively. Otherwise the user
1071 should have the ability to de-auto a package by changing its state */
1072 RemoveSizes(Pkg);
1073 RemoveStates(Pkg);
1074
1075 P.Mode = ModeInstall;
1076 P.InstallVer = P.CandidateVer;
1077
1078 if(FromUser)
1079 {
1080 // Set it to manual if it's a new install or already installed,
1081 // but only if its not marked by the autoremover (aptitude depend on this behavior)
1082 // or if we do automatic installation (aptitude never does it)
1083 if(P.Status == 2 || (Pkg->CurrentVer != 0 && (AutoInst == true || P.Marked == false)))
1084 P.Flags &= ~Flag::Auto;
1085 }
1086 else
1087 {
1088 // Set it to auto if this is a new install.
1089 if(P.Status == 2)
1090 P.Flags |= Flag::Auto;
1091 }
1092 if (P.CandidateVer == (Version *)Pkg.CurrentVer())
1093 P.Mode = ModeKeep;
1094
1095 AddStates(Pkg);
1096 Update(Pkg);
1097 AddSizes(Pkg);
1098
1099 if (AutoInst == false || _config->Find("APT::Solver", "internal") != "internal")
1100 return true;
1101
1102 if (DebugMarker == true)
1103 std::clog << OutputInDepth(Depth) << "MarkInstall " << Pkg << " FU=" << FromUser << std::endl;
1104
1105 DepIterator Dep = P.InstVerIter(*this).DependsList();
1106 for (; Dep.end() != true;)
1107 {
1108 // Grok or groups
1109 DepIterator Start = Dep;
1110 bool Result = true;
1111 unsigned Ors = 0;
1112 for (bool LastOR = true; Dep.end() == false && LastOR == true; ++Dep, ++Ors)
1113 {
1114 LastOR = (Dep->CompareOp & Dep::Or) == Dep::Or;
1115
1116 if ((DepState[Dep->ID] & DepInstall) == DepInstall)
1117 Result = false;
1118 }
1119
1120 // Dep is satisfied okay.
1121 if (Result == false)
1122 continue;
1123
1124 /* Check if this dep should be consider for install. If it is a user
1125 defined important dep and we are installed a new package then
1126 it will be installed. Otherwise we only check for important
1127 deps that have changed from the installed version
1128 */
1129 if (IsImportantDep(Start) == false)
1130 continue;
1131
1132 /* If we are in an or group locate the first or that can
1133 succeed. We have already cached this.. */
1134 for (; Ors > 1 && (DepState[Start->ID] & DepCVer) != DepCVer; --Ors)
1135 ++Start;
1136 if (Ors == 1 && (DepState[Start->ID] &DepCVer) != DepCVer && Start.IsNegative() == false)
1137 {
1138 if(DebugAutoInstall == true)
1139 std::clog << OutputInDepth(Depth) << Start << " can't be satisfied!" << std::endl;
1140 if (Start.IsCritical() == false)
1141 continue;
1142 // if the dependency was critical, we have absolutely no chance to install it,
1143 // so if it wasn't installed remove it again. If it was, discard the candidate
1144 // as the problemresolver will trip over it otherwise trying to install it (#735967)
1145 if (Pkg->CurrentVer == 0)
1146 MarkDelete(Pkg,false,Depth + 1, false);
1147 else
1148 SetCandidateVersion(Pkg.CurrentVer());
1149 return false;
1150 }
1151
1152 /* Check if any ImportantDep() (but not Critical) were added
1153 * since we installed the package. Also check for deps that
1154 * were satisfied in the past: for instance, if a version
1155 * restriction in a Recommends was tightened, upgrading the
1156 * package should follow that Recommends rather than causing the
1157 * dependency to be removed. (bug #470115)
1158 */
1159 if (Pkg->CurrentVer != 0 && ForceImportantDeps == false && Start.IsCritical() == false)
1160 {
1161 bool isNewImportantDep = true;
1162 bool isPreviouslySatisfiedImportantDep = false;
1163 for (DepIterator D = Pkg.CurrentVer().DependsList(); D.end() != true; ++D)
1164 {
1165 //FIXME: Should we handle or-group better here?
1166 // We do not check if the package we look for is part of the same or-group
1167 // we might find while searching, but could that really be a problem?
1168 if (D.IsCritical() == true || IsImportantDep(D) == false ||
1169 Start.TargetPkg() != D.TargetPkg())
1170 continue;
1171
1172 isNewImportantDep = false;
1173
1174 while ((D->CompareOp & Dep::Or) != 0)
1175 ++D;
1176
1177 isPreviouslySatisfiedImportantDep = (((*this)[D] & DepGNow) != 0);
1178 if (isPreviouslySatisfiedImportantDep == true)
1179 break;
1180 }
1181
1182 if(isNewImportantDep == true)
1183 {
1184 if (DebugAutoInstall == true)
1185 std::clog << OutputInDepth(Depth) << "new important dependency: "
1186 << Start.TargetPkg().FullName() << std::endl;
1187 }
1188 else if(isPreviouslySatisfiedImportantDep == true)
1189 {
1190 if (DebugAutoInstall == true)
1191 std::clog << OutputInDepth(Depth) << "previously satisfied important dependency on "
1192 << Start.TargetPkg().FullName() << std::endl;
1193 }
1194 else
1195 {
1196 if (DebugAutoInstall == true)
1197 std::clog << OutputInDepth(Depth) << "ignore old unsatisfied important dependency on "
1198 << Start.TargetPkg().FullName() << std::endl;
1199 continue;
1200 }
1201 }
1202
1203 /* This bit is for processing the possibility of an install/upgrade
1204 fixing the problem for "positive" dependencies */
1205 if (Start.IsNegative() == false && (DepState[Start->ID] & DepCVer) == DepCVer)
1206 {
1207 APT::VersionList verlist;
1208 pkgCache::VerIterator Cand = PkgState[Start.TargetPkg()->ID].CandidateVerIter(*this);
1209 if (Cand.end() == false && Start.IsSatisfied(Cand) == true)
1210 verlist.insert(Cand);
1211 for (PrvIterator Prv = Start.TargetPkg().ProvidesList(); Prv.end() != true; ++Prv)
1212 {
1213 pkgCache::VerIterator V = Prv.OwnerVer();
1214 pkgCache::VerIterator Cand = PkgState[Prv.OwnerPkg()->ID].CandidateVerIter(*this);
1215 if (Cand.end() == true || V != Cand || Start.IsSatisfied(Prv) == false)
1216 continue;
1217 verlist.insert(Cand);
1218 }
1219 CompareProviders comp(Start);
1220
1221 do {
1222 APT::VersionList::iterator InstVer = std::max_element(verlist.begin(), verlist.end(), comp);
1223
1224 if (InstVer == verlist.end())
1225 break;
1226
1227 pkgCache::PkgIterator InstPkg = InstVer.ParentPkg();
1228 if(DebugAutoInstall == true)
1229 std::clog << OutputInDepth(Depth) << "Installing " << InstPkg.Name()
1230 << " as " << Start.DepType() << " of " << Pkg.Name()
1231 << std::endl;
1232 if (MarkInstall(InstPkg, true, Depth + 1, false, ForceImportantDeps) == false)
1233 {
1234 verlist.erase(InstVer);
1235 continue;
1236 }
1237 // now check if we should consider it a automatic dependency or not
1238 if(InstPkg->CurrentVer == 0 && Pkg->Section != 0 && ConfigValueInSubTree("APT::Never-MarkAuto-Sections", Pkg.Section()))
1239 {
1240 if(DebugAutoInstall == true)
1241 std::clog << OutputInDepth(Depth) << "Setting NOT as auto-installed (direct "
1242 << Start.DepType() << " of pkg in APT::Never-MarkAuto-Sections)" << std::endl;
1243 MarkAuto(InstPkg, false);
1244 }
1245 break;
1246 } while(true);
1247 continue;
1248 }
1249 /* Negative dependencies have no or-group
1250 If the dependency isn't versioned, we try if an upgrade might solve the problem.
1251 Otherwise we remove the offender if needed */
1252 else if (Start.IsNegative() == true && Start->Type != pkgCache::Dep::Obsoletes)
1253 {
1254 SPtrArray<Version *> List = Start.AllTargets();
1255 pkgCache::PkgIterator TrgPkg = Start.TargetPkg();
1256 for (Version **I = List; *I != 0; I++)
1257 {
1258 VerIterator Ver(*this,*I);
1259 PkgIterator Pkg = Ver.ParentPkg();
1260
1261 /* The List includes all packages providing this dependency,
1262 even providers which are not installed, so skip them. */
1263 if (PkgState[Pkg->ID].InstallVer == 0)
1264 continue;
1265
1266 /* Ignore negative dependencies that we are not going to
1267 get installed */
1268 if (PkgState[Pkg->ID].InstallVer != *I)
1269 continue;
1270
1271 if ((Start->Version != 0 || TrgPkg != Pkg) &&
1272 PkgState[Pkg->ID].CandidateVer != PkgState[Pkg->ID].InstallVer &&
1273 PkgState[Pkg->ID].CandidateVer != *I &&
1274 MarkInstall(Pkg,true,Depth + 1, false, ForceImportantDeps) == true)
1275 continue;
1276 else if (Start->Type == pkgCache::Dep::Conflicts ||
1277 Start->Type == pkgCache::Dep::DpkgBreaks)
1278 {
1279 if(DebugAutoInstall == true)
1280 std::clog << OutputInDepth(Depth)
1281 << " Removing: " << Pkg.Name()
1282 << std::endl;
1283 if (MarkDelete(Pkg,false,Depth + 1, false) == false)
1284 break;
1285 }
1286 }
1287 continue;
1288 }
1289 }
1290
1291 return Dep.end() == true;
1292}
1293 /*}}}*/
1294// DepCache::IsInstallOk - check if it is ok to install this package /*{{{*/
1295// ---------------------------------------------------------------------
1296/* The default implementation checks if the installation of an M-A:same
1297 package would lead us into a version-screw and if so forbids it.
1298 dpkg holds are enforced by the private IsModeChangeOk */
1299bool pkgDepCache::IsInstallOk(PkgIterator const &Pkg,bool AutoInst,
1300 unsigned long Depth, bool FromUser)
1301{
1302 return IsInstallOkMultiArchSameVersionSynced(Pkg,AutoInst, Depth, FromUser);
1303}
1304bool pkgDepCache::IsInstallOkMultiArchSameVersionSynced(PkgIterator const &Pkg,
1305 bool const /*AutoInst*/, unsigned long const Depth, bool const FromUser)
1306{
1307 if (FromUser == true) // as always: user is always right
1308 return true;
1309
1310 // if we have checked before and it was okay, it will still be okay
1311 if (PkgState[Pkg->ID].Mode == ModeInstall &&
1312 PkgState[Pkg->ID].InstallVer == PkgState[Pkg->ID].CandidateVer)
1313 return true;
1314
1315 // ignore packages with none-M-A:same candidates
1316 VerIterator const CandVer = PkgState[Pkg->ID].CandidateVerIter(*this);
1317 if (unlikely(CandVer.end() == true) || CandVer == Pkg.CurrentVer() ||
1318 (CandVer->MultiArch & pkgCache::Version::Same) != pkgCache::Version::Same)
1319 return true;
1320
1321 GrpIterator const Grp = Pkg.Group();
1322 for (PkgIterator P = Grp.PackageList(); P.end() == false; P = Grp.NextPkg(P))
1323 {
1324 // not installed or version synced: fine by definition
1325 // (simple string-compare as stuff like '1' == '0:1-0' can't happen here)
1326 if (P->CurrentVer == 0 || strcmp(Pkg.CandVersion(), P.CandVersion()) == 0)
1327 continue;
1328 // packages losing M-A:same can be out-of-sync
1329 VerIterator CV = PkgState[P->ID].CandidateVerIter(*this);
1330 if (unlikely(CV.end() == true) ||
1331 (CV->MultiArch & pkgCache::Version::Same) != pkgCache::Version::Same)
1332 continue;
1333
1334 // not downloadable means the package is obsolete, so allow out-of-sync
1335 if (CV.Downloadable() == false)
1336 continue;
1337
1338 PkgState[Pkg->ID].iFlags |= AutoKept;
1339 if (unlikely(DebugMarker == true))
1340 std::clog << OutputInDepth(Depth) << "Ignore MarkInstall of " << Pkg
1341 << " as its M-A:same siblings are not version-synced" << std::endl;
1342 return false;
1343 }
1344
1345 return true;
1346}
1347 /*}}}*/
1348// DepCache::SetReInstall - Set the reinstallation flag /*{{{*/
1349// ---------------------------------------------------------------------
1350/* */
1351void pkgDepCache::SetReInstall(PkgIterator const &Pkg,bool To)
1352{
1353 if (unlikely(Pkg.end() == true))
1354 return;
1355
1356 APT::PackageList pkglist;
1357 if (Pkg->CurrentVer != 0 &&
1358 (Pkg.CurrentVer()-> MultiArch & pkgCache::Version::Same) == pkgCache::Version::Same)
1359 {
1360 pkgCache::GrpIterator Grp = Pkg.Group();
1361 for (pkgCache::PkgIterator P = Grp.PackageList(); P.end() == false; P = Grp.NextPkg(P))
1362 {
1363 if (P->CurrentVer != 0)
1364 pkglist.insert(P);
1365 }
1366 }
1367 else
1368 pkglist.insert(Pkg);
1369
1370 ActionGroup group(*this);
1371
1372 for (APT::PackageList::const_iterator Pkg = pkglist.begin(); Pkg != pkglist.end(); ++Pkg)
1373 {
1374 RemoveSizes(Pkg);
1375 RemoveStates(Pkg);
1376
1377 StateCache &P = PkgState[Pkg->ID];
1378 if (To == true)
1379 P.iFlags |= ReInstall;
1380 else
1381 P.iFlags &= ~ReInstall;
1382
1383 AddStates(Pkg);
1384 AddSizes(Pkg);
1385 }
1386}
1387 /*}}}*/
1388// DepCache::SetCandidateVersion - Change the candidate version /*{{{*/
1389// ---------------------------------------------------------------------
1390/* */
1391void pkgDepCache::SetCandidateVersion(VerIterator TargetVer)
1392{
1393 pkgCache::PkgIterator Pkg = TargetVer.ParentPkg();
1394 StateCache &P = PkgState[Pkg->ID];
1395
1396 if (P.CandidateVer == TargetVer)
1397 return;
1398
1399 ActionGroup group(*this);
1400
1401 RemoveSizes(Pkg);
1402 RemoveStates(Pkg);
1403
1404 if (P.CandidateVer == P.InstallVer && P.Install() == true)
1405 P.InstallVer = (Version *)TargetVer;
1406 P.CandidateVer = (Version *)TargetVer;
1407 P.Update(Pkg,*this);
1408
1409 AddStates(Pkg);
1410 Update(Pkg);
1411 AddSizes(Pkg);
1412
1413}
1414 /*}}}*/
1415// DepCache::SetCandidateRelease - Change the candidate version /*{{{*/
1416// ---------------------------------------------------------------------
1417/* changes the candidate of a package and walks over all its dependencies
1418 to check if it needs to change the candidate of the dependency, too,
1419 to reach a installable versionstate */
1420bool pkgDepCache::SetCandidateRelease(pkgCache::VerIterator TargetVer,
1421 std::string const &TargetRel)
1422{
1423 std::list<std::pair<pkgCache::VerIterator, pkgCache::VerIterator> > Changed;
1424 return SetCandidateRelease(TargetVer, TargetRel, Changed);
1425}
1426bool pkgDepCache::SetCandidateRelease(pkgCache::VerIterator TargetVer,
1427 std::string const &TargetRel,
1428 std::list<std::pair<pkgCache::VerIterator, pkgCache::VerIterator> > &Changed)
1429{
1430 ActionGroup group(*this);
1431 SetCandidateVersion(TargetVer);
1432
1433 if (TargetRel == "installed" || TargetRel == "candidate") // both doesn't make sense in this context
1434 return true;
1435
1436 pkgVersionMatch Match(TargetRel, pkgVersionMatch::Release);
1437 // save the position of the last element we will not undo - if we have to
1438 std::list<std::pair<pkgCache::VerIterator, pkgCache::VerIterator> >::iterator newChanged = --(Changed.end());
1439
1440 for (pkgCache::DepIterator D = TargetVer.DependsList(); D.end() == false; ++D)
1441 {
1442 if (D->Type != pkgCache::Dep::PreDepends && D->Type != pkgCache::Dep::Depends &&
1443 ((D->Type != pkgCache::Dep::Recommends && D->Type != pkgCache::Dep::Suggests) ||
1444 IsImportantDep(D) == false))
1445 continue;
1446
1447 // walk over an or-group and check if we need to do anything
1448 // for simpilicity no or-group is handled as a or-group including one dependency
1449 pkgCache::DepIterator Start = D;
1450 bool itsFine = false;
1451 for (bool stillOr = true; stillOr == true; ++Start)
1452 {
1453 stillOr = (Start->CompareOp & Dep::Or) == Dep::Or;
1454 pkgCache::PkgIterator const P = Start.TargetPkg();
1455 // virtual packages can't be a solution
1456 if (P.end() == true || (P->ProvidesList == 0 && P->VersionList == 0))
1457 continue;
1458 pkgCache::VerIterator const Cand = PkgState[P->ID].CandidateVerIter(*this);
1459 // no versioned dependency - but is it installable?
1460 if (Start.TargetVer() == 0 || Start.TargetVer()[0] == '\0')
1461 {
1462 // Check if one of the providers is installable
1463 if (P->ProvidesList != 0)
1464 {
1465 pkgCache::PrvIterator Prv = P.ProvidesList();
1466 for (; Prv.end() == false; ++Prv)
1467 {
1468 pkgCache::VerIterator const C = PkgState[Prv.OwnerPkg()->ID].CandidateVerIter(*this);
1469 if (C.end() == true || C != Prv.OwnerVer() ||
1470 (VersionState(C.DependsList(), DepInstall, DepCandMin, DepCandPolicy) & DepCandMin) != DepCandMin)
1471 continue;
1472 break;
1473 }
1474 if (Prv.end() == true)
1475 continue;
1476 }
1477 // no providers, so check if we have an installable candidate version
1478 else if (Cand.end() == true ||
1479 (VersionState(Cand.DependsList(), DepInstall, DepCandMin, DepCandPolicy) & DepCandMin) != DepCandMin)
1480 continue;
1481 itsFine = true;
1482 break;
1483 }
1484 if (Cand.end() == true)
1485 continue;
1486 // check if the current candidate is enough for the versioned dependency - and installable?
1487 if (Start.IsSatisfied(Cand) == true &&
1488 (VersionState(Cand.DependsList(), DepInstall, DepCandMin, DepCandPolicy) & DepCandMin) == DepCandMin)
1489 {
1490 itsFine = true;
1491 break;
1492 }
1493 }
1494
1495 if (itsFine == true) {
1496 // something in the or-group was fine, skip all other members
1497 for (; (D->CompareOp & Dep::Or) == Dep::Or; ++D);
1498 continue;
1499 }
1500
1501 // walk again over the or-group and check each if a candidate switch would help
1502 itsFine = false;
1503 for (bool stillOr = true; stillOr == true; ++D)
1504 {
1505 stillOr = (D->CompareOp & Dep::Or) == Dep::Or;
1506 // changing candidate will not help if the dependency is not versioned
1507 if (D.TargetVer() == 0 || D.TargetVer()[0] == '\0')
1508 {
1509 if (stillOr == true)
1510 continue;
1511 break;
1512 }
1513
1514 pkgCache::VerIterator V;
1515 if (TargetRel == "newest")
1516 V = D.TargetPkg().VersionList();
1517 else
1518 V = Match.Find(D.TargetPkg());
1519
1520 // check if the version from this release could satisfy the dependency
1521 if (V.end() == true || D.IsSatisfied(V) == false)
1522 {
1523 if (stillOr == true)
1524 continue;
1525 break;
1526 }
1527
1528 pkgCache::VerIterator oldCand = PkgState[D.TargetPkg()->ID].CandidateVerIter(*this);
1529 if (V == oldCand)
1530 {
1531 // Do we already touched this Version? If so, their versioned dependencies are okay, no need to check again
1532 for (std::list<std::pair<pkgCache::VerIterator, pkgCache::VerIterator> >::const_iterator c = Changed.begin();
1533 c != Changed.end(); ++c)
1534 {
1535 if (c->first->ParentPkg != V->ParentPkg)
1536 continue;
1537 itsFine = true;
1538 break;
1539 }
1540 }
1541
1542 if (itsFine == false)
1543 {
1544 // change the candidate
1545 Changed.push_back(make_pair(V, TargetVer));
1546 if (SetCandidateRelease(V, TargetRel, Changed) == false)
1547 {
1548 if (stillOr == false)
1549 break;
1550 // undo the candidate changing
1551 SetCandidateVersion(oldCand);
1552 Changed.pop_back();
1553 continue;
1554 }
1555 itsFine = true;
1556 }
1557
1558 // something in the or-group was fine, skip all other members
1559 for (; (D->CompareOp & Dep::Or) == Dep::Or; ++D);
1560 break;
1561 }
1562
1563 if (itsFine == false && (D->Type == pkgCache::Dep::PreDepends || D->Type == pkgCache::Dep::Depends))
1564 {
1565 // undo all changes which aren't lead to a solution
1566 for (std::list<std::pair<pkgCache::VerIterator, pkgCache::VerIterator> >::const_iterator c = ++newChanged;
1567 c != Changed.end(); ++c)
1568 SetCandidateVersion(c->first);
1569 Changed.erase(newChanged, Changed.end());
1570 return false;
1571 }
1572 }
1573 return true;
1574}
1575 /*}}}*/
1576// DepCache::MarkAuto - set the Auto flag for a package /*{{{*/
1577// ---------------------------------------------------------------------
1578/* */
1579void pkgDepCache::MarkAuto(const PkgIterator &Pkg, bool Auto)
1580{
1581 StateCache &state = PkgState[Pkg->ID];
1582
1583 ActionGroup group(*this);
1584
1585 if(Auto)
1586 state.Flags |= Flag::Auto;
1587 else
1588 state.Flags &= ~Flag::Auto;
1589}
1590 /*}}}*/
1591// StateCache::Update - Compute the various static display things /*{{{*/
1592// ---------------------------------------------------------------------
1593/* This is called whenever the Candidate version changes. */
1594void pkgDepCache::StateCache::Update(PkgIterator Pkg,pkgCache &Cache)
1595{
1596 // Some info
1597 VerIterator Ver = CandidateVerIter(Cache);
1598
1599 // Use a null string or the version string
1600 if (Ver.end() == true)
1601 CandVersion = "";
1602 else
1603 CandVersion = Ver.VerStr();
1604
1605 // Find the current version
1606 CurVersion = "";
1607 if (Pkg->CurrentVer != 0)
1608 CurVersion = Pkg.CurrentVer().VerStr();
1609
1610 // Strip off the epochs for display
1611 CurVersion = StripEpoch(CurVersion);
1612 CandVersion = StripEpoch(CandVersion);
1613
1614 // Figure out if its up or down or equal
1615 Status = Ver.CompareVer(Pkg.CurrentVer());
1616 if (Pkg->CurrentVer == 0 || Pkg->VersionList == 0 || CandidateVer == 0)
1617 Status = 2;
1618}
1619 /*}}}*/
1620// StateCache::StripEpoch - Remove the epoch specifier from the version /*{{{*/
1621// ---------------------------------------------------------------------
1622/* */
1623const char *pkgDepCache::StateCache::StripEpoch(const char *Ver)
1624{
1625 if (Ver == 0)
1626 return 0;
1627
1628 // Strip any epoch
1629 for (const char *I = Ver; *I != 0; I++)
1630 if (*I == ':')
1631 return I + 1;
1632 return Ver;
1633}
1634 /*}}}*/
1635// Policy::GetCandidateVer - Returns the Candidate install version /*{{{*/
1636// ---------------------------------------------------------------------
1637/* The default just returns the highest available version that is not
1638 a source and automatic. */
1639pkgCache::VerIterator pkgDepCache::Policy::GetCandidateVer(PkgIterator const &Pkg)
1640{
1641 /* Not source/not automatic versions cannot be a candidate version
1642 unless they are already installed */
1643 VerIterator Last(*(pkgCache *)this,0);
1644
1645 for (VerIterator I = Pkg.VersionList(); I.end() == false; ++I)
1646 {
1647 if (Pkg.CurrentVer() == I)
1648 return I;
1649
1650 for (VerFileIterator J = I.FileList(); J.end() == false; ++J)
1651 {
1652 if ((J.File()->Flags & Flag::NotSource) != 0)
1653 continue;
1654
1655 /* Stash the highest version of a not-automatic source, we use it
1656 if there is nothing better */
1657 if ((J.File()->Flags & Flag::NotAutomatic) != 0 ||
1658 (J.File()->Flags & Flag::ButAutomaticUpgrades) != 0)
1659 {
1660 if (Last.end() == true)
1661 Last = I;
1662 continue;
1663 }
1664
1665 return I;
1666 }
1667 }
1668
1669 return Last;
1670}
1671 /*}}}*/
1672// Policy::IsImportantDep - True if the dependency is important /*{{{*/
1673// ---------------------------------------------------------------------
1674/* */
1675bool pkgDepCache::Policy::IsImportantDep(DepIterator const &Dep)
1676{
1677 if(Dep.IsCritical())
1678 return true;
1679 else if(Dep->Type == pkgCache::Dep::Recommends)
1680 {
1681 if (InstallRecommends)
1682 return true;
1683 // we suport a special mode to only install-recommends for certain
1684 // sections
1685 // FIXME: this is a meant as a temporarly solution until the
1686 // recommends are cleaned up
1687 const char *sec = Dep.ParentVer().Section();
1688 if (sec && ConfigValueInSubTree("APT::Install-Recommends-Sections", sec))
1689 return true;
1690 }
1691 else if(Dep->Type == pkgCache::Dep::Suggests)
1692 return InstallSuggests;
1693
1694 return false;
1695}
1696 /*}}}*/
1697// Policy::GetPriority - Get the priority of the package pin /*{{{*/
1698APT_CONST signed short pkgDepCache::Policy::GetPriority(pkgCache::PkgIterator const &/*Pkg*/)
1699{ return 0; }
1700APT_CONST signed short pkgDepCache::Policy::GetPriority(pkgCache::PkgFileIterator const &/*File*/)
1701{ return 0; }
1702 /*}}}*/
1703pkgDepCache::InRootSetFunc *pkgDepCache::GetRootSetFunc() /*{{{*/
1704{
1705 DefaultRootSetFunc *f = new DefaultRootSetFunc;
1706 if(f->wasConstructedSuccessfully())
1707 return f;
1708 else
1709 {
1710 delete f;
1711 return NULL;
1712 }
1713}
1714 /*}}}*/
1715bool pkgDepCache::MarkFollowsRecommends()
1716{
1717 return _config->FindB("APT::AutoRemove::RecommendsImportant", true);
1718}
1719
1720bool pkgDepCache::MarkFollowsSuggests()
1721{
1722 return _config->FindB("APT::AutoRemove::SuggestsImportant", true);
1723}
1724
1725// pkgDepCache::MarkRequired - the main mark algorithm /*{{{*/
1726bool pkgDepCache::MarkRequired(InRootSetFunc &userFunc)
1727{
1728 if (_config->Find("APT::Solver", "internal") != "internal")
1729 return true;
1730
1731 bool follow_recommends;
1732 bool follow_suggests;
1733 bool debug_autoremove = _config->FindB("Debug::pkgAutoRemove",false);
1734
1735 // init the states
1736 for(PkgIterator p = PkgBegin(); !p.end(); ++p)
1737 {
1738 PkgState[p->ID].Marked = false;
1739 PkgState[p->ID].Garbage = false;
1740
1741 // debug output
1742 if(debug_autoremove && PkgState[p->ID].Flags & Flag::Auto)
1743 std::clog << "AutoDep: " << p.FullName() << std::endl;
1744 }
1745
1746 // init vars
1747 follow_recommends = MarkFollowsRecommends();
1748 follow_suggests = MarkFollowsSuggests();
1749
1750 // do the mark part, this is the core bit of the algorithm
1751 for(PkgIterator p = PkgBegin(); !p.end(); ++p)
1752 {
1753 if(!(PkgState[p->ID].Flags & Flag::Auto) ||
1754 (p->Flags & Flag::Essential) ||
1755 (p->Flags & Flag::Important) ||
1756 userFunc.InRootSet(p) ||
1757 // be nice even then a required package violates the policy (#583517)
1758 // and do the full mark process also for required packages
1759 (p.CurrentVer().end() != true &&
1760 p.CurrentVer()->Priority == pkgCache::State::Required) ||
1761 // packages which can't be changed (like holds) can't be garbage
1762 (IsModeChangeOk(ModeGarbage, p, 0, false) == false))
1763 {
1764 // the package is installed (and set to keep)
1765 if(PkgState[p->ID].Keep() && !p.CurrentVer().end())
1766 MarkPackage(p, p.CurrentVer(),
1767 follow_recommends, follow_suggests);
1768 // the package is to be installed
1769 else if(PkgState[p->ID].Install())
1770 MarkPackage(p, PkgState[p->ID].InstVerIter(*this),
1771 follow_recommends, follow_suggests);
1772 }
1773 }
1774
1775 return true;
1776}
1777 /*}}}*/
1778// MarkPackage - mark a single package in Mark-and-Sweep /*{{{*/
1779void pkgDepCache::MarkPackage(const pkgCache::PkgIterator &pkg,
1780 const pkgCache::VerIterator &ver,
1781 bool const &follow_recommends,
1782 bool const &follow_suggests)
1783{
1784 pkgDepCache::StateCache &state = PkgState[pkg->ID];
1785
1786 // if we are marked already we are done
1787 if(state.Marked)
1788 return;
1789
1790 VerIterator const currver = pkg.CurrentVer();
1791 VerIterator const instver = state.InstVerIter(*this);
1792
1793#if 0
1794 VerIterator const candver = state.CandidateVerIter(*this);
1795
1796 // If a package was garbage-collected but is now being marked, we
1797 // should re-select it
1798 // For cases when a pkg is set to upgrade and this trigger the
1799 // removal of a no-longer used dependency. if the pkg is set to
1800 // keep again later it will result in broken deps
1801 if(state.Delete() && state.RemoveReason = Unused)
1802 {
1803 if(ver==candver)
1804 mark_install(pkg, false, false, NULL);
1805 else if(ver==pkg.CurrentVer())
1806 MarkKeep(pkg, false, false);
1807
1808 instver=state.InstVerIter(*this);
1809 }
1810#endif
1811
1812 // For packages that are not going to be removed, ignore versions
1813 // other than the InstVer. For packages that are going to be
1814 // removed, ignore versions other than the current version.
1815 if(!(ver == instver && !instver.end()) &&
1816 !(ver == currver && instver.end() && !ver.end()))
1817 return;
1818
1819 bool const debug_autoremove = _config->FindB("Debug::pkgAutoRemove", false);
1820
1821 if(debug_autoremove)
1822 {
1823 std::clog << "Marking: " << pkg.FullName();
1824 if(!ver.end())
1825 std::clog << " " << ver.VerStr();
1826 if(!currver.end())
1827 std::clog << ", Curr=" << currver.VerStr();
1828 if(!instver.end())
1829 std::clog << ", Inst=" << instver.VerStr();
1830 std::clog << std::endl;
1831 }
1832
1833 state.Marked=true;
1834
1835 if(ver.end() == true)
1836 return;
1837
1838 for(DepIterator d = ver.DependsList(); !d.end(); ++d)
1839 {
1840 if(d->Type == Dep::Depends ||
1841 d->Type == Dep::PreDepends ||
1842 (follow_recommends &&
1843 d->Type == Dep::Recommends) ||
1844 (follow_suggests &&
1845 d->Type == Dep::Suggests))
1846 {
1847 // Try all versions of this package.
1848 for(VerIterator V = d.TargetPkg().VersionList();
1849 !V.end(); ++V)
1850 {
1851 if(d.IsSatisfied(V))
1852 {
1853 if(debug_autoremove)
1854 {
1855 std::clog << "Following dep: " << d.ParentPkg().FullName()
1856 << " " << d.ParentVer().VerStr() << " "
1857 << d.DepType() << " " << d.TargetPkg().FullName();
1858 if((d->CompareOp & ~pkgCache::Dep::Or) != pkgCache::Dep::NoOp)
1859 {
1860 std::clog << " (" << d.CompType() << " "
1861 << d.TargetVer() << ")";
1862 }
1863 std::clog << std::endl;
1864 }
1865 MarkPackage(V.ParentPkg(), V,
1866 follow_recommends, follow_suggests);
1867 }
1868 }
1869 // Now try virtual packages
1870 for(PrvIterator prv=d.TargetPkg().ProvidesList();
1871 !prv.end(); ++prv)
1872 {
1873 if(d.IsSatisfied(prv))
1874 {
1875 if(debug_autoremove)
1876 {
1877 std::clog << "Following dep: " << d.ParentPkg().FullName() << " "
1878 << d.ParentVer().VerStr() << " "
1879 << d.DepType() << " " << d.TargetPkg().FullName() << " ";
1880 if((d->CompareOp & ~pkgCache::Dep::Or) != pkgCache::Dep::NoOp)
1881 {
1882 std::clog << " (" << d.CompType() << " "
1883 << d.TargetVer() << ")";
1884 }
1885 std::clog << ", provided by "
1886 << prv.OwnerPkg().FullName() << " "
1887 << prv.OwnerVer().VerStr()
1888 << std::endl;
1889 }
1890
1891 MarkPackage(prv.OwnerPkg(), prv.OwnerVer(),
1892 follow_recommends, follow_suggests);
1893 }
1894 }
1895 }
1896 }
1897}
1898 /*}}}*/
1899bool pkgDepCache::Sweep() /*{{{*/
1900{
1901 bool debug_autoremove = _config->FindB("Debug::pkgAutoRemove",false);
1902
1903 // do the sweep
1904 for(PkgIterator p=PkgBegin(); !p.end(); ++p)
1905 {
1906 StateCache &state=PkgState[p->ID];
1907
1908 // skip required packages
1909 if (!p.CurrentVer().end() &&
1910 (p.CurrentVer()->Priority == pkgCache::State::Required))
1911 continue;
1912
1913 // if it is not marked and it is installed, it's garbage
1914 if(!state.Marked && (!p.CurrentVer().end() || state.Install()))
1915 {
1916 state.Garbage=true;
1917 if(debug_autoremove)
1918 std::clog << "Garbage: " << p.FullName() << std::endl;
1919 }
1920 }
1921
1922 return true;
1923}
1924 /*}}}*/