#include "tools_util.h"
#include "repo_rpmmd.h"
#include "chksum.h"
-
+#ifdef ENABLE_COMPLEX_DEPS
+#include "pool_parserpmrichdep.h"
+#endif
enum state {
STATE_START,
STATE_INSTALL_TIME,
/* product */
- STATE_SHORTNAME,
- STATE_DISTNAME, /* obsolete */
- STATE_DISTEDITION, /* obsolete */
- STATE_SOURCE,
- STATE_TYPE,
STATE_RELNOTESURL,
STATE_UPDATEURL,
STATE_OPTIONALURL,
/* product attributes */
/* note the product type is an attribute */
{ STATE_SOLVABLE, "release-notes-url", STATE_RELNOTESURL, 1 },
- { STATE_SOLVABLE, "update-url", STATE_UPDATEURL, 1 },
- { STATE_SOLVABLE, "optional-url", STATE_OPTIONALURL, 1 },
- { STATE_SOLVABLE, "flag", STATE_FLAG, 1 },
+ { STATE_SOLVABLE, "update-url", STATE_UPDATEURL, 1 },
+ { STATE_SOLVABLE, "optional-url", STATE_OPTIONALURL, 1 },
+ { STATE_SOLVABLE, "flag", STATE_FLAG, 1 },
- { STATE_SOLVABLE, "rpm:vendor", STATE_VENDOR, 1 },
- { STATE_SOLVABLE, "rpm:group", STATE_RPM_GROUP, 1 },
- { STATE_SOLVABLE, "rpm:license", STATE_RPM_LICENSE, 1 },
+ { STATE_SOLVABLE, "rpm:vendor", STATE_VENDOR, 1 },
+ { STATE_SOLVABLE, "rpm:group", STATE_RPM_GROUP, 1 },
+ { STATE_SOLVABLE, "rpm:license", STATE_RPM_LICENSE, 1 },
/* rpm-md dependencies */
- { STATE_SOLVABLE, "rpm:provides", STATE_PROVIDES, 0 },
- { STATE_SOLVABLE, "rpm:requires", STATE_REQUIRES, 0 },
- { STATE_SOLVABLE, "rpm:obsoletes", STATE_OBSOLETES, 0 },
- { STATE_SOLVABLE, "rpm:conflicts", STATE_CONFLICTS, 0 },
- { STATE_SOLVABLE, "rpm:recommends", STATE_RECOMMENDS , 0 },
- { STATE_SOLVABLE, "rpm:supplements", STATE_SUPPLEMENTS, 0 },
- { STATE_SOLVABLE, "rpm:suggests", STATE_SUGGESTS, 0 },
- { STATE_SOLVABLE, "rpm:enhances", STATE_ENHANCES, 0 },
- { STATE_SOLVABLE, "rpm:freshens", STATE_FRESHENS, 0 },
- { STATE_SOLVABLE, "rpm:sourcerpm", STATE_SOURCERPM, 1 },
- { STATE_SOLVABLE, "rpm:header-range", STATE_HEADERRANGE, 0 },
- { STATE_SOLVABLE, "file", STATE_FILE, 1 },
- { STATE_SOLVABLE, "changelog", STATE_CHANGELOG, 1 },
+ { STATE_SOLVABLE, "rpm:provides", STATE_PROVIDES, 0 },
+ { STATE_SOLVABLE, "rpm:requires", STATE_REQUIRES, 0 },
+ { STATE_SOLVABLE, "rpm:obsoletes", STATE_OBSOLETES, 0 },
+ { STATE_SOLVABLE, "rpm:conflicts", STATE_CONFLICTS, 0 },
+ { STATE_SOLVABLE, "rpm:recommends", STATE_RECOMMENDS , 0 },
+ { STATE_SOLVABLE, "rpm:supplements", STATE_SUPPLEMENTS, 0 },
+ { STATE_SOLVABLE, "rpm:suggests", STATE_SUGGESTS, 0 },
+ { STATE_SOLVABLE, "rpm:enhances", STATE_ENHANCES, 0 },
+ { STATE_SOLVABLE, "rpm:freshens", STATE_FRESHENS, 0 },
+ { STATE_SOLVABLE, "rpm:sourcerpm", STATE_SOURCERPM, 1 },
+ { STATE_SOLVABLE, "rpm:header-range", STATE_HEADERRANGE, 0 },
+ { STATE_SOLVABLE, "file", STATE_FILE, 1 },
+ { STATE_SOLVABLE, "changelog", STATE_CHANGELOG, 1 },
/* extended Novell/SUSE diskusage attributes (susedata.xml) */
{ STATE_DISKUSAGE, "dirs", STATE_DIRS, 0 },
Id changelog_handle;
- /** Hash to maps checksums to solv */
- Stringpool cspool;
- /** Cache of known checksums to solvable id */
- Id *cscache;
- /* the current longest index in the table */
- int ncscache;
+ int extending; /* are we extending an existing solvable? */
+ int first; /* first solvable we added */
+ int cshash_filled; /* hash is filled with data */
+
+ Hashtable cshash; /* checksum hash -> offset into csdata */
+ Hashval cshashm; /* hash mask */
+ int ncshash; /* entries used */
+ unsigned char *csdata; /* [len, checksum, id] */
+ int ncsdata; /* used bytes */
};
static Id
else if (!strcmp(*atts, "rel"))
r = atts[1];
}
- if (e && !strcmp(e, "0"))
+ if (e && (!*e || !strcmp(e, "0")))
e = 0;
if (v && !e)
{
static unsigned int
adddep(Pool *pool, struct parsedata *pd, unsigned int olddeps, const char **atts, int isreq)
{
- Id id, name, marker;
+ Id id, marker;
const char *n, *f, *k;
const char **a;
pd->acontent = l + 256;
}
sprintf(pd->content, "%s:%s", k, n);
- name = pool_str2id(pool, pd->content, 1);
+ id = pool_str2id(pool, pd->content, 1);
+ }
+#ifdef ENABLE_COMPLEX_DEPS
+ else if (!f && n[0] == '(')
+ {
+ id = pool_parserpmrichdep(pool, n);
+ if (!id)
+ return olddeps;
}
+#endif
else
- name = pool_str2id(pool, (char *)n, 1);
+ id = pool_str2id(pool, (char *)n, 1);
if (f)
{
Id evr = makeevr_atts(pool, pd, atts);
if (!strcmp(f, flagtab[flags]))
break;
flags = flags < 6 ? flags + 1 : 0;
- id = pool_rel2id(pool, name, evr, flags, 1);
+ id = pool_rel2id(pool, id, evr, flags, 1);
}
- else
- id = name;
#if 0
fprintf(stderr, "new dep %s\n", pool_dep2str(pool, id));
#endif
/*-----------------------------------------------*/
+/* checksum hash functions
+ *
+ * used to look up a solvable with the checksum for solvable extension purposes.
+ *
+ */
+
+static void
+init_cshash(struct parsedata *pd)
+{
+}
+
+static void
+free_cshash(struct parsedata *pd)
+{
+ pd->cshash = solv_free(pd->cshash);
+ pd->ncshash = 0;
+ pd->cshashm = 0;
+ pd->csdata = solv_free(pd->csdata);
+ pd->ncsdata = 0;
+}
+
+static inline Hashval
+hashkey(const unsigned char *key, int keyl)
+{
+ return key[0] << 24 | key[1] << 16 | key[2] << 8 | key[3];
+}
+
+static void
+rebuild_cshash(struct parsedata *pd)
+{
+ Hashval h, hh, hm;
+ Hashtable ht;
+ unsigned char *d, *de;
+
+ hm = pd->cshashm;
+#if 0
+ fprintf(stderr, "rebuild cshash with mask 0x%x\n", hm);
+#endif
+ solv_free(pd->cshash);
+ ht = pd->cshash = (Hashtable)solv_calloc(hm + 1, sizeof(Id));
+ d = pd->csdata;
+ de = d + pd->ncsdata;
+ while (d != de)
+ {
+ h = hashkey(d + 1, d[0] + 1) & hm;
+ hh = HASHCHAIN_START;
+ while (ht[h])
+ h = HASHCHAIN_NEXT(h, hh, hm);
+ ht[h] = d + 1 - pd->csdata;
+ d += 2 + d[0] + sizeof(Id);
+ }
+}
+
+static void
+put_in_cshash(struct parsedata *pd, const unsigned char *key, int keyl, Id id)
+{
+ Hashtable ht;
+ Hashval h, hh, hm;
+ unsigned char *d;
+
+ if (keyl < 4 || keyl > 256)
+ return;
+ ht = pd->cshash;
+ hm = pd->cshashm;
+ h = hashkey(key, keyl) & hm;
+ hh = HASHCHAIN_START;
+ if (ht)
+ {
+ while (ht[h])
+ {
+ unsigned char *d = pd->csdata + ht[h];
+ if (d[-1] == keyl - 1 && !memcmp(key, d, keyl))
+ return; /* XXX: first id wins... */
+ h = HASHCHAIN_NEXT(h, hh, hm);
+ }
+ }
+ /* a new entry. put in csdata */
+ pd->csdata = solv_extend(pd->csdata, pd->ncsdata, 1 + keyl + sizeof(Id), 1, 4095);
+ d = pd->csdata + pd->ncsdata;
+ d[0] = keyl - 1;
+ memcpy(d + 1, key, keyl);
+ memcpy(d + 1 + keyl, &id, sizeof(Id));
+ pd->ncsdata += 1 + keyl + sizeof(Id);
+ if ((Hashval)++pd->ncshash * 2 > hm)
+ {
+ pd->cshashm = pd->cshashm ? (2 * pd->cshashm + 1) : 4095;
+ rebuild_cshash(pd);
+ }
+ else
+ ht[h] = pd->ncsdata - (keyl + sizeof(Id));
+}
+
+static Id
+lookup_cshash(struct parsedata *pd, const unsigned char *key, int keyl)
+{
+ Hashtable ht;
+ Hashval h, hh, hm;
+
+ if (keyl < 4 || keyl > 256)
+ return 0;
+ ht = pd->cshash;
+ if (!ht)
+ return 0;
+ hm = pd->cshashm;
+ h = hashkey(key, keyl) & hm;
+ hh = HASHCHAIN_START;
+ while (ht[h])
+ {
+ unsigned char *d = pd->csdata + ht[h];
+ if (d[-1] == keyl - 1 && !memcmp(key, d, keyl))
+ {
+ Id id;
+ memcpy(&id, d + keyl, sizeof(Id));
+ return id;
+ }
+ h = HASHCHAIN_NEXT(h, hh, hm);
+ }
+ return 0;
+}
+
+static void
+fill_cshash_from_repo(struct parsedata *pd)
+{
+ Dataiterator di;
+ /* setup join data */
+ dataiterator_init(&di, pd->pool, pd->repo, 0, SOLVABLE_CHECKSUM, 0, 0);
+ while (dataiterator_step(&di))
+ put_in_cshash(pd, (const unsigned char *)di.kv.str, solv_chksum_len(di.key->type), di.solvid);
+ dataiterator_free(&di);
+}
+
+static void
+fill_cshash_from_new_solvables(struct parsedata *pd)
+{
+ Pool *pool = pd->pool;
+ Id cstype = 0;
+ unsigned const char *cs;
+ int i;
+
+ for (i = pd->first; i < pool->nsolvables; i++)
+ {
+ if (pool->solvables[i].repo != pd->repo)
+ continue;
+ cs = repodata_lookup_bin_checksum_uninternalized(pd->data, i, SOLVABLE_CHECKSUM, &cstype);
+ if (cs)
+ put_in_cshash(pd, cs, solv_chksum_len(cstype), i);
+ }
+}
+
+/*-----------------------------------------------*/
/* XML callbacks */
/*
a new solvable but just append the attributes to the existing
one.
*/
+ pd->extending = 0;
if ((pkgid = find_attr("pkgid", atts)) != NULL)
{
+ unsigned char chk[256];
+ int l;
+ const char *str = pkgid;
+ if (!pd->cshash_filled)
+ {
+ pd->cshash_filled = 1;
+ fill_cshash_from_new_solvables(pd);
+ }
+ handle = 0;
+ /* convert into bin checksum */
+ l = solv_hex2bin(&str, chk, sizeof(chk));
/* look at the checksum cache */
- Id index = stringpool_str2id(&pd->cspool, pkgid, 0);
- if (!index || index >= pd->ncscache || !pd->cscache[index])
+ if (l >= 4 && !pkgid[2 * l])
+ handle = lookup_cshash(pd, chk, l);
+#if 0
+ fprintf(stderr, "Lookup %s -> %d\n", pkgid, handle);
+#endif
+ if (!handle)
{
pool_debug(pool, SOLV_WARN, "the repository specifies extra information about package with checksum '%s', which does not exist in the repository.\n", pkgid);
- pd->solvable = 0;
pd->handle = 0;
+ pd->solvable = 0;
break;
}
- pd->solvable = pool_id2solvable(pool, pd->cscache[index]);
+ pd->extending = 1;
}
- else
+ else
{
/* this is a new package */
- pd->solvable = pool_id2solvable(pool, repo_add_solvable(pd->repo));
+ handle = repo_add_solvable(pd->repo);
+ if (!pd->first)
+ pd->first = handle;
pd->freshens = 0;
}
- pd->handle = pd->solvable - pool->solvables;
+ pd->handle = handle;
+ pd->solvable = pool_id2solvable(pool, handle);
+ if (pd->kind && pd->kind[1] == 'r')
+ {
+ /* products can have a type */
+ const char *type = find_attr("type", atts);
+ if (type && *type)
+ repodata_set_str(pd->data, handle, PRODUCT_TYPE, type);
+ }
#if 0
fprintf(stderr, "package #%d\n", pd->solvable - pool->solvables);
#endif
break;
case STATE_VERSION:
+ if (pd->extending && s->evr)
+ break; /* ignore version tag repetition in extend data */
s->evr = makeevr_atts(pool, pd, atts);
break;
case STATE_PROVIDES:
case STATE_INCLUDESENTRY:
str = find_attr("pattern", atts);
if (str)
- repodata_add_poolstr_array(pd->data, pd->handle, SOLVABLE_INCLUDES, join2(&pd->jd, "pattern", ":", str));
+ repodata_add_poolstr_array(pd->data, handle, SOLVABLE_INCLUDES, join2(&pd->jd, "pattern", ":", str));
break;
case STATE_EXTENDSENTRY:
str = find_attr("pattern", atts);
if (str)
- repodata_add_poolstr_array(pd->data, pd->handle, SOLVABLE_EXTENDS, join2(&pd->jd, "pattern", ":", str));
+ repodata_add_poolstr_array(pd->data, handle, SOLVABLE_EXTENDS, join2(&pd->jd, "pattern", ":", str));
break;
case STATE_LOCATION:
str = find_attr("href", atts);
if (str)
{
- repodata_set_location(pd->data, handle, 0, 0, str);
- str = find_attr("xml:base", atts);
- if (str)
- repodata_set_poolstr(pd->data, handle, SOLVABLE_MEDIABASE, str);
+ int medianr = 0;
+ const char *base = find_attr("xml:base", atts);
+ if (base && !strncmp(base, "media:", 6))
+ {
+ /* check for the media number in the fragment */
+ int l = strlen(base);
+ while (l && base[l - 1] >= '0' && base[l - 1] <= '9')
+ l--;
+ if (l && base[l - 1] == '#' && base[l])
+ medianr = atoi(base + l);
+ }
+ repodata_set_location(pd->data, handle, medianr, 0, str);
+ if (base)
+ repodata_set_poolstr(pd->data, handle, SOLVABLE_MEDIABASE, base);
}
break;
case STATE_CHECKSUM:
{
long filesz = 0, filenum = 0;
Id dirid;
- if ((str = find_attr("name", atts)) != 0)
- dirid = repodata_str2dir(pd->data, str, 1);
- else
- {
+ if ((str = find_attr("name", atts)) == 0)
+ {
pd->ret = pool_error(pool, -1, "<dir .../> tag without 'name' attribute");
break;
- }
+ }
+ if (*str != '/')
+ {
+ int l = strlen(str) + 2;
+ if (l > pd->acontent)
+ {
+ pd->content = solv_realloc(pd->content, l + 256);
+ pd->acontent = l + 256;
+ }
+ *pd->content = '/';
+ strcpy(pd->content + 1, str);
+ str = pd->content;
+ }
+ dirid = repodata_str2dir(pd->data, str, 1);
if ((str = find_attr("size", atts)) != 0)
filesz = strtol(str, 0, 0);
if ((str = find_attr("count", atts)) != 0)
switch (pd->state)
{
case STATE_SOLVABLE:
+ if (pd->extending)
+ {
+ pd->solvable = 0;
+ break;
+ }
if (pd->kind && !s->name) /* add namespace in case of NULL name */
s->name = pool_str2id(pool, join2(&pd->jd, pd->kind, ":", 0), 1);
if (!s->arch)
s->evr = ID_EMPTY; /* some patterns have this */
if (s->name && s->arch != ARCH_SRC && s->arch != ARCH_NOSRC)
s->provides = repo_addid_dep(repo, s->provides, pool_rel2id(pool, s->name, s->evr, REL_EQ, 1), 0);
- s->supplements = repo_fix_supplements(repo, s->provides, s->supplements, pd->freshens);
- s->conflicts = repo_fix_conflicts(repo, s->conflicts);
+ repo_rewrite_suse_deps(s, pd->freshens);
pd->freshens = 0;
pd->kind = 0;
- pd->solvable = s = 0;
+ pd->solvable = 0;
break;
case STATE_NAME:
if (pd->kind)
break;
case STATE_CHECKSUM:
{
- Id index;
-
- if (!pd->chksumtype)
+ unsigned char chk[256];
+ int l = solv_chksum_len(pd->chksumtype);
+ const char *str = pd->content;
+ if (!l || l > sizeof(chk))
break;
- if (strlen(pd->content) != 2 * solv_chksum_len(pd->chksumtype))
+ if (solv_hex2bin(&str, chk, l) != l || pd->content[2 * l])
{
- pd->ret = pool_error(pool, -1, "line %d: invalid checksum length for %s", (unsigned int)XML_GetCurrentLineNumber(*pd->parser), solv_chksum_type2str(pd->chksumtype));
+ pd->ret = pool_error(pool, -1, "line %u: invalid %s checksum", (unsigned int)XML_GetCurrentLineNumber(*pd->parser), solv_chksum_type2str(pd->chksumtype));
break;
}
- repodata_set_checksum(pd->data, handle, SOLVABLE_CHECKSUM, pd->chksumtype, pd->content);
- /* we save the checksum to solvable id relationship for extended
- metadata */
- index = stringpool_str2id(&pd->cspool, pd->content, 1 /* create it */);
- if (index >= pd->ncscache)
- {
- pd->cscache = solv_zextend(pd->cscache, pd->ncscache, index + 1 - pd->ncscache, sizeof(Id), 255);
- pd->ncscache = index + 1;
- }
- /* add the checksum to the cache */
- pd->cscache[index] = s - pool->solvables;
+ repodata_set_bin_checksum(pd->data, handle, SOLVABLE_CHECKSUM, pd->chksumtype, chk);
+ /* we save the checksum to solvable id relationship for extending metadata */
+ if (pd->cshash_filled)
+ put_in_cshash(pd, chk, l, s - pool->solvables);
break;
}
case STATE_FILE:
case STATE_RELNOTESURL:
if (pd->content[0])
{
- repodata_add_poolstr_array(pd->data, pd->handle, PRODUCT_URL, pd->content);
- repodata_add_idarray(pd->data, pd->handle, PRODUCT_URL_TYPE, pool_str2id(pool, "releasenotes", 1));
+ repodata_add_poolstr_array(pd->data, handle, PRODUCT_URL, pd->content);
+ repodata_add_idarray(pd->data, handle, PRODUCT_URL_TYPE, pool_str2id(pool, "releasenotes", 1));
}
break;
case STATE_UPDATEURL:
if (pd->content[0])
{
- repodata_add_poolstr_array(pd->data, pd->handle, PRODUCT_URL, pd->content);
- repodata_add_idarray(pd->data, pd->handle, PRODUCT_URL_TYPE, pool_str2id(pool, "update", 1));
+ repodata_add_poolstr_array(pd->data, handle, PRODUCT_URL, pd->content);
+ repodata_add_idarray(pd->data, handle, PRODUCT_URL_TYPE, pool_str2id(pool, "update", 1));
}
break;
case STATE_OPTIONALURL:
if (pd->content[0])
{
- repodata_add_poolstr_array(pd->data, pd->handle, PRODUCT_URL, pd->content);
- repodata_add_idarray(pd->data, pd->handle, PRODUCT_URL_TYPE, pool_str2id(pool, "optional", 1));
+ repodata_add_poolstr_array(pd->data, handle, PRODUCT_URL, pd->content);
+ repodata_add_idarray(pd->data, handle, PRODUCT_URL_TYPE, pool_str2id(pool, "optional", 1));
}
break;
case STATE_FLAG:
if (pd->content[0])
- repodata_set_poolstr(pd->data, handle, PRODUCT_FLAGS, pd->content);
+ repodata_add_poolstr_array(pd->data, handle, PRODUCT_FLAGS, pd->content);
break;
case STATE_EULA:
if (pd->content[0])
break;
case STATE_KEYWORD:
if (pd->content[0])
- repodata_add_poolstr_array(pd->data, pd->handle, SOLVABLE_KEYWORDS, pd->content);
+ repodata_add_poolstr_array(pd->data, handle, SOLVABLE_KEYWORDS, pd->content);
break;
case STATE_DISKUSAGE:
if (pd->ndirs)
- commit_diskusage(pd, pd->handle);
+ commit_diskusage(pd, handle);
break;
case STATE_ORDER:
if (pd->content[0])
- repodata_set_str(pd->data, pd->handle, SOLVABLE_ORDER, pd->content);
+ repodata_set_str(pd->data, handle, SOLVABLE_ORDER, pd->content);
break;
case STATE_CHANGELOG:
repodata_set_str(pd->data, pd->changelog_handle, SOLVABLE_CHANGELOG_TEXT, pd->content);
- repodata_add_flexarray(pd->data, pd->handle, SOLVABLE_CHANGELOG, pd->changelog_handle);
+ repodata_add_flexarray(pd->data, handle, SOLVABLE_CHANGELOG, pd->changelog_handle);
pd->changelog_handle = 0;
break;
default:
pd.kind = 0;
pd.language = language && *language && strcmp(language, "en") != 0 ? language : 0;
- /* initialize the string pool where we will store
- the package checksums we know about, to get an Id
- we can use in a cache */
- stringpool_init_empty(&pd.cspool);
+ init_cshash(&pd);
if ((flags & REPO_EXTEND_SOLVABLES) != 0)
{
/* setup join data */
- Dataiterator di;
- dataiterator_init(&di, pool, repo, 0, SOLVABLE_CHECKSUM, 0, 0);
- while (dataiterator_step(&di))
- {
- const char *str;
- int index;
-
- if (!solv_chksum_len(di.key->type))
- continue;
- str = repodata_chk2str(di.data, di.key->type, (const unsigned char *)di.kv.str);
- index = stringpool_str2id(&pd.cspool, str, 1);
- if (index >= pd.ncscache)
- {
- pd.cscache = solv_zextend(pd.cscache, pd.ncscache, index + 1 - pd.ncscache, sizeof(Id), 255);
- pd.ncscache = index + 1;
- }
- pd.cscache[index] = di.solvid;
- }
- dataiterator_free(&di);
+ pd.cshash_filled = 1;
+ fill_cshash_from_repo(&pd);
}
parser = XML_ParserCreate(NULL);
solv_free(pd.content);
solv_free(pd.lastdirstr);
join_freemem(&pd.jd);
- stringpool_free(&pd.cspool);
- solv_free(pd.cscache);
+ free_cshash(&pd);
repodata_free_dircache(data);
if (!(flags & REPO_NO_INTERNALIZE))
projects / platform / upstream / libsolv.git / blobdiff