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