2 * Copyright (c) 2007, Novell Inc.
4 * This program is licensed under the BSD license, read LICENSE.BSD
5 * for further information
11 * Manage metadata coming from one repository
26 #include "poolid_private.h"
29 #include "attr_store_p.h"
32 #define IDARRAY_BLOCK 4095
41 repo_create(Pool *pool, const char *name)
45 pool_freewhatprovides(pool);
46 repo = (Repo *)sat_calloc(1, sizeof(*repo));
47 pool->repos = (Repo **)sat_realloc2(pool->repos, pool->nrepos + 1, sizeof(Repo *));
48 pool->repos[pool->nrepos++] = repo;
49 repo->name = name ? strdup(name) : 0;
51 repo->start = pool->nsolvables;
52 repo->end = pool->nsolvables;
58 repo_freedata(Repo *repo)
60 sat_free(repo->idarraydata);
61 sat_free(repo->rpmdbid);
62 sat_free((char *)repo->name);
68 * olddeps = old array to extend
73 repo_addid(Repo *repo, Offset olddeps, Id id)
79 idarray = repo->idarraydata;
80 idarraysize = repo->idarraysize;
82 if (!idarray) /* alloc idarray if not done yet */
85 idarray = sat_extend_resize(0, 1, sizeof(Id), IDARRAY_BLOCK);
90 if (!olddeps) /* no deps yet */
92 olddeps = idarraysize;
93 idarray = sat_extend(idarray, idarraysize, 1, sizeof(Id), IDARRAY_BLOCK);
95 else if (olddeps == repo->lastoff) /* extend at end */
97 else /* can't extend, copy old */
100 olddeps = idarraysize;
101 for (; idarray[i]; i++)
103 idarray = sat_extend(idarray, idarraysize, 1, sizeof(Id), IDARRAY_BLOCK);
104 idarray[idarraysize++] = idarray[i];
106 idarray = sat_extend(idarray, idarraysize, 1, sizeof(Id), IDARRAY_BLOCK);
109 idarray[idarraysize++] = id; /* insert Id into array */
110 idarray = sat_extend(idarray, idarraysize, 1, sizeof(Id), IDARRAY_BLOCK);
111 idarray[idarraysize++] = 0; /* ensure NULL termination */
113 repo->idarraydata = idarray;
114 repo->idarraysize = idarraysize;
115 repo->lastoff = olddeps;
122 * add dependency (as Id) to repo, also unifies dependencies
123 * olddeps = offset into idarraydata
124 * marker= 0 for normal dep
125 * marker > 0 add dep after marker
126 * marker < 0 add dep after -marker
130 repo_addid_dep(Repo *repo, Offset olddeps, Id id, Id marker)
132 Id oid, *oidp, *markerp;
138 olddeps = repo_addid(repo, olddeps, marker);
139 return repo_addid(repo, olddeps, id);
144 for (oidp = repo->idarraydata + olddeps; (oid = *oidp) != ID_NULL; oidp++)
149 return repo_addid(repo, olddeps, id);
159 for (oidp = repo->idarraydata + olddeps; (oid = *oidp) != ID_NULL; oidp++)
169 if (markerp || before)
171 /* we found it, but in the wrong half */
173 for (; (oid = *oidp) != ID_NULL; oidp++)
178 /* no marker in array yet */
181 memmove(markerp, markerp + 1, (oidp - markerp) * sizeof(Id));
183 return repo_addid(repo, olddeps, id);
187 memmove(markerp, markerp + 1, (oidp - markerp) * sizeof(Id));
191 /* id not yet in array */
192 if (!before && !markerp)
193 olddeps = repo_addid(repo, olddeps, marker);
194 else if (before && markerp)
199 memmove(markerp + 1, markerp, (oidp - markerp) * sizeof(Id));
202 return repo_addid(repo, olddeps, id);
208 * make space for 'num' more dependencies
212 repo_reserve_ids(Repo *repo, Offset olddeps, int num)
214 num++; /* room for trailing ID_NULL */
216 if (!repo->idarraysize) /* ensure buffer space */
218 repo->idarraysize = 1;
219 repo->idarraydata = sat_extend_resize(0, 1 + num, sizeof(Id), IDARRAY_BLOCK);
220 repo->idarraydata[0] = 0;
225 if (olddeps && olddeps != repo->lastoff) /* if not appending */
227 /* can't insert into idarray, this would invalidate all 'larger' offsets
228 * so create new space at end and move existing deps there.
229 * Leaving 'hole' at old position.
235 for (idstart = idend = repo->idarraydata + olddeps; *idend++; ) /* find end */
237 count = idend - idstart - 1 + num; /* new size */
239 repo->idarraydata = sat_extend(repo->idarraydata, repo->idarraysize, count, sizeof(Id), IDARRAY_BLOCK);
240 /* move old deps to end */
241 olddeps = repo->lastoff = repo->idarraysize;
242 memcpy(repo->idarraydata + olddeps, idstart, count - num);
243 repo->idarraysize = olddeps + count - num;
248 if (olddeps) /* appending */
252 repo->idarraydata = sat_extend(repo->idarraydata, repo->idarraysize, num, sizeof(Id), IDARRAY_BLOCK);
254 /* appending or new */
255 repo->lastoff = olddeps ? olddeps : repo->idarraysize;
257 return repo->lastoff;
262 * remove repo from pool, zero out solvables
267 repo_free(Repo *repo, int reuseids)
269 Pool *pool = repo->pool;
273 pool_freewhatprovides(pool);
275 if (reuseids && repo->end == pool->nsolvables)
277 /* it's ok to reuse the ids. As this is the last repo, we can
278 just shrink the solvable array */
279 for (i = repo->end - 1, s = pool->solvables + i; i >= repo->start; i--, s--)
283 pool->nsolvables = i + 1;
285 /* zero out solvables belonging to this repo */
286 for (i = repo->start, s = pool->solvables + i; i < repo->end; i++, s++)
288 memset(s, 0, sizeof(*s));
289 for (i = 0; i < pool->nrepos; i++) /* find repo in pool */
290 if (pool->repos[i] == repo)
292 if (i == pool->nrepos) /* repo not in pool, return */
294 if (i < pool->nrepos - 1)
295 memmove(pool->repos + i, pool->repos + i + 1, (pool->nrepos - 1 - i) * sizeof(Repo *));
301 repo_freeallrepos(Pool *pool, int reuseids)
305 pool_freewhatprovides(pool);
306 for (i = 0; i < pool->nrepos; i++)
307 repo_freedata(pool->repos[i]);
308 pool->repos = sat_free(pool->repos);
310 /* the first two solvables don't belong to a repo */
311 pool_free_solvable_block(pool, 2, pool->nsolvables - 2, reuseids);
315 repo_fix_legacy(Repo *repo, Offset provides, Offset supplements)
317 Pool *pool = repo->pool;
319 char buf[1024], *p, *dep;
324 for (i = provides; repo->idarraydata[i]; i++)
326 id = repo->idarraydata[i];
329 dep = (char *)id2str(pool, id);
330 if (!strncmp(dep, "locale(", 7) && strlen(dep) < sizeof(buf) - 2)
333 strcpy(buf + 2, dep);
335 if ((p = strchr(dep, ':')) != 0 && p != dep)
338 idp = str2id(pool, dep, 1);
342 while ((p = strchr(dep, ';')) != 0)
351 strncpy(dep - 9, "language:", 9);
352 idl = str2id(pool, dep - 9, 1);
354 idl = str2id(pool, dep, 1);
355 idl = rel2id(pool, NAMESPACE_LANGUAGE, idl, REL_NAMESPACE, 1);
358 id = rel2id(pool, id, idl, REL_OR, 1);
363 if (dep[0] && dep[1])
365 for (p = dep; *p && *p != ')'; p++)
369 strncpy(dep - 9, "language:", 9);
370 idl = str2id(pool, dep - 9, 1);
372 idl = str2id(pool, dep, 1);
373 idl = rel2id(pool, NAMESPACE_LANGUAGE, idl, REL_NAMESPACE, 1);
376 id = rel2id(pool, id, idl, REL_OR, 1);
381 id = rel2id(pool, idp, id, REL_AND, 1);
383 supplements = repo_addid_dep(repo, supplements, id, 0);
385 else if ((p = strchr(dep, ':')) != 0 && p != dep && p[1] == '/' && strlen(dep) < sizeof(buf))
390 idp = str2id(pool, buf, 1);
391 /* strip trailing slashes */
393 while (i > 1 && p[i - 1] == '/')
395 id = str2id(pool, p, 1);
396 id = rel2id(pool, idp, id, REL_WITH, 1);
397 id = rel2id(pool, NAMESPACE_SPLITPROVIDES, id, REL_NAMESPACE, 1);
398 supplements = repo_addid_dep(repo, supplements, id, 0);
404 for (i = supplements; repo->idarraydata[i]; i++)
406 id = repo->idarraydata[i];
409 dep = (char *)id2str(pool, id);
410 if (!strncmp(dep, "system:modalias(", 16))
412 if (!strncmp(dep, "modalias(", 9) && dep[9] && dep[10] && strlen(dep) < sizeof(buf))
415 p = strchr(buf + 9, ':');
416 if (p && p != buf + 9 && strchr(p + 1, ':'))
419 idp = str2id(pool, buf + 9, 1);
420 p[strlen(p) - 1] = 0;
421 id = str2id(pool, p, 1);
422 id = rel2id(pool, NAMESPACE_MODALIAS, id, REL_NAMESPACE, 1);
423 id = rel2id(pool, idp, id, REL_AND, 1);
428 p[strlen(p) - 1] = 0;
429 id = str2id(pool, p, 1);
430 id = rel2id(pool, NAMESPACE_MODALIAS, id, REL_NAMESPACE, 1);
433 repo->idarraydata[i] = id;
435 else if (!strncmp(dep, "packageand(", 11) && strlen(dep) < sizeof(buf))
440 while ((p = strchr(dep, ':')) != 0)
448 idp = str2id(pool, dep, 1);
450 id = rel2id(pool, id, idp, REL_AND, 1);
455 if (dep[0] && dep[1])
457 dep[strlen(dep) - 1] = 0;
458 idp = str2id(pool, dep, 1);
460 id = rel2id(pool, id, idp, REL_AND, 1);
465 repo->idarraydata[i] = id;
480 int (*callback)(void *cbdata, Solvable *s, Repodata *data, Repokey *key, KeyValue *kv);
485 repo_matchvalue(void *cbdata, Solvable *s, Repodata *data, Repokey *key, KeyValue *kv)
487 struct matchdata *md = cbdata;
488 int flags = md->flags;
490 if ((flags & SEARCH_STRINGMASK) != 0)
496 if (data && data->localpool)
497 kv->str = stringpool_id2str(&data->spool, kv->id);
499 kv->str = id2str(s->repo->pool, kv->id);
506 switch ((flags & SEARCH_STRINGMASK))
508 case SEARCH_SUBSTRING:
509 if (flags & SEARCH_NOCASE)
511 if (!strcasestr(kv->str, md->match))
516 if (!strstr(kv->str, md->match))
521 if (flags & SEARCH_NOCASE)
523 if (strcasecmp(md->match, kv->str))
528 if (strcmp(md->match, kv->str))
533 if (fnmatch(md->match, kv->str, (flags & SEARCH_NOCASE) ? FNM_CASEFOLD : 0))
538 if (regexec(&md->regexp, kv->str, 0, NULL, 0))
545 md->stop = md->callback(md->callback_data, s, data, key, kv);
550 static Repokey solvablekeys[RPM_RPMDBID - SOLVABLE_NAME + 1] = {
551 { SOLVABLE_NAME, TYPE_ID, 0, KEY_STORAGE_SOLVABLE },
552 { SOLVABLE_ARCH, TYPE_ID, 0, KEY_STORAGE_SOLVABLE },
553 { SOLVABLE_EVR, TYPE_ID, 0, KEY_STORAGE_SOLVABLE },
554 { SOLVABLE_VENDOR, TYPE_ID, 0, KEY_STORAGE_SOLVABLE },
555 { SOLVABLE_PROVIDES, TYPE_IDARRAY, 0, KEY_STORAGE_SOLVABLE },
556 { SOLVABLE_OBSOLETES, TYPE_IDARRAY, 0, KEY_STORAGE_SOLVABLE },
557 { SOLVABLE_CONFLICTS, TYPE_IDARRAY, 0, KEY_STORAGE_SOLVABLE },
558 { SOLVABLE_REQUIRES, TYPE_IDARRAY, 0, KEY_STORAGE_SOLVABLE },
559 { SOLVABLE_RECOMMENDS, TYPE_IDARRAY, 0, KEY_STORAGE_SOLVABLE },
560 { SOLVABLE_SUGGESTS, TYPE_IDARRAY, 0, KEY_STORAGE_SOLVABLE },
561 { SOLVABLE_SUPPLEMENTS, TYPE_IDARRAY, 0, KEY_STORAGE_SOLVABLE },
562 { SOLVABLE_ENHANCES, TYPE_IDARRAY, 0, KEY_STORAGE_SOLVABLE },
563 { SOLVABLE_FRESHENS, TYPE_IDARRAY, 0, KEY_STORAGE_SOLVABLE },
564 { RPM_RPMDBID, TYPE_U32, 0, KEY_STORAGE_SOLVABLE },
568 domatch_idarray(Solvable *s, Id keyname, struct matchdata *md, Id *ida)
571 for (; *ida && !md->stop; ida++)
574 kv.eof = ida[1] ? 0 : 1;
575 repo_matchvalue(md, s, 0, solvablekeys + (keyname - SOLVABLE_NAME), &kv);
580 repo_search_md(Repo *repo, Id p, Id keyname, struct matchdata *md)
583 Pool *pool = repo->pool;
591 for (p = repo->start, s = repo->pool->solvables + p; p < repo->end; p++, s++)
594 repo_search_md(repo, p, keyname, md);
595 if (md->stop > SEARCH_NEXT_SOLVABLE)
600 s = pool->solvables + p;
602 if (!(flags & SEARCH_NO_STORAGE_SOLVABLE))
611 repo_matchvalue(md, s, 0, solvablekeys + 0, &kv);
613 if (keyname || md->stop > SEARCH_NEXT_KEY)
619 repo_matchvalue(md, s, 0, solvablekeys + 1, &kv);
621 if (keyname || md->stop > SEARCH_NEXT_KEY)
627 repo_matchvalue(md, s, 0, solvablekeys + 2, &kv);
629 if (keyname || md->stop > SEARCH_NEXT_KEY)
631 case SOLVABLE_VENDOR:
635 repo_matchvalue(md, s, 0, solvablekeys + 3, &kv);
637 if (keyname || md->stop > SEARCH_NEXT_KEY)
639 case SOLVABLE_PROVIDES:
641 domatch_idarray(s, SOLVABLE_PROVIDES, md, repo->idarraydata + s->provides);
642 if (keyname || md->stop > SEARCH_NEXT_KEY)
644 case SOLVABLE_OBSOLETES:
646 domatch_idarray(s, SOLVABLE_OBSOLETES, md, repo->idarraydata + s->obsoletes);
647 if (keyname || md->stop > SEARCH_NEXT_KEY)
649 case SOLVABLE_CONFLICTS:
651 domatch_idarray(s, SOLVABLE_CONFLICTS, md, repo->idarraydata + s->conflicts);
652 if (keyname || md->stop > SEARCH_NEXT_KEY)
654 case SOLVABLE_REQUIRES:
656 domatch_idarray(s, SOLVABLE_REQUIRES, md, repo->idarraydata + s->requires);
657 if (keyname || md->stop > SEARCH_NEXT_KEY)
659 case SOLVABLE_RECOMMENDS:
661 domatch_idarray(s, SOLVABLE_RECOMMENDS, md, repo->idarraydata + s->recommends);
662 if (keyname || md->stop > SEARCH_NEXT_KEY)
664 case SOLVABLE_SUPPLEMENTS:
666 domatch_idarray(s, SOLVABLE_SUPPLEMENTS, md, repo->idarraydata + s->supplements);
667 if (keyname || md->stop > SEARCH_NEXT_KEY)
669 case SOLVABLE_SUGGESTS:
671 domatch_idarray(s, SOLVABLE_SUGGESTS, md, repo->idarraydata + s->suggests);
672 if (keyname || md->stop > SEARCH_NEXT_KEY)
674 case SOLVABLE_ENHANCES:
676 domatch_idarray(s, SOLVABLE_ENHANCES, md, repo->idarraydata + s->enhances);
677 if (keyname || md->stop > SEARCH_NEXT_KEY)
679 case SOLVABLE_FRESHENS:
681 domatch_idarray(s, SOLVABLE_FRESHENS, md, repo->idarraydata + s->freshens);
682 if (keyname || md->stop > SEARCH_NEXT_KEY)
687 kv.num = repo->rpmdbid[p - repo->start];
688 repo_matchvalue(md, s, 0, solvablekeys + (RPM_RPMDBID - SOLVABLE_NAME), &kv);
690 if (keyname || md->stop > SEARCH_NEXT_KEY)
698 for (i = 0, data = repo->repodata; i < repo->nrepodata; i++, data++)
700 if (p < data->start || p >= data->end)
702 if (data->state == REPODATA_STUB)
706 for (j = 1; j < data->nkeys; j++)
707 if (keyname == data->keys[j].name)
709 if (j == data->nkeys)
713 if (data->loadcallback)
714 data->loadcallback(data);
716 data->state = REPODATA_ERROR;
718 if (data->state == REPODATA_ERROR)
720 repodata_search(data, p - data->start, keyname, repo_matchvalue, md);
721 if (md->stop > SEARCH_NEXT_KEY)
727 repo_search(Repo *repo, Id p, Id key, const char *match, int flags, int (*callback)(void *cbdata, Solvable *s, Repodata *data, Repokey *key, KeyValue *kv), void *cbdata)
731 memset(&md, 0, sizeof(md));
732 md.pool = repo->pool;
735 md.callback = callback;
736 md.callback_data = cbdata;
737 repo_search_md(repo, p, key, &md);
741 repo_lookup_str(Solvable *s, Id key)
743 Repo *repo = s->repo;
744 Pool *pool = repo->pool;
751 return id2str(pool, s->name);
753 return id2str(pool, s->arch);
755 return id2str(pool, s->evr);
756 case SOLVABLE_VENDOR:
757 return id2str(pool, s->vendor);
759 n = s - pool->solvables;
760 for (i = 0, data = repo->repodata; i < repo->nrepodata; i++, data++)
762 if (n < data->start || n >= data->end)
764 for (j = 1; j < data->nkeys; j++)
766 if (data->keys[j].name == key && (data->keys[j].type == TYPE_ID || data->keys[j].type == TYPE_STR))
767 return repodata_lookup_str(data, n - data->start, j);
774 repo_lookup_num(Solvable *s, Id key)
776 Repo *repo = s->repo;
777 Pool *pool = repo->pool;
781 n = s - pool->solvables;
782 for (i = 0, data = repo->repodata; i < repo->nrepodata; i++, data++)
784 if (n < data->start || n >= data->end)
786 for (j = 1; j < data->nkeys; j++)
788 if (data->keys[j].name == key
789 && (data->keys[j].type == TYPE_U32
790 || data->keys[j].type == TYPE_NUM
791 || data->keys[j].type == TYPE_CONSTANT))
794 if (repodata_lookup_num(data, n - data->start, j, &value))
804 * generic attribute lookup
805 * returns non-zero if found
810 repo_lookup(Solvable *s, Id key, int (*callback)(void *cbdata, Solvable *s, Repodata *data, Repokey *key, KeyValue *kv), void *cbdata)
812 Repo *repo = s->repo;
813 Pool *pool = repo->pool;
817 s_id = s - pool->solvables;
818 for (i = 0, data = repo->repodata; i < repo->nrepodata; i++, data++)
820 if (s_id < data->start || s_id >= data->end)
822 repodata_search (data, s_id - data->start, key, callback, cbdata);
830 repo_add_repodata(Repo *repo)
835 repo->repodata = sat_realloc2(repo->repodata, repo->nrepodata, sizeof(*data));
836 data = repo->repodata + repo->nrepodata - 1;
837 memset(data, 0, sizeof (*data));
839 data->start = repo->start;
840 data->end = repo->end;
842 data->keys = sat_calloc(1, sizeof(Repokey));
844 data->schemata = sat_calloc(1, sizeof(Id));
845 data->schemadata = sat_calloc(1, sizeof(Id));
847 data->schemadatalen = 1;
848 data->incoreoffset = sat_calloc(data->end - data->start, sizeof(Id));
853 findrepodata(Repo *repo, Id p, Id keyname)
858 /* FIXME: enter nice code here */
859 for (i = 0, data = repo->repodata; i < repo->nrepodata; i++, data++)
860 if (p >= data->start && p < data->end)
862 for (i = 0, data = repo->repodata; i < repo->nrepodata; i++, data++)
865 if (i < repo->nrepodata)
867 repodata_extend(data, p);
870 return repo_add_repodata(repo);
874 repo_set_id(Repo *repo, Id p, Id keyname, Id id)
876 Repodata *data = findrepodata(repo, p, keyname);
877 repodata_set_id(data, p - data->start, keyname, id);
881 repo_set_num(Repo *repo, Id p, Id keyname, Id num)
883 Repodata *data = findrepodata(repo, p, keyname);
884 repodata_set_num(data, p - data->start, keyname, num);
888 repo_set_str(Repo *repo, Id p, Id keyname, const char *str)
890 Repodata *data = findrepodata(repo, p, keyname);
891 repodata_set_str(data, p - data->start, keyname, str);
895 repo_set_poolstr(Repo *repo, Id p, Id keyname, const char *str)
897 Repodata *data = findrepodata(repo, p, keyname);
898 repodata_set_poolstr(data, p - data->start, keyname, str);
902 repo_internalize(Repo *repo)
907 for (i = 0, data = repo->repodata; i < repo->nrepodata; i++, data++)
909 repodata_internalize(data);
916 key_cmp (const void *pa, const void *pb)
918 Repokey *a = (Repokey *)pa;
919 Repokey *b = (Repokey *)pb;
920 return a->name - b->name;
924 repo_add_attrstore (Repo *repo, Attrstore *s, const char *location)
928 /* If this is meant to be the embedded attributes, make sure we don't
929 have them already. */
932 for (i = 0; i < repo->nrepodata; i++)
933 if (repo->repodata[i].location == 0)
935 if (i != repo->nrepodata)
937 pool_debug (repo->pool, SAT_FATAL, "embedded attribs added twice\n");
942 repo->repodata = sat_realloc2(repo->repodata, repo->nrepodata, sizeof(*data));
943 data = repo->repodata + repo->nrepodata - 1;
944 memset (data, 0, sizeof (*data));
946 data->nkeys = s->nkeys;
949 data->keys = sat_malloc2(data->nkeys, sizeof(data->keys[0]));
950 for (i = 1; i < data->nkeys; i++)
952 data->keys[i].name = s->keys[i].name;
953 data->keys[i].type = s->keys[i].type;
956 qsort(data->keys + 1, data->nkeys - 1, sizeof(data->keys[0]), key_cmp);
959 data->location = strdup(location);