X-Git-Url: https://git.saurik.com/apt.git/blobdiff_plain/036eb0127ac3339347eb39c805e98fe43905bafe..1bae10217617c2f79969635d4387fb2a5fe19ecb:/apt-pkg/edsp.cc

diff --git a/apt-pkg/edsp.cc b/apt-pkg/edsp.cc
index 6ce9da784..2aaffcfc7 100644
--- a/apt-pkg/edsp.cc
+++ b/apt-pkg/edsp.cc
@@ -7,19 +7,25 @@
 // Include Files							/*{{{*/
 #include <config.h>
 
-#include <apt-pkg/edsp.h>
 #include <apt-pkg/error.h>
 #include <apt-pkg/cacheset.h>
-#include <apt-pkg/configuration.h>
-#include <apt-pkg/version.h>
-#include <apt-pkg/policy.h>
-#include <apt-pkg/tagfile.h>
-#include <apt-pkg/fileutl.h>
+#include <apt-pkg/depcache.h>
+#include <apt-pkg/pkgcache.h>
+#include <apt-pkg/cacheiterators.h>
 #include <apt-pkg/progress.h>
+#include <apt-pkg/fileutl.h>
+#include <apt-pkg/edsp.h>
+#include <apt-pkg/tagfile.h>
+#include <apt-pkg/strutl.h>
 
-#include <limits>
+#include <ctype.h>
+#include <stddef.h>
+#include <string.h>
+#include <unistd.h>
 #include <stdio.h>
 
+#include <array>
+#include <limits>
 #include <string>
 
 #include <apti18n.h>
@@ -28,97 +34,112 @@
 using std::string;
 
 // we could use pkgCache::DepType and ::Priority, but these would be localized strings…
-const char * const EDSP::PrioMap[] = {0, "important", "required", "standard",
-				      "optional", "extra"};
-const char * const EDSP::DepMap[] = {"", "Depends", "Pre-Depends", "Suggests",
-				     "Recommends" , "Conflicts", "Replaces",
-				     "Obsoletes", "Breaks", "Enhances"};
+constexpr char const * const PrioMap[] = {
+   nullptr, "important", "required", "standard",
+   "optional", "extra"
+};
+constexpr char const * const DepMap[] = {
+   nullptr, "Depends", "Pre-Depends", "Suggests",
+   "Recommends" , "Conflicts", "Replaces",
+   "Obsoletes", "Breaks", "Enhances"
+};
 
-// EDSP::WriteScenario - to the given file descriptor			/*{{{*/
-bool EDSP::WriteScenario(pkgDepCache &Cache, FILE* output, OpProgress *Progress)
+// WriteOkay - varaidic helper to easily Write to a FileFd		/*{{{*/
+static bool WriteOkay_fn(FileFd &) { return true; }
+template<typename... Tail> static bool WriteOkay_fn(FileFd &output, APT::StringView data, Tail... more_data)
 {
-   if (Progress != NULL)
-      Progress->SubProgress(Cache.Head().VersionCount, _("Send scenario to solver"));
-   unsigned long p = 0;
-   for (pkgCache::PkgIterator Pkg = Cache.PkgBegin(); Pkg.end() == false; ++Pkg)
-      for (pkgCache::VerIterator Ver = Pkg.VersionList(); Ver.end() == false; ++Ver, ++p)
-      {
-	 WriteScenarioVersion(Cache, output, Pkg, Ver);
-	 WriteScenarioDependency(Cache, output, Pkg, Ver);
-	 fprintf(output, "\n");
-	 if (Progress != NULL && p % 100 == 0)
-	    Progress->Progress(p);
-      }
-   return true;
+   return likely(output.Write(data.data(), data.length()) && WriteOkay_fn(output, more_data...));
 }
-									/*}}}*/
-// EDSP::WriteLimitedScenario - to the given file descriptor		/*{{{*/
-bool EDSP::WriteLimitedScenario(pkgDepCache &Cache, FILE* output,
-				APT::PackageSet const &pkgset,
-				OpProgress *Progress)
+template<typename... Tail> static bool WriteOkay_fn(FileFd &output, unsigned int data, Tail... more_data)
 {
-   if (Progress != NULL)
-      Progress->SubProgress(Cache.Head().VersionCount, _("Send scenario to solver"));
-   unsigned long p  = 0;
-   for (APT::PackageSet::const_iterator Pkg = pkgset.begin(); Pkg != pkgset.end(); ++Pkg, ++p)
-      for (pkgCache::VerIterator Ver = Pkg.VersionList(); Ver.end() == false; ++Ver)
-      {
-	 WriteScenarioVersion(Cache, output, Pkg, Ver);
-	 WriteScenarioLimitedDependency(Cache, output, Pkg, Ver, pkgset);
-	 fprintf(output, "\n");
-	 if (Progress != NULL && p % 100 == 0)
-	    Progress->Progress(p);
-      }
-   if (Progress != NULL)
-      Progress->Done();
-   return true;
+   std::string number;
+   strprintf(number, "%d", data);
+   return likely(output.Write(number.data(), number.length()) && WriteOkay_fn(output, more_data...));
+}
+template<typename... Data> static bool WriteOkay(bool &Okay, FileFd &output, Data&&... data)
+{
+   Okay = likely(Okay && WriteOkay_fn(output, std::forward<Data>(data)...));
+   return Okay;
+}
+template<typename... Data> static bool WriteOkay(FileFd &output, Data&&... data)
+{
+   bool Okay = likely(output.Failed() == false);
+   return WriteOkay(Okay, output, std::forward<Data>(data)...);
 }
 									/*}}}*/
-// EDSP::WriteScenarioVersion						/*{{{*/
-void EDSP::WriteScenarioVersion(pkgDepCache &Cache, FILE* output, pkgCache::PkgIterator const &Pkg,
+// WriteScenarioVersion							/*{{{*/
+static void WriteScenarioVersion(pkgDepCache &Cache, FILE* output, pkgCache::PkgIterator const &Pkg,
 				pkgCache::VerIterator const &Ver)
 {
    fprintf(output, "Package: %s\n", Pkg.Name());
+   fprintf(output, "Source: %s\n", Ver.SourcePkgName());
    fprintf(output, "Architecture: %s\n", Ver.Arch());
    fprintf(output, "Version: %s\n", Ver.VerStr());
+   fprintf(output, "Source-Version: %s\n", Ver.SourceVerStr());
    if (Pkg.CurrentVer() == Ver)
       fprintf(output, "Installed: yes\n");
    if (Pkg->SelectedState == pkgCache::State::Hold ||
        (Cache[Pkg].Keep() == true && Cache[Pkg].Protect() == true))
       fprintf(output, "Hold: yes\n");
    fprintf(output, "APT-ID: %d\n", Ver->ID);
-   fprintf(output, "Priority: %s\n", PrioMap[Ver->Priority]);
+   if (PrioMap[Ver->Priority] != nullptr)
+      fprintf(output, "Priority: %s\n", PrioMap[Ver->Priority]);
    if ((Pkg->Flags & pkgCache::Flag::Essential) == pkgCache::Flag::Essential)
       fprintf(output, "Essential: yes\n");
-   fprintf(output, "Section: %s\n", Ver.Section());
+   if (Ver->Section != 0)
+      fprintf(output, "Section: %s\n", Ver.Section());
    if ((Ver->MultiArch & pkgCache::Version::Allowed) == pkgCache::Version::Allowed)
       fprintf(output, "Multi-Arch: allowed\n");
    else if ((Ver->MultiArch & pkgCache::Version::Foreign) == pkgCache::Version::Foreign)
       fprintf(output, "Multi-Arch: foreign\n");
    else if ((Ver->MultiArch & pkgCache::Version::Same) == pkgCache::Version::Same)
       fprintf(output, "Multi-Arch: same\n");
-   signed short Pin = std::numeric_limits<signed short>::min();
-   for (pkgCache::VerFileIterator File = Ver.FileList(); File.end() == false; ++File) {
-      signed short const p = Cache.GetPolicy().GetPriority(File.File());
-      if (Pin < p)
-	 Pin = p;
+   std::set<string> Releases;
+   for (pkgCache::VerFileIterator I = Ver.FileList(); I.end() == false; ++I) {
+      pkgCache::PkgFileIterator File = I.File();
+      if (File.Flagged(pkgCache::Flag::NotSource) == false) {
+	 string Release = File.RelStr();
+	 if (!Release.empty())
+	    Releases.insert(Release);
+      }
+   }
+   if (!Releases.empty()) {
+       fprintf(output, "APT-Release:\n");
+       for (std::set<string>::iterator R = Releases.begin(); R != Releases.end(); ++R)
+	   fprintf(output, " %s\n", R->c_str());
    }
-   fprintf(output, "APT-Pin: %d\n", Pin);
-   if (Cache.GetCandidateVer(Pkg) == Ver)
+   fprintf(output, "APT-Pin: %d\n", Cache.GetPolicy().GetPriority(Ver));
+   if (Cache.GetCandidateVersion(Pkg) == Ver)
       fprintf(output, "APT-Candidate: yes\n");
    if ((Cache[Pkg].Flags & pkgCache::Flag::Auto) == pkgCache::Flag::Auto)
       fprintf(output, "APT-Automatic: yes\n");
 }
-									/*}}}*/
-// EDSP::WriteScenarioDependency					/*{{{*/
-void EDSP::WriteScenarioDependency(pkgDepCache &Cache, FILE* output, pkgCache::PkgIterator const &Pkg,
+static bool WriteScenarioVersion(FileFd &output, pkgCache::PkgIterator const &Pkg,
 				pkgCache::VerIterator const &Ver)
 {
-   std::string dependencies[pkgCache::Dep::Enhances + 1];
+   bool Okay = WriteOkay(output, "Package: ", Pkg.Name(),
+	 "\nArchitecture: ", Ver.Arch(),
+	 "\nVersion: ", Ver.VerStr());
+   WriteOkay(Okay, output, "\nAPT-ID: ", Ver->ID);
+   if ((Pkg->Flags & pkgCache::Flag::Essential) == pkgCache::Flag::Essential)
+      WriteOkay(Okay, output, "\nEssential: yes");
+   if ((Ver->MultiArch & pkgCache::Version::Allowed) == pkgCache::Version::Allowed)
+      WriteOkay(Okay, output, "\nMulti-Arch: allowed");
+   else if ((Ver->MultiArch & pkgCache::Version::Foreign) == pkgCache::Version::Foreign)
+      WriteOkay(Okay, output, "\nMulti-Arch: foreign");
+   else if ((Ver->MultiArch & pkgCache::Version::Same) == pkgCache::Version::Same)
+      WriteOkay(Okay, output, "\nMulti-Arch: same");
+   return Okay;
+}
+									/*}}}*/
+// WriteScenarioDependency						/*{{{*/
+static void WriteScenarioDependency( FILE* output, pkgCache::VerIterator const &Ver)
+{
+   std::array<std::string, _count(DepMap)> dependencies;
    bool orGroup = false;
    for (pkgCache::DepIterator Dep = Ver.DependsList(); Dep.end() == false; ++Dep)
    {
-      if (Dep.IsMultiArchImplicit() == true)
+      if (Dep.IsImplicit() == true)
 	 continue;
       if (orGroup == false)
 	 dependencies[Dep->Type].append(", ");
@@ -133,7 +154,7 @@ void EDSP::WriteScenarioDependency(pkgDepCache &Cache, FILE* output, pkgCache::P
       else
 	 orGroup = false;
    }
-   for (int i = 1; i < pkgCache::Dep::Enhances + 1; ++i)
+   for (size_t i = 1; i < dependencies.size(); ++i)
       if (dependencies[i].empty() == false)
 	 fprintf(output, "%s: %s\n", DepMap[i], dependencies[i].c_str()+2);
    string provides;
@@ -141,29 +162,75 @@ void EDSP::WriteScenarioDependency(pkgDepCache &Cache, FILE* output, pkgCache::P
    {
       if (Prv.IsMultiArchImplicit() == true)
 	 continue;
-      provides.append(", ").append(Prv.Name());
+      if (provides.empty() == false)
+	 provides.append(", ");
+      provides.append(Prv.Name());
+      if (Prv->ProvideVersion != 0)
+	 provides.append(" (= ").append(Prv.ProvideVersion()).append(")");
+   }
+   if (provides.empty() == false)
+      fprintf(output, "Provides: %s\n", provides.c_str());
+}
+static bool WriteScenarioDependency(FileFd &output, pkgCache::VerIterator const &Ver, bool const OnlyCritical)
+{
+   std::array<std::string, _count(DepMap)> dependencies;
+   bool orGroup = false;
+   for (pkgCache::DepIterator Dep = Ver.DependsList(); Dep.end() == false; ++Dep)
+   {
+      if (Dep.IsImplicit() == true)
+	 continue;
+      if (OnlyCritical && Dep.IsCritical() == false)
+	 continue;
+      if (orGroup == false && dependencies[Dep->Type].empty() == false)
+	 dependencies[Dep->Type].append(", ");
+      dependencies[Dep->Type].append(Dep.TargetPkg().Name());
+      if (Dep->Version != 0)
+	 dependencies[Dep->Type].append(" (").append(pkgCache::CompTypeDeb(Dep->CompareOp)).append(" ").append(Dep.TargetVer()).append(")");
+      if ((Dep->CompareOp & pkgCache::Dep::Or) == pkgCache::Dep::Or)
+      {
+	 dependencies[Dep->Type].append(" | ");
+	 orGroup = true;
+      }
+      else
+	 orGroup = false;
+   }
+   bool Okay = output.Failed() == false;
+   for (size_t i = 1; i < dependencies.size(); ++i)
+      if (dependencies[i].empty() == false)
+	 WriteOkay(Okay, output, "\n", DepMap[i], ": ", dependencies[i]);
+   string provides;
+   for (pkgCache::PrvIterator Prv = Ver.ProvidesList(); Prv.end() == false; ++Prv)
+   {
+      if (Prv.IsMultiArchImplicit() == true)
+	 continue;
+      if (provides.empty() == false)
+	 provides.append(", ");
+      provides.append(Prv.Name());
+      if (Prv->ProvideVersion != 0)
+	 provides.append(" (= ").append(Prv.ProvideVersion()).append(")");
    }
    if (provides.empty() == false)
-      fprintf(output, "Provides: %s\n", provides.c_str()+2);
+      WriteOkay(Okay, output, "\nProvides: ", provides);
+   return WriteOkay(Okay, output, "\n");
 }
 									/*}}}*/
-// EDSP::WriteScenarioLimitedDependency					/*{{{*/
-void EDSP::WriteScenarioLimitedDependency(pkgDepCache &Cache, FILE* output,
-					  pkgCache::PkgIterator const &Pkg,
+// WriteScenarioLimitedDependency					/*{{{*/
+static void WriteScenarioLimitedDependency(FILE* output,
 					  pkgCache::VerIterator const &Ver,
 					  APT::PackageSet const &pkgset)
 {
-   std::string dependencies[pkgCache::Dep::Enhances + 1];
+   std::array<std::string, _count(DepMap)> dependencies;
    bool orGroup = false;
    for (pkgCache::DepIterator Dep = Ver.DependsList(); Dep.end() == false; ++Dep)
    {
-      if (Dep.IsMultiArchImplicit() == true)
+      if (Dep.IsImplicit() == true)
 	 continue;
       if (orGroup == false)
       {
 	 if (pkgset.find(Dep.TargetPkg()) == pkgset.end())
 	    continue;
-	 dependencies[Dep->Type].append(", ");
+	 if (dependencies[Dep->Type].empty() == false)
+	    dependencies[Dep->Type].append(", ");
       }
       else if (pkgset.find(Dep.TargetPkg()) == pkgset.end())
       {
@@ -184,9 +251,9 @@ void EDSP::WriteScenarioLimitedDependency(pkgDepCache &Cache, FILE* output,
       else
 	 orGroup = false;
    }
-   for (int i = 1; i < pkgCache::Dep::Enhances + 1; ++i)
+   for (size_t i = 1; i < dependencies.size(); ++i)
       if (dependencies[i].empty() == false)
-	 fprintf(output, "%s: %s\n", DepMap[i], dependencies[i].c_str()+2);
+	 fprintf(output, "%s: %s\n", DepMap[i], dependencies[i].c_str());
    string provides;
    for (pkgCache::PrvIterator Prv = Ver.ProvidesList(); Prv.end() == false; ++Prv)
    {
@@ -194,10 +261,232 @@ void EDSP::WriteScenarioLimitedDependency(pkgDepCache &Cache, FILE* output,
 	 continue;
       if (pkgset.find(Prv.ParentPkg()) == pkgset.end())
 	 continue;
-      provides.append(", ").append(Prv.Name());
+      if (provides.empty() == false)
+	 provides.append(", ");
+      provides.append(Prv.Name());
+      if (Prv->ProvideVersion != 0)
+	 provides.append(" (= ").append(Prv.ProvideVersion()).append(")");
+   }
+   if (provides.empty() == false)
+      fprintf(output, "Provides: %s\n", provides.c_str());
+}
+static bool WriteScenarioLimitedDependency(FileFd &output,
+					  pkgCache::VerIterator const &Ver,
+					  std::vector<bool> const &pkgset,
+					  bool const OnlyCritical)
+{
+   std::array<std::string, _count(DepMap)> dependencies;
+   bool orGroup = false;
+   for (pkgCache::DepIterator Dep = Ver.DependsList(); Dep.end() == false; ++Dep)
+   {
+      if (Dep.IsImplicit() == true)
+	 continue;
+      if (OnlyCritical && Dep.IsCritical() == false)
+	 continue;
+      if (orGroup == false)
+      {
+	 if (pkgset[Dep.TargetPkg()->ID] == false)
+	    continue;
+	 if (dependencies[Dep->Type].empty() == false)
+	    dependencies[Dep->Type].append(", ");
+      }
+      else if (pkgset[Dep.TargetPkg()->ID] == false)
+      {
+	 if ((Dep->CompareOp & pkgCache::Dep::Or) == pkgCache::Dep::Or)
+	    continue;
+	 dependencies[Dep->Type].erase(dependencies[Dep->Type].end()-3, dependencies[Dep->Type].end());
+	 orGroup = false;
+	 continue;
+      }
+      dependencies[Dep->Type].append(Dep.TargetPkg().Name());
+      if (Dep->Version != 0)
+	 dependencies[Dep->Type].append(" (").append(pkgCache::CompTypeDeb(Dep->CompareOp)).append(" ").append(Dep.TargetVer()).append(")");
+      if ((Dep->CompareOp & pkgCache::Dep::Or) == pkgCache::Dep::Or)
+      {
+	 dependencies[Dep->Type].append(" | ");
+	 orGroup = true;
+      }
+      else
+	 orGroup = false;
+   }
+   bool Okay = output.Failed() == false;
+   for (size_t i = 1; i < dependencies.size(); ++i)
+      if (dependencies[i].empty() == false)
+	 WriteOkay(Okay, output, "\n", DepMap[i], ": ", dependencies[i]);
+   string provides;
+   for (pkgCache::PrvIterator Prv = Ver.ProvidesList(); Prv.end() == false; ++Prv)
+   {
+      if (Prv.IsMultiArchImplicit() == true)
+	 continue;
+      if (pkgset[Prv.ParentPkg()->ID] == false)
+	 continue;
+      if (provides.empty() == false)
+	 provides.append(", ");
+      provides.append(Prv.Name());
+      if (Prv->ProvideVersion != 0)
+	 provides.append(" (= ").append(Prv.ProvideVersion()).append(")");
    }
    if (provides.empty() == false)
-      fprintf(output, "Provides: %s\n", provides.c_str()+2);
+      WriteOkay(Okay, output, "\nProvides: ", provides);
+   return WriteOkay(Okay, output, "\n");
+}
+									/*}}}*/
+static bool SkipUnavailableVersions(pkgDepCache &Cache, pkgCache::PkgIterator const &Pkg, pkgCache::VerIterator const &Ver)/*{{{*/
+{
+   /* versions which aren't current and aren't available in
+      any "online" source file are bad, expect if they are the choosen
+      candidate: The exception is for build-dep implementation as it creates
+      such pseudo (package) versions and removes them later on again.
+      We filter out versions at all so packages in 'rc' state only available
+      in dpkg/status aren't passed to solvers as they can't be installed. */
+   if (Pkg->CurrentVer != 0)
+      return false;
+   if (Cache.GetCandidateVersion(Pkg) == Ver)
+      return false;
+   for (pkgCache::VerFileIterator I = Ver.FileList(); I.end() == false; ++I)
+      if (I.File().Flagged(pkgCache::Flag::NotSource) == false)
+	 return false;
+   return true;
+}
+									/*}}}*/
+static bool WriteScenarioEDSPVersion(pkgDepCache &Cache, FileFd &output, pkgCache::PkgIterator const &Pkg,/*{{{*/
+				pkgCache::VerIterator const &Ver)
+{
+   bool Okay = WriteOkay(output, "\nSource: ", Ver.SourcePkgName(),
+	 "\nSource-Version: ", Ver.SourceVerStr());
+   if (PrioMap[Ver->Priority] != nullptr)
+      WriteOkay(Okay, output, "\nPriority: ", PrioMap[Ver->Priority]);
+   if (Ver->Section != 0)
+      WriteOkay(Okay, output, "\nSection: ", Ver.Section());
+   if (Pkg.CurrentVer() == Ver)
+      WriteOkay(Okay, output, "\nInstalled: yes");
+   if (Pkg->SelectedState == pkgCache::State::Hold ||
+       (Cache[Pkg].Keep() == true && Cache[Pkg].Protect() == true))
+      WriteOkay(Okay, output, "\nHold: yes");
+   std::set<string> Releases;
+   for (pkgCache::VerFileIterator I = Ver.FileList(); I.end() == false; ++I) {
+      pkgCache::PkgFileIterator File = I.File();
+      if (File.Flagged(pkgCache::Flag::NotSource) == false) {
+	 string Release = File.RelStr();
+	 if (!Release.empty())
+	    Releases.insert(Release);
+      }
+   }
+   if (!Releases.empty()) {
+       WriteOkay(Okay, output, "\nAPT-Release:");
+       for (std::set<string>::iterator R = Releases.begin(); R != Releases.end(); ++R)
+	   WriteOkay(Okay, output, "\n ", *R);
+   }
+   WriteOkay(Okay, output, "\nAPT-Pin: ", Cache.GetPolicy().GetPriority(Ver));
+   if (Cache.GetCandidateVersion(Pkg) == Ver)
+      WriteOkay(Okay, output, "\nAPT-Candidate: yes");
+   if ((Cache[Pkg].Flags & pkgCache::Flag::Auto) == pkgCache::Flag::Auto)
+      WriteOkay(Okay, output, "\nAPT-Automatic: yes");
+   return Okay;
+}
+									/*}}}*/
+// EDSP::WriteScenario - to the given file descriptor			/*{{{*/
+bool EDSP::WriteScenario(pkgDepCache &Cache, FILE* output, OpProgress *Progress)
+{
+   if (Progress != NULL)
+      Progress->SubProgress(Cache.Head().VersionCount, _("Send scenario to solver"));
+   unsigned long p = 0;
+   std::vector<std::string> archs = APT::Configuration::getArchitectures();
+   for (pkgCache::PkgIterator Pkg = Cache.PkgBegin(); Pkg.end() == false; ++Pkg)
+   {
+      std::string const arch = Pkg.Arch();
+      if (std::find(archs.begin(), archs.end(), arch) == archs.end())
+	 continue;
+      for (pkgCache::VerIterator Ver = Pkg.VersionList(); Ver.end() == false; ++Ver, ++p)
+      {
+	 if (SkipUnavailableVersions(Cache, Pkg, Ver))
+	    continue;
+	 WriteScenarioVersion(Cache, output, Pkg, Ver);
+	 WriteScenarioDependency(output, Ver);
+	 fprintf(output, "\n");
+	 if (Progress != NULL && p % 100 == 0)
+	    Progress->Progress(p);
+      }
+   }
+   return true;
+}
+bool EDSP::WriteScenario(pkgDepCache &Cache, FileFd &output, OpProgress *Progress)
+{
+   if (Progress != NULL)
+      Progress->SubProgress(Cache.Head().VersionCount, _("Send scenario to solver"));
+   unsigned long p = 0;
+   bool Okay = output.Failed() == false;
+   std::vector<std::string> archs = APT::Configuration::getArchitectures();
+   for (pkgCache::PkgIterator Pkg = Cache.PkgBegin(); Pkg.end() == false && likely(Okay); ++Pkg)
+   {
+      std::string const arch = Pkg.Arch();
+      if (std::find(archs.begin(), archs.end(), arch) == archs.end())
+	 continue;
+      for (pkgCache::VerIterator Ver = Pkg.VersionList(); Ver.end() == false && likely(Okay); ++Ver, ++p)
+      {
+	 if (SkipUnavailableVersions(Cache, Pkg, Ver))
+	    continue;
+	 Okay &= WriteScenarioVersion(output, Pkg, Ver);
+	 Okay &= WriteScenarioEDSPVersion(Cache, output, Pkg, Ver);
+	 Okay &= WriteScenarioDependency(output, Ver, false);
+	 WriteOkay(Okay, output, "\n");
+	 if (Progress != NULL && p % 100 == 0)
+	    Progress->Progress(p);
+      }
+   }
+   return true;
+}
+									/*}}}*/
+// EDSP::WriteLimitedScenario - to the given file descriptor		/*{{{*/
+bool EDSP::WriteLimitedScenario(pkgDepCache &Cache, FILE* output,
+				APT::PackageSet const &pkgset,
+				OpProgress *Progress)
+{
+   if (Progress != NULL)
+      Progress->SubProgress(Cache.Head().VersionCount, _("Send scenario to solver"));
+   unsigned long p  = 0;
+   for (APT::PackageSet::const_iterator Pkg = pkgset.begin(); Pkg != pkgset.end(); ++Pkg, ++p)
+      for (pkgCache::VerIterator Ver = Pkg.VersionList(); Ver.end() == false; ++Ver)
+      {
+	 if (SkipUnavailableVersions(Cache, Pkg, Ver))
+	    continue;
+	 WriteScenarioVersion(Cache, output, Pkg, Ver);
+	 WriteScenarioLimitedDependency(output, Ver, pkgset);
+	 fprintf(output, "\n");
+	 if (Progress != NULL && p % 100 == 0)
+	    Progress->Progress(p);
+      }
+   if (Progress != NULL)
+      Progress->Done();
+   return true;
+}
+bool EDSP::WriteLimitedScenario(pkgDepCache &Cache, FileFd &output,
+				std::vector<bool> const &pkgset,
+				OpProgress *Progress)
+{
+   if (Progress != NULL)
+      Progress->SubProgress(Cache.Head().VersionCount, _("Send scenario to solver"));
+   unsigned long p  = 0;
+   bool Okay = output.Failed() == false;
+   for (auto Pkg = Cache.PkgBegin(); Pkg.end() == false && likely(Okay); ++Pkg, ++p)
+   {
+      if (pkgset[Pkg->ID] == false)
+	 continue;
+      for (pkgCache::VerIterator Ver = Pkg.VersionList(); Ver.end() == false && likely(Okay); ++Ver)
+      {
+	 if (SkipUnavailableVersions(Cache, Pkg, Ver))
+	    continue;
+	 Okay &= WriteScenarioVersion(output, Pkg, Ver);
+	 Okay &= WriteScenarioEDSPVersion(Cache, output, Pkg, Ver);
+	 Okay &= WriteScenarioLimitedDependency(output, Ver, pkgset, false);
+	 WriteOkay(Okay, output, "\n");
+	 if (Progress != NULL && p % 100 == 0)
+	    Progress->Progress(p);
+      }
+   }
+   if (Progress != NULL)
+      Progress->Done();
+   return Okay;
 }
 									/*}}}*/
 // EDSP::WriteRequest - to the given file descriptor			/*{{{*/
@@ -224,7 +513,16 @@ bool EDSP::WriteRequest(pkgDepCache &Cache, FILE* output, bool const Upgrade,
 	 continue;
       req->append(" ").append(Pkg.FullName());
    }
-   fprintf(output, "Request: EDSP 0.4\n");
+   fprintf(output, "Request: EDSP 0.5\n");
+
+   const char *arch = _config->Find("APT::Architecture").c_str();
+   std::vector<string> archs = APT::Configuration::getArchitectures();
+   fprintf(output, "Architecture: %s\n", arch);
+   fprintf(output, "Architectures:");
+   for (std::vector<string>::const_iterator a = archs.begin(); a != archs.end(); ++a)
+       fprintf(output, " %s", a->c_str());
+   fprintf(output, "\n");
+
    if (del.empty() == false)
       fprintf(output, "Remove: %s\n", del.c_str()+1);
    if (inst.empty() == false)
@@ -235,15 +533,75 @@ bool EDSP::WriteRequest(pkgDepCache &Cache, FILE* output, bool const Upgrade,
       fprintf(output, "Dist-Upgrade: yes\n");
    if (AutoRemove == true)
       fprintf(output, "Autoremove: yes\n");
-   if (_config->FindB("APT::Solver::Strict-Pinning", true) == false)
+   auto const solver = _config->Find("APT::Solver", "internal");
+   fprintf(output, "Solver: %s\n", solver.c_str());
+   auto const solverconf = std::string("APT::Solver::") + solver + "::";
+   if (_config->FindB(solverconf + "Strict-Pinning", _config->FindB("APT::Solver::Strict-Pinning", true)) == false)
       fprintf(output, "Strict-Pinning: no\n");
+   auto const solverpref = _config->Find(solverconf + "Preferences", _config->Find("APT::Solver::Preferences", ""));
+   if (solverpref.empty() == false)
+      fprintf(output, "Preferences: %s\n", solverpref.c_str());
+   fprintf(output, "\n");
+   return true;
+}
+bool EDSP::WriteRequest(pkgDepCache &Cache, FileFd &output,
+			unsigned int const flags,
+			OpProgress *Progress)
+{
+   if (Progress != NULL)
+      Progress->SubProgress(Cache.Head().PackageCount, _("Send request to solver"));
+   unsigned long p = 0;
+   string del, inst;
+   for (pkgCache::PkgIterator Pkg = Cache.PkgBegin(); Pkg.end() == false; ++Pkg, ++p)
+   {
+      if (Progress != NULL && p % 100 == 0)
+         Progress->Progress(p);
+      string* req;
+      pkgDepCache::StateCache &P = Cache[Pkg];
+      if (P.Delete() == true)
+	 req = &del;
+      else if (P.NewInstall() == true || P.Upgrade() == true || P.ReInstall() == true ||
+	       (P.Mode == pkgDepCache::ModeKeep && (P.iFlags & pkgDepCache::Protected) == pkgDepCache::Protected))
+	 req = &inst;
+      else
+	 continue;
+      req->append(" ").append(Pkg.FullName());
+   }
+   bool Okay = WriteOkay(output, "Request: EDSP 0.5\n");
+
+   const char *arch = _config->Find("APT::Architecture").c_str();
+   std::vector<string> archs = APT::Configuration::getArchitectures();
+   WriteOkay(Okay, output, "Architecture: ", arch, "\n",
+	 "Architectures:");
+   for (std::vector<string>::const_iterator a = archs.begin(); a != archs.end(); ++a)
+       WriteOkay(Okay, output, " ", *a);
+   WriteOkay(Okay, output, "\n");
+
+   if (del.empty() == false)
+      WriteOkay(Okay, output, "Remove:", del, "\n");
+   if (inst.empty() == false)
+      WriteOkay(Okay, output, "Install:", inst, "\n");
+   if (flags & Request::AUTOREMOVE)
+      WriteOkay(Okay, output, "Autoremove: yes\n");
+   if (flags & Request::UPGRADE_ALL)
+   {
+      WriteOkay(Okay, output, "Upgrade-All: yes\n");
+      if (flags & (Request::FORBID_NEW_INSTALL | Request::FORBID_REMOVE))
+	 WriteOkay(Okay, output, "Upgrade: yes\n");
+      else
+	 WriteOkay(Okay, output, "Dist-Upgrade: yes\n");
+   }
+   if (flags & Request::FORBID_NEW_INSTALL)
+      WriteOkay(Okay, output, "Forbid-New-Install: yes\n");
+   if (flags & Request::FORBID_REMOVE)
+      WriteOkay(Okay, output, "Forbid-Remove: yes\n");
+   if (_config->FindB("APT::Solver::Strict-Pinning", true) == false)
+      WriteOkay(Okay, output, "Strict-Pinning: no\n");
    string solverpref("APT::Solver::");
    solverpref.append(_config->Find("APT::Solver", "internal")).append("::Preferences");
    if (_config->Exists(solverpref) == true)
-      fprintf(output, "Preferences: %s\n", _config->Find(solverpref,"").c_str());
-   fprintf(output, "\n");
-
-   return true;
+      WriteOkay(Okay, output, "Preferences: ", _config->Find(solverpref,""), "\n");
+   return WriteOkay(Okay, output, "\n");
 }
 									/*}}}*/
 // EDSP::ReadResponse - from the given file descriptor			/*{{{*/
@@ -266,6 +624,7 @@ bool EDSP::ReadResponse(int const input, pkgDepCache &Cache, OpProgress *Progres
 	pkgTagFile response(&in, 100);
 	pkgTagSection section;
 
+	std::set<decltype(Cache.PkgBegin()->ID)> seenOnce;
 	while (response.Step(section) == true) {
 		std::string type;
 		if (section.Exists("Install") == true)
@@ -308,26 +667,41 @@ bool EDSP::ReadResponse(int const input, pkgDepCache &Cache, OpProgress *Progres
 		}
 
 		pkgCache::VerIterator Ver(Cache.GetCache(), Cache.GetCache().VerP + VerIdx[id]);
-		Cache.SetCandidateVersion(Ver);
-		if (type == "Install")
-			Cache.MarkInstall(Ver.ParentPkg(), false, 0, false);
-		else if (type == "Remove")
-			Cache.MarkDelete(Ver.ParentPkg(), false);
-		else if (type == "Autoremove") {
-			Cache[Ver.ParentPkg()].Marked = false;
-			Cache[Ver.ParentPkg()].Garbage = true;
+		auto const Pkg = Ver.ParentPkg();
+		if (type == "Autoremove") {
+			Cache[Pkg].Marked = false;
+			Cache[Pkg].Garbage = true;
+		} else if (seenOnce.emplace(Pkg->ID).second == false) {
+			_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());
+		} else if (type == "Install") {
+			if (Pkg.CurrentVer() == Ver) {
+				_error->Warning("Ignoring Install stanza received for version %s of package %s which is already installed!",
+				      Ver.VerStr(), Pkg.FullName(false).c_str());
+			} else {
+				Cache.SetCandidateVersion(Ver);
+				Cache.MarkInstall(Pkg, false, 0, false);
+			}
+		} else if (type == "Remove") {
+			if (Pkg->CurrentVer == 0)
+				_error->Warning("Ignoring Remove stanza received for version %s of package %s which isn't installed!",
+				      Ver.VerStr(), Pkg.FullName(false).c_str());
+			else if (Pkg.CurrentVer() != Ver)
+				_error->Warning("Ignoring Remove stanza received for version %s of package %s which isn't the installed version %s!",
+				      Ver.VerStr(), Pkg.FullName(false).c_str(), Pkg.CurrentVer().VerStr());
+			else
+				Cache.MarkDelete(Ver.ParentPkg(), false);
 		}
 	}
 	return true;
 }
 									/*}}}*/
-// EDSP::ReadLine - first line from the given file descriptor		/*{{{*/
+// ReadLine - first line from the given file descriptor			/*{{{*/
 // ---------------------------------------------------------------------
 /* Little helper method to read a complete line into a string. Similar to
    fgets but we need to use the low-level read() here as otherwise the
    listparser will be confused later on as mixing of fgets and read isn't
    a supported action according to the manpages and results are undefined */
-bool EDSP::ReadLine(int const input, std::string &line) {
+static bool ReadLine(int const input, std::string &line) {
 	char one;
 	ssize_t data = 0;
 	line.erase();
@@ -346,11 +720,11 @@ bool EDSP::ReadLine(int const input, std::string &line) {
 	return false;
 }
 									/*}}}*/
-// EDSP::StringToBool - convert yes/no to bool				/*{{{*/
+// StringToBool - convert yes/no to bool				/*{{{*/
 // ---------------------------------------------------------------------
 /* we are not as lazy as we are in the global StringToBool as we really
    only accept yes/no here - but we will ignore leading spaces */
-bool EDSP::StringToBool(char const *answer, bool const defValue) {
+static bool StringToBool(char const *answer, bool const defValue) {
    for (; isspace(*answer) != 0; ++answer);
    if (strncasecmp(answer, "yes", 3) == 0)
       return true;
@@ -361,16 +735,25 @@ bool EDSP::StringToBool(char const *answer, bool const defValue) {
    return defValue;
 }
 									/*}}}*/
+static bool ReadFlag(unsigned int &flags, std::string const &line, APT::StringView const name, unsigned int const setflag)/*{{{*/
+{
+   if (line.compare(0, name.length(), name.data()) != 0)
+      return false;
+   auto const l = line.c_str() + name.length() + 1;
+   if (StringToBool(l, false))
+      flags |= setflag;
+   else
+      flags &= ~setflag;
+   return true;
+}
+									/*}}}*/
 // EDSP::ReadRequest - first stanza from the given file descriptor	/*{{{*/
 bool EDSP::ReadRequest(int const input, std::list<std::string> &install,
-			std::list<std::string> &remove, bool &upgrade,
-			bool &distUpgrade, bool &autoRemove)
+			std::list<std::string> &remove, unsigned int &flags)
 {
    install.clear();
    remove.clear();
-   upgrade = false;
-   distUpgrade = false;
-   autoRemove = false;
+   flags = 0;
    std::string line;
    while (ReadLine(input, line) == true)
    {
@@ -398,12 +781,22 @@ bool EDSP::ReadRequest(int const input, std::list<std::string> &install,
 	    line.erase(0, 7);
 	    request = &remove;
 	 }
-	 else if (line.compare(0, 8, "Upgrade:") == 0)
-	    upgrade = EDSP::StringToBool(line.c_str() + 9, false);
-	 else if (line.compare(0, 13, "Dist-Upgrade:") == 0)
-	    distUpgrade = EDSP::StringToBool(line.c_str() + 14, false);
-	 else if (line.compare(0, 11, "Autoremove:") == 0)
-	    autoRemove = EDSP::StringToBool(line.c_str() + 12, false);
+	 else if (ReadFlag(flags, line, "Upgrade:", (Request::UPGRADE_ALL | Request::FORBID_REMOVE | Request::FORBID_NEW_INSTALL)) ||
+	       ReadFlag(flags, line, "Dist-Upgrade:", Request::UPGRADE_ALL) ||
+	       ReadFlag(flags, line, "Upgrade-All:", Request::UPGRADE_ALL) ||
+	       ReadFlag(flags, line, "Forbid-New-Install:", Request::FORBID_NEW_INSTALL) ||
+	       ReadFlag(flags, line, "Forbid-Remove:", Request::FORBID_REMOVE) ||
+	       ReadFlag(flags, line, "Autoremove:", Request::AUTOREMOVE))
+	    ;
+	 else if (line.compare(0, 13, "Architecture:") == 0)
+	    _config->Set("APT::Architecture", line.c_str() + 14);
+	 else if (line.compare(0, 14, "Architectures:") == 0)
+	 {
+	    std::string const archs = line.c_str() + 15;
+	    _config->Set("APT::Architectures", SubstVar(archs, " ", ","));
+	 }
+	 else if (line.compare(0, 7, "Solver:") == 0)
+	    ; // purely informational line
 	 else
 	    _error->Warning("Unknown line in EDSP Request stanza: %s", line.c_str());
 
@@ -425,6 +818,31 @@ bool EDSP::ReadRequest(int const input, std::list<std::string> &install,
       }
    }
    return false;
+}
+bool EDSP::ReadRequest(int const input, std::list<std::string> &install,
+			std::list<std::string> &remove, bool &upgrade,
+			bool &distUpgrade, bool &autoRemove)
+{
+   unsigned int flags;
+   auto const ret = ReadRequest(input, install, remove, flags);
+   autoRemove = (flags & Request::AUTOREMOVE);
+   if (flags & Request::UPGRADE_ALL)
+   {
+      if (flags & (Request::FORBID_NEW_INSTALL | Request::FORBID_REMOVE))
+      {
+	 upgrade = true;
+	 distUpgrade = false;
+      } else {
+	 upgrade = false;
+	 distUpgrade = false;
+      }
+   }
+   else
+   {
+      upgrade = false;
+      distUpgrade = false;
+   }
+   return ret;
 }
 									/*}}}*/
 // EDSP::ApplyRequest - first stanza from the given file descriptor	/*{{{*/
@@ -466,16 +884,16 @@ bool EDSP::WriteSolution(pkgDepCache &Cache, FILE* output)
       }
       else if (Cache[Pkg].NewInstall() == true || Cache[Pkg].Upgrade() == true)
       {
-	 fprintf(output, "Install: %d\n", Cache.GetCandidateVer(Pkg)->ID);
+	 pkgCache::VerIterator const CandVer = Cache.GetCandidateVersion(Pkg);
+	 fprintf(output, "Install: %d\n", CandVer->ID);
 	 if (Debug == true)
-	    fprintf(output, "Package: %s\nVersion: %s\n", Pkg.FullName().c_str(), Cache.GetCandidateVer(Pkg).VerStr());
+	    fprintf(output, "Package: %s\nVersion: %s\n", Pkg.FullName().c_str(), CandVer.VerStr());
       }
       else if (Cache[Pkg].Garbage == true)
       {
 	 fprintf(output, "Autoremove: %d\n", Pkg.CurrentVer()->ID);
 	 if (Debug == true)
 	    fprintf(output, "Package: %s\nVersion: %s\n", Pkg.FullName().c_str(), Pkg.CurrentVer().VerStr());
-	    fprintf(stderr, "Autoremove: %s\nVersion: %s\n", Pkg.FullName().c_str(), Pkg.CurrentVer().VerStr());
       }
       else
 	 continue;
@@ -483,6 +901,35 @@ bool EDSP::WriteSolution(pkgDepCache &Cache, FILE* output)
    }
 
    return true;
+}
+bool EDSP::WriteSolution(pkgDepCache &Cache, FileFd &output)
+{
+   bool const Debug = _config->FindB("Debug::EDSP::WriteSolution", false);
+   bool Okay = output.Failed() == false;
+   for (pkgCache::PkgIterator Pkg = Cache.PkgBegin(); Pkg.end() == false && likely(Okay); ++Pkg)
+   {
+      std::string action;
+      if (Cache[Pkg].Delete() == true)
+	 WriteOkay(Okay, output, "Remove: ", Pkg.CurrentVer()->ID, "\n");
+      else if (Cache[Pkg].NewInstall() == true || Cache[Pkg].Upgrade() == true)
+	 WriteOkay(Okay, output, "Install: ", Cache.GetCandidateVersion(Pkg)->ID, "\n");
+      else if (Cache[Pkg].Garbage == true)
+	 WriteOkay(Okay, output, "Autoremove: ", Pkg.CurrentVer()->ID, "\n");
+      else
+	 continue;
+
+      if (Debug)
+      {
+	 WriteOkay(Okay, output, "Package: ", Pkg.FullName(), "\nVersion: ");
+	 if (Cache[Pkg].Delete() == true || Cache[Pkg].Garbage == true)
+	    WriteOkay(Okay, output, Pkg.CurrentVer().VerStr(), "\n\n");
+	 else
+	    WriteOkay(Okay, output, Cache.GetCandidateVersion(Pkg).VerStr(), "\n\n");
+      }
+      else
+	 WriteOkay(Okay, output, "\n");
+   }
+   return Okay;
 }
 									/*}}}*/
 // EDSP::WriteProgess - pulse to the given file descriptor		/*{{{*/
@@ -492,6 +939,11 @@ bool EDSP::WriteProgress(unsigned short const percent, const char* const message
 	fprintf(output, "Message: %s\n\n", message);
 	fflush(output);
 	return true;
+}
+bool EDSP::WriteProgress(unsigned short const percent, const char* const message, FileFd &output) {
+	return WriteOkay(output, "Progress: ", TimeRFC1123(time(NULL)), "\n",
+	      "Percentage: ", percent, "\n",
+	      "Message: ", message, "\n\n") && output.Flush();
 }
 									/*}}}*/
 // EDSP::WriteError - format an error message to be send to file descriptor /*{{{*/
@@ -499,25 +951,35 @@ bool EDSP::WriteError(char const * const uuid, std::string const &message, FILE*
 	fprintf(output, "Error: %s\n", uuid);
 	fprintf(output, "Message: %s\n\n", SubstVar(SubstVar(message, "\n\n", "\n.\n"), "\n", "\n ").c_str());
 	return true;
+}
+bool EDSP::WriteError(char const * const uuid, std::string const &message, FileFd &output) {
+	return WriteOkay(output, "Error: ", uuid, "\n",
+	      "Message: ", SubstVar(SubstVar(message, "\n\n", "\n.\n"), "\n", "\n "),
+	      "\n\n");
 }
 									/*}}}*/
-// EDSP::ExecuteSolver - fork requested solver and setup ipc pipes	{{{*/
-bool EDSP::ExecuteSolver(const char* const solver, int *solver_in, int *solver_out) {
-	std::vector<std::string> const solverDirs = _config->FindVector("Dir::Bin::Solvers");
+static pid_t ExecuteExternal(char const* const type, char const * const binary, char const * const configdir, int * const solver_in, int * const solver_out) {/*{{{*/
+	std::vector<std::string> const solverDirs = _config->FindVector(configdir);
 	std::string file;
 	for (std::vector<std::string>::const_iterator dir = solverDirs.begin();
 	     dir != solverDirs.end(); ++dir) {
-		file = flCombine(*dir, solver);
+		file = flCombine(*dir, binary);
 		if (RealFileExists(file.c_str()) == true)
 			break;
 		file.clear();
 	}
 
 	if (file.empty() == true)
-		return _error->Error("Can't call external solver '%s' as it is not in a configured directory!", solver);
+	{
+		_error->Error("Can't call external %s '%s' as it is not in a configured directory!", type, binary);
+		return 0;
+	}
 	int external[4] = {-1, -1, -1, -1};
 	if (pipe(external) != 0 || pipe(external + 2) != 0)
-		return _error->Errno("Resolve", "Can't create needed IPC pipes for EDSP");
+	{
+		_error->Errno("Resolve", "Can't create needed IPC pipes for EDSP");
+		return 0;
+	}
 	for (int i = 0; i < 4; ++i)
 		SetCloseExec(external[i], true);
 
@@ -527,45 +989,71 @@ bool EDSP::ExecuteSolver(const char* const solver, int *solver_in, int *solver_o
 		dup2(external[3], STDOUT_FILENO);
 		const char* calling[2] = { file.c_str(), 0 };
 		execv(calling[0], (char**) calling);
-		std::cerr << "Failed to execute solver '" << solver << "'!" << std::endl;
+		std::cerr << "Failed to execute " << type << " '" << binary << "'!" << std::endl;
 		_exit(100);
 	}
 	close(external[0]);
 	close(external[3]);
 
 	if (WaitFd(external[1], true, 5) == false)
-		return _error->Errno("Resolve", "Timed out while Waiting on availability of solver stdin");
+	{
+		_error->Errno("Resolve", "Timed out while Waiting on availability of %s stdin", type);
+		return 0;
+	}
 
 	*solver_in = external[1];
 	*solver_out = external[2];
-	return true;
+	return Solver;
+}
+									/*}}}*/
+// EDSP::ExecuteSolver - fork requested solver and setup ipc pipes	{{{*/
+pid_t EDSP::ExecuteSolver(const char* const solver, int * const solver_in, int * const solver_out, bool) {
+	return ExecuteExternal("solver", solver, "Dir::Bin::Solvers", solver_in, solver_out);
+}
+bool EDSP::ExecuteSolver(const char* const solver, int *solver_in, int *solver_out) {
+   if (ExecuteSolver(solver, solver_in, solver_out, true) == 0)
+      return false;
+   return true;
 }
 									/*}}}*/
 // EDSP::ResolveExternal - resolve problems by asking external for help	{{{*/
 bool EDSP::ResolveExternal(const char* const solver, pkgDepCache &Cache,
-			 bool const upgrade, bool const distUpgrade,
-			 bool const autoRemove, OpProgress *Progress) {
+			 unsigned int const flags, OpProgress *Progress) {
 	int solver_in, solver_out;
-	if (EDSP::ExecuteSolver(solver, &solver_in, &solver_out) == false)
+	pid_t const solver_pid = EDSP::ExecuteSolver(solver, &solver_in, &solver_out, true);
+	if (solver_pid == 0)
 		return false;
 
-	FILE* output = fdopen(solver_in, "w");
-	if (output == NULL)
-		return _error->Errno("Resolve", "fdopen on solver stdin failed");
+	FileFd output;
+	if (output.OpenDescriptor(solver_in, FileFd::WriteOnly | FileFd::BufferedWrite, true) == false)
+		return _error->Errno("ResolveExternal", "Opening solver %s stdin on fd %d for writing failed", solver, solver_in);
 
+	bool Okay = output.Failed() == false;
 	if (Progress != NULL)
 		Progress->OverallProgress(0, 100, 5, _("Execute external solver"));
-	EDSP::WriteRequest(Cache, output, upgrade, distUpgrade, autoRemove, Progress);
+	Okay &= EDSP::WriteRequest(Cache, output, flags, Progress);
 	if (Progress != NULL)
 		Progress->OverallProgress(5, 100, 20, _("Execute external solver"));
-	EDSP::WriteScenario(Cache, output, Progress);
-	fclose(output);
+	Okay &= EDSP::WriteScenario(Cache, output, Progress);
+	output.Close();
 
 	if (Progress != NULL)
 		Progress->OverallProgress(25, 100, 75, _("Execute external solver"));
-	if (EDSP::ReadResponse(solver_out, Cache, Progress) == false)
+	if (Okay && EDSP::ReadResponse(solver_out, Cache, Progress) == false)
 		return false;
 
-	return true;
+	return ExecWait(solver_pid, solver);
+}
+bool EDSP::ResolveExternal(const char* const solver, pkgDepCache &Cache,
+			 bool const upgrade, bool const distUpgrade,
+			 bool const autoRemove, OpProgress *Progress) {
+   unsigned int flags = 0;
+   if (autoRemove)
+      flags |= Request::AUTOREMOVE;
+   if (upgrade)
+      flags |= Request::UPGRADE_ALL | Request::FORBID_REMOVE | Request::FORBID_NEW_INSTALL;
+   if (distUpgrade)
+      flags |= Request::UPGRADE_ALL;
+   return ResolveExternal(solver, Cache, flags, Progress);
 }
 									/*}}}*/