summaryrefslogtreecommitdiff
path: root/apt-pkg
diff options
context:
space:
mode:
authorMichael Vogt <michael.vogt@ubuntu.com>2012-11-01 10:44:13 +0100
committerMichael Vogt <michael.vogt@ubuntu.com>2012-11-01 10:44:13 +0100
commitf69b2c3d2984cd4dca485fb05ab84df94067c50d (patch)
tree11ac3bcba3399c2fa5c8d7fc45555d490a0497ff /apt-pkg
parent6292ea19bc71d0c1b977693195dcf9153bd07555 (diff)
parent446fb1002ad218929f3a6da911388b160b738f2a (diff)
merged from the debian-sid branch
Diffstat (limited to 'apt-pkg')
-rw-r--r--apt-pkg/algorithms.cc5
-rw-r--r--apt-pkg/contrib/netrc.cc63
-rw-r--r--apt-pkg/contrib/netrc.h8
-rw-r--r--apt-pkg/deb/deblistparser.cc22
-rw-r--r--apt-pkg/deb/dpkgpm.cc8
-rw-r--r--apt-pkg/depcache.cc2
-rw-r--r--apt-pkg/edsp.cc6
-rw-r--r--apt-pkg/packagemanager.cc2
-rw-r--r--apt-pkg/pkgcache.cc31
-rw-r--r--apt-pkg/pkgcachegen.cc62
-rw-r--r--apt-pkg/policy.cc49
11 files changed, 186 insertions, 72 deletions
diff --git a/apt-pkg/algorithms.cc b/apt-pkg/algorithms.cc
index 2f5fcc7ab..1b0161ffd 100644
--- a/apt-pkg/algorithms.cc
+++ b/apt-pkg/algorithms.cc
@@ -194,6 +194,11 @@ bool pkgSimulate::Remove(PkgIterator iPkg,bool Purge)
{
// Adapt the iterator
PkgIterator Pkg = Sim.FindPkg(iPkg.Name(), iPkg.Arch());
+ if (Pkg.end() == true)
+ {
+ std::cerr << (Purge ? "Purg" : "Remv") << " invalid package " << iPkg.FullName() << std::endl;
+ return false;
+ }
Flags[Pkg->ID] = 3;
Sim.MarkDelete(Pkg);
diff --git a/apt-pkg/contrib/netrc.cc b/apt-pkg/contrib/netrc.cc
index 2321ef063..0a902f126 100644
--- a/apt-pkg/contrib/netrc.cc
+++ b/apt-pkg/contrib/netrc.cc
@@ -45,11 +45,11 @@ enum {
#define NETRC DOT_CHAR "netrc"
/* returns -1 on failure, 0 if the host is found, 1 is the host isn't found */
-int parsenetrc (char *host, char *login, char *password, char *netrcfile = NULL)
+static int parsenetrc_string (char *host, std::string &login, std::string &password, char *netrcfile = NULL)
{
FILE *file;
int retcode = 1;
- int specific_login = (login[0] != 0);
+ int specific_login = (login.empty() == false);
char *home = NULL;
bool netrc_alloc = false;
@@ -80,16 +80,17 @@ int parsenetrc (char *host, char *login, char *password, char *netrcfile = NULL)
char *tok;
char *tok_buf;
bool done = false;
- char netrcbuffer[256];
+ char *netrcbuffer = NULL;
+ size_t netrcbuffer_size = 0;
int state = NOTHING;
char state_login = 0; /* Found a login keyword */
char state_password = 0; /* Found a password keyword */
- while (!done && fgets(netrcbuffer, sizeof (netrcbuffer), file)) {
+ while (!done && getline(&netrcbuffer, &netrcbuffer_size, file) != -1) {
tok = strtok_r (netrcbuffer, " \t\n", &tok_buf);
while (!done && tok) {
- if(login[0] && password[0]) {
+ if(login.empty() == false && password.empty() == false) {
done = true;
break;
}
@@ -121,23 +122,13 @@ int parsenetrc (char *host, char *login, char *password, char *netrcfile = NULL)
/* we are now parsing sub-keywords concerning "our" host */
if (state_login) {
if (specific_login)
- state_our_login = !strcasecmp (login, tok);
+ state_our_login = !strcasecmp (login.c_str(), tok);
else
- {
- if (strlen(tok) > LOGINSIZE)
- _error->Error("login token too long %i (max: %i)",
- strlen(tok), LOGINSIZE);
- strncpy (login, tok, LOGINSIZE - 1);
- }
+ login = tok;
state_login = 0;
} else if (state_password) {
- if (state_our_login || !specific_login)
- {
- if (strlen(tok) > PASSWORDSIZE)
- _error->Error("password token too long %i (max %i)",
- strlen(tok), PASSWORDSIZE);
- strncpy (password, tok, PASSWORDSIZE - 1);
- }
+ if (state_our_login || !specific_login)
+ password = tok;
state_password = 0;
} else if (!strcasecmp ("login", tok))
state_login = 1;
@@ -153,8 +144,9 @@ int parsenetrc (char *host, char *login, char *password, char *netrcfile = NULL)
tok = strtok_r (NULL, " \t\n", &tok_buf);
} /* while(tok) */
- } /* while fgets() */
+ } /* while getline() */
+ free(netrcbuffer);
fclose(file);
}
@@ -163,6 +155,18 @@ int parsenetrc (char *host, char *login, char *password, char *netrcfile = NULL)
return retcode;
}
+// for some unknown reason this method is exported so keep a compatible interface for now …
+int parsenetrc (char *host, char *login, char *password, char *netrcfile = NULL)
+{
+ std::string login_string, password_string;
+ int const ret = parsenetrc_string(host, login_string, password_string, netrcfile);
+ if (ret < 0)
+ return ret;
+ strncpy(login, login_string.c_str(), LOGINSIZE - 1);
+ strncpy(password, password_string.c_str(), PASSWORDSIZE - 1);
+ return ret;
+}
+
void maybe_add_auth (URI &Uri, string NetRCFile)
{
@@ -173,21 +177,20 @@ void maybe_add_auth (URI &Uri, string NetRCFile)
{
if (NetRCFile.empty () == false)
{
- char login[LOGINSIZE] = "";
- char password[PASSWORDSIZE] = "";
+ std::string login, password;
char *netrcfile = strdup(NetRCFile.c_str());
// first check for a generic host based netrc entry
char *host = strdup(Uri.Host.c_str());
- if (host && parsenetrc (host, login, password, netrcfile) == 0)
+ if (host && parsenetrc_string(host, login, password, netrcfile) == 0)
{
if (_config->FindB("Debug::Acquire::netrc", false) == true)
std::clog << "host: " << host
<< " user: " << login
- << " pass-size: " << strlen(password)
+ << " pass-size: " << password.size()
<< std::endl;
- Uri.User = string (login);
- Uri.Password = string (password);
+ Uri.User = login;
+ Uri.Password = password;
free(netrcfile);
free(host);
return;
@@ -198,15 +201,15 @@ void maybe_add_auth (URI &Uri, string NetRCFile)
// a lookup uri.startswith(host) in the netrc file parser (because
// of the "/"
char *hostpath = strdup(string(Uri.Host+Uri.Path).c_str());
- if (hostpath && parsenetrc (hostpath, login, password, netrcfile) == 0)
+ if (hostpath && parsenetrc_string(hostpath, login, password, netrcfile) == 0)
{
if (_config->FindB("Debug::Acquire::netrc", false) == true)
std::clog << "hostpath: " << hostpath
<< " user: " << login
- << " pass-size: " << strlen(password)
+ << " pass-size: " << password.size()
<< std::endl;
- Uri.User = string (login);
- Uri.Password = string (password);
+ Uri.User = login;
+ Uri.Password = password;
}
free(netrcfile);
free(hostpath);
diff --git a/apt-pkg/contrib/netrc.h b/apt-pkg/contrib/netrc.h
index 5931d4a42..6feb5b726 100644
--- a/apt-pkg/contrib/netrc.h
+++ b/apt-pkg/contrib/netrc.h
@@ -25,11 +25,9 @@
class URI;
-// Assume: password[0]=0, host[0] != 0.
-// If login[0] = 0, search for login and password within a machine section
-// in the netrc.
-// If login[0] != 0, search for password within machine and login.
-int parsenetrc (char *host, char *login, char *password, char *filename);
+// kill this export on the next ABI break - strongly doubt its in use anyway
+// outside of the apt itself, its really a internal interface
+__deprecated int parsenetrc (char *host, char *login, char *password, char *filename);
void maybe_add_auth (URI &Uri, std::string NetRCFile);
#endif
diff --git a/apt-pkg/deb/deblistparser.cc b/apt-pkg/deb/deblistparser.cc
index 12c6ab4c9..b84bd6fdd 100644
--- a/apt-pkg/deb/deblistparser.cc
+++ b/apt-pkg/deb/deblistparser.cc
@@ -645,6 +645,8 @@ bool debListParser::ParseDepends(pkgCache::VerIterator &Ver,
a != Architectures.end(); ++a)
if (NewDepends(Ver,Package,*a,Version,Op,Type) == false)
return false;
+ if (NewDepends(Ver,Package,"none",Version,Op,Type) == false)
+ return false;
}
else if (MultiArchEnabled == true && found != string::npos &&
strcmp(Package.c_str() + found, ":any") != 0)
@@ -658,8 +660,18 @@ bool debListParser::ParseDepends(pkgCache::VerIterator &Ver,
if (NewDepends(Ver,Package,Arch,Version,Op,Type) == false)
return false;
}
- else if (NewDepends(Ver,Package,pkgArch,Version,Op,Type) == false)
- return false;
+ else
+ {
+ if (NewDepends(Ver,Package,pkgArch,Version,Op,Type) == false)
+ return false;
+ if ((Type == pkgCache::Dep::Conflicts ||
+ Type == pkgCache::Dep::DpkgBreaks ||
+ Type == pkgCache::Dep::Replaces) &&
+ NewDepends(Ver, Package,
+ (pkgArch != "none") ? "none" : _config->Find("APT::Architecture"),
+ Version,Op,Type) == false)
+ return false;
+ }
if (Start == Stop)
break;
}
@@ -753,13 +765,15 @@ bool debListParser::Step()
drop the whole section. A missing arch tag only happens (in theory)
inside the Status file, so that is a positive return */
string const Architecture = Section.FindS("Architecture");
- if (Architecture.empty() == true)
- return true;
if (Arch.empty() == true || Arch == "any" || MultiArchEnabled == false)
{
if (APT::Configuration::checkArchitecture(Architecture) == true)
return true;
+ /* parse version stanzas without an architecture only in the status file
+ (and as misfortune bycatch flat-archives) */
+ if ((Arch.empty() == true || Arch == "any") && Architecture.empty() == true)
+ return true;
}
else
{
diff --git a/apt-pkg/deb/dpkgpm.cc b/apt-pkg/deb/dpkgpm.cc
index 4f0957b8e..8732fba88 100644
--- a/apt-pkg/deb/dpkgpm.cc
+++ b/apt-pkg/deb/dpkgpm.cc
@@ -1130,7 +1130,9 @@ bool pkgDPkgPM::Go(int OutStatusFd)
if (I->Op == Item::Configure && disappearedPkgs.find(I->Pkg.Name()) != disappearedPkgs.end())
continue;
// We keep this here to allow "smooth" transitions from e.g. multiarch dpkg/ubuntu to dpkg/debian
- if (dpkgMultiArch == false && (I->Pkg.Arch() == nativeArch || !strcmp(I->Pkg.Arch(), "all")))
+ if (dpkgMultiArch == false && (I->Pkg.Arch() == nativeArch ||
+ strcmp(I->Pkg.Arch(), "all") == 0 ||
+ strcmp(I->Pkg.Arch(), "none") == 0))
{
char const * const name = I->Pkg.Name();
ADDARG(name);
@@ -1147,7 +1149,9 @@ bool pkgDPkgPM::Go(int OutStatusFd)
}
else
PkgVer = Cache[I->Pkg].InstVerIter(Cache);
- if (PkgVer.end() == false)
+ if (strcmp(I->Pkg.Arch(), "none") == 0)
+ ; // never arch-qualify a package without an arch
+ else if (PkgVer.end() == false)
name.append(":").append(PkgVer.Arch());
else
_error->Warning("Can not find PkgVer for '%s'", name.c_str());
diff --git a/apt-pkg/depcache.cc b/apt-pkg/depcache.cc
index 2656e9b42..deb8ec21f 100644
--- a/apt-pkg/depcache.cc
+++ b/apt-pkg/depcache.cc
@@ -346,7 +346,7 @@ bool pkgDepCache::CheckDep(DepIterator Dep,int Type,PkgIterator &Res)
/* Check simple depends. A depends -should- never self match but
we allow it anyhow because dpkg does. Technically it is a packaging
bug. Conflicts may never self match */
- if (Dep.TargetPkg() != Dep.ParentPkg() || Dep.IsNegative() == false)
+ if (Dep.IsIgnorable(Res) == false)
{
PkgIterator Pkg = Dep.TargetPkg();
// Check the base package
diff --git a/apt-pkg/edsp.cc b/apt-pkg/edsp.cc
index adb8788b3..6ce9da784 100644
--- a/apt-pkg/edsp.cc
+++ b/apt-pkg/edsp.cc
@@ -214,9 +214,11 @@ bool EDSP::WriteRequest(pkgDepCache &Cache, FILE* output, bool const Upgrade,
if (Progress != NULL && p % 100 == 0)
Progress->Progress(p);
string* req;
- if (Cache[Pkg].Delete() == true)
+ pkgDepCache::StateCache &P = Cache[Pkg];
+ if (P.Delete() == true)
req = &del;
- else if (Cache[Pkg].NewInstall() == true || Cache[Pkg].Upgrade() == true)
+ else if (P.NewInstall() == true || P.Upgrade() == true || P.ReInstall() == true ||
+ (P.Mode == pkgDepCache::ModeKeep && (P.iFlags & pkgDepCache::Protected) == pkgDepCache::Protected))
req = &inst;
else
continue;
diff --git a/apt-pkg/packagemanager.cc b/apt-pkg/packagemanager.cc
index ed817934b..9848ac1b0 100644
--- a/apt-pkg/packagemanager.cc
+++ b/apt-pkg/packagemanager.cc
@@ -492,6 +492,7 @@ bool pkgPackageManager::SmartConfigure(PkgIterator Pkg, int const Depth)
P.end() == false; P = Pkg.Group().NextPkg(P))
{
if (Pkg == P || List->IsFlag(P,pkgOrderList::Configured) == true ||
+ List->IsFlag(P,pkgOrderList::UnPacked) == false ||
Cache[P].InstallVer == 0 || (P.CurrentVer() == Cache[P].InstallVer &&
(Cache[Pkg].iFlags & pkgDepCache::ReInstall) != pkgDepCache::ReInstall))
continue;
@@ -877,6 +878,7 @@ bool pkgPackageManager::SmartUnPack(PkgIterator Pkg, bool const Immediate, int c
P.end() == false; P = Pkg.Group().NextPkg(P))
{
if (P->CurrentVer != 0 || P == Pkg || List->IsFlag(P,pkgOrderList::UnPacked) == true ||
+ List->IsFlag(P,pkgOrderList::Configured) == true ||
Cache[P].InstallVer == 0 || (P.CurrentVer() == Cache[P].InstallVer &&
(Cache[Pkg].iFlags & pkgDepCache::ReInstall) != pkgDepCache::ReInstall))
continue;
diff --git a/apt-pkg/pkgcache.cc b/apt-pkg/pkgcache.cc
index 9acb7da72..1de33ff9b 100644
--- a/apt-pkg/pkgcache.cc
+++ b/apt-pkg/pkgcache.cc
@@ -238,7 +238,7 @@ pkgCache::PkgIterator pkgCache::FindPkg(const string &Name) {
// ---------------------------------------------------------------------
/* Returns 0 on error, pointer to the package otherwise */
pkgCache::PkgIterator pkgCache::FindPkg(const string &Name, string const &Arch) {
- if (MultiArchCache() == false) {
+ if (MultiArchCache() == false && Arch != "none") {
if (Arch == "native" || Arch == "all" || Arch == "any" ||
Arch == NativeArch())
return SingleArchFindPkg(Name);
@@ -376,6 +376,10 @@ pkgCache::PkgIterator pkgCache::GrpIterator::FindPreferredPkg(bool const &Prefer
if (Pkg.end() == false && (PreferNonVirtual == false || Pkg->VersionList != 0))
return Pkg;
}
+ // packages without an architecture
+ Pkg = FindPkg("none");
+ if (Pkg.end() == false && (PreferNonVirtual == false || Pkg->VersionList != 0))
+ return Pkg;
if (PreferNonVirtual == true)
return FindPreferredPkg(false);
@@ -686,8 +690,29 @@ void pkgCache::DepIterator::GlobOr(DepIterator &Start,DepIterator &End)
on virtual packages. */
bool pkgCache::DepIterator::IsIgnorable(PkgIterator const &Pkg) const
{
- if (ParentPkg() == TargetPkg())
- return IsNegative();
+ if (IsNegative() == false)
+ return false;
+
+ pkgCache::PkgIterator PP = ParentPkg();
+ pkgCache::PkgIterator PT = TargetPkg();
+ if (PP->Group != PT->Group)
+ return false;
+ // self-conflict
+ if (PP == PT)
+ return true;
+ pkgCache::VerIterator PV = ParentVer();
+ // ignore group-conflict on a M-A:same package - but not our implicit dependencies
+ // so that we can have M-A:same packages conflicting with their own real name
+ if ((PV->MultiArch & pkgCache::Version::Same) == pkgCache::Version::Same)
+ {
+ // Replaces: ${self}:other ( << ${binary:Version})
+ if (S->Type == pkgCache::Dep::Replaces && S->CompareOp == pkgCache::Dep::Less && strcmp(PV.VerStr(), TargetVer()) == 0)
+ return false;
+ // Breaks: ${self}:other (!= ${binary:Version})
+ if (S->Type == pkgCache::Dep::DpkgBreaks && S->CompareOp == pkgCache::Dep::NotEquals && strcmp(PV.VerStr(), TargetVer()) == 0)
+ return false;
+ return true;
+ }
return false;
}
diff --git a/apt-pkg/pkgcachegen.cc b/apt-pkg/pkgcachegen.cc
index 67018f057..373f6625c 100644
--- a/apt-pkg/pkgcachegen.cc
+++ b/apt-pkg/pkgcachegen.cc
@@ -69,7 +69,9 @@ pkgCacheGenerator::pkgCacheGenerator(DynamicMMap *pMap,OpProgress *Prog) :
*Cache.HeaderP = pkgCache::Header();
map_ptrloc const idxVerSysName = WriteStringInMap(_system->VS->Label);
Cache.HeaderP->VerSysName = idxVerSysName;
- map_ptrloc const idxArchitecture = WriteStringInMap(_config->Find("APT::Architecture"));
+ // this pointer is set in ReMap, but we need it now for WriteUniqString
+ Cache.StringItemP = (pkgCache::StringItem *)Map.Data();
+ map_ptrloc const idxArchitecture = WriteUniqString(_config->Find("APT::Architecture"));
Cache.HeaderP->Architecture = idxArchitecture;
if (unlikely(idxVerSysName == 0 || idxArchitecture == 0))
return;
@@ -195,12 +197,27 @@ bool pkgCacheGenerator::MergeList(ListParser &List,
string const Version = List.Version();
if (Version.empty() == true && Arch.empty() == true)
{
+ // package descriptions
if (MergeListGroup(List, PackageName) == false)
return false;
+ continue;
}
if (Arch.empty() == true)
- Arch = _config->Find("APT::Architecture");
+ {
+ // use the pseudo arch 'none' for arch-less packages
+ Arch = "none";
+ /* We might built a SingleArchCache here, which we don't want to blow up
+ just for these :none packages to a proper MultiArchCache, so just ensure
+ that we have always a native package structure first for SingleArch */
+ pkgCache::PkgIterator NP;
+ Dynamic<pkgCache::PkgIterator> DynPkg(NP);
+ if (NewPackage(NP, PackageName, _config->Find("APT::Architecture")) == false)
+ // TRANSLATOR: The first placeholder is a package name,
+ // the other two should be copied verbatim as they include debug info
+ return _error->Error(_("Error occurred while processing %s (%s%d)"),
+ PackageName.c_str(), "NewPackage", 0);
+ }
// Get a pointer to the package structure
pkgCache::PkgIterator Pkg;
@@ -418,6 +435,43 @@ bool pkgCacheGenerator::MergeListVersion(ListParser &List, pkgCache::PkgIterator
return _error->Error(_("Error occurred while processing %s (%s%d)"),
Pkg.Name(), "AddImplicitDepends", 1);
}
+ /* :none packages are packages without an architecture. They are forbidden by
+ debian-policy, so usually they will only be in (old) dpkg status files -
+ and dpkg will complain about them - and are pretty rare. We therefore do
+ usually not create conflicts while the parent is created, but only if a :none
+ package (= the target) appears. This creates incorrect dependencies on :none
+ for architecture-specific dependencies on the package we copy from, but we
+ will ignore this bug as architecture-specific dependencies are only allowed
+ in jessie and until then the :none packages should be extinct (hopefully).
+ In other words: This should work long enough to allow graceful removal of
+ these packages, it is not supposed to allow users to keep using them … */
+ if (strcmp(Pkg.Arch(), "none") == 0)
+ {
+ pkgCache::PkgIterator M = Grp.FindPreferredPkg();
+ if (M.end() == false && Pkg != M)
+ {
+ pkgCache::DepIterator D = M.RevDependsList();
+ Dynamic<pkgCache::DepIterator> DynD(D);
+ for (; D.end() == false; ++D)
+ {
+ if ((D->Type != pkgCache::Dep::Conflicts &&
+ D->Type != pkgCache::Dep::DpkgBreaks &&
+ D->Type != pkgCache::Dep::Replaces) ||
+ D.ParentPkg().Group() == Grp)
+ continue;
+
+ map_ptrloc *OldDepLast = NULL;
+ pkgCache::VerIterator ConVersion = D.ParentVer();
+ Dynamic<pkgCache::VerIterator> DynV(ConVersion);
+ // duplicate the Conflicts/Breaks/Replaces for :none arch
+ if (D->Version == 0)
+ NewDepends(Pkg, ConVersion, "", 0, D->Type, OldDepLast);
+ else
+ NewDepends(Pkg, ConVersion, D.TargetVer(),
+ D->CompareOp, D->Type, OldDepLast);
+ }
+ }
+ }
}
if (unlikely(AddImplicitDepends(Grp, Pkg, Ver) == false))
return _error->Error(_("Error occurred while processing %s (%s%d)"),
@@ -722,6 +776,7 @@ unsigned long pkgCacheGenerator::NewVersion(pkgCache::VerIterator &Ver,
// Fill it in
Ver = pkgCache::VerIterator(Cache,Cache.VerP + Version);
+ //Dynamic<pkgCache::VerIterator> DynV(Ver); // caller MergeListVersion already takes care of it
Ver->NextVer = Next;
Ver->ID = Cache.HeaderP->VersionCount++;
map_ptrloc const idxVerStr = WriteStringInMap(VerStr);
@@ -871,6 +926,9 @@ bool pkgCacheGenerator::ListParser::NewDepends(pkgCache::VerIterator &Ver,
// Locate the target package
pkgCache::PkgIterator Pkg = Grp.FindPkg(Arch);
+ // we don't create 'none' packages and their dependencies if we can avoid it …
+ if (Pkg.end() == true && Arch == "none" && strcmp(Ver.ParentPkg().Arch(), "none") != 0)
+ return true;
Dynamic<pkgCache::PkgIterator> DynPkg(Pkg);
if (Pkg.end() == true) {
if (unlikely(Owner->NewPackage(Pkg, PackageName, Arch) == false))
diff --git a/apt-pkg/policy.cc b/apt-pkg/policy.cc
index b47dab90c..4ae3b5f87 100644
--- a/apt-pkg/policy.cc
+++ b/apt-pkg/policy.cc
@@ -27,6 +27,7 @@
#include <apt-pkg/policy.h>
#include <apt-pkg/configuration.h>
+#include <apt-pkg/cachefilter.h>
#include <apt-pkg/tagfile.h>
#include <apt-pkg/strutl.h>
#include <apt-pkg/fileutl.h>
@@ -259,17 +260,33 @@ void pkgPolicy::CreatePin(pkgVersionMatch::MatchType Type,string Name,
}
// find the package (group) this pin applies to
- pkgCache::GrpIterator Grp;
- pkgCache::PkgIterator Pkg;
- if (Arch.empty() == false)
- Pkg = Cache->FindPkg(Name, Arch);
- else {
- Grp = Cache->FindGrp(Name);
- if (Grp.end() == false)
- Pkg = Grp.PackageList();
+ pkgCache::GrpIterator Grp = Cache->FindGrp(Name);
+ bool matched = false;
+ if (Grp.end() == false)
+ {
+ std::string MatchingArch;
+ if (Arch.empty() == true)
+ MatchingArch = Cache->NativeArch();
+ else
+ MatchingArch = Arch;
+ APT::CacheFilter::PackageArchitectureMatchesSpecification pams(MatchingArch);
+ for (pkgCache::PkgIterator Pkg = Grp.PackageList(); Pkg.end() != true; Pkg = Grp.NextPkg(Pkg))
+ {
+ if (pams(Pkg.Arch()) == false)
+ continue;
+ Pin *P = Pins + Pkg->ID;
+ // the first specific stanza for a package is the ruler,
+ // all others need to be ignored
+ if (P->Type != pkgVersionMatch::None)
+ P = &*Unmatched.insert(Unmatched.end(),PkgPin(Pkg.FullName()));
+ P->Type = Type;
+ P->Priority = Priority;
+ P->Data = Data;
+ matched = true;
+ }
}
- if (Pkg.end() == true)
+ if (matched == false)
{
PkgPin *P = &*Unmatched.insert(Unmatched.end(),PkgPin(Name));
if (Arch.empty() == false)
@@ -279,20 +296,6 @@ void pkgPolicy::CreatePin(pkgVersionMatch::MatchType Type,string Name,
P->Data = Data;
return;
}
-
- for (; Pkg.end() != true; Pkg = Grp.NextPkg(Pkg))
- {
- Pin *P = Pins + Pkg->ID;
- // the first specific stanza for a package is the ruler,
- // all others need to be ignored
- if (P->Type != pkgVersionMatch::None)
- P = &*Unmatched.insert(Unmatched.end(),PkgPin(Pkg.FullName()));
- P->Type = Type;
- P->Priority = Priority;
- P->Data = Data;
- if (Grp.end() == true)
- break;
- }
}
/*}}}*/
// Policy::GetMatch - Get the matching version for a package pin /*{{{*/