]> git.saurik.com Git - apt.git/blame_incremental - apt-pkg/edsp.cc
projects / apt.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Merge branch 'cmake'
[apt.git] / apt-pkg / edsp.cc
... / ...
CommitLineData
1// -*- mode: cpp; mode: fold -*-
2// Description /*{{{*/
3/* ######################################################################
4 Set of methods to help writing and reading everything needed for EDSP
5 ##################################################################### */
6 /*}}}*/
7// Include Files /*{{{*/
8#include <config.h>
9
10#include <apt-pkg/algorithms.h>
11#include <apt-pkg/error.h>
12#include <apt-pkg/cacheset.h>
13#include <apt-pkg/depcache.h>
14#include <apt-pkg/pkgcache.h>
15#include <apt-pkg/cacheiterators.h>
16#include <apt-pkg/prettyprinters.h>
17#include <apt-pkg/packagemanager.h>
18#include <apt-pkg/progress.h>
19#include <apt-pkg/fileutl.h>
20#include <apt-pkg/edsp.h>
21#include <apt-pkg/tagfile.h>
22#include <apt-pkg/strutl.h>
23#include <apt-pkg/string_view.h>
24#include <apt-pkg/pkgsystem.h>
25
26#include <sys/stat.h>
27#include <ctype.h>
28#include <stddef.h>
29#include <string.h>
30#include <unistd.h>
31#include <stdio.h>
32
33#include <array>
34#include <limits>
35#include <string>
36
37#include <apti18n.h>
38 /*}}}*/
39
40using std::string;
41
42// we could use pkgCache::DepType and ::Priority, but these would be localized strings…
43constexpr char const * const PrioMap[] = {
44 nullptr, "important", "required", "standard",
45 "optional", "extra"
46};
47constexpr char const * const DepMap[] = {
48 nullptr, "Depends", "Pre-Depends", "Suggests",
49 "Recommends" , "Conflicts", "Replaces",
50 "Obsoletes", "Breaks", "Enhances"
51};
52
53// WriteOkay - varaidic helper to easily Write to a FileFd /*{{{*/
54static bool WriteOkay_fn(FileFd &) { return true; }
55template<typename... Tail> static bool WriteOkay_fn(FileFd &output, APT::StringView data, Tail... more_data)
56{
57 return likely(output.Write(data.data(), data.length()) && WriteOkay_fn(output, more_data...));
58}
59template<typename... Tail> static bool WriteOkay_fn(FileFd &output, unsigned int data, Tail... more_data)
60{
61 std::string number;
62 strprintf(number, "%d", data);
63 return likely(output.Write(number.data(), number.length()) && WriteOkay_fn(output, more_data...));
64}
65template<typename... Data> static bool WriteOkay(bool &Okay, FileFd &output, Data&&... data)
66{
67 Okay = likely(Okay && WriteOkay_fn(output, std::forward<Data>(data)...));
68 return Okay;
69}
70template<typename... Data> static bool WriteOkay(FileFd &output, Data&&... data)
71{
72 bool Okay = likely(output.Failed() == false);
73 return WriteOkay(Okay, output, std::forward<Data>(data)...);
74}
75 /*}}}*/
76// WriteScenarioVersion /*{{{*/
77static void WriteScenarioVersion(pkgDepCache &Cache, FILE* output, pkgCache::PkgIterator const &Pkg,
78 pkgCache::VerIterator const &Ver)
79{
80 fprintf(output, "Package: %s\n", Pkg.Name());
81 fprintf(output, "Source: %s\n", Ver.SourcePkgName());
82 fprintf(output, "Architecture: %s\n", Ver.Arch());
83 fprintf(output, "Version: %s\n", Ver.VerStr());
84 fprintf(output, "Source-Version: %s\n", Ver.SourceVerStr());
85 if (Pkg.CurrentVer() == Ver)
86 fprintf(output, "Installed: yes\n");
87 if (Pkg->SelectedState == pkgCache::State::Hold ||
88 (Cache[Pkg].Keep() == true && Cache[Pkg].Protect() == true))
89 fprintf(output, "Hold: yes\n");
90 fprintf(output, "APT-ID: %d\n", Ver->ID);
91 if (PrioMap[Ver->Priority] != nullptr)
92 fprintf(output, "Priority: %s\n", PrioMap[Ver->Priority]);
93 if ((Pkg->Flags & pkgCache::Flag::Essential) == pkgCache::Flag::Essential)
94 fprintf(output, "Essential: yes\n");
95 if (Ver->Section != 0)
96 fprintf(output, "Section: %s\n", Ver.Section());
97 if ((Ver->MultiArch & pkgCache::Version::Allowed) == pkgCache::Version::Allowed)
98 fprintf(output, "Multi-Arch: allowed\n");
99 else if ((Ver->MultiArch & pkgCache::Version::Foreign) == pkgCache::Version::Foreign)
100 fprintf(output, "Multi-Arch: foreign\n");
101 else if ((Ver->MultiArch & pkgCache::Version::Same) == pkgCache::Version::Same)
102 fprintf(output, "Multi-Arch: same\n");
103 std::set<string> Releases;
104 for (pkgCache::VerFileIterator I = Ver.FileList(); I.end() == false; ++I) {
105 pkgCache::PkgFileIterator File = I.File();
106 if (File.Flagged(pkgCache::Flag::NotSource) == false) {
107 string Release = File.RelStr();
108 if (!Release.empty())
109 Releases.insert(Release);
110 }
111 }
112 if (!Releases.empty()) {
113 fprintf(output, "APT-Release:\n");
114 for (std::set<string>::iterator R = Releases.begin(); R != Releases.end(); ++R)
115 fprintf(output, " %s\n", R->c_str());
116 }
117 fprintf(output, "APT-Pin: %d\n", Cache.GetPolicy().GetPriority(Ver));
118 if (Cache.GetCandidateVersion(Pkg) == Ver)
119 fprintf(output, "APT-Candidate: yes\n");
120 if ((Cache[Pkg].Flags & pkgCache::Flag::Auto) == pkgCache::Flag::Auto)
121 fprintf(output, "APT-Automatic: yes\n");
122}
123static bool WriteScenarioVersion(FileFd &output, pkgCache::PkgIterator const &Pkg,
124 pkgCache::VerIterator const &Ver)
125{
126 bool Okay = WriteOkay(output, "Package: ", Pkg.Name(),
127 "\nArchitecture: ", Ver.Arch(),
128 "\nVersion: ", Ver.VerStr());
129 WriteOkay(Okay, output, "\nAPT-ID: ", Ver->ID);
130 if ((Pkg->Flags & pkgCache::Flag::Essential) == pkgCache::Flag::Essential)
131 WriteOkay(Okay, output, "\nEssential: yes");
132 if ((Ver->MultiArch & pkgCache::Version::Allowed) == pkgCache::Version::Allowed)
133 WriteOkay(Okay, output, "\nMulti-Arch: allowed");
134 else if ((Ver->MultiArch & pkgCache::Version::Foreign) == pkgCache::Version::Foreign)
135 WriteOkay(Okay, output, "\nMulti-Arch: foreign");
136 else if ((Ver->MultiArch & pkgCache::Version::Same) == pkgCache::Version::Same)
137 WriteOkay(Okay, output, "\nMulti-Arch: same");
138 return Okay;
139}
140 /*}}}*/
141// WriteScenarioDependency /*{{{*/
142static void WriteScenarioDependency( FILE* output, pkgCache::VerIterator const &Ver)
143{
144 std::array<std::string, _count(DepMap)> dependencies;
145 bool orGroup = false;
146 for (pkgCache::DepIterator Dep = Ver.DependsList(); Dep.end() == false; ++Dep)
147 {
148 if (Dep.IsImplicit() == true)
149 continue;
150 if (orGroup == false)
151 dependencies[Dep->Type].append(", ");
152 dependencies[Dep->Type].append(Dep.TargetPkg().Name());
153 if (Dep->Version != 0)
154 dependencies[Dep->Type].append(" (").append(pkgCache::CompTypeDeb(Dep->CompareOp)).append(" ").append(Dep.TargetVer()).append(")");
155 if ((Dep->CompareOp & pkgCache::Dep::Or) == pkgCache::Dep::Or)
156 {
157 dependencies[Dep->Type].append(" | ");
158 orGroup = true;
159 }
160 else
161 orGroup = false;
162 }
163 for (size_t i = 1; i < dependencies.size(); ++i)
164 if (dependencies[i].empty() == false)
165 fprintf(output, "%s: %s\n", DepMap[i], dependencies[i].c_str()+2);
166 string provides;
167 for (pkgCache::PrvIterator Prv = Ver.ProvidesList(); Prv.end() == false; ++Prv)
168 {
169 if (Prv.IsMultiArchImplicit() == true)
170 continue;
171 if (provides.empty() == false)
172 provides.append(", ");
173 provides.append(Prv.Name());
174 if (Prv->ProvideVersion != 0)
175 provides.append(" (= ").append(Prv.ProvideVersion()).append(")");
176 }
177 if (provides.empty() == false)
178 fprintf(output, "Provides: %s\n", provides.c_str());
179}
180static bool WriteScenarioDependency(FileFd &output, pkgCache::VerIterator const &Ver, bool const OnlyCritical)
181{
182 std::array<std::string, _count(DepMap)> dependencies;
183 bool orGroup = false;
184 for (pkgCache::DepIterator Dep = Ver.DependsList(); Dep.end() == false; ++Dep)
185 {
186 if (Dep.IsImplicit() == true)
187 continue;
188 if (OnlyCritical && Dep.IsCritical() == false)
189 continue;
190 if (orGroup == false && dependencies[Dep->Type].empty() == false)
191 dependencies[Dep->Type].append(", ");
192 dependencies[Dep->Type].append(Dep.TargetPkg().Name());
193 if (Dep->Version != 0)
194 dependencies[Dep->Type].append(" (").append(pkgCache::CompTypeDeb(Dep->CompareOp)).append(" ").append(Dep.TargetVer()).append(")");
195 if ((Dep->CompareOp & pkgCache::Dep::Or) == pkgCache::Dep::Or)
196 {
197 dependencies[Dep->Type].append(" | ");
198 orGroup = true;
199 }
200 else
201 orGroup = false;
202 }
203 bool Okay = output.Failed() == false;
204 for (size_t i = 1; i < dependencies.size(); ++i)
205 if (dependencies[i].empty() == false)
206 WriteOkay(Okay, output, "\n", DepMap[i], ": ", dependencies[i]);
207 string provides;
208 for (pkgCache::PrvIterator Prv = Ver.ProvidesList(); Prv.end() == false; ++Prv)
209 {
210 if (Prv.IsMultiArchImplicit() == true)
211 continue;
212 if (provides.empty() == false)
213 provides.append(", ");
214 provides.append(Prv.Name());
215 if (Prv->ProvideVersion != 0)
216 provides.append(" (= ").append(Prv.ProvideVersion()).append(")");
217 }
218 if (provides.empty() == false)
219 WriteOkay(Okay, output, "\nProvides: ", provides);
220 return WriteOkay(Okay, output, "\n");
221}
222 /*}}}*/
223// WriteScenarioLimitedDependency /*{{{*/
224static void WriteScenarioLimitedDependency(FILE* output,
225 pkgCache::VerIterator const &Ver,
226 APT::PackageSet const &pkgset)
227{
228 std::array<std::string, _count(DepMap)> dependencies;
229 bool orGroup = false;
230 for (pkgCache::DepIterator Dep = Ver.DependsList(); Dep.end() == false; ++Dep)
231 {
232 if (Dep.IsImplicit() == true)
233 continue;
234 if (orGroup == false)
235 {
236 if (pkgset.find(Dep.TargetPkg()) == pkgset.end())
237 continue;
238 if (dependencies[Dep->Type].empty() == false)
239 dependencies[Dep->Type].append(", ");
240 }
241 else if (pkgset.find(Dep.TargetPkg()) == pkgset.end())
242 {
243 if ((Dep->CompareOp & pkgCache::Dep::Or) == pkgCache::Dep::Or)
244 continue;
245 dependencies[Dep->Type].erase(dependencies[Dep->Type].end()-3, dependencies[Dep->Type].end());
246 orGroup = false;
247 continue;
248 }
249 dependencies[Dep->Type].append(Dep.TargetPkg().Name());
250 if (Dep->Version != 0)
251 dependencies[Dep->Type].append(" (").append(pkgCache::CompTypeDeb(Dep->CompareOp)).append(" ").append(Dep.TargetVer()).append(")");
252 if ((Dep->CompareOp & pkgCache::Dep::Or) == pkgCache::Dep::Or)
253 {
254 dependencies[Dep->Type].append(" | ");
255 orGroup = true;
256 }
257 else
258 orGroup = false;
259 }
260 for (size_t i = 1; i < dependencies.size(); ++i)
261 if (dependencies[i].empty() == false)
262 fprintf(output, "%s: %s\n", DepMap[i], dependencies[i].c_str());
263 string provides;
264 for (pkgCache::PrvIterator Prv = Ver.ProvidesList(); Prv.end() == false; ++Prv)
265 {
266 if (Prv.IsMultiArchImplicit() == true)
267 continue;
268 if (pkgset.find(Prv.ParentPkg()) == pkgset.end())
269 continue;
270 if (provides.empty() == false)
271 provides.append(", ");
272 provides.append(Prv.Name());
273 if (Prv->ProvideVersion != 0)
274 provides.append(" (= ").append(Prv.ProvideVersion()).append(")");
275 }
276 if (provides.empty() == false)
277 fprintf(output, "Provides: %s\n", provides.c_str());
278}
279static bool WriteScenarioLimitedDependency(FileFd &output,
280 pkgCache::VerIterator const &Ver,
281 std::vector<bool> const &pkgset,
282 bool const OnlyCritical)
283{
284 std::array<std::string, _count(DepMap)> dependencies;
285 bool orGroup = false;
286 for (pkgCache::DepIterator Dep = Ver.DependsList(); Dep.end() == false; ++Dep)
287 {
288 if (Dep.IsImplicit() == true)
289 continue;
290 if (OnlyCritical && Dep.IsCritical() == false)
291 continue;
292 if (orGroup == false)
293 {
294 if (pkgset[Dep.TargetPkg()->ID] == false)
295 continue;
296 if (dependencies[Dep->Type].empty() == false)
297 dependencies[Dep->Type].append(", ");
298 }
299 else if (pkgset[Dep.TargetPkg()->ID] == false)
300 {
301 if ((Dep->CompareOp & pkgCache::Dep::Or) == pkgCache::Dep::Or)
302 continue;
303 dependencies[Dep->Type].erase(dependencies[Dep->Type].end()-3, dependencies[Dep->Type].end());
304 orGroup = false;
305 continue;
306 }
307 dependencies[Dep->Type].append(Dep.TargetPkg().Name());
308 if (Dep->Version != 0)
309 dependencies[Dep->Type].append(" (").append(pkgCache::CompTypeDeb(Dep->CompareOp)).append(" ").append(Dep.TargetVer()).append(")");
310 if ((Dep->CompareOp & pkgCache::Dep::Or) == pkgCache::Dep::Or)
311 {
312 dependencies[Dep->Type].append(" | ");
313 orGroup = true;
314 }
315 else
316 orGroup = false;
317 }
318 bool Okay = output.Failed() == false;
319 for (size_t i = 1; i < dependencies.size(); ++i)
320 if (dependencies[i].empty() == false)
321 WriteOkay(Okay, output, "\n", DepMap[i], ": ", dependencies[i]);
322 string provides;
323 for (pkgCache::PrvIterator Prv = Ver.ProvidesList(); Prv.end() == false; ++Prv)
324 {
325 if (Prv.IsMultiArchImplicit() == true)
326 continue;
327 if (pkgset[Prv.ParentPkg()->ID] == false)
328 continue;
329 if (provides.empty() == false)
330 provides.append(", ");
331 provides.append(Prv.Name());
332 if (Prv->ProvideVersion != 0)
333 provides.append(" (= ").append(Prv.ProvideVersion()).append(")");
334 }
335 if (provides.empty() == false)
336 WriteOkay(Okay, output, "\nProvides: ", provides);
337 return WriteOkay(Okay, output, "\n");
338}
339 /*}}}*/
340static bool SkipUnavailableVersions(pkgDepCache &Cache, pkgCache::PkgIterator const &Pkg, pkgCache::VerIterator const &Ver)/*{{{*/
341{
342 /* versions which aren't current and aren't available in
343 any "online" source file are bad, expect if they are the chosen
344 candidate: The exception is for build-dep implementation as it creates
345 such pseudo (package) versions and removes them later on again.
346 We filter out versions at all so packages in 'rc' state only available
347 in dpkg/status aren't passed to solvers as they can't be installed. */
348 if (Pkg->CurrentVer != 0)
349 return false;
350 if (Cache.GetCandidateVersion(Pkg) == Ver)
351 return false;
352 for (pkgCache::VerFileIterator I = Ver.FileList(); I.end() == false; ++I)
353 if (I.File().Flagged(pkgCache::Flag::NotSource) == false)
354 return false;
355 return true;
356}
357 /*}}}*/
358static bool WriteScenarioEDSPVersion(pkgDepCache &Cache, FileFd &output, pkgCache::PkgIterator const &Pkg,/*{{{*/
359 pkgCache::VerIterator const &Ver)
360{
361 bool Okay = WriteOkay(output, "\nSource: ", Ver.SourcePkgName(),
362 "\nSource-Version: ", Ver.SourceVerStr());
363 if (PrioMap[Ver->Priority] != nullptr)
364 WriteOkay(Okay, output, "\nPriority: ", PrioMap[Ver->Priority]);
365 if (Ver->Section != 0)
366 WriteOkay(Okay, output, "\nSection: ", Ver.Section());
367 if (Pkg.CurrentVer() == Ver)
368 WriteOkay(Okay, output, "\nInstalled: yes");
369 if (Pkg->SelectedState == pkgCache::State::Hold ||
370 (Cache[Pkg].Keep() == true && Cache[Pkg].Protect() == true))
371 WriteOkay(Okay, output, "\nHold: yes");
372 std::set<string> Releases;
373 for (pkgCache::VerFileIterator I = Ver.FileList(); I.end() == false; ++I) {
374 pkgCache::PkgFileIterator File = I.File();
375 if (File.Flagged(pkgCache::Flag::NotSource) == false) {
376 string Release = File.RelStr();
377 if (!Release.empty())
378 Releases.insert(Release);
379 }
380 }
381 if (!Releases.empty()) {
382 WriteOkay(Okay, output, "\nAPT-Release:");
383 for (std::set<string>::iterator R = Releases.begin(); R != Releases.end(); ++R)
384 WriteOkay(Okay, output, "\n ", *R);
385 }
386 WriteOkay(Okay, output, "\nAPT-Pin: ", Cache.GetPolicy().GetPriority(Ver));
387 if (Cache.GetCandidateVersion(Pkg) == Ver)
388 WriteOkay(Okay, output, "\nAPT-Candidate: yes");
389 if ((Cache[Pkg].Flags & pkgCache::Flag::Auto) == pkgCache::Flag::Auto)
390 WriteOkay(Okay, output, "\nAPT-Automatic: yes");
391 return Okay;
392}
393 /*}}}*/
394// EDSP::WriteScenario - to the given file descriptor /*{{{*/
395bool EDSP::WriteScenario(pkgDepCache &Cache, FILE* output, OpProgress *Progress)
396{
397 if (Progress != NULL)
398 Progress->SubProgress(Cache.Head().VersionCount, _("Send scenario to solver"));
399 unsigned long p = 0;
400 std::vector<std::string> archs = APT::Configuration::getArchitectures();
401 for (pkgCache::PkgIterator Pkg = Cache.PkgBegin(); Pkg.end() == false; ++Pkg)
402 {
403 std::string const arch = Pkg.Arch();
404 if (std::find(archs.begin(), archs.end(), arch) == archs.end())
405 continue;
406 for (pkgCache::VerIterator Ver = Pkg.VersionList(); Ver.end() == false; ++Ver, ++p)
407 {
408 if (SkipUnavailableVersions(Cache, Pkg, Ver))
409 continue;
410 WriteScenarioVersion(Cache, output, Pkg, Ver);
411 WriteScenarioDependency(output, Ver);
412 fprintf(output, "\n");
413 if (Progress != NULL && p % 100 == 0)
414 Progress->Progress(p);
415 }
416 }
417 return true;
418}
419bool EDSP::WriteScenario(pkgDepCache &Cache, FileFd &output, OpProgress *Progress)
420{
421 if (Progress != NULL)
422 Progress->SubProgress(Cache.Head().VersionCount, _("Send scenario to solver"));
423 unsigned long p = 0;
424 bool Okay = output.Failed() == false;
425 std::vector<std::string> archs = APT::Configuration::getArchitectures();
426 for (pkgCache::PkgIterator Pkg = Cache.PkgBegin(); Pkg.end() == false && likely(Okay); ++Pkg)
427 {
428 std::string const arch = Pkg.Arch();
429 if (std::find(archs.begin(), archs.end(), arch) == archs.end())
430 continue;
431 for (pkgCache::VerIterator Ver = Pkg.VersionList(); Ver.end() == false && likely(Okay); ++Ver, ++p)
432 {
433 if (SkipUnavailableVersions(Cache, Pkg, Ver))
434 continue;
435 Okay &= WriteScenarioVersion(output, Pkg, Ver);
436 Okay &= WriteScenarioEDSPVersion(Cache, output, Pkg, Ver);
437 Okay &= WriteScenarioDependency(output, Ver, false);
438 WriteOkay(Okay, output, "\n");
439 if (Progress != NULL && p % 100 == 0)
440 Progress->Progress(p);
441 }
442 }
443 return Okay;
444}
445 /*}}}*/
446// EDSP::WriteLimitedScenario - to the given file descriptor /*{{{*/
447bool EDSP::WriteLimitedScenario(pkgDepCache &Cache, FILE* output,
448 APT::PackageSet const &pkgset,
449 OpProgress *Progress)
450{
451 if (Progress != NULL)
452 Progress->SubProgress(Cache.Head().VersionCount, _("Send scenario to solver"));
453 unsigned long p = 0;
454 for (APT::PackageSet::const_iterator Pkg = pkgset.begin(); Pkg != pkgset.end(); ++Pkg, ++p)
455 for (pkgCache::VerIterator Ver = Pkg.VersionList(); Ver.end() == false; ++Ver)
456 {
457 if (SkipUnavailableVersions(Cache, Pkg, Ver))
458 continue;
459 WriteScenarioVersion(Cache, output, Pkg, Ver);
460 WriteScenarioLimitedDependency(output, Ver, pkgset);
461 fprintf(output, "\n");
462 if (Progress != NULL && p % 100 == 0)
463 Progress->Progress(p);
464 }
465 if (Progress != NULL)
466 Progress->Done();
467 return true;
468}
469bool EDSP::WriteLimitedScenario(pkgDepCache &Cache, FileFd &output,
470 std::vector<bool> const &pkgset,
471 OpProgress *Progress)
472{
473 if (Progress != NULL)
474 Progress->SubProgress(Cache.Head().VersionCount, _("Send scenario to solver"));
475 unsigned long p = 0;
476 bool Okay = output.Failed() == false;
477 for (auto Pkg = Cache.PkgBegin(); Pkg.end() == false && likely(Okay); ++Pkg, ++p)
478 {
479 if (pkgset[Pkg->ID] == false)
480 continue;
481 for (pkgCache::VerIterator Ver = Pkg.VersionList(); Ver.end() == false && likely(Okay); ++Ver)
482 {
483 if (SkipUnavailableVersions(Cache, Pkg, Ver))
484 continue;
485 Okay &= WriteScenarioVersion(output, Pkg, Ver);
486 Okay &= WriteScenarioEDSPVersion(Cache, output, Pkg, Ver);
487 Okay &= WriteScenarioLimitedDependency(output, Ver, pkgset, false);
488 WriteOkay(Okay, output, "\n");
489 if (Progress != NULL && p % 100 == 0)
490 Progress->Progress(p);
491 }
492 }
493 if (Progress != NULL)
494 Progress->Done();
495 return Okay;
496}
497 /*}}}*/
498// EDSP::WriteRequest - to the given file descriptor /*{{{*/
499bool EDSP::WriteRequest(pkgDepCache &Cache, FILE* output, bool const Upgrade,
500 bool const DistUpgrade, bool const AutoRemove,
501 OpProgress *Progress)
502{
503 if (Progress != NULL)
504 Progress->SubProgress(Cache.Head().PackageCount, _("Send request to solver"));
505 unsigned long p = 0;
506 string del, inst;
507 for (pkgCache::PkgIterator Pkg = Cache.PkgBegin(); Pkg.end() == false; ++Pkg, ++p)
508 {
509 if (Progress != NULL && p % 100 == 0)
510 Progress->Progress(p);
511 string* req;
512 pkgDepCache::StateCache &P = Cache[Pkg];
513 if (P.Delete() == true)
514 req = &del;
515 else if (P.NewInstall() == true || P.Upgrade() == true || P.ReInstall() == true ||
516 (P.Mode == pkgDepCache::ModeKeep && (P.iFlags & pkgDepCache::Protected) == pkgDepCache::Protected))
517 req = &inst;
518 else
519 continue;
520 req->append(" ").append(Pkg.FullName());
521 }
522 fprintf(output, "Request: EDSP 0.5\n");
523
524 const char *arch = _config->Find("APT::Architecture").c_str();
525 std::vector<string> archs = APT::Configuration::getArchitectures();
526 fprintf(output, "Architecture: %s\n", arch);
527 fprintf(output, "Architectures:");
528 for (std::vector<string>::const_iterator a = archs.begin(); a != archs.end(); ++a)
529 fprintf(output, " %s", a->c_str());
530 fprintf(output, "\n");
531
532 if (del.empty() == false)
533 fprintf(output, "Remove: %s\n", del.c_str()+1);
534 if (inst.empty() == false)
535 fprintf(output, "Install: %s\n", inst.c_str()+1);
536 if (Upgrade == true)
537 fprintf(output, "Upgrade: yes\n");
538 if (DistUpgrade == true)
539 fprintf(output, "Dist-Upgrade: yes\n");
540 if (AutoRemove == true)
541 fprintf(output, "Autoremove: yes\n");
542 auto const solver = _config->Find("APT::Solver", "internal");
543 fprintf(output, "Solver: %s\n", solver.c_str());
544 auto const solverconf = std::string("APT::Solver::") + solver + "::";
545 if (_config->FindB(solverconf + "Strict-Pinning", _config->FindB("APT::Solver::Strict-Pinning", true)) == false)
546 fprintf(output, "Strict-Pinning: no\n");
547 auto const solverpref = _config->Find(solverconf + "Preferences", _config->Find("APT::Solver::Preferences", ""));
548 if (solverpref.empty() == false)
549 fprintf(output, "Preferences: %s\n", solverpref.c_str());
550 fprintf(output, "\n");
551 return true;
552}
553bool EDSP::WriteRequest(pkgDepCache &Cache, FileFd &output,
554 unsigned int const flags,
555 OpProgress *Progress)
556{
557 if (Progress != NULL)
558 Progress->SubProgress(Cache.Head().PackageCount, _("Send request to solver"));
559 unsigned long p = 0;
560 string del, inst;
561 for (pkgCache::PkgIterator Pkg = Cache.PkgBegin(); Pkg.end() == false; ++Pkg, ++p)
562 {
563 if (Progress != NULL && p % 100 == 0)
564 Progress->Progress(p);
565 string* req;
566 pkgDepCache::StateCache &P = Cache[Pkg];
567 if (P.Delete() == true)
568 req = &del;
569 else if (P.NewInstall() == true || P.Upgrade() == true || P.ReInstall() == true ||
570 (P.Mode == pkgDepCache::ModeKeep && (P.iFlags & pkgDepCache::Protected) == pkgDepCache::Protected))
571 req = &inst;
572 else
573 continue;
574 req->append(" ").append(Pkg.FullName());
575 }
576 bool Okay = WriteOkay(output, "Request: EDSP 0.5\n");
577
578 const char *arch = _config->Find("APT::Architecture").c_str();
579 std::vector<string> archs = APT::Configuration::getArchitectures();
580 WriteOkay(Okay, output, "Architecture: ", arch, "\n",
581 "Architectures:");
582 for (std::vector<string>::const_iterator a = archs.begin(); a != archs.end(); ++a)
583 WriteOkay(Okay, output, " ", *a);
584 WriteOkay(Okay, output, "\n");
585
586 if (del.empty() == false)
587 WriteOkay(Okay, output, "Remove:", del, "\n");
588 if (inst.empty() == false)
589 WriteOkay(Okay, output, "Install:", inst, "\n");
590 if (flags & Request::AUTOREMOVE)
591 WriteOkay(Okay, output, "Autoremove: yes\n");
592 if (flags & Request::UPGRADE_ALL)
593 {
594 WriteOkay(Okay, output, "Upgrade-All: yes\n");
595 if (flags & (Request::FORBID_NEW_INSTALL | Request::FORBID_REMOVE))
596 WriteOkay(Okay, output, "Upgrade: yes\n");
597 else
598 WriteOkay(Okay, output, "Dist-Upgrade: yes\n");
599 }
600 if (flags & Request::FORBID_NEW_INSTALL)
601 WriteOkay(Okay, output, "Forbid-New-Install: yes\n");
602 if (flags & Request::FORBID_REMOVE)
603 WriteOkay(Okay, output, "Forbid-Remove: yes\n");
604 auto const solver = _config->Find("APT::Solver", "internal");
605 WriteOkay(Okay, output, "Solver: ", solver, "\n");
606 if (_config->FindB("APT::Solver::Strict-Pinning", true) == false)
607 WriteOkay(Okay, output, "Strict-Pinning: no\n");
608 string solverpref("APT::Solver::");
609 solverpref.append(solver).append("::Preferences");
610 if (_config->Exists(solverpref) == true)
611 WriteOkay(Okay, output, "Preferences: ", _config->Find(solverpref,""), "\n");
612 return WriteOkay(Okay, output, "\n");
613}
614 /*}}}*/
615// EDSP::ReadResponse - from the given file descriptor /*{{{*/
616bool EDSP::ReadResponse(int const input, pkgDepCache &Cache, OpProgress *Progress) {
617 /* We build an map id to mmap offset here
618 In theory we could use the offset as ID, but then VersionCount
619 couldn't be used to create other versionmappings anymore and it
620 would be too easy for a (buggy) solver to segfault APT… */
621 unsigned long long const VersionCount = Cache.Head().VersionCount;
622 unsigned long VerIdx[VersionCount];
623 for (pkgCache::PkgIterator P = Cache.PkgBegin(); P.end() == false; ++P) {
624 for (pkgCache::VerIterator V = P.VersionList(); V.end() == false; ++V)
625 VerIdx[V->ID] = V.Index();
626 Cache[P].Marked = true;
627 Cache[P].Garbage = false;
628 }
629
630 FileFd in;
631 in.OpenDescriptor(input, FileFd::ReadOnly, true);
632 pkgTagFile response(&in, 100);
633 pkgTagSection section;
634
635 std::set<decltype(Cache.PkgBegin()->ID)> seenOnce;
636 while (response.Step(section) == true) {
637 std::string type;
638 if (section.Exists("Install") == true)
639 type = "Install";
640 else if (section.Exists("Remove") == true)
641 type = "Remove";
642 else if (section.Exists("Progress") == true) {
643 if (Progress != NULL) {
644 string msg = section.FindS("Message");
645 if (msg.empty() == true)
646 msg = _("Prepare for receiving solution");
647 Progress->SubProgress(100, msg, section.FindI("Percentage", 0));
648 }
649 continue;
650 } else if (section.Exists("Error") == true) {
651 std::string msg = SubstVar(SubstVar(section.FindS("Message"), "\n .\n", "\n\n"), "\n ", "\n");
652 if (msg.empty() == true) {
653 msg = _("External solver failed without a proper error message");
654 _error->Error("%s", msg.c_str());
655 } else
656 _error->Error("External solver failed with: %s", msg.substr(0,msg.find('\n')).c_str());
657 if (Progress != NULL)
658 Progress->Done();
659 std::cerr << "The solver encountered an error of type: " << section.FindS("Error") << std::endl;
660 std::cerr << "The following information might help you to understand what is wrong:" << std::endl;
661 std::cerr << msg << std::endl << std::endl;
662 return false;
663 } else if (section.Exists("Autoremove") == true)
664 type = "Autoremove";
665 else {
666 char const *Start, *End;
667 section.GetSection(Start, End);
668 _error->Warning("Encountered an unexpected section with %d fields: %s", section.Count(), std::string(Start, End).c_str());
669 continue;
670 }
671
672 size_t const id = section.FindULL(type.c_str(), VersionCount);
673 if (id == VersionCount) {
674 _error->Warning("Unable to parse %s request with id value '%s'!", type.c_str(), section.FindS(type.c_str()).c_str());
675 continue;
676 } else if (id > Cache.Head().VersionCount) {
677 _error->Warning("ID value '%s' in %s request stanza is to high to refer to a known version!", section.FindS(type.c_str()).c_str(), type.c_str());
678 continue;
679 }
680
681 pkgCache::VerIterator Ver(Cache.GetCache(), Cache.GetCache().VerP + VerIdx[id]);
682 auto const Pkg = Ver.ParentPkg();
683 if (type == "Autoremove") {
684 Cache[Pkg].Marked = false;
685 Cache[Pkg].Garbage = true;
686 } else if (seenOnce.emplace(Pkg->ID).second == false) {
687 _error->Warning("Ignoring %s stanza received for package %s which already had a previous stanza effecting it!", type.c_str(), Pkg.FullName(false).c_str());
688 } else if (type == "Install") {
689 if (Pkg.CurrentVer() == Ver) {
690 _error->Warning("Ignoring Install stanza received for version %s of package %s which is already installed!",
691 Ver.VerStr(), Pkg.FullName(false).c_str());
692 } else {
693 Cache.SetCandidateVersion(Ver);
694 Cache.MarkInstall(Pkg, false, 0, false);
695 }
696 } else if (type == "Remove") {
697 if (Pkg->CurrentVer == 0)
698 _error->Warning("Ignoring Remove stanza received for version %s of package %s which isn't installed!",
699 Ver.VerStr(), Pkg.FullName(false).c_str());
700 else if (Pkg.CurrentVer() != Ver)
701 _error->Warning("Ignoring Remove stanza received for version %s of package %s which isn't the installed version %s!",
702 Ver.VerStr(), Pkg.FullName(false).c_str(), Pkg.CurrentVer().VerStr());
703 else
704 Cache.MarkDelete(Ver.ParentPkg(), false);
705 }
706 }
707 return true;
708}
709 /*}}}*/
710// ReadLine - first line from the given file descriptor /*{{{*/
711// ---------------------------------------------------------------------
712/* Little helper method to read a complete line into a string. Similar to
713 fgets but we need to use the low-level read() here as otherwise the
714 listparser will be confused later on as mixing of fgets and read isn't
715 a supported action according to the manpages and results are undefined */
716static bool ReadLine(int const input, std::string &line) {
717 char one;
718 ssize_t data = 0;
719 line.erase();
720 line.reserve(100);
721 while ((data = read(input, &one, sizeof(one))) != -1) {
722 if (data != 1)
723 continue;
724 if (one == '\n')
725 return true;
726 if (one == '\r')
727 continue;
728 if (line.empty() == true && isblank(one) != 0)
729 continue;
730 line += one;
731 }
732 return false;
733}
734 /*}}}*/
735// StringToBool - convert yes/no to bool /*{{{*/
736// ---------------------------------------------------------------------
737/* we are not as lazy as we are in the global StringToBool as we really
738 only accept yes/no here */
739static bool localStringToBool(std::string answer, bool const defValue) {
740 std::transform(answer.begin(), answer.end(), answer.begin(), ::tolower);
741 if (answer == "yes")
742 return true;
743 else if (answer == "no")
744 return false;
745 else
746 _error->Warning("Value '%s' is not a boolean 'yes' or 'no'!", answer.c_str());
747 return defValue;
748}
749 /*}}}*/
750static bool LineStartsWithAndStrip(std::string &line, APT::StringView const with)/*{{{*/
751{
752 if (line.compare(0, with.size(), with.data()) != 0)
753 return false;
754 line = APT::String::Strip(line.substr(with.length()));
755 return true;
756}
757 /*}}}*/
758static bool ReadFlag(unsigned int &flags, std::string &line, APT::StringView const name, unsigned int const setflag)/*{{{*/
759{
760 if (LineStartsWithAndStrip(line, name) == false)
761 return false;
762 if (localStringToBool(line, false))
763 flags |= setflag;
764 else
765 flags &= ~setflag;
766 return true;
767}
768 /*}}}*/
769// EDSP::ReadRequest - first stanza from the given file descriptor /*{{{*/
770bool EDSP::ReadRequest(int const input, std::list<std::string> &install,
771 std::list<std::string> &remove, unsigned int &flags)
772{
773 install.clear();
774 remove.clear();
775 flags = 0;
776 std::string line;
777 while (ReadLine(input, line) == true)
778 {
779 // Skip empty lines before request
780 if (line.empty() == true)
781 continue;
782 // The first Tag must be a request, so search for it
783 if (LineStartsWithAndStrip(line, "Request:"))
784 continue;
785
786 while (ReadLine(input, line) == true)
787 {
788 // empty lines are the end of the request
789 if (line.empty() == true)
790 return true;
791
792 std::list<std::string> *request = NULL;
793 if (LineStartsWithAndStrip(line, "Install:"))
794 request = &install;
795 else if (LineStartsWithAndStrip(line, "Remove:"))
796 request = &remove;
797 else if (ReadFlag(flags, line, "Upgrade:", (Request::UPGRADE_ALL | Request::FORBID_REMOVE | Request::FORBID_NEW_INSTALL)) ||
798 ReadFlag(flags, line, "Dist-Upgrade:", Request::UPGRADE_ALL) ||
799 ReadFlag(flags, line, "Upgrade-All:", Request::UPGRADE_ALL) ||
800 ReadFlag(flags, line, "Forbid-New-Install:", Request::FORBID_NEW_INSTALL) ||
801 ReadFlag(flags, line, "Forbid-Remove:", Request::FORBID_REMOVE) ||
802 ReadFlag(flags, line, "Autoremove:", Request::AUTOREMOVE))
803 ;
804 else if (LineStartsWithAndStrip(line, "Architecture:"))
805 _config->Set("APT::Architecture", line);
806 else if (LineStartsWithAndStrip(line, "Architectures:"))
807 _config->Set("APT::Architectures", SubstVar(line, " ", ","));
808 else if (LineStartsWithAndStrip(line, "Solver:"))
809 ; // purely informational line
810 else
811 _error->Warning("Unknown line in EDSP Request stanza: %s", line.c_str());
812
813 if (request == NULL)
814 continue;
815 auto const pkgs = VectorizeString(line, ' ');
816 std::move(pkgs.begin(), pkgs.end(), std::back_inserter(*request));
817 }
818 }
819 return false;
820}
821bool EDSP::ReadRequest(int const input, std::list<std::string> &install,
822 std::list<std::string> &remove, bool &upgrade,
823 bool &distUpgrade, bool &autoRemove)
824{
825 unsigned int flags;
826 auto const ret = ReadRequest(input, install, remove, flags);
827 autoRemove = (flags & Request::AUTOREMOVE);
828 if (flags & Request::UPGRADE_ALL)
829 {
830 if (flags & (Request::FORBID_NEW_INSTALL | Request::FORBID_REMOVE))
831 {
832 upgrade = true;
833 distUpgrade = false;
834 } else {
835 upgrade = false;
836 distUpgrade = false;
837 }
838 }
839 else
840 {
841 upgrade = false;
842 distUpgrade = false;
843 }
844 return ret;
845}
846 /*}}}*/
847// EDSP::ApplyRequest - first stanza from the given file descriptor /*{{{*/
848bool EDSP::ApplyRequest(std::list<std::string> const &install,
849 std::list<std::string> const &remove,
850 pkgDepCache &Cache)
851{
852 for (std::list<std::string>::const_iterator i = install.begin();
853 i != install.end(); ++i) {
854 pkgCache::PkgIterator P = Cache.FindPkg(*i);
855 if (P.end() == true)
856 _error->Warning("Package %s is not known, so can't be installed", i->c_str());
857 else
858 Cache.MarkInstall(P, false);
859 }
860
861 for (std::list<std::string>::const_iterator i = remove.begin();
862 i != remove.end(); ++i) {
863 pkgCache::PkgIterator P = Cache.FindPkg(*i);
864 if (P.end() == true)
865 _error->Warning("Package %s is not known, so can't be installed", i->c_str());
866 else
867 Cache.MarkDelete(P);
868 }
869 return true;
870}
871 /*}}}*/
872// EDSP::WriteSolutionStanza - to the given file descriptor /*{{{*/
873bool EDSP::WriteSolution(pkgDepCache &Cache, FILE* output)
874{
875 bool const Debug = _config->FindB("Debug::EDSP::WriteSolution", false);
876 for (pkgCache::PkgIterator Pkg = Cache.PkgBegin(); Pkg.end() == false; ++Pkg)
877 {
878 if (Cache[Pkg].Delete() == true)
879 {
880 fprintf(output, "Remove: %d\n", _system->GetVersionMapping(Pkg.CurrentVer()->ID));
881 if (Debug == true)
882 fprintf(output, "Package: %s\nVersion: %s\n", Pkg.FullName().c_str(), Pkg.CurrentVer().VerStr());
883 }
884 else if (Cache[Pkg].NewInstall() == true || Cache[Pkg].Upgrade() == true)
885 {
886 pkgCache::VerIterator const CandVer = Cache.GetCandidateVersion(Pkg);
887 fprintf(output, "Install: %d\n", _system->GetVersionMapping(CandVer->ID));
888 if (Debug == true)
889 fprintf(output, "Package: %s\nVersion: %s\n", Pkg.FullName().c_str(), CandVer.VerStr());
890 }
891 else if (Cache[Pkg].Garbage == true)
892 {
893 fprintf(output, "Autoremove: %d\n", _system->GetVersionMapping(Pkg.CurrentVer()->ID));
894 if (Debug == true)
895 fprintf(output, "Package: %s\nVersion: %s\n", Pkg.FullName().c_str(), Pkg.CurrentVer().VerStr());
896 }
897 else
898 continue;
899 fprintf(output, "\n");
900 }
901
902 return true;
903}
904bool EDSP::WriteSolutionStanza(FileFd &output, char const * const Type, pkgCache::VerIterator const &Ver)
905{
906 bool Okay = output.Failed() == false;
907 WriteOkay(Okay, output, Type, ": ", _system->GetVersionMapping(Ver->ID));
908 if (_config->FindB("Debug::EDSP::WriteSolution", false) == true)
909 WriteOkay(Okay, output, "\nPackage: ", Ver.ParentPkg().FullName(), "\nVersion: ", Ver.VerStr());
910 return WriteOkay(Okay, output, "\n\n");
911}
912 /*}}}*/
913// EDSP::WriteProgess - pulse to the given file descriptor /*{{{*/
914bool EDSP::WriteProgress(unsigned short const percent, const char* const message, FILE* output) {
915 fprintf(output, "Progress: %s\n", TimeRFC1123(time(NULL), true).c_str());
916 fprintf(output, "Percentage: %d\n", percent);
917 fprintf(output, "Message: %s\n\n", message);
918 fflush(output);
919 return true;
920}
921bool EDSP::WriteProgress(unsigned short const percent, const char* const message, FileFd &output) {
922 return WriteOkay(output, "Progress: ", TimeRFC1123(time(NULL), true), "\n",
923 "Percentage: ", percent, "\n",
924 "Message: ", message, "\n\n") && output.Flush();
925}
926 /*}}}*/
927// EDSP::WriteError - format an error message to be send to file descriptor /*{{{*/
928bool EDSP::WriteError(char const * const uuid, std::string const &message, FILE* output) {
929 fprintf(output, "Error: %s\n", uuid);
930 fprintf(output, "Message: %s\n\n", SubstVar(SubstVar(message, "\n\n", "\n.\n"), "\n", "\n ").c_str());
931 return true;
932}
933bool EDSP::WriteError(char const * const uuid, std::string const &message, FileFd &output) {
934 return WriteOkay(output, "Error: ", uuid, "\n",
935 "Message: ", SubstVar(SubstVar(message, "\n\n", "\n.\n"), "\n", "\n "),
936 "\n\n");
937}
938 /*}}}*/
939static std::string findExecutable(std::vector<std::string> const &dirs, char const * const binary) {/*{{{*/
940 for (auto && dir : dirs) {
941 std::string const file = flCombine(dir, binary);
942 if (RealFileExists(file) == true)
943 return file;
944 }
945 return "";
946}
947 /*}}}*/
948static pid_t ExecuteExternal(char const* const type, char const * const binary, char const * const configdir, int * const solver_in, int * const solver_out) {/*{{{*/
949 auto const solverDirs = _config->FindVector(configdir);
950 auto const file = findExecutable(solverDirs, binary);
951 std::string dumper;
952 {
953 dumper = findExecutable(solverDirs, "apt-dump-solver");
954 if (dumper.empty())
955 dumper = findExecutable(solverDirs, "dump");
956 }
957
958 if (file.empty() == true)
959 {
960 _error->Error("Can't call external %s '%s' as it is not in a configured directory!", type, binary);
961 return 0;
962 }
963 int external[4] = {-1, -1, -1, -1};
964 if (pipe(external) != 0 || pipe(external + 2) != 0)
965 {
966 _error->Errno("Resolve", "Can't create needed IPC pipes for EDSP");
967 return 0;
968 }
969 for (int i = 0; i < 4; ++i)
970 SetCloseExec(external[i], true);
971
972 pid_t Solver = ExecFork();
973 if (Solver == 0) {
974 dup2(external[0], STDIN_FILENO);
975 dup2(external[3], STDOUT_FILENO);
976 auto const dumpfile = _config->FindFile((std::string("Dir::Log::") + type).c_str());
977 auto const dumpdir = flNotFile(dumpfile);
978 auto const runasuser = _config->Find(std::string("APT::") + type + "::" + binary + "::RunAsUser",
979 _config->Find(std::string("APT::") + type + "::RunAsUser",
980 _config->Find("APT::Sandbox::User")));
981 if (dumper.empty() || dumpfile.empty() || dumper == file || CreateAPTDirectoryIfNeeded(dumpdir, dumpdir) == false)
982 {
983 _config->Set("APT::Sandbox::User", runasuser);
984 DropPrivileges();
985 char const * const calling[] = { file.c_str(), nullptr };
986 execv(calling[0], const_cast<char**>(calling));
987 }
988 else
989 {
990 char const * const calling[] = { dumper.c_str(), "--user", runasuser.c_str(), dumpfile.c_str(), file.c_str(), nullptr };
991 execv(calling[0], const_cast<char**>(calling));
992 }
993 std::cerr << "Failed to execute " << type << " '" << binary << "'!" << std::endl;
994 _exit(100);
995 }
996 close(external[0]);
997 close(external[3]);
998
999 if (WaitFd(external[1], true, 5) == false)
1000 {
1001 _error->Errno("Resolve", "Timed out while Waiting on availability of %s stdin", type);
1002 return 0;
1003 }
1004
1005 *solver_in = external[1];
1006 *solver_out = external[2];
1007 return Solver;
1008}
1009 /*}}}*/
1010// EDSP::ExecuteSolver - fork requested solver and setup ipc pipes {{{*/
1011pid_t EDSP::ExecuteSolver(const char* const solver, int * const solver_in, int * const solver_out, bool) {
1012 return ExecuteExternal("solver", solver, "Dir::Bin::Solvers", solver_in, solver_out);
1013}
1014bool EDSP::ExecuteSolver(const char* const solver, int *solver_in, int *solver_out) {
1015 if (ExecuteSolver(solver, solver_in, solver_out, true) == 0)
1016 return false;
1017 return true;
1018}
1019 /*}}}*/
1020static bool CreateDumpFile(char const * const id, char const * const type, FileFd &output)/*{{{*/
1021{
1022 auto const dumpfile = _config->FindFile((std::string("Dir::Log::") + type).c_str());
1023 if (dumpfile.empty())
1024 return false;
1025 auto const dumpdir = flNotFile(dumpfile);
1026 _error->PushToStack();
1027 bool errored_out = CreateAPTDirectoryIfNeeded(dumpdir, dumpdir) == false ||
1028 output.Open(dumpfile, FileFd::WriteOnly | FileFd::Exclusive | FileFd::Create, FileFd::Extension, 0644) == false;
1029 std::vector<std::string> downgrademsgs;
1030 while (_error->empty() == false)
1031 {
1032 std::string msg;
1033 _error->PopMessage(msg);
1034 downgrademsgs.emplace_back(std::move(msg));
1035 }
1036 _error->RevertToStack();
1037 for (auto && msg : downgrademsgs)
1038 _error->Warning("%s", msg.c_str());
1039 if (errored_out)
1040 return _error->WarningE(id, _("Could not open file '%s'"), dumpfile.c_str());
1041 return true;
1042}
1043 /*}}}*/
1044// EDSP::ResolveExternal - resolve problems by asking external for help {{{*/
1045bool EDSP::ResolveExternal(const char* const solver, pkgDepCache &Cache,
1046 unsigned int const flags, OpProgress *Progress) {
1047 if (strcmp(solver, "internal") == 0)
1048 {
1049 FileFd output;
1050 bool Okay = CreateDumpFile("EDSP::Resolve", "solver", output);
1051 Okay &= EDSP::WriteRequest(Cache, output, flags, nullptr);
1052 return Okay && EDSP::WriteScenario(Cache, output, nullptr);
1053 }
1054 int solver_in, solver_out;
1055 pid_t const solver_pid = EDSP::ExecuteSolver(solver, &solver_in, &solver_out, true);
1056 if (solver_pid == 0)
1057 return false;
1058
1059 FileFd output;
1060 if (output.OpenDescriptor(solver_in, FileFd::WriteOnly | FileFd::BufferedWrite, true) == false)
1061 return _error->Errno("ResolveExternal", "Opening solver %s stdin on fd %d for writing failed", solver, solver_in);
1062
1063 bool Okay = output.Failed() == false;
1064 if (Okay && Progress != NULL)
1065 Progress->OverallProgress(0, 100, 5, _("Execute external solver"));
1066 Okay &= EDSP::WriteRequest(Cache, output, flags, Progress);
1067 if (Okay && Progress != NULL)
1068 Progress->OverallProgress(5, 100, 20, _("Execute external solver"));
1069 Okay &= EDSP::WriteScenario(Cache, output, Progress);
1070 output.Close();
1071
1072 if (Okay && Progress != NULL)
1073 Progress->OverallProgress(25, 100, 75, _("Execute external solver"));
1074 if (Okay && EDSP::ReadResponse(solver_out, Cache, Progress) == false)
1075 return false;
1076
1077 bool const waited = ExecWait(solver_pid, solver);
1078 return Okay && waited;
1079}
1080bool EDSP::ResolveExternal(const char* const solver, pkgDepCache &Cache,
1081 bool const upgrade, bool const distUpgrade,
1082 bool const autoRemove, OpProgress *Progress) {
1083 unsigned int flags = 0;
1084 if (autoRemove)
1085 flags |= Request::AUTOREMOVE;
1086 if (upgrade)
1087 flags |= Request::UPGRADE_ALL | Request::FORBID_REMOVE | Request::FORBID_NEW_INSTALL;
1088 if (distUpgrade)
1089 flags |= Request::UPGRADE_ALL;
1090 return ResolveExternal(solver, Cache, flags, Progress);
1091}
1092 /*}}}*/
1093
1094bool EIPP::OrderInstall(char const * const solver, pkgPackageManager * const PM, /*{{{*/
1095 unsigned int const flags, OpProgress * const Progress)
1096{
1097 if (strcmp(solver, "internal") == 0)
1098 {
1099 FileFd output;
1100 _error->PushToStack();
1101 bool Okay = CreateDumpFile("EIPP::OrderInstall", "planner", output);
1102 if (Okay == false && dynamic_cast<pkgSimulate*>(PM) != nullptr)
1103 {
1104 _error->RevertToStack();
1105 return false;
1106 }
1107 _error->MergeWithStack();
1108 Okay &= EIPP::WriteRequest(PM->Cache, output, flags, nullptr);
1109 return Okay && EIPP::WriteScenario(PM->Cache, output, nullptr);
1110 }
1111
1112 int solver_in, solver_out;
1113 pid_t const solver_pid = ExecuteExternal("planner", solver, "Dir::Bin::Planners", &solver_in, &solver_out);
1114 if (solver_pid == 0)
1115 return false;
1116
1117 FileFd output;
1118 if (output.OpenDescriptor(solver_in, FileFd::WriteOnly | FileFd::BufferedWrite, true) == false)
1119 return _error->Errno("EIPP::OrderInstall", "Opening planner %s stdin on fd %d for writing failed", solver, solver_in);
1120
1121 bool Okay = output.Failed() == false;
1122 if (Okay && Progress != NULL)
1123 Progress->OverallProgress(0, 100, 5, _("Execute external planner"));
1124 Okay &= EIPP::WriteRequest(PM->Cache, output, flags, Progress);
1125 if (Okay && Progress != NULL)
1126 Progress->OverallProgress(5, 100, 20, _("Execute external planner"));
1127 Okay &= EIPP::WriteScenario(PM->Cache, output, Progress);
1128 output.Close();
1129
1130 if (Okay)
1131 {
1132 if (Progress != nullptr)
1133 Progress->OverallProgress(25, 100, 75, _("Execute external planner"));
1134
1135 // we don't tell the external planners about boring things
1136 for (auto Pkg = PM->Cache.PkgBegin(); Pkg.end() == false; ++Pkg)
1137 {
1138 if (Pkg->CurrentState == pkgCache::State::ConfigFiles && PM->Cache[Pkg].Purge() == true)
1139 PM->Remove(Pkg, true);
1140 }
1141 }
1142
1143 if (EIPP::ReadResponse(solver_out, PM, Progress) == false)
1144 return false;
1145
1146 bool const waited = ExecWait(solver_pid, solver);
1147 return Okay && waited;
1148}
1149 /*}}}*/
1150bool EIPP::WriteRequest(pkgDepCache &Cache, FileFd &output, /*{{{*/
1151 unsigned int const flags,
1152 OpProgress * const Progress)
1153{
1154 if (Progress != NULL)
1155 Progress->SubProgress(Cache.Head().PackageCount, _("Send request to planner"));
1156 unsigned long p = 0;
1157 string del, inst, reinst;
1158 for (pkgCache::PkgIterator Pkg = Cache.PkgBegin(); Pkg.end() == false; ++Pkg, ++p)
1159 {
1160 if (Progress != NULL && p % 100 == 0)
1161 Progress->Progress(p);
1162 string* req;
1163 pkgDepCache::StateCache &P = Cache[Pkg];
1164 if (P.Purge() == true && Pkg->CurrentState == pkgCache::State::ConfigFiles)
1165 continue;
1166 if (P.Delete() == true)
1167 req = &del;
1168 else if (P.NewInstall() == true || P.Upgrade() == true || P.Downgrade() == true)
1169 req = &inst;
1170 else if (P.ReInstall() == true)
1171 req = &reinst;
1172 else
1173 continue;
1174 req->append(" ").append(Pkg.FullName());
1175 }
1176 bool Okay = WriteOkay(output, "Request: EIPP 0.1\n");
1177
1178 const char *arch = _config->Find("APT::Architecture").c_str();
1179 std::vector<string> archs = APT::Configuration::getArchitectures();
1180 WriteOkay(Okay, output, "Architecture: ", arch, "\n",
1181 "Architectures:");
1182 for (std::vector<string>::const_iterator a = archs.begin(); a != archs.end(); ++a)
1183 WriteOkay(Okay, output, " ", *a);
1184 WriteOkay(Okay, output, "\n");
1185
1186 if (del.empty() == false)
1187 WriteOkay(Okay, output, "Remove:", del, "\n");
1188 if (inst.empty() == false)
1189 WriteOkay(Okay, output, "Install:", inst, "\n");
1190 if (reinst.empty() == false)
1191 WriteOkay(Okay, output, "ReInstall:", reinst, "\n");
1192 WriteOkay(Okay, output, "Planner: ", _config->Find("APT::Planner", "internal"), "\n");
1193 if ((flags & Request::IMMEDIATE_CONFIGURATION_ALL) != 0)
1194 WriteOkay(Okay, output, "Immediate-Configuration: yes\n");
1195 else if ((flags & Request::NO_IMMEDIATE_CONFIGURATION) != 0)
1196 WriteOkay(Okay, output, "Immediate-Configuration: no\n");
1197 else if ((flags & Request::ALLOW_TEMPORARY_REMOVE_OF_ESSENTIALS) != 0)
1198 WriteOkay(Okay, output, "Allow-Temporary-Remove-of-Essentials: yes\n");
1199 return WriteOkay(Okay, output, "\n");
1200}
1201 /*}}}*/
1202static bool WriteScenarioEIPPVersion(pkgDepCache &, FileFd &output, pkgCache::PkgIterator const &Pkg,/*{{{*/
1203 pkgCache::VerIterator const &Ver)
1204{
1205 bool Okay = true;
1206 if (Pkg.CurrentVer() == Ver)
1207 switch (Pkg->CurrentState)
1208 {
1209 case pkgCache::State::NotInstalled: WriteOkay(Okay, output, "\nStatus: not-installed"); break;
1210 case pkgCache::State::ConfigFiles: WriteOkay(Okay, output, "\nStatus: config-files"); break;
1211 case pkgCache::State::HalfInstalled: WriteOkay(Okay, output, "\nStatus: half-installed"); break;
1212 case pkgCache::State::UnPacked: WriteOkay(Okay, output, "\nStatus: unpacked"); break;
1213 case pkgCache::State::HalfConfigured: WriteOkay(Okay, output, "\nStatus: half-configured"); break;
1214 case pkgCache::State::TriggersAwaited: WriteOkay(Okay, output, "\nStatus: triggers-awaited"); break;
1215 case pkgCache::State::TriggersPending: WriteOkay(Okay, output, "\nStatus: triggers-pending"); break;
1216 case pkgCache::State::Installed: WriteOkay(Okay, output, "\nStatus: installed"); break;
1217 }
1218 return Okay;
1219}
1220 /*}}}*/
1221// EIPP::WriteScenario - to the given file descriptor /*{{{*/
1222template<typename forVersion> void forAllInterestingVersions(pkgDepCache &Cache, pkgCache::PkgIterator const &Pkg, forVersion const &func)
1223{
1224 if (Pkg->CurrentState == pkgCache::State::NotInstalled)
1225 {
1226 auto P = Cache[Pkg];
1227 if (P.Install() == false)
1228 return;
1229 func(Pkg, P.InstVerIter(Cache));
1230 }
1231 else
1232 {
1233 if (Pkg->CurrentVer != 0)
1234 func(Pkg, Pkg.CurrentVer());
1235 auto P = Cache[Pkg];
1236 auto const V = P.InstVerIter(Cache);
1237 if (P.Delete() == false && Pkg.CurrentVer() != V)
1238 func(Pkg, V);
1239 }
1240}
1241
1242bool EIPP::WriteScenario(pkgDepCache &Cache, FileFd &output, OpProgress * const Progress)
1243{
1244 if (Progress != NULL)
1245 Progress->SubProgress(Cache.Head().PackageCount, _("Send scenario to planner"));
1246 unsigned long p = 0;
1247 bool Okay = output.Failed() == false;
1248 std::vector<std::string> archs = APT::Configuration::getArchitectures();
1249 std::vector<bool> pkgset(Cache.Head().PackageCount, false);
1250 auto const MarkVersion = [&](pkgCache::PkgIterator const &Pkg, pkgCache::VerIterator const &Ver) {
1251 pkgset[Pkg->ID] = true;
1252 for (auto D = Ver.DependsList(); D.end() == false; ++D)
1253 {
1254 if (D.IsCritical() == false)
1255 continue;
1256 auto const P = D.TargetPkg();
1257 for (auto Prv = P.ProvidesList(); Prv.end() == false; ++Prv)
1258 {
1259 auto const V = Prv.OwnerVer();
1260 auto const PV = V.ParentPkg();
1261 if (V == PV.CurrentVer() || V == Cache[PV].InstVerIter(Cache))
1262 pkgset[PV->ID] = true;
1263 }
1264 pkgset[P->ID] = true;
1265 if (strcmp(P.Arch(), "any") == 0)
1266 {
1267 APT::StringView const pkgname(P.Name());
1268 auto const idxColon = pkgname.find(':');
1269 if (idxColon != APT::StringView::npos)
1270 {
1271 pkgCache::PkgIterator PA;
1272 if (pkgname.substr(idxColon + 1) == "any")
1273 {
1274 auto const GA = Cache.FindGrp(pkgname.substr(0, idxColon).to_string());
1275 for (auto PA = GA.PackageList(); PA.end() == false; PA = GA.NextPkg(PA))
1276 {
1277 pkgset[PA->ID] = true;
1278 }
1279 }
1280 else
1281 {
1282 auto const PA = Cache.FindPkg(pkgname.to_string());
1283 if (PA.end() == false)
1284 pkgset[PA->ID] = true;
1285 }
1286 }
1287 }
1288 else
1289 {
1290 auto const PA = Cache.FindPkg(P.FullName(false), "any");
1291 if (PA.end() == false)
1292 pkgset[PA->ID] = true;
1293 }
1294 }
1295 };
1296 for (pkgCache::PkgIterator Pkg = Cache.PkgBegin(); Pkg.end() == false; ++Pkg)
1297 forAllInterestingVersions(Cache, Pkg, MarkVersion);
1298 auto const WriteVersion = [&](pkgCache::PkgIterator const &Pkg, pkgCache::VerIterator const &Ver) {
1299 Okay &= WriteScenarioVersion(output, Pkg, Ver);
1300 Okay &= WriteScenarioEIPPVersion(Cache, output, Pkg, Ver);
1301 Okay &= WriteScenarioLimitedDependency(output, Ver, pkgset, true);
1302 WriteOkay(Okay, output, "\n");
1303 if (Progress != NULL && p % 100 == 0)
1304 Progress->Progress(p);
1305 };
1306 for (pkgCache::PkgIterator Pkg = Cache.PkgBegin(); Pkg.end() == false && likely(Okay); ++Pkg, ++p)
1307 {
1308 if (pkgset[Pkg->ID] == false || Pkg->VersionList == 0)
1309 continue;
1310 forAllInterestingVersions(Cache, Pkg, WriteVersion);
1311 }
1312 return Okay;
1313}
1314 /*}}}*/
1315// EIPP::ReadResponse - from the given file descriptor /*{{{*/
1316bool EIPP::ReadResponse(int const input, pkgPackageManager * const PM, OpProgress *Progress) {
1317 /* We build an map id to mmap offset here
1318 In theory we could use the offset as ID, but then VersionCount
1319 couldn't be used to create other versionmappings anymore and it
1320 would be too easy for a (buggy) solver to segfault APT… */
1321 unsigned long long const VersionCount = PM->Cache.Head().VersionCount;
1322 unsigned long VerIdx[VersionCount];
1323 for (pkgCache::PkgIterator P = PM->Cache.PkgBegin(); P.end() == false; ++P) {
1324 for (pkgCache::VerIterator V = P.VersionList(); V.end() == false; ++V)
1325 VerIdx[V->ID] = V.Index();
1326 }
1327
1328 FileFd in;
1329 in.OpenDescriptor(input, FileFd::ReadOnly);
1330 pkgTagFile response(&in, 100);
1331 pkgTagSection section;
1332
1333 while (response.Step(section) == true) {
1334 char const * type = nullptr;
1335 if (section.Exists("Progress") == true) {
1336 if (Progress != NULL) {
1337 string msg = section.FindS("Message");
1338 if (msg.empty() == true)
1339 msg = _("Prepare for receiving solution");
1340 Progress->SubProgress(100, msg, section.FindI("Percentage", 0));
1341 }
1342 continue;
1343 } else if (section.Exists("Error") == true) {
1344 std::string msg = SubstVar(SubstVar(section.FindS("Message"), "\n .\n", "\n\n"), "\n ", "\n");
1345 if (msg.empty() == true) {
1346 msg = _("External planner failed without a proper error message");
1347 _error->Error("%s", msg.c_str());
1348 } else
1349 _error->Error("External planner failed with: %s", msg.substr(0,msg.find('\n')).c_str());
1350 if (Progress != NULL)
1351 Progress->Done();
1352 std::cerr << "The planner encountered an error of type: " << section.FindS("Error") << std::endl;
1353 std::cerr << "The following information might help you to understand what is wrong:" << std::endl;
1354 std::cerr << msg << std::endl << std::endl;
1355 return false;
1356 } else if (section.Exists("Unpack") == true)
1357 type = "Unpack";
1358 else if (section.Exists("Configure") == true)
1359 type = "Configure";
1360 else if (section.Exists("Remove") == true)
1361 type = "Remove";
1362 else {
1363 char const *Start, *End;
1364 section.GetSection(Start, End);
1365 _error->Warning("Encountered an unexpected section with %d fields: %s", section.Count(), std::string(Start, End).c_str());
1366 continue;
1367 }
1368
1369 if (type == nullptr)
1370 continue;
1371 size_t const id = section.FindULL(type, VersionCount);
1372 if (id == VersionCount) {
1373 _error->Warning("Unable to parse %s request with id value '%s'!", type, section.FindS(type).c_str());
1374 continue;
1375 } else if (id > PM->Cache.Head().VersionCount) {
1376 _error->Warning("ID value '%s' in %s request stanza is to high to refer to a known version!", section.FindS(type).c_str(), type);
1377 continue;
1378 }
1379
1380 pkgCache::VerIterator Ver(PM->Cache.GetCache(), PM->Cache.GetCache().VerP + VerIdx[id]);
1381 auto const Pkg = Ver.ParentPkg();
1382 if (strcmp(type, "Unpack") == 0)
1383 PM->Install(Pkg, PM->FileNames[Pkg->ID]);
1384 else if (strcmp(type, "Configure") == 0)
1385 PM->Configure(Pkg);
1386 else if (strcmp(type, "Remove") == 0)
1387 PM->Remove(Pkg, PM->Cache[Pkg].Purge());
1388 }
1389 return in.Failed() == false;
1390}
1391 /*}}}*/
1392bool EIPP::ReadRequest(int const input, std::list<std::pair<std::string,PKG_ACTION>> &actions,/*{{{*/
1393 unsigned int &flags)
1394{
1395 actions.clear();
1396 flags = 0;
1397 std::string line;
1398 while (ReadLine(input, line) == true)
1399 {
1400 // Skip empty lines before request
1401 if (line.empty() == true)
1402 continue;
1403 // The first Tag must be a request, so search for it
1404 if (line.compare(0, 8, "Request:") != 0)
1405 continue;
1406
1407 while (ReadLine(input, line) == true)
1408 {
1409 // empty lines are the end of the request
1410 if (line.empty() == true)
1411 return true;
1412
1413 PKG_ACTION pkgact = PKG_ACTION::NOOP;
1414 if (LineStartsWithAndStrip(line, "Install:"))
1415 pkgact = PKG_ACTION::INSTALL;
1416 else if (LineStartsWithAndStrip(line, "ReInstall:"))
1417 pkgact = PKG_ACTION::REINSTALL;
1418 else if (LineStartsWithAndStrip(line, "Remove:"))
1419 pkgact = PKG_ACTION::REMOVE;
1420 else if (LineStartsWithAndStrip(line, "Architecture:"))
1421 _config->Set("APT::Architecture", line);
1422 else if (LineStartsWithAndStrip(line, "Architectures:"))
1423 _config->Set("APT::Architectures", SubstVar(line, " ", ","));
1424 else if (LineStartsWithAndStrip(line, "Planner:"))
1425 ; // purely informational line
1426 else if (LineStartsWithAndStrip(line, "Immediate-Configuration:"))
1427 {
1428 if (localStringToBool(line, true))
1429 flags |= Request::IMMEDIATE_CONFIGURATION_ALL;
1430 else
1431 flags |= Request::NO_IMMEDIATE_CONFIGURATION;
1432 }
1433 else if (ReadFlag(flags, line, "Allow-Temporary-Remove-of-Essentials:", Request::ALLOW_TEMPORARY_REMOVE_OF_ESSENTIALS))
1434 ;
1435 else
1436 _error->Warning("Unknown line in EIPP Request stanza: %s", line.c_str());
1437
1438 if (pkgact == PKG_ACTION::NOOP)
1439 continue;
1440 for (auto && p: VectorizeString(line, ' '))
1441 actions.emplace_back(std::move(p), pkgact);
1442 }
1443 }
1444 return false;
1445}
1446 /*}}}*/
1447bool EIPP::ApplyRequest(std::list<std::pair<std::string,PKG_ACTION>> &actions,/*{{{*/
1448 pkgDepCache &Cache)
1449{
1450 for (auto Pkg = Cache.PkgBegin(); Pkg.end() == false; ++Pkg)
1451 {
1452 short versions = 0;
1453 for (auto Ver = Pkg.VersionList(); Ver.end() == false; ++Ver)
1454 {
1455 ++versions;
1456 if (Pkg.CurrentVer() == Ver)
1457 continue;
1458 Cache.SetCandidateVersion(Ver);
1459 }
1460 if (unlikely(versions > 2))
1461 _error->Warning("Package %s has %d versions, but should have at most 2!", Pkg.FullName().c_str(), versions);
1462 }
1463 for (auto && a: actions)
1464 {
1465 pkgCache::PkgIterator P = Cache.FindPkg(a.first);
1466 if (P.end() == true)
1467 {
1468 _error->Warning("Package %s is not known, so can't be acted on", a.first.c_str());
1469 continue;
1470 }
1471 switch (a.second)
1472 {
1473 case PKG_ACTION::NOOP:
1474 _error->Warning("Package %s has NOOP as action?!?", a.first.c_str());
1475 break;
1476 case PKG_ACTION::INSTALL:
1477 Cache.MarkInstall(P, false);
1478 break;
1479 case PKG_ACTION::REINSTALL:
1480 Cache.MarkInstall(P, false);
1481 Cache.SetReInstall(P, true);
1482 break;
1483 case PKG_ACTION::REMOVE:
1484 Cache.MarkDelete(P);
1485 break;
1486 }
1487 }
1488 return true;
1489}
1490 /*}}}*/
APT (for Cydia)