#include "pool.h"
#include "repo.h"
#include "util.h"
+#include "policy.h"
+#include "poolvendor.h"
#include "chksum.h"
+#include "linkedpkg.h"
const char *
pool_solvable2str(Pool *pool, Solvable *s)
}
p = pool_alloctmpspace(pool, nl + el + al + 3);
strcpy(p, n);
- p[nl] = '-';
- strncpy(p + nl + 1, e, el);
- p[nl + 1 + el] = '.';
- strcpy(p + nl + 1 + el + 1, a);
+ if (el)
+ {
+ p[nl++] = '-';
+ strncpy(p + nl, e, el);
+ p[nl + el] = 0;
+ }
+ if (al)
+ {
+ p[nl + el] = pool->disttype == DISTTYPE_HAIKU ? '-' : '.';
+ strcpy(p + nl + el + 1, a);
+ }
return p;
}
return repo_lookup_deparray(s->repo, s - s->repo->pool->solvables, keyname, q, marker);
}
+static const char *
+solvable_lookup_str_joinarray(Solvable *s, Id keyname, const char *joinstr)
+{
+ Queue q;
+ Id qbuf[10];
+ char *str = 0;
+
+ queue_init_buffer(&q, qbuf, sizeof(qbuf)/sizeof(*qbuf));
+ if (solvable_lookup_idarray(s, keyname, &q) && q.count)
+ {
+ Pool *pool = s->repo->pool;
+ int i;
+ str = pool_tmpjoin(pool, pool_id2str(pool, q.elements[0]), 0, 0);
+ for (i = 1; i < q.count; i++)
+ str = pool_tmpappend(pool, str, joinstr, pool_id2str(pool, q.elements[i]));
+ }
+ queue_free(&q);
+ return str;
+}
+
const char *
solvable_lookup_str(Solvable *s, Id keyname)
{
+ const char *str;
if (!s->repo)
return 0;
- return repo_lookup_str(s->repo, s - s->repo->pool->solvables, keyname);
+ str = repo_lookup_str(s->repo, s - s->repo->pool->solvables, keyname);
+ if (!str && (keyname == SOLVABLE_LICENSE || keyname == SOLVABLE_GROUP))
+ str = solvable_lookup_str_joinarray(s, keyname, ", ");
+ return str;
}
static const char *
{
Pool *pool;
const char *str, *basestr;
- Id p, pp;
+ Id p, pp, name;
Solvable *s2;
int pass;
* translation */
if (!pool->whatprovides)
return usebase ? basestr : 0;
+ name = s->name;
/* we do this in two passes, first same vendor, then all other vendors */
for (pass = 0; pass < 2; pass++)
{
- FOR_PROVIDES(p, pp, s->name)
+ FOR_PROVIDES(p, pp, name)
{
s2 = pool->solvables + p;
- if (s2->name != s->name)
+ if (s2->name != name)
continue;
if ((s->vendor == s2->vendor) != (pass == 0))
continue;
if (str)
return str;
}
+#ifdef ENABLE_LINKED_PKGS
+ /* autopattern/product translation magic */
+ if (pass)
+ {
+ const char *n = pool_id2str(pool, name);
+ if (*n == 'p')
+ {
+ if (!strncmp("pattern:", n, 8) && (name = find_autopattern_name(pool, s)) != 0)
+ pass = -1;
+ if (!strncmp("product:", n, 8) && (name = find_autoproduct_name(pool, s)) != 0)
+ pass = -1;
+ }
+ }
+#endif
}
return usebase ? basestr : 0;
}
return 0;
pool = s->repo->pool;
if (medianrp)
- *medianrp = solvable_lookup_num(s, SOLVABLE_MEDIANR, 1);
+ *medianrp = solvable_lookup_num(s, SOLVABLE_MEDIANR, 0);
if (solvable_lookup_void(s, SOLVABLE_MEDIADIR))
mediadir = pool_id2str(pool, s->arch);
else
const char *
solvable_get_location(Solvable *s, unsigned int *medianrp)
{
- return solvable_lookup_location(s, medianrp);
+ const char *loc = solvable_lookup_location(s, medianrp);
+ if (medianrp && *medianrp == 0)
+ *medianrp = 1; /* compat, to be removed */
+ return loc;
}
const char *
str = pool_tmpappend(pool, str, ".", pool_id2str(pool, archid));
return pool_tmpappend(pool, str, ".rpm", 0);
}
- else
+ else
return name; /* FIXME */
}
{
while (ISRELDEP(dep))
{
- Reldep *rd = rd = GETRELDEP(pool, dep);
+ Reldep *rd = GETRELDEP(pool, dep);
dep = rd->name;
}
return dep;
}
-static int providedbyinstalled_multiversion(Pool *pool, Map *installed, Id n, Id con)
+static int providedbyinstalled_multiversion(Pool *pool, Map *installed, Id n, Id con)
{
Id p, pp;
- Solvable *sn = pool->solvables + n;
+ Solvable *sn = pool->solvables + n;
FOR_PROVIDES(p, pp, sn->name)
- {
- Solvable *s = pool->solvables + p;
+ {
+ Solvable *s = pool->solvables + p;
if (s->name != sn->name || s->arch != sn->arch)
continue;
if (!MAPTST(installed, p))
if (pool_match_nevr(pool, pool->solvables + p, con))
continue;
return 1; /* found installed package that doesn't conflict */
- }
+ }
return 0;
}
-static inline int providedbyinstalled(Pool *pool, Map *installed, Id dep, int ispatch, Map *noobsoletesmap)
+static inline int providedbyinstalled(Pool *pool, Map *installed, Id dep, int ispatch, Map *multiversionmap)
{
Id p, pp;
FOR_PROVIDES(p, pp, dep)
return -1;
if (ispatch && !pool_match_nevr(pool, pool->solvables + p, dep))
continue;
- if (ispatch && noobsoletesmap && noobsoletesmap->size && MAPTST(noobsoletesmap, p) && ISRELDEP(dep))
+ if (ispatch && multiversionmap && multiversionmap->size && MAPTST(multiversionmap, p) && ISRELDEP(dep))
if (providedbyinstalled_multiversion(pool, installed, p, dep))
continue;
if (MAPTST(installed, p))
* -1: solvable is installable, but doesn't constrain any installed packages
*/
int
-solvable_trivial_installable_map(Solvable *s, Map *installedmap, Map *conflictsmap, Map *noobsoletesmap)
+solvable_trivial_installable_map(Solvable *s, Map *installedmap, Map *conflictsmap, Map *multiversionmap)
{
Pool *pool = s->repo->pool;
Solvable *s2;
conp = s->repo->idarraydata + s->conflicts;
while ((con = *conp++) != 0)
{
- if (providedbyinstalled(pool, installedmap, con, ispatch, noobsoletesmap))
- return 0;
+ if (providedbyinstalled(pool, installedmap, con, ispatch, multiversionmap))
+ {
+ if (ispatch && solvable_is_irrelevant_patch(s, installedmap))
+ return -1;
+ return 0;
+ }
if (!interesting && ISRELDEP(con))
{
con = dep2name(pool, con);
- if (providedbyinstalled(pool, installedmap, con, ispatch, noobsoletesmap))
+ if (providedbyinstalled(pool, installedmap, con, ispatch, multiversionmap))
interesting = 1;
}
}
+ if (ispatch && interesting && solvable_is_irrelevant_patch(s, installedmap))
+ interesting = 0;
}
#if 0
if (s->repo)
* by a queue.
*/
int
-solvable_trivial_installable_queue(Solvable *s, Queue *installed, Map *noobsoletesmap)
+solvable_trivial_installable_queue(Solvable *s, Queue *installed, Map *multiversionmap)
{
Pool *pool = s->repo->pool;
int i;
if (p > 0) /* makes it work with decisionq */
MAPSET(&installedmap, p);
}
- r = solvable_trivial_installable_map(s, &installedmap, 0, noobsoletesmap);
+ r = solvable_trivial_installable_map(s, &installedmap, 0, multiversionmap);
map_free(&installedmap);
return r;
}
* by a repo containing the installed solvables.
*/
int
-solvable_trivial_installable_repo(Solvable *s, Repo *installed, Map *noobsoletesmap)
+solvable_trivial_installable_repo(Solvable *s, Repo *installed, Map *multiversionmap)
{
Pool *pool = s->repo->pool;
Id p;
map_init(&installedmap, pool->nsolvables);
FOR_REPO_SOLVABLES(installed, p, s2)
MAPSET(&installedmap, p);
- r = solvable_trivial_installable_map(s, &installedmap, 0, noobsoletesmap);
+ r = solvable_trivial_installable_map(s, &installedmap, 0, multiversionmap);
map_free(&installedmap);
return r;
}
+/* FIXME: this mirrors policy_illegal_vendorchange */
+static int
+pool_illegal_vendorchange(Pool *pool, Solvable *s1, Solvable *s2)
+{
+ Id v1, v2;
+ Id vendormask1, vendormask2;
+
+ if (pool->custom_vendorcheck)
+ return pool->custom_vendorcheck(pool, s1, s2);
+ /* treat a missing vendor as empty string */
+ v1 = s1->vendor ? s1->vendor : ID_EMPTY;
+ v2 = s2->vendor ? s2->vendor : ID_EMPTY;
+ if (v1 == v2)
+ return 0;
+ vendormask1 = pool_vendor2mask(pool, v1);
+ if (!vendormask1)
+ return 1; /* can't match */
+ vendormask2 = pool_vendor2mask(pool, v2);
+ if ((vendormask1 & vendormask2) != 0)
+ return 0;
+ return 1; /* no class matches */
+}
+
+/* check if this patch is relevant according to the vendor. To bad that patches
+ * don't have a vendor, so we need to do some careful repo testing. */
+int
+solvable_is_irrelevant_patch(Solvable *s, Map *installedmap)
+{
+ Pool *pool = s->repo->pool;
+ Id con, *conp;
+ int hadpatchpackage = 0;
+
+ if (!s->conflicts)
+ return 0;
+ conp = s->repo->idarraydata + s->conflicts;
+ while ((con = *conp++) != 0)
+ {
+ Reldep *rd;
+ Id p, pp, p2, pp2;
+ if (!ISRELDEP(con))
+ continue;
+ rd = GETRELDEP(pool, con);
+ if (rd->flags != REL_LT)
+ continue;
+ FOR_PROVIDES(p, pp, con)
+ {
+ Solvable *si;
+ if (!MAPTST(installedmap, p))
+ continue;
+ si = pool->solvables + p;
+ if (!pool_match_nevr(pool, si, con))
+ continue;
+ FOR_PROVIDES(p2, pp2, rd->name)
+ {
+ Solvable *s2 = pool->solvables + p2;
+ if (!pool_match_nevr(pool, s2, rd->name))
+ continue;
+ if (pool_match_nevr(pool, s2, con))
+ continue; /* does not fulfill patch */
+ if (s2->repo == s->repo)
+ {
+ hadpatchpackage = 1;
+ /* ok, we have a package from the patch repo that solves the conflict. check vendor */
+ if (si->vendor == s2->vendor)
+ return 0;
+ if (!pool_illegal_vendorchange(pool, si, s2))
+ return 0;
+ /* vendor change was illegal, ignore conflict */
+ }
+ }
+ }
+ }
+ /* if we didn't find a patchpackage don't claim that the patch is irrelevant */
+ if (!hadpatchpackage)
+ return 0;
+ return 1;
+}
/*****************************************************************************/
/*
* Create maps containing the state of each solvable. Input is a "installed" queue,
* it contains all solvable ids that are considered to be installed.
- *
+ *
* The created maps can be used for solvable_trivial_installable_map(),
* pool_calc_duchanges(), pool_calc_installsizechange().
*
{
repo_unset(s->repo, s - s->repo->pool->solvables, keyname);
}
+
+/* return true if a dependency intersects dep in the keyname array */
+int
+solvable_matchesdep(Solvable *s, Id keyname, Id dep, int marker)
+{
+ int i;
+ Pool *pool = s->repo->pool;
+ Queue q;
+ queue_init(&q);
+ solvable_lookup_deparray(s, keyname, &q, marker);
+ for (i = 0; i < q.count; i++)
+ if (pool_match_dep(pool, q.elements[i], dep))
+ break;
+ i = i == q.count ? 0 : 1;
+ queue_free(&q);
+ return i;
+}