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/prettyprinters.h>
  16 #include <apt-pkg/packagemanager.h>
  17 #include <apt-pkg/progress.h>
  18 #include <apt-pkg/fileutl.h>
  19 #include <apt-pkg/edsp.h>
  20 #include <apt-pkg/tagfile.h>
  21 #include <apt-pkg/strutl.h>
  22 #include <apt-pkg/string_view.h>
  23 #include <apt-pkg/pkgsystem.h>
  24
  25 #include <sys/stat.h>
  26 #include <ctype.h>
  27 #include <stddef.h>
  28 #include <string.h>
  29 #include <unistd.h>
  30 #include <stdio.h>
  31
  32 #include <array>
  33 #include <limits>
  34 #include <string>
  35
  36 #include <apti18n.h>
  37                                                                         /*}}}*/
  38
  39 using std::string;
  40
  41 // we could use pkgCache::DepType and ::Priority, but these would be localized strings…
  42 constexpr char const * const PrioMap[] = {
  43    nullptr, "important", "required", "standard",
  44    "optional", "extra"
  45 };
  46 constexpr char const * const DepMap[] = {
  47    nullptr, "Depends", "Pre-Depends", "Suggests",
  48    "Recommends" , "Conflicts", "Replaces",
  49    "Obsoletes", "Breaks", "Enhances"
  50 };
  51
  52 // WriteOkay - varaidic helper to easily Write to a FileFd              /*{{{*/
  53 static bool WriteOkay_fn(FileFd &) { return true; }
  54 template<typename... Tail> static bool WriteOkay_fn(FileFd &output, APT::StringView data, Tail... more_data)
  55 {
  56    return likely(output.Write(data.data(), data.length()) && WriteOkay_fn(output, more_data...));
  57 }
  58 template<typename... Tail> static bool WriteOkay_fn(FileFd &output, unsigned int data, Tail... more_data)
  59 {
  60    std::string number;
  61    strprintf(number, "%d", data);
  62    return likely(output.Write(number.data(), number.length()) && WriteOkay_fn(output, more_data...));
  63 }
  64 template<typename... Data> static bool WriteOkay(bool &Okay, FileFd &output, Data&&... data)
  65 {
  66    Okay = likely(Okay && WriteOkay_fn(output, std::forward<Data>(data)...));
  67    return Okay;
  68 }
  69 template<typename... Data> static bool WriteOkay(FileFd &output, Data&&... data)
  70 {
  71    bool Okay = likely(output.Failed() == false);
  72    return WriteOkay(Okay, output, std::forward<Data>(data)...);
  73 }
  74                                                                         /*}}}*/
  75 // WriteScenarioVersion                                                 /*{{{*/
  76 static void WriteScenarioVersion(pkgDepCache &Cache, FILE* output, pkgCache::PkgIterator const &Pkg,
  77                                 pkgCache::VerIterator const &Ver)
  78 {
  79    fprintf(output, "Package: %s\n", Pkg.Name());
  80    fprintf(output, "Source: %s\n", Ver.SourcePkgName());
  81    fprintf(output, "Architecture: %s\n", Ver.Arch());
  82    fprintf(output, "Version: %s\n", Ver.VerStr());
  83    fprintf(output, "Source-Version: %s\n", Ver.SourceVerStr());
  84    if (Pkg.CurrentVer() == Ver)
  85       fprintf(output, "Installed: yes\n");
  86    if (Pkg->SelectedState == pkgCache::State::Hold ||
  87        (Cache[Pkg].Keep() == true && Cache[Pkg].Protect() == true))
  88       fprintf(output, "Hold: yes\n");
  89    fprintf(output, "APT-ID: %d\n", Ver->ID);
  90    if (PrioMap[Ver->Priority] != nullptr)
  91       fprintf(output, "Priority: %s\n", PrioMap[Ver->Priority]);
  92    if ((Pkg->Flags & pkgCache::Flag::Essential) == pkgCache::Flag::Essential)
  93       fprintf(output, "Essential: yes\n");
  94    if (Ver->Section != 0)
  95       fprintf(output, "Section: %s\n", Ver.Section());
  96    if ((Ver->MultiArch & pkgCache::Version::Allowed) == pkgCache::Version::Allowed)
  97       fprintf(output, "Multi-Arch: allowed\n");
  98    else if ((Ver->MultiArch & pkgCache::Version::Foreign) == pkgCache::Version::Foreign)
  99       fprintf(output, "Multi-Arch: foreign\n");
 100    else if ((Ver->MultiArch & pkgCache::Version::Same) == pkgCache::Version::Same)
 101       fprintf(output, "Multi-Arch: same\n");
 102    std::set<string> Releases;
 103    for (pkgCache::VerFileIterator I = Ver.FileList(); I.end() == false; ++I) {
 104       pkgCache::PkgFileIterator File = I.File();
 105       if (File.Flagged(pkgCache::Flag::NotSource) == false) {
 106          string Release = File.RelStr();
 107          if (!Release.empty())
 108             Releases.insert(Release);
 109       }
 110    }
 111    if (!Releases.empty()) {
 112        fprintf(output, "APT-Release:\n");
 113        for (std::set<string>::iterator R = Releases.begin(); R != Releases.end(); ++R)
 114            fprintf(output, " %s\n", R->c_str());
 115    }
 116    fprintf(output, "APT-Pin: %d\n", Cache.GetPolicy().GetPriority(Ver));
 117    if (Cache.GetCandidateVersion(Pkg) == Ver)
 118       fprintf(output, "APT-Candidate: yes\n");
 119    if ((Cache[Pkg].Flags & pkgCache::Flag::Auto) == pkgCache::Flag::Auto)
 120       fprintf(output, "APT-Automatic: yes\n");
 121 }
 122 static bool WriteScenarioVersion(FileFd &output, pkgCache::PkgIterator const &Pkg,
 123                                 pkgCache::VerIterator const &Ver)
 124 {
 125    bool Okay = WriteOkay(output, "Package: ", Pkg.Name(),
 126          "\nArchitecture: ", Ver.Arch(),
 127          "\nVersion: ", Ver.VerStr());
 128    WriteOkay(Okay, output, "\nAPT-ID: ", Ver->ID);
 129    if ((Pkg->Flags & pkgCache::Flag::Essential) == pkgCache::Flag::Essential)
 130       WriteOkay(Okay, output, "\nEssential: yes");
 131    if ((Ver->MultiArch & pkgCache::Version::Allowed) == pkgCache::Version::Allowed)
 132       WriteOkay(Okay, output, "\nMulti-Arch: allowed");
 133    else if ((Ver->MultiArch & pkgCache::Version::Foreign) == pkgCache::Version::Foreign)
 134       WriteOkay(Okay, output, "\nMulti-Arch: foreign");
 135    else if ((Ver->MultiArch & pkgCache::Version::Same) == pkgCache::Version::Same)
 136       WriteOkay(Okay, output, "\nMulti-Arch: same");
 137    return Okay;
 138 }
 139                                                                         /*}}}*/
 140 // WriteScenarioDependency                                              /*{{{*/
 141 static void WriteScenarioDependency( FILE* output, pkgCache::VerIterator const &Ver)
 142 {
 143    std::array<std::string, _count(DepMap)> dependencies;
 144    bool orGroup = false;
 145    for (pkgCache::DepIterator Dep = Ver.DependsList(); Dep.end() == false; ++Dep)
 146    {
 147       if (Dep.IsImplicit() == true)
 148          continue;
 149       if (orGroup == false)
 150          dependencies[Dep->Type].append(", ");
 151       dependencies[Dep->Type].append(Dep.TargetPkg().Name());
 152       if (Dep->Version != 0)
 153          dependencies[Dep->Type].append(" (").append(pkgCache::CompTypeDeb(Dep->CompareOp)).append(" ").append(Dep.TargetVer()).append(")");
 154       if ((Dep->CompareOp & pkgCache::Dep::Or) == pkgCache::Dep::Or)
 155       {
 156          dependencies[Dep->Type].append(" | ");
 157          orGroup = true;
 158       }
 159       else
 160          orGroup = false;
 161    }
 162    for (size_t i = 1; i < dependencies.size(); ++i)
 163       if (dependencies[i].empty() == false)
 164          fprintf(output, "%s: %s\n", DepMap[i], dependencies[i].c_str()+2);
 165    string provides;
 166    for (pkgCache::PrvIterator Prv = Ver.ProvidesList(); Prv.end() == false; ++Prv)
 167    {
 168       if (Prv.IsMultiArchImplicit() == true)
 169          continue;
 170       if (provides.empty() == false)
 171          provides.append(", ");
 172       provides.append(Prv.Name());
 173       if (Prv->ProvideVersion != 0)
 174          provides.append(" (= ").append(Prv.ProvideVersion()).append(")");
 175    }
 176    if (provides.empty() == false)
 177       fprintf(output, "Provides: %s\n", provides.c_str());
 178 }
 179 static bool WriteScenarioDependency(FileFd &output, pkgCache::VerIterator const &Ver, bool const OnlyCritical)
 180 {
 181    std::array<std::string, _count(DepMap)> dependencies;
 182    bool orGroup = false;
 183    for (pkgCache::DepIterator Dep = Ver.DependsList(); Dep.end() == false; ++Dep)
 184    {
 185       if (Dep.IsImplicit() == true)
 186          continue;
 187       if (OnlyCritical && Dep.IsCritical() == false)
 188          continue;
 189       if (orGroup == false && dependencies[Dep->Type].empty() == false)
 190          dependencies[Dep->Type].append(", ");
 191       dependencies[Dep->Type].append(Dep.TargetPkg().Name());
 192       if (Dep->Version != 0)
 193          dependencies[Dep->Type].append(" (").append(pkgCache::CompTypeDeb(Dep->CompareOp)).append(" ").append(Dep.TargetVer()).append(")");
 194       if ((Dep->CompareOp & pkgCache::Dep::Or) == pkgCache::Dep::Or)
 195       {
 196          dependencies[Dep->Type].append(" | ");
 197          orGroup = true;
 198       }
 199       else
 200          orGroup = false;
 201    }
 202    bool Okay = output.Failed() == false;
 203    for (size_t i = 1; i < dependencies.size(); ++i)
 204       if (dependencies[i].empty() == false)
 205          WriteOkay(Okay, output, "\n", DepMap[i], ": ", dependencies[i]);
 206    string provides;
 207    for (pkgCache::PrvIterator Prv = Ver.ProvidesList(); Prv.end() == false; ++Prv)
 208    {
 209       if (Prv.IsMultiArchImplicit() == true)
 210          continue;
 211       if (provides.empty() == false)
 212          provides.append(", ");
 213       provides.append(Prv.Name());
 214       if (Prv->ProvideVersion != 0)
 215          provides.append(" (= ").append(Prv.ProvideVersion()).append(")");
 216    }
 217    if (provides.empty() == false)
 218       WriteOkay(Okay, output, "\nProvides: ", provides);
 219    return WriteOkay(Okay, output, "\n");
 220 }
 221                                                                         /*}}}*/
 222 // WriteScenarioLimitedDependency                                       /*{{{*/
 223 static void WriteScenarioLimitedDependency(FILE* output,
 224                                           pkgCache::VerIterator const &Ver,
 225                                           APT::PackageSet const &pkgset)
 226 {
 227    std::array<std::string, _count(DepMap)> dependencies;
 228    bool orGroup = false;
 229    for (pkgCache::DepIterator Dep = Ver.DependsList(); Dep.end() == false; ++Dep)
 230    {
 231       if (Dep.IsImplicit() == true)
 232          continue;
 233       if (orGroup == false)
 234       {
 235          if (pkgset.find(Dep.TargetPkg()) == pkgset.end())
 236             continue;
 237          if (dependencies[Dep->Type].empty() == false)
 238             dependencies[Dep->Type].append(", ");
 239       }
 240       else if (pkgset.find(Dep.TargetPkg()) == pkgset.end())
 241       {
 242          if ((Dep->CompareOp & pkgCache::Dep::Or) == pkgCache::Dep::Or)
 243             continue;
 244          dependencies[Dep->Type].erase(dependencies[Dep->Type].end()-3, dependencies[Dep->Type].end());
 245          orGroup = false;
 246          continue;
 247       }
 248       dependencies[Dep->Type].append(Dep.TargetPkg().Name());
 249       if (Dep->Version != 0)
 250          dependencies[Dep->Type].append(" (").append(pkgCache::CompTypeDeb(Dep->CompareOp)).append(" ").append(Dep.TargetVer()).append(")");
 251       if ((Dep->CompareOp & pkgCache::Dep::Or) == pkgCache::Dep::Or)
 252       {
 253          dependencies[Dep->Type].append(" | ");
 254          orGroup = true;
 255       }
 256       else
 257          orGroup = false;
 258    }
 259    for (size_t i = 1; i < dependencies.size(); ++i)
 260       if (dependencies[i].empty() == false)
 261          fprintf(output, "%s: %s\n", DepMap[i], dependencies[i].c_str());
 262    string provides;
 263    for (pkgCache::PrvIterator Prv = Ver.ProvidesList(); Prv.end() == false; ++Prv)
 264    {
 265       if (Prv.IsMultiArchImplicit() == true)
 266          continue;
 267       if (pkgset.find(Prv.ParentPkg()) == pkgset.end())
 268          continue;
 269       if (provides.empty() == false)
 270          provides.append(", ");
 271       provides.append(Prv.Name());
 272       if (Prv->ProvideVersion != 0)
 273          provides.append(" (= ").append(Prv.ProvideVersion()).append(")");
 274    }
 275    if (provides.empty() == false)
 276       fprintf(output, "Provides: %s\n", provides.c_str());
 277 }
 278 static bool WriteScenarioLimitedDependency(FileFd &output,
 279                                           pkgCache::VerIterator const &Ver,
 280                                           std::vector<bool> const &pkgset,
 281                                           bool const OnlyCritical)
 282 {
 283    std::array<std::string, _count(DepMap)> dependencies;
 284    bool orGroup = false;
 285    for (pkgCache::DepIterator Dep = Ver.DependsList(); Dep.end() == false; ++Dep)
 286    {
 287       if (Dep.IsImplicit() == true)
 288          continue;
 289       if (OnlyCritical && Dep.IsCritical() == false)
 290          continue;
 291       if (orGroup == false)
 292       {
 293          if (pkgset[Dep.TargetPkg()->ID] == false)
 294             continue;
 295          if (dependencies[Dep->Type].empty() == false)
 296             dependencies[Dep->Type].append(", ");
 297       }
 298       else if (pkgset[Dep.TargetPkg()->ID] == false)
 299       {
 300          if ((Dep->CompareOp & pkgCache::Dep::Or) == pkgCache::Dep::Or)
 301             continue;
 302          dependencies[Dep->Type].erase(dependencies[Dep->Type].end()-3, dependencies[Dep->Type].end());
 303          orGroup = false;
 304          continue;
 305       }
 306       dependencies[Dep->Type].append(Dep.TargetPkg().Name());
 307       if (Dep->Version != 0)
 308          dependencies[Dep->Type].append(" (").append(pkgCache::CompTypeDeb(Dep->CompareOp)).append(" ").append(Dep.TargetVer()).append(")");
 309       if ((Dep->CompareOp & pkgCache::Dep::Or) == pkgCache::Dep::Or)
 310       {
 311          dependencies[Dep->Type].append(" | ");
 312          orGroup = true;
 313       }
 314       else
 315          orGroup = false;
 316    }
 317    bool Okay = output.Failed() == false;
 318    for (size_t i = 1; i < dependencies.size(); ++i)
 319       if (dependencies[i].empty() == false)
 320          WriteOkay(Okay, output, "\n", DepMap[i], ": ", dependencies[i]);
 321    string provides;
 322    for (pkgCache::PrvIterator Prv = Ver.ProvidesList(); Prv.end() == false; ++Prv)
 323    {
 324       if (Prv.IsMultiArchImplicit() == true)
 325          continue;
 326       if (pkgset[Prv.ParentPkg()->ID] == false)
 327          continue;
 328       if (provides.empty() == false)
 329          provides.append(", ");
 330       provides.append(Prv.Name());
 331       if (Prv->ProvideVersion != 0)
 332          provides.append(" (= ").append(Prv.ProvideVersion()).append(")");
 333    }
 334    if (provides.empty() == false)
 335       WriteOkay(Okay, output, "\nProvides: ", provides);
 336    return WriteOkay(Okay, output, "\n");
 337 }
 338                                                                         /*}}}*/
 339 static bool SkipUnavailableVersions(pkgDepCache &Cache, pkgCache::PkgIterator const &Pkg, pkgCache::VerIterator const &Ver)/*{{{*/
 340 {
 341    /* versions which aren't current and aren't available in
 342       any "online" source file are bad, expect if they are the choosen
 343       candidate: The exception is for build-dep implementation as it creates
 344       such pseudo (package) versions and removes them later on again.
 345       We filter out versions at all so packages in 'rc' state only available
 346       in dpkg/status aren't passed to solvers as they can't be installed. */
 347    if (Pkg->CurrentVer != 0)
 348       return false;
 349    if (Cache.GetCandidateVersion(Pkg) == Ver)
 350       return false;
 351    for (pkgCache::VerFileIterator I = Ver.FileList(); I.end() == false; ++I)
 352       if (I.File().Flagged(pkgCache::Flag::NotSource) == false)
 353          return false;
 354    return true;
 355 }
 356                                                                         /*}}}*/
 357 static bool WriteScenarioEDSPVersion(pkgDepCache &Cache, FileFd &output, pkgCache::PkgIterator const &Pkg,/*{{{*/
 358                                 pkgCache::VerIterator const &Ver)
 359 {
 360    bool Okay = WriteOkay(output, "\nSource: ", Ver.SourcePkgName(),
 361          "\nSource-Version: ", Ver.SourceVerStr());
 362    if (PrioMap[Ver->Priority] != nullptr)
 363       WriteOkay(Okay, output, "\nPriority: ", PrioMap[Ver->Priority]);
 364    if (Ver->Section != 0)
 365       WriteOkay(Okay, output, "\nSection: ", Ver.Section());
 366    if (Pkg.CurrentVer() == Ver)
 367       WriteOkay(Okay, output, "\nInstalled: yes");
 368    if (Pkg->SelectedState == pkgCache::State::Hold ||
 369        (Cache[Pkg].Keep() == true && Cache[Pkg].Protect() == true))
 370       WriteOkay(Okay, output, "\nHold: yes");
 371    std::set<string> Releases;
 372    for (pkgCache::VerFileIterator I = Ver.FileList(); I.end() == false; ++I) {
 373       pkgCache::PkgFileIterator File = I.File();
 374       if (File.Flagged(pkgCache::Flag::NotSource) == false) {
 375          string Release = File.RelStr();
 376          if (!Release.empty())
 377             Releases.insert(Release);
 378       }
 379    }
 380    if (!Releases.empty()) {
 381        WriteOkay(Okay, output, "\nAPT-Release:");
 382        for (std::set<string>::iterator R = Releases.begin(); R != Releases.end(); ++R)
 383            WriteOkay(Okay, output, "\n ", *R);
 384    }
 385    WriteOkay(Okay, output, "\nAPT-Pin: ", Cache.GetPolicy().GetPriority(Ver));
 386    if (Cache.GetCandidateVersion(Pkg) == Ver)
 387       WriteOkay(Okay, output, "\nAPT-Candidate: yes");
 388    if ((Cache[Pkg].Flags & pkgCache::Flag::Auto) == pkgCache::Flag::Auto)
 389       WriteOkay(Okay, output, "\nAPT-Automatic: yes");
 390    return Okay;
 391 }
 392                                                                         /*}}}*/
 393 // EDSP::WriteScenario - to the given file descriptor                   /*{{{*/
 394 bool EDSP::WriteScenario(pkgDepCache &Cache, FILE* output, OpProgress *Progress)
 395 {
 396    if (Progress != NULL)
 397       Progress->SubProgress(Cache.Head().VersionCount, _("Send scenario to solver"));
 398    unsigned long p = 0;
 399    std::vector<std::string> archs = APT::Configuration::getArchitectures();
 400    for (pkgCache::PkgIterator Pkg = Cache.PkgBegin(); Pkg.end() == false; ++Pkg)
 401    {
 402       std::string const arch = Pkg.Arch();
 403       if (std::find(archs.begin(), archs.end(), arch) == archs.end())
 404          continue;
 405       for (pkgCache::VerIterator Ver = Pkg.VersionList(); Ver.end() == false; ++Ver, ++p)
 406       {
 407          if (SkipUnavailableVersions(Cache, Pkg, Ver))
 408             continue;
 409          WriteScenarioVersion(Cache, output, Pkg, Ver);
 410          WriteScenarioDependency(output, Ver);
 411          fprintf(output, "\n");
 412          if (Progress != NULL && p % 100 == 0)
 413             Progress->Progress(p);
 414       }
 415    }
 416    return true;
 417 }
 418 bool EDSP::WriteScenario(pkgDepCache &Cache, FileFd &output, OpProgress *Progress)
 419 {
 420    if (Progress != NULL)
 421       Progress->SubProgress(Cache.Head().VersionCount, _("Send scenario to solver"));
 422    unsigned long p = 0;
 423    bool Okay = output.Failed() == false;
 424    std::vector<std::string> archs = APT::Configuration::getArchitectures();
 425    for (pkgCache::PkgIterator Pkg = Cache.PkgBegin(); Pkg.end() == false && likely(Okay); ++Pkg)
 426    {
 427       std::string const arch = Pkg.Arch();
 428       if (std::find(archs.begin(), archs.end(), arch) == archs.end())
 429          continue;
 430       for (pkgCache::VerIterator Ver = Pkg.VersionList(); Ver.end() == false && likely(Okay); ++Ver, ++p)
 431       {
 432          if (SkipUnavailableVersions(Cache, Pkg, Ver))
 433             continue;
 434          Okay &= WriteScenarioVersion(output, Pkg, Ver);
 435          Okay &= WriteScenarioEDSPVersion(Cache, output, Pkg, Ver);
 436          Okay &= WriteScenarioDependency(output, Ver, false);
 437          WriteOkay(Okay, output, "\n");
 438          if (Progress != NULL && p % 100 == 0)
 439             Progress->Progress(p);
 440       }
 441    }
 442    return true;
 443 }
 444                                                                         /*}}}*/
 445 // EDSP::WriteLimitedScenario - to the given file descriptor            /*{{{*/
 446 bool EDSP::WriteLimitedScenario(pkgDepCache &Cache, FILE* output,
 447                                 APT::PackageSet const &pkgset,
 448                                 OpProgress *Progress)
 449 {
 450    if (Progress != NULL)
 451       Progress->SubProgress(Cache.Head().VersionCount, _("Send scenario to solver"));
 452    unsigned long p  = 0;
 453    for (APT::PackageSet::const_iterator Pkg = pkgset.begin(); Pkg != pkgset.end(); ++Pkg, ++p)
 454       for (pkgCache::VerIterator Ver = Pkg.VersionList(); Ver.end() == false; ++Ver)
 455       {
 456          if (SkipUnavailableVersions(Cache, Pkg, Ver))
 457             continue;
 458          WriteScenarioVersion(Cache, output, Pkg, Ver);
 459          WriteScenarioLimitedDependency(output, Ver, pkgset);
 460          fprintf(output, "\n");
 461          if (Progress != NULL && p % 100 == 0)
 462             Progress->Progress(p);
 463       }
 464    if (Progress != NULL)
 465       Progress->Done();
 466    return true;
 467 }
 468 bool EDSP::WriteLimitedScenario(pkgDepCache &Cache, FileFd &output,
 469                                 std::vector<bool> const &pkgset,
 470                                 OpProgress *Progress)
 471 {
 472    if (Progress != NULL)
 473       Progress->SubProgress(Cache.Head().VersionCount, _("Send scenario to solver"));
 474    unsigned long p  = 0;
 475    bool Okay = output.Failed() == false;
 476    for (auto Pkg = Cache.PkgBegin(); Pkg.end() == false && likely(Okay); ++Pkg, ++p)
 477    {
 478       if (pkgset[Pkg->ID] == false)
 479          continue;
 480       for (pkgCache::VerIterator Ver = Pkg.VersionList(); Ver.end() == false && likely(Okay); ++Ver)
 481       {
 482          if (SkipUnavailableVersions(Cache, Pkg, Ver))
 483             continue;
 484          Okay &= WriteScenarioVersion(output, Pkg, Ver);
 485          Okay &= WriteScenarioEDSPVersion(Cache, output, Pkg, Ver);
 486          Okay &= WriteScenarioLimitedDependency(output, Ver, pkgset, false);
 487          WriteOkay(Okay, output, "\n");
 488          if (Progress != NULL && p % 100 == 0)
 489             Progress->Progress(p);
 490       }
 491    }
 492    if (Progress != NULL)
 493       Progress->Done();
 494    return Okay;
 495 }
 496                                                                         /*}}}*/
 497 // EDSP::WriteRequest - to the given file descriptor                    /*{{{*/
 498 bool EDSP::WriteRequest(pkgDepCache &Cache, FILE* output, bool const Upgrade,
 499                         bool const DistUpgrade, bool const AutoRemove,
 500                         OpProgress *Progress)
 501 {
 502    if (Progress != NULL)
 503       Progress->SubProgress(Cache.Head().PackageCount, _("Send request to solver"));
 504    unsigned long p = 0;
 505    string del, inst;
 506    for (pkgCache::PkgIterator Pkg = Cache.PkgBegin(); Pkg.end() == false; ++Pkg, ++p)
 507    {
 508       if (Progress != NULL && p % 100 == 0)
 509          Progress->Progress(p);
 510       string* req;
 511       pkgDepCache::StateCache &P = Cache[Pkg];
 512       if (P.Delete() == true)
 513          req = &del;
 514       else if (P.NewInstall() == true || P.Upgrade() == true || P.ReInstall() == true ||
 515                (P.Mode == pkgDepCache::ModeKeep && (P.iFlags & pkgDepCache::Protected) == pkgDepCache::Protected))
 516          req = &inst;
 517       else
 518          continue;
 519       req->append(" ").append(Pkg.FullName());
 520    }
 521    fprintf(output, "Request: EDSP 0.5\n");
 522
 523    const char *arch = _config->Find("APT::Architecture").c_str();
 524    std::vector<string> archs = APT::Configuration::getArchitectures();
 525    fprintf(output, "Architecture: %s\n", arch);
 526    fprintf(output, "Architectures:");
 527    for (std::vector<string>::const_iterator a = archs.begin(); a != archs.end(); ++a)
 528        fprintf(output, " %s", a->c_str());
 529    fprintf(output, "\n");
 530
 531    if (del.empty() == false)
 532       fprintf(output, "Remove: %s\n", del.c_str()+1);
 533    if (inst.empty() == false)
 534       fprintf(output, "Install: %s\n", inst.c_str()+1);
 535    if (Upgrade == true)
 536       fprintf(output, "Upgrade: yes\n");
 537    if (DistUpgrade == true)
 538       fprintf(output, "Dist-Upgrade: yes\n");
 539    if (AutoRemove == true)
 540       fprintf(output, "Autoremove: yes\n");
 541    auto const solver = _config->Find("APT::Solver", "internal");
 542    fprintf(output, "Solver: %s\n", solver.c_str());
 543    auto const solverconf = std::string("APT::Solver::") + solver + "::";
 544    if (_config->FindB(solverconf + "Strict-Pinning", _config->FindB("APT::Solver::Strict-Pinning", true)) == false)
 545       fprintf(output, "Strict-Pinning: no\n");
 546    auto const solverpref = _config->Find(solverconf + "Preferences", _config->Find("APT::Solver::Preferences", ""));
 547    if (solverpref.empty() == false)
 548       fprintf(output, "Preferences: %s\n", solverpref.c_str());
 549    fprintf(output, "\n");
 550    return true;
 551 }
 552 bool EDSP::WriteRequest(pkgDepCache &Cache, FileFd &output,
 553                         unsigned int const flags,
 554                         OpProgress *Progress)
 555 {
 556    if (Progress != NULL)
 557       Progress->SubProgress(Cache.Head().PackageCount, _("Send request to solver"));
 558    unsigned long p = 0;
 559    string del, inst;
 560    for (pkgCache::PkgIterator Pkg = Cache.PkgBegin(); Pkg.end() == false; ++Pkg, ++p)
 561    {
 562       if (Progress != NULL && p % 100 == 0)
 563          Progress->Progress(p);
 564       string* req;
 565       pkgDepCache::StateCache &P = Cache[Pkg];
 566       if (P.Delete() == true)
 567          req = &del;
 568       else if (P.NewInstall() == true || P.Upgrade() == true || P.ReInstall() == true ||
 569                (P.Mode == pkgDepCache::ModeKeep && (P.iFlags & pkgDepCache::Protected) == pkgDepCache::Protected))
 570          req = &inst;
 571       else
 572          continue;
 573       req->append(" ").append(Pkg.FullName());
 574    }
 575    bool Okay = WriteOkay(output, "Request: EDSP 0.5\n");
 576
 577    const char *arch = _config->Find("APT::Architecture").c_str();
 578    std::vector<string> archs = APT::Configuration::getArchitectures();
 579    WriteOkay(Okay, output, "Architecture: ", arch, "\n",
 580          "Architectures:");
 581    for (std::vector<string>::const_iterator a = archs.begin(); a != archs.end(); ++a)
 582        WriteOkay(Okay, output, " ", *a);
 583    WriteOkay(Okay, output, "\n");
 584
 585    if (del.empty() == false)
 586       WriteOkay(Okay, output, "Remove:", del, "\n");
 587    if (inst.empty() == false)
 588       WriteOkay(Okay, output, "Install:", inst, "\n");
 589    if (flags & Request::AUTOREMOVE)
 590       WriteOkay(Okay, output, "Autoremove: yes\n");
 591    if (flags & Request::UPGRADE_ALL)
 592    {
 593       WriteOkay(Okay, output, "Upgrade-All: yes\n");
 594       if (flags & (Request::FORBID_NEW_INSTALL | Request::FORBID_REMOVE))
 595          WriteOkay(Okay, output, "Upgrade: yes\n");
 596       else
 597          WriteOkay(Okay, output, "Dist-Upgrade: yes\n");
 598    }
 599    if (flags & Request::FORBID_NEW_INSTALL)
 600       WriteOkay(Okay, output, "Forbid-New-Install: yes\n");
 601    if (flags & Request::FORBID_REMOVE)
 602       WriteOkay(Okay, output, "Forbid-Remove: yes\n");
 603    auto const solver = _config->Find("APT::Solver", "internal");
 604    WriteOkay(Okay, output, "Solver: ", solver, "\n");
 605    if (_config->FindB("APT::Solver::Strict-Pinning", true) == false)
 606       WriteOkay(Okay, output, "Strict-Pinning: no\n");
 607    string solverpref("APT::Solver::");
 608    solverpref.append(solver).append("::Preferences");
 609    if (_config->Exists(solverpref) == true)
 610       WriteOkay(Okay, output, "Preferences: ", _config->Find(solverpref,""), "\n");
 611    return WriteOkay(Okay, output, "\n");
 612 }
 613                                                                         /*}}}*/
 614 // EDSP::ReadResponse - from the given file descriptor                  /*{{{*/
 615 bool EDSP::ReadResponse(int const input, pkgDepCache &Cache, OpProgress *Progress) {
 616         /* We build an map id to mmap offset here
 617            In theory we could use the offset as ID, but then VersionCount
 618            couldn't be used to create other versionmappings anymore and it
 619            would be too easy for a (buggy) solver to segfault APT… */
 620         unsigned long long const VersionCount = Cache.Head().VersionCount;
 621         unsigned long VerIdx[VersionCount];
 622         for (pkgCache::PkgIterator P = Cache.PkgBegin(); P.end() == false; ++P) {
 623                 for (pkgCache::VerIterator V = P.VersionList(); V.end() == false; ++V)
 624                         VerIdx[V->ID] = V.Index();
 625                 Cache[P].Marked = true;
 626                 Cache[P].Garbage = false;
 627         }
 628
 629         FileFd in;
 630         in.OpenDescriptor(input, FileFd::ReadOnly, true);
 631         pkgTagFile response(&in, 100);
 632         pkgTagSection section;
 633
 634         std::set<decltype(Cache.PkgBegin()->ID)> seenOnce;
 635         while (response.Step(section) == true) {
 636                 std::string type;
 637                 if (section.Exists("Install") == true)
 638                         type = "Install";
 639                 else if (section.Exists("Remove") == true)
 640                         type = "Remove";
 641                 else if (section.Exists("Progress") == true) {
 642                         if (Progress != NULL) {
 643                                 string msg = section.FindS("Message");
 644                                 if (msg.empty() == true)
 645                                         msg = _("Prepare for receiving solution");
 646                                 Progress->SubProgress(100, msg, section.FindI("Percentage", 0));
 647                         }
 648                         continue;
 649                 } else if (section.Exists("Error") == true) {
 650                         std::string msg = SubstVar(SubstVar(section.FindS("Message"), "\n .\n", "\n\n"), "\n ", "\n");
 651                         if (msg.empty() == true) {
 652                                 msg = _("External solver failed without a proper error message");
 653                                 _error->Error("%s", msg.c_str());
 654                         } else
 655                                 _error->Error("External solver failed with: %s", msg.substr(0,msg.find('\n')).c_str());
 656                         if (Progress != NULL)
 657                                 Progress->Done();
 658                         std::cerr << "The solver encountered an error of type: " << section.FindS("Error") << std::endl;
 659                         std::cerr << "The following information might help you to understand what is wrong:" << std::endl;
 660                         std::cerr << msg << std::endl << std::endl;
 661                         return false;
 662                 } else if (section.Exists("Autoremove") == true)
 663                         type = "Autoremove";
 664                 else {
 665                         char const *Start, *End;
 666                         section.GetSection(Start, End);
 667                         _error->Warning("Encountered an unexpected section with %d fields: %s", section.Count(), std::string(Start, End).c_str());
 668                         continue;
 669                 }
 670
 671                 size_t const id = section.FindULL(type.c_str(), VersionCount);
 672                 if (id == VersionCount) {
 673                         _error->Warning("Unable to parse %s request with id value '%s'!", type.c_str(), section.FindS(type.c_str()).c_str());
 674                         continue;
 675                 } else if (id > Cache.Head().VersionCount) {
 676                         _error->Warning("ID value '%s' in %s request stanza is to high to refer to a known version!", section.FindS(type.c_str()).c_str(), type.c_str());
 677                         continue;
 678                 }
 679
 680                 pkgCache::VerIterator Ver(Cache.GetCache(), Cache.GetCache().VerP + VerIdx[id]);
 681                 auto const Pkg = Ver.ParentPkg();
 682                 if (type == "Autoremove") {
 683                         Cache[Pkg].Marked = false;
 684                         Cache[Pkg].Garbage = true;
 685                 } else if (seenOnce.emplace(Pkg->ID).second == false) {
 686                         _error->Warning("Ignoring %s stanza received for package %s which already had a previous stanza effecting it!", type.c_str(), Pkg.FullName(false).c_str());
 687                 } else if (type == "Install") {
 688                         if (Pkg.CurrentVer() == Ver) {
 689                                 _error->Warning("Ignoring Install stanza received for version %s of package %s which is already installed!",
 690                                       Ver.VerStr(), Pkg.FullName(false).c_str());
 691                         } else {
 692                                 Cache.SetCandidateVersion(Ver);
 693                                 Cache.MarkInstall(Pkg, false, 0, false);
 694                         }
 695                 } else if (type == "Remove") {
 696                         if (Pkg->CurrentVer == 0)
 697                                 _error->Warning("Ignoring Remove stanza received for version %s of package %s which isn't installed!",
 698                                       Ver.VerStr(), Pkg.FullName(false).c_str());
 699                         else if (Pkg.CurrentVer() != Ver)
 700                                 _error->Warning("Ignoring Remove stanza received for version %s of package %s which isn't the installed version %s!",
 701                                       Ver.VerStr(), Pkg.FullName(false).c_str(), Pkg.CurrentVer().VerStr());
 702                         else
 703                                 Cache.MarkDelete(Ver.ParentPkg(), false);
 704                 }
 705         }
 706         return true;
 707 }
 708                                                                         /*}}}*/
 709 // ReadLine - first line from the given file descriptor                 /*{{{*/
 710 // ---------------------------------------------------------------------
 711 /* Little helper method to read a complete line into a string. Similar to
 712    fgets but we need to use the low-level read() here as otherwise the
 713    listparser will be confused later on as mixing of fgets and read isn't
 714    a supported action according to the manpages and results are undefined */
 715 static bool ReadLine(int const input, std::string &line) {
 716         char one;
 717         ssize_t data = 0;
 718         line.erase();
 719         line.reserve(100);
 720         while ((data = read(input, &one, sizeof(one))) != -1) {
 721                 if (data != 1)
 722                         continue;
 723                 if (one == '\n')
 724                         return true;
 725                 if (one == '\r')
 726                         continue;
 727                 if (line.empty() == true && isblank(one) != 0)
 728                         continue;
 729                 line += one;
 730         }
 731         return false;
 732 }
 733                                                                         /*}}}*/
 734 // StringToBool - convert yes/no to bool                                /*{{{*/
 735 // ---------------------------------------------------------------------
 736 /* we are not as lazy as we are in the global StringToBool as we really
 737    only accept yes/no here */
 738 static bool localStringToBool(std::string answer, bool const defValue) {
 739    std::transform(answer.begin(), answer.end(), answer.begin(), ::tolower);
 740    if (answer == "yes")
 741       return true;
 742    else if (answer == "no")
 743       return false;
 744    else
 745       _error->Warning("Value '%s' is not a boolean 'yes' or 'no'!", answer.c_str());
 746    return defValue;
 747 }
 748                                                                         /*}}}*/
 749 static bool LineStartsWithAndStrip(std::string &line, APT::StringView const with)/*{{{*/
 750 {
 751    if (line.compare(0, with.size(), with.data()) != 0)
 752       return false;
 753    line = APT::String::Strip(line.substr(with.length()));
 754    return true;
 755 }
 756                                                                         /*}}}*/
 757 static bool ReadFlag(unsigned int &flags, std::string &line, APT::StringView const name, unsigned int const setflag)/*{{{*/
 758 {
 759    if (LineStartsWithAndStrip(line, name) == false)
 760       return false;
 761    if (localStringToBool(line, false))
 762       flags |= setflag;
 763    else
 764       flags &= ~setflag;
 765    return true;
 766 }
 767                                                                         /*}}}*/
 768 // EDSP::ReadRequest - first stanza from the given file descriptor      /*{{{*/
 769 bool EDSP::ReadRequest(int const input, std::list<std::string> &install,
 770                         std::list<std::string> &remove, unsigned int &flags)
 771 {
 772    install.clear();
 773    remove.clear();
 774    flags = 0;
 775    std::string line;
 776    while (ReadLine(input, line) == true)
 777    {
 778       // Skip empty lines before request
 779       if (line.empty() == true)
 780          continue;
 781       // The first Tag must be a request, so search for it
 782       if (LineStartsWithAndStrip(line, "Request:"))
 783          continue;
 784
 785       while (ReadLine(input, line) == true)
 786       {
 787          // empty lines are the end of the request
 788          if (line.empty() == true)
 789             return true;
 790
 791          std::list<std::string> *request = NULL;
 792          if (LineStartsWithAndStrip(line, "Install:"))
 793             request = &install;
 794          else if (LineStartsWithAndStrip(line, "Remove:"))
 795             request = &remove;
 796          else if (ReadFlag(flags, line, "Upgrade:", (Request::UPGRADE_ALL | Request::FORBID_REMOVE | Request::FORBID_NEW_INSTALL)) ||
 797                ReadFlag(flags, line, "Dist-Upgrade:", Request::UPGRADE_ALL) ||
 798                ReadFlag(flags, line, "Upgrade-All:", Request::UPGRADE_ALL) ||
 799                ReadFlag(flags, line, "Forbid-New-Install:", Request::FORBID_NEW_INSTALL) ||
 800                ReadFlag(flags, line, "Forbid-Remove:", Request::FORBID_REMOVE) ||
 801                ReadFlag(flags, line, "Autoremove:", Request::AUTOREMOVE))
 802             ;
 803          else if (LineStartsWithAndStrip(line, "Architecture:"))
 804             _config->Set("APT::Architecture", line);
 805          else if (LineStartsWithAndStrip(line, "Architectures:"))
 806             _config->Set("APT::Architectures", SubstVar(line, " ", ","));
 807          else if (LineStartsWithAndStrip(line, "Solver:"))
 808             ; // purely informational line
 809          else
 810             _error->Warning("Unknown line in EDSP Request stanza: %s", line.c_str());
 811
 812          if (request == NULL)
 813             continue;
 814          auto const pkgs = VectorizeString(line, ' ');
 815          std::move(pkgs.begin(), pkgs.end(), std::back_inserter(*request));
 816       }
 817    }
 818    return false;
 819 }
 820 bool EDSP::ReadRequest(int const input, std::list<std::string> &install,
 821                         std::list<std::string> &remove, bool &upgrade,
 822                         bool &distUpgrade, bool &autoRemove)
 823 {
 824    unsigned int flags;
 825    auto const ret = ReadRequest(input, install, remove, flags);
 826    autoRemove = (flags & Request::AUTOREMOVE);
 827    if (flags & Request::UPGRADE_ALL)
 828    {
 829       if (flags & (Request::FORBID_NEW_INSTALL | Request::FORBID_REMOVE))
 830       {
 831          upgrade = true;
 832          distUpgrade = false;
 833       } else {
 834          upgrade = false;
 835          distUpgrade = false;
 836       }
 837    }
 838    else
 839    {
 840       upgrade = false;
 841       distUpgrade = false;
 842    }
 843    return ret;
 844 }
 845                                                                         /*}}}*/
 846 // EDSP::ApplyRequest - first stanza from the given file descriptor     /*{{{*/
 847 bool EDSP::ApplyRequest(std::list<std::string> const &install,
 848                          std::list<std::string> const &remove,
 849                          pkgDepCache &Cache)
 850 {
 851         for (std::list<std::string>::const_iterator i = install.begin();
 852              i != install.end(); ++i) {
 853                 pkgCache::PkgIterator P = Cache.FindPkg(*i);
 854                 if (P.end() == true)
 855                         _error->Warning("Package %s is not known, so can't be installed", i->c_str());
 856                 else
 857                         Cache.MarkInstall(P, false);
 858         }
 859
 860         for (std::list<std::string>::const_iterator i = remove.begin();
 861              i != remove.end(); ++i) {
 862                 pkgCache::PkgIterator P = Cache.FindPkg(*i);
 863                 if (P.end() == true)
 864                         _error->Warning("Package %s is not known, so can't be installed", i->c_str());
 865                 else
 866                         Cache.MarkDelete(P);
 867         }
 868         return true;
 869 }
 870                                                                         /*}}}*/
 871 // EDSP::WriteSolutionStanza - to the given file descriptor             /*{{{*/
 872 bool EDSP::WriteSolution(pkgDepCache &Cache, FILE* output)
 873 {
 874    bool const Debug = _config->FindB("Debug::EDSP::WriteSolution", false);
 875    for (pkgCache::PkgIterator Pkg = Cache.PkgBegin(); Pkg.end() == false; ++Pkg)
 876    {
 877       if (Cache[Pkg].Delete() == true)
 878       {
 879          fprintf(output, "Remove: %d\n", _system->GetVersionMapping(Pkg.CurrentVer()->ID));
 880          if (Debug == true)
 881             fprintf(output, "Package: %s\nVersion: %s\n", Pkg.FullName().c_str(), Pkg.CurrentVer().VerStr());
 882       }
 883       else if (Cache[Pkg].NewInstall() == true || Cache[Pkg].Upgrade() == true)
 884       {
 885          pkgCache::VerIterator const CandVer = Cache.GetCandidateVersion(Pkg);
 886          fprintf(output, "Install: %d\n", _system->GetVersionMapping(CandVer->ID));
 887          if (Debug == true)
 888             fprintf(output, "Package: %s\nVersion: %s\n", Pkg.FullName().c_str(), CandVer.VerStr());
 889       }
 890       else if (Cache[Pkg].Garbage == true)
 891       {
 892          fprintf(output, "Autoremove: %d\n", _system->GetVersionMapping(Pkg.CurrentVer()->ID));
 893          if (Debug == true)
 894             fprintf(output, "Package: %s\nVersion: %s\n", Pkg.FullName().c_str(), Pkg.CurrentVer().VerStr());
 895       }
 896       else
 897          continue;
 898       fprintf(output, "\n");
 899    }
 900
 901    return true;
 902 }
 903 bool EDSP::WriteSolutionStanza(FileFd &output, char const * const Type, pkgCache::VerIterator const &Ver)
 904 {
 905    bool Okay = output.Failed() == false;
 906    WriteOkay(Okay, output, Type, ": ", _system->GetVersionMapping(Ver->ID));
 907    if (_config->FindB("Debug::EDSP::WriteSolution", false) == true)
 908       WriteOkay(Okay, output, "\nPackage: ", Ver.ParentPkg().FullName(), "\nVersion: ", Ver.VerStr());
 909    return WriteOkay(Okay, output, "\n\n");
 910 }
 911                                                                         /*}}}*/
 912 // EDSP::WriteProgess - pulse to the given file descriptor              /*{{{*/
 913 bool EDSP::WriteProgress(unsigned short const percent, const char* const message, FILE* output) {
 914         fprintf(output, "Progress: %s\n", TimeRFC1123(time(NULL), true).c_str());
 915         fprintf(output, "Percentage: %d\n", percent);
 916         fprintf(output, "Message: %s\n\n", message);
 917         fflush(output);
 918         return true;
 919 }
 920 bool EDSP::WriteProgress(unsigned short const percent, const char* const message, FileFd &output) {
 921         return WriteOkay(output, "Progress: ", TimeRFC1123(time(NULL), true), "\n",
 922               "Percentage: ", percent, "\n",
 923               "Message: ", message, "\n\n") && output.Flush();
 924 }
 925                                                                         /*}}}*/
 926 // EDSP::WriteError - format an error message to be send to file descriptor /*{{{*/
 927 bool EDSP::WriteError(char const * const uuid, std::string const &message, FILE* output) {
 928         fprintf(output, "Error: %s\n", uuid);
 929         fprintf(output, "Message: %s\n\n", SubstVar(SubstVar(message, "\n\n", "\n.\n"), "\n", "\n ").c_str());
 930         return true;
 931 }
 932 bool EDSP::WriteError(char const * const uuid, std::string const &message, FileFd &output) {
 933         return WriteOkay(output, "Error: ", uuid, "\n",
 934               "Message: ", SubstVar(SubstVar(message, "\n\n", "\n.\n"), "\n", "\n "),
 935               "\n\n");
 936 }
 937                                                                         /*}}}*/
 938 static std::string findExecutable(std::vector<std::string> const &dirs, char const * const binary) {/*{{{*/
 939         for (auto && dir : dirs) {
 940                 std::string const file = flCombine(dir, binary);
 941                 if (RealFileExists(file) == true)
 942                         return file;
 943         }
 944         return "";
 945 }
 946                                                                         /*}}}*/
 947 static pid_t ExecuteExternal(char const* const type, char const * const binary, char const * const configdir, int * const solver_in, int * const solver_out) {/*{{{*/
 948         auto const solverDirs = _config->FindVector(configdir);
 949         auto const file = findExecutable(solverDirs, binary);
 950         std::string dumper;
 951         {
 952                 dumper = findExecutable(solverDirs, "apt-dump-solver");
 953                 if (dumper.empty())
 954                         dumper = findExecutable(solverDirs, "dump");
 955         }
 956
 957         if (file.empty() == true)
 958         {
 959                 _error->Error("Can't call external %s '%s' as it is not in a configured directory!", type, binary);
 960                 return 0;
 961         }
 962         int external[4] = {-1, -1, -1, -1};
 963         if (pipe(external) != 0 || pipe(external + 2) != 0)
 964         {
 965                 _error->Errno("Resolve", "Can't create needed IPC pipes for EDSP");
 966                 return 0;
 967         }
 968         for (int i = 0; i < 4; ++i)
 969                 SetCloseExec(external[i], true);
 970
 971         pid_t Solver = ExecFork();
 972         if (Solver == 0) {
 973                 dup2(external[0], STDIN_FILENO);
 974                 dup2(external[3], STDOUT_FILENO);
 975                 auto const dumpfile = _config->FindFile((std::string("Dir::Log::") + type).c_str());
 976                 auto const dumpdir = flNotFile(dumpfile);
 977                 auto const runasuser = _config->Find(std::string("APT::") + type + "::" + binary + "::RunAsUser",
 978                       _config->Find(std::string("APT::") + type + "::RunAsUser",
 979                          _config->Find("APT::Sandbox::User")));
 980                 if (dumper.empty() || dumpfile.empty() || dumper == file || CreateAPTDirectoryIfNeeded(dumpdir, dumpdir) == false)
 981                 {
 982                    _config->Set("APT::Sandbox::User", runasuser);
 983                    DropPrivileges();
 984                    char const * const calling[] = { file.c_str(), nullptr };
 985                    execv(calling[0], const_cast<char**>(calling));
 986                 }
 987                 else
 988                 {
 989                    char const * const calling[] = { dumper.c_str(), "--user", runasuser.c_str(), dumpfile.c_str(), file.c_str(), nullptr };
 990                    execv(calling[0], const_cast<char**>(calling));
 991                 }
 992                 std::cerr << "Failed to execute " << type << " '" << binary << "'!" << std::endl;
 993                 _exit(100);
 994         }
 995         close(external[0]);
 996         close(external[3]);
 997
 998         if (WaitFd(external[1], true, 5) == false)
 999         {
1000                 _error->Errno("Resolve", "Timed out while Waiting on availability of %s stdin", type);
1001                 return 0;
1002         }
1003
1004         *solver_in = external[1];
1005         *solver_out = external[2];
1006         return Solver;
1007 }
1008                                                                         /*}}}*/
1009 // EDSP::ExecuteSolver - fork requested solver and setup ipc pipes      {{{*/
1010 pid_t EDSP::ExecuteSolver(const char* const solver, int * const solver_in, int * const solver_out, bool) {
1011         return ExecuteExternal("solver", solver, "Dir::Bin::Solvers", solver_in, solver_out);
1012 }
1013 bool EDSP::ExecuteSolver(const char* const solver, int *solver_in, int *solver_out) {
1014    if (ExecuteSolver(solver, solver_in, solver_out, true) == 0)
1015       return false;
1016    return true;
1017 }
1018                                                                         /*}}}*/
1019 // EDSP::ResolveExternal - resolve problems by asking external for help {{{*/
1020 bool EDSP::ResolveExternal(const char* const solver, pkgDepCache &Cache,
1021                          unsigned int const flags, OpProgress *Progress) {
1022         if (strcmp(solver, "internal") == 0)
1023         {
1024                 auto const dumpfile = _config->FindFile("Dir::Log::Solver");
1025                 if (dumpfile.empty())
1026                         return false;
1027                 auto const dumpdir = flNotFile(dumpfile);
1028                 FileFd output;
1029                 if (CreateAPTDirectoryIfNeeded(dumpdir, dumpdir) == false ||
1030                       output.Open(dumpfile, FileFd::WriteOnly | FileFd::Exclusive | FileFd::Create, FileFd::Extension, 0644) == false)
1031                         return _error->WarningE("EDSP::Resolve", _("Could not open file '%s'"), dumpfile.c_str());
1032                 bool Okay = EDSP::WriteRequest(Cache, output, flags, nullptr);
1033                 return Okay && EDSP::WriteScenario(Cache, output, nullptr);
1034         }
1035         int solver_in, solver_out;
1036         pid_t const solver_pid = EDSP::ExecuteSolver(solver, &solver_in, &solver_out, true);
1037         if (solver_pid == 0)
1038                 return false;
1039
1040         FileFd output;
1041         if (output.OpenDescriptor(solver_in, FileFd::WriteOnly | FileFd::BufferedWrite, true) == false)
1042                 return _error->Errno("ResolveExternal", "Opening solver %s stdin on fd %d for writing failed", solver, solver_in);
1043
1044         bool Okay = output.Failed() == false;
1045         if (Progress != NULL)
1046                 Progress->OverallProgress(0, 100, 5, _("Execute external solver"));
1047         Okay &= EDSP::WriteRequest(Cache, output, flags, Progress);
1048         if (Progress != NULL)
1049                 Progress->OverallProgress(5, 100, 20, _("Execute external solver"));
1050         Okay &= EDSP::WriteScenario(Cache, output, Progress);
1051         output.Close();
1052
1053         if (Progress != NULL)
1054                 Progress->OverallProgress(25, 100, 75, _("Execute external solver"));
1055         if (Okay && EDSP::ReadResponse(solver_out, Cache, Progress) == false)
1056                 return false;
1057
1058         return ExecWait(solver_pid, solver);
1059 }
1060 bool EDSP::ResolveExternal(const char* const solver, pkgDepCache &Cache,
1061                          bool const upgrade, bool const distUpgrade,
1062                          bool const autoRemove, OpProgress *Progress) {
1063    unsigned int flags = 0;
1064    if (autoRemove)
1065       flags |= Request::AUTOREMOVE;
1066    if (upgrade)
1067       flags |= Request::UPGRADE_ALL | Request::FORBID_REMOVE | Request::FORBID_NEW_INSTALL;
1068    if (distUpgrade)
1069       flags |= Request::UPGRADE_ALL;
1070    return ResolveExternal(solver, Cache, flags, Progress);
1071 }
1072                                                                         /*}}}*/
1073
1074 bool EIPP::OrderInstall(char const * const solver, pkgPackageManager * const PM,        /*{{{*/
1075                          unsigned int const flags, OpProgress * const Progress)
1076 {
1077    if (strcmp(solver, "internal") == 0)
1078    {
1079       auto const dumpfile = _config->FindFile("Dir::Log::Planner");
1080       if (dumpfile.empty())
1081          return false;
1082       auto const dumpdir = flNotFile(dumpfile);
1083       FileFd output;
1084       if (CreateAPTDirectoryIfNeeded(dumpdir, dumpdir) == false ||
1085             output.Open(dumpfile, FileFd::WriteOnly | FileFd::Exclusive | FileFd::Create, FileFd::Extension, 0644) == false)
1086          return _error->WarningE("EIPP::OrderInstall", _("Could not open file '%s'"), dumpfile.c_str());
1087       bool Okay = EIPP::WriteRequest(PM->Cache, output, flags, nullptr);
1088       return Okay && EIPP::WriteScenario(PM->Cache, output, nullptr);
1089    }
1090
1091    int solver_in, solver_out;
1092    pid_t const solver_pid = ExecuteExternal("planner", solver, "Dir::Bin::Planners", &solver_in, &solver_out);
1093    if (solver_pid == 0)
1094       return false;
1095
1096    FileFd output;
1097    if (output.OpenDescriptor(solver_in, FileFd::WriteOnly | FileFd::BufferedWrite, true) == false)
1098       return _error->Errno("EIPP::OrderInstall", "Opening planner %s stdin on fd %d for writing failed", solver, solver_in);
1099
1100    bool Okay = output.Failed() == false;
1101    if (Progress != NULL)
1102       Progress->OverallProgress(0, 100, 5, _("Execute external planner"));
1103    Okay &= EIPP::WriteRequest(PM->Cache, output, flags, Progress);
1104    if (Progress != NULL)
1105       Progress->OverallProgress(5, 100, 20, _("Execute external planner"));
1106    Okay &= EIPP::WriteScenario(PM->Cache, output, Progress);
1107    output.Close();
1108
1109    if (Progress != NULL)
1110       Progress->OverallProgress(25, 100, 75, _("Execute external planner"));
1111
1112    // we don't tell the external planners about boring things
1113    for (auto Pkg = PM->Cache.PkgBegin(); Pkg.end() == false; ++Pkg)
1114    {
1115       if (Pkg->CurrentState == pkgCache::State::ConfigFiles && PM->Cache[Pkg].Purge() == true)
1116          PM->Remove(Pkg, true);
1117    }
1118
1119    if (Okay && EIPP::ReadResponse(solver_out, PM, Progress) == false)
1120       return false;
1121
1122    return ExecWait(solver_pid, solver);
1123 }
1124                                                                         /*}}}*/
1125 bool EIPP::WriteRequest(pkgDepCache &Cache, FileFd &output,             /*{{{*/
1126                         unsigned int const flags,
1127                         OpProgress * const Progress)
1128 {
1129    if (Progress != NULL)
1130       Progress->SubProgress(Cache.Head().PackageCount, _("Send request to planner"));
1131    unsigned long p = 0;
1132    string del, inst, reinst;
1133    for (pkgCache::PkgIterator Pkg = Cache.PkgBegin(); Pkg.end() == false; ++Pkg, ++p)
1134    {
1135       if (Progress != NULL && p % 100 == 0)
1136          Progress->Progress(p);
1137       string* req;
1138       pkgDepCache::StateCache &P = Cache[Pkg];
1139       if (P.Purge() == true && Pkg->CurrentState == pkgCache::State::ConfigFiles)
1140          continue;
1141       if (P.Delete() == true)
1142          req = &del;
1143       else if (P.NewInstall() == true || P.Upgrade() == true || P.Downgrade() == true)
1144          req = &inst;
1145       else if (P.ReInstall() == true)
1146          req = &reinst;
1147       else
1148          continue;
1149       req->append(" ").append(Pkg.FullName());
1150    }
1151    bool Okay = WriteOkay(output, "Request: EIPP 0.1\n");
1152
1153    const char *arch = _config->Find("APT::Architecture").c_str();
1154    std::vector<string> archs = APT::Configuration::getArchitectures();
1155    WriteOkay(Okay, output, "Architecture: ", arch, "\n",
1156          "Architectures:");
1157    for (std::vector<string>::const_iterator a = archs.begin(); a != archs.end(); ++a)
1158        WriteOkay(Okay, output, " ", *a);
1159    WriteOkay(Okay, output, "\n");
1160
1161    if (del.empty() == false)
1162       WriteOkay(Okay, output, "Remove:", del, "\n");
1163    if (inst.empty() == false)
1164       WriteOkay(Okay, output, "Install:", inst, "\n");
1165    if (reinst.empty() == false)
1166       WriteOkay(Okay, output, "ReInstall:", reinst, "\n");
1167    WriteOkay(Okay, output, "Planner: ", _config->Find("APT::Planner", "internal"), "\n");
1168    if ((flags & Request::IMMEDIATE_CONFIGURATION_ALL) != 0)
1169       WriteOkay(Okay, output, "Immediate-Configuration: yes\n");
1170    else if ((flags & Request::NO_IMMEDIATE_CONFIGURATION) != 0)
1171       WriteOkay(Okay, output, "Immediate-Configuration: no\n");
1172    else if ((flags & Request::ALLOW_TEMPORARY_REMOVE_OF_ESSENTIALS) != 0)
1173       WriteOkay(Okay, output, "Allow-Temporary-Remove-of-Essentials: yes\n");
1174    return WriteOkay(Okay, output, "\n");
1175 }
1176                                                                         /*}}}*/
1177 static bool WriteScenarioEIPPVersion(pkgDepCache &, FileFd &output, pkgCache::PkgIterator const &Pkg,/*{{{*/
1178                                 pkgCache::VerIterator const &Ver)
1179 {
1180    bool Okay = true;
1181    if (Pkg.CurrentVer() == Ver)
1182       switch (Pkg->CurrentState)
1183       {
1184          case pkgCache::State::NotInstalled: WriteOkay(Okay, output, "\nStatus: not-installed"); break;
1185          case pkgCache::State::ConfigFiles: WriteOkay(Okay, output, "\nStatus: config-files"); break;
1186          case pkgCache::State::HalfInstalled: WriteOkay(Okay, output, "\nStatus: half-installed"); break;
1187          case pkgCache::State::UnPacked: WriteOkay(Okay, output, "\nStatus: unpacked"); break;
1188          case pkgCache::State::HalfConfigured: WriteOkay(Okay, output, "\nStatus: half-configured"); break;
1189          case pkgCache::State::TriggersAwaited: WriteOkay(Okay, output, "\nStatus: triggers-awaited"); break;
1190          case pkgCache::State::TriggersPending: WriteOkay(Okay, output, "\nStatus: triggers-pending"); break;
1191          case pkgCache::State::Installed: WriteOkay(Okay, output, "\nStatus: installed"); break;
1192       }
1193    return Okay;
1194 }
1195                                                                         /*}}}*/
1196 // EIPP::WriteScenario - to the given file descriptor                   /*{{{*/
1197 template<typename forVersion> void forAllInterestingVersions(pkgDepCache &Cache, pkgCache::PkgIterator const &Pkg, forVersion const &func)
1198 {
1199    if (Pkg->CurrentState == pkgCache::State::NotInstalled)
1200    {
1201       auto P = Cache[Pkg];
1202       if (P.Install() == false)
1203          return;
1204       func(Pkg, P.InstVerIter(Cache));
1205    }
1206    else
1207    {
1208       if (Pkg->CurrentVer != 0)
1209          func(Pkg, Pkg.CurrentVer());
1210       auto P = Cache[Pkg];
1211       auto const V = P.InstVerIter(Cache);
1212       if (P.Delete() == false && Pkg.CurrentVer() != V)
1213          func(Pkg, V);
1214    }
1215 }
1216
1217 bool EIPP::WriteScenario(pkgDepCache &Cache, FileFd &output, OpProgress * const Progress)
1218 {
1219    if (Progress != NULL)
1220       Progress->SubProgress(Cache.Head().PackageCount, _("Send scenario to planner"));
1221    unsigned long p = 0;
1222    bool Okay = output.Failed() == false;
1223    std::vector<std::string> archs = APT::Configuration::getArchitectures();
1224    std::vector<bool> pkgset(Cache.Head().PackageCount, false);
1225    auto const MarkVersion = [&](pkgCache::PkgIterator const &Pkg, pkgCache::VerIterator const &Ver) {
1226       pkgset[Pkg->ID] = true;
1227       for (auto D = Ver.DependsList(); D.end() == false; ++D)
1228       {
1229          if (D.IsCritical() == false)
1230             continue;
1231          auto const P = D.TargetPkg();
1232          for (auto Prv = P.ProvidesList(); Prv.end() == false; ++Prv)
1233          {
1234             auto const V = Prv.OwnerVer();
1235             auto const PV = V.ParentPkg();
1236             if (V == PV.CurrentVer() || V == Cache[PV].InstVerIter(Cache))
1237                pkgset[PV->ID] = true;
1238          }
1239          pkgset[P->ID] = true;
1240          if (strcmp(P.Arch(), "any") == 0)
1241          {
1242             APT::StringView const pkgname(P.Name());
1243             auto const idxColon = pkgname.find(':');
1244             if (idxColon != APT::StringView::npos)
1245             {
1246                pkgCache::PkgIterator PA;
1247                if (pkgname.substr(idxColon + 1) == "any")
1248                {
1249                   auto const GA = Cache.FindGrp(pkgname.substr(0, idxColon).to_string());
1250                   for (auto PA = GA.PackageList(); PA.end() == false; PA = GA.NextPkg(PA))
1251                   {
1252                      pkgset[PA->ID] = true;
1253                   }
1254                }
1255                else
1256                {
1257                   auto const PA = Cache.FindPkg(pkgname.to_string());
1258                   if (PA.end() == false)
1259                      pkgset[PA->ID] = true;
1260                }
1261             }
1262          }
1263          else
1264          {
1265             auto const PA = Cache.FindPkg(P.FullName(false), "any");
1266             if (PA.end() == false)
1267                pkgset[PA->ID] = true;
1268          }
1269       }
1270    };
1271    for (pkgCache::PkgIterator Pkg = Cache.PkgBegin(); Pkg.end() == false; ++Pkg)
1272       forAllInterestingVersions(Cache, Pkg, MarkVersion);
1273    auto const WriteVersion = [&](pkgCache::PkgIterator const &Pkg, pkgCache::VerIterator const &Ver) {
1274       Okay &= WriteScenarioVersion(output, Pkg, Ver);
1275       Okay &= WriteScenarioEIPPVersion(Cache, output, Pkg, Ver);
1276       Okay &= WriteScenarioLimitedDependency(output, Ver, pkgset, true);
1277       WriteOkay(Okay, output, "\n");
1278       if (Progress != NULL && p % 100 == 0)
1279          Progress->Progress(p);
1280    };
1281    for (pkgCache::PkgIterator Pkg = Cache.PkgBegin(); Pkg.end() == false && likely(Okay); ++Pkg, ++p)
1282    {
1283       if (pkgset[Pkg->ID] == false || Pkg->VersionList == 0)
1284          continue;
1285       forAllInterestingVersions(Cache, Pkg, WriteVersion);
1286    }
1287    return true;
1288 }
1289                                                                         /*}}}*/
1290 // EIPP::ReadResponse - from the given file descriptor                  /*{{{*/
1291 bool EIPP::ReadResponse(int const input, pkgPackageManager * const PM, OpProgress *Progress) {
1292    /* We build an map id to mmap offset here
1293       In theory we could use the offset as ID, but then VersionCount
1294       couldn't be used to create other versionmappings anymore and it
1295       would be too easy for a (buggy) solver to segfault APT… */
1296    unsigned long long const VersionCount = PM->Cache.Head().VersionCount;
1297    unsigned long VerIdx[VersionCount];
1298    for (pkgCache::PkgIterator P = PM->Cache.PkgBegin(); P.end() == false; ++P) {
1299       for (pkgCache::VerIterator V = P.VersionList(); V.end() == false; ++V)
1300          VerIdx[V->ID] = V.Index();
1301    }
1302
1303    FileFd in;
1304    in.OpenDescriptor(input, FileFd::ReadOnly);
1305    pkgTagFile response(&in, 100);
1306    pkgTagSection section;
1307
1308    while (response.Step(section) == true) {
1309       char const * type = nullptr;
1310       if (section.Exists("Progress") == true) {
1311          if (Progress != NULL) {
1312             string msg = section.FindS("Message");
1313             if (msg.empty() == true)
1314                msg = _("Prepare for receiving solution");
1315             Progress->SubProgress(100, msg, section.FindI("Percentage", 0));
1316          }
1317          continue;
1318       } else if (section.Exists("Error") == true) {
1319          std::string msg = SubstVar(SubstVar(section.FindS("Message"), "\n .\n", "\n\n"), "\n ", "\n");
1320          if (msg.empty() == true) {
1321             msg = _("External planner failed without a proper error message");
1322             _error->Error("%s", msg.c_str());
1323          } else
1324             _error->Error("External planner failed with: %s", msg.substr(0,msg.find('\n')).c_str());
1325          if (Progress != NULL)
1326             Progress->Done();
1327          std::cerr << "The planner encountered an error of type: " << section.FindS("Error") << std::endl;
1328          std::cerr << "The following information might help you to understand what is wrong:" << std::endl;
1329          std::cerr << msg << std::endl << std::endl;
1330          return false;
1331       } else if (section.Exists("Unpack") == true)
1332          type = "Unpack";
1333       else if (section.Exists("Configure") == true)
1334          type = "Configure";
1335       else if (section.Exists("Remove") == true)
1336          type = "Remove";
1337       else {
1338          char const *Start, *End;
1339          section.GetSection(Start, End);
1340          _error->Warning("Encountered an unexpected section with %d fields: %s", section.Count(), std::string(Start, End).c_str());
1341          continue;
1342       }
1343
1344       if (type == nullptr)
1345          continue;
1346       size_t const id = section.FindULL(type, VersionCount);
1347       if (id == VersionCount) {
1348          _error->Warning("Unable to parse %s request with id value '%s'!", type, section.FindS(type).c_str());
1349          continue;
1350       } else if (id > PM->Cache.Head().VersionCount) {
1351          _error->Warning("ID value '%s' in %s request stanza is to high to refer to a known version!", section.FindS(type).c_str(), type);
1352          continue;
1353       }
1354
1355       pkgCache::VerIterator Ver(PM->Cache.GetCache(), PM->Cache.GetCache().VerP + VerIdx[id]);
1356       auto const Pkg = Ver.ParentPkg();
1357       if (strcmp(type, "Unpack") == 0)
1358          PM->Install(Pkg, PM->FileNames[Pkg->ID]);
1359       else if (strcmp(type, "Configure") == 0)
1360          PM->Configure(Pkg);
1361       else if (strcmp(type, "Remove") == 0)
1362          PM->Remove(Pkg, PM->Cache[Pkg].Purge());
1363    }
1364    return true;
1365 }
1366                                                                         /*}}}*/
1367 bool EIPP::ReadRequest(int const input, std::list<std::pair<std::string,PKG_ACTION>> &actions,/*{{{*/
1368       unsigned int &flags)
1369 {
1370    actions.clear();
1371    flags = 0;
1372    std::string line;
1373    while (ReadLine(input, line) == true)
1374    {
1375       // Skip empty lines before request
1376       if (line.empty() == true)
1377          continue;
1378       // The first Tag must be a request, so search for it
1379       if (line.compare(0, 8, "Request:") != 0)
1380          continue;
1381
1382       while (ReadLine(input, line) == true)
1383       {
1384          // empty lines are the end of the request
1385          if (line.empty() == true)
1386             return true;
1387
1388          PKG_ACTION pkgact = PKG_ACTION::NOOP;
1389          if (LineStartsWithAndStrip(line, "Install:"))
1390             pkgact = PKG_ACTION::INSTALL;
1391          else if (LineStartsWithAndStrip(line, "ReInstall:"))
1392             pkgact = PKG_ACTION::REINSTALL;
1393          else if (LineStartsWithAndStrip(line, "Remove:"))
1394             pkgact = PKG_ACTION::REMOVE;
1395          else if (LineStartsWithAndStrip(line, "Architecture:"))
1396             _config->Set("APT::Architecture", line);
1397          else if (LineStartsWithAndStrip(line, "Architectures:"))
1398             _config->Set("APT::Architectures", SubstVar(line, " ", ","));
1399          else if (LineStartsWithAndStrip(line, "Planner:"))
1400             ; // purely informational line
1401          else if (LineStartsWithAndStrip(line, "Immediate-Configuration:"))
1402          {
1403             if (localStringToBool(line, true))
1404                flags |= Request::IMMEDIATE_CONFIGURATION_ALL;
1405             else
1406                flags |= Request::NO_IMMEDIATE_CONFIGURATION;
1407          }
1408          else if (ReadFlag(flags, line, "Allow-Temporary-Remove-of-Essentials:", Request::ALLOW_TEMPORARY_REMOVE_OF_ESSENTIALS))
1409             ;
1410          else
1411             _error->Warning("Unknown line in EIPP Request stanza: %s", line.c_str());
1412
1413          if (pkgact == PKG_ACTION::NOOP)
1414             continue;
1415          for (auto && p: VectorizeString(line, ' '))
1416             actions.emplace_back(std::move(p), pkgact);
1417       }
1418    }
1419    return false;
1420
1421
1422    return false;
1423 }
1424                                                                         /*}}}*/
1425 bool EIPP::ApplyRequest(std::list<std::pair<std::string,PKG_ACTION>> &actions,/*{{{*/
1426          pkgDepCache &Cache)
1427 {
1428    for (auto Pkg = Cache.PkgBegin(); Pkg.end() == false; ++Pkg)
1429    {
1430       short versions = 0;
1431       for (auto Ver = Pkg.VersionList(); Ver.end() == false; ++Ver)
1432       {
1433          ++versions;
1434          if (Pkg.CurrentVer() == Ver)
1435             continue;
1436          Cache.SetCandidateVersion(Ver);
1437       }
1438       if (unlikely(versions > 2))
1439          _error->Warning("Package %s has %d versions, but should have at most 2!", Pkg.FullName().c_str(), versions);
1440    }
1441    for (auto && a: actions)
1442    {
1443       pkgCache::PkgIterator P = Cache.FindPkg(a.first);
1444       if (P.end() == true)
1445       {
1446          _error->Warning("Package %s is not known, so can't be acted on", a.first.c_str());
1447          continue;
1448       }
1449       switch (a.second)
1450       {
1451          case PKG_ACTION::NOOP:
1452             _error->Warning("Package %s has NOOP as action?!?", a.first.c_str());
1453             break;
1454          case PKG_ACTION::INSTALL:
1455             Cache.MarkInstall(P, false);
1456             break;
1457          case PKG_ACTION::REINSTALL:
1458             Cache.MarkInstall(P, false);
1459             Cache.SetReInstall(P, true);
1460             break;
1461          case PKG_ACTION::REMOVE:
1462             Cache.MarkDelete(P);
1463             break;
1464       }
1465    }
1466    return true;
1467 }
1468                                                                         /*}}}*/