give a descriptive error for pipe tries with 'false'
[apt.git] / apt-pkg / edsp.cc
index 9596a9eb359f37daa445e4fe4d5099e7363de93d..27b269fd21cbf5cec6c066e279dc53566e15beeb 100644 (file)
 #include <apt-pkg/depcache.h>
 #include <apt-pkg/pkgcache.h>
 #include <apt-pkg/cacheiterators.h>
 #include <apt-pkg/depcache.h>
 #include <apt-pkg/pkgcache.h>
 #include <apt-pkg/cacheiterators.h>
+#include <apt-pkg/prettyprinters.h>
+#include <apt-pkg/packagemanager.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 <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 <apt-pkg/string_view.h>
+#include <apt-pkg/pkgsystem.h>
 
 
+#include <sys/stat.h>
 #include <ctype.h>
 #include <stddef.h>
 #include <string.h>
 #include <ctype.h>
 #include <stddef.h>
 #include <string.h>
@@ -114,51 +119,21 @@ static void WriteScenarioVersion(pkgDepCache &Cache, FILE* output, pkgCache::Pkg
    if ((Cache[Pkg].Flags & pkgCache::Flag::Auto) == pkgCache::Flag::Auto)
       fprintf(output, "APT-Automatic: yes\n");
 }
    if ((Cache[Pkg].Flags & pkgCache::Flag::Auto) == pkgCache::Flag::Auto)
       fprintf(output, "APT-Automatic: yes\n");
 }
-static bool WriteScenarioVersion(pkgDepCache &Cache, FileFd &output, pkgCache::PkgIterator const &Pkg,
+static bool WriteScenarioVersion(FileFd &output, pkgCache::PkgIterator const &Pkg,
                                pkgCache::VerIterator const &Ver)
 {
    bool Okay = WriteOkay(output, "Package: ", Pkg.Name(),
                                pkgCache::VerIterator const &Ver)
 {
    bool Okay = WriteOkay(output, "Package: ", Pkg.Name(),
-        "\nSource: ", Ver.SourcePkgName(),
         "\nArchitecture: ", Ver.Arch(),
         "\nArchitecture: ", Ver.Arch(),
-        "\nVersion: ", Ver.VerStr(),
-        "\nSource-Version: ", Ver.SourceVerStr());
-   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");
+        "\nVersion: ", Ver.VerStr());
    WriteOkay(Okay, output, "\nAPT-ID: ", Ver->ID);
    WriteOkay(Okay, output, "\nAPT-ID: ", Ver->ID);
-   if (PrioMap[Ver->Priority] != nullptr)
-      WriteOkay(Okay, output, "\nPriority: ", PrioMap[Ver->Priority]);
    if ((Pkg->Flags & pkgCache::Flag::Essential) == pkgCache::Flag::Essential)
       WriteOkay(Okay, output, "\nEssential: yes");
    if ((Pkg->Flags & pkgCache::Flag::Essential) == pkgCache::Flag::Essential)
       WriteOkay(Okay, output, "\nEssential: yes");
-   if (Ver->Section != 0)
-      WriteOkay(Okay, output, "\nSection: ", Ver.Section());
    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");
    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");
-   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;
 }
                                                                        /*}}}*/
    return Okay;
 }
                                                                        /*}}}*/
@@ -201,7 +176,7 @@ static void WriteScenarioDependency( FILE* output, pkgCache::VerIterator const &
    if (provides.empty() == false)
       fprintf(output, "Provides: %s\n", provides.c_str());
 }
    if (provides.empty() == false)
       fprintf(output, "Provides: %s\n", provides.c_str());
 }
-static bool WriteScenarioDependency(FileFd &output, pkgCache::VerIterator const &Ver)
+static bool WriteScenarioDependency(FileFd &output, pkgCache::VerIterator const &Ver, bool const OnlyCritical)
 {
    std::array<std::string, _count(DepMap)> dependencies;
    bool orGroup = false;
 {
    std::array<std::string, _count(DepMap)> dependencies;
    bool orGroup = false;
@@ -209,6 +184,8 @@ static bool WriteScenarioDependency(FileFd &output, pkgCache::VerIterator const
    {
       if (Dep.IsImplicit() == true)
         continue;
    {
       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 (orGroup == false && dependencies[Dep->Type].empty() == false)
         dependencies[Dep->Type].append(", ");
       dependencies[Dep->Type].append(Dep.TargetPkg().Name());
@@ -300,7 +277,8 @@ static void WriteScenarioLimitedDependency(FILE* output,
 }
 static bool WriteScenarioLimitedDependency(FileFd &output,
                                          pkgCache::VerIterator const &Ver,
 }
 static bool WriteScenarioLimitedDependency(FileFd &output,
                                          pkgCache::VerIterator const &Ver,
-                                         APT::PackageSet const &pkgset)
+                                         std::vector<bool> const &pkgset,
+                                         bool const OnlyCritical)
 {
    std::array<std::string, _count(DepMap)> dependencies;
    bool orGroup = false;
 {
    std::array<std::string, _count(DepMap)> dependencies;
    bool orGroup = false;
@@ -308,14 +286,16 @@ static bool WriteScenarioLimitedDependency(FileFd &output,
    {
       if (Dep.IsImplicit() == true)
         continue;
    {
       if (Dep.IsImplicit() == true)
         continue;
+      if (OnlyCritical && Dep.IsCritical() == false)
+        continue;
       if (orGroup == false)
       {
       if (orGroup == false)
       {
-        if (pkgset.find(Dep.TargetPkg()) == pkgset.end())
+        if (pkgset[Dep.TargetPkg()->ID] == false)
            continue;
         if (dependencies[Dep->Type].empty() == false)
            dependencies[Dep->Type].append(", ");
       }
            continue;
         if (dependencies[Dep->Type].empty() == false)
            dependencies[Dep->Type].append(", ");
       }
-      else if (pkgset.find(Dep.TargetPkg()) == pkgset.end())
+      else if (pkgset[Dep.TargetPkg()->ID] == false)
       {
         if ((Dep->CompareOp & pkgCache::Dep::Or) == pkgCache::Dep::Or)
            continue;
       {
         if ((Dep->CompareOp & pkgCache::Dep::Or) == pkgCache::Dep::Or)
            continue;
@@ -343,7 +323,7 @@ static bool WriteScenarioLimitedDependency(FileFd &output,
    {
       if (Prv.IsMultiArchImplicit() == true)
         continue;
    {
       if (Prv.IsMultiArchImplicit() == true)
         continue;
-      if (pkgset.find(Prv.ParentPkg()) == pkgset.end())
+      if (pkgset[Prv.ParentPkg()->ID] == false)
         continue;
       if (provides.empty() == false)
         provides.append(", ");
         continue;
       if (provides.empty() == false)
         provides.append(", ");
@@ -374,6 +354,42 @@ static bool SkipUnavailableVersions(pkgDepCache &Cache, pkgCache::PkgIterator co
    return true;
 }
                                                                        /*}}}*/
    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)
 {
 // EDSP::WriteScenario - to the given file descriptor                  /*{{{*/
 bool EDSP::WriteScenario(pkgDepCache &Cache, FILE* output, OpProgress *Progress)
 {
@@ -415,8 +431,9 @@ bool EDSP::WriteScenario(pkgDepCache &Cache, FileFd &output, OpProgress *Progres
       {
         if (SkipUnavailableVersions(Cache, Pkg, Ver))
            continue;
       {
         if (SkipUnavailableVersions(Cache, Pkg, Ver))
            continue;
-        Okay &= WriteScenarioVersion(Cache, output, Pkg, Ver);
-        Okay &= WriteScenarioDependency(output, Ver);
+        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);
         WriteOkay(Okay, output, "\n");
         if (Progress != NULL && p % 100 == 0)
            Progress->Progress(p);
@@ -449,24 +466,29 @@ bool EDSP::WriteLimitedScenario(pkgDepCache &Cache, FILE* output,
    return true;
 }
 bool EDSP::WriteLimitedScenario(pkgDepCache &Cache, FileFd &output,
    return true;
 }
 bool EDSP::WriteLimitedScenario(pkgDepCache &Cache, FileFd &output,
-                               APT::PackageSet const &pkgset,
+                               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;
                                OpProgress *Progress)
 {
    if (Progress != NULL)
       Progress->SubProgress(Cache.Head().VersionCount, _("Send scenario to solver"));
    unsigned long p  = 0;
    bool Okay = output.Failed() == false;
-   for (APT::PackageSet::const_iterator Pkg = pkgset.begin(); Pkg != pkgset.end() && likely(Okay); ++Pkg, ++p)
+   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;
       for (pkgCache::VerIterator Ver = Pkg.VersionList(); Ver.end() == false && likely(Okay); ++Ver)
       {
         if (SkipUnavailableVersions(Cache, Pkg, Ver))
            continue;
-        Okay &= WriteScenarioVersion(Cache, output, Pkg, Ver);
-        Okay &= WriteScenarioLimitedDependency(output, Ver, pkgset);
+        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);
       }
         WriteOkay(Okay, output, "\n");
         if (Progress != NULL && p % 100 == 0)
            Progress->Progress(p);
       }
+   }
    if (Progress != NULL)
       Progress->Done();
    return Okay;
    if (Progress != NULL)
       Progress->Done();
    return Okay;
@@ -527,8 +549,8 @@ bool EDSP::WriteRequest(pkgDepCache &Cache, FILE* output, bool const Upgrade,
    fprintf(output, "\n");
    return true;
 }
    fprintf(output, "\n");
    return true;
 }
-bool EDSP::WriteRequest(pkgDepCache &Cache, FileFd &output, bool const Upgrade,
-                       bool const DistUpgrade, bool const AutoRemove,
+bool EDSP::WriteRequest(pkgDepCache &Cache, FileFd &output,
+                       unsigned int const flags,
                        OpProgress *Progress)
 {
    if (Progress != NULL)
                        OpProgress *Progress)
 {
    if (Progress != NULL)
@@ -564,16 +586,26 @@ bool EDSP::WriteRequest(pkgDepCache &Cache, FileFd &output, bool const Upgrade,
       WriteOkay(Okay, output, "Remove:", del, "\n");
    if (inst.empty() == false)
       WriteOkay(Okay, output, "Install:", inst, "\n");
       WriteOkay(Okay, output, "Remove:", del, "\n");
    if (inst.empty() == false)
       WriteOkay(Okay, output, "Install:", inst, "\n");
-   if (Upgrade == true)
-      WriteOkay(Okay, output, "Upgrade: yes\n");
-   if (DistUpgrade == true)
-      WriteOkay(Okay, output, "Dist-Upgrade: yes\n");
-   if (AutoRemove == true)
+   if (flags & Request::AUTOREMOVE)
       WriteOkay(Okay, output, "Autoremove: yes\n");
       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");
+   auto const solver = _config->Find("APT::Solver", "internal");
+   WriteOkay(Okay, output, "Solver: ", solver, "\n");
    if (_config->FindB("APT::Solver::Strict-Pinning", true) == false)
       WriteOkay(Okay, output, "Strict-Pinning: no\n");
    string solverpref("APT::Solver::");
    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");
+   solverpref.append(solver).append("::Preferences");
    if (_config->Exists(solverpref) == true)
       WriteOkay(Okay, output, "Preferences: ", _config->Find(solverpref,""), "\n");
    return WriteOkay(Okay, output, "\n");
    if (_config->Exists(solverpref) == true)
       WriteOkay(Okay, output, "Preferences: ", _config->Find(solverpref,""), "\n");
    return WriteOkay(Okay, output, "\n");
@@ -595,7 +627,7 @@ bool EDSP::ReadResponse(int const input, pkgDepCache &Cache, OpProgress *Progres
        }
 
        FileFd in;
        }
 
        FileFd in;
-       in.OpenDescriptor(input, FileFd::ReadOnly);
+       in.OpenDescriptor(input, FileFd::ReadOnly, true);
        pkgTagFile response(&in, 100);
        pkgTagSection section;
 
        pkgTagFile response(&in, 100);
        pkgTagSection section;
 
@@ -629,8 +661,12 @@ bool EDSP::ReadResponse(int const input, pkgDepCache &Cache, OpProgress *Progres
                        return false;
                } else if (section.Exists("Autoremove") == true)
                        type = "Autoremove";
                        return false;
                } else if (section.Exists("Autoremove") == true)
                        type = "Autoremove";
-               else
+               else {
+                       char const *Start, *End;
+                       section.GetSection(Start, End);
+                       _error->Warning("Encountered an unexpected section with %d fields: %s", section.Count(), std::string(Start, End).c_str());
                        continue;
                        continue;
+               }
 
                size_t const id = section.FindULL(type.c_str(), VersionCount);
                if (id == VersionCount) {
 
                size_t const id = section.FindULL(type.c_str(), VersionCount);
                if (id == VersionCount) {
@@ -698,28 +734,44 @@ static bool ReadLine(int const input, std::string &line) {
 // StringToBool - convert yes/no to bool                               /*{{{*/
 // ---------------------------------------------------------------------
 /* we are not as lazy as we are in the global StringToBool as we really
 // 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 */
-static bool StringToBool(char const *answer, bool const defValue) {
-   for (; isspace(*answer) != 0; ++answer);
-   if (strncasecmp(answer, "yes", 3) == 0)
+   only accept yes/no here */
+static bool localStringToBool(std::string answer, bool const defValue) {
+   std::transform(answer.begin(), answer.end(), answer.begin(), ::tolower);
+   if (answer == "yes")
       return true;
       return true;
-   else if (strncasecmp(answer, "no", 2) == 0)
+   else if (answer == "no")
       return false;
    else
       return false;
    else
-      _error->Warning("Value '%s' is not a boolean 'yes' or 'no'!", answer);
+      _error->Warning("Value '%s' is not a boolean 'yes' or 'no'!", answer.c_str());
    return defValue;
 }
                                                                        /*}}}*/
    return defValue;
 }
                                                                        /*}}}*/
+static bool LineStartsWithAndStrip(std::string &line, APT::StringView const with)/*{{{*/
+{
+   if (line.compare(0, with.size(), with.data()) != 0)
+      return false;
+   line = APT::String::Strip(line.substr(with.length()));
+   return true;
+}
+                                                                       /*}}}*/
+static bool ReadFlag(unsigned int &flags, std::string &line, APT::StringView const name, unsigned int const setflag)/*{{{*/
+{
+   if (LineStartsWithAndStrip(line, name) == false)
+      return false;
+   if (localStringToBool(line, 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,
 // 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();
 {
    install.clear();
    remove.clear();
-   upgrade = false;
-   distUpgrade = false;
-   autoRemove = false;
+   flags = 0;
    std::string line;
    while (ReadLine(input, line) == true)
    {
    std::string line;
    while (ReadLine(input, line) == true)
    {
@@ -727,7 +779,7 @@ bool EDSP::ReadRequest(int const input, std::list<std::string> &install,
       if (line.empty() == true)
         continue;
       // The first Tag must be a request, so search for it
       if (line.empty() == true)
         continue;
       // The first Tag must be a request, so search for it
-      if (line.compare(0, 8, "Request:") != 0)
+      if (LineStartsWithAndStrip(line, "Request:"))
         continue;
 
       while (ReadLine(input, line) == true)
         continue;
 
       while (ReadLine(input, line) == true)
@@ -737,52 +789,58 @@ bool EDSP::ReadRequest(int const input, std::list<std::string> &install,
            return true;
 
         std::list<std::string> *request = NULL;
            return true;
 
         std::list<std::string> *request = NULL;
-        if (line.compare(0, 8, "Install:") == 0)
-        {
-           line.erase(0, 8);
+        if (LineStartsWithAndStrip(line, "Install:"))
            request = &install;
            request = &install;
-        }
-        else if (line.compare(0, 7, "Remove:") == 0)
-        {
-           line.erase(0, 7);
+        else if (LineStartsWithAndStrip(line, "Remove:"))
            request = &remove;
            request = &remove;
-        }
-        else if (line.compare(0, 8, "Upgrade:") == 0)
-           upgrade = StringToBool(line.c_str() + 9, false);
-        else if (line.compare(0, 13, "Dist-Upgrade:") == 0)
-           distUpgrade = StringToBool(line.c_str() + 14, false);
-        else if (line.compare(0, 11, "Autoremove:") == 0)
-           autoRemove = StringToBool(line.c_str() + 12, false);
-        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)
+        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 (LineStartsWithAndStrip(line, "Architecture:"))
+           _config->Set("APT::Architecture", line);
+        else if (LineStartsWithAndStrip(line, "Architectures:"))
+           _config->Set("APT::Architectures", SubstVar(line, " ", ","));
+        else if (LineStartsWithAndStrip(line, "Solver:"))
            ; // purely informational line
         else
            _error->Warning("Unknown line in EDSP Request stanza: %s", line.c_str());
 
         if (request == NULL)
            continue;
            ; // purely informational line
         else
            _error->Warning("Unknown line in EDSP Request stanza: %s", line.c_str());
 
         if (request == NULL)
            continue;
-        size_t end = line.length();
-        do {
-           size_t begin = line.rfind(' ');
-           if (begin == std::string::npos)
-           {
-              request->push_back(line.substr(0, end));
-              break;
-           }
-           else if (begin < end)
-              request->push_back(line.substr(begin + 1, end));
-           line.erase(begin);
-           end = line.find_last_not_of(' ');
-        } while (end != std::string::npos);
+        auto const pkgs = VectorizeString(line, ' ');
+        std::move(pkgs.begin(), pkgs.end(), std::back_inserter(*request));
       }
    }
    return false;
       }
    }
    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    /*{{{*/
 }
                                                                        /*}}}*/
 // EDSP::ApplyRequest - first stanza from the given file descriptor    /*{{{*/
@@ -810,7 +868,7 @@ bool EDSP::ApplyRequest(std::list<std::string> const &install,
        return true;
 }
                                                                        /*}}}*/
        return true;
 }
                                                                        /*}}}*/
-// EDSP::WriteSolution - to the given file descriptor                  /*{{{*/
+// EDSP::WriteSolutionStanza - to the given file descriptor            /*{{{*/
 bool EDSP::WriteSolution(pkgDepCache &Cache, FILE* output)
 {
    bool const Debug = _config->FindB("Debug::EDSP::WriteSolution", false);
 bool EDSP::WriteSolution(pkgDepCache &Cache, FILE* output)
 {
    bool const Debug = _config->FindB("Debug::EDSP::WriteSolution", false);
@@ -818,20 +876,20 @@ bool EDSP::WriteSolution(pkgDepCache &Cache, FILE* output)
    {
       if (Cache[Pkg].Delete() == true)
       {
    {
       if (Cache[Pkg].Delete() == true)
       {
-        fprintf(output, "Remove: %d\n", Pkg.CurrentVer()->ID);
+        fprintf(output, "Remove: %d\n", _system->GetVersionMapping(Pkg.CurrentVer()->ID));
         if (Debug == true)
            fprintf(output, "Package: %s\nVersion: %s\n", Pkg.FullName().c_str(), Pkg.CurrentVer().VerStr());
       }
       else if (Cache[Pkg].NewInstall() == true || Cache[Pkg].Upgrade() == true)
       {
         pkgCache::VerIterator const CandVer = Cache.GetCandidateVersion(Pkg);
         if (Debug == true)
            fprintf(output, "Package: %s\nVersion: %s\n", Pkg.FullName().c_str(), Pkg.CurrentVer().VerStr());
       }
       else if (Cache[Pkg].NewInstall() == true || Cache[Pkg].Upgrade() == true)
       {
         pkgCache::VerIterator const CandVer = Cache.GetCandidateVersion(Pkg);
-        fprintf(output, "Install: %d\n", CandVer->ID);
+        fprintf(output, "Install: %d\n", _system->GetVersionMapping(CandVer->ID));
         if (Debug == true)
            fprintf(output, "Package: %s\nVersion: %s\n", Pkg.FullName().c_str(), CandVer.VerStr());
       }
       else if (Cache[Pkg].Garbage == true)
       {
         if (Debug == true)
            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);
+        fprintf(output, "Autoremove: %d\n", _system->GetVersionMapping(Pkg.CurrentVer()->ID));
         if (Debug == true)
            fprintf(output, "Package: %s\nVersion: %s\n", Pkg.FullName().c_str(), Pkg.CurrentVer().VerStr());
       }
         if (Debug == true)
            fprintf(output, "Package: %s\nVersion: %s\n", Pkg.FullName().c_str(), Pkg.CurrentVer().VerStr());
       }
@@ -842,46 +900,25 @@ bool EDSP::WriteSolution(pkgDepCache &Cache, FILE* output)
 
    return true;
 }
 
    return true;
 }
-bool EDSP::WriteSolution(pkgDepCache &Cache, FileFd &output)
+bool EDSP::WriteSolutionStanza(FileFd &output, char const * const Type, pkgCache::VerIterator const &Ver)
 {
 {
-   bool const Debug = _config->FindB("Debug::EDSP::WriteSolution", false);
    bool Okay = output.Failed() == 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;
+   WriteOkay(Okay, output, Type, ": ", _system->GetVersionMapping(Ver->ID));
+   if (_config->FindB("Debug::EDSP::WriteSolution", false) == true)
+      WriteOkay(Okay, output, "\nPackage: ", Ver.ParentPkg().FullName(), "\nVersion: ", Ver.VerStr());
+   return WriteOkay(Okay, output, "\n\n");
 }
                                                                        /*}}}*/
 // EDSP::WriteProgess - pulse to the given file descriptor             /*{{{*/
 bool EDSP::WriteProgress(unsigned short const percent, const char* const message, FILE* output) {
 }
                                                                        /*}}}*/
 // EDSP::WriteProgess - pulse to the given file descriptor             /*{{{*/
 bool EDSP::WriteProgress(unsigned short const percent, const char* const message, FILE* output) {
-       fprintf(output, "Progress: %s\n", TimeRFC1123(time(NULL)).c_str());
+       fprintf(output, "Progress: %s\n", TimeRFC1123(time(NULL), true).c_str());
        fprintf(output, "Percentage: %d\n", percent);
        fprintf(output, "Message: %s\n\n", message);
        fflush(output);
        return true;
 }
 bool EDSP::WriteProgress(unsigned short const percent, const char* const message, FileFd &output) {
        fprintf(output, "Percentage: %d\n", percent);
        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",
+       return WriteOkay(output, "Progress: ", TimeRFC1123(time(NULL), true), "\n",
              "Percentage: ", percent, "\n",
              "Message: ", message, "\n\n") && output.Flush();
 }
              "Percentage: ", percent, "\n",
              "Message: ", message, "\n\n") && output.Flush();
 }
@@ -898,21 +935,28 @@ bool EDSP::WriteError(char const * const uuid, std::string const &message, FileF
              "\n\n");
 }
                                                                        /*}}}*/
              "\n\n");
 }
                                                                        /*}}}*/
-// 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) {
-       std::vector<std::string> const solverDirs = _config->FindVector("Dir::Bin::Solvers");
-       std::string file;
-       for (std::vector<std::string>::const_iterator dir = solverDirs.begin();
-            dir != solverDirs.end(); ++dir) {
-               file = flCombine(*dir, solver);
-               if (RealFileExists(file.c_str()) == true)
-                       break;
-               file.clear();
+static std::string findExecutable(std::vector<std::string> const &dirs, char const * const binary) {/*{{{*/
+       for (auto && dir : dirs) {
+               std::string const file = flCombine(dir, binary);
+               if (RealFileExists(file) == true)
+                       return file;
+       }
+       return "";
+}
+                                                                       /*}}}*/
+static pid_t ExecuteExternal(char const* const type, char const * const binary, char const * const configdir, int * const solver_in, int * const solver_out) {/*{{{*/
+       auto const solverDirs = _config->FindVector(configdir);
+       auto const file = findExecutable(solverDirs, binary);
+       std::string dumper;
+       {
+               dumper = findExecutable(solverDirs, "apt-dump-solver");
+               if (dumper.empty())
+                       dumper = findExecutable(solverDirs, "dump");
        }
 
        if (file.empty() == true)
        {
        }
 
        if (file.empty() == true)
        {
-               _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};
                return 0;
        }
        int external[4] = {-1, -1, -1, -1};
@@ -928,9 +972,24 @@ pid_t EDSP::ExecuteSolver(const char* const solver, int * const solver_in, int *
        if (Solver == 0) {
                dup2(external[0], STDIN_FILENO);
                dup2(external[3], STDOUT_FILENO);
        if (Solver == 0) {
                dup2(external[0], STDIN_FILENO);
                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;
+               auto const dumpfile = _config->FindFile((std::string("Dir::Log::") + type).c_str());
+               auto const dumpdir = flNotFile(dumpfile);
+               auto const runasuser = _config->Find(std::string("APT::") + type + "::" + binary + "::RunAsUser",
+                     _config->Find(std::string("APT::") + type + "::RunAsUser",
+                        _config->Find("APT::Sandbox::User")));
+               if (dumper.empty() || dumpfile.empty() || dumper == file || CreateAPTDirectoryIfNeeded(dumpdir, dumpdir) == false)
+               {
+                  _config->Set("APT::Sandbox::User", runasuser);
+                  DropPrivileges();
+                  char const * const calling[] = { file.c_str(), nullptr };
+                  execv(calling[0], const_cast<char**>(calling));
+               }
+               else
+               {
+                  char const * const calling[] = { dumper.c_str(), "--user", runasuser.c_str(), dumpfile.c_str(), file.c_str(), nullptr };
+                  execv(calling[0], const_cast<char**>(calling));
+               }
+               std::cerr << "Failed to execute " << type << " '" << binary << "'!" << std::endl;
                _exit(100);
        }
        close(external[0]);
                _exit(100);
        }
        close(external[0]);
@@ -938,13 +997,18 @@ pid_t EDSP::ExecuteSolver(const char* const solver, int * const solver_in, int *
 
        if (WaitFd(external[1], true, 5) == false)
        {
 
        if (WaitFd(external[1], true, 5) == false)
        {
-               _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 Solver;
                return 0;
        }
 
        *solver_in = external[1];
        *solver_out = external[2];
        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)
 }
 bool EDSP::ExecuteSolver(const char* const solver, int *solver_in, int *solver_out) {
    if (ExecuteSolver(solver, solver_in, solver_out, true) == 0)
@@ -954,8 +1018,20 @@ bool EDSP::ExecuteSolver(const char* const solver, int *solver_in, int *solver_o
                                                                        /*}}}*/
 // EDSP::ResolveExternal - resolve problems by asking external for help        {{{*/
 bool EDSP::ResolveExternal(const char* const solver, pkgDepCache &Cache,
                                                                        /*}}}*/
 // 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) {
+       if (strcmp(solver, "internal") == 0)
+       {
+               auto const dumpfile = _config->FindFile("Dir::Log::Solver");
+               if (dumpfile.empty())
+                       return false;
+               auto const dumpdir = flNotFile(dumpfile);
+               FileFd output;
+               if (CreateAPTDirectoryIfNeeded(dumpdir, dumpdir) == false ||
+                     output.Open(dumpfile, FileFd::WriteOnly | FileFd::Exclusive | FileFd::Create, FileFd::Extension, 0644) == false)
+                       return _error->WarningE("EDSP::Resolve", _("Could not open file '%s'"), dumpfile.c_str());
+               bool Okay = EDSP::WriteRequest(Cache, output, flags, nullptr);
+               return Okay && EDSP::WriteScenario(Cache, output, nullptr);
+       }
        int solver_in, solver_out;
        pid_t const solver_pid = EDSP::ExecuteSolver(solver, &solver_in, &solver_out, true);
        if (solver_pid == 0)
        int solver_in, solver_out;
        pid_t const solver_pid = EDSP::ExecuteSolver(solver, &solver_in, &solver_out, true);
        if (solver_pid == 0)
@@ -968,7 +1044,7 @@ bool EDSP::ResolveExternal(const char* const solver, pkgDepCache &Cache,
        bool Okay = output.Failed() == false;
        if (Progress != NULL)
                Progress->OverallProgress(0, 100, 5, _("Execute external solver"));
        bool Okay = output.Failed() == false;
        if (Progress != NULL)
                Progress->OverallProgress(0, 100, 5, _("Execute external solver"));
-       Okay &= 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"));
        Okay &= EDSP::WriteScenario(Cache, output, Progress);
        if (Progress != NULL)
                Progress->OverallProgress(5, 100, 20, _("Execute external solver"));
        Okay &= EDSP::WriteScenario(Cache, output, Progress);
@@ -980,5 +1056,413 @@ bool EDSP::ResolveExternal(const char* const solver, pkgDepCache &Cache,
                return false;
 
        return ExecWait(solver_pid, solver);
                return false;
 
        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);
+}
+                                                                       /*}}}*/
+
+bool EIPP::OrderInstall(char const * const solver, pkgPackageManager * const PM,       /*{{{*/
+                        unsigned int const flags, OpProgress * const Progress)
+{
+   if (strcmp(solver, "internal") == 0)
+   {
+      auto const dumpfile = _config->FindFile("Dir::Log::Planner");
+      if (dumpfile.empty())
+        return false;
+      auto const dumpdir = flNotFile(dumpfile);
+      FileFd output;
+      if (CreateAPTDirectoryIfNeeded(dumpdir, dumpdir) == false ||
+           output.Open(dumpfile, FileFd::WriteOnly | FileFd::Exclusive | FileFd::Create, FileFd::Extension, 0644) == false)
+        return _error->WarningE("EIPP::OrderInstall", _("Could not open file '%s'"), dumpfile.c_str());
+      bool Okay = EIPP::WriteRequest(PM->Cache, output, flags, nullptr);
+      return Okay && EIPP::WriteScenario(PM->Cache, output, nullptr);
+   }
+
+   int solver_in, solver_out;
+   pid_t const solver_pid = ExecuteExternal("planner", solver, "Dir::Bin::Planners", &solver_in, &solver_out);
+   if (solver_pid == 0)
+      return false;
+
+   FileFd output;
+   if (output.OpenDescriptor(solver_in, FileFd::WriteOnly | FileFd::BufferedWrite, true) == false)
+      return _error->Errno("EIPP::OrderInstall", "Opening planner %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 planner"));
+   Okay &= EIPP::WriteRequest(PM->Cache, output, flags, Progress);
+   if (Progress != NULL)
+      Progress->OverallProgress(5, 100, 20, _("Execute external planner"));
+   Okay &= EIPP::WriteScenario(PM->Cache, output, Progress);
+   output.Close();
+
+   if (Progress != NULL)
+      Progress->OverallProgress(25, 100, 75, _("Execute external planner"));
+
+   // we don't tell the external planners about boring things
+   for (auto Pkg = PM->Cache.PkgBegin(); Pkg.end() == false; ++Pkg)
+   {
+      if (Pkg->CurrentState == pkgCache::State::ConfigFiles && PM->Cache[Pkg].Purge() == true)
+        PM->Remove(Pkg, true);
+   }
+
+   if (Okay && EIPP::ReadResponse(solver_out, PM, Progress) == false)
+      return false;
+
+   return ExecWait(solver_pid, solver);
+}
+                                                                       /*}}}*/
+bool EIPP::WriteRequest(pkgDepCache &Cache, FileFd &output,            /*{{{*/
+                       unsigned int const flags,
+                       OpProgress * const Progress)
+{
+   if (Progress != NULL)
+      Progress->SubProgress(Cache.Head().PackageCount, _("Send request to planner"));
+   unsigned long p = 0;
+   string del, inst, reinst;
+   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.Purge() == true && Pkg->CurrentState == pkgCache::State::ConfigFiles)
+        continue;
+      if (P.Delete() == true)
+        req = &del;
+      else if (P.NewInstall() == true || P.Upgrade() == true || P.Downgrade() == true)
+        req = &inst;
+      else if (P.ReInstall() == true)
+        req = &reinst;
+      else
+        continue;
+      req->append(" ").append(Pkg.FullName());
+   }
+   bool Okay = WriteOkay(output, "Request: EIPP 0.1\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 (reinst.empty() == false)
+      WriteOkay(Okay, output, "ReInstall:", reinst, "\n");
+   WriteOkay(Okay, output, "Planner: ", _config->Find("APT::Planner", "internal"), "\n");
+   if ((flags & Request::IMMEDIATE_CONFIGURATION_ALL) != 0)
+      WriteOkay(Okay, output, "Immediate-Configuration: yes\n");
+   else if ((flags & Request::NO_IMMEDIATE_CONFIGURATION) != 0)
+      WriteOkay(Okay, output, "Immediate-Configuration: no\n");
+   else if ((flags & Request::ALLOW_TEMPORARY_REMOVE_OF_ESSENTIALS) != 0)
+      WriteOkay(Okay, output, "Allow-Temporary-Remove-of-Essentials: yes\n");
+   return WriteOkay(Okay, output, "\n");
+}
+                                                                       /*}}}*/
+static bool WriteScenarioEIPPVersion(pkgDepCache &, FileFd &output, pkgCache::PkgIterator const &Pkg,/*{{{*/
+                               pkgCache::VerIterator const &Ver)
+{
+   bool Okay = true;
+   if (Pkg.CurrentVer() == Ver)
+      switch (Pkg->CurrentState)
+      {
+        case pkgCache::State::NotInstalled: WriteOkay(Okay, output, "\nStatus: not-installed"); break;
+        case pkgCache::State::ConfigFiles: WriteOkay(Okay, output, "\nStatus: config-files"); break;
+        case pkgCache::State::HalfInstalled: WriteOkay(Okay, output, "\nStatus: half-installed"); break;
+        case pkgCache::State::UnPacked: WriteOkay(Okay, output, "\nStatus: unpacked"); break;
+        case pkgCache::State::HalfConfigured: WriteOkay(Okay, output, "\nStatus: half-configured"); break;
+        case pkgCache::State::TriggersAwaited: WriteOkay(Okay, output, "\nStatus: triggers-awaited"); break;
+        case pkgCache::State::TriggersPending: WriteOkay(Okay, output, "\nStatus: triggers-pending"); break;
+        case pkgCache::State::Installed: WriteOkay(Okay, output, "\nStatus: installed"); break;
+      }
+   return Okay;
+}
+                                                                       /*}}}*/
+// EIPP::WriteScenario - to the given file descriptor                  /*{{{*/
+template<typename forVersion> void forAllInterestingVersions(pkgDepCache &Cache, pkgCache::PkgIterator const &Pkg, forVersion const &func)
+{
+   if (Pkg->CurrentState == pkgCache::State::NotInstalled)
+   {
+      auto P = Cache[Pkg];
+      if (P.Install() == false)
+        return;
+      func(Pkg, P.InstVerIter(Cache));
+   }
+   else
+   {
+      if (Pkg->CurrentVer != 0)
+        func(Pkg, Pkg.CurrentVer());
+      auto P = Cache[Pkg];
+      auto const V = P.InstVerIter(Cache);
+      if (P.Delete() == false && Pkg.CurrentVer() != V)
+        func(Pkg, V);
+   }
+}
+
+bool EIPP::WriteScenario(pkgDepCache &Cache, FileFd &output, OpProgress * const Progress)
+{
+   if (Progress != NULL)
+      Progress->SubProgress(Cache.Head().PackageCount, _("Send scenario to planner"));
+   unsigned long p = 0;
+   bool Okay = output.Failed() == false;
+   std::vector<std::string> archs = APT::Configuration::getArchitectures();
+   std::vector<bool> pkgset(Cache.Head().PackageCount, false);
+   auto const MarkVersion = [&](pkgCache::PkgIterator const &Pkg, pkgCache::VerIterator const &Ver) {
+      pkgset[Pkg->ID] = true;
+      for (auto D = Ver.DependsList(); D.end() == false; ++D)
+      {
+        if (D.IsCritical() == false)
+           continue;
+        auto const P = D.TargetPkg();
+        for (auto Prv = P.ProvidesList(); Prv.end() == false; ++Prv)
+        {
+           auto const V = Prv.OwnerVer();
+           auto const PV = V.ParentPkg();
+           if (V == PV.CurrentVer() || V == Cache[PV].InstVerIter(Cache))
+              pkgset[PV->ID] = true;
+        }
+        pkgset[P->ID] = true;
+        if (strcmp(P.Arch(), "any") == 0)
+        {
+           APT::StringView const pkgname(P.Name());
+           auto const idxColon = pkgname.find(':');
+           if (idxColon != APT::StringView::npos)
+           {
+              pkgCache::PkgIterator PA;
+              if (pkgname.substr(idxColon + 1) == "any")
+              {
+                 auto const GA = Cache.FindGrp(pkgname.substr(0, idxColon).to_string());
+                 for (auto PA = GA.PackageList(); PA.end() == false; PA = GA.NextPkg(PA))
+                 {
+                    pkgset[PA->ID] = true;
+                 }
+              }
+              else
+              {
+                 auto const PA = Cache.FindPkg(pkgname.to_string());
+                 if (PA.end() == false)
+                    pkgset[PA->ID] = true;
+              }
+           }
+        }
+        else
+        {
+           auto const PA = Cache.FindPkg(P.FullName(false), "any");
+           if (PA.end() == false)
+              pkgset[PA->ID] = true;
+        }
+      }
+   };
+   for (pkgCache::PkgIterator Pkg = Cache.PkgBegin(); Pkg.end() == false; ++Pkg)
+      forAllInterestingVersions(Cache, Pkg, MarkVersion);
+   auto const WriteVersion = [&](pkgCache::PkgIterator const &Pkg, pkgCache::VerIterator const &Ver) {
+      Okay &= WriteScenarioVersion(output, Pkg, Ver);
+      Okay &= WriteScenarioEIPPVersion(Cache, output, Pkg, Ver);
+      Okay &= WriteScenarioLimitedDependency(output, Ver, pkgset, true);
+      WriteOkay(Okay, output, "\n");
+      if (Progress != NULL && p % 100 == 0)
+        Progress->Progress(p);
+   };
+   for (pkgCache::PkgIterator Pkg = Cache.PkgBegin(); Pkg.end() == false && likely(Okay); ++Pkg, ++p)
+   {
+      if (pkgset[Pkg->ID] == false || Pkg->VersionList == 0)
+        continue;
+      forAllInterestingVersions(Cache, Pkg, WriteVersion);
+   }
+   return true;
+}
+                                                                       /*}}}*/
+// EIPP::ReadResponse - from the given file descriptor                 /*{{{*/
+bool EIPP::ReadResponse(int const input, pkgPackageManager * const PM, OpProgress *Progress) {
+   /* We build an map id to mmap offset here
+      In theory we could use the offset as ID, but then VersionCount
+      couldn't be used to create other versionmappings anymore and it
+      would be too easy for a (buggy) solver to segfault APT… */
+   unsigned long long const VersionCount = PM->Cache.Head().VersionCount;
+   unsigned long VerIdx[VersionCount];
+   for (pkgCache::PkgIterator P = PM->Cache.PkgBegin(); P.end() == false; ++P) {
+      for (pkgCache::VerIterator V = P.VersionList(); V.end() == false; ++V)
+        VerIdx[V->ID] = V.Index();
+   }
+
+   FileFd in;
+   in.OpenDescriptor(input, FileFd::ReadOnly);
+   pkgTagFile response(&in, 100);
+   pkgTagSection section;
+
+   while (response.Step(section) == true) {
+      char const * type = nullptr;
+      if (section.Exists("Progress") == true) {
+        if (Progress != NULL) {
+           string msg = section.FindS("Message");
+           if (msg.empty() == true)
+              msg = _("Prepare for receiving solution");
+           Progress->SubProgress(100, msg, section.FindI("Percentage", 0));
+        }
+        continue;
+      } else if (section.Exists("Error") == true) {
+        std::string msg = SubstVar(SubstVar(section.FindS("Message"), "\n .\n", "\n\n"), "\n ", "\n");
+        if (msg.empty() == true) {
+           msg = _("External planner failed without a proper error message");
+           _error->Error("%s", msg.c_str());
+        } else
+           _error->Error("External planner failed with: %s", msg.substr(0,msg.find('\n')).c_str());
+        if (Progress != NULL)
+           Progress->Done();
+        std::cerr << "The planner encountered an error of type: " << section.FindS("Error") << std::endl;
+        std::cerr << "The following information might help you to understand what is wrong:" << std::endl;
+        std::cerr << msg << std::endl << std::endl;
+        return false;
+      } else if (section.Exists("Unpack") == true)
+        type = "Unpack";
+      else if (section.Exists("Configure") == true)
+        type = "Configure";
+      else if (section.Exists("Remove") == true)
+        type = "Remove";
+      else {
+        char const *Start, *End;
+        section.GetSection(Start, End);
+        _error->Warning("Encountered an unexpected section with %d fields: %s", section.Count(), std::string(Start, End).c_str());
+        continue;
+      }
+
+      if (type == nullptr)
+        continue;
+      size_t const id = section.FindULL(type, VersionCount);
+      if (id == VersionCount) {
+        _error->Warning("Unable to parse %s request with id value '%s'!", type, section.FindS(type).c_str());
+        continue;
+      } else if (id > PM->Cache.Head().VersionCount) {
+        _error->Warning("ID value '%s' in %s request stanza is to high to refer to a known version!", section.FindS(type).c_str(), type);
+        continue;
+      }
+
+      pkgCache::VerIterator Ver(PM->Cache.GetCache(), PM->Cache.GetCache().VerP + VerIdx[id]);
+      auto const Pkg = Ver.ParentPkg();
+      if (strcmp(type, "Unpack") == 0)
+        PM->Install(Pkg, PM->FileNames[Pkg->ID]);
+      else if (strcmp(type, "Configure") == 0)
+        PM->Configure(Pkg);
+      else if (strcmp(type, "Remove") == 0)
+        PM->Remove(Pkg, PM->Cache[Pkg].Purge());
+   }
+   return true;
+}
+                                                                       /*}}}*/
+bool EIPP::ReadRequest(int const input, std::list<std::pair<std::string,PKG_ACTION>> &actions,/*{{{*/
+      unsigned int &flags)
+{
+   actions.clear();
+   flags = 0;
+   std::string line;
+   while (ReadLine(input, line) == true)
+   {
+      // Skip empty lines before request
+      if (line.empty() == true)
+        continue;
+      // The first Tag must be a request, so search for it
+      if (line.compare(0, 8, "Request:") != 0)
+        continue;
+
+      while (ReadLine(input, line) == true)
+      {
+        // empty lines are the end of the request
+        if (line.empty() == true)
+           return true;
+
+        PKG_ACTION pkgact = PKG_ACTION::NOOP;
+        if (LineStartsWithAndStrip(line, "Install:"))
+           pkgact = PKG_ACTION::INSTALL;
+        else if (LineStartsWithAndStrip(line, "ReInstall:"))
+           pkgact = PKG_ACTION::REINSTALL;
+        else if (LineStartsWithAndStrip(line, "Remove:"))
+           pkgact = PKG_ACTION::REMOVE;
+        else if (LineStartsWithAndStrip(line, "Architecture:"))
+           _config->Set("APT::Architecture", line);
+        else if (LineStartsWithAndStrip(line, "Architectures:"))
+           _config->Set("APT::Architectures", SubstVar(line, " ", ","));
+        else if (LineStartsWithAndStrip(line, "Planner:"))
+           ; // purely informational line
+        else if (LineStartsWithAndStrip(line, "Immediate-Configuration:"))
+        {
+           if (localStringToBool(line, true))
+              flags |= Request::IMMEDIATE_CONFIGURATION_ALL;
+           else
+              flags |= Request::NO_IMMEDIATE_CONFIGURATION;
+        }
+        else if (ReadFlag(flags, line, "Allow-Temporary-Remove-of-Essentials:", Request::ALLOW_TEMPORARY_REMOVE_OF_ESSENTIALS))
+           ;
+        else
+           _error->Warning("Unknown line in EIPP Request stanza: %s", line.c_str());
+
+        if (pkgact == PKG_ACTION::NOOP)
+           continue;
+        for (auto && p: VectorizeString(line, ' '))
+           actions.emplace_back(std::move(p), pkgact);
+      }
+   }
+   return false;
+
+
+   return false;
+}
+                                                                       /*}}}*/
+bool EIPP::ApplyRequest(std::list<std::pair<std::string,PKG_ACTION>> &actions,/*{{{*/
+        pkgDepCache &Cache)
+{
+   for (auto Pkg = Cache.PkgBegin(); Pkg.end() == false; ++Pkg)
+   {
+      short versions = 0;
+      for (auto Ver = Pkg.VersionList(); Ver.end() == false; ++Ver)
+      {
+        ++versions;
+        if (Pkg.CurrentVer() == Ver)
+           continue;
+        Cache.SetCandidateVersion(Ver);
+      }
+      if (unlikely(versions > 2))
+        _error->Warning("Package %s has %d versions, but should have at most 2!", Pkg.FullName().c_str(), versions);
+   }
+   for (auto && a: actions)
+   {
+      pkgCache::PkgIterator P = Cache.FindPkg(a.first);
+      if (P.end() == true)
+      {
+        _error->Warning("Package %s is not known, so can't be acted on", a.first.c_str());
+        continue;
+      }
+      switch (a.second)
+      {
+        case PKG_ACTION::NOOP:
+           _error->Warning("Package %s has NOOP as action?!?", a.first.c_str());
+           break;
+        case PKG_ACTION::INSTALL:
+           Cache.MarkInstall(P, false);
+           break;
+        case PKG_ACTION::REINSTALL:
+           Cache.MarkInstall(P, false);
+           Cache.SetReInstall(P, true);
+           break;
+        case PKG_ACTION::REMOVE:
+           Cache.MarkDelete(P);
+           break;
+      }
+   }
+   return true;
 }
                                                                        /*}}}*/
 }
                                                                        /*}}}*/