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
25 solvable2str(Pool *pool, Solvable *s)
27 const char *n, *e, *a;
29 n = id2str(pool, s->name);
30 e = id2str(pool, s->evr);
31 a = id2str(pool, s->arch);
32 p = pool_alloctmpspace(pool, strlen(n) + strlen(e) + strlen(a) + 3);
33 sprintf(p, "%s-%s.%s", n, e, a);
38 solvable_lookup_id(Solvable *s, Id keyname)
59 n = s - pool->solvables;
60 for (i = 0, data = repo->repodata; i < repo->nrepodata; i++, data++)
62 if (n < data->start || n >= data->end)
64 for (j = 1; j < data->nkeys; j++)
66 if (data->keys[j].name == keyname && (data->keys[j].type == REPOKEY_TYPE_ID || data->keys[j].type == REPOKEY_TYPE_CONSTANTID))
68 Id id = repodata_lookup_id(data, n - data->start, j);
72 id = repodata_globalize_id(data, id);
82 solvable_lookup_str(Solvable *s, Id keyname)
96 return id2str(pool, s->name);
98 return id2str(pool, s->arch);
100 return id2str(pool, s->evr);
101 case SOLVABLE_VENDOR:
102 return id2str(pool, s->vendor);
104 n = s - pool->solvables;
105 for (i = 0, data = repo->repodata; i < repo->nrepodata; i++, data++)
107 if (n < data->start || n >= data->end)
109 for (j = 1; j < data->nkeys; j++)
111 if (data->keys[j].name == keyname && (data->keys[j].type == REPOKEY_TYPE_ID || data->keys[j].type == REPOKEY_TYPE_CONSTANTID || data->keys[j].type == REPOKEY_TYPE_STR))
113 str = repodata_lookup_str(data, n - data->start, j);
123 solvable_lookup_str_poollang(Solvable *s, Id keyname)
131 return repo_lookup_str(s, keyname);
132 pool = s->repo->pool;
133 if (!pool->nlanguages)
134 return repo_lookup_str(s, keyname);
135 cols = pool->nlanguages + 1;
136 if (!pool->languagecache)
138 pool->languagecache = sat_calloc(cols * ID_NUM_INTERNAL, sizeof(Id));
139 pool->languagecacheother = 0;
141 if (keyname >= ID_NUM_INTERNAL)
143 row = pool->languagecache + ID_NUM_INTERNAL * cols;
144 for (i = 0; i < pool->languagecacheother; i++, row += cols)
147 if (i >= pool->languagecacheother)
149 pool->languagecache = sat_realloc2(pool->languagecache, pool->languagecacheother + 1, cols * sizeof(Id));
150 pool->languagecacheother++;
151 row = pool->languagecache + cols * (ID_NUM_INTERNAL + pool->languagecacheother++);
155 row = pool->languagecache + keyname * cols;
156 row++; /* skip keyname */
157 for (i = 0; i < pool->nlanguages; i++, row++)
164 kn = id2str(pool, keyname);
165 p = sat_malloc(strlen(kn) + strlen(pool->languages[i]) + 2);
166 sprintf(p, "%s:%s", kn, pool->languages[i]);
167 *row = str2id(pool, p, 1);
170 str = repo_lookup_str(s, *row);
174 return repo_lookup_str(s, keyname);
178 solvable_lookup_str_lang(Solvable *s, Id keyname, const char *lang)
183 Id id = pool_id2langid(s->repo->pool, keyname, lang, 0);
184 if (id && (str = repo_lookup_str(s, id)) != 0)
187 return repo_lookup_str(s, keyname);
191 solvable_lookup_num(Solvable *s, Id keyname, unsigned int notfound)
193 Repo *repo = s->repo;
201 if (keyname == RPM_RPMDBID)
204 return repo->rpmdbid[(s - pool->solvables) - repo->start];
207 n = s - pool->solvables;
208 for (i = 0, data = repo->repodata; i < repo->nrepodata; i++, data++)
210 if (n < data->start || n >= data->end)
212 for (j = 1; j < data->nkeys; j++)
214 if (data->keys[j].name == keyname
215 && (data->keys[j].type == REPOKEY_TYPE_U32
216 || data->keys[j].type == REPOKEY_TYPE_NUM
217 || data->keys[j].type == REPOKEY_TYPE_CONSTANT))
220 if (repodata_lookup_num(data, n - data->start, j, &value))
229 solvable_lookup_void(Solvable *s, Id keyname)
231 Repo *repo = s->repo;
239 n = s - pool->solvables;
240 for (i = 0, data = repo->repodata; i < repo->nrepodata; i++, data++)
242 if (n < data->start || n >= data->end)
244 for (j = 1; j < data->nkeys; j++)
246 if (data->keys[j].name == keyname
247 && (data->keys[j].type == REPOKEY_TYPE_VOID))
249 if (repodata_lookup_void(data, n - data->start, j))
258 solvable_lookup_bool(Solvable *s, Id keyname)
260 Repo *repo = s->repo;
268 n = s - pool->solvables;
269 for (i = 0, data = repo->repodata; i < repo->nrepodata; i++, data++)
271 if (n < data->start || n >= data->end)
273 /* there are two ways of storing a bool */
274 for (j = 1; j < data->nkeys; j++)
277 if (data->keys[j].name == keyname
278 && (data->keys[j].type == REPOKEY_TYPE_U32
279 || data->keys[j].type == REPOKEY_TYPE_NUM
280 || data->keys[j].type == REPOKEY_TYPE_CONSTANT))
283 if (repodata_lookup_num(data, n - data->start, j, &value))
287 /* as a void attribute, if it is there, then true */
288 if (data->keys[j].name == keyname
289 && (data->keys[j].type == REPOKEY_TYPE_VOID))
291 if (repodata_lookup_void(data, n - data->start, j))
299 const unsigned char *
300 solvable_lookup_bin_checksum(Solvable *s, Id keyname, Id *typep)
302 Repo *repo = s->repo;
311 n = s - pool->solvables;
312 for (i = 0, data = repo->repodata; i < repo->nrepodata; i++, data++)
314 if (n < data->start || n >= data->end)
316 for (j = 1; j < data->nkeys; j++)
318 if (data->keys[j].name == keyname
319 && (data->keys[j].type == REPOKEY_TYPE_MD5
320 || data->keys[j].type == REPOKEY_TYPE_SHA1
321 || data->keys[j].type == REPOKEY_TYPE_SHA256))
323 const unsigned char *chk = repodata_lookup_bin_checksum(data, n - data->start, j, typep);
333 solvable_lookup_checksum(Solvable *s, Id keyname, Id *typep)
335 const unsigned char *chk = solvable_lookup_bin_checksum(s, keyname, typep);
336 /* we need the repodata just as a reference for a pool */
337 return chk ? repodata_chk2str(s->repo->repodata, *typep, chk) : 0;
341 solvable_get_location(Solvable *s, unsigned int *medianrp)
346 const char *mediadir, *mediafile;
351 pool = s->repo->pool;
352 *medianrp = solvable_lookup_num(s, SOLVABLE_MEDIANR, 1);
353 if (solvable_lookup_void(s, SOLVABLE_MEDIADIR))
354 mediadir = id2str(pool, s->arch);
356 mediadir = solvable_lookup_str(s, SOLVABLE_MEDIADIR);
358 l = strlen(mediadir) + 1;
359 if (solvable_lookup_void(s, SOLVABLE_MEDIAFILE))
361 const char *name, *evr, *arch;
362 name = id2str(pool, s->name);
363 evr = id2str(pool, s->evr);
364 arch = id2str(pool, s->arch);
365 /* name-evr.arch.rpm */
366 loc = pool_alloctmpspace(pool, l + strlen(name) + strlen(evr) + strlen(arch) + 7);
368 sprintf(loc, "%s/%s-%s.%s.rpm", mediadir, name, evr, arch);
370 sprintf(loc, "%s-%s.%s.rpm", name, evr, arch);
374 mediafile = solvable_lookup_str(s, SOLVABLE_MEDIAFILE);
377 loc = pool_alloctmpspace(pool, l + strlen(mediafile) + 1);
379 sprintf(loc, "%s/%s", mediadir, mediafile);
381 strcpy(loc, mediafile);
386 /*****************************************************************************/
388 static inline Id dep2name(Pool *pool, Id dep)
390 while (ISRELDEP(dep))
392 Reldep *rd = rd = GETRELDEP(pool, dep);
398 static inline int providedbyinstalled(Pool *pool, Map *installed, Id dep)
401 FOR_PROVIDES(p, pp, dep)
403 if (p == SYSTEMSOLVABLE)
405 if (MAPTST(installed, p))
412 * solvable_trivial_installable_map - anwers is a solvable is installable
413 * without any other installs/deinstalls.
414 * The packages considered to be installed are provided via the
415 * installedmap bitmap. A additional "conflictsmap" bitmap providing
416 * information about the conflicts of the installed packages can be
417 * used for extra speed up. Provide a NULL pointer if you do not
418 * have this information.
419 * Both maps can be created with pool_create_state_maps() or
420 * solver_create_state_maps().
423 * 1: solvable is installable without any other package changes
424 * 0: solvable is not installable
425 * -1: solvable is installable, but doesn't constrain any installed packages
428 solvable_trivial_installable_map(Solvable *s, Map *installedmap, Map *conflictsmap)
430 Pool *pool = s->repo->pool;
436 int r, interesting = 0;
438 if (conflictsmap && MAPTST(conflictsmap, s - pool->solvables))
442 reqp = s->repo->idarraydata + s->requires;
443 while ((req = *reqp++) != 0)
445 if (req == SOLVABLE_PREREQMARKER)
447 r = providedbyinstalled(pool, installedmap, req);
456 conp = s->repo->idarraydata + s->conflicts;
457 while ((con = *conp++) != 0)
459 if (providedbyinstalled(pool, installedmap, con))
461 if (!interesting && ISRELDEP(con))
463 con = dep2name(pool, con);
464 if (providedbyinstalled(pool, installedmap, con))
472 if (s->obsoletes && s->repo != installed)
474 obsp = s->repo->idarraydata + s->obsoletes;
475 while ((obs = *obsp++) != 0)
477 if (providedbyinstalled(pool, installedmap, obs))
481 if (s->repo != installed)
483 FOR_PROVIDES(p, pp, s->name)
485 s2 = pool->solvables + p;
486 if (s2->repo == installed && s2->name == s->name)
495 p = s - pool->solvables;
496 for (i = 1; i < pool->nsolvables; i++)
498 if (!MAPTST(installedmap, i))
500 s2 = pool->solvables + i;
503 conp = s2->repo->idarraydata + s2->conflicts;
504 while ((con = *conp++) != 0)
506 dp = pool->whatprovidesdata + pool_whatprovides(pool, con);
513 return interesting ? 1 : -1;
517 * different interface for solvable_trivial_installable_map, where
518 * the information about the installed packages is provided
522 solvable_trivial_installable_queue(Solvable *s, Queue *installed)
524 Pool *pool = s->repo->pool;
530 map_init(&installedmap, pool->nsolvables);
531 for (i = 0; i < installed->count; i++)
533 p = installed->elements[i];
534 if (p > 0) /* makes it work with decisionq */
535 MAPSET(&installedmap, p);
537 r = solvable_trivial_installable_map(s, &installedmap, 0);
538 map_free(&installedmap);
543 * different interface for solvable_trivial_installable_map, where
544 * the information about the installed packages is provided
545 * by a repo containing the installed solvables.
548 solvable_trivial_installable_repo(Solvable *s, Repo *installed)
550 Pool *pool = s->repo->pool;
556 map_init(&installedmap, pool->nsolvables);
557 FOR_REPO_SOLVABLES(installed, p, s2)
558 MAPSET(&installedmap, p);
559 r = solvable_trivial_installable_map(s, &installedmap, 0);
560 map_free(&installedmap);
565 /*****************************************************************************/
568 * Create maps containing the state of each solvable. Input is a "installed" queue,
569 * it contains all solvable ids that are considered to be installed.
571 * The created maps can be used for solvable_trivial_installable_map(),
572 * pool_calc_duchanges(), pool_calc_installsizechange().
576 pool_create_state_maps(Pool *pool, Queue *installed, Map *installedmap, Map *conflictsmap)
583 map_init(installedmap, pool->nsolvables);
585 map_init(conflictsmap, pool->nsolvables);
586 for (i = 0; i < installed->count; i++)
588 p = installed->elements[i];
589 if (p <= 0) /* makes it work with decisionq */
591 MAPSET(installedmap, p);
594 s = pool->solvables + p;
597 conp = s->repo->idarraydata + s->conflicts;
598 while ((con = *conp++) != 0)
600 dp = pool->whatprovidesdata + pool_whatprovides(pool, con);
602 MAPSET(conflictsmap, *dp);
608 solvable_identical(Pool *pool, Solvable *s1, Solvable *s2)
610 unsigned int bt1, bt2;
614 if (s1->name != s2->name)
616 if (s1->arch != s2->arch)
618 if (s1->evr != s2->evr)
620 if (s1->vendor != s2->vendor)
623 /* looking good, try some fancier stuff */
624 /* might also look up the package checksum here */
625 bt1 = solvable_lookup_num(s1, SOLVABLE_BUILDTIME, 0);
626 bt2 = solvable_lookup_num(s2, SOLVABLE_BUILDTIME, 0);
634 /* look at requires in a last attempt to find recompiled packages */
637 for (reqp = s1->repo->idarraydata + s1->requires; *reqp; reqp++)
640 for (reqp = s2->repo->idarraydata + s2->requires; *reqp; reqp++)