#include <unistd.h>
#include <assert.h>
#include <stdint.h>
+#include <errno.h>
#include <rpm/rpmio.h>
#include <rpm/rpmpgp.h>
#include <rpm/rpmdb.h>
#ifndef DB_CREATE
-# ifdef FEDORA
-# include <db.h>
-# else
+# if defined(SUSE) || defined(HAVE_RPM_DB_H)
# include <rpm/db.h>
+# else
+# include <db.h>
# endif
#endif
#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_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 */
int cnt;
int dcnt;
unsigned char *dp;
+ int forcebinary; /* sigh */
unsigned char data[1];
} RpmHead;
if (!version || !release)
{
fprintf(stderr, "headtoevr: bad rpm header\n");
- exit(1);
+ return 0;
}
for (v = version; *v >= '0' && *v <= '9'; v++)
;
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)
- {
- solv_free(n);
- return 0;
- }
f = headint32array(rpmhead, tagf, &fc);
- if (!f)
+ 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);
- free(v);
+ 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 */
unsigned int *di;
int bnc, dnc, dic;
int i;
+ Id lastdid = 0;
+ int lastdii = -1;
#ifdef USE_FILEFILTER
int j;
struct filefilter *ff;
if (bnc != dic)
{
fprintf(stderr, "bad filelist\n");
- exit(1);
+ return olddeps;
}
if (data)
#endif
if (data)
{
- Id handle, did;
+ Id did;
char *b = bn[i];
- handle = s - pool->solvables;
- did = repodata_str2dir(data, dn[di[i]], 1);
- if (!did)
+ if (di[i] == lastdii)
+ did = lastdid;
+ else
{
- did = repodata_str2dir(data, "/", 1);
- if (b && b[0] == '/')
- b++; /* work around rpm bug */
+ did = repodata_str2dir(data, dn[di[i]], 1);
+ if (!did)
+ did = repodata_str2dir(data, "/", 1);
+ lastdid = did;
+ lastdii = di[i];
}
- repodata_add_dirstr(data, handle, SOLVABLE_FILELIST, did, b);
+ if (b && *b == '/') /* work around rpm bug */
+ b++;
+ repodata_add_dirstr(data, s - pool->solvables, SOLVABLE_FILELIST, did, b);
}
}
#if 0
}
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, 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, 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, pool_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 = pool_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)
+ if (sourcerpm || (rpmhead->forcebinary && !headexists(rpmhead, TAG_SOURCEPACKAGE)))
s->arch = pool_str2id(pool, headstring(rpmhead, TAG_ARCH), 1);
else
{
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);
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;
lastid = id;
}
}
+ if ((flags & RPM_ADD_WITH_CHANGELOG) != 0)
+ addchangelog(data, handle, rpmhead);
}
solv_free(evr);
return 1;
struct solvable_copy_cbdata {
Repodata *data;
Id handle;
+ Id subhandle;
Id *dircache;
};
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;
}
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 */
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);
+ 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 / RPM_INDEX_SIZE;
*/
int
-repo_add_rpmdb(Repo *repo, Repo *ref, const char *rootdir, int flags)
+repo_add_rpmdb(Repo *repo, Repo *ref, int flags)
{
Pool *pool = repo->pool;
unsigned char buf[16];
Repodata *data;
int count = 0, done = 0;
unsigned int now;
+ const char *rootdir = 0;
now = solv_timems(0);
memset(&dbkey, 0, sizeof(dbkey));
memset(&dbdata, 0, sizeof(dbdata));
- if (!rootdir)
- rootdir = "";
-
data = repo_add_repodata(repo, flags);
if (ref && !(ref->nsolvables && ref->rpmdbid))
ref = 0;
+ if (flags & REPO_USE_ROOTDIR)
+ rootdir = pool_get_rootdir(pool);
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);
+ 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");
}
rpmheadsize = 0;
rpmhead = 0;
repo->rpmdbid = repo_sidedata_create(repo, sizeof(Id));
if (dbkey.size != 4)
{
- fprintf(stderr, "corrupt Packages database (key size)\n");
- exit(1);
+ dbc->c_close(dbc);
+ db->close(db, 0);
+ dbenv->close(dbenv, 0);
+ return pool_error(pool, -1, "corrupt Packages database (key size)");
}
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)
{
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;
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");
}
nrpmids = 0;
rpmids = 0;
{
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");
}
}
rpmdbid2db(buf, rp->dbid, byteswapped);
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)
{
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;
}
-int
-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;
data = repo_add_repodata(repo, flags);
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 = solv_chksum_free(chksumh, 0);
- if (chksumtype)
- chksumh = solv_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)
- solv_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 = solv_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)
- 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)
{
- 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)
- solv_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)
- solv_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 = solv_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)
- 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 */
- 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)
- solv_chksum_add(chksumh, lead, l);
- fclose(fp);
- s = pool_id2solvable(pool, repo_add_solvable(repo));
- rpm2solv(pool, repo, data, s, rpmhead, flags);
- if (data)
+ }
+ else
+ {
+ /* just skip the signature header */
+ while (sigdsize)
{
- 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 long long)stb.st_size);
- repodata_set_num(data, handle, SOLVABLE_HEADEREND, headerend);
- if (gotpkgid)
- repodata_set_bin_checksum(data, handle, SOLVABLE_PKGID, REPOKEY_TYPE_MD5, pkgid);
+ 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)
- repodata_set_bin_checksum(data, handle, SOLVABLE_CHECKSUM, chksumtype, solv_chksum_get(chksumh, 0));
+ solv_chksum_add(chksumh, lead, l);
+ if (leadsigchksumh)
+ solv_chksum_add(leadsigchksumh, lead, l);
+ sigdsize -= 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);
+ return 0;
+ }
if (chksumh)
- chksumh = solv_chksum_free(chksumh, 0);
+ 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)
+ 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)
solv_free(rpmhead);
if (!(flags & REPO_NO_INTERNALIZE))
repodata_internalize(data);
- return 0;
+ return s - pool->solvables;
}
Id
-repo_add_rpm(Repo *repo, const char *rpm, int flags)
+repo_add_rpm_handle(Repo *repo, void *rpmhandle, int flags)
{
- int end = repo->end;
- repo_add_rpms(repo, &rpm, 1, flags);
- if (end == repo->end)
- return 0;
- else
- return repo->end - 1;
+ 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
if (!name)
name = "";
sourcerpm = headstring(rpmhead, TAG_SOURCERPM);
- if (sourcerpm)
+ if (sourcerpm || (rpmhead->forcebinary && !headexists(rpmhead, TAG_SOURCEPACKAGE)))
arch = headstring(rpmhead, TAG_ARCH);
else
{
if (!arch)
arch = "noarch";
evr = headtoevr(rpmhead);
- l = strlen(name) + 1 + strlen(evr) + 1 + strlen(arch) + 1;
+ l = strlen(name) + 1 + strlen(evr ? evr : "") + 1 + strlen(arch) + 1;
r = solv_malloc(l);
- sprintf(r, "%s-%s.%s", name, evr, arch);
- free(evr);
+ sprintf(r, "%s-%s.%s", name, evr ? evr : "", arch);
+ solv_free(evr);
break;
case SOLVABLE_NAME:
name = headstring(rpmhead, TAG_NAME);
int rpmheadsize;
int dbopened;
+ char *rootdir;
DB_ENV *dbenv;
DB *db;
int byteswapped;
DBT dbdata;
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))
{
continue;
dl = dbdata.size;
dp = dbdata.data;
- while(dl >= RPM_INDEX_SIZE)
+ nameoff = namedatal;
+ if (namedatap)
{
- entries = solv_extend(entries, nentries, 1, sizeof(*entries), ENTRIES_BLOCK);
- entries[nentries].rpmdbid = db2rpmdbid(dp, byteswapped);
- entries[nentries].nameoff = namedatal;
- nentries++;
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;
+ }
+ 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;
}
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)
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, const char *index, const char *match, 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 (!(state.dbenv = opendbenv(rootdir)))
- return 0;
- entries = getinstalledrpmdbids(&state, index, match, &nentries, &namedata);
+ entries = getinstalledrpmdbids(state, index, match, &nentries, 0);
if (rpmdbidq)
for (i = 0; i < nentries; i++)
queue_push(rpmdbidq, entries[i].rpmdbid);
solv_free(entries);
- solv_free(namedata);
- freestate(&state);
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 */
- freestate(state);
- solv_free(state);
- *statep = (void *)0;
- return 0;
- }
-
- if (!state)
- {
- state = solv_calloc(1, sizeof(*state));
- *statep = state;
- }
- if (!state->dbopened)
- {
- 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;
- }
- }
+ if (!state->dbopened && !openpkgdb(state, state->rootdir))
+ return 0;
rpmdbid2db(buf, rpmdbid, state->byteswapped);
memset(&dbkey, 0, sizeof(dbkey));
memset(&dbdata, 0, sizeof(dbdata));
}
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)
}
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;
+ 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 = solv_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;
}
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);
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(Header h, void **statep)
+rpm_byrpmh(void *rpmstate, Header h)
{
- struct rpm_by_state *state = *statep;
+ struct rpm_by_state *state = rpmstate;
const unsigned char *uh;
- int sigdsize, sigcnt, l;
+ unsigned int sigdsize, sigcnt, l;
RpmHead *rpmhead;
#ifndef RPM5
sigcnt = getu32(uh);
sigdsize = getu32(uh + 4);
l = sigdsize + sigcnt * 16;
- if (!state)
- {
- state = solv_calloc(1, sizeof(*state));
- *statep = state;
- }
if (l > state->rpmheadsize)
{
state->rpmheadsize = l + 128;
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
}
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;
}
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)
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);
}
}
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;
}
}
int
-repo_add_rpmdb_pubkeys(Repo *repo, const char *rootdir, int flags)
+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;
data = repo_add_repodata(repo, flags);
+ if (flags & REPO_USE_ROOTDIR)
+ rootdir = pool_get_rootdir(pool);
memset(&state, 0, sizeof(state));
if (!(state.dbenv = opendbenv(rootdir)))
return 0;
- entries = getinstalledrpmdbids(&state, "Name", "gpg-pubkey", &nentries, &namedata);
+ entries = getinstalledrpmdbids(&state, "Name", "gpg-pubkey", &nentries, 0);
for (i = 0 ; i < nentries; i++)
{
- void *statep = &state;
- RpmHead *rpmhead = rpm_byrpmdbid(entries[i].rpmdbid, rootdir, &statep);
+ RpmHead *rpmhead = rpm_byrpmdbid(&state, entries[i].rpmdbid);
if (!rpmhead)
continue;
str = headstring(rpmhead, TAG_DESCRIPTION);
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;
}
-int
-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(flags & REPO_USE_ROOTDIR ? pool_prepend_rootdir_tmp(pool, key) : key, "r")) == 0)
+ {
+ pool_error(pool, -1, "%s: %s", key, strerror(errno));
+ return 0;
+ }
+ for (l = 0; ;)
{
- if ((fp = fopen(keys[i], "r")) == 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 = solv_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;
+ }
+ 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 0;
+ return s - pool->solvables;
}
#endif /* ENABLE_RPMDB_PUBKEY */
projects / platform / upstream / libsolv.git / blobdiff