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