]> git.saurik.com Git - apt.git/blob - apt-pkg/edsp.cc
projects / apt.git / blob
? search:


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