/*
- * 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>
#include <rpm/rpmio.h>
#include <rpm/rpmpgp.h>
+#ifndef RPM5
#include <rpm/header.h>
+#endif
#include <rpm/rpmdb.h>
#ifndef DB_CREATE
#include "repo_rpmdb.h"
/* 3: added triggers */
-#define RPMDB_COOKIE_VERSION 3
+/* 4: fixed triggers */
+#define RPMDB_COOKIE_VERSION 4
+#define TAG_SIGBASE 256
+#define TAG_SHA1HEADER TAG_SIGBASE+13
#define TAG_NAME 1000
#define TAG_VERSION 1001
#define TAG_RELEASE 1002
#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_ENHANCESVERSION 1160
#define TAG_ENHANCESFLAGS 1161
+/* rpm5 tags */
+#define TAG_DISTEPOCH 1218
+
+/* rpm4 tags */
+#define TAG_LONGFILESIZES 5008
+#define TAG_LONGSIZE 5009
+
#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;
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);
}
v = headstringarray(rpmhead, tagv, &vc);
if (!v)
{
- sat_free(n);
+ solv_free(n);
return 0;
}
f = headint32array(rpmhead, tagf, &fc);
if (!f)
{
- sat_free(n);
+ solv_free(n);
free(v);
return 0;
}
if (nc != vc || nc != fc)
{
fprintf(stderr, "bad dependency entries\n");
- exit(1);
+ return 0;
}
cc = nc;
}
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;
}
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 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(dc, sizeof(unsigned int));
- fkb = sat_calloc(dc, 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 (di[i] >= dc)
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 < dc; i++)
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! */
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)
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)
{
}
#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;
}
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));
+ repodata_set_constantid(data, handle, SOLVABLE_SOURCEARCH, pool_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));
+ repodata_set_id(data, handle, SOLVABLE_SOURCEEVR, pool_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));
+ repodata_set_id(data, handle, SOLVABLE_SOURCENAME, pool_strn2id(pool, sourcerpm, sevr - sourcerpm - 1, 1));
}
static int
name = headstring(rpmhead, TAG_NAME);
if (!strcmp(name, "gpg-pubkey"))
return 0;
- s->name = str2id(pool, name, 1);
+ s->name = pool_str2id(pool, name, 1);
if (!s->name)
{
fprintf(stderr, "package has no name\n");
- exit(1);
+ return 0;
}
sourcerpm = headstring(rpmhead, TAG_SOURCERPM);
if (sourcerpm)
- s->arch = str2id(pool, headstring(rpmhead, TAG_ARCH), 1);
+ 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_HDRID) != 0)
+ {
+ str = headstring(rpmhead, TAG_SHA1HEADER);
+ if (str)
+ repodata_set_poolstr(data, handle, SOLVABLE_HDRID, 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);
if ((flags & RPM_ADD_TRIGGERS) != 0)
}
}
}
- 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)
{
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);
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);
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
{
char dbpath[PATH_MAX];
struct stat statbuf;
- int byteswapped;
DB *db = 0;
DBC *dbc = 0;
int count = 0;
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
+int
repo_add_rpmdb(Repo *repo, Repo *ref, const char *rootdir, int flags)
{
Pool *pool = repo->pool;
DBC *dbc = 0;
int byteswapped;
unsigned int dbid;
- unsigned char *dp, *dbidp;
+ unsigned char *dp;
int dl, nrpmids;
struct rpmid *rpmids, *rp;
int i;
int count = 0, done = 0;
unsigned int now;
- now = sat_timems(0);
+ now = solv_timems(0);
memset(&dbkey, 0, sizeof(dbkey));
memset(&dbdata, 0, sizeof(dbdata));
ref = 0;
if (!(dbenv = opendbenv(rootdir)))
- 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);
if (stat(dbpath, &packagesstat))
{
- perror(dbpath);
- exit(1);
+ return pool_error(pool, -1, "repo_add_rpmdb: %s: %s", dbpath, strerror(errno));
}
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->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;
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->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;
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;
}
}
-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;
+ int sigdsize, sigcnt, l;
Pool *pool = repo->pool;
Solvable *s;
RpmHead *rpmhead = 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(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 (fread(lead, 96 + 16, 1, fp) != 1 || getu32(lead) != 0xedabeedb)
+ {
+ pool_error(pool, -1, "%s: not a rpm", rpm);
+ fclose(fp);
+ return 0;
+ }
+ if (chksumh)
+ solv_chksum_add(chksumh, 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;
+ gotpkgid = 0;
+ if ((flags & RPM_ADD_WITH_PKGID) != 0)
+ {
+ unsigned char *chksum;
+ unsigned int chksumsize;
+ /* extract pkgid 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)
+ solv_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)
{
- fprintf(stderr, "%s: bad signature header\n", rpms[i]);
- fclose(fp);
- continue;
+ gotpkgid = 1;
+ memcpy(pkgid, chksum, 16);
}
- sigdsize += sigcnt * 16;
- sigdsize = (sigdsize + 7) & ~7;
- headerstart = 96 + 16 + sigdsize;
- gotpkgid = 0;
- if ((flags & RPM_ADD_WITH_PKGID) != 0)
+ }
+ else
+ {
+ /* just skip the signature header */
+ while (sigdsize)
{
- 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)
+ l = sigdsize > 4096 ? 4096 : sigdsize;
+ if (fread(lead, l, 1, fp) != 1)
{
- fprintf(stderr, "%s: unexpected EOF\n", rpms[i]);
+ pool_error(pool, -1, "%s: unexpected EOF", rpm);
fclose(fp);
- continue;
+ return 0;
}
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;
- memcpy(pkgid, chksum, 16);
- }
+ solv_chksum_add(chksumh, lead, l);
+ sigdsize -= l;
}
- else
- {
- /* just skip the signature header */
- while (sigdsize)
- {
- 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 (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)
- {
- rpmheadsize = l + 128;
- rpmhead = sat_realloc(rpmhead, sizeof(*rpmhead) + rpmheadsize);
- }
- 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 (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 >= 0x800000)
+ {
+ 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)
+ solv_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 */
+ pool_error(pool, -1, "%s: is patch rpm", rpm);
+ fclose(fp);
+ 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);
+ 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))
+ {
+ repo_free_solvable(repo, s - pool->solvables, 1);
+ return 0;
}
+ 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 (gotpkgid)
+ repodata_set_bin_checksum(data, s - pool->solvables, SOLVABLE_PKGID, REPOKEY_TYPE_MD5, pkgid);
if (chksumh)
- chksumh = sat_chksum_free(chksumh, 0);
+ {
+ 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;
}
static inline void
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;
}
}
co = headint32array(rpmhead, TAG_FILECOLORS, &cnt2);
if (!co || cnt != cnt2)
{
- sat_free(co);
- sat_free(md);
- sat_free(fm);
- sat_free(di);
- sat_free(bn);
- sat_free(dn);
+ 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)
{
- sprintf(md5, "%08x%08x", (fm[i] >> 12) & 65535, 0);
+ sprintf(md5, "%08x%08x%08x%08x", (fm[i] >> 12) & 65535, 0, 0, 0);
md5p = md5;
}
}
(*cb)(cbdata, space, co ? (fm[i] | co[i] << 24) : fm[i], md5p);
}
- sat_free(space);
- sat_free(lt);
- sat_free(md);
- sat_free(fm);
- sat_free(di);
- sat_free(bn);
- sat_free(dn);
- sat_free(co);
+ 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 *
if (!arch)
arch = "noarch";
evr = headtoevr(rpmhead);
+ if (!evr)
+ break;
l = strlen(name) + 1 + strlen(evr) + 1 + strlen(arch) + 1;
- r = sat_malloc(l);
+ r = solv_malloc(l);
sprintf(r, "%s-%s.%s", name, evr, arch);
free(evr);
break;
case SOLVABLE_NAME:
name = headstring(rpmhead, TAG_NAME);
- r = strdup(name);
+ r = solv_strdup(name);
break;
case SOLVABLE_EVR:
r = headtoevr(rpmhead);
int byteswapped;
DBT dbkey;
DBT dbdata;
- Id rpmdbid;
unsigned char *dp;
int dl;
continue;
dl = dbdata.size;
dp = dbdata.data;
- while(dl >= 8)
+ while(dl >= RPM_INDEX_SIZE)
{
- 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 = solv_extend(entries, nentries, 1, sizeof(*entries), ENTRIES_BLOCK);
+ entries[nentries].rpmdbid = db2rpmdbid(dp, byteswapped);
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;
+ dp += RPM_INDEX_SIZE;
+ dl -= RPM_INDEX_SIZE;
}
if (match)
break;
state->db->close(state->db, 0);
if (state->dbenv)
state->dbenv->close(state->dbenv, 0);
- sat_free(state->rpmhead);
+ solv_free(state->rpmhead);
}
int
if (rpmdbidq)
for (i = 0; i < nentries; i++)
queue_push(rpmdbidq, entries[i].rpmdbid);
- sat_free(entries);
- sat_free(namedata);
+ solv_free(entries);
+ solv_free(namedata);
freestate(&state);
return nentries;
}
{
/* close down */
freestate(state);
- sat_free(state);
+ solv_free(state);
*statep = (void *)0;
return 0;
}
if (!state)
{
- state = sat_calloc(1, sizeof(*state));
+ state = solv_calloc(1, sizeof(*state));
*statep = state;
}
if (!state->dbopened)
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;
- }
+ 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);
rpm_byfp(FILE *fp, const char *name, void **statep)
{
struct rpm_by_state *state = *statep;
- int headerstart, headerend;
+ /* int headerstart, headerend; */
RpmHead *rpmhead;
int sigdsize, sigcnt, l;
unsigned char lead[4096];
return rpm_byrpmdbid(0, 0, statep);
if (!state)
{
- state = sat_calloc(1, sizeof(*state));
+ state = solv_calloc(1, sizeof(*state));
*statep = state;
}
if (fread(lead, 96 + 16, 1, fp) != 1 || getu32(lead) != 0xedabeedb)
}
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 >= 0x800000)
{
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)
int sigdsize, sigcnt, l;
RpmHead *rpmhead;
+#ifndef RPM5
uh = headerUnload(h);
+#else
+ uh = headerUnload(h, NULL);
+#endif
if (!uh)
return 0;
sigcnt = getu32(uh);
l = sigdsize + sigcnt * 16;
if (!state)
{
- state = sat_calloc(1, sizeof(*state));
+ state = solv_calloc(1, sizeof(*state));
*statep = state;
}
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;
memcpy(rpmhead->data, uh + 8, l - 8);
}
+#ifdef ENABLE_RPMDB_PUBKEY
+
static char *
r64dec1(char *p, unsigned int *vp, int *eofp)
{
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)
{
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);
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);
#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)
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
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
+int
repo_add_rpmdb_pubkeys(Repo *repo, const char *rootdir, int flags)
{
Pool *pool = repo->pool;
memset(&state, 0, sizeof(state));
if (!(state.dbenv = opendbenv(rootdir)))
- return;
+ return 0;
entries = getinstalledrpmdbids(&state, "Name", "gpg-pubkey", &nentries, &namedata);
for (i = 0 ; i < nentries; i++)
{
repo->rpmdbid = repo_sidedata_create(repo, sizeof(Id));
repo->rpmdbid[s - pool->solvables - repo->start] = entries[i].rpmdbid;
}
+ solv_free(entries);
+ solv_free(namedata);
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;
data = repo_add_repodata(repo, flags);
buf = 0;
bufl = 0;
- for (i = 0; i < nkeys; i++)
+ if ((fp = fopen(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)
- {
- bufl += 4096;
- buf = sat_realloc(buf, bufl);
- }
- 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;
- fclose(fp);
- 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