Compare `15f32c4 ... +34 ... e5f9d66`

   return false;
}
									/*}}}*/

																		/*}}}*/
int pkgAcquire::Item::Priority() 				/*{{{*/
int pkgAcquire::Item::Priority()					/*{{{*/
{
   // Stage 1: Meta indices and diff indices
   // - those need to be fetched first to have progress reporting working

@@ -1925,10 +1923,16 @@

   }
   else if(MetaIndex->CheckAuthDone(Message) == true)
   {
      if (TransactionManager->IMSHit == false)
      auto const Releasegpg = GetFinalFilename();
      auto const Release = MetaIndex->GetFinalFilename();
      // if this is an IMS-Hit on Release ensure we also have the the Release.gpg file stored
      // (previously an unknown pubkey) – but only if the Release file exists locally (unlikely
      // event of InRelease removed from the mirror causing fallback but still an IMS-Hit)
      if (TransactionManager->IMSHit == false ||
	    (FileExists(Releasegpg) == false && FileExists(Release) == true))
      {
	 TransactionManager->TransactionStageCopy(this, DestFile, GetFinalFilename());
	 TransactionManager->TransactionStageCopy(MetaIndex, MetaIndex->DestFile, MetaIndex->GetFinalFilename());
	 TransactionManager->TransactionStageCopy(this, DestFile, Releasegpg);
	 TransactionManager->TransactionStageCopy(MetaIndex, MetaIndex->DestFile, Release);
      }
   }
   else if (MetaIndex->Status != StatAuthError)

@@ -2051,7 +2055,7 @@

{
   // list cleanup needs to know that this file as well as the already
   // present index is ours, so we create an empty diff to save it for us
   new pkgAcqIndexDiffs(Owner, TransactionManager, Target);
   new pkgAcqIndexDiffs(Owner, TransactionManager, Target, UsedMirror, Target.URI);
}
									/*}}}*/
static bool RemoveFileForBootstrapLinking(bool const Debug, std::string const &For, std::string const &Boot)/*{{{*/

@@ -2427,14 +2431,26 @@

      }
   }

   std::string indexURI = Desc.URI;
   auto const byhashidx = indexURI.find("/by-hash/");
   if (byhashidx != std::string::npos)
      indexURI = indexURI.substr(0, byhashidx - strlen(".diff"));
   else
   {
      auto end = indexURI.length() - strlen(".diff/Index");
      if (CurrentCompressionExtension != "uncompressed")
	 end -= (1 + CurrentCompressionExtension.length());
      indexURI = indexURI.substr(0, end);
   }

   if (pdiff_merge == false)
      new pkgAcqIndexDiffs(Owner, TransactionManager, Target, available_patches);
      new pkgAcqIndexDiffs(Owner, TransactionManager, Target, UsedMirror, indexURI, available_patches);
   else
   {
      diffs = new std::vector<pkgAcqIndexMergeDiffs*>(available_patches.size());
      for(size_t i = 0; i < available_patches.size(); ++i)
	 (*diffs)[i] = new pkgAcqIndexMergeDiffs(Owner, TransactionManager,
               Target,
               Target, UsedMirror, indexURI,
	       available_patches[i],
	       diffs);
   }

@@ -2504,8 +2520,9 @@

pkgAcqIndexDiffs::pkgAcqIndexDiffs(pkgAcquire * const Owner,
                                   pkgAcqMetaClearSig * const TransactionManager,
                                   IndexTarget const &Target,
				   std::string const &indexUsedMirror, std::string const &indexURI,
				   vector<DiffInfo> const &diffs)
   : pkgAcqBaseIndex(Owner, TransactionManager, Target), d(NULL),
   : pkgAcqBaseIndex(Owner, TransactionManager, Target), indexURI(indexURI),
     available_patches(diffs)
{
   DestFile = GetKeepCompressedFileName(GetPartialFileNameFromURI(Target.URI), Target);

@@ -2516,6 +2533,12 @@

   Description = Target.Description;
   Desc.ShortDesc = Target.ShortDesc;

   UsedMirror = indexUsedMirror;
   if (UsedMirror == "DIRECT")
      UsedMirror.clear();
   else if (UsedMirror.empty() == false && Description.find(" ") != string::npos)
      Description.replace(0, Description.find(" "), UsedMirror);

   if(available_patches.empty() == true)
   {
      // we are done (yeah!), check hashes against the final file

@@ -2630,7 +2653,7 @@

   }

   // queue the right diff
   Desc.URI = Target.URI + ".diff/" + available_patches[0].file + ".gz";
   Desc.URI = indexURI + ".diff/" + available_patches[0].file + ".gz";
   Desc.Description = Description + " " + available_patches[0].file + string(".pdiff");
   DestFile = GetKeepCompressedFileName(GetPartialFileNameFromURI(Target.URI + ".diff/" + available_patches[0].file), Target);


@@ -2683,7 +2706,7 @@

	 // see if there is more to download
	 if(available_patches.empty() == false)
	 {
	    new pkgAcqIndexDiffs(Owner, TransactionManager, Target, available_patches);
	    new pkgAcqIndexDiffs(Owner, TransactionManager, Target, UsedMirror, indexURI, available_patches);
	    Finish();
	 } else {
	    DestFile = PatchedFile;

@@ -2712,19 +2735,26 @@

pkgAcqIndexMergeDiffs::pkgAcqIndexMergeDiffs(pkgAcquire * const Owner,
                                             pkgAcqMetaClearSig * const TransactionManager,
                                             IndexTarget const &Target,
					     std::string const &indexUsedMirror, std::string const &indexURI,
                                             DiffInfo const &patch,
                                             std::vector<pkgAcqIndexMergeDiffs*> const * const allPatches)
  : pkgAcqBaseIndex(Owner, TransactionManager, Target), d(NULL),
     patch(patch), allPatches(allPatches), State(StateFetchDiff)
  : pkgAcqBaseIndex(Owner, TransactionManager, Target), indexURI(indexURI),
    patch(patch), allPatches(allPatches), State(StateFetchDiff)
{
   Debug = _config->FindB("Debug::pkgAcquire::Diffs",false);

   Desc.Owner = this;
   Description = Target.Description;
   UsedMirror = indexUsedMirror;
   if (UsedMirror == "DIRECT")
      UsedMirror.clear();
   else if (UsedMirror.empty() == false && Description.find(" ") != string::npos)
      Description.replace(0, Description.find(" "), UsedMirror);

   Desc.Owner = this;
   Desc.ShortDesc = Target.ShortDesc;
   Desc.URI = Target.URI + ".diff/" + patch.file + ".gz";
   Desc.URI = indexURI + ".diff/" + patch.file + ".gz";
   Desc.Description = Description + " " + patch.file + ".pdiff";
   DestFile = GetPartialFileNameFromURI(Desc.URI);
   DestFile = GetPartialFileNameFromURI(Target.URI + ".diff/" + patch.file + ".gz");

   if(Debug)
      std::clog << "pkgAcqIndexMergeDiffs: " << Desc.URI << std::endl;

@@ -2731 +2761 @@

@@ -143,6 +143,8 @@

  // of each array is the key, entry 1 is the value.
  const std::pair<const char *, const char *> PackageProcessingOps[] = {
    std::make_pair("install",   N_("Installing %s")),
    // we don't care for the difference
    std::make_pair("upgrade",   N_("Installing %s")),
    std::make_pair("configure", N_("Configuring %s")),
    std::make_pair("remove",    N_("Removing %s")),
    std::make_pair("purge",    N_("Completely removing %s")),

@@ -615,68 +617,154 @@

   {
      pkgname = APT::String::Strip(list[2]);
      action = APT::String::Strip(list[1]);
      // we don't care for the difference (as dpkg doesn't really either)
      if (action == "upgrade")
	 action = "install";
   }
   // "status" has the form: "status: pkg: state"
   // with state in ["half-installed", "unpacked", "half-configured", 
   // with state in ["half-installed", "unpacked", "half-configured",
   //                "installed", "config-files", "not-installed"]
   else if (prefix == "status")
   {
      pkgname = APT::String::Strip(list[1]);
      action = APT::String::Strip(list[2]);
   } else {
      if (Debug == true)
	 std::clog << "unknown prefix '" << prefix << "'" << std::endl;
      return;
   }


   /* handle the special cases first:
      /* handle the special cases first:

      errors look like this:
      'status: /var/cache/apt/archives/krecipes_0.8.1-0ubuntu1_i386.deb : error : trying to overwrite `/usr/share/doc/kde/HTML/en/krecipes/krectip.png', which is also in package krecipes-data 
      and conffile-prompt like this
      'status:/etc/compiz.conf/compiz.conf :  conffile-prompt: 'current-conffile' 'new-conffile' useredited distedited
   */
   if (prefix == "status")
   {
	 errors look like this:
	 'status: /var/cache/apt/archives/krecipes_0.8.1-0ubuntu1_i386.deb : error : trying to overwrite `/usr/share/doc/kde/HTML/en/krecipes/krectip.png', which is also in package krecipes-data
	 and conffile-prompt like this
	 'status:/etc/compiz.conf/compiz.conf :  conffile-prompt: 'current-conffile' 'new-conffile' useredited distedited
	 */
      if(action == "error")
      {
         d->progress->Error(pkgname, PackagesDone, PackagesTotal,
                            list[3]);
         pkgFailures++;
         d->progress->Error(pkgname, PackagesDone, PackagesTotal, list[3]);
         ++pkgFailures;
         WriteApportReport(pkgname.c_str(), list[3].c_str());
         return;
      }
      else if(action == "conffile-prompt")
      {
         d->progress->ConffilePrompt(pkgname, PackagesDone, PackagesTotal,
                                     list[3]);
         d->progress->ConffilePrompt(pkgname, PackagesDone, PackagesTotal, list[3]);
         return;
      }
   } else {
      if (Debug == true)
	 std::clog << "unknown prefix '" << prefix << "'" << std::endl;
      return;
   }

   // at this point we know that we should have a valid pkgname, so build all 
   // the info from it

   // dpkg does not always send "pkgname:arch" so we add it here if needed
   // At this point we have a pkgname, but it might not be arch-qualified !
   if (pkgname.find(":") == std::string::npos)
   {
      // find the package in the group that is touched by dpkg
      // if there are multiple pkgs dpkg would send us a full pkgname:arch
      pkgCache::GrpIterator Grp = Cache.FindGrp(pkgname);
      if (Grp.end() == false)
	 for (auto P = Grp.PackageList(); P.end() != true; P = Grp.NextPkg(P))
	    if(Cache[P].Keep() == false || Cache[P].ReInstall() == true)
      /* No arch means that dpkg believes there can only be one package
         this can refer to so lets see what could be candidates here: */
      std::vector<pkgCache::PkgIterator> candset;
      for (auto P = Grp.PackageList(); P.end() != true; P = Grp.NextPkg(P))
      {
	 if (PackageOps.find(P.FullName()) != PackageOps.end())
	    candset.push_back(P);
	 // packages can disappear without them having any interaction itself
	 // so we have to consider these as candidates, too
	 else if (P->CurrentVer != 0 && action == "disappear")
	    candset.push_back(P);
      }
      if (unlikely(candset.empty()))
      {
	 if (Debug == true)
	    std::clog << "unable to figure out which package is dpkg refering to with '" << pkgname << "'! (1)" << std::endl;
	 return;
      }
      else if (candset.size() == 1) // we are lucky
	 pkgname = candset.cbegin()->FullName();
      else
      {
	 /* here be dragons^Wassumptions about dpkg:
	    - an M-A:same version is always arch-qualified
	    - a package from a foreign arch is (in newer versions) */
	 size_t installedInstances = 0, wannabeInstances = 0;
	 for (auto const &P: candset)
	 {
	    if (P->CurrentVer != 0)
	    {
	       ++installedInstances;
	       if (Cache[P].Delete() == false)
		  ++wannabeInstances;
	    }
	    else if (Cache[P].Install())
	       ++wannabeInstances;
	 }
	 // the package becomes M-A:same, so we are still talking about current
	 if (installedInstances == 1 && wannabeInstances >= 2)
	 {
	    for (auto const &P: candset)
	    {
	       auto fullname = P.FullName();
	       if (Cache[P].Delete() && PackageOps[fullname].size() <= PackageOpsDone[fullname])
	       if (P->CurrentVer == 0)
		  continue;
	       pkgname = std::move(fullname);
	       pkgname = P.FullName();
	       break;
	    }
	 }
	 // the package was M-A:same, it isn't now, so we can only talk about that
	 else if (installedInstances >= 2 && wannabeInstances == 1)
	 {
	    for (auto const &P: candset)
	    {
	       auto const IV = Cache[P].InstVerIter(Cache);
	       if (IV.end())
		  continue;
	       pkgname = P.FullName();
	       break;
	    }
	 }
	 // that is a crossgrade
	 else if (installedInstances == 1 && wannabeInstances == 1 && candset.size() == 2)
	 {
	    auto const PkgHasCurrentVersion = [](pkgCache::PkgIterator const &P) { return P->CurrentVer != 0; };
	    auto const P = std::find_if(candset.begin(), candset.end(), PkgHasCurrentVersion);
	    if (unlikely(P == candset.end()))
	    {
	       if (Debug == true)
		  std::clog << "situation for '" << pkgname << "' looked like a crossgrade, but no current version?!" << std::endl;
	       return;
	    }
	    auto fullname = P->FullName();
	    if (PackageOps[fullname].size() != PackageOpsDone[fullname])
	       pkgname = std::move(fullname);
	    else
	       pkgname = std::find_if_not(candset.begin(), candset.end(), PkgHasCurrentVersion)->FullName();
	 }
	 // we are desperate: so "just" take the native one, but that might change mid-air,
	 // so we have to ask dpkg what it believes native is at the moment… all the time
	 else
	 {
	    std::vector<std::string> sArgs = debSystem::GetDpkgBaseCommand();
	    sArgs.push_back("--print-architecture");
	    int outputFd = -1;
	    pid_t const dpkgNativeArch = debSystem::ExecDpkg(sArgs, nullptr, &outputFd, true);
	    if (unlikely(dpkgNativeArch == -1))
	    {
	       if (Debug == true)
		  std::clog << "calling dpkg failed to ask it for its current native architecture to expand '" << pkgname << "'!" << std::endl;
	       return;
	    }
	    FILE *dpkg = fdopen(outputFd, "r");
	    if(dpkg != NULL)
	    {
	       char* buf = NULL;
	       size_t bufsize = 0;
	       if (getline(&buf, &bufsize, dpkg) != -1)
		  pkgname += ':' + bufsize;
	       free(buf);
	       fclose(dpkg);
	    }
	    ExecWait(dpkgNativeArch, "dpkg --print-architecture", true);
	    if (pkgname.find(':') != std::string::npos)
	    {
	       if (Debug == true)
		  std::clog << "unable to figure out which package is dpkg refering to with '" << pkgname << "'! (2)" << std::endl;
	       return;
	    }
	 }
      }
   }

   std::string arch = "";

@@ -690,10 +778,7 @@

   // 'processing: action: pkg'
   if(prefix == "processing")
   {
      const std::pair<const char *, const char *> * const iter =
	std::find_if(PackageProcessingOpsBegin,
		     PackageProcessingOpsEnd,
		     MatchProcessingOp(action.c_str()));
      auto const iter = std::find_if(PackageProcessingOpsBegin, PackageProcessingOpsEnd, MatchProcessingOp(action.c_str()));
      if(iter == PackageProcessingOpsEnd)
      {
	 if (Debug == true)

@@ -709,24 +794,15 @@

      //         short pkgnames?
      if (action == "disappear")
	 handleDisappearAction(pkgname);
      else if (action == "upgrade")
	 handleCrossUpgradeAction(pkgname);
      return;
   }

   if (prefix == "status")
   {
      std::vector<struct DpkgState> &states = PackageOps[pkgname];
      if (action == "triggers-pending")
      {
	 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())
      if(PackageOpsDone[pkgname] < states.size())
      {
	 char const * next_action = states[PackageOpsDone[pkgname]].state;
	 if (next_action)

@@ -763,36 +839,19 @@

	       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;

	       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;
			   }
			}
		  }
	       }
	    }
	 }
      }
      else if (action == "triggers-pending")
      {
	 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;
      }
   }
}
									/*}}}*/

@@ -803,6 +862,12 @@

   if (unlikely(Pkg.end() == true))
      return;

   // a disappeared package has no further actions
   auto const ROps = PackageOps[Pkg.FullName()].size();
   auto && ROpsDone = PackageOpsDone[Pkg.FullName()];
   PackagesDone += ROps - ROpsDone;
   ROpsDone = ROps;

   // record the package name for display and stuff later
   disappearedPkgs.insert(Pkg.FullName(true));


@@ -844,6 +909,38 @@

844	909		}
845	910		}
846	911		/}}}/
	912	+	void pkgDPkgPM::handleCrossUpgradeAction(string const &pkgname) /{{{/
	913	+	{
	914	+	// in a crossgrade what looked like a remove first is really an unpack over it
	915	+	auto const Pkg = Cache.FindPkg(pkgname);
	916	+	if (likely(Pkg.end() == false) && Cache[Pkg].Delete())
	917	+	{
	918	+	auto const Grp = Pkg.Group();
	919	+	if (likely(Grp.end() == false))
	920	+	{
	921	+	for (auto P = Grp.PackageList(); P.end() != true; P = Grp.NextPkg(P))
	922	+	if(Cache[P].Install())
	923	+	{
	924	+	auto && Ops = PackageOps[P.FullName()];
	925	+	auto const unpackOp = std::find_if(Ops.cbegin(), Ops.cend(), [](DpkgState const &s) { return strcmp(s.state, "unpacked") == 0; });
	926	+	if (unpackOp != Ops.cend())
	927	+	{
	928	+	// skip ahead in the crossgraded packages
	929	+	auto const skipped = std::distance(Ops.cbegin(), unpackOp);
	930	+	PackagesDone += skipped;
	931	+	PackageOpsDone[P.FullName()] += skipped;
	932	+	// finish the crossremoved package
	933	+	auto const ROps = PackageOps[Pkg.FullName()].size();
	934	+	auto && ROpsDone = PackageOpsDone[Pkg.FullName()];
	935	+	PackagesDone += ROps - ROpsDone;
	936	+	ROpsDone = ROps;
	937	+	break;
	938	+	}
	939	+	}
	940	+	}
	941	+	}
	942	+	}
	943	+	/}}}/
847	944		// DPkgPM::DoDpkgStatusFd /{{{/
848	945		void pkgDPkgPM::DoDpkgStatusFd(int statusfd)
849	946		{

@@ -1087,6 +1184,18 @@

	 ++PackagesTotal;
	 return true;
      });
      if ((I.Op == Item::Remove || I.Op == Item::Purge) && I.Pkg->CurrentVer != 0)
      {
	 if (I.Pkg->CurrentState == pkgCache::State::UnPacked ||
	       I.Pkg->CurrentState == pkgCache::State::HalfInstalled)
	 {
	    if (likely(strcmp(PackageOps[name][0].state, "half-configured") == 0))
	    {
	       ++PackageOpsDone[name];
	       --PackagesTotal;
	    }
	 }
      }
   }
   /* 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

@@ -1327,7 +1436,8 @@

	 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)
	 if (Pkg.State() == pkgCache::PkgIterator::NeedsConfigure &&
	       Cache[Pkg].Delete() == false && alreadyConfigured.insert(Pkg->ID).second == true)
	    AppendList.emplace_back(Item::Configure, Pkg);
      std::move(AppendList.begin(), AppendList.end(), std::back_inserter(List));
   }

@@ -1397,7 +1507,7 @@

	 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);
   unsigned int const dpkg_recursive_install_min = _config->FindI("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);


@@ -1428,11 +1538,30 @@

	    continue;

	 auto const Grp = I->Pkg.Group();
	 size_t installedInstances = 0;
	 size_t installedInstances = 0, wannabeInstances = 0;
	 bool multiArchInstances = false;
	 for (auto Pkg = Grp.PackageList(); Pkg.end() == false; Pkg = Grp.NextPkg(Pkg))
	    if (Pkg->CurrentVer != 0 || Cache[Pkg].Install())
	 {
	    if (Pkg->CurrentVer != 0)
	    {
	       ++installedInstances;
	 if (installedInstances == 2)
	       if (Cache[Pkg].Delete() == false)
		  ++wannabeInstances;
	    }
	    else if (PackageOps.find(Pkg.FullName()) != PackageOps.end())
	       ++wannabeInstances;
	    if (multiArchInstances == false)
	    {
	       auto const V = Cache[Pkg].InstVerIter(Cache);
	       if (V.end() == false && (Pkg->CurrentVer == 0 || V != Pkg.CurrentVer()))
		  multiArchInstances = ((V->MultiArch & pkgCache::Version::Same) == pkgCache::Version::Same);
	    }
	 }
	 /* theoretically the installed check would be enough as some wannabe will
	    be first and hence be the crossgrade we were looking for, but #844300
	    prevents this so we keep these situations explicit removes.
	    It is also the reason why neither of them can be a M-A:same package */
	 if (installedInstances == 1 && wannabeInstances == 1 && multiArchInstances == false)
	 {
	    auto const FirstInstall = std::find_if_not(I, List.end(),
		  [](Item const &i) { return i.Op == Item::Remove || i.Op == Item::Purge; });

@@ -1994,6 +2123,24 @@


   if (noopDPkgInvocation == false)
   {
      if (d->dpkg_error.empty() && (PackagesDone + 1) != PackagesTotal)
      {
	 std::string pkglist;
	 for (auto const &PO: PackageOps)
	    if (PO.second.size() != PackageOpsDone[PO.first])
	    {
	       if (pkglist.empty() == false)
		  pkglist.append(" ");
	       pkglist.append(PO.first);
	    }
	 /* who cares about correct progress? As we depend on it for skipping actions
	    our parsing should be correct. People will no doubt be confused if they see
	    this message, but the dpkg warning about unknown packages isn't much better
	    from a user POV and combined we might have a chance to figure out what is wrong */
	 _error->Warning("APT had planned for dpkg to do more than it reported back (%u vs %u).\n"
	       "Affected packages: %s", PackagesDone, PackagesTotal, pkglist.c_str());
      }

      std::string const oldpkgcache = _config->FindFile("Dir::cache::pkgcache");
      if (oldpkgcache.empty() == false && RealFileExists(oldpkgcache) == true &&
	  RemoveFile("pkgDPkgPM::Go", oldpkgcache))

@@ -2000 +2147 @@

@@ -931,14 +931,18 @@

}
									/*}}}*/
// EDSP::WriteError - format an error message to be send to file descriptor /*{{{*/
static std::string formatMessage(std::string const &msg)
{
	return SubstVar(SubstVar(APT::String::Strip(msg), "\n\n", "\n.\n"), "\n", "\n ");
}
bool EDSP::WriteError(char const * const uuid, std::string const &message, FILE* output) {
	fprintf(output, "Error: %s\n", uuid);
	fprintf(output, "Message: %s\n\n", SubstVar(SubstVar(message, "\n\n", "\n.\n"), "\n", "\n ").c_str());
	fprintf(output, "Message: %s\n\n", formatMessage(message).c_str());
	return true;
}
bool EDSP::WriteError(char const * const uuid, std::string const &message, FileFd &output) {
	return WriteOkay(output, "Error: ", uuid, "\n",
	      "Message: ", SubstVar(SubstVar(message, "\n\n", "\n.\n"), "\n", "\n "),
	      "Message: ", formatMessage(message),
	      "\n\n");
}
									/*}}}*/

@@ -945 +949 @@

@@ -662,12 +662,14 @@

	 FileFd inp, out;
	 if (inp.Open(Path, FileFd::ReadOnly, FileFd::Extension) == false)
	 {
	    std::cerr << "FAILED to open inp " << Path << std::endl;
	    if (Debug == true)
	       std::clog << "FAILED to open inp " << Path << std::endl;
	    return _error->Error("Failed to open inp %s", Path.c_str());
	 }
	 if (out.Open(Itm->DestFile, FileFd::WriteOnly | FileFd::Create | FileFd::Empty | FileFd::BufferedWrite, FileFd::Extension) == false)
	 {
	    std::cerr << "FAILED to open out " << Itm->DestFile << std::endl;
	    if (Debug == true)
	       std::clog << "FAILED to open out " << Itm->DestFile << std::endl;
	    return _error->Error("Failed to open out %s", Itm->DestFile.c_str());
	 }


@@ -686,7 +688,8 @@

	 inp.Close();

	 if (_error->PendingError() == true) {
	    std::cerr << "FAILED to read or write files" << std::endl;
	    if (Debug == true)
	       std::clog << "FAILED to read or write files" << std::endl;
	    return false;
	 }


@@ -693 +696 @@

@@ -367,7 +367,7 @@

   }

   CacheFile Cache;
   if (Cache.Open() == false)
   if (Cache.Open(false) == false)
      return false;

   LogCleaner Cleaner;

@@ -374 +374 @@

@@ -2778,9 +2778,9 @@

   return result;
}
									/*}}}*/
std::string GetTempDir()						/*{{{*/
static std::string APT_NONNULL(1) GetTempDirEnv(char const * const env)	/*{{{*/
{
   const char *tmpdir = getenv("TMPDIR");
   const char *tmpdir = getenv(env);

#ifdef P_tmpdir
   if (!tmpdir)

@@ -2792,10 +2792,15 @@

	 stat(tmpdir, &st) != 0 || (st.st_mode & S_IFDIR) == 0) // exists and is directory
      tmpdir = "/tmp";
   else if (geteuid() != 0 && // root can do everything anyway
	 faccessat(-1, tmpdir, R_OK | W_OK | X_OK, AT_EACCESS | AT_SYMLINK_NOFOLLOW) != 0) // current user has rwx access to directory
	 faccessat(AT_FDCWD, tmpdir, R_OK | W_OK | X_OK, AT_EACCESS) != 0) // current user has rwx access to directory
      tmpdir = "/tmp";

   return string(tmpdir);
}
									/*}}}*/
std::string GetTempDir()						/*{{{*/
{
   return GetTempDirEnv("TMPDIR");
}
std::string GetTempDir(std::string const &User)
{

@@ -3051,6 +3056,32 @@

3051	3056		return _error->Error("Could restore a uid to root, privilege dropping did not work");
3052	3057		}
3053	3058
	3059	+	if (_config->FindB("APT::Sandbox::ResetEnvironment", true))
	3060	+	{
	3061	+	setenv("HOME", pw->pw_dir, 1);
	3062	+	setenv("USER", pw->pw_name, 1);
	3063	+	setenv("USERNAME", pw->pw_name, 1);
	3064	+	setenv("LOGNAME", pw->pw_name, 1);
	3065	+	auto const shell = flNotDir(pw->pw_shell);
	3066	+	if (shell == "false" \|\| shell == "nologin")
	3067	+	setenv("SHELL", "/bin/sh", 1);
	3068	+	else
	3069	+	setenv("SHELL", pw->pw_shell, 1);
	3070	+	auto const apt_setenv_tmp = [](char const * const env) {
	3071	+	auto const tmpdir = getenv(env);
	3072	+	if (tmpdir != nullptr)
	3073	+	{
	3074	+	auto const ourtmpdir = GetTempDirEnv(env);
	3075	+	if (ourtmpdir != tmpdir)
	3076	+	setenv(env, ourtmpdir.c_str(), 1);
	3077	+	}
	3078	+	};
	3079	+	apt_setenv_tmp("TMPDIR");
	3080	+	apt_setenv_tmp("TEMPDIR");
	3081	+	apt_setenv_tmp("TMP");
	3082	+	apt_setenv_tmp("TEMP");
	3083	+	}
	3084	+
3054	3085		return true;
3055	3086		}
3056	3087		/}}}/

@@ -3057 +3088 @@

@@ -779,7 +779,7 @@

 */
class APT_HIDDEN pkgAcqIndexMergeDiffs : public pkgAcqBaseIndex
{
   void * const d;
   std::string const indexURI;

   protected:


@@ -830,23 +830,19 @@

   /** \brief Create an index merge-diff item.
    *
    *  \param Owner The pkgAcquire object that owns this item.
    *
    *  \param URI The URI of the package index file being
    *  reconstructed.
    *
    *  \param URIDesc A long description of this item.
    *
    *  \param ShortDesc A brief description of this item.
    *
    *  \param TransactionManager responsible for this item
    *  \param Target we intend to built via pdiff patching
    *  \param baseURI is the URI used for the Index, but stripped down to Target
    *  \param DiffInfo of the patch in question
    *  \param patch contains infos about the patch this item is supposed
    *  to download which were read from the index
    *
    *  \param allPatches contains all related items so that each item can
    *  check if it was the last one to complete the download step
    */
   pkgAcqIndexMergeDiffs(pkgAcquire * const Owner, pkgAcqMetaClearSig * const TransactionManager,
                         IndexTarget const &Target, DiffInfo const &patch,
                         std::vector<pkgAcqIndexMergeDiffs*> const * const allPatches) APT_NONNULL(2, 3, 6);
			 IndexTarget const &Target, std::string const &indexUsedMirror,
			 std::string const &indexURI, DiffInfo const &patch,
                         std::vector<pkgAcqIndexMergeDiffs*> const * const allPatches) APT_NONNULL(2, 3, 8);
   virtual ~pkgAcqIndexMergeDiffs();
};
									/*}}}*/

@@ -863,7 +859,7 @@

 */
class APT_HIDDEN pkgAcqIndexDiffs : public pkgAcqBaseIndex
{
   void * const d;
   std::string const indexURI;

   private:


@@ -943,20 +939,16 @@

    *  \a diffs is empty, or QueueNextDiff() otherwise.
    *
    *  \param Owner The pkgAcquire object that owns this item.
    *
    *  \param URI The URI of the package index file being
    *  reconstructed.
    *
    *  \param URIDesc A long description of this item.
    *
    *  \param ShortDesc A brief description of this item.
    *
    *  \param TransactionManager responsible for this item
    *  \param Target we want to built via pdiff patching
    *  \param baseURI is the URI used for the Index, but stripped down to Target
    *  \param diffs The remaining diffs from the index of diffs.  They
    *  should be ordered so that each diff appears before any diff
    *  that depends on it.
    */
   pkgAcqIndexDiffs(pkgAcquire * const Owner, pkgAcqMetaClearSig * const TransactionManager,
                    IndexTarget const &Target,
		    std::string const &indexUsedMirror, std::string const &indexURI,
		    std::vector<DiffInfo> const &diffs=std::vector<DiffInfo>()) APT_NONNULL(2, 3);
   virtual ~pkgAcqIndexDiffs();
};

@@ -963 +955 @@

@@ -136,16 +136,19 @@

       _error->PendingError() == true)
      return false;

   if (_config->FindB("APT::Get::Fix-Missing",false) == true &&
	 _config->FindB("APT::Get::Download",true) == false)
   if (_config->FindB("APT::Get::Download",true) == false)
   {
      bool Missing = false;
      RemoveDownloadNeedingItemsFromFetcher(Fetcher, Missing);
      if (Missing)
	 PM->FixMissing();
      {
	 if (_config->FindB("APT::Get::Fix-Missing",false))
	    PM->FixMissing();
	 else
	    return _error->Error(_("Unable to fetch some archives, maybe run apt-get update or try with --fix-missing?"));
      }
      Fetcher.Shutdown();
      if (PM->GetArchives(&Fetcher,List,&Recs) == false ||
	    _error->PendingError() == true)
      if (_error->PendingError() == true)
	 return false;
   }


@@ -396,7 +399,7 @@

/* Remove unused automatic packages */
bool DoAutomaticRemove(CacheFile &Cache)
{
   bool Debug = _config->FindI("Debug::pkgAutoRemove",false);
   bool Debug = _config->FindB("Debug::pkgAutoRemove",false);
   bool doAutoRemove = _config->FindB("APT::Get::AutomaticRemove", false);
   bool hideAutoRemove = _config->FindB("APT::Get::HideAutoRemove");


@@ -426,11 +429,11 @@

      {
	 if(Pkg.CurrentVer() != 0 || Cache[Pkg].Install())
	    if(Debug)
	       std::cout << "We could delete %s" <<  Pkg.FullName(true).c_str() << std::endl;
	       std::cout << "We could delete " <<  APT::PrettyPkg(Cache, Pkg) << std::endl;

	 if (doAutoRemove)
	 {
	    if(Pkg.CurrentVer() != 0 && 
	    if(Pkg.CurrentVer() != 0 &&
	       Pkg->CurrentState != pkgCache::State::ConfigFiles)
	       Cache->MarkDelete(Pkg, purgePkgs, 0, false);
	    else

@@ -475,11 +478,25 @@

		  if (R.IsNegative() == true ||
		      Cache->IsImportantDep(R) == false)
		     continue;
		 pkgCache::PkgIterator N = R.ParentPkg();
		 if (N.end() == true || (N->CurrentVer == 0 && (*Cache)[N].Install() == false))
		 auto const RV = R.ParentVer();
		 if (unlikely(RV.end() == true))
		    continue;
		 auto const RP = RV.ParentPkg();
		 // check if that dependency comes from an interesting version
		 if (RP.CurrentVer() == RV)
		 {
		    if ((*Cache)[RP].Keep() == false)
		       continue;
		 }
		 else if (Cache[RP].CandidateVerIter(Cache) == RV)
		 {
		    if ((*Cache)[RP].NewInstall() == false && (*Cache)[RP].Upgrade() == false)
		       continue;
		 }
		 else // ignore dependency from a non-candidate version
		    continue;
		 if (Debug == true)
		    std::clog << "Save " << APT::PrettyPkg(Cache, Pkg) << " as another installed garbage package depends on it" << std::endl;
		    std::clog << "Save " << APT::PrettyPkg(Cache, Pkg) << " as another installed package depends on it: " << APT::PrettyPkg(Cache, RP) << std::endl;
		 Cache->MarkInstall(Pkg, false, 0, false);
		 if (hideAutoRemove == false)
		    ++autoRemoveCount;

@@ -495,6 +512,8 @@

	 }
      } while (Changed == true);
   }
   // trigger marking now so that the package list below is correct
   group.release();

   // Now see if we had destroyed anything (if we had done anything)
   if (Cache->BrokenCount() != 0)

@@ -501 +520 @@

@@ -71,19 +71,19 @@

      ListUpdate(Stat, *List);
   }

   if (_config->FindB("pkgCacheFile::Generate", true) == false)
      return true;

   // Rebuild the cache.
   if (_config->FindB("pkgCacheFile::Generate", true) == true)
   {
      pkgCacheFile::RemoveCaches();
      if (Cache.BuildCaches() == false)
	 return false;
   }
   pkgCacheFile::RemoveCaches();
   if (Cache.BuildCaches(false) == false)
      return false;

   // show basic stats (if the user whishes)
   if (_config->FindB("APT::Cmd::Show-Update-Stats", false) == true)
   {
      int upgradable = 0;
      if (Cache.Open() == false)
      if (Cache.Open(false) == false)
         return false;
      for (pkgCache::PkgIterator I = Cache->PkgBegin(); I.end() != true; ++I)
      {

@@ -90 +90 @@

@@ -495,7 +495,7 @@

      return _error->Error(_("Failed to fetch some archives."));
   }

   if (_config->FindB("APT::Get::Download-only",false) == true)
   if (diffOnly || tarOnly || dscOnly || _config->FindB("APT::Get::Download-only",false) == true)
   {
      c1out << _("Download complete and in download only mode") << std::endl;
      return true;

@@ -509,13 +509,9 @@

      bool const fixBroken = _config->FindB("APT::Get::Fix-Broken", false);
      for (unsigned I = 0; I != J; ++I)
      {
	 std::string Dir = Dsc[I].Package + '-' + Cache.GetPkgCache()->VS->UpstreamVersion(Dsc[I].Version.c_str());

	 // Diff only mode only fetches .diff files
	 if (_config->FindB("APT::Get::Diff-Only",false) == true ||
	       _config->FindB("APT::Get::Tar-Only",false) == true ||
	       Dsc[I].Dsc.empty() == true)
	 if (unlikely(Dsc[I].Dsc.empty() == true))
	    continue;
	 std::string const Dir = Dsc[I].Package + '-' + Cache.GetPkgCache()->VS->UpstreamVersion(Dsc[I].Version.c_str());

	 // See if the package is already unpacked
	 struct stat Stat;

@@ -522 +518 @@

@@ -117,6 +117,12 @@

   if (chmod(partial.c_str(), 0700) != 0)
      _error->WarningE("SetupAPTPartialDirectory", "chmod 0700 of directory %s failed", partial.c_str());

   _error->PushToStack();
   // remove 'old' FAILED files to stop us from collecting them for no reason
   for (auto const &Failed: GetListOfFilesInDir(partial, "FAILED", false, false))
      RemoveFile("SetupAPTPartialDirectory", Failed);
   _error->RevertToStack();

   return true;
}
bool pkgAcquire::Setup(pkgAcquireStatus *Progress, string const &Lock)

@@ -894,11 +900,27 @@

/* */
bool pkgAcquire::Queue::Enqueue(ItemDesc &Item)
{
   // MetaKeysMatch checks whether the two items have no non-matching
   // meta-keys. If the items are not transaction items, it returns
   // true, so other items can still be merged.
   auto MetaKeysMatch = [](pkgAcquire::ItemDesc const &A, pkgAcquire::Queue::QItem const *B) {
      auto OwnerA = dynamic_cast<pkgAcqTransactionItem*>(A.Owner);
      if (OwnerA == nullptr)
	 return true;

      for (auto const & OwnerBUncast : B->Owners) {
	 auto OwnerB = dynamic_cast<pkgAcqTransactionItem*>(OwnerBUncast);

	 if (OwnerB != nullptr && OwnerA->GetMetaKey() != OwnerB->GetMetaKey())
	    return false;
      }
      return true;
   };
   QItem **OptimalI = &Items;
   QItem **I = &Items;
   // move to the end of the queue and check for duplicates here
   for (; *I != 0; ) {
      if (Item.URI == (*I)->URI)
      if (Item.URI == (*I)->URI && MetaKeysMatch(Item, *I))
      {
	 if (_config->FindB("Debug::pkgAcquire::Worker",false) == true)
	    std::cerr << " @ Queue: Action combined for " << Item.URI << " and " << (*I)->URI << std::endl;

@@ -1154,7 +1176,7 @@

   return Maximum;
}
									/*}}}*/
APT_PURE int pkgAcquire::Queue::QItem::GetPriority() const	/*{{{*/
APT_PURE int pkgAcquire::Queue::QItem::GetPriority() const		/*{{{*/
{
   int Priority = 0;
   for (auto const &O: Owners)

@@ -1161 +1183 @@

@@ -1363,41 +1363,43 @@

   ScopedErrorRevert() { _error->PushToStack(); }
   ~ScopedErrorRevert() { _error->RevertToStack(); }
};
static bool CheckValidity(const string &CacheFile,
static bool CheckValidity(FileFd &CacheFile, std::string const &CacheFileName,
                          pkgSourceList &List,
                          FileIterator const Start,
                          FileIterator const End,
                          MMap **OutMap = 0,
			  pkgCache **OutCache = 0)
{
   if (CacheFileName.empty())
      return false;
   ScopedErrorRevert ser;

   bool const Debug = _config->FindB("Debug::pkgCacheGen", false);
   // No file, certainly invalid
   if (CacheFile.empty() == true || FileExists(CacheFile) == false)
   if (CacheFile.Open(CacheFileName, FileFd::ReadOnly, FileFd::None) == false)
   {
      if (Debug == true)
	 std::clog << "CacheFile " << CacheFile << " doesn't exist" << std::endl;
	 std::clog << "CacheFile " << CacheFileName << " doesn't exist" << std::endl;
      return false;
   }

   if (List.GetLastModifiedTime() > GetModificationTime(CacheFile))
   if (List.GetLastModifiedTime() > CacheFile.ModificationTime())
   {
      if (Debug == true)
	 std::clog << "sources.list is newer than the cache" << std::endl;
      return false;
   }

   // Map it
   FileFd CacheF(CacheFile,FileFd::ReadOnly);
   std::unique_ptr<MMap> Map(new MMap(CacheF,0));
   std::unique_ptr<MMap> Map(new MMap(CacheFile,0));
   if (unlikely(Map->validData()) == false)
      return false;
   std::unique_ptr<pkgCache> CacheP(new pkgCache(Map.get()));
   pkgCache &Cache = *CacheP.get();
   if (_error->PendingError() || Map->Size() == 0)
   {
      if (Debug == true)
	 std::clog << "Errors are pending or Map is empty() for " << CacheFile << std::endl;
	 std::clog << "Errors are pending or Map is empty() for " << CacheFileName << std::endl;
      return false;
   }


@@ -1623,13 +1625,12 @@

   return true;
}
static bool loadBackMMapFromFile(std::unique_ptr<pkgCacheGenerator> &Gen,
      std::unique_ptr<DynamicMMap> &Map, OpProgress * const Progress, std::string const &FileName)
      std::unique_ptr<DynamicMMap> &Map, OpProgress * const Progress, FileFd &CacheF)
{
   Map.reset(CreateDynamicMMap(NULL, 0));
   if (unlikely(Map->validData()) == false)
      return false;
   FileFd CacheF(FileName, FileFd::ReadOnly);
   if (CacheF.IsOpen() == false || CacheF.Failed())
   if (CacheF.IsOpen() == false || CacheF.Seek(0) == false || CacheF.Failed())
      return false;
   _error->PushToStack();
   map_pointer_t const alloc = Map->RawAllocate(CacheF.Size());

@@ -1661,20 +1662,20 @@

      return false;

   // Decide if we can write to the files..
   string const CacheFile = _config->FindFile("Dir::Cache::pkgcache");
   string const SrcCacheFile = _config->FindFile("Dir::Cache::srcpkgcache");
   string const CacheFileName = _config->FindFile("Dir::Cache::pkgcache");
   string const SrcCacheFileName = _config->FindFile("Dir::Cache::srcpkgcache");

   // ensure the cache directory exists
   if (CacheFile.empty() == false || SrcCacheFile.empty() == false)
   if (CacheFileName.empty() == false || SrcCacheFileName.empty() == false)
   {
      string dir = _config->FindDir("Dir::Cache");
      size_t const len = dir.size();
      if (len > 5 && dir.find("/apt/", len - 6, 5) == len - 5)
	 dir = dir.substr(0, len - 5);
      if (CacheFile.empty() == false)
	 CreateDirectory(dir, flNotFile(CacheFile));
      if (SrcCacheFile.empty() == false)
	 CreateDirectory(dir, flNotFile(SrcCacheFile));
      if (CacheFileName.empty() == false)
	 CreateDirectory(dir, flNotFile(CacheFileName));
      if (SrcCacheFileName.empty() == false)
	 CreateDirectory(dir, flNotFile(SrcCacheFileName));
   }

   if (Progress != NULL)

@@ -1683,18 +1684,20 @@

   bool pkgcache_fine = false;
   bool srcpkgcache_fine = false;
   bool volatile_fine = List.GetVolatileFiles().empty();

   if (CheckValidity(CacheFile, List, Files.begin(), Files.end(), volatile_fine ? OutMap : NULL,
   FileFd CacheFile;
   if (CheckValidity(CacheFile, CacheFileName, List, Files.begin(), Files.end(), volatile_fine ? OutMap : NULL,
		     volatile_fine ? OutCache : NULL) == true)
   {
      if (Debug == true)
	 std::clog << "pkgcache.bin is valid - no need to build any cache" << std::endl;
      pkgcache_fine = true;
      srcpkgcache_fine = true;
   }

   FileFd SrcCacheFile;
   if (pkgcache_fine == false)
   {
      if (CheckValidity(SrcCacheFile, List, Files.end(), Files.end()) == true)
      if (CheckValidity(SrcCacheFile, SrcCacheFileName, List, Files.end(), Files.end()) == true)
      {
	 if (Debug == true)
	    std::clog << "srcpkgcache.bin is valid - it can be reused" << std::endl;

@@ -1712,10 +1715,10 @@

   bool Writeable = false;
   if (srcpkgcache_fine == false || pkgcache_fine == false)
   {
      if (CacheFile.empty() == false)
	 Writeable = access(flNotFile(CacheFile).c_str(),W_OK) == 0;
      else if (SrcCacheFile.empty() == false)
	 Writeable = access(flNotFile(SrcCacheFile).c_str(),W_OK) == 0;
      if (CacheFileName.empty() == false)
	 Writeable = access(flNotFile(CacheFileName).c_str(),W_OK) == 0;
      else if (SrcCacheFileName.empty() == false)
	 Writeable = access(flNotFile(SrcCacheFileName).c_str(),W_OK) == 0;

      if (Debug == true)
	 std::clog << "Do we have write-access to the cache files? " << (Writeable ? "YES" : "NO") << std::endl;

@@ -1754,8 +1757,8 @@

	       Files.end(),Files.end()) == false)
	 return false;

      if (Writeable == true && SrcCacheFile.empty() == false)
	 if (writeBackMMapToFile(Gen.get(), Map.get(), SrcCacheFile) == false)
      if (Writeable == true && SrcCacheFileName.empty() == false)
	 if (writeBackMMapToFile(Gen.get(), Map.get(), SrcCacheFileName) == false)
	    return false;
   }


@@ -1767,8 +1770,8 @@

	       Files.begin(), Files.end()) == false)
	 return false;

      if (Writeable == true && CacheFile.empty() == false)
	 if (writeBackMMapToFile(Gen.get(), Map.get(), CacheFile) == false)
      if (Writeable == true && CacheFileName.empty() == false)
	 if (writeBackMMapToFile(Gen.get(), Map.get(), CacheFileName) == false)
	    return false;
   }


@@ -1775 +1778 @@

@@ -180,7 +180,11 @@

      return true;
   }

   if (stringcasecmp(Tag,"Content-Range:") == 0)
   // The Content-Range field only has a meaning in HTTP/1.1 for the
   // 206 (Partial Content) and 416 (Range Not Satisfiable) responses
   // according to RFC7233 "Range Requests", §4.2, so only consider it
   // for such responses.
   if ((Result == 416 || Result == 206) && stringcasecmp(Tag,"Content-Range:") == 0)
   {
      HaveContent = true;


@@ -770,8 +774,8 @@

	 // We need to flush the data, the header is like a 404 w/ error text
	 case ERROR_WITH_CONTENT_PAGE:
	 {
	    Fail();
	    Server->RunDataToDevNull();
	    Fail();
	    break;
	 }


@@ -778 +782 @@

@@ -1144,7 +1144,7 @@

   pkgCache::PkgIterator I = Cache.PkgBegin();
   for (;I.end() != true; ++I) {
      if (Cache[I].NewInstall() && !(Flags[I->ID] & PreInstalled)) {
	 if(_config->FindI("Debug::pkgAutoRemove",false)) {
	 if(_config->FindB("Debug::pkgAutoRemove",false)) {
	    std::clog << "Resolve installed new pkg: " << I.FullName(false) 
		      << " (now marking it as auto)" << std::endl;
	 }

@@ -1151 +1151 @@

@@ -1101,8 +1101,11 @@

      UseByHash = _config->Find("Acquire::By-Hash", UseByHash);
      {
	 std::string const host = ::URI(URI).Host;
	 UseByHash = _config->Find("APT::Acquire::" + host + "::By-Hash", UseByHash);
	 UseByHash = _config->Find("Acquire::" + host + "::By-Hash", UseByHash);
	 if (host.empty() == false)
	 {
	    UseByHash = _config->Find("APT::Acquire::" + host + "::By-Hash", UseByHash);
	    UseByHash = _config->Find("Acquire::" + host + "::By-Hash", UseByHash);
	 }
	 std::map<std::string, std::string>::const_iterator const opt = Options.find("by-hash");
	 if (opt != Options.end())
	    UseByHash = opt->second;

@@ -1109 +1112 @@

@@ -61,8 +61,19 @@

   string Result = Section.Find("Package").to_string();

   // Normalize mixed case package names to lower case, like dpkg does
   // See Bug#807012 for details
   std::transform(Result.begin(), Result.end(), Result.begin(), tolower_ascii);
   // See Bug#807012 for details.
   // Only do this when the package name does not contain a / - as that
   // indicates that the package name was derived from a filename given
   // to install or build-dep or similar (Bug#854794)
   if (likely(Result.find('/') == string::npos))
   {
      for (char &c: Result)
      {
	 char l = tolower_ascii_inline(c);
	 if (unlikely(l != c))
	    c = l;
      }
   }

   if(unlikely(Result.empty() == true))
      _error->Error("Encountered a section with no Package: header");

@@ -69 +80 @@

@@ -365,6 +365,11 @@

   curl_easy_setopt(curl, CURLOPT_LOW_SPEED_LIMIT, DL_MIN_SPEED);
   curl_easy_setopt(curl, CURLOPT_LOW_SPEED_TIME, timeout);

   if(_config->FindB("Acquire::ForceIPv4", false) == true)
      curl_easy_setopt(curl, CURLOPT_IPRESOLVE, CURL_IPRESOLVE_V4);
   else if(_config->FindB("Acquire::ForceIPv6", false) == true)
      curl_easy_setopt(curl, CURLOPT_IPRESOLVE, CURL_IPRESOLVE_V6);

   // debug
   if (Debug == true)
      curl_easy_setopt(curl, CURLOPT_VERBOSE, true);

@@ -371 +376 @@

Learn more Showing 16 files with coverage changes found.

Changes in apt-pkg/acquire-method.cc

-5

→

Loading file...

Changes in apt-pkg/cacheiterators.h

-1

→

Loading file...

Changes in apt-pkg/deb/debmetaindex.cc

-2

→

Loading file...

Changes in apt-private/private-source.cc

-1

→

Loading file...

Changes in apt-pkg/contrib/fileutl.cc

-2

→

Loading file...

Changes in apt-pkg/contrib/strutl.cc

-1

→

Loading file...

methods/file.cc

Loading file...

Changes in apt-private/private-install.cc

-2

→

Loading file...

Changes in methods/connect.cc

-1

→

Loading file...

Changes in apt-private/private-moo.cc

-1

→

Loading file...

Changes in methods/http.cc

-21

→

+21

Loading file...

Changes in methods/gpgv.cc

-10

→

+11

Loading file...

Changes in methods/aptmethod.h

-4

→

Loading file...

Changes in methods/https.cc

-19

→

+19

Loading file...

Changes in methods/server.cc

-33

→

+33

Loading file...

Changes in methods/server.h

-1

→

Loading file...

Hiding 30 contexual commits

77.24% 100.00% ø

http: clear content before reporting the failure

efuss

38667e0

CI Passed

Files		•	•	•	Coverage
apt-inst	ø	ø	ø	ø	23.56%
apt-pkg	+151	+88	ø	+63	^-0.14% 78.12%
apt-private	+8	+10	ø	-2	^0.09% 85.86%
cmdline	ø	ø	ø	ø	84.90%
ftparchive	ø	ø	ø	ø	74.93%
methods	-46	+50	ø	-96	^+3.26% 60.64%
test	ø	ø	ø	ø	84.18%
Project Totals (196 files)	35,901	27,733	154	8,014	77.24%

1018	1018		return false;
1019	1019		}
1020	1020		/}}}/
1021		-
1022		-	/}}}/
1023		-	int pkgAcquire::Item::Priority() /{{{/
	1021	+	int pkgAcquire::Item::Priority() /{{{/
1024	1022		{
1025	1023		// Stage 1: Meta indices and diff indices
1026	1024		// - those need to be fetched first to have progress reporting working

1925	1923		}
1926	1924		else if(MetaIndex->CheckAuthDone(Message) == true)
1927	1925		{
1928		-	if (TransactionManager->IMSHit == false)
	1926	+	auto const Releasegpg = GetFinalFilename();
	1927	+	auto const Release = MetaIndex->GetFinalFilename();
	1928	+	// if this is an IMS-Hit on Release ensure we also have the the Release.gpg file stored
	1929	+	// (previously an unknown pubkey) – but only if the Release file exists locally (unlikely
	1930	+	// event of InRelease removed from the mirror causing fallback but still an IMS-Hit)
	1931	+	if (TransactionManager->IMSHit == false \|\|
	1932	+	(FileExists(Releasegpg) == false && FileExists(Release) == true))
1929	1933		{
1930		-	TransactionManager->TransactionStageCopy(this, DestFile, GetFinalFilename());
1931		-	TransactionManager->TransactionStageCopy(MetaIndex, MetaIndex->DestFile, MetaIndex->GetFinalFilename());
	1934	+	TransactionManager->TransactionStageCopy(this, DestFile, Releasegpg);
	1935	+	TransactionManager->TransactionStageCopy(MetaIndex, MetaIndex->DestFile, Release);
1932	1936		}
1933	1937		}
1934	1938		else if (MetaIndex->Status != StatAuthError)

2051	2055		{
2052	2056		// list cleanup needs to know that this file as well as the already
2053	2057		// present index is ours, so we create an empty diff to save it for us
2054		-	new pkgAcqIndexDiffs(Owner, TransactionManager, Target);
	2058	+	new pkgAcqIndexDiffs(Owner, TransactionManager, Target, UsedMirror, Target.URI);
2055	2059		}
2056	2060		/}}}/
2057	2061		static bool RemoveFileForBootstrapLinking(bool const Debug, std::string const &For, std::string const &Boot)/{{{/

2427	2431		}
2428	2432		}
2429	2433
	2434	+	std::string indexURI = Desc.URI;
	2435	+	auto const byhashidx = indexURI.find("/by-hash/");
	2436	+	if (byhashidx != std::string::npos)
	2437	+	indexURI = indexURI.substr(0, byhashidx - strlen(".diff"));
	2438	+	else
	2439	+	{
	2440	+	auto end = indexURI.length() - strlen(".diff/Index");
	2441	+	if (CurrentCompressionExtension != "uncompressed")
	2442	+	end -= (1 + CurrentCompressionExtension.length());
	2443	+	indexURI = indexURI.substr(0, end);
	2444	+	}
	2445	+
2430	2446		if (pdiff_merge == false)
2431		-	new pkgAcqIndexDiffs(Owner, TransactionManager, Target, available_patches);
	2447	+	new pkgAcqIndexDiffs(Owner, TransactionManager, Target, UsedMirror, indexURI, available_patches);
2432	2448		else
2433	2449		{
2434	2450		diffs = new std::vector<pkgAcqIndexMergeDiffs*>(available_patches.size());
2435	2451		for(size_t i = 0; i < available_patches.size(); ++i)
2436	2452		(*diffs)[i] = new pkgAcqIndexMergeDiffs(Owner, TransactionManager,
2437		-	Target,
	2453	+	Target, UsedMirror, indexURI,
2438	2454		available_patches[i],
2439	2455		diffs);
2440	2456		}

2504	2520		pkgAcqIndexDiffs::pkgAcqIndexDiffs(pkgAcquire * const Owner,
2505	2521		pkgAcqMetaClearSig * const TransactionManager,
2506	2522		IndexTarget const &Target,
	2523	+	std::string const &indexUsedMirror, std::string const &indexURI,
2507	2524		vector<DiffInfo> const &diffs)
2508		-	: pkgAcqBaseIndex(Owner, TransactionManager, Target), d(NULL),
	2525	+	: pkgAcqBaseIndex(Owner, TransactionManager, Target), indexURI(indexURI),
2509	2526		available_patches(diffs)
2510	2527		{
2511	2528		DestFile = GetKeepCompressedFileName(GetPartialFileNameFromURI(Target.URI), Target);

Compare `15f32c4 ... +34 ... e5f9d66`

No flags found

Show failed CI and contexual commits `c`

36 Commits

2516	2533		Description = Target.Description;
2517	2534		Desc.ShortDesc = Target.ShortDesc;
2518	2535
	2536	+	UsedMirror = indexUsedMirror;
	2537	+	if (UsedMirror == "DIRECT")
	2538	+	UsedMirror.clear();
	2539	+	else if (UsedMirror.empty() == false && Description.find(" ") != string::npos)
	2540	+	Description.replace(0, Description.find(" "), UsedMirror);
	2541	+
2519	2542		if(available_patches.empty() == true)
2520	2543		{
2521	2544		// we are done (yeah!), check hashes against the final file

2630	2653		}
2631	2654
2632	2655		// queue the right diff
2633		-	Desc.URI = Target.URI + ".diff/" + available_patches[0].file + ".gz";
	2656	+	Desc.URI = indexURI + ".diff/" + available_patches[0].file + ".gz";
2634	2657		Desc.Description = Description + " " + available_patches[0].file + string(".pdiff");
2635	2658		DestFile = GetKeepCompressedFileName(GetPartialFileNameFromURI(Target.URI + ".diff/" + available_patches[0].file), Target);
2636	2659

2683	2706		// see if there is more to download
2684	2707		if(available_patches.empty() == false)
2685	2708		{
2686		-	new pkgAcqIndexDiffs(Owner, TransactionManager, Target, available_patches);
	2709	+	new pkgAcqIndexDiffs(Owner, TransactionManager, Target, UsedMirror, indexURI, available_patches);
2687	2710		Finish();
2688	2711		} else {
2689	2712		DestFile = PatchedFile;

2712	2735		pkgAcqIndexMergeDiffs::pkgAcqIndexMergeDiffs(pkgAcquire * const Owner,
2713	2736		pkgAcqMetaClearSig * const TransactionManager,
2714	2737		IndexTarget const &Target,
	2738	+	std::string const &indexUsedMirror, std::string const &indexURI,
2715	2739		DiffInfo const &patch,
2716	2740		std::vector<pkgAcqIndexMergeDiffs> const const allPatches)
2717		-	: pkgAcqBaseIndex(Owner, TransactionManager, Target), d(NULL),
2718		-	patch(patch), allPatches(allPatches), State(StateFetchDiff)
	2741	+	: pkgAcqBaseIndex(Owner, TransactionManager, Target), indexURI(indexURI),
	2742	+	patch(patch), allPatches(allPatches), State(StateFetchDiff)
2719	2743		{
2720	2744		Debug = _config->FindB("Debug::pkgAcquire::Diffs",false);
2721	2745
2722		-	Desc.Owner = this;
2723	2746		Description = Target.Description;
	2747	+	UsedMirror = indexUsedMirror;
	2748	+	if (UsedMirror == "DIRECT")
	2749	+	UsedMirror.clear();
	2750	+	else if (UsedMirror.empty() == false && Description.find(" ") != string::npos)
	2751	+	Description.replace(0, Description.find(" "), UsedMirror);
	2752	+
	2753	+	Desc.Owner = this;
2724	2754		Desc.ShortDesc = Target.ShortDesc;
2725		-	Desc.URI = Target.URI + ".diff/" + patch.file + ".gz";
	2755	+	Desc.URI = indexURI + ".diff/" + patch.file + ".gz";
2726	2756		Desc.Description = Description + " " + patch.file + ".pdiff";
2727		-	DestFile = GetPartialFileNameFromURI(Desc.URI);
	2757	+	DestFile = GetPartialFileNameFromURI(Target.URI + ".diff/" + patch.file + ".gz");
2728	2758
2729	2759		if(Debug)
2730	2760		std::clog << "pkgAcqIndexMergeDiffs: " << Desc.URI << std::endl;

143	143		// of each array is the key, entry 1 is the value.
144	144		const std::pair<const char , const char > PackageProcessingOps[] = {
145	145		std::make_pair("install", N_("Installing %s")),
	146	+	// we don't care for the difference
	147	+	std::make_pair("upgrade", N_("Installing %s")),
146	148		std::make_pair("configure", N_("Configuring %s")),
147	149		std::make_pair("remove", N_("Removing %s")),
148	150		std::make_pair("purge", N_("Completely removing %s")),

615	617		{
616	618		pkgname = APT::String::Strip(list[2]);
617	619		action = APT::String::Strip(list[1]);
618		-	// we don't care for the difference (as dpkg doesn't really either)
619		-	if (action == "upgrade")
620		-	action = "install";
621	620		}
622	621		// "status" has the form: "status: pkg: state"
623		-	// with state in ["half-installed", "unpacked", "half-configured",
	622	+	// with state in ["half-installed", "unpacked", "half-configured",
624	623		// "installed", "config-files", "not-installed"]
625	624		else if (prefix == "status")
626	625		{
627	626		pkgname = APT::String::Strip(list[1]);
628	627		action = APT::String::Strip(list[2]);
629		-	} else {
630		-	if (Debug == true)
631		-	std::clog << "unknown prefix '" << prefix << "'" << std::endl;
632		-	return;
633		-	}
634		-
635	628
636		-	/* handle the special cases first:
	629	+	/* handle the special cases first:
637	630
638		-	errors look like this:
639		-	'status: /var/cache/apt/archives/krecipes_0.8.1-0ubuntu1_i386.deb : error : trying to overwrite `/usr/share/doc/kde/HTML/en/krecipes/krectip.png', which is also in package krecipes-data
640		-	and conffile-prompt like this
641		-	'status:/etc/compiz.conf/compiz.conf : conffile-prompt: 'current-conffile' 'new-conffile' useredited distedited
642		-	*/
643		-	if (prefix == "status")
644		-	{
	631	+	errors look like this:
	632	+	'status: /var/cache/apt/archives/krecipes_0.8.1-0ubuntu1_i386.deb : error : trying to overwrite `/usr/share/doc/kde/HTML/en/krecipes/krectip.png', which is also in package krecipes-data
	633	+	and conffile-prompt like this
	634	+	'status:/etc/compiz.conf/compiz.conf : conffile-prompt: 'current-conffile' 'new-conffile' useredited distedited
	635	+	*/
645	636		if(action == "error")
646	637		{
647		-	d->progress->Error(pkgname, PackagesDone, PackagesTotal,
648		-	list[3]);
649		-	pkgFailures++;
	638	+	d->progress->Error(pkgname, PackagesDone, PackagesTotal, list[3]);
	639	+	++pkgFailures;
650	640		WriteApportReport(pkgname.c_str(), list[3].c_str());
651	641		return;
652	642		}
653	643		else if(action == "conffile-prompt")
654	644		{
655		-	d->progress->ConffilePrompt(pkgname, PackagesDone, PackagesTotal,
656		-	list[3]);
	645	+	d->progress->ConffilePrompt(pkgname, PackagesDone, PackagesTotal, list[3]);
657	646		return;
658	647		}
	648	+	} else {
	649	+	if (Debug == true)
	650	+	std::clog << "unknown prefix '" << prefix << "'" << std::endl;
	651	+	return;
659	652		}
660	653
661		-	// at this point we know that we should have a valid pkgname, so build all
662		-	// the info from it
663		-
664		-	// dpkg does not always send "pkgname:arch" so we add it here if needed
	654	+	// At this point we have a pkgname, but it might not be arch-qualified !
665	655		if (pkgname.find(":") == std::string::npos)
666	656		{
667		-	// find the package in the group that is touched by dpkg
668		-	// if there are multiple pkgs dpkg would send us a full pkgname:arch
669	657		pkgCache::GrpIterator Grp = Cache.FindGrp(pkgname);
670		-	if (Grp.end() == false)
671		-	for (auto P = Grp.PackageList(); P.end() != true; P = Grp.NextPkg(P))
672		-	if(Cache[P].Keep() == false \|\| Cache[P].ReInstall() == true)
	658	+	/* No arch means that dpkg believes there can only be one package
	659	+	this can refer to so lets see what could be candidates here: */
	660	+	std::vector<pkgCache::PkgIterator> candset;
	661	+	for (auto P = Grp.PackageList(); P.end() != true; P = Grp.NextPkg(P))
	662	+	{
	663	+	if (PackageOps.find(P.FullName()) != PackageOps.end())
	664	+	candset.push_back(P);
	665	+	// packages can disappear without them having any interaction itself
	666	+	// so we have to consider these as candidates, too
	667	+	else if (P->CurrentVer != 0 && action == "disappear")
	668	+	candset.push_back(P);
	669	+	}
	670	+	if (unlikely(candset.empty()))
	671	+	{
	672	+	if (Debug == true)
	673	+	std::clog << "unable to figure out which package is dpkg refering to with '" << pkgname << "'! (1)" << std::endl;
	674	+	return;
	675	+	}
	676	+	else if (candset.size() == 1) // we are lucky
	677	+	pkgname = candset.cbegin()->FullName();
	678	+	else
	679	+	{
	680	+	/* here be dragons^Wassumptions about dpkg:
	681	+	- an M-A:same version is always arch-qualified
	682	+	- a package from a foreign arch is (in newer versions) */
	683	+	size_t installedInstances = 0, wannabeInstances = 0;
	684	+	for (auto const &P: candset)
	685	+	{
	686	+	if (P->CurrentVer != 0)
	687	+	{
	688	+	++installedInstances;
	689	+	if (Cache[P].Delete() == false)
	690	+	++wannabeInstances;
	691	+	}
	692	+	else if (Cache[P].Install())
	693	+	++wannabeInstances;
	694	+	}
	695	+	// the package becomes M-A:same, so we are still talking about current
	696	+	if (installedInstances == 1 && wannabeInstances >= 2)
	697	+	{
	698	+	for (auto const &P: candset)
673	699		{
674		-	auto fullname = P.FullName();
675		-	if (Cache[P].Delete() && PackageOps[fullname].size() <= PackageOpsDone[fullname])
	700	+	if (P->CurrentVer == 0)
676	701		continue;
677		-	pkgname = std::move(fullname);
	702	+	pkgname = P.FullName();
	703	+	break;
	704	+	}
	705	+	}
	706	+	// the package was M-A:same, it isn't now, so we can only talk about that
	707	+	else if (installedInstances >= 2 && wannabeInstances == 1)
	708	+	{
	709	+	for (auto const &P: candset)
	710	+	{
	711	+	auto const IV = Cache[P].InstVerIter(Cache);
	712	+	if (IV.end())
	713	+	continue;
	714	+	pkgname = P.FullName();
678	715		break;
679	716		}
	717	+	}
	718	+	// that is a crossgrade
	719	+	else if (installedInstances == 1 && wannabeInstances == 1 && candset.size() == 2)
	720	+	{
	721	+	auto const PkgHasCurrentVersion = [](pkgCache::PkgIterator const &P) { return P->CurrentVer != 0; };
	722	+	auto const P = std::find_if(candset.begin(), candset.end(), PkgHasCurrentVersion);
	723	+	if (unlikely(P == candset.end()))
	724	+	{
	725	+	if (Debug == true)
	726	+	std::clog << "situation for '" << pkgname << "' looked like a crossgrade, but no current version?!" << std::endl;
	727	+	return;
	728	+	}
	729	+	auto fullname = P->FullName();
	730	+	if (PackageOps[fullname].size() != PackageOpsDone[fullname])
	731	+	pkgname = std::move(fullname);
	732	+	else
	733	+	pkgname = std::find_if_not(candset.begin(), candset.end(), PkgHasCurrentVersion)->FullName();
	734	+	}
	735	+	// we are desperate: so "just" take the native one, but that might change mid-air,
	736	+	// so we have to ask dpkg what it believes native is at the moment… all the time
	737	+	else
	738	+	{
	739	+	std::vector<std::string> sArgs = debSystem::GetDpkgBaseCommand();
	740	+	sArgs.push_back("--print-architecture");
	741	+	int outputFd = -1;
	742	+	pid_t const dpkgNativeArch = debSystem::ExecDpkg(sArgs, nullptr, &outputFd, true);
	743	+	if (unlikely(dpkgNativeArch == -1))
	744	+	{
	745	+	if (Debug == true)
	746	+	std::clog << "calling dpkg failed to ask it for its current native architecture to expand '" << pkgname << "'!" << std::endl;
	747	+	return;
	748	+	}
	749	+	FILE *dpkg = fdopen(outputFd, "r");
	750	+	if(dpkg != NULL)
	751	+	{
	752	+	char* buf = NULL;
	753	+	size_t bufsize = 0;
	754	+	if (getline(&buf, &bufsize, dpkg) != -1)
	755	+	pkgname += ':' + bufsize;
	756	+	free(buf);
	757	+	fclose(dpkg);
	758	+	}
	759	+	ExecWait(dpkgNativeArch, "dpkg --print-architecture", true);
	760	+	if (pkgname.find(':') != std::string::npos)
	761	+	{
	762	+	if (Debug == true)
	763	+	std::clog << "unable to figure out which package is dpkg refering to with '" << pkgname << "'! (2)" << std::endl;
	764	+	return;
	765	+	}
	766	+	}
	767	+	}
680	768		}
681	769
682	770		std::string arch = "";

690	778		// 'processing: action: pkg'
691	779		if(prefix == "processing")
692	780		{
693		-	const std::pair<const char , const char > * const iter =
694		-	std::find_if(PackageProcessingOpsBegin,
695		-	PackageProcessingOpsEnd,
696		-	MatchProcessingOp(action.c_str()));
	781	+	auto const iter = std::find_if(PackageProcessingOpsBegin, PackageProcessingOpsEnd, MatchProcessingOp(action.c_str()));
697	782		if(iter == PackageProcessingOpsEnd)
698	783		{
699	784		if (Debug == true)

709	794		// short pkgnames?
710	795		if (action == "disappear")
711	796		handleDisappearAction(pkgname);
	797	+	else if (action == "upgrade")
	798	+	handleCrossUpgradeAction(pkgname);
712	799		return;
713	800		}
714	801
715	802		if (prefix == "status")
716	803		{
717	804		std::vector<struct DpkgState> &states = PackageOps[pkgname];
718		-	if (action == "triggers-pending")
719		-	{
720		-	if (Debug == true)
721		-	std::clog << "(parsed from dpkg) pkg: " << pkgname
722		-	<< " action: " << action << " (prefix 2 to "
723		-	<< PackageOpsDone[pkgname] << " of " << states.size() << ")" << endl;
724		-
725		-	states.insert(states.begin(), {"installed", N_("Installed %s")});
726		-	states.insert(states.begin(), {"half-configured", N_("Configuring %s")});
727		-	PackagesTotal += 2;
728		-	}
729		-	else if(PackageOpsDone[pkgname] < states.size())
	805	+	if(PackageOpsDone[pkgname] < states.size())
730	806		{
731	807		char const * next_action = states[PackageOpsDone[pkgname]].state;
732	808		if (next_action)

763	839		strprintf(msg, translation, i18n_pkgname.c_str());
764	840		d->progress->StatusChanged(pkgname, PackagesDone, PackagesTotal, msg);
765	841		}
766		-	else if (action == "unpacked" && strcmp(next_action, "config-files") == 0)
767		-	{
768		-	// in a crossgrade what looked like a remove first is really an unpack over it
769		-	++PackageOpsDone[pkgname];
770		-	++PackagesDone;
771		-
772		-	auto const Pkg = Cache.FindPkg(pkgname);
773		-	if (likely(Pkg.end() == false))
774		-	{
775		-	auto const Grp = Pkg.Group();
776		-	if (likely(Grp.end() == false))
777		-	{
778		-	for (auto P = Grp.PackageList(); P.end() != true; P = Grp.NextPkg(P))
779		-	if(Cache[P].Install())
780		-	{
781		-	auto && Ops = PackageOps[P.FullName()];
782		-	auto const unpackOp = std::find_if(Ops.cbegin(), Ops.cend(), [](DpkgState const &s) { return strcmp(s.state, "unpacked") == 0; });
783		-	if (unpackOp != Ops.cend())
784		-	{
785		-	auto const skipped = std::distance(Ops.cbegin(), unpackOp);
786		-	PackagesDone += skipped;
787		-	PackageOpsDone[P.FullName()] += skipped;
788		-	break;
789		-	}
790		-	}
791		-	}
792		-	}
793		-	}
794	842		}
795	843		}
	844	+	else if (action == "triggers-pending")
	845	+	{
	846	+	if (Debug == true)
	847	+	std::clog << "(parsed from dpkg) pkg: " << pkgname
	848	+	<< " action: " << action << " (prefix 2 to "
	849	+	<< PackageOpsDone[pkgname] << " of " << states.size() << ")" << endl;
	850	+
	851	+	states.insert(states.begin(), {"installed", N_("Installed %s")});
	852	+	states.insert(states.begin(), {"half-configured", N_("Configuring %s")});
	853	+	PackagesTotal += 2;
	854	+	}
796	855		}
797	856		}
798	857		/}}}/

803	862		if (unlikely(Pkg.end() == true))
804	863		return;
805	864
	865	+	// a disappeared package has no further actions
	866	+	auto const ROps = PackageOps[Pkg.FullName()].size();
	867	+	auto && ROpsDone = PackageOpsDone[Pkg.FullName()];
	868	+	PackagesDone += ROps - ROpsDone;
	869	+	ROpsDone = ROps;
	870	+
806	871		// record the package name for display and stuff later
807	872		disappearedPkgs.insert(Pkg.FullName(true));
808	873

367	367		}
368	368
369	369		CacheFile Cache;
370		-	if (Cache.Open() == false)
	370	+	if (Cache.Open(false) == false)
371	371		return false;
372	372
373	373		LogCleaner Cleaner;

1087	1184		++PackagesTotal;
1088	1185		return true;
1089	1186		});
	1187	+	if ((I.Op == Item::Remove \|\| I.Op == Item::Purge) && I.Pkg->CurrentVer != 0)
	1188	+	{
	1189	+	if (I.Pkg->CurrentState == pkgCache::State::UnPacked \|\|
	1190	+	I.Pkg->CurrentState == pkgCache::State::HalfInstalled)
	1191	+	{
	1192	+	if (likely(strcmp(PackageOps[name][0].state, "half-configured") == 0))
	1193	+	{
	1194	+	++PackageOpsDone[name];
	1195	+	--PackagesTotal;
	1196	+	}
	1197	+	}
	1198	+	}
1090	1199		}
1091	1200		/* one extra: We don't want the progress bar to reach 100%, especially not
1092	1201		if we call dpkg --configure --pending and process a bunch of triggers

1327	1436		if (I.Op == Item::Install && alreadyConfigured.insert(I.Pkg->ID).second == true)
1328	1437		AppendList.emplace_back(Item::Configure, I.Pkg);
1329	1438		for (auto Pkg = Cache.PkgBegin(); Pkg.end() == false; ++Pkg)
1330		-	if (Pkg.State() == pkgCache::PkgIterator::NeedsConfigure && alreadyConfigured.insert(Pkg->ID).second == true)
	1439	+	if (Pkg.State() == pkgCache::PkgIterator::NeedsConfigure &&
	1440	+	Cache[Pkg].Delete() == false && alreadyConfigured.insert(Pkg->ID).second == true)
1331	1441		AppendList.emplace_back(Item::Configure, Pkg);
1332	1442		std::move(AppendList.begin(), AppendList.end(), std::back_inserter(List));
1333	1443		}

1397	1507		dpkg_recursive_install = Cache.VS().CmpVersion("1.18.5", dpkgpkg.CurrentVer().VerStr()) <= 0;
1398	1508		}
1399	1509		// no point in doing this dance for a handful of packages only
1400		-	unsigned int const dpkg_recursive_install_min = _config->FindB("dpkg::install::recursive::minimum", 5);
	1510	+	unsigned int const dpkg_recursive_install_min = _config->FindI("dpkg::install::recursive::minimum", 5);
1401	1511		// FIXME: workaround for dpkg bug, see our ./test-bug-740843-versioned-up-down-breaks test
1402	1512		bool const dpkg_recursive_install_numbered = _config->FindB("dpkg::install::recursive::numbered", true);
1403	1513

1428	1538		continue;
1429	1539
1430	1540		auto const Grp = I->Pkg.Group();
1431		-	size_t installedInstances = 0;
	1541	+	size_t installedInstances = 0, wannabeInstances = 0;
	1542	+	bool multiArchInstances = false;
1432	1543		for (auto Pkg = Grp.PackageList(); Pkg.end() == false; Pkg = Grp.NextPkg(Pkg))
1433		-	if (Pkg->CurrentVer != 0 \|\| Cache[Pkg].Install())
	1544	+	{
	1545	+	if (Pkg->CurrentVer != 0)
	1546	+	{
1434	1547		++installedInstances;
1435		-	if (installedInstances == 2)
	1548	+	if (Cache[Pkg].Delete() == false)
	1549	+	++wannabeInstances;
	1550	+	}
	1551	+	else if (PackageOps.find(Pkg.FullName()) != PackageOps.end())
	1552	+	++wannabeInstances;
	1553	+	if (multiArchInstances == false)
	1554	+	{
	1555	+	auto const V = Cache[Pkg].InstVerIter(Cache);
	1556	+	if (V.end() == false && (Pkg->CurrentVer == 0 \|\| V != Pkg.CurrentVer()))
	1557	+	multiArchInstances = ((V->MultiArch & pkgCache::Version::Same) == pkgCache::Version::Same);
	1558	+	}
	1559	+	}
	1560	+	/* theoretically the installed check would be enough as some wannabe will
	1561	+	be first and hence be the crossgrade we were looking for, but #844300
	1562	+	prevents this so we keep these situations explicit removes.
	1563	+	It is also the reason why neither of them can be a M-A:same package */
	1564	+	if (installedInstances == 1 && wannabeInstances == 1 && multiArchInstances == false)
1436	1565		{
1437	1566		auto const FirstInstall = std::find_if_not(I, List.end(),
1438	1567		[](Item const &i) { return i.Op == Item::Remove \|\| i.Op == Item::Purge; });

1994	2123
1995	2124		if (noopDPkgInvocation == false)
1996	2125		{
	2126	+	if (d->dpkg_error.empty() && (PackagesDone + 1) != PackagesTotal)
	2127	+	{
	2128	+	std::string pkglist;
	2129	+	for (auto const &PO: PackageOps)
	2130	+	if (PO.second.size() != PackageOpsDone[PO.first])
	2131	+	{
	2132	+	if (pkglist.empty() == false)
	2133	+	pkglist.append(" ");
	2134	+	pkglist.append(PO.first);
	2135	+	}
	2136	+	/* who cares about correct progress? As we depend on it for skipping actions
	2137	+	our parsing should be correct. People will no doubt be confused if they see
	2138	+	this message, but the dpkg warning about unknown packages isn't much better
	2139	+	from a user POV and combined we might have a chance to figure out what is wrong */
	2140	+	_error->Warning("APT had planned for dpkg to do more than it reported back (%u vs %u).\n"
	2141	+	"Affected packages: %s", PackagesDone, PackagesTotal, pkglist.c_str());
	2142	+	}
	2143	+
1997	2144		std::string const oldpkgcache = _config->FindFile("Dir::cache::pkgcache");
1998	2145		if (oldpkgcache.empty() == false && RealFileExists(oldpkgcache) == true &&
1999	2146		RemoveFile("pkgDPkgPM::Go", oldpkgcache))

931	931		}
932	932		/}}}/
933	933		// EDSP::WriteError - format an error message to be send to file descriptor /{{{/
	934	+	static std::string formatMessage(std::string const &msg)
	935	+	{
	936	+	return SubstVar(SubstVar(APT::String::Strip(msg), "\n\n", "\n.\n"), "\n", "\n ");
	937	+	}
934	938		bool EDSP::WriteError(char const * const uuid, std::string const &message, FILE* output) {
935	939		fprintf(output, "Error: %s\n", uuid);
936		-	fprintf(output, "Message: %s\n\n", SubstVar(SubstVar(message, "\n\n", "\n.\n"), "\n", "\n ").c_str());
	940	+	fprintf(output, "Message: %s\n\n", formatMessage(message).c_str());
937	941		return true;
938	942		}
939	943		bool EDSP::WriteError(char const * const uuid, std::string const &message, FileFd &output) {
940	944		return WriteOkay(output, "Error: ", uuid, "\n",
941		-	"Message: ", SubstVar(SubstVar(message, "\n\n", "\n.\n"), "\n", "\n "),
	945	+	"Message: ", formatMessage(message),
942	946		"\n\n");
943	947		}
944	948		/}}}/

662	662		FileFd inp, out;
663	663		if (inp.Open(Path, FileFd::ReadOnly, FileFd::Extension) == false)
664	664		{
665		-	std::cerr << "FAILED to open inp " << Path << std::endl;
	665	+	if (Debug == true)
	666	+	std::clog << "FAILED to open inp " << Path << std::endl;
666	667		return _error->Error("Failed to open inp %s", Path.c_str());
667	668		}
668	669		if (out.Open(Itm->DestFile, FileFd::WriteOnly \| FileFd::Create \| FileFd::Empty \| FileFd::BufferedWrite, FileFd::Extension) == false)
669	670		{
670		-	std::cerr << "FAILED to open out " << Itm->DestFile << std::endl;
	671	+	if (Debug == true)
	672	+	std::clog << "FAILED to open out " << Itm->DestFile << std::endl;
671	673		return _error->Error("Failed to open out %s", Itm->DestFile.c_str());
672	674		}
673	675

686	688		inp.Close();
687	689
688	690		if (_error->PendingError() == true) {
689		-	std::cerr << "FAILED to read or write files" << std::endl;
	691	+	if (Debug == true)
	692	+	std::clog << "FAILED to read or write files" << std::endl;
690	693		return false;
691	694		}
692	695

2778	2778		return result;
2779	2779		}
2780	2780		/}}}/
2781		-	std::string GetTempDir() /{{{/
	2781	+	static std::string APT_NONNULL(1) GetTempDirEnv(char const * const env) /{{{/
2782	2782		{
2783		-	const char *tmpdir = getenv("TMPDIR");
	2783	+	const char *tmpdir = getenv(env);
2784	2784
2785	2785		#ifdef P_tmpdir
2786	2786		if (!tmpdir)

2792	2792		stat(tmpdir, &st) != 0 \|\| (st.st_mode & S_IFDIR) == 0) // exists and is directory
2793	2793		tmpdir = "/tmp";
2794	2794		else if (geteuid() != 0 && // root can do everything anyway
2795		-	faccessat(-1, tmpdir, R_OK \| W_OK \| X_OK, AT_EACCESS \| AT_SYMLINK_NOFOLLOW) != 0) // current user has rwx access to directory
	2795	+	faccessat(AT_FDCWD, tmpdir, R_OK \| W_OK \| X_OK, AT_EACCESS) != 0) // current user has rwx access to directory
2796	2796		tmpdir = "/tmp";
2797	2797
2798	2798		return string(tmpdir);
	2799	+	}
	2800	+	/}}}/
	2801	+	std::string GetTempDir() /{{{/
	2802	+	{
	2803	+	return GetTempDirEnv("TMPDIR");
2799	2804		}
2800	2805		std::string GetTempDir(std::string const &User)
2801	2806		{

Compare 15f32c4 ... +34 ... e5f9d66

No flags found

Show failed CI and contexual commits c 36 Commits

Compare `15f32c4 ... +34 ... e5f9d66`

Show failed CI and contexual commits `c`

36 Commits

779	779		*/
780	780		class APT_HIDDEN pkgAcqIndexMergeDiffs : public pkgAcqBaseIndex
781	781		{
782		-	void * const d;
	782	+	std::string const indexURI;
783	783
784	784		protected:
785	785

830	830		/** \brief Create an index merge-diff item.
831	831		*
832	832		* \param Owner The pkgAcquire object that owns this item.
833		-	*
834		-	* \param URI The URI of the package index file being
835		-	* reconstructed.
836		-	*
837		-	* \param URIDesc A long description of this item.
838		-	*
839		-	* \param ShortDesc A brief description of this item.
840		-	*
	833	+	* \param TransactionManager responsible for this item
	834	+	* \param Target we intend to built via pdiff patching
	835	+	* \param baseURI is the URI used for the Index, but stripped down to Target
	836	+	* \param DiffInfo of the patch in question
841	837		* \param patch contains infos about the patch this item is supposed
842	838		* to download which were read from the index
843		-	*
844	839		* \param allPatches contains all related items so that each item can
845	840		* check if it was the last one to complete the download step
846	841		*/
847	842		pkgAcqIndexMergeDiffs(pkgAcquire * const Owner, pkgAcqMetaClearSig * const TransactionManager,
848		-	IndexTarget const &Target, DiffInfo const &patch,
849		-	std::vector<pkgAcqIndexMergeDiffs> const const allPatches) APT_NONNULL(2, 3, 6);
	843	+	IndexTarget const &Target, std::string const &indexUsedMirror,
	844	+	std::string const &indexURI, DiffInfo const &patch,
	845	+	std::vector<pkgAcqIndexMergeDiffs> const const allPatches) APT_NONNULL(2, 3, 8);
850	846		virtual ~pkgAcqIndexMergeDiffs();
851	847		};
852	848		/}}}/

863	859		*/
864	860		class APT_HIDDEN pkgAcqIndexDiffs : public pkgAcqBaseIndex
865	861		{
866		-	void * const d;
	862	+	std::string const indexURI;
867	863
868	864		private:
869	865

943	939		* \a diffs is empty, or QueueNextDiff() otherwise.
944	940		*
945	941		* \param Owner The pkgAcquire object that owns this item.
946		-	*
947		-	* \param URI The URI of the package index file being
948		-	* reconstructed.
949		-	*
950		-	* \param URIDesc A long description of this item.
951		-	*
952		-	* \param ShortDesc A brief description of this item.
953		-	*
	942	+	* \param TransactionManager responsible for this item
	943	+	* \param Target we want to built via pdiff patching
	944	+	* \param baseURI is the URI used for the Index, but stripped down to Target
954	945		* \param diffs The remaining diffs from the index of diffs. They
955	946		* should be ordered so that each diff appears before any diff
956	947		* that depends on it.
957	948		*/
958	949		pkgAcqIndexDiffs(pkgAcquire * const Owner, pkgAcqMetaClearSig * const TransactionManager,
959	950		IndexTarget const &Target,
	951	+	std::string const &indexUsedMirror, std::string const &indexURI,
960	952		std::vector<DiffInfo> const &diffs=std::vector<DiffInfo>()) APT_NONNULL(2, 3);
961	953		virtual ~pkgAcqIndexDiffs();
962	954		};

136	136		_error->PendingError() == true)
137	137		return false;
138	138
139		-	if (_config->FindB("APT::Get::Fix-Missing",false) == true &&
140		-	_config->FindB("APT::Get::Download",true) == false)
	139	+	if (_config->FindB("APT::Get::Download",true) == false)
141	140		{
142	141		bool Missing = false;
143	142		RemoveDownloadNeedingItemsFromFetcher(Fetcher, Missing);
144	143		if (Missing)
145		-	PM->FixMissing();
	144	+	{
	145	+	if (_config->FindB("APT::Get::Fix-Missing",false))
	146	+	PM->FixMissing();
	147	+	else
	148	+	return _error->Error(_("Unable to fetch some archives, maybe run apt-get update or try with --fix-missing?"));
	149	+	}
146	150		Fetcher.Shutdown();
147		-	if (PM->GetArchives(&Fetcher,List,&Recs) == false \|\|
148		-	_error->PendingError() == true)
	151	+	if (_error->PendingError() == true)
149	152		return false;
150	153		}
151	154

396	399		/* Remove unused automatic packages */
397	400		bool DoAutomaticRemove(CacheFile &Cache)
398	401		{
399		-	bool Debug = _config->FindI("Debug::pkgAutoRemove",false);
	402	+	bool Debug = _config->FindB("Debug::pkgAutoRemove",false);
400	403		bool doAutoRemove = _config->FindB("APT::Get::AutomaticRemove", false);
401	404		bool hideAutoRemove = _config->FindB("APT::Get::HideAutoRemove");
402	405

426	429		{
427	430		if(Pkg.CurrentVer() != 0 \|\| Cache[Pkg].Install())
428	431		if(Debug)
429		-	std::cout << "We could delete %s" << Pkg.FullName(true).c_str() << std::endl;
	432	+	std::cout << "We could delete " << APT::PrettyPkg(Cache, Pkg) << std::endl;
430	433
431	434		if (doAutoRemove)
432	435		{
433		-	if(Pkg.CurrentVer() != 0 &&
	436	+	if(Pkg.CurrentVer() != 0 &&
434	437		Pkg->CurrentState != pkgCache::State::ConfigFiles)
435	438		Cache->MarkDelete(Pkg, purgePkgs, 0, false);
436	439		else

475	478		if (R.IsNegative() == true \|\|
476	479		Cache->IsImportantDep(R) == false)
477	480		continue;
478		-	pkgCache::PkgIterator N = R.ParentPkg();
479		-	if (N.end() == true \|\| (N->CurrentVer == 0 && (*Cache)[N].Install() == false))
	481	+	auto const RV = R.ParentVer();
	482	+	if (unlikely(RV.end() == true))
	483	+	continue;
	484	+	auto const RP = RV.ParentPkg();
	485	+	// check if that dependency comes from an interesting version
	486	+	if (RP.CurrentVer() == RV)
	487	+	{
	488	+	if ((*Cache)[RP].Keep() == false)
	489	+	continue;
	490	+	}
	491	+	else if (Cache[RP].CandidateVerIter(Cache) == RV)
	492	+	{
	493	+	if ((Cache)[RP].NewInstall() == false && (Cache)[RP].Upgrade() == false)
	494	+	continue;
	495	+	}
	496	+	else // ignore dependency from a non-candidate version
480	497		continue;
481	498		if (Debug == true)
482		-	std::clog << "Save " << APT::PrettyPkg(Cache, Pkg) << " as another installed garbage package depends on it" << std::endl;
	499	+	std::clog << "Save " << APT::PrettyPkg(Cache, Pkg) << " as another installed package depends on it: " << APT::PrettyPkg(Cache, RP) << std::endl;
483	500		Cache->MarkInstall(Pkg, false, 0, false);
484	501		if (hideAutoRemove == false)
485	502		++autoRemoveCount;

495	512		}
496	513		} while (Changed == true);
497	514		}
	515	+	// trigger marking now so that the package list below is correct
	516	+	group.release();
498	517
499	518		// Now see if we had destroyed anything (if we had done anything)
500	519		if (Cache->BrokenCount() != 0)

71	71		ListUpdate(Stat, *List);
72	72		}
73	73
	74	+	if (_config->FindB("pkgCacheFile::Generate", true) == false)
	75	+	return true;
	76	+
74	77		// Rebuild the cache.
75		-	if (_config->FindB("pkgCacheFile::Generate", true) == true)
76		-	{
77		-	pkgCacheFile::RemoveCaches();
78		-	if (Cache.BuildCaches() == false)
79		-	return false;
80		-	}
	78	+	pkgCacheFile::RemoveCaches();
	79	+	if (Cache.BuildCaches(false) == false)
	80	+	return false;
81	81
82	82		// show basic stats (if the user whishes)
83	83		if (_config->FindB("APT::Cmd::Show-Update-Stats", false) == true)
84	84		{
85	85		int upgradable = 0;
86		-	if (Cache.Open() == false)
	86	+	if (Cache.Open(false) == false)
87	87		return false;
88	88		for (pkgCache::PkgIterator I = Cache->PkgBegin(); I.end() != true; ++I)
89	89		{