static void
endElement(struct solv_xmlparser *xmlp, int state, char *content)
{
struct parsedata *pd = xmlp->userdata;
Solvable *s = pd->solvable;
switch (state)
{
case STATE_PRODUCT:
if (!s->arch)
s->arch = ARCH_NOARCH;
if (!s->evr)
s->evr = ID_EMPTY;
if (s->name && s->arch != ARCH_SRC && s->arch != ARCH_NOSRC)
s->provides = repo_addid_dep(pd->repo, s->provides, pool_rel2id(pd->pool, s->name, s->evr, REL_EQ, 1), 0);
pd->solvable = 0;
break;
case STATE_NAME:
s->name = pool_str2id(pd->pool, join2(&pd->jd, "product", ":", content), 1);
break;
case STATE_ARCH:
s->arch = pool_str2id(pd->pool, content, 1);
break;
case STATE_SUMMARY:
repodata_set_str(pd->data, pd->handle, pool_id2langid(pd->pool, SOLVABLE_SUMMARY, pd->tmplang, 1), content);
break;
case STATE_VENDOR:
s->vendor = pool_str2id(pd->pool, content, 1);
break;
case STATE_INSTALLTIME:
repodata_set_num(pd->data, pd->handle, SOLVABLE_INSTALLTIME, atol(content));
default:
break;
}
}
static void XMLCALL
endElement(void *userData, const char *name)
{
struct parsedata *pd = userData;
Solvable *s = pd->solvable;
#if 0
fprintf(stderr, "end: [%d]%s\n", pd->state, name);
#endif
if (pd->depth != pd->statedepth)
{
pd->depth--;
#if 0
fprintf(stderr, "back from unknown %d %d %d\n", pd->state, pd->depth, pd->statedepth);
#endif
return;
}
pd->depth--;
pd->statedepth--;
switch (pd->state)
{
case STATE_PRODUCT:
if (!s->arch)
s->arch = ARCH_NOARCH;
if (!s->evr)
s->evr = ID_EMPTY;
if (s->name && s->arch != ARCH_SRC && s->arch != ARCH_NOSRC)
s->provides = repo_addid_dep(pd->repo, s->provides, pool_rel2id(pd->pool, s->name, s->evr, REL_EQ, 1), 0);
pd->solvable = 0;
break;
case STATE_NAME:
s->name = pool_str2id(pd->pool, join2("product", ":", pd->content), 1);
break;
case STATE_ARCH:
s->arch = pool_str2id(pd->pool, pd->content, 1);
break;
case STATE_SUMMARY:
repodata_set_str(pd->data, pd->handle, langtag(pd, SOLVABLE_SUMMARY, pd->tmplang), pd->content);
pd->tmplang = solv_free((void *)pd->tmplang);
break;
case STATE_VENDOR:
s->vendor = pool_str2id(pd->pool, pd->content, 1);
break;
case STATE_INSTALLTIME:
repodata_set_num(pd->data, pd->handle, SOLVABLE_INSTALLTIME, atol(pd->content));
default:
break;
}
pd->state = pd->sbtab[pd->state];
pd->docontent = 0;
#if 0
fprintf(stderr, "end: [%s] -> %d\n", name, pd->state);
#endif
}
void
repo_set_num(Repo *repo, Id p, Id keyname, unsigned int num)
{
Repodata *data;
if (p >= 0)
{
if (keyname == RPM_RPMDBID)
{
if (!repo->rpmdbid)
repo->rpmdbid = repo_sidedata_create(repo, sizeof(Id));
repo->rpmdbid[p] = num;
return;
}
}
data = repo_last_repodata(repo);
repodata_set_num(data, p, keyname, num);
}
static void XMLCALL
endElement(void *userData, const char *name)
{
struct parsedata *pd = userData;
Pool *pool = pd->pool;
Solvable *s = pd->solvable;
Repo *repo = pd->repo;
#if 0
fprintf(stderr, "end: %s\n", name);
#endif
if (pd->depth != pd->statedepth)
{
pd->depth--;
#if 0
fprintf(stderr, "back from unknown %d %d %d\n", pd->state, pd->depth, pd->statedepth);
#endif
return;
}
pd->depth--;
pd->statedepth--;
switch (pd->state)
{
case STATE_START:
break;
case STATE_UPDATES:
break;
case STATE_UPDATE:
s->provides = repo_addid_dep(repo, s->provides, pool_rel2id(pool, s->name, s->evr, REL_EQ, 1), 0);
if (pd->buildtime)
{
repodata_set_num(pd->data, pd->datanum, SOLVABLE_BUILDTIME, pd->buildtime);
pd->buildtime = (time_t)0;
}
break;
case STATE_ID:
s->name = pool_str2id(pool, join2(&pd->jd, "patch", ":", pd->content), 1);
break;
/* <title>imlib-1.9.15-6.fc8</title> */
case STATE_TITLE:
while (pd->lcontent > 0 && pd->content[pd->lcontent - 1] == '\n')
pd->content[--pd->lcontent] = 0;
repodata_set_str(pd->data, pd->datanum, SOLVABLE_SUMMARY, pd->content);
break;
case STATE_SEVERITY:
repodata_set_poolstr(pd->data, pd->datanum, UPDATE_SEVERITY, pd->content);
break;
case STATE_RIGHTS:
repodata_set_poolstr(pd->data, pd->datanum, UPDATE_RIGHTS, pd->content);
break;
/*
* <release>Fedora 8</release>
*/
case STATE_RELEASE:
break;
case STATE_ISSUED:
break;
case STATE_REFERENCES:
break;
case STATE_REFERENCE:
break;
/*
* <description>This update ...</description>
*/
case STATE_DESCRIPTION:
repodata_set_str(pd->data, pd->datanum, SOLVABLE_DESCRIPTION, pd->content);
break;
/*
* <message>Warning! ...</message>
*/
case STATE_MESSAGE:
repodata_set_str(pd->data, pd->datanum, UPDATE_MESSAGE, pd->content);
break;
case STATE_PKGLIST:
break;
case STATE_COLLECTION:
break;
case STATE_NAME:
break;
case STATE_PACKAGE:
repodata_add_flexarray(pd->data, pd->datanum, UPDATE_COLLECTION, pd->collhandle);
pd->collhandle = 0;
break;
/* <filename>libntlm-0.4.2-1.fc8.x86_64.rpm</filename> */
/* <filename>libntlm-0.4.2-1.fc8.x86_64.rpm</filename> */
case STATE_FILENAME:
repodata_set_str(pd->data, pd->collhandle, UPDATE_COLLECTION_FILENAME, pd->content);
break;
/* <reboot_suggested>True</reboot_suggested> */
case STATE_REBOOT:
if (pd->content[0] == 'T' || pd->content[0] == 't'|| pd->content[0] == '1')
{
/* FIXME: this is per-package, the global flag should be computed at runtime */
repodata_set_void(pd->data, pd->datanum, UPDATE_REBOOT);
repodata_set_void(pd->data, pd->collhandle, UPDATE_REBOOT);
}
break;
/* <restart_suggested>True</restart_suggested> */
case STATE_RESTART:
if (pd->content[0] == 'T' || pd->content[0] == 't'|| pd->content[0] == '1')
{
/* FIXME: this is per-package, the global flag should be computed at runtime */
repodata_set_void(pd->data, pd->datanum, UPDATE_RESTART);
repodata_set_void(pd->data, pd->collhandle, UPDATE_RESTART);
}
break;
/* <relogin_suggested>True</relogin_suggested> */
case STATE_RELOGIN:
if (pd->content[0] == 'T' || pd->content[0] == 't'|| pd->content[0] == '1')
{
/* FIXME: this is per-package, the global flag should be computed at runtime */
repodata_set_void(pd->data, pd->datanum, UPDATE_RELOGIN);
repodata_set_void(pd->data, pd->collhandle, UPDATE_RELOGIN);
}
break;
default:
break;
}
pd->state = pd->sbtab[pd->state];
pd->docontent = 0;
}
static void XMLCALL
startElement(void *userData, const char *name, const char **atts)
{
//fprintf(stderr,"+tag: %s\n", name);
struct parsedata *pd = userData;
Pool *pool = pd->common.pool;
Solvable *s = pd->solvable;
struct stateswitch *sw;
const char *str;
Id handle = pd->handle;
// fprintf(stderr, "into %s, from %d, depth %d, statedepth %d\n", name, pd->state, pd->depth, pd->statedepth);
if (pd->depth != pd->statedepth)
{
pd->depth++;
return;
}
if (pd->state == STATE_START && !strcmp(name, "patterns"))
return;
if (pd->state == STATE_START && !strcmp(name, "products"))
return;
//if (pd->state == STATE_START && !strcmp(name, "metadata"))
// return;
if (pd->state == STATE_SOLVABLE && !strcmp(name, "format"))
return;
pd->depth++;
if (!pd->swtab[pd->state])
return;
for (sw = pd->swtab[pd->state]; sw->from == pd->state; sw++)
if (!strcmp(sw->ename, name))
break;
if (sw->from != pd->state)
{
#if 0
fprintf(stderr, "into unknown: %s\n", name);
#endif
return;
}
pd->state = sw->to;
pd->docontent = sw->docontent;
pd->statedepth = pd->depth;
pd->lcontent = 0;
*pd->content = 0;
switch(pd->state)
{
case STATE_SOLVABLE:
pd->kind = 0;
if (name[2] == 't' && name[3] == 't')
pd->kind = "pattern";
else if (name[1] == 'r')
pd->kind = "product";
else if (name[2] == 't' && name[3] == 'c')
pd->kind = "patch";
/* to support extension metadata files like others.xml which
have the following structure:
<otherdata xmlns="http://linux.duke.edu/metadata/other"
packages="101">
<package pkgid="b78f8664cd90efe42e09a345e272997ef1b53c18"
name="zaptel-kmp-default"
arch="i586"><version epoch="0"
ver="1.2.10_2.6.22_rc4_git6_2" rel="70"/>
...
we need to check if the pkgid is there and if it matches
an already seen package, that means we don't need to create
a new solvable but just append the attributes to the existing
one.
*/
const char *pkgid;
if ((pkgid = find_attr("pkgid", atts)) != NULL)
{
// look at the checksum cache
Id index = stringpool_str2id(&pd->cspool, pkgid, 0);
if (!index || index >= pd->ncscache || !pd->cscache[index])
{
fprintf(stderr, "error, the repository specifies extra information about package with checksum '%s', which does not exist in the repository.\n", pkgid);
exit(1);
}
pd->solvable = pool_id2solvable(pool, pd->cscache[index]);
}
else
{
/* this is a new package */
pd->solvable = pool_id2solvable(pool, repo_add_solvable(pd->common.repo));
pd->freshens = 0;
}
pd->handle = pd->solvable - pool->solvables;
#if 0
fprintf(stderr, "package #%d\n", pd->solvable - pool->solvables);
#endif
break;
case STATE_VERSION:
s->evr = makeevr_atts(pool, pd, atts);
break;
case STATE_PROVIDES:
s->provides = 0;
break;
case STATE_PROVIDESENTRY:
s->provides = adddep(pool, pd, s->provides, atts, 0);
break;
case STATE_REQUIRES:
s->requires = 0;
break;
case STATE_REQUIRESENTRY:
s->requires = adddep(pool, pd, s->requires, atts, 1);
break;
case STATE_OBSOLETES:
s->obsoletes = 0;
break;
case STATE_OBSOLETESENTRY:
s->obsoletes = adddep(pool, pd, s->obsoletes, atts, 0);
break;
case STATE_CONFLICTS:
s->conflicts = 0;
break;
case STATE_CONFLICTSENTRY:
s->conflicts = adddep(pool, pd, s->conflicts, atts, 0);
break;
case STATE_RECOMMENDS:
s->recommends = 0;
break;
case STATE_RECOMMENDSENTRY:
s->recommends = adddep(pool, pd, s->recommends, atts, 0);
break;
case STATE_SUPPLEMENTS:
s->supplements= 0;
break;
case STATE_SUPPLEMENTSENTRY:
s->supplements = adddep(pool, pd, s->supplements, atts, 0);
break;
case STATE_SUGGESTS:
s->suggests = 0;
break;
case STATE_SUGGESTSENTRY:
s->suggests = adddep(pool, pd, s->suggests, atts, 0);
break;
case STATE_ENHANCES:
s->enhances = 0;
break;
case STATE_ENHANCESENTRY:
s->enhances = adddep(pool, pd, s->enhances, atts, 0);
break;
case STATE_FRESHENS:
pd->freshens = 0;
break;
case STATE_FRESHENSENTRY:
pd->freshens = adddep(pool, pd, pd->freshens, atts, 0);
break;
case STATE_EULA:
case STATE_SUMMARY:
case STATE_CATEGORY:
case STATE_DESCRIPTION:
pd->tmplang = find_attr("lang", atts);
break;
case STATE_USERVISIBLE:
repodata_set_void(pd->data, handle, SOLVABLE_ISVISIBLE );
break;
case STATE_INCLUDESENTRY:
{
const char *tmp = find_attr("pattern", atts);
if (tmp)
repodata_add_poolstr_array(pd->data, pd->handle, SOLVABLE_INCLUDES, join2("pattern", ":", tmp));
}
break;
case STATE_EXTENDSENTRY:
{
const char *tmp = find_attr("pattern", atts);
if (tmp)
repodata_add_poolstr_array(pd->data, pd->handle, SOLVABLE_EXTENDS, join2("pattern", ":", tmp));
}
break;
case STATE_LOCATION:
str = find_attr("href", atts);
if (str)
repodata_set_location(pd->data, handle, 0, 0, str);
break;
case STATE_CHECKSUM:
pd->tmpattr = find_attr("type", atts);
break;
case STATE_TIME:
{
unsigned int t;
str = find_attr("build", atts);
if (str && (t = atoi(str)) != 0)
repodata_set_num(pd->data, handle, SOLVABLE_BUILDTIME, t);
break;
}
case STATE_SIZE:
{
unsigned int k;
str = find_attr("installed", atts);
if (str && (k = atoi(str)) != 0)
repodata_set_num(pd->data, handle, SOLVABLE_INSTALLSIZE, (k + 1023) / 1024);
/* XXX the "package" attribute gives the size of the rpm file,
i.e. the download size. Except on packman, there it seems to be
something else entirely, it has a value near to the other two
values, as if the rpm is uncompressed. */
str = find_attr("package", atts);
if (str && (k = atoi(str)) != 0)
repodata_set_num(pd->data, handle, SOLVABLE_DOWNLOADSIZE, (k + 1023) / 1024);
break;
}
case STATE_HEADERRANGE:
{
unsigned int end;
str = find_attr("end", atts);
if (str && (end = atoi(str)) != 0)
repodata_set_num(pd->data, handle, SOLVABLE_HEADEREND, end);
}
/*
<diskusage>
<dirs>
<dir name="/" size="56" count="11"/>
<dir name="usr/" size="56" count="11"/>
<dir name="usr/bin/" size="38" count="10"/>
<dir name="usr/share/" size="18" count="1"/>
<dir name="usr/share/doc/" size="18" count="1"/>
</dirs>
</diskusage>
*/
case STATE_DISKUSAGE:
{
/* Really, do nothing, wat for <dir> tag */
break;
}
case STATE_DIR:
{
long filesz = 0, filenum = 0;
unsigned dirid;
if ((str = find_attr("name", atts)) != 0)
dirid = repodata_str2dir(pd->data, str, 1);
else
{
fprintf( stderr, "<dir .../> tag without 'name' attribute, atts = %p, *atts = %p\n",
(void *)atts, *atts);
break;
}
if ((str = find_attr("size", atts)) != 0)
filesz = strtol(str, 0, 0);
if ((str = find_attr("count", atts)) != 0)
filenum = strtol(str, 0, 0);
pd->dirs = sat_extend(pd->dirs, pd->ndirs, 1, sizeof(pd->dirs[0]), 31);
pd->dirs[pd->ndirs][0] = dirid;
pd->dirs[pd->ndirs][1] = filesz;
pd->dirs[pd->ndirs][2] = filenum;
pd->ndirs++;
break;
}
default:
break;
}
}
Id
repo_add_deb(Repo *repo, const char *deb, int flags)
{
Pool *pool = repo->pool;
Repodata *data;
unsigned char buf[4096], *bp;
int l, l2, vlen, clen, ctarlen;
unsigned char *ctgz;
unsigned char pkgid[16];
unsigned char *ctar;
int gotpkgid;
FILE *fp;
Solvable *s;
struct stat stb;
data = repo_add_repodata(repo, flags);
if ((fp = fopen(flags & REPO_USE_ROOTDIR ? pool_prepend_rootdir_tmp(pool, deb) : deb, "r")) == 0)
{
pool_error(pool, -1, "%s: %s", deb, strerror(errno));
return 0;
}
if (fstat(fileno(fp), &stb))
{
pool_error(pool, -1, "fstat: %s", strerror(errno));
fclose(fp);
return 0;
}
l = fread(buf, 1, sizeof(buf), fp);
if (l < 8 + 60 || strncmp((char *)buf, "!<arch>\ndebian-binary ", 8 + 16) != 0)
{
pool_error(pool, -1, "%s: not a deb package", deb);
fclose(fp);
return 0;
}
vlen = atoi((char *)buf + 8 + 48);
if (vlen < 0 || vlen > l)
{
pool_error(pool, -1, "%s: not a deb package", deb);
fclose(fp);
return 0;
}
vlen += vlen & 1;
if (l < 8 + 60 + vlen + 60)
{
pool_error(pool, -1, "%s: unhandled deb package", deb);
fclose(fp);
return 0;
}
if (strncmp((char *)buf + 8 + 60 + vlen, "control.tar.gz ", 16) != 0)
{
pool_error(pool, -1, "%s: control.tar.gz is not second entry", deb);
fclose(fp);
return 0;
}
clen = atoi((char *)buf + 8 + 60 + vlen + 48);
if (clen <= 0 || clen >= 0x100000)
{
pool_error(pool, -1, "%s: control.tar.gz has illegal size", deb);
fclose(fp);
return 0;
}
ctgz = solv_calloc(1, clen + 4);
bp = buf + 8 + 60 + vlen + 60;
l -= 8 + 60 + vlen + 60;
if (l > clen)
l = clen;
if (l)
memcpy(ctgz, bp, l);
if (l < clen)
{
if (fread(ctgz + l, clen - l, 1, fp) != 1)
{
pool_error(pool, -1, "%s: unexpected EOF", deb);
solv_free(ctgz);
fclose(fp);
return 0;
}
}
fclose(fp);
gotpkgid = 0;
if (flags & DEBS_ADD_WITH_PKGID)
{
Chksum *chk = solv_chksum_create(REPOKEY_TYPE_MD5);
solv_chksum_add(chk, ctgz, clen);
solv_chksum_free(chk, pkgid);
gotpkgid = 1;
}
if (ctgz[0] != 0x1f || ctgz[1] != 0x8b)
{
pool_error(pool, -1, "%s: control.tar.gz is not gzipped", deb);
solv_free(ctgz);
return 0;
}
if (ctgz[2] != 8 || (ctgz[3] & 0xe0) != 0)
{
pool_error(pool, -1, "%s: control.tar.gz is compressed in a strange way", deb);
solv_free(ctgz);
return 0;
}
bp = ctgz + 4;
bp += 6; /* skip time, xflags and OS code */
if (ctgz[3] & 0x04)
{
/* skip extra field */
l = bp[0] | bp[1] << 8;
bp += l + 2;
if (bp >= ctgz + clen)
{
pool_error(pool, -1, "%s: control.tar.gz is corrupt", deb);
solv_free(ctgz);
return 0;
}
}
if (ctgz[3] & 0x08) /* orig filename */
while (*bp)
bp++;
if (ctgz[3] & 0x10) /* file comment */
while (*bp)
bp++;
if (ctgz[3] & 0x02) /* header crc */
bp += 2;
if (bp >= ctgz + clen)
{
pool_error(pool, -1, "%s: control.tar.gz is corrupt", deb);
solv_free(ctgz);
return 0;
}
ctar = decompress(bp, ctgz + clen - bp, &ctarlen);
solv_free(ctgz);
if (!ctar)
{
pool_error(pool, -1, "%s: control.tar.gz is corrupt", deb);
return 0;
}
bp = ctar;
l = ctarlen;
while (l > 512)
{
int j;
l2 = 0;
for (j = 124; j < 124 + 12; j++)
if (bp[j] >= '0' && bp[j] <= '7')
l2 = l2 * 8 + (bp[j] - '0');
if (!strcmp((char *)bp, "./control") || !strcmp((char *)bp, "control"))
break;
l2 = 512 + ((l2 + 511) & ~511);
l -= l2;
bp += l2;
}
if (l <= 512 || l - 512 - l2 <= 0 || l2 <= 0)
{
pool_error(pool, -1, "%s: control.tar.gz contains no control file", deb);
free(ctar);
return 0;
}
memmove(ctar, bp + 512, l2);
ctar = solv_realloc(ctar, l2 + 1);
ctar[l2] = 0;
s = pool_id2solvable(pool, repo_add_solvable(repo));
control2solvable(s, data, (char *)ctar);
if (!(flags & REPO_NO_LOCATION))
repodata_set_location(data, s - pool->solvables, 0, 0, deb);
if (S_ISREG(stb.st_mode))
repodata_set_num(data, s - pool->solvables, SOLVABLE_DOWNLOADSIZE, (unsigned long long)stb.st_size);
if (gotpkgid)
repodata_set_bin_checksum(data, s - pool->solvables, SOLVABLE_PKGID, REPOKEY_TYPE_MD5, pkgid);
solv_free(ctar);
if (!(flags & REPO_NO_INTERNALIZE))
repodata_internalize(data);
return s - pool->solvables;
}
/* warning: does inplace changes */
static void
control2solvable(Solvable *s, Repodata *data, char *control)
{
Repo *repo = s->repo;
Pool *pool = repo->pool;
char *p, *q, *end, *tag;
int x, l;
int havesource = 0;
char checksum[32 * 2 + 1];
Id checksumtype = 0;
Id newtype;
p = control;
while (*p)
{
p = strchr(p, '\n');
if (!p)
break;
if (p[1] == ' ' || p[1] == '\t')
{
char *q;
/* continuation line */
q = p - 1;
while (q >= control && *q == ' ' && *q == '\t')
q--;
l = q + 1 - control;
if (l)
memmove(p + 1 - l, control, l);
control = p + 1 - l;
p[1] = '\n';
p += 2;
continue;
}
end = p - 1;
if (*p)
*p++ = 0;
/* strip trailing space */
while (end >= control && (*end == ' ' || *end == '\t'))
*end-- = 0;
tag = control;
control = p;
q = strchr(tag, ':');
if (!q || q - tag < 4)
continue;
*q++ = 0;
while (*q == ' ' || *q == '\t')
q++;
x = '@' + (tag[0] & 0x1f);
x = (x << 8) + '@' + (tag[1] & 0x1f);
switch(x)
{
case 'A' << 8 | 'R':
if (!strcasecmp(tag, "architecture"))
s->arch = pool_str2id(pool, q, 1);
break;
case 'B' << 8 | 'R':
if (!strcasecmp(tag, "breaks"))
s->conflicts = makedeps(repo, q, s->conflicts, 0);
break;
case 'C' << 8 | 'O':
if (!strcasecmp(tag, "conflicts"))
s->conflicts = makedeps(repo, q, s->conflicts, 0);
break;
case 'D' << 8 | 'E':
if (!strcasecmp(tag, "depends"))
s->requires = makedeps(repo, q, s->requires, -SOLVABLE_PREREQMARKER);
else if (!strcasecmp(tag, "description"))
{
char *ld = strchr(q, '\n');
if (ld)
{
*ld++ = 0;
repodata_set_str(data, s - pool->solvables, SOLVABLE_DESCRIPTION, ld);
}
else
repodata_set_str(data, s - pool->solvables, SOLVABLE_DESCRIPTION, q);
repodata_set_str(data, s - pool->solvables, SOLVABLE_SUMMARY, q);
}
break;
case 'E' << 8 | 'N':
if (!strcasecmp(tag, "enhances"))
s->enhances = makedeps(repo, q, s->enhances, 0);
break;
case 'F' << 8 | 'I':
if (!strcasecmp(tag, "filename"))
repodata_set_location(data, s - pool->solvables, 0, 0, q);
break;
case 'H' << 8 | 'O':
if (!strcasecmp(tag, "homepage"))
repodata_set_str(data, s - pool->solvables, SOLVABLE_URL, q);
break;
case 'I' << 8 | 'N':
if (!strcasecmp(tag, "installed-size"))
repodata_set_num(data, s - pool->solvables, SOLVABLE_INSTALLSIZE, strtoull(q, 0, 10) << 10);
break;
case 'M' << 8 | 'D':
if (!strcasecmp(tag, "md5sum") && !checksumtype && strlen(q) == 16 * 2)
{
strcpy(checksum, q);
checksumtype = REPOKEY_TYPE_MD5;
}
break;
case 'P' << 8 | 'A':
if (!strcasecmp(tag, "package"))
s->name = pool_str2id(pool, q, 1);
break;
case 'P' << 8 | 'R':
if (!strcasecmp(tag, "pre-depends"))
s->requires = makedeps(repo, q, s->requires, SOLVABLE_PREREQMARKER);
else if (!strcasecmp(tag, "provides"))
s->provides = makedeps(repo, q, s->provides, 0);
break;
case 'R' << 8 | 'E':
if (!strcasecmp(tag, "replaces"))
s->obsoletes = makedeps(repo, q, s->obsoletes, 0);
else if (!strcasecmp(tag, "recommends"))
s->recommends = makedeps(repo, q, s->recommends, 0);
break;
case 'S' << 8 | 'H':
newtype = solv_chksum_str2type(tag);
if (!newtype || solv_chksum_len(newtype) * 2 != strlen(q))
break;
if (!checksumtype || (newtype == REPOKEY_TYPE_SHA1 && checksumtype != REPOKEY_TYPE_SHA256) || newtype == REPOKEY_TYPE_SHA256)
{
strcpy(checksum, q);
checksumtype = newtype;
}
break;
case 'S' << 8 | 'O':
if (!strcasecmp(tag, "source"))
{
char *q2;
/* ignore version for now */
for (q2 = q; *q2; q2++)
if (*q2 == ' ' || *q2 == '\t')
{
*q2 = 0;
break;
}
if (s->name && !strcmp(q, pool_id2str(pool, s->name)))
repodata_set_void(data, s - pool->solvables, SOLVABLE_SOURCENAME);
else
repodata_set_id(data, s - pool->solvables, SOLVABLE_SOURCENAME, pool_str2id(pool, q, 1));
havesource = 1;
}
break;
case 'S' << 8 | 'T':
if (!strcasecmp(tag, "status"))
repodata_set_poolstr(data, s - pool->solvables, SOLVABLE_INSTALLSTATUS, q);
break;
case 'S' << 8 | 'U':
if (!strcasecmp(tag, "suggests"))
s->suggests = makedeps(repo, q, s->suggests, 0);
break;
case 'V' << 8 | 'E':
if (!strcasecmp(tag, "version"))
s->evr = pool_str2id(pool, q, 1);
break;
}
}
if (checksumtype)
repodata_set_checksum(data, s - pool->solvables, SOLVABLE_CHECKSUM, checksumtype, checksum);
if (!s->arch)
s->arch = ARCH_ALL;
if (!s->evr)
s->evr = ID_EMPTY;
if (s->name)
s->provides = repo_addid_dep(repo, s->provides, pool_rel2id(pool, s->name, s->evr, REL_EQ, 1), 0);
if (s->name && !havesource)
repodata_set_void(data, s - pool->solvables, SOLVABLE_SOURCENAME);
if (s->obsoletes)
{
/* obsoletes only count when the packages also conflict */
/* XXX: should not transcode here */
int i, j, k;
Id d, cid;
for (i = j = s->obsoletes; (d = repo->idarraydata[i]) != 0; i++)
{
if (!s->conflicts)
continue;
for (k = s->conflicts; (cid = repo->idarraydata[k]) != 0; k++)
{
if (repo->idarraydata[k] == cid)
break;
if (ISRELDEP(cid))
{
Reldep *rd = GETRELDEP(pool, cid);
if (rd->flags < 8 && rd->name == d)
break; /* specialize obsoletes */
}
}
if (cid)
repo->idarraydata[j++] = cid;
}
repo->idarraydata[j] = 0;
if (j == s->obsoletes)
s->obsoletes = 0;
}
}
int
repo_add_autopattern(Repo *repo, int flags)
{
Pool *pool = repo->pool;
Repodata *data = 0;
Solvable *s, *s2;
Queue q, q2;
Id p;
Id pattern_id;
Id autopattern_id = 0;
int i, j;
queue_init(&q);
queue_init(&q2);
pattern_id = pool_str2id(pool, "pattern()", 9);
FOR_REPO_SOLVABLES(repo, p, s)
{
const char *n = pool_id2str(pool, s->name);
if (!strncmp("pattern:", n, 8))
queue_push(&q, p);
else if (s->provides)
{
Id prv, *prvp = repo->idarraydata + s->provides;
while ((prv = *prvp++) != 0) /* go through all provides */
if (ISRELDEP(prv))
{
Reldep *rd = GETRELDEP(pool, prv);
if (rd->name == pattern_id && rd->flags == REL_EQ)
{
queue_push2(&q2, p, rd->evr);
break;
}
}
}
}
for (i = 0; i < q2.count; i += 2)
{
const char *pn = 0;
char *newname;
Id name, prv, *prvp;
const char *str;
unsigned long long num;
s = pool->solvables + q2.elements[i];
/* construct new name */
newname = pool_tmpjoin(pool, "pattern:", pool_id2str(pool, q2.elements[i + 1]), 0);
unescape(newname);
name = pool_str2id(pool, newname, 0);
if (name)
{
/* check if we already have that pattern */
for (j = 0; j < q.count; j++)
{
s2 = pool->solvables + q.elements[j];
if (s2->name == name && s2->arch == s->arch && s2->evr == s->evr)
break;
}
if (j < q.count)
continue; /* yes, do not add again */
}
/* new pattern */
if (!name)
name = pool_str2id(pool, newname, 1);
if (!data)
{
repo_internalize(repo); /* to make that the lookups work */
data = repo_add_repodata(repo, flags);
}
s2 = pool_id2solvable(pool, repo_add_solvable(repo));
s = pool->solvables + q2.elements[i]; /* re-calc pointer */
s2->name = name;
s2->arch = s->arch;
s2->evr = s->evr;
s2->vendor = s->vendor;
/* add link requires */
s2->requires = repo_addid_dep(repo, s2->requires, pool_rel2id(pool, s->name, s->evr, REL_EQ, 1) , 0);
/* add autopattern provides */
if (!autopattern_id)
autopattern_id = pool_str2id(pool, "autopattern()", 1);
s2->provides = repo_addid_dep(repo, s2->provides, pool_rel2id(pool, autopattern_id, s->name, REL_EQ, 1), 0);
/* add self provides */
s2->provides = repo_addid_dep(repo, s2->provides, pool_rel2id(pool, s2->name, s2->evr, REL_EQ, 1), 0);
if ((num = solvable_lookup_num(s, SOLVABLE_INSTALLTIME, 0)) != 0)
repodata_set_num(data, s2 - pool->solvables, SOLVABLE_INSTALLTIME, num);
if ((num = solvable_lookup_num(s, SOLVABLE_BUILDTIME, 0)) != 0)
repodata_set_num(data, s2 - pool->solvables, SOLVABLE_BUILDTIME, num);
if ((str = solvable_lookup_str(s, SOLVABLE_SUMMARY)) != 0)
repodata_set_str(data, s2 - pool->solvables, SOLVABLE_SUMMARY, str);
if ((str = solvable_lookup_str(s, SOLVABLE_DESCRIPTION)) != 0)
repodata_set_str(data, s2 - pool->solvables, SOLVABLE_DESCRIPTION, str);
/* fill in stuff from provides */
prvp = repo->idarraydata + s->provides;
while ((prv = *prvp++) != 0) /* go through all provides */
{
Id evr = 0;
if (ISRELDEP(prv))
{
Reldep *rd = GETRELDEP(pool, prv);
if (rd->flags != REL_EQ)
continue;
prv = rd->name;
evr = rd->evr;
}
pn = pool_id2str(pool, prv);
if (strncmp("pattern-", pn, 8) != 0)
continue;
newname = 0;
if (evr)
{
newname = pool_tmpjoin(pool, pool_id2str(pool, evr), 0, 0);
unescape(newname);
}
if (!strncmp(pn, "pattern-category(", 17) && evr)
{
char lang[9];
int l = strlen(pn);
Id langtag;
if (l > 17 + 9 || pn[l - 1] != ')')
continue;
strncpy(lang, pn + 17, l - 17 - 1);
lang[l - 17 - 1] = 0;
langtag = SOLVABLE_CATEGORY;
if (*lang && strcmp(lang, "en") != 0)
langtag = pool_id2langid(pool, SOLVABLE_CATEGORY, lang, 1);
repodata_set_str(data, s2 - pool->solvables, langtag, newname);
}
else if (!strcmp(pn, "pattern-includes()") && evr)
repodata_add_poolstr_array(data, s2 - pool->solvables, SOLVABLE_INCLUDES, pool_tmpjoin(pool, "pattern:", newname, 0));
else if (!strcmp(pn, "pattern-extends()") && evr)
repodata_add_poolstr_array(data, s2 - pool->solvables, SOLVABLE_EXTENDS, pool_tmpjoin(pool, "pattern:", newname, 0));
else if (!strcmp(pn, "pattern-icon()") && evr)
repodata_set_str(data, s2 - pool->solvables, SOLVABLE_ICON, newname);
else if (!strcmp(pn, "pattern-order()") && evr)
repodata_set_str(data, s2 - pool->solvables, SOLVABLE_ORDER, newname);
else if (!strcmp(pn, "pattern-visible()") && !evr)
repodata_set_void(data, s2 - pool->solvables, SOLVABLE_ISVISIBLE);
}
}
queue_free(&q);
queue_free(&q2);
if (data && !(flags & REPO_NO_INTERNALIZE))
repodata_internalize(data);
else if (!data && !(flags & REPO_NO_INTERNALIZE))
repo_internalize(repo);
return 0;
}
int
repo_add_mdk(Repo *repo, FILE *fp, int flags)
{
Pool *pool = repo->pool;
Repodata *data;
Solvable *s;
char *buf;
int bufa, bufl;
data = repo_add_repodata(repo, flags);
bufa = 4096;
buf = solv_malloc(bufa);
bufl = 0;
s = 0;
while (fgets(buf + bufl, bufa - bufl, fp) > 0)
{
bufl += strlen(buf + bufl);
if (bufl && buf[bufl - 1] != '\n')
{
if (bufa - bufl < 256)
{
bufa += 4096;
buf = solv_realloc(buf, bufa);
}
continue;
}
buf[--bufl] = 0;
bufl = 0;
if (buf[0] != '@')
{
pool_debug(pool, SOLV_ERROR, "bad line <%s>\n", buf);
continue;
}
if (!s)
s = pool_id2solvable(pool, repo_add_solvable(repo));
if (!strncmp(buf + 1, "filesize@", 9))
repodata_set_num(data, s - pool->solvables, SOLVABLE_DOWNLOADSIZE, strtoull(buf + 10, 0, 10));
else if (!strncmp(buf + 1, "summary@", 8))
repodata_set_str(data, s - pool->solvables, SOLVABLE_SUMMARY, buf + 9);
else if (!strncmp(buf + 1, "provides@", 9))
s->provides = parse_deps(s, buf + 10, 0);
else if (!strncmp(buf + 1, "requires@", 9))
s->requires = parse_deps(s, buf + 10, SOLVABLE_PREREQMARKER);
else if (!strncmp(buf + 1, "suggests@", 9))
s->suggests = parse_deps(s, buf + 10, 0);
else if (!strncmp(buf + 1, "obsoletes@", 10))
s->obsoletes = parse_deps(s, buf + 11, 0);
else if (!strncmp(buf + 1, "conflicts@", 10))
s->conflicts = parse_deps(s, buf + 11, 0);
else if (!strncmp(buf + 1, "info@", 5))
{
char *nvra = buf + 6;
char *epochstr;
char *arch;
char *version;
char *filename;
if ((epochstr = strchr(nvra, '@')) != 0)
{
char *sizestr;
*epochstr++ = 0;
if ((sizestr = strchr(epochstr, '@')) != 0)
{
char *groupstr;
*sizestr++ = 0;
if ((groupstr = strchr(sizestr, '@')) != 0)
{
char *n;
*groupstr++ = 0;
if ((n = strchr(groupstr, '@')) != 0)
*n = 0;
if (*groupstr)
repodata_set_poolstr(data, s - pool->solvables, SOLVABLE_GROUP, groupstr);
}
repodata_set_num(data, s - pool->solvables, SOLVABLE_INSTALLSIZE, strtoull(sizestr, 0, 10));
}
}
filename = pool_tmpjoin(pool, nvra, ".rpm", 0);
arch = strrchr(nvra, '.');
if (arch)
{
*arch++ = 0;
s->arch = pool_str2id(pool, arch, 1);
}
/* argh, do we have a distepoch or not, check self-provides */
if (s->provides)
{
Id id, lastid, *idp = s->repo->idarraydata + s->provides;
lastid = 0;
for (idp = s->repo->idarraydata + s->provides; (id = *idp) != 0; idp++)
{
const char *evr, *name;
int namel;
Reldep *rd;
if (!ISRELDEP(id))
continue;
rd = GETRELDEP(pool, id);
if (rd->flags != REL_EQ)
continue;
name = pool_id2str(pool, rd->name);
namel = strlen(name);
if (strncmp(name, nvra, namel) != 0 || nvra[namel] != '-')
continue;
evr = pool_id2str(pool, rd->evr);
evr = strrchr(evr, '-');
if (evr && strchr(evr, ':') != 0)
lastid = id;
}
if (lastid)
{
/* self provides found, and it contains a distepoch */
/* replace with self-provides distepoch to get rid of the disttag */
char *nvradistepoch = strrchr(nvra, '-');
if (nvradistepoch)
{
Reldep *rd = GETRELDEP(pool, lastid);
const char *evr = pool_id2str(pool, rd->evr);
evr = strrchr(evr, '-');
if (evr && (evr = strchr(evr, ':')) != 0)
{
if (strlen(evr) < strlen(nvradistepoch))
strcpy(nvradistepoch, evr);
}
}
}
}
version = strrchr(nvra, '-');
if (version)
{
char *release = version;
*release = 0;
version = strrchr(nvra, '-');
*release = '-';
if (!version)
version = release;
*version++ = 0;
}
else
version = "";
s->name = pool_str2id(pool, nvra, 1);
if (epochstr && *epochstr && strcmp(epochstr, "0") != 0)
{
char *evr = pool_tmpjoin(pool, epochstr, ":", version);
s->evr = pool_str2id(pool, evr, 1);
}
else
s->evr = pool_str2id(pool, version, 1);
repodata_set_location(data, s - pool->solvables, 0, 0, filename);
if (s->name && s->arch != ARCH_SRC && s->arch != ARCH_NOSRC)
s->provides = repo_addid_dep(s->repo, s->provides, pool_rel2id(pool, s->name, s->evr, REL_EQ, 1), 0);
s = 0;
}
else
{
char *tagend = strchr(buf + 1, '@');
if (tagend)
*tagend = 0;
pool_debug(pool, SOLV_ERROR, "unknown tag <%s>\n", buf + 1);
continue;
}
}
if (s)
{
pool_debug(pool, SOLV_ERROR, "unclosed package at EOF\n");
repo_free_solvable(s->repo, s - pool->solvables, 1);
}
solv_free(buf);
if (!(flags & REPO_NO_INTERNALIZE))
repodata_internalize(data);
return 0;
}
static void XMLCALL
endElement(void *userData, const char *name)
{
Parsedata *pd = (Parsedata *)userData;
Pool *pool = pd->pool;
Solvable *s = pd->solvable;
Id evr;
unsigned int t = 0;
const char *flavor;
if (pd->depth != pd->statedepth)
{
pd->depth--;
/* printf("back from unknown %d %d %d\n", pd->state, pd->depth, pd->statedepth); */
return;
}
/* ignore deps element */
if (pd->state == STATE_PACKAGE && !strcmp(name, "deps"))
return;
pd->depth--;
pd->statedepth--;
switch (pd->state)
{
case STATE_PACKAGE: /* package complete */
if (name[0] == 's' && name[1] == 'r' && name[2] == 'c' && s->arch != ARCH_SRC && s->arch != ARCH_NOSRC)
s->arch = ARCH_SRC;
if (!s->arch) /* default to "noarch" */
s->arch = ARCH_NOARCH;
if (!s->evr && pd->version) /* set solvable evr */
s->evr = evr2id(pool, pd,
pd->epoch ? pd->evrspace + pd->epoch : 0,
pd->version ? pd->evrspace + pd->version : 0,
pd->release ? pd->evrspace + pd->release : "");
/* ensure self-provides */
if (s->name && s->arch != ARCH_SRC && s->arch != ARCH_NOSRC)
s->provides = repo_addid_dep(pd->repo, s->provides, pool_rel2id(pool, s->name, s->evr, REL_EQ, 1), 0);
s->supplements = repo_fix_supplements(pd->repo, s->provides, s->supplements, pd->freshens);
s->conflicts = repo_fix_conflicts(pd->repo, s->conflicts);
pd->freshens = 0;
/* see bugzilla bnc#190163 */
flavor = findKernelFlavor(pd, s);
if (flavor)
{
char *cflavor = solv_strdup(flavor); /* make pointer safe */
Id npr;
Id pid;
/* this is either a kernel package or a kmp */
if (s->provides)
{
Offset prov = s->provides;
npr = 0;
while ((pid = pd->repo->idarraydata[prov++]) != 0)
{
const char *depname = 0;
Reldep *prd = 0;
if (ISRELDEP(pid))
{
prd = GETRELDEP(pool, pid);
depname = pool_id2str(pool, prd->name);
}
else
{
depname = pool_id2str(pool, pid);
}
if (!strncmp(depname, "kernel(", 7) && !strchr(depname, ':'))
{
char newdep[100];
snprintf(newdep, sizeof(newdep), "kernel(%s:%s", cflavor, depname + 7);
pid = pool_str2id(pool, newdep, 1);
if (prd)
pid = pool_rel2id(pool, pid, prd->evr, prd->flags, 1);
}
npr = repo_addid_dep(pd->repo, npr, pid, 0);
}
s->provides = npr;
}
#if 1
if (s->requires)
{
Offset reqs = s->requires;
npr = 0;
while ((pid = pd->repo->idarraydata[reqs++]) != 0)
{
const char *depname = 0;
Reldep *prd = 0;
if (ISRELDEP(pid))
{
prd = GETRELDEP(pool, pid);
depname = pool_id2str(pool, prd->name);
}
else
{
depname = pool_id2str(pool, pid);
}
if (!strncmp(depname, "kernel(", 7) && !strchr(depname, ':'))
{
char newdep[100];
snprintf(newdep, sizeof(newdep), "kernel(%s:%s", cflavor, depname + 7);
pid = pool_str2id(pool, newdep, 1);
if (prd)
pid = pool_rel2id(pool, pid, prd->evr, prd->flags, 1);
}
npr = repo_addid_dep(pd->repo, npr, pid, 0);
}
s->requires = npr;
}
#endif
free(cflavor);
}
break;
case STATE_NAME:
s->name = pool_str2id(pool, pd->content, 1);
break;
case STATE_VENDOR:
s->vendor = pool_str2id(pool, pd->content, 1);
break;
case STATE_BUILDTIME:
t = atoi (pd->content);
if (t)
repodata_set_num(pd->data, s - pool->solvables, SOLVABLE_BUILDTIME, t);
break;
case STATE_UPDATE: /* new version, keeping all other metadata */
evr = evr2id(pool, pd,
pd->epoch ? pd->evrspace + pd->epoch : 0,
pd->version ? pd->evrspace + pd->version : 0,
pd->release ? pd->evrspace + pd->release : 0);
pd->levrspace = 1;
pd->epoch = 0;
pd->version = 0;
pd->release = 0;
/* use highest evr */
if (!s->evr || pool_evrcmp(pool, s->evr, evr, EVRCMP_COMPARE) <= 0)
s->evr = evr;
break;
case STATE_EPOCH:
case STATE_VERSION:
case STATE_RELEASE:
case STATE_PEPOCH:
case STATE_PVERSION:
case STATE_PRELEASE:
/* ensure buffer space */
if (pd->lcontent + 1 + pd->levrspace > pd->aevrspace)
{
pd->evrspace = (char *)realloc(pd->evrspace, pd->lcontent + 1 + pd->levrspace + 256);
pd->aevrspace = pd->lcontent + 1 + pd->levrspace + 256;
}
memcpy(pd->evrspace + pd->levrspace, pd->content, pd->lcontent + 1);
if (pd->state == STATE_EPOCH || pd->state == STATE_PEPOCH)
pd->epoch = pd->levrspace;
else if (pd->state == STATE_VERSION || pd->state == STATE_PVERSION)
pd->version = pd->levrspace;
else
pd->release = pd->levrspace;
pd->levrspace += pd->lcontent + 1;
break;
case STATE_ARCH:
case STATE_PARCH:
s->arch = pool_str2id(pool, pd->content, 1);
break;
default:
break;
}
pd->state = pd->sbtab[pd->state];
pd->docontent = 0;
/* printf("back from known %d %d %d\n", pd->state, pd->depth, pd->statedepth); */
}
Id
repo_add_arch_pkg(Repo *repo, const char *fn, int flags)
{
Pool *pool = repo->pool;
Repodata *data;
FILE *fp;
struct tarhead th;
char line[4096];
int ignoreline;
Solvable *s;
int l, fd;
struct stat stb;
void *pkgidhandle = 0;
data = repo_add_repodata(repo, flags);
if ((fd = open(flags & REPO_USE_ROOTDIR ? pool_prepend_rootdir_tmp(pool, fn) : fn, O_RDONLY, 0)) < 0)
{
pool_error(pool, -1, "%s: %s", fn, strerror(errno));
return 0;
}
if (fstat(fd, &stb))
{
pool_error(pool, -1, "%s: fstat: %s", fn, strerror(errno));
close(fd);
return 0;
}
if (!(fp = solv_xfopen_fd(fn, fd, "r")))
{
pool_error(pool, -1, "%s: fdopen failed", fn);
close(fd);
return 0;
}
s = 0;
inittarhead(&th, fp);
while (gettarhead(&th) > 0)
{
if (th.type != 1 || strcmp(th.path, ".PKGINFO") != 0)
{
skipentry(&th);
continue;
}
ignoreline = 0;
s = pool_id2solvable(pool, repo_add_solvable(repo));
if (flags & ARCH_ADD_WITH_PKGID)
pkgidhandle = solv_chksum_create(REPOKEY_TYPE_MD5);
while (getsentry(&th, line, sizeof(line)))
{
l = strlen(line);
if (l == 0)
continue;
if (pkgidhandle)
solv_chksum_add(pkgidhandle, line, l);
if (line[l - 1] != '\n')
{
ignoreline = 1;
continue;
}
if (ignoreline)
{
ignoreline = 0;
continue;
}
line[--l] = 0;
if (l == 0 || line[0] == '#')
continue;
if (!strncmp(line, "pkgname = ", 10))
s->name = pool_str2id(pool, line + 10, 1);
else if (!strncmp(line, "pkgver = ", 9))
s->evr = pool_str2id(pool, line + 9, 1);
else if (!strncmp(line, "pkgdesc = ", 10))
{
repodata_set_str(data, s - pool->solvables, SOLVABLE_SUMMARY, line + 10);
repodata_set_str(data, s - pool->solvables, SOLVABLE_DESCRIPTION, line + 10);
}
else if (!strncmp(line, "url = ", 6))
repodata_set_str(data, s - pool->solvables, SOLVABLE_URL, line + 6);
else if (!strncmp(line, "builddate = ", 12))
repodata_set_num(data, s - pool->solvables, SOLVABLE_BUILDTIME, strtoull(line + 12, 0, 10));
else if (!strncmp(line, "packager = ", 11))
repodata_set_poolstr(data, s - pool->solvables, SOLVABLE_PACKAGER, line + 11);
else if (!strncmp(line, "size = ", 7))
repodata_set_num(data, s - pool->solvables, SOLVABLE_INSTALLSIZE, strtoull(line + 7, 0, 10));
else if (!strncmp(line, "arch = ", 7))
s->arch = pool_str2id(pool, line + 7, 1);
else if (!strncmp(line, "license = ", 10))
repodata_set_poolstr(data, s - pool->solvables, SOLVABLE_LICENSE, line + 10);
else if (!strncmp(line, "replaces = ", 11))
s->obsoletes = adddep(repo, s->obsoletes, line + 11);
else if (!strncmp(line, "group = ", 8))
repodata_set_poolstr(data, s - pool->solvables, SOLVABLE_GROUP, line + 8);
else if (!strncmp(line, "depend = ", 9))
s->requires = adddep(repo, s->requires, line + 9);
else if (!strncmp(line, "optdepend = ", 12))
{
char *p = strchr(line, ':');
if (p)
*p = 0;
s->suggests = adddep(repo, s->suggests, line + 12);
}
else if (!strncmp(line, "conflict = ", 11))
s->conflicts = adddep(repo, s->conflicts, line + 11);
else if (!strncmp(line, "provides = ", 11))
s->provides = adddep(repo, s->provides, line + 11);
}
break;
}
freetarhead(&th);
fclose(fp);
if (!s)
{
pool_error(pool, -1, "%s: not an arch package", fn);
if (pkgidhandle)
solv_chksum_free(pkgidhandle, 0);
return 0;
}
if (s && !s->name)
{
pool_error(pool, -1, "%s: package has no name", fn);
repo_free_solvable(repo, s - pool->solvables, 1);
s = 0;
}
if (s)
{
if (!s->arch)
s->arch = ARCH_ANY;
if (!s->evr)
s->evr = ID_EMPTY;
s->provides = repo_addid_dep(repo, s->provides, pool_rel2id(pool, s->name, s->evr, REL_EQ, 1), 0);
if (!(flags & REPO_NO_LOCATION))
repodata_set_location(data, s - pool->solvables, 0, 0, fn);
if (S_ISREG(stb.st_mode))
repodata_set_num(data, s - pool->solvables, SOLVABLE_DOWNLOADSIZE, (unsigned long long)stb.st_size);
if (pkgidhandle)
{
unsigned char pkgid[16];
solv_chksum_free(pkgidhandle, pkgid);
repodata_set_bin_checksum(data, s - pool->solvables, SOLVABLE_PKGID, REPOKEY_TYPE_MD5, pkgid);
pkgidhandle = 0;
}
}
if (pkgidhandle)
solv_chksum_free(pkgidhandle, 0);
if (!(flags & REPO_NO_INTERNALIZE))
repodata_internalize(data);
return s ? s - pool->solvables : 0;
}
static void XMLCALL
endElement(void *userData, const char *name)
{
struct parsedata *pd = userData;
Solvable *s = pd->solvable;
#if 0
fprintf(stderr, "end: [%d]%s\n", pd->state, name);
#endif
if (pd->depth != pd->statedepth)
{
pd->depth--;
#if 0
fprintf(stderr, "back from unknown %d %d %d\n", pd->state, pd->depth, pd->statedepth);
#endif
return;
}
pd->depth--;
pd->statedepth--;
switch (pd->state)
{
case STATE_PRODUCT:
/* product done, finish solvable */
if (pd->ctime)
repodata_set_num(pd->data, pd->handle, SOLVABLE_INSTALLTIME, pd->ctime);
if (pd->basename)
repodata_set_str(pd->data, pd->handle, PRODUCT_REFERENCEFILE, pd->basename);
/* this is where <productsdir>/baseproduct points to */
if (pd->currentproduct == pd->baseproduct)
repodata_set_str(pd->data, pd->handle, PRODUCT_TYPE, "base");
if (pd->tmprel)
{
if (pd->tmpvers)
s->evr = makeevr(pd->pool, join2(&pd->jd, pd->tmpvers, "-", pd->tmprel));
else
{
fprintf(stderr, "Seen <release> but no <version>\n");
}
}
else if (pd->tmpvers)
s->evr = makeevr(pd->pool, pd->tmpvers); /* just version, no release */
pd->tmpvers = solv_free((void *)pd->tmpvers);
pd->tmprel = solv_free((void *)pd->tmprel);
if (!s->arch)
s->arch = ARCH_NOARCH;
if (!s->evr)
s->evr = ID_EMPTY;
if (s->name && s->arch != ARCH_SRC && s->arch != ARCH_NOSRC)
s->provides = repo_addid_dep(pd->repo, s->provides, pool_rel2id(pd->pool, s->name, s->evr, REL_EQ, 1), 0);
pd->solvable = 0;
break;
case STATE_VENDOR:
s->vendor = pool_str2id(pd->pool, pd->content, 1);
break;
case STATE_NAME:
s->name = pool_str2id(pd->pool, join2(&pd->jd, "product", ":", pd->content), 1);
break;
case STATE_VERSION:
pd->tmpvers = solv_strdup(pd->content);
break;
case STATE_RELEASE:
pd->tmprel = solv_strdup(pd->content);
break;
case STATE_ARCH:
s->arch = pool_str2id(pd->pool, pd->content, 1);
break;
case STATE_PRODUCTLINE:
repodata_set_str(pd->data, pd->handle, PRODUCT_PRODUCTLINE, pd->content);
break;
case STATE_UPDATEREPOKEY:
/** obsolete **/
break;
case STATE_SUMMARY:
repodata_set_str(pd->data, pd->handle, pool_id2langid(pd->pool, SOLVABLE_SUMMARY, pd->tmplang, 1), pd->content);
break;
case STATE_SHORTSUMMARY:
repodata_set_str(pd->data, pd->handle, PRODUCT_SHORTLABEL, pd->content);
break;
case STATE_DESCRIPTION:
repodata_set_str(pd->data, pd->handle, pool_id2langid(pd->pool, SOLVABLE_DESCRIPTION, pd->tmplang, 1), pd->content);
break;
case STATE_URL:
if (pd->urltype)
{
repodata_add_poolstr_array(pd->data, pd->handle, PRODUCT_URL, pd->content);
repodata_add_idarray(pd->data, pd->handle, PRODUCT_URL_TYPE, pd->urltype);
}
break;
case STATE_TARGET:
repodata_set_str(pd->data, pd->handle, PRODUCT_REGISTER_TARGET, pd->content);
break;
case STATE_REGRELEASE:
repodata_set_str(pd->data, pd->handle, PRODUCT_REGISTER_RELEASE, pd->content);
break;
case STATE_CPEID:
if (*pd->content)
repodata_set_str(pd->data, pd->handle, SOLVABLE_CPEID, pd->content);
default:
break;
}
pd->state = pd->sbtab[pd->state];
pd->docontent = 0;
#if 0
fprintf(stderr, "end: [%s] -> %d\n", name, pd->state);
#endif
}
int
repo_add_autopattern(Repo *repo, int flags)
{
Pool *pool = repo->pool;
Repodata *data = 0;
Solvable *s, *s2;
Queue patq, patq2;
Queue prdq, prdq2;
Id p;
Id pattern_id, product_id;
Id autopattern_id = 0, autoproduct_id = 0;
int i, j;
queue_init(&patq);
queue_init(&patq2);
queue_init(&prdq);
queue_init(&prdq2);
pattern_id = pool_str2id(pool, "pattern()", 9);
product_id = pool_str2id(pool, "product()", 9);
FOR_REPO_SOLVABLES(repo, p, s)
{
const char *n = pool_id2str(pool, s->name);
if (*n == 'p')
{
if (!strncmp("pattern:", n, 8))
{
queue_push(&patq, p);
continue;
}
else if (!strncmp("product:", n, 8))
{
queue_push(&prdq, p);
continue;
}
}
if (s->provides)
{
Id prv, *prvp = repo->idarraydata + s->provides;
while ((prv = *prvp++) != 0) /* go through all provides */
if (ISRELDEP(prv))
{
Reldep *rd = GETRELDEP(pool, prv);
if (rd->flags != REL_EQ)
continue;
if (rd->name == pattern_id)
{
queue_push2(&patq2, p, rd->evr);
break;
}
if (rd->name == product_id)
{
queue_push2(&prdq2, p, rd->evr);
break;
}
}
}
}
for (i = 0; i < patq2.count; i += 2)
{
const char *pn = 0;
char *newname;
Id name, prv, *prvp;
const char *str;
unsigned long long num;
s = pool->solvables + patq2.elements[i];
/* construct new name */
newname = pool_tmpjoin(pool, "pattern:", pool_id2str(pool, patq2.elements[i + 1]), 0);
unescape(newname);
name = pool_str2id(pool, newname, 0);
if (name)
{
/* check if we already have that pattern */
for (j = 0; j < patq.count; j++)
{
s2 = pool->solvables + patq.elements[j];
if (s2->name == name && s2->arch == s->arch && s2->evr == s->evr)
break;
}
if (j < patq.count)
continue; /* yes, do not add again */
}
/* new pattern */
if (!name)
name = pool_str2id(pool, newname, 1);
if (!data)
{
repo_internalize(repo); /* to make that the lookups work */
data = repo_add_repodata(repo, flags);
}
s2 = pool_id2solvable(pool, repo_add_solvable(repo));
s = pool->solvables + patq2.elements[i]; /* re-calc pointer */
s2->name = name;
s2->arch = s->arch;
s2->evr = s->evr;
s2->vendor = s->vendor;
/* add link requires */
s2->requires = repo_addid_dep(repo, s2->requires, pool_rel2id(pool, s->name, s->evr, REL_EQ, 1) , 0);
/* add autopattern provides */
if (!autopattern_id)
autopattern_id = pool_str2id(pool, "autopattern()", 1);
s2->provides = repo_addid_dep(repo, s2->provides, pool_rel2id(pool, autopattern_id, s->name, REL_EQ, 1), 0);
/* add self provides */
s2->provides = repo_addid_dep(repo, s2->provides, pool_rel2id(pool, s2->name, s2->evr, REL_EQ, 1), 0);
if ((num = solvable_lookup_num(s, SOLVABLE_INSTALLTIME, 0)) != 0)
repodata_set_num(data, s2 - pool->solvables, SOLVABLE_INSTALLTIME, num);
if ((num = solvable_lookup_num(s, SOLVABLE_BUILDTIME, 0)) != 0)
repodata_set_num(data, s2 - pool->solvables, SOLVABLE_BUILDTIME, num);
if ((str = solvable_lookup_str(s, SOLVABLE_SUMMARY)) != 0)
repodata_set_str(data, s2 - pool->solvables, SOLVABLE_SUMMARY, str);
if ((str = solvable_lookup_str(s, SOLVABLE_DESCRIPTION)) != 0)
repodata_set_str(data, s2 - pool->solvables, SOLVABLE_DESCRIPTION, str);
/* fill in stuff from provides */
prvp = repo->idarraydata + s->provides;
while ((prv = *prvp++) != 0) /* go through all provides */
{
Id evr = 0;
if (ISRELDEP(prv))
{
Reldep *rd = GETRELDEP(pool, prv);
if (rd->flags != REL_EQ)
continue;
prv = rd->name;
evr = rd->evr;
}
pn = pool_id2str(pool, prv);
if (strncmp("pattern-", pn, 8) != 0)
continue;
newname = 0;
if (evr)
{
newname = pool_tmpjoin(pool, pool_id2str(pool, evr), 0, 0);
unescape(newname);
}
if (!strncmp(pn, "pattern-category(", 17) && evr)
{
char lang[9];
int l = strlen(pn);
Id langtag;
if (l > 17 + 9 || pn[l - 1] != ')')
continue;
strncpy(lang, pn + 17, l - 17 - 1);
lang[l - 17 - 1] = 0;
langtag = SOLVABLE_CATEGORY;
if (*lang && strcmp(lang, "en") != 0)
langtag = pool_id2langid(pool, SOLVABLE_CATEGORY, lang, 1);
if (newname[solv_validutf8(newname)] == 0)
repodata_set_str(data, s2 - pool->solvables, langtag, newname);
else
{
char *ustr = solv_latin1toutf8(newname);
repodata_set_str(data, s2 - pool->solvables, langtag, ustr);
solv_free(ustr);
}
}
else if (!strcmp(pn, "pattern-includes()") && evr)
repodata_add_poolstr_array(data, s2 - pool->solvables, SOLVABLE_INCLUDES, pool_tmpjoin(pool, "pattern:", newname, 0));
else if (!strcmp(pn, "pattern-extends()") && evr)
repodata_add_poolstr_array(data, s2 - pool->solvables, SOLVABLE_EXTENDS, pool_tmpjoin(pool, "pattern:", newname, 0));
else if (!strcmp(pn, "pattern-icon()") && evr)
repodata_set_str(data, s2 - pool->solvables, SOLVABLE_ICON, newname);
else if (!strcmp(pn, "pattern-order()") && evr)
repodata_set_str(data, s2 - pool->solvables, SOLVABLE_ORDER, newname);
else if (!strcmp(pn, "pattern-visible()") && !evr)
repodata_set_void(data, s2 - pool->solvables, SOLVABLE_ISVISIBLE);
}
}
queue_free(&patq);
queue_free(&patq2);
if (repo == pool->installed)
queue_empty(&prdq2); /* no auto products for installed repos */
for (i = 0; i < prdq2.count; i += 2)
{
const char *pn = 0;
char *newname;
Id name, evr = 0, prv, *prvp;
const char *str;
unsigned long long num;
s = pool->solvables + prdq2.elements[i];
/* construct new name */
newname = pool_tmpjoin(pool, "product(", pool_id2str(pool, prdq2.elements[i + 1]), ")");
unescape(newname);
name = pool_str2id(pool, newname, 0);
if (!name)
continue; /* must have it in provides! */
prvp = repo->idarraydata + s->provides;
while ((prv = *prvp++) != 0) /* go through all provides */
{
if (ISRELDEP(prv))
{
Reldep *rd = GETRELDEP(pool, prv);
if (rd->name == name && rd->flags == REL_EQ)
{
evr = rd->evr;
break;
}
}
}
if (!prv)
continue; /* not found in provides */
newname = pool_tmpjoin(pool, "product:", pool_id2str(pool, prdq2.elements[i + 1]), 0);
unescape(newname);
name = pool_str2id(pool, newname, 0);
if (name)
{
/* check if we already have that product */
for (j = 0; j < prdq.count; j++)
{
s2 = pool->solvables + prdq.elements[j];
if (s2->name == name && s2->arch == s->arch && s2->evr == evr)
break;
}
if (j < prdq.count)
continue; /* yes, do not add again */
}
/* new product */
if (!name)
name = pool_str2id(pool, newname, 1);
if (!data)
{
repo_internalize(repo); /* to make that the lookups work */
data = repo_add_repodata(repo, flags);
}
if ((num = solvable_lookup_num(s, SOLVABLE_INSTALLTIME, 0)) != 0)
continue; /* eek, not for installed packages, please! */
s2 = pool_id2solvable(pool, repo_add_solvable(repo));
s = pool->solvables + prdq2.elements[i]; /* re-calc pointer */
s2->name = name;
s2->arch = s->arch;
s2->evr = evr;
s2->vendor = s->vendor;
/* add link requires */
s2->requires = repo_addid_dep(repo, s2->requires, prv, 0);
if (!autoproduct_id)
autoproduct_id = pool_str2id(pool, "autoproduct()", 1);
s2->provides = repo_addid_dep(repo, s2->provides, pool_rel2id(pool, autoproduct_id, s->name, REL_EQ, 1), 0);
/* add self provides */
s2->provides = repo_addid_dep(repo, s2->provides, pool_rel2id(pool, s2->name, s2->evr, REL_EQ, 1), 0);
if ((num = solvable_lookup_num(s, SOLVABLE_BUILDTIME, 0)) != 0)
repodata_set_num(data, s2 - pool->solvables, SOLVABLE_BUILDTIME, num);
if ((str = solvable_lookup_str(s, SOLVABLE_SUMMARY)) != 0)
repodata_set_str(data, s2 - pool->solvables, SOLVABLE_SUMMARY, str);
if ((str = solvable_lookup_str(s, SOLVABLE_DESCRIPTION)) != 0)
repodata_set_str(data, s2 - pool->solvables, SOLVABLE_DESCRIPTION, str);
if ((str = solvable_lookup_str(s, SOLVABLE_DISTRIBUTION)) != 0)
repodata_set_str(data, s2 - pool->solvables, SOLVABLE_DISTRIBUTION, str);
/* fill in stuff from provides */
prvp = repo->idarraydata + s->provides;
while ((prv = *prvp++) != 0) /* go through all provides */
{
Id evr = 0;
if (ISRELDEP(prv))
{
Reldep *rd = GETRELDEP(pool, prv);
if (rd->flags != REL_EQ)
continue;
prv = rd->name;
evr = rd->evr;
}
pn = pool_id2str(pool, prv);
if (strncmp("product-", pn, 8) != 0)
continue;
newname = 0;
if (evr)
{
newname = pool_tmpjoin(pool, pool_id2str(pool, evr), 0, 0);
unescape(newname);
}
if (!strcmp(pn, "product-label()") && evr)
repodata_set_str(data, s2 - pool->solvables, PRODUCT_SHORTLABEL, newname);
else if (!strcmp(pn, "product-type()") && evr)
repodata_set_str(data, s2 - pool->solvables, PRODUCT_TYPE, newname);
else if (!strcmp(pn, "product-cpeid()") && evr)
repodata_set_str(data, s2 - pool->solvables, SOLVABLE_CPEID, newname);
else if (!strcmp(pn, "product-flags()") && evr)
repodata_add_poolstr_array(data, s2 - pool->solvables, PRODUCT_FLAGS, newname);
else if (!strcmp(pn, "product-updates-repoid()") && evr)
repodata_add_poolstr_array(data, s2 - pool->solvables, PRODUCT_UPDATES_REPOID, newname);
else if (!strncmp(pn, "product-url(", 12) && evr && pn[12] && pn[13] && strlen(pn + 12) < 32)
{
char type[34];
strcpy(type, pn + 12);
type[strlen(type) - 1] = 0; /* closing ) */
repodata_add_poolstr_array(data, s2 - pool->solvables, PRODUCT_URL_TYPE, type);
repodata_add_poolstr_array(data, s2 - pool->solvables, PRODUCT_URL, newname);
}
}
}
queue_free(&prdq);
queue_free(&prdq2);
if (data && !(flags & REPO_NO_INTERNALIZE))
repodata_internalize(data);
else if (!data && !(flags & REPO_NO_INTERNALIZE))
repo_internalize(repo);
return 0;
}