2 * Copyright (c) 2008, Novell Inc.
4 * This program is licensed under the BSD license, read LICENSE.BSD
5 * for further information
11 * set/retrieve data from solvables
24 #include "poolvendor.h"
26 #include "linkedpkg.h"
29 pool_solvable2str(Pool *pool, Solvable *s)
31 const char *n, *e, *a;
34 n = pool_id2str(pool, s->name);
35 e = s->evr ? pool_id2str(pool, s->evr) : "";
36 /* XXX: may want to skip the epoch here */
37 a = s->arch ? pool_id2str(pool, s->arch) : "";
41 if (pool->havedistepoch)
43 /* strip the distepoch from the evr */
44 const char *de = strrchr(e, '-');
45 if (de && (de = strchr(de, ':')) != 0)
48 p = pool_alloctmpspace(pool, nl + el + al + 3);
53 strncpy(p + nl, e, el);
58 p[nl + el] = pool->disttype == DISTTYPE_HAIKU ? '-' : '.';
59 strcpy(p + nl + el + 1, a);
61 if (pool->disttype == DISTTYPE_CONDA && solvable_lookup_type(s, SOLVABLE_BUILDFLAVOR))
66 solvable_lookup_idarray(s, SOLVABLE_BUILDFLAVOR, &flavorq);
67 for (i = 0; i < flavorq.count; i++)
68 p = pool_tmpappend(pool, p, "-", pool_id2str(pool, flavorq.elements[i]));
75 solvable_lookup_type(Solvable *s, Id keyname)
79 return repo_lookup_type(s->repo, s - s->repo->pool->solvables, keyname);
83 solvable_lookup_id(Solvable *s, Id keyname)
87 return repo_lookup_id(s->repo, s - s->repo->pool->solvables, keyname);
91 solvable_lookup_idarray(Solvable *s, Id keyname, Queue *q)
98 return repo_lookup_idarray(s->repo, s - s->repo->pool->solvables, keyname, q);
102 solvable_lookup_deparray(Solvable *s, Id keyname, Queue *q, Id marker)
109 return repo_lookup_deparray(s->repo, s - s->repo->pool->solvables, keyname, q, marker);
113 solvable_lookup_str_joinarray(Solvable *s, Id keyname, const char *joinstr)
119 queue_init_buffer(&q, qbuf, sizeof(qbuf)/sizeof(*qbuf));
120 if (solvable_lookup_idarray(s, keyname, &q) && q.count)
122 Pool *pool = s->repo->pool;
124 str = (char *)pool_id2str(pool, q.elements[0]);
128 str = pool_tmpjoin(pool, pool_id2str(pool, q.elements[0]), 0, 0);
129 for (i = 1; i < q.count; i++)
130 str = pool_tmpappend(pool, str, joinstr, pool_id2str(pool, q.elements[i]));
138 solvable_lookup_str(Solvable *s, Id keyname)
143 str = repo_lookup_str(s->repo, s - s->repo->pool->solvables, keyname);
144 if (!str && (keyname == SOLVABLE_LICENSE || keyname == SOLVABLE_GROUP || keyname == SOLVABLE_BUILDFLAVOR))
145 str = solvable_lookup_str_joinarray(s, keyname, ", ");
150 solvable_lookup_str_base(Solvable *s, Id keyname, Id basekeyname, int usebase)
153 const char *str, *basestr;
160 pool = s->repo->pool;
161 str = solvable_lookup_str(s, keyname);
162 if (str || keyname == basekeyname)
164 basestr = solvable_lookup_str(s, basekeyname);
167 /* search for a solvable with same name and same base that has the
169 if (!pool->whatprovides)
170 return usebase ? basestr : 0;
172 /* we do this in two passes, first same vendor, then all other vendors */
173 for (pass = 0; pass < 2; pass++)
175 FOR_PROVIDES(p, pp, name)
177 s2 = pool->solvables + p;
178 if (s2->name != name)
180 if ((s->vendor == s2->vendor) != (pass == 0))
182 str = solvable_lookup_str(s2, basekeyname);
183 if (!str || strcmp(str, basestr))
185 str = solvable_lookup_str(s2, keyname);
189 #ifdef ENABLE_LINKED_PKGS
190 /* autopattern/product translation magic */
193 const char *n = pool_id2str(pool, name);
196 if (!strncmp("pattern:", n, 8) && (name = find_autopattern_name(pool, s)) != 0)
198 if (!strncmp("product:", n, 8) && (name = find_autoproduct_name(pool, s)) != 0)
204 return usebase ? basestr : 0;
208 solvable_lookup_str_poollang(Solvable *s, Id keyname)
217 pool = s->repo->pool;
218 if (!pool->nlanguages)
219 return solvable_lookup_str(s, keyname);
220 cols = pool->nlanguages + 1;
221 if (!pool->languagecache)
223 pool->languagecache = solv_calloc(cols * ID_NUM_INTERNAL, sizeof(Id));
224 pool->languagecacheother = 0;
226 if (keyname >= ID_NUM_INTERNAL)
228 row = pool->languagecache + ID_NUM_INTERNAL * cols;
229 for (i = 0; i < pool->languagecacheother; i++, row += cols)
232 if (i >= pool->languagecacheother)
234 pool->languagecache = solv_realloc2(pool->languagecache, pool->languagecacheother + 1, cols * sizeof(Id));
235 row = pool->languagecache + cols * (ID_NUM_INTERNAL + pool->languagecacheother++);
240 row = pool->languagecache + keyname * cols;
241 row++; /* skip keyname */
242 for (i = 0; i < pool->nlanguages; i++, row++)
245 *row = pool_id2langid(pool, keyname, pool->languages[i], 1);
246 str = solvable_lookup_str_base(s, *row, keyname, 0);
250 return solvable_lookup_str(s, keyname);
254 solvable_lookup_str_lang(Solvable *s, Id keyname, const char *lang, int usebase)
259 id = pool_id2langid(s->repo->pool, keyname, lang, 0);
261 return solvable_lookup_str_base(s, id, keyname, usebase);
264 return solvable_lookup_str(s, keyname);
268 solvable_lookup_num(Solvable *s, Id keyname, unsigned long long notfound)
272 return repo_lookup_num(s->repo, s - s->repo->pool->solvables, keyname, notfound);
276 solvable_lookup_sizek(Solvable *s, Id keyname, unsigned long long notfound)
278 unsigned long long size;
281 size = solvable_lookup_num(s, keyname, (unsigned long long)-1);
282 return size == (unsigned long long)-1 ? notfound : ((size + 1023) >> 10);
286 solvable_lookup_void(Solvable *s, Id keyname)
290 return repo_lookup_void(s->repo, s - s->repo->pool->solvables, keyname);
294 solvable_lookup_bool(Solvable *s, Id keyname)
299 /* historic nonsense: there are two ways of storing a bool, as num == 1 or void. test both. */
300 type = repo_lookup_type(s->repo, s - s->repo->pool->solvables, keyname);
301 if (type == REPOKEY_TYPE_VOID)
303 if (type == REPOKEY_TYPE_NUM || type == REPOKEY_TYPE_CONSTANT)
304 return repo_lookup_num(s->repo, s - s->repo->pool->solvables, keyname, 0) == 1;
308 const unsigned char *
309 solvable_lookup_bin_checksum(Solvable *s, Id keyname, Id *typep)
316 return repo_lookup_bin_checksum(s->repo, s - s->repo->pool->solvables, keyname, typep);
320 solvable_lookup_checksum(Solvable *s, Id keyname, Id *typep)
322 const unsigned char *chk = solvable_lookup_bin_checksum(s, keyname, typep);
323 return chk ? pool_bin2hex(s->repo->pool, chk, solv_chksum_len(*typep)) : 0;
327 solvable_lookup_count(Solvable *s, Id keyname)
329 return s->repo ? repo_lookup_count(s->repo, s - s->repo->pool->solvables, keyname) : 0;
332 static inline const char *
333 evrid2vrstr(Pool *pool, Id evrid)
335 const char *p, *evr = pool_id2str(pool, evrid);
338 for (p = evr; *p >= '0' && *p <= '9'; p++)
340 return p != evr && *p == ':' && p[1] ? p + 1 : evr;
344 solvable_lookup_location(Solvable *s, unsigned int *medianrp)
349 const char *mediadir, *mediafile;
355 pool = s->repo->pool;
357 *medianrp = solvable_lookup_num(s, SOLVABLE_MEDIANR, 0);
358 if (solvable_lookup_void(s, SOLVABLE_MEDIADIR))
359 mediadir = pool_id2str(pool, s->arch);
361 mediadir = solvable_lookup_str(s, SOLVABLE_MEDIADIR);
363 l = strlen(mediadir) + 1;
364 if (solvable_lookup_void(s, SOLVABLE_MEDIAFILE))
366 const char *name, *evr, *arch;
367 name = pool_id2str(pool, s->name);
368 evr = evrid2vrstr(pool, s->evr);
369 arch = pool_id2str(pool, s->arch);
370 /* name-vr.arch.rpm */
371 loc = pool_alloctmpspace(pool, l + strlen(name) + strlen(evr) + strlen(arch) + 7);
373 sprintf(loc, "%s/%s-%s.%s.rpm", mediadir, name, evr, arch);
375 sprintf(loc, "%s-%s.%s.rpm", name, evr, arch);
379 mediafile = solvable_lookup_str(s, SOLVABLE_MEDIAFILE);
382 loc = pool_alloctmpspace(pool, l + strlen(mediafile) + 1);
384 sprintf(loc, "%s/%s", mediadir, mediafile);
386 strcpy(loc, mediafile);
392 solvable_get_location(Solvable *s, unsigned int *medianrp)
394 const char *loc = solvable_lookup_location(s, medianrp);
395 if (medianrp && *medianrp == 0)
396 *medianrp = 1; /* compat, to be removed */
401 solvable_lookup_sourcepkg(Solvable *s)
404 const char *evr, *name;
409 pool = s->repo->pool;
410 if (solvable_lookup_void(s, SOLVABLE_SOURCENAME))
411 name = pool_id2str(pool, s->name);
413 name = solvable_lookup_str(s, SOLVABLE_SOURCENAME);
416 archid = solvable_lookup_id(s, SOLVABLE_SOURCEARCH);
417 if (solvable_lookup_void(s, SOLVABLE_SOURCEEVR))
418 evr = evrid2vrstr(pool, s->evr);
420 evr = solvable_lookup_str(s, SOLVABLE_SOURCEEVR);
421 if (archid == ARCH_SRC || archid == ARCH_NOSRC)
424 str = pool_tmpjoin(pool, name, evr ? "-" : 0, evr);
425 str = pool_tmpappend(pool, str, ".", pool_id2str(pool, archid));
426 return pool_tmpappend(pool, str, ".rpm", 0);
429 return name; /* FIXME */
433 /*****************************************************************************/
436 * Create maps containing the state of each solvable. Input is a "installed" queue,
437 * it contains all solvable ids that are considered to be installed.
439 * The created maps can be used for * pool_calc_duchanges() and
440 * pool_calc_installsizechange().
444 pool_create_state_maps(Pool *pool, Queue *installed, Map *installedmap, Map *conflictsmap)
451 map_init(installedmap, pool->nsolvables);
453 map_init(conflictsmap, pool->nsolvables);
454 for (i = 0; i < installed->count; i++)
456 p = installed->elements[i];
457 if (p <= 0) /* makes it work with decisionq */
459 MAPSET(installedmap, p);
462 s = pool->solvables + p;
465 conp = s->repo->idarraydata + s->conflicts;
466 while ((con = *conp++) != 0)
468 dp = pool_whatprovides_ptr(pool, con);
470 MAPSET(conflictsmap, *dp);
475 /* Tests if two solvables have identical content. Currently
476 * both solvables need to come from the same pool
480 solvable_identical(Solvable *s1, Solvable *s2)
482 unsigned long long bt1, bt2;
485 if (s1->name != s2->name)
487 if (s1->arch != s2->arch)
489 if (s1->evr != s2->evr)
492 /* check vendor, map missing vendor to empty string */
493 if ((s1->vendor ? s1->vendor : 1) != (s2->vendor ? s2->vendor : 1))
495 /* workaround for bug 881493 */
496 if (s1->repo && !strncmp(pool_id2str(s1->repo->pool, s1->name), "product:", 8))
501 /* looking good, try some fancier stuff */
502 /* might also look up the package checksum here */
503 bt1 = solvable_lookup_num(s1, SOLVABLE_BUILDTIME, 0);
504 bt2 = solvable_lookup_num(s2, SOLVABLE_BUILDTIME, 0);
514 /* workaround for bugs 881493 and 885830*/
515 const char *n = pool_id2str(s1->repo->pool, s1->name);
516 if (!strncmp(n, "product:", 8) || !strncmp(n, "application:", 12))
519 /* look at requires in a last attempt to find recompiled packages */
522 for (reqp = s1->repo->idarraydata + s1->requires; *reqp; reqp++)
525 for (reqp = s2->repo->idarraydata + s2->requires; *reqp; reqp++)
530 if (s1->repo && s1->repo->pool->disttype == DISTTYPE_CONDA)
532 /* check buildflavor and buildversion */
533 const char *str1, *str2;
534 str1 = solvable_lookup_str(s1, SOLVABLE_BUILDFLAVOR);
535 str2 = solvable_lookup_str(s2, SOLVABLE_BUILDFLAVOR);
536 if (str1 != str2 && (!str1 || !str2 || strcmp(str1, str2) != 0))
538 str1 = solvable_lookup_str(s1, SOLVABLE_BUILDVERSION);
539 str2 = solvable_lookup_str(s2, SOLVABLE_BUILDVERSION);
540 if (str1 != str2 && (!str1 || !str2 || strcmp(str1, str2) != 0))
546 /* return the self provide dependency of a solvable */
548 solvable_selfprovidedep(Solvable *s)
556 pool = s->repo->pool;
559 provp = s->repo->idarraydata + s->provides;
560 while ((prov = *provp++) != 0)
564 rd = GETRELDEP(pool, prov);
565 if (rd->name == s->name && rd->evr == s->evr && rd->flags == REL_EQ)
569 return pool_rel2id(pool, s->name, s->evr, REL_EQ, 1);
572 /* setter functions, simply call the repo variants */
574 solvable_set_id(Solvable *s, Id keyname, Id id)
576 repo_set_id(s->repo, s - s->repo->pool->solvables, keyname, id);
580 solvable_set_num(Solvable *s, Id keyname, unsigned long long num)
582 repo_set_num(s->repo, s - s->repo->pool->solvables, keyname, num);
586 solvable_set_str(Solvable *s, Id keyname, const char *str)
588 repo_set_str(s->repo, s - s->repo->pool->solvables, keyname, str);
592 solvable_set_poolstr(Solvable *s, Id keyname, const char *str)
594 repo_set_poolstr(s->repo, s - s->repo->pool->solvables, keyname, str);
598 solvable_add_poolstr_array(Solvable *s, Id keyname, const char *str)
600 repo_add_poolstr_array(s->repo, s - s->repo->pool->solvables, keyname, str);
604 solvable_add_idarray(Solvable *s, Id keyname, Id id)
606 repo_add_idarray(s->repo, s - s->repo->pool->solvables, keyname, id);
610 solvable_add_deparray(Solvable *s, Id keyname, Id dep, Id marker)
612 repo_add_deparray(s->repo, s - s->repo->pool->solvables, keyname, dep, marker);
616 solvable_set_idarray(Solvable *s, Id keyname, Queue *q)
618 repo_set_idarray(s->repo, s - s->repo->pool->solvables, keyname, q);
622 solvable_set_deparray(Solvable *s, Id keyname, Queue *q, Id marker)
624 repo_set_deparray(s->repo, s - s->repo->pool->solvables, keyname, q, marker);
628 solvable_unset(Solvable *s, Id keyname)
630 repo_unset(s->repo, s - s->repo->pool->solvables, keyname);
633 /* return true if a dependency intersects dep in the keyname array */
635 solvable_matchesdep(Solvable *s, Id keyname, Id dep, int marker)
638 Pool *pool = s->repo->pool;
641 if (keyname == SOLVABLE_NAME)
642 return pool_match_nevr(pool, s, dep) ? 1 : 0; /* nevr match hack */
644 solvable_lookup_deparray(s, keyname, &q, marker);
645 for (i = 0; i < q.count; i++)
646 if (pool_match_dep(pool, q.elements[i], dep))
648 i = i == q.count ? 0 : 1;
654 solvable_matchessolvable_int(Solvable *s, Id keyname, int marker, Id solvid, Map *solvidmap, Queue *depq, Map *missc, int reloff, Queue *outdepq)
656 Pool *pool = s->repo->pool;
662 if (outdepq && outdepq->count)
663 queue_empty(outdepq);
664 solvable_lookup_deparray(s, keyname, depq, marker);
665 for (i = 0; i < depq->count; i++)
667 Id dep = depq->elements[i];
668 boff = ISRELDEP(dep) ? reloff + GETRELID(dep) : dep;
669 if (MAPTST(missc, boff))
673 Reldep *rd = GETRELDEP(pool, dep);
674 if (!ISRELDEP(rd->name) && rd->flags < 8)
676 /* do pre-filtering on the base */
677 if (MAPTST(missc, rd->name))
679 wp = pool_whatprovides_ptr(pool, rd->name);
683 if (MAPTST(solvidmap, *wp))
694 /* the base does not include solvid, no need to check the complete dep */
695 MAPSET(missc, rd->name);
701 wp = pool_whatprovides_ptr(pool, dep);
705 if (MAPTST(solvidmap, *wp))
718 queue_pushunique(outdepq, dep);
725 return outdepq && outdepq->count ? 1 : 0;
729 solvable_matchessolvable(Solvable *s, Id keyname, Id solvid, Queue *depq, int marker)
731 Pool *pool = s->repo->pool;
732 Map missc; /* cache for misses */
736 if (depq && depq->count)
738 if (s - pool->solvables == solvid)
739 return 0; /* no self-matches */
742 reloff = pool->ss.nstrings;
743 map_init(&missc, reloff + pool->nrels);
744 res = solvable_matchessolvable_int(s, keyname, marker, solvid, 0, &qq, &missc, reloff, depq);