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