# --- in progress
#+bounds
#+boundswrite
++slovak-fcns
-redecl
+-macroparams
+-declundef
+-enummemuse
+-fcnuse
+-typeuse
+-varuse
+
# --- not-yet at strict level
-bitwisesigned # pita
-elseifcomplete # 95 occurences
$(PROGRAMS): $(myLDADD) @WITH_APIDOCS_TARGET@
+.PHONY: splint
+splint:
+ splint \
+ -load build/rpmbuild.lcd \
+ -load lib/rpmlib.lcd \
+ -load rpmdb/rpmdb.lcd \
+ -load rpmio/rpmio.lcd \
+ -load popt/popt.lcd \
+ $(DEFS) $(INCLUDES) rpmqv.c $(rpmb_SOURCES)
+
.PHONY: lclint
lclint:
lclint -Dlint $(DEFS) $(INCLUDES) rpmqv.c $(rpmb_SOURCES) \
listobjs
ltconfig
ltmain.sh
-*.o
*.la
+*.lcd
*.lo
+*.o
*.S
stamp-h
stamp-h1
make -C tests beetest
./tests/beetest
+beecrypt.lcd: Makefile.am ${libbeecrypt_la_SOURCES} ${pkginclude_HEADERS} ${noinst_HEADERS}
+ lclint $(DEFS) $(INCLUDES) ${libbeecrypt_la_SOURCES} -dump $@
+
# XXX don't bite into gcj java dependencies (yet)
.PHONY: sources
sources:
/**
*/
-BEECRYPTAPI
+BEECRYPTAPI /*@unused@*/
int dsavrfy(const mp32barrett* p, const mp32barrett* q, const mp32number* g, const mp32number* hm, const mp32number* y, const mp32number* r, const mp32number* s)
/*@*/;
/** \ingroup HASH_sha1_m
*/
-BEECRYPTAPI
+BEECRYPTAPI /*@unused@*/
int sha1Reset (sha1Param* p)
/*@modifies p */;
/** \ingroup HASH_sha1_m
*/
-BEECRYPTAPI
+BEECRYPTAPI /*@unused@*/
int sha1Update (sha1Param* p, const byte* data, int size)
/*@modifies p */;
/** \ingroup HASH_sha1_m
*/
-BEECRYPTAPI
+BEECRYPTAPI /*@unused@*/
int sha1Digest (sha1Param* p, /*@out@*/ uint32* data)
/*@modifies p, data */;
Makefile.in
.libs
*.la
+*.lcd
*.lo
sed -e "s|^dependency_libs='|& -lrpm|" < librpmbuild.la > .librpmbuild.la && \
mv .librpmbuild.la librpmbuild.la
+BUILT_SOURCES = rpmbuild.lcd
+
+rpmbuild.lcd: Makefile.am ${librpmbuild_la_SOURCES} ${pkginc_HEADERS} ${noinst_HEADERS}
+ -lclint ${DEFS} ${INCLUDES} ${librpmbuild_la_SOURCES} -dump $@ 2>/dev/null
+
.PHONY: sources
sources:
@echo $(librpmbuild_la_SOURCES:%=build/%)
tagtable.c
.libs
*.la
+*.lcd
*.lo
+strict # lclint level
# --- in progress
-#+bounds # 629
-#+boundswrite # 317
++slovak-fcns
-redecl
# --- +partial artifacts
-varuse
# --- not-yet at strict level
++bounds # 0
-bitwisesigned # 255
-elseifcomplete # 95 occurences
-exportconst # 839 occurences
fi ;\
fi
-BUILT_SOURCES = getdate.c
+BUILT_SOURCES = getdate.c rpmlib.lcd
+
+rpmlib.lcd: Makefile.am ${librpm_la_SOURCES} ${pkginc_HEADERS} ${noinst_HEADERS}
+ -lclint ${DEFS} ${INCLUDES} ${librpm_la_SOURCES} -dump $@ 2>/dev/null
.PHONY: sources
sources:
+/*@-boundsread@*/
/** \ingroup payload
* \file lib/cpio.c
* Handle cpio payloads within rpm packages.
buf[num] = '\0';
ret = strtoul(buf, &end, base);
+/*@-boundswrite@*/
if (*end != '\0')
*endptr = ((char *)str) + (end - buf); /* XXX discards const */
else
*endptr = ((char *)str) + strlen(buf);
+/*@=boundswrite@*/
return ret;
}
(struct cpioCrcPhysicalHeader *)fsm->rdbuf;
int rc;
+/*@-boundswrite@*/
memset(hdr, '0', PHYS_HDR_SIZE);
memcpy(hdr->magic, CPIO_NEWC_MAGIC, sizeof(hdr->magic));
memcpy(hdr->nlink, "00000001", 8);
memcpy(hdr->namesize, "0000000b", 8);
memcpy(fsm->rdbuf + PHYS_HDR_SIZE, CPIO_TRAILER, sizeof(CPIO_TRAILER));
+/*@=boundswrite@*/
/* XXX DWRITE uses rdnb for I/O length. */
fsm->rdnb = PHYS_HDR_SIZE + sizeof(CPIO_TRAILER);
len = strlen(fsm->path) + 1; SET_NUM_FIELD(hdr->namesize, len, field);
memcpy(hdr->checksum, "00000000", 8);
+/*@-boundswrite@*/
memcpy(fsm->rdbuf + PHYS_HDR_SIZE, fsm->path, len);
+/*@=boundswrite@*/
/* XXX DWRITE uses rdnb for I/O length. */
fsm->rdnb = PHYS_HDR_SIZE + len;
if (!rc && fsm->rdnb != fsm->wrlen)
rc = CPIOERR_READ_FAILED;
if (rc) return rc;
+/*@-boundswrite@*/
memcpy(&hdr, fsm->wrbuf, fsm->rdnb);
+/*@=boundswrite@*/
if (strncmp(CPIO_CRC_MAGIC, hdr.magic, sizeof(CPIO_CRC_MAGIC)-1) &&
strncmp(CPIO_NEWC_MAGIC, hdr.magic, sizeof(CPIO_NEWC_MAGIC)-1))
fsm->path = NULL;
return rc;
}
+/*@-boundswrite@*/
memcpy(t, fsm->wrbuf, fsm->rdnb);
t[nameSize] = '\0';
+/*@=boundswrite@*/
fsm->path = t;
}
/*@=branchstate@*/
return msg;
}
+/*@=boundsread@*/
+/*@-boundsread@*/
/** \ingroup rpmts
* \file lib/depends.c
*/
/* Filter out duplicate erasures. */
if (ts->numRemovedPackages > 0 && ts->removedPackages != NULL) {
+/*@-boundswrite@*/
if (bsearch(&dboffset, ts->removedPackages, ts->numRemovedPackages,
sizeof(*ts->removedPackages), intcmp) != NULL)
return 0;
+/*@=boundswrite@*/
}
if (ts->numRemovedPackages == ts->allocedRemovedPackages) {
}
if (ts->removedPackages != NULL) { /* XXX can't happen. */
+/*@-boundswrite@*/
ts->removedPackages[ts->numRemovedPackages] = dboffset;
ts->numRemovedPackages++;
+/*@=boundswrite@*/
if (ts->numRemovedPackages > 1)
qsort(ts->removedPackages, ts->numRemovedPackages,
sizeof(*ts->removedPackages), intcmp);
}
p = rpmteNew(ts, h, TR_REMOVED, NULL, NULL, dboffset, depends);
+/*@-boundswrite@*/
ts->order[ts->orderCount] = p;
ts->orderCount++;
+/*@=boundswrite@*/
return 0;
}
if (p != NULL && duplicate && oc < ts->orderCount) {
/* XXX FIXME removed transaction element side effects need to be weeded */
/*@-type -unqualifiedtrans@*/
+/*@-boundswrite@*/
ts->order[oc] = rpmteFree(ts->order[oc]);
+/*@=boundswrite@*/
/*@=type =unqualifiedtrans@*/
}
}
p = rpmteNew(ts, h, TR_ADDED, key, relocs, -1, pkgKey);
+/*@-boundswrite@*/
ts->order[oc] = p;
+/*@=boundswrite@*/
if (!duplicate)
ts->orderCount++;
rpmteDS(p, RPMTAG_PROVIDENAME),
rpmteFI(p, RPMTAG_BASENAMES));
if (pkgKey == RPMAL_NOMATCH) {
+/*@-boundswrite@*/
ts->order[oc] = rpmteFree(ts->order[oc]);
+/*@=boundswrite@*/
ec = 1;
goto exit;
}
datap = data->data;
datalen = data->size;
+/*@-boundswrite@*/
if (xx == 0 && datap && datalen == 4)
memcpy(&rc, datap, datalen);
+/*@=boundswrite@*/
xx = dbiCclose(dbi, dbcursor, 0);
}
/*@=branchstate@*/
* @retval nzaps address of no. of relations removed
* @return (possibly NULL) formatted "q <- p" releation (malloc'ed)
*/
+/*@-boundswrite@*/
/*@-mustmod@*/ /* FIX: hack modifies, but -type disables */
static /*@owned@*/ /*@null@*/ const char *
zapRelation(rpmte q, rpmte p,
return dp;
}
/*@=mustmod@*/
+/*@=boundswrite@*/
static void prtTSI(const char * msg, tsortInfo tsi)
/*@globals fileSystem@*/
/* XXX TODO: add control bit. */
if (selected[i] != 0)
return 0;
+/*@-boundswrite@*/
selected[i] = 1;
+/*@=boundswrite@*/
/*@-nullpass@*/
if (_tso_debug)
fprintf(stderr, "addRelation: selected[%d] = 1\n", i);
* @retval qp address of first element
* @retval rp address of last element
*/
+/*@-boundswrite@*/
/*@-mustmod@*/
static void addQ(/*@dependent@*/ rpmte p,
/*@in@*/ /*@out@*/ rpmte * qp,
}
}
/*@=mustmod@*/
+/*@=boundswrite@*/
+/*@-bounds@*/
int rpmtsOrder(rpmts ts)
{
rpmds requires;
return 0;
}
+/*@=bounds@*/
/**
* Close a single database index.
for (dbix = 0; dbix < dbiTagsMax; dbix++) {
if (dbiTags[dbix] != rpmtag)
continue;
+/*@-boundswrite@*/
if (db->_dbi[dbix] != NULL) {
int xx;
/*@-unqualifiedtrans@*/ /* FIX: double indirection. */
db->_dbi[dbix] = NULL;
/*@=unqualifiedtrans@*/
}
+/*@=boundswrite@*/
break;
}
return rc;
/*@=branchstate@*/
return rc;
}
+/*@=boundsread@*/
+/*@-boundsread@*/
/** \ingroup header
* \file lib/formats.c
*/
char * val;
char * buf;
+/*@-boundswrite@*/
if (type != RPM_INT32_TYPE) {
val = xstrdup(_("(not a number)"));
} else {
/*@=formatconst@*/
buf = _free(buf);
}
+/*@=boundswrite@*/
return val;
}
char buf[15];
int anint = *((int_32 *) data);
+/*@-boundswrite@*/
if (type != RPM_INT32_TYPE) {
val = xstrdup(_("(not a number)"));
} else {
sprintf(val, formatPrefix, buf);
/*@=formatconst@*/
}
+/*@=boundswrite@*/
return val;
}
nt += 512; /* XXX slop for armor and crc */
+/*@-boundswrite@*/
val = t = xmalloc(nt + padding + 1);
*t = '\0';
t = stpcpy(t, "-----BEGIN PGP ");
t = stpcpy(t, "-----END PGP ");
t = stpcpy(t, pgpValStr(pgpArmorTbl, atype));
t = stpcpy(t, "-----\n");
+/*@=boundswrite@*/
/*@-branchstate@*/
if (s != data) s = _free(s);
{
char * val;
+/*@-boundswrite@*/
if (type != RPM_BIN_TYPE) {
val = xstrdup(_("(not a blob)"));
} else {
enc = _free(enc);
}
}
+/*@=boundswrite@*/
return val;
}
char buf[10];
int anint = *((int_32 *) data);
+/*@-boundswrite@*/
if (type != RPM_INT32_TYPE) {
val = xstrdup(_("(not a number)"));
} else {
sprintf(val, formatPrefix, buf);
/*@=formatconst@*/
}
+/*@=boundswrite@*/
return val;
}
return 1;
}
+/*@-boundswrite@*/
*type = RPM_STRING_ARRAY_TYPE;
*((const char ***) data) = list;
*freeData = 0;
+/*@=boundswrite@*/
return 0;
}
rpmTagType ipt;
char ** array;
+/*@-boundswrite@*/
if (hge(h, RPMTAG_INSTALLPREFIX, type, (void **)data, count)) {
if (freeData) *freeData = 0;
return 0;
if (type) *type = RPM_STRING_TYPE;
array = hfd(array, ipt);
return 0;
- }
+ }
+/*@=boundswrite@*/
return 1;
}
return 1;
}
+/*@-boundswrite@*/
*type = RPM_INT32_TYPE;
*freeData = 1;
return 1;
*data = usages;
+/*@=boundswrite@*/
filenames = _free(filenames);
* @retval freeData address of data-was-malloc'ed indicator
* @return 0 on success
*/
+/*@-bounds@*/
static int triggercondsTag(Header h, /*@out@*/ rpmTagType * type,
/*@out@*/ const void ** data, /*@out@*/ int_32 * count,
/*@out@*/ int * freeData)
return 0;
}
+/*@=bounds@*/
/**
* Retrieve trigger type info.
* @retval freeData address of data-was-malloc'ed indicator
* @return 0 on success
*/
+/*@-bounds@*/
static int triggertypeTag(Header h, /*@out@*/ rpmTagType * type,
/*@out@*/ const void ** data, /*@out@*/ int_32 * count,
/*@out@*/ int * freeData)
return 0;
}
+/*@=bounds@*/
/**
* Retrieve file paths.
*type = RPM_STRING_ARRAY_TYPE;
rpmBuildFileList(h, (const char ***) data, count);
+/*@-boundswrite@*/
*freeData = 1;
*freeData = 0; /* XXX WTFO? */
+/*@=boundswrite@*/
return 0;
}
char * dstring = rpmExpand(_macro_i18ndomains, NULL);
int rc;
+/*@-boundswrite@*/
*type = RPM_STRING_TYPE;
*data = NULL;
*count = 0;
*freeData = 0;
+/*@=boundswrite@*/
if (dstring && *dstring) {
char *domain, *de;
unsetenv(language);
/*@i@*/ ++_nl_msg_cat_cntr;
+/*@-boundswrite@*/
if (domain && msgid) {
*data = /*@-unrecog@*/ dgettext(domain, msgid) /*@=unrecog@*/;
*data = xstrdup(*data); /* XXX xstrdup has side effects. */
*count = 1;
*freeData = 1;
}
+/*@=boundswrite@*/
dstring = _free(dstring);
if (*data)
return 0;
rc = hge(h, tag, type, (void **)data, count);
+/*@-boundswrite@*/
if (rc && (*data) != NULL) {
*data = xstrdup(*data);
*freeData = 1;
*freeData = 0;
*data = NULL;
*count = 0;
+/*@=boundswrite@*/
return 1;
}
{ HEADER_EXT_MORE, NULL, { (void *) headerDefaultFormats } }
} ;
/*@=type@*/
+/*@=boundsread@*/
+/*@-boundsread@*/
/*@-mods@*/
/**
* \file lib/fs.c
{
if (filesystems) {
int i;
+/*@-boundswrite@*/
for (i = 0; i < numFilesystems; i++)
filesystems[i].mntPoint = _free(filesystems[i].mntPoint);
+/*@=boundswrite@*/
filesystems = _free(filesystems);
}
if (fsnames) {
filesystems[numFilesystems].mntPoint = NULL;
filesystems[numFilesystems].rdonly = 0;
+/*@-boundswrite@*/
fsnames = xcalloc((numFilesystems + 1), sizeof(*fsnames));
for (i = 0; i < numFilesystems; i++)
fsnames[i] = filesystems[i].mntPoint;
fsnames[numFilesystems] = NULL;
+/*@=boundswrite@*/
return 0;
}
if (getFilesystemList())
return 1;
+/*@-boundswrite@*/
if (listptr) *listptr = fsnames;
if (num) *num = numFilesystems;
+/*@=boundswrite@*/
return 0;
}
if (maxLen < len) maxLen = len;
}
+/*@-boundswrite@*/
buf = alloca(maxLen + 1);
lastDir = alloca(maxLen + 1);
dirName = alloca(maxLen + 1);
strcpy(lastDir, buf);
usages[lastfs] += fssizes[i];
}
+/*@=boundswrite@*/
sourceDir = _free(sourceDir);
+/*@-boundswrite@*/
/*@-branchstate@*/
if (usagesPtr)
*usagesPtr = usages;
else
usages = _free(usages);
/*@=branchstate@*/
+/*@=boundswrite@*/
return 0;
}
/*@=usereleased =onlytrans@*/
/*@=mods@*/
+/*@=boundsread@*/
+/*@-boundsread@*/
/** \ingroup payload
* \file lib/fsm.c
* File state machine to handle a payload from a package.
(st && !S_ISDIR(st->st_mode) ? (subdir ? strlen(subdir) : 0) : 0) +
(st && !S_ISDIR(st->st_mode) ? (suffix ? strlen(suffix) : 0) : 0) +
strlen(fsm->baseName) + 1;
+/*@-boundswrite@*/
s = t = xmalloc(nb);
t = stpcpy(t, fsm->dirName);
if (st && !S_ISDIR(st->st_mode))
t = stpcpy(t, fsm->baseName);
if (st && !S_ISDIR(st->st_mode))
if (suffix) t = stpcpy(t, suffix);
+/*@=boundswrite@*/
}
return s;
}
if (fi && fi->fc > 0 && fi->apath && fsmPath && *fsmPath) {
const char ** p = NULL;
+/*@-boundswrite@*/
if (fi->apath != NULL)
p = bsearch(&fsmPath, fi->apath, fi->fc, sizeof(fsmPath),
cpioStrCmp);
+/*@=boundswrite@*/
if (p) {
iter->i = p - fi->apath;
ix = mapNextIterator(iter);
dnli->active = xcalloc(fi->dc, sizeof(*dnli->active));
/* Identify parent directories not skipped. */
+/*@-boundswrite@*/
for (i = 0; i < fi->fc; i++)
if (!XFA_SKIPPING(fi->actions[i])) dnli->active[fi->dil[i]] = 1;
+/*@=boundswrite@*/
/* Exclude parent directories that are explicitly included. */
for (i = 0; i < fi->fc; i++) {
if (dnl[dnlen+bnlen] != '/' || dnl[dnlen+bnlen+1] != '\0')
/*@innercontinue@*/ continue;
/* This directory is included in the package. */
+/*@-boundswrite@*/
dnli->active[j] = 0;
+/*@=boundswrite@*/
/*@innerbreak@*/ break;
}
}
/*@=branchstate@*/
/* New hard link encountered, add new link to set. */
+/*@-boundswrite@*/
/*@-branchstate@*/
if (fsm->li == NULL) {
fsm->li = xcalloc(1, sizeof(*fsm->li));
fsm->links = fsm->li;
}
/*@=branchstate@*/
+/*@=boundswrite@*/
if (fsm->goal == FSM_PKGBUILD) --fsm->li->linksLeft;
+/*@-boundswrite@*/
fsm->li->filex[fsm->li->linksLeft] = fsm->ix;
/*@-observertrans -dependenttrans@*/
fsm->li->nsuffix[fsm->li->linksLeft] = fsm->nsuffix;
/*@=observertrans =dependenttrans@*/
+/*@=boundswrite@*/
if (fsm->goal == FSM_PKGINSTALL) fsm->li->linksLeft++;
if (fsm->goal == FSM_PKGBUILD)
RPMCALLBACK_INST_START, 0, fi->archiveSize);
}
+/*@-boundswrite@*/
/*@-assignexpose@*/
fsm->archiveSize = archiveSize;
if (fsm->archiveSize)
if (fsm->failedFile)
*fsm->failedFile = NULL;
/*@=assignexpose@*/
+/*@=boundswrite@*/
memset(fsm->sufbuf, 0, sizeof(fsm->sufbuf));
if (fsm->goal == FSM_PKGINSTALL) {
rc = fsmStage(fsm, fsm->goal);
if (rc && !ec) ec = rc;
+/*@-boundswrite@*/
if (fsm->archiveSize && ec == 0)
*fsm->archiveSize = (fdGetCpioPos(fsm->cfd) - pos);
+/*@=boundswrite@*/
return ec;
}
fsm->dirName = fi->dnl[fi->dil[i]];
fsm->baseName = fi->bnl[i];
+/*@-boundswrite@*/
switch (fsm->action) {
case FA_SKIP:
break;
default:
break;
}
+/*@=boundswrite@*/
if ((fsm->mapFlags & CPIO_MAP_PATH) || fsm->nsuffix) {
const struct stat * st = &fsm->sb;
if (fsm->mapFlags & CPIO_MAP_ABSOLUTE) {
/*@-compdef@*/ /* FIX: dirName/baseName annotations ? */
+/*@-boundswrite@*/
int nb = strlen(fsm->dirName) + strlen(fsm->baseName) + sizeof(".");
char * t = alloca(nb);
*t = '\0';
if (fsm->mapFlags & CPIO_MAP_ADDDOT)
*t++ = '.';
t = stpcpy( stpcpy(t, fsm->dirName), fsm->baseName);
+/*@=boundswrite@*/
/*@=compdef@*/
} else if (fsm->mapFlags & CPIO_MAP_PATH) {
rpmfi fi = fsmGetFi(fsm);
} else if (writeData && S_ISLNK(st->st_mode)) {
/* XXX DWRITE uses rdnb for I/O length. */
+/*@-boundswrite@*/
strcpy(fsm->rdbuf, symbuf); /* XXX restore readlink buffer. */
+/*@=boundswrite@*/
fsm->rdnb = strlen(symbuf);
rc = fsmStage(fsm, FSM_DWRITE);
if (rc) goto exit;
fsm->nsuffix = NULL;
fsm->ix = -1;
+/*@-boundswrite@*/
for (i = fsm->li->nlink - 1; i >= 0; i--) {
if (fsm->li->filex[i] < 0) continue;
fsm->path = _free(fsm->path);
fsm->li->filex[i] = -1;
}
+/*@=boundswrite@*/
fsm->ix = iterIndex;
fsm->nsuffix = nsuffix;
rc = fsmStage(fsm, FSM_LINK);
if (fsm->failedFile && rc != 0 && *fsm->failedFile == NULL) {
ec = rc;
+/*@-boundswrite@*/
*fsm->failedFile = xstrdup(fsm->path);
+/*@=boundswrite@*/
}
fsm->li->linksLeft--;
}
/*@=branchstate@*/
+/*@-boundswrite@*/
for (i = 0; i < fsm->li->nlink; i++) {
if (fsm->li->filex[i] < 0) continue;
fsm->ix = fsm->li->filex[i];
fsm->path = _free(fsm->path);
fsm->li->filex[i] = -1;
}
+/*@=boundswrite@*/
fsm->ix = iterIndex;
fsm->nsuffix = nsuffix;
int rc = 0;
fsm->path = NULL;
+/*@-boundswrite@*/
dn[0] = '\0';
/*@-observertrans -dependenttrans@*/
if (fsm->ldn != NULL && fsm->dnlx != NULL)
} while ((te - fsm->path) > fsm->dnlx[dc]);
/*@=usereleased@*/
}
+/*@=boundswrite@*/
dnli = dnlFreeIterator(dnli);
/*@=observertrans =dependenttrans@*/
fsm->path = NULL;
+/*@-boundswrite@*/
dn[0] = '\0';
fsm->dnlx = (dc ? xcalloc(dc, sizeof(*fsm->dnlx)) : NULL);
/*@-observertrans -dependenttrans@*/
}
/*@=compdef@*/
}
+/*@=boundswrite@*/
dnli = dnlFreeIterator(dnli);
/*@=observertrans =dependenttrans@*/
if (j == -1) j = i;
}
/* XXX force the contents out as well. */
+/*@-boundswrite@*/
if (j != 0) {
fsm->li->filex[0] = fsm->li->filex[j];
fsm->li->filex[j] = -1;
}
+/*@=boundswrite@*/
fsm->li->sb.st_nlink = nlink;
fsm->sb = fsm->li->sb; /* structure assignment */
_("archive file %s was not found in header file list\n"),
fsm->path);
#endif
+/*@-boundswrite@*/
if (fsm->failedFile && *fsm->failedFile == NULL)
*fsm->failedFile = xstrdup(fsm->path);
+/*@=boundswrite@*/
rc = CPIOERR_UNMAPPED_FILE;
} else {
rc = CPIOERR_HDR_TRAILER;
if (rc) break;
/* On non-install, the disk file stat is what's remapped. */
+/*@-boundswrite@*/
if (fsm->goal != FSM_PKGINSTALL)
*st = *ost; /* structure assignment */
+/*@=boundswrite@*/
/* Remap file perms, owner, and group. */
rc = fsmMapAttrs(fsm);
rc = CPIOERR_READ_FAILED;
if (rc) break;
+/*@-boundswrite@*/
fsm->wrbuf[st->st_size] = '\0';
+/*@=boundswrite@*/
/* XXX symlink(fsm->opath, fsm->path) */
/*@-dependenttrans@*/
fsm->opath = fsm->wrbuf;
errno = saveerrno;
/*@=mods@*/
}
+/*@-boundswrite@*/
if (fsm->failedFile && *fsm->failedFile == NULL)
*fsm->failedFile = xstrdup(fsm->path);
+/*@=boundswrite@*/
break;
case FSM_FINI:
if (!fsm->postpone && fsm->commit) {
}
fsm->path = _free(fsm->path);
fsm->opath = _free(fsm->opath);
+/*@-boundswrite@*/
memset(st, 0, sizeof(*st));
memset(ost, 0, sizeof(*ost));
+/*@=boundswrite@*/
break;
case FSM_COMMIT:
/* Rename pre-existing modified or unmanaged file. */
/* Notify on success. */
if (!rc) rc = fsmStage(fsm, FSM_NOTIFY);
else if (fsm->failedFile && *fsm->failedFile == NULL) {
+/*@-boundswrite@*/
*fsm->failedFile = fsm->path;
+/*@=boundswrite@*/
fsm->path = NULL;
}
break;
if (fsm->failedFile && *fsm->failedFile == NULL) {
fsm->ix = fsm->li->filex[i];
if (!fsmStage(fsm, FSM_MAP)) {
+/*@-boundswrite@*/
*fsm->failedFile = fsm->path;
+/*@=boundswrite@*/
fsm->path = NULL;
}
}
}
if (S_ISREG(st->st_mode)) {
char * path = alloca(strlen(fsm->path) + sizeof("-RPMDELETE"));
+/*@-boundswrite@*/
(void) stpcpy( stpcpy(path, fsm->path), "-RPMDELETE");
+/*@=boundswrite@*/
/*
* XXX HP-UX (and other os'es) don't permit unlink on busy
* XXX files.
break;
case FSM_READLINK:
/* XXX NUL terminated result in fsm->rdbuf, len in fsm->rdnb. */
+/*@-boundswrite@*/
rc = Readlink(fsm->path, fsm->rdbuf, fsm->rdsize - 1);
+/*@=boundswrite@*/
if (_fsm_debug && (stage & FSM_SYSCALL))
rpmMessage(RPMMESS_DEBUG, " %8s (%s, rdbuf, %d) %s\n", cur,
fsm->path, (int)(fsm->rdsize -1), (rc < 0 ? strerror(errno) : ""));
if (rc < 0) rc = CPIOERR_READLINK_FAILED;
else {
fsm->rdnb = rc;
+/*@-boundswrite@*/
fsm->rdbuf[fsm->rdnb] = '\0';
+/*@=boundswrite@*/
rc = 0;
}
break;
case FSM_PAD:
left = (modulo - (fdGetCpioPos(fsm->cfd) % modulo)) % modulo;
if (left) {
+/*@-boundswrite@*/
memset(fsm->rdbuf, 0, left);
+/*@=boundswrite@*/
/* XXX DWRITE uses rdnb for I/O length. */
fsm->rdnb = left;
(void) fsmStage(fsm, FSM_DWRITE);
}
/*@noteached@*/
}
+/*@=boundsread@*/
+/*@-bounds@*/
/*@-globstate -statictrans -unqualifiedtrans -noparams @*/
/*@-retvalint -usedef -varuse -nullderef -nullassign @*/
/*@-readonlytrans -modunconnomods -compdef -noeffectuncon @*/
/*@=readonlytrans =modunconnomods =compdef =noeffectuncon @*/
/*@=retvalint =usedef =varuse =nullderef =nullassign @*/
/*@=globstate =statictrans =unqualifiedtrans =noparams @*/
+/*@=bounds@*/
/*@access StringBuf @*/
+/*@-boundswrite@*/
char * rpmPermsString(int mode)
{
char *perms = xstrdup("----------");
return perms;
}
+/*@=boundswrite@*/
/**@todo Infinite loops through manifest files exist, operator error for now. */
+/*@-boundsread@*/
int rpmReadPackageManifest(FD_t fd, int * argcPtr, const char *** argvPtr)
{
StringBuf sb = newStringBuf();
int rc = 0;
int i;
+/*@-boundswrite@*/
if (f != NULL)
while (1) {
char line[BUFSIZ];
}
if (argcPtr)
*argcPtr = ac;
+/*@=boundswrite@*/
exit:
/*@-branchstate@*/
if (argvPtr == NULL || (rc != 0 && av)) {
if (av)
+/*@-boundswrite@*/
for (i = 0; i < ac; i++)
/*@-unqualifiedtrans@*/av[i] = _free(av[i]); /*@=unqualifiedtrans@*/
+/*@=boundswrite@*/
/*@-dependenttrans@*/ av = _free(av); /*@=dependenttrans@*/
}
/*@=branchstate@*/
return rc;
/*@=nullstate@*/
}
+/*@=boundsread@*/
* @param mode file mode
* @return (malloc'd) formatted mode string
*/
+/*@-incondefs@*/
+/*@only@*/
char * rpmPermsString(int mode)
- /*@*/;
+ /*@*/
+ /*@ensures maxSet(result) == 10 /\ maxRead(result) == 10 @*/;
+/*@=incondefs@*/
/**
* Read manifest, glob items, and append to existing args.
+/*@-boundsread@*/
/**
* \file lib/misc.c
*/
}
/*@notreached@*/
}
+/*@=boundsread@*/
/*@modifies *s */
{
char * t;
+/*@-boundswrite@*/
for (t = s + strlen(s) - 1; *t == c && t >= s; t--)
*t = '\0';
+/*@=boundswrite@*/
return s;
}
+/*@-boundsread@*/
/** \ingroup header
* \file lib/package.c
*/
int i;
{ struct stat st;
+/*@-boundswrite@*/
memset(&st, 0, sizeof(st));
+/*@=boundswrite@*/
(void) fstat(Fileno(fd), &st);
/* if fd points to a socket, pipe, etc, st.st_size is *always* zero */
if (S_ISREG(st.st_mode) && st.st_size < sizeof(*l))
/** @todo Implement disable/enable/warn/error/anal policy. */
+/*@-boundswrite@*/
buf[0] = '\0';
+/*@=boundswrite@*/
switch (rpmVerifySignature(ts, buf)) {
case RPMSIG_OK: /* Signature is OK. */
rpmMessage(RPMMESS_DEBUG, "%s: %s", fn, buf);
headerMergeLegacySigs(h, sig);
/* Bump reference count for return. */
+/*@-boundswrite@*/
*hdrp = headerLink(h, "ReadPackageFile *hdrp");
+/*@=boundswrite@*/
}
h = headerFree(h, "ReadPackageFile");
if (ts->sig != NULL)
sig = rpmFreeSignature(sig);
return rc;
}
+/*@=boundsread@*/
+/*@-boundsread@*/
/** \ingroup rpmcli
* \file lib/poptI.c
* Popt tables for install modes.
POPT_TABLEEND
};
/*@=bitwisesigned =compmempass @*/
+/*@=boundsread@*/
+/*@-bounds@*/
/** \ingroup rpmcli
* \file lib/poptQV.c
* Popt tables for query/verify modes.
POPT_TABLEEND
};
+/*@=bounds@*/
+/*@-boundsread@*/
/** \ingroup rpmts payload
* \file lib/psm.c
* Package state machine to handle a package from a transaction set.
* @param newH header to
* @return 0 on success, 1 on failure
*/
+/*@-boundswrite@*/
static int mergeFiles(rpmfi fi, Header h, Header newH)
/*@modifies h @*/
{
}
return 0;
}
+/*@=boundswrite@*/
/**
* Mark files in database shared with this package as "replaced".
/*@=nullstate@*/
}
/*@=nullpass@*/
+/*@=boundsread@*/
if (now == 0) {
now = time(NULL);
tm = localtime(&now);
+/*@-boundsread@*/
if (tm) nowtm = *tm; /* structure assignment */
+/*@=boundsread@*/
}
if (owner)
/**
*/
+/*@-boundsread@*/
static int countLinks(int_16 * fileRdevList, int_32 * fileInodeList, int nfiles,
int xfile)
/*@*/
if (nlink == 0) nlink = 1;
return nlink;
}
+/*@=boundsread@*/
+/*@-boundswrite@*/
int showQueryPackage(QVA_t qva, /*@unused@*/ rpmts ts, Header h)
{
HGE_t hge = (HGE_t)headerGetEntryMinMemory;
fileGroupList = hfd(fileGroupList, fgt);
return rc;
}
+/*@=boundswrite@*/
/**
*/
Package pkg;
char *fe;
+/*@-bounds@*/
strcpy(fmt, t->t_msgid);
for (fe = fmt; *fe && *fe != '('; fe++)
{} ;
if (*fe == '(') *fe = '\0';
+/*@=bounds@*/
h = NULL;
for (pkg = spec->packages; pkg != NULL; pkg = pkg->next) {
const char *pkgname;
continue;
fmt[0] = '\0';
+/*@-boundswrite@*/
(void) stpcpy( stpcpy( stpcpy( fmt, "%{"), tn), "}");
+/*@=boundswrite@*/
msgstr = _free(msgstr);
/* XXX this should use queryHeader(), but prints out tn as well. */
return;
}
+/*@-boundswrite@*/
switch(t->t_tag) {
case RPMTAG_SUMMARY:
case RPMTAG_GROUP:
sl->sl_lines[t->t_startx + 2] = xstrdup("\n\n");
/*@switchbreak@*/ break;
}
+/*@=boundswrite@*/
}
/*@=branchstate@*/
msgstr = _free(msgstr);
+/*@-boundsread@*/
for (i = 0; i < sl->sl_nlines; i++) {
const char * s = sl->sl_lines[i];
if (s == NULL)
if (strchr(s, '\n') == NULL && s[strlen(s)-1] != '\n')
printf("\n");
}
+/*@=boundsread@*/
}
void rpmDisplayQueryTags(FILE * fp)
/*@null@*/ Spec (*freeSpecVec) (Spec spec) = NULL;
/*@=redecl@*/
+/*@-bounds@*/
int rpmQueryVerify(QVA_t qva, rpmts ts, const char * arg)
{
const char ** av = NULL;
return res;
}
+/*@=bounds@*/
int rpmcliQuery(rpmts ts, QVA_t qva, const char ** argv)
{
/*@=assignexpose =dependenttrans =observertrans@*/
dieNeedle->dirNameLen = (dieNeedle->dirName != NULL
? strlen(dieNeedle->dirName) : 0);
+/*@-boundswrite@*/
die = bsearch(dieNeedle, al->dirs, al->numDirs,
sizeof(*dieNeedle), dieCompare);
+/*@=boundswrite@*/
if (die == NULL)
continue;
die->numFiles--;
if (i > die->numFiles)
/*@innercontinue@*/ continue;
+/*@-bounds@*/
memmove(fie, fie+1, (die->numFiles - i));
+/*@=bounds@*/
}
if (die->numFiles > 0) {
if (last > i)
al->numDirs--;
if ((die - al->dirs) > al->numDirs)
continue;
+/*@-bounds@*/
memmove(die, die+1, (al->numDirs - (die - al->dirs)));
+/*@=bounds@*/
}
if (origNumDirs > al->numDirs) {
alp->provides = rpmdsFree(alp->provides);
alp->fi = rpmfiFree(alp->fi, 1);
+/*@-boundswrite@*/
memset(alp, 0, sizeof(*alp)); /* XXX trash and burn */
+/*@=boundswrite@*/
return;
}
* @retval keyp added package key pointer (or NULL)
* @return associated package key, NULL if none
*/
+/*@null@*/
fnpyKey rpmalSatisfiesDepend(const rpmal al, const rpmds ds,
/*@null@*/ alKey * keyp)
/*@globals fileSystem @*/
/**
*/
+/*@-boundsread@*/
static int manageFile(FD_t *fdp, const char **fnp, int flags,
/*@unused@*/ int rc)
/*@globals rpmGlobalMacroContext,
return 1;
}
+/*@-boundswrite@*/
/* close and reset *fdp to NULL */
if (*fdp && (fnp == NULL || *fnp == NULL)) {
(void) Fclose(*fdp);
fd = fdFree(fd, "manageFile return");
return 0;
}
+/*@=boundswrite@*/
/* no operation */
if (*fdp && fnp && *fnp) {
/* XXX never reached */
return 1;
}
+/*@=boundsread@*/
/**
* Copy header+payload, calculating digest(s) on the fly.
*/
+/*@-boundsread@*/
static int copyFile(FD_t *sfdp, const char **sfnp,
FD_t *tfdp, const char **tfnp)
/*@globals rpmGlobalMacroContext,
if (*tfdp) (void) manageFile(tfdp, NULL, 0, rc);
return rc;
}
+/*@=boundsread@*/
/** \ingroup rpmcli
* Create/modify elements in signature header.
tmprpm[0] = '\0';
/*@-branchstate@*/
+/*@-boundsread@*/
if (argv)
- while ((rpm = *argv++) != NULL) {
+ while ((rpm = *argv++) != NULL)
+/*@=boundsread@*/
+ {
fprintf(stdout, "%s:\n", rpm);
if (manageFile(&fd, &rpm, O_RDONLY, 0))
goto exit;
+/*@-boundswrite@*/
memset(l, 0, sizeof(*l));
+/*@=boundswrite@*/
if (readLead(fd, l)) {
rpmError(RPMERR_READLEAD, _("%s: readLead failed\n"), rpm);
goto exit;
goto exit;
/* Write the lead/signature of the output rpm */
+/*@-boundswrite@*/
strcpy(tmprpm, rpm);
strcat(tmprpm, ".XXXXXX");
+/*@=boundswrite@*/
(void) mktemp(tmprpm);
trpm = tmprpm;
if (argv == NULL) return res;
/*@-branchstate@*/
- while ((fn = *argv++) != NULL) {
+/*@-boundsread@*/
+ while ((fn = *argv++) != NULL)
+/*@=boundsread@*/
+ {
const char * d = NULL;
const char * enc = NULL;
const char * n = NULL;
(void) pgpPrtPkts(pkt, pktlen, dig, 0);
digp = &dig->pubkey;
+/*@-boundswrite@*/
v = t = xmalloc(16+1);
t = stpcpy(t, pgpHexStr(digp->signid, sizeof(digp->signid)));
evr = t = xmalloc(sizeof("4X:-")+strlen(v)+strlen(r));
t = stpcpy(t, (digp->version == 4 ? "4:" : "3:"));
t = stpcpy( stpcpy( stpcpy(t, v), "-"), r);
+/*@=boundswrite@*/
/* Check for pre-existing header. */
int nosignatures = !(qva->qva_flags & VERIFY_SIGNATURE);
{
+/*@-boundswrite@*/
memset(l, 0, sizeof(*l));
+/*@=boundswrite@*/
if (readLead(fd, l)) {
rpmError(RPMERR_READLEAD, _("%s: readLead failed\n"), fn);
res++;
}
res3 = rpmVerifySignature(ts, result);
+
+/*@-bounds@*/
if (res3) {
if (rpmIsVerbose()) {
b = stpcpy(b, " ");
}
}
}
+/*@=bounds@*/
}
hi = headerFreeIterator(hi);
/** \ingroup rpmcli
* Should version 3 packages be produced?
*/
+/*@-redecl@*/
/*@unchecked@*/
extern int _noDirTokens;
+/*@=redecl@*/
#ifdef __cplusplus
extern "C" {
#include "debug.h"
-/*@access rpmds @*/
-
/**
* Enable noisy range comparison debugging message?
*/
(void) rpmdsUnlink(ds, ds->Type);
/*@-refcounttrans -usereleased@*/
+/*@-boundswrite@*/
memset(ds, 0, sizeof(*ds)); /* XXX trash and burn */
+/*@=boundswrite@*/
ds = _free(ds);
/*@=refcounttrans =usereleased@*/
return NULL;
xx = hge(h, tagEVR, &ds->EVRt, (void **) &ds->EVR, NULL);
xx = hge(h, tagF, &ds->Ft, (void **) &ds->Flags, NULL);
+/*@-boundsread@*/
if (!scareMem && ds->Flags != NULL)
ds->Flags = memcpy(xmalloc(ds->Count * sizeof(*ds->Flags)),
ds->Flags, ds->Count * sizeof(*ds->Flags));
+/*@=boundsread@*/
/*@-modfilesystem@*/
if (_rpmds_debug < 0)
nb = 0;
if (dspfx) nb += strlen(dspfx) + 1;
+/*@-boundsread@*/
if (ds->N[ds->i]) nb += strlen(ds->N[ds->i]);
if (ds->Flags[ds->i] & RPMSENSE_SENSEMASK) {
if (nb) nb++;
if (nb) nb++;
nb += strlen(ds->EVR[ds->i]);
}
+/*@=boundsread@*/
+/*@-boundswrite@*/
t = tbuf = xmalloc(nb + 1);
if (dspfx) {
t = stpcpy(t, dspfx);
t = stpcpy(t, ds->EVR[ds->i]);
}
*t = '\0';
+/*@=boundswrite@*/
return tbuf;
}
xx = hge(h, RPMTAG_EPOCH, NULL, (void **)&ep, NULL);
t = xmalloc(sizeof(*N) + strlen(n) + 1);
+/*@-boundswrite@*/
N = (const char **) t;
t += sizeof(*N);
N[0] = t;
t += strlen(t);
}
t = stpcpy( stpcpy( stpcpy( t, v), "-"), r);
+/*@=boundswrite@*/
ds = xcalloc(1, sizeof(*ds));
ds->h = NULL;
ds->Nt = -1; /* XXX to insure that hfd will free */
ds->EVR = EVR;
ds->EVRt = -1; /* XXX to insure that hfd will free */
+/*@-boundswrite@*/
ds->Flags = xmalloc(sizeof(*ds->Flags)); ds->Flags[0] = Flags;
+/*@=boundswrite@*/
ds->i = 0;
{ char pre[2];
+/*@-boundsread@*/
pre[0] = ds->Type[0];
+/*@=boundsread@*/
pre[1] = '\0';
/*@-nullstate@*/ /* LCL: ds->Type may be NULL ??? */
ds->DNEVR = rpmdsNewDNEVR(pre, ds);
ds->tagN = tagN;
ds->Count = 1;
/*@-assignexpose@*/
+/*@-boundswrite@*/
ds->N = xmalloc(sizeof(*ds->N)); ds->N[0] = N;
ds->Nt = -1; /* XXX to insure that hfd will free */
ds->EVR = xmalloc(sizeof(*ds->EVR)); ds->EVR[0] = EVR;
ds->EVRt = -1; /* XXX to insure that hfd will free */
/*@=assignexpose@*/
ds->Flags = xmalloc(sizeof(*ds->Flags)); ds->Flags[0] = Flags;
+/*@=boundswrite@*/
ds->i = 0;
{ char t[2];
+/*@-boundsread@*/
t[0] = ds->Type[0];
+/*@=boundsread@*/
t[1] = '\0';
ds->DNEVR = rpmdsNewDNEVR(t, ds);
}
const char * DNEVR = NULL;
if (ds != NULL && ds->i >= 0 && ds->i < ds->Count) {
+/*@-boundsread@*/
if (ds->DNEVR != NULL)
DNEVR = ds->DNEVR;
+/*@=boundsread@*/
}
return DNEVR;
}
const char * N = NULL;
if (ds != NULL && ds->i >= 0 && ds->i < ds->Count) {
+/*@-boundsread@*/
if (ds->N != NULL)
N = ds->N[ds->i];
+/*@=boundsread@*/
}
return N;
}
const char * EVR = NULL;
if (ds != NULL && ds->i >= 0 && ds->i < ds->Count) {
+/*@-boundsread@*/
if (ds->EVR != NULL)
EVR = ds->EVR[ds->i];
+/*@=boundsread@*/
}
return EVR;
}
int_32 Flags = 0;
if (ds != NULL && ds->i >= 0 && ds->i < ds->Count) {
+/*@-boundsread@*/
if (ds->Flags != NULL)
Flags = ds->Flags[ds->i];
+/*@=boundsread@*/
}
return Flags;
}
char *s, *se;
s = evr;
+/*@-boundsread@*/
while (*s && xisdigit(*s)) s++; /* s points to epoch terminator */
se = strrchr(s, '-'); /* se points to version terminator */
epoch = NULL; /* XXX disable epoch compare if missing */
version = evr;
}
+/*@=boundsread@*/
if (se) {
+/*@-boundswrite@*/
*se++ = '\0';
+/*@=boundswrite@*/
release = se;
} else {
release = NULL;
}
+/*@-boundswrite@*/
if (ep) *ep = epoch;
if (vp) *vp = version;
if (rp) *rp = release;
+/*@=boundswrite@*/
}
int rpmdsCompare(const rpmds A, const rpmds B)
int result;
int sense;
+/*@-boundsread@*/
/* Different names don't overlap. */
if (strcmp(A->N[A->i], B->N[B->i])) {
result = 0;
sense = rpmvercmp(aR, bR);
}
}
+/*@=boundsread@*/
aEVR = _free(aEVR);
bEVR = _free(bEVR);
rpmds provides = NULL;
int result = 0;
+/*@-boundsread@*/
if (!(req->Flags[req->i] & RPMSENSE_SENSEMASK) || !req->EVR[req->i] || *req->EVR[req->i] == '\0')
return 1;
+/*@=boundsread@*/
/* Get provides information from header */
provides = rpmdsInit(rpmdsNew(h, RPMTAG_PROVIDENAME, scareMem));
while (rpmdsNext(provides) >= 0) {
/* Filter out provides that came along for the ride. */
+/*@-boundsread@*/
if (strcmp(provides->N[provides->i], req->N[req->i]))
continue;
+/*@=boundsread@*/
result = rpmdsCompare(provides, req);
rpmds pkg;
int rc = 1; /* XXX assume match, names already match here */
+/*@-boundsread@*/
if (!((req->Flags[req->i] & RPMSENSE_SENSEMASK) && req->EVR[req->i] && *req->EVR[req->i]))
return rc;
+/*@=boundsread@*/
/* Get package information from header */
(void) headerNVR(h, &pkgN, &v, &r);
+/*@-boundswrite@*/
t = alloca(21 + strlen(v) + 1 + strlen(r) + 1);
pkgEVR = t;
*t = '\0';
t++;
}
(void) stpcpy( stpcpy( stpcpy(t, v) , "-") , r);
+/*@=boundswrite@*/
if ((pkg = rpmdsSingle(RPMTAG_PROVIDENAME, pkgN, pkgEVR, pkgFlags)) != NULL) {
rc = rpmdsCompare(pkg, req);
#include "debug.h"
-/*@access rpmfi @*/
/*@access rpmte @*/
/*@unchecked@*/
if (fi != NULL && fx >= 0 && fx < fi->fc) {
i = fi->i;
fi->i = fx;
+/*@-boundsread@*/
fi->j = fi->dil[fi->i];
+/*@=boundsread@*/
}
return i;
}
const char * BN = NULL;
if (fi != NULL && fi->i >= 0 && fi->i < fi->fc) {
+/*@-boundsread@*/
if (fi->bnl != NULL)
BN = fi->bnl[fi->i];
+/*@=boundsread@*/
}
return BN;
}
const char * DN = NULL;
if (fi != NULL && fi->j >= 0 && fi->j < fi->dc) {
+/*@-boundsread@*/
if (fi->dnl != NULL)
DN = fi->dnl[fi->j];
+/*@=boundsread@*/
}
return DN;
}
if (fi->fn == NULL)
fi->fn = xmalloc(fi->fnlen);
FN = t = fi->fn;
+/*@-boundswrite@*/
*t = '\0';
t = stpcpy(t, fi->dnl[fi->dil[fi->i]]);
t = stpcpy(t, fi->bnl[fi->i]);
+/*@=boundswrite@*/
}
/*@=branchstate@*/
return FN;
int_32 FFlags = 0;
if (fi != NULL && fi->i >= 0 && fi->i < fi->fc) {
+/*@-boundsread@*/
if (fi->fflags != NULL)
FFlags = fi->fflags[fi->i];
+/*@=boundsread@*/
}
return FFlags;
}
int_32 VFlags = 0;
if (fi != NULL && fi->i >= 0 && fi->i < fi->fc) {
+/*@-boundsread@*/
if (fi->vflags != NULL)
VFlags = fi->vflags[fi->i];
+/*@=boundsread@*/
}
return VFlags;
}
int_16 fmode = 0;
if (fi != NULL && fi->i >= 0 && fi->i < fi->fc) {
+/*@-boundsread@*/
if (fi->fmodes != NULL)
fmode = fi->fmodes[fi->i];
+/*@=boundsread@*/
}
return fmode;
}
char fstate = 0;
if (fi != NULL && fi->i >= 0 && fi->i < fi->fc) {
+/*@-boundsread@*/
if (fi->fstates != NULL)
fstate = fi->fstates[fi->i];
+/*@=boundsread@*/
}
return fstate;
}
unsigned char * md5 = NULL;
if (fi != NULL && fi->i >= 0 && fi->i < fi->fc) {
+/*@-boundsread@*/
if (fi->md5s != NULL)
md5 = fi->md5s + (16 * fi->i);
+/*@=boundsread@*/
}
return md5;
}
const char * flink = NULL;
if (fi != NULL && fi->i >= 0 && fi->i < fi->fc) {
+/*@-boundsread@*/
if (fi->flinks != NULL)
flink = fi->flinks[fi->i];
+/*@=boundsread@*/
}
return flink;
}
int_32 fsize = 0;
if (fi != NULL && fi->i >= 0 && fi->i < fi->fc) {
+/*@-boundsread@*/
if (fi->fsizes != NULL)
fsize = fi->fsizes[fi->i];
+/*@=boundsread@*/
}
return fsize;
}
int_16 frdev = 0;
if (fi != NULL && fi->i >= 0 && fi->i < fi->fc) {
+/*@-boundsread@*/
if (fi->frdevs != NULL)
frdev = fi->frdevs[fi->i];
+/*@=boundsread@*/
}
return frdev;
}
int_32 fmtime = 0;
if (fi != NULL && fi->i >= 0 && fi->i < fi->fc) {
+/*@-boundsread@*/
if (fi->fmtimes != NULL)
fmtime = fi->fmtimes[fi->i];
+/*@=boundsread@*/
}
return fmtime;
}
const char * fuser = NULL;
if (fi != NULL && fi->i >= 0 && fi->i < fi->fc) {
+/*@-boundsread@*/
if (fi->fuser != NULL)
fuser = fi->fuser[fi->i];
+/*@=boundsread@*/
}
return fuser;
}
const char * fgroup = NULL;
if (fi != NULL && fi->i >= 0 && fi->i < fi->fc) {
+/*@-boundsread@*/
if (fi->fgroup != NULL)
fgroup = fi->fgroup[fi->i];
+/*@=boundsread@*/
}
return fgroup;
}
if (fi != NULL && ++fi->i >= 0) {
if (fi->i < fi->fc) {
i = fi->i;
+/*@-boundsread@*/
if (fi->dil != NULL)
fi->j = fi->dil[fi->i];
+/*@=boundsread@*/
} else
fi->i = -1;
if (S_ISCHR(mode)) return CDEV;
if (S_ISBLK(mode)) return BDEV;
if (S_ISLNK(mode)) return LINK;
+/*@-unrecog@*/
if (S_ISSOCK(mode)) return SOCK;
+/*@=unrecog@*/
if (S_ISFIFO(mode)) return PIPE;
return REG;
}
switch (what) {
case RPMCALLBACK_INST_OPEN_FILE:
+/*@-boundsread@*/
if (filename == NULL || filename[0] == '\0')
return NULL;
+/*@=boundsread@*/
fd = Fopen(filename, "r.ufdio");
/*@-type@*/ /* FIX: still necessary? */
if (fd)
{
struct rpmlead l;
+/*@-boundswrite@*/
memcpy(&l, lead, sizeof(*lead));
+/*@=boundswrite@*/
l.magic[0] = RPMLEAD_MAGIC0;
l.magic[1] = RPMLEAD_MAGIC1;
int readLead(FD_t fd, struct rpmlead *lead)
{
+/*@-boundswrite@*/
memset(lead, 0, sizeof(*lead));
+/*@=boundswrite@*/
/*@-type@*/ /* FIX: remove timed read */
if (timedRead(fd, (char *)lead, sizeof(*lead)) != sizeof(*lead)) {
rpmError(RPMERR_READ, _("read failed: %s (%d)\n"), Fstrerror(fd),
* \file lib/rpmlead.h
* Routines to read and write an rpm lead structure for a a package.
*/
-
-#include <rpmlib.h>
-
#ifdef __cplusplus
extern "C" {
#endif
int * flags;
int n = 0;
+/*@-boundswrite@*/
while (rpmlibProvides[n].featureName != NULL)
n++;
+/*@=boundswrite@*/
names = xcalloc((n+1), sizeof(*names));
versions = xcalloc((n+1), sizeof(*versions));
flags = xcalloc((n+1), sizeof(*flags));
+/*@-boundswrite@*/
for (n = 0; rpmlibProvides[n].featureName != NULL; n++) {
names[n] = rpmlibProvides[n].featureName;
flags[n] = rpmlibProvides[n].featureFlags;
else
versions = _free(versions);
/*@=branchstate@*/
+/*@=boundswrite@*/
/*@-compmempass@*/ /* FIX: rpmlibProvides[] reachable */
return n;
/*@access fnpyKey @*/
/*@access rpmProblem @*/
-/*@access rpmps @*/
/*@unchecked@*/
static int _ps_debug = 0;
p = ps->probs + ps->numProblems;
ps->numProblems++;
+/*@-boundswrite@*/
memset(p, 0, sizeof(*p));
+/*@=boundswrite@*/
p->type = type;
p->key = key;
p->str1 = NULL;
if (dn != NULL || bn != NULL) {
+/*@-boundswrite@*/
t = xcalloc(1, (dn != NULL ? strlen(dn) : 0) +
(bn != NULL ? strlen(bn) : 0) + 1);
p->str1 = t;
if (dn != NULL) t = stpcpy(t, dn);
if (bn != NULL) t = stpcpy(t, bn);
+/*@=boundswrite@*/
}
}
+/*@-bounds@*/
/*@-mods@*/
#include "system.h"
return 0;
}
/*@=mods@*/
+/*@=bounds@*/
int _rpmte_debug = 0;
/*@access alKey @*/
-/*@access rpmte @*/
/*@access rpmtsi @*/
/*@access rpmts @*/
p->h = headerFree(p->h, "delTE");
+/*@-boundswrite@*/
memset(p, 0, sizeof(*p)); /* XXX trash and burn */
+/*@=boundswrite@*/
/*@-nullstate@*/ /* FIX: p->{NEVR,name} annotations */
return;
/*@=nullstate@*/
(void) headerNVR(h, &n, &v, &r);
NVR = t = xcalloc(1, strlen(n) + strlen(v) + strlen(r) + sizeof("--"));
+/*@-boundswrite@*/
t = stpcpy(t, n);
t = stpcpy(t, "-");
t = stpcpy(t, v);
t = stpcpy(t, r);
if (np)
*np = n;
+/*@=boundswrite@*/
return NVR;
}
* @param b 2nd instance address
* @return result of comparison
*/
-static int sugcmp(const void * a, const void * b) /*@*/
+static int sugcmp(const void * a, const void * b)
+ /*@*/
{
+/*@-boundsread@*/
const char * astr = *(const char **)a;
const char * bstr = *(const char **)b;
+/*@=boundsread@*/
return strcmp(astr, bstr);
}
* @retval np name tag value
* @return name-version-release string
*/
-/*@only@*/ char * hGetNEVR(Header h, /*@out@*/ const char ** np )
+/*@only@*/ char * hGetNEVR(Header h, /*@null@*/ /*@out@*/ const char ** np )
/*@modifies *np @*/;
#ifdef __cplusplus
/* loop through each version segment of str1 and str2 and compare them */
/*@-branchstate@*/
+/*@-boundsread@*/
while (*one && *two) {
while (*one && !xisalnum(*one)) one++;
while (*two && !xisalnum(*two)) two++;
/* save character at the end of the alpha or numeric segment */
/* so that they can be restored after the comparison */
+/*@-boundswrite@*/
oldch1 = *str1;
*str1 = '\0';
oldch2 = *str2;
*str2 = '\0';
+/*@=boundswrite@*/
/* take care of the case where the two version segments are */
/* different types: one numeric, the other alpha (i.e. empty) */
if (rc) return rc;
/* restore character that was replaced by null above */
+/*@-boundswrite@*/
*str1 = oldch1;
one = str1;
*str2 = oldch2;
two = str2;
+/*@=boundswrite@*/
}
/*@=branchstate@*/
+/*@=boundsread@*/
/* this catches the case where all numeric and alpha segments have */
/* compared identically but the segment sepparating characters were */
/* different */
+/*@-boundsread@*/
if ((!*one) && (!*two)) return 0;
/* whichever version still has characters left over wins */
if (!*one) return -1; else return 1;
+/*@=boundsread@*/
}
case RPMLOOKUPSIG_QUERY:
if (disabled)
break; /* Disabled */
+/*@-boundsread@*/
{ const char *name = rpmExpand("%{?_signature}", NULL);
if (!(name && *name != '\0'))
rc = 0;
rc = -1; /* Invalid %_signature spec in macro file */
name = _free(name);
} break;
+/*@=boundsread@*/
}
return rc;
}
char *pgpvbin;
struct stat st;
+/*@-boundsread@*/
if (!(pgpbin && pgpbin[0] != '\0')) {
pgpbin = _free(pgpbin);
saved_pgp_version = -1;
return NULL;
}
+/*@=boundsread@*/
+/*@-boundswrite@*/
pgpvbin = (char *)alloca(strlen(pgpbin) + sizeof("v"));
(void)stpcpy(stpcpy(pgpvbin, pgpbin), "v");
+/*@=boundswrite@*/
if (stat(pgpvbin, &st) == 0)
saved_pgp_version = PGP_5;
saved_pgp_version = PGP_NOTDETECTED;
}
+/*@-boundswrite@*/
if (pgpVer && pgpbin)
*pgpVer = saved_pgp_version;
+/*@=boundswrite@*/
return pgpbin;
}
Header h = NULL;
rpmRC rc = RPMRC_FAIL; /* assume failure */
+/*@-boundswrite@*/
if (headerp)
*headerp = NULL;
+/*@=boundswrite@*/
buf[0] = 0;
switch (sig_type) {
if (! headerGetEntry(h, RPMSIGTAG_SIZE, &type,
(void **)&archSize, &count))
break;
+/*@-boundsread@*/
rc = checkSize(fd, sigSize, pad, *archSize);
+/*@=boundsread@*/
}
if (pad && timedRead(fd, buf, pad) != pad)
rc = RPMRC_SHORTREAD;
break;
}
+/*@-boundswrite@*/
if (headerp && rc == RPMRC_OK)
*headerp = headerLink(h, NULL);
+/*@=boundswrite@*/
h = headerFree(h, NULL);
char *const *av;
int rc;
+/*@-boundswrite@*/
(void) stpcpy( stpcpy(sigfile, file), ".sig");
+/*@=boundswrite@*/
addMacro(NULL, "__plaintext_filename", NULL, file, -1);
addMacro(NULL, "__signature_filename", NULL, sigfile, -1);
(void) close(inpipe[1]);
(void) dosetenv("PGPPASSFD", "3", 1);
+/*@-boundsread@*/
if (pgp_path && *pgp_path != '\0')
(void) dosetenv("PGPPATH", pgp_path, 1);
+/*@=boundsread@*/
/* dosetenv("PGPPASS", passPhrase, 1); */
case PGP_2:
cmd = rpmExpand("%{?__pgp_sign_cmd}", NULL);
rc = poptParseArgvString(cmd, NULL, (const char ***)&av);
+/*@-boundsread@*/
if (!rc)
rc = execve(av[0], av+1, environ);
+/*@=boundsread@*/
break;
case PGP_5:
cmd = rpmExpand("%{?__pgp5_sign_cmd}", NULL);
rc = poptParseArgvString(cmd, NULL, (const char ***)&av);
+/*@-boundsread@*/
if (!rc)
rc = execve(av[0], av+1, environ);
+/*@=boundsread@*/
break;
case PGP_UNKNOWN:
case PGP_NOTDETECTED:
return 1;
}
+/*@-boundswrite@*/
*pktlen = st.st_size;
rpmMessage(RPMMESS_DEBUG, _("PGP sig size: %d\n"), *pktlen);
*pkt = xmalloc(*pktlen);
+/*@=boundswrite@*/
+/*@-boundsread@*/
{ FD_t fd;
rc = 0;
(void) Fclose(fd);
}
if (rc != *pktlen) {
+/*@-boundswrite@*/
*pkt = _free(*pkt);
+/*@=boundswrite@*/
rpmError(RPMERR_SIGGEN, _("unable to read the signature\n"));
return 1;
}
}
rpmMessage(RPMMESS_DEBUG, _("Got %d bytes of PGP sig\n"), *pktlen);
+/*@=boundsread@*/
return 0;
}
char *const *av;
int rc;
+/*@-boundswrite@*/
(void) stpcpy( stpcpy(sigfile, file), ".sig");
+/*@=boundswrite@*/
addMacro(NULL, "__plaintext_filename", NULL, file, -1);
addMacro(NULL, "__signature_filename", NULL, sigfile, -1);
(void) dup2(inpipe[0], 3);
(void) close(inpipe[1]);
+/*@-boundsread@*/
if (gpg_path && *gpg_path != '\0')
(void) dosetenv("GNUPGHOME", gpg_path, 1);
+/*@=boundsread@*/
cmd = rpmExpand("%{?__gpg_sign_cmd}", NULL);
rc = poptParseArgvString(cmd, NULL, (const char ***)&av);
+/*@-boundsread@*/
if (!rc)
rc = execve(av[0], av+1, environ);
+/*@=boundsread@*/
rpmError(RPMERR_EXEC, _("Could not exec %s: %s\n"), "gpg",
strerror(errno));
return 1;
}
+/*@-boundswrite@*/
*pktlen = st.st_size;
rpmMessage(RPMMESS_DEBUG, _("GPG sig size: %d\n"), *pktlen);
*pkt = xmalloc(*pktlen);
+/*@=boundswrite@*/
+/*@-boundsread@*/
{ FD_t fd;
rc = 0;
(void) Fclose(fd);
}
if (rc != *pktlen) {
+/*@-boundswrite@*/
*pkt = _free(*pkt);
+/*@=boundswrite@*/
rpmError(RPMERR_SIGGEN, _("unable to read the signature\n"));
return 1;
}
}
rpmMessage(RPMMESS_DEBUG, _("Got %d bytes of GPG sig\n"), *pktlen);
+/*@=boundsread@*/
return 0;
}
case RPMSIGTAG_GPG:
{ const char *gpg_path = rpmExpand("%{?_gpg_path}", NULL);
+/*@-boundsread@*/
if (gpg_path && *gpg_path != '\0')
(void) dosetenv("GNUPGHOME", gpg_path, 1);
+/*@=boundsread@*/
cmd = rpmExpand("%{?__gpg_check_password_cmd}", NULL);
rc = poptParseArgvString(cmd, NULL, (const char ***)&av);
+/*@-boundsread@*/
if (!rc)
rc = execve(av[0], av+1, environ);
+/*@=boundsread@*/
rpmError(RPMERR_EXEC, _("Could not exec %s: %s\n"), "gpg",
strerror(errno));
pgpVersion pgpVer;
(void) dosetenv("PGPPASSFD", "3", 1);
+/*@-boundsread@*/
if (pgp_path && *pgp_path != '\0')
xx = dosetenv("PGPPATH", pgp_path, 1);
+/*@=boundsread@*/
if ((path = rpmDetectPGPVersion(&pgpVer)) != NULL) {
switch(pgpVer) {
case PGP_2:
cmd = rpmExpand("%{?__pgp_check_password_cmd}", NULL);
rc = poptParseArgvString(cmd, NULL, (const char ***)&av);
+/*@-boundsread@*/
if (!rc)
rc = execve(av[0], av+1, environ);
+/*@=boundsread@*/
/*@innerbreak@*/ break;
case PGP_5: /* XXX legacy */
cmd = rpmExpand("%{?__pgp5_check_password_cmd}", NULL);
rc = poptParseArgvString(cmd, NULL, (const char ***)&av);
+/*@-boundsread@*/
if (!rc)
rc = execve(av[0], av+1, environ);
+/*@=boundsread@*/
/*@innerbreak@*/ break;
case PGP_UNKNOWN:
case PGP_NOTDETECTED:
switch (sigTag) {
case RPMSIGTAG_DSA:
case RPMSIGTAG_GPG:
+/*@-boundsread@*/
{ const char *name = rpmExpand("%{?_gpg_name}", NULL);
aok = (name && *name != '\0');
name = _free(name);
}
+/*@=boundsread@*/
if (!aok) {
rpmError(RPMERR_SIGGEN,
_("You must set \"%%_gpg_name\" in your macro file\n"));
case RPMSIGTAG_RSA:
case RPMSIGTAG_PGP5: /* XXX legacy */
case RPMSIGTAG_PGP:
+/*@-boundsread@*/
{ const char *name = rpmExpand("%{?_pgp_name}", NULL);
aok = (name && *name != '\0');
name = _free(name);
}
+/*@=boundsread@*/
if (!aok) {
rpmError(RPMERR_SIGGEN,
_("You must set \"%%_pgp_name\" in your macro file\n"));
return str;
}
+/*@-boundswrite@*/
static rpmVerifySignatureReturn
verifySizeSignature(const rpmts ts, /*@out@*/ char * t)
/*@modifies *t @*/
t = stpcpy(t, "\n");
return res;
}
+/*@=boundswrite@*/
+/*@-boundswrite@*/
static rpmVerifySignatureReturn
verifyMD5Signature(const rpmts ts, /*@out@*/ char * t,
/*@null@*/ DIGEST_CTX md5ctx)
t = stpcpy(t, "\n");
return res;
}
+/*@=boundswrite@*/
+/*@-boundswrite@*/
/**
* Verify header immutable region SHA1 digest.
* @param ts transaction set
t = stpcpy(t, "\n");
return res;
}
+/*@=boundswrite@*/
/**
* Retrieve pubkey from rpm database.
if (!headerGetEntry(h, RPMTAG_PUBKEYS, &pt, (void **)&pubkeys, &pc))
continue;
ix = rpmdbGetIteratorFileNum(mi);
+/*@-boundsread@*/
if (ix >= pc
|| b64decode(pubkeys[ix], (void **) &ts->pkpkt, &ts->pkpktlen))
ix = -1;
+/*@=boundsread@*/
pubkeys = headerFreeData(pubkeys, pt);
break;
}
/* XXX Verify the pubkey signature. */
/* Packet looks good, save the signer id. */
+/*@-boundsread@*/
memcpy(ts->pksignid, sigp->signid, sizeof(ts->pksignid));
+/*@=boundsread@*/
rpmMessage(RPMMESS_DEBUG, "========== %s pubkey id %s\n",
(sigp->pubkey_algo == PGPPUBKEYALGO_DSA ? "DSA" :
return 0;
}
+/*@-boundswrite@*/
/**
* Verify PGP (aka RSA/MD5) signature.
* @param ts transaction set
t = stpcpy(t, "\n");
return res;
}
+/*@=boundswrite@*/
/**
* Verify GPG (aka DSA) signature.
* @param sha1ctx
* @return RPMSIG_OK on success
*/
+/*@-boundswrite@*/
static rpmVerifySignatureReturn
verifyGPGSignature(rpmts ts, /*@out@*/ char * t,
/*@null@*/ DIGEST_CTX sha1ctx)
t = stpcpy(t, "\n");
return res;
}
+/*@=boundswrite@*/
rpmVerifySignatureReturn
rpmVerifySignature(const rpmts ts, char * result)
void truncStringBuf(StringBuf sb)
{
+/*@-boundswrite@*/
sb->buf[0] = '\0';
+/*@=boundswrite@*/
sb->tail = sb->buf;
sb->free = sb->allocated;
}
void stripTrailingBlanksStringBuf(StringBuf sb)
{
+/*@-bounds@*/
while (sb->free != sb->allocated) {
if (! xisspace(*(sb->tail - 1)))
break;
sb->tail--;
}
sb->tail[0] = '\0';
+/*@=bounds@*/
}
char * getStringBuf(StringBuf sb)
sb->tail = sb->buf + (sb->allocated - sb->free);
}
+/*@-boundswrite@*/
/*@-mayaliasunique@*/ /* FIX: shrug */
strcpy(sb->tail, s);
/*@=mayaliasunique@*/
sb->tail++;
sb->free--;
}
+/*@=boundswrite@*/
}
+/*@-boundsread@*/
/** \ingroup rpmts
* \file lib/transaction.c
*/
/**
*/
/* XXX only ts->{probs,rpmdb} modified */
+/*@-bounds@*/
static int handleInstInstalledFiles(const rpmts ts,
rpmte p, rpmfi fi,
sharedFileInfo shared,
return 0;
}
+/*@=bounds@*/
/**
*/
xx = hge(h, RPMTAG_FILESTATES, NULL, (void **) &otherStates, NULL);
+/*@-boundswrite@*/
for (i = 0; i < sharedCount; i++, shared++) {
int otherFileNum, fileNum;
otherFileNum = shared->otherFileNum;
fi->actions[fileNum] = FA_SKIP;
}
+/*@=boundswrite@*/
mi = rpmdbFreeIterator(mi);
if (adnlen == 1 && asnlen != 0) adnlen = 0;
if (bdnlen == 1 && bsnlen != 0) bdnlen = 0;
+/*@-boundswrite@*/
afn = t = alloca(adnlen+asnlen+abnlen+2);
if (adnlen) t = stpcpy(t, a->entry->dirName);
*t++ = '/';
if (b->subDir && bsnlen) t = stpcpy(t, b->subDir);
if (bbnlen) t = stpcpy(t, b->baseName);
if (bfn[0] == '/' && bfn[1] == '/') bfn++;
+/*@=boundswrite@*/
rc = strcmp(afn, bfn);
/*@-modfilesys@*/
const struct fingerPrint_s * bingoFps;
+/*@-boundswrite@*/
bingoFps = bsearch(fiFps, otherFps, otherFc, sizeof(*otherFps), fpsCompare);
+/*@=boundswrite@*/
if (bingoFps == NULL) {
/*@-modfilesys@*/
fprintf(stderr, "*** NULL %s/%s%s\n",
/*@innerbreak@*/ break;
}
+/*@-boundswrite@*/
switch (rpmteType(p)) {
case TR_ADDED:
{ struct stat sb;
fi->actions[i] = FA_ERASE;
/*@switchbreak@*/ break;
}
+/*@=boundswrite@*/
/* Update disk space info for a file. */
rpmtsUpdateDSI(ts, fi->fps[i].entry->dev,
if (p == NULL || h == NULL)
return 1;
+/*@-boundswrite@*/
nb = strlen(rpmteNEVR(p)) + (rpmteE(p) != NULL ? strlen(rpmteE(p)) : 0) + 1;
t = alloca(nb);
*t = '\0';
if (rpmteV(p) != NULL) t = stpcpy(t, rpmteV(p));
*t++ = '-';
if (rpmteR(p) != NULL) t = stpcpy(t, rpmteR(p));
+/*@=boundswrite@*/
req = rpmdsSingle(RPMTAG_REQUIRENAME, rpmteN(p), reqEVR, reqFlags);
rc = headerMatchesDepFlags(h, req);
return 0;
/*@=nullstate@*/
}
+/*@=boundsread@*/
int rc;
/* Prepend the path to root (if specified). */
+/*@-bounds@*/
if (rootDir && *rootDir != '\0'
&& !(rootDir[0] == '/' && rootDir[1] == '\0'))
{
t = stpcpy(t, fn);
fn = t;
}
+/*@=bounds@*/
+/*@-boundswrite@*/
*result = RPMVERIFY_NONE;
+/*@=boundswrite@*/
/*
* Check to see if the file was installed - if not pretend all is OK.
}
if (fn == NULL || Lstat(fn, &sb) != 0) {
+/*@-bounds@*/
*result |= RPMVERIFY_LSTATFAIL;
+/*@=bounds@*/
return 1;
}
*/
flags &= ~(omitMask | RPMVERIFY_LSTATFAIL|RPMVERIFY_READFAIL|RPMVERIFY_READLINKFAIL);
+/*@-bounds@*/
if (flags & RPMVERIFY_MD5) {
unsigned char md5sum[16];
size_t fsize;
if (name == NULL || fgroup == NULL || strcmp(name, fgroup))
*result |= RPMVERIFY_GROUP;
}
+/*@=bounds@*/
return 0;
}
int ec = 0; /* assume no problems */
int i;
+/*@-boundswrite@*/
te = t = buf;
*te = '\0';
*t = '\0';
}
}
+/*@=boundswrite@*/
fi = rpmfiUnlink(fi, "verifyHeader");
return ec;
nb += strlen(altNEVR+2) + sizeof(", ") - 1;
}
te = t = alloca(nb);
+/*@-boundswrite@*/
*te = '\0';
pkgNEVR = (ps->probs->pkgNEVR ? ps->probs->pkgNEVR : "?pkgNEVR?");
sprintf(te, _("Unsatisifed dependencies for %s: "), pkgNEVR);
te = t;
*t = '\0';
}
+/*@=boundswrite@*/
rc = 1;
}
/*@=branchstate@*/
ec = rpmQueryVerify(qva, ts, (const char *) argv);
/*@=nullpass@*/
} else {
+/*@-boundsread@*/
if (argv != NULL)
while ((arg = *argv++) != NULL) {
ec += rpmQueryVerify(qva, ts, arg);
rpmtsClean(ts);
}
+/*@=boundsread@*/
}
(void) rpmtsSetVerifySigFlags(ts, 0);
.libs
Makefile
Makefile.in
+aclocal.m4
autom4te-*
config.cache
config.guess
ChangeLog COPYING.LIB INSTALL README VERSION \
libelf.spec po/*.in po/*.po po/@PACKAGE@.pot
+BUILT_SOURCES = libelf.lcd
+
+libelf.lcd: Makefile.am
+ make -C lib libelf.lcd
+ cp lib/libelf.lcd .
+
.PHONY: sources
sources:
make -C lib sources
.libs
Makefile
Makefile.in
-*.o
*.la
+*.lcd
*.lo
+*.o
stamp-h
stamp-h2
+sys_elf.h
+strict # lclint level
# --- in progress
-#+bounds # 675
-#+boundswrite # 94
++boundsread # 0
++boundswrite # 0
-branchstate # 77
-compdef # 85
-unsignedcompare # 11
-usereleased # 50
--immediatetrans # 19
--kepttrans # 15
--temptrans # 15
+-immediatetrans # 18
+-kepttrans # 11
+-temptrans # 20
# --- +partial artifacts
-declundef
else if (!valid_type(type)) {
seterr(ERROR_UNKNOWN_TYPE);
}
+/*@-boundsread@*/
else if (!(n = _fsize(cls, ver, type))) {
seterr(ERROR_UNKNOWN_TYPE);
}
+/*@=boundsread@*/
return n;
}
else if (!valid_type(type)) {
seterr(ERROR_UNKNOWN_TYPE);
}
+/*@-boundsread@*/
else if (!(n = _msize(elf->e_class, ver, type))) {
seterr(ERROR_UNKNOWN_TYPE);
}
+/*@=boundsread@*/
else {
return count * n;
}
return _elf_getehdr(elf, cls);
}
else if (!elf->e_ehdr) {
+/*@-boundsread@*/
size = _msize(cls, _elf_version, ELF_T_EHDR);
+/*@=boundsread@*/
elf_assert(size);
if ((elf->e_ehdr = (char*)malloc(size))) {
memset(elf->e_ehdr, 0, size);
unsigned long
gelf_newehdr(Elf *elf, int cls) {
+/*@-boundsread@*/
if (!valid_class(cls) || !_msize(cls, _elf_version, ELF_T_EHDR)) {
seterr(ERROR_UNKNOWN_CLASS);
return 0;
}
+/*@=boundsread@*/
if (!_elf_newehdr(elf, cls)) {
return 0;
}
seterr(ERROR_CLASSMISMATCH);
}
else if (elf->e_ehdr || _elf_cook(elf)) {
+/*@-boundsread@*/
size = _msize(cls, _elf_version, ELF_T_PHDR);
+/*@=boundsread@*/
elf_assert(size);
if (count) {
if (!(phdr = (char*)malloc(count * size))) {
seq(copy_half(e,io,st_shndx), \
/**/))))))
+/*@-boundswrite@*/ /* FIX: memmove precondition? */
static size_t
byte_copy(unsigned char *dst, const unsigned char *src, size_t n)
/*@modifies *dst @*/
copy_type(rel_32,11,Elf32_Rel,copy_rel_11)
copy_type(shdr_32,11,Elf32_Shdr,copy_shdr_11)
copy_type(sym_32,11,Elf32_Sym,copy_sym_11)
+/*@=boundswrite@*/
typedef size_t (*xlator)(unsigned char* dst, const unsigned char* src, size_t n)
/*@modifies *dst @*/;
seterr(ERROR_UNKNOWN_TYPE);
return (size_t)-1;
}
+/*@-boundsread@*/
if (!(op = translator(sv, dv, encode, type, tof))) {
seterr(ERROR_UNKNOWN_TYPE);
return (size_t)-1;
}
return (*op)(NULL, src->d_buf, src->d_size);
+/*@=boundsread@*/
}
/*
seterr(ERROR_UNKNOWN_TYPE);
return NULL;
}
+/*@-boundsread@*/
op = translator(sv, dv, encode, type, tof);
if (!op) {
seterr(ERROR_UNKNOWN_TYPE);
tmp = (*op)(dst->d_buf, src->d_buf, src->d_size);
elf_assert(tmp == dsize);
}
+/*@=boundsread@*/
dst->d_size = dsize;
dst->d_type = type;
return dst;
seq(copy_xword(e,io,st_size), \
/**/))))))
+/*@-boundswrite@*/ /* FIX: memmove precondition? */
static size_t
byte_copy(unsigned char *dst, const unsigned char *src, size_t n)
/*@modifies *dst @*/
copy_type(rel_64,11,Elf64_Rel,copy_rel_11)
copy_type(shdr_64,11,Elf64_Shdr,copy_shdr_11)
copy_type(sym_64,11,Elf64_Sym,copy_sym_11)
+/*@=boundswrite@*/
typedef size_t (*xlator)(unsigned char* dst, const unsigned char* src, size_t n)
/*@modifies *dst @*/;
seterr(ERROR_UNKNOWN_TYPE);
return (size_t)-1;
}
+/*@-boundsread@*/
if (!(op = translator(sv, dv, encode, type, tof))) {
seterr(ERROR_UNKNOWN_TYPE);
return (size_t)-1;
}
return (*op)(NULL, src->d_buf, src->d_size);
+/*@=boundsread@*/
}
/*
seterr(ERROR_UNKNOWN_TYPE);
return NULL;
}
+/*@-boundsread@*/
op = translator(sv, dv, encode, type, tof);
+/*@=boundsread@*/
if (!op) {
seterr(ERROR_UNKNOWN_TYPE);
return NULL;
}
+/*@-boundsread@*/
dsize = (*op)(NULL, src->d_buf, src->d_size);
+/*@=boundsread@*/
if (dst->d_size < dsize) {
seterr(ERROR_DST2SMALL);
return NULL;
}
if (dsize) {
+/*@-boundsread@*/
tmp = (*op)(dst->d_buf, src->d_buf, src->d_size);
+/*@=boundsread@*/
elf_assert(tmp == dsize);
}
dst->d_size = dsize;
libelf.h nlist.h gelf.h sys_elf.h \
byteswap.h errors.h ext_types.h private.h elf_repl.h $(HDRS_V)
+BUILT_SOURCES = libelf.lcd
+
+libelf.lcd: Makefile.am ${libelf_la_SOURCES} ${noinst_HEADERS}
+ -lclint ${DEFS} ${INCLUDES} ${libelf_la_SOURCES} -dump $@ 2>/dev/null
+
.PHONY: sources
sources:
@echo $(libelf_la_SOURCES:%=libelf/lib/%)
+/*@+boundswrite@*/
/*
begin.c - implementation of the elf_begin(3) and elf_memory(3) functions.
Copyright (C) 1995 - 2001 Michael Riepe <michael@stud.uni-hannover.de>
static unsigned long
getnum(const char *str, size_t len, int base, int *err)
/*@modifies *err @*/
+ /*@requires maxSet(err) >= 0 @*/
{
unsigned long result = 0;
+/*@-boundsread@*/
while (len && *str == ' ') {
str++; len--;
}
while (len && *str == ' ') {
str++; len--;
}
+/*@=boundsread@*/
if (len) {
*err = len;
}
if (memcmp(hdr->ar_fmag, fmag, sizeof(fmag) - 1)) {
break;
}
+/*@-boundsread@*/
if (hdr->ar_name[0] != '/') {
break;
}
+/*@-boundswrite@*/
size = getnum(hdr->ar_size, sizeof(hdr->ar_size), 10, &err);
+/*@=boundswrite @*/
+/*@=boundsread@*/
if (err || !size) {
break;
}
if (offset + size > elf->e_size) {
break;
}
+/*@-boundsread@*/
if (hdr->ar_name[1] == '/' && hdr->ar_name[2] == ' ') {
elf->e_strtab = elf->e_data + offset;
elf->e_strlen = size;
if (elf->e_symtab || hdr->ar_name[1] != ' ') {
break;
}
+/*@=boundsread@*/
elf->e_symtab = elf->e_data + offset;
elf->e_symlen = size;
offset += size + (size & 1);
}
name = hdr->ar_name;
+/*@-boundsread@*/
for (namelen = sizeof(hdr->ar_name); namelen > 0; namelen--) {
if (name[namelen - 1] != ' ') {
break;
seterr(ERROR_ARSTRTAB);
return NULL;
}
+/*@-boundswrite@*/
tmp = getnum(&name[1], namelen - 1, 10, &err);
+/*@=boundswrite@*/
if (err) {
seterr(ERROR_ARSPECIAL);
return NULL;
else if (namelen > 0 && name[namelen - 1] == '/') {
namelen--;
}
- /* XXX some broken software omits the trailing slash
+/*@=boundsread@*/
+ /* XXX some broken software omits the trailing slash */
+#if 0
else {
namelen = 0;
}
- */
+#endif
if (!(arhdr = (Elf_Arhdr*)malloc(sizeof(*arhdr) +
sizeof(hdr->ar_name) + namelen + 2))) {
arhdr->ar_name = NULL;
arhdr->ar_rawname = (char*)(arhdr + 1);
+/*@-boundsread -boundswrite @*/
arhdr->ar_date = getnum(hdr->ar_date, sizeof(hdr->ar_date), 10, &err);
arhdr->ar_uid = getnum(hdr->ar_uid, sizeof(hdr->ar_uid), 10, &err);
arhdr->ar_gid = getnum(hdr->ar_gid, sizeof(hdr->ar_gid), 10, &err);
arhdr->ar_mode = getnum(hdr->ar_mode, sizeof(hdr->ar_mode), 8, &err);
arhdr->ar_size = getnum(hdr->ar_size, sizeof(hdr->ar_size), 10, &err);
+/*@=boundsread =boundswrite @*/
if (err) {
free(arhdr);
seterr(ERROR_ARHDR);
return NULL;
}
+/*@-boundswrite@*/
memcpy(arhdr->ar_rawname, hdr->ar_name, sizeof(hdr->ar_name));
arhdr->ar_rawname[sizeof(hdr->ar_name)] = '\0';
memcpy(arhdr->ar_name, name, namelen);
arhdr->ar_name[namelen] = '\0';
}
+/*@=boundswrite@*/
return arhdr;
}
if (size >= EI_NIDENT && !memcmp(elf->e_data, ELFMAG, SELFMAG)) {
elf->e_kind = ELF_K_ELF;
elf->e_idlen = EI_NIDENT;
+/*@-boundsread@*/
elf->e_class = elf->e_data[EI_CLASS];
elf->e_encoding = elf->e_data[EI_DATA];
elf->e_version = elf->e_data[EI_VERSION];
+/*@=boundsread@*/
}
else if (size >= SARMAG && !memcmp(elf->e_data, ARMAG, SARMAG)) {
_elf_init_ar(elf);
seterr(ERROR_MEM_ELF);
return NULL;
}
+/*@-boundswrite@*/ /* structure assignment */
*elf = _elf_init;
+/*@=boundswrite@*/
elf->e_fd = fd;
elf->e_parent = ref;
elf->e_size = elf->e_dsize = size;
* original image, we have to re-read the archive file.
* Will fail if the archive's file descriptor is disabled.
*/
+/*@-boundswrite@*/
if (!ref->e_cooked) {
ref->e_cooked = 1;
}
free(elf);
return NULL;
}
+/*@=boundswrite@*/
}
elf->e_next = offset + size + (size & 1);
elf->e_disabled = ref->e_disabled;
ref->e_off = elf->e_next;
}
else if (size) {
+/*@-boundswrite@*/
#if HAVE_MMAP
/*
* Using mmap on writable files will interfere with elf_update
free(elf);
return NULL;
}
+/*@=boundswrite@*/
}
_elf_check_type(elf, size);
seterr(ERROR_MEM_ELF);
return NULL;
}
+/*@-boundswrite@*/ /* structure assignment */
*elf = _elf_init;
+/*@=boundswrite@*/
elf->e_size = elf->e_dsize = size;
elf->e_data = elf->e_rawdata = image;
elf->e_readable = 1;
}
#endif /* __LIBELF64 */
+/*@=boundswrite@*/
{
long csum = 0;
+/*@-boundsread@*/
while (len--) {
csum += *ptr++;
}
+/*@=boundsread@*/
return csum;
}
_elf_item(Elf *elf, Elf_Type type, size_t n, size_t off, int *flag)
/*@globals _elf_errno @*/
/*@modifies *elf, *flag, _elf_errno @*/
+ /*@requires maxSet(flag) >= 0 @*/
{
Elf_Data src, dst;
src.d_type = type;
src.d_version = elf->e_version;
+/*@-boundsread@*/
src.d_size = n * _fsize(elf->e_class, src.d_version, type);
+/*@=boundsread@*/
elf_assert(src.d_size);
if (off + src.d_size < off /* modulo overflow */
|| off + src.d_size > elf->e_size) {
}
dst.d_version = _elf_version;
+/*@-boundsread@*/
dst.d_size = n * _msize(elf->e_class, dst.d_version, type);
+/*@=boundsread@*/
elf_assert(dst.d_size);
elf_assert(elf->e_data);
}
if (_elf_xlatetom(elf, &dst, &src)) {
+/*@-boundsread@*/
if (!*flag) {
elf->e_cooked = 1;
}
+/*@=boundsread@*/
return (char*)dst.d_buf;
}
+/*@-boundsread@*/
if (*flag) {
free(dst.d_buf);
*flag = 0;
}
+/*@=boundsread@*/
return NULL;
}
size_t num, off, align_addr;
int flag;
+/*@-boundswrite@*/
elf->e_ehdr = _elf_item(elf, ELF_T_EHDR, 1, 0, &flag);
+/*@=boundswrite@*/
if (!elf->e_ehdr) {
return 0;
}
if (flag) {
elf->e_free_ehdr = 1;
}
+/*@-boundsread@*/
align_addr = _fsize(elf->e_class, elf->e_version, ELF_T_ADDR);
+/*@=boundsread@*/
elf_assert(align_addr);
if (elf->e_class == ELFCLASS32) {
num = ((Elf32_Ehdr*)elf->e_ehdr)->e_phnum;
seterr(ERROR_ALIGN_PHDR);
return 0;
}
+/*@-boundswrite@*/
elf->e_phdr = _elf_item(elf, ELF_T_PHDR, num, off, &flag);
+/*@=boundswrite@*/
if (!elf->e_phdr) {
return 0;
}
sd->sd_data.d_size = scn->s_size;
sd->sd_data.d_version = _elf_version;
}
+/*@-boundsread@*/
elf_assert(scn == &head[0].scn);
+/*@=boundsread@*/
elf->e_scn_1 = &head[0].scn;
+/*@-boundswrite@*/
head[0].scn.s_freeme = 1;
+/*@=boundswrite@*/
}
return 1;
}
elf_assert(elf->e_parent->e_magic == ELF_MAGIC);
elf_assert(elf->e_parent->e_kind == ELF_K_AR);
siblings = &elf->e_parent->e_members;
+/*@-boundsread@*/
while (*siblings) {
if (*siblings == elf) {
+/*@-boundswrite@*/
*siblings = elf->e_link;
+/*@=boundswrite@*/
break;
}
siblings = &(*siblings)->e_link;
}
+/*@=boundsread@*/
elf_end(elf->e_parent);
_elf_free(elf->e_arhdr);
}
err = _elf_errno;
}
+/*@-boundsread@*/
if (err < 0 || err >= ERROR_NUM || _messages[err] == NULL) {
err = ERROR_UNKNOWN;
}
+/*@=boundsread@*/
#if HAVE_CATGETS
if (_libelf_cat == (nl_catd)0) {
dst = &buf;
}
if (elf->e_class == ELFCLASS64) {
+/*@-boundswrite@*/ /* structure assignment */
*dst = *(Elf64_Ehdr*)tmp;
+/*@=boundswrite@*/
}
else if (elf->e_class == ELFCLASS32) {
Elf32_Ehdr *src = (Elf32_Ehdr*)tmp;
+/*@-boundsread@*/
memcpy(dst->e_ident, src->e_ident, EI_NIDENT);
+/*@=boundsread@*/
check_and_copy(GElf_Half, dst, src, e_type, NULL);
check_and_copy(GElf_Half, dst, src, e_machine, NULL);
check_and_copy(GElf_Word, dst, src, e_version, NULL);
seterr(ERROR_MEM_EHDR);
return NULL;
}
+/*@-boundswrite@*/ /* structure assignment */
*dst = buf;
+/*@=boundswrite@*/
}
return dst;
}
return 0;
}
if (elf->e_class == ELFCLASS64) {
+/*@-boundswrite@*/ /* structure assignment */
*(Elf64_Ehdr*)tmp = *src;
+/*@=boundswrite@*/
}
else if (elf->e_class == ELFCLASS32) {
Elf32_Ehdr *dst = (Elf32_Ehdr*)tmp;
+/*@-boundsread@*/
memcpy(dst->e_ident, src->e_ident, EI_NIDENT);
+/*@=boundsread@*/
check_and_copy(Elf32_Half, dst, src, e_type, 0);
check_and_copy(Elf32_Half, dst, src, e_machine, 0);
check_and_copy(Elf32_Word, dst, src, e_version, 0);
seterr(ERROR_BADINDEX);
return NULL;
}
+/*@-boundsread@*/
n = _msize(elf->e_class, _elf_version, ELF_T_PHDR);
+/*@=boundsread@*/
if (n == 0) {
seterr(ERROR_UNIMPLEMENTED);
return NULL;
dst = &buf;
}
if (elf->e_class == ELFCLASS64) {
+/*@-boundswrite@*/ /* structure assignment */
*dst = *(Elf64_Phdr*)(tmp + ndx * n);
+/*@=boundswrite@*/
}
else if (elf->e_class == ELFCLASS32) {
Elf32_Phdr *src = (Elf32_Phdr*)(tmp + ndx * n);
seterr(ERROR_MEM_PHDR);
return NULL;
}
+/*@-boundswrite@*/ /* structure assignment */
*dst = buf;
+/*@=boundswrite@*/
}
return dst;
}
seterr(ERROR_BADINDEX);
return 0;
}
+/*@-boundsread@*/
n = _msize(elf->e_class, _elf_version, ELF_T_PHDR);
+/*@=boundsread@*/
if (n == 0) {
seterr(ERROR_UNIMPLEMENTED);
return 0;
}
if (elf->e_class == ELFCLASS64) {
+/*@-boundswrite@*/ /* structure assignment */
*(Elf64_Phdr*)(tmp + ndx * n) = *src;
+/*@=boundswrite@*/
}
else if (elf->e_class == ELFCLASS32) {
Elf32_Phdr *dst = (Elf32_Phdr*)(tmp + ndx * n);
dst = &buf;
}
if (scn->s_elf->e_class == ELFCLASS64) {
+/*@-boundswrite@*/ /* structure assignment */
*dst = scn->s_shdr64;
+/*@=boundswrite@*/
}
else if (scn->s_elf->e_class == ELFCLASS32) {
Elf32_Shdr *src = &scn->s_shdr32;
seterr(ERROR_MEM_SHDR);
return NULL;
}
+/*@-boundswrite@*/ /* structure assignment */
*dst = buf;
+/*@=boundswrite@*/
}
return dst;
}
elf_assert(scn->s_elf);
elf_assert(scn->s_elf->e_magic == ELF_MAGIC);
if (scn->s_elf->e_class == ELFCLASS64) {
+/*@-boundsread@*/ /* structure assignment */
scn->s_shdr64 = *src;
+/*@=boundsread@*/
}
else if (scn->s_elf->e_class == ELFCLASS32) {
Elf32_Shdr *dst = &scn->s_shdr32;
seterr(ERROR_BADTYPE);
return NULL;
}
+/*@-boundsread@*/
n = _msize(elf->e_class, data->d_version, type);
+/*@=boundsread@*/
if (n == 0) {
seterr(ERROR_UNIMPLEMENTED);
return NULL;
return NULL;
}
if (cls) {
+/*@-boundswrite@*/ /* structure assignment */
*cls = elf->e_class;
+/*@=boundswrite@*/
}
return (char*)data->d_buf + n * ndx;
}
return NULL;
}
if (cls == ELFCLASS64) {
+/*@-boundswrite@*/ /* structure assignment */
*dst = *(Elf64_Sym*)tmp;
+/*@=boundswrite@*/
}
else if (cls == ELFCLASS32) {
Elf32_Sym *src = (Elf32_Sym*)tmp;
seterr(ERROR_MEM_SYM);
return NULL;
}
+/*@-boundswrite@*/ /* structure assignment */
*dst = buf;
+/*@=boundswrite@*/
}
return dst;
}
return 0;
}
if (cls == ELFCLASS64) {
+/*@-boundswrite@*/ /* structure assignment */
*(Elf64_Sym*)tmp = *src;
+/*@=boundswrite@*/
}
else if (cls == ELFCLASS32) {
Elf32_Sym *dst = (Elf32_Sym*)tmp;
return NULL;
}
if (cls == ELFCLASS64) {
+/*@-boundswrite@*/ /* structure assignment */
*dst = *(Elf64_Dyn*)tmp;
+/*@=boundswrite@*/
}
else if (cls == ELFCLASS32) {
Elf32_Dyn *src = (Elf32_Dyn*)tmp;
seterr(ERROR_MEM_DYN);
return NULL;
}
+/*@-boundswrite@*/ /* structure assignment */
*dst = buf;
+/*@=boundswrite@*/
}
return dst;
}
return 0;
}
if (cls == ELFCLASS64) {
+/*@-boundswrite@*/ /* structure assignment */
*(Elf64_Dyn*)tmp = *src;
+/*@=boundswrite@*/
}
else if (cls == ELFCLASS32) {
Elf32_Dyn *dst = (Elf32_Dyn*)tmp;
return NULL;
}
if (cls == ELFCLASS64) {
+/*@-boundswrite@*/ /* structure assignment */
*dst = *(Elf64_Rela*)tmp;
+/*@=boundswrite@*/
}
else if (cls == ELFCLASS32) {
Elf32_Rela *src = (Elf32_Rela*)tmp;
seterr(ERROR_MEM_RELA);
return NULL;
}
+/*@-boundswrite@*/ /* structure assignment */
*dst = buf;
+/*@=boundswrite@*/
}
return dst;
}
return 0;
}
if (cls == ELFCLASS64) {
+/*@-boundswrite@*/ /* structure assignment */
*(Elf64_Rela*)tmp = *src;
+/*@=boundswrite@*/
}
else if (cls == ELFCLASS32) {
Elf32_Rela *dst = (Elf32_Rela*)tmp;
return NULL;
}
if (cls == ELFCLASS64) {
+/*@-boundswrite@*/ /* structure assignment */
*dst = *(Elf64_Rel*)tmp;
+/*@=boundswrite@*/
}
else if (cls == ELFCLASS32) {
Elf32_Rel *src = (Elf32_Rel*)tmp;
seterr(ERROR_MEM_REL);
return NULL;
}
+/*@-boundswrite@*/ /* structure assignment */
*dst = buf;
+/*@=boundswrite@*/
}
return dst;
}
return 0;
}
if (cls == ELFCLASS64) {
+/*@-boundswrite@*/ /* structure assignment */
*(Elf64_Rel*)tmp = *src;
+/*@=boundswrite@*/
}
else if (cls == ELFCLASS32) {
Elf32_Rel *dst = (Elf32_Rel*)tmp;
/*
hash.c - implementation of the elf_hash(3) function.
-Copyright (C) 1995, 1996 Michael Riepe <michael@stud.uni-hannover.de>
+Copyright (C) 1995 - 1999 Michael Riepe <michael@stud.uni-hannover.de>
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
#include <private.h>
+#ifndef lint
+static const char rcsid[] = "@(#) Id: hash.c,v 1.4 1999/03/17 15:21:02 michael Exp ";
+#endif /* lint */
+
unsigned long
-elf_hash(const char *name) {
+elf_hash(const unsigned char *name) {
unsigned long hash = 0;
unsigned long tmp;
- unsigned char c;
- while ((c = *name++)) {
- hash = (hash << 4) + c;
+/*@-boundsread@*/
+ while (*name) {
+ hash = (hash << 4) + *name++;
if ((tmp = hash & 0xf0000000)) {
hash ^= tmp | (tmp >> 24);
}
}
+/*@=boundsread@*/
return hash;
}
/*@*/;
/*@null@*/
extern Elf_Data *elf_getdata __P((Elf_Scn *scn, /*@null@*/ Elf_Data *data))
- /*@modifies *scn @*/;
+ /*@modifies *scn @*/
+ /*@ensures maxRead(data->d_buf) == data->d_size @*/;
/*@null@*/
extern Elf32_Ehdr *elf32_getehdr __P((Elf *elf))
/*@modifies *elf @*/;
/*@null@*/
extern char *elf_getident __P((Elf *elf, size_t *ptr))
- /*@modifies *elf, *ptr @*/;
+ /*@modifies *elf, *ptr @*/
+ /*@requires maxSet(ptr) >= 0 @*/;
/*@null@*/
extern Elf32_Phdr *elf32_getphdr __P((Elf *elf))
/*@modifies *elf @*/;
/*
newdata.c - implementation of the elf_newdata(3) function.
-Copyright (C) 1995, 1996 Michael Riepe <michael@stud.uni-hannover.de>
+Copyright (C) 1995 - 2000 Michael Riepe <michael@stud.uni-hannover.de>
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
#include <private.h>
+#ifndef lint
+static const char rcsid[] = "@(#) Id: newdata.c,v 1.6 2000/03/26 03:00:20 michael Exp ";
+#endif /* lint */
+
Elf_Data*
elf_newdata(Elf_Scn *scn) {
Scn_Data *sd;
seterr(ERROR_MEM_SCNDATA);
}
else {
+/*@-boundswrite@*/
*sd = _elf_data_init;
+/*@=boundswrite@*/
sd->sd_scn = scn;
sd->sd_data_flags = ELF_F_DIRTY;
sd->sd_freeme = 1;
scn->s_data_1 = sd;
}
scn->s_data_n = sd;
- return (Elf_Data*)sd;
+ return &sd->sd_data;
}
return NULL;
}
elf_assert(elf->e_ehdr);
elf_assert(_elf_scn_init.s_magic == SCN_MAGIC);
while ((scn = (Elf_Scn*)malloc(sizeof(*scn)))) {
+/*@-boundswrite@*/
*scn = _elf_scn_init;
+/*@=boundswrite@*/
scn->s_elf = elf;
scn->s_scn_flags = ELF_F_DIRTY;
scn->s_shdr_flags = ELF_F_DIRTY;
{
size_t off;
+/*@-boundsread@*/
if (elf->e_class == ELFCLASS32) {
off = ((Elf32_Sym*)syms)[index].st_name;
}
else {
return NULL;
}
+/*@=boundsread@*/
if (off >= 0 && off < nlimit) {
return &names[off];
}
copy_symbol(Elf *elf, struct nlist *np, const void *syms, size_t index)
/*@modifies *np @*/
{
+/*@-boundsread@*/
if (elf->e_class == ELFCLASS32) {
np->n_value = ((Elf32_Sym*)syms)[index].st_value;
np->n_scnum = ((Elf32_Sym*)syms)[index].st_shndx;
np->n_scnum = ((Elf64_Sym*)syms)[index].st_shndx;
}
#endif /* __LIBELF64 */
+/*@=boundsread@*/
/*
* this needs more work
*/
np->n_numaux = 0;
}
+/*@-boundswrite@*/ /* LCL: segfault here */
static int
_elf_nlist(Elf *elf, struct nlist *nl)
/*@modifies *elf, *nl @*/
free(table);
return 0;
}
+/*@=boundswrite@*/
int
nlist(const char *filename, struct nlist *nl) {
elf_version(oldver);
}
if (result) {
+/*@-boundsread@*/
while (nl->n_name && *nl->n_name) {
nl->n_value = 0;
nl++;
}
+/*@=boundsread@*/
}
return result;
}
unsigned s_shdr_flags; /* shdr flags (ELF_F_*) */
/*@null@*/
Scn_Data* s_data_1; /* first data buffer */
-/*@null@*/
+/*@kept@*/ /*@null@*/
Scn_Data* s_data_n; /* last data buffer */
/*@null@*/
Scn_Data* s_rawdata; /* raw data buffer */
/*@null@*/
extern void *_elf_read __P((Elf* elf, /*@returned@*/ /*@null@*/ void* buffer, size_t off, size_t len))
/*@globals _elf_errno @*/
- /*@modifies *buffer, _elf_errno @*/;
+ /*@modifies *buffer, _elf_errno @*/
+ /*@requires maxSet(buffer) >= (len - 1) @*/
+ /*@ensures maxRead(buffer) >= len @*/;
/*@null@*/
extern void *_elf_mmap __P((Elf* elf))
/*@globals _elf_errno @*/
- /*@modifies _elf_errno @*/;
+ /*@modifies _elf_errno @*/
+ /*@ensures maxSet(result) == elf->e_size /\ maxRead(result) == elf->e_size @*/;
extern int _elf_cook __P((Elf* elf))
/*@globals _elf_errno @*/
/*@modifies *elf, _elf_errno @*/;
/*
rawdata.c - implementation of the elf_rawdata(3) function.
-Copyright (C) 1995, 1996 Michael Riepe <michael@stud.uni-hannover.de>
+Copyright (C) 1995 - 2000 Michael Riepe <michael@stud.uni-hannover.de>
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
#include <private.h>
+#ifndef lint
+static const char rcsid[] = "@(#) Id: rawdata.c,v 1.6 2000/03/26 03:00:20 michael Exp ";
+#endif /* lint */
+
Elf_Data*
elf_rawdata(Elf_Scn *scn, Elf_Data *data) {
Scn_Data *sd;
return NULL;
}
else if ((sd = scn->s_rawdata)) {
- return (Elf_Data*)sd;
+ elf_assert(sd->sd_magic == DATA_MAGIC);
+ elf_assert(sd->sd_scn == scn);
+ return &sd->sd_data;
}
else if (scn->s_offset < 0 || scn->s_offset > elf->e_size) {
seterr(ERROR_OUTSIDE);
seterr(ERROR_MEM_SCNDATA);
}
else {
+/*@-boundswrite@*/
*sd = _elf_data_init;
+/*@=boundswrite@*/
sd->sd_scn = scn;
sd->sd_freeme = 1;
sd->sd_data.d_size = scn->s_size;
free(sd);
return NULL;
}
+/*@-boundsread@*/
else if (elf->e_rawdata) {
memcpy(sd->sd_memdata, elf->e_rawdata + scn->s_offset, scn->s_size);
}
+/*@=boundsread@*/
else if (!_elf_read(elf, sd->sd_memdata, scn->s_offset, scn->s_size)) {
free(sd->sd_memdata);
free(sd);
sd->sd_free_data = 1;
}
scn->s_rawdata = sd;
- return (Elf_Data*)sd;
+ return &sd->sd_data;
}
return NULL;
}
/*
rawfile.c - implementation of the elf_rawfile(3) function.
-Copyright (C) 1995, 1996 Michael Riepe <michael@stud.uni-hannover.de>
+Copyright (C) 1995 - 1998 Michael Riepe <michael@stud.uni-hannover.de>
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
#include <private.h>
+#ifndef lint
+static const char rcsid[] = "@(#) Id: rawfile.c,v 1.3 1998/06/12 19:42:38 michael Exp ";
+#endif /* lint */
+
char*
elf_rawfile(Elf *elf, size_t *ptr) {
size_t tmp;
if (!ptr) {
ptr = &tmp;
}
+/*@-boundswrite@*/
*ptr = 0;
+/*@=boundswrite@*/
if (!elf) {
return NULL;
}
}
else if (elf->e_size && !elf->e_rawdata) {
elf_assert(elf->e_data);
+/*@-boundswrite@*/
if (!elf->e_cooked) {
elf->e_rawdata = elf->e_data;
}
return NULL;
}
*ptr = elf->e_size;
+/*@=boundswrite@*/
}
return elf->e_rawdata;
}
len = max(len, sd->sd_data.d_off + fsize);
}
+/*@-boundsread@*/
*flag |= sd->sd_data_flags;
+/*@=boundsread@*/
}
+/*@-boundswrite@*/
*algn = scn_align;
+/*@=boundswrite@*/
return (off_t)len;
}
unsigned shnum;
Elf_Scn *scn;
+/*@-boundswrite@*/
*flag = elf->e_elf_flags | elf->e_phdr_flags;
+/*@=boundswrite@*/
if ((version = ehdr->e_version) == EV_NONE) {
version = EV_CURRENT;
seterr(ERROR_UNKNOWN_VERSION);
return -1;
}
+/*@-boundsread@*/
if ((encoding = ehdr->e_ident[EI_DATA]) == ELFDATANONE) {
encoding = native_encoding;
}
+/*@=boundsread@*/
if (!valid_encoding(encoding)) {
seterr(ERROR_UNKNOWN_ENCODING);
return -1;
}
+/*@-boundsread@*/
entsize = _fsize(ELFCLASS32, version, ELF_T_EHDR);
+/*@=boundsread@*/
elf_assert(entsize);
rewrite(ehdr->e_ehsize, entsize, elf->e_ehdr_flags);
off = entsize;
elf_assert(scn->s_index == shnum);
+/*@-boundsread@*/
*flag |= scn->s_scn_flags | scn->s_shdr_flags;
+/*@=boundsread@*/
if (scn->s_index == SHN_UNDEF) {
rewrite(shdr->sh_entsize, 0, scn->s_shdr_flags);
rewrite(ehdr->e_shnum, shnum, elf->e_ehdr_flags);
rewrite(ehdr->e_shentsize, entsize, elf->e_ehdr_flags);
+/*@-boundsread@*/
rewrite(ehdr->e_ident[EI_MAG0], ELFMAG0, elf->e_ehdr_flags);
rewrite(ehdr->e_ident[EI_MAG1], ELFMAG1, elf->e_ehdr_flags);
rewrite(ehdr->e_ident[EI_MAG2], ELFMAG2, elf->e_ehdr_flags);
rewrite(ehdr->e_version, version, elf->e_ehdr_flags);
*flag |= elf->e_ehdr_flags;
+/*@=boundsread@*/
return off;
}
unsigned shnum;
Elf_Scn *scn;
+/*@-boundswrite@*/
*flag = elf->e_elf_flags | elf->e_phdr_flags;
+/*@=boundswrite@*/
if ((version = ehdr->e_version) == EV_NONE) {
version = EV_CURRENT;
seterr(ERROR_UNKNOWN_VERSION);
return -1;
}
+/*@-boundsread@*/
if ((encoding = ehdr->e_ident[EI_DATA]) == ELFDATANONE) {
encoding = native_encoding;
}
+/*@=boundsread@*/
if (!valid_encoding(encoding)) {
seterr(ERROR_UNKNOWN_ENCODING);
return -1;
}
+/*@-boundsread@*/
entsize = _fsize(ELFCLASS64, version, ELF_T_EHDR);
+/*@=boundsread@*/
elf_assert(entsize);
rewrite(ehdr->e_ehsize, entsize, elf->e_ehdr_flags);
off = entsize;
elf_assert(scn->s_index == shnum);
+/*@-boundsread@*/
*flag |= scn->s_scn_flags | scn->s_shdr_flags;
+/*@=boundsread@*/
if (scn->s_index == SHN_UNDEF) {
rewrite(shdr->sh_entsize, 0, scn->s_shdr_flags);
entsize = scn_entsize(elf, version, shdr->sh_type);
if (entsize > 1) {
/* Some architectures use 64-bit hash entries. */
+/*@-boundsread@*/
if (shdr->sh_type != SHT_HASH
|| shdr->sh_entsize != _fsize(elf->e_class, version, ELF_T_ADDR))
rewrite(shdr->sh_entsize, entsize, scn->s_shdr_flags);
+/*@=boundsread@*/
}
if (layout) {
rewrite(ehdr->e_shnum, shnum, elf->e_ehdr_flags);
rewrite(ehdr->e_shentsize, entsize, elf->e_ehdr_flags);
+/*@-boundsread@*/
rewrite(ehdr->e_ident[EI_MAG0], ELFMAG0, elf->e_ehdr_flags);
rewrite(ehdr->e_ident[EI_MAG1], ELFMAG1, elf->e_ehdr_flags);
rewrite(ehdr->e_ident[EI_MAG2], ELFMAG2, elf->e_ehdr_flags);
rewrite(ehdr->e_version, version, elf->e_ehdr_flags);
*flag |= elf->e_ehdr_flags;
+/*@=boundsread@*/
return off;
}
_elf_update_pointers(Elf *elf, char *outbuf, size_t len)
/*@globals _elf_errno @*/
/*@modifies *elf, _elf_errno @*/
+ /*@requires maxSet(outbuf) >= (len - 1) @*/
{
Elf_Scn *scn;
Scn_Data *sd;
}
if (elf->e_rawdata == elf->e_data) {
/* update frozen raw image */
+/*@-boundswrite@*/ /* FIX: realloc ensures annotation? */
memcpy(data, outbuf, len);
+/*@=boundswrite@*/
elf->e_data = elf->e_rawdata = data;
/* cooked data is stored outside the raw image */
return 0;
seterr(ERROR_IO_2BIG);
return -1;
}
+/*@-boundsread@*/
memcpy(rawdata, outbuf, len);
+/*@=boundsread@*/
elf->e_rawdata = rawdata;
}
if (data == elf->e_data) {
seterr(ERROR_IO_2BIG);
return -1;
}
+/*@-boundsread@*/
memcpy(rawdata, outbuf + off, len);
+/*@=boundsread@*/
if (sd->sd_data.d_buf == sd->sd_memdata) {
sd->sd_data.d_buf = rawdata;
}
elf_assert(len);
elf_assert(elf->e_ehdr);
ehdr = (Elf32_Ehdr*)elf->e_ehdr;
+/*@-boundsread@*/
encode = ehdr->e_ident[EI_DATA];
+/*@=boundsread@*/
src.d_buf = ehdr;
src.d_type = ELF_T_EHDR;
+/*@-boundsread@*/
src.d_size = _msize(ELFCLASS32, _elf_version, ELF_T_EHDR);
+/*@=boundsread@*/
src.d_version = _elf_version;
dst.d_buf = outbuf;
dst.d_size = ehdr->e_ehsize;
src.d_buf = &scn->s_uhdr;
src.d_type = ELF_T_SHDR;
+/*@-boundsread@*/
src.d_size = _msize(ELFCLASS32, EV_CURRENT, ELF_T_SHDR);
+/*@=boundsread@*/
src.d_version = EV_CURRENT;
dst.d_buf = outbuf + ehdr->e_shoff + scn->s_index * ehdr->e_shentsize;
dst.d_size = ehdr->e_shentsize;
}
/* cleanup */
+/*@-boundswrite@*/
if (elf->e_readable && _elf_update_pointers(elf, outbuf, len)) {
return -1;
}
+/*@=boundswrite@*/
/* NOTE: ehdr is no longer valid! */
ehdr = (Elf32_Ehdr*)elf->e_ehdr; elf_assert(ehdr);
elf->e_encoding = ehdr->e_ident[EI_DATA];
+/*@-boundsread@*/
elf->e_version = ehdr->e_ident[EI_VERSION];
+/*@=boundsread@*/
elf->e_elf_flags &= ~ELF_F_DIRTY;
elf->e_ehdr_flags &= ~ELF_F_DIRTY;
elf->e_phdr_flags &= ~ELF_F_DIRTY;
elf_assert(len);
elf_assert(elf->e_ehdr);
ehdr = (Elf64_Ehdr*)elf->e_ehdr;
+/*@-boundsread@*/
encode = ehdr->e_ident[EI_DATA];
+/*@=boundsread@*/
src.d_buf = ehdr;
src.d_type = ELF_T_EHDR;
+/*@-boundsread@*/
src.d_size = _msize(ELFCLASS64, _elf_version, ELF_T_EHDR);
+/*@=boundsread@*/
src.d_version = _elf_version;
dst.d_buf = outbuf;
dst.d_size = ehdr->e_ehsize;
src.d_buf = &scn->s_uhdr;
src.d_type = ELF_T_SHDR;
+/*@-boundsread@*/
src.d_size = _msize(ELFCLASS64, EV_CURRENT, ELF_T_SHDR);
+/*@=boundsread@*/
src.d_version = EV_CURRENT;
dst.d_buf = outbuf + ehdr->e_shoff + scn->s_index * ehdr->e_shentsize;
dst.d_size = ehdr->e_shentsize;
}
/* cleanup */
+/*@-boundswrite@*/
if (elf->e_readable && _elf_update_pointers(elf, outbuf, len)) {
return -1;
}
+/*@=boundswrite@*/
/* NOTE: ehdr is no longer valid! */
ehdr = (Elf64_Ehdr*)elf->e_ehdr; elf_assert(ehdr);
elf->e_encoding = ehdr->e_ident[EI_DATA];
+/*@-boundsread@*/
elf->e_version = ehdr->e_ident[EI_VERSION];
+/*@=boundsread@*/
elf->e_elf_flags &= ~ELF_F_DIRTY;
elf->e_ehdr_flags &= ~ELF_F_DIRTY;
elf->e_phdr_flags &= ~ELF_F_DIRTY;
return -1;
}
}
+/*@-boundswrite@*/ /* FIX: mmap ensures annotation */
buf = (void*)mmap(NULL, len, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
if (buf != (char*)-1) {
/*@-nullpass@*/
/*@=nullpass@*/
return err;
}
+/*@=boundswrite@*/
#endif /* HAVE_MMAP */
if (!(buf = (char*)malloc(len))) {
seterr(ERROR_MEM_OUTBUF);
__load_verdaux(verdaux_mtype *dst, const verdaux_ftype *src, unsigned enc)
/*@modifies *dst @*/
{
+/*@-boundsread@*/
if (enc == ELFDATA2LSB) {
dst->vda_name = __load_u32L(src->vda_name);
dst->vda_next = __load_u32L(src->vda_next);
dst->vda_name = __load_u32M(src->vda_name);
dst->vda_next = __load_u32M(src->vda_next);
}
+/*@=boundsread@*/
}
static void
__load_verdef(verdef_mtype *dst, const verdef_ftype *src, unsigned enc)
/*@modifies *dst @*/
{
+/*@-boundsread@*/
if (enc == ELFDATA2LSB) {
dst->vd_version = __load_u16L(src->vd_version);
dst->vd_flags = __load_u16L(src->vd_flags);
dst->vd_aux = __load_u32M(src->vd_aux);
dst->vd_next = __load_u32M(src->vd_next);
}
+/*@=boundsread@*/
}
typedef verdaux_ftype verdaux_stype;
__load_vernaux(vernaux_mtype *dst, const vernaux_ftype *src, unsigned enc)
/*@modifies *dst @*/
{
+/*@-boundsread@*/
if (enc == ELFDATA2LSB) {
dst->vna_hash = __load_u32L(src->vna_hash);
dst->vna_flags = __load_u16L(src->vna_flags);
dst->vna_name = __load_u32M(src->vna_name);
dst->vna_next = __load_u32M(src->vna_next);
}
+/*@=boundsread@*/
}
static void
__load_verneed(verneed_mtype *dst, const verneed_ftype *src, unsigned enc)
/*@modifies *dst @*/
{
+/*@-boundsread@*/
if (enc == ELFDATA2LSB) {
dst->vn_version = __load_u16L(src->vn_version);
dst->vn_cnt = __load_u16L(src->vn_cnt);
dst->vn_aux = __load_u32M(src->vn_aux);
dst->vn_next = __load_u32M(src->vn_next);
}
+/*@=boundsread@*/
}
typedef vernaux_ftype vernaux_stype;
test1
test2
*.la
+*.lcd
*.lo
popt-*.tar.gz
# --- in progress
#+bounds # 56
-#+boundswrite # 40
++boundswrite # 40
# --- +partial artifacts
-exportlocal # 14
man_MANS = popt.3
+BUILT_SOURCES = popt.lcd
+
+popt.lcd: Makefile.am ${libpopt_la_SOURCES} ${include_HEADERS} ${noinst_HEADERS}
+ lclint -dump $@ ${libpopt_la_SOURCES}
+
.PHONY: sources
sources:
@echo $(libpopt_la_SOURCES:%=popt/%)
os->argb = PBM_FREE(os->argb);
}
+/*@-boundswrite@*/
void poptResetContext(poptContext con)
{
int i;
return;
/*@=nullstate@*/
}
+/*@=boundswrite@*/
/* Only one of longName, shortName should be set, not both. */
+/*@-boundswrite@*/
static int handleExec(/*@special@*/ poptContext con,
/*@null@*/ const char * longName, char shortName)
/*@uses con->execs, con->numExecs, con->flags, con->doExec,
return 1;
/*@=nullstate@*/
}
+/*@=boundswrite@*/
/* Only one of longName, shortName may be set at a time */
static int handleAlias(/*@special@*/ poptContext con,
}
/*@=bounds =boundswrite @*/
+/*@-boundswrite@*/
/*@observer@*/ /*@null@*/ static const struct poptOption *
findOption(const struct poptOption * opt, /*@null@*/ const char * longName,
char shortName,
return opt;
}
+/*@=boundswrite@*/
static const char * findNextArg(/*@special@*/ poptContext con,
unsigned argx, int delete_arg)
return arg;
}
+/*@-boundswrite@*/
static /*@only@*/ /*@null@*/ const char *
expandNextArg(/*@special@*/ poptContext con, const char * s)
/*@uses con->optionStack, con->os,
t = realloc(t, strlen(t) + 1); /* XXX memory leak, hard to plug */
return t;
}
+/*@=boundswrite@*/
static void poptStripArg(/*@special@*/ poptContext con, int which)
/*@uses con->arg_strip, con->optionStack @*/
/*@=compdef@*/
}
+/*@-boundswrite@*/
static int poptSaveLong(const struct poptOption * opt, long aLong)
/*@modifies opt->arg @*/
{
}
return 0;
}
+/*@=boundswrite@*/
+/*@-boundswrite@*/
static int poptSaveInt(const struct poptOption * opt, long aLong)
/*@modifies opt->arg @*/
{
}
return 0;
}
+/*@=boundswrite@*/
+/*@-boundswrite@*/
/* returns 'val' element, -1 on last item, POPT_ERROR_* on error */
int poptGetNextOpt(poptContext con)
{
return (opt ? opt->val : -1); /* XXX can't happen */
}
+/*@=boundswrite@*/
const char * poptGetOptArg(poptContext con)
{
return ret;
}
+/*@-boundswrite@*/
const char ** poptGetArgs(poptContext con)
{
if (con == NULL ||
return (con->leftovers + con->nextLeftover);
/*@=nullret =nullstate @*/
}
+/*@=boundswrite@*/
poptContext poptFreeContext(poptContext con)
{
return poptAddItem(con, item, 0);
}
+/*@-boundswrite@*/
/*@-mustmod@*/ /* LCL: con not modified? */
int poptAddItem(poptContext con, poptItem newItem, int flags)
{
return 0;
}
/*@=mustmod@*/
+/*@=boundswrite@*/
const char * poptBadOption(poptContext con, int flags)
{
return (con->os->argv ? con->os->argv[0] : "");
}
+/*@-boundswrite@*/
int poptStrippedArgv(poptContext con, int argc, char ** argv)
{
int numargs = argc;
return numargs;
}
+/*@=boundswrite@*/
poptItem item = alloca(sizeof(*item));
int i, j;
+/*@-boundswrite@*/
memset(item, 0, sizeof(*item));
/*@-type@*/
item->argc = j;
}
/*@=modobserver@*/
+/*@=boundswrite@*/
/*@-nullstate@*/ /* FIX: item->argv[] may be NULL */
if (!strcmp(entryType, "alias"))
if (close(fd) == -1)
return POPT_ERROR_ERRNO;
+/*@-boundswrite@*/
dst = buf = alloca(fileLength + 1);
chptr = file;
}
}
/*@=infloops@*/
+/*@=boundswrite@*/
return 0;
}
char * l = le;
if (le == NULL) return NULL; /* XXX can't happen */
+/*@-boundswrite@*/
*le = '\0';
*le++ = '(';
strcpy(le, defstr); le += strlen(le);
}
*le++ = ')';
*le = '\0';
+/*@=boundswrite@*/
return l;
}
if (opt->longName) nb += strlen(opt->longName);
if (argDescrip) nb += strlen(argDescrip);
+/*@-boundswrite@*/
left = malloc(nb);
if (left == NULL) return; /* XXX can't happen */
left[0] = '\0';
((opt->argInfo & POPT_ARGFLAG_ONEDASH) ? "-" : "--"),
opt->longName);
if (!*left) goto out;
+
if (argDescrip) {
char * le = left + strlen(left);
*le++ = ']';
*le = '\0';
}
+/*@=boundswrite@*/
if (help)
fprintf(fp," %-*s ", maxLeftCol, left);
}
/*@=branchstate@*/
+/*@-boundswrite@*/
if (opt != NULL)
for (; (opt->longName || opt->shortName || opt->arg); opt++) {
if (opt->shortName && !(opt->argInfo & POPT_ARG_MASK))
if (opt->arg) /* XXX program error */
(void) showShortOptions(opt->arg, fp, str);
}
+/*@=boundswrite@*/
if (s != str || *s != '\0')
return 0;
#define POPT_ARGV_ARRAY_GROW_DELTA 5
+/*@-boundswrite@*/
int poptDupArgv(int argc, const char **argv,
int * argcPtr, const char *** argvPtr)
{
*argcPtr = argc;
return 0;
}
+/*@=boundswrite@*/
+/*@-bounds@*/
int poptParseArgvString(const char * s, int * argcPtr, const char *** argvPtr)
{
const char * src;
if (argv) free(argv);
return rc;
}
+/*@=bounds@*/
#include "config.h"
#endif
+#if defined (__GLIBC__) && defined(__LCLINT__)
+/*@-declundef@*/
+/*@unchecked@*/
+extern __const __int32_t *__ctype_tolower;
+/*@unchecked@*/
+extern __const __int32_t *__ctype_toupper;
+/*@=declundef@*/
+#endif
+
#include <ctype.h>
+
#include <errno.h>
#include <fcntl.h>
#include <limits.h>
%config(noreplace,missingok) /etc/cron.daily/rpm
%config(noreplace,missingok) /etc/logrotate.d/rpm
%dir /etc/rpm
-%config(noreplace,missingok) /etc/rpm/macros.*
+#%config(noreplace,missingok) /etc/rpm/macros.*
%attr(0755, @RPMUSER@, @RPMGROUP@) %dir /var/lib/rpm
%define rpmdbattr %attr(0644, @RPMUSER@, @RPMGROUP@) %verify(not md5 size mtime) %ghost %config(missingok,noreplace)
db3lobjs
tagtbl.c
*.la
+*.lcd
*.lo
+strict # lclint level
+# --- in progress
+#+bounds # 0
++boundswrite # 0
++slovak-fcns
+
# --- +partial artifacts
-declundef
-exportheadervar
sed -e "s|^dependency_libs='|& -lrpmio|" < librpmdb.la > .librpmdb.la && \
mv .librpmdb.la librpmdb.la
-tagtbl.c: $(top_srcdir)/lib/rpmlib.h
- @echo '#include "system.h"' > $@
- @echo '#include "lib/rpmlib.h"' >> $@
+tagtbl.c: Makefile.am $(top_srcdir)/lib/rpmlib.h
+ @echo '/*@-bounds@*/' > $@
+ @echo '#include "system.h"' >> $@
+ @echo '#include <rpmlib.h>' >> $@
@echo '' >> $@
@echo '/*@observer@*/ /*@unchecked@*/' >> $@
@echo 'static const struct headerTagTableEntry_s rpmTagTbl[] = {' >> $@
@echo '' >> $@
@echo '/*@unchecked@*/' >> $@
@echo 'const int rpmTagTableSize = sizeof(rpmTagTbl) / sizeof(rpmTagTbl[0]) - 1;' >> $@
+ @echo '/*@=bounds@*/' >> $@
db.h:
@ln -sf ../$(WITH_DB_SUBDIR)/db.h $@
# XXX TODO: figger why .created addition here dinna work
BUILT_SOURCES = tagtbl.c # .created
+rpmdb.lcd: Makefile.am ${librpmdb_la_SOURCES} ${pkginc_HEADERS} ${noinst_HEADERS}
+ -lclint ${DEFS} ${INCLUDES} ${librpmdb_la_SOURCES} -dump $@ 2>/dev/null
+
.PHONY: sources
sources:
@echo $(librpmdb_la_SOURCES:%=rpmdb/%)
int type;
int count;
+/*@-boundswrite@*/
if (np) {
if (!(headerGetEntry(h, RPMTAG_NAME, &type, (void **) np, &count)
&& type == RPM_STRING_TYPE && count == 1))
&& type == RPM_STRING_TYPE && count == 1))
*rp = NULL;
}
+/*@=boundswrite@*/
return 0;
}
* @param regionid region offset
* @return no. bytes of data in region, -1 on error
*/
+/*@-boundswrite@*/
static int regionSwab(/*@null@*/ indexEntry entry, int il, int dl,
entryInfo pe, char * dataStart, int regionid)
/*@modifies *entry, *dataStart @*/
return dl;
}
+/*@=boundswrite@*/
/** \ingroup header
*/
+/*@-boundswrite@*/
static /*@only@*/ /*@null@*/ void * doHeaderUnload(Header h,
/*@out@*/ int * lengthPtr)
/*@modifies h, *lengthPtr @*/
/*@=usereleased@*/
return (void *) ei;
}
+/*@=boundswrite@*/
/** \ingroup header
* Convert header to on-disk representation.
key.info.tag = tag;
+/*@-boundswrite@*/
entry2 = entry =
bsearch(&key, h->index, h->indexUsed, sizeof(*h->index), indexCmp);
+/*@=boundswrite@*/
if (entry == NULL)
return NULL;
* @param tag tag
* @return 0 on success, 1 on failure (INCONSISTENT)
*/
+/*@-boundswrite@*/
static
int headerRemoveEntry(Header h, int_32 tag)
/*@modifies h @*/
return 0;
}
+/*@=boundswrite@*/
/** \ingroup header
* Convert header to in-memory representation.
* @param uh on-disk header blob (i.e. with offsets)
* @return header
*/
+/*@-boundswrite@*/
static /*@null@*/
Header headerLoad(/*@kept@*/ void * uh)
/*@modifies uh @*/
return h;
/*@=refcounttrans =globstate@*/
}
+/*@=boundswrite@*/
/** \ingroup header
* Convert header to on-disk representation, and then reload.
* @param tag region tag
* @return on-disk header (with offsets)
*/
+/*@-boundswrite@*/
static /*@null@*/
Header headerReload(/*@only@*/ Header h, int tag)
/*@modifies h @*/
}
return nh;
}
+/*@=boundswrite@*/
/** \ingroup header
* Make a copy and convert header to in-memory representation.
* @param magicp read (and verify) 8 bytes of (magic, 0)?
* @return header (or NULL on error)
*/
+/*@-boundswrite@*/
static /*@null@*/
Header headerRead(FD_t fd, enum hMagic magicp)
/*@modifies fd @*/
return h;
/*@-mustmod@*/
}
+/*@=boundswrite@*/
/** \ingroup header
* Write (with unload) header to file handle.
* @param minMem string pointers refer to header memory?
* @return 1 on success, otherwise error.
*/
+/*@-boundswrite@*/
static int copyEntry(const indexEntry entry,
/*@null@*/ /*@out@*/ hTYP_t type,
/*@null@*/ /*@out@*/ hPTR_t * p,
if (c) *c = count;
return rc;
}
+/*@=boundswrite@*/
/**
* Does locale match entry in header i18n table?
* @param minMem string pointers reference header memory?
* @return 1 on success, 0 on not found
*/
+/*@-boundswrite@*/
static int intGetEntry(Header h, int_32 tag,
/*@null@*/ /*@out@*/ hTAG_t type,
/*@null@*/ /*@out@*/ hPTR_t * p,
/* XXX 1 on success */
return ((rc == 1) ? 1 : 0);
}
+/*@=boundswrite@*/
/** \ingroup header
* Free data allocated when retrieved from header.
return intGetEntry(h, tag, type, p, c, 1);
}
+/*@-boundswrite@*/
int headerGetRawEntry(Header h, int_32 tag, int_32 * type, hPTR_t * p,
int_32 * c)
{
/* XXX 1 on success */
return ((rc == 1) ? 1 : 0);
}
+/*@=boundswrite@*/
/**
*/
+/*@-boundswrite@*/
static void copyData(int_32 type, /*@out@*/ void * dstPtr, const void * srcPtr,
int_32 c, int dataLength)
/*@modifies *dstPtr @*/
break;
}
}
+/*@=boundswrite@*/
/**
* Return (malloc'ed) copy of entry data.
* @retval lengthPtr no. bytes in returned data
* @return (malloc'ed) copy of entry data
*/
+/*@-boundswrite@*/
static void * grabData(int_32 type, hPTR_t p, int_32 c,
/*@out@*/ int * lengthPtr)
/*@modifies *lengthPtr @*/
*lengthPtr = length;
return data;
}
+/*@=boundswrite@*/
/** \ingroup header
* Add tag to header.
* @param c number of values
* @return 1 on success, 0 on failure
*/
+/*@-boundswrite@*/
static
int headerAppendEntry(Header h, int_32 tag, int_32 type,
const void * p, int_32 c)
return 1;
}
+/*@=boundswrite@*/
/** \ingroup header
* Add or append element to tag array in header.
* @param lang locale
* @return 1 on success, 0 on failure
*/
+/*@-bounds@*/
static
int headerAddI18NString(Header h, int_32 tag, const char * string,
const char * lang)
return 0;
}
+/*@=bounds@*/
/** \ingroup header
* Modify tag in header.
* @param num number of elements
* @return NULL always
*/
+/*@-boundswrite@*/
static /*@null@*/ sprintfToken
freeFormat( /*@only@*/ /*@null@*/ sprintfToken format, int num)
/*@modifies *format @*/
format = _free(format);
return NULL;
}
+/*@=boundswrite@*/
/**
*/
+/*@-boundswrite@*/
static void findTag(char * name, const headerTagTableEntry tags,
const headerSprintfExtension extensions,
/*@out@*/ headerTagTableEntry * tagMatch,
return;
}
}
+/*@=boundswrite@*/
/* forward ref */
static int parseExpression(sprintfToken token, char * str,
/**
*/
+/*@-boundswrite@*/
static int parseFormat(/*@null@*/ char * str, const headerTagTableEntry tags,
const headerSprintfExtension extensions,
/*@out@*/sprintfToken * formatPtr, /*@out@*/int * numTokensPtr,
return 0;
}
+/*@=boundswrite@*/
/**
*/
+/*@-boundswrite@*/
static int parseExpression(sprintfToken token, char * str,
const headerTagTableEntry tags,
const headerSprintfExtension extensions,
return 0;
}
+/*@=boundswrite@*/
/**
* @return 0 on success, 1 on failure
ext->avail = 1;
}
+/*@-boundswrite@*/
if (typeptr) *typeptr = ext->type;
if (data) *data = ext->data;
if (countptr) *countptr = ext->count;
+/*@=boundswrite@*/
return 0;
}
type = RPM_INT32_TYPE;
}
+/*@-boundswrite@*/
(void) stpcpy( stpcpy(buf, "%"), tag->format);
+/*@=boundswrite@*/
if (tag->type) {
ext = extensions;
static char hex[] = "0123456789abcdef";
const char * s = data;
+/*@-boundswrite@*/
need = 2*count + tag->pad;
val = t = xmalloc(need+1);
while (count-- > 0) {
*t++ = hex[ (i ) & 0xf ];
}
*t = '\0';
+/*@=boundswrite@*/
#endif
}
break;
/*@-branchstate@*/
if (val && need > 0) {
+/*@-boundswrite@*/
if (((*vallenp) + need) >= (*allocedp)) {
if ((*allocedp) <= need)
(*allocedp) += need;
te = stpcpy(t, val);
(*vallenp) += (te - t);
val = _free(val);
+/*@=boundswrite@*/
}
/*@=branchstate@*/
break;
case PTOK_STRING:
+/*@-boundswrite@*/
need = token->u.string.len;
if (need <= 0) break;
if (((*vallenp) + need) >= (*allocedp)) {
t = (*valp) + (*vallenp);
te = stpcpy(t, token->u.string.string);
(*vallenp) += (te - t);
+/*@=boundswrite@*/
break;
case PTOK_TAG:
need = condNumFormats * 20;
if (condFormat == NULL || need <= 0) break;
+/*@-boundswrite@*/
if (((*vallenp) + need) >= (*allocedp)) {
if ((*allocedp) <= need)
(*allocedp) += need;
(*valp) = xrealloc((*valp), (*allocedp)+1);
/*@=unqualifiedtrans@*/
}
+/*@=boundswrite@*/
t = (*valp) + (*vallenp);
for (i = 0; i < condNumFormats; i++)
/*@loopbreak@*/ break;
}
+/*@-boundswrite@*/
if (numElements == -1) {
need = sizeof("(none)") - 1;
if (((*vallenp) + need) >= (*allocedp)) {
valp, vallenp, allocedp);
}
}
+/*@=boundswrite@*/
break;
}
int i = 0;
while (ext->type != HEADER_EXT_LAST) {
+/*@-boundswrite@*/
if (cache[i].freeit) cache[i].data = _free(cache[i].data);
+/*@=boundswrite@*/
i++;
if (ext->type == HEADER_EXT_MORE)
if (type != RPM_INT32_TYPE) {
val = xstrdup(_("(not a number)"));
} else {
+/*@-boundswrite@*/
val = xmalloc(20 + padding);
strcat(formatPrefix, "o");
/*@-formatconst@*/
sprintf(val, formatPrefix, *((int_32 *) data));
/*@=formatconst@*/
+/*@=boundswrite@*/
}
return val;
if (type != RPM_INT32_TYPE) {
val = xstrdup(_("(not a number)"));
} else {
+/*@-boundswrite@*/
val = xmalloc(20 + padding);
strcat(formatPrefix, "x");
/*@-formatconst@*/
sprintf(val, formatPrefix, *((int_32 *) data));
/*@=formatconst@*/
+/*@=boundswrite@*/
}
return val;
struct tm * tstruct;
char buf[50];
+/*@-boundswrite@*/
val = xmalloc(50 + padding);
strcat(formatPrefix, "s");
/*@-formatconst@*/
sprintf(val, formatPrefix, buf);
/*@=formatconst@*/
+/*@=boundswrite@*/
}
return val;
/**
*/
+/*@-boundswrite@*/
static char * shescapeFormat(int_32 type, hPTR_t data,
char * formatPrefix, int padding, /*@unused@*/int element)
/*@modifies formatPrefix @*/
return result;
}
+/*@=boundswrite@*/
/*@-type@*/ /* FIX: cast? */
const struct headerSprintfExtension_s headerDefaultFormats[] = {
hi->next_index++;
/*@=noeffect@*/
+/*@-boundswrite@*/
if (tag)
*tag = entry->info.tag;
+/*@=boundswrite@*/
rc = copyEntry(entry, type, p, c, 0);
if ((table = (char **)xcalloc((count+1), sizeof(char *))) == NULL)
return NULL;
+/*@-boundswrite@*/
for (i = 0, e = *s; i < count > 0; i++, e += strlen(e)+1)
table[i] = e;
table[count] = NULL;
+/*@=boundswrite@*/
/*@-nullret@*/ return table; /*@=nullret@*/ /* LCL: double indirection? */
}
initted++;
}
+/*@-boundswrite@*/
if (pidp) *pidp = 0;
if (fsizep) {
return -1;
*fsizep = st->st_size;
}
+/*@=boundswrite@*/
fdno = open(path, O_RDONLY);
if (fdno < 0)
}
/*@=branchstate =uniondef @*/
+/*@-boundswrite@*/
if (pidp != NULL && bingo) {
int pipes[2];
int xx;
fdno = pipes[0];
xx = close(pipes[1]);
}
+/*@=boundswrite@*/
exit:
if (elf) (void) elf_end(elf);
}
exit:
+/*@-boundswrite@*/
if (fsizep)
*fsizep = fsize;
if (!rc)
memcpy(digest, md5sum, md5len);
+/*@=boundswrite@*/
md5sum = _free(md5sum);
return rc;
return strcmp(*first, *second);
}
+/*@-bounds@*/
void compressFilelist(Header h)
{
HGE_t hge = (HGE_t)headerGetEntryMinMemory;
xx = hre(h, RPMTAG_OLDFILENAMES);
}
+/*@=bounds@*/
/*
* This is pretty straight-forward. The only thing that even resembles a trick
-/*@-mustmod -sizeoftype @*/
+/*@-bounds -mustmod -sizeoftype @*/
/*-
* Copyright (c) 1992, 1993
* The Regents of the University of California. All rights reserved.
/*@=usereleased@*/
return (0);
}
-/*@=mustmod =sizeoftype @*/
+/*@=bounds =mustmod =sizeoftype @*/
#include "system.h"
#include <rpmcli.h>
-#include "legacy.h" /* XXX _noDirTokens */
#include "debug.h"
#ifndef H_RPMDB
#define H_RPMDB
+/*@-bounds@*/
/** \ingroup rpmdb dbi db1 db3
* \file rpmdb/rpmdb.h
}
#endif
+/*@=bounds@*/
#endif /* H_RPMDB */
return ht;
}
+/*@-boundswrite@*/
void htAddEntry(hashTable ht, const void * key, const void * data)
{
unsigned int hash;
b->data = xrealloc(b->data, sizeof(*b->data) * (b->dataCount + 1));
b->data[b->dataCount++] = data;
}
+/*@=boundswrite@*/
hashTable htFree(hashTable ht)
{
b = ht->buckets[i];
if (b == NULL)
continue;
+/*@-boundswrite@*/
ht->buckets[i] = NULL;
+/*@=boundswrite@*/
if (ht->keySize > 0)
b->key = _free(b->key);
do {
n = b->next;
/*@-branchstate@*/
if (b->data) {
+/*@-boundswrite@*/
if (ht->freeData)
*b->data = _free(*b->data);
+/*@=boundswrite@*/
b->data = _free(b->data);
}
/*@=branchstate@*/
if ((b = findEntry(ht, key)) == NULL)
return 1;
+/*@-boundswrite@*/
if (data)
*data = (const void **) b->data;
if (dataCount)
*dataCount = b->dataCount;
if (tableKey)
*tableKey = b->key;
+/*@=boundswrite@*/
return 0;
}
}
strcpy(nameBuf, "(unknown)");
+/*@-boundswrite@*/
for (i = 0; i < rpmTagTableSize; i++) {
if (tag != rpmTagTable[i].val)
continue;
*s = xtolower(*s);
break;
}
+/*@=boundswrite@*/
return nameBuf;
}
Makefile.in
.libs
*.la
+*.lcd
*.lo
tdigest
tdir
clean-local:
rm -f $(BEECRYPTLOBJS) *.o .created
+BUILT_SOURCES = rpmio.lcd
+
+rpmio.lcd: Makefile.am ${librpmio_la_SOURCES} ${pkginc_HEADERS} ${noinst_HEADERS}
+ -lclint -load ../beecrypt/beecrypt.lcd $(DEFS) $(INCLUDES) $(librpmio_la_SOURCES) -dump $@ 2>/dev/null
+
+.PHONY: sources
+sources:
+ @echo $(librpmio_la_SOURCES:%=rpmio/%)
+
+.PHONY: lclint
+lclint:
+ lclint $(DEFS) $(INCLUDES) $(librpmio_la_SOURCES)
+
tdigest_SOURCES = tdigest.c
tdigest_LDADD = librpmio.la $(top_builddir)/popt/libpopt.la
dumpasn1_SOURCES = dumpasn1.c
-.PHONY: sources
-sources:
- @echo $(librpmio_la_SOURCES:%=rpmio/%)
-
-.PHONY: lclint
-lclint:
- lclint $(DEFS) $(INCLUDES) $(librpmio_la_SOURCES)
-
tficl.o: tficl.c
$(COMPILE) -I/usr/include/ficl -o $@ -c tficl.c
#ifndef H_RPMIO_INTERNAL
#define H_RPMIO_INTERNAL
+/*@-bounds@*/
/** \ingroup rpmio
* \file rpmio/rpmio_internal.h
}
#endif
+/*@=bounds@*/
#endif /* H_RPMIO_INTERNAL */
#ifndef H_RPMPGP
#define H_RPMPGP
+/*@-bounds@*/
/** \ingroup rpmio
* \file rpmio/rpmpgp.h
#endif
/*@=fcnuse@*/
+/*@=bounds@*/
#endif /* H_RPMPGP */
#if defined(__LCLINT__)
/*@-declundef -incondefs @*/ /* LCL: missing annotation */
/*@only@*/ /*@out@*/ void * alloca (size_t __size)
- /*@ensures MaxSet(result) == (__size - 1) @*/
+ /*@ensures maxSet(result) == (__size - 1) @*/
/*@*/;
/*@=declundef =incondefs @*/
#endif
*/
/*@mayexit@*/ /*@only@*/ /*@out@*/ void * xmalloc (size_t size)
/*@globals errno @*/
- /*@ensures MaxSet(result) == (size - 1) @*/
+ /*@ensures maxSet(result) == (size - 1) @*/
/*@modifies errno @*/;
/**
*/
/*@mayexit@*/ /*@only@*/ void * xcalloc (size_t nmemb, size_t size)
- /*@ensures MaxSet(result) == (nmemb - 1) @*/
+ /*@ensures maxSet(result) == (nmemb - 1) @*/
/*@*/;
/**
*/
/*@mayexit@*/ /*@only@*/ void * xrealloc (/*@null@*/ /*@only@*/ void * ptr,
size_t size)
- /*@ensures MaxSet(result) == (size - 1) @*/
+ /*@ensures maxSet(result) == (size - 1) @*/
/*@modifies *ptr @*/;
/**
#include "system.h"
-#include "header.h"
+#include <rpmlib.h>
#include "rpmlead.h"
#include "signature.h"
#include "system.h"
-#include "header.h"
+#include <rpmlib.h>
#include "rpmlead.h"
#include "signature.h"
#include "debug.h"
#include "system.h"
-#include "rpmio.h"
+#include <rpmlib.h>
#include "rpmlead.h"
#include "debug.h"
#include "system.h"
+#include <rpmlib.h>
#include "rpmlead.h"
#include "signature.h"
#include "debug.h"
stamp-h
stamp-h.in
*.la
+*.lcd
*.lo
zlib-*.tar.gz
-unrecogcomments # XXX ignore doxygen markings
+strict # lclint level
--includenest 16 # getting deep, sigh
-
-# --- not yet
--retvalint # painful
-
--protoparammatch # 22
+# --- in progress
+-abstract
+-aliasunique
+-branchstate
+-casebreak
+-castfcnptr
+-commenterror
+-compdef
+-compmempass
+-dependenttrans
+-evalorder
+-globs
+-globstate
+-immediatetrans
+-infloopsuncon
+-internalglobs
+-kepttrans
+-looploopbreak
+-looploopcontinue
+-loopswitchbreak
+-modfilesys
+-modnomods
+-modobserveruncon
+-moduncon
+-modunconnomods
+-mustmod
+-noeffect
-noeffectuncon # 22
-
--sizeoftype # 110
+-nullderef
+-nullpass
+-nullret
-nullstate # 36
+-observertrans
+-oldstyle
+-paramuse
+-protoparammatch # 22
+-readonlytrans
+-redef
+-retalias
+-retvalint # painful
+-sizeoftype # 110
+-statictrans
+-switchswitchbreak
+-temptrans
+-type
+-unqualifiedtrans
+-unsignedcompare
+-usereleased
+-whileempty
# --- +partial artifacts
-declundef
-incondefs # <bits/{ipc,pthreadtypes}.h> heartburn
-matchfields # <bits/ipc.h> heartburn
-namechecks # tedious ANSI compliance checks
--numenummembers 1024 # RPMTAG has 138 members
--numstructfields 256 # Java jni.h has 229 fields
-ptrarith # tedious
-compdestroy
zlib.3 zlib.spec \
amiga/* contrib/* msdos/* nt/* os2/*
-BUILT_SOURCES = Doxyfile
-
# crc32.h
noinst_HEADERS = \
deflate.h infblock.h infcodes.h inffast.h inffixed.h \
minigzip_SOURCES = minigzip.c
minigzip_LDFLAGS = -L. -lz
+BUILT_SOURCES = Doxyfile zlib.lcd
+
+zlib.lcd: Makefile.am ${libz_la_SOURCES} ${noinst_HEADERS}
+ -lclint ${DEFS} ${INCLUDES} ${libz_la_SOURCES} -dump $@ 2>/dev/null
+
.PHONY: sources
sources:
@echo $(libz_la_SOURCES:%=zlib/%)
amiga/* contrib/* msdos/* nt/* os2/*
-BUILT_SOURCES = Doxyfile
-
# crc32.h
noinst_HEADERS = \
deflate.h infblock.h infcodes.h inffast.h inffixed.h \
minigzip_SOURCES = minigzip.c
minigzip_LDFLAGS = -L. -lz
+
+BUILT_SOURCES = Doxyfile zlib.lcd
subdir = .
ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
mkinstalldirs = $(SHELL) $(top_srcdir)/mkinstalldirs
tags uninstall uninstall-am uninstall-info-am
+zlib.lcd: Makefile.am ${libz_la_SOURCES} ${noinst_HEADERS}
+ -lclint ${DEFS} ${INCLUDES} ${libz_la_SOURCES} -dump $@ 2>/dev/null
+
.PHONY: sources
sources:
@echo $(libz_la_SOURCES:%=zlib/%)
* Addison-Wesley, 1983. ISBN 0-201-06672-6.
*/
-/* @(#) $Id$ */
+/* @(#) $Id: trees.c,v 1.8 2002/03/17 15:46:23 jbj Exp $ */
/* #define GEN_TREES_H */
* @param tree the tree to be scanned
* @param max_code and its largest code of non zero frequency
*/
-local void scan_tree (s, tree, max_code)
- deflate_state *s;
- ct_data *tree; /* the tree to be scanned */
- int max_code; /* and its largest code of non zero frequency */
+local void scan_tree (deflate_state *s, ct_data *tree, int max_code)
{
int n; /* iterates over all tree elements */
int prevlen = -1; /* last emitted length */
projects / tools / librpm-tizen.git / commitdiff