apt-pkg/edsp.cc

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 /* ######################################################################
   4    Set of methods to help writing and reading everything needed for EDSP
   5    ##################################################################### */
   6                                                                         /*}}}*/
   7 // Include Files                                                        /*{{{*/
   8 #include <config.h>
   9
  10 #include <apt-pkg/error.h>
  11 #include <apt-pkg/cacheset.h>
  12 #include <apt-pkg/depcache.h>
  13 #include <apt-pkg/pkgcache.h>
  14 #include <apt-pkg/cacheiterators.h>
  15 #include <apt-pkg/progress.h>
  16 #include <apt-pkg/fileutl.h>
  17 #include <apt-pkg/edsp.h>
  18 #include <apt-pkg/tagfile.h>
  19 #include <apt-pkg/strutl.h>
  20 #include <apt-pkg/string_view.h>
  21 #include <apt-pkg/pkgsystem.h>
  22
  23 #include <ctype.h>
  24 #include <stddef.h>
  25 #include <string.h>
  26 #include <unistd.h>
  27 #include <stdio.h>
  28
  29 #include <array>
  30 #include <limits>
  31 #include <string>
  32
  33 #include <apti18n.h>
  34                                                                         /*}}}*/
  35
  36 using std::string;
  37
  38 // we could use pkgCache::DepType and ::Priority, but these would be localized strings…
  39 constexpr char const * const PrioMap[] = {
  40    nullptr, "important", "required", "standard",
  41    "optional", "extra"
  42 };
  43 constexpr char const * const DepMap[] = {
  44    nullptr, "Depends", "Pre-Depends", "Suggests",
  45    "Recommends" , "Conflicts", "Replaces",
  46    "Obsoletes", "Breaks", "Enhances"
  47 };
  48
  49 // WriteOkay - varaidic helper to easily Write to a FileFd              /*{{{*/
  50 static bool WriteOkay_fn(FileFd &) { return true; }
  51 template<typename... Tail> static bool WriteOkay_fn(FileFd &output, APT::StringView data, Tail... more_data)
  52 {
  53    return likely(output.Write(data.data(), data.length()) && WriteOkay_fn(output, more_data...));
  54 }
  55 template<typename... Tail> static bool WriteOkay_fn(FileFd &output, unsigned int data, Tail... more_data)
  56 {
  57    std::string number;
  58    strprintf(number, "%d", data);
  59    return likely(output.Write(number.data(), number.length()) && WriteOkay_fn(output, more_data...));
  60 }
  61 template<typename... Data> static bool WriteOkay(bool &Okay, FileFd &output, Data&&... data)
  62 {
  63    Okay = likely(Okay && WriteOkay_fn(output, std::forward<Data>(data)...));
  64    return Okay;
  65 }
  66 template<typename... Data> static bool WriteOkay(FileFd &output, Data&&... data)
  67 {
  68    bool Okay = likely(output.Failed() == false);
  69    return WriteOkay(Okay, output, std::forward<Data>(data)...);
  70 }
  71                                                                         /*}}}*/
  72 // WriteScenarioVersion                                                 /*{{{*/
  73 static void WriteScenarioVersion(pkgDepCache &Cache, FILE* output, pkgCache::PkgIterator const &Pkg,
  74                                 pkgCache::VerIterator const &Ver)
  75 {
  76    fprintf(output, "Package: %s\n", Pkg.Name());
  77    fprintf(output, "Source: %s\n", Ver.SourcePkgName());
  78    fprintf(output, "Architecture: %s\n", Ver.Arch());
  79    fprintf(output, "Version: %s\n", Ver.VerStr());
  80    fprintf(output, "Source-Version: %s\n", Ver.SourceVerStr());
  81    if (Pkg.CurrentVer() == Ver)
  82       fprintf(output, "Installed: yes\n");
  83    if (Pkg->SelectedState == pkgCache::State::Hold ||
  84        (Cache[Pkg].Keep() == true && Cache[Pkg].Protect() == true))
  85       fprintf(output, "Hold: yes\n");
  86    fprintf(output, "APT-ID: %d\n", Ver->ID);
  87    if (PrioMap[Ver->Priority] != nullptr)
  88       fprintf(output, "Priority: %s\n", PrioMap[Ver->Priority]);
  89    if ((Pkg->Flags & pkgCache::Flag::Essential) == pkgCache::Flag::Essential)
  90       fprintf(output, "Essential: yes\n");
  91    if (Ver->Section != 0)
  92       fprintf(output, "Section: %s\n", Ver.Section());
  93    if ((Ver->MultiArch & pkgCache::Version::Allowed) == pkgCache::Version::Allowed)
  94       fprintf(output, "Multi-Arch: allowed\n");
  95    else if ((Ver->MultiArch & pkgCache::Version::Foreign) == pkgCache::Version::Foreign)
  96       fprintf(output, "Multi-Arch: foreign\n");
  97    else if ((Ver->MultiArch & pkgCache::Version::Same) == pkgCache::Version::Same)
  98       fprintf(output, "Multi-Arch: same\n");
  99    std::set<string> Releases;
 100    for (pkgCache::VerFileIterator I = Ver.FileList(); I.end() == false; ++I) {
 101       pkgCache::PkgFileIterator File = I.File();
 102       if (File.Flagged(pkgCache::Flag::NotSource) == false) {
 103          string Release = File.RelStr();
 104          if (!Release.empty())
 105             Releases.insert(Release);
 106       }
 107    }
 108    if (!Releases.empty()) {
 109        fprintf(output, "APT-Release:\n");
 110        for (std::set<string>::iterator R = Releases.begin(); R != Releases.end(); ++R)
 111            fprintf(output, " %s\n", R->c_str());
 112    }
 113    fprintf(output, "APT-Pin: %d\n", Cache.GetPolicy().GetPriority(Ver));
 114    if (Cache.GetCandidateVersion(Pkg) == Ver)
 115       fprintf(output, "APT-Candidate: yes\n");
 116    if ((Cache[Pkg].Flags & pkgCache::Flag::Auto) == pkgCache::Flag::Auto)
 117       fprintf(output, "APT-Automatic: yes\n");
 118 }
 119 static bool WriteScenarioVersion(FileFd &output, pkgCache::PkgIterator const &Pkg,
 120                                 pkgCache::VerIterator const &Ver)
 121 {
 122    bool Okay = WriteOkay(output, "Package: ", Pkg.Name(),
 123          "\nArchitecture: ", Ver.Arch(),
 124          "\nVersion: ", Ver.VerStr());
 125    WriteOkay(Okay, output, "\nAPT-ID: ", Ver->ID);
 126    if ((Pkg->Flags & pkgCache::Flag::Essential) == pkgCache::Flag::Essential)
 127       WriteOkay(Okay, output, "\nEssential: yes");
 128    if ((Ver->MultiArch & pkgCache::Version::Allowed) == pkgCache::Version::Allowed)
 129       WriteOkay(Okay, output, "\nMulti-Arch: allowed");
 130    else if ((Ver->MultiArch & pkgCache::Version::Foreign) == pkgCache::Version::Foreign)
 131       WriteOkay(Okay, output, "\nMulti-Arch: foreign");
 132    else if ((Ver->MultiArch & pkgCache::Version::Same) == pkgCache::Version::Same)
 133       WriteOkay(Okay, output, "\nMulti-Arch: same");
 134    return Okay;
 135 }
 136                                                                         /*}}}*/
 137 // WriteScenarioDependency                                              /*{{{*/
 138 static void WriteScenarioDependency( FILE* output, pkgCache::VerIterator const &Ver)
 139 {
 140    std::array<std::string, _count(DepMap)> dependencies;
 141    bool orGroup = false;
 142    for (pkgCache::DepIterator Dep = Ver.DependsList(); Dep.end() == false; ++Dep)
 143    {
 144       if (Dep.IsImplicit() == true)
 145          continue;
 146       if (orGroup == false)
 147          dependencies[Dep->Type].append(", ");
 148       dependencies[Dep->Type].append(Dep.TargetPkg().Name());
 149       if (Dep->Version != 0)
 150          dependencies[Dep->Type].append(" (").append(pkgCache::CompTypeDeb(Dep->CompareOp)).append(" ").append(Dep.TargetVer()).append(")");
 151       if ((Dep->CompareOp & pkgCache::Dep::Or) == pkgCache::Dep::Or)
 152       {
 153          dependencies[Dep->Type].append(" | ");
 154          orGroup = true;
 155       }
 156       else
 157          orGroup = false;
 158    }
 159    for (size_t i = 1; i < dependencies.size(); ++i)
 160       if (dependencies[i].empty() == false)
 161          fprintf(output, "%s: %s\n", DepMap[i], dependencies[i].c_str()+2);
 162    string provides;
 163    for (pkgCache::PrvIterator Prv = Ver.ProvidesList(); Prv.end() == false; ++Prv)
 164    {
 165       if (Prv.IsMultiArchImplicit() == true)
 166          continue;
 167       if (provides.empty() == false)
 168          provides.append(", ");
 169       provides.append(Prv.Name());
 170       if (Prv->ProvideVersion != 0)
 171          provides.append(" (= ").append(Prv.ProvideVersion()).append(")");
 172    }
 173    if (provides.empty() == false)
 174       fprintf(output, "Provides: %s\n", provides.c_str());
 175 }
 176 static bool WriteScenarioDependency(FileFd &output, pkgCache::VerIterator const &Ver, bool const OnlyCritical)
 177 {
 178    std::array<std::string, _count(DepMap)> dependencies;
 179    bool orGroup = false;
 180    for (pkgCache::DepIterator Dep = Ver.DependsList(); Dep.end() == false; ++Dep)
 181    {
 182       if (Dep.IsImplicit() == true)
 183          continue;
 184       if (OnlyCritical && Dep.IsCritical() == false)
 185          continue;
 186       if (orGroup == false && dependencies[Dep->Type].empty() == false)
 187          dependencies[Dep->Type].append(", ");
 188       dependencies[Dep->Type].append(Dep.TargetPkg().Name());
 189       if (Dep->Version != 0)
 190          dependencies[Dep->Type].append(" (").append(pkgCache::CompTypeDeb(Dep->CompareOp)).append(" ").append(Dep.TargetVer()).append(")");
 191       if ((Dep->CompareOp & pkgCache::Dep::Or) == pkgCache::Dep::Or)
 192       {
 193          dependencies[Dep->Type].append(" | ");
 194          orGroup = true;
 195       }
 196       else
 197          orGroup = false;
 198    }
 199    bool Okay = output.Failed() == false;
 200    for (size_t i = 1; i < dependencies.size(); ++i)
 201       if (dependencies[i].empty() == false)
 202          WriteOkay(Okay, output, "\n", DepMap[i], ": ", dependencies[i]);
 203    string provides;
 204    for (pkgCache::PrvIterator Prv = Ver.ProvidesList(); Prv.end() == false; ++Prv)
 205    {
 206       if (Prv.IsMultiArchImplicit() == true)
 207          continue;
 208       if (provides.empty() == false)
 209          provides.append(", ");
 210       provides.append(Prv.Name());
 211       if (Prv->ProvideVersion != 0)
 212          provides.append(" (= ").append(Prv.ProvideVersion()).append(")");
 213    }
 214    if (provides.empty() == false)
 215       WriteOkay(Okay, output, "\nProvides: ", provides);
 216    return WriteOkay(Okay, output, "\n");
 217 }
 218                                                                         /*}}}*/
 219 // WriteScenarioLimitedDependency                                       /*{{{*/
 220 static void WriteScenarioLimitedDependency(FILE* output,
 221                                           pkgCache::VerIterator const &Ver,
 222                                           APT::PackageSet const &pkgset)
 223 {
 224    std::array<std::string, _count(DepMap)> dependencies;
 225    bool orGroup = false;
 226    for (pkgCache::DepIterator Dep = Ver.DependsList(); Dep.end() == false; ++Dep)
 227    {
 228       if (Dep.IsImplicit() == true)
 229          continue;
 230       if (orGroup == false)
 231       {
 232          if (pkgset.find(Dep.TargetPkg()) == pkgset.end())
 233             continue;
 234          if (dependencies[Dep->Type].empty() == false)
 235             dependencies[Dep->Type].append(", ");
 236       }
 237       else if (pkgset.find(Dep.TargetPkg()) == pkgset.end())
 238       {
 239          if ((Dep->CompareOp & pkgCache::Dep::Or) == pkgCache::Dep::Or)
 240             continue;
 241          dependencies[Dep->Type].erase(dependencies[Dep->Type].end()-3, dependencies[Dep->Type].end());
 242          orGroup = false;
 243          continue;
 244       }
 245       dependencies[Dep->Type].append(Dep.TargetPkg().Name());
 246       if (Dep->Version != 0)
 247          dependencies[Dep->Type].append(" (").append(pkgCache::CompTypeDeb(Dep->CompareOp)).append(" ").append(Dep.TargetVer()).append(")");
 248       if ((Dep->CompareOp & pkgCache::Dep::Or) == pkgCache::Dep::Or)
 249       {
 250          dependencies[Dep->Type].append(" | ");
 251          orGroup = true;
 252       }
 253       else
 254          orGroup = false;
 255    }
 256    for (size_t i = 1; i < dependencies.size(); ++i)
 257       if (dependencies[i].empty() == false)
 258          fprintf(output, "%s: %s\n", DepMap[i], dependencies[i].c_str());
 259    string provides;
 260    for (pkgCache::PrvIterator Prv = Ver.ProvidesList(); Prv.end() == false; ++Prv)
 261    {
 262       if (Prv.IsMultiArchImplicit() == true)
 263          continue;
 264       if (pkgset.find(Prv.ParentPkg()) == pkgset.end())
 265          continue;
 266       if (provides.empty() == false)
 267          provides.append(", ");
 268       provides.append(Prv.Name());
 269       if (Prv->ProvideVersion != 0)
 270          provides.append(" (= ").append(Prv.ProvideVersion()).append(")");
 271    }
 272    if (provides.empty() == false)
 273       fprintf(output, "Provides: %s\n", provides.c_str());
 274 }
 275 static bool WriteScenarioLimitedDependency(FileFd &output,
 276                                           pkgCache::VerIterator const &Ver,
 277                                           std::vector<bool> const &pkgset,
 278                                           bool const OnlyCritical)
 279 {
 280    std::array<std::string, _count(DepMap)> dependencies;
 281    bool orGroup = false;
 282    for (pkgCache::DepIterator Dep = Ver.DependsList(); Dep.end() == false; ++Dep)
 283    {
 284       if (Dep.IsImplicit() == true)
 285          continue;
 286       if (OnlyCritical && Dep.IsCritical() == false)
 287          continue;
 288       if (orGroup == false)
 289       {
 290          if (pkgset[Dep.TargetPkg()->ID] == false)
 291             continue;
 292          if (dependencies[Dep->Type].empty() == false)
 293             dependencies[Dep->Type].append(", ");
 294       }
 295       else if (pkgset[Dep.TargetPkg()->ID] == false)
 296       {
 297          if ((Dep->CompareOp & pkgCache::Dep::Or) == pkgCache::Dep::Or)
 298             continue;
 299          dependencies[Dep->Type].erase(dependencies[Dep->Type].end()-3, dependencies[Dep->Type].end());
 300          orGroup = false;
 301          continue;
 302       }
 303       dependencies[Dep->Type].append(Dep.TargetPkg().Name());
 304       if (Dep->Version != 0)
 305          dependencies[Dep->Type].append(" (").append(pkgCache::CompTypeDeb(Dep->CompareOp)).append(" ").append(Dep.TargetVer()).append(")");
 306       if ((Dep->CompareOp & pkgCache::Dep::Or) == pkgCache::Dep::Or)
 307       {
 308          dependencies[Dep->Type].append(" | ");
 309          orGroup = true;
 310       }
 311       else
 312          orGroup = false;
 313    }
 314    bool Okay = output.Failed() == false;
 315    for (size_t i = 1; i < dependencies.size(); ++i)
 316       if (dependencies[i].empty() == false)
 317          WriteOkay(Okay, output, "\n", DepMap[i], ": ", dependencies[i]);
 318    string provides;
 319    for (pkgCache::PrvIterator Prv = Ver.ProvidesList(); Prv.end() == false; ++Prv)
 320    {
 321       if (Prv.IsMultiArchImplicit() == true)
 322          continue;
 323       if (pkgset[Prv.ParentPkg()->ID] == false)
 324          continue;
 325       if (provides.empty() == false)
 326          provides.append(", ");
 327       provides.append(Prv.Name());
 328       if (Prv->ProvideVersion != 0)
 329          provides.append(" (= ").append(Prv.ProvideVersion()).append(")");
 330    }
 331    if (provides.empty() == false)
 332       WriteOkay(Okay, output, "\nProvides: ", provides);
 333    return WriteOkay(Okay, output, "\n");
 334 }
 335                                                                         /*}}}*/
 336 static bool SkipUnavailableVersions(pkgDepCache &Cache, pkgCache::PkgIterator const &Pkg, pkgCache::VerIterator const &Ver)/*{{{*/
 337 {
 338    /* versions which aren't current and aren't available in
 339       any "online" source file are bad, expect if they are the choosen
 340       candidate: The exception is for build-dep implementation as it creates
 341       such pseudo (package) versions and removes them later on again.
 342       We filter out versions at all so packages in 'rc' state only available
 343       in dpkg/status aren't passed to solvers as they can't be installed. */
 344    if (Pkg->CurrentVer != 0)
 345       return false;
 346    if (Cache.GetCandidateVersion(Pkg) == Ver)
 347       return false;
 348    for (pkgCache::VerFileIterator I = Ver.FileList(); I.end() == false; ++I)
 349       if (I.File().Flagged(pkgCache::Flag::NotSource) == false)
 350          return false;
 351    return true;
 352 }
 353                                                                         /*}}}*/
 354 static bool WriteScenarioEDSPVersion(pkgDepCache &Cache, FileFd &output, pkgCache::PkgIterator const &Pkg,/*{{{*/
 355                                 pkgCache::VerIterator const &Ver)
 356 {
 357    bool Okay = WriteOkay(output, "\nSource: ", Ver.SourcePkgName(),
 358          "\nSource-Version: ", Ver.SourceVerStr());
 359    if (PrioMap[Ver->Priority] != nullptr)
 360       WriteOkay(Okay, output, "\nPriority: ", PrioMap[Ver->Priority]);
 361    if (Ver->Section != 0)
 362       WriteOkay(Okay, output, "\nSection: ", Ver.Section());
 363    if (Pkg.CurrentVer() == Ver)
 364       WriteOkay(Okay, output, "\nInstalled: yes");
 365    if (Pkg->SelectedState == pkgCache::State::Hold ||
 366        (Cache[Pkg].Keep() == true && Cache[Pkg].Protect() == true))
 367       WriteOkay(Okay, output, "\nHold: yes");
 368    std::set<string> Releases;
 369    for (pkgCache::VerFileIterator I = Ver.FileList(); I.end() == false; ++I) {
 370       pkgCache::PkgFileIterator File = I.File();
 371       if (File.Flagged(pkgCache::Flag::NotSource) == false) {
 372          string Release = File.RelStr();
 373          if (!Release.empty())
 374             Releases.insert(Release);
 375       }
 376    }
 377    if (!Releases.empty()) {
 378        WriteOkay(Okay, output, "\nAPT-Release:");
 379        for (std::set<string>::iterator R = Releases.begin(); R != Releases.end(); ++R)
 380            WriteOkay(Okay, output, "\n ", *R);
 381    }
 382    WriteOkay(Okay, output, "\nAPT-Pin: ", Cache.GetPolicy().GetPriority(Ver));
 383    if (Cache.GetCandidateVersion(Pkg) == Ver)
 384       WriteOkay(Okay, output, "\nAPT-Candidate: yes");
 385    if ((Cache[Pkg].Flags & pkgCache::Flag::Auto) == pkgCache::Flag::Auto)
 386       WriteOkay(Okay, output, "\nAPT-Automatic: yes");
 387    return Okay;
 388 }
 389                                                                         /*}}}*/
 390 // EDSP::WriteScenario - to the given file descriptor                   /*{{{*/
 391 bool EDSP::WriteScenario(pkgDepCache &Cache, FILE* output, OpProgress *Progress)
 392 {
 393    if (Progress != NULL)
 394       Progress->SubProgress(Cache.Head().VersionCount, _("Send scenario to solver"));
 395    unsigned long p = 0;
 396    std::vector<std::string> archs = APT::Configuration::getArchitectures();
 397    for (pkgCache::PkgIterator Pkg = Cache.PkgBegin(); Pkg.end() == false; ++Pkg)
 398    {
 399       std::string const arch = Pkg.Arch();
 400       if (std::find(archs.begin(), archs.end(), arch) == archs.end())
 401          continue;
 402       for (pkgCache::VerIterator Ver = Pkg.VersionList(); Ver.end() == false; ++Ver, ++p)
 403       {
 404          if (SkipUnavailableVersions(Cache, Pkg, Ver))
 405             continue;
 406          WriteScenarioVersion(Cache, output, Pkg, Ver);
 407          WriteScenarioDependency(output, Ver);
 408          fprintf(output, "\n");
 409          if (Progress != NULL && p % 100 == 0)
 410             Progress->Progress(p);
 411       }
 412    }
 413    return true;
 414 }
 415 bool EDSP::WriteScenario(pkgDepCache &Cache, FileFd &output, OpProgress *Progress)
 416 {
 417    if (Progress != NULL)
 418       Progress->SubProgress(Cache.Head().VersionCount, _("Send scenario to solver"));
 419    unsigned long p = 0;
 420    bool Okay = output.Failed() == false;
 421    std::vector<std::string> archs = APT::Configuration::getArchitectures();
 422    for (pkgCache::PkgIterator Pkg = Cache.PkgBegin(); Pkg.end() == false && likely(Okay); ++Pkg)
 423    {
 424       std::string const arch = Pkg.Arch();
 425       if (std::find(archs.begin(), archs.end(), arch) == archs.end())
 426          continue;
 427       for (pkgCache::VerIterator Ver = Pkg.VersionList(); Ver.end() == false && likely(Okay); ++Ver, ++p)
 428       {
 429          if (SkipUnavailableVersions(Cache, Pkg, Ver))
 430             continue;
 431          Okay &= WriteScenarioVersion(output, Pkg, Ver);
 432          Okay &= WriteScenarioEDSPVersion(Cache, output, Pkg, Ver);
 433          Okay &= WriteScenarioDependency(output, Ver, false);
 434          WriteOkay(Okay, output, "\n");
 435          if (Progress != NULL && p % 100 == 0)
 436             Progress->Progress(p);
 437       }
 438    }
 439    return true;
 440 }
 441                                                                         /*}}}*/
 442 // EDSP::WriteLimitedScenario - to the given file descriptor            /*{{{*/
 443 bool EDSP::WriteLimitedScenario(pkgDepCache &Cache, FILE* output,
 444                                 APT::PackageSet const &pkgset,
 445                                 OpProgress *Progress)
 446 {
 447    if (Progress != NULL)
 448       Progress->SubProgress(Cache.Head().VersionCount, _("Send scenario to solver"));
 449    unsigned long p  = 0;
 450    for (APT::PackageSet::const_iterator Pkg = pkgset.begin(); Pkg != pkgset.end(); ++Pkg, ++p)
 451       for (pkgCache::VerIterator Ver = Pkg.VersionList(); Ver.end() == false; ++Ver)
 452       {
 453          if (SkipUnavailableVersions(Cache, Pkg, Ver))
 454             continue;
 455          WriteScenarioVersion(Cache, output, Pkg, Ver);
 456          WriteScenarioLimitedDependency(output, Ver, pkgset);
 457          fprintf(output, "\n");
 458          if (Progress != NULL && p % 100 == 0)
 459             Progress->Progress(p);
 460       }
 461    if (Progress != NULL)
 462       Progress->Done();
 463    return true;
 464 }
 465 bool EDSP::WriteLimitedScenario(pkgDepCache &Cache, FileFd &output,
 466                                 std::vector<bool> const &pkgset,
 467                                 OpProgress *Progress)
 468 {
 469    if (Progress != NULL)
 470       Progress->SubProgress(Cache.Head().VersionCount, _("Send scenario to solver"));
 471    unsigned long p  = 0;
 472    bool Okay = output.Failed() == false;
 473    for (auto Pkg = Cache.PkgBegin(); Pkg.end() == false && likely(Okay); ++Pkg, ++p)
 474    {
 475       if (pkgset[Pkg->ID] == false)
 476          continue;
 477       for (pkgCache::VerIterator Ver = Pkg.VersionList(); Ver.end() == false && likely(Okay); ++Ver)
 478       {
 479          if (SkipUnavailableVersions(Cache, Pkg, Ver))
 480             continue;
 481          Okay &= WriteScenarioVersion(output, Pkg, Ver);
 482          Okay &= WriteScenarioEDSPVersion(Cache, output, Pkg, Ver);
 483          Okay &= WriteScenarioLimitedDependency(output, Ver, pkgset, false);
 484          WriteOkay(Okay, output, "\n");
 485          if (Progress != NULL && p % 100 == 0)
 486             Progress->Progress(p);
 487       }
 488    }
 489    if (Progress != NULL)
 490       Progress->Done();
 491    return Okay;
 492 }
 493                                                                         /*}}}*/
 494 // EDSP::WriteRequest - to the given file descriptor                    /*{{{*/
 495 bool EDSP::WriteRequest(pkgDepCache &Cache, FILE* output, bool const Upgrade,
 496                         bool const DistUpgrade, bool const AutoRemove,
 497                         OpProgress *Progress)
 498 {
 499    if (Progress != NULL)
 500       Progress->SubProgress(Cache.Head().PackageCount, _("Send request to solver"));
 501    unsigned long p = 0;
 502    string del, inst;
 503    for (pkgCache::PkgIterator Pkg = Cache.PkgBegin(); Pkg.end() == false; ++Pkg, ++p)
 504    {
 505       if (Progress != NULL && p % 100 == 0)
 506          Progress->Progress(p);
 507       string* req;
 508       pkgDepCache::StateCache &P = Cache[Pkg];
 509       if (P.Delete() == true)
 510          req = &del;
 511       else if (P.NewInstall() == true || P.Upgrade() == true || P.ReInstall() == true ||
 512                (P.Mode == pkgDepCache::ModeKeep && (P.iFlags & pkgDepCache::Protected) == pkgDepCache::Protected))
 513          req = &inst;
 514       else
 515          continue;
 516       req->append(" ").append(Pkg.FullName());
 517    }
 518    fprintf(output, "Request: EDSP 0.5\n");
 519
 520    const char *arch = _config->Find("APT::Architecture").c_str();
 521    std::vector<string> archs = APT::Configuration::getArchitectures();
 522    fprintf(output, "Architecture: %s\n", arch);
 523    fprintf(output, "Architectures:");
 524    for (std::vector<string>::const_iterator a = archs.begin(); a != archs.end(); ++a)
 525        fprintf(output, " %s", a->c_str());
 526    fprintf(output, "\n");
 527
 528    if (del.empty() == false)
 529       fprintf(output, "Remove: %s\n", del.c_str()+1);
 530    if (inst.empty() == false)
 531       fprintf(output, "Install: %s\n", inst.c_str()+1);
 532    if (Upgrade == true)
 533       fprintf(output, "Upgrade: yes\n");
 534    if (DistUpgrade == true)
 535       fprintf(output, "Dist-Upgrade: yes\n");
 536    if (AutoRemove == true)
 537       fprintf(output, "Autoremove: yes\n");
 538    auto const solver = _config->Find("APT::Solver", "internal");
 539    fprintf(output, "Solver: %s\n", solver.c_str());
 540    auto const solverconf = std::string("APT::Solver::") + solver + "::";
 541    if (_config->FindB(solverconf + "Strict-Pinning", _config->FindB("APT::Solver::Strict-Pinning", true)) == false)
 542       fprintf(output, "Strict-Pinning: no\n");
 543    auto const solverpref = _config->Find(solverconf + "Preferences", _config->Find("APT::Solver::Preferences", ""));
 544    if (solverpref.empty() == false)
 545       fprintf(output, "Preferences: %s\n", solverpref.c_str());
 546    fprintf(output, "\n");
 547    return true;
 548 }
 549 bool EDSP::WriteRequest(pkgDepCache &Cache, FileFd &output,
 550                         unsigned int const flags,
 551                         OpProgress *Progress)
 552 {
 553    if (Progress != NULL)
 554       Progress->SubProgress(Cache.Head().PackageCount, _("Send request to solver"));
 555    unsigned long p = 0;
 556    string del, inst;
 557    for (pkgCache::PkgIterator Pkg = Cache.PkgBegin(); Pkg.end() == false; ++Pkg, ++p)
 558    {
 559       if (Progress != NULL && p % 100 == 0)
 560          Progress->Progress(p);
 561       string* req;
 562       pkgDepCache::StateCache &P = Cache[Pkg];
 563       if (P.Delete() == true)
 564          req = &del;
 565       else if (P.NewInstall() == true || P.Upgrade() == true || P.ReInstall() == true ||
 566                (P.Mode == pkgDepCache::ModeKeep && (P.iFlags & pkgDepCache::Protected) == pkgDepCache::Protected))
 567          req = &inst;
 568       else
 569          continue;
 570       req->append(" ").append(Pkg.FullName());
 571    }
 572    bool Okay = WriteOkay(output, "Request: EDSP 0.5\n");
 573
 574    const char *arch = _config->Find("APT::Architecture").c_str();
 575    std::vector<string> archs = APT::Configuration::getArchitectures();
 576    WriteOkay(Okay, output, "Architecture: ", arch, "\n",
 577          "Architectures:");
 578    for (std::vector<string>::const_iterator a = archs.begin(); a != archs.end(); ++a)
 579        WriteOkay(Okay, output, " ", *a);
 580    WriteOkay(Okay, output, "\n");
 581
 582    if (del.empty() == false)
 583       WriteOkay(Okay, output, "Remove:", del, "\n");
 584    if (inst.empty() == false)
 585       WriteOkay(Okay, output, "Install:", inst, "\n");
 586    if (flags & Request::AUTOREMOVE)
 587       WriteOkay(Okay, output, "Autoremove: yes\n");
 588    if (flags & Request::UPGRADE_ALL)
 589    {
 590       WriteOkay(Okay, output, "Upgrade-All: yes\n");
 591       if (flags & (Request::FORBID_NEW_INSTALL | Request::FORBID_REMOVE))
 592          WriteOkay(Okay, output, "Upgrade: yes\n");
 593       else
 594          WriteOkay(Okay, output, "Dist-Upgrade: yes\n");
 595    }
 596    if (flags & Request::FORBID_NEW_INSTALL)
 597       WriteOkay(Okay, output, "Forbid-New-Install: yes\n");
 598    if (flags & Request::FORBID_REMOVE)
 599       WriteOkay(Okay, output, "Forbid-Remove: yes\n");
 600    if (_config->FindB("APT::Solver::Strict-Pinning", true) == false)
 601       WriteOkay(Okay, output, "Strict-Pinning: no\n");
 602    string solverpref("APT::Solver::");
 603    solverpref.append(_config->Find("APT::Solver", "internal")).append("::Preferences");
 604    if (_config->Exists(solverpref) == true)
 605       WriteOkay(Okay, output, "Preferences: ", _config->Find(solverpref,""), "\n");
 606    return WriteOkay(Okay, output, "\n");
 607 }
 608                                                                         /*}}}*/
 609 // EDSP::ReadResponse - from the given file descriptor                  /*{{{*/
 610 bool EDSP::ReadResponse(int const input, pkgDepCache &Cache, OpProgress *Progress) {
 611         /* We build an map id to mmap offset here
 612            In theory we could use the offset as ID, but then VersionCount
 613            couldn't be used to create other versionmappings anymore and it
 614            would be too easy for a (buggy) solver to segfault APT… */
 615         unsigned long long const VersionCount = Cache.Head().VersionCount;
 616         unsigned long VerIdx[VersionCount];
 617         for (pkgCache::PkgIterator P = Cache.PkgBegin(); P.end() == false; ++P) {
 618                 for (pkgCache::VerIterator V = P.VersionList(); V.end() == false; ++V)
 619                         VerIdx[V->ID] = V.Index();
 620                 Cache[P].Marked = true;
 621                 Cache[P].Garbage = false;
 622         }
 623
 624         FileFd in;
 625         in.OpenDescriptor(input, FileFd::ReadOnly);
 626         pkgTagFile response(&in, 100);
 627         pkgTagSection section;
 628
 629         std::set<decltype(Cache.PkgBegin()->ID)> seenOnce;
 630         while (response.Step(section) == true) {
 631                 std::string type;
 632                 if (section.Exists("Install") == true)
 633                         type = "Install";
 634                 else if (section.Exists("Remove") == true)
 635                         type = "Remove";
 636                 else if (section.Exists("Progress") == true) {
 637                         if (Progress != NULL) {
 638                                 string msg = section.FindS("Message");
 639                                 if (msg.empty() == true)
 640                                         msg = _("Prepare for receiving solution");
 641                                 Progress->SubProgress(100, msg, section.FindI("Percentage", 0));
 642                         }
 643                         continue;
 644                 } else if (section.Exists("Error") == true) {
 645                         std::string msg = SubstVar(SubstVar(section.FindS("Message"), "\n .\n", "\n\n"), "\n ", "\n");
 646                         if (msg.empty() == true) {
 647                                 msg = _("External solver failed without a proper error message");
 648                                 _error->Error("%s", msg.c_str());
 649                         } else
 650                                 _error->Error("External solver failed with: %s", msg.substr(0,msg.find('\n')).c_str());
 651                         if (Progress != NULL)
 652                                 Progress->Done();
 653                         std::cerr << "The solver encountered an error of type: " << section.FindS("Error") << std::endl;
 654                         std::cerr << "The following information might help you to understand what is wrong:" << std::endl;
 655                         std::cerr << msg << std::endl << std::endl;
 656                         return false;
 657                 } else if (section.Exists("Autoremove") == true)
 658                         type = "Autoremove";
 659                 else
 660                         continue;
 661
 662                 size_t const id = section.FindULL(type.c_str(), VersionCount);
 663                 if (id == VersionCount) {
 664                         _error->Warning("Unable to parse %s request with id value '%s'!", type.c_str(), section.FindS(type.c_str()).c_str());
 665                         continue;
 666                 } else if (id > Cache.Head().VersionCount) {
 667                         _error->Warning("ID value '%s' in %s request stanza is to high to refer to a known version!", section.FindS(type.c_str()).c_str(), type.c_str());
 668                         continue;
 669                 }
 670
 671                 pkgCache::VerIterator Ver(Cache.GetCache(), Cache.GetCache().VerP + VerIdx[id]);
 672                 auto const Pkg = Ver.ParentPkg();
 673                 if (type == "Autoremove") {
 674                         Cache[Pkg].Marked = false;
 675                         Cache[Pkg].Garbage = true;
 676                 } else if (seenOnce.emplace(Pkg->ID).second == false) {
 677                         _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());
 678                 } else if (type == "Install") {
 679                         if (Pkg.CurrentVer() == Ver) {
 680                                 _error->Warning("Ignoring Install stanza received for version %s of package %s which is already installed!",
 681                                       Ver.VerStr(), Pkg.FullName(false).c_str());
 682                         } else {
 683                                 Cache.SetCandidateVersion(Ver);
 684                                 Cache.MarkInstall(Pkg, false, 0, false);
 685                         }
 686                 } else if (type == "Remove") {
 687                         if (Pkg->CurrentVer == 0)
 688                                 _error->Warning("Ignoring Remove stanza received for version %s of package %s which isn't installed!",
 689                                       Ver.VerStr(), Pkg.FullName(false).c_str());
 690                         else if (Pkg.CurrentVer() != Ver)
 691                                 _error->Warning("Ignoring Remove stanza received for version %s of package %s which isn't the installed version %s!",
 692                                       Ver.VerStr(), Pkg.FullName(false).c_str(), Pkg.CurrentVer().VerStr());
 693                         else
 694                                 Cache.MarkDelete(Ver.ParentPkg(), false);
 695                 }
 696         }
 697         return true;
 698 }
 699                                                                         /*}}}*/
 700 // ReadLine - first line from the given file descriptor                 /*{{{*/
 701 // ---------------------------------------------------------------------
 702 /* Little helper method to read a complete line into a string. Similar to
 703    fgets but we need to use the low-level read() here as otherwise the
 704    listparser will be confused later on as mixing of fgets and read isn't
 705    a supported action according to the manpages and results are undefined */
 706 static bool ReadLine(int const input, std::string &line) {
 707         char one;
 708         ssize_t data = 0;
 709         line.erase();
 710         line.reserve(100);
 711         while ((data = read(input, &one, sizeof(one))) != -1) {
 712                 if (data != 1)
 713                         continue;
 714                 if (one == '\n')
 715                         return true;
 716                 if (one == '\r')
 717                         continue;
 718                 if (line.empty() == true && isblank(one) != 0)
 719                         continue;
 720                 line += one;
 721         }
 722         return false;
 723 }
 724                                                                         /*}}}*/
 725 // StringToBool - convert yes/no to bool                                /*{{{*/
 726 // ---------------------------------------------------------------------
 727 /* we are not as lazy as we are in the global StringToBool as we really
 728    only accept yes/no here */
 729 static bool localStringToBool(std::string answer, bool const defValue) {
 730    std::transform(answer.begin(), answer.end(), answer.begin(), ::tolower);
 731    if (answer == "yes")
 732       return true;
 733    else if (answer == "no")
 734       return false;
 735    else
 736       _error->Warning("Value '%s' is not a boolean 'yes' or 'no'!", answer.c_str());
 737    return defValue;
 738 }
 739                                                                         /*}}}*/
 740 static bool LineStartsWithAndStrip(std::string &line, APT::StringView const with)/*{{{*/
 741 {
 742    if (line.compare(0, with.size(), with.data()) != 0)
 743       return false;
 744    line = APT::String::Strip(line.substr(with.length()));
 745    return true;
 746 }
 747                                                                         /*}}}*/
 748 static bool ReadFlag(unsigned int &flags, std::string &line, APT::StringView const name, unsigned int const setflag)/*{{{*/
 749 {
 750    if (LineStartsWithAndStrip(line, name) == false)
 751       return false;
 752    if (localStringToBool(line, false))
 753       flags |= setflag;
 754    else
 755       flags &= ~setflag;
 756    return true;
 757 }
 758                                                                         /*}}}*/
 759 // EDSP::ReadRequest - first stanza from the given file descriptor      /*{{{*/
 760 bool EDSP::ReadRequest(int const input, std::list<std::string> &install,
 761                         std::list<std::string> &remove, unsigned int &flags)
 762 {
 763    install.clear();
 764    remove.clear();
 765    flags = 0;
 766    std::string line;
 767    while (ReadLine(input, line) == true)
 768    {
 769       // Skip empty lines before request
 770       if (line.empty() == true)
 771          continue;
 772       // The first Tag must be a request, so search for it
 773       if (LineStartsWithAndStrip(line, "Request:"))
 774          continue;
 775
 776       while (ReadLine(input, line) == true)
 777       {
 778          // empty lines are the end of the request
 779          if (line.empty() == true)
 780             return true;
 781
 782          std::list<std::string> *request = NULL;
 783          if (LineStartsWithAndStrip(line, "Install:"))
 784             request = &install;
 785          else if (LineStartsWithAndStrip(line, "Remove:"))
 786             request = &remove;
 787          else if (ReadFlag(flags, line, "Upgrade:", (Request::UPGRADE_ALL | Request::FORBID_REMOVE | Request::FORBID_NEW_INSTALL)) ||
 788                ReadFlag(flags, line, "Dist-Upgrade:", Request::UPGRADE_ALL) ||
 789                ReadFlag(flags, line, "Upgrade-All:", Request::UPGRADE_ALL) ||
 790                ReadFlag(flags, line, "Forbid-New-Install:", Request::FORBID_NEW_INSTALL) ||
 791                ReadFlag(flags, line, "Forbid-Remove:", Request::FORBID_REMOVE) ||
 792                ReadFlag(flags, line, "Autoremove:", Request::AUTOREMOVE))
 793             ;
 794          else if (LineStartsWithAndStrip(line, "Architecture:"))
 795             _config->Set("APT::Architecture", line);
 796          else if (LineStartsWithAndStrip(line, "Architectures:"))
 797             _config->Set("APT::Architectures", SubstVar(line, " ", ","));
 798          else if (LineStartsWithAndStrip(line, "Solver:"))
 799             ; // purely informational line
 800          else
 801             _error->Warning("Unknown line in EDSP Request stanza: %s", line.c_str());
 802
 803          if (request == NULL)
 804             continue;
 805          auto const pkgs = VectorizeString(line, ' ');
 806          std::move(pkgs.begin(), pkgs.end(), std::back_inserter(*request));
 807       }
 808    }
 809    return false;
 810 }
 811 bool EDSP::ReadRequest(int const input, std::list<std::string> &install,
 812                         std::list<std::string> &remove, bool &upgrade,
 813                         bool &distUpgrade, bool &autoRemove)
 814 {
 815    unsigned int flags;
 816    auto const ret = ReadRequest(input, install, remove, flags);
 817    autoRemove = (flags & Request::AUTOREMOVE);
 818    if (flags & Request::UPGRADE_ALL)
 819    {
 820       if (flags & (Request::FORBID_NEW_INSTALL | Request::FORBID_REMOVE))
 821       {
 822          upgrade = true;
 823          distUpgrade = false;
 824       } else {
 825          upgrade = false;
 826          distUpgrade = false;
 827       }
 828    }
 829    else
 830    {
 831       upgrade = false;
 832       distUpgrade = false;
 833    }
 834    return ret;
 835 }
 836                                                                         /*}}}*/
 837 // EDSP::ApplyRequest - first stanza from the given file descriptor     /*{{{*/
 838 bool EDSP::ApplyRequest(std::list<std::string> const &install,
 839                          std::list<std::string> const &remove,
 840                          pkgDepCache &Cache)
 841 {
 842         for (std::list<std::string>::const_iterator i = install.begin();
 843              i != install.end(); ++i) {
 844                 pkgCache::PkgIterator P = Cache.FindPkg(*i);
 845                 if (P.end() == true)
 846                         _error->Warning("Package %s is not known, so can't be installed", i->c_str());
 847                 else
 848                         Cache.MarkInstall(P, false);
 849         }
 850
 851         for (std::list<std::string>::const_iterator i = remove.begin();
 852              i != remove.end(); ++i) {
 853                 pkgCache::PkgIterator P = Cache.FindPkg(*i);
 854                 if (P.end() == true)
 855                         _error->Warning("Package %s is not known, so can't be installed", i->c_str());
 856                 else
 857                         Cache.MarkDelete(P);
 858         }
 859         return true;
 860 }
 861                                                                         /*}}}*/
 862 // EDSP::WriteSolutionStanza - to the given file descriptor             /*{{{*/
 863 bool EDSP::WriteSolution(pkgDepCache &Cache, FILE* output)
 864 {
 865    bool const Debug = _config->FindB("Debug::EDSP::WriteSolution", false);
 866    for (pkgCache::PkgIterator Pkg = Cache.PkgBegin(); Pkg.end() == false; ++Pkg)
 867    {
 868       if (Cache[Pkg].Delete() == true)
 869       {
 870          fprintf(output, "Remove: %d\n", _system->GetVersionMapping(Pkg.CurrentVer()->ID));
 871          if (Debug == true)
 872             fprintf(output, "Package: %s\nVersion: %s\n", Pkg.FullName().c_str(), Pkg.CurrentVer().VerStr());
 873       }
 874       else if (Cache[Pkg].NewInstall() == true || Cache[Pkg].Upgrade() == true)
 875       {
 876          pkgCache::VerIterator const CandVer = Cache.GetCandidateVersion(Pkg);
 877          fprintf(output, "Install: %d\n", _system->GetVersionMapping(CandVer->ID));
 878          if (Debug == true)
 879             fprintf(output, "Package: %s\nVersion: %s\n", Pkg.FullName().c_str(), CandVer.VerStr());
 880       }
 881       else if (Cache[Pkg].Garbage == true)
 882       {
 883          fprintf(output, "Autoremove: %d\n", _system->GetVersionMapping(Pkg.CurrentVer()->ID));
 884          if (Debug == true)
 885             fprintf(output, "Package: %s\nVersion: %s\n", Pkg.FullName().c_str(), Pkg.CurrentVer().VerStr());
 886       }
 887       else
 888          continue;
 889       fprintf(output, "\n");
 890    }
 891
 892    return true;
 893 }
 894 bool EDSP::WriteSolutionStanza(FileFd &output, char const * const Type, pkgCache::VerIterator const &Ver)
 895 {
 896    bool Okay = output.Failed() == false;
 897    WriteOkay(Okay, output, Type, ": ", _system->GetVersionMapping(Ver->ID));
 898    if (_config->FindB("Debug::EDSP::WriteSolution", false) == true)
 899       WriteOkay(Okay, output, "\nPackage: ", Ver.ParentPkg().FullName(), "\nVersion: ", Ver.VerStr());
 900    return WriteOkay(Okay, output, "\n\n");
 901 }
 902                                                                         /*}}}*/
 903 // EDSP::WriteProgess - pulse to the given file descriptor              /*{{{*/
 904 bool EDSP::WriteProgress(unsigned short const percent, const char* const message, FILE* output) {
 905         fprintf(output, "Progress: %s\n", TimeRFC1123(time(NULL)).c_str());
 906         fprintf(output, "Percentage: %d\n", percent);
 907         fprintf(output, "Message: %s\n\n", message);
 908         fflush(output);
 909         return true;
 910 }
 911 bool EDSP::WriteProgress(unsigned short const percent, const char* const message, FileFd &output) {
 912         return WriteOkay(output, "Progress: ", TimeRFC1123(time(NULL)), "\n",
 913               "Percentage: ", percent, "\n",
 914               "Message: ", message, "\n\n") && output.Flush();
 915 }
 916                                                                         /*}}}*/
 917 // EDSP::WriteError - format an error message to be send to file descriptor /*{{{*/
 918 bool EDSP::WriteError(char const * const uuid, std::string const &message, FILE* output) {
 919         fprintf(output, "Error: %s\n", uuid);
 920         fprintf(output, "Message: %s\n\n", SubstVar(SubstVar(message, "\n\n", "\n.\n"), "\n", "\n ").c_str());
 921         return true;
 922 }
 923 bool EDSP::WriteError(char const * const uuid, std::string const &message, FileFd &output) {
 924         return WriteOkay(output, "Error: ", uuid, "\n",
 925               "Message: ", SubstVar(SubstVar(message, "\n\n", "\n.\n"), "\n", "\n "),
 926               "\n\n");
 927 }
 928                                                                         /*}}}*/
 929 static pid_t ExecuteExternal(char const* const type, char const * const binary, char const * const configdir, int * const solver_in, int * const solver_out) {/*{{{*/
 930         std::vector<std::string> const solverDirs = _config->FindVector(configdir);
 931         std::string file;
 932         for (std::vector<std::string>::const_iterator dir = solverDirs.begin();
 933              dir != solverDirs.end(); ++dir) {
 934                 file = flCombine(*dir, binary);
 935                 if (RealFileExists(file.c_str()) == true)
 936                         break;
 937                 file.clear();
 938         }
 939
 940         if (file.empty() == true)
 941         {
 942                 _error->Error("Can't call external %s '%s' as it is not in a configured directory!", type, binary);
 943                 return 0;
 944         }
 945         int external[4] = {-1, -1, -1, -1};
 946         if (pipe(external) != 0 || pipe(external + 2) != 0)
 947         {
 948                 _error->Errno("Resolve", "Can't create needed IPC pipes for EDSP");
 949                 return 0;
 950         }
 951         for (int i = 0; i < 4; ++i)
 952                 SetCloseExec(external[i], true);
 953
 954         pid_t Solver = ExecFork();
 955         if (Solver == 0) {
 956                 dup2(external[0], STDIN_FILENO);
 957                 dup2(external[3], STDOUT_FILENO);
 958                 const char* calling[2] = { file.c_str(), 0 };
 959                 execv(calling[0], (char**) calling);
 960                 std::cerr << "Failed to execute " << type << " '" << binary << "'!" << std::endl;
 961                 _exit(100);
 962         }
 963         close(external[0]);
 964         close(external[3]);
 965
 966         if (WaitFd(external[1], true, 5) == false)
 967         {
 968                 _error->Errno("Resolve", "Timed out while Waiting on availability of %s stdin", type);
 969                 return 0;
 970         }
 971
 972         *solver_in = external[1];
 973         *solver_out = external[2];
 974         return Solver;
 975 }
 976                                                                         /*}}}*/
 977 // EDSP::ExecuteSolver - fork requested solver and setup ipc pipes      {{{*/
 978 pid_t EDSP::ExecuteSolver(const char* const solver, int * const solver_in, int * const solver_out, bool) {
 979         return ExecuteExternal("solver", solver, "Dir::Bin::Solvers", solver_in, solver_out);
 980 }
 981 bool EDSP::ExecuteSolver(const char* const solver, int *solver_in, int *solver_out) {
 982    if (ExecuteSolver(solver, solver_in, solver_out, true) == 0)
 983       return false;
 984    return true;
 985 }
 986                                                                         /*}}}*/
 987 // EDSP::ResolveExternal - resolve problems by asking external for help {{{*/
 988 bool EDSP::ResolveExternal(const char* const solver, pkgDepCache &Cache,
 989                          unsigned int const flags, OpProgress *Progress) {
 990         int solver_in, solver_out;
 991         pid_t const solver_pid = EDSP::ExecuteSolver(solver, &solver_in, &solver_out, true);
 992         if (solver_pid == 0)
 993                 return false;
 994
 995         FileFd output;
 996         if (output.OpenDescriptor(solver_in, FileFd::WriteOnly | FileFd::BufferedWrite, true) == false)
 997                 return _error->Errno("ResolveExternal", "Opening solver %s stdin on fd %d for writing failed", solver, solver_in);
 998
 999         bool Okay = output.Failed() == false;
1000         if (Progress != NULL)
1001                 Progress->OverallProgress(0, 100, 5, _("Execute external solver"));
1002         Okay &= EDSP::WriteRequest(Cache, output, flags, Progress);
1003         if (Progress != NULL)
1004                 Progress->OverallProgress(5, 100, 20, _("Execute external solver"));
1005         Okay &= EDSP::WriteScenario(Cache, output, Progress);
1006         output.Close();
1007
1008         if (Progress != NULL)
1009                 Progress->OverallProgress(25, 100, 75, _("Execute external solver"));
1010         if (Okay && EDSP::ReadResponse(solver_out, Cache, Progress) == false)
1011                 return false;
1012
1013         return ExecWait(solver_pid, solver);
1014 }
1015 bool EDSP::ResolveExternal(const char* const solver, pkgDepCache &Cache,
1016                          bool const upgrade, bool const distUpgrade,
1017                          bool const autoRemove, OpProgress *Progress) {
1018    unsigned int flags = 0;
1019    if (autoRemove)
1020       flags |= Request::AUTOREMOVE;
1021    if (upgrade)
1022       flags |= Request::UPGRADE_ALL | Request::FORBID_REMOVE | Request::FORBID_NEW_INSTALL;
1023    if (distUpgrade)
1024       flags |= Request::UPGRADE_ALL;
1025    return ResolveExternal(solver, Cache, flags, Progress);
1026 }
1027                                                                         /*}}}*/