- fix: rpmdb iterator memory leak in python bindings.
- fix: include <sys/time.h> for 6.2 python modules.
- remove vestiges of mipseb arch (#62408).
CVS patchset: 5414
CVS date: 2002/05/02 22:16:30
- add --nosuggests to disable suggested resolutions.
- attempt to make peace with automake-1.6.1, autoconf-2.53.
- rip out two layers of dbN gook, internal Berkeley db is here to stay.
+ - eliminate db1 support.
4.0.3 -> 4.0.4:
- solaris: translate i86pc to i386 (#57182).
- non-glibc: on upgrade, mergesort is much faster than quicksort.
- fix: queries that evaluated to "" incorrectly returned NULL.
- fix: packages produced by rpm-4.0 dinna merge signature tags.
+ - fix: rpmdb iterator memory leak in python bindings.
+ - fix: include <sys/time.h> for 6.2 python modules.
+ - remove vestiges of mipseb arch (#62408).
4.0.2 -> 4.0.3:
- update per-interpreter dependency scripts, add sql/tcl (#20295).
@top_srcdir@/rpmdb/db1.c \
@top_srcdir@/rpmdb/db3.c \
@top_srcdir@/rpmdb/dbconfig.c \
- @top_srcdir@/rpmdb/falloc.c \
- @top_srcdir@/rpmdb/falloc.h \
@top_srcdir@/rpmdb/fprint.c \
@top_srcdir@/rpmdb/fprint.h \
@top_srcdir@/rpmdb/hdrNVR.c \
/*@access tsortInfo @*/
/*@access rpmTransactionSet @*/
+/*@access dbiIndex @*/ /* XXX for dbi->dbi_txnid */
+
/*@access alKey @*/ /* XXX for reordering and RPMAL_NOMATCH assign */
/**
memset(data, 0, sizeof(*data));
data->data = datap;
data->size = datalen;
- xx = dbiGet(dbi, dbcursor, key, data);
+ xx = dbiGet(dbi, dbcursor, key, data, 0);
DNEVR = key->data;
DNEVRlen = key->size;
datap = data->data;
} else {
const char * DNEVR;
xx = 0;
+ /*@-branchstate@*/
if ((DNEVR = dsiGetDNEVR(dep)) != NULL) {
DBC * dbcursor = NULL;
size_t DNEVRlen = strlen(DNEVR);
- xx = dbiCopen(dbi, dbi->dbi_txnid, &dbcursor, DBI_WRITECURSOR);
+ xx = dbiCopen(dbi, dbi->dbi_txnid, &dbcursor, DB_WRITECURSOR);
memset(key, 0, sizeof(*key));
key->data = (void *) DNEVR;
data->data = &rc;
data->size = sizeof(rc);
- xx = dbiPut(dbi, dbcursor, key, data);
- xx = dbiCclose(dbi, dbcursor, DBI_WRITECURSOR);
+ /*@-compmempass@*/
+ xx = dbiPut(dbi, dbcursor, key, data, 0);
+ /*@=compmempass@*/
+ xx = dbiCclose(dbi, dbcursor, DB_WRITECURSOR);
}
+ /*@=branchstate@*/
if (xx)
_cacheDependsRC = 0;
}
const char * errstr = "(unkown error)";
const char * str;
+/*@-modobserver@*/
str = headerSprintf(h, qfmt, rpmTagTable, rpmHeaderFormats, &errstr);
+/*@=modobserver@*/
if (str == NULL)
rpmError(RPMERR_QFMT, _("incorrect format: %s\n"), errstr);
return str;
/*@unused@*/
int_32 * odil; /*!< Original dirindex(s) (from header) */
-/*@only@*/ /*@null@*/
+/*@only@*/
unsigned char * md5s; /*!< File md5 sums in binary. */
/*@only@*/ /*@null@*/
strcpy(un.machine, "mipsel");
# elif defined(__MIPSEB__) || defined(__MIPSEB) || defined(_MIPSEB)
/* big endian */
- strcpy(un.machine, "mipseb");
+ strcpy(un.machine, "mips");
# endif
# if defined(__hpux) && defined(_SC_CPU_VERSION)
/**
* Destroy transaction element iterator.
* @param tei transaction element iterator
+ * @param fn
+ * @param ln
* @return NULL always
*/
/*@null@*/
/**
* Create transaction element iterator.
* @param ts transaction set
+ * @param fn
+ * @param ln
* @return transaction element iterator
*/
/*@unused@*/ /*@only@*/
/* XXX Prefer the newest build if given alternatives. */
if (htime <= bhtime)
continue;
- if (bh)
- bh = headerFree(bh, NULL);
+ bh = headerFree(bh, NULL);
bh = headerLink(h, NULL);
bhtime = htime;
}
rpmdb/db1.c
rpmdb/db3.c
rpmdb/dbconfig.c
-rpmdb/falloc.c
-rpmdb/fprint.c
rpmdb/hdrNVR.c
rpmdb/header.c
rpmdb/header_internal.c
* \file python/db-py.c
*/
+#include <sys/time.h>
#include <fcntl.h>
#include <unistd.h>
* \file python/header-py.c
*/
+#include <sys/time.h>
+
#include "Python.h"
#include "rpmio_internal.h"
#include "rpmcli.h" /* XXX for rpmCheckSig */
%ifarch armv3l armv4l
%attr(-, @RPMUSER@, @RPMGROUP@) %{__prefix}/lib/rpm/armv[34][lb]*
%endif
-%ifarch mips mipsel mipseb
+%ifarch mips mipsel
%attr(-, @RPMUSER@, @RPMGROUP@) %{__prefix}/lib/rpm/mips*
%endif
%attr(-, @RPMUSER@, @RPMGROUP@) %{__prefix}/lib/rpm/noarch*
-I$(top_srcdir)/popt \
@INCPATH@
-EXTRA_DIST = db3.c db1.c falloc.c
+EXTRA_DIST = db3.c
EXTRA_PROGRAMS = tjfn
pkgincdir = $(pkgincludedir)
pkginc_HEADERS = db.h header.h hdrinline.h rpmdb.h
-noinst_HEADERS = falloc.h fprint.h header_internal.h legacy.h rpmhash.h
+noinst_HEADERS = fprint.h header_internal.h legacy.h rpmhash.h
mylibpaths = \
-L$(top_builddir)/lib \
sed -e "s|^dependency_libs='|& -lrpmio|" < librpmdb.la > .librpmdb.la && \
mv .librpmdb.la librpmdb.la
-falloc.lo: falloc.c $(top_srcdir)/system.h $(top_srcdir)/rpmio/rpmio.h falloc.h
- $(LIBTOOL) --mode=compile $(COMPILE) -c $<
-
tagtbl.c: $(top_srcdir)/lib/rpmlib.h
@echo '#include "system.h"' > $@
@echo '#include "lib/rpmlib.h"' >> $@
tdbi: librpmdb.la tdbi.o
$(LINK) -all-static $@.o $< $(mylibpaths) $(mylibs) $(LIBS)
-
-tfalloc: librpmdb.la tfalloc.o
- $(LINK) -all-static $@.o $< $(mylibpaths) $(mylibs) $(LIBS)
#include <sys/ipc.h>
#endif
-#if defined(__LCLINT__)
-/*@-redef@*/ /* FIX: rpmio/rpmio.c also declares */
-typedef unsigned int u_int32_t;
-typedef unsigned short u_int16_t;
-typedef unsigned char u_int8_t;
-/*@-incondefs@*/ /* LCLint 3.0.0.15 */
-typedef int int32_t;
-/*@=incondefs@*/
-/*@=redef@*/
-#endif
-
#include <rpmlib.h>
#include <rpmmacro.h>
#include <rpmurl.h> /* XXX urlPath proto */
/*@globals fileSystem @*/
/*@modifies fileSystem @*/
{
- int rc = 0;
-
- rc = error;
+ int rc = error;
if (printit && rc) {
/*@-moduncon@*/ /* FIX: annotate db3 methods */
return rc;
}
-/*@unused@*/ static int db3c_dup(dbiIndex dbi, DBC * dbcursor, DBC ** dbcp,
- u_int32_t flags)
+#ifdef DYING
+/*@unused@*/
+static int db3c_dup(dbiIndex dbi, DBC * dbcursor, DBC ** dbcp,
+ unsigned int flags)
/*@globals fileSystem @*/
/*@modifies *dbcp, fileSystem @*/
{
return rc;
/*@=nullstate @*/
}
+#endif
-static inline int db3c_close(dbiIndex dbi, /*@only@*/ /*@null@*/ DBC * dbcursor)
+static int db3cclose(dbiIndex dbi, /*@only@*/ /*@null@*/ DBC * dbcursor,
+ unsigned int flags)
/*@globals fileSystem @*/
- /*@modifies fileSystem @*/
+ /*@modifies dbi, fileSystem @*/
{
int rc;
- if (dbcursor == NULL) return -2;
-
+ assert(dbcursor != NULL);
rc = dbcursor->c_close(dbcursor);
rc = cvtdberr(dbi, "dbcursor->c_close", rc, _debug);
return rc;
}
-static inline int db3c_open(dbiIndex dbi, DB_TXN * txnid,
- /*@null@*/ /*@out@*/ DBC ** dbcp, int dbiflags)
+static int db3copen(dbiIndex dbi, DB_TXN * txnid,
+ /*@null@*/ /*@out@*/ DBC ** dbcp, unsigned int dbiflags)
/*@globals fileSystem @*/
- /*@modifies *dbcp, fileSystem @*/
+ /*@modifies dbi, *dbcp, fileSystem @*/
{
DB * db = dbi->dbi_db;
+ DBC * dbcursor = NULL;
int flags;
int rc;
- if (db == NULL) return -2;
- if ((dbiflags & DBI_WRITECURSOR) &&
+ assert(db != NULL);
+ if ((dbiflags & DB_WRITECURSOR) &&
(dbi->dbi_eflags & DB_INIT_CDB) && !(dbi->dbi_oflags & DB_RDONLY))
{
flags = DB_WRITECURSOR;
} else
flags = 0;
- if (dbcp) *dbcp = NULL;
- rc = db->cursor(db, txnid, dbcp, flags);
- rc = cvtdberr(dbi, "db3c_open", rc, _debug);
-
- return rc;
-}
-
-static int db3cclose(dbiIndex dbi, /*@only@*/ /*@null@*/ DBC * dbcursor,
- unsigned int flags)
- /*@globals fileSystem @*/
- /*@modifies dbi, fileSystem @*/
-{
- int rc = 0;
-
- /* XXX per-iterator cursors */
- if (flags & DBI_ITERATOR)
- return db3c_close(dbi, dbcursor);
-
- if (!dbi->dbi_use_cursors)
- return 0;
-
- if (dbcursor) {
- rc = db3c_close(dbi, dbcursor);
- }
- /*@-usereleased -compdef@*/ return rc; /*@=usereleased =compdef@*/
-}
-
-static int db3copen(dbiIndex dbi, DB_TXN * txnid,
- /*@null@*/ /*@out@*/ DBC ** dbcp, unsigned int flags)
- /*@globals fileSystem @*/
- /*@modifies dbi, *dbcp, fileSystem @*/
-{
- DBC * dbcursor;
- int rc = 0;
-
- /* XXX per-iterator cursors */
- if (flags & DBI_ITERATOR)
- return db3c_open(dbi, txnid, dbcp, flags);
-
- if (!dbi->dbi_use_cursors) {
- if (dbcp) *dbcp = NULL;
- return 0;
- }
- rc = db3c_open(dbi, txnid, &dbcursor, flags);
+ rc = db->cursor(db, txnid, &dbcursor, flags);
+ rc = cvtdberr(dbi, "db->cursor", rc, _debug);
if (dbcp)
/*@-onlytrans@*/ *dbcp = dbcursor; /*@=onlytrans@*/
+ else
+ (void) db3cclose(dbi, dbcursor, 0);
return rc;
}
-static int db3cput(dbiIndex dbi, DBC * dbcursor, DBT * key, DBT * data)
+static int db3cput(dbiIndex dbi, DBC * dbcursor, DBT * key, DBT * data,
+ unsigned int flags)
/*@globals fileSystem @*/
/*@modifies fileSystem @*/
{
DB * db = dbi->dbi_db;
int rc;
+ assert(db != NULL);
if (dbcursor == NULL) {
- if (db == NULL) return -2;
rc = db->put(db, dbi->dbi_txnid, key, data, 0);
rc = cvtdberr(dbi, "db->put", rc, _debug);
} else {
return rc;
}
-static int db3cdel(dbiIndex dbi, DBC * dbcursor, DBT * key, unsigned int flags)
+static int db3cdel(dbiIndex dbi, DBC * dbcursor, DBT * key, DBT * data,
+ unsigned int flags)
/*@globals fileSystem @*/
/*@modifies *dbcursor, fileSystem @*/
{
DB * db = dbi->dbi_db;
int rc;
+ assert(db != NULL);
if (dbcursor == NULL) {
- if (db == NULL) return -2;
rc = db->del(db, dbi->dbi_txnid, key, flags);
rc = cvtdberr(dbi, "db->del", rc, _debug);
} else {
- DBT * data = alloca(sizeof(*data));
int _printit;
- memset(data, 0, sizeof(*data));
-
+ /* XXX TODO: insure that cursor is positioned with duplicates */
rc = dbcursor->c_get(dbcursor, key, data, DB_SET);
/* XXX DB_NOTFOUND can be returned */
_printit = (rc == DB_NOTFOUND ? 0 : _debug);
rc = cvtdberr(dbi, "dbcursor->c_get", rc, _printit);
if (rc == 0) {
- /* XXX TODO: loop over duplicates */
rc = dbcursor->c_del(dbcursor, flags);
rc = cvtdberr(dbi, "dbcursor->c_del", rc, _debug);
}
-
}
return rc;
}
-static int db3cget(dbiIndex dbi, DBC * dbcursor, DBT * key, DBT * data)
+static int db3cget(dbiIndex dbi, DBC * dbcursor, DBT * key, DBT * data,
+ unsigned int flags)
/*@globals fileSystem @*/
/*@modifies *dbcursor, *key, *data, fileSystem @*/
{
DB * db = dbi->dbi_db;
int rc;
+ assert(db != NULL);
if (dbcursor == NULL) {
int _printit;
- /*@-compmempass@*/
- if (db == NULL) return -2;
- /*@=compmempass@*/
-
rc = db->get(db, dbi->dbi_txnid, key, data, 0);
/* XXX DB_NOTFOUND can be returned */
_printit = (rc == DB_NOTFOUND ? 0 : _debug);
DB * db = dbi->dbi_db;
int rc = 0;
- if (db == NULL) return -2;
+ assert(db != NULL);
#if defined(DB_FAST_STAT)
if (flags)
flags = DB_FAST_STAT;
#include "system.h"
-#if defined(__LCLINT__)
-/*@-redef@*/
-typedef unsigned int u_int32_t;
-typedef unsigned short u_int16_t;
-typedef unsigned char u_int8_t;
-/*@-incondefs@*/ /* LCLint 3.0.0.15 */
-typedef int int32_t;
-/*@=incondefs@*/
-/*@=redef@*/
-#endif
-
#include <rpmlib.h>
#include <rpmmacro.h>
+++ /dev/null
-/** \ingroup rpmio db1
- * \file rpmdb/falloc.c
- *
- * The entire file space is thus divided into blocks with a "struct fablock"
- * at the header of each. The size fields doubly link this block list.
- *
- * There is an additional free list weaved through the block list, which
- * keeps new allocations fast.
- *
- * Much of this was inspired by Knuth vol 1.
- *
- */
-
-#include "system.h"
-#include <rpmio_internal.h>
-#include <rpmmessages.h>
-#include <rpmerr.h>
-#include "falloc.h"
-#include "debug.h"
-
-/** \ingroup db1
- */
-#define FA_MAGIC 0x02050920
-
-struct faFileHeader {
- unsigned int magic;
- unsigned int firstFree;
-};
-
-struct faHeader {
- unsigned int size;
- unsigned int freeNext; /* offset of the next free block, 0 if none */
- unsigned int freePrev;
- unsigned int isFree;
-
- /* note that the u16's appear last for alignment/space reasons */
-};
-
-struct faFooter {
- unsigned int size;
- unsigned int isFree;
-} ;
-
-/* =============================================================== */
-/*@-nullassign@*/
-static struct FDIO_s fadio_s = {
- NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
- fadOpen, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL
-};
-/*@=nullassign@*/
-FDIO_t fadio = /*@-compmempass@*/ &fadio_s /*@=compmempass@*/ ;
-/* =============================================================== */
-
-/**
- * pread(2) clone.
- */
-static
-ssize_t Pread(FD_t fd, void * buf, size_t count, _libio_off_t offset)
- /*@globals fileSystem @*/
- /*@modifies fd, *buf, fileSystem @*/
-{
- if (Fseek(fd, offset, SEEK_SET) < 0)
- return -1;
- /*@-sizeoftype@*/
- return Fread(buf, sizeof(char), count, fd);
- /*@=sizeoftype@*/
-}
-
-/**
- * pwrite(2) clone.
- */
-static
-ssize_t Pwrite(FD_t fd, const void * buf, size_t count, _libio_off_t offset)
- /*@globals fileSystem @*/
- /*@modifies fd, fileSystem @*/
-{
- if (Fseek(fd, offset, SEEK_SET) < 0)
- return -1;
- /*@-sizeoftype@*/
- return Fwrite(buf, sizeof(char), count, fd);
- /*@=sizeoftype@*/
-}
-
-/* flags are the same as for open(2) - NULL returned on error */
-FD_t fadOpen(const char * path, int flags, mode_t perms)
-{
- struct faFileHeader newHdr;
- FD_t fd;
-
- if (flags & O_WRONLY)
- return NULL;
-
- /*@-type@*/ /* FIX: cast? */
- fd = ufdio->_open(path, flags, perms);
- /*@=type@*/
- if (Ferror(fd))
- /* XXX Fstrerror */
- return NULL;
-
- /*@-modobserver -observertrans -mods @*/
- memcpy(fadio, fdio, sizeof(*fadio));
- fadio->_open = fadOpen;
- /*@=modobserver =observertrans =mods @*/
-
- fdSetIo(fd, fadio);
- fadSetFirstFree(fd, 0);
- fadSetFileSize(fd, Fseek(fd, 0, SEEK_END));
-
- /* is this file brand new? */
- if (fadGetFileSize(fd) == 0) {
- newHdr.magic = FA_MAGIC;
- newHdr.firstFree = 0;
- /*@-sizeoftype@*/
- if (Fwrite(&newHdr, sizeof(char), sizeof(newHdr), fd) != sizeof(newHdr)) {
- (void) Fclose(fd);
- return NULL;
- }
- /*@=sizeoftype@*/
- fadSetFirstFree(fd, 0);
- fadSetFileSize(fd, sizeof(newHdr));
- } else {
- memset(&newHdr, 0, sizeof(newHdr));
- if (Pread(fd, &newHdr, sizeof(newHdr), 0) != sizeof(newHdr)) {
- (void) Fclose(fd);
- return NULL;
- }
- if (newHdr.magic != FA_MAGIC) {
- (void) Fclose(fd);
- return NULL;
- }
- fadSetFirstFree(fd, newHdr.firstFree);
- fadSetFileSize(fd, Fseek(fd, 0, SEEK_END));
-
- if (fadGetFileSize(fd) < 0) {
- (void) Fclose(fd);
- return NULL;
- }
- }
-
- /*@-refcounttrans@*/ return fd /*@=refcounttrans@*/ ;
-}
-
-/* returns 0 on failure */
-unsigned int fadAlloc(FD_t fd, unsigned int size)
-{
- unsigned int nextFreeBlock;
- unsigned int newBlockOffset;
- unsigned int footerOffset;
- int failed = 0;
- struct faFileHeader faHeader;
- struct faHeader header, origHeader;
- struct faHeader * restoreHeader = NULL;
- struct faHeader nextFreeHeader, origNextFreeHeader;
- struct faHeader * restoreNextHeader = NULL;
- struct faHeader prevFreeHeader, origPrevFreeHeader;
- struct faHeader * restorePrevHeader = NULL;
- struct faFooter footer, origFooter;
- struct faFooter * restoreFooter = NULL;
- int updateHeader = 0;
-
- memset(&header, 0, sizeof(header));
-
- /* our internal idea of size includes overhead */
- /*@-sizeoftype@*/
- size += sizeof(struct faHeader) + sizeof(struct faFooter);
- /*@=sizeoftype@*/
-
- /* Make sure they are allocing multiples of 64 bytes. It'll keep
- things less fragmented that way */
- (size % 64) ? size += (64 - (size % 64)) : 0;
-
- /* find a block via first fit - see Knuth vol 1 for why */
- /* XXX this could be optimized a bit still */
-
- nextFreeBlock = fadGetFirstFree(fd);
- newBlockOffset = 0;
-
- while (nextFreeBlock && !newBlockOffset) {
- if (Pread(fd, &header, sizeof(header), nextFreeBlock) != sizeof(header)) return 0;
-
-/* XXX W2DO? exit(EXIT_FAILURE) forces the user to discover rpm --rebuilddb */
- if (!header.isFree) {
- rpmError(RPMERR_FREELIST, _("free list corrupt (%u)- please run\n"
- "\t\"rpm --rebuilddb\"\n"
- "More information is available from http://www.rpm.org "
- "or the rpm-list@redhat.com mailing list\n"
- "if \"rpm --rebuilddb\" fails to correct the problem.\n"),
- nextFreeBlock);
-
- exit(EXIT_FAILURE);
- /*@notreached@*/
- }
-
- if (header.size >= size) {
- newBlockOffset = nextFreeBlock;
- } else {
- nextFreeBlock = header.freeNext;
- }
- }
-
- if (newBlockOffset) {
- /* header should still be good from the search */
- origHeader = header;
-
- footerOffset = newBlockOffset + header.size - sizeof(footer);
-
- if (Pread(fd, &footer, sizeof(footer), footerOffset) != sizeof(footer))
- return 0;
- origFooter = footer;
-
- /* should we split this block into two? */
- /* XXX implement fragment creation here */
-
- footer.isFree = header.isFree = 0;
-
- /* remove it from the free list before */
- if (newBlockOffset == fadGetFirstFree(fd)) {
- faHeader.magic = FA_MAGIC;
- faHeader.firstFree = header.freeNext;
- fadSetFirstFree(fd, header.freeNext);
- updateHeader = 1;
- } else {
- if (Pread(fd, &prevFreeHeader, sizeof(prevFreeHeader),
- header.freePrev) != sizeof(prevFreeHeader))
- return 0;
- origPrevFreeHeader = prevFreeHeader;
-
- prevFreeHeader.freeNext = header.freeNext;
- }
-
- /* and after */
- if (header.freeNext) {
- if (Pread(fd, &nextFreeHeader, sizeof(nextFreeHeader),
- header.freeNext) != sizeof(nextFreeHeader))
- return 0;
- origNextFreeHeader = nextFreeHeader;
-
- nextFreeHeader.freePrev = header.freePrev;
- }
-
- /* if any of these fail, try and restore everything before leaving */
- if (updateHeader) {
- if (Pwrite(fd, &faHeader, sizeof(faHeader), 0) !=
- sizeof(faHeader))
- return 0;
- } else {
- if (Pwrite(fd, &prevFreeHeader, sizeof(prevFreeHeader),
- header.freePrev) != sizeof(prevFreeHeader))
- return 0;
- restorePrevHeader = &origPrevFreeHeader;
- }
-
- if (header.freeNext) {
- if (Pwrite(fd, &nextFreeHeader, sizeof(nextFreeHeader),
- header.freeNext) != sizeof(nextFreeHeader))
- return 0;
-
- restoreNextHeader = &origNextFreeHeader;
- }
-
- if (!failed) {
- if (Pwrite(fd, &header, sizeof(header), newBlockOffset) !=
- sizeof(header)) {
- failed = 1;
- restoreHeader = &origHeader;
- }
- }
-
- if (!failed) {
- if (Pwrite(fd, &footer, sizeof(footer),
- footerOffset) != sizeof(footer)) {
- failed = 1;
- restoreFooter = &origFooter;
- }
- }
-
- if (failed) {
- if (updateHeader) {
- faHeader.firstFree = newBlockOffset;
- fadSetFirstFree(fd, newBlockOffset);
- (void)Pwrite(fd, &faHeader, sizeof(faHeader), 0);
- }
-
- if (restorePrevHeader)
- (void)Pwrite(fd, restorePrevHeader, sizeof(*restorePrevHeader),
- header.freePrev);
-
- if (restoreNextHeader)
- (void)Pwrite(fd, restoreNextHeader, sizeof(*restoreNextHeader),
- header.freeNext);
-
- if (restoreHeader)
- (void)Pwrite(fd, restoreHeader, sizeof(header),
- newBlockOffset);
-
- if (restoreFooter)
- (void)Pwrite(fd, restoreFooter, sizeof(footer),
- footerOffset);
-
- return 0;
- }
- } else {
- char * space;
-
- /* make a new block */
- newBlockOffset = fadGetFileSize(fd);
- footerOffset = newBlockOffset + size - sizeof(footer);
-
- space = alloca(size);
- if (space == NULL) return 0;
- memset(space, 0, size);
-
- footer.isFree = header.isFree = 0;
- footer.size = header.size = size;
- header.freePrev = header.freeNext = 0;
-
- /* reserve all space up front */
- /* XXX TODO: check max. no. of bytes to write */
- if (Pwrite(fd, space, size, newBlockOffset) != size)
- return 0;
-
- if (Pwrite(fd, &header, sizeof(header), newBlockOffset) != sizeof(header))
- return 0;
-
- if (Pwrite(fd, &footer, sizeof(footer), footerOffset) != sizeof(footer))
- return 0;
-
- fadSetFileSize(fd, fadGetFileSize(fd) + size);
- }
-
- return newBlockOffset + sizeof(header);
-}
-
-void fadFree(FD_t fd, unsigned int offset)
-{
- struct faHeader header;
- struct faFooter footer;
- int footerOffset;
- int prevFreeOffset, nextFreeOffset;
- struct faHeader prevFreeHeader, nextFreeHeader;
- struct faFileHeader faHeader;
-
- /* any errors cause this to die, and thus result in lost space in the
- database. which is at least better then corruption */
-
- offset -= sizeof(header);
-
- /* find out where in the (sorted) free list to put this */
- prevFreeOffset = fadGetFirstFree(fd);
-
- if (!prevFreeOffset || (prevFreeOffset > offset)) {
- nextFreeOffset = fadGetFirstFree(fd);
- prevFreeOffset = 0;
- } else {
- memset(&prevFreeHeader, 0, sizeof(prevFreeHeader));
- if (Pread(fd, &prevFreeHeader, sizeof(prevFreeHeader),
- prevFreeOffset) != sizeof(prevFreeHeader))
- return;
-
- while (prevFreeHeader.freeNext && prevFreeHeader.freeNext < offset) {
- prevFreeOffset = prevFreeHeader.freeNext;
- if (Pread(fd, &prevFreeHeader, sizeof(prevFreeHeader),
- prevFreeOffset) != sizeof(prevFreeHeader))
- return;
- }
-
- nextFreeOffset = prevFreeHeader.freeNext;
- }
-
- if (nextFreeOffset) {
- memset(&nextFreeHeader, 0, sizeof(nextFreeHeader));
- if (Pread(fd, &nextFreeHeader, sizeof(nextFreeHeader),
- nextFreeOffset) != sizeof(nextFreeHeader))
- return;
- }
-
- memset(&header, 0, sizeof(header));
- if (Pread(fd, &header, sizeof(header), offset) != sizeof(header))
- return;
-
- footerOffset = offset + header.size - sizeof(footer);
-
- memset(&footer, 0, sizeof(footer));
- if (Pread(fd, &footer, sizeof(footer), footerOffset) != sizeof(footer))
- return;
-
- header.isFree = 1;
- header.freeNext = nextFreeOffset;
- header.freePrev = prevFreeOffset;
- footer.isFree = 1;
-
- /* XXX TODO: set max. no. of bytes to write */
- (void)Pwrite(fd, &header, sizeof(header), offset);
-
- (void)Pwrite(fd, &footer, sizeof(footer), footerOffset);
-
- if (nextFreeOffset) {
- nextFreeHeader.freePrev = offset;
- if (Pwrite(fd, &nextFreeHeader, sizeof(nextFreeHeader),
- nextFreeOffset) != sizeof(nextFreeHeader))
- return;
- }
-
- if (prevFreeOffset) {
- prevFreeHeader.freeNext = offset;
- if (Pwrite(fd, &prevFreeHeader, sizeof(prevFreeHeader),
- prevFreeOffset) != sizeof(prevFreeHeader))
- return;
- } else {
- fadSetFirstFree(fd, offset);
-
- faHeader.magic = FA_MAGIC;
- faHeader.firstFree = fadGetFirstFree(fd);
-
- /* XXX TODO: set max. no. of bytes to write */
- if (Pwrite(fd, &faHeader, sizeof(faHeader), 0) != sizeof(faHeader))
- return;
- }
-}
-
-static int fadSanity(FD_t fd, int offset, const struct faHeader * fh, int printit)
- /*@*/
-{
- int rc = 0;
-
- /*@-sizeoftype@*/
- /* Check size range and alignment. */
- if (!(fh->size > 0 && fh->size <= 0x00200000 && (fh->size & 0x3f) == 0))
- rc |= 0x1;
-
- /* Check forward link range, alignment and offset. */
- if (fh->freeNext &&
- !( fh->freeNext > sizeof(struct faFileHeader) &&
- fh->freeNext < fadGetFileSize(fd) &&
- (fh->freeNext & 0x3f) == sizeof(struct faFileHeader)) )
- rc |= 0x2;
-
- /* Check backward link range, alignment and offset. */
- if (fh->freePrev &&
- !( fh->freePrev > sizeof(struct faFileHeader) &&
- fh->freePrev < fadGetFileSize(fd) &&
- (fh->freePrev & 0x3f) == sizeof(struct faFileHeader)) )
- rc |= 0x4;
- /*@=sizeoftype@*/
-
- /* Check that only the isFree bit is (possibly) set. */
- if (fh->isFree & ~1)
- rc |= 0x8;
-
- if (printit && rc) {
- rpmMessage(RPMMESS_DEBUG,
- "offset %d(0x%08x) rc %d: size 0x%08x next %d(0x%08x) prev %d(0x%08x) isFree 0x%08x\n",
- offset, (unsigned) offset, rc,
- (unsigned) fh->size,
- (int) fh->freeNext, fh->freeNext,
- (int) fh->freePrev, fh->freePrev,
- (unsigned) fh->isFree);
- }
- return rc;
-}
-
-int fadFirstOffset(FD_t fd)
-{
- return fadNextOffset(fd, 0);
-}
-
-int fadNextOffset(FD_t fd, unsigned int lastoff)
-{
- struct faHeader header;
- int offset;
-
- /*@-sizeoftype@*/
- offset = (lastoff)
- ? (lastoff - sizeof(header))
- : sizeof(struct faFileHeader);
- /*@=sizeoftype@*/
-
- if (offset >= fadGetFileSize(fd))
- return 0;
-
- memset(&header, 0, sizeof(header));
- if (Pread(fd, &header, sizeof(header), offset) != sizeof(header))
- return 0;
-
- if (!lastoff && header.isFree == 0)
- return (offset + sizeof(header));
-
- /*
- * XXX Try to reconnect at next record found. This isn't perfect
- * XXX but handles many common db1 corruption problems.
- */
- if (fadSanity(fd, offset, &header, 0)) {
- struct faHeader myheader;
- int o = offset;
-
- memset(&myheader, 0, sizeof(myheader));
- do {
- o += 0x40; /* XXX allocation chunks are padded to 64b */
- if (o >= fadGetFileSize(fd))
- return 0;
- if (Pread(fd, &myheader, sizeof(myheader), o) != sizeof(header))
- return 0;
- } while (fadSanity(fd, o, &myheader, 0));
- return (o + sizeof(header));
- }
-
- do {
- offset += header.size;
- if (offset >= fadGetFileSize(fd))
- return 0;
-
- if (Pread(fd, &header, sizeof(header), offset) != sizeof(header))
- return 0;
-
- } while (header.isFree == 1);
-
- /* Sanity check this to make sure we're not going in loops */
- offset += sizeof(header);
- if (offset <= lastoff)
- return 0; /* XXX used to return -1 */
-
- return offset;
-}
+++ /dev/null
-#ifndef H_FALLOC
-#define H_FALLOC
-
-/** \ingroup db1
- * \file rpmdb/falloc.h
- * File space allocation routines.
- *
- * Best fit allocation is used, free blocks are compacted. Minimal
- * fragmentation is more important then speed. This uses 32 bit
- * offsets on all platforms and should be byte order independent.
- */
-
-/*@access FD_t@*/
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/*@unused@*/ static inline long int fadGetFileSize(FD_t fd) /*@*/ {
- return fd->fileSize;
-}
-
-/*@unused@*/ static inline void fadSetFileSize(FD_t fd, long int fileSize)
- /*@modifies fd @*/
-{
- fd->fileSize = fileSize;
-}
-
-/*@unused@*/ static inline unsigned int fadGetFirstFree(FD_t fd) /*@*/ {
- return fd->firstFree;
-}
-
-/*@unused@*/ static inline void fadSetFirstFree(FD_t fd, unsigned int firstFree)
- /*@modifies fd @*/
-{
- fd->firstFree = firstFree;
-}
-
-/** \ingroup db1
- */
-/*@null@*/ FD_t fadOpen(const char * path, int flags, mode_t perms)
- /*@globals fileSystem @*/
- /*@modifies fileSystem @*/;
-
-/** \ingroup db1
- * @param fd file handle
- * @param size
- * @return 0 on failure
- */
-unsigned int fadAlloc(FD_t fd, unsigned int size)
- /*@globals fileSystem @*/
- /*@modifies fd, fileSystem @*/;
-
-/** \ingroup db1
- * @param fd file handle
- * @param offset
- */
-void fadFree(FD_t fd, unsigned int offset)
- /*@globals fileSystem @*/
- /*@modifies fd, fileSystem @*/;
-
-/** \ingroup db1
- * @param fd file handle
- */
-int fadFirstOffset(FD_t fd)
- /*@globals fileSystem @*/
- /*@modifies fd, fileSystem @*/;
-
-/** \ingroup db1
- * @param fd file handle
- * @param lastoff
- * @return next offset, 0 to terminate
- */
-int fadNextOffset(FD_t fd, unsigned int lastoff)
- /*@globals fileSystem @*/
- /*@modifies fd, fileSystem @*/;
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* H_FALLOC */
needle = dirNames;
savechar = *baseName;
*baseName = '\0';
+/*@-compdef@*/
if (dirIndex < 0 ||
(needle = bsearch(&fileNames[i], dirNames, dirIndex + 1, sizeof(dirNames[0]), dncmp)) == NULL) {
char *s = alloca(len + 1);
dirNames[dirIndex] = s;
} else
dirIndexes[i] = needle - dirNames;
+/*@=compdef@*/
*baseName = savechar;
baseNames[i] = baseName;
/*@access pgpDig@*/
/*@unchecked@*/
-static int _debug = 0;
-#define INLINE
-
-/*@unchecked@*/
static int _rebuildinprogress = 0;
/*@unchecked@*/
static int _db_filter_dups = 0;
* @param tagNum tag index in header
* @return new item
*/
-static INLINE dbiIndexItem dbiIndexNewItem(unsigned int hdrNum, unsigned int tagNum)
+static dbiIndexItem dbiIndexNewItem(unsigned int hdrNum, unsigned int tagNum)
/*@*/
{
dbiIndexItem rec = xcalloc(1, sizeof(*rec));
if (keylen == 0) keylen = strlen(keyp);
memset(key, 0, sizeof(*key));
+/*@-temptrans@*/
key->data = (void *) keyp;
+/*@=temptrans@*/
key->size = keylen;
memset(data, 0, sizeof(*data));
data->data = datap;
data->size = datalen;
- rc = dbiGet(dbi, dbcursor, key, data);
+ rc = dbiGet(dbi, dbcursor, key, data, 0);
keyp = key->data;
keylen = key->size;
datap = data->data;
{
DBT * key = alloca(sizeof(*key));
DBT * data = alloca(sizeof(*data));
- void * datap;
- size_t datalen;
+ void * datap = NULL;
+ size_t datalen = 0;
int rc;
if (set->count) {
}
memset(key, 0, sizeof(*key));
+/*@-temptrans@*/
key->data = (void *) keyp;
+/*@=temptrans@*/
key->size = keylen;
memset(data, 0, sizeof(*data));
data->data = datap;
data->size = datalen;
- rc = dbiPut(dbi, dbcursor, key, data);
+/*@-compdef@*/
+ rc = dbiPut(dbi, dbcursor, key, data, 0);
+/*@=compdef@*/
if (rc) {
rpmError(RPMERR_DBPUTINDEX,
} else {
memset(key, 0, sizeof(*key));
+/*@-temptrans@*/
key->data = (void *) keyp;
+/*@=temptrans@*/
key->size = keylen;
- rc = dbiDel(dbi, dbcursor, key, 0);
+ memset(data, 0, sizeof(*data));
+ data->data = datap;
+ data->size = datalen;
+/*@-compdef@*/
+ rc = dbiDel(dbi, dbcursor, key, data, 0);
+/*@=compdef@*/
if (rc) {
rpmError(RPMERR_DBPUTINDEX,
* @param sortset should resulting set be sorted?
* @return 0 success, 1 failure (bad args)
*/
-static INLINE int dbiAppendSet(dbiIndexSet set, const void * recs,
+static int dbiAppendSet(dbiIndexSet set, const void * recs,
int nrecs, size_t recsize, int sortset)
/*@modifies *set @*/
{
* @param sorted array is already sorted?
* @return 0 success, 1 failure (no items found)
*/
-static INLINE int dbiPruneSet(dbiIndexSet set, void * recs, int nrecs,
+static int dbiPruneSet(dbiIndexSet set, void * recs, int nrecs,
size_t recsize, int sorted)
/*@modifies set, recs @*/
{
DBT * data = alloca(sizeof(*data));
memset(key, 0, sizeof(*key));
+/*@-immediatetrans@*/
key->data = (void *) &offset;
+/*@=immediatetrans@*/
key->size = sizeof(offset);
memset(data, 0, sizeof(*data));
data->data = uh;
data->size = uhlen;
(void) blockSignals(dbi->dbi_rpmdb, &signalMask);
- rc = dbiPut(dbi, dbcursor, key, data);
+ rc = dbiPut(dbi, dbcursor, key, data, 0);
xx = dbiSync(dbi, 0);
(void) unblockSignals(dbi->dbi_rpmdb, &signalMask);
+/*@-kepttrans@*/
uh = _free(uh);
+/*@=kepttrans@*/
} else
fprintf(stderr, "*** dbiUpdateRecord: uh is NULL\n");
return rc;
mi->mi_version = _free(mi->mi_version);
/*@-branchstate@*/
if (dbi && mi->mi_dbc)
- xx = dbiCclose(dbi, mi->mi_dbc, DBI_ITERATOR);
+ xx = dbiCclose(dbi, mi->mi_dbc, 0);
/*@=branchstate@*/
mi->mi_dbc = NULL;
mi->mi_set = dbiFreeIndexSet(mi->mi_set);
int rc;
if (mi == NULL)
return 0;
- rc = (mi->mi_cflags & DBI_WRITECURSOR) ? 1 : 0;
+ rc = (mi->mi_cflags & DB_WRITECURSOR) ? 1 : 0;
if (rewrite)
- mi->mi_cflags |= DBI_WRITECURSOR;
+ mi->mi_cflags |= DB_WRITECURSOR;
else
- mi->mi_cflags &= ~DBI_WRITECURSOR;
+ mi->mi_cflags &= ~DB_WRITECURSOR;
return rc;
}
return rpmdbNextIterator(mi);
}
+/*@-compmempass@*/
Header rpmdbNextIterator(rpmdbMatchIterator mi)
{
dbiIndex dbi;
* marked with DB_WRITECURSOR as well.
*/
if (mi->mi_dbc == NULL)
- xx = dbiCopen(dbi, dbi->dbi_txnid, &mi->mi_dbc, (mi->mi_cflags | DBI_ITERATOR));
+ xx = dbiCopen(dbi, dbi->dbi_txnid, &mi->mi_dbc, mi->mi_cflags);
dbi->dbi_lastoffset = mi->mi_prevoffset;
key = alloca(sizeof(*key));
data = alloca(sizeof(*data));
/* XXX skip over instances with 0 join key */
do {
+ /*@-branchstate@*/
if (mi->mi_set) {
if (!(mi->mi_setx < mi->mi_set->count))
return NULL;
memset(data, 0, sizeof(*data));
data->data = uh;
data->size = uhlen;
- rc = dbiGet(dbi, mi->mi_dbc, key, data);
+ rc = dbiGet(dbi, mi->mi_dbc, key, data, 0);
keyp = key->data;
keylen = key->size;
uh = data->data;
if (rc || (mi->mi_setx && mi->mi_offset == 0))
return NULL;
}
+ /*@=branchstate@*/
mi->mi_setx++;
} while (mi->mi_offset == 0);
goto exit;
/* Retrieve next header */
+ /*@-branchstate -immediatetrans @*/
if (uh == NULL) {
memset(key, 0, sizeof(*key));
key->data = keyp;
memset(data, 0, sizeof(*data));
uh = data->data;
uhlen = data->size;
- rc = dbiGet(dbi, mi->mi_dbc, key, data);
+ rc = dbiGet(dbi, mi->mi_dbc, key, data, 0);
keyp = key->data;
keylen = key->size;
uh = data->data;
if (rc)
return NULL;
}
+ /*@=branchstate =immediatetrans @*/
/* Free current header */
if (mi->mi_h) {
/*@-compdef -usereleased@*/ return mi->mi_h; /*@=compdef =usereleased@*/
/*@=retexpose =retalias@*/
}
+/*@=compmempass@*/
static void rpmdbSortIterator(/*@null@*/ rpmdbMatchIterator mi)
/*@modifies mi @*/
* @param rec record to remove
* @return 0 on success
*/
-static INLINE int removeIndexEntry(dbiIndex dbi, DBC * dbcursor,
+static int removeIndexEntry(dbiIndex dbi, DBC * dbcursor,
const void * keyp, size_t keylen, dbiIndexItem rec)
/*@globals fileSystem @*/
/*@modifies *dbcursor, fileSystem @*/
int rpmdbRemove(rpmdb db, /*@unused@*/ int rid, unsigned int hdrNum)
{
DBT * key = alloca(sizeof(*key));
+ DBT * data = alloca(sizeof(*data));
HGE_t hge = (HGE_t)headerGetEntryMinMemory;
HFD_t hfd = headerFreeData;
Header h;
if (dbi != NULL) {
memset(key, 0, sizeof(*key));
+/*@-immediatetrans@*/
key->data = &hdrNum;
+/*@=immediatetrans@*/
key->size = sizeof(hdrNum);
+ memset(data, 0, sizeof(*data));
- xx = dbiCopen(dbi, dbi->dbi_txnid, &dbcursor, DBI_WRITECURSOR);
- xx = dbiDel(dbi, dbcursor, key, 0);
- xx = dbiCclose(dbi, dbcursor, DBI_WRITECURSOR);
+ xx = dbiCopen(dbi, dbi->dbi_txnid, &dbcursor, DB_WRITECURSOR);
+ xx = dbiDel(dbi, dbcursor, key, data, 0);
+ xx = dbiCclose(dbi, dbcursor, DB_WRITECURSOR);
dbcursor = NULL;
if (!dbi->dbi_no_dbsync)
xx = dbiSync(dbi, 0);
}
printed = 0;
- xx = dbiCopen(dbi, dbi->dbi_txnid, &dbcursor, DBI_WRITECURSOR);
+ xx = dbiCopen(dbi, dbi->dbi_txnid, &dbcursor, DB_WRITECURSOR);
for (i = 0; i < rpmcnt; i++) {
const void * valp;
size_t vallen;
xx = removeIndexEntry(dbi, dbcursor, valp, vallen, rec);
}
- xx = dbiCclose(dbi, dbcursor, DBI_WRITECURSOR);
+ xx = dbiCclose(dbi, dbcursor, DB_WRITECURSOR);
dbcursor = NULL;
if (!dbi->dbi_no_dbsync)
* @param rec record to add
* @return 0 on success
*/
-static INLINE int addIndexEntry(dbiIndex dbi, DBC * dbcursor,
+static int addIndexEntry(dbiIndex dbi, DBC * dbcursor,
const char * keyp, size_t keylen, dbiIndexItem rec)
/*@globals fileSystem @*/
/*@modifies *dbcursor, fileSystem @*/
datap = h;
datalen = headerSizeof(h, HEADER_MAGIC_NO);
- xx = dbiCopen(dbi, dbi->dbi_txnid, &dbcursor, DBI_WRITECURSOR);
+ xx = dbiCopen(dbi, dbi->dbi_txnid, &dbcursor, DB_WRITECURSOR);
/* Retrieve join key for next header instance. */
key->data = keyp;
key->size = keylen;
memset(data, 0, sizeof(*data));
- data->data = datap;
+/*@i@*/ data->data = datap;
data->size = datalen;
- rc = dbiGet(dbi, dbcursor, key, data);
+/*@-compmempass@*/
+ rc = dbiGet(dbi, dbcursor, key, data, 0);
+/*@=compmempass@*/
keyp = key->data;
keylen = key->size;
datap = data->data;
key->data = keyp;
key->size = keylen;
memset(data, 0, sizeof(*data));
+/*@-kepttrans@*/
data->data = datap;
+/*@=kepttrans@*/
data->size = datalen;
- rc = dbiPut(dbi, dbcursor, key, data);
+/*@-compmempass@*/
+ rc = dbiPut(dbi, dbcursor, key, data, 0);
+/*@=compmempass@*/
xx = dbiSync(dbi, 0);
- xx = dbiCclose(dbi, dbcursor, DBI_WRITECURSOR);
+ xx = dbiCclose(dbi, dbcursor, DB_WRITECURSOR);
dbcursor = NULL;
}
/*@=branchstate@*/
case RPMDBI_PACKAGES:
dbi = dbiOpen(db, rpmtag, 0);
if (dbi != NULL) {
- xx = dbiCopen(dbi, dbi->dbi_txnid, &dbcursor, DBI_WRITECURSOR);
+ xx = dbiCopen(dbi, dbi->dbi_txnid, &dbcursor, DB_WRITECURSOR);
xx = dbiUpdateRecord(dbi, dbcursor, hdrNum, h);
- xx = dbiCclose(dbi, dbcursor, DBI_WRITECURSOR);
+ xx = dbiCclose(dbi, dbcursor, DB_WRITECURSOR);
dbcursor = NULL;
if (!dbi->dbi_no_dbsync)
xx = dbiSync(dbi, 0);
}
printed = 0;
- xx = dbiCopen(dbi, dbi->dbi_txnid, &dbcursor, DBI_WRITECURSOR);
+ xx = dbiCopen(dbi, dbi->dbi_txnid, &dbcursor, DB_WRITECURSOR);
for (i = 0; i < rpmcnt; i++) {
const void * valp;
size_t vallen;
}
rc += addIndexEntry(dbi, dbcursor, valp, vallen, rec);
}
- xx = dbiCclose(dbi, dbcursor, DBI_WRITECURSOR);
+ xx = dbiCclose(dbi, dbcursor, DB_WRITECURSOR);
dbcursor = NULL;
if (!dbi->dbi_no_dbsync)
int (*copen) (dbiIndex dbi, /*@null@*/ DB_TXN * txnid,
/*@out@*/ DBC ** dbcp, unsigned int flags)
/*@globals fileSystem@*/
- /*@modifies dbi, *txnidp, *dbcp, fileSystem @*/;
+ /*@modifies dbi, *txnid, *dbcp, fileSystem @*/;
/** \ingroup dbi
* Close database cursor.
* @param dbi index database handle
* @param dbcursor database cursor (NULL will use db->del)
* @param key delete key value/length/flags
+ * @param data delete data value/length/flags
* @param flags (unused)
* @return 0 on success
*/
- int (*cdel) (dbiIndex dbi, /*@null@*/ DBC * dbcursor, DBT * key,
+ int (*cdel) (dbiIndex dbi, /*@null@*/ DBC * dbcursor, DBT * key, DBT * data,
unsigned int flags)
/*@globals fileSystem@*/
/*@modifies *dbcursor, fileSystem @*/;
* @param dbcursor database cursor (NULL will use db->get)
* @param key retrieve key value/length/flags
* @param data retrieve data value/length/flags
+ * @param flags (unused)
* @return 0 on success
*/
- int (*cget) (dbiIndex dbi, /*@null@*/ DBC * dbcursor, DBT * key, DBT * data)
+ int (*cget) (dbiIndex dbi, /*@null@*/ DBC * dbcursor, DBT * key, DBT * data,
+ unsigned int flags)
/*@globals fileSystem@*/
/*@modifies *dbcursor, *key, *data, fileSystem @*/;
* @param dbcursor database cursor (NULL will use db->put)
* @param key store key value/length/flags
* @param data store data value/length/flags
+ * @param flags (unused)
* @return 0 on success
*/
- int (*cput) (dbiIndex dbi, /*@null@*/ DBC * dbcursor, DBT * key, DBT * data)
+ int (*cput) (dbiIndex dbi, /*@null@*/ DBC * dbcursor, DBT * key, DBT * data,
+ unsigned int flags)
/*@globals fileSystem@*/
/*@modifies *dbcursor, fileSystem @*/;
*/
/*@-redecl@*/
/*@exposed@*/
-extern const char *const prDbiOpenFlags(int dbflags,
- int print_dbenv_flags)
+extern const char *const prDbiOpenFlags(int dbflags, int print_dbenv_flags)
/*@*/;
/*@=redecl@*/
unsigned int flags)
/*@modifies db @*/;
+/*@-globuse -mods -mustmod @*/
/** \ingroup dbi
* Open a database cursor.
* @param dbi index database handle
* @param txnid database transaction handle
* @retval dbcp returned database cursor
- * @param flags DBI_WRITECURSOR, DBI_ITERATOR or 0
+ * @param flags DB_WRITECURSOR if writing, or 0
* @return 0 on success
*/
/*@unused@*/ static inline
return (*dbi->dbi_vec->copen) (dbi, txnid, dbcp, flags);
}
-#define DBI_WRITECURSOR (1 << 0)
-#define DBI_ITERATOR (1 << 1)
-
/** \ingroup dbi
* Close a database cursor.
* @param dbi index database handle
* @param dbi index database handle
* @param dbcursor database cursor (NULL will use db->del)
* @param key delete key value/length/flags
+ * @param data delete data value/length/flags
* @param flags (unused)
* @return 0 on success
*/
/*@unused@*/ static inline
-int dbiDel(dbiIndex dbi, /*@null@*/ DBC * dbcursor, DBT * key,
+int dbiDel(dbiIndex dbi, /*@null@*/ DBC * dbcursor, DBT * key, DBT * data,
unsigned int flags)
/*@globals fileSystem@*/
/*@modifies *dbcursor, fileSystem @*/
int rc;
if (NULkey) key->size++;
- rc = (dbi->dbi_vec->cdel) (dbi, dbcursor, key, flags);
+ rc = (dbi->dbi_vec->cdel) (dbi, dbcursor, key, data, flags);
if (NULkey) key->size--;
return rc;
}
-
/** \ingroup dbi
* Retrieve (key,data) pair from index database.
* @param dbi index database handle
* @param dbcursor database cursor (NULL will use db->get)
* @param key retrieve key value/length/flags
* @param data retrieve data value/length/flags
+ * @param flags (unused)
* @return 0 on success
*/
/*@unused@*/ static inline
-int dbiGet(dbiIndex dbi, /*@null@*/ DBC * dbcursor, DBT * key, DBT * data)
+int dbiGet(dbiIndex dbi, /*@null@*/ DBC * dbcursor, DBT * key, DBT * data,
+ unsigned int flags)
/*@globals fileSystem@*/
/*@modifies *dbcursor, *key, *data, fileSystem @*/
{
int rc;
if (NULkey) key->size++;
- rc = (dbi->dbi_vec->cget) (dbi, dbcursor, key, data);
+ rc = (dbi->dbi_vec->cget) (dbi, dbcursor, key, data, flags);
if (NULkey) key->size--;
return rc;
}
* @param dbcursor database cursor (NULL will use db->put)
* @param key store key value/length/flags
* @param data store data value/length/flags
+ * @param flags (unused)
* @return 0 on success
*/
/*@unused@*/ static inline
-int dbiPut(dbiIndex dbi, /*@null@*/ DBC * dbcursor, DBT * key, DBT * data)
+int dbiPut(dbiIndex dbi, /*@null@*/ DBC * dbcursor, DBT * key, DBT * data,
+ unsigned int flags)
/*@globals fileSystem@*/
/*@modifies *dbcursor, *key, fileSystem @*/
{
int rc;
if (NULkey) key->size++;
- rc = (dbi->dbi_vec->cput) (dbi, dbcursor, key, data);
+ rc = (dbi->dbi_vec->cput) (dbi, dbcursor, key, data, flags);
if (NULkey) key->size--;
return rc;
}
/*@=mods@*/
return dbi->dbi_byteswapped;
}
+/*@=globuse =mods =mustmod @*/
/** \ingroup db1
* Return base file name for db1 database (legacy).
RPMMESS_ALTNAME = _em(38), /*!< file written as .rpmnew */
RPMMESS_PREREQLOOP = _em(39), /*!< loop in prerequisites */
RPMERR_BADRELOCATE = _em(40), /*!< bad relocation was specified */
-/*@=enummemuse@*/
RPMERR_OLDDB = _em(41), /*!< old format database */
+/*@=enummemuse@*/
RPMERR_UNMATCHEDIF = _em(107), /*!< unclosed %ifarch or %ifos */
RPMERR_RELOAD = _em(108), /*!< */
#endif
#include <sys/types.h>
+#if defined(__LCLINT__)
+/*@-redef@*/
+typedef unsigned int u_int32_t;
+typedef unsigned short u_int16_t;
+typedef unsigned char u_int8_t;
+/*@-incondefs@*/ /* LCLint 3.0.0.15 */
+typedef int int32_t;
+/*@=incondefs@*/
+/*@=redef@*/
+#endif
+
#include <sys/stat.h>
#include <stdio.h>
projects / platform / upstream / rpm.git / commitdiff