X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Frepo.c;h=4fc38b7557e5dcd2b3ee5120499589e97685807f;hb=db67f9cb45157f2d4660a8fc2f24dcf3957d4b7c;hp=218e2c06e7f7a026e0d07cc2c1d59341416ee134;hpb=a00b22fc21692242f0582ae6d9ff4e27d927c09d;p=platform%2Fupstream%2Flibsolv.git diff --git a/src/repo.c b/src/repo.c index 218e2c0..4fc38b7 100644 --- a/src/repo.c +++ b/src/repo.c @@ -1,18 +1,33 @@ /* + * Copyright (c) 2007, Novell Inc. + * + * This program is licensed under the BSD license, read LICENSE.BSD + * for further information + */ + +/* * repo.c * * Manage metadata coming from one repository * */ +#define _GNU_SOURCE +#include +#include + #include #include -#include + + #include "repo.h" #include "pool.h" #include "poolid_private.h" #include "util.h" +#if 0 +#include "attr_store_p.h" +#endif #define IDARRAY_BLOCK 4095 @@ -23,28 +38,42 @@ */ Repo * -pool_addrepo_empty(Pool *pool) +repo_create(Pool *pool, const char *name) { Repo *repo; pool_freewhatprovides(pool); - repo = (Repo *)xcalloc(1, sizeof(*repo)); - pool->repos = (Repo **)xrealloc(pool->repos, (pool->nrepos + 1) * sizeof(Repo *)); + repo = (Repo *)sat_calloc(1, sizeof(*repo)); + pool->repos = (Repo **)sat_realloc2(pool->repos, pool->nrepos + 1, sizeof(Repo *)); pool->repos[pool->nrepos++] = repo; - repo->name = "empty"; + repo->name = name ? strdup(name) : 0; repo->pool = pool; repo->start = pool->nsolvables; + repo->end = pool->nsolvables; repo->nsolvables = 0; return repo; } +static void +repo_freedata(Repo *repo) +{ + int i; + for (i = 0; i < repo->nrepodata; i++) + repodata_free(repo->repodata + i); + sat_free(repo->repodata); + sat_free(repo->idarraydata); + sat_free(repo->rpmdbid); + sat_free((char *)repo->name); + sat_free(repo); +} + /* * add Id to repo * olddeps = old array to extend * */ -unsigned int +Offset repo_addid(Repo *repo, Offset olddeps, Id id) { Id *idarray; @@ -56,17 +85,16 @@ repo_addid(Repo *repo, Offset olddeps, Id id) if (!idarray) /* alloc idarray if not done yet */ { - idarray = (Id *)xmalloc((1 + IDARRAY_BLOCK) * sizeof(Id)); - idarray[0] = 0; idarraysize = 1; + idarray = sat_extend_resize(0, 1, sizeof(Id), IDARRAY_BLOCK); + idarray[0] = 0; repo->lastoff = 0; } if (!olddeps) /* no deps yet */ { olddeps = idarraysize; - if ((idarraysize & IDARRAY_BLOCK) == 0) - idarray = (Id *)xrealloc(idarray, (idarraysize + 1 + IDARRAY_BLOCK) * sizeof(Id)); + idarray = sat_extend(idarray, idarraysize, 1, sizeof(Id), IDARRAY_BLOCK); } else if (olddeps == repo->lastoff) /* extend at end */ idarraysize--; @@ -76,19 +104,14 @@ repo_addid(Repo *repo, Offset olddeps, Id id) olddeps = idarraysize; for (; idarray[i]; i++) { - if ((idarraysize & IDARRAY_BLOCK) == 0) - idarray = (Id *)xrealloc(idarray, (idarraysize + 1 + IDARRAY_BLOCK) * sizeof(Id)); + idarray = sat_extend(idarray, idarraysize, 1, sizeof(Id), IDARRAY_BLOCK); idarray[idarraysize++] = idarray[i]; } - if ((idarraysize & IDARRAY_BLOCK) == 0) - idarray = (Id *)xrealloc(idarray, (idarraysize + 1 + IDARRAY_BLOCK) * sizeof(Id)); + idarray = sat_extend(idarray, idarraysize, 1, sizeof(Id), IDARRAY_BLOCK); } idarray[idarraysize++] = id; /* insert Id into array */ - - if ((idarraysize & IDARRAY_BLOCK) == 0) /* realloc if at block boundary */ - idarray = (Id *)xrealloc(idarray, (idarraysize + 1 + IDARRAY_BLOCK) * sizeof(Id)); - + idarray = sat_extend(idarray, idarraysize, 1, sizeof(Id), IDARRAY_BLOCK); idarray[idarraysize++] = 0; /* ensure NULL termination */ repo->idarraydata = idarray; @@ -100,23 +123,27 @@ repo_addid(Repo *repo, Offset olddeps, Id id) /* - * add dependency (as Id) to repo + * add dependency (as Id) to repo, also unifies dependencies * olddeps = offset into idarraydata - * isreq = 0 for normal dep - * isreq = 1 for requires - * isreq = 2 for pre-requires + * marker= 0 for normal dep + * marker > 0 add dep after marker + * marker < 0 add dep after -marker * */ - -unsigned int -repo_addid_dep(Repo *repo, Offset olddeps, Id id, int isreq) +Offset +repo_addid_dep(Repo *repo, Offset olddeps, Id id, Id marker) { - Id oid, *oidp, *marker = 0; + Id oid, *oidp, *markerp; + int before; if (!olddeps) - return repo_addid(repo, olddeps, id); + { + if (marker > 0) + olddeps = repo_addid(repo, olddeps, marker); + return repo_addid(repo, olddeps, id); + } - if (!isreq) + if (!marker) { for (oidp = repo->idarraydata + olddeps; (oid = *oidp) != ID_NULL; oidp++) { @@ -126,45 +153,55 @@ repo_addid_dep(Repo *repo, Offset olddeps, Id id, int isreq) return repo_addid(repo, olddeps, id); } + before = 0; + markerp = 0; + if (marker < 0) + { + before = 1; + marker = -marker; + } for (oidp = repo->idarraydata + olddeps; (oid = *oidp) != ID_NULL; oidp++) { - if (oid == SOLVABLE_PREREQMARKER) - marker = oidp; + if (oid == marker) + markerp = oidp; else if (oid == id) break; } if (oid) { - if (marker || isreq == 1) + if (markerp || before) return olddeps; - marker = oidp++; + /* we found it, but in the wrong half */ + markerp = oidp++; for (; (oid = *oidp) != ID_NULL; oidp++) - if (oid == SOLVABLE_PREREQMARKER) + if (oid == marker) break; if (!oid) { + /* no marker in array yet */ oidp--; - if (marker < oidp) - memmove(marker, marker + 1, (oidp - marker) * sizeof(Id)); - *oidp = SOLVABLE_PREREQMARKER; + if (markerp < oidp) + memmove(markerp, markerp + 1, (oidp - markerp) * sizeof(Id)); + *oidp = marker; return repo_addid(repo, olddeps, id); } while (oidp[1]) oidp++; - memmove(marker, marker + 1, (oidp - marker) * sizeof(Id)); + memmove(markerp, markerp + 1, (oidp - markerp) * sizeof(Id)); *oidp = id; return olddeps; } - if (isreq == 2 && !marker) - olddeps = repo_addid(repo, olddeps, SOLVABLE_PREREQMARKER); - else if (isreq == 1 && marker) + /* id not yet in array */ + if (!before && !markerp) + olddeps = repo_addid(repo, olddeps, marker); + else if (before && markerp) { - *marker++ = id; + *markerp++ = id; id = *--oidp; - if (marker < oidp) - memmove(marker + 1, marker, (oidp - marker) * sizeof(Id)); - *marker = SOLVABLE_PREREQMARKER; + if (markerp < oidp) + memmove(markerp + 1, markerp, (oidp - markerp) * sizeof(Id)); + *markerp = marker; } return repo_addid(repo, olddeps, id); } @@ -175,15 +212,15 @@ repo_addid_dep(Repo *repo, Offset olddeps, Id id, int isreq) * make space for 'num' more dependencies */ -unsigned int -repo_reserve_ids(Repo *repo, unsigned int olddeps, int num) +Offset +repo_reserve_ids(Repo *repo, Offset olddeps, int num) { num++; /* room for trailing ID_NULL */ if (!repo->idarraysize) /* ensure buffer space */ { repo->idarraysize = 1; - repo->idarraydata = (Id *)xmalloc(((1 + num + IDARRAY_BLOCK) & ~IDARRAY_BLOCK) * sizeof(Id)); + repo->idarraydata = sat_extend_resize(0, 1 + num, sizeof(Id), IDARRAY_BLOCK); repo->idarraydata[0] = 0; repo->lastoff = 1; return 1; @@ -203,10 +240,7 @@ repo_reserve_ids(Repo *repo, unsigned int olddeps, int num) ; count = idend - idstart - 1 + num; /* new size */ - /* realloc if crossing block boundary */ - if (((repo->idarraysize - 1) | IDARRAY_BLOCK) != ((repo->idarraysize + count - 1) | IDARRAY_BLOCK)) - repo->idarraydata = (Id *)xrealloc(repo->idarraydata, ((repo->idarraysize + count + IDARRAY_BLOCK) & ~IDARRAY_BLOCK) * sizeof(Id)); - + repo->idarraydata = sat_extend(repo->idarraydata, repo->idarraysize, count, sizeof(Id), IDARRAY_BLOCK); /* move old deps to end */ olddeps = repo->lastoff = repo->idarraysize; memcpy(repo->idarraydata + olddeps, idstart, count - num); @@ -218,9 +252,8 @@ repo_reserve_ids(Repo *repo, unsigned int olddeps, int num) if (olddeps) /* appending */ repo->idarraysize--; - /* realloc if crossing block boundary */ - if (((repo->idarraysize - 1) | IDARRAY_BLOCK) != ((repo->idarraysize + num - 1) | IDARRAY_BLOCK)) - repo->idarraydata = (Id *)xrealloc(repo->idarraydata, ((repo->idarraysize + num + IDARRAY_BLOCK) & ~IDARRAY_BLOCK) * sizeof(Id)); + /* make room*/ + repo->idarraydata = sat_extend(repo->idarraydata, repo->idarraysize, num, sizeof(Id), IDARRAY_BLOCK); /* appending or new */ repo->lastoff = olddeps ? olddeps : repo->idarraysize; @@ -230,55 +263,97 @@ repo_reserve_ids(Repo *repo, unsigned int olddeps, int num) /* - * remove repo from pool + * remove repo from pool, zero out solvables * */ void -pool_freerepo(Pool *pool, Repo *repo) +repo_free(Repo *repo, int reuseids) { - int i, nsolvables; + Pool *pool = repo->pool; + Solvable *s; + int i; pool_freewhatprovides(pool); + if (repo == pool->installed) + pool->installed = 0; - for (i = 0; i < pool->nrepos; i++) /* find repo in pool */ + if (reuseids && repo->end == pool->nsolvables) { - if (pool->repos[i] == repo) - break; + /* it's ok to reuse the ids. As this is the last repo, we can + just shrink the solvable array */ + for (i = repo->end - 1, s = pool->solvables + i; i >= repo->start; i--, s--) + if (s->repo != repo) + break; + repo->end = i + 1; + pool->nsolvables = i + 1; } + /* zero out solvables belonging to this repo */ + for (i = repo->start, s = pool->solvables + i; i < repo->end; i++, s++) + if (s->repo == repo) + memset(s, 0, sizeof(*s)); + for (i = 0; i < pool->nrepos; i++) /* find repo in pool */ + if (pool->repos[i] == repo) + break; if (i == pool->nrepos) /* repo not in pool, return */ return; + if (i < pool->nrepos - 1) + memmove(pool->repos + i, pool->repos + i + 1, (pool->nrepos - 1 - i) * sizeof(Repo *)); + pool->nrepos--; + repo_freedata(repo); +} - /* close gap - * all repos point into pool->solvables _relatively_ to repo->start - * so closing the gap only needs adaption of repo->start for all - * other repos. - */ - - nsolvables = repo->nsolvables; - if (pool->nsolvables > repo->start + nsolvables) - memmove(pool->solvables + repo->start, pool->solvables + repo->start + nsolvables, (pool->nsolvables - repo->start - nsolvables) * sizeof(Solvable)); - pool->nsolvables -= nsolvables; +void +repo_freeallrepos(Pool *pool, int reuseids) +{ + int i; - for (; i < pool->nrepos - 1; i++) - { - pool->repos[i] = pool->repos[i + 1]; /* remove repo */ - pool->repos[i]->start -= nsolvables; /* adapt start offset of remaining repos */ - } - pool->nrepos = i; + pool_freewhatprovides(pool); + for (i = 0; i < pool->nrepos; i++) + repo_freedata(pool->repos[i]); + pool->repos = sat_free(pool->repos); + pool->nrepos = 0; + /* the first two solvables don't belong to a repo */ + pool_free_solvable_block(pool, 2, pool->nsolvables - 2, reuseids); +} - xfree(repo->idarraydata); - xfree(repo->rpmdbid); - xfree(repo); + +#define REPO_SIDEDATA_BLOCK 63 + +void * +repo_sidedata_create(Repo *repo, size_t size) +{ + return sat_calloc_block(repo->end - repo->start, size, REPO_SIDEDATA_BLOCK); } -unsigned int -repo_fix_legacy(Repo *repo, unsigned int provides, unsigned int supplements) +void * +repo_sidedata_extend(Repo *repo, void *b, size_t size, Id p, int count) +{ + int n = repo->end - repo->start; + if (p < repo->start) + { + int d = repo->start - p; + b = sat_extend(b, n, d, size, REPO_SIDEDATA_BLOCK); + memmove((char*)b + d * size, b, n * size); + memset(b, 0, d * size); + n += d; + } + if (p + count > repo->end) + { + int d = p + count - repo->end; + b = sat_extend(b, n, d, size, REPO_SIDEDATA_BLOCK); + memset((char*)b + n * size, 0, d * size); + } + return b; +} + +Offset +repo_fix_supplements(Repo *repo, Offset provides, Offset supplements, Offset freshens) { Pool *pool = repo->pool; - Id id, idp, idl, idns; + Id id, idp, idl; char buf[1024], *p, *dep; - int i; + int i, l; if (provides) { @@ -307,9 +382,14 @@ repo_fix_legacy(Repo *repo, unsigned int provides, unsigned int supplements) dep = p + 1; continue; } - strncpy(dep - 9, "language:", 9); *p++ = 0; +#if 0 + strncpy(dep - 9, "language:", 9); idl = str2id(pool, dep - 9, 1); +#else + idl = str2id(pool, dep, 1); + idl = rel2id(pool, NAMESPACE_LANGUAGE, idl, REL_NAMESPACE, 1); +#endif if (id) id = rel2id(pool, id, idl, REL_OR, 1); else @@ -321,8 +401,13 @@ repo_fix_legacy(Repo *repo, unsigned int provides, unsigned int supplements) for (p = dep; *p && *p != ')'; p++) ; *p = 0; +#if 0 strncpy(dep - 9, "language:", 9); idl = str2id(pool, dep - 9, 1); +#else + idl = str2id(pool, dep, 1); + idl = rel2id(pool, NAMESPACE_LANGUAGE, idl, REL_NAMESPACE, 1); +#endif if (id) id = rel2id(pool, id, idl, REL_OR, 1); else @@ -339,82 +424,611 @@ repo_fix_legacy(Repo *repo, unsigned int provides, unsigned int supplements) p = buf + (p - dep); *p++ = 0; idp = str2id(pool, buf, 1); - idns = str2id(pool, "namespace:installed", 1); + /* strip trailing slashes */ + l = strlen(p); + while (l > 1 && p[l - 1] == '/') + p[--l] = 0; id = str2id(pool, p, 1); - id = rel2id(pool, idns, id, REL_NAMESPACE, 1); - id = rel2id(pool, idp, id, REL_AND, 1); + id = rel2id(pool, idp, id, REL_WITH, 1); + id = rel2id(pool, NAMESPACE_SPLITPROVIDES, id, REL_NAMESPACE, 1); supplements = repo_addid_dep(repo, supplements, id, 0); } } } - if (!supplements) - return 0; - for (i = supplements; repo->idarraydata[i]; i++) + if (supplements) + { + for (i = supplements; repo->idarraydata[i]; i++) + { + id = repo->idarraydata[i]; + if (ISRELDEP(id)) + continue; + dep = (char *)id2str(pool, id); + if (!strncmp(dep, "system:modalias(", 16)) + dep += 7; + if (!strncmp(dep, "modalias(", 9) && dep[9] && dep[10] && strlen(dep) < sizeof(buf)) + { + strcpy(buf, dep); + p = strchr(buf + 9, ':'); + if (p && p != buf + 9 && strchr(p + 1, ':')) + { + *p++ = 0; + idp = str2id(pool, buf + 9, 1); + p[strlen(p) - 1] = 0; + id = str2id(pool, p, 1); + id = rel2id(pool, NAMESPACE_MODALIAS, id, REL_NAMESPACE, 1); + id = rel2id(pool, idp, id, REL_AND, 1); + } + else + { + p = buf + 9; + p[strlen(p) - 1] = 0; + id = str2id(pool, p, 1); + id = rel2id(pool, NAMESPACE_MODALIAS, id, REL_NAMESPACE, 1); + } + if (id) + repo->idarraydata[i] = id; + } + else if (!strncmp(dep, "packageand(", 11) && strlen(dep) < sizeof(buf)) + { + strcpy(buf, dep); + id = 0; + dep = buf + 11; + while ((p = strchr(dep, ':')) != 0) + { + if (p == dep) + { + dep = p + 1; + continue; + } + *p++ = 0; + idp = str2id(pool, dep, 1); + if (id) + id = rel2id(pool, id, idp, REL_AND, 1); + else + id = idp; + dep = p; + } + if (dep[0] && dep[1]) + { + dep[strlen(dep) - 1] = 0; + idp = str2id(pool, dep, 1); + if (id) + id = rel2id(pool, id, idp, REL_AND, 1); + else + id = idp; + } + if (id) + repo->idarraydata[i] = id; + } + else if (!strncmp(dep, "filesystem(", 11) && strlen(dep) < sizeof(buf)) + { + strcpy(buf, dep + 11); + if ((p = strrchr(buf, ')')) != 0) + *p = 0; + id = str2id(pool, buf, 1); + id = rel2id(pool, NAMESPACE_FILESYSTEM, id, REL_NAMESPACE, 1); + repo->idarraydata[i] = id; + } + } + } + if (freshens && repo->idarraydata[freshens]) + { + Id idsupp = 0, idfresh = 0; + if (!supplements) + return freshens; + for (i = supplements; repo->idarraydata[i]; i++) + { + if (!idsupp) + idsupp = repo->idarraydata[i]; + else + idsupp = rel2id(pool, idsupp, repo->idarraydata[i], REL_OR, 1); + } + for (i = freshens; repo->idarraydata[i]; i++) + { + if (!idfresh) + idfresh = repo->idarraydata[i]; + else + idfresh = rel2id(pool, idfresh, repo->idarraydata[i], REL_OR, 1); + } + if (!idsupp) + idsupp = idfresh; + else + idsupp = rel2id(pool, idsupp, idfresh, REL_AND, 1); + supplements = repo_addid_dep(repo, 0, idsupp, 0); + } + return supplements; +} + +Offset +repo_fix_conflicts(Repo *repo, Offset conflicts) +{ + char buf[1024], *p, *dep; + Pool *pool = repo->pool; + Id id; + int i; + + if (!conflicts) + return conflicts; + for (i = conflicts; repo->idarraydata[i]; i++) { id = repo->idarraydata[i]; if (ISRELDEP(id)) continue; dep = (char *)id2str(pool, id); - if (!strncmp(dep, "system:modalias(", 16)) - dep += 7; - if (!strncmp(dep, "modalias(", 9) && dep[9] && dep[10] && strlen(dep) < sizeof(buf)) + if (!strncmp(dep, "otherproviders(", 15) && strlen(dep) < sizeof(buf) - 2) + { + strcpy(buf, dep + 15); + if ((p = strchr(buf, ')')) != 0) + *p = 0; + id = str2id(pool, buf, 1); + id = rel2id(pool, NAMESPACE_OTHERPROVIDERS, id, REL_NAMESPACE, 1); + repo->idarraydata[i] = id; + } + } + return conflicts; +} + +struct matchdata +{ + Pool *pool; + int flags; + Datamatcher matcher; + int stop; + int (*callback)(void *cbdata, Solvable *s, Repodata *data, Repokey *key, KeyValue *kv); + void *callback_data; +}; + +int +repo_matchvalue(void *cbdata, Solvable *s, Repodata *data, Repokey *key, KeyValue *kv) +{ + struct matchdata *md = cbdata; + + if (md->matcher.match) + { + if (!repodata_stringify(md->pool, data, key, kv, md->flags)) + return 0; + if (!datamatcher_match(&md->matcher, kv->str)) + return 0; + } + md->stop = md->callback(md->callback_data, s, data, key, kv); + return md->stop; +} + + +static Repokey solvablekeys[RPM_RPMDBID - SOLVABLE_NAME + 1] = { + { SOLVABLE_NAME, REPOKEY_TYPE_ID, 0, KEY_STORAGE_SOLVABLE }, + { SOLVABLE_ARCH, REPOKEY_TYPE_ID, 0, KEY_STORAGE_SOLVABLE }, + { SOLVABLE_EVR, REPOKEY_TYPE_ID, 0, KEY_STORAGE_SOLVABLE }, + { SOLVABLE_VENDOR, REPOKEY_TYPE_ID, 0, KEY_STORAGE_SOLVABLE }, + { SOLVABLE_PROVIDES, REPOKEY_TYPE_IDARRAY, 0, KEY_STORAGE_SOLVABLE }, + { SOLVABLE_OBSOLETES, REPOKEY_TYPE_IDARRAY, 0, KEY_STORAGE_SOLVABLE }, + { SOLVABLE_CONFLICTS, REPOKEY_TYPE_IDARRAY, 0, KEY_STORAGE_SOLVABLE }, + { SOLVABLE_REQUIRES, REPOKEY_TYPE_IDARRAY, 0, KEY_STORAGE_SOLVABLE }, + { SOLVABLE_RECOMMENDS, REPOKEY_TYPE_IDARRAY, 0, KEY_STORAGE_SOLVABLE }, + { SOLVABLE_SUGGESTS, REPOKEY_TYPE_IDARRAY, 0, KEY_STORAGE_SOLVABLE }, + { SOLVABLE_SUPPLEMENTS, REPOKEY_TYPE_IDARRAY, 0, KEY_STORAGE_SOLVABLE }, + { SOLVABLE_ENHANCES, REPOKEY_TYPE_IDARRAY, 0, KEY_STORAGE_SOLVABLE }, + { RPM_RPMDBID, REPOKEY_TYPE_U32, 0, KEY_STORAGE_SOLVABLE }, +}; + +static void +domatch_idarray(Solvable *s, Id keyname, struct matchdata *md, Id *ida) +{ + KeyValue kv; + kv.entry = 0; + kv.parent = 0; + for (; *ida && !md->stop; ida++) + { + kv.id = *ida; + kv.eof = ida[1] ? 0 : 1; + repo_matchvalue(md, s, 0, solvablekeys + (keyname - SOLVABLE_NAME), &kv); + kv.entry++; + } +} + +static void +repo_search_md(Repo *repo, Id p, Id keyname, struct matchdata *md) +{ + KeyValue kv; + Pool *pool = repo->pool; + Repodata *data; + int i, j, flags; + Solvable *s; + + kv.parent = 0; + md->stop = 0; + if (!p) + { + for (p = repo->start, s = repo->pool->solvables + p; p < repo->end; p++, s++) { - strcpy(buf, dep); - p = strchr(buf + 9, ':'); - idns = str2id(pool, "namespace:modalias", 1); - if (p && p != buf + 9 && strchr(p + 1, ':')) + if (s->repo == repo) + repo_search_md(repo, p, keyname, md); + if (md->stop > SEARCH_NEXT_SOLVABLE) + break; + } + return; + } + else if (p < 0) + /* The callback only supports solvables, so we can't iterate over the + extra things. */ + return; + flags = md->flags; + if (!(flags & SEARCH_NO_STORAGE_SOLVABLE)) + { + s = pool->solvables + p; + switch(keyname) + { + case 0: + case SOLVABLE_NAME: + if (s->name) + { + kv.id = s->name; + repo_matchvalue(md, s, 0, solvablekeys + 0, &kv); + } + if (keyname || md->stop > SEARCH_NEXT_KEY) + return; + case SOLVABLE_ARCH: + if (s->arch) + { + kv.id = s->arch; + repo_matchvalue(md, s, 0, solvablekeys + 1, &kv); + } + if (keyname || md->stop > SEARCH_NEXT_KEY) + return; + case SOLVABLE_EVR: + if (s->evr) + { + kv.id = s->evr; + repo_matchvalue(md, s, 0, solvablekeys + 2, &kv); + } + if (keyname || md->stop > SEARCH_NEXT_KEY) + return; + case SOLVABLE_VENDOR: + if (s->vendor) + { + kv.id = s->vendor; + repo_matchvalue(md, s, 0, solvablekeys + 3, &kv); + } + if (keyname || md->stop > SEARCH_NEXT_KEY) + return; + case SOLVABLE_PROVIDES: + if (s->provides) + domatch_idarray(s, SOLVABLE_PROVIDES, md, repo->idarraydata + s->provides); + if (keyname || md->stop > SEARCH_NEXT_KEY) + return; + case SOLVABLE_OBSOLETES: + if (s->obsoletes) + domatch_idarray(s, SOLVABLE_OBSOLETES, md, repo->idarraydata + s->obsoletes); + if (keyname || md->stop > SEARCH_NEXT_KEY) + return; + case SOLVABLE_CONFLICTS: + if (s->conflicts) + domatch_idarray(s, SOLVABLE_CONFLICTS, md, repo->idarraydata + s->conflicts); + if (keyname || md->stop > SEARCH_NEXT_KEY) + return; + case SOLVABLE_REQUIRES: + if (s->requires) + domatch_idarray(s, SOLVABLE_REQUIRES, md, repo->idarraydata + s->requires); + if (keyname || md->stop > SEARCH_NEXT_KEY) + return; + case SOLVABLE_RECOMMENDS: + if (s->recommends) + domatch_idarray(s, SOLVABLE_RECOMMENDS, md, repo->idarraydata + s->recommends); + if (keyname || md->stop > SEARCH_NEXT_KEY) + return; + case SOLVABLE_SUPPLEMENTS: + if (s->supplements) + domatch_idarray(s, SOLVABLE_SUPPLEMENTS, md, repo->idarraydata + s->supplements); + if (keyname || md->stop > SEARCH_NEXT_KEY) + return; + case SOLVABLE_SUGGESTS: + if (s->suggests) + domatch_idarray(s, SOLVABLE_SUGGESTS, md, repo->idarraydata + s->suggests); + if (keyname || md->stop > SEARCH_NEXT_KEY) + return; + case SOLVABLE_ENHANCES: + if (s->enhances) + domatch_idarray(s, SOLVABLE_ENHANCES, md, repo->idarraydata + s->enhances); + if (keyname || md->stop > SEARCH_NEXT_KEY) + return; + case RPM_RPMDBID: + if (repo->rpmdbid) + { + kv.num = repo->rpmdbid[p - repo->start]; + repo_matchvalue(md, s, 0, solvablekeys + (RPM_RPMDBID - SOLVABLE_NAME), &kv); + } + if (keyname || md->stop > SEARCH_NEXT_KEY) + return; + break; + default: + break; + } + } + + for (i = 0, data = repo->repodata; i < repo->nrepodata; i++, data++) + { + if (p < data->start || p >= data->end) + continue; + if (keyname && !repodata_precheck_keyname(data, keyname)) + continue; + if (data->state == REPODATA_STUB) + { + if (keyname) { - *p++ = 0; - idp = str2id(pool, buf + 9, 1); - p[strlen(p) - 1] = 0; - id = str2id(pool, p, 1); - id = rel2id(pool, idns, id, REL_NAMESPACE, 1); - id = rel2id(pool, idp, id, REL_AND, 1); + for (j = 1; j < data->nkeys; j++) + if (keyname == data->keys[j].name) + break; + if (j == data->nkeys) + continue; } + /* load it */ + if (data->loadcallback) + data->loadcallback(data); else + data->state = REPODATA_ERROR; + } + if (data->state == REPODATA_ERROR) + continue; + repodata_search(data, p, keyname, md->flags, repo_matchvalue, md); + if (md->stop > SEARCH_NEXT_KEY) + break; + } +} + +void +repo_search(Repo *repo, Id p, Id keyname, const char *match, int flags, int (*callback)(void *cbdata, Solvable *s, Repodata *data, Repokey *key, KeyValue *kv), void *cbdata) +{ + struct matchdata md; + + memset(&md, 0, sizeof(md)); + md.pool = repo->pool; + md.flags = flags; + md.callback = callback; + md.callback_data = cbdata; + if (match) + datamatcher_init(&md.matcher, match, flags); + repo_search_md(repo, p, keyname, &md); + if (match) + datamatcher_free(&md.matcher); +} + +const char * +repo_lookup_str(Repo *repo, Id entry, Id keyname) +{ + Pool *pool = repo->pool; + Repodata *data; + int i, j; + + switch(keyname) + { + case SOLVABLE_NAME: + return id2str(pool, pool->solvables[entry].name); + case SOLVABLE_ARCH: + return id2str(pool, pool->solvables[entry].arch); + case SOLVABLE_EVR: + return id2str(pool, pool->solvables[entry].evr); + case SOLVABLE_VENDOR: + return id2str(pool, pool->solvables[entry].vendor); + } + for (i = 0, data = repo->repodata; i < repo->nrepodata; i++, data++) + { + if (entry != SOLVID_META && (entry < data->start || entry >= data->end)) + continue; + if (!repodata_precheck_keyname(data, keyname)) + continue; + for (j = 1; j < data->nkeys; j++) + { + 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)) + return repodata_lookup_str(data, entry, keyname); + } + } + return 0; +} + + +unsigned int +repo_lookup_num(Repo *repo, Id entry, Id keyname, unsigned int notfound) +{ + Repodata *data; + int i, j; + + if (keyname == RPM_RPMDBID) + { + if (repo->rpmdbid && entry >= repo->start && entry < repo->end) + return repo->rpmdbid[entry - repo->start]; + return notfound; + } + for (i = 0, data = repo->repodata; i < repo->nrepodata; i++, data++) + { + if (entry != SOLVID_META && (entry < data->start || entry >= data->end)) + continue; + if (!repodata_precheck_keyname(data, keyname)) + continue; + for (j = 1; j < data->nkeys; j++) + { + if (data->keys[j].name == keyname + && (data->keys[j].type == REPOKEY_TYPE_U32 + || data->keys[j].type == REPOKEY_TYPE_NUM + || data->keys[j].type == REPOKEY_TYPE_CONSTANT)) { - p = buf + 9; - p[strlen(p) - 1] = 0; - id = str2id(pool, p, 1); - id = rel2id(pool, idns, id, REL_NAMESPACE, 1); + unsigned value; + if (repodata_lookup_num(data, entry, keyname, &value)) + return value; } - if (id) - repo->idarraydata[i] = id; } - else if (!strncmp(dep, "packageand(", 11) && strlen(dep) < sizeof(buf)) + } + return notfound; +} + +Id +repo_lookup_id(Repo *repo, Id entry, Id keyname) +{ + Repodata *data; + int i, j; + + switch(keyname) + { + case SOLVABLE_NAME: + return repo->pool->solvables[entry].name; + case SOLVABLE_ARCH: + return repo->pool->solvables[entry].arch; + case SOLVABLE_EVR: + return repo->pool->solvables[entry].evr; + case SOLVABLE_VENDOR: + return repo->pool->solvables[entry].vendor; + } + for (i = 0, data = repo->repodata; i < repo->nrepodata; i++, data++) + { + if (entry != SOLVID_META && (entry < data->start || entry >= data->end)) + continue; + if (!repodata_precheck_keyname(data, keyname)) + continue; + for (j = 1; j < data->nkeys; j++) { - strcpy(buf, dep); - id = 0; - dep = buf + 11; - while ((p = strchr(dep, ':')) != 0) + if (data->keys[j].name == keyname && (data->keys[j].type == REPOKEY_TYPE_ID || data->keys[j].type == REPOKEY_TYPE_CONSTANTID)) { - if (p == dep) + Id id = repodata_lookup_id(data, entry, keyname); + if (id) { - dep = p + 1; - continue; + if (data->localpool) + id = repodata_globalize_id(data, id); + return id; } - *p++ = 0; - idp = str2id(pool, dep, 1); - if (id) - id = rel2id(pool, id, idp, REL_AND, 1); - else - id = idp; - dep = p; } - if (dep[0] && dep[1]) + } + } + return 0; +} + +const unsigned char * +repo_lookup_bin_checksum(Repo *repo, Id entry, Id keyname, Id *typep) +{ + Repodata *data; + int i, j; + for (i = 0, data = repo->repodata; i < repo->nrepodata; i++, data++) + { + if (entry != SOLVID_META && (entry < data->start || entry >= data->end)) + continue; + if (!repodata_precheck_keyname(data, keyname)) + continue; + for (j = 1; j < data->nkeys; j++) + { + if (data->keys[j].name == keyname) { - dep[strlen(dep) - 1] = 0; - idp = str2id(pool, dep, 1); - if (id) - id = rel2id(pool, id, idp, REL_AND, 1); - else - id = idp; + const unsigned char *chk = repodata_lookup_bin_checksum(data, entry, keyname, typep); + if (chk) + return chk; } - if (id) - repo->idarraydata[i] = id; } } - return supplements; + *typep = 0; + return 0; +} + +int +repo_lookup_void(Repo *repo, Id entry, Id keyname) +{ + Repodata *data; + int i, j; + for (i = 0, data = repo->repodata; i < repo->nrepodata; i++, data++) + { + if (entry != SOLVID_META && (entry < data->start || entry >= data->end)) + continue; + if (!repodata_precheck_keyname(data, keyname)) + continue; + for (j = 1; j < data->nkeys; j++) + { + if (data->keys[j].name == keyname + && (data->keys[j].type == REPOKEY_TYPE_VOID)) + { + if (repodata_lookup_void(data, entry, keyname)) + return 1; + } + } + } + return 0; +} + +/***********************************************************************/ + +Repodata * +repo_add_repodata(Repo *repo, int localpool) +{ + Repodata *data; + + repo->nrepodata++; + repo->repodata = sat_realloc2(repo->repodata, repo->nrepodata, sizeof(*data)); + data = repo->repodata + repo->nrepodata - 1; + repodata_init(data, repo, localpool); + return data; +} + +Repodata * +repo_last_repodata(Repo *repo) +{ + int i; + for (i = repo->nrepodata - 1; i >= 0; i--) + if (repo->repodata[i].state != REPODATA_STUB) + return repo->repodata + i; + return repo_add_repodata(repo, 0); } +void +repo_set_id(Repo *repo, Id p, Id keyname, Id id) +{ + Repodata *data = repo_last_repodata(repo); + repodata_set_id(data, p, keyname, id); +} + +void +repo_set_num(Repo *repo, Id p, Id keyname, Id num) +{ + Repodata *data = repo_last_repodata(repo); + repodata_set_num(data, p, keyname, num); +} + +void +repo_set_str(Repo *repo, Id p, Id keyname, const char *str) +{ + Repodata *data = repo_last_repodata(repo); + repodata_set_str(data, p, keyname, str); +} + +void +repo_set_poolstr(Repo *repo, Id p, Id keyname, const char *str) +{ + Repodata *data = repo_last_repodata(repo); + repodata_set_poolstr(data, p, keyname, str); +} + +void +repo_add_poolstr_array(Repo *repo, Id p, Id keyname, const char *str) +{ + Repodata *data = repo_last_repodata(repo); + repodata_add_poolstr_array(data, p, keyname, str); +} + +void +repo_internalize(Repo *repo) +{ + int i; + Repodata *data; + + for (i = 0, data = repo->repodata; i < repo->nrepodata; i++, data++) + if (data->attrs || data->xattrs) + repodata_internalize(data); +} + +void +repo_disable_paging(Repo *repo) +{ + int i; + Repodata *data; + + for (i = 0, data = repo->repodata; i < repo->nrepodata; i++, data++) + repodata_disable_paging(data); +} // EOF +/* +vim:cinoptions={.5s,g0,p5,t0,(0,^-0.5s,n-0.5s:tw=78:cindent:sw=4: +*/