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
26 pool_solvable2str(Pool *pool, Solvable *s)
28 const char *n, *e, *a;
31 n = pool_id2str(pool, s->name);
32 e = pool_id2str(pool, s->evr);
33 /* XXX: may want to skip the epoch here */
34 a = pool_id2str(pool, s->arch);
38 if (pool->havedistepoch)
40 /* strip the distepoch from the evr */
41 const char *de = strrchr(e, '-');
42 if (de && (de = strchr(de, ':')) != 0)
45 p = pool_alloctmpspace(pool, nl + el + al + 3);
48 strncpy(p + nl + 1, e, el);
50 strcpy(p + nl + 1 + el + 1, a);
55 solvable_lookup_type(Solvable *s, Id keyname)
59 return repo_lookup_type(s->repo, s - s->repo->pool->solvables, keyname);
63 solvable_lookup_id(Solvable *s, Id keyname)
67 return repo_lookup_id(s->repo, s - s->repo->pool->solvables, keyname);
71 solvable_lookup_idarray(Solvable *s, Id keyname, Queue *q)
78 return repo_lookup_idarray(s->repo, s - s->repo->pool->solvables, keyname, q);
82 solvable_lookup_deparray(Solvable *s, Id keyname, Queue *q, Id marker)
89 return repo_lookup_deparray(s->repo, s - s->repo->pool->solvables, keyname, q, marker);
93 solvable_lookup_str(Solvable *s, Id keyname)
97 return repo_lookup_str(s->repo, s - s->repo->pool->solvables, keyname);
101 solvable_lookup_str_base(Solvable *s, Id keyname, Id basekeyname, int usebase)
104 const char *str, *basestr;
111 pool = s->repo->pool;
112 str = solvable_lookup_str(s, keyname);
113 if (str || keyname == basekeyname)
115 basestr = solvable_lookup_str(s, basekeyname);
118 /* search for a solvable with same name and same base that has the
120 if (!pool->whatprovides)
121 return usebase ? basestr : 0;
122 /* we do this in two passes, first same vendor, then all other vendors */
123 for (pass = 0; pass < 2; pass++)
125 FOR_PROVIDES(p, pp, s->name)
127 s2 = pool->solvables + p;
128 if (s2->name != s->name)
130 if ((s->vendor == s2->vendor) != (pass == 0))
132 str = solvable_lookup_str(s2, basekeyname);
133 if (!str || strcmp(str, basestr))
135 str = solvable_lookup_str(s2, keyname);
140 return usebase ? basestr : 0;
144 solvable_lookup_str_poollang(Solvable *s, Id keyname)
153 pool = s->repo->pool;
154 if (!pool->nlanguages)
155 return solvable_lookup_str(s, keyname);
156 cols = pool->nlanguages + 1;
157 if (!pool->languagecache)
159 pool->languagecache = solv_calloc(cols * ID_NUM_INTERNAL, sizeof(Id));
160 pool->languagecacheother = 0;
162 if (keyname >= ID_NUM_INTERNAL)
164 row = pool->languagecache + ID_NUM_INTERNAL * cols;
165 for (i = 0; i < pool->languagecacheother; i++, row += cols)
168 if (i >= pool->languagecacheother)
170 pool->languagecache = solv_realloc2(pool->languagecache, pool->languagecacheother + 1, cols * sizeof(Id));
171 row = pool->languagecache + cols * (ID_NUM_INTERNAL + pool->languagecacheother++);
176 row = pool->languagecache + keyname * cols;
177 row++; /* skip keyname */
178 for (i = 0; i < pool->nlanguages; i++, row++)
181 *row = pool_id2langid(pool, keyname, pool->languages[i], 1);
182 str = solvable_lookup_str_base(s, *row, keyname, 0);
186 return solvable_lookup_str(s, keyname);
190 solvable_lookup_str_lang(Solvable *s, Id keyname, const char *lang, int usebase)
194 Id id = pool_id2langid(s->repo->pool, keyname, lang, 0);
196 return solvable_lookup_str_base(s, id, keyname, usebase);
200 return solvable_lookup_str(s, keyname);
204 solvable_lookup_num(Solvable *s, Id keyname, unsigned long long notfound)
208 return repo_lookup_num(s->repo, s - s->repo->pool->solvables, keyname, notfound);
212 solvable_lookup_sizek(Solvable *s, Id keyname, unsigned int notfound)
214 unsigned long long size;
217 size = solvable_lookup_num(s, keyname, (unsigned long long)notfound << 10);
218 return (unsigned int)((size + 1023) >> 10);
222 solvable_lookup_void(Solvable *s, Id keyname)
226 return repo_lookup_void(s->repo, s - s->repo->pool->solvables, keyname);
230 solvable_lookup_bool(Solvable *s, Id keyname)
234 /* historic nonsense: there are two ways of storing a bool, as num == 1 or void. test both. */
235 if (repo_lookup_type(s->repo, s - s->repo->pool->solvables, keyname) == REPOKEY_TYPE_VOID)
237 return repo_lookup_num(s->repo, s - s->repo->pool->solvables, keyname, 0) == 1;
240 const unsigned char *
241 solvable_lookup_bin_checksum(Solvable *s, Id keyname, Id *typep)
243 Repo *repo = s->repo;
250 return repo_lookup_bin_checksum(repo, s - repo->pool->solvables, keyname, typep);
254 solvable_lookup_checksum(Solvable *s, Id keyname, Id *typep)
256 const unsigned char *chk = solvable_lookup_bin_checksum(s, keyname, typep);
257 return chk ? pool_bin2hex(s->repo->pool, chk, solv_chksum_len(*typep)) : 0;
260 static inline const char *
261 evrid2vrstr(Pool *pool, Id evrid)
263 const char *p, *evr = pool_id2str(pool, evrid);
266 for (p = evr; *p >= '0' && *p <= '9'; p++)
268 return p != evr && *p == ':' ? p + 1 : evr;
272 solvable_get_location(Solvable *s, unsigned int *medianrp)
277 const char *mediadir, *mediafile;
283 pool = s->repo->pool;
285 *medianrp = solvable_lookup_num(s, SOLVABLE_MEDIANR, 1);
286 if (solvable_lookup_void(s, SOLVABLE_MEDIADIR))
287 mediadir = pool_id2str(pool, s->arch);
289 mediadir = solvable_lookup_str(s, SOLVABLE_MEDIADIR);
291 l = strlen(mediadir) + 1;
292 if (solvable_lookup_void(s, SOLVABLE_MEDIAFILE))
294 const char *name, *evr, *arch;
295 name = pool_id2str(pool, s->name);
296 evr = evrid2vrstr(pool, s->evr);
297 arch = pool_id2str(pool, s->arch);
298 /* name-vr.arch.rpm */
299 loc = pool_alloctmpspace(pool, l + strlen(name) + strlen(evr) + strlen(arch) + 7);
301 sprintf(loc, "%s/%s-%s.%s.rpm", mediadir, name, evr, arch);
303 sprintf(loc, "%s-%s.%s.rpm", name, evr, arch);
307 mediafile = solvable_lookup_str(s, SOLVABLE_MEDIAFILE);
310 loc = pool_alloctmpspace(pool, l + strlen(mediafile) + 1);
312 sprintf(loc, "%s/%s", mediadir, mediafile);
314 strcpy(loc, mediafile);
319 /*****************************************************************************/
321 static inline Id dep2name(Pool *pool, Id dep)
323 while (ISRELDEP(dep))
325 Reldep *rd = rd = GETRELDEP(pool, dep);
331 static int providedbyinstalled_multiversion(Pool *pool, Map *installed, Id n, Id con)
334 Solvable *sn = pool->solvables + n;
336 FOR_PROVIDES(p, pp, sn->name)
338 Solvable *s = pool->solvables + p;
339 if (s->name != sn->name || s->arch != sn->arch)
341 if (!MAPTST(installed, p))
343 if (pool_match_nevr(pool, pool->solvables + p, con))
345 return 1; /* found installed package that doesn't conflict */
350 static inline int providedbyinstalled(Pool *pool, Map *installed, Id dep, int ispatch, Map *noobsoletesmap)
353 FOR_PROVIDES(p, pp, dep)
355 if (p == SYSTEMSOLVABLE)
357 if (ispatch && !pool_match_nevr(pool, pool->solvables + p, dep))
359 if (ispatch && noobsoletesmap && noobsoletesmap->size && MAPTST(noobsoletesmap, p) && ISRELDEP(dep))
360 if (providedbyinstalled_multiversion(pool, installed, p, dep))
362 if (MAPTST(installed, p))
369 * solvable_trivial_installable_map - anwers is a solvable is installable
370 * without any other installs/deinstalls.
371 * The packages considered to be installed are provided via the
372 * installedmap bitmap. A additional "conflictsmap" bitmap providing
373 * information about the conflicts of the installed packages can be
374 * used for extra speed up. Provide a NULL pointer if you do not
375 * have this information.
376 * Both maps can be created with pool_create_state_maps() or
377 * solver_create_state_maps().
380 * 1: solvable is installable without any other package changes
381 * 0: solvable is not installable
382 * -1: solvable is installable, but doesn't constrain any installed packages
385 solvable_trivial_installable_map(Solvable *s, Map *installedmap, Map *conflictsmap, Map *noobsoletesmap)
387 Pool *pool = s->repo->pool;
392 int r, interesting = 0;
394 if (conflictsmap && MAPTST(conflictsmap, s - pool->solvables))
398 reqp = s->repo->idarraydata + s->requires;
399 while ((req = *reqp++) != 0)
401 if (req == SOLVABLE_PREREQMARKER)
403 r = providedbyinstalled(pool, installedmap, req, 0, 0);
414 if (!strncmp("patch:", pool_id2str(pool, s->name), 6))
416 conp = s->repo->idarraydata + s->conflicts;
417 while ((con = *conp++) != 0)
419 if (providedbyinstalled(pool, installedmap, con, ispatch, noobsoletesmap))
421 if (!interesting && ISRELDEP(con))
423 con = dep2name(pool, con);
424 if (providedbyinstalled(pool, installedmap, con, ispatch, noobsoletesmap))
434 if (s->obsoletes && s->repo != installed)
436 obsp = s->repo->idarraydata + s->obsoletes;
437 while ((obs = *obsp++) != 0)
439 if (providedbyinstalled(pool, installedmap, obs, 0, 0))
443 if (s->repo != installed)
446 FOR_PROVIDES(p, pp, s->name)
448 s2 = pool->solvables + p;
449 if (s2->repo == installed && s2->name == s->name)
459 p = s - pool->solvables;
460 for (i = 1; i < pool->nsolvables; i++)
462 if (!MAPTST(installedmap, i))
464 s2 = pool->solvables + i;
467 conp = s2->repo->idarraydata + s2->conflicts;
468 while ((con = *conp++) != 0)
470 dp = pool_whatprovides_ptr(pool, con);
477 return interesting ? 1 : -1;
481 * different interface for solvable_trivial_installable_map, where
482 * the information about the installed packages is provided
486 solvable_trivial_installable_queue(Solvable *s, Queue *installed, Map *noobsoletesmap)
488 Pool *pool = s->repo->pool;
494 map_init(&installedmap, pool->nsolvables);
495 for (i = 0; i < installed->count; i++)
497 p = installed->elements[i];
498 if (p > 0) /* makes it work with decisionq */
499 MAPSET(&installedmap, p);
501 r = solvable_trivial_installable_map(s, &installedmap, 0, noobsoletesmap);
502 map_free(&installedmap);
507 * different interface for solvable_trivial_installable_map, where
508 * the information about the installed packages is provided
509 * by a repo containing the installed solvables.
512 solvable_trivial_installable_repo(Solvable *s, Repo *installed, Map *noobsoletesmap)
514 Pool *pool = s->repo->pool;
520 map_init(&installedmap, pool->nsolvables);
521 FOR_REPO_SOLVABLES(installed, p, s2)
522 MAPSET(&installedmap, p);
523 r = solvable_trivial_installable_map(s, &installedmap, 0, noobsoletesmap);
524 map_free(&installedmap);
529 /*****************************************************************************/
532 * Create maps containing the state of each solvable. Input is a "installed" queue,
533 * it contains all solvable ids that are considered to be installed.
535 * The created maps can be used for solvable_trivial_installable_map(),
536 * pool_calc_duchanges(), pool_calc_installsizechange().
540 pool_create_state_maps(Pool *pool, Queue *installed, Map *installedmap, Map *conflictsmap)
547 map_init(installedmap, pool->nsolvables);
549 map_init(conflictsmap, pool->nsolvables);
550 for (i = 0; i < installed->count; i++)
552 p = installed->elements[i];
553 if (p <= 0) /* makes it work with decisionq */
555 MAPSET(installedmap, p);
558 s = pool->solvables + p;
561 conp = s->repo->idarraydata + s->conflicts;
562 while ((con = *conp++) != 0)
564 dp = pool_whatprovides_ptr(pool, con);
566 MAPSET(conflictsmap, *dp);
571 /* Tests if two solvables have identical content. Currently
572 * both solvables need to come from the same pool
575 solvable_identical(Solvable *s1, Solvable *s2)
577 unsigned int bt1, bt2;
581 if (s1->name != s2->name)
583 if (s1->arch != s2->arch)
585 if (s1->evr != s2->evr)
587 /* map missing vendor to empty string */
588 if ((s1->vendor ? s1->vendor : 1) != (s2->vendor ? s2->vendor : 1))
591 /* looking good, try some fancier stuff */
592 /* might also look up the package checksum here */
593 bt1 = solvable_lookup_num(s1, SOLVABLE_BUILDTIME, 0);
594 bt2 = solvable_lookup_num(s2, SOLVABLE_BUILDTIME, 0);
602 /* look at requires in a last attempt to find recompiled packages */
605 for (reqp = s1->repo->idarraydata + s1->requires; *reqp; reqp++)
608 for (reqp = s2->repo->idarraydata + s2->requires; *reqp; reqp++)
616 /* return the self provide dependency of a solvable */
618 solvable_selfprovidedep(Solvable *s)
626 pool = s->repo->pool;
629 provp = s->repo->idarraydata + s->provides;
630 while ((prov = *provp++) != 0)
634 rd = GETRELDEP(pool, prov);
635 if (rd->name == s->name && rd->evr == s->evr && rd->flags == REL_EQ)
639 return pool_rel2id(pool, s->name, s->evr, REL_EQ, 1);
642 /* setter functions, simply call the repo variants */
644 solvable_set_id(Solvable *s, Id keyname, Id id)
646 repo_set_id(s->repo, s - s->repo->pool->solvables, keyname, id);
650 solvable_set_num(Solvable *s, Id keyname, unsigned long long num)
652 repo_set_num(s->repo, s - s->repo->pool->solvables, keyname, num);
656 solvable_set_str(Solvable *s, Id keyname, const char *str)
658 repo_set_str(s->repo, s - s->repo->pool->solvables, keyname, str);
662 solvable_set_poolstr(Solvable *s, Id keyname, const char *str)
664 repo_set_poolstr(s->repo, s - s->repo->pool->solvables, keyname, str);
668 solvable_add_poolstr_array(Solvable *s, Id keyname, const char *str)
670 repo_add_poolstr_array(s->repo, s - s->repo->pool->solvables, keyname, str);
674 solvable_add_idarray(Solvable *s, Id keyname, Id id)
676 repo_add_idarray(s->repo, s - s->repo->pool->solvables, keyname, id);
680 solvable_add_deparray(Solvable *s, Id keyname, Id dep, Id marker)
682 repo_add_deparray(s->repo, s - s->repo->pool->solvables, keyname, dep, marker);
686 solvable_set_idarray(Solvable *s, Id keyname, Queue *q)
688 repo_set_idarray(s->repo, s - s->repo->pool->solvables, keyname, q);
692 solvable_set_deparray(Solvable *s, Id keyname, Queue *q, Id marker)
694 repo_set_deparray(s->repo, s - s->repo->pool->solvables, keyname, q, marker);