- boring lclint annotations and fiddles.
- transaction iterator(s) need to run in reverse order on pure erasures.
- erasures not yet strict, warn & chug on unlink(2)/rmdir(2) failure.
+ - more boring lclint annotations and fiddles.
4.0 -> 4.0.[12]
- add doxygen and lclint annotations most everywhere.
@echo expect 10 shift/reduce conflicts
$(YACC) $(srcdir)/getdate.y
-@if test -f y.tab.c; then \
- mv y.tab.c getdate.c ;\
+ { echo "/*@-unqualifiedtrans -usedef -varuse -globstate@*/";\
+ cat y.tab.c ;\
+ echo "/*@=unqualifiedtrans =usedef =varuse =globstate@*/";\
+ } > getdate.c ;\
+ rm -f y.tab.c; \
else \
if test -f getdate.tab.c ; then \
mv getdate.tab.c getdate.c ; \
/*@access rpmdb@*/
/*@access dbiIndex@*/
/*@access dbiIndexSet@*/
+/*@-onlytrans@*/
/* XXX remap DB3 types back into DB1 types */
static inline DBTYPE db3_to_dbtype(int dbitype)
/*@notreached@*/ return DB_HASH;
}
+/*@-shadow@*/
static /*@observer@*/ char * db_strerror(int error)
+/*@=shadow@*/
{
if (error == 0)
return ("Successful return: 0");
return 0;
}
+/*@-compmempass@*/
static int db1cget(dbiIndex dbi, /*@unused@*/ DBC * dbcursor, void ** keyp,
size_t * keylen, void ** datap, size_t * datalen,
/*@unused@*/ unsigned int flags)
memset(&key, 0, sizeof(key));
memset(&data, 0, sizeof(data));
+ /*@-unqualifiedtrans@*/
if (keyp) key.data = *keyp;
if (keylen) key.size = *keylen;
if (datap) data.data = *datap;
if (datalen) data.size = *datalen;
+ /*@=unqualifiedtrans@*/
if (dbi->dbi_rpmtag == RPMDBI_PACKAGES) {
FD_t pkgs = dbi->dbi_db;
} else {
dbi->dbi_lastoffset = fadNextOffset(pkgs, dbi->dbi_lastoffset);
}
+ /*@-immediatetrans@*/
key.data = &dbi->dbi_lastoffset;
+ /*@=immediatetrans@*/
key.size = sizeof(dbi->dbi_lastoffset);
}
return rc;
}
+/*@=compmempass@*/
static int db1cdel(dbiIndex dbi, /*@unused@*/ DBC * dbcursor, const void * keyp,
size_t keylen, /*@unused@*/ unsigned int flags)
_mymemset(&key, 0, sizeof(key));
+ /*@-usedef@*/
key.data = (void *)keyp;
+ /*@=usedef@*/
key.size = keylen;
rc = db->del(db, &key, 0);
if (offset == 0) { /* XXX simulated offset 0 record */
/* XXX hack: return offset as data, free in db1cput */
- if (data.size == sizeof(offset)) {
- free(data.data);
- }
+ if (data.size == sizeof(offset))
+ /*@-unqualifiedtrans@*/ free(data.data); /*@=unqualifiedtrans@*/
} else { /* XXX simulated DB_KEYLAST */
Header h = headerLoad(data.data);
int newSize = headerSizeof(h, HEADER_MAGIC_NO);
return rc;
}
-static int db1open(rpmdb rpmdb, int rpmtag, dbiIndex * dbip)
+static int db1open(/*@keep@*/ rpmdb rpmdb, int rpmtag, dbiIndex * dbip)
{
+ /*@-nestedextern@*/
+ extern struct _dbiVec db1vec;
+ /*@=nestedextern@*/
const char * base = NULL;
const char * urlfn = NULL;
const char * fn = NULL;
dbiIndex dbi = NULL;
- extern struct _dbiVec db1vec;
int rc = 0;
if (dbip)
return rc;
}
+/*@=onlytrans@*/
/** \ingroup db1
*/
return rc;
}
-static int db2open(rpmdb rpmdb, int rpmtag, dbiIndex * dbip)
+static int db2open(/*@keep@*/ rpmdb rpmdb, int rpmtag, dbiIndex * dbip)
{
+ /*@-nestedextern@*/
+ extern struct _dbiVec db2vec;
+ /*@=nestedextern@*/
const char * urlfn = NULL;
const char * dbhome;
const char * dbfile;
const char * dbsubfile;
- extern struct _dbiVec db2vec;
dbiIndex dbi = NULL;
int rc = 0;
int xx;
dbi->dbi_rmw = NULL;
rc = db3c_close(dbi, dbcursor);
}
- return rc;
+ /*@-usereleased -compdef@*/ return rc; /*@=usereleased =compdef@*/
}
static int db3copen(dbiIndex dbi, /*@out@*/ DBC ** dbcp, unsigned int flags)
}
if (dbcp)
- *dbcp = dbi->dbi_rmw;
+ /*@-onlytrans@*/ *dbcp = dbi->dbi_rmw; /*@=onlytrans@*/
return rc;
}
memset(&key, 0, sizeof(key));
memset(&data, 0, sizeof(data));
+ /*@-unqualifiedtrans@*/
if (keyp) key.data = *keyp;
if (keylen) key.size = *keylen;
if (datap) data.data = *datap;
if (datalen) data.size = *datalen;
+ /*@=unqualifiedtrans@*/
if (dbcursor == NULL) {
int _printit;
}
if (rc == 0) {
+ /*@-onlytrans@*/
if (keyp) *keyp = key.data;
if (keylen) *keylen = key.size;
if (datap) *datap = data.data;
if (datalen) *datalen = data.size;
+ /*@=onlytrans@*/
}
+ /*@-compmempass@*/
return rc;
+ /*@=compmempass@*/
}
static int db3byteswapped(dbiIndex dbi)
static int db3open(/*@keep@*/ rpmdb rpmdb, int rpmtag, dbiIndex * dbip)
{
+ /*@-nestedextern@*/
+ extern struct _dbiVec db3vec;
+ /*@=nestedextern@*/
const char * urlfn = NULL;
const char * dbhome;
const char * dbfile;
const char * dbsubfile;
- extern struct _dbiVec db3vec;
dbiIndex dbi = NULL;
int rc = 0;
int xx;
if (!(dbi->dbi_perms & 0600))
dbi->dbi_perms = 0644;
dbi->dbi_mode = rpmdb->db_mode;
+ /*@-keeptrans@*/
dbi->dbi_rpmdb = rpmdb;
+ /*@=keeptrans@*/
dbi->dbi_rpmtag = rpmtag;
switch (rpmtag) {
* @return available package pointer
*/
static /*@exposed@*/ struct availablePackage * alAddPackage(struct availableList * al,
- Header h, /*@dependent@*/ const void * key,
- FD_t fd, rpmRelocation * relocs)
+ Header h, /*@null@*/ /*@dependent@*/ const void * key,
+ /*@null@*/ FD_t fd, /*@null@*/ rpmRelocation * relocs)
{
HGE_t hge = (HGE_t)headerGetEntryMinMemory;
HFD_t hfd = headerFreeData;
}
}
}
- rpmdbFreeIterator(mi);
+ mi = rpmdbFreeIterator(mi);
}
if (hge(h, RPMTAG_OBSOLETENAME, &ont, (void **) &obsoletes, &count)) {
removePackage(ts, rpmdbGetIteratorOffset(mi), alNum);
}
}
- rpmdbFreeIterator(mi);
+ mi = rpmdbFreeIterator(mi);
}
}
while ((h = rpmdbNextIterator(mi)) != NULL) {
rpmMessage(RPMMESS_DEBUG, _("%s: %-45s YES (db files)\n"),
keyType, keyDepend+2);
- rpmdbFreeIterator(mi);
+ mi = rpmdbFreeIterator(mi);
goto exit;
}
- rpmdbFreeIterator(mi);
+ mi = rpmdbFreeIterator(mi);
}
mi = rpmdbInitIterator(ts->rpmdb, RPMTAG_PROVIDENAME, keyName, 0);
if (rangeMatchesDepFlags(h, keyName, keyEVR, keyFlags)) {
rpmMessage(RPMMESS_DEBUG, _("%s: %-45s YES (db provides)\n"),
keyType, keyDepend+2);
- rpmdbFreeIterator(mi);
+ mi = rpmdbFreeIterator(mi);
goto exit;
}
}
- rpmdbFreeIterator(mi);
+ mi = rpmdbFreeIterator(mi);
#ifndef DYING
mi = rpmdbInitIterator(ts->rpmdb, RPMTAG_NAME, keyName, 0);
if (rangeMatchesDepFlags(h, keyName, keyEVR, keyFlags)) {
rpmMessage(RPMMESS_DEBUG, _("%s: %-45s YES (db package)\n"),
keyType, keyDepend+2);
- rpmdbFreeIterator(mi);
+ mi = rpmdbFreeIterator(mi);
goto exit;
}
}
- rpmdbFreeIterator(mi);
+ mi = rpmdbFreeIterator(mi);
#endif
}
if (suggestion)
+ /*@-dependenttrans@*/
*suggestion = alSatisfiesDepend(&ts->availablePackages, NULL, NULL,
keyName, keyEVR, keyFlags);
+ /*@=dependenttrans@*/
unsatisfied:
rpmMessage(RPMMESS_DEBUG, _("%s: %-45s NO\n"), keyType, keyDepend+2);
* Erasing: check name/provides/filename key against each requiredby match.
*/
static int checkPackageSet(rpmTransactionSet ts, struct problemsSet * psp,
- const char * key, /*@only@*/ rpmdbMatchIterator mi)
+ const char * key, /*@only@*/ /*@null@*/ rpmdbMatchIterator mi)
{
Header h;
int rc = 0;
break;
}
}
- rpmdbFreeIterator(mi);
+ mi = rpmdbFreeIterator(mi);
return rc;
}
* @retval rp address of last element
*/
static void addQ(/*@kept@*/ struct availablePackage * p,
- struct availablePackage ** qp,
- struct availablePackage ** rp)
+ /*@in@*/ /*@out@*/ struct availablePackage ** qp,
+ /*@in@*/ /*@out@*/ struct availablePackage ** rp)
{
struct availablePackage *q, *qprev;
if (p->tsi.tsi_count != 0)
continue;
p->tsi.tsi_suc = NULL;
+ /*@-ownedtrans@*/
addQ(p, &q, &r);
+ /*@=ownedtrans@*/
qlen++;
}
}
}
- rpmdbFreeIterator(mi);
- mi = NULL;
+ mi = rpmdbFreeIterator(mi);
}
if (ps.num) {
rc = 0;
exit:
- if (mi != NULL)
- rpmdbFreeIterator(mi);
+ mi = rpmdbFreeIterator(mi);
ps.problems = _free(ps.problems);
return rc;
}
/* XXX Fstrerror */
return NULL;
+ /*@-modobserver -observertrans@*/
memcpy(fadio, fdio, sizeof(*fadio));
fadio->_open = fadOpen;
+ /*@=modobserver =observertrans@*/
fdSetIo(fd, fadio);
fadSetFirstFree(fd, 0);
fadSetFirstFree(fd, 0);
fadSetFileSize(fd, sizeof(newHdr));
} else {
+ memset(&newHdr, 0, sizeof(newHdr));
if (Pread(fd, &newHdr, sizeof(newHdr), 0) != sizeof(newHdr)) {
Fclose(fd);
return NULL;
nextFreeOffset = fadGetFirstFree(fd);
prevFreeOffset = 0;
} else {
+ memset(&prevFreeHeader, 0, sizeof(prevFreeHeader));
if (Pread(fd, &prevFreeHeader, sizeof(prevFreeHeader),
prevFreeOffset) != sizeof(prevFreeHeader))
return;
}
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;
if (offset >= fadGetFileSize(fd))
return 0;
+ memset(&header, 0, sizeof(header));
if (Pread(fd, &header, sizeof(header), offset) != sizeof(header))
return 0;
newEntry->dirName = dn;
fp.entry = newEntry;
+ /*@-kepttrans@*/
htAddEntry(cache->ht, dn, fp.entry);
+ /*@@kepttrans@*/
}
if (fp.entry) {
#include <rpmmacro.h> /* XXX for rpmGetPath */
#include "debug.h"
+/*@-usereleased -onlytrans@*/
+
struct fsinfo {
/*@only@*/ const char * mntPoint; /*!< path to mount point. */
dev_t dev; /*!< devno for mount point. */
item = *itemptr; /* structure assignment */
mntdir = item.our_mntdir;
#if defined(MNTOPT_RO)
+ /*@-compdef@*/
if (hasmntopt(itemptr, MNTOPT_RO) != NULL)
rdonly = 1;
+ /*@=compdef@*/
#endif
# elif GETMNTENT_TWO
/* Solaris, maybe others */
return 0;
}
+/*@=usereleased =onlytrans@*/
* @param fsm file state machine data
* @return Is chain only partially filled?
*/
+/*@-compmempass@*/
static int saveHardLink(FSM_t fsm)
{
struct stat * st = &fsm->sb;
if (fsm->goal == FSM_PKGINSTALL)
fsm->li->linksLeft = 0;
+ /*@-kepttrans@*/
fsm->li->next = fsm->links;
+ /*@=kepttrans@*/
fsm->links = fsm->li;
}
if (fsm->goal == FSM_PKGBUILD) --fsm->li->linksLeft;
fsm->li->filex[fsm->li->linksLeft] = fsm->ix;
- /*@-observertrans@*/
+ /*@-observertrans -dependenttrans@*/
fsm->li->nsuffix[fsm->li->linksLeft] = fsm->nsuffix;
- /*@=observertrans@*/
+ /*@=observertrans =dependenttrans@*/
if (fsm->goal == FSM_PKGINSTALL) fsm->li->linksLeft++;
#if 0
rc = fsmStage(fsm, FSM_MAP);
return rc;
}
+/*@=compmempass@*/
/** \ingroup payload
* Destroy set of hard links.
* @param writeData should data be written?
* @return 0 on success
*/
+/*@-compmempass@*/
static int writeFile(FSM_t fsm, int writeData)
/*@modifies fsm @*/
{
exit:
if (fsm->rfd)
(void) fsmStage(fsm, FSM_RCLOSE);
+ /*@-dependenttrans@*/
fsm->opath = opath;
fsm->path = path;
+ /*@=dependenttrans@*/
return rc;
}
+/*@=compmempass@*/
/** \ingroup payload
* Write set of linked files to payload stream.
* @param fsm file state machine data
* @return 0 on success
*/
+/*@-compmempass@*/
static int fsmCommitLinks(FSM_t fsm)
{
const char * path = fsm->path;
fsm->path = path;
return rc;
}
+/*@=compmempass@*/
/**
* Remove (if created) directories not explicitly included in package.
fsm->path = NULL;
dn[0] = '\0';
+ /*@-observertrans -dependenttrans@*/
while ((fsm->path = dnlNextIterator(dnli)) != NULL) {
int dnlen = strlen(fsm->path);
char * te;
} while ((te - dn) > fsm->dnlx[dc]);
}
dnli = dnlFreeIterator(dnli);
+ /*@=observertrans =dependenttrans@*/
+
fsm->path = path;
return rc;
}
dn[0] = '\0';
fsm->dnlx = (dc ? xcalloc(dc, sizeof(*fsm->dnlx)) : NULL);
+ /*@-observertrans -dependenttrans@*/
while ((fsm->path = dnlNextIterator(dnli)) != NULL) {
int dnlen = strlen(fsm->path);
char * te;
fsm->ldnlen = dnlen;
}
dnli = dnlFreeIterator(dnli);
+ /*@=observertrans =dependenttrans@*/
+
fsm->path = path;
st->st_mode = st_mode; /* XXX restore st->st_mode */
return rc;
}
+/*@-compmempass@*/
int fsmStage(FSM_t fsm, fileStage stage)
{
#ifdef UNUSED
fsm->opath = opath;
}
+ /*@-dependenttrans@*/
fsm->path = path;
+ /*@=dependenttrans@*/
if (rc != CPIOERR_LSTAT_FAILED) return rc;
rc = expandRegular(fsm);
} else if (S_ISDIR(st->st_mode)) {
fsm->wrbuf[st->st_size] = '\0';
/* XXX symlink(fsm->opath, fsm->path) */
- fsm->opath = fsm->wrbuf; /* XXX abuse fsm->path */
+ /*@-dependenttrans@*/
+ fsm->opath = fsm->wrbuf;
+ /*@=dependenttrans@*/
rc = fsmStage(fsm, FSM_VERIFY);
if (rc == CPIOERR_LSTAT_FAILED)
rc = fsmStage(fsm, FSM_SYMLINK);
rc = fsmStage(fsm, FSM_UNLINK);
if (!rc) break;
if (!(errno == ENOENT && (fsm->fflags & RPMFILE_MISSINGOK)))
- rpmError(RPMERR_UNLINK,
+ rpmError(
(strict_erasures ? RPMERR_UNLINK : RPMWARN_UNLINK),
_("%s unlink of %s failed: %s\n"),
fiTypeString(fi), fsm->path, strerror(errno));
}
return rc;
}
+/*@=compmempass@*/
/*@obserever@*/ const char *const fileActionString(fileAction a)
{
unportable getdate.c's), but that seems to cause as many problems
as it solves. */
+#if 0
extern struct tm *gmtime();
extern struct tm *localtime();
+#endif
+
+extern time_t get_date(char * p, struct timeb * now);
#define yyparse getdate_yyparse
#define yylex getdate_yylex
#define yyerror getdate_yyerror
-static int yylex ();
-static int yyerror ();
+static int yyparse (void);
+static int yylex (void);
+static int yyerror(const char * s);
#define EPOCH 1970
#define HOUR(x) ((time_t)(x) * 60)
{ "thurs", tDAY, 4 },
{ "friday", tDAY, 5 },
{ "saturday", tDAY, 6 },
- { NULL }
+ { NULL, 0, 0 }
};
/* Time units table. */
{ "min", tMINUTE_UNIT, 1 },
{ "second", tSEC_UNIT, 1 },
{ "sec", tSEC_UNIT, 1 },
- { NULL }
+ { NULL, 0, 0 }
};
/* Assorted relative-time words. */
{ "eleventh", tUNUMBER, 11 },
{ "twelfth", tUNUMBER, 12 },
{ "ago", tAGO, 1 },
- { NULL }
+ { NULL, 0, 0 }
};
/* The timezone table. */
{ "nzst", tZONE, -HOUR(12) }, /* New Zealand Standard */
{ "nzdt", tDAYZONE, -HOUR(12) }, /* New Zealand Daylight */
{ "idle", tZONE, -HOUR(12) }, /* International Date Line East */
- { NULL }
+ { NULL, 0, 0 }
};
/* Military timezone table. */
{ "x", tZONE, HOUR(-11) },
{ "y", tZONE, HOUR(-12) },
{ "z", tZONE, HOUR( 0) },
- { NULL }
+ { NULL, 0, 0 }
};
\f
/* ARGSUSED */
static int
-yyerror(s)
- char *s;
+yyerror(const char * s)
{
return 0;
}
static time_t
-ToSeconds(Hours, Minutes, Seconds, Meridian)
- time_t Hours;
- time_t Minutes;
- time_t Seconds;
- MERIDIAN Meridian;
+ToSeconds(time_t Hours, time_t Minutes, time_t Seconds, MERIDIAN Meridian)
{
if (Minutes < 0 || Minutes > 59 || Seconds < 0 || Seconds > 59)
return -1;
* A number from 0 to 99, which means a year from 1900 to 1999, or
* The actual year (>=100). */
static time_t
-Convert(Month, Day, Year, Hours, Minutes, Seconds, Meridian, DSTmode)
- time_t Month;
- time_t Day;
- time_t Year;
- time_t Hours;
- time_t Minutes;
- time_t Seconds;
- MERIDIAN Meridian;
- DSTMODE DSTmode;
+Convert(time_t Month, time_t Day, time_t Year,
+ time_t Hours, time_t Minutes, time_t Seconds,
+ MERIDIAN Meridian, DSTMODE DSTmode)
{
static int DaysInMonth[12] = {
31, 0, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
static time_t
-DSTcorrect(Start, Future)
- time_t Start;
- time_t Future;
+DSTcorrect(time_t Start, time_t Future)
{
time_t StartDay;
time_t FutureDay;
static time_t
-RelativeDate(Start, DayOrdinal, DayNumber)
- time_t Start;
- time_t DayOrdinal;
- time_t DayNumber;
+RelativeDate(time_t Start, time_t DayOrdinal, time_t DayNumber)
{
struct tm *tm;
time_t now;
static time_t
-RelativeMonth(Start, RelMonth)
- time_t Start;
- time_t RelMonth;
+RelativeMonth(time_t Start, time_t RelMonth)
{
struct tm *tm;
time_t Month;
static int
-LookupWord(buff)
- char *buff;
+LookupWord(char * buff)
{
register char *p;
register char *q;
static int
-yylex()
+yylex(void)
{
register char c;
register char *p;
Count--;
} while (Count > 0);
}
+ /*@notreached@*/
+ return 0;
}
#define TM_YEAR_ORIGIN 1900
/* Yield A - B, measured in seconds. */
static long
-difftm (a, b)
- struct tm *a, *b;
+difftm (const struct tm * a, const struct tm * b)
{
- int ay = a->tm_year + (TM_YEAR_ORIGIN - 1);
- int by = b->tm_year + (TM_YEAR_ORIGIN - 1);
+ unsigned ay = a->tm_year + (TM_YEAR_ORIGIN - 1);
+ unsigned by = b->tm_year + (TM_YEAR_ORIGIN - 1);
int days = (
/* difference in day of year */
a->tm_yday - b->tm_yday
}
time_t
-get_date(p, now)
- char *p;
- struct timeb *now;
+get_date(char * p, struct timeb * now)
{
struct tm *tm, gmt;
struct timeb ftz;
time_t nowtime;
yyInput = p;
+ memset(&gmt, 0, sizeof(gmt));
if (now == NULL) {
struct tm *gmt_ptr;
return -1;
if (gmt_ptr != NULL)
+ /*@-observertrans -dependenttrans@*/
ftz.timezone = difftm (&gmt, tm) / 60;
+ /*@=observertrans =dependenttrans@*/
else
/* We are on a system like VMS, where the system clock is
in local time and the system has no concept of timezones.
yyHaveTime = 0;
yyHaveZone = 0;
+ /*@-unrecog@*/
if (yyparse()
|| yyHaveTime > 1 || yyHaveZone > 1 || yyHaveDate > 1 || yyHaveDay > 1)
return -1;
+ /*@=unrecog@*/
if (yyHaveDate || yyHaveTime || yyHaveDay) {
Start = Convert(yyMonth, yyDay, yyYear, yyHour, yyMinutes, yySeconds,
while (b) {
n = b->next;
if (b->data) {
- if (ht->freeData && *b->data) free((void *)*b->data);
- free((void *)b->data);
+ if (ht->freeData)
+ *b->data = _free(*b->data);
+ b->data = _free(b->data);
}
- free(b);
+ b = _free(b);
b = n;
}
}
- free(ht->buckets);
- free(ht);
+ ht->buckets = _free(ht->buckets);
+ ht = _free(ht);
}
int htHasEntry(hashTable ht, const void * key)
* @param data pointer to data value
*/
void htAddEntry(hashTable ht, /*@owned@*/ const void * key,
- /*@owned@*/ const void * data) /*@modifies ht */;
+ /*@owned@*/ const void * data) /*@modifies ht */;
/**
* Retrieve item from hash table.
* @retval tableKey address to store key value from bucket (may be NULL)
* @return 0 on success, 1 if the item is not found.
*/
-int htGetEntry(hashTable ht, const void * key, /*@out@*/ const void *** data,
- /*@out@*/ int * dataCount, /*@out@*/ const void ** tableKey)
- /*@modifies *data, *dataCount, *tableKey @*/;
+int htGetEntry(hashTable ht, const void * key,
+ /*@null@*/ /*@out@*/ const void *** data,
+ /*@null@*/ /*@out@*/ int * dataCount,
+ /*@null@*/ /*@out@*/ const void ** tableKey)
+ /*@modifies *data, *dataCount, *tableKey @*/;
/**
* Check for key in hash table.
char * t;
int i;
+ /*@-mods@*/
if (minMem) {
*p = xmalloc(tableSize);
ptrEntry = (const char **) *p;
t += tableSize;
memcpy(t, entry->data, entry->length);
}
+ /*@=mods@*/
for (i = 0; i < count; i++) {
*ptrEntry++ = t;
t = strchr(t, 0);
{
Header nh;
int length;
+ /*@-onlytrans@*/
void * uh = doHeaderUnload(h, &length);
headerFree(h);
+ /*@=onlytrans@*/
nh = headerLoad(uh);
if (nh == NULL) {
free(uh);
break;
default:
+ /*@-mayaliasunique@*/
memcpy(dstPtr, srcPtr, dataLength);
+ /*@=mayaliasunique@*/
break;
}
}
table->info.offset = 0;
} else
table->data = xrealloc(table->data, table->length + length);
+ /*@-mayaliasunique@*/
memcpy(((char *)table->data) + table->length, lang, length);
+ /*@=mayaliasunique@*/
table->length += length;
table->info.count++;
}
entry->data = xrealloc(entry->data, entry->length + length);
memset(((char *)entry->data) + entry->length, '\0', ghosts);
+ /*@-mayaliasunique@*/
strcpy(((char *)entry->data) + entry->length + ghosts, string);
+ /*@=mayaliasunique@*/
entry->length += length;
entry->info.count = langNum + 1;
entry->info.offset = 0;
} else
free(entry->data);
+ /*@-dependenttrans@*/
entry->data = buf;
+ /*@=dependenttrans@*/
}
return 0;
if (currToken < 0 || format[currToken].type != PTOK_STRING) {
currToken++;
format[currToken].type = PTOK_STRING;
+ /*@-temptrans@*/
dst = format[currToken].u.string.string = start;
+ /*@=temptrans@*/
}
start++;
if (currToken < 0 || format[currToken].type != PTOK_STRING) {
currToken++;
format[currToken].type = PTOK_STRING;
+ /*@-temptrans@*/
dst = format[currToken].u.string.string = start;
+ /*@=temptrans@*/
}
if (*start == '\\') {
const char * piece;
int pieceLength;
+ /*@-mods@*/
piece = singleSprintf(h, format + i, extensions, extCache, 0);
+ /*@=mods@*/
if (piece) {
pieceLength = strlen(piece);
if ((answerLength + pieceLength) >= answerAlloced) {
exit:
if (argvPtr == NULL || (rc != 0 && av)) {
for (i = 0; i < ac; i++)
- av[i] = _free(av[i]);
- av = _free(av);
+ /*@-unqualifiedtrans@*/av[i] = _free(av[i]); /*@=unqualifiedtrans@*/
+ /*@-dependenttrans@*/ av = _free(av); /*@=dependenttrans@*/
}
freeStringBuf(sb);
return rc;
* Final wrapup - pad to 64-byte boundary with the bit pattern
* 1 0* (64-bit count of bits processed, MSB-first)
*/
+/*@-fixedformalarray@*/
void rpmMD5Final(unsigned char digest[16], struct MD5Context *ctx)
+/*@=fixedformalarray@*/
{
unsigned count;
unsigned char *p;
* reflect the addition of 16 longwords of new data. rpmMD5Update blocks
* the data and converts bytes into longwords for this routine.
*/
+/*@-fixedformalarray@*/
void rpmMD5Transform(uint32 buf[4], uint32 const in[16])
+/*@=fixedformalarray@*/
{
register uint32 a, b, c, d;
* @retval MD5 digest
* @param context MD5 private data
*/
+/*@-fixedformalarray@*/
void rpmMD5Final(unsigned char digest[16], struct MD5Context *context);
+/*@=fixedformalarray@*/
/**
* The core of the MD5 algorithm.
* @param buf current MD5 variables
* @param in next block of data to add
*/
+/*@-fixedformalarray@*/
void rpmMD5Transform(uint32 buf[4], uint32 const in[16]);
+/*@=fixedformalarray@*/
/**
* Return MD5 sum of file as ASCII string.
void freeSplitString(char ** list)
{
+ /*@-unqualifiedtrans@*/
list[0] = _free(list[0]);
+ /*@=unqualifiedtrans@*/
list = _free(list);
}
errxit:
tempfn = _free(tempfn);
+ /*@-usereleased@*/
if (fd) Fclose(fd);
+ /*@=usereleased@*/
return 1;
}
char savechar;
int len = baseName - fileNames[i];
+ needle = dirNames;
savechar = *baseName;
*baseName = '\0';
if (dirIndex < 0 ||
fprintf(stderr, "*** rpmGlob argv[%d] \"%s\"\n", argc, globURL);
argv[argc++] = xstrdup(globURL);
}
+ /*@-immediatetrans@*/
Globfree(&gl);
+ /*@=immediatetrans@*/
globURL = _free(globURL);
}
if (argv != NULL && argc > 0) {
/*@access Header@*/ /* XXX compared with NULL */
+/*@-mods@*/
void headerMergeLegacySigs(Header h, const Header sig)
{
HeaderIterator hi;
headerFreeIterator(hi);
return sig;
}
+/*@=mods@*/
/**
* Retrieve package components from file handle.
}
if (isSource) *isSource = lead.type == RPMLEAD_SOURCE;
+ /*@-mods@*/
if (major) *major = lead.major;
if (minor) *minor = lead.minor;
+ /*@=mods@*/
exit:
return rc;
sfi++;
}
}
- rpmdbFreeIterator(mi);
+ mi = rpmdbFreeIterator(mi);
return 0;
}
return RPMRC_OK;
}
+/*@-compmempass@*/
rpmRC rpmInstallSourcePackage(const char * rootDir, FD_t fd,
const char ** specFilePtr,
rpmCallbackFunction notify, rpmCallbackData notifyData,
int i;
ts->notify = notify;
+ /*@-temptrans@*/
ts->notifyData = notifyData;
+ /*@=temptrans@*/
rc = rpmReadPackageHeader(fd, &h, &isSource, NULL, NULL);
if (rc)
fi->dil = (int *)(fi->dnl + fi->dc);
memset(fi->dil, 0, fi->fc * sizeof(*fi->dil));
fi->dil[i] = 1;
+ /*@-dependenttrans@*/
fi->dnl[0] = t = (char *)(fi->dil + fi->fc);
fi->dnl[1] = t = stpcpy( stpcpy(t, _sourcedir), "/") + 1;
+ /*@=dependenttrans@*/
(void) stpcpy( stpcpy(t, _specdir), "/");
t = xmalloc(speclen + strlen(fi->bnl[i]) + 1);
if (fi) {
freeFi(fi);
- free(fi);
+ fi = _free(fi);
}
if (ts)
rpmtransFree(ts);
return rc;
}
+/*@=compmempass@*/
static char * SCRIPT_PATH = "PATH=/sbin:/bin:/usr/sbin:/usr/bin:/usr/X11R6/bin";
rc |= handleOneTrigger(psm, fi->h, triggeredH, numPackage, NULL);
}
- rpmdbFreeIterator(mi);
+ mi = rpmdbFreeIterator(mi);
psm->countCorrection = countCorrection;
}
triggersRun);
}
- rpmdbFreeIterator(mi);
+ mi = rpmdbFreeIterator(mi);
}
}
triggerIndices = hfd(triggerIndices, tit);
rpmdbSetIteratorRelease(psm->mi, fi->release);
while ((psm->oh = rpmdbNextIterator(psm->mi))) {
fi->record = rpmdbGetIteratorOffset(psm->mi);
- psm->oh = (ts->transFlags & RPMTRANS_FLAG_MULTILIB)
- ? headerCopy(psm->oh) : NULL;
+ if (ts->transFlags & RPMTRANS_FLAG_MULTILIB)
+ psm->oh = headerCopy(psm->oh);
+ else
+ psm->oh = NULL;
break;
}
- rpmdbFreeIterator(psm->mi);
- psm->mi = NULL;
+ psm->mi = rpmdbFreeIterator(psm->mi);
rc = RPMRC_OK;
if (fi->fc > 0 && fi->fstates == NULL) {
fi->h = rpmdbNextIterator(psm->mi);
if (fi->h)
fi->h = headerLink(fi->h);
- rpmdbFreeIterator(psm->mi);
- psm->mi = NULL;
+ psm->mi = rpmdbFreeIterator(psm->mi);
rc = (fi->h ? RPMRC_OK : RPMRC_FAIL);
break;
case PSM_RPMDB_ADD:
switch(t->t_tag) {
case RPMTAG_SUMMARY:
case RPMTAG_GROUP:
+ /*@-unqualifiedtrans@*/
sl->sl_lines[t->t_startx] = _free(sl->sl_lines[t->t_startx]);
+ /*@=unqualifiedtrans@*/
if (t->t_lang && strcmp(t->t_lang, RPMBUILD_DEFAULT_LANG))
continue;
{ char *buf = xmalloc(strlen(tn) + sizeof(": ") + strlen(msgstr));
break;
case RPMTAG_DESCRIPTION:
for (j = 1; j < t->t_nlines; j++) {
+ /*@-unqualifiedtrans@*/
sl->sl_lines[t->t_startx + j] =
_free(sl->sl_lines[t->t_startx + j]);
+ /*@=unqualifiedtrans@*/
}
if (t->t_lang && strcmp(t->t_lang, RPMBUILD_DEFAULT_LANG)) {
sl->sl_lines[t->t_startx] = _free(sl->sl_lines[t->t_startx]);
if ((rc = showPackage(qva, rpmdbGetIteratorRpmDB(mi), h)) != 0)
ec = rc;
}
- rpmdbFreeIterator(mi);
+ mi = rpmdbFreeIterator(mi);
return ec;
}
/*@access Header@*/ /* XXX compared with NULL */
/*@access FD_t@*/ /* XXX compared with NULL */
-static int manageFile(FD_t *fdp, const char **fnp, int flags, int rc)
+static int manageFile(FD_t *fdp, const char **fnp, int flags,
+ /*@unused@*/ int rc)
{
const char *fn;
FD_t fd;
/* open a temp file */
if (*fdp == NULL && (fnp == NULL || *fnp == NULL)) {
+ fn = NULL;
if (makeTempFile(NULL, (fnp ? &fn : NULL), &fd)) {
rpmError(RPMERR_MAKETEMP, _("makeTempFile failed\n"));
return 1;
}
if (fnp)
- *fnp = fn;
- *fdp = fd;
+ *fnp = fn;
+ *fdp = fdLink(fd, "manageFile return");
+ fdFree(fd, "manageFile return");
return 0;
}
if (manageFile(&fd, &rpm, O_RDONLY, 0))
goto exit;
+ memset(l, 0, sizeof(*l));
if (readLead(fd, l)) {
rpmError(RPMERR_READLEAD, _("%s: readLead failed\n"), rpm);
goto exit;
goto bottom;
}
- if (readLead(fd, &lead)) {
+ memset(l, 0, sizeof(*l));
+ if (readLead(fd, l)) {
rpmError(RPMERR_READLEAD, _("%s: readLead failed\n"), rpm);
res++;
goto bottom;
if (tempKey) {
if (res3 == RPMSIG_NOKEY) {
strcat(missingKeys, " PGP#");
+ /*@-compdef@*/
strncat(missingKeys, tempKey + offset, 8);
+ /*@=compdef@*/
} else {
strcat(untrustedKeys, " PGP#");
+ /*@-compdef@*/
strncat(untrustedKeys, tempKey + offset, 8);
+ /*@=compdef@*/
}
}
} break;
strcat(missingKeys, " GPG#");
tempKey = strstr(result, "key ID");
if (tempKey)
+ /*@-compdef@*/
strncat(missingKeys, tempKey+7, 8);
+ /*@=compdef@*/
break;
default:
strcat(buffer, "GPG ");
memset(set->recs + set->count, 0, nrecs * sizeof(*(set->recs)));
while (nrecs-- > 0) {
+ /*@-mayaliasunique@*/
memcpy(set->recs + set->count, rptr, rlen);
+ /*@=mayaliasunique@*/
rptr += recsize;
set->count++;
}
for (dbix = rpmdb->db_ndbi; --dbix >= 0; ) {
if (rpmdb->_dbi[dbix] == NULL)
continue;
+ /*@-unqualifiedtrans@*/
dbiClose(rpmdb->_dbi[dbix], 0);
rpmdb->_dbi[dbix] = NULL;
+ /*@=unqualifiedtrans@*/
}
rpmdb->db_errpfx = _free(rpmdb->db_errpfx);
rpmdb->db_root = _free(rpmdb->db_root);
if (!(rpmdb->db_home && rpmdb->db_home[0] != '%')) {
rpmError(RPMERR_DBOPEN, _("no dbpath has been set\n"));
rpmdbClose(rpmdb);
- return NULL;
+ /*@-globstate@*/ return NULL; /*@=globstate@*/
}
rpmdb->db_errpfx = rpmExpand( (epfx && *epfx ? epfx : _DB_ERRPFX), NULL);
rpmdb->db_remove_env = 0;
rpmdb->db_filter_dups = _filterDbDups;
rpmdb->db_ndbi = dbiTagsMax;
rpmdb->_dbi = xcalloc(rpmdb->db_ndbi, sizeof(*rpmdb->_dbi));
- return rpmdb;
+ /*@-globstate@*/ return rpmdb; /*@=globstate@*/
}
static int openDatabase(const char * prefix, const char * dbpath, int _dbapi,
h = rpmdbNextIterator(mi);
if (h)
h = headerLink(h);
- rpmdbFreeIterator(mi);
+ mi = rpmdbFreeIterator(mi);
}
if (h == NULL) {
hge(h, RPMTAG_BASENAMES, &bnt, (void **) &baseNames, NULL);
hge(h, RPMTAG_DIRNAMES, &dnt, (void **) &dirNames, NULL);
- hge(h, RPMTAG_DIRINDEXES, NULL, (const void **) &dirIndexes, NULL);
+ hge(h, RPMTAG_DIRINDEXES, NULL, (void **) &dirIndexes, NULL);
do {
fingerPrint fp2;
h = rpmdbNextIterator(mi);
if (h)
h = headerLink(h);
- rpmdbFreeIterator(mi);
+ mi = rpmdbFreeIterator(mi);
}
if (h == NULL) {
exit:
if (rc && matches && *matches) {
- dbiFreeIndexSet(*matches);
+ /*@-unqualifiedtrans@*/dbiFreeIndexSet(*matches);/*@=unqualifiedtrans@*/
*matches = NULL;
}
return rc;
rc = dbiFindMatches(dbi, dbcursor, arg, NULL, NULL, matches);
if (rc != 1) return rc;
if (*matches) {
- dbiFreeIndexSet(*matches);
+ /*@-unqualifiedtrans@*/dbiFreeIndexSet(*matches);/*@=unqualifiedtrans@*/
*matches = NULL;
}
*chptr = '\0';
rc = dbiFindMatches(dbi, dbcursor, localarg, chptr + 1, NULL, matches);
if (rc != 1) return rc;
- if (*matches) dbiFreeIndexSet(*matches);
+ if (*matches) {
+ /*@-unqualifiedtrans@*/dbiFreeIndexSet(*matches);/*@=unqualifiedtrans@*/
+ *matches = NULL;
+ }
/* how about name-version-release? */
/*@only@*/ const char *mi_release;
};
-void rpmdbFreeIterator(rpmdbMatchIterator mi)
+rpmdbMatchIterator rpmdbFreeIterator(rpmdbMatchIterator mi)
{
dbiIndex dbi = NULL;
int xx;
if (mi == NULL)
- return;
+ return mi;
dbi = dbiOpen(mi->mi_rpmdb, RPMDBI_PACKAGES, 0);
if (mi->mi_h) {
}
mi->mi_keyp = _free(mi->mi_keyp);
mi = _free(mi);
+ return mi;
}
rpmdb rpmdbGetIteratorRpmDB(rpmdbMatchIterator mi) {
mi->mi_offset, mi->mi_h);
}
#endif
- return mi->mi_h;
+ /*@-compdef -usereleased@*/ return mi->mi_h; /*@=compdef =usereleased@*/
}
static void rpmdbSortIterator(rpmdbMatchIterator mi) {
h = rpmdbNextIterator(mi);
if (h)
h = headerLink(h);
- rpmdbFreeIterator(mi);
+ mi = rpmdbFreeIterator(mi);
}
if (h == NULL) {
memcpy(&hdrNum, datap, sizeof(hdrNum));
++hdrNum;
if (rc == 0 && datap) {
+ /*@-refcounttrans@*/
memcpy(datap, &hdrNum, sizeof(hdrNum));
+ /*@=refcounttrans@*/
} else {
datap = &hdrNum;
datalen = sizeof(hdrNum);
(const char *)rpmvals, tagName(dbi->dbi_rpmtag));
/* XXX force uniform headerGetEntry return */
+ /*@-observertrans@*/
av[0] = (const char *) rpmvals;
+ /*@=observertrans@*/
rpmvals = av;
rpmcnt = 1;
} else {
}
if ((i = rpmdbGetIteratorCount(mi)) == 0) {
- rpmdbFreeIterator(mi);
+ mi = rpmdbFreeIterator(mi);
return 0;
}
fpc = fpCacheCreate(i);
/* Add db (recnum,filenum) to list for fingerprint matches. */
for (i = 0; i < num; i++, im++) {
if (FP_EQUAL(fps[i], fpList[im->fpNum]))
+ /*@-usedef@*/
dbiAppendSet(matchList[im->fpNum], im, 1, sizeof(*im), 0);
+ /*@=usedef@*/
}
fps = _free(fps);
mi->mi_setx = end;
}
- rpmdbFreeIterator(mi);
+ mi = rpmdbFreeIterator(mi);
fpCacheFree(fpc);
skip = 1;
break;
}
- rpmdbFreeIterator(mi);
+ mi = rpmdbFreeIterator(mi);
}
/*@=shadow@*/
}
}
- rpmdbFreeIterator(mi);
+ mi = rpmdbFreeIterator(mi);
}
count = 0;
break;
}
- rpmdbFreeIterator(mi);
+ mi = rpmdbFreeIterator(mi);
if (count == 0) {
headerFree(h);
continue;
}
}
}
- rpmdbFreeIterator(mi);
+ mi = rpmdbFreeIterator(mi);
}
if (!(interfaceFlags & UNINSTALL_NODEPS)) {
}
if (rc != 0) {
rpmMessage(RPMMESS_ERROR, _("%s cannot be installed\n"), arg);
+ /*@-unqualifiedtrans@*/
if (specFile && *specFile)
*specFile = _free(*specFile);
if (cookie && *cookie)
*cookie = _free(*cookie);
+ /*@=unqualifiedtrans@*/
}
Fclose(fd);
int readLead(FD_t fd, struct rpmlead *lead)
{
+ memset(lead, 0, sizeof(*lead));
if (timedRead(fd, (char *)lead, sizeof(*lead)) != sizeof(*lead)) {
rpmError(RPMERR_READ, _("read failed: %s (%d)\n"), Fstrerror(fd),
errno);
/** \ingroup rpmdb
* Destroy rpm database iterator.
* @param mi rpm database iterator
+ * @return NULL always
*/
-void rpmdbFreeIterator( /*@only@*/ rpmdbMatchIterator mi);
+rpmdbMatchIterator rpmdbFreeIterator(/*@only@*//*@null@*/rpmdbMatchIterator mi)
+ /*@modifies mi @*/;
/** \ingroup rpmdb
* Return rpm database used by iterator.
* @param mi rpm database iterator
* @return NULL on end of iteration.
*/
-Header rpmdbNextIterator(rpmdbMatchIterator mi)
+/*@null@*/ Header rpmdbNextIterator(/*@null@*/ rpmdbMatchIterator mi)
/*@modifies mi @*/;
#define rpmdbNextIterator(_a) \
XrpmdbNextIterator(_a, __FILE__, __LINE__)
-Header XrpmdbNextIterator(rpmdbMatchIterator mi, const char * f, unsigned int l)
+/*@null@*/ Header XrpmdbNextIterator(/*@null@*/ rpmdbMatchIterator mi,
+ const char * f, unsigned int l)
/*@modifies mi @*/;
/** \ingroup rpmdb
* @param rootdir path to top of install tree
* @return transaction set
*/
-/*@only@*/ rpmTransactionSet rpmtransCreateSet(rpmdb rpmdb,
- const char * rootdir);
+/*@only@*/ rpmTransactionSet rpmtransCreateSet(
+ /*@null@*/ /*@kept@*/ rpmdb rpmdb,
+ /*@null@*/ const char * rootdir);
/** \ingroup rpmtrans
* Add package to be installed to unordered transaction set.
* @param relocs package file relocations
* @return 0 on success, 1 on I/O error, 2 needs capabilities
*/
-int rpmtransAddPackage(rpmTransactionSet ts, Header h, FD_t fd,
- /*@owned@*/ const void * key, int update,
- rpmRelocation * relocs);
+int rpmtransAddPackage(rpmTransactionSet ts, Header h, /*@null@*/ FD_t fd,
+ /*@null@*/ /*@owned@*/ const void * key, int update,
+ /*@null@*/ rpmRelocation * relocs);
/** \ingroup rpmtrans
* Add package to universe of possible packages to install in transaction set.
* @param key package private data
*/
void rpmtransAvailablePackage(rpmTransactionSet ts, Header h,
- /*@owned@*/ const void * key);
+ /*@null@*/ /*@owned@*/ const void * key);
/** \ingroup rpmtrans
* Add package to be removed to unordered transaction set.
* @return 0 always
*/
int rpmtransGetKeys(const rpmTransactionSet ts,
- /*@out@*/ const void *** ep, /*@out@*/ int * nep)
+ /*@null@*/ /*@out@*/ const void *** ep, /*@null@*/ /*@out@*/ int * nep)
/*@modifies ep, nep @*/;
/** \ingroup rpmtrans
#define __power_pc() 0
#endif
-/*@ access FD_t @*/ /* compared with NULL */
-
#include <rpmlib.h>
#include <rpmmacro.h>
#include "misc.h"
#include "debug.h"
+/*@access FD_t@*/ /* compared with NULL */
+
static const char *defrcfiles = LIBRPMRC_FILENAME ":/etc/rpmrc:~/.rpmrc";
const char * macrofiles = MACROFILES;
*table = xmalloc(2 * sizeof(struct canonEntry));
} else {
(*tableLen) += 2;
+ /*@-unqualifiedtrans@*/
*table = xrealloc(*table, sizeof(struct canonEntry) * (*tableLen));
+ /*@=unqualifiedtrans@*/
}
t = & ((*table)[*tableLen - 2]);
*table = xmalloc(sizeof(struct defaultEntry));
} else {
(*tableLen)++;
+ /*@-unqualifiedtrans@*/
*table = xrealloc(*table, sizeof(struct defaultEntry) * (*tableLen));
+ /*@=unqualifiedtrans@*/
}
t = & ((*table)[*tableLen - 1]);
+ /*@-temptrans@*/
t->name = strtok(line, ": \t");
t->defName = strtok(NULL, " \t");
if (! (t->name && t->defName)) {
t->name = xstrdup(t->name);
t->defName = xstrdup(t->defName);
+ /*@=temptrans@*/
return 0;
}
{
while (tableLen) {
tableLen--;
- if (!strcmp(name, table[tableLen].name)) {
- return &(table[tableLen]);
- }
+ if (strcmp(name, table[tableLen].name))
+ continue;
+ /*@-immediatetrans@*/
+ return &(table[tableLen]);
+ /*@=immediatetrans@*/
}
return NULL;
!strncmp(un.release, "4.0", 3))
{
/* we are on ncr-sysv4 */
- char *prelid = NULL;
- FD_t fd;
- fd = Fopen("/etc/.relid", "r.fdio");
+ char * prelid = NULL;
+ FD_t fd = Fopen("/etc/.relid", "r.fdio");
+ int gotit = 0;
if (!Ferror(fd)) {
- chptr = (char *) xcalloc(1, 256);
- if (chptr != NULL) {
- int irelid = Fread(chptr, sizeof(*chptr), 256, fd);
+ chptr = xcalloc(1, 256);
+ { int irelid = Fread(chptr, sizeof(*chptr), 256, fd);
Fclose(fd);
/* example: "112393 RELEASE 020200 Version 01 OS" */
if (irelid > 0) {
- if ((prelid=strstr(chptr, "RELEASE "))){
+ if ((prelid = strstr(chptr, "RELEASE "))){
prelid += strlen("RELEASE ")+1;
sprintf(un.sysname,"ncr-sysv4.%.*s",1,prelid);
+ gotit = 1;
}
}
- free (chptr);
}
+ chptr = _free (chptr);
}
- if (prelid == NULL) /* parsing /etc/.relid file failed? */
+ if (!gotit) /* parsing /etc/.relid file failed? */
strcpy(un.sysname,"ncr-sysv4");
/* wrong, just for now, find out how to look for i586 later*/
strcpy(un.machine,"i486");
}
/* this doesn't free the passed pointer! */
-static void freeRpmVar(struct rpmvarValue * orig) {
+static void freeRpmVar(/*@only@*/ struct rpmvarValue * orig) {
struct rpmvarValue * next, * var = orig;
while (var) {
}
void rpmSetVar(int var, const char *val) {
+ /*@-immediatetrans@*/
freeRpmVar(&values[var]);
+ /*@=immediatetrans@*/
values[var].value = (val ? xstrdup(val) : NULL);
}
else
ct = _free(ct);
ca = _free(ca);
+ /*@-usereleased@*/
co = _free(co);
+ /*@=usereleased@*/
}
void rpmFreeRpmrc(void)
sb->tail = sb->buf + (sb->allocated - sb->free);
}
+ /*@-mayaliasunique@*/
strcpy(sb->tail, s);
+ /*@=mayaliasunique@*/
sb->tail += l;
sb->free -= l;
if (nl) {
#define XSTRCMP(a, b) ((!(a) && !(b)) || ((a) && (b) && !strcmp((a), (b))))
-static void freeFl(rpmTransactionSet ts, TFI_t flList)
+static /*@null@*/ void * freeFl(rpmTransactionSet ts, /*@only@*/ /*@null@*/ TFI_t flList)
{
- TFI_t fi;
- int oc;
+ if (flList) {
+ TFI_t fi;
+ int oc;
- for (oc = 0, fi = flList; oc < ts->orderCount; oc++, fi++) {
- freeFi(fi);
+ /*@-usereleased@*/
+ for (oc = 0, fi = flList; oc < ts->orderCount; oc++, fi++)
+ freeFi(fi);
+ flList = _free(flList);
+ /*@=usereleased@*/
}
+ return NULL;
}
void rpmtransSetScriptFd(rpmTransactionSet ts, FD_t fd)
const char ** actualRelocations;
int numActual;
- actualRelocations = xmalloc(sizeof(*actualRelocations) * numValid);
+ actualRelocations = xmalloc(numValid * sizeof(*actualRelocations));
numActual = 0;
for (i = 0; i < numValid; i++) {
for (j = 0; j < numRelocations; j++) {
const char ** newDirList;
haveRelocatedFile = 1;
- newDirList = xmalloc(sizeof(*newDirList) * (dirCount + 1));
+ newDirList = xmalloc((dirCount + 1) * sizeof(*newDirList));
for (j = 0; j < dirCount; j++)
newDirList[j] = alloca_strdup(dirNames[j]);
dirNames = hfd(dirNames, RPM_STRING_ARRAY_TYPE);
mi = rpmdbInitIterator(db, RPMDBI_PACKAGES, &shared->otherPkg, sizeof(shared->otherPkg));
h = rpmdbNextIterator(mi);
if (h == NULL) {
- rpmdbFreeIterator(mi);
+ mi = rpmdbFreeIterator(mi);
return 1;
}
hge(h, RPMTAG_FILEFLAGS, NULL, (void **) &otherFlags, NULL);
hge(h, RPMTAG_FILESIZES, NULL, (void **) &otherSizes, NULL);
- fi->replaced = xmalloc(sizeof(*fi->replaced) * sharedCount);
+ fi->replaced = xmalloc(sharedCount * sizeof(*fi->replaced));
for (i = 0; i < sharedCount; i++, shared++) {
int otherFileNum, fileNum;
otherMd5s = hfd(otherMd5s, omtype);
otherLinks = hfd(otherLinks, oltype);
- rpmdbFreeIterator(mi);
+ mi = rpmdbFreeIterator(mi);
fi->replaced = xrealloc(fi->replaced, /* XXX memory leak */
sizeof(*fi->replaced) * (numReplaced + 1));
&shared->otherPkg, sizeof(shared->otherPkg));
h = rpmdbNextIterator(mi);
if (h == NULL) {
- rpmdbFreeIterator(mi);
+ mi = rpmdbFreeIterator(mi);
return 1;
}
fi->actions[fileNum] = FA_SKIP;
}
- rpmdbFreeIterator(mi);
+ mi = rpmdbFreeIterator(mi);
return 0;
}
/**
*/
-static struct availablePackage * tsGetAlp(void * this) {
+static /*@dependent@*/ struct availablePackage * tsGetAlp(void * this) {
struct tsIterator_s * iter = this;
struct availablePackage * alp = NULL;
int oc = iter->ocsave;
* @param this file info iterator
* @return next index, -1 on termination
*/
-static TFI_t tsNextIterator(void * this) {
+static /*@dependent@*/ TFI_t tsNextIterator(void * this) {
struct tsIterator_s * iter = this;
rpmTransactionSet ts = iter->ts;
TFI_t fi = NULL;
mi = rpmdbInitIterator(ts->rpmdb, RPMTAG_NAME, alp->name, 0);
while ((oldH = rpmdbNextIterator(mi)) != NULL)
ensureOlder(alp, oldH, ts->probs);
- rpmdbFreeIterator(mi);
+ mi = rpmdbFreeIterator(mi);
}
/* XXX multilib should not display "already installed" problems */
NULL, NULL, NULL, 0);
break;
}
- rpmdbFreeIterator(mi);
+ mi = rpmdbFreeIterator(mi);
}
totalFileCount += alp->filesCount;
if (headerGetEntry(h, RPMTAG_BASENAMES, NULL, NULL, &fileCount))
totalFileCount += fileCount;
}
- rpmdbFreeIterator(mi);
+ mi = rpmdbFreeIterator(mi);
}
/* ===============================================
* Initialize file list:
*/
ts->flEntries = ts->addedPackages.size + ts->numRemovedPackages;
- ts->flList = alloca(sizeof(*ts->flList) * (ts->flEntries));
+ ts->flList = xcalloc(ts->flEntries, sizeof(*ts->flList));
/*
* FIXME?: we'd be better off assembling one very large file list and
* calling fpLookupList only once. I'm not sure that the speedup is
* worth the trouble though.
*/
- for (oc = 0, fi = ts->flList; oc < ts->orderCount; oc++, fi++) {
- const char **preTrans;
- int preTransCount;
-
- memset(fi, 0, sizeof(*fi));
+ tsi = tsInitIterator(ts);
+ while ((fi = tsNextIterator(tsi)) != NULL) {
+ oc = tsGetOc(tsi);
fi->magic = TFIMAGIC;
- preTrans = NULL;
- preTransCount = 0;
+ /* XXX watchout: fi->type must be set for tsGetAlp() to "work" */
fi->type = ts->order[oc].type;
switch (fi->type) {
case TR_ADDED:
i = ts->order[oc].u.addedIndex;
- alp = ts->addedPackages.list + i;
- fi->ap = alp;
+ /* XXX watchout: fi->type must be set for tsGetAlp() to "work" */
+ fi->ap = tsGetAlp(tsi);
fi->record = 0;
- loadFi(alp->h, fi);
+ loadFi(fi->ap->h, fi);
if (fi->fc == 0) {
hdrs[i] = headerLink(fi->h);
continue;
/* Allocate file actions (and initialize to FA_UNKNOWN) */
fi->actions = xcalloc(fi->fc, sizeof(*fi->actions));
- hdrs[i] = relocateFileList(ts, fi, alp, fi->h, fi->actions);
+ hdrs[i] = relocateFileList(ts, fi, fi->ap, fi->h, fi->actions);
/* Skip netshared paths, not our i18n files, and excluded docs */
skipFiles(ts, fi);
break;
case TR_REMOVED:
- fi->ap = alp = NULL;
+ fi->ap = NULL;
fi->record = ts->order[oc].u.removed.dboffset;
{ rpmdbMatchIterator mi;
&fi->record, sizeof(fi->record));
if ((fi->h = rpmdbNextIterator(mi)) != NULL)
fi->h = headerLink(fi->h);
- rpmdbFreeIterator(mi);
+ mi = rpmdbFreeIterator(mi);
}
if (fi->h == NULL) {
/* ACK! */
}
if (fi->fc)
- fi->fps = xmalloc(sizeof(*fi->fps) * fi->fc);
+ fi->fps = xmalloc(fi->fc * sizeof(*fi->fps));
}
+ tsi = tsFreeIterator(tsi);
/* Open all database indices before installing. */
rpmdbOpenAll(ts->rpmdb);
/* ===============================================
* Add fingerprint for each file not skipped.
*/
- for (fi = ts->flList; (fi - ts->flList) < ts->flEntries; fi++) {
+ tsi = tsInitIterator(ts);
+ while ((fi = tsNextIterator(tsi)) != NULL) {
fpLookupList(fpc, fi->dnl, fi->bnl, fi->dil, fi->fc, fi->fps);
for (i = 0; i < fi->fc; i++) {
if (XFA_SKIPPING(fi->actions[i]))
continue;
+ /*@-dependenttrans@*/
htAddEntry(ht, fi->fps + i, fi);
+ /*@=dependenttrans@*/
}
}
+ tsi = tsFreeIterator(tsi);
NOTIFY(ts, (NULL, RPMCALLBACK_TRANS_START, 6, ts->flEntries,
NULL, ts->notifyData));
/* ===============================================
* Compute file disposition for each package in transaction set.
*/
- for (fi = ts->flList; (fi - ts->flList) < ts->flEntries; fi++) {
+ tsi = tsInitIterator(ts);
+ while ((fi = tsNextIterator(tsi)) != NULL) {
dbiIndexSet * matches;
int knownBad;
/* Extract file info for all files in this package from the database. */
matches = xcalloc(sizeof(*matches), fi->fc);
if (rpmdbFindFpList(ts->rpmdb, fi->fps, matches, fi->fc))
- return 1;
+ return 1; /* XXX WTFO? */
numShared = 0;
for (i = 0; i < fi->fc; i++)
numShared += dbiIndexSetCount(matches[i]);
/* Build sorted file info list for this package. */
- shared = sharedList = xmalloc(sizeof(*sharedList) * (numShared + 1));
+ shared = sharedList = xmalloc((numShared + 1) * sizeof(*sharedList));
for (i = 0; i < fi->fc; i++) {
/*
* Take care not to mark files as replaced in packages that will
break;
}
}
-
- NOTIFY(ts, (NULL, RPMCALLBACK_TRANS_STOP, 6, ts->flEntries,
- NULL, ts->notifyData));
+ tsi = tsFreeIterator(tsi);
if (ts->chrootDone) {
/*@-unrecog@*/ chroot("."); /*@-unrecog@*/
chdir(ts->currDir);
}
+ NOTIFY(ts, (NULL, RPMCALLBACK_TRANS_STOP, 6, ts->flEntries,
+ NULL, ts->notifyData));
+
/* ===============================================
* Free unused memory as soon as possible.
*/
headerFree(hdrs[alp - ts->addedPackages.list]);
}
- freeFl(ts, ts->flList);
+ ts->flList = freeFl(ts, ts->flList);
+ ts->flEntries = 0;
return ts->orderCount;
}
}
tsi = tsFreeIterator(tsi);
- freeFl(ts, ts->flList);
+ ts->flList = freeFl(ts, ts->flList);
+ ts->flEntries = 0;
if (ourrc)
return -1;
RPMERR_SIGGEN = _em(201), /*!< Error generating signature */
RPMERR_SIGVFY = _nm(202), /*!< */
- RPMWARN_UNLINK = _wm(512+16), /*!< unlink(2) failed */
- RPMWARN_RMDIR = _wm(512+17) /*!< rmdir(2) failed */
+ RPMWARN_UNLINK = _wm(512u+16), /*!< unlink(2) failed */
+ RPMWARN_RMDIR = _wm(512u+17) /*!< rmdir(2) failed */
} rpmerrCode;
/**
* \file rpmio/rpmio_internal.h
*/
+/*@-shadow@*/
static inline int fdFileno(void * cookie);
+/*@=shadow@*/
#include <rpmio.h>
#include <rpmurl.h>
if (lenp) *lenp = 0;
return;
}
+ /*@-mayaliasunique@*/
rpmDigestFinal(fd->digest, datap, lenp, asAscii);
+ /*@=mayaliasunique@*/
fd->digest = NULL;
}
if (lenp) *lenp = 0;
return;
}
+ /*@-mayaliasunique@*/
rpmDigestFinal(fd->digest, datap, lenp, asAscii);
+ /*@=mayaliasunique@*/
fd->digest = NULL;
}
projects / platform / upstream / rpm.git / commitdiff