]> git.saurik.com Git - apt.git/blame_incremental - apt-pkg/edsp.cc
projects / apt.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
test framework: More noopchroot fixes
[apt.git] / apt-pkg / edsp.cc
... / ...
CommitLineData
1// -*- mode: cpp; mode: fold -*-
2// Description /*{{{*/
3/* ######################################################################
4 Set of methods to help writing and reading everything needed for EDSP
5 ##################################################################### */
6 /*}}}*/
7// Include Files /*{{{*/
8#include <config.h>
9
10#include <apt-pkg/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/progress.h>
16#include <apt-pkg/fileutl.h>
17#include <apt-pkg/edsp.h>
18#include <apt-pkg/tagfile.h>
19#include <apt-pkg/strutl.h>
20
21#include <ctype.h>
22#include <stddef.h>
23#include <string.h>
24#include <unistd.h>
25#include <stdio.h>
26#include <iostream>
27#include <limits>
28#include <string>
29
30#include <apti18n.h>
31 /*}}}*/
32
33using std::string;
34
35// we could use pkgCache::DepType and ::Priority, but these would be localized strings…
36const char * const PrioMap[] = {0, "important", "required", "standard",
37 "optional", "extra"};
38const char * const DepMap[] = {"", "Depends", "Pre-Depends", "Suggests",
39 "Recommends" , "Conflicts", "Replaces",
40 "Obsoletes", "Breaks", "Enhances"};
41
42
43// WriteScenarioVersion /*{{{*/
44static void WriteScenarioVersion(pkgDepCache &Cache, FILE* output, pkgCache::PkgIterator const &Pkg,
45 pkgCache::VerIterator const &Ver)
46{
47 fprintf(output, "Package: %s\n", Pkg.Name());
48 fprintf(output, "Source: %s\n", Ver.SourcePkgName());
49 fprintf(output, "Architecture: %s\n", Ver.Arch());
50 fprintf(output, "Version: %s\n", Ver.VerStr());
51 fprintf(output, "Source-Version: %s\n", Ver.SourceVerStr());
52 if (Pkg.CurrentVer() == Ver)
53 fprintf(output, "Installed: yes\n");
54 if (Pkg->SelectedState == pkgCache::State::Hold ||
55 (Cache[Pkg].Keep() == true && Cache[Pkg].Protect() == true))
56 fprintf(output, "Hold: yes\n");
57 fprintf(output, "APT-ID: %d\n", Ver->ID);
58 fprintf(output, "Priority: %s\n", PrioMap[Ver->Priority]);
59 if ((Pkg->Flags & pkgCache::Flag::Essential) == pkgCache::Flag::Essential)
60 fprintf(output, "Essential: yes\n");
61 fprintf(output, "Section: %s\n", Ver.Section());
62 if ((Ver->MultiArch & pkgCache::Version::Allowed) == pkgCache::Version::Allowed)
63 fprintf(output, "Multi-Arch: allowed\n");
64 else if ((Ver->MultiArch & pkgCache::Version::Foreign) == pkgCache::Version::Foreign)
65 fprintf(output, "Multi-Arch: foreign\n");
66 else if ((Ver->MultiArch & pkgCache::Version::Same) == pkgCache::Version::Same)
67 fprintf(output, "Multi-Arch: same\n");
68 signed short Pin = std::numeric_limits<signed short>::min();
69 std::set<string> Releases;
70 for (pkgCache::VerFileIterator I = Ver.FileList(); I.end() == false; ++I) {
71 pkgCache::PkgFileIterator File = I.File();
72 signed short const p = Cache.GetPolicy().GetPriority(File);
73 if (Pin < p)
74 Pin = p;
75 if (File.Flagged(pkgCache::Flag::NotSource) == false) {
76 string Release = File.RelStr();
77 if (!Release.empty())
78 Releases.insert(Release);
79 }
80 }
81 if (!Releases.empty()) {
82 fprintf(output, "APT-Release:\n");
83 for (std::set<string>::iterator R = Releases.begin(); R != Releases.end(); ++R)
84 fprintf(output, " %s\n", R->c_str());
85 }
86 fprintf(output, "APT-Pin: %d\n", Pin);
87 if (Cache.GetCandidateVersion(Pkg) == Ver)
88 fprintf(output, "APT-Candidate: yes\n");
89 if ((Cache[Pkg].Flags & pkgCache::Flag::Auto) == pkgCache::Flag::Auto)
90 fprintf(output, "APT-Automatic: yes\n");
91}
92 /*}}}*/
93// WriteScenarioDependency /*{{{*/
94static void WriteScenarioDependency( FILE* output, pkgCache::VerIterator const &Ver)
95{
96 std::string dependencies[pkgCache::Dep::Enhances + 1];
97 bool orGroup = false;
98 for (pkgCache::DepIterator Dep = Ver.DependsList(); Dep.end() == false; ++Dep)
99 {
100 if (Dep.IsImplicit() == true)
101 continue;
102 if (orGroup == false)
103 dependencies[Dep->Type].append(", ");
104 dependencies[Dep->Type].append(Dep.TargetPkg().Name());
105 if (Dep->Version != 0)
106 dependencies[Dep->Type].append(" (").append(pkgCache::CompTypeDeb(Dep->CompareOp)).append(" ").append(Dep.TargetVer()).append(")");
107 if ((Dep->CompareOp & pkgCache::Dep::Or) == pkgCache::Dep::Or)
108 {
109 dependencies[Dep->Type].append(" | ");
110 orGroup = true;
111 }
112 else
113 orGroup = false;
114 }
115 for (int i = 1; i < pkgCache::Dep::Enhances + 1; ++i)
116 if (dependencies[i].empty() == false)
117 fprintf(output, "%s: %s\n", DepMap[i], dependencies[i].c_str()+2);
118 string provides;
119 for (pkgCache::PrvIterator Prv = Ver.ProvidesList(); Prv.end() == false; ++Prv)
120 {
121 if (Prv.IsMultiArchImplicit() == true)
122 continue;
123 provides.append(", ").append(Prv.Name());
124 }
125 if (provides.empty() == false)
126 fprintf(output, "Provides: %s\n", provides.c_str()+2);
127}
128 /*}}}*/
129// WriteScenarioLimitedDependency /*{{{*/
130static void WriteScenarioLimitedDependency(FILE* output,
131 pkgCache::VerIterator const &Ver,
132 APT::PackageSet const &pkgset)
133{
134 std::string dependencies[pkgCache::Dep::Enhances + 1];
135 bool orGroup = false;
136 for (pkgCache::DepIterator Dep = Ver.DependsList(); Dep.end() == false; ++Dep)
137 {
138 if (Dep.IsImplicit() == true)
139 continue;
140 if (orGroup == false)
141 {
142 if (pkgset.find(Dep.TargetPkg()) == pkgset.end())
143 continue;
144 dependencies[Dep->Type].append(", ");
145 }
146 else if (pkgset.find(Dep.TargetPkg()) == pkgset.end())
147 {
148 if ((Dep->CompareOp & pkgCache::Dep::Or) == pkgCache::Dep::Or)
149 continue;
150 dependencies[Dep->Type].erase(dependencies[Dep->Type].end()-3, dependencies[Dep->Type].end());
151 orGroup = false;
152 continue;
153 }
154 dependencies[Dep->Type].append(Dep.TargetPkg().Name());
155 if (Dep->Version != 0)
156 dependencies[Dep->Type].append(" (").append(pkgCache::CompTypeDeb(Dep->CompareOp)).append(" ").append(Dep.TargetVer()).append(")");
157 if ((Dep->CompareOp & pkgCache::Dep::Or) == pkgCache::Dep::Or)
158 {
159 dependencies[Dep->Type].append(" | ");
160 orGroup = true;
161 }
162 else
163 orGroup = false;
164 }
165 for (int i = 1; i < pkgCache::Dep::Enhances + 1; ++i)
166 if (dependencies[i].empty() == false)
167 fprintf(output, "%s: %s\n", DepMap[i], dependencies[i].c_str()+2);
168 string provides;
169 for (pkgCache::PrvIterator Prv = Ver.ProvidesList(); Prv.end() == false; ++Prv)
170 {
171 if (Prv.IsMultiArchImplicit() == true)
172 continue;
173 if (pkgset.find(Prv.ParentPkg()) == pkgset.end())
174 continue;
175 provides.append(", ").append(Prv.Name());
176 }
177 if (provides.empty() == false)
178 fprintf(output, "Provides: %s\n", provides.c_str()+2);
179}
180 /*}}}*/
181// EDSP::WriteScenario - to the given file descriptor /*{{{*/
182bool EDSP::WriteScenario(pkgDepCache &Cache, FILE* output, OpProgress *Progress)
183{
184 if (Progress != NULL)
185 Progress->SubProgress(Cache.Head().VersionCount, _("Send scenario to solver"));
186 unsigned long p = 0;
187 std::vector<std::string> archs = APT::Configuration::getArchitectures();
188 for (pkgCache::PkgIterator Pkg = Cache.PkgBegin(); Pkg.end() == false; ++Pkg)
189 {
190 std::string const arch = Pkg.Arch();
191 if (std::find(archs.begin(), archs.end(), arch) == archs.end())
192 continue;
193 for (pkgCache::VerIterator Ver = Pkg.VersionList(); Ver.end() == false; ++Ver, ++p)
194 {
195 WriteScenarioVersion(Cache, output, Pkg, Ver);
196 WriteScenarioDependency(output, Ver);
197 fprintf(output, "\n");
198 if (Progress != NULL && p % 100 == 0)
199 Progress->Progress(p);
200 }
201 }
202 return true;
203}
204 /*}}}*/
205// EDSP::WriteLimitedScenario - to the given file descriptor /*{{{*/
206bool EDSP::WriteLimitedScenario(pkgDepCache &Cache, FILE* output,
207 APT::PackageSet const &pkgset,
208 OpProgress *Progress)
209{
210 if (Progress != NULL)
211 Progress->SubProgress(Cache.Head().VersionCount, _("Send scenario to solver"));
212 unsigned long p = 0;
213 for (APT::PackageSet::const_iterator Pkg = pkgset.begin(); Pkg != pkgset.end(); ++Pkg, ++p)
214 for (pkgCache::VerIterator Ver = Pkg.VersionList(); Ver.end() == false; ++Ver)
215 {
216 WriteScenarioVersion(Cache, output, Pkg, Ver);
217 WriteScenarioLimitedDependency(output, Ver, pkgset);
218 fprintf(output, "\n");
219 if (Progress != NULL && p % 100 == 0)
220 Progress->Progress(p);
221 }
222 if (Progress != NULL)
223 Progress->Done();
224 return true;
225}
226 /*}}}*/
227// EDSP::WriteRequest - to the given file descriptor /*{{{*/
228bool EDSP::WriteRequest(pkgDepCache &Cache, FILE* output, bool const Upgrade,
229 bool const DistUpgrade, bool const AutoRemove,
230 OpProgress *Progress)
231{
232 if (Progress != NULL)
233 Progress->SubProgress(Cache.Head().PackageCount, _("Send request to solver"));
234 unsigned long p = 0;
235 string del, inst;
236 for (pkgCache::PkgIterator Pkg = Cache.PkgBegin(); Pkg.end() == false; ++Pkg, ++p)
237 {
238 if (Progress != NULL && p % 100 == 0)
239 Progress->Progress(p);
240 string* req;
241 pkgDepCache::StateCache &P = Cache[Pkg];
242 if (P.Delete() == true)
243 req = &del;
244 else if (P.NewInstall() == true || P.Upgrade() == true || P.ReInstall() == true ||
245 (P.Mode == pkgDepCache::ModeKeep && (P.iFlags & pkgDepCache::Protected) == pkgDepCache::Protected))
246 req = &inst;
247 else
248 continue;
249 req->append(" ").append(Pkg.FullName());
250 }
251 fprintf(output, "Request: EDSP 0.5\n");
252
253 const char *arch = _config->Find("APT::Architecture").c_str();
254 std::vector<string> archs = APT::Configuration::getArchitectures();
255 fprintf(output, "Architecture: %s\n", arch);
256 fprintf(output, "Architectures:");
257 for (std::vector<string>::const_iterator a = archs.begin(); a != archs.end(); ++a)
258 fprintf(output, " %s", a->c_str());
259 fprintf(output, "\n");
260
261 if (del.empty() == false)
262 fprintf(output, "Remove: %s\n", del.c_str()+1);
263 if (inst.empty() == false)
264 fprintf(output, "Install: %s\n", inst.c_str()+1);
265 if (Upgrade == true)
266 fprintf(output, "Upgrade: yes\n");
267 if (DistUpgrade == true)
268 fprintf(output, "Dist-Upgrade: yes\n");
269 if (AutoRemove == true)
270 fprintf(output, "Autoremove: yes\n");
271 if (_config->FindB("APT::Solver::Strict-Pinning", true) == false)
272 fprintf(output, "Strict-Pinning: no\n");
273 string solverpref("APT::Solver::");
274 solverpref.append(_config->Find("APT::Solver", "internal")).append("::Preferences");
275 if (_config->Exists(solverpref) == true)
276 fprintf(output, "Preferences: %s\n", _config->Find(solverpref,"").c_str());
277 fprintf(output, "\n");
278
279 return true;
280}
281 /*}}}*/
282// EDSP::ReadResponse - from the given file descriptor /*{{{*/
283bool EDSP::ReadResponse(int const input, pkgDepCache &Cache, OpProgress *Progress) {
284 /* We build an map id to mmap offset here
285 In theory we could use the offset as ID, but then VersionCount
286 couldn't be used to create other versionmappings anymore and it
287 would be too easy for a (buggy) solver to segfault APT… */
288 unsigned long long const VersionCount = Cache.Head().VersionCount;
289 unsigned long VerIdx[VersionCount];
290 for (pkgCache::PkgIterator P = Cache.PkgBegin(); P.end() == false; ++P) {
291 for (pkgCache::VerIterator V = P.VersionList(); V.end() == false; ++V)
292 VerIdx[V->ID] = V.Index();
293 Cache[P].Marked = true;
294 Cache[P].Garbage = false;
295 }
296
297 FileFd in;
298 in.OpenDescriptor(input, FileFd::ReadOnly);
299 pkgTagFile response(&in, 100);
300 pkgTagSection section;
301
302 while (response.Step(section) == true) {
303 std::string type;
304 if (section.Exists("Install") == true)
305 type = "Install";
306 else if (section.Exists("Remove") == true)
307 type = "Remove";
308 else if (section.Exists("Progress") == true) {
309 if (Progress != NULL) {
310 string msg = section.FindS("Message");
311 if (msg.empty() == true)
312 msg = _("Prepare for receiving solution");
313 Progress->SubProgress(100, msg, section.FindI("Percentage", 0));
314 }
315 continue;
316 } else if (section.Exists("Error") == true) {
317 std::string msg = SubstVar(SubstVar(section.FindS("Message"), "\n .\n", "\n\n"), "\n ", "\n");
318 if (msg.empty() == true) {
319 msg = _("External solver failed without a proper error message");
320 _error->Error("%s", msg.c_str());
321 } else
322 _error->Error("External solver failed with: %s", msg.substr(0,msg.find('\n')).c_str());
323 if (Progress != NULL)
324 Progress->Done();
325 std::cerr << "The solver encountered an error of type: " << section.FindS("Error") << std::endl;
326 std::cerr << "The following information might help you to understand what is wrong:" << std::endl;
327 std::cerr << msg << std::endl << std::endl;
328 return false;
329 } else if (section.Exists("Autoremove") == true)
330 type = "Autoremove";
331 else
332 continue;
333
334 size_t const id = section.FindULL(type.c_str(), VersionCount);
335 if (id == VersionCount) {
336 _error->Warning("Unable to parse %s request with id value '%s'!", type.c_str(), section.FindS(type.c_str()).c_str());
337 continue;
338 } else if (id > Cache.Head().VersionCount) {
339 _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());
340 continue;
341 }
342
343 pkgCache::VerIterator Ver(Cache.GetCache(), Cache.GetCache().VerP + VerIdx[id]);
344 Cache.SetCandidateVersion(Ver);
345 if (type == "Install")
346 {
347 pkgCache::PkgIterator const P = Ver.ParentPkg();
348 if (Cache[P].Mode != pkgDepCache::ModeInstall)
349 Cache.MarkInstall(P, false, 0, false);
350 }
351 else if (type == "Remove")
352 Cache.MarkDelete(Ver.ParentPkg(), false);
353 else if (type == "Autoremove") {
354 Cache[Ver.ParentPkg()].Marked = false;
355 Cache[Ver.ParentPkg()].Garbage = true;
356 }
357 }
358 return true;
359}
360 /*}}}*/
361// ReadLine - first line from the given file descriptor /*{{{*/
362// ---------------------------------------------------------------------
363/* Little helper method to read a complete line into a string. Similar to
364 fgets but we need to use the low-level read() here as otherwise the
365 listparser will be confused later on as mixing of fgets and read isn't
366 a supported action according to the manpages and results are undefined */
367static bool ReadLine(int const input, std::string &line) {
368 char one;
369 ssize_t data = 0;
370 line.erase();
371 line.reserve(100);
372 while ((data = read(input, &one, sizeof(one))) != -1) {
373 if (data != 1)
374 continue;
375 if (one == '\n')
376 return true;
377 if (one == '\r')
378 continue;
379 if (line.empty() == true && isblank(one) != 0)
380 continue;
381 line += one;
382 }
383 return false;
384}
385 /*}}}*/
386// StringToBool - convert yes/no to bool /*{{{*/
387// ---------------------------------------------------------------------
388/* we are not as lazy as we are in the global StringToBool as we really
389 only accept yes/no here - but we will ignore leading spaces */
390static bool StringToBool(char const *answer, bool const defValue) {
391 for (; isspace(*answer) != 0; ++answer);
392 if (strncasecmp(answer, "yes", 3) == 0)
393 return true;
394 else if (strncasecmp(answer, "no", 2) == 0)
395 return false;
396 else
397 _error->Warning("Value '%s' is not a boolean 'yes' or 'no'!", answer);
398 return defValue;
399}
400 /*}}}*/
401// EDSP::ReadRequest - first stanza from the given file descriptor /*{{{*/
402bool EDSP::ReadRequest(int const input, std::list<std::string> &install,
403 std::list<std::string> &remove, bool &upgrade,
404 bool &distUpgrade, bool &autoRemove)
405{
406 install.clear();
407 remove.clear();
408 upgrade = false;
409 distUpgrade = false;
410 autoRemove = false;
411 std::string line;
412 while (ReadLine(input, line) == true)
413 {
414 // Skip empty lines before request
415 if (line.empty() == true)
416 continue;
417 // The first Tag must be a request, so search for it
418 if (line.compare(0, 8, "Request:") != 0)
419 continue;
420
421 while (ReadLine(input, line) == true)
422 {
423 // empty lines are the end of the request
424 if (line.empty() == true)
425 return true;
426
427 std::list<std::string> *request = NULL;
428 if (line.compare(0, 8, "Install:") == 0)
429 {
430 line.erase(0, 8);
431 request = &install;
432 }
433 else if (line.compare(0, 7, "Remove:") == 0)
434 {
435 line.erase(0, 7);
436 request = &remove;
437 }
438 else if (line.compare(0, 8, "Upgrade:") == 0)
439 upgrade = StringToBool(line.c_str() + 9, false);
440 else if (line.compare(0, 13, "Dist-Upgrade:") == 0)
441 distUpgrade = StringToBool(line.c_str() + 14, false);
442 else if (line.compare(0, 11, "Autoremove:") == 0)
443 autoRemove = StringToBool(line.c_str() + 12, false);
444 else if (line.compare(0, 13, "Architecture:") == 0)
445 _config->Set("APT::Architecture", line.c_str() + 14);
446 else if (line.compare(0, 14, "Architectures:") == 0)
447 {
448 std::string const archs = line.c_str() + 15;
449 _config->Set("APT::Architectures", SubstVar(archs, " ", ","));
450 }
451 else
452 _error->Warning("Unknown line in EDSP Request stanza: %s", line.c_str());
453
454 if (request == NULL)
455 continue;
456 size_t end = line.length();
457 do {
458 size_t begin = line.rfind(' ');
459 if (begin == std::string::npos)
460 {
461 request->push_back(line.substr(0, end));
462 break;
463 }
464 else if (begin < end)
465 request->push_back(line.substr(begin + 1, end));
466 line.erase(begin);
467 end = line.find_last_not_of(' ');
468 } while (end != std::string::npos);
469 }
470 }
471 return false;
472}
473 /*}}}*/
474// EDSP::ApplyRequest - first stanza from the given file descriptor /*{{{*/
475bool EDSP::ApplyRequest(std::list<std::string> const &install,
476 std::list<std::string> const &remove,
477 pkgDepCache &Cache)
478{
479 for (std::list<std::string>::const_iterator i = install.begin();
480 i != install.end(); ++i) {
481 pkgCache::PkgIterator P = Cache.FindPkg(*i);
482 if (P.end() == true)
483 _error->Warning("Package %s is not known, so can't be installed", i->c_str());
484 else
485 Cache.MarkInstall(P, false);
486 }
487
488 for (std::list<std::string>::const_iterator i = remove.begin();
489 i != remove.end(); ++i) {
490 pkgCache::PkgIterator P = Cache.FindPkg(*i);
491 if (P.end() == true)
492 _error->Warning("Package %s is not known, so can't be installed", i->c_str());
493 else
494 Cache.MarkDelete(P);
495 }
496 return true;
497}
498 /*}}}*/
499// EDSP::WriteSolution - to the given file descriptor /*{{{*/
500bool EDSP::WriteSolution(pkgDepCache &Cache, FILE* output)
501{
502 bool const Debug = _config->FindB("Debug::EDSP::WriteSolution", false);
503 for (pkgCache::PkgIterator Pkg = Cache.PkgBegin(); Pkg.end() == false; ++Pkg)
504 {
505 if (Cache[Pkg].Delete() == true)
506 {
507 fprintf(output, "Remove: %d\n", Pkg.CurrentVer()->ID);
508 if (Debug == true)
509 fprintf(output, "Package: %s\nVersion: %s\n", Pkg.FullName().c_str(), Pkg.CurrentVer().VerStr());
510 }
511 else if (Cache[Pkg].NewInstall() == true || Cache[Pkg].Upgrade() == true)
512 {
513 pkgCache::VerIterator const CandVer = Cache.GetCandidateVersion(Pkg);
514 fprintf(output, "Install: %d\n", CandVer->ID);
515 if (Debug == true)
516 fprintf(output, "Package: %s\nVersion: %s\n", Pkg.FullName().c_str(), CandVer.VerStr());
517 }
518 else if (Cache[Pkg].Garbage == true)
519 {
520 fprintf(output, "Autoremove: %d\n", Pkg.CurrentVer()->ID);
521 if (Debug == true)
522 fprintf(output, "Package: %s\nVersion: %s\n", Pkg.FullName().c_str(), Pkg.CurrentVer().VerStr());
523 }
524 else
525 continue;
526 fprintf(output, "\n");
527 }
528
529 return true;
530}
531 /*}}}*/
532// EDSP::WriteProgess - pulse to the given file descriptor /*{{{*/
533bool EDSP::WriteProgress(unsigned short const percent, const char* const message, FILE* output) {
534 fprintf(output, "Progress: %s\n", TimeRFC1123(time(NULL)).c_str());
535 fprintf(output, "Percentage: %d\n", percent);
536 fprintf(output, "Message: %s\n\n", message);
537 fflush(output);
538 return true;
539}
540 /*}}}*/
541// EDSP::WriteError - format an error message to be send to file descriptor /*{{{*/
542bool EDSP::WriteError(char const * const uuid, std::string const &message, FILE* output) {
543 fprintf(output, "Error: %s\n", uuid);
544 fprintf(output, "Message: %s\n\n", SubstVar(SubstVar(message, "\n\n", "\n.\n"), "\n", "\n ").c_str());
545 return true;
546}
547 /*}}}*/
548// EDSP::ExecuteSolver - fork requested solver and setup ipc pipes {{{*/
549pid_t EDSP::ExecuteSolver(const char* const solver, int * const solver_in, int * const solver_out, bool) {
550 std::vector<std::string> const solverDirs = _config->FindVector("Dir::Bin::Solvers");
551 std::string file;
552 for (std::vector<std::string>::const_iterator dir = solverDirs.begin();
553 dir != solverDirs.end(); ++dir) {
554 file = flCombine(*dir, solver);
555 if (RealFileExists(file.c_str()) == true)
556 break;
557 file.clear();
558 }
559
560 if (file.empty() == true)
561 {
562 _error->Error("Can't call external solver '%s' as it is not in a configured directory!", solver);
563 return 0;
564 }
565 int external[4] = {-1, -1, -1, -1};
566 if (pipe(external) != 0 || pipe(external + 2) != 0)
567 {
568 _error->Errno("Resolve", "Can't create needed IPC pipes for EDSP");
569 return 0;
570 }
571 for (int i = 0; i < 4; ++i)
572 SetCloseExec(external[i], true);
573
574 pid_t Solver = ExecFork();
575 if (Solver == 0) {
576 dup2(external[0], STDIN_FILENO);
577 dup2(external[3], STDOUT_FILENO);
578 const char* calling[2] = { file.c_str(), 0 };
579 execv(calling[0], (char**) calling);
580 std::cerr << "Failed to execute solver '" << solver << "'!" << std::endl;
581 _exit(100);
582 }
583 close(external[0]);
584 close(external[3]);
585
586 if (WaitFd(external[1], true, 5) == false)
587 {
588 _error->Errno("Resolve", "Timed out while Waiting on availability of solver stdin");
589 return 0;
590 }
591
592 *solver_in = external[1];
593 *solver_out = external[2];
594 return Solver;
595}
596bool EDSP::ExecuteSolver(const char* const solver, int *solver_in, int *solver_out) {
597 if (ExecuteSolver(solver, solver_in, solver_out, true) == 0)
598 return false;
599 return true;
600}
601 /*}}}*/
602// EDSP::ResolveExternal - resolve problems by asking external for help {{{*/
603bool EDSP::ResolveExternal(const char* const solver, pkgDepCache &Cache,
604 bool const upgrade, bool const distUpgrade,
605 bool const autoRemove, OpProgress *Progress) {
606 int solver_in, solver_out;
607 pid_t const solver_pid = EDSP::ExecuteSolver(solver, &solver_in, &solver_out, true);
608 if (solver_pid == 0)
609 return false;
610
611 FILE* output = fdopen(solver_in, "w");
612 if (output == NULL)
613 return _error->Errno("Resolve", "fdopen on solver stdin failed");
614
615 if (Progress != NULL)
616 Progress->OverallProgress(0, 100, 5, _("Execute external solver"));
617 EDSP::WriteRequest(Cache, output, upgrade, distUpgrade, autoRemove, Progress);
618 if (Progress != NULL)
619 Progress->OverallProgress(5, 100, 20, _("Execute external solver"));
620 EDSP::WriteScenario(Cache, output, Progress);
621 fclose(output);
622
623 if (Progress != NULL)
624 Progress->OverallProgress(25, 100, 75, _("Execute external solver"));
625 if (EDSP::ReadResponse(solver_out, Cache, Progress) == false)
626 return false;
627
628 return ExecWait(solver_pid, solver);
629}
630 /*}}}*/
APT (for Cydia)