[apt.git] / apt-private / private-cacheset.cc

#include <config.h>

#include <apt-pkg/cachefile.h>
#include <apt-pkg/pkgcache.h>
#include <apt-pkg/depcache.h>
#include <apt-pkg/cacheiterators.h>
#include <apt-pkg/cachefilter.h>
#include <apt-pkg/aptconfiguration.h>
#include <apt-pkg/configuration.h>
#include <apt-pkg/progress.h>
#include <apt-pkg/policy.h>
#include <apt-pkg/strutl.h>

#include <apt-private/private-cacheset.h>

#include <stddef.h>

#include <apti18n.h>

bool GetLocalitySortedVersionSet(pkgCacheFile &CacheFile,		/*{{{*/
                                 APT::VersionContainerInterface * const vci,
                                 OpProgress * const progress)
{
    Matcher null_matcher = Matcher();
    return GetLocalitySortedVersionSet(CacheFile, vci,
                                       null_matcher, progress);
}
bool GetLocalitySortedVersionSet(pkgCacheFile &CacheFile,
                                 APT::VersionContainerInterface * const vci,
                                 Matcher &matcher,
                                 OpProgress * const progress)
{
   pkgCache * const Cache = CacheFile.GetPkgCache();
   if (unlikely(Cache == nullptr))
      return false;
   if (progress != nullptr)
      progress->SubProgress(Cache->Head().PackageCount, _("Sorting"));

   pkgDepCache * const DepCache = CacheFile.GetDepCache();
   if (unlikely(DepCache == nullptr))
      return false;
   APT::CacheSetHelper helper(false);

   int Done=0;

   bool const insertCurrentVer = _config->FindB("APT::Cmd::Installed", false);
   bool const insertUpgradable = _config->FindB("APT::Cmd::Upgradable", false);
   bool const insertManualInstalled = _config->FindB("APT::Cmd::Manual-Installed", false);

   for (pkgCache::PkgIterator P = Cache->PkgBegin(); P.end() == false; ++P)
   {
      if (progress != NULL)
      {
	 if (Done % 500 == 0)
	    progress->Progress(Done);
	 ++Done;
      }

      // exclude virtual pkgs
      if (P->VersionList == 0)
	 continue;

      if ((matcher)(P) == false)
	 continue;

      pkgDepCache::StateCache &state = (*DepCache)[P];
      if (insertCurrentVer == true)
      {
	 if (P->CurrentVer != 0)
	    vci->FromPackage(vci, CacheFile, P, APT::CacheSetHelper::INSTALLED, helper);
      }
      else if (insertUpgradable == true)
      {
	 if(P.CurrentVer() && state.Upgradable())
	    vci->FromPackage(vci, CacheFile, P, APT::CacheSetHelper::CANDIDATE, helper);
      }
      else if (insertManualInstalled == true)
      {
	 if (P.CurrentVer() &&
	       ((*DepCache)[P].Flags & pkgCache::Flag::Auto) == false)
	    vci->FromPackage(vci, CacheFile, P, APT::CacheSetHelper::CANDIDATE, helper);
      }
      else
      {
         if (vci->FromPackage(vci, CacheFile, P, APT::CacheSetHelper::CANDIDATE, helper) == false)
	 {
	    // no candidate, this may happen for packages in
	    // dpkg "deinstall ok config-file" state - we pick the first ver
	    // (which should be the only one)
	    vci->insert(P.VersionList());
	 }
      }
   }
   if (progress != NULL)
      progress->Done();
   return true;
}
									/*}}}*/

// CacheSetHelper saving virtual packages				/*{{{*/
pkgCache::VerIterator CacheSetHelperVirtuals::canNotGetVersion(
      enum CacheSetHelper::VerSelector const select,
      pkgCacheFile &Cache,
      pkgCache::PkgIterator const &Pkg)
{
   if (select == NEWEST || select == CANDIDATE || select == ALL)
      virtualPkgs.insert(Pkg);
   return CacheSetHelper::canNotGetVersion(select, Cache, Pkg);
}
void CacheSetHelperVirtuals::canNotFindVersion(
      enum CacheSetHelper::VerSelector const select,
      APT::VersionContainerInterface * vci,
      pkgCacheFile &Cache,
      pkgCache::PkgIterator const &Pkg)
{
   if (select == NEWEST || select == CANDIDATE || select == ALL)
      virtualPkgs.insert(Pkg);
   return CacheSetHelper::canNotFindVersion(select, vci, Cache, Pkg);
}
static pkgCache::PkgIterator canNotFindPkgName_impl(pkgCacheFile &Cache, std::string const &str)
{
   std::string pkg = str;
   size_t const archfound = pkg.find_last_of(':');
   std::string arch;
   if (archfound != std::string::npos) {
      arch = pkg.substr(archfound+1);
      pkg.erase(archfound);
      if (arch == "all" || arch == "native")
	 arch = _config->Find("APT::Architecture");
   }

   // If we don't find 'foo:amd64' look for 'foo:amd64:any'.
   // Note: we prepare for an error here as if foo:amd64 does not exist,
   // but foo:amd64:any it means that this package is only referenced in a
   // (architecture specific) dependency. We do not add to virtualPkgs directly
   // as we can't decide from here which error message has to be printed.
   // FIXME: This doesn't match 'barbarian' architectures
   pkgCache::PkgIterator Pkg(Cache, 0);
   std::vector<std::string> const archs = APT::Configuration::getArchitectures();
   if (archfound == std::string::npos)
   {
      for (auto const &a : archs)
      {
	 Pkg = Cache.GetPkgCache()->FindPkg(pkg + ':' + a, "any");
	 if (Pkg.end() == false && Pkg->ProvidesList != 0)
	    break;
      }
      if (Pkg.end() == true)
	 for (auto const &a : archs)
	 {
	    Pkg = Cache.GetPkgCache()->FindPkg(pkg + ':' + a, "any");
	    if (Pkg.end() == false)
	       break;
	 }
   }
   else
   {
      Pkg = Cache.GetPkgCache()->FindPkg(pkg + ':' + arch, "any");
      if (Pkg.end() == true)
      {
	 APT::CacheFilter::PackageArchitectureMatchesSpecification pams(arch);
	 for (auto const &a : archs)
	 {
	    if (pams(a.c_str()) == false)
	       continue;
	    Pkg = Cache.GetPkgCache()->FindPkg(pkg + ':' + a, "any");
	    if (Pkg.end() == false)
	       break;
	 }
      }
   }
   return Pkg;
}
pkgCache::PkgIterator CacheSetHelperVirtuals::canNotFindPkgName(pkgCacheFile &Cache, std::string const &str)
{
   pkgCache::PkgIterator const Pkg = canNotFindPkgName_impl(Cache, str);
   if (Pkg.end())
      return APT::CacheSetHelper::canNotFindPkgName(Cache, str);
   return Pkg;
}
CacheSetHelperVirtuals::CacheSetHelperVirtuals(bool const ShowErrors, GlobalError::MsgType const &ErrorType) :
   CacheSetHelper{ShowErrors, ErrorType}
{}
									/*}}}*/

// CacheSetHelperAPTGet - responsible for message telling from the CacheSets/*{{{*/
CacheSetHelperAPTGet::CacheSetHelperAPTGet(std::ostream &pout) :
   APT::CacheSetHelper{true}, out(pout)
{
   explicitlyNamed = true;
}
void CacheSetHelperAPTGet::showTaskSelection(pkgCache::PkgIterator const &Pkg, std::string const &pattern)
{
   ioprintf(out, _("Note, selecting '%s' for task '%s'\n"),
	 Pkg.FullName(true).c_str(), pattern.c_str());
   explicitlyNamed = false;
}
void CacheSetHelperAPTGet::showFnmatchSelection(pkgCache::PkgIterator const &Pkg, std::string const &pattern)
{
   ioprintf(out, _("Note, selecting '%s' for glob '%s'\n"),
	 Pkg.FullName(true).c_str(), pattern.c_str());
   explicitlyNamed = false;
}
void CacheSetHelperAPTGet::showRegExSelection(pkgCache::PkgIterator const &Pkg, std::string const &pattern)
{
   ioprintf(out, _("Note, selecting '%s' for regex '%s'\n"),
	 Pkg.FullName(true).c_str(), pattern.c_str());
   explicitlyNamed = false;
}
void CacheSetHelperAPTGet::showSelectedVersion(pkgCache::PkgIterator const &/*Pkg*/, pkgCache::VerIterator const Ver,
      std::string const &ver, bool const /*verIsRel*/)
{
   if (ver == Ver.VerStr())
      return;
   selectedByRelease.push_back(make_pair(Ver, ver));
}
bool CacheSetHelperAPTGet::showVirtualPackageErrors(pkgCacheFile &Cache)
{
   if (virtualPkgs.empty() == true)
      return true;
   for (APT::PackageSet::const_iterator Pkg = virtualPkgs.begin();
	 Pkg != virtualPkgs.end(); ++Pkg) {
      if (Pkg->ProvidesList != 0) {
	 ioprintf(c1out,_("Package %s is a virtual package provided by:\n"),
	       Pkg.FullName(true).c_str());

	 pkgCache::PrvIterator I = Pkg.ProvidesList();
	 unsigned short provider = 0;
	 for (; I.end() == false; ++I) {
	    pkgCache::PkgIterator Pkg = I.OwnerPkg();

	    if (Cache[Pkg].CandidateVerIter(Cache) == I.OwnerVer()) {
	       c1out << "  " << Pkg.FullName(true) << " " << I.OwnerVer().VerStr();
	       if (Cache[Pkg].Install() == true && Cache[Pkg].NewInstall() == false)
		  c1out << _(" [Installed]");
	       c1out << std::endl;
	       ++provider;
	    }
	 }
	 // if we found no candidate which provide this package, show non-candidates
	 if (provider == 0)
	    for (I = Pkg.ProvidesList(); I.end() == false; ++I)
	       c1out << "  " << I.OwnerPkg().FullName(true) << " " << I.OwnerVer().VerStr()
		  << _(" [Not candidate version]") << std::endl;
	 else
	    out << _("You should explicitly select one to install.") << std::endl;
      } else {
	 ioprintf(c1out,
	       _("Package %s is not available, but is referred to by another package.\n"
		  "This may mean that the package is missing, has been obsoleted, or\n"
		  "is only available from another source\n"),Pkg.FullName(true).c_str());

	 std::vector<bool> Seen(Cache.GetPkgCache()->Head().PackageCount, false);
	 APT::PackageList pkglist;
	 for (pkgCache::DepIterator Dep = Pkg.RevDependsList();
	       Dep.end() == false; ++Dep) {
	    if (Dep->Type != pkgCache::Dep::Replaces)
	       continue;
	    pkgCache::PkgIterator const DP = Dep.ParentPkg();
	    if (Seen[DP->ID] == true)
	       continue;
	    Seen[DP->ID] = true;
	    pkglist.insert(DP);
	 }
	 ShowList(c1out, _("However the following packages replace it:"), pkglist,
	       &AlwaysTrue, &PrettyFullName, &EmptyString);
      }
      c1out << std::endl;
   }
   return false;
}
pkgCache::VerIterator CacheSetHelperAPTGet::canNotFindCandidateVer(pkgCacheFile &Cache, pkgCache::PkgIterator const &Pkg)
{
   APT::VersionSet const verset = tryVirtualPackage(Cache, Pkg, CacheSetHelper::CANDIDATE);
   if (verset.empty() == false)
      return *(verset.begin());
   else if (ShowError == true) {
      _error->Error(_("Package '%s' has no installation candidate"),Pkg.FullName(true).c_str());
      virtualPkgs.insert(Pkg);
   }
   return pkgCache::VerIterator(Cache, 0);
}
pkgCache::VerIterator CacheSetHelperAPTGet::canNotFindNewestVer(pkgCacheFile &Cache, pkgCache::PkgIterator const &Pkg)
{
   if (Pkg->ProvidesList != 0)
   {
      APT::VersionSet const verset = tryVirtualPackage(Cache, Pkg, CacheSetHelper::NEWEST);
      if (verset.empty() == false)
	 return *(verset.begin());
      if (ShowError == true)
	 ioprintf(out, _("Virtual packages like '%s' can't be removed\n"), Pkg.FullName(true).c_str());
   }
   else
   {
      pkgCache::GrpIterator Grp = Pkg.Group();
      pkgCache::PkgIterator P = Grp.PackageList();
      for (; P.end() != true; P = Grp.NextPkg(P))
      {
	 if (P == Pkg)
	    continue;
	 if (P->CurrentVer != 0) {
	    // TRANSLATORS: Note, this is not an interactive question
	    ioprintf(c1out,_("Package '%s' is not installed, so not removed. Did you mean '%s'?\n"),
		  Pkg.FullName(true).c_str(), P.FullName(true).c_str());
	    break;
	 }
      }
      if (P.end() == true)
	 ioprintf(c1out,_("Package '%s' is not installed, so not removed\n"),Pkg.FullName(true).c_str());
   }
   return pkgCache::VerIterator(Cache, 0);
}
APT::VersionSet CacheSetHelperAPTGet::tryVirtualPackage(pkgCacheFile &Cache, pkgCache::PkgIterator const &Pkg,
      CacheSetHelper::VerSelector const select)
{
   /* This is a pure virtual package and there is a single available
      candidate providing it. */
   if (unlikely(Cache[Pkg].CandidateVer != 0) || Pkg->ProvidesList == 0)
      return APT::VersionSet();

   pkgCache::PkgIterator Prov;
   bool found_one = false;
   for (pkgCache::PrvIterator P = Pkg.ProvidesList(); P; ++P) {
      pkgCache::VerIterator const PVer = P.OwnerVer();
      pkgCache::PkgIterator const PPkg = PVer.ParentPkg();

      /* Ignore versions that are not a candidate. */
      if (Cache[PPkg].CandidateVer != PVer)
	 continue;

      if (found_one == false) {
	 Prov = PPkg;
	 found_one = true;
      } else if (PPkg != Prov) {
	 // same group, so it's a foreign package
	 if (PPkg->Group == Prov->Group) {
	    // do we already have the requested arch?
	    if (strcmp(Pkg.Arch(), Prov.Arch()) == 0 ||
		  strcmp(Prov.Arch(), "all") == 0 ||
		  unlikely(strcmp(PPkg.Arch(), Prov.Arch()) == 0)) // packages have only on candidate, but just to be sure
	       continue;
	    // see which architecture we prefer more and switch to it
	    std::vector<std::string> archs = APT::Configuration::getArchitectures();
	    if (std::find(archs.begin(), archs.end(), PPkg.Arch()) < std::find(archs.begin(), archs.end(), Prov.Arch()))
	       Prov = PPkg;
	    continue;
	 }
	 found_one = false; // we found at least two
	 break;
      }
   }

   if (found_one == true) {
      ioprintf(out, _("Note, selecting '%s' instead of '%s'\n"),
	    Prov.FullName(true).c_str(), Pkg.FullName(true).c_str());
      return APT::VersionSet::FromPackage(Cache, Prov, select, *this);
   }
   return APT::VersionSet();
}
pkgCache::PkgIterator CacheSetHelperAPTGet::canNotFindPkgName(pkgCacheFile &Cache, std::string const &str)
{
   pkgCache::PkgIterator const Pkg = canNotFindPkgName_impl(Cache, str);
   if (Pkg.end())
      return APT::CacheSetHelper::canNotFindPkgName(Cache, str);
   return Pkg;
}
									/*}}}*/
Commit	Line	Data
453b82a3 DK	1	#include <config.h>
453b82a3 DK	2
b9179170 MV	3	#include <apt-pkg/cachefile.h>
	4	#include <apt-pkg/pkgcache.h>
	5	#include <apt-pkg/depcache.h>
453b82a3	6	#include <apt-pkg/cacheiterators.h>
3addaba1	7	#include <apt-pkg/cachefilter.h>
6cfadda1	8	#include <apt-pkg/aptconfiguration.h>
453b82a3 DK	9	#include <apt-pkg/configuration.h>
	10	#include <apt-pkg/progress.h>
	11	#include <apt-pkg/policy.h>
6cfadda1	12	#include <apt-pkg/strutl.h>
453b82a3 DK	13
	14	#include <apt-private/private-cacheset.h>
	15
	16	#include <stddef.h>
b9179170	17
453b82a3	18	#include <apti18n.h>
b9179170	19
6cfadda1	20	bool GetLocalitySortedVersionSet(pkgCacheFile &CacheFile, /{{{/
25594bb5 DK	21	APT::VersionContainerInterface * const vci,
25594bb5 DK	22	OpProgress * const progress)
b9179170 MV	23	{
b9179170 MV	24	Matcher null_matcher = Matcher();
25594bb5	25	return GetLocalitySortedVersionSet(CacheFile, vci,
b9179170 MV	26	null_matcher, progress);
b9179170 MV	27	}
25594bb5 DK	28	bool GetLocalitySortedVersionSet(pkgCacheFile &CacheFile,
25594bb5 DK	29	APT::VersionContainerInterface * const vci,
b9179170	30	Matcher &matcher,
25594bb5	31	OpProgress * const progress)
b9179170	32	{
fdf9eef4 DK	33	pkgCache * const Cache = CacheFile.GetPkgCache();
	34	if (unlikely(Cache == nullptr))
	35	return false;
	36	if (progress != nullptr)
	37	progress->SubProgress(Cache->Head().PackageCount, _("Sorting"));
	38
	39	pkgDepCache * const DepCache = CacheFile.GetDepCache();
	40	if (unlikely(DepCache == nullptr))
	41	return false;
25594bb5	42	APT::CacheSetHelper helper(false);
b9179170 MV	43
b9179170 MV	44	int Done=0;
25594bb5 DK	45
	46	bool const insertCurrentVer = _config->FindB("APT::Cmd::Installed", false);
	47	bool const insertUpgradable = _config->FindB("APT::Cmd::Upgradable", false);
	48	bool const insertManualInstalled = _config->FindB("APT::Cmd::Manual-Installed", false);
	49
b9179170 MV	50	for (pkgCache::PkgIterator P = Cache->PkgBegin(); P.end() == false; ++P)
b9179170 MV	51	{
25594bb5 DK	52	if (progress != NULL)
	53	{
	54	if (Done % 500 == 0)
	55	progress->Progress(Done);
	56	++Done;
	57	}
	58
	59	// exclude virtual pkgs
	60	if (P->VersionList == 0)
	61	continue;
b9179170 MV	62
b9179170 MV	63	if ((matcher)(P) == false)
25594bb5	64	continue;
b9179170	65
b9179170	66	pkgDepCache::StateCache &state = (*DepCache)[P];
25594bb5	67	if (insertCurrentVer == true)
b9179170	68	{
25594bb5	69	if (P->CurrentVer != 0)
fdba4d53	70	vci->FromPackage(vci, CacheFile, P, APT::CacheSetHelper::INSTALLED, helper);
b9179170	71	}
25594bb5	72	else if (insertUpgradable == true)
b9179170	73	{
25594bb5	74	if(P.CurrentVer() && state.Upgradable())
fdba4d53	75	vci->FromPackage(vci, CacheFile, P, APT::CacheSetHelper::CANDIDATE, helper);
b9179170	76	}
25594bb5	77	else if (insertManualInstalled == true)
3bdf7da5	78	{
25594bb5 DK	79	if (P.CurrentVer() &&
25594bb5 DK	80	((*DepCache)[P].Flags & pkgCache::Flag::Auto) == false)
fdba4d53	81	vci->FromPackage(vci, CacheFile, P, APT::CacheSetHelper::CANDIDATE, helper);
3bdf7da5	82	}
25594bb5	83	else
b9179170	84	{
fdba4d53	85	if (vci->FromPackage(vci, CacheFile, P, APT::CacheSetHelper::CANDIDATE, helper) == false)
25594bb5 DK	86	{
	87	// no candidate, this may happen for packages in
	88	// dpkg "deinstall ok config-file" state - we pick the first ver
	89	// (which should be the only one)
	90	vci->insert(P.VersionList());
	91	}
b9179170 MV	92	}
b9179170 MV	93	}
25594bb5 DK	94	if (progress != NULL)
25594bb5 DK	95	progress->Done();
b9179170 MV	96	return true;
b9179170 MV	97	}
6cfadda1 DK	98	/}}}/
	99
	100	// CacheSetHelper saving virtual packages /{{{/
	101	pkgCache::VerIterator CacheSetHelperVirtuals::canNotGetVersion(
	102	enum CacheSetHelper::VerSelector const select,
	103	pkgCacheFile &Cache,
	104	pkgCache::PkgIterator const &Pkg)
	105	{
	106	if (select == NEWEST \|\| select == CANDIDATE \|\| select == ALL)
	107	virtualPkgs.insert(Pkg);
	108	return CacheSetHelper::canNotGetVersion(select, Cache, Pkg);
	109	}
	110	void CacheSetHelperVirtuals::canNotFindVersion(
	111	enum CacheSetHelper::VerSelector const select,
	112	APT::VersionContainerInterface * vci,
	113	pkgCacheFile &Cache,
	114	pkgCache::PkgIterator const &Pkg)
	115	{
	116	if (select == NEWEST \|\| select == CANDIDATE \|\| select == ALL)
	117	virtualPkgs.insert(Pkg);
	118	return CacheSetHelper::canNotFindVersion(select, vci, Cache, Pkg);
	119	}
3addaba1 DK	120	static pkgCache::PkgIterator canNotFindPkgName_impl(pkgCacheFile &Cache, std::string const &str)
	121	{
	122	std::string pkg = str;
	123	size_t const archfound = pkg.find_last_of(':');
	124	std::string arch;
	125	if (archfound != std::string::npos) {
	126	arch = pkg.substr(archfound+1);
	127	pkg.erase(archfound);
	128	if (arch == "all" \|\| arch == "native")
	129	arch = _config->Find("APT::Architecture");
	130	}
	131
	132	// If we don't find 'foo:amd64' look for 'foo:amd64:any'.
	133	// Note: we prepare for an error here as if foo:amd64 does not exist,
	134	// but foo:amd64:any it means that this package is only referenced in a
	135	// (architecture specific) dependency. We do not add to virtualPkgs directly
	136	// as we can't decide from here which error message has to be printed.
	137	// FIXME: This doesn't match 'barbarian' architectures
	138	pkgCache::PkgIterator Pkg(Cache, 0);
	139	std::vector<std::string> const archs = APT::Configuration::getArchitectures();
	140	if (archfound == std::string::npos)
	141	{
	142	for (auto const &a : archs)
	143	{
	144	Pkg = Cache.GetPkgCache()->FindPkg(pkg + ':' + a, "any");
	145	if (Pkg.end() == false && Pkg->ProvidesList != 0)
	146	break;
	147	}
	148	if (Pkg.end() == true)
	149	for (auto const &a : archs)
	150	{
	151	Pkg = Cache.GetPkgCache()->FindPkg(pkg + ':' + a, "any");
	152	if (Pkg.end() == false)
	153	break;
	154	}
	155	}
	156	else
	157	{
	158	Pkg = Cache.GetPkgCache()->FindPkg(pkg + ':' + arch, "any");
	159	if (Pkg.end() == true)
	160	{
	161	APT::CacheFilter::PackageArchitectureMatchesSpecification pams(arch);
	162	for (auto const &a : archs)
	163	{
	164	if (pams(a.c_str()) == false)
	165	continue;
	166	Pkg = Cache.GetPkgCache()->FindPkg(pkg + ':' + a, "any");
	167	if (Pkg.end() == false)
	168	break;
	169	}
	170	}
	171	}
	172	return Pkg;
	173	}
	174	pkgCache::PkgIterator CacheSetHelperVirtuals::canNotFindPkgName(pkgCacheFile &Cache, std::string const &str)
	175	{
	176	pkgCache::PkgIterator const Pkg = canNotFindPkgName_impl(Cache, str);
	177	if (Pkg.end())
	178	return APT::CacheSetHelper::canNotFindPkgName(Cache, str);
	179	return Pkg;
	180	}
6cfadda1 DK	181	CacheSetHelperVirtuals::CacheSetHelperVirtuals(bool const ShowErrors, GlobalError::MsgType const &ErrorType) :
	182	CacheSetHelper{ShowErrors, ErrorType}
	183	{}
	184	/}}}/
	185
	186	// CacheSetHelperAPTGet - responsible for message telling from the CacheSets/{{{/
258b9e51 DK	187	CacheSetHelperAPTGet::CacheSetHelperAPTGet(std::ostream &pout) :
258b9e51 DK	188	APT::CacheSetHelper{true}, out(pout)
6cfadda1 DK	189	{
	190	explicitlyNamed = true;
	191	}
	192	void CacheSetHelperAPTGet::showTaskSelection(pkgCache::PkgIterator const &Pkg, std::string const &pattern)
	193	{
	194	ioprintf(out, _("Note, selecting '%s' for task '%s'\n"),
	195	Pkg.FullName(true).c_str(), pattern.c_str());
	196	explicitlyNamed = false;
	197	}
	198	void CacheSetHelperAPTGet::showFnmatchSelection(pkgCache::PkgIterator const &Pkg, std::string const &pattern)
	199	{
	200	ioprintf(out, _("Note, selecting '%s' for glob '%s'\n"),
	201	Pkg.FullName(true).c_str(), pattern.c_str());
	202	explicitlyNamed = false;
	203	}
	204	void CacheSetHelperAPTGet::showRegExSelection(pkgCache::PkgIterator const &Pkg, std::string const &pattern)
	205	{
	206	ioprintf(out, _("Note, selecting '%s' for regex '%s'\n"),
	207	Pkg.FullName(true).c_str(), pattern.c_str());
	208	explicitlyNamed = false;
	209	}
	210	void CacheSetHelperAPTGet::showSelectedVersion(pkgCache::PkgIterator const &/Pkg/, pkgCache::VerIterator const Ver,
	211	std::string const &ver, bool const /verIsRel/)
	212	{
	213	if (ver == Ver.VerStr())
	214	return;
	215	selectedByRelease.push_back(make_pair(Ver, ver));
	216	}
	217	bool CacheSetHelperAPTGet::showVirtualPackageErrors(pkgCacheFile &Cache)
	218	{
	219	if (virtualPkgs.empty() == true)
	220	return true;
	221	for (APT::PackageSet::const_iterator Pkg = virtualPkgs.begin();
	222	Pkg != virtualPkgs.end(); ++Pkg) {
	223	if (Pkg->ProvidesList != 0) {
	224	ioprintf(c1out,_("Package %s is a virtual package provided by:\n"),
	225	Pkg.FullName(true).c_str());
	226
	227	pkgCache::PrvIterator I = Pkg.ProvidesList();
	228	unsigned short provider = 0;
	229	for (; I.end() == false; ++I) {
	230	pkgCache::PkgIterator Pkg = I.OwnerPkg();
	231
	232	if (Cache[Pkg].CandidateVerIter(Cache) == I.OwnerVer()) {
	233	c1out << " " << Pkg.FullName(true) << " " << I.OwnerVer().VerStr();
	234	if (Cache[Pkg].Install() == true && Cache[Pkg].NewInstall() == false)
	235	c1out << _(" [Installed]");
	236	c1out << std::endl;
	237	++provider;
	238	}
	239	}
	240	// if we found no candidate which provide this package, show non-candidates
	241	if (provider == 0)
	242	for (I = Pkg.ProvidesList(); I.end() == false; ++I)
	243	c1out << " " << I.OwnerPkg().FullName(true) << " " << I.OwnerVer().VerStr()
	244	<< _(" [Not candidate version]") << std::endl;
	245	else
	246	out << _("You should explicitly select one to install.") << std::endl;
	247	} else {
	248	ioprintf(c1out,
	249	_("Package %s is not available, but is referred to by another package.\n"
	250	"This may mean that the package is missing, has been obsoleted, or\n"
	251	"is only available from another source\n"),Pkg.FullName(true).c_str());
	252
6cfadda1 DK	253	std::vector<bool> Seen(Cache.GetPkgCache()->Head().PackageCount, false);
	254	APT::PackageList pkglist;
	255	for (pkgCache::DepIterator Dep = Pkg.RevDependsList();
	256	Dep.end() == false; ++Dep) {
	257	if (Dep->Type != pkgCache::Dep::Replaces)
	258	continue;
	259	pkgCache::PkgIterator const DP = Dep.ParentPkg();
	260	if (Seen[DP->ID] == true)
	261	continue;
	262	Seen[DP->ID] = true;
	263	pkglist.insert(DP);
	264	}
	265	ShowList(c1out, _("However the following packages replace it:"), pkglist,
	266	&AlwaysTrue, &PrettyFullName, &EmptyString);
	267	}
	268	c1out << std::endl;
	269	}
	270	return false;
	271	}
	272	pkgCache::VerIterator CacheSetHelperAPTGet::canNotFindCandidateVer(pkgCacheFile &Cache, pkgCache::PkgIterator const &Pkg)
	273	{
	274	APT::VersionSet const verset = tryVirtualPackage(Cache, Pkg, CacheSetHelper::CANDIDATE);
	275	if (verset.empty() == false)
	276	return *(verset.begin());
	277	else if (ShowError == true) {
	278	_error->Error(_("Package '%s' has no installation candidate"),Pkg.FullName(true).c_str());
	279	virtualPkgs.insert(Pkg);
	280	}
	281	return pkgCache::VerIterator(Cache, 0);
	282	}
	283	pkgCache::VerIterator CacheSetHelperAPTGet::canNotFindNewestVer(pkgCacheFile &Cache, pkgCache::PkgIterator const &Pkg)
	284	{
	285	if (Pkg->ProvidesList != 0)
	286	{
	287	APT::VersionSet const verset = tryVirtualPackage(Cache, Pkg, CacheSetHelper::NEWEST);
	288	if (verset.empty() == false)
	289	return *(verset.begin());
	290	if (ShowError == true)
	291	ioprintf(out, _("Virtual packages like '%s' can't be removed\n"), Pkg.FullName(true).c_str());
	292	}
	293	else
	294	{
	295	pkgCache::GrpIterator Grp = Pkg.Group();
	296	pkgCache::PkgIterator P = Grp.PackageList();
	297	for (; P.end() != true; P = Grp.NextPkg(P))
	298	{
	299	if (P == Pkg)
	300	continue;
	301	if (P->CurrentVer != 0) {
	302	// TRANSLATORS: Note, this is not an interactive question
	303	ioprintf(c1out,_("Package '%s' is not installed, so not removed. Did you mean '%s'?\n"),
	304	Pkg.FullName(true).c_str(), P.FullName(true).c_str());
	305	break;
	306	}
	307	}
	308	if (P.end() == true)
	309	ioprintf(c1out,_("Package '%s' is not installed, so not removed\n"),Pkg.FullName(true).c_str());
	310	}
	311	return pkgCache::VerIterator(Cache, 0);
	312	}
	313	APT::VersionSet CacheSetHelperAPTGet::tryVirtualPackage(pkgCacheFile &Cache, pkgCache::PkgIterator const &Pkg,
	314	CacheSetHelper::VerSelector const select)
	315	{
	316	/* This is a pure virtual package and there is a single available
317	candidate providing it. */
318	if (unlikely(Cache[Pkg].CandidateVer != 0) \|\| Pkg->ProvidesList == 0)
319	return APT::VersionSet();
320
321	pkgCache::PkgIterator Prov;
322	bool found_one = false;
323	for (pkgCache::PrvIterator P = Pkg.ProvidesList(); P; ++P) {
324	pkgCache::VerIterator const PVer = P.OwnerVer();
325	pkgCache::PkgIterator const PPkg = PVer.ParentPkg();
326
327	/* Ignore versions that are not a candidate. */
328	if (Cache[PPkg].CandidateVer != PVer)
329	continue;
330
331	if (found_one == false) {
332	Prov = PPkg;
333	found_one = true;
334	} else if (PPkg != Prov) {
335	// same group, so it's a foreign package
336	if (PPkg->Group == Prov->Group) {
337	// do we already have the requested arch?
338	if (strcmp(Pkg.Arch(), Prov.Arch()) == 0 \|\|
339	strcmp(Prov.Arch(), "all") == 0 \|\|
340	unlikely(strcmp(PPkg.Arch(), Prov.Arch()) == 0)) // packages have only on candidate, but just to be sure
341	continue;
342	// see which architecture we prefer more and switch to it
343	std::vector<std::string> archs = APT::Configuration::getArchitectures();
344	if (std::find(archs.begin(), archs.end(), PPkg.Arch()) < std::find(archs.begin(), archs.end(), Prov.Arch()))
345	Prov = PPkg;
346	continue;
347	}
348	found_one = false; // we found at least two
349	break;
350	}
351	}
352
353	if (found_one == true) {
354	ioprintf(out, _("Note, selecting '%s' instead of '%s'\n"),
355	Prov.FullName(true).c_str(), Pkg.FullName(true).c_str());
356	return APT::VersionSet::FromPackage(Cache, Prov, select, *this);
357	}
358	return APT::VersionSet();
3addaba1 DK	359	}
	360	pkgCache::PkgIterator CacheSetHelperAPTGet::canNotFindPkgName(pkgCacheFile &Cache, std::string const &str)
	361	{
	362	pkgCache::PkgIterator const Pkg = canNotFindPkgName_impl(Cache, str);
	363	if (Pkg.end())
	364	return APT::CacheSetHelper::canNotFindPkgName(Cache, str);
	365	return Pkg;
6cfadda1 DK	366	}
6cfadda1 DK	367	/}}}/