]> git.saurik.com Git - apt.git/blame - apt-pkg/edsp.cc
projects / apt.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
eipp: rename stanza 'Install' to 'Unpack'
[apt.git] / apt-pkg / edsp.cc
CommitLineData
6d38011b
DK		 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 /*{{{*/
ea542140
DK		 8#include <config.h>
9
6d38011b 10#include <apt-pkg/error.h>
472ff00e 11#include <apt-pkg/cacheset.h>
453b82a3
DK		 12#include <apt-pkg/depcache.h>
13#include <apt-pkg/pkgcache.h>
14#include <apt-pkg/cacheiterators.h>
f74d99c6
DK		 15#include <apt-pkg/prettyprinters.h>
16#include <apt-pkg/packagemanager.h>
ac7f8f79
MV		 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>
0b661a5c 22#include <apt-pkg/string_view.h>
307d9eb2 23#include <apt-pkg/pkgsystem.h>
6d38011b 24
3a487cc0 25#include <sys/stat.h>
453b82a3
DK		 26#include <ctype.h>
27#include <stddef.h>
28#include <string.h>
453b82a3 29#include <unistd.h>
6d38011b 30#include <stdio.h>
a6f8c07f
DK		 31
32#include <array>
453b82a3 33#include <limits>
472ff00e
DK		 34#include <string>
35
ea542140 36#include <apti18n.h>
6d38011b
DK		 37 /*}}}*/
38
472ff00e
DK		 39using std::string;
40
d4f626ff 41// we could use pkgCache::DepType and ::Priority, but these would be localized strings…
a6f8c07f
DK		 42constexpr char const * const PrioMap[] = {
43 nullptr, "important", "required", "standard",
44 "optional", "extra"
45};
46constexpr char const * const DepMap[] = {
47 nullptr, "Depends", "Pre-Depends", "Suggests",
48 "Recommends" , "Conflicts", "Replaces",
49 "Obsoletes", "Breaks", "Enhances"
50};
d4f626ff 51
4e92b116
DK		 52// WriteOkay - varaidic helper to easily Write to a FileFd /*{{{*/
53static bool WriteOkay_fn(FileFd &) { return true; }
54template<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}
58template<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}
64template<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}
69template<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 /*}}}*/
c8a4ce6c
DK		 75// WriteScenarioVersion /*{{{*/
76static void WriteScenarioVersion(pkgDepCache &Cache, FILE* output, pkgCache::PkgIterator const &Pkg,
d4f626ff
DK		 77 pkgCache::VerIterator const &Ver)
78{
79 fprintf(output, "Package: %s\n", Pkg.Name());
a221efc3 80 fprintf(output, "Source: %s\n", Ver.SourcePkgName());
d4f626ff
DK		 81 fprintf(output, "Architecture: %s\n", Ver.Arch());
82 fprintf(output, "Version: %s\n", Ver.VerStr());
eed4639e 83 fprintf(output, "Source-Version: %s\n", Ver.SourceVerStr());
d4f626ff
DK		 84 if (Pkg.CurrentVer() == Ver)
85 fprintf(output, "Installed: yes\n");
cbc702ea
DK		 86 if (Pkg->SelectedState == pkgCache::State::Hold ||
87 (Cache[Pkg].Keep() == true && Cache[Pkg].Protect() == true))
d4f626ff
DK		 88 fprintf(output, "Hold: yes\n");
89 fprintf(output, "APT-ID: %d\n", Ver->ID);
ef00bd7a
DK		 90 if (PrioMap[Ver->Priority] != nullptr)
91 fprintf(output, "Priority: %s\n", PrioMap[Ver->Priority]);
d4f626ff
DK		 92 if ((Pkg->Flags & pkgCache::Flag::Essential) == pkgCache::Flag::Essential)
93 fprintf(output, "Essential: yes\n");
ef00bd7a
DK		 94 if (Ver->Section != 0)
95 fprintf(output, "Section: %s\n", Ver.Section());
894d672e 96 if ((Ver->MultiArch & pkgCache::Version::Allowed) == pkgCache::Version::Allowed)
d4f626ff 97 fprintf(output, "Multi-Arch: allowed\n");
894d672e 98 else if ((Ver->MultiArch & pkgCache::Version::Foreign) == pkgCache::Version::Foreign)
d4f626ff 99 fprintf(output, "Multi-Arch: foreign\n");
894d672e 100 else if ((Ver->MultiArch & pkgCache::Version::Same) == pkgCache::Version::Same)
d4f626ff 101 fprintf(output, "Multi-Arch: same\n");
b5ea5d4a
SZ		 102 std::set<string> Releases;
103 for (pkgCache::VerFileIterator I = Ver.FileList(); I.end() == false; ++I) {
104 pkgCache::PkgFileIterator File = I.File();
b07aeb1a 105 if (File.Flagged(pkgCache::Flag::NotSource) == false) {
b5ea5d4a
SZ		 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());
d4f626ff 115 }
3c7567a5 116 fprintf(output, "APT-Pin: %d\n", Cache.GetPolicy().GetPriority(Ver));
294a8020 117 if (Cache.GetCandidateVersion(Pkg) == Ver)
d4f626ff
DK		 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");
ef00bd7a 121}
5caf35a7 122static bool WriteScenarioVersion(FileFd &output, pkgCache::PkgIterator const &Pkg,
ef00bd7a
DK		 123 pkgCache::VerIterator const &Ver)
124{
4e92b116 125 bool Okay = WriteOkay(output, "Package: ", Pkg.Name(),
4e92b116 126 "\nArchitecture: ", Ver.Arch(),
5caf35a7 127 "\nVersion: ", Ver.VerStr());
4e92b116 128 WriteOkay(Okay, output, "\nAPT-ID: ", Ver->ID);
ef00bd7a 129 if ((Pkg->Flags & pkgCache::Flag::Essential) == pkgCache::Flag::Essential)
4e92b116 130 WriteOkay(Okay, output, "\nEssential: yes");
ef00bd7a 131 if ((Ver->MultiArch & pkgCache::Version::Allowed) == pkgCache::Version::Allowed)
4e92b116 132 WriteOkay(Okay, output, "\nMulti-Arch: allowed");
ef00bd7a 133 else if ((Ver->MultiArch & pkgCache::Version::Foreign) == pkgCache::Version::Foreign)
4e92b116 134 WriteOkay(Okay, output, "\nMulti-Arch: foreign");
ef00bd7a 135 else if ((Ver->MultiArch & pkgCache::Version::Same) == pkgCache::Version::Same)
4e92b116 136 WriteOkay(Okay, output, "\nMulti-Arch: same");
ef00bd7a 137 return Okay;
d4f626ff
DK		 138}
139 /*}}}*/
c8a4ce6c
DK		 140// WriteScenarioDependency /*{{{*/
141static void WriteScenarioDependency( FILE* output, pkgCache::VerIterator const &Ver)
d4f626ff 142{
a6f8c07f 143 std::array<std::string, _count(DepMap)> dependencies;
d4f626ff
DK		 144 bool orGroup = false;
145 for (pkgCache::DepIterator Dep = Ver.DependsList(); Dep.end() == false; ++Dep)
146 {
8c7af4d4 147 if (Dep.IsImplicit() == true)
d4f626ff
DK		 148 continue;
149 if (orGroup == false)
150 dependencies[Dep->Type].append(", ");
3addaba1 151 dependencies[Dep->Type].append(Dep.TargetPkg().Name());
d4f626ff
DK		 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 }
a6f8c07f 162 for (size_t i = 1; i < dependencies.size(); ++i)
d4f626ff
DK		 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 {
d5648746 168 if (Prv.IsMultiArchImplicit() == true)
d4f626ff 169 continue;
ef00bd7a
DK		 170 if (provides.empty() == false)
171 provides.append(", ");
172 provides.append(Prv.Name());
2c53226b
DK		 173 if (Prv->ProvideVersion != 0)
174 provides.append(" (= ").append(Prv.ProvideVersion()).append(")");
d4f626ff
DK		 175 }
176 if (provides.empty() == false)
ef00bd7a
DK		 177 fprintf(output, "Provides: %s\n", provides.c_str());
178}
5caf35a7 179static bool WriteScenarioDependency(FileFd &output, pkgCache::VerIterator const &Ver, bool const OnlyCritical)
ef00bd7a 180{
a6f8c07f 181 std::array<std::string, _count(DepMap)> dependencies;
ef00bd7a
DK		 182 bool orGroup = false;
183 for (pkgCache::DepIterator Dep = Ver.DependsList(); Dep.end() == false; ++Dep)
184 {
185 if (Dep.IsImplicit() == true)
186 continue;
5caf35a7
DK		 187 if (OnlyCritical && Dep.IsCritical() == false)
188 continue;
ef00bd7a
DK		 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 }
4e92b116 202 bool Okay = output.Failed() == false;
a6f8c07f 203 for (size_t i = 1; i < dependencies.size(); ++i)
ef00bd7a 204 if (dependencies[i].empty() == false)
4e92b116 205 WriteOkay(Okay, output, "\n", DepMap[i], ": ", dependencies[i]);
ef00bd7a
DK		 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)
4e92b116
DK		 218 WriteOkay(Okay, output, "\nProvides: ", provides);
219 return WriteOkay(Okay, output, "\n");
d4f626ff
DK		 220}
221 /*}}}*/
c8a4ce6c
DK		 222// WriteScenarioLimitedDependency /*{{{*/
223static void WriteScenarioLimitedDependency(FILE* output,
d4f626ff
DK		 224 pkgCache::VerIterator const &Ver,
225 APT::PackageSet const &pkgset)
226{
a6f8c07f 227 std::array<std::string, _count(DepMap)> dependencies;
d4f626ff
DK		 228 bool orGroup = false;
229 for (pkgCache::DepIterator Dep = Ver.DependsList(); Dep.end() == false; ++Dep)
230 {
8c7af4d4 231 if (Dep.IsImplicit() == true)
d4f626ff
DK		 232 continue;
233 if (orGroup == false)
234 {
235 if (pkgset.find(Dep.TargetPkg()) == pkgset.end())
236 continue;
ef00bd7a
DK		 237 if (dependencies[Dep->Type].empty() == false)
238 dependencies[Dep->Type].append(", ");
d4f626ff
DK		 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 }
3addaba1 248 dependencies[Dep->Type].append(Dep.TargetPkg().Name());
d4f626ff
DK		 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 }
a6f8c07f 259 for (size_t i = 1; i < dependencies.size(); ++i)
d4f626ff 260 if (dependencies[i].empty() == false)
ef00bd7a 261 fprintf(output, "%s: %s\n", DepMap[i], dependencies[i].c_str());
d4f626ff
DK		 262 string provides;
263 for (pkgCache::PrvIterator Prv = Ver.ProvidesList(); Prv.end() == false; ++Prv)
264 {
d5648746 265 if (Prv.IsMultiArchImplicit() == true)
d4f626ff
DK		 266 continue;
267 if (pkgset.find(Prv.ParentPkg()) == pkgset.end())
268 continue;
ef00bd7a
DK		 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(")");
d4f626ff
DK		 274 }
275 if (provides.empty() == false)
ef00bd7a
DK		 276 fprintf(output, "Provides: %s\n", provides.c_str());
277}
278static bool WriteScenarioLimitedDependency(FileFd &output,
279 pkgCache::VerIterator const &Ver,
5caf35a7
DK		 280 std::vector<bool> const &pkgset,
281 bool const OnlyCritical)
ef00bd7a 282{
a6f8c07f 283 std::array<std::string, _count(DepMap)> dependencies;
ef00bd7a
DK		 284 bool orGroup = false;
285 for (pkgCache::DepIterator Dep = Ver.DependsList(); Dep.end() == false; ++Dep)
286 {
287 if (Dep.IsImplicit() == true)
288 continue;
5caf35a7
DK		 289 if (OnlyCritical && Dep.IsCritical() == false)
290 continue;
ef00bd7a
DK		 291 if (orGroup == false)
292 {
6dcae298 293 if (pkgset[Dep.TargetPkg()->ID] == false)
ef00bd7a
DK		 294 continue;
295 if (dependencies[Dep->Type].empty() == false)
296 dependencies[Dep->Type].append(", ");
297 }
6dcae298 298 else if (pkgset[Dep.TargetPkg()->ID] == false)
ef00bd7a
DK		 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 }
4e92b116 317 bool Okay = output.Failed() == false;
a6f8c07f 318 for (size_t i = 1; i < dependencies.size(); ++i)
ef00bd7a 319 if (dependencies[i].empty() == false)
4e92b116 320 WriteOkay(Okay, output, "\n", DepMap[i], ": ", dependencies[i]);
ef00bd7a
DK		 321 string provides;
322 for (pkgCache::PrvIterator Prv = Ver.ProvidesList(); Prv.end() == false; ++Prv)
323 {
324 if (Prv.IsMultiArchImplicit() == true)
325 continue;
6dcae298 326 if (pkgset[Prv.ParentPkg()->ID] == false)
ef00bd7a
DK		 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)
4e92b116
DK		 335 WriteOkay(Okay, output, "\nProvides: ", provides);
336 return WriteOkay(Okay, output, "\n");
d4f626ff
DK		 337}
338 /*}}}*/
33190fe3
DK		 339static 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 /*}}}*/
5caf35a7
DK		 357static 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 /*}}}*/
c8a4ce6c
DK		 393// EDSP::WriteScenario - to the given file descriptor /*{{{*/
394bool 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 {
33190fe3
DK		 407 if (SkipUnavailableVersions(Cache, Pkg, Ver))
408 continue;
c8a4ce6c
DK		 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;
ef00bd7a
DK		 417}
418bool 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;
4e92b116 423 bool Okay = output.Failed() == false;
ef00bd7a 424 std::vector<std::string> archs = APT::Configuration::getArchitectures();
4e92b116 425 for (pkgCache::PkgIterator Pkg = Cache.PkgBegin(); Pkg.end() == false && likely(Okay); ++Pkg)
ef00bd7a
DK		 426 {
427 std::string const arch = Pkg.Arch();
428 if (std::find(archs.begin(), archs.end(), arch) == archs.end())
429 continue;
4e92b116 430 for (pkgCache::VerIterator Ver = Pkg.VersionList(); Ver.end() == false && likely(Okay); ++Ver, ++p)
ef00bd7a
DK		 431 {
432 if (SkipUnavailableVersions(Cache, Pkg, Ver))
433 continue;
5caf35a7
DK		 434 Okay &= WriteScenarioVersion(output, Pkg, Ver);
435 Okay &= WriteScenarioEDSPVersion(Cache, output, Pkg, Ver);
436 Okay &= WriteScenarioDependency(output, Ver, false);
4e92b116 437 WriteOkay(Okay, output, "\n");
ef00bd7a
DK		 438 if (Progress != NULL && p % 100 == 0)
439 Progress->Progress(p);
440 }
441 }
442 return true;
c8a4ce6c
DK		 443}
444 /*}}}*/
445// EDSP::WriteLimitedScenario - to the given file descriptor /*{{{*/
446bool 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 {
33190fe3
DK		 456 if (SkipUnavailableVersions(Cache, Pkg, Ver))
457 continue;
c8a4ce6c
DK		 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;
ef00bd7a
DK		 467}
468bool EDSP::WriteLimitedScenario(pkgDepCache &Cache, FileFd &output,
6dcae298 469 std::vector<bool> const &pkgset,
ef00bd7a
DK		 470 OpProgress *Progress)
471{
472 if (Progress != NULL)
473 Progress->SubProgress(Cache.Head().VersionCount, _("Send scenario to solver"));
474 unsigned long p = 0;
4e92b116 475 bool Okay = output.Failed() == false;
6dcae298
DK		 476 for (auto Pkg = Cache.PkgBegin(); Pkg.end() == false && likely(Okay); ++Pkg, ++p)
477 {
478 if (pkgset[Pkg->ID] == false)
479 continue;
4e92b116 480 for (pkgCache::VerIterator Ver = Pkg.VersionList(); Ver.end() == false && likely(Okay); ++Ver)
ef00bd7a
DK		 481 {
482 if (SkipUnavailableVersions(Cache, Pkg, Ver))
483 continue;
5caf35a7
DK		 484 Okay &= WriteScenarioVersion(output, Pkg, Ver);
485 Okay &= WriteScenarioEDSPVersion(Cache, output, Pkg, Ver);
486 Okay &= WriteScenarioLimitedDependency(output, Ver, pkgset, false);
4e92b116 487 WriteOkay(Okay, output, "\n");
ef00bd7a
DK		 488 if (Progress != NULL && p % 100 == 0)
489 Progress->Progress(p);
490 }
6dcae298 491 }
ef00bd7a
DK		 492 if (Progress != NULL)
493 Progress->Done();
494 return Okay;
c8a4ce6c
DK		 495}
496 /*}}}*/
c3b85126 497// EDSP::WriteRequest - to the given file descriptor /*{{{*/
93794bc9 498bool EDSP::WriteRequest(pkgDepCache &Cache, FILE* output, bool const Upgrade,
b57c0e35
DK		 499 bool const DistUpgrade, bool const AutoRemove,
500 OpProgress *Progress)
6d38011b 501{
b57c0e35
DK		 502 if (Progress != NULL)
503 Progress->SubProgress(Cache.Head().PackageCount, _("Send request to solver"));
504 unsigned long p = 0;
93794bc9 505 string del, inst;
b57c0e35 506 for (pkgCache::PkgIterator Pkg = Cache.PkgBegin(); Pkg.end() == false; ++Pkg, ++p)
6d38011b 507 {
b57c0e35
DK		 508 if (Progress != NULL && p % 100 == 0)
509 Progress->Progress(p);
6d38011b 510 string* req;
036eb012
DK		 511 pkgDepCache::StateCache &P = Cache[Pkg];
512 if (P.Delete() == true)
6d38011b 513 req = &del;
036eb012
DK		 514 else if (P.NewInstall() == true || P.Upgrade() == true || P.ReInstall() == true ||
515 (P.Mode == pkgDepCache::ModeKeep && (P.iFlags & pkgDepCache::Protected) == pkgDepCache::Protected))
6d38011b 516 req = &inst;
6d38011b
DK		 517 else
518 continue;
6d5bd614 519 req->append(" ").append(Pkg.FullName());
6d38011b 520 }
25252738 521 fprintf(output, "Request: EDSP 0.5\n");
caa32793
SZ		 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
6d38011b 531 if (del.empty() == false)
6d5bd614 532 fprintf(output, "Remove: %s\n", del.c_str()+1);
6d38011b 533 if (inst.empty() == false)
6d5bd614 534 fprintf(output, "Install: %s\n", inst.c_str()+1);
93794bc9
DK		 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");
eb1000f6
DK		 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)
93794bc9 545 fprintf(output, "Strict-Pinning: no\n");
eb1000f6
DK		 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());
6d5bd614 549 fprintf(output, "\n");
e3674d91 550 return true;
ef00bd7a 551}
43c71fad
DK		 552bool EDSP::WriteRequest(pkgDepCache &Cache, FileFd &output,
553 unsigned int const flags,
ef00bd7a
DK		 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 }
4e92b116 575 bool Okay = WriteOkay(output, "Request: EDSP 0.5\n");
ef00bd7a
DK		 576
577 const char *arch = _config->Find("APT::Architecture").c_str();
578 std::vector<string> archs = APT::Configuration::getArchitectures();
4e92b116
DK		 579 WriteOkay(Okay, output, "Architecture: ", arch, "\n",
580 "Architectures:");
ef00bd7a 581 for (std::vector<string>::const_iterator a = archs.begin(); a != archs.end(); ++a)
4e92b116
DK		 582 WriteOkay(Okay, output, " ", *a);
583 WriteOkay(Okay, output, "\n");
ef00bd7a
DK		 584
585 if (del.empty() == false)
4e92b116 586 WriteOkay(Okay, output, "Remove:", del, "\n");
ef00bd7a 587 if (inst.empty() == false)
4e92b116 588 WriteOkay(Okay, output, "Install:", inst, "\n");
43c71fad 589 if (flags & Request::AUTOREMOVE)
4e92b116 590 WriteOkay(Okay, output, "Autoremove: yes\n");
43c71fad
DK		 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");
385d9f2f
DK		 603 auto const solver = _config->Find("APT::Solver", "internal");
604 WriteOkay(Okay, output, "Solver: ", solver, "\n");
ef00bd7a 605 if (_config->FindB("APT::Solver::Strict-Pinning", true) == false)
4e92b116 606 WriteOkay(Okay, output, "Strict-Pinning: no\n");
ef00bd7a 607 string solverpref("APT::Solver::");
385d9f2f 608 solverpref.append(solver).append("::Preferences");
ef00bd7a 609 if (_config->Exists(solverpref) == true)
4e92b116
DK		 610 WriteOkay(Okay, output, "Preferences: ", _config->Find(solverpref,""), "\n");
611 return WriteOkay(Okay, output, "\n");
e3674d91
DK		 612}
613 /*}}}*/
2029276f 614// EDSP::ReadResponse - from the given file descriptor /*{{{*/
b57c0e35 615bool EDSP::ReadResponse(int const input, pkgDepCache &Cache, OpProgress *Progress) {
2a33cb16
DK		 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];
76d4aab0 622 for (pkgCache::PkgIterator P = Cache.PkgBegin(); P.end() == false; ++P) {
2a33cb16
DK		 623 for (pkgCache::VerIterator V = P.VersionList(); V.end() == false; ++V)
624 VerIdx[V->ID] = V.Index();
76d4aab0
DK		 625 Cache[P].Marked = true;
626 Cache[P].Garbage = false;
627 }
2a33cb16 628
c80a49f5 629 FileFd in;
2202a8a0 630 in.OpenDescriptor(input, FileFd::ReadOnly, true);
288a76d2 631 pkgTagFile response(&in, 100);
c80a49f5
DK		 632 pkgTagSection section;
633
90e7fba4 634 std::set<decltype(Cache.PkgBegin()->ID)> seenOnce;
2029276f
DK		 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";
e876223c 641 else if (section.Exists("Progress") == true) {
b57c0e35 642 if (Progress != NULL) {
c6660a4b 643 string msg = section.FindS("Message");
b57c0e35 644 if (msg.empty() == true)
c6660a4b
DK		 645 msg = _("Prepare for receiving solution");
646 Progress->SubProgress(100, msg, section.FindI("Percentage", 0));
b57c0e35 647 }
e876223c 648 continue;
ebfeeaed 649 } else if (section.Exists("Error") == true) {
27c69dd0
DK		 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");
a1e68c33 653 _error->Error("%s", msg.c_str());
27c69dd0
DK		 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();
ebfeeaed
DK		 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;
27c69dd0
DK		 660 std::cerr << msg << std::endl << std::endl;
661 return false;
76d4aab0
DK		 662 } else if (section.Exists("Autoremove") == true)
663 type = "Autoremove";
f74d99c6
DK		 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());
2029276f 668 continue;
f74d99c6 669 }
29099cb6 670
2a33cb16
DK		 671 size_t const id = section.FindULL(type.c_str(), VersionCount);
672 if (id == VersionCount) {
69a78835
DK		 673 _error->Warning("Unable to parse %s request with id value '%s'!", type.c_str(), section.FindS(type.c_str()).c_str());
674 continue;
2a33cb16
DK		 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;
69a78835 678 }
2029276f 679
2a33cb16 680 pkgCache::VerIterator Ver(Cache.GetCache(), Cache.GetCache().VerP + VerIdx[id]);
90e7fba4
DK		 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);
76d4aab0 704 }
2029276f
DK		 705 }
706 return true;
707}
708 /*}}}*/
c8a4ce6c 709// ReadLine - first line from the given file descriptor /*{{{*/
6d5bd614
DK		 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
2029276f 714 a supported action according to the manpages and results are undefined */
c8a4ce6c 715static bool ReadLine(int const input, std::string &line) {
6d5bd614
DK		 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 /*}}}*/
c8a4ce6c 734// StringToBool - convert yes/no to bool /*{{{*/
40795fca
DK		 735// ---------------------------------------------------------------------
736/* we are not as lazy as we are in the global StringToBool as we really
0b661a5c
DK		 737 only accept yes/no here */
738static bool localStringToBool(std::string answer, bool const defValue) {
739 std::transform(answer.begin(), answer.end(), answer.begin(), ::tolower);
740 if (answer == "yes")
40795fca 741 return true;
0b661a5c 742 else if (answer == "no")
40795fca
DK		 743 return false;
744 else
0b661a5c 745 _error->Warning("Value '%s' is not a boolean 'yes' or 'no'!", answer.c_str());
40795fca
DK		 746 return defValue;
747}
748 /*}}}*/
0b661a5c 749static bool LineStartsWithAndStrip(std::string &line, APT::StringView const with)/*{{{*/
43c71fad 750{
0b661a5c 751 if (line.compare(0, with.size(), with.data()) != 0)
43c71fad 752 return false;
0b661a5c
DK		 753 line = APT::String::Strip(line.substr(with.length()));
754 return true;
755}
756 /*}}}*/
757static 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))
43c71fad
DK		 762 flags |= setflag;
763 else
764 flags &= ~setflag;
765 return true;
766}
5caf35a7
DK		 767 /*}}}*/
768// EDSP::ReadRequest - first stanza from the given file descriptor /*{{{*/
6d5bd614 769bool EDSP::ReadRequest(int const input, std::list<std::string> &install,
43c71fad 770 std::list<std::string> &remove, unsigned int &flags)
6d5bd614 771{
40795fca
DK		 772 install.clear();
773 remove.clear();
43c71fad 774 flags = 0;
6d5bd614
DK		 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
0b661a5c 782 if (LineStartsWithAndStrip(line, "Request:"))
6d5bd614
DK		 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;
0b661a5c 792 if (LineStartsWithAndStrip(line, "Install:"))
6d5bd614 793 request = &install;
0b661a5c 794 else if (LineStartsWithAndStrip(line, "Remove:"))
6d5bd614 795 request = &remove;
43c71fad
DK		 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 ;
0b661a5c
DK		 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:"))
eb1000f6 808 ; // purely informational line
40795fca
DK		 809 else
810 _error->Warning("Unknown line in EDSP Request stanza: %s", line.c_str());
811
6d5bd614
DK		 812 if (request == NULL)
813 continue;
0b661a5c
DK		 814 auto const pkgs = VectorizeString(line, ' ');
815 std::move(pkgs.begin(), pkgs.end(), std::back_inserter(*request));
6d5bd614
DK		 816 }
817 }
818 return false;
43c71fad
DK		 819}
820bool 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;
6d5bd614
DK		 844}
845 /*}}}*/
846// EDSP::ApplyRequest - first stanza from the given file descriptor /*{{{*/
c3b85126 847bool EDSP::ApplyRequest(std::list<std::string> const &install,
29099cb6
DK		 848 std::list<std::string> const &remove,
849 pkgDepCache &Cache)
6d5bd614
DK		 850{
851 for (std::list<std::string>::const_iterator i = install.begin();
d4f626ff
DK		 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 }
6d5bd614
DK		 859
860 for (std::list<std::string>::const_iterator i = remove.begin();
d4f626ff
DK		 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 }
6d5bd614
DK		 868 return true;
869}
870 /*}}}*/
71608330 871// EDSP::WriteSolutionStanza - to the given file descriptor /*{{{*/
c3b85126 872bool EDSP::WriteSolution(pkgDepCache &Cache, FILE* output)
e3674d91 873{
6d5bd614 874 bool const Debug = _config->FindB("Debug::EDSP::WriteSolution", false);
e3674d91
DK		 875 for (pkgCache::PkgIterator Pkg = Cache.PkgBegin(); Pkg.end() == false; ++Pkg)
876 {
877 if (Cache[Pkg].Delete() == true)
d4f626ff 878 {
307d9eb2 879 fprintf(output, "Remove: %d\n", _system->GetVersionMapping(Pkg.CurrentVer()->ID));
d4f626ff
DK		 880 if (Debug == true)
881 fprintf(output, "Package: %s\nVersion: %s\n", Pkg.FullName().c_str(), Pkg.CurrentVer().VerStr());
882 }
e3674d91 883 else if (Cache[Pkg].NewInstall() == true || Cache[Pkg].Upgrade() == true)
d4f626ff 884 {
294a8020 885 pkgCache::VerIterator const CandVer = Cache.GetCandidateVersion(Pkg);
307d9eb2 886 fprintf(output, "Install: %d\n", _system->GetVersionMapping(CandVer->ID));
d4f626ff 887 if (Debug == true)
294a8020 888 fprintf(output, "Package: %s\nVersion: %s\n", Pkg.FullName().c_str(), CandVer.VerStr());
d4f626ff 889 }
76d4aab0
DK		 890 else if (Cache[Pkg].Garbage == true)
891 {
307d9eb2 892 fprintf(output, "Autoremove: %d\n", _system->GetVersionMapping(Pkg.CurrentVer()->ID));
76d4aab0
DK		 893 if (Debug == true)
894 fprintf(output, "Package: %s\nVersion: %s\n", Pkg.FullName().c_str(), Pkg.CurrentVer().VerStr());
76d4aab0 895 }
e3674d91
DK		 896 else
897 continue;
e3674d91
DK		 898 fprintf(output, "\n");
899 }
900
6d38011b 901 return true;
ef00bd7a 902}
71608330 903bool EDSP::WriteSolutionStanza(FileFd &output, char const * const Type, pkgCache::VerIterator const &Ver)
ef00bd7a 904{
4e92b116 905 bool Okay = output.Failed() == false;
71608330
DK		 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");
6d38011b
DK		 910}
911 /*}}}*/
e876223c
DK		 912// EDSP::WriteProgess - pulse to the given file descriptor /*{{{*/
913bool EDSP::WriteProgress(unsigned short const percent, const char* const message, FILE* output) {
3d17b9ff
DK		 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);
e876223c 918 return true;
ef00bd7a
DK		 919}
920bool EDSP::WriteProgress(unsigned short const percent, const char* const message, FileFd &output) {
4e92b116
DK		 921 return WriteOkay(output, "Progress: ", TimeRFC1123(time(NULL)), "\n",
922 "Percentage: ", percent, "\n",
923 "Message: ", message, "\n\n") && output.Flush();
e876223c
DK		 924}
925 /*}}}*/
ebfeeaed
DK		 926// EDSP::WriteError - format an error message to be send to file descriptor /*{{{*/
927bool 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;
ef00bd7a
DK		 931}
932bool EDSP::WriteError(char const * const uuid, std::string const &message, FileFd &output) {
4e92b116
DK		 933 return WriteOkay(output, "Error: ", uuid, "\n",
934 "Message: ", SubstVar(SubstVar(message, "\n\n", "\n.\n"), "\n", "\n "),
935 "\n\n");
ebfeeaed
DK		 936}
937 /*}}}*/
385d9f2f
DK		 938static 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 /*}}}*/
5caf35a7 947static pid_t ExecuteExternal(char const* const type, char const * const binary, char const * const configdir, int * const solver_in, int * const solver_out) {/*{{{*/
385d9f2f
DK		 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");
741b7da9 955 }
ac5fbff8 956
741b7da9 957 if (file.empty() == true)
5681b3fc 958 {
5caf35a7 959 _error->Error("Can't call external %s '%s' as it is not in a configured directory!", type, binary);
5681b3fc
DK		 960 return 0;
961 }
741b7da9
DK		 962 int external[4] = {-1, -1, -1, -1};
963 if (pipe(external) != 0 || pipe(external + 2) != 0)
5681b3fc
DK		 964 {
965 _error->Errno("Resolve", "Can't create needed IPC pipes for EDSP");
966 return 0;
967 }
741b7da9
DK		 968 for (int i = 0; i < 4; ++i)
969 SetCloseExec(external[i], true);
ac5fbff8 970
741b7da9
DK		 971 pid_t Solver = ExecFork();
972 if (Solver == 0) {
973 dup2(external[0], STDIN_FILENO);
974 dup2(external[3], STDOUT_FILENO);
385d9f2f
DK		 975 auto const dumpfile = _config->FindFile((std::string("Dir::Log::") + type).c_str());
976 auto const dumpdir = flNotFile(dumpfile);
007d8b48
DK		 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")));
385d9f2f
DK		 980 if (dumper.empty() || dumpfile.empty() || dumper == file || CreateAPTDirectoryIfNeeded(dumpdir, dumpdir) == false)
981 {
007d8b48
DK		 982 _config->Set("APT::Sandbox::User", runasuser);
983 DropPrivileges();
385d9f2f
DK		 984 char const * const calling[] = { file.c_str(), nullptr };
985 execv(calling[0], const_cast<char**>(calling));
986 }
987 else
988 {
007d8b48 989 char const * const calling[] = { dumper.c_str(), "--user", runasuser.c_str(), dumpfile.c_str(), file.c_str(), nullptr };
385d9f2f
DK		 990 execv(calling[0], const_cast<char**>(calling));
991 }
5caf35a7 992 std::cerr << "Failed to execute " << type << " '" << binary << "'!" << std::endl;
741b7da9
DK		 993 _exit(100);
994 }
995 close(external[0]);
996 close(external[3]);
ac5fbff8 997
741b7da9 998 if (WaitFd(external[1], true, 5) == false)
5681b3fc 999 {
5caf35a7 1000 _error->Errno("Resolve", "Timed out while Waiting on availability of %s stdin", type);
5681b3fc
DK		 1001 return 0;
1002 }
ac5fbff8 1003
741b7da9
DK		 1004 *solver_in = external[1];
1005 *solver_out = external[2];
5681b3fc 1006 return Solver;
5caf35a7
DK		 1007}
1008 /*}}}*/
1009// EDSP::ExecuteSolver - fork requested solver and setup ipc pipes {{{*/
1010pid_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);
5681b3fc
DK		 1012}
1013bool 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;
741b7da9
DK		 1017}
1018 /*}}}*/
1019// EDSP::ResolveExternal - resolve problems by asking external for help {{{*/
1020bool EDSP::ResolveExternal(const char* const solver, pkgDepCache &Cache,
43c71fad 1021 unsigned int const flags, OpProgress *Progress) {
3a487cc0
DK		 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 }
741b7da9 1035 int solver_in, solver_out;
5681b3fc
DK		 1036 pid_t const solver_pid = EDSP::ExecuteSolver(solver, &solver_in, &solver_out, true);
1037 if (solver_pid == 0)
741b7da9
DK		 1038 return false;
1039
ef00bd7a
DK		 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);
b57c0e35 1043
4e92b116 1044 bool Okay = output.Failed() == false;
b57c0e35
DK		 1045 if (Progress != NULL)
1046 Progress->OverallProgress(0, 100, 5, _("Execute external solver"));
43c71fad 1047 Okay &= EDSP::WriteRequest(Cache, output, flags, Progress);
b57c0e35
DK		 1048 if (Progress != NULL)
1049 Progress->OverallProgress(5, 100, 20, _("Execute external solver"));
4e92b116 1050 Okay &= EDSP::WriteScenario(Cache, output, Progress);
ef00bd7a 1051 output.Close();
741b7da9 1052
b57c0e35
DK		 1053 if (Progress != NULL)
1054 Progress->OverallProgress(25, 100, 75, _("Execute external solver"));
4e92b116 1055 if (Okay && EDSP::ReadResponse(solver_out, Cache, Progress) == false)
27c69dd0 1056 return false;
741b7da9 1057
5681b3fc 1058 return ExecWait(solver_pid, solver);
43c71fad
DK		 1059}
1060bool 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);
ac5fbff8
DK		 1071}
1072 /*}}}*/
7b197262 1073
f74d99c6 1074bool EIPP::OrderInstall(char const * const solver, pkgPackageManager * const PM, /*{{{*/
7b197262
DK		 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"));
f74d99c6 1089 Okay &= EIPP::WriteRequest(PM->Cache, output, flags, Progress);
7b197262
DK		 1090 if (Progress != NULL)
1091 Progress->OverallProgress(5, 100, 20, _("Execute external planer"));
f74d99c6 1092 Okay &= EIPP::WriteScenario(PM->Cache, output, Progress);
7b197262
DK		 1093 output.Close();
1094
1095 if (Progress != NULL)
1096 Progress->OverallProgress(25, 100, 75, _("Execute external planer"));
4cdc3bf0
DK		 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
f74d99c6 1105 if (Okay && EIPP::ReadResponse(solver_out, PM, Progress) == false)
7b197262
DK		 1106 return false;
1107
1108 return ExecWait(solver_pid, solver);
1109}
1110 /*}}}*/
1111bool EIPP::WriteRequest(pkgDepCache &Cache, FileFd &output, /*{{{*/
1112 unsigned int const flags,
1113 OpProgress * const Progress)
1114{
7b197262
DK		 1115 if (Progress != NULL)
1116 Progress->SubProgress(Cache.Head().PackageCount, _("Send request to planer"));
1117 unsigned long p = 0;
4cdc3bf0 1118 string del, inst, reinst;
7b197262
DK		 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];
4cdc3bf0
DK		 1125 if (P.Purge() == true && Pkg->CurrentState == pkgCache::State::ConfigFiles)
1126 continue;
7b197262
DK		 1127 if (P.Delete() == true)
1128 req = &del;
f74d99c6 1129 else if (P.NewInstall() == true || P.Upgrade() == true || P.Downgrade() == true)
7b197262
DK		 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
7b197262
DK		 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");
a21aca10
DK		 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");
8d1cb6da
DK		 1158 else if ((flags & Request::ALLOW_TEMPORARY_REMOVE_OF_ESSENTIALS) != 0)
1159 WriteOkay(Okay, output, "Allow-Temporary-Remove-of-Essentials: yes\n");
7b197262
DK		 1160 return WriteOkay(Okay, output, "\n");
1161}
1162 /*}}}*/
dae19747 1163static bool WriteScenarioEIPPVersion(pkgDepCache &, FileFd &output, pkgCache::PkgIterator const &Pkg,/*{{{*/
7b197262
DK		 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 }
7b197262
DK		 1179 return Okay;
1180}
1181 /*}}}*/
1182// EIPP::WriteScenario - to the given file descriptor /*{{{*/
dae19747
DK		 1183template<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
7b197262
DK		 1203bool EIPP::WriteScenario(pkgDepCache &Cache, FileFd &output, OpProgress * const Progress)
1204{
1205 if (Progress != NULL)
dae19747 1206 Progress->SubProgress(Cache.Head().PackageCount, _("Send scenario to planer"));
7b197262
DK		 1207 unsigned long p = 0;
1208 bool Okay = output.Failed() == false;
1209 std::vector<std::string> archs = APT::Configuration::getArchitectures();
dae19747
DK		 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)
7b197262 1214 {
dae19747
DK		 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;
14bed2c0
DK		 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 }
7b197262 1255 }
dae19747
DK		 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);
7b197262
DK		 1272 }
1273 return true;
1274}
1275 /*}}}*/
1276// EIPP::ReadResponse - from the given file descriptor /*{{{*/
f74d99c6 1277bool EIPP::ReadResponse(int const input, pkgPackageManager * const PM, OpProgress *Progress) {
7b197262
DK		 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… */
f74d99c6 1282 unsigned long long const VersionCount = PM->Cache.Head().VersionCount;
7b197262 1283 unsigned long VerIdx[VersionCount];
f74d99c6 1284 for (pkgCache::PkgIterator P = PM->Cache.PkgBegin(); P.end() == false; ++P) {
7b197262
DK		 1285 for (pkgCache::VerIterator V = P.VersionList(); V.end() == false; ++V)
1286 VerIdx[V->ID] = V.Index();
1287 }
7b197262
DK		 1288
1289 FileFd in;
1290 in.OpenDescriptor(input, FileFd::ReadOnly);
1291 pkgTagFile response(&in, 100);
1292 pkgTagSection section;
1293
7b197262 1294 while (response.Step(section) == true) {
f74d99c6 1295 char const * type = nullptr;
7b197262
DK		 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;
262fdd8b
DK		 1317 } else if (section.Exists("Unpack") == true)
1318 type = "Unpack";
f74d99c6
DK		 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();
262fdd8b 1343 if (strcmp(type, "Unpack") == 0)
f74d99c6
DK		 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 /*}}}*/
1353bool 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
a21aca10
DK		 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 }
8d1cb6da
DK		 1394 else if (ReadFlag(flags, line, "Allow-Temporary-Remove-of-Essentials:", Request::ALLOW_TEMPORARY_REMOVE_OF_ESSENTIALS))
1395 ;
f74d99c6
DK		 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 /*}}}*/
1411bool 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;
7b197262
DK		 1450 }
1451 }
1452 return true;
1453}
1454 /*}}}*/
APT (for Cydia)