/*
- * Copyright (c) 2007, Novell Inc.
+ * Copyright (c) 2007-2012, Novell Inc.
*
* This program is licensed under the BSD license, read LICENSE.BSD
* for further information
#include <string.h>
#include <unistd.h>
#include <assert.h>
+#include <stdint.h>
+#include <errno.h>
-#ifdef FEDORA
-#include <db4/db.h>
-#else
-#include <rpm/db.h>
-#endif
#include <rpm/rpmio.h>
#include <rpm/rpmpgp.h>
+#ifndef RPM5
+#include <rpm/header.h>
+#endif
+#include <rpm/rpmdb.h>
+
+#ifndef DB_CREATE
+# if defined(SUSE) || defined(HAVE_RPM_DB_H)
+# include <rpm/db.h>
+# else
+# include <db.h>
+# endif
+#endif
#include "pool.h"
#include "repo.h"
#include "chksum.h"
#include "repo_rpmdb.h"
-#define RPMDB_COOKIE_VERSION 2
+/* 3: added triggers */
+/* 4: fixed triggers */
+#define RPMDB_COOKIE_VERSION 4
#define TAG_NAME 1000
#define TAG_VERSION 1001
#define TAG_FILEMODES 1030
#define TAG_FILEMD5S 1035
#define TAG_FILELINKTOS 1036
+#define TAG_FILEFLAGS 1037
#define TAG_SOURCERPM 1044
#define TAG_PROVIDENAME 1047
#define TAG_REQUIREFLAGS 1048
#define TAG_CONFLICTFLAGS 1053
#define TAG_CONFLICTNAME 1054
#define TAG_CONFLICTVERSION 1055
+#define TAG_TRIGGERNAME 1066
+#define TAG_TRIGGERVERSION 1067
+#define TAG_TRIGGERFLAGS 1068
+#define TAG_CHANGELOGTIME 1080
+#define TAG_CHANGELOGNAME 1081
+#define TAG_CHANGELOGTEXT 1082
#define TAG_OBSOLETENAME 1090
#define TAG_FILEDEVICES 1095
#define TAG_FILEINODES 1096
+#define TAG_SOURCEPACKAGE 1106
#define TAG_PROVIDEFLAGS 1112
#define TAG_PROVIDEVERSION 1113
#define TAG_OBSOLETEFLAGS 1114
#define TAG_ENHANCESVERSION 1160
#define TAG_ENHANCESFLAGS 1161
+/* rpm5 tags */
+#define TAG_DISTEPOCH 1218
+
+/* rpm4 tags */
+#define TAG_LONGFILESIZES 5008
+#define TAG_LONGSIZE 5009
+
+/* signature tags */
+#define TAG_SIGBASE 256
+#define TAG_SIGMD5 (TAG_SIGBASE + 5)
+#define TAG_SHA1HEADER (TAG_SIGBASE + 13)
+
#define SIGTAG_SIZE 1000
#define SIGTAG_PGP 1002 /* RSA signature */
#define SIGTAG_MD5 1004 /* header+payload md5 checksum */
#define DEP_STRONG (1 << 27)
#define DEP_PRE ((1 << 6) | (1 << 9) | (1 << 10) | (1 << 11) | (1 << 12))
+#define FILEFLAG_GHOST (1 << 6)
+
+
+#ifdef RPM5
+# define RPM_INDEX_SIZE 4
+#else
+# define RPM_INDEX_SIZE 8
+#endif
struct rpmid {
unsigned int dbid;
int cnt;
int dcnt;
unsigned char *dp;
+ int forcebinary; /* sigh */
unsigned char data[1];
} RpmHead;
if (o + 4 * i > h->dcnt)
return 0;
d = h->dp + o;
- r = sat_calloc(i ? i : 1, sizeof(unsigned int));
+ r = solv_calloc(i ? i : 1, sizeof(unsigned int));
if (cnt)
*cnt = i;
for (o = 0; o < i; o++, d += 4)
return d[0] << 24 | d[1] << 16 | d[2] << 8 | d[3];
}
+/* returns the first entry of an 64bit integer array */
+static unsigned long long
+headint64(RpmHead *h, int tag)
+{
+ unsigned int i, o;
+ unsigned char *d = headfindtag(h, tag);
+ if (!d || d[4] != 0 || d[5] != 0 || d[6] != 0 || d[7] != 5)
+ return 0;
+ o = d[8] << 24 | d[9] << 16 | d[10] << 8 | d[11];
+ i = d[12] << 24 | d[13] << 16 | d[14] << 8 | d[15];
+ if (i == 0 || o + 8 * i > h->dcnt)
+ return 0;
+ d = h->dp + o;
+ i = d[0] << 24 | d[1] << 16 | d[2] << 8 | d[3];
+ return (unsigned long long)i << 32 | (d[4] << 24 | d[5] << 16 | d[6] << 8 | d[7]);
+}
+
static unsigned int *
headint16array(RpmHead *h, int tag, int *cnt)
{
if (o + 4 * i > h->dcnt)
return 0;
d = h->dp + o;
- r = sat_calloc(i ? i : 1, sizeof(unsigned int));
+ r = solv_calloc(i ? i : 1, sizeof(unsigned int));
if (cnt)
*cnt = i;
for (o = 0; o < i; o++, d += 2)
return 0;
o = d[8] << 24 | d[9] << 16 | d[10] << 8 | d[11];
i = d[12] << 24 | d[13] << 16 | d[14] << 8 | d[15];
- r = sat_calloc(i ? i : 1, sizeof(char *));
+ r = solv_calloc(i ? i : 1, sizeof(char *));
if (cnt)
*cnt = i;
d = h->dp + o;
d += strlen((char *)d) + 1;
if (d >= h->dp + h->dcnt)
{
- sat_free(r);
+ solv_free(r);
return 0;
}
}
char *version, *v;
char *release;
char *evr;
+ char *distepoch;
version = headstring(h, TAG_VERSION);
release = headstring(h, TAG_RELEASE);
if (!version || !release)
{
fprintf(stderr, "headtoevr: bad rpm header\n");
- exit(1);
+ return 0;
}
- for (v = version; *v >= 0 && *v <= '9'; v++)
+ for (v = version; *v >= '0' && *v <= '9'; v++)
;
if (epoch || (v != version && *v == ':'))
{
char epochbuf[11]; /* 32bit decimal will fit in */
sprintf(epochbuf, "%u", epoch);
- evr = sat_malloc(strlen(epochbuf) + 1 + strlen(version) + 1 + strlen(release) + 1);
+ evr = solv_malloc(strlen(epochbuf) + 1 + strlen(version) + 1 + strlen(release) + 1);
sprintf(evr, "%s:%s-%s", epochbuf, version, release);
}
else
{
- evr = sat_malloc(strlen(version) + 1 + strlen(release) + 1);
+ evr = solv_malloc(strlen(version) + 1 + strlen(release) + 1);
sprintf(evr, "%s-%s", version, release);
}
+ distepoch = headstring(h, TAG_DISTEPOCH);
+ if (distepoch && *distepoch)
+ {
+ int l = strlen(evr);
+ evr = solv_realloc(evr, l + strlen(distepoch) + 2);
+ evr[l++] = ':';
+ strcpy(evr + l, distepoch);
+ }
return evr;
}
if (c)
{
/* not utf8, assume latin1 */
- buf = sat_malloc(2 * strlen(str) + 1);
+ buf = solv_malloc(2 * strlen(str) + 1);
cp = (const unsigned char *)str;
str = (char *)buf;
bp = buf;
}
repodata_set_str(repodata, handle, tag, str);
if (buf)
- sat_free(buf);
+ solv_free(buf);
}
strong = flags & (MAKEDEPS_FILTER_STRONG|MAKEDEPS_FILTER_WEAK);
n = headstringarray(rpmhead, tagn, &nc);
- if (!n)
+ if (!n || !nc)
return 0;
+ vc = fc = 0;
v = headstringarray(rpmhead, tagv, &vc);
- if (!v)
- {
- sat_free(n);
- return 0;
- }
f = headint32array(rpmhead, tagf, &fc);
- if (!f)
- {
- sat_free(n);
- free(v);
+ if (!v || !f || nc != vc || nc != fc)
+ {
+ char *pkgname = rpm_query(rpmhead, 0);
+ fprintf(stderr, "bad dependency entries for %s: %d %d %d\n", pkgname ? pkgname : "<NULL>", nc, vc, fc);
+ solv_free(pkgname);
+ solv_free(n);
+ solv_free(v);
+ solv_free(f);
return 0;
}
- if (nc != vc || nc != fc)
- {
- fprintf(stderr, "bad dependency entries\n");
- exit(1);
- }
cc = nc;
haspre = 0; /* add no prereq marker */
}
if (cc == 0)
{
- sat_free(n);
- sat_free(v);
- sat_free(f);
+ solv_free(n);
+ solv_free(v);
+ solv_free(f);
return 0;
}
cc += haspre;
flags |= 2;
if ((f[i] & DEP_GREATER) != 0)
flags |= 1;
- name = str2id(pool, n[i], 1);
+ name = pool_str2id(pool, n[i], 1);
if (v[i][0] == '0' && v[i][1] == ':' && v[i][2])
- evr = str2id(pool, v[i] + 2, 1);
+ evr = pool_str2id(pool, v[i] + 2, 1);
else
- evr = str2id(pool, v[i], 1);
- *ida++ = rel2id(pool, name, evr, flags, 1);
+ evr = pool_str2id(pool, v[i], 1);
+ *ida++ = pool_rel2id(pool, name, evr, flags, 1);
}
else
- *ida++ = str2id(pool, n[i], 1);
+ *ida++ = pool_str2id(pool, n[i], 1);
}
*ida++ = 0;
repo->idarraysize += cc + 1;
- sat_free(n);
- sat_free(v);
- sat_free(f);
+ solv_free(n);
+ solv_free(v);
+ solv_free(f);
return olddeps;
}
#endif
static void
-adddudata(Pool *pool, Repo *repo, Repodata *data, Solvable *s, RpmHead *rpmhead, char **dn, unsigned int *di, int fc, int dic)
+adddudata(Pool *pool, Repo *repo, Repodata *data, Solvable *s, RpmHead *rpmhead, char **dn, unsigned int *di, int fc, int dc)
{
Id handle, did;
int i, fszc;
if (!fc)
return;
+ /* XXX: use TAG_LONGFILESIZES if available */
fsz = headint32array(rpmhead, TAG_FILESIZES, &fszc);
if (!fsz || fc != fszc)
{
- sat_free(fsz);
+ solv_free(fsz);
return;
}
- /* stupid rpm recodrs sizes of directories, so we have to check the mode */
+ /* stupid rpm records sizes of directories, so we have to check the mode */
fm = headint16array(rpmhead, TAG_FILEMODES, &fszc);
if (!fm || fc != fszc)
{
- sat_free(fsz);
- sat_free(fm);
+ solv_free(fsz);
+ solv_free(fm);
return;
}
fino = headint32array(rpmhead, TAG_FILEINODES, &fszc);
if (!fino || fc != fszc)
{
- sat_free(fsz);
- sat_free(fm);
- sat_free(fino);
+ solv_free(fsz);
+ solv_free(fm);
+ solv_free(fino);
return;
}
inotestok = 0;
unsigned int mask, hash, hh;
if (!fdev || fc != fszc)
{
- sat_free(fsz);
- sat_free(fm);
- sat_free(fdev);
- sat_free(fino);
+ solv_free(fsz);
+ solv_free(fm);
+ solv_free(fdev);
+ solv_free(fino);
return;
}
mask = fc;
mask = mask & (mask - 1);
mask <<= 2;
if (mask > sizeof(inotest)/sizeof(*inotest))
- fx = sat_calloc(mask, sizeof(unsigned int));
+ fx = solv_calloc(mask, sizeof(unsigned int));
else
{
fx = inotest;
fx[hash] = i + 1;
}
if (fx != inotest)
- sat_free(fx);
- sat_free(fdev);
+ solv_free(fx);
+ solv_free(fdev);
}
- sat_free(fino);
- fn = sat_calloc(dic, sizeof(unsigned int));
- fkb = sat_calloc(dic, sizeof(unsigned int));
+ solv_free(fino);
+ fn = solv_calloc(dc, sizeof(unsigned int));
+ fkb = solv_calloc(dc, sizeof(unsigned int));
for (i = 0; i < fc; i++)
{
- if (fsz[i] == 0 || !S_ISREG(fm[i]))
- continue;
- if (di[i] >= dic)
+ if (di[i] >= dc)
continue;
fn[di[i]]++;
+ if (fsz[i] == 0 || !S_ISREG(fm[i]))
+ continue;
fkb[di[i]] += fsz[i] / 1024 + 1;
}
- sat_free(fsz);
- sat_free(fm);
+ solv_free(fsz);
+ solv_free(fm);
/* commit */
handle = s - pool->solvables;
- for (i = 0; i < fc; i++)
+ for (i = 0; i < dc; i++)
{
if (!fn[i])
continue;
- if (!*dn[i] && (s->arch == ARCH_SRC || s->arch == ARCH_NOSRC))
- did = repodata_str2dir(data, "/usr/src", 1);
+ if (!*dn[i])
+ {
+ if (s->arch == ARCH_SRC || s->arch == ARCH_NOSRC)
+ did = repodata_str2dir(data, "/usr/src", 1);
+ else
+ continue; /* work around rpm bug */
+ }
else
did = repodata_str2dir(data, dn[i], 1);
repodata_add_dirnumnum(data, handle, SOLVABLE_DISKUSAGE, did, fkb[i], fn[i]);
}
- sat_free(fn);
- sat_free(fkb);
+ solv_free(fn);
+ solv_free(fkb);
}
/* assumes last processed array is provides! */
unsigned int *di;
int bnc, dnc, dic;
int i;
+ Id lastdid = 0;
+ int lastdii = -1;
#ifdef USE_FILEFILTER
int j;
struct filefilter *ff;
dn = headstringarray(rpmhead, TAG_DIRNAMES, &dnc);
if (!dn)
{
- sat_free(bn);
+ solv_free(bn);
return olddeps;
}
di = headint32array(rpmhead, TAG_DIRINDEXES, &dic);
if (!di)
{
- sat_free(bn);
- sat_free(dn);
+ solv_free(bn);
+ solv_free(dn);
return olddeps;
}
if (bnc != dic)
{
fprintf(stderr, "bad filelist\n");
- exit(1);
+ return olddeps;
}
if (data)
- adddudata(pool, repo, data, s, rpmhead, dn, di, bnc, dic);
+ adddudata(pool, repo, data, s, rpmhead, dn, di, bnc, dnc);
for (i = 0; i < bnc; i++)
{
if (j > fna)
{
fna = j + 256;
- fn = sat_realloc(fn, fna);
+ fn = solv_realloc(fn, fna);
}
strcpy(fn, dn[di[i]]);
strcat(fn, bn[i]);
- olddeps = repo_addid_dep(repo, olddeps, str2id(pool, fn, 1), SOLVABLE_FILEMARKER);
+ olddeps = repo_addid_dep(repo, olddeps, pool_str2id(pool, fn, 1), SOLVABLE_FILEMARKER);
#endif
if (data)
{
- Id handle, did;
- handle = s - pool->solvables;
- did = repodata_str2dir(data, dn[di[i]], 1);
- if (!did)
- did = repodata_str2dir(data, "/", 1);
- repodata_add_dirstr(data, handle, SOLVABLE_FILELIST, did, bn[i]);
+ Id did;
+ char *b = bn[i];
+
+ if (di[i] == lastdii)
+ did = lastdid;
+ else
+ {
+ did = repodata_str2dir(data, dn[di[i]], 1);
+ if (!did)
+ did = repodata_str2dir(data, "/", 1);
+ lastdid = did;
+ lastdii = di[i];
+ }
+ if (b && *b == '/') /* work around rpm bug */
+ b++;
+ repodata_add_dirstr(data, s - pool->solvables, SOLVABLE_FILELIST, did, b);
}
}
#if 0
if (fn)
- sat_free(fn);
+ solv_free(fn);
#endif
- sat_free(bn);
- sat_free(dn);
- sat_free(di);
+ solv_free(bn);
+ solv_free(dn);
+ solv_free(di);
return olddeps;
}
static void
-addsourcerpm(Pool *pool, Repodata *data, Id handle, char *sourcerpm, char *name, char *evr)
+addchangelog(Repodata *data, Id handle, RpmHead *rpmhead)
{
- const char *p, *sevr, *sarch;
-
- p = strrchr(sourcerpm, '.');
- if (!p || strcmp(p, ".rpm") != 0)
- return;
- p--;
- while (p > sourcerpm && *p != '.')
- p--;
- if (*p != '.' || p == sourcerpm)
- return;
- sarch = p-- + 1;
- while (p > sourcerpm && *p != '-')
- p--;
- if (*p != '-' || p == sourcerpm)
- return;
- p--;
- while (p > sourcerpm && *p != '-')
- p--;
- if (*p != '-' || p == sourcerpm)
- return;
- sevr = p + 1;
- if (!strcmp(sarch, "src.rpm"))
- repodata_set_constantid(data, handle, SOLVABLE_SOURCEARCH, ARCH_SRC);
- else if (!strcmp(sarch, "nosrc.rpm"))
- repodata_set_constantid(data, handle, SOLVABLE_SOURCEARCH, ARCH_NOSRC);
- else
- repodata_set_constantid(data, handle, SOLVABLE_SOURCEARCH, strn2id(pool, sarch, strlen(sarch) - 4, 1));
- if (evr && !strncmp(sevr, evr, sarch - sevr - 1) && evr[sarch - sevr - 1] == 0)
- repodata_set_void(data, handle, SOLVABLE_SOURCEEVR);
- else
- repodata_set_id(data, handle, SOLVABLE_SOURCEEVR, strn2id(pool, sevr, sarch - sevr - 1, 1));
- if (name && !strncmp(sourcerpm, name, sevr - sourcerpm - 1) && name[sevr - sourcerpm - 1] == 0)
- repodata_set_void(data, handle, SOLVABLE_SOURCENAME);
- else
- repodata_set_id(data, handle, SOLVABLE_SOURCENAME, strn2id(pool, sourcerpm, sevr - sourcerpm - 1, 1));
+ char **cn;
+ char **cx;
+ unsigned int *ct;
+ int i, cnc, cxc, ctc;
+ Queue hq;
+
+ ct = headint32array(rpmhead, TAG_CHANGELOGTIME, &ctc);
+ cx = headstringarray(rpmhead, TAG_CHANGELOGTEXT, &cxc);
+ cn = headstringarray(rpmhead, TAG_CHANGELOGNAME, &cnc);
+ if (!ct || !cx || !cn || !ctc || ctc != cxc || ctc != cnc)
+ {
+ solv_free(ct);
+ solv_free(cx);
+ solv_free(cn);
+ return;
+ }
+ queue_init(&hq);
+ for (i = 0; i < ctc; i++)
+ {
+ Id h = repodata_new_handle(data);
+ if (ct[i])
+ repodata_set_num(data, h, SOLVABLE_CHANGELOG_TIME, ct[i]);
+ if (cn[i])
+ repodata_set_str(data, h, SOLVABLE_CHANGELOG_AUTHOR, cn[i]);
+ if (cx[i])
+ repodata_set_str(data, h, SOLVABLE_CHANGELOG_TEXT, cx[i]);
+ queue_push(&hq, h);
+ }
+ for (i = 0; i < hq.count; i++)
+ repodata_add_flexarray(data, handle, SOLVABLE_CHANGELOG, hq.elements[i]);
+ queue_free(&hq);
+ solv_free(ct);
+ solv_free(cx);
+ solv_free(cn);
}
+
static int
rpm2solv(Pool *pool, Repo *repo, Repodata *data, Solvable *s, RpmHead *rpmhead, int flags)
{
char *sourcerpm;
name = headstring(rpmhead, TAG_NAME);
- if (!strcmp(name, "gpg-pubkey"))
- return 0;
- s->name = str2id(pool, name, 1);
- if (!s->name)
+ if (!name)
{
fprintf(stderr, "package has no name\n");
- exit(1);
+ return 0;
}
+ if (!strcmp(name, "gpg-pubkey"))
+ return 0;
+ s->name = pool_str2id(pool, name, 1);
sourcerpm = headstring(rpmhead, TAG_SOURCERPM);
- if (sourcerpm)
- s->arch = str2id(pool, headstring(rpmhead, TAG_ARCH), 1);
+ if (sourcerpm || (rpmhead->forcebinary && !headexists(rpmhead, TAG_SOURCEPACKAGE)))
+ s->arch = pool_str2id(pool, headstring(rpmhead, TAG_ARCH), 1);
else
{
if (headexists(rpmhead, TAG_NOSOURCE) || headexists(rpmhead, TAG_NOPATCH))
if (!s->arch)
s->arch = ARCH_NOARCH;
evr = headtoevr(rpmhead);
- s->evr = str2id(pool, evr, 1);
- s->vendor = str2id(pool, headstring(rpmhead, TAG_VENDOR), 1);
+ s->evr = pool_str2id(pool, evr, 1);
+ s->vendor = pool_str2id(pool, headstring(rpmhead, TAG_VENDOR), 1);
s->provides = makedeps(pool, repo, rpmhead, TAG_PROVIDENAME, TAG_PROVIDEVERSION, TAG_PROVIDEFLAGS, 0);
if ((flags & RPM_ADD_NO_FILELIST) == 0)
s->provides = addfileprovides(pool, repo, data, s, rpmhead, s->provides);
if (s->arch != ARCH_SRC && s->arch != ARCH_NOSRC)
- s->provides = repo_addid_dep(repo, s->provides, rel2id(pool, s->name, s->evr, REL_EQ, 1), 0);
+ s->provides = repo_addid_dep(repo, s->provides, pool_rel2id(pool, s->name, s->evr, REL_EQ, 1), 0);
s->requires = makedeps(pool, repo, rpmhead, TAG_REQUIRENAME, TAG_REQUIREVERSION, TAG_REQUIREFLAGS, (flags & RPM_ADD_NO_RPMLIBREQS) ? MAKEDEPS_NO_RPMLIB : 0);
s->conflicts = makedeps(pool, repo, rpmhead, TAG_CONFLICTNAME, TAG_CONFLICTVERSION, TAG_CONFLICTFLAGS, 0);
s->obsoletes = makedeps(pool, repo, rpmhead, TAG_OBSOLETENAME, TAG_OBSOLETEVERSION, TAG_OBSOLETEFLAGS, 0);
Id handle;
char *str;
unsigned int u32;
+ unsigned long long u64;
handle = s - pool->solvables;
str = headstring(rpmhead, TAG_SUMMARY);
{
/* oh my, found SUSE special author section */
int l = aut - str;
- str = strdup(str);
+ str = solv_strdup(str);
aut = str + l;
str[l] = 0;
while (l > 0 && str[l - 1] == '\n')
str = headstring(rpmhead, TAG_PACKAGER);
if (str)
repodata_set_poolstr(data, handle, SOLVABLE_PACKAGER, str);
+ if ((flags & RPM_ADD_WITH_PKGID) != 0)
+ {
+ unsigned char *chksum;
+ unsigned int chksumsize;
+ chksum = headbinary(rpmhead, TAG_SIGMD5, &chksumsize);
+ if (chksum && chksumsize == 16)
+ repodata_set_bin_checksum(data, handle, SOLVABLE_PKGID, REPOKEY_TYPE_MD5, chksum);
+ }
+ if ((flags & RPM_ADD_WITH_HDRID) != 0)
+ {
+ str = headstring(rpmhead, TAG_SHA1HEADER);
+ if (str && strlen(str) == 40)
+ repodata_set_checksum(data, handle, SOLVABLE_HDRID, REPOKEY_TYPE_SHA1, str);
+ else if (str && strlen(str) == 64)
+ repodata_set_checksum(data, handle, SOLVABLE_HDRID, REPOKEY_TYPE_SHA256, str);
+ }
u32 = headint32(rpmhead, TAG_BUILDTIME);
if (u32)
repodata_set_num(data, handle, SOLVABLE_BUILDTIME, u32);
u32 = headint32(rpmhead, TAG_INSTALLTIME);
if (u32)
repodata_set_num(data, handle, SOLVABLE_INSTALLTIME, u32);
- u32 = headint32(rpmhead, TAG_SIZE);
- if (u32)
- repodata_set_num(data, handle, SOLVABLE_INSTALLSIZE, (u32 + 1023) / 1024);
+ u64 = headint64(rpmhead, TAG_LONGSIZE);
+ if (u64)
+ repodata_set_num(data, handle, SOLVABLE_INSTALLSIZE, u64);
+ else
+ {
+ u32 = headint32(rpmhead, TAG_SIZE);
+ if (u32)
+ repodata_set_num(data, handle, SOLVABLE_INSTALLSIZE, u32);
+ }
if (sourcerpm)
- addsourcerpm(pool, data, handle, sourcerpm, name, evr);
+ repodata_set_sourcepkg(data, handle, sourcerpm);
+ if ((flags & RPM_ADD_TRIGGERS) != 0)
+ {
+ Id id, lastid;
+ unsigned int ida = makedeps(pool, repo, rpmhead, TAG_TRIGGERNAME, TAG_TRIGGERVERSION, TAG_TRIGGERFLAGS, 0);
+
+ lastid = 0;
+ for (; (id = repo->idarraydata[ida]) != 0; ida++)
+ {
+ /* we currently do not support rel ids in incore data, so
+ * strip off versioning information */
+ while (ISRELDEP(id))
+ {
+ Reldep *rd = GETRELDEP(pool, id);
+ id = rd->name;
+ }
+ if (id == lastid)
+ continue;
+ repodata_add_idarray(data, handle, SOLVABLE_TRIGGERS, id);
+ lastid = id;
+ }
+ }
+ if ((flags & RPM_ADD_WITH_CHANGELOG) != 0)
+ addchangelog(data, handle, rpmhead);
}
- sat_free(evr);
+ solv_free(evr);
return 1;
}
if (ISRELDEP(name))
name = copyreldep(pool, frompool, name);
else
- name = str2id(pool, id2str(frompool, name), 1);
+ name = pool_str2id(pool, pool_id2str(frompool, name), 1);
if (ISRELDEP(evr))
evr = copyreldep(pool, frompool, evr);
else
- evr = str2id(pool, id2str(frompool, evr), 1);
- return rel2id(pool, name, evr, rd->flags, 1);
+ evr = pool_str2id(pool, pool_id2str(frompool, evr), 1);
+ return pool_rel2id(pool, name, evr, rd->flags, 1);
}
static Offset
if (ISRELDEP(id))
id = copyreldep(pool, frompool, id);
else
- id = str2id(pool, id2str(frompool, id), 1);
+ id = pool_str2id(pool, pool_id2str(frompool, id), 1);
*ida++ = id;
}
*ida = 0;
if (parent)
parent = copydir(pool, data, fromspool, fromdata, parent, cache);
if (fromspool != &pool->ss)
- compid = str2id(pool, stringpool_id2str(fromspool, compid), 1);
+ compid = pool_str2id(pool, stringpool_id2str(fromspool, compid), 1);
compid = dirpool_add_dir(&data->dirpool, parent, compid, 1);
if (cache)
{
struct solvable_copy_cbdata {
Repodata *data;
Id handle;
+ Id subhandle;
Id *dircache;
};
Stringpool *fromspool = fromdata->localpool ? &fromdata->spool : &frompool->ss;
keyname = key->name;
- if (keyname >= ID_NUM_INTERNAL)
- keyname = str2id(pool, id2str(frompool, keyname), 1);
+ if (keyname >= ID_NUM_INTERNAL && pool != frompool)
+ keyname = pool_str2id(pool, pool_id2str(frompool, keyname), 1);
switch(key->type)
{
case REPOKEY_TYPE_ID:
case REPOKEY_TYPE_CONSTANTID:
+ case REPOKEY_TYPE_IDARRAY: /* used for triggers */
id = kv->id;
assert(!data->localpool); /* implement me! */
if (pool != frompool || fromdata->localpool)
if (ISRELDEP(id))
id = copyreldep(pool, frompool, id);
else
- id = str2id(pool, stringpool_id2str(fromspool, id), 1);
+ id = pool_str2id(pool, stringpool_id2str(fromspool, id), 1);
}
if (key->type == REPOKEY_TYPE_ID)
repodata_set_id(data, handle, keyname, id);
- else
+ else if (key->type == REPOKEY_TYPE_CONSTANTID)
repodata_set_constantid(data, handle, keyname, id);
+ else
+ repodata_add_idarray(data, handle, keyname, id);
break;
case REPOKEY_TYPE_STR:
repodata_set_str(data, handle, keyname, kv->str);
repodata_set_void(data, handle, keyname);
break;
case REPOKEY_TYPE_NUM:
- repodata_set_num(data, handle, keyname, kv->num);
+ repodata_set_num(data, handle, keyname, SOLV_KV_NUM64(kv));
break;
case REPOKEY_TYPE_CONSTANT:
repodata_set_constant(data, handle, keyname, kv->num);
id = copydir(pool, data, fromspool, fromdata, id, cbdata->dircache);
repodata_add_dirstr(data, handle, keyname, id, kv->str);
break;
+ case REPOKEY_TYPE_FLEXARRAY:
+ if (kv->eof == 2)
+ {
+ assert(cbdata->subhandle);
+ cbdata->handle = cbdata->subhandle;
+ cbdata->subhandle = 0;
+ break;
+ }
+ if (!kv->entry)
+ {
+ assert(!cbdata->subhandle);
+ cbdata->subhandle = cbdata->handle;
+ }
+ cbdata->handle = repodata_new_handle(data);
+ repodata_add_flexarray(data, cbdata->subhandle, keyname, cbdata->handle);
+ break;
default:
break;
}
else
{
if (r->name)
- s->name = str2id(pool, id2str(fromrepo->pool, r->name), 1);
+ s->name = pool_str2id(pool, pool_id2str(fromrepo->pool, r->name), 1);
if (r->evr)
- s->evr = str2id(pool, id2str(fromrepo->pool, r->evr), 1);
+ s->evr = pool_str2id(pool, pool_id2str(fromrepo->pool, r->evr), 1);
if (r->arch)
- s->arch = str2id(pool, id2str(fromrepo->pool, r->arch), 1);
+ s->arch = pool_str2id(pool, pool_id2str(fromrepo->pool, r->arch), 1);
if (r->vendor)
- s->vendor = str2id(pool, id2str(fromrepo->pool, r->vendor), 1);
+ s->vendor = pool_str2id(pool, pool_id2str(fromrepo->pool, r->vendor), 1);
}
s->provides = copydeps(pool, repo, r->provides, fromrepo);
s->requires = copydeps(pool, repo, r->requires, fromrepo);
return;
cbdata.data = data;
cbdata.handle = s - pool->solvables;
+ cbdata.subhandle = 0;
cbdata.dircache = dircache;
- repo_search(fromrepo, (r - fromrepo->pool->solvables), 0, 0, SEARCH_NO_STORAGE_SOLVABLE, solvable_copy_cb, &cbdata);
+ repo_search(fromrepo, (r - fromrepo->pool->solvables), 0, 0, SEARCH_NO_STORAGE_SOLVABLE | SEARCH_SUB | SEARCH_ARRAYSENTINEL, solvable_copy_cb, &cbdata);
}
/* used to sort entries returned in some database order */
Id *rpmdbid;
if (a->name != b->name)
- return strcmp(id2str(pool, a->name), id2str(pool, b->name));
+ return strcmp(pool_id2str(pool, a->name), pool_id2str(pool, b->name));
rpmdbid = repo->rpmdbid;
return rpmdbid[(a - pool->solvables) - repo->start] - rpmdbid[(b - pool->solvables) - repo->start];
}
repo->rpmdbid[pb - repo->start] = tmpid;
}
/* only works if nothing is already internalized! */
- if (data && data->attrs)
- {
- Id *tmpattrs = data->attrs[pa - data->start];
- data->attrs[pa - data->start] = data->attrs[pb - data->start];
- data->attrs[pb - data->start] = tmpattrs;
- }
+ if (data)
+ repodata_swap_attrs(data, pa, pb);
+}
+
+
+static inline Id db2rpmdbid(unsigned char *db, int byteswapped)
+{
+#ifdef RPM5
+ return db[0] << 24 | db[1] << 16 | db[2] << 8 | db[3];
+#else
+# if defined(WORDS_BIGENDIAN)
+ if (!byteswapped)
+# else
+ if (byteswapped)
+# endif
+ return db[0] << 24 | db[1] << 16 | db[2] << 8 | db[3];
+ else
+ return db[3] << 24 | db[2] << 16 | db[1] << 8 | db[0];
+#endif
+}
+
+static inline void rpmdbid2db(unsigned char *db, Id id, int byteswapped)
+{
+#ifdef RPM5
+ db[0] = id >> 24, db[1] = id >> 16, db[2] = id >> 8, db[3] = id;
+#else
+# if defined(WORDS_BIGENDIAN)
+ if (!byteswapped)
+# else
+ if (byteswapped)
+# endif
+ db[0] = id >> 24, db[1] = id >> 16, db[2] = id >> 8, db[3] = id;
+ else
+ db[3] = id >> 24, db[2] = id >> 16, db[1] = id >> 8, db[0] = id;
+#endif
}
static void
memcpy(cookie + 24, &st->st_dev, sizeof(st->st_dev));
}
+/* should look in /usr/lib/rpm/macros instead, but we want speed... */
+static DB_ENV *
+opendbenv(const char *rootdir)
+{
+ char dbpath[PATH_MAX];
+ DB_ENV *dbenv = 0;
+ int r;
+
+ if (db_env_create(&dbenv, 0))
+ {
+ perror("db_env_create");
+ return 0;
+ }
+#if defined(FEDORA) && (DB_VERSION_MAJOR >= 5 || (DB_VERSION_MAJOR == 4 && DB_VERSION_MINOR >= 5))
+ dbenv->set_thread_count(dbenv, 8);
+#endif
+ snprintf(dbpath, PATH_MAX, "%s/var/lib/rpm", rootdir ? rootdir : "");
+ if (access(dbpath, W_OK) == -1)
+ {
+ r = dbenv->open(dbenv, dbpath, DB_CREATE|DB_PRIVATE|DB_INIT_MPOOL, 0);
+ }
+ else
+ {
+#ifdef FEDORA
+ r = dbenv->open(dbenv, dbpath, DB_CREATE|DB_INIT_CDB|DB_INIT_MPOOL, 0644);
+#else
+ r = dbenv->open(dbenv, dbpath, DB_CREATE|DB_PRIVATE|DB_INIT_MPOOL, 0);
+#endif
+ }
+ if (r)
+ {
+ perror("dbenv open");
+ dbenv->close(dbenv, 0);
+ return 0;
+ }
+ return dbenv;
+}
+
+
static int
count_headers(const char *rootdir, DB_ENV *dbenv)
{
char dbpath[PATH_MAX];
struct stat statbuf;
- int byteswapped;
DB *db = 0;
DBC *dbc = 0;
int count = 0;
DBT dbkey;
DBT dbdata;
- snprintf(dbpath, PATH_MAX, "%s/var/lib/rpm/Name", rootdir);
+ snprintf(dbpath, PATH_MAX, "%s/var/lib/rpm/Name", rootdir ? rootdir : "");
if (stat(dbpath, &statbuf))
return 0;
memset(&dbkey, 0, sizeof(dbkey));
if (db_create(&db, dbenv, 0))
{
perror("db_create");
- exit(1);
+ return 0;
}
if (db->open(db, 0, "Name", 0, DB_UNKNOWN, DB_RDONLY, 0664))
{
perror("db->open Name index");
- exit(1);
- }
- if (db->get_byteswapped(db, &byteswapped))
- {
- perror("db->get_byteswapped");
- exit(1);
+ return 0;
}
if (db->cursor(db, NULL, &dbc, 0))
{
perror("db->cursor");
- exit(1);
+ return 0;
}
while (dbc->c_get(dbc, &dbkey, &dbdata, DB_NEXT) == 0)
- count += dbdata.size >> 3;
+ count += dbdata.size / RPM_INDEX_SIZE;
dbc->c_close(dbc);
db->close(db, 0);
return count;
*
*/
-void
-repo_add_rpmdb(Repo *repo, Repo *ref, const char *rootdir, int flags)
+int
+repo_add_rpmdb(Repo *repo, Repo *ref, int flags)
{
Pool *pool = repo->pool;
unsigned char buf[16];
DBC *dbc = 0;
int byteswapped;
unsigned int dbid;
- unsigned char *dp, *dbidp;
+ unsigned char *dp;
int dl, nrpmids;
struct rpmid *rpmids, *rp;
int i;
Repodata *data;
int count = 0, done = 0;
unsigned int now;
+ const char *rootdir = 0;
- now = sat_timems(0);
+ now = solv_timems(0);
memset(&dbkey, 0, sizeof(dbkey));
memset(&dbdata, 0, sizeof(dbdata));
- if (!rootdir)
- rootdir = "";
-
- if (!(flags & REPO_REUSE_REPODATA))
- data = repo_add_repodata(repo, 0);
- else
- data = repo_last_repodata(repo);
+ data = repo_add_repodata(repo, flags);
if (ref && !(ref->nsolvables && ref->rpmdbid))
ref = 0;
- if (db_env_create(&dbenv, 0))
- {
- perror("db_env_create");
- exit(1);
- }
- snprintf(dbpath, PATH_MAX, "%s/var/lib/rpm", rootdir);
- /* should look in /usr/lib/rpm/macros instead, but we want speed... */
-#ifdef FEDORA
- if (dbenv->open(dbenv, dbpath, DB_CREATE|DB_INIT_CDB|DB_INIT_MPOOL, 0))
-#else
- if (dbenv->open(dbenv, dbpath, DB_CREATE|DB_PRIVATE|DB_INIT_MPOOL, 0))
-#endif
+ if (flags & REPO_USE_ROOTDIR)
+ rootdir = pool_get_rootdir(pool);
+ if (!(dbenv = opendbenv(rootdir)))
{
- perror("dbenv open");
- exit(1);
+ return pool_error(pool, -1, "repo_add_rpmdb: opendbenv failed");
}
/* XXX: should get ro lock of Packages database! */
- snprintf(dbpath, PATH_MAX, "%s/var/lib/rpm/Packages", rootdir);
+ snprintf(dbpath, PATH_MAX, "%s/var/lib/rpm/Packages", rootdir ? rootdir : "");
if (stat(dbpath, &packagesstat))
{
- perror(dbpath);
- exit(1);
+ pool_error(pool, -1, "repo_add_rpmdb: %s: %s", dbpath, strerror(errno));
+ dbenv->close(dbenv, 0);
+ return -1;
}
mkrpmdbcookie(&packagesstat, newcookie);
repodata_set_bin_checksum(data, SOLVID_META, REPOSITORY_RPMDBCOOKIE, REPOKEY_TYPE_SHA256, newcookie);
count = count_headers(rootdir, dbenv);
if (db_create(&db, dbenv, 0))
{
- perror("db_create");
- exit(1);
+ pool_error(pool, -1, "repo_add_rpmdb: db_create: %s", strerror(errno));
+ dbenv->close(dbenv, 0);
+ return -1;
}
if (db->open(db, 0, "Packages", 0, DB_UNKNOWN, DB_RDONLY, 0664))
{
- perror("db->open Packages index");
- exit(1);
+ pool_error(pool, -1, "repo_add_rpmdb: db->open Packages index failed: %s", strerror(errno));
+ db->close(db, 0);
+ dbenv->close(dbenv, 0);
+ return -1;
}
if (db->get_byteswapped(db, &byteswapped))
{
- perror("db->get_byteswapped");
- exit(1);
+ db->close(db, 0);
+ dbenv->close(dbenv, 0);
+ return pool_error(pool, -1, "repo_add_rpmdb: db->get_byteswapped failed");
}
if (db->cursor(db, NULL, &dbc, 0))
{
- perror("db->cursor");
- exit(1);
+ db->close(db, 0);
+ dbenv->close(dbenv, 0);
+ return pool_error(pool, -1, "repo_add_rpmdb: db->cursor failed");
}
- dbidp = (unsigned char *)&dbid;
rpmheadsize = 0;
rpmhead = 0;
i = 0;
repo->rpmdbid = repo_sidedata_create(repo, sizeof(Id));
if (dbkey.size != 4)
{
- fprintf(stderr, "corrupt Packages database (key size)\n");
- exit(1);
- }
- dp = dbkey.data;
- if (byteswapped)
- {
- dbidp[0] = dp[3];
- dbidp[1] = dp[2];
- dbidp[2] = dp[1];
- dbidp[3] = dp[0];
+ dbc->c_close(dbc);
+ db->close(db, 0);
+ dbenv->close(dbenv, 0);
+ return pool_error(pool, -1, "corrupt Packages database (key size)");
}
- else
- memcpy(dbidp, dp, 4);
+ dbid = db2rpmdbid(dbkey.data, byteswapped);
if (dbid == 0) /* the join key */
continue;
if (dbdata.size < 8)
{
- fprintf(stderr, "corrupt rpm database (size %u)\n", dbdata.size);
- exit(1);
+ dbc->c_close(dbc);
+ db->close(db, 0);
+ dbenv->close(dbenv, 0);
+ return pool_error(pool, -1, "corrupt rpm database (size %u)\n", dbdata.size);
}
if (dbdata.size > rpmheadsize)
{
rpmheadsize = dbdata.size + 128;
- rpmhead = sat_realloc(rpmhead, sizeof(*rpmhead) + rpmheadsize);
+ rpmhead = solv_realloc(rpmhead, sizeof(*rpmhead) + rpmheadsize);
}
memcpy(buf, dbdata.data, 8);
+ rpmhead->forcebinary = 1;
rpmhead->cnt = buf[0] << 24 | buf[1] << 16 | buf[2] << 8 | buf[3];
rpmhead->dcnt = buf[4] << 24 | buf[5] << 16 | buf[6] << 8 | buf[7];
if (8 + rpmhead->cnt * 16 + rpmhead->dcnt > dbdata.size)
{
- fprintf(stderr, "corrupt rpm database (data size)\n");
- exit(1);
+ dbc->c_close(dbc);
+ db->close(db, 0);
+ dbenv->close(dbenv, 0);
+ return pool_error(pool, -1, "corrupt rpm database (data size)\n");
}
memcpy(rpmhead->data, (unsigned char *)dbdata.data + 8, rpmhead->cnt * 16 + rpmhead->dcnt);
rpmhead->dp = rpmhead->data + rpmhead->cnt * 16;
repo->rpmdbid[(s - pool->solvables) - repo->start] = dbid;
- if (rpm2solv(pool, repo, data, s, rpmhead, flags))
+ if (rpm2solv(pool, repo, data, s, rpmhead, flags | RPM_ADD_TRIGGERS))
{
i++;
s = 0;
if (done < count)
done++;
if (done < count && (done - 1) * 100 / count != done * 100 / count)
- pool_debug(pool, SAT_ERROR, "%%%% %d\n", done * 100 / count);
+ pool_debug(pool, SOLV_ERROR, "%%%% %d\n", done * 100 / count);
}
}
if (s)
{
/* oops, could not reuse. free it instead */
- repo_free_solvable_block(repo, s - pool->solvables, 1, 1);
+ repo_free_solvable(repo, s - pool->solvables, 1);
solvend--;
s = 0;
}
/* now sort all solvables in the new solvstart..solvend block */
if (solvend - solvstart > 1)
{
- pkgids = sat_malloc2(solvend - solvstart, sizeof(Id));
+ pkgids = solv_malloc2(solvend - solvstart, sizeof(Id));
for (i = solvstart; i < solvend; i++)
pkgids[i - solvstart] = i;
- sat_sort(pkgids, solvend - solvstart, sizeof(Id), pkgids_sort_cmp, repo);
+ solv_sort(pkgids, solvend - solvstart, sizeof(Id), pkgids_sort_cmp, repo);
/* adapt order */
for (i = solvstart; i < solvend; i++)
{
if (j != i)
swap_solvables(repo, data, i, j);
}
- sat_free(pkgids);
+ solv_free(pkgids);
}
}
else
memset(dircache, 0, sizeof(dircache));
if (db_create(&db, dbenv, 0))
{
- perror("db_create");
- exit(1);
+ pool_error(pool, -1, "repo_add_rpmdb: db_create: %s", strerror(errno));
+ dbenv->close(dbenv, 0);
+ return -1;
}
if (db->open(db, 0, "Name", 0, DB_UNKNOWN, DB_RDONLY, 0664))
{
- perror("db->open Name index");
- exit(1);
+ pool_error(pool, -1, "repo_add_rpmdb: db->open Name index failed: %s", strerror(errno));
+ db->close(db, 0);
+ dbenv->close(dbenv, 0);
+ return -1;
}
if (db->get_byteswapped(db, &byteswapped))
{
- perror("db->get_byteswapped");
- exit(1);
+ db->close(db, 0);
+ dbenv->close(dbenv, 0);
+ return pool_error(pool, -1, "repo_add_rpmdb: db->get_byteswapped failed");
}
if (db->cursor(db, NULL, &dbc, 0))
{
- perror("db->cursor");
- exit(1);
+ db->close(db, 0);
+ dbenv->close(dbenv, 0);
+ return pool_error(pool, -1, "repo_add_rpmdb: db->cursor failed");
}
- dbidp = (unsigned char *)&dbid;
nrpmids = 0;
rpmids = 0;
while (dbc->c_get(dbc, &dbkey, &dbdata, DB_NEXT) == 0)
continue;
dl = dbdata.size;
dp = dbdata.data;
- while(dl >= 8)
+ while(dl >= RPM_INDEX_SIZE)
{
- if (byteswapped)
- {
- dbidp[0] = dp[3];
- dbidp[1] = dp[2];
- dbidp[2] = dp[1];
- dbidp[3] = dp[0];
- }
- else
- memcpy(dbidp, dp, 4);
- rpmids = sat_extend(rpmids, nrpmids, 1, sizeof(*rpmids), 255);
- rpmids[nrpmids].dbid = dbid;
- rpmids[nrpmids].name = sat_malloc((int)dbkey.size + 1);
+ rpmids = solv_extend(rpmids, nrpmids, 1, sizeof(*rpmids), 255);
+ rpmids[nrpmids].dbid = db2rpmdbid(dp, byteswapped);
+ rpmids[nrpmids].name = solv_malloc((int)dbkey.size + 1);
memcpy(rpmids[nrpmids].name, dbkey.data, (int)dbkey.size);
rpmids[nrpmids].name[(int)dbkey.size] = 0;
nrpmids++;
- dp += 8;
- dl -= 8;
+ dp += RPM_INDEX_SIZE;
+ dl -= RPM_INDEX_SIZE;
}
}
dbc->c_close(dbc);
db = 0;
/* sort rpmids */
- sat_sort(rpmids, nrpmids, sizeof(*rpmids), rpmids_sort_cmp, 0);
+ solv_sort(rpmids, nrpmids, sizeof(*rpmids), rpmids_sort_cmp, 0);
- dbidp = (unsigned char *)&dbid;
rpmheadsize = 0;
rpmhead = 0;
/* create hash from dbid to ref */
refmask = mkmask(ref->nsolvables);
- refhash = sat_calloc(refmask + 1, sizeof(Id));
+ refhash = solv_calloc(refmask + 1, sizeof(Id));
for (i = 0; i < ref->end - ref->start; i++)
{
if (!ref->rpmdbid[i])
for (i = 0, rp = rpmids; i < nrpmids; i++, rp++, s++)
{
dbid = rp->dbid;
- repo->rpmdbid[(s - pool->solvables) - repo->start] = dbid;
+ repo->rpmdbid[(s - pool->solvables) - repo->start] = rp->dbid;
if (refhash)
{
h = dbid & refmask;
{
if (db_create(&db, dbenv, 0))
{
- perror("db_create");
- exit(1);
+ pool_error(pool, -1, "repo_add_rpmdb: db_create: %s", strerror(errno));
+ dbenv->close(dbenv, 0);
+ return -1;
}
if (db->open(db, 0, "Packages", 0, DB_UNKNOWN, DB_RDONLY, 0664))
{
- perror("db->open var/lib/rpm/Packages");
- exit(1);
+ pool_error(pool, -1, "repo_add_rpmdb: db->open Packages index failed: %s", strerror(errno));
+ db->close(db, 0);
+ dbenv->close(dbenv, 0);
+ return -1;
}
if (db->get_byteswapped(db, &byteswapped))
{
- perror("db->get_byteswapped");
- exit(1);
+ db->close(db, 0);
+ dbenv->close(dbenv, 0);
+ return pool_error(pool, -1, "repo_add_rpmdb: db->get_byteswapped failed");
}
}
- if (byteswapped)
- {
- buf[0] = dbidp[3];
- buf[1] = dbidp[2];
- buf[2] = dbidp[1];
- buf[3] = dbidp[0];
- }
- else
- memcpy(buf, dbidp, 4);
+ rpmdbid2db(buf, rp->dbid, byteswapped);
dbkey.data = buf;
dbkey.size = 4;
dbdata.data = 0;
dbdata.size = 0;
if (db->get(db, NULL, &dbkey, &dbdata, 0))
{
- perror("db->get");
- fprintf(stderr, "corrupt rpm database, key %d not found\n", dbid);
- fprintf(stderr, "please run 'rpm --rebuilddb' to recreate the database index files\n");
- exit(1);
+ db->close(db, 0);
+ dbenv->close(dbenv, 0);
+ return pool_error(pool, -1, "inconsistent rpm database, key %d not found. run 'rpm --rebuilddb' to fix.", dbid);
}
if (dbdata.size < 8)
{
- fprintf(stderr, "corrupt rpm database (size)\n");
- exit(1);
+ db->close(db, 0);
+ dbenv->close(dbenv, 0);
+ return pool_error(pool, -1, "corrupt Packages database (size)");
}
if (dbdata.size > rpmheadsize)
{
rpmheadsize = dbdata.size + 128;
- rpmhead = sat_realloc(rpmhead, sizeof(*rpmhead) + rpmheadsize);
+ rpmhead = solv_realloc(rpmhead, sizeof(*rpmhead) + rpmheadsize);
}
memcpy(buf, dbdata.data, 8);
+ rpmhead->forcebinary = 1;
rpmhead->cnt = buf[0] << 24 | buf[1] << 16 | buf[2] << 8 | buf[3];
rpmhead->dcnt = buf[4] << 24 | buf[5] << 16 | buf[6] << 8 | buf[7];
if (8 + rpmhead->cnt * 16 + rpmhead->dcnt > dbdata.size)
{
- fprintf(stderr, "corrupt rpm database (data size)\n");
- exit(1);
+ db->close(db, 0);
+ dbenv->close(dbenv, 0);
+ return pool_error(pool, -1, "corrupt Packages database (data size)");
}
memcpy(rpmhead->data, (unsigned char *)dbdata.data + 8, rpmhead->cnt * 16 + rpmhead->dcnt);
rpmhead->dp = rpmhead->data + rpmhead->cnt * 16;
- rpm2solv(pool, repo, data, s, rpmhead, flags);
+ rpm2solv(pool, repo, data, s, rpmhead, flags | RPM_ADD_TRIGGERS);
if ((flags & RPMDB_REPORT_PROGRESS) != 0)
{
if (done < count)
done++;
if (done < count && (done - 1) * 100 / count != done * 100 / count)
- pool_debug(pool, SAT_ERROR, "%%%% %d\n", done * 100 / count);
+ pool_debug(pool, SOLV_ERROR, "%%%% %d\n", done * 100 / count);
}
}
if (refhash)
- sat_free(refhash);
+ solv_free(refhash);
if (rpmids)
{
for (i = 0; i < nrpmids; i++)
- sat_free(rpmids[i].name);
- sat_free(rpmids);
+ solv_free(rpmids[i].name);
+ solv_free(rpmids);
}
}
if (db)
db->close(db, 0);
dbenv->close(dbenv, 0);
if (rpmhead)
- sat_free(rpmhead);
+ solv_free(rpmhead);
if (!(flags & REPO_NO_INTERNALIZE))
repodata_internalize(data);
if ((flags & RPMDB_REPORT_PROGRESS) != 0)
- pool_debug(pool, SAT_ERROR, "%%%% 100\n");
- POOL_DEBUG(SAT_DEBUG_STATS, "repo_add_rpmdb took %d ms\n", sat_timems(now));
- POOL_DEBUG(SAT_DEBUG_STATS, "repo size: %d solvables\n", repo->nsolvables);
- POOL_DEBUG(SAT_DEBUG_STATS, "repo memory used: %d K incore, %d K idarray\n", data->incoredatalen/1024, repo->idarraysize / (int)(1024/sizeof(Id)));
+ pool_debug(pool, SOLV_ERROR, "%%%% 100\n");
+ POOL_DEBUG(SOLV_DEBUG_STATS, "repo_add_rpmdb took %d ms\n", solv_timems(now));
+ POOL_DEBUG(SOLV_DEBUG_STATS, "repo size: %d solvables\n", repo->nsolvables);
+ POOL_DEBUG(SOLV_DEBUG_STATS, "repo memory used: %d K incore, %d K idarray\n", repodata_memused(data)/1024, repo->idarraysize / (int)(1024/sizeof(Id)));
+ return 0;
}
static inline unsigned int
-getu32(unsigned char *dp)
+getu32(const unsigned char *dp)
{
return dp[0] << 24 | dp[1] << 16 | dp[2] << 8 | dp[3];
}
-void
-repo_add_rpms(Repo *repo, const char **rpms, int nrpms, int flags)
+Id
+repo_add_rpm(Repo *repo, const char *rpm, int flags)
{
- int i, sigdsize, sigcnt, l;
+ unsigned int sigdsize, sigcnt, l;
Pool *pool = repo->pool;
Solvable *s;
RpmHead *rpmhead = 0;
struct stat stb;
Repodata *data;
unsigned char pkgid[16];
- int gotpkgid;
+ unsigned char leadsigid[16];
+ unsigned char hdrid[32];
+ int pkgidtype, leadsigidtype, hdridtype;
Id chksumtype = 0;
void *chksumh = 0;
+ void *leadsigchksumh = 0;
+ int forcebinary = 0;
- if (!(flags & REPO_REUSE_REPODATA))
- data = repo_add_repodata(repo, 0);
- else
- data = repo_last_repodata(repo);
+ data = repo_add_repodata(repo, flags);
if ((flags & RPM_ADD_WITH_SHA256SUM) != 0)
chksumtype = REPOKEY_TYPE_SHA256;
else if ((flags & RPM_ADD_WITH_SHA1SUM) != 0)
chksumtype = REPOKEY_TYPE_SHA1;
- for (i = 0; i < nrpms; i++)
+
+ if ((fp = fopen(flags & REPO_USE_ROOTDIR ? pool_prepend_rootdir_tmp(pool, rpm) : rpm, "r")) == 0)
{
- if ((fp = fopen(rpms[i], "r")) == 0)
- {
- perror(rpms[i]);
- continue;
- }
- if (fstat(fileno(fp), &stb))
+ pool_error(pool, -1, "%s: %s", rpm, strerror(errno));
+ return 0;
+ }
+ if (fstat(fileno(fp), &stb))
+ {
+ pool_error(pool, -1, "fstat: %s", strerror(errno));
+ fclose(fp);
+ return 0;
+ }
+ if (chksumtype)
+ chksumh = solv_chksum_create(chksumtype);
+ if ((flags & RPM_ADD_WITH_LEADSIGID) != 0)
+ leadsigchksumh = solv_chksum_create(REPOKEY_TYPE_MD5);
+ if (fread(lead, 96 + 16, 1, fp) != 1 || getu32(lead) != 0xedabeedb)
+ {
+ pool_error(pool, -1, "%s: not a rpm", rpm);
+ fclose(fp);
+ return 0;
+ }
+ forcebinary = lead[6] != 0 || lead[7] != 1;
+ if (chksumh)
+ solv_chksum_add(chksumh, lead, 96 + 16);
+ if (leadsigchksumh)
+ solv_chksum_add(leadsigchksumh, lead, 96 + 16);
+ if (lead[78] != 0 || lead[79] != 5)
+ {
+ pool_error(pool, -1, "%s: not a rpm v5 header", rpm);
+ fclose(fp);
+ return 0;
+ }
+ if (getu32(lead + 96) != 0x8eade801)
+ {
+ pool_error(pool, -1, "%s: bad signature header", rpm);
+ fclose(fp);
+ return 0;
+ }
+ sigcnt = getu32(lead + 96 + 8);
+ sigdsize = getu32(lead + 96 + 12);
+ if (sigcnt >= 0x100000 || sigdsize >= 0x100000)
+ {
+ pool_error(pool, -1, "%s: bad signature header", rpm);
+ fclose(fp);
+ return 0;
+ }
+ sigdsize += sigcnt * 16;
+ sigdsize = (sigdsize + 7) & ~7;
+ headerstart = 96 + 16 + sigdsize;
+ pkgidtype = leadsigidtype = hdridtype = 0;
+ if ((flags & (RPM_ADD_WITH_PKGID | RPM_ADD_WITH_HDRID)) != 0)
+ {
+ /* extract pkgid or hdrid from the signature header */
+ if (sigdsize > rpmheadsize)
{
- perror("stat");
- continue;
+ rpmheadsize = sigdsize + 128;
+ rpmhead = solv_realloc(rpmhead, sizeof(*rpmhead) + rpmheadsize);
}
- if (chksumh)
- chksumh = sat_chksum_free(chksumh, 0);
- if (chksumtype)
- chksumh = sat_chksum_create(chksumtype);
- if (fread(lead, 96 + 16, 1, fp) != 1 || getu32(lead) != 0xedabeedb)
+ if (fread(rpmhead->data, sigdsize, 1, fp) != 1)
{
- fprintf(stderr, "%s: not a rpm\n", rpms[i]);
+ pool_error(pool, -1, "%s: unexpected EOF", rpm);
fclose(fp);
- continue;
+ return 0;
}
if (chksumh)
- sat_chksum_add(chksumh, lead, 96 + 16);
- if (lead[78] != 0 || lead[79] != 5)
- {
- fprintf(stderr, "%s: not a V5 header\n", rpms[i]);
- fclose(fp);
- continue;
- }
- if (getu32(lead + 96) != 0x8eade801)
- {
- fprintf(stderr, "%s: bad signature header\n", rpms[i]);
- fclose(fp);
- continue;
- }
- sigcnt = getu32(lead + 96 + 8);
- sigdsize = getu32(lead + 96 + 12);
- if (sigcnt >= 0x4000000 || sigdsize >= 0x40000000)
- {
- fprintf(stderr, "%s: bad signature header\n", rpms[i]);
- fclose(fp);
- continue;
- }
- sigdsize += sigcnt * 16;
- sigdsize = (sigdsize + 7) & ~7;
- headerstart = 96 + 16 + sigdsize;
- gotpkgid = 0;
+ solv_chksum_add(chksumh, rpmhead->data, sigdsize);
+ if (leadsigchksumh)
+ solv_chksum_add(leadsigchksumh, rpmhead->data, sigdsize);
+ rpmhead->forcebinary = 0;
+ rpmhead->cnt = sigcnt;
+ rpmhead->dcnt = sigdsize - sigcnt * 16;
+ rpmhead->dp = rpmhead->data + rpmhead->cnt * 16;
if ((flags & RPM_ADD_WITH_PKGID) != 0)
{
unsigned char *chksum;
unsigned int chksumsize;
- /* extract pkgid from the signature header */
- if (sigdsize > rpmheadsize)
- {
- rpmheadsize = sigdsize + 128;
- rpmhead = sat_realloc(rpmhead, sizeof(*rpmhead) + rpmheadsize);
- }
- if (fread(rpmhead->data, sigdsize, 1, fp) != 1)
- {
- fprintf(stderr, "%s: unexpected EOF\n", rpms[i]);
- fclose(fp);
- continue;
- }
- if (chksumh)
- sat_chksum_add(chksumh, rpmhead->data, sigdsize);
- rpmhead->cnt = sigcnt;
- rpmhead->dcnt = sigdsize - sigcnt * 16;
- rpmhead->dp = rpmhead->data + rpmhead->cnt * 16;
chksum = headbinary(rpmhead, SIGTAG_MD5, &chksumsize);
if (chksum && chksumsize == 16)
{
- gotpkgid = 1;
+ pkgidtype = REPOKEY_TYPE_MD5;
memcpy(pkgid, chksum, 16);
}
}
- else
+ if ((flags & RPM_ADD_WITH_HDRID) != 0)
{
- /* just skip the signature header */
- while (sigdsize)
+ const char *str = headstring(rpmhead, TAG_SHA1HEADER);
+ if (str && strlen(str) == 40)
{
- l = sigdsize > 4096 ? 4096 : sigdsize;
- if (fread(lead, l, 1, fp) != 1)
- {
- fprintf(stderr, "%s: unexpected EOF\n", rpms[i]);
- fclose(fp);
- continue;
- }
- if (chksumh)
- sat_chksum_add(chksumh, lead, l);
- sigdsize -= l;
+ if (solv_hex2bin(&str, hdrid, 20) == 20)
+ hdridtype = REPOKEY_TYPE_SHA1;
+ }
+ else if (str && strlen(str) == 64)
+ {
+ if (solv_hex2bin(&str, hdrid, 32) == 32)
+ hdridtype = REPOKEY_TYPE_SHA256;
}
}
- if (fread(lead, 16, 1, fp) != 1)
- {
- fprintf(stderr, "%s: unexpected EOF\n", rpms[i]);
- fclose(fp);
- continue;
- }
- if (chksumh)
- sat_chksum_add(chksumh, lead, 16);
- if (getu32(lead) != 0x8eade801)
- {
- fprintf(stderr, "%s: bad header\n", rpms[i]);
- fclose(fp);
- continue;
- }
- sigcnt = getu32(lead + 8);
- sigdsize = getu32(lead + 12);
- if (sigcnt >= 0x4000000 || sigdsize >= 0x40000000)
- {
- fprintf(stderr, "%s: bad header\n", rpms[i]);
- fclose(fp);
- continue;
- }
- l = sigdsize + sigcnt * 16;
- headerend = headerstart + 16 + l;
- if (l > rpmheadsize)
+ }
+ else
+ {
+ /* just skip the signature header */
+ while (sigdsize)
{
- rpmheadsize = l + 128;
- rpmhead = sat_realloc(rpmhead, sizeof(*rpmhead) + rpmheadsize);
+ l = sigdsize > 4096 ? 4096 : sigdsize;
+ if (fread(lead, l, 1, fp) != 1)
+ {
+ pool_error(pool, -1, "%s: unexpected EOF", rpm);
+ fclose(fp);
+ return 0;
+ }
+ if (chksumh)
+ solv_chksum_add(chksumh, lead, l);
+ if (leadsigchksumh)
+ solv_chksum_add(leadsigchksumh, lead, l);
+ sigdsize -= l;
}
- if (fread(rpmhead->data, l, 1, fp) != 1)
- {
- fprintf(stderr, "%s: unexpected EOF\n", rpms[i]);
- fclose(fp);
- continue;
- }
- if (chksumh)
- sat_chksum_add(chksumh, rpmhead->data, l);
- rpmhead->cnt = sigcnt;
- rpmhead->dcnt = sigdsize;
- rpmhead->dp = rpmhead->data + rpmhead->cnt * 16;
- if (headexists(rpmhead, TAG_PATCHESNAME))
- {
- /* this is a patch rpm, ignore */
- fclose(fp);
- continue;
- }
- payloadformat = headstring(rpmhead, TAG_PAYLOADFORMAT);
- if (payloadformat && !strcmp(payloadformat, "drpm"))
- {
- /* this is a delta rpm */
- fclose(fp);
- continue;
- }
- if (chksumh)
- while ((l = fread(lead, 1, sizeof(lead), fp)) > 0)
- sat_chksum_add(chksumh, lead, l);
+ }
+ if (leadsigchksumh)
+ {
+ leadsigchksumh = solv_chksum_free(leadsigchksumh, leadsigid);
+ leadsigidtype = REPOKEY_TYPE_MD5;
+ }
+ if (fread(lead, 16, 1, fp) != 1)
+ {
+ pool_error(pool, -1, "%s: unexpected EOF", rpm);
fclose(fp);
- s = pool_id2solvable(pool, repo_add_solvable(repo));
- rpm2solv(pool, repo, data, s, rpmhead, flags);
- if (data)
- {
- Id handle = s - pool->solvables;
- repodata_set_location(data, handle, 0, 0, rpms[i]);
- if (S_ISREG(stb.st_mode))
- repodata_set_num(data, handle, SOLVABLE_DOWNLOADSIZE, (unsigned int)((stb.st_size + 1023) / 1024));
- repodata_set_num(data, handle, SOLVABLE_HEADEREND, headerend);
- if (gotpkgid)
- repodata_set_bin_checksum(data, handle, SOLVABLE_PKGID, REPOKEY_TYPE_MD5, pkgid);
- if (chksumh)
- repodata_set_bin_checksum(data, handle, SOLVABLE_CHECKSUM, chksumtype, sat_chksum_get(chksumh, 0));
- }
+ return 0;
+ }
+ if (chksumh)
+ solv_chksum_add(chksumh, lead, 16);
+ if (getu32(lead) != 0x8eade801)
+ {
+ pool_error(pool, -1, "%s: bad header", rpm);
+ fclose(fp);
+ return 0;
+ }
+ sigcnt = getu32(lead + 8);
+ sigdsize = getu32(lead + 12);
+ if (sigcnt >= 0x100000 || sigdsize >= 0x2000000)
+ {
+ pool_error(pool, -1, "%s: bad header", rpm);
+ fclose(fp);
+ return 0;
+ }
+ l = sigdsize + sigcnt * 16;
+ headerend = headerstart + 16 + l;
+ if (l > rpmheadsize)
+ {
+ rpmheadsize = l + 128;
+ rpmhead = solv_realloc(rpmhead, sizeof(*rpmhead) + rpmheadsize);
+ }
+ if (fread(rpmhead->data, l, 1, fp) != 1)
+ {
+ pool_error(pool, -1, "%s: unexpected EOF", rpm);
+ fclose(fp);
+ return 0;
}
if (chksumh)
- chksumh = sat_chksum_free(chksumh, 0);
+ solv_chksum_add(chksumh, rpmhead->data, l);
+ rpmhead->forcebinary = forcebinary;
+ rpmhead->cnt = sigcnt;
+ rpmhead->dcnt = sigdsize;
+ rpmhead->dp = rpmhead->data + rpmhead->cnt * 16;
+ if (headexists(rpmhead, TAG_PATCHESNAME))
+ {
+ /* this is a patch rpm, ignore */
+ pool_error(pool, -1, "%s: is patch rpm", rpm);
+ fclose(fp);
+ solv_chksum_free(chksumh, 0);
+ solv_free(rpmhead);
+ return 0;
+ }
+ payloadformat = headstring(rpmhead, TAG_PAYLOADFORMAT);
+ if (payloadformat && !strcmp(payloadformat, "drpm"))
+ {
+ /* this is a delta rpm */
+ pool_error(pool, -1, "%s: is delta rpm", rpm);
+ fclose(fp);
+ solv_chksum_free(chksumh, 0);
+ solv_free(rpmhead);
+ return 0;
+ }
+ if (chksumh)
+ while ((l = fread(lead, 1, sizeof(lead), fp)) > 0)
+ solv_chksum_add(chksumh, lead, l);
+ fclose(fp);
+ s = pool_id2solvable(pool, repo_add_solvable(repo));
+ if (!rpm2solv(pool, repo, data, s, rpmhead, flags & ~(RPM_ADD_WITH_HDRID | RPM_ADD_WITH_PKGID)))
+ {
+ repo_free_solvable(repo, s - pool->solvables, 1);
+ solv_chksum_free(chksumh, 0);
+ solv_free(rpmhead);
+ return 0;
+ }
+ if (!(flags & REPO_NO_LOCATION))
+ repodata_set_location(data, s - pool->solvables, 0, 0, rpm);
+ if (S_ISREG(stb.st_mode))
+ repodata_set_num(data, s - pool->solvables, SOLVABLE_DOWNLOADSIZE, (unsigned long long)stb.st_size);
+ repodata_set_num(data, s - pool->solvables, SOLVABLE_HEADEREND, headerend);
+ if (pkgidtype)
+ repodata_set_bin_checksum(data, s - pool->solvables, SOLVABLE_PKGID, pkgidtype, pkgid);
+ if (hdridtype)
+ repodata_set_bin_checksum(data, s - pool->solvables, SOLVABLE_HDRID, hdridtype, hdrid);
+ if (leadsigidtype)
+ repodata_set_bin_checksum(data, s - pool->solvables, SOLVABLE_LEADSIGID, leadsigidtype, leadsigid);
+ if (chksumh)
+ {
+ repodata_set_bin_checksum(data, s - pool->solvables, SOLVABLE_CHECKSUM, chksumtype, solv_chksum_get(chksumh, 0));
+ chksumh = solv_chksum_free(chksumh, 0);
+ }
if (rpmhead)
- sat_free(rpmhead);
+ solv_free(rpmhead);
if (!(flags & REPO_NO_INTERNALIZE))
repodata_internalize(data);
+ return s - pool->solvables;
+}
+
+Id
+repo_add_rpm_handle(Repo *repo, void *rpmhandle, int flags)
+{
+ Pool *pool = repo->pool;
+ Repodata *data;
+ RpmHead *rpmhead = rpmhandle;
+ Solvable *s;
+ char *payloadformat;
+
+ data = repo_add_repodata(repo, flags);
+ if (headexists(rpmhead, TAG_PATCHESNAME))
+ {
+ pool_error(pool, -1, "is a patch rpm");
+ return 0;
+ }
+ payloadformat = headstring(rpmhead, TAG_PAYLOADFORMAT);
+ if (payloadformat && !strcmp(payloadformat, "drpm"))
+ {
+ /* this is a delta rpm */
+ pool_error(pool, -1, "is a delta rpm");
+ return 0;
+ }
+ s = pool_id2solvable(pool, repo_add_solvable(repo));
+ if (!rpm2solv(pool, repo, data, s, rpmhead, flags))
+ {
+ repo_free_solvable(repo, s - pool->solvables, 1);
+ return 0;
+ }
+ if (!(flags & REPO_NO_INTERNALIZE))
+ repodata_internalize(data);
+ return s - pool->solvables;
}
static inline void
char **md = 0;
char **lt = 0;
unsigned int *di, diidx;
+ unsigned int *co = 0;
+ unsigned int *ff = 0;
unsigned int lastdir;
int lastdirl;
unsigned int *fm;
{
for (i = 0; i < dcnt; i++)
(*cb)(cbdata, dn[i], 0, (char *)0);
- sat_free(dn);
+ solv_free(dn);
return;
}
bn = headstringarray(rpmhead, TAG_BASENAMES, &cnt);
if (!bn)
{
- sat_free(dn);
+ solv_free(dn);
return;
}
di = headint32array(rpmhead, TAG_DIRINDEXES, &cnt2);
if (!di || cnt != cnt2)
{
- sat_free(di);
- sat_free(bn);
- sat_free(dn);
+ solv_free(di);
+ solv_free(bn);
+ solv_free(dn);
return;
}
fm = headint16array(rpmhead, TAG_FILEMODES, &cnt2);
if (!fm || cnt != cnt2)
{
- sat_free(fm);
- sat_free(di);
- sat_free(bn);
- sat_free(dn);
+ solv_free(fm);
+ solv_free(di);
+ solv_free(bn);
+ solv_free(dn);
return;
}
if ((flags & RPM_ITERATE_FILELIST_WITHMD5) != 0)
md = headstringarray(rpmhead, TAG_FILEMD5S, &cnt2);
if (!md || cnt != cnt2)
{
- sat_free(md);
- sat_free(fm);
- sat_free(di);
- sat_free(bn);
- sat_free(dn);
+ solv_free(md);
+ solv_free(fm);
+ solv_free(di);
+ solv_free(bn);
+ solv_free(dn);
+ return;
+ }
+ }
+ if ((flags & RPM_ITERATE_FILELIST_WITHCOL) != 0)
+ {
+ co = headint32array(rpmhead, TAG_FILECOLORS, &cnt2);
+ if (!co || cnt != cnt2)
+ {
+ solv_free(co);
+ solv_free(md);
+ solv_free(fm);
+ solv_free(di);
+ solv_free(bn);
+ solv_free(dn);
+ return;
+ }
+ }
+ if ((flags & RPM_ITERATE_FILELIST_NOGHOSTS) != 0)
+ {
+ ff = headint32array(rpmhead, TAG_FILEFLAGS, &cnt2);
+ if (!ff || cnt != cnt2)
+ {
+ solv_free(ff);
+ solv_free(co);
+ solv_free(md);
+ solv_free(fm);
+ solv_free(di);
+ solv_free(bn);
+ solv_free(dn);
return;
}
}
lastdirl = 0;
for (i = 0; i < cnt; i++)
{
+ if (ff && (ff[i] & FILEFLAG_GHOST) != 0)
+ continue;
diidx = di[i];
if (diidx >= dcnt)
continue;
if (l > spacen)
{
spacen = l + 16;
- space = sat_realloc(space, spacen);
+ space = solv_realloc(space, spacen);
}
if (lastdir != diidx)
{
{
lt = headstringarray(rpmhead, TAG_FILELINKTOS, &cnt2);
if (cnt != cnt2)
- lt = sat_free(lt);
+ lt = solv_free(lt);
}
if (lt)
{
}
}
if (!md5p)
- md5p = "";
+ {
+ sprintf(md5, "%08x%08x%08x%08x", (fm[i] >> 12) & 65535, 0, 0, 0);
+ md5p = md5;
+ }
}
- (*cb)(cbdata, space, fm[i], md5p);
- }
- sat_free(space);
- sat_free(lt);
- sat_free(md);
- sat_free(fm);
- sat_free(di);
- sat_free(bn);
- sat_free(dn);
+ (*cb)(cbdata, space, co ? (fm[i] | co[i] << 24) : fm[i], md5p);
+ }
+ solv_free(space);
+ solv_free(lt);
+ solv_free(md);
+ solv_free(fm);
+ solv_free(di);
+ solv_free(bn);
+ solv_free(dn);
+ solv_free(co);
+ solv_free(ff);
+}
+
+char *
+rpm_query(void *rpmhandle, Id what)
+{
+ const char *name, *arch, *sourcerpm;
+ char *evr, *r;
+ int l;
+
+ RpmHead *rpmhead = rpmhandle;
+ r = 0;
+ switch (what)
+ {
+ case 0:
+ name = headstring(rpmhead, TAG_NAME);
+ if (!name)
+ name = "";
+ sourcerpm = headstring(rpmhead, TAG_SOURCERPM);
+ if (sourcerpm || (rpmhead->forcebinary && !headexists(rpmhead, TAG_SOURCEPACKAGE)))
+ arch = headstring(rpmhead, TAG_ARCH);
+ else
+ {
+ if (headexists(rpmhead, TAG_NOSOURCE) || headexists(rpmhead, TAG_NOPATCH))
+ arch = "nosrc";
+ else
+ arch = "src";
+ }
+ if (!arch)
+ arch = "noarch";
+ evr = headtoevr(rpmhead);
+ l = strlen(name) + 1 + strlen(evr ? evr : "") + 1 + strlen(arch) + 1;
+ r = solv_malloc(l);
+ sprintf(r, "%s-%s.%s", name, evr ? evr : "", arch);
+ solv_free(evr);
+ break;
+ case SOLVABLE_NAME:
+ name = headstring(rpmhead, TAG_NAME);
+ r = solv_strdup(name);
+ break;
+ case SOLVABLE_EVR:
+ r = headtoevr(rpmhead);
+ break;
+ }
+ return r;
}
int rpmheadsize;
int dbopened;
+ char *rootdir;
DB_ENV *dbenv;
DB *db;
int byteswapped;
#define ENTRIES_BLOCK 255
#define NAMEDATA_BLOCK 1023
-static int
-opendbenv(struct rpm_by_state *state, const char *rootdir)
-{
- char dbpath[PATH_MAX];
-
- if (state->dbenv)
- return 1;
- if (db_env_create(&state->dbenv, 0))
- {
- perror("db_env_create");
- return 0;
- }
- snprintf(dbpath, PATH_MAX, "%s/var/lib/rpm", rootdir ? rootdir : "");
-#ifdef FEDORA
- if (state->dbenv->open(state->dbenv, dbpath, DB_CREATE|DB_INIT_CDB|DB_INIT_MPOOL, 0))
-#else
- if (state->dbenv->open(state->dbenv, dbpath, DB_CREATE|DB_PRIVATE|DB_INIT_MPOOL, 0))
-#endif
- {
- perror("dbenv open");
- state->dbenv->close(state->dbenv, 0);
- return 0;
- }
- return 1;
-}
-
-#define FLAGS_GET_PUBKEYS 1
-
-struct rpmdbentry *
-getinstalledrpmdbids(struct rpm_by_state *state, int *nentriesp, char **namedatap, int flags)
+static struct rpmdbentry *
+getinstalledrpmdbids(struct rpm_by_state *state, const char *index, const char *match, int *nentriesp, char **namedatap)
{
DB_ENV *dbenv = 0;
DB *db = 0;
int byteswapped;
DBT dbkey;
DBT dbdata;
- Id rpmdbid;
unsigned char *dp;
int dl;
+ Id nameoff;
char *namedata = 0;
int namedatal = 0;
int nentries = 0;
*nentriesp = 0;
- *namedatap = 0;
+ if (namedatap)
+ *namedatap = 0;
+ if (!state->dbenv && !(state->dbenv = opendbenv(state->rootdir)))
+ return 0;
dbenv = state->dbenv;
if (db_create(&db, dbenv, 0))
{
perror("db_create");
return 0;
}
- if (db->open(db, 0, "Name", 0, DB_UNKNOWN, DB_RDONLY, 0664))
+ if (db->open(db, 0, index, 0, DB_UNKNOWN, DB_RDONLY, 0664))
{
- perror("db->open Name index");
+ perror("db->open index");
db->close(db, 0);
return 0;
}
}
memset(&dbkey, 0, sizeof(dbkey));
memset(&dbdata, 0, sizeof(dbdata));
- while (dbc->c_get(dbc, &dbkey, &dbdata, DB_NEXT) == 0)
+ if (match)
{
- if ((flags & FLAGS_GET_PUBKEYS))
- {
- if (dbkey.size != 10 || memcmp(dbkey.data, "gpg-pubkey", 10))
- continue;
- }
- else
- {
- if (dbkey.size == 10 && !memcmp(dbkey.data, "gpg-pubkey", 10))
- continue;
- }
+ dbkey.data = (void *)match;
+ dbkey.size = strlen(match);
+ }
+ while (dbc->c_get(dbc, &dbkey, &dbdata, match ? DB_SET : DB_NEXT) == 0)
+ {
+ if (!match && dbkey.size == 10 && !memcmp(dbkey.data, "gpg-pubkey", 10))
+ continue;
dl = dbdata.size;
dp = dbdata.data;
- while(dl >= 8)
+ nameoff = namedatal;
+ if (namedatap)
{
- if (byteswapped)
- {
- ((char *)&rpmdbid)[0] = dp[3];
- ((char *)&rpmdbid)[1] = dp[2];
- ((char *)&rpmdbid)[2] = dp[1];
- ((char *)&rpmdbid)[3] = dp[0];
- }
- else
- memcpy((char *)&rpmdbid, dp, 4);
- entries = sat_extend(entries, nentries, 1, sizeof(*entries), ENTRIES_BLOCK);
- entries[nentries].rpmdbid = rpmdbid;
- entries[nentries].nameoff = namedatal;
- nentries++;
- namedata = sat_extend(namedata, namedatal, dbkey.size + 1, 1, NAMEDATA_BLOCK);
+ namedata = solv_extend(namedata, namedatal, dbkey.size + 1, 1, NAMEDATA_BLOCK);
memcpy(namedata + namedatal, dbkey.data, dbkey.size);
namedata[namedatal + dbkey.size] = 0;
namedatal += dbkey.size + 1;
- dp += 8;
- dl -= 8;
}
+ while(dl >= RPM_INDEX_SIZE)
+ {
+ entries = solv_extend(entries, nentries, 1, sizeof(*entries), ENTRIES_BLOCK);
+ entries[nentries].rpmdbid = db2rpmdbid(dp, byteswapped);
+ entries[nentries].nameoff = nameoff;
+ nentries++;
+ dp += RPM_INDEX_SIZE;
+ dl -= RPM_INDEX_SIZE;
+ }
+ if (match)
+ break;
}
dbc->c_close(dbc);
db->close(db, 0);
*nentriesp = nentries;
- *namedatap = namedata;
+ if (namedatap)
+ *namedatap = namedata;
return entries;
}
+static int
+openpkgdb(struct rpm_by_state *state, const char *rootdir)
+{
+ if (state->dbopened)
+ return state->dbopened > 0 ? 1 : 0;
+ state->dbopened = -1;
+ if (!state->dbenv && !(state->dbenv = opendbenv(rootdir)))
+ return 0;
+ if (db_create(&state->db, state->dbenv, 0))
+ {
+ perror("db_create");
+ state->db = 0;
+ state->dbenv->close(state->dbenv, 0);
+ state->dbenv = 0;
+ return 0;
+ }
+ if (state->db->open(state->db, 0, "Packages", 0, DB_UNKNOWN, DB_RDONLY, 0664))
+ {
+ perror("db->open var/lib/rpm/Packages");
+ state->db->close(state->db, 0);
+ state->db = 0;
+ state->dbenv->close(state->dbenv, 0);
+ state->dbenv = 0;
+ return 0;
+ }
+ if (state->db->get_byteswapped(state->db, &state->byteswapped))
+ {
+ perror("db->get_byteswapped");
+ state->db->close(state->db, 0);
+ state->db = 0;
+ state->dbenv->close(state->dbenv, 0);
+ state->dbenv = 0;
+ return 0;
+ }
+ state->dbopened = 1;
+ return 1;
+}
+
+static void
+freestate(struct rpm_by_state *state)
+{
+ /* close down */
+ if (!state)
+ return;
+ if (state->rootdir)
+ solv_free(state->rootdir);
+ if (state->db)
+ state->db->close(state->db, 0);
+ if (state->dbenv)
+ state->dbenv->close(state->dbenv, 0);
+ solv_free(state->rpmhead);
+}
+
+void *
+rpm_state_create(const char *rootdir)
+{
+ struct rpm_by_state *state;
+ state = solv_calloc(1, sizeof(*state));
+ if (rootdir)
+ state->rootdir = solv_strdup(rootdir);
+ return state;
+}
+
+void *
+rpm_state_free(void *state)
+{
+ freestate(state);
+ return solv_free(state);
+}
+
int
-rpm_installedrpmdbids(const char *rootdir, Queue *rpmdbidq)
+rpm_installedrpmdbids(void *rpmstate, const char *index, const char *match, Queue *rpmdbidq)
{
- struct rpm_by_state state;
+ struct rpm_by_state *state = rpmstate;
struct rpmdbentry *entries;
int nentries, i;
- char *namedata;
+ if (!index)
+ index = "Name";
if (rpmdbidq)
queue_empty(rpmdbidq);
- memset(&state, 0, sizeof(state));
- if (!opendbenv(&state, rootdir))
- return 0;
- entries = getinstalledrpmdbids(&state, &nentries, &namedata, 0);
+ entries = getinstalledrpmdbids(state, index, match, &nentries, 0);
if (rpmdbidq)
for (i = 0; i < nentries; i++)
queue_push(rpmdbidq, entries[i].rpmdbid);
- sat_free(entries);
- sat_free(namedata);
- rpm_byrpmdbid(0, 0, (void **)&state);
+ solv_free(entries);
return nentries;
}
void *
-rpm_byrpmdbid(Id rpmdbid, const char *rootdir, void **statep)
+rpm_byrpmdbid(void *rpmstate, Id rpmdbid)
{
- struct rpm_by_state *state = *statep;
+ struct rpm_by_state *state = rpmstate;
unsigned char buf[16];
DBT dbkey;
DBT dbdata;
RpmHead *rpmhead;
- if (!rpmdbid)
- {
- /* close down */
- if (!state)
- return 0;
- if (state->db)
- state->db->close(state->db, 0);
- if (state->dbenv)
- state->dbenv->close(state->dbenv, 0);
- sat_free(state->rpmhead);
- sat_free(state);
- *statep = (void *)0;
- return 0;
- }
-
- if (!state)
- {
- state = sat_calloc(1, sizeof(*state));
- *statep = state;
- }
- if (!state->dbopened)
- {
- state->dbopened = 1;
- if (!opendbenv(state, rootdir))
- return 0;
- if (db_create(&state->db, state->dbenv, 0))
- {
- perror("db_create");
- state->db = 0;
- state->dbenv->close(state->dbenv, 0);
- state->dbenv = 0;
- return 0;
- }
- if (state->db->open(state->db, 0, "Packages", 0, DB_UNKNOWN, DB_RDONLY, 0664))
- {
- perror("db->open var/lib/rpm/Packages");
- state->db->close(state->db, 0);
- state->db = 0;
- state->dbenv->close(state->dbenv, 0);
- state->dbenv = 0;
- return 0;
- }
- if (state->db->get_byteswapped(state->db, &state->byteswapped))
- {
- perror("db->get_byteswapped");
- state->db->close(state->db, 0);
- state->db = 0;
- state->dbenv->close(state->dbenv, 0);
- state->dbenv = 0;
- return 0;
- }
- }
- memcpy(buf, &rpmdbid, 4);
- if (state->byteswapped)
- {
- unsigned char bx;
- bx = buf[0]; buf[0] = buf[3]; buf[3] = bx;
- bx = buf[1]; buf[1] = buf[2]; buf[2] = bx;
- }
+ if (!state->dbopened && !openpkgdb(state, state->rootdir))
+ return 0;
+ rpmdbid2db(buf, rpmdbid, state->byteswapped);
memset(&dbkey, 0, sizeof(dbkey));
memset(&dbdata, 0, sizeof(dbdata));
dbkey.data = buf;
if (dbdata.size > state->rpmheadsize)
{
state->rpmheadsize = dbdata.size + 128;
- state->rpmhead = sat_realloc(state->rpmhead, sizeof(*rpmhead) + state->rpmheadsize);
+ state->rpmhead = solv_realloc(state->rpmhead, sizeof(*rpmhead) + state->rpmheadsize);
}
rpmhead = state->rpmhead;
memcpy(buf, dbdata.data, 8);
+ rpmhead->forcebinary = 1;
rpmhead->cnt = buf[0] << 24 | buf[1] << 16 | buf[2] << 8 | buf[3];
rpmhead->dcnt = buf[4] << 24 | buf[5] << 16 | buf[6] << 8 | buf[7];
if (8 + rpmhead->cnt * 16 + rpmhead->dcnt > dbdata.size)
rpmhead->dp = rpmhead->data + rpmhead->cnt * 16;
return rpmhead;
}
-
+
void *
-rpm_byfp(FILE *fp, const char *name, void **statep)
+rpm_byfp(void *rpmstate, FILE *fp, const char *name)
{
- struct rpm_by_state *state = *statep;
- int headerstart, headerend;
+ struct rpm_by_state *state = rpmstate;
+ /* int headerstart, headerend; */
RpmHead *rpmhead;
- int sigdsize, sigcnt, l;
+ unsigned int sigdsize, sigcnt, l;
unsigned char lead[4096];
+ int forcebinary = 0;
- if (!fp)
- return rpm_byrpmdbid(0, 0, statep);
- if (!state)
- {
- state = sat_calloc(1, sizeof(*state));
- *statep = state;
- }
if (fread(lead, 96 + 16, 1, fp) != 1 || getu32(lead) != 0xedabeedb)
{
fprintf(stderr, "%s: not a rpm\n", name);
return 0;
}
+ forcebinary = lead[6] != 0 || lead[7] != 1;
if (lead[78] != 0 || lead[79] != 5)
{
fprintf(stderr, "%s: not a V5 header\n", name);
}
sigcnt = getu32(lead + 96 + 8);
sigdsize = getu32(lead + 96 + 12);
- if (sigcnt >= 0x4000000 || sigdsize >= 0x40000000)
+ if (sigcnt >= 0x100000 || sigdsize >= 0x100000)
{
fprintf(stderr, "%s: bad signature header\n", name);
return 0;
}
sigdsize += sigcnt * 16;
sigdsize = (sigdsize + 7) & ~7;
- headerstart = 96 + 16 + sigdsize;
+ /* headerstart = 96 + 16 + sigdsize; */
while (sigdsize)
{
l = sigdsize > 4096 ? 4096 : sigdsize;
}
sigcnt = getu32(lead + 8);
sigdsize = getu32(lead + 12);
- if (sigcnt >= 0x4000000 || sigdsize >= 0x40000000)
+ if (sigcnt >= 0x100000 || sigdsize >= 0x2000000)
{
fprintf(stderr, "%s: bad header\n", name);
fclose(fp);
return 0;
}
l = sigdsize + sigcnt * 16;
- headerend = headerstart + 16 + l;
+ /* headerend = headerstart + 16 + l; */
if (l > state->rpmheadsize)
{
state->rpmheadsize = l + 128;
- state->rpmhead = sat_realloc(state->rpmhead, sizeof(*state->rpmhead) + state->rpmheadsize);
+ state->rpmhead = solv_realloc(state->rpmhead, sizeof(*state->rpmhead) + state->rpmheadsize);
}
rpmhead = state->rpmhead;
if (fread(rpmhead->data, l, 1, fp) != 1)
fclose(fp);
return 0;
}
+ rpmhead->forcebinary = forcebinary;
rpmhead->cnt = sigcnt;
rpmhead->dcnt = sigdsize;
rpmhead->dp = rpmhead->data + rpmhead->cnt * 16;
return rpmhead;
}
+#ifdef ENABLE_RPMDB_BYRPMHEADER
+
+void *
+rpm_byrpmh(void *rpmstate, Header h)
+{
+ struct rpm_by_state *state = rpmstate;
+ const unsigned char *uh;
+ unsigned int sigdsize, sigcnt, l;
+ RpmHead *rpmhead;
+
+#ifndef RPM5
+ uh = headerUnload(h);
+#else
+ uh = headerUnload(h, NULL);
+#endif
+ if (!uh)
+ return 0;
+ sigcnt = getu32(uh);
+ sigdsize = getu32(uh + 4);
+ l = sigdsize + sigcnt * 16;
+ if (l > state->rpmheadsize)
+ {
+ state->rpmheadsize = l + 128;
+ state->rpmhead = solv_realloc(state->rpmhead, sizeof(*state->rpmhead) + state->rpmheadsize);
+ }
+ rpmhead = state->rpmhead;
+ memcpy(rpmhead->data, uh + 8, l - 8);
+ free((void *)uh);
+ rpmhead->forcebinary = 0;
+ rpmhead->cnt = sigcnt;
+ rpmhead->dcnt = sigdsize;
+ rpmhead->dp = rpmhead->data + rpmhead->cnt * 16;
+ return rpmhead;
+}
+
+#endif
+
+
+#ifdef ENABLE_RPMDB_PUBKEY
static char *
r64dec1(char *p, unsigned int *vp, int *eofp)
return p;
}
-static unsigned int
+static unsigned int
crc24(unsigned char *p, int len)
{
unsigned int crc = 0xb704ceL;
if (!p)
return 0;
l = p - pubkey;
- bp = buf = sat_malloc(l * 3 / 4 + 4);
+ bp = buf = solv_malloc(l * 3 / 4 + 4);
eof = 0;
while (!eof)
{
pubkey = r64dec1(pubkey, &v, &eof);
if (!pubkey)
{
- sat_free(buf);
+ solv_free(buf);
return 0;
}
*bp++ = v >> 16;
bp -= eof;
if (*pubkey != '=' || (pubkey = r64dec1(pubkey + 1, &v, &eof)) == 0)
{
- sat_free(buf);
+ solv_free(buf);
return 0;
}
if (v != crc24(buf, bp - buf))
{
- sat_free(buf);
+ solv_free(buf);
return 0;
}
while (*pubkey == ' ' || *pubkey == '\t' || *pubkey == '\n' || *pubkey == '\r')
pubkey++;
if (strncmp(pubkey, "-----END PGP PUBLIC KEY BLOCK-----", 34) != 0)
{
- sat_free(buf);
+ solv_free(buf);
return 0;
}
*pktlp = bp - buf;
unsigned char keyid[8];
unsigned int kcr = 0, maxex = 0;
unsigned char *pubkey = 0;
- int pubkeyl = 0;
unsigned char *userid = 0;
+#if 0
+ int pubkeyl = 0;
int useridl = 0;
+#endif
for (; pl; p += l, pl -= l)
{
}
else if (x == 255)
{
- if (pl <= 4)
+ /* sanity: p[0] must be zero */
+ if (pl <= 4 || p[0] != 0)
return;
- l = p[0] << 24 | p[1] << 16 | p[2] << 8 | p[3];
+ l = p[1] << 16 | p[2] << 8 | p[3];
p += 4;
pl -= 4;
}
return;
if (tag == 6)
{
- pubkey = sat_realloc(pubkey, l);
+ pubkey = solv_realloc(pubkey, l);
if (l)
memcpy(pubkey, p, l);
+#if 0
pubkeyl = l;
+#endif
kcr = 0;
if (p[0] == 3)
{
ql = ((p[8] << 8 | p[9]) + 7) / 8;
memcpy(keyid, p + 10 + ql - 8, 8);
- h = sat_chksum_create(REPOKEY_TYPE_MD5);
- sat_chksum_add(h, p + 10, ql);
+ h = solv_chksum_create(REPOKEY_TYPE_MD5);
+ solv_chksum_add(h, p + 10, ql);
q = p + 10 + ql;
ql = ((q[0] << 8 | q[1]) + 7) / 8;
- sat_chksum_add(h, q + 2, ql);
- sat_chksum_free(h, fp);
+ solv_chksum_add(h, q + 2, ql);
+ solv_chksum_free(h, fp);
for (i = 0; i < 16; i++)
sprintf(fpx + i * 2, "%02x", fp[i]);
- setutf8string(data, s - s->repo->pool->solvables, PUBKEY_FINGERPRINT, fpx);
+ repodata_set_str(data, s - s->repo->pool->solvables, PUBKEY_FINGERPRINT, fpx);
}
}
else if (p[0] == 4)
hdr[0] = 0x99;
hdr[1] = l >> 8;
hdr[2] = l;
- h = sat_chksum_create(REPOKEY_TYPE_SHA1);
- sat_chksum_add(h, hdr, 3);
- sat_chksum_add(h, p, l);
- sat_chksum_free(h, fp);
+ h = solv_chksum_create(REPOKEY_TYPE_SHA1);
+ solv_chksum_add(h, hdr, 3);
+ solv_chksum_add(h, p, l);
+ solv_chksum_free(h, fp);
for (i = 0; i < 20; i++)
sprintf(fpx + i * 2, "%02x", fp[i]);
- setutf8string(data, s - s->repo->pool->solvables, PUBKEY_FINGERPRINT, fpx);
+ repodata_set_str(data, s - s->repo->pool->solvables, PUBKEY_FINGERPRINT, fpx);
memcpy(keyid, fp + 12, 8);
}
}
#if 0
Id htype = 0;
#endif
- // printf("V3 signature packet\n");
+ /* printf("V3 signature packet\n"); */
+ if (l < 17)
+ continue;
if (p[2] != 0x10 && p[2] != 0x11 && p[2] != 0x12 && p[2] != 0x13 && p[2] != 0x1f)
continue;
if (!memcmp(keyid, p + 6, 8))
{
- // printf("SELF SIG\n");
+ /* printf("SELF SIG\n"); */
}
else
{
- // printf("OTHER SIG\n");
+ /* printf("OTHER SIG\n"); */
}
#if 0
if (p[16] == 1)
htype = REPOKEY_TYPE_SHA256;
if (htype)
{
- void *h = sat_chksum_create(htype);
+ void *h = solv_chksum_create(htype);
unsigned char b[3], *cs;
b[0] = 0x99;
b[1] = pubkeyl >> 8;
b[2] = pubkeyl;
- sat_chksum_add(h, b, 3);
- sat_chksum_add(h, pubkey, pubkeyl);
+ solv_chksum_add(h, b, 3);
+ solv_chksum_add(h, pubkey, pubkeyl);
if (p[2] >= 0x10 && p[2] <= 0x13)
- sat_chksum_add(h, userid, useridl);
- sat_chksum_add(h, p + 2, 5);
- cs = sat_chksum_get(h, 0);
- sat_chksum_free(h, 0);
+ solv_chksum_add(h, userid, useridl);
+ solv_chksum_add(h, p + 2, 5);
+ cs = solv_chksum_get(h, 0);
+ solv_chksum_free(h, 0);
}
#endif
}
{
int j, ql, haveissuer;
unsigned char *q;
- unsigned int ex = 0, scr = 0;
+ unsigned int ex = 0;
+#if 0
+ unsigned int scr = 0;
+#endif
unsigned char issuer[8];
- // printf("V4 signature packet\n");
+ /* printf("V4 signature packet\n"); */
+ if (l < 6)
+ continue;
if (p[1] != 0x10 && p[1] != 0x11 && p[1] != 0x12 && p[1] != 0x13 && p[1] != 0x1f)
continue;
haveissuer = 0;
q = p + 4;
for (j = 0; q && j < 2; j++)
{
+ if (q + 2 > p + l)
+ {
+ q = 0;
+ break;
+ }
ql = q[0] << 8 | q[1];
q += 2;
+ if (q + ql > p + l)
+ {
+ q = 0;
+ break;
+ }
while (ql)
{
int sl;
sl = x;
else if (x == 255)
{
- if (ql < 4)
+ if (ql < 4 || q[0] != 0)
{
q = 0;
break;
}
- sl = q[0] << 24 | q[1] << 16 | q[2] << 8 | q[3];
+ sl = q[1] << 16 | q[2] << 8 | q[3];
q += 4;
ql -= 4;
}
break;
}
x = q[0] & 127;
- // printf("%d SIGSUB %d %d\n", j, x, sl);
+ /* printf("%d SIGSUB %d %d\n", j, x, sl); */
if (x == 16 && sl == 9 && !haveissuer)
{
memcpy(issuer, q + 1, 8);
haveissuer = 1;
}
+#if 0
if (x == 2 && j == 0)
scr = q[1] << 24 | q[2] << 16 | q[3] << 8 | q[4];
+#endif
if (x == 9 && j == 0)
ex = q[1] << 24 | q[2] << 16 | q[3] << 8 | q[4];
q += sl;
htype = REPOKEY_TYPE_SHA256;
if (htype && pubkeyl)
{
- void *h = sat_chksum_create(htype);
+ void *h = solv_chksum_create(htype);
unsigned char b[6], *cs;
unsigned int hl;
b[0] = 0x99;
b[1] = pubkeyl >> 8;
b[2] = pubkeyl;
- sat_chksum_add(h, b, 3);
- sat_chksum_add(h, pubkey, pubkeyl);
+ solv_chksum_add(h, b, 3);
+ solv_chksum_add(h, pubkey, pubkeyl);
if (p[1] >= 0x10 && p[1] <= 0x13)
{
b[0] = 0xb4;
b[2] = useridl >> 16;
b[3] = useridl >> 8;
b[4] = useridl;
- sat_chksum_add(h, b, 5);
- sat_chksum_add(h, userid, useridl);
+ solv_chksum_add(h, b, 5);
+ solv_chksum_add(h, userid, useridl);
}
hl = 6 + (p[4] << 8 | p[5]);
- sat_chksum_add(h, p, hl);
+ solv_chksum_add(h, p, hl);
b[0] = 4;
b[1] = 0xff;
b[2] = hl >> 24;
b[3] = hl >> 16;
b[4] = hl >> 8;
b[5] = hl;
- sat_chksum_add(h, b, 6);
- cs = sat_chksum_get(h, 0);
- sat_chksum_free(h, 0);
+ solv_chksum_add(h, b, 6);
+ cs = solv_chksum_get(h, 0);
+ solv_chksum_free(h, 0);
}
#endif
if (!memcmp(keyid, issuer, 8))
{
- // printf("SELF SIG cr %d ex %d\n", cr, ex);
+ /* printf("SELF SIG cr %d ex %d\n", cr, ex); */
if (ex > maxex)
maxex = ex;
}
else
{
- // printf("OTHER SIG cr %d ex %d\n", cr, ex);
+ /* printf("OTHER SIG cr %d ex %d\n", cr, ex); */
}
}
}
}
if (tag == 13)
{
- userid = sat_realloc(userid, l);
+ userid = solv_realloc(userid, l);
if (l)
memcpy(userid, p, l);
+#if 0
useridl = l;
+#endif
}
}
if (maxex)
repodata_set_num(data, s - s->repo->pool->solvables, PUBKEY_EXPIRES, maxex);
- sat_free(pubkey);
- sat_free(userid);
+ solv_free(pubkey);
+ solv_free(userid);
}
/* this is private to rpm, but rpm lacks an interface to retrieve
* the values. Sigh. */
struct pgpDigParams_s {
const char * userid;
- const byte * hash;
+ const unsigned char * hash;
const char * params[4];
- byte tag;
- byte version; /*!< version number. */
- byte time[4]; /*!< time that the key was created. */
- byte pubkey_algo; /*!< public key algorithm. */
- byte hash_algo;
- byte sigtype;
- byte hashlen;
- byte signhash16[2];
- byte signid[8];
- byte saved;
+ unsigned char tag;
+ unsigned char version; /*!< version number. */
+ unsigned char time[4]; /*!< time that the key was created. */
+ unsigned char pubkey_algo; /*!< public key algorithm. */
+ unsigned char hash_algo;
+ unsigned char sigtype;
+ unsigned char hashlen;
+ unsigned char signhash16[2];
+ unsigned char signid[8];
+ unsigned char saved;
};
struct pgpDig_s {
return 0;
setutf8string(data, s - s->repo->pool->solvables, SOLVABLE_DESCRIPTION, pubkey);
parsekeydata(s, data, pkts, pktsl);
+ /* only rpm knows how to do the release calculation, we don't dare
+ * to recreate all the bugs */
+#ifndef RPM5
dig = pgpNewDig();
+#else
+ dig = pgpDigNew(RPMVSF_DEFAULT, 0);
+#endif
(void) pgpPrtPkts(pkts, pktsl, dig, 0);
btime = dig->pubkey.time[0] << 24 | dig->pubkey.time[1] << 16 | dig->pubkey.time[2] << 8 | dig->pubkey.signid[3];
sprintf(evrbuf, "%02x%02x%02x%02x-%02x%02x%02x%02x", dig->pubkey.signid[4], dig->pubkey.signid[5], dig->pubkey.signid[6], dig->pubkey.signid[7], dig->pubkey.time[0], dig->pubkey.time[1], dig->pubkey.time[2], dig->pubkey.time[3]);
repodata_set_num(data, s - s->repo->pool->solvables, SOLVABLE_BUILDTIME, btime);
- s->name = str2id(pool, "gpg-pubkey", 1);
- s->evr = str2id(pool, evrbuf, 1);
+
+ s->name = pool_str2id(pool, "gpg-pubkey", 1);
+ s->evr = pool_str2id(pool, evrbuf, 1);
s->arch = 1;
for (i = 0; i < 8; i++)
sprintf(keyid + 2 * i, "%02x", dig->pubkey.signid[i]);
repodata_set_str(data, s - s->repo->pool->solvables, PUBKEY_KEYID, keyid);
if (dig->pubkey.userid)
setutf8string(data, s - s->repo->pool->solvables, SOLVABLE_SUMMARY, dig->pubkey.userid);
- pgpFreeDig(dig);
- sat_free((void *)pkts);
+#ifndef RPM5
+ (void)pgpFreeDig(dig);
+#else
+ (void)pgpDigFree(dig);
+#endif
+ solv_free((void *)pkts);
return 1;
}
-void
-repo_add_rpmdb_pubkeys(Repo *repo, const char *rootdir, int flags)
+int
+repo_add_rpmdb_pubkeys(Repo *repo, int flags)
{
Pool *pool = repo->pool;
struct rpm_by_state state;
struct rpmdbentry *entries;
int nentries, i;
- char *namedata, *str;
+ char *str;
unsigned int u32;
Repodata *data;
Solvable *s;
+ const char *rootdir = 0;
- if (!(flags & REPO_REUSE_REPODATA))
- data = repo_add_repodata(repo, 0);
- else
- data = repo_last_repodata(repo);
+ data = repo_add_repodata(repo, flags);
+ if (flags & REPO_USE_ROOTDIR)
+ rootdir = pool_get_rootdir(pool);
memset(&state, 0, sizeof(state));
- if (!opendbenv(&state, rootdir))
- return;
- entries = getinstalledrpmdbids(&state, &nentries, &namedata, FLAGS_GET_PUBKEYS);
+ if (!(state.dbenv = opendbenv(rootdir)))
+ return 0;
+ entries = getinstalledrpmdbids(&state, "Name", "gpg-pubkey", &nentries, 0);
for (i = 0 ; i < nentries; i++)
{
- RpmHead *rpmhead = rpm_byrpmdbid(entries[i].rpmdbid, rootdir, (void **)&state);
+ RpmHead *rpmhead = rpm_byrpmdbid(&state, entries[i].rpmdbid);
if (!rpmhead)
continue;
str = headstring(rpmhead, TAG_DESCRIPTION);
repo->rpmdbid = repo_sidedata_create(repo, sizeof(Id));
repo->rpmdbid[s - pool->solvables - repo->start] = entries[i].rpmdbid;
}
- rpm_byrpmdbid(0, 0, (void **)&state);
+ solv_free(entries);
+ freestate(&state);
if (!(flags & REPO_NO_INTERNALIZE))
repodata_internalize(data);
+ return 0;
}
-void
-repo_add_pubkeys(Repo *repo, const char **keys, int nkeys, int flags)
+Id
+repo_add_pubkey(Repo *repo, const char *key, int flags)
{
Pool *pool = repo->pool;
Repodata *data;
Solvable *s;
char *buf;
- int i, bufl, l, ll;
+ int bufl, l, ll;
FILE *fp;
- if (!(flags & REPO_REUSE_REPODATA))
- data = repo_add_repodata(repo, 0);
- else
- data = repo_last_repodata(repo);
+ data = repo_add_repodata(repo, flags);
buf = 0;
bufl = 0;
- for (i = 0; i < nkeys; i++)
+ if ((fp = fopen(flags & REPO_USE_ROOTDIR ? pool_prepend_rootdir_tmp(pool, key) : key, "r")) == 0)
{
- if ((fp = fopen(keys[i], "r")) == 0)
+ pool_error(pool, -1, "%s: %s", key, strerror(errno));
+ return 0;
+ }
+ for (l = 0; ;)
+ {
+ if (bufl - l < 4096)
{
- perror(keys[i]);
- continue;
+ bufl += 4096;
+ buf = solv_realloc(buf, bufl);
}
- for (l = 0; ;)
+ ll = fread(buf, 1, bufl - l, fp);
+ if (ll < 0)
{
- if (bufl - l < 4096)
- {
- buf = sat_realloc(buf, bufl + 4096);
- bufl += 4096;
- }
- ll = fread(buf, 1, bufl - l, fp);
- if (ll <= 0)
- break;
- l += ll;
+ fclose(fp);
+ pool_error(pool, -1, "%s: %s", key, strerror(errno));
+ return 0;
}
- buf[l] = 0;
- s = pool_id2solvable(pool, repo_add_solvable(repo));
- pubkey2solvable(s, data, buf);
+ if (ll == 0)
+ break;
+ l += ll;
}
- sat_free(buf);
+ buf[l] = 0;
+ fclose(fp);
+ s = pool_id2solvable(pool, repo_add_solvable(repo));
+ if (!pubkey2solvable(s, data, buf))
+ {
+ repo_free_solvable(repo, s - pool->solvables, 1);
+ solv_free(buf);
+ return 0;
+ }
+ solv_free(buf);
+ if (!(flags & REPO_NO_INTERNALIZE))
+ repodata_internalize(data);
+ return s - pool->solvables;
}
+
+#endif /* ENABLE_RPMDB_PUBKEY */
projects / platform / upstream / libsolv.git / blobdiff