2020-01-23 13:50:26 +01:00
--- ./lib/backend/ndb/glue.c.orig 2020-01-23 12:47:46.527816289 +0000
2020-02-03 13:59:25 +01:00
+++ ./lib/backend/ndb/glue.c 2020-02-03 12:57:34.817304473 +0000
2020-01-17 13:48:49 +01:00
@@ -52,8 +52,8 @@ static void closeEnv(rpmdb rdb)
if (ndbenv->data)
free(ndbenv->data);
free(ndbenv);
+ rdb->db_dbenv = 0;
}
- rdb->db_dbenv = 0;
}
static struct ndbEnv_s *openEnv(rpmdb rdb)
@@ -80,6 +80,31 @@ static int ndb_Close(dbiIndex dbi, unsig
return 0;
}
+static void ndb_CheckIndexSync(rpmpkgdb pkgdb, rpmxdb xdb)
+{
+ unsigned int generation, xdb_generation;
+ if (!pkgdb || !xdb)
+ return;
+ if (rpmpkgLock(pkgdb, 0))
+ return;
+ if (rpmpkgGeneration(pkgdb, &generation)) {
+ rpmpkgUnlock(pkgdb, 0);
+ return;
+ }
+ if (!rpmxdbGetUserGeneration(xdb, &xdb_generation) && generation == xdb_generation) {
+ rpmpkgUnlock(pkgdb, 0);
+ return;
+ }
+ rpmpkgUnlock(pkgdb, 0);
+ /* index corrupt or with different generation */
+ if (rpmxdbIsRdonly(xdb)) {
+ rpmlog(RPMLOG_WARNING, _("Detected outdated index databases\n"));
+ } else {
+ rpmlog(RPMLOG_WARNING, _("Rebuilding outdated index databases\n"));
+ rpmxdbDelAllBlobs(xdb);
+ }
+}
+
static int ndb_Open(rpmdb rdb, rpmDbiTagVal rpmtag, dbiIndex * dbip, int flags)
{
const char *dbhome = rpmdbHome(rdb);
2020-02-03 13:59:25 +01:00
@@ -130,12 +155,13 @@ static int ndb_Open(rpmdb rdb, rpmDbiTag
2020-01-17 13:48:49 +01:00
}
if (!ndbenv->xdb) {
char *path = rstrscat(NULL, dbhome, "/Index.db", NULL);
+ int created = 0;
rpmlog(RPMLOG_DEBUG, "opening db index %s mode=0x%x\n", path, rdb->db_mode);
/* Open indexes readwrite if possible */
2020-02-03 13:59:25 +01:00
ioflags = O_RDWR;
rc = rpmxdbOpen(&ndbenv->xdb, rdb->db_pkgs->dbi_db, path, ioflags, 0666);
- if (rc && errno == EACCES) {
+ if (rc && (errno == EACCES || errno == EROFS)) {
/* If it is not asked for rw explicitly, try to open ro */
if (!(oflags & O_RDWR)) {
ioflags = O_RDONLY;
2020-01-17 13:48:49 +01:00
@@ -144,6 +170,7 @@ static int ndb_Open(rpmdb rdb, rpmDbiTag
} else if (rc && errno == ENOENT) {
ioflags = O_CREAT|O_RDWR;
rc = rpmxdbOpen(&ndbenv->xdb, rdb->db_pkgs->dbi_db, path, ioflags, 0666);
+ created = 1;
}
if (rc) {
perror("rpmxdbOpen");
@@ -153,6 +180,8 @@ static int ndb_Open(rpmdb rdb, rpmDbiTag
}
free(path);
rpmxdbSetFsync(ndbenv->xdb, ndbenv->dofsync);
+ if (!created)
+ ndb_CheckIndexSync(ndbenv->pkgdb, ndbenv->xdb);
}
if (rpmxdbLookupBlob(ndbenv->xdb, &id, rpmtag, 0, 0) == RPMRC_NOTFOUND) {
dbi->dbi_flags |= DBI_CREATED;
@@ -179,7 +208,13 @@ static int ndb_Open(rpmdb rdb, rpmDbiTag
static int ndb_Verify(dbiIndex dbi, unsigned int flags)
{
- return 0;
+ int rc;
+ if (dbi->dbi_type == DBI_PRIMARY) {
+ rc = rpmpkgVerify(dbi->dbi_db);
+ } else {
+ rc = 0; /* cannot verify the index databases */
+ }
+ return rc;
}
static void ndb_SetFSync(rpmdb rdb, int enable)
@@ -396,15 +431,15 @@ static rpmRC ndb_idxdbIter(dbiIndex dbi,
}
k = dbc->listdata + dbc->list[dbc->ilist];
kl = dbc->list[dbc->ilist + 1];
-#if 0
- if (searchType == DBC_KEY_SEARCH) {
+
+ if (set == NULL) {
dbc->ilist += 2;
dbc->key = k;
dbc->keylen = kl;
rc = RPMRC_OK;
break;
}
-#endif
+
pkglist = 0;
pkglistn = 0;
rc = rpmidxGet(dbc->dbi->dbi_db, k, kl, &pkglist, &pkglistn);
--- ./lib/backend/ndb/rpmpkg.c.orig 2019-11-13 09:19:29.306710577 +0000
2020-01-23 13:50:26 +01:00
+++ ./lib/backend/ndb/rpmpkg.c 2020-01-23 12:48:59.739630414 +0000
2020-01-17 13:48:49 +01:00
@@ -7,7 +7,6 @@
#include <sys/file.h>
#include <fcntl.h>
#include <stdio.h>
-#include <time.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
@@ -19,10 +18,6 @@
#define RPMRC_NOTFOUND 1
#define RPMRC_OK 0
-#ifdef RPMPKG_LZO
-static int rpmpkgLZOCompress(unsigned char **blobp, unsigned int *bloblp);
-static int rpmpkgLZODecompress(unsigned char **blobp, unsigned int *bloblp);
-#endif
static int rpmpkgVerifyblob(rpmpkgdb pkgdb, unsigned int pkgidx, unsigned int blkoff, unsigned int blkcnt);
@@ -49,23 +44,19 @@ typedef struct rpmpkgdb_s {
unsigned int nextpkgidx;
struct pkgslot_s *slots;
- unsigned int aslots; /* allocated slots */
unsigned int nslots; /* used slots */
unsigned int *slothash;
unsigned int nslothash;
unsigned int freeslot; /* first free slot */
- int slotorder;
+ int ordered; /* slots are ordered by the blk offsets */
char *filename;
unsigned int fileblks; /* file size in blks */
int dofsync;
} * rpmpkgdb;
-#define SLOTORDER_UNORDERED 0
-#define SLOTORDER_BLKOFF 1
-
static inline unsigned int le2h(unsigned char *p)
{
@@ -144,10 +135,6 @@ static int rpmpkgReadHeader(rpmpkgdb pkg
if (pkgdb->slots && (pkgdb->generation != generation || pkgdb->slotnpages != slotnpages)) {
free(pkgdb->slots);
pkgdb->slots = 0;
- if (pkgdb->slothash) {
- free(pkgdb->slothash);
- pkgdb->slothash = 0;
- }
}
pkgdb->generation = generation;
pkgdb->slotnpages = slotnpages;
@@ -200,6 +187,7 @@ static inline unsigned int hashpkgidx(un
return h;
}
+/* (re-)create a hash mapping pkgidx numbers to slots */
static int rpmpkgHashSlots(rpmpkgdb pkgdb)
{
unsigned int nslots, num;
@@ -208,14 +196,14 @@ static int rpmpkgHashSlots(rpmpkgdb pkgd
int i;
pkgslot *slot;
- pkgdb->nslothash = 0;
- num = pkgdb->nslots;
+ num = pkgdb->nslots + 32;
while (num & (num - 1))
num = num & (num - 1);
num *= 4;
hash = pkgdb->slothash;
if (!hash || pkgdb->nslothash != num) {
- free(pkgdb->slothash);
+ if (hash)
+ free(hash);
hash = pkgdb->slothash = xcalloc(num, sizeof(unsigned int));
pkgdb->nslothash = num;
} else {
@@ -228,8 +216,6 @@ static int rpmpkgHashSlots(rpmpkgdb pkgd
;
hash[h] = i + 1;
}
- pkgdb->slothash = hash;
- pkgdb->nslothash = num;
return RPMRC_OK;
}
@@ -247,10 +233,6 @@ static int rpmpkgReadSlots(rpmpkgdb pkgd
free(pkgdb->slots);
pkgdb->slots = 0;
}
- if (pkgdb->slothash) {
- free(pkgdb->slothash);
- pkgdb->slothash = 0;
- }
pkgdb->nslots = 0;
pkgdb->freeslot = 0;
@@ -262,8 +244,7 @@ static int rpmpkgReadSlots(rpmpkgdb pkgd
fileblks = stb.st_size / BLK_SIZE;
/* read (and somewhat verify) all slots */
- pkgdb->aslots = slotnpages * (PAGE_SIZE / SLOT_SIZE);
- pkgdb->slots = xcalloc(pkgdb->aslots, sizeof(*pkgdb->slots));
+ pkgdb->slots = xcalloc(slotnpages * (PAGE_SIZE / SLOT_SIZE), sizeof(*pkgdb->slots));
i = 0;
slot = pkgdb->slots;
minblkoff = slotnpages * (PAGE_SIZE / BLK_SIZE);
@@ -299,7 +280,7 @@ static int rpmpkgReadSlots(rpmpkgdb pkgd
}
}
pkgdb->nslots = i;
- pkgdb->slotorder = SLOTORDER_UNORDERED; /* XXX: always order? */
+ pkgdb->ordered = 0;
pkgdb->fileblks = fileblks;
pkgdb->freeslot = freeslot;
if (rpmpkgHashSlots(pkgdb)) {
@@ -317,15 +298,13 @@ static int orderslots_blkoff_cmp(const v
return blkoffa > blkoffb ? 1 : blkoffa < blkoffb ? -1 : 0;
}
-static void rpmpkgOrderSlots(rpmpkgdb pkgdb, int slotorder)
+static void rpmpkgOrderSlots(rpmpkgdb pkgdb)
{
- if (pkgdb->slotorder == slotorder)
+ if (pkgdb->ordered)
return;
- if (slotorder == SLOTORDER_BLKOFF) {
- if (pkgdb->nslots > 1)
- qsort(pkgdb->slots, pkgdb->nslots, sizeof(*pkgdb->slots), orderslots_blkoff_cmp);
- }
- pkgdb->slotorder = slotorder;
+ if (pkgdb->nslots > 1)
+ qsort(pkgdb->slots, pkgdb->nslots, sizeof(*pkgdb->slots), orderslots_blkoff_cmp);
+ pkgdb->ordered = 1;
rpmpkgHashSlots(pkgdb);
}
@@ -340,6 +319,8 @@ static inline pkgslot *rpmpkgFindSlot(rp
return 0;
}
+/* Find an empty space for blkcnt blocks. If dontprepend is true, ignore
+ the space between the slot area and the first blob */
static int rpmpkgFindEmptyOffset(rpmpkgdb pkgdb, unsigned int pkgidx, unsigned int blkcnt, unsigned *blkoffp, pkgslot **oldslotp, int dontprepend)
{
unsigned int i, nslots = pkgdb->nslots;
@@ -348,8 +329,8 @@ static int rpmpkgFindEmptyOffset(rpmpkgd
unsigned int lastblkend = pkgdb->slotnpages * (PAGE_SIZE / BLK_SIZE);
pkgslot *slot, *oldslot = 0;
- if (pkgdb->slotorder != SLOTORDER_BLKOFF)
- rpmpkgOrderSlots(pkgdb, SLOTORDER_BLKOFF);
+ if (!pkgdb->ordered)
+ rpmpkgOrderSlots(pkgdb);
if (dontprepend && nslots) {
lastblkend = pkgdb->slots[0].blkoff;
@@ -382,14 +363,15 @@ static int rpmpkgFindEmptyOffset(rpmpkgd
return RPMRC_OK;
}
+/* verify the blobs to the left and right of a free area */
static int rpmpkgNeighbourCheck(rpmpkgdb pkgdb, unsigned int blkoff, unsigned int blkcnt, unsigned int *newblkcnt)
{
unsigned int i, nslots = pkgdb->nslots;
unsigned int lastblkend = pkgdb->slotnpages * (PAGE_SIZE / BLK_SIZE);
pkgslot *slot, *left = 0, *right = 0;
- if (pkgdb->slotorder != SLOTORDER_BLKOFF)
- rpmpkgOrderSlots(pkgdb, SLOTORDER_BLKOFF);
+ if (!pkgdb->ordered)
+ rpmpkgOrderSlots(pkgdb);
if (blkoff < lastblkend)
return RPMRC_FAIL;
for (i = 0, slot = pkgdb->slots; i < nslots; i++, slot++) {
@@ -413,7 +395,7 @@ static int rpmpkgNeighbourCheck(rpmpkgdb
if (right && rpmpkgVerifyblob(pkgdb, right->pkgidx, right->blkoff, right->blkcnt) != RPMRC_OK)
return RPMRC_FAIL;
*newblkcnt = right ? right->blkoff - blkoff : blkcnt;
- /* bounds are intect. free area. */
+ /* bounds are intact. ok to zero area. */
return RPMRC_OK;
}
@@ -433,6 +415,7 @@ static int rpmpkgWriteslot(rpmpkgdb pkgd
return RPMRC_FAIL;
}
pkgdb->generation++;
+ /* rpmpkgFsync() is done by rpmpkgWriteHeader() */
if (rpmpkgWriteHeader(pkgdb)) {
return RPMRC_FAIL;
}
@@ -527,7 +510,7 @@ static int rpmpkgValidateZero(rpmpkgdb p
/*** Blob primitives ***/
-/* head: magic + pkgidx + timestamp + bloblen */
+/* head: magic + pkgidx + generation + bloblen */
/* tail: adler32 + bloblen + magic */
#define BLOBHEAD_MAGIC ('B' | 'l' << 8 | 'b' << 16 | 'S' << 24)
@@ -536,10 +519,10 @@ static int rpmpkgValidateZero(rpmpkgdb p
#define BLOBHEAD_SIZE (4 + 4 + 4 + 4)
#define BLOBTAIL_SIZE (4 + 4 + 4)
-static int rpmpkgReadBlob(rpmpkgdb pkgdb, unsigned int pkgidx, unsigned int blkoff, unsigned int blkcnt, unsigned char *blob, unsigned int *bloblp, unsigned int *tstampp)
+static int rpmpkgReadBlob(rpmpkgdb pkgdb, unsigned int pkgidx, unsigned int blkoff, unsigned int blkcnt, unsigned char *blob, unsigned int *bloblp, unsigned int *generationp)
{
unsigned char buf[BLOBHEAD_SIZE > BLOBTAIL_SIZE ? BLOBHEAD_SIZE : BLOBTAIL_SIZE];
- unsigned int bloblen, toread, tstamp;
+ unsigned int bloblen, toread, generation;
off_t fileoff;
unsigned int adl;
int verifyadler = bloblp ? 0 : 1;
@@ -555,7 +538,7 @@ static int rpmpkgReadBlob(rpmpkgdb pkgdb
return RPMRC_FAIL; /* bad blob */
if (le2h(buf + 4) != pkgidx)
return RPMRC_FAIL; /* bad blob */
- tstamp = le2h(buf + 8);
+ generation = le2h(buf + 8);
bloblen = le2h(buf + 12);
if (blkcnt != (BLOBHEAD_SIZE + bloblen + BLOBTAIL_SIZE + BLK_SIZE - 1) / BLK_SIZE)
return RPMRC_FAIL; /* bad blob */
@@ -600,8 +583,8 @@ static int rpmpkgReadBlob(rpmpkgdb pkgdb
}
if (bloblp)
*bloblp = bloblen;
- if (tstampp)
- *tstampp = tstamp;
+ if (generationp)
+ *generationp = generation;
return RPMRC_OK;
}
@@ -684,14 +667,14 @@ static int rpmpkgMoveBlob(rpmpkgdb pkgdb
unsigned int blkoff = slot->blkoff;
unsigned int blkcnt = slot->blkcnt;
unsigned char *blob;
- unsigned int tstamp, blobl;
+ unsigned int generation, blobl;
blob = xmalloc((size_t)blkcnt * BLK_SIZE);
- if (rpmpkgReadBlob(pkgdb, pkgidx, blkoff, blkcnt, blob, &blobl, &tstamp)) {
+ if (rpmpkgReadBlob(pkgdb, pkgidx, blkoff, blkcnt, blob, &blobl, &generation)) {
free(blob);
return RPMRC_FAIL;
}
- if (rpmpkgWriteBlob(pkgdb, pkgidx, newblkoff, blkcnt, blob, blobl, tstamp)) {
+ if (rpmpkgWriteBlob(pkgdb, pkgidx, newblkoff, blkcnt, blob, blobl, generation)) {
free(blob);
return RPMRC_FAIL;
}
@@ -703,15 +686,15 @@ static int rpmpkgMoveBlob(rpmpkgdb pkgdb
return RPMRC_FAIL;
}
slot->blkoff = newblkoff;
- pkgdb->slotorder = SLOTORDER_UNORDERED;
+ pkgdb->ordered = 0;
return RPMRC_OK;
}
static int rpmpkgAddSlotPage(rpmpkgdb pkgdb)
{
unsigned int cutoff;
- if (pkgdb->slotorder != SLOTORDER_BLKOFF)
- rpmpkgOrderSlots(pkgdb, SLOTORDER_BLKOFF);
+ if (!pkgdb->ordered)
+ rpmpkgOrderSlots(pkgdb);
cutoff = (pkgdb->slotnpages + 1) * (PAGE_SIZE / BLK_SIZE);
/* now move every blob before cutoff */
@@ -729,7 +712,7 @@ static int rpmpkgAddSlotPage(rpmpkgdb pk
if (rpmpkgMoveBlob(pkgdb, slot, newblkoff)) {
return RPMRC_FAIL;
}
- rpmpkgOrderSlots(pkgdb, SLOTORDER_BLKOFF);
+ rpmpkgOrderSlots(pkgdb);
}
/* make sure our new page is empty */
@@ -958,6 +941,7 @@ static int rpmpkgPutInternal(rpmpkgdb pk
pkgslot *oldslot;
/* we always read all slots when writing, just in case */
+ /* this also will set pkgdb->freeslot */
if (rpmpkgReadSlots(pkgdb)) {
return RPMRC_FAIL;
}
2020-01-23 13:50:26 +01:00
@@ -981,14 +965,15 @@ static int rpmpkgPutInternal(rpmpkgdb pk
2020-01-17 13:48:49 +01:00
return RPMRC_FAIL;
}
/* write new blob */
- if (rpmpkgWriteBlob(pkgdb, pkgidx, blkoff, blkcnt, blob, blobl, (unsigned int)time(0))) {
+ if (rpmpkgWriteBlob(pkgdb, pkgidx, blkoff, blkcnt, blob, blobl, pkgdb->generation)) {
return RPMRC_FAIL;
}
2020-01-23 13:50:26 +01:00
+ /* update nextpkgidx if needed */
+ if (pkgidx >= pkgdb->nextpkgidx) {
+ pkgdb->nextpkgidx = pkgidx + 1;
+ }
2020-01-17 13:48:49 +01:00
/* write slot */
2020-01-23 13:50:26 +01:00
slotno = oldslot ? oldslot->slotno : pkgdb->freeslot;
- if (!slotno) {
- return RPMRC_FAIL;
- }
if (rpmpkgWriteslot(pkgdb, slotno, pkgidx, blkoff, blkcnt)) {
free(pkgdb->slots);
pkgdb->slots = 0;
@@ -1006,7 +991,7 @@ static int rpmpkgPutInternal(rpmpkgdb pk
2020-01-17 13:48:49 +01:00
/* just update the slot, no need to free the slot data */
oldslot->blkoff = blkoff;
oldslot->blkcnt = blkcnt;
- pkgdb->slotorder = SLOTORDER_UNORDERED;
+ pkgdb->ordered = 0;
} else {
free(pkgdb->slots);
pkgdb->slots = 0;
2020-01-23 13:50:26 +01:00
@@ -1023,7 +1008,7 @@ static int rpmpkgDelInternal(rpmpkgdb pk
2020-01-17 13:48:49 +01:00
if (rpmpkgReadSlots(pkgdb)) {
return RPMRC_FAIL;
}
- rpmpkgOrderSlots(pkgdb, SLOTORDER_BLKOFF);
+ rpmpkgOrderSlots(pkgdb);
slot = rpmpkgFindSlot(pkgdb, pkgidx);
if (!slot) {
return RPMRC_OK;
2020-01-23 13:50:26 +01:00
@@ -1049,9 +1034,10 @@ static int rpmpkgDelInternal(rpmpkgdb pk
2020-01-17 13:48:49 +01:00
}
slot->blkoff = 0;
slot->blkcnt = 0;
+ /* try to move the last two slots, the bigger one first */
slot = pkgdb->slots + pkgdb->nslots - 2;
if (slot->blkcnt < slot[1].blkcnt)
- slot++; /* bigger slot first */
+ slot++; /* bigger slot first */
for (i = 0; i < 2; i++, slot++) {
if (slot == pkgdb->slots + pkgdb->nslots)
slot -= 2;
2020-01-23 13:50:26 +01:00
@@ -1065,7 +1051,7 @@ static int rpmpkgDelInternal(rpmpkgdb pk
2020-01-17 13:48:49 +01:00
blkoff += slot->blkcnt;
blkcnt -= slot->blkcnt;
}
- rpmpkgOrderSlots(pkgdb, SLOTORDER_BLKOFF);
+ rpmpkgOrderSlots(pkgdb);
} else {
slot->blkoff = 0;
slot->blkcnt = 0;
2020-01-23 13:50:26 +01:00
@@ -1104,7 +1090,7 @@ static int rpmpkgListInternal(rpmpkgdb p
2020-01-17 13:48:49 +01:00
*npkgidxlistp = pkgdb->nslots;
return RPMRC_OK;
}
- rpmpkgOrderSlots(pkgdb, SLOTORDER_BLKOFF);
+ rpmpkgOrderSlots(pkgdb);
nslots = pkgdb->nslots;
pkgidxlist = xcalloc(nslots + 1, sizeof(unsigned int));
for (i = 0, slot = pkgdb->slots; i < nslots; i++, slot++) {
2020-01-23 13:50:26 +01:00
@@ -1115,6 +1101,22 @@ static int rpmpkgListInternal(rpmpkgdb p
2020-01-17 13:48:49 +01:00
return RPMRC_OK;
}
+static int rpmpkgVerifyInternal(rpmpkgdb pkgdb)
+{
+ unsigned int i, nslots;
+ pkgslot *slot;
+
+ if (rpmpkgReadSlots(pkgdb))
+ return RPMRC_FAIL;
+ rpmpkgOrderSlots(pkgdb);
+ nslots = pkgdb->nslots;
+ for (i = 0, slot = pkgdb->slots; i < nslots; i++, slot++) {
+ if (rpmpkgVerifyblob(pkgdb, slot->pkgidx, slot->blkoff, slot->blkcnt))
+ return RPMRC_FAIL;
+ }
+ return RPMRC_OK;
+}
+
int rpmpkgGet(rpmpkgdb pkgdb, unsigned int pkgidx, unsigned char **blobp, unsigned int *bloblp)
{
int rc;
2020-01-23 13:50:26 +01:00
@@ -1127,10 +1129,6 @@ int rpmpkgGet(rpmpkgdb pkgdb, unsigned i
2020-01-17 13:48:49 +01:00
return RPMRC_FAIL;
rc = rpmpkgGetInternal(pkgdb, pkgidx, blobp, bloblp);
rpmpkgUnlock(pkgdb, 0);
-#ifdef RPMPKG_LZO
- if (!rc)
- rc = rpmpkgLZODecompress(blobp, bloblp);
-#endif
return rc;
}
2020-01-23 13:50:26 +01:00
@@ -1143,16 +1141,7 @@ int rpmpkgPut(rpmpkgdb pkgdb, unsigned i
2020-01-17 13:48:49 +01:00
}
if (rpmpkgLockReadHeader(pkgdb, 1))
return RPMRC_FAIL;
-#ifdef RPMPKG_LZO
- if (rpmpkgLZOCompress(&blob, &blobl)) {
- rpmpkgUnlock(pkgdb, 1);
- return RPMRC_FAIL;
- }
-#endif
rc = rpmpkgPutInternal(pkgdb, pkgidx, blob, blobl);
-#ifdef RPMPKG_LZO
- free(blob);
-#endif
rpmpkgUnlock(pkgdb, 1);
return rc;
}
2020-01-23 13:50:26 +01:00
@@ -1184,6 +1173,16 @@ int rpmpkgList(rpmpkgdb pkgdb, unsigned
2020-01-17 13:48:49 +01:00
return rc;
}
+int rpmpkgVerify(rpmpkgdb pkgdb)
+{
+ int rc;
+ if (rpmpkgLockReadHeader(pkgdb, 0))
+ return RPMRC_FAIL;
+ rc = rpmpkgVerifyInternal(pkgdb);
+ rpmpkgUnlock(pkgdb, 0);
+ return rc;
+}
+
int rpmpkgNextPkgIdx(rpmpkgdb pkgdb, unsigned int *pkgidxp)
{
if (rpmpkgLockReadHeader(pkgdb, 1))
2020-01-23 13:50:26 +01:00
@@ -1233,64 +1232,3 @@ int rpmpkgStats(rpmpkgdb pkgdb)
2020-01-17 13:48:49 +01:00
return RPMRC_OK;
}
-#ifdef RPMPKG_LZO
-
-#include "lzo/lzoconf.h"
-#include "lzo/lzo1x.h"
-
-#define BLOBLZO_MAGIC ('L' | 'Z' << 8 | 'O' << 16 | 'B' << 24)
-
-static int rpmpkgLZOCompress(unsigned char **blobp, unsigned int *bloblp)
-{
- unsigned char *blob = *blobp;
- unsigned int blobl = *bloblp;
- unsigned char *lzoblob, *workmem;
- unsigned int lzoblobl;
- lzo_uint blobl2;
-
- if (lzo_init() != LZO_E_OK) {
- return RPMRC_FAIL;
- }
- workmem = xmalloc(LZO1X_1_MEM_COMPRESS);
- lzoblobl = 4 + 4 + blobl + blobl / 16 + 64 + 3;
- lzoblob = xmalloc(lzoblobl);
- h2le(BLOBLZO_MAGIC, lzoblob);
- h2le(blobl, lzoblob + 4);
- if (lzo1x_1_compress(blob, blobl, lzoblob + 8, &blobl2, workmem) != LZO_E_OK) {
- free(workmem);
- free(lzoblob);
- return RPMRC_FAIL;
- }
- free(workmem);
- *blobp = lzoblob;
- *bloblp = 8 + blobl2;
- return RPMRC_OK;
-}
-
-static int rpmpkgLZODecompress(unsigned char **blobp, unsigned int *bloblp)
-{
- unsigned char *lzoblob = *blobp;
- unsigned int lzoblobl = *bloblp;
- unsigned char *blob;
- unsigned int blobl;
- lzo_uint blobl2;
-
- if (!lzoblob || lzoblobl < 8)
- return RPMRC_FAIL;
- if (le2h(lzoblob) != BLOBLZO_MAGIC)
- return RPMRC_FAIL;
- if (lzo_init() != LZO_E_OK)
- return RPMRC_FAIL;
- blobl = le2h(lzoblob + 4);
- blob = xmalloc(blobl ? blobl : 1);
- if (lzo1x_decompress(lzoblob + 8, lzoblobl - 8, blob, &blobl2, 0) != LZO_E_OK || blobl2 != blobl) {
- free(blob);
- return RPMRC_FAIL;
- }
- free(lzoblob);
- *blobp = blob;
- *bloblp = blobl;
- return RPMRC_OK;
-}
-
-#endif
--- ./lib/backend/ndb/rpmpkg.h.orig 2019-06-26 14:17:31.406985703 +0000
2020-01-23 13:50:26 +01:00
+++ ./lib/backend/ndb/rpmpkg.h 2020-01-23 12:48:20.919728972 +0000
2020-01-17 13:48:49 +01:00
@@ -12,6 +12,7 @@ int rpmpkgGet(rpmpkgdb pkgdb, unsigned i
int rpmpkgPut(rpmpkgdb pkgdb, unsigned int pkgidx, unsigned char *blob, unsigned int blobl);
int rpmpkgDel(rpmpkgdb pkgdb, unsigned int pkgidx);
int rpmpkgList(rpmpkgdb pkgdb, unsigned int **pkgidxlistp, unsigned int *npkgidxlistp);
+int rpmpkgVerify(rpmpkgdb pkgdb);
int rpmpkgNextPkgIdx(rpmpkgdb pkgdb, unsigned int *pkgidxp);
int rpmpkgGeneration(rpmpkgdb pkgdb, unsigned int *generationp);
--- ./lib/backend/ndb/rpmxdb.c.orig 2019-11-13 09:19:29.307710583 +0000
2020-01-23 13:50:26 +01:00
+++ ./lib/backend/ndb/rpmxdb.c 2020-01-23 12:48:20.919728972 +0000
2020-01-17 13:48:49 +01:00
@@ -224,11 +224,33 @@ static int usedslots_cmp(const void *a,
return sa->startpage > sb->startpage ? 1 : -1;
}
+static int rpmxdbReadHeaderRaw(rpmxdb xdb, unsigned int *generationp, unsigned int *slotnpagesp, unsigned int *pagesizep, unsigned int *usergenerationp)
+{
+ unsigned int header[XDB_HEADER_SIZE / sizeof(unsigned int)];
+ unsigned int version;
+ if (pread(xdb->fd, header, sizeof(header), 0) != sizeof(header))
+ return RPMRC_FAIL;
+ if (le2ha((unsigned char *)header + XDB_OFFSET_MAGIC) != XDB_MAGIC)
+ return RPMRC_FAIL;
+ version = le2ha((unsigned char *)header + XDB_OFFSET_VERSION);
+ if (version != XDB_VERSION) {
+ rpmlog(RPMLOG_ERR, _("rpmxdb: Version mismatch. Expected version: %u. "
+ "Found version: %u\n"), XDB_VERSION, version);
+ return RPMRC_FAIL;
+ }
+ *generationp = le2ha((unsigned char *)header + XDB_OFFSET_GENERATION);
+ *slotnpagesp = le2ha((unsigned char *)header + XDB_OFFSET_SLOTNPAGES);
+ *pagesizep = le2ha((unsigned char *)header + XDB_OFFSET_PAGESIZE);
+ *usergenerationp = le2ha((unsigned char *)header + XDB_OFFSET_USERGENERATION);
+ if (!*slotnpagesp || !*pagesizep)
+ return RPMRC_FAIL;
+ return RPMRC_OK;
+}
+
static int rpmxdbReadHeader(rpmxdb xdb)
{
struct xdb_slot *slot;
- unsigned int header[XDB_HEADER_SIZE / sizeof(unsigned int)];
- unsigned int slotnpages, pagesize, generation, usergeneration, version;
+ unsigned int slotnpages, pagesize, generation, usergeneration;
unsigned int page, *lastfreep;
unsigned char *pageptr;
struct xdb_slot *slots, **usedslots, *lastslot;
@@ -246,23 +268,9 @@ static int rpmxdbReadHeader(rpmxdb xdb)
if (fstat(xdb->fd, &stb)) {
return RPMRC_FAIL;
}
- if (pread(xdb->fd, header, sizeof(header), 0) != sizeof(header)) {
- return RPMRC_FAIL;
- }
- if (le2ha((unsigned char *)header + XDB_OFFSET_MAGIC) != XDB_MAGIC)
- return RPMRC_FAIL;
- version = le2ha((unsigned char *)header + XDB_OFFSET_VERSION);
- if (version != XDB_VERSION) {
- rpmlog(RPMLOG_ERR, _("rpmxdb: Version mismatch. Expected version: %u. "
- "Found version: %u\n"), XDB_VERSION, version);
+ if (rpmxdbReadHeaderRaw(xdb, &generation, &slotnpages, &pagesize, &usergeneration))
return RPMRC_FAIL;
- }
-
- generation = le2ha((unsigned char *)header + XDB_OFFSET_GENERATION);
- slotnpages = le2ha((unsigned char *)header + XDB_OFFSET_SLOTNPAGES);
- pagesize = le2ha((unsigned char *)header + XDB_OFFSET_PAGESIZE);
- usergeneration = le2ha((unsigned char *)header + XDB_OFFSET_USERGENERATION);
- if (!slotnpages || !pagesize || stb.st_size % pagesize != 0)
+ if (stb.st_size % pagesize != 0)
return RPMRC_FAIL;
xdb->pagesize = pagesize;
xdb->mapflags = xdb->rdonly ? PROT_READ : PROT_READ | PROT_WRITE;
@@ -922,6 +930,43 @@ int rpmxdbDelBlob(rpmxdb xdb, unsigned i
rpmxdbUnlock(xdb, 1);
return RPMRC_OK;
}
+
+int rpmxdbDelAllBlobs(rpmxdb xdb)
+{
+ unsigned int slotnpages, pagesize, generation, usergeneration;
+ if (rpmxdbLockOnly(xdb, 1))
+ return RPMRC_FAIL;
+ /* unmap all blobs */
+ if (xdb->slots) {
+ int i;
+ struct xdb_slot *slot;
+ for (i = 1, slot = xdb->slots + i; i < xdb->nslots; i++, slot++) {
+ if (slot->startpage && slot->mapped) {
+ unmapslot(xdb, slot);
+ slot->mapcallback(xdb, slot->mapcallbackdata, 0, 0);
+ }
+ }
+ free(xdb->slots);
+ xdb->slots = 0;
+ }
+ if (xdb->mapped)
+ unmapheader(xdb);
+ if (rpmxdbReadHeaderRaw(xdb, &generation, &slotnpages, &pagesize, &usergeneration)) {
+ rpmxdbUnlock(xdb, 1);
+ return RPMRC_FAIL;
+ }
+ xdb->generation = generation + 1;
+ xdb->slotnpages = 1;
+ xdb->pagesize = pagesize;
+ xdb->usergeneration = usergeneration;
+ if (rpmxdbWriteEmptySlotpage(xdb, 0)) {
+ rpmxdbUnlock(xdb, 1);
+ return RPMRC_FAIL;
+ }
+ ftruncate(xdb->fd, xdb->pagesize);
+ rpmxdbUnlock(xdb, 1);
+ return RPMRC_OK;
+}
int rpmxdbResizeBlob(rpmxdb xdb, unsigned int id, size_t newsize)
{
--- ./lib/backend/ndb/rpmxdb.h.orig 2019-11-13 09:19:29.307710583 +0000
2020-01-23 13:50:26 +01:00
+++ ./lib/backend/ndb/rpmxdb.h 2020-01-23 12:48:20.919728972 +0000
2020-01-17 13:48:49 +01:00
@@ -14,6 +14,7 @@ int rpmxdbUnlock(rpmxdb xdb, int excl);
int rpmxdbLookupBlob(rpmxdb xdb, unsigned int *idp, unsigned int blobtag, unsigned int subtag, int flags);
int rpmxdbDelBlob(rpmxdb xdb, unsigned int id) ;
+int rpmxdbDelAllBlobs(rpmxdb xdb);
int rpmxdbMapBlob(rpmxdb xdb, unsigned int id, int flags, void (*mapcallback)(rpmxdb xdb, void *data, void *newaddr, size_t newsize), void *mapcallbackdata);
int rpmxdbUnmapBlob(rpmxdb xdb, unsigned int id);
