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 const char *kn, *str;
186 return repo_lookup_str(s, keyname);
187 pool = s->repo->pool;
188 kn = id2str(pool, keyname);
189 p = sat_malloc(strlen(kn) + strlen(lang) + 2);
190 sprintf(p, "%s:%s", kn, lang);
191 id = str2id(pool, p, 0);
194 str = repo_lookup_str(s, id);
198 return repo_lookup_str(s, keyname);
202 solvable_lookup_num(Solvable *s, Id keyname, unsigned int notfound)
204 Repo *repo = s->repo;
212 if (keyname == RPM_RPMDBID)
215 return repo->rpmdbid[(s - pool->solvables) - repo->start];
218 n = s - pool->solvables;
219 for (i = 0, data = repo->repodata; i < repo->nrepodata; i++, data++)
221 if (n < data->start || n >= data->end)
223 for (j = 1; j < data->nkeys; j++)
225 if (data->keys[j].name == keyname
226 && (data->keys[j].type == REPOKEY_TYPE_U32
227 || data->keys[j].type == REPOKEY_TYPE_NUM
228 || data->keys[j].type == REPOKEY_TYPE_CONSTANT))
231 if (repodata_lookup_num(data, n - data->start, j, &value))
240 solvable_lookup_void(Solvable *s, Id keyname)
242 Repo *repo = s->repo;
250 n = s - pool->solvables;
251 for (i = 0, data = repo->repodata; i < repo->nrepodata; i++, data++)
253 if (n < data->start || n >= data->end)
255 for (j = 1; j < data->nkeys; j++)
257 if (data->keys[j].name == keyname
258 && (data->keys[j].type == REPOKEY_TYPE_VOID))
260 if (repodata_lookup_void(data, n - data->start, j))
268 const unsigned char *
269 solvable_lookup_bin_checksum(Solvable *s, Id keyname, Id *typep)
271 Repo *repo = s->repo;
280 n = s - pool->solvables;
281 for (i = 0, data = repo->repodata; i < repo->nrepodata; i++, data++)
283 if (n < data->start || n >= data->end)
285 for (j = 1; j < data->nkeys; j++)
287 if (data->keys[j].name == keyname
288 && (data->keys[j].type == REPOKEY_TYPE_MD5
289 || data->keys[j].type == REPOKEY_TYPE_SHA1
290 || data->keys[j].type == REPOKEY_TYPE_SHA256))
292 const unsigned char *chk = repodata_lookup_bin_checksum(data, n - data->start, j, typep);
302 solvable_lookup_checksum(Solvable *s, Id keyname, Id *typep)
304 const unsigned char *chk = solvable_lookup_bin_checksum(s, keyname, typep);
305 /* we need the repodata just as a reference for a pool */
306 return chk ? repodata_chk2str(s->repo->repodata, *typep, chk) : 0;
310 solvable_get_location(Solvable *s, unsigned int *medianrp)
315 const char *mediadir, *mediafile;
320 pool = s->repo->pool;
321 *medianrp = solvable_lookup_num(s, SOLVABLE_MEDIANR, 1);
322 if (solvable_lookup_void(s, SOLVABLE_MEDIADIR))
323 mediadir = id2str(pool, s->arch);
325 mediadir = solvable_lookup_str(s, SOLVABLE_MEDIADIR);
327 l = strlen(mediadir) + 1;
328 if (solvable_lookup_void(s, SOLVABLE_MEDIAFILE))
330 const char *name, *evr, *arch;
331 name = id2str(pool, s->name);
332 evr = id2str(pool, s->evr);
333 arch = id2str(pool, s->arch);
334 /* name-evr.arch.rpm */
335 loc = pool_alloctmpspace(pool, l + strlen(name) + strlen(evr) + strlen(arch) + 7);
337 sprintf(loc, "%s/%s-%s.%s.rpm", mediadir, name, evr, arch);
339 sprintf(loc, "%s-%s.%s.rpm", name, evr, arch);
343 mediafile = solvable_lookup_str(s, SOLVABLE_MEDIAFILE);
346 loc = pool_alloctmpspace(pool, l + strlen(mediafile) + 1);
348 sprintf(loc, "%s/%s", mediadir, mediafile);
350 strcpy(loc, mediafile);