// -*- mode: cpp; mode: fold -*-
// Description /*{{{*/
-// $Id: dpkgpm.cc,v 1.28 2004/01/27 02:25:01 mdz Exp $
/* ######################################################################
DPKG Package Manager - Provide an interface to dpkg
-
+
##################################################################### */
/*}}}*/
// Includes /*{{{*/
#include <apt-pkg/install-progress.h>
#include <apt-pkg/packagemanager.h>
#include <apt-pkg/strutl.h>
+#include <apt-pkg/statechanges.h>
#include <apt-pkg/cacheiterators.h>
#include <apt-pkg/macros.h>
#include <apt-pkg/pkgcache.h>
+#include <apt-pkg/version.h>
#include <errno.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <sys/wait.h>
+#include <sys/types.h>
+#include <dirent.h>
#include <termios.h>
#include <time.h>
#include <unistd.h>
+
#include <algorithm>
+#include <array>
#include <cstring>
#include <iostream>
#include <map>
#include <set>
#include <string>
+#include <type_traits>
#include <utility>
+#include <unordered_set>
#include <vector>
#include <sstream>
#include <numeric>
#include <apti18n.h>
/*}}}*/
+extern char **environ;
+
using namespace std;
-APT_PURE static string
-AptHistoryRequestingUser()
+APT_PURE static string AptHistoryRequestingUser() /*{{{*/
{
const char* EnvKeys[]{"SUDO_UID", "PKEXEC_UID", "PACKAGEKIT_CALLER_UID"};
}
return "";
}
-
-APT_PURE static unsigned int
-EnvironmentSize()
+ /*}}}*/
+APT_PURE static unsigned int EnvironmentSize() /*{{{*/
{
unsigned int size = 0;
char **envp = environ;
return size;
}
-
-class pkgDPkgPMPrivate
+ /*}}}*/
+class pkgDPkgPMPrivate /*{{{*/
{
public:
pkgDPkgPMPrivate() : stdin_is_dev_null(false), dpkgbuf_pos(0),
bool direct_stdin;
};
-
+ /*}}}*/
namespace
{
// Maps the dpkg "processing" info to human readable names. Entry 0
};
}
-/* helper function to ionice the given PID
-
- there is no C header for ionice yet - just the syscall interface
- so we use the binary from util-linux
-*/
-static bool
-ionice(int PID)
+// ionice - helper function to ionice the given PID /*{{{*/
+/* there is no C header for ionice yet - just the syscall interface
+ so we use the binary from util-linux */
+static bool ionice(int PID)
{
if (!FileExists("/usr/bin/ionice"))
return false;
}
return ExecWait(Process, "ionice");
}
-
+ /*}}}*/
// FindNowVersion - Helper to find a Version in "now" state /*{{{*/
// ---------------------------------------------------------------------
-/* This is helpful when a package is no longer installed but has residual
+/* This is helpful when a package is no longer installed but has residual
* config files
*/
-static
+static
pkgCache::VerIterator FindNowVersion(const pkgCache::PkgIterator &Pkg)
{
pkgCache::VerIterator Ver;
return Ver;
}
/*}}}*/
+static pkgCache::VerIterator FindToBeRemovedVersion(pkgCache::PkgIterator const &Pkg)/*{{{*/
+{
+ auto const PV = Pkg.CurrentVer();
+ if (PV.end() == false)
+ return PV;
+ return FindNowVersion(Pkg);
+}
+ /*}}}*/
// DPkgPM::pkgDPkgPM - Constructor /*{{{*/
// ---------------------------------------------------------------------
{
if (Pkg.end() == true)
return false;
-
+
if (Purge == true)
List.push_back(Item(Item::Purge,Pkg));
else
Top = Top->Child;
continue;
}
-
+
while (Top != 0 && Top->Next == 0)
Top = Top->Parent;
if (Top != 0)
Top = Top->Next;
- }
+ }
fprintf(F,"\n");
-
+
// Write out the package actions in order.
for (vector<Item>::iterator I = List.begin(); I != List.end(); ++I)
{
continue;
pkgDepCache::StateCache &S = Cache[I->Pkg];
-
+
fprintf(F,"%s ",I->Pkg.Name());
// Current version which we are going to replace
fprintf(F,"**ERROR**\n");
else
fprintf(F,"%s\n",I->File.c_str());
- }
+ }
else if (I->Op == Item::Configure)
fprintf(F,"**CONFIGURE**\n");
else if (I->Op == Item::Remove ||
I->Op == Item::Purge)
fprintf(F,"**REMOVE**\n");
-
+
if (ferror(F) != 0)
return false;
}
Opts = Opts->Child;
sighandler_t old_sigpipe = signal(SIGPIPE, SIG_IGN);
-
+ sighandler_t old_sigint = signal(SIGINT, SIG_IGN);
+ sighandler_t old_sigquit = signal(SIGQUIT, SIG_IGN);
+
unsigned int Count = 1;
for (; Opts != 0; Opts = Opts->Next, Count++)
{
if ((Pos = OptSec.find(' ')) == string::npos || Pos == 0)
Pos = OptSec.length();
OptSec = "DPkg::Tools::Options::" + string(Opts->Value.c_str(),Pos);
-
+
unsigned int Version = _config->FindI(OptSec+"::Version",1);
unsigned int InfoFD = _config->FindI(OptSec + "::InfoFD", STDIN_FILENO);
-
+
// Create the pipes
std::set<int> KeepFDs;
MergeKeepFdsFromConfiguration(KeepFDs);
close(Pipes[0]);
FILE *F = fdopen(Pipes[1],"w");
if (F == 0) {
- result = _error->Errno("fdopen","Faild to open new FD");
+ result = _error->Errno("fdopen","Failed to open new FD");
break;
}
-
+
// Feed it the filenames.
if (Version <= 1)
{
// No errors here..
if (I->File[0] != '/')
continue;
-
+
/* Feed the filename of each package that is pending install
into the pipe. */
fprintf(F,"%s\n",I->File.c_str());
SendPkgsInfo(F, Version);
fclose(F);
-
+
// Clean up the sub process
if (ExecWait(Process,Opts->Value.c_str()) == false) {
result = _error->Error("Failure running script %s",Opts->Value.c_str());
break;
}
}
+ signal(SIGINT, old_sigint);
signal(SIGPIPE, old_sigpipe);
+ signal(SIGQUIT, old_sigquit);
return result;
}
struct timespec sleepfor = { 0, 500000000 };
nanosleep(&sleepfor, NULL);
return;
- }
- if(len <= 0)
+ }
+ if(len <= 0)
return;
FileFd::Write(1, term_buf, len);
if(d->term_out)
fwrite(term_buf, len, sizeof(char), d->term_out);
}
/*}}}*/
-// DPkgPM::ProcessDpkgStatusBuf /*{{{*/
-// ---------------------------------------------------------------------
-/*
- */
+// DPkgPM::ProcessDpkgStatusBuf /*{{{*/
void pkgDPkgPM::ProcessDpkgStatusLine(char *line)
{
bool const Debug = _config->FindB("Debug::pkgDPkgProgressReporting",false);
/* dpkg sends strings like this:
'status: <pkg>: <pkg qstate>'
'status: <pkg>:<arch>: <pkg qstate>'
-
+
'processing: {install,upgrade,configure,remove,purge,disappear,trigproc}: pkg'
'processing: {install,upgrade,configure,remove,purge,disappear,trigproc}: trigger'
*/
// we need to split on ": " (note the appended space) as the ':' is
// part of the pkgname:arch information that dpkg sends
- //
+ //
// A dpkg error message may contain additional ":" (like
// "failed in buffer_write(fd) (10, ret=-1): backend dpkg-deb ..."
// so we need to ensure to not split too much
// if there are multiple pkgs dpkg would send us a full pkgname:arch
pkgCache::GrpIterator Grp = Cache.FindGrp(pkgname);
if (Grp.end() == false)
- {
- pkgCache::PkgIterator P = Grp.PackageList();
- for (; P.end() != true; P = Grp.NextPkg(P))
- {
+ for (auto P = Grp.PackageList(); P.end() != true; P = Grp.NextPkg(P))
if(Cache[P].Keep() == false || Cache[P].ReInstall() == true)
{
- pkgname = P.FullName();
+ auto fullname = P.FullName();
+ if (Cache[P].Delete() && PackageOps[fullname].size() <= PackageOpsDone[fullname])
+ continue;
+ pkgname = std::move(fullname);
break;
}
- }
- }
}
- const char* const pkg = pkgname.c_str();
- std::string short_pkgname = StringSplit(pkgname, ":")[0];
std::string arch = "";
if (pkgname.find(":") != string::npos)
arch = StringSplit(pkgname, ":")[1];
std::string i18n_pkgname = pkgname;
if (arch.size() != 0)
- strprintf(i18n_pkgname, "%s (%s)", short_pkgname.c_str(), arch.c_str());
+ strprintf(i18n_pkgname, "%s (%s)", StringSplit(pkgname, ":")[0].c_str(), arch.c_str());
// 'processing' from dpkg looks like
// 'processing: action: pkg'
d->progress->StatusChanged(pkgname, PackagesDone, PackagesTotal, msg);
// FIXME: this needs a muliarch testcase
- // FIXME2: is "pkgname" here reliable with dpkg only sending us
+ // FIXME2: is "pkgname" here reliable with dpkg only sending us
// short pkgnames?
if (action == "disappear")
handleDisappearAction(pkgname);
return;
- }
+ }
if (prefix == "status")
{
- vector<struct DpkgState> const &states = PackageOps[pkg];
- if(PackageOpsDone[pkg] < states.size())
+ std::vector<struct DpkgState> &states = PackageOps[pkgname];
+ if (action == "triggers-pending")
{
- char const * const next_action = states[PackageOpsDone[pkg]].state;
- if (next_action && Debug == true)
- std::clog << "(parsed from dpkg) pkg: " << short_pkgname
- << " action: " << action << " (expected: '" << next_action << "' "
- << PackageOpsDone[pkg] << " of " << states.size() << ")" << endl;
-
- // check if the package moved to the next dpkg state
- if(next_action && (action == next_action))
+ if (Debug == true)
+ std::clog << "(parsed from dpkg) pkg: " << pkgname
+ << " action: " << action << " (prefix 2 to "
+ << PackageOpsDone[pkgname] << " of " << states.size() << ")" << endl;
+
+ states.insert(states.begin(), {"installed", N_("Installed %s")});
+ states.insert(states.begin(), {"half-configured", N_("Configuring %s")});
+ PackagesTotal += 2;
+ }
+ else if(PackageOpsDone[pkgname] < states.size())
+ {
+ char const * next_action = states[PackageOpsDone[pkgname]].state;
+ if (next_action)
{
- // only read the translation if there is actually a next action
- char const * const translation = _(states[PackageOpsDone[pkg]].str);
+ /*
+ if (action == "half-installed" && strcmp("half-configured", next_action) == 0 &&
+ PackageOpsDone[pkg] + 2 < states.size() && action == states[PackageOpsDone[pkg] + 2].state)
+ {
+ if (Debug == true)
+ std::clog << "(parsed from dpkg) pkg: " << short_pkgname << " action: " << action
+ << " pending trigger defused by unpack" << std::endl;
+ // unpacking a package defuses the pending trigger
+ PackageOpsDone[pkg] += 2;
+ PackagesDone += 2;
+ next_action = states[PackageOpsDone[pkg]].state;
+ }
+ */
+ if (Debug == true)
+ std::clog << "(parsed from dpkg) pkg: " << pkgname
+ << " action: " << action << " (expected: '" << next_action << "' "
+ << PackageOpsDone[pkgname] << " of " << states.size() << ")" << endl;
+
+ // check if the package moved to the next dpkg state
+ if(action == next_action)
+ {
+ // only read the translation if there is actually a next action
+ char const * const translation = _(states[PackageOpsDone[pkgname]].str);
+
+ // we moved from one dpkg state to a new one, report that
+ ++PackageOpsDone[pkgname];
+ ++PackagesDone;
- // we moved from one dpkg state to a new one, report that
- ++PackageOpsDone[pkg];
- ++PackagesDone;
+ std::string msg;
+ strprintf(msg, translation, i18n_pkgname.c_str());
+ d->progress->StatusChanged(pkgname, PackagesDone, PackagesTotal, msg);
+ }
+ else if (action == "unpacked" && strcmp(next_action, "config-files") == 0)
+ {
+ // in a crossgrade what looked like a remove first is really an unpack over it
+ ++PackageOpsDone[pkgname];
+ ++PackagesDone;
- std::string msg;
- strprintf(msg, translation, i18n_pkgname.c_str());
- d->progress->StatusChanged(pkgname, PackagesDone, PackagesTotal, msg);
+ auto const Pkg = Cache.FindPkg(pkgname);
+ if (likely(Pkg.end() == false))
+ {
+ auto const Grp = Pkg.Group();
+ if (likely(Grp.end() == false))
+ {
+ for (auto P = Grp.PackageList(); P.end() != true; P = Grp.NextPkg(P))
+ if(Cache[P].Install())
+ {
+ auto && Ops = PackageOps[P.FullName()];
+ auto const unpackOp = std::find_if(Ops.cbegin(), Ops.cend(), [](DpkgState const &s) { return strcmp(s.state, "unpacked") == 0; });
+ if (unpackOp != Ops.cend())
+ {
+ auto const skipped = std::distance(Ops.cbegin(), unpackOp);
+ PackagesDone += skipped;
+ PackageOpsDone[P.FullName()] += skipped;
+ break;
+ }
+ }
+ }
+ }
+ }
}
}
}
WriteHistoryTag("Purge",purge);
fflush(d->history_out);
}
-
+
return true;
}
/*}}}*/
return true;
}
/*}}}*/
- /*}}}*/
-/*{{{*/
-// This implements a racy version of pselect for those architectures
-// that don't have a working implementation.
-// FIXME: Probably can be removed on Lenny+1
-static int racy_pselect(int nfds, fd_set *readfds, fd_set *writefds,
- fd_set *exceptfds, const struct timespec *timeout,
- const sigset_t *sigmask)
-{
- sigset_t origmask;
- struct timeval tv;
- int retval;
-
- tv.tv_sec = timeout->tv_sec;
- tv.tv_usec = timeout->tv_nsec/1000;
-
- sigprocmask(SIG_SETMASK, sigmask, &origmask);
- retval = select(nfds, readfds, writefds, exceptfds, &tv);
- sigprocmask(SIG_SETMASK, &origmask, 0);
- return retval;
-}
- /*}}}*/
// DPkgPM::BuildPackagesProgressMap /*{{{*/
void pkgDPkgPM::BuildPackagesProgressMap()
{
// map the dpkg states to the operations that are performed
// (this is sorted in the same way as Item::Ops)
- static const struct DpkgState DpkgStatesOpMap[][7] = {
+ static const std::array<std::array<DpkgState, 3>, 4> DpkgStatesOpMap = {{
// Install operation
- {
- {"half-installed", N_("Preparing %s")},
- {"unpacked", N_("Unpacking %s") },
- {NULL, NULL}
- },
+ {{
+ {"half-installed", N_("Preparing %s")},
+ {"unpacked", N_("Unpacking %s") },
+ {nullptr, nullptr}
+ }},
// Configure operation
- {
+ {{
{"unpacked",N_("Preparing to configure %s") },
{"half-configured", N_("Configuring %s") },
{ "installed", N_("Installed %s")},
- {NULL, NULL}
- },
+ }},
// Remove operation
- {
+ {{
{"half-configured", N_("Preparing for removal of %s")},
{"half-installed", N_("Removing %s")},
{"config-files", N_("Removed %s")},
- {NULL, NULL}
- },
+ }},
// Purge operation
- {
+ {{
{"config-files", N_("Preparing to completely remove %s")},
{"not-installed", N_("Completely removed %s")},
- {NULL, NULL}
- },
- };
+ {nullptr, nullptr}
+ }},
+ }};
+ static_assert(Item::Purge == 3, "Enum item has unexpected index for mapping array");
// init the PackageOps map, go over the list of packages that
// that will be [installed|configured|removed|purged] and add
// them to the PackageOps map (the dpkg states it goes through)
// and the PackageOpsTranslations (human readable strings)
- for (vector<Item>::const_iterator I = List.begin(); I != List.end(); ++I)
+ for (auto &&I : List)
{
- if((*I).Pkg.end() == true)
+ if(I.Pkg.end() == true)
continue;
- string const name = (*I).Pkg.FullName();
+ string const name = I.Pkg.FullName();
PackageOpsDone[name] = 0;
- for(int i=0; (DpkgStatesOpMap[(*I).Op][i]).state != NULL; ++i)
+ auto AddToPackageOps = std::back_inserter(PackageOps[name]);
+ if (I.Op == Item::Purge && I.Pkg->CurrentVer != 0)
{
- PackageOps[name].push_back(DpkgStatesOpMap[(*I).Op][i]);
- PackagesTotal++;
+ // purging a package which is installed first passes through remove states
+ auto const DpkgOps = DpkgStatesOpMap[Item::Remove];
+ std::copy(DpkgOps.begin(), DpkgOps.end(), AddToPackageOps);
+ PackagesTotal += DpkgOps.size();
}
+ auto const DpkgOps = DpkgStatesOpMap[I.Op];
+ std::copy_if(DpkgOps.begin(), DpkgOps.end(), AddToPackageOps, [&](DpkgState const &state) {
+ if (state.state == nullptr)
+ return false;
+ ++PackagesTotal;
+ return true;
+ });
}
/* one extra: We don't want the progress bar to reach 100%, especially not
if we call dpkg --configure --pending and process a bunch of triggers
++PackagesTotal;
}
/*}}}*/
-bool pkgDPkgPM::Go(int StatusFd)
+bool pkgDPkgPM::Go(int StatusFd) /*{{{*/
{
APT::Progress::PackageManager *progress = NULL;
if (StatusFd == -1)
progress = APT::Progress::PackageManagerProgressFactory();
else
progress = new APT::Progress::PackageManagerProgressFd(StatusFd);
-
+
return Go(progress);
}
-
-void pkgDPkgPM::StartPtyMagic()
+ /*}}}*/
+void pkgDPkgPM::StartPtyMagic() /*{{{*/
{
if (_config->FindB("Dpkg::Use-Pty", true) == false)
{
_error->Errno("unlockpt", "Unlocking the slave of master fd %d failed!", d->master);
else
{
-#ifdef HAVE_PTS_NAME_R
+#ifdef HAVE_PTSNAME_R
char slave_name[64]; // 64 is used by bionic
if (ptsname_r(d->master, slave_name, sizeof(slave_name)) != 0)
#else
}
_error->RevertToStack();
}
-void pkgDPkgPM::SetupSlavePtyMagic()
+ /*}}}*/
+void pkgDPkgPM::SetupSlavePtyMagic() /*{{{*/
{
if(d->master == -1 || d->slave == NULL)
return;
if (slaveFd != -1)
close(slaveFd);
}
-void pkgDPkgPM::StopPtyMagic()
+ /*}}}*/
+void pkgDPkgPM::StopPtyMagic() /*{{{*/
{
if (d->slave != NULL)
free(d->slave);
close(d->protect_slave_from_dying);
d->protect_slave_from_dying = -1;
}
- if(d->master >= 0)
+ if(d->master >= 0)
{
if (d->tt_is_valid == true && tcsetattr(STDIN_FILENO, TCSAFLUSH, &d->tt) == -1)
_error->FatalE("tcsetattr", "Setting in Stop via TCSAFLUSH for stdin failed!");
d->master = -1;
}
}
+ /*}}}*/
+static void cleanUpTmpDir(char * const tmpdir) /*{{{*/
+{
+ if (tmpdir == nullptr)
+ return;
+ DIR * const D = opendir(tmpdir);
+ if (D == nullptr)
+ _error->Errno("opendir", _("Unable to read %s"), tmpdir);
+ else
+ {
+ auto const dfd = dirfd(D);
+ for (struct dirent *Ent = readdir(D); Ent != nullptr; Ent = readdir(D))
+ {
+ if (Ent->d_name[0] == '.')
+ continue;
+#ifdef _DIRENT_HAVE_D_TYPE
+ if (unlikely(Ent->d_type != DT_LNK && Ent->d_type != DT_UNKNOWN))
+ continue;
+#endif
+ if (unlikely(unlinkat(dfd, Ent->d_name, 0) != 0))
+ break;
+ }
+ closedir(D);
+ rmdir(tmpdir);
+ }
+ free(tmpdir);
+}
+ /*}}}*/
// DPkgPM::Go - Run the sequence /*{{{*/
// ---------------------------------------------------------------------
-/* This globs the operations and calls dpkg
+/* This globs the operations and calls dpkg
*
* If it is called with a progress object apt will report the install
* progress to this object. It maps the dpkg states a package goes
* through to human readable (and i10n-able)
* names and calculates a percentage for each step.
*/
+static bool ItemIsEssential(pkgDPkgPM::Item const &I)
+{
+ static auto const cachegen = _config->Find("pkgCacheGen::Essential");
+ if (cachegen == "none" || cachegen == "native")
+ return true;
+ if (unlikely(I.Pkg.end()))
+ return true;
+ return (I.Pkg->Flags & pkgCache::Flag::Essential) != 0;
+}
+bool pkgDPkgPM::ExpandPendingCalls(std::vector<Item> &List, pkgDepCache &Cache)
+{
+ {
+ std::unordered_set<decltype(pkgCache::Package::ID)> alreadyRemoved;
+ for (auto && I : List)
+ if (I.Op == Item::Remove || I.Op == Item::Purge)
+ alreadyRemoved.insert(I.Pkg->ID);
+ std::remove_reference<decltype(List)>::type AppendList;
+ for (auto Pkg = Cache.PkgBegin(); Pkg.end() == false; ++Pkg)
+ if (Cache[Pkg].Delete() && alreadyRemoved.insert(Pkg->ID).second == true)
+ AppendList.emplace_back(Cache[Pkg].Purge() ? Item::Purge : Item::Remove, Pkg);
+ std::move(AppendList.begin(), AppendList.end(), std::back_inserter(List));
+ }
+ {
+ std::unordered_set<decltype(pkgCache::Package::ID)> alreadyConfigured;
+ for (auto && I : List)
+ if (I.Op == Item::Configure)
+ alreadyConfigured.insert(I.Pkg->ID);
+ std::remove_reference<decltype(List)>::type AppendList;
+ for (auto && I : List)
+ if (I.Op == Item::Install && alreadyConfigured.insert(I.Pkg->ID).second == true)
+ AppendList.emplace_back(Item::Configure, I.Pkg);
+ for (auto Pkg = Cache.PkgBegin(); Pkg.end() == false; ++Pkg)
+ if (Pkg.State() == pkgCache::PkgIterator::NeedsConfigure && alreadyConfigured.insert(Pkg->ID).second == true)
+ AppendList.emplace_back(Item::Configure, Pkg);
+ std::move(AppendList.begin(), AppendList.end(), std::back_inserter(List));
+ }
+ return true;
+}
bool pkgDPkgPM::Go(APT::Progress::PackageManager *progress)
{
+ // explicitely remove&configure everything for hookscripts and progress building
+ // we need them only temporarily through, so keep the length and erase afterwards
+ decltype(List)::const_iterator::difference_type explicitIdx =
+ std::distance(List.cbegin(), List.cend());
+ ExpandPendingCalls(List, Cache);
+
+ /* if dpkg told us that it has already done everything to the package we wanted it to do,
+ we shouldn't ask it for "more" later. That can e.g. happen if packages without conffiles
+ are purged as they will have pass through the purge states on remove already */
+ auto const StripAlreadyDoneFrom = [&](APT::VersionVector & Pending) {
+ Pending.erase(std::remove_if(Pending.begin(), Pending.end(), [&](pkgCache::VerIterator const &Ver) {
+ auto const PN = Ver.ParentPkg().FullName();
+ auto const POD = PackageOpsDone.find(PN);
+ if (POD == PackageOpsDone.end())
+ return false;
+ return PackageOps[PN].size() <= POD->second;
+ }), Pending.end());
+ };
+
pkgPackageManager::SigINTStop = false;
d->progress = progress;
fd_set rfds;
struct timespec tv;
- // FIXME: do we really need this limit when we have MaxArgBytes?
- unsigned int const MaxArgs = _config->FindI("Dpkg::MaxArgs",32*1024);
-
// try to figure out the max environment size
int OSArgMax = sysconf(_SC_ARG_MAX);
if(OSArgMax < 0)
OSArgMax = 32*1024;
OSArgMax -= EnvironmentSize() - 2*1024;
unsigned int const MaxArgBytes = _config->FindI("Dpkg::MaxArgBytes", OSArgMax);
- bool const NoTriggers = _config->FindB("DPkg::NoTriggers", false);
+ bool const NoTriggers = _config->FindB("DPkg::NoTriggers", true);
if (RunScripts("DPkg::Pre-Invoke") == false)
return false;
if (RunScriptsWithPkgs("DPkg::Pre-Install-Pkgs") == false)
return false;
- // support subpressing of triggers processing for special
- // cases like d-i that runs the triggers handling manually
- bool const TriggersPending = _config->FindB("DPkg::TriggersPending", false);
- if (_config->FindB("DPkg::ConfigurePending", true) == true)
- List.push_back(Item(Item::ConfigurePending, PkgIterator()));
+ auto const noopDPkgInvocation = _config->FindB("Debug::pkgDPkgPM",false);
+ // store auto-bits as they are supposed to be after dpkg is run
+ if (noopDPkgInvocation == false)
+ Cache.writeStateFile(NULL);
+
+ bool dpkg_recursive_install = _config->FindB("dpkg::install::recursive", false);
+ if (_config->FindB("dpkg::install::recursive::force", false) == false)
+ {
+ // dpkg uses a sorted treewalk since that version which enables the workaround to work
+ auto const dpkgpkg = Cache.FindPkg("dpkg");
+ if (likely(dpkgpkg.end() == false && dpkgpkg->CurrentVer != 0))
+ dpkg_recursive_install = Cache.VS().CmpVersion("1.18.5", dpkgpkg.CurrentVer().VerStr()) <= 0;
+ }
+ // no point in doing this dance for a handful of packages only
+ unsigned int const dpkg_recursive_install_min = _config->FindB("dpkg::install::recursive::minimum", 5);
+ // FIXME: workaround for dpkg bug, see our ./test-bug-740843-versioned-up-down-breaks test
+ bool const dpkg_recursive_install_numbered = _config->FindB("dpkg::install::recursive::numbered", true);
// for the progress
BuildPackagesProgressMap();
+ APT::StateChanges approvedStates;
+ if (_config->FindB("dpkg::selection::remove::approved", true))
+ {
+ for (auto && I : List)
+ if (I.Op == Item::Purge)
+ approvedStates.Purge(FindToBeRemovedVersion(I.Pkg));
+ else if (I.Op == Item::Remove)
+ approvedStates.Remove(FindToBeRemovedVersion(I.Pkg));
+ }
+
+ // Skip removes if we install another architecture of this package soon (crossgrade)
+ // We can't just skip them all the time as it could be an ordering requirement [of another package]
+ if ((approvedStates.Remove().empty() == false || approvedStates.Purge().empty() == false) &&
+ _config->FindB("dpkg::remove::crossgrade::implicit", true) == true)
+ {
+ std::unordered_set<decltype(pkgCache::Package::ID)> crossgraded;
+ std::vector<std::pair<Item*, std::string>> toCrossgrade;
+ auto const PlanedEnd = std::next(List.begin(), explicitIdx);
+ for (auto I = List.begin(); I != PlanedEnd; ++I)
+ {
+ if (I->Op != Item::Remove && I->Op != Item::Purge)
+ continue;
+
+ auto const Grp = I->Pkg.Group();
+ size_t installedInstances = 0;
+ for (auto Pkg = Grp.PackageList(); Pkg.end() == false; Pkg = Grp.NextPkg(Pkg))
+ if (Pkg->CurrentVer != 0 || Cache[Pkg].Install())
+ ++installedInstances;
+ if (installedInstances == 2)
+ {
+ auto const FirstInstall = std::find_if_not(I, List.end(),
+ [](Item const &i) { return i.Op == Item::Remove || i.Op == Item::Purge; });
+ auto const LastInstall = std::find_if_not(FirstInstall, List.end(),
+ [](Item const &i) { return i.Op == Item::Install; });
+ auto const crosser = std::find_if(FirstInstall, LastInstall,
+ [&I](Item const &i) { return i.Pkg->Group == I->Pkg->Group; });
+ if (crosser != LastInstall)
+ {
+ crossgraded.insert(I->Pkg->ID);
+ toCrossgrade.emplace_back(&(*I), crosser->Pkg.FullName());
+ }
+ }
+ }
+ for (auto I = PlanedEnd; I != List.end(); ++I)
+ {
+ if (I->Op != Item::Remove && I->Op != Item::Purge)
+ continue;
+
+ auto const Grp = I->Pkg.Group();
+ for (auto Pkg = Grp.PackageList(); Pkg.end() == false; Pkg = Grp.NextPkg(Pkg))
+ {
+ if (Pkg == I->Pkg || Cache[Pkg].Install() == false)
+ continue;
+ toCrossgrade.emplace_back(&(*I), Pkg.FullName());
+ break;
+ }
+ }
+ for (auto C : toCrossgrade)
+ {
+ // we never do purges on packages which are crossgraded, even if "requested"
+ if (C.first->Op == Item::Purge)
+ {
+ C.first->Op = Item::Remove; // crossgrades should never be purged
+ auto && Purges = approvedStates.Purge();
+ auto const Ver = std::find_if(
+#if __GNUC__ >= 5 || (__GNUC_MINOR__ >= 9 && __GNUC__ >= 4)
+ Purges.cbegin(), Purges.cend(),
+#else
+ Purges.begin(), Purges.end(),
+#endif
+ [&C](pkgCache::VerIterator const &V) { return V.ParentPkg() == C.first->Pkg; });
+ approvedStates.Remove(*Ver);
+ Purges.erase(Ver);
+ auto && RemOp = PackageOps[C.first->Pkg.FullName()];
+ if (RemOp.size() == 5)
+ {
+ RemOp.erase(std::next(RemOp.begin(), 3), RemOp.end());
+ PackagesTotal -= 2;
+ }
+ else
+ _error->Warning("Unexpected amount of planned ops for package %s: %lu", C.first->Pkg.FullName().c_str(), RemOp.size());
+ }
+ }
+ if (crossgraded.empty() == false)
+ {
+ auto const oldsize = List.size();
+ List.erase(std::remove_if(List.begin(), PlanedEnd,
+ [&crossgraded](Item const &i){
+ return (i.Op == Item::Remove || i.Op == Item::Purge) &&
+ crossgraded.find(i.Pkg->ID) != crossgraded.end();
+ }), PlanedEnd);
+ explicitIdx -= (oldsize - List.size());
+ }
+ }
+
+ APT::StateChanges currentStates;
+ if (_config->FindB("dpkg::selection::current::saveandrestore", true))
+ {
+ for (auto Pkg = Cache.PkgBegin(); Pkg.end() == false; ++Pkg)
+ if (Pkg->CurrentVer == 0)
+ continue;
+ else if (Pkg->SelectedState == pkgCache::State::Purge)
+ currentStates.Purge(FindToBeRemovedVersion(Pkg));
+ else if (Pkg->SelectedState == pkgCache::State::DeInstall)
+ currentStates.Remove(FindToBeRemovedVersion(Pkg));
+ if (currentStates.empty() == false)
+ {
+ APT::StateChanges cleanStates;
+ for (auto && P: currentStates.Remove())
+ cleanStates.Install(P);
+ for (auto && P: currentStates.Purge())
+ cleanStates.Install(P);
+ if (cleanStates.Save(false) == false)
+ return _error->Error("Couldn't clean the currently selected dpkg states");
+ }
+ }
+
+ if (_config->FindB("dpkg::selection::remove::approved", true))
+ {
+ if (approvedStates.Save(false) == false)
+ {
+ _error->Error("Couldn't record the approved state changes as dpkg selection states");
+ if (currentStates.Save(false) == false)
+ _error->Error("Couldn't restore dpkg selection states which were present before this interaction!");
+ return false;
+ }
+
+ List.erase(std::next(List.begin(), explicitIdx), List.end());
+
+ std::vector<bool> toBeRemoved(Cache.Head().PackageCount, false);
+ for (auto && I: approvedStates.Remove())
+ toBeRemoved[I.ParentPkg()->ID] = true;
+ for (auto && I: approvedStates.Purge())
+ toBeRemoved[I.ParentPkg()->ID] = true;
+
+ for (auto && I: List)
+ if (I.Op == Item::Remove || I.Op == Item::Purge)
+ toBeRemoved[I.Pkg->ID] = false;
+
+ bool const RemovePending = std::find(toBeRemoved.begin(), toBeRemoved.end(), true) != toBeRemoved.end();
+ bool const PurgePending = approvedStates.Purge().empty() == false;
+ if (RemovePending != false || PurgePending != false)
+ List.emplace_back(Item::ConfigurePending, pkgCache::PkgIterator());
+ if (RemovePending)
+ List.emplace_back(Item::RemovePending, pkgCache::PkgIterator());
+ if (PurgePending)
+ List.emplace_back(Item::PurgePending, pkgCache::PkgIterator());
+
+ // support subpressing of triggers processing for special
+ // cases like d-i that runs the triggers handling manually
+ if (_config->FindB("DPkg::ConfigurePending", true))
+ List.emplace_back(Item::ConfigurePending, pkgCache::PkgIterator());
+ }
+ bool const TriggersPending = _config->FindB("DPkg::TriggersPending", false);
+
d->stdin_is_dev_null = false;
// create log
// start pty magic before the loop
StartPtyMagic();
- // Tell the progress that its starting and fork dpkg
+ // Tell the progress that its starting and fork dpkg
d->progress->Start(d->master);
// this loop is runs once per dpkg operation
- vector<Item>::const_iterator I = List.begin();
+ vector<Item>::const_iterator I = List.cbegin();
while (I != List.end())
{
// Do all actions with the same Op in one run
continue;
break;
}
+ else if (J->Op == Item::Remove || J->Op == Item::Purge)
+ J = std::find_if(J, List.cend(), [](Item const &I) { return I.Op != Item::Remove && I.Op != Item::Purge; });
else
- for (; J != List.end() && J->Op == I->Op; ++J)
- /* nothing */;
+ J = std::find_if(J, List.cend(), [&J](Item const &I) { return I.Op != J->Op; });
- // keep track of allocated strings for multiarch package names
- std::vector<char *> Packages;
+ auto const size = (J - I) + 10;
// start with the baseset of arguments
- unsigned long Size = StartSize;
+ auto Size = StartSize;
Args.erase(Args.begin() + BaseArgs, Args.end());
-
- // Now check if we are within the MaxArgs limit
- //
- // this code below is problematic, because it may happen that
- // the argument list is split in a way that A depends on B
- // and they are in the same "--configure A B" run
- // - with the split they may now be configured in different
- // runs, using Immediate-Configure-All can help prevent this.
- if (J - I > (signed)MaxArgs)
- {
- J = I + MaxArgs;
- unsigned long const size = MaxArgs + 10;
- Args.reserve(size);
- Packages.reserve(size);
- }
- else
- {
- unsigned long const size = (J - I) + 10;
- Args.reserve(size);
- Packages.reserve(size);
- }
+ Args.reserve(size);
+ // keep track of allocated strings for multiarch package names
+ std::vector<char *> Packages(size, nullptr);
int fd[2];
if (pipe(fd) != 0)
ADDARG(status_fd_buf);
unsigned long const Op = I->Op;
+ if (NoTriggers == true && I->Op != Item::TriggersPending &&
+ (I->Op != Item::ConfigurePending || std::next(I) != List.end()))
+ {
+ ADDARGC("--no-triggers");
+ }
+
switch (I->Op)
{
case Item::Remove:
- ADDARGC("--force-depends");
- ADDARGC("--force-remove-essential");
- ADDARGC("--remove");
- break;
-
case Item::Purge:
ADDARGC("--force-depends");
- ADDARGC("--force-remove-essential");
- ADDARGC("--purge");
+ if (std::any_of(I, J, ItemIsEssential))
+ ADDARGC("--force-remove-essential");
+ ADDARGC("--remove");
break;
-
+
case Item::Configure:
ADDARGC("--configure");
break;
ADDARGC("--pending");
break;
+ case Item::RemovePending:
+ ADDARGC("--remove");
+ ADDARGC("--pending");
+ break;
+
+ case Item::PurgePending:
+ ADDARGC("--purge");
+ ADDARGC("--pending");
+ break;
+
case Item::Install:
ADDARGC("--unpack");
ADDARGC("--auto-deconfigure");
break;
}
- if (NoTriggers == true && I->Op != Item::TriggersPending &&
- I->Op != Item::ConfigurePending)
- {
- ADDARGC("--no-triggers");
- }
-#undef ADDARGC
+ char * tmpdir_to_free = nullptr;
// Write in the file or package names
if (I->Op == Item::Install)
{
- for (;I != J && Size < MaxArgBytes; ++I)
+ auto const installsToDo = J - I;
+ if (dpkg_recursive_install == true && dpkg_recursive_install_min < installsToDo)
{
- if (I->File[0] != '/')
- return _error->Error("Internal Error, Pathname to install is not absolute '%s'",I->File.c_str());
- Args.push_back(I->File.c_str());
- Size += I->File.length();
+ std::string tmpdir;
+ strprintf(tmpdir, "%s/apt-dpkg-install-XXXXXX", GetTempDir().c_str());
+ tmpdir_to_free = strndup(tmpdir.data(), tmpdir.length());
+ if (mkdtemp(tmpdir_to_free) == nullptr)
+ return _error->Errno("DPkg::Go", "mkdtemp of %s failed in preparation of calling dpkg unpack", tmpdir_to_free);
+
+ char p = 1;
+ for (auto c = installsToDo - 1; (c = c/10) != 0; ++p);
+ for (unsigned long n = 0; I != J; ++n, ++I)
+ {
+ if (I->File[0] != '/')
+ return _error->Error("Internal Error, Pathname to install is not absolute '%s'",I->File.c_str());
+ auto file = flNotDir(I->File);
+ if (flExtension(file) != "deb")
+ file.append(".deb");
+ std::string linkpath;
+ if (dpkg_recursive_install_numbered)
+ strprintf(linkpath, "%s/%.*lu-%s", tmpdir_to_free, p, n, file.c_str());
+ else
+ strprintf(linkpath, "%s/%s", tmpdir_to_free, file.c_str());
+ if (symlink(I->File.c_str(), linkpath.c_str()) != 0)
+ return _error->Errno("DPkg::Go", "Symlinking %s to %s failed!", I->File.c_str(), linkpath.c_str());
+ }
+ ADDARGC("--recursive");
+ ADDARG(tmpdir_to_free);
+ }
+ else
+ {
+ for (;I != J && Size < MaxArgBytes; ++I)
+ {
+ if (I->File[0] != '/')
+ return _error->Error("Internal Error, Pathname to install is not absolute '%s'",I->File.c_str());
+ Args.push_back(I->File.c_str());
+ Size += I->File.length();
+ }
}
}
+ else if (I->Op == Item::RemovePending)
+ {
+ ++I;
+ StripAlreadyDoneFrom(approvedStates.Remove());
+ if (approvedStates.Remove().empty())
+ continue;
+ }
+ else if (I->Op == Item::PurgePending)
+ {
+ ++I;
+ // explicit removes of packages without conffiles passthrough the purge states instantly, too.
+ // Setting these non-installed packages up for purging generates 'unknown pkg' warnings from dpkg
+ StripAlreadyDoneFrom(approvedStates.Purge());
+ if (approvedStates.Purge().empty())
+ continue;
+ std::remove_reference<decltype(approvedStates.Remove())>::type approvedRemoves;
+ std::swap(approvedRemoves, approvedStates.Remove());
+ // we apply it again here as an explicit remove in the ordering will have cleared the purge state
+ if (approvedStates.Save(false) == false)
+ {
+ _error->Error("Couldn't record the approved purges as dpkg selection states");
+ if (currentStates.Save(false) == false)
+ _error->Error("Couldn't restore dpkg selection states which were present before this interaction!");
+ return false;
+ }
+ std::swap(approvedRemoves, approvedStates.Remove());
+ }
else
{
string const nativeArch = _config->Find("APT::Architecture");
- unsigned long const oldSize = I->Op == Item::Configure ? Size : 0;
+ unsigned long const oldSize = I->Pkg.end() == false ? Size : 0;
for (;I != J && Size < MaxArgBytes; ++I)
{
if((*I).Pkg.end() == true)
{
pkgCache::VerIterator PkgVer;
std::string name = I->Pkg.Name();
- if (Op == Item::Remove || Op == Item::Purge)
- {
+ if (Op == Item::Remove)
PkgVer = I->Pkg.CurrentVer();
- if(PkgVer.end() == true)
- PkgVer = FindNowVersion(I->Pkg);
- }
+ else if (Op == Item::Purge)
+ {
+ // we purge later with --purge --pending, so if it isn't installed (aka rc-only), skip it here
+ PkgVer = I->Pkg.CurrentVer();
+ if (PkgVer.end() == true)
+ continue;
+ }
else
PkgVer = Cache[I->Pkg].InstVerIter(Cache);
if (strcmp(I->Pkg.Arch(), "none") == 0)
if (oldSize == Size)
continue;
}
+#undef ADDARGC
#undef ADDARG
J = I;
-
- if (_config->FindB("Debug::pkgDPkgPM",false) == true)
+
+ if (noopDPkgInvocation == true)
{
for (std::vector<const char *>::const_iterator a = Args.begin();
a != Args.end(); ++a)
p != Packages.end(); ++p)
free(*p);
Packages.clear();
+ close(fd[0]);
+ close(fd[1]);
+ cleanUpTmpDir(tmpdir_to_free);
continue;
}
Args.push_back(NULL);
clog << flush;
cerr << flush;
- /* Mask off sig int/quit. We do this because dpkg also does when
+ /* Mask off sig int/quit. We do this because dpkg also does when
it forks scripts. What happens is that when you hit ctrl-c it sends
- it to all processes in the group. Since dpkg ignores the signal
+ it to all processes in the group. Since dpkg ignores the signal
it doesn't die but we do! So we must also ignore it */
sighandler_t old_SIGQUIT = signal(SIGQUIT,SIG_IGN);
sighandler_t old_SIGINT = signal(SIGINT,SigINT);
-
+
// Check here for any SIGINT
- if (pkgPackageManager::SigINTStop && (Op == Item::Remove || Op == Item::Purge || Op == Item::Install))
+ if (pkgPackageManager::SigINTStop && (Op == Item::Remove || Op == Item::Purge || Op == Item::Install))
break;
-
-
+
// ignore SIGHUP as well (debian #463030)
sighandler_t old_SIGHUP = signal(SIGHUP,SIG_IGN);
int dummy = 0;
if ((Flags = fcntl(STDIN_FILENO,F_GETFL,dummy)) < 0)
_exit(100);
-
+
// Discard everything in stdin before forking dpkg
if (fcntl(STDIN_FILENO,F_SETFL,Flags | O_NONBLOCK) < 0)
_exit(100);
-
+
while (read(STDIN_FILENO,&dummy,1) == 1);
-
+
if (fcntl(STDIN_FILENO,F_SETFL,Flags & (~(long)O_NONBLOCK)) < 0)
_exit(100);
}
+ // if color support isn't enabled/disabled explicitly tell
+ // dpkg to use the same state apt is using for its color support
+ if (_config->FindB("APT::Color", false) == true)
+ setenv("DPKG_COLORS", "always", 0);
+ else
+ setenv("DPKG_COLORS", "never", 0);
+
execvp(Args[0], (char**) &Args[0]);
cerr << "Could not exec dpkg!" << endl;
_exit(100);
- }
-
- // apply ionice
- if (_config->FindB("DPkg::UseIoNice", false) == true)
- ionice(Child);
-
- // Wait for dpkg
- int Status = 0;
+ }
// we read from dpkg here
int const _dpkgin = fd[0];
close(fd[1]); // close the write end of the pipe
+ // apply ionice
+ if (_config->FindB("DPkg::UseIoNice", false) == true)
+ ionice(Child);
+
// setups fds
sigemptyset(&d->sigmask);
sigprocmask(SIG_BLOCK,&d->sigmask,&d->original_sigmask);
Packages.clear();
// the result of the waitpid call
+ int Status = 0;
int res;
- int select_ret;
bool waitpid_failure = false;
while ((res=waitpid(Child,&Status, WNOHANG)) != Child) {
if(res < 0) {
FD_SET(d->master, &rfds);
tv.tv_sec = 0;
tv.tv_nsec = d->progress->GetPulseInterval();
- select_ret = pselect(max(d->master, _dpkgin)+1, &rfds, NULL, NULL,
+ auto const select_ret = pselect(max(d->master, _dpkgin)+1, &rfds, NULL, NULL,
&tv, &d->original_sigmask);
- if (select_ret < 0 && (errno == EINVAL || errno == ENOSYS))
- select_ret = racy_pselect(max(d->master, _dpkgin)+1, &rfds, NULL,
- NULL, &tv, &d->original_sigmask);
d->progress->Pulse();
- if (select_ret == 0)
- continue;
- else if (select_ret < 0 && errno == EINTR)
- continue;
- else if (select_ret < 0)
- {
- perror("select() returned error");
- continue;
- }
-
+ if (select_ret == 0)
+ continue;
+ else if (select_ret < 0 && errno == EINTR)
+ continue;
+ else if (select_ret < 0)
+ {
+ perror("select() returned error");
+ continue;
+ }
+
if(d->master >= 0 && FD_ISSET(d->master, &rfds))
DoTerminalPty(d->master);
if(d->master >= 0 && FD_ISSET(0, &rfds))
signal(SIGINT,old_SIGINT);
signal(SIGHUP,old_SIGHUP);
+ cleanUpTmpDir(tmpdir_to_free);
+
if (waitpid_failure == true)
{
strprintf(d->dpkg_error, "Sub-process %s couldn't be waited for.",Args[0]);
StopPtyMagic();
CloseLog();
+ if (d->dpkg_error.empty() == false)
+ {
+ // no point in reseting packages we already completed removal for
+ StripAlreadyDoneFrom(approvedStates.Remove());
+ StripAlreadyDoneFrom(approvedStates.Purge());
+ APT::StateChanges undo;
+ auto && undoRem = approvedStates.Remove();
+ std::move(undoRem.begin(), undoRem.end(), std::back_inserter(undo.Install()));
+ auto && undoPur = approvedStates.Purge();
+ std::move(undoPur.begin(), undoPur.end(), std::back_inserter(undo.Install()));
+ approvedStates.clear();
+ if (undo.Save(false) == false)
+ _error->Error("Couldn't revert dpkg selection for approved remove/purge after an error was encountered!");
+ }
+
+ StripAlreadyDoneFrom(currentStates.Remove());
+ StripAlreadyDoneFrom(currentStates.Purge());
+ if (currentStates.Save(false) == false)
+ _error->Error("Couldn't restore dpkg selection states which were present before this interaction!");
+
if (pkgPackageManager::SigINTStop)
_error->Warning(_("Operation was interrupted before it could finish"));
- if (_config->FindB("Debug::pkgDPkgPM",false) == false)
+ if (noopDPkgInvocation == false)
{
std::string const oldpkgcache = _config->FindFile("Dir::cache::pkgcache");
if (oldpkgcache.empty() == false && RealFileExists(oldpkgcache) == true &&
}
}
- Cache.writeStateFile(NULL);
+ // disappearing packages can forward their auto-bit
+ if (disappearedPkgs.empty() == false)
+ Cache.writeStateFile(NULL);
d->progress->Stop();
// pkgDpkgPM::Reset - Dump the contents of the command list /*{{{*/
// ---------------------------------------------------------------------
/* */
-void pkgDPkgPM::Reset()
+void pkgDPkgPM::Reset()
{
List.erase(List.begin(),List.end());
}
// pkgDpkgPM::WriteApportReport - write out error report pkg failure /*{{{*/
// ---------------------------------------------------------------------
/* */
-void pkgDPkgPM::WriteApportReport(const char *pkgpath, const char *errormsg)
+void pkgDPkgPM::WriteApportReport(const char *pkgpath, const char *errormsg)
{
// If apport doesn't exist or isn't installed do nothing
// This e.g. prevents messages in 'universes' without apport
return;
}
- // check if its not a follow up error
+ // check if its not a follow up error
const char *needle = dgettext("dpkg", "dependency problems - leaving unconfigured");
if(strstr(errormsg, needle) != NULL) {
std::clog << _("No apport report written because the error message indicates its a followup error from a previous failure.") << std::endl;
return;
}
- // do not report disk-full failures
+ // do not report disk-full failures
if(strstr(errormsg, strerror(ENOSPC)) != NULL) {
std::clog << _("No apport report written because the error message indicates a disk full error") << std::endl;
return;
}
- // do not report out-of-memory failures
+ // do not report out-of-memory failures
if(strstr(errormsg, strerror(ENOMEM)) != NULL ||
strstr(errormsg, "failed to allocate memory") != NULL) {
std::clog << _("No apport report written because the error message indicates a out of memory error") << std::endl;
// to kill the "s" manually
if (list[1].size() > 1) {
list[1].erase(0, 1);
- if(strstr(errormsg, list[0].c_str()) &&
+ if(strstr(errormsg, list[0].c_str()) &&
strstr(errormsg, list[1].c_str())) {
std::clog << _("No apport report written because the error message indicates a dpkg I/O error") << std::endl;
return;
// find the package version and source package name
pkgCache::PkgIterator Pkg = Cache.FindPkg(pkgname);
if (Pkg.end() == true)
- return;
+ {
+ if (pos == std::string::npos || _config->FindB("dpkg::install::recursive::numbered", true) == false)
+ return;
+ auto const dash = pkgname.find_first_not_of("0123456789");
+ if (dash == std::string::npos || pkgname[dash] != '-')
+ return;
+ pkgname.erase(0, dash + 1);
+ Pkg = Cache.FindPkg(pkgname);
+ if (Pkg.end() == true)
+ return;
+ }
pkgCache::VerIterator Ver = Cache.GetCandidateVersion(Pkg);
if (Ver.end() == true)
return;
// we overwrite it. This is the same behaviour as apport
// - if we have a report with the same pkgversion already
// then we skip it
- reportfile = flCombine("/var/crash",pkgname+".0.crash");
+ _config->CndSet("Dir::Apport", "var/crash");
+ reportfile = flCombine(_config->FindDir("Dir::Apport", "var/crash"), pkgname+".0.crash");
if(FileExists(reportfile))
{
struct stat buf;
}
// log the ordering, see dpkgpm.h and the "Ops" enum there
- const char *ops_str[] = {
- "Install",
- "Configure",
- "Remove",
- "Purge",
- "ConfigurePending",
- "TriggersPending",
- };
fprintf(report, "AptOrdering:\n");
- for (vector<Item>::iterator I = List.begin(); I != List.end(); ++I)
- if ((*I).Pkg != NULL)
- fprintf(report, " %s: %s\n", (*I).Pkg.Name(), ops_str[(*I).Op]);
- else
- fprintf(report, " %s: %s\n", "NULL", ops_str[(*I).Op]);
+ for (auto && I : List)
+ {
+ char const * opstr = nullptr;
+ switch (I.Op)
+ {
+ case Item::Install: opstr = "Install"; break;
+ case Item::Configure: opstr = "Configure"; break;
+ case Item::Remove: opstr = "Remove"; break;
+ case Item::Purge: opstr = "Purge"; break;
+ case Item::ConfigurePending: opstr = "ConfigurePending"; break;
+ case Item::TriggersPending: opstr = "TriggersPending"; break;
+ case Item::RemovePending: opstr = "RemovePending"; break;
+ case Item::PurgePending: opstr = "PurgePending"; break;
+ }
+ auto const pkgname = I.Pkg.end() ? "NULL" : I.Pkg.FullName();
+ fprintf(report, " %s: %s\n", pkgname.c_str(), opstr);
+ }
// attach dmesg log (to learn about segfaults)
if (FileExists("/bin/dmesg"))
projects / apt.git / blobdiff