Print to private buffer, not stdout.

Kill off ckfputs/ckfprintf.

CVS patchset: 5873
CVS date: 2002/11/18 23:53:05

11 files changed, 277 insertions, 267 deletions

diff --git a/file/.lclintrc b/file/.lclintrc
index 66644f981..cb792083c 100644
--- a/file/.lclintrc
+++ b/file/.lclintrc
@@ -1,4 +1,4 @@
--I. -DHAVE_CONFIG_H -DSTDC -D_GNU_SOURCE -D_FILE_OFFSET_BITS=64 -D_LARGFILE_SOURCE -D__GLIBC__ -D__STDC__=1 -DHAVE_STRUCT_STAT_ST_RDEV
+-I. -DHAVE_CONFIG_H -DSTDC -D_GNU_SOURCE -D_FILE_OFFSET_BITS=64 -D_LARGFILE_SOURCE -D__GLIBC__ -D__STDC__=1 -DHAVE_STRUCT_STAT_ST_RDEV -DSIZEOF_UINT64_T=8
 
 #+partial
 +forcehints
@@ -14,18 +14,18 @@
 +strict			# lclint level
 
 # --- in progress
-+slovak-fcns
-
+-compdef
+-compmempass
 -exportheader		# 19
--formatconst		# 9
--macroredef		# 1 tar.h
+-formatconst		# 1
+-macroredef		# 20 tar.h
+#-noeffect
 -nullderef		# 4
--nullpass		# 27
+-nullpass		# 22
 -nullptrarith		# 1
--redef			# 4
+-redef			# 1 tar.h
 -sizeoftype		# 29
 -uniondef		# 6
--warnmissingglobs
 
 # --- +partial artifacts
 
diff --git a/file/Makefile.am b/file/Makefile.am
index 1c45904c3..77037adee 100644
--- a/file/Makefile.am
+++ b/file/Makefile.am
@@ -1,5 +1,7 @@
 AUTOMAKE_OPTIONS = 1.4 foreign
 
+LINT = splint
+
 EXTRA_DIST = LEGAL.NOTICE MAINT Makefile.std magic2mime magic.mime \
 	Localstuff Header $(magic_FRAGMENTS) file.man magic.man
 
@@ -26,13 +28,16 @@ file_SOURCES =	file.c
 file_LDFLAGS =	-all-static
 file_LDADD =	libfmagic.la
 
-data_DATA = magic magic.mime magic.mgc magic.mime.mgc
-
 man_MAGIC = magic.@fsect@
 #man_MANS = file.1 $(man_MAGIC)
 noinst_MANS = file.1 $(man_MAGIC)
 
-MAGIC	 = @datadir@/magic
+#MAGIC	 = @datadir@/magic
+#data_DATA = magic magic.mime magic.mgc magic.mime.mgc
+
+pkglibdir =  @prefix@/lib/rpm
+pkglib_DATA = magic magic.mime magic.mgc magic.mime.mgc
+MAGIC	 = $(pkglibdir)/magic
 CPPFLAGS = -DMAGIC='"$(MAGIC)"'
 
 fsect = @fsect@
@@ -225,7 +230,7 @@ Magdir/xenix \
 Magdir/zilog \
 Magdir/zyxel
 
-.PHONY: lclint
-lclint:
-	lclint $(DEFS) $(INCLUDES) $(file_SOURCES) $(libfmagic_la_SOURCES) $(pkginc_HEADERS) $(noinst_HEADERS)
+.PHONY: lint
+lint:
+	$(LINT)  $(DEFS) $(INCLUDES) $(file_SOURCES) $(libfmagic_la_SOURCES) $(pkginc_HEADERS) $(noinst_HEADERS)
 
diff --git a/file/ascmagic.c b/file/ascmagic.c
index 0ab448ccf..2ff880620 100644
--- a/file/ascmagic.c
+++ b/file/ascmagic.c
@@ -520,12 +520,12 @@ fmagicA(fmagic fm)
 	 */
 	switch (is_tar(fm)) {
 	case 1:
-		ckfputs(((fm->flags & FMAGIC_FLAGS_MIME)
-			? "application/x-tar" : "tar archive"), fm);
+		fmagicPrintf(fm, ((fm->flags & FMAGIC_FLAGS_MIME)
+			? "application/x-tar" : "tar archive"));
 		return 1;
 	case 2:
-		ckfputs(((fm->flags & FMAGIC_FLAGS_MIME)
-			? "application/x-tar, POSIX" : "POSIX tar archive"), fm);
+		fmagicPrintf(fm, ((fm->flags & FMAGIC_FLAGS_MIME)
+			? "application/x-tar, POSIX" : "POSIX tar archive"));
 		return 1;
 	}
 
@@ -681,26 +681,26 @@ subtype_identified:
 
 	if ((fm->flags & FMAGIC_FLAGS_MIME)) {
 		if (subtype_mime != NULL)
-			ckfputs(subtype_mime, fm);
+			fmagicPrintf(fm, subtype_mime);
 		else
-			ckfputs("text/plain", fm);
+			fmagicPrintf(fm, "text/plain");
 
 		if (code_mime != NULL) {
-			ckfputs("; charset=", fm);
-			ckfputs(code_mime, fm);
+			fmagicPrintf(fm, "; charset=");
+			fmagicPrintf(fm, code_mime);
 		}
 	} else {
-		ckfputs(code, fm);
+		fmagicPrintf(fm, code);
 
 		if (subtype != NULL) {
-			ckfputs(" ", fm);
-			ckfputs(subtype, fm);
+			fmagicPrintf(fm, " ");
+			fmagicPrintf(fm, subtype);
 		}
-		ckfputs(" ", fm);
-		ckfputs(type, fm);
+		fmagicPrintf(fm, " ");
+		fmagicPrintf(fm, type);
 
 		if (has_long_lines)
-			ckfputs(", with very long lines", fm);
+			fmagicPrintf(fm, ", with very long lines");
 
 		/*
 		 * Only report line terminators if we find one other than LF,
@@ -708,37 +708,37 @@ subtype_identified:
 		 */
 		if ((n_crlf == 0 && n_cr == 0 && n_nel == 0 && n_lf == 0) ||
 		    (n_crlf != 0 || n_cr != 0 || n_nel != 0)) {
-			ckfputs(", with", fm);
+			fmagicPrintf(fm, ", with");
 
 			if (n_crlf == 0 && n_cr == 0 && n_nel == 0 && n_lf == 0)
-				ckfputs(" no", fm);
+				fmagicPrintf(fm, " no");
 			else {
 				if (n_crlf) {
-					ckfputs(" CRLF", fm);
+					fmagicPrintf(fm, " CRLF");
 					if (n_cr || n_lf || n_nel)
-						ckfputs(",", fm);
+						fmagicPrintf(fm, ",");
 				}
 				if (n_cr) {
-					ckfputs(" CR", fm);
+					fmagicPrintf(fm, " CR");
 					if (n_lf || n_nel)
-						ckfputs(",", fm);
+						fmagicPrintf(fm, ",");
 				}
 				if (n_lf) {
-					ckfputs(" LF", fm);
+					fmagicPrintf(fm, " LF");
 					if (n_nel)
-						ckfputs(",", fm);
+						fmagicPrintf(fm, ",");
 				}
 				if (n_nel)
-					ckfputs(" NEL", fm);
+					fmagicPrintf(fm, " NEL");
 			}
 
-			ckfputs(" line terminators", fm);
+			fmagicPrintf(fm, " line terminators");
 		}
 
 		if (has_escapes)
-			ckfputs(", with escape sequences", fm);
+			fmagicPrintf(fm, ", with escape sequences");
 		if (has_backspace)
-			ckfputs(", with overstriking", fm);
+			fmagicPrintf(fm, ", with overstriking");
 	}
 
 	return 1;
diff --git a/file/compress.c b/file/compress.c
index 6427ca97f..0535d6040 100644
--- a/file/compress.c
+++ b/file/compress.c
@@ -5,6 +5,8 @@
 
 FILE_RCSID("@(#)Id: compress.c,v 1.25 2002/07/03 18:26:37 christos Exp ")
 
+/*@access fmagic @*/
+
 /*@-nullassign@*/
 /*@unchecked@*/
 static struct {
@@ -316,7 +318,9 @@ fmagicZ(fmagic fm)
 			(void) fmagicF(fm, 1);
 			fm->buf = buf;
 			fm->nb = nb;
+/*@-kepttrans@*/
 			free(newbuf);
+/*@=kepttrans@*/
 			printf(" (");
 			(void) fmagicF(fm, 0);
 			printf(")");
diff --git a/file/file.c b/file/file.c
index 293591794..e0cd9d1b0 100644
--- a/file/file.c
+++ b/file/file.c
@@ -99,8 +99,12 @@ unwrap(fmagic fm, char *fn)
 
 	while (fgets(buf, MAXPATHLEN, f) != NULL) {
 		buf[strlen(buf)-1] = '\0';
+		fm->obp = fm->obuf;
+		*fm->obp = '\0';
+		fm->nob = sizeof(fm->obuf);
 		xx = fmagicProcess(fm, buf, wid);
-		if(nobuffer)
+		fprintf(stdout, "%s\n", fm->obuf);
+		if (nobuffer)
 			(void) fflush(stdout);
 	}
 
@@ -336,8 +340,15 @@ main(int argc, char **argv)
 			if (nw > wid)
 				wid = nw;
 		}
-		for (; optind < argc; optind++)
+		for (; optind < argc; optind++) {
+			fm->obp = fm->obuf;
+			*fm->obp = '\0';
+			fm->nob = sizeof(fm->obuf);
 			xx = fmagicProcess(fm, argv[optind], wid);
+			fprintf(stdout, "%s\n", fm->obuf);
+			if (nobuffer)
+				(void) fflush(stdout);
+		}
 	}
 
 #if HAVE_MCHECK_H && HAVE_MTRACE
diff --git a/file/file.h b/file/file.h
index fba8e4d77..c58f0035b 100644
--- a/file/file.h
+++ b/file/file.h
@@ -140,13 +140,20 @@ struct fmagic_s {
     struct mlist * mlist;	/*!< list of arrays of magic entries	*/
 /*@null@*/
     struct mlist * ml;		/*!< current magic array item		*/
+/*@observer@*/
     const char * fn;		/*!< current file name			*/
-    int fd;			/*!< current file descriptor		*/
+    int fd;			/*!< current file descriptor            */
     struct stat sb;		/*!< current file stat(2) buffer	*/
+/*@relnull@*/
     unsigned char * buf;	/*!< current file buffer		*/
     int nb;			/*!< current no. bytes in file buffer	*/
     union VALUETYPE val;	/*!< current magic expression value	*/
-    FILE * f;			/*!< output file handle			*/
+    int cls;			/*!< Elf class				*/
+    int swap;			/*!< Elf swap bytes?			*/
+/*@dependent@*/
+    char * obp;			/*!< current output buffer pointer	*/
+    size_t nob;			/*!< bytes remaining in output buffer	*/
+    char obuf[512];		/*!< output buffer			*/
 };
 
 typedef /*@abstract@*/ struct fmagic_s * fmagic;
@@ -160,33 +167,30 @@ extern int fmagicProcess(fmagic fm, const char *fn, int wid)
 	/*@modifies fm, fileSystem, internalState @*/;
 
 extern int fmagicA(fmagic fm)
-	/*@globals fileSystem @*/
-	/*@modifies fileSystem @*/;
-struct stat;
+	/*@modifies fm @*/;
 extern int fmagicD(fmagic fm)
 	/*@globals fileSystem, internalState @*/
 	/*@modifies fm, fileSystem, internalState @*/;
-extern int fmagicS(fmagic fm)
-	/*@globals fileSystem @*/
-	/*@modifies fm, fileSystem @*/;
+extern void fmagicE(fmagic fm)
+	/*@globals fileSystem, internalState @*/
+	/*@modifies fm, fileSystem, internalState @*/;
 extern int fmagicF(fmagic fm, int zfl)
 	/*@globals fileSystem, internalState @*/
 	/*@modifies fm, fileSystem, internalState @*/;
+extern int fmagicS(fmagic fm)
+	/*@globals fileSystem @*/
+	/*@modifies fm, fileSystem @*/;
 extern int fmagicZ(fmagic fm)
 	/*@globals fileSystem, internalState @*/
 	/*@modifies fm, fileSystem, internalState @*/;
 
+extern void fmagicPrintf(const fmagic fm, const char *f, ...)
+	/*@modifies fm @*/;
+
 /*@observer@*/
 extern char *fmttime(long v, int local)
 	/*@*/;
 
-extern void ckfputs(const char *str, fmagic fm)
-	/*@globals fileSystem @*/
-	/*@modifies fm, fileSystem @*/;
-extern void ckfprintf(fmagic fm, const char *fmt, ...)
-	/*@globals fileSystem @*/
-	/*@modifies fm, fileSystem @*/;
-
 extern void magwarn(const char *f, ...)
 	/*@globals fileSystem @*/
 	/*@modifies fileSystem @*/;
@@ -200,9 +204,6 @@ extern void showstr(FILE *fp, const char *s, int len)
 extern uint32_t signextend(struct magic *m, uint32_t v)
 	/*@globals fileSystem @*/
 	/*@modifies fileSystem @*/;
-extern void tryelf(int fd, unsigned char *buf, int nbytes)
-	/*@globals fileSystem, internalState @*/
-	/*@modifies fileSystem, internalState @*/;
 extern int pipe2file(int fd, void *startbuf, size_t nbytes)
 	/*@globals errno, fileSystem, internalState @*/
 	/*@modifies errno, fileSystem, internalState @*/;
diff --git a/file/fsmagic.c b/file/fsmagic.c
index 2d6a3ff7e..bf466107d 100644
--- a/file/fsmagic.c
+++ b/file/fsmagic.c
@@ -55,31 +55,31 @@ fmagicD(fmagic fm)
 	if (ret) {
 		/* Yes, I do mean stdout. */
 		/* No \n, caller will provide. */
-		ckfprintf(fm, "can't stat `%s' (%s).", fn, strerror(errno));
+		fmagicPrintf(fm, "can't stat `%s' (%s).", fn, strerror(errno));
 		return 1;
 	}
 
 	if ((fm->flags & FMAGIC_FLAGS_MIME)) {
 		if ((st->st_mode & S_IFMT) != S_IFREG) {
-			ckfputs("application/x-not-regular-file", fm);
+			fmagicPrintf(fm, "application/x-not-regular-file");
 			return 1;
 		}
 	}
 	else {
 #if defined(S_ISUID) || defined(__LCLINT__)
-		if (st->st_mode & S_ISUID) ckfputs("setuid ", fm);
+		if (st->st_mode & S_ISUID) fmagicPrintf(fm, "setuid ");
 #endif
 #if defined(S_ISGID) || defined(__LCLINT__)
-		if (st->st_mode & S_ISGID) ckfputs("setgid ", fm);
+		if (st->st_mode & S_ISGID) fmagicPrintf(fm, "setgid ");
 #endif
 #if defined(S_ISVTX) || defined(__LCLINT__)
-		if (st->st_mode & S_ISVTX) ckfputs("sticky ", fm);
+		if (st->st_mode & S_ISVTX) fmagicPrintf(fm, "sticky ");
 #endif
 	}
 	
 	switch (st->st_mode & S_IFMT) {
 	case S_IFDIR:
-		ckfputs("directory", fm);
+		fmagicPrintf(fm, "directory");
 		return 1;
 #if defined(S_IFCHR) || defined(__LCLINT__)
 	case S_IFCHR:
@@ -92,16 +92,16 @@ fmagicD(fmagic fm)
 			break;
 #ifdef HAVE_STRUCT_STAT_ST_RDEV
 # ifdef dv_unit
-		(void) printf("character special (%d/%d/%d)",
+		fmagicPrintf(fm, "character special (%d/%d/%d)",
 			major(st->st_rdev),
 			dv_unit(st->st_rdev),
 			dv_subunit(st->st_rdev));
 # else
-		(void) printf("character special (%ld/%ld)",
+		fmagicPrintf(fm, "character special (%ld/%ld)",
 			(long) major(st->st_rdev), (long) minor(st->st_rdev));
 # endif
 #else
-		(void) printf("character special");
+		fmagicPrintf(fm, "character special");
 #endif
 		return 1;
 #endif
@@ -116,28 +116,28 @@ fmagicD(fmagic fm)
 			break;
 #ifdef HAVE_STRUCT_STAT_ST_RDEV
 # ifdef dv_unit
-		(void) printf("block special (%d/%d/%d)",
+		fmagicPrintf(fm, "block special (%d/%d/%d)",
 			major(st->st_rdev),
 			dv_unit(st->st_rdev),
 			dv_subunit(st->st_rdev));
 # else
-		(void) printf("block special (%ld/%ld)",
+		fmagicPrintf(fm, "block special (%ld/%ld)",
 			(long) major(st->st_rdev), (long) minor(st->st_rdev));
 # endif
 #else
-		(void) printf("block special");
+		fmagicPrintf(fm, "block special");
 #endif
 		return 1;
 #endif
 	/* TODO add code to handle V7 MUX and Blit MUX files */
 #if defined(S_IFIFO) || defined(__LCLINT__)
 	case S_IFIFO:
-		ckfputs("fifo (named pipe)", fm);
+		fmagicPrintf(fm, "fifo (named pipe)");
 		return 1;
 #endif
 #if defined(S_IFDOOR)
 	case S_IFDOOR:
-		ckfputs("door", fm);
+		fmagicPrintf(fm, "door");
 		return 1;
 #endif
 #if defined(S_IFLNK) || defined(__LCLINT__)
@@ -149,7 +149,7 @@ fmagicD(fmagic fm)
 
 			buf[0] = '\0';
 			if ((nch = readlink(fn, buf, BUFSIZ-1)) <= 0) {
-				ckfprintf(fm, "unreadable symlink (%s).", strerror(errno));
+				fmagicPrintf(fm, "unreadable symlink (%s).", strerror(errno));
 				return 1;
 			}
 			buf[nch] = '\0';	/* readlink(2) forgets this */
@@ -158,7 +158,7 @@ fmagicD(fmagic fm)
 /*@-branchstate@*/
 			if (*buf == '/') {
 			    if (stat(buf, &tstatbuf) < 0) {
-				ckfprintf(fm, "broken symbolic link to %s", buf);
+				fmagicPrintf(fm, "broken symbolic link to %s", buf);
 				return 1;
 			    }
 			}
@@ -176,7 +176,7 @@ fmagicD(fmagic fm)
 				tmp = buf2;
 			    }
 			    if (stat(tmp, &tstatbuf) < 0) {
-				ckfprintf(fm, "broken symbolic link to %s", buf);
+				fmagicPrintf(fm, "broken symbolic link to %s", buf);
 				return 1;
 			    }
                         }
@@ -184,11 +184,11 @@ fmagicD(fmagic fm)
 
 			/* Otherwise, handle it. */
 			if ((fm->flags & FMAGIC_FLAGS_FOLLOW)) {
+				fmagicPrintf(fm, "\n");
 				xx = fmagicProcess(fm, buf, strlen(buf));
 				return 1;
 			} else { /* just print what it points to */
-				ckfputs("symbolic link to ", fm);
-				ckfputs(buf, fm);
+				fmagicPrintf(fm, "symbolic link to %s", buf);
 			}
 		}
 		return 1;
@@ -196,7 +196,7 @@ fmagicD(fmagic fm)
 #if defined(S_IFSOCK)
 #ifndef __COHERENT__
 	case S_IFSOCK:
-		ckfputs("socket", fm);
+		fmagicPrintf(fm, "socket");
 		return 1;
 #endif
 #endif
@@ -220,8 +220,8 @@ fmagicD(fmagic fm)
 	 * when we read the file.)
 	 */
 	if (!(fm->flags & FMAGIC_FLAGS_SPECIAL) && st->st_size == 0) {
-		ckfputs(((fm->flags & FMAGIC_FLAGS_MIME)
-			? "application/x-empty" : "empty"), fm);
+		fmagicPrintf(fm, ((fm->flags & FMAGIC_FLAGS_MIME)
+			? "application/x-empty" : "empty"));
 		return 1;
 	}
 	return 0;
@@ -256,8 +256,8 @@ fmagicF(fmagic fm, int zfl)
 		return 'a';
 
 	/* abandon hope, all ye who remain here */
-	ckfputs(((fm->flags & FMAGIC_FLAGS_MIME)
-		? "application/octet-stream" : "data"), fm);
+	fmagicPrintf(fm, ((fm->flags & FMAGIC_FLAGS_MIME)
+		? "application/octet-stream" : "data"));
 	return '\0';
 }
 
@@ -267,16 +267,18 @@ fmagicF(fmagic fm, int zfl)
 int
 fmagicProcess(fmagic fm, const char *fn, int wid)
 {
-	int	fd = 0;
 	static  const char stdname[] = "standard input";
 	unsigned char	b[HOWMANY+1];	/* one extra for terminating '\0' */
 	char match = '\0';
 	int ret = 0;
 
+/*@-assignexpose -temptrans @*/
 	fm->fn = fn;
+/*@=assignexpose =temptrans @*/
 	fm->buf = b;
 	fm->nb = 0;
 
+/*@-branchstate@*/
 	if (strcmp("-", fn) == 0) {
 		if (fstat(0, &fm->sb)<0) {
 			error(EXIT_FAILURE, 0, "cannot fstat `%s' (%s).\n", stdname,
@@ -285,9 +287,10 @@ fmagicProcess(fmagic fm, const char *fn, int wid)
 		}
 		fm->fn = stdname;
 	}
+/*@=branchstate@*/
 
 	if (wid > 0 && !(fm->flags & FMAGIC_FLAGS_BRIEF))
-	     (void) printf("%s:%*s ", fm->fn, 
+	     fmagicPrintf(fm, "%s:%*s ", fm->fn, 
 			   (int) (wid - strlen(fm->fn)), "");
 
 	if (fm->fn != stdname) {
@@ -297,13 +300,13 @@ fmagicProcess(fmagic fm, const char *fn, int wid)
 		if (fmagicD(fm) != 0)
 			goto exit;
 
-		if ((fd = open(fm->fn, O_RDONLY)) < 0) {
+		if ((fm->fd = open(fm->fn, O_RDONLY)) < 0) {
 			/* We can't open it, but we were able to stat it. */
 			if (fm->sb.st_mode & 0002)
-				ckfputs("writeable, ", fm);
+				fmagicPrintf(fm, "writeable, ");
 			if (fm->sb.st_mode & 0111)
-				ckfputs("executable, ", fm);
-			ckfprintf(fm, "can't read `%s' (%s).", fm->fn, strerror(errno));
+				fmagicPrintf(fm, "executable, ");
+			fmagicPrintf(fm, "can't read `%s' (%s).", fm->fn, strerror(errno));
 			goto exit;
 		}
 	}
@@ -312,13 +315,13 @@ fmagicProcess(fmagic fm, const char *fn, int wid)
 	/*
 	 * try looking at the first HOWMANY bytes
 	 */
-	if ((fm->nb = read(fd, (char *)fm->buf, HOWMANY)) == -1) {
+	if ((fm->nb = read(fm->fd, (char *)fm->buf, HOWMANY)) == -1) {
 		error(EXIT_FAILURE, 0, "read failed (%s).\n", strerror(errno));
 		/*@notreached@*/
 	}
 
 	if (fm->nb == 0)
-		ckfputs(((fm->flags & FMAGIC_FLAGS_MIME)
+		fmagicPrintf(fm, ((fm->flags & FMAGIC_FLAGS_MIME)
 			? "application/x-empty" : "empty"), fm);
 	else {
 		fm->buf[fm->nb++] = '\0';	/* null-terminate it */
@@ -335,7 +338,7 @@ fmagicProcess(fmagic fm, const char *fn, int wid)
 		 * from the ELF headers that can't easily be extracted
 		 * with rules in the magic file.
 		 */
-		tryelf(fd, fm->buf, fm->nb);
+		fmagicE(fm);
 	}
 #endif
 
@@ -361,11 +364,11 @@ fmagicProcess(fmagic fm, const char *fn, int wid)
 		(void) utime(fm->fn, &utbuf); /* don't care if loses */
 # endif
 #endif
-		(void) close(fd);
+		(void) close(fm->fd);
+		fm->fd = -1;
 	}
 
 exit:
-	ckfputs("\n", fm);
 	fm->buf = NULL;
 	fm->nb = 0;
 	return ret;
diff --git a/file/print.c b/file/print.c
index 08476a23b..3af7fcc43 100644
--- a/file/print.c
+++ b/file/print.c
@@ -129,33 +129,6 @@ mdump(struct magic *m)
 }
 #endif
 
-/*
- * ckfputs - fputs, but with error checking
- * ckfprintf - fprintf, but with error checking
- */
-void
-ckfputs(const char *str, fmagic fm)
-{
-	FILE *f = (fm->f ? fm->f : stdout);
-	if (fputs(str, f) == EOF)
-		error(EXIT_FAILURE, 0, "ckfputs write failed.\n");
-}
-
-/*VARARGS*/
-void
-ckfprintf(fmagic fm, const char *fmt, ...)
-{
-	FILE *f = (fm->f ? fm->f : stdout);
-
-	va_list va;
-
-	va_start(va, fmt);
-	(void) vfprintf(f, fmt, va);
-	if (ferror(f))
-		error(EXIT_FAILURE, 0, "ckfprintf write failed.\n");
-	va_end(va);
-}
-
 #if !defined(HAVE_ERROR)
 /*
  * error - print best error message possible and exit
@@ -200,6 +173,23 @@ magwarn(const char *f, ...)
 	(void) fputc('\n', stderr);
 }
 
+void
+fmagicPrintf(const fmagic fm, const char *f, ...)
+{
+	va_list va;
+	size_t nob;
+	int rc;
+
+	va_start(va, f);
+	rc = vsnprintf(fm->obp, fm->nob, f, va);
+	va_end(va);
+
+	fm->obuf[sizeof(fm->obuf)-1] = '\0';
+	nob = strlen(fm->obp);
+	fm->obp += nob;
+	fm->nob -= nob;
+}
+
 
 #ifndef COMPILE_ONLY
 char *
diff --git a/file/readelf.c b/file/readelf.c
index 36c7d4814..db093463f 100644
--- a/file/readelf.c
+++ b/file/readelf.c
@@ -7,8 +7,10 @@
 
 FILE_RCSID("@(#)Id: readelf.c,v 1.22 2002/07/03 18:26:38 christos Exp ")
 
+/*@access fmagic @*/
+
 static uint16_t
-getu16(int swap, uint16_t value)
+getu16(const fmagic fm, uint16_t value)
 	/*@*/
 {
 	union {
@@ -16,7 +18,7 @@ getu16(int swap, uint16_t value)
 		char c[2];
 	} retval, tmpval;
 
-	if (swap) {
+	if (fm->swap) {
 		tmpval.ui = value;
 
 		retval.c[0] = tmpval.c[1];
@@ -28,7 +30,7 @@ getu16(int swap, uint16_t value)
 }
 
 static uint32_t
-getu32(int swap, uint32_t value)
+getu32(const fmagic fm, uint32_t value)
 	/*@*/
 {
 	union {
@@ -36,7 +38,7 @@ getu32(int swap, uint32_t value)
 		char c[4];
 	} retval, tmpval;
 
-	if (swap) {
+	if (fm->swap) {
 		tmpval.ui = value;
 
 		retval.c[0] = tmpval.c[3];
@@ -50,7 +52,7 @@ getu32(int swap, uint32_t value)
 }
 
 static uint64_t
-getu64(int swap, uint64_t value)
+getu64(const fmagic fm, uint64_t value)
 	/*@*/
 {
 	union {
@@ -58,7 +60,7 @@ getu64(int swap, uint64_t value)
 		char c[8];
 	} retval, tmpval;
 
-	if (swap) {
+	if (fm->swap) {
 		tmpval.ui = value;
 
 		retval.c[0] = tmpval.c[7];
@@ -75,61 +77,60 @@ getu64(int swap, uint64_t value)
 		return value;
 }
 
-#define sh_addr		(cls == ELFCLASS32		\
+#define sh_addr		(fm->cls == ELFCLASS32		\
 			 ? (void *) &sh32		\
 			 : (void *) &sh64)
-#define shs_type	(cls == ELFCLASS32		\
-			 ? getu32(swap, sh32.sh_type)	\
-			 : getu32(swap, sh64.sh_type))
-#define ph_addr		(cls == ELFCLASS32		\
+#define shs_type	(fm->cls == ELFCLASS32		\
+			 ? getu32(fm, sh32.sh_type)	\
+			 : getu32(fm, sh64.sh_type))
+#define ph_addr		(fm->cls == ELFCLASS32		\
 			 ? (void *) &ph32		\
 			 : (void *) &ph64)
-#define ph_type		(cls == ELFCLASS32		\
-			 ? getu32(swap, ph32.p_type)	\
-			 : getu32(swap, ph64.p_type))
-#define ph_offset	(cls == ELFCLASS32		\
-			 ? getu32(swap, ph32.p_offset)	\
-			 : getu64(swap, ph64.p_offset))
-#define nh_size		(cls == ELFCLASS32		\
+#define ph_type		(fm->cls == ELFCLASS32		\
+			 ? getu32(fm, ph32.p_type)	\
+			 : getu32(fm, ph64.p_type))
+#define ph_offset	(fm->cls == ELFCLASS32		\
+			 ? getu32(fm, ph32.p_offset)	\
+			 : getu64(fm, ph64.p_offset))
+#define nh_size		(fm->cls == ELFCLASS32		\
 			 ? sizeof *nh32			\
 			 : sizeof *nh64)
-#define nh_type		(cls == ELFCLASS32		\
-			 ? getu32(swap, nh32->n_type)	\
-			 : getu32(swap, nh64->n_type))
-#define nh_namesz	(cls == ELFCLASS32		\
-			 ? getu32(swap, nh32->n_namesz)	\
-			 : getu32(swap, nh64->n_namesz))
-#define nh_descsz	(cls == ELFCLASS32		\
-			 ? getu32(swap, nh32->n_descsz)	\
-			 : getu32(swap, nh64->n_descsz))
-#define prpsoffsets(i)	(cls == ELFCLASS32		\
+#define nh_type		(fm->cls == ELFCLASS32		\
+			 ? getu32(fm, nh32->n_type)	\
+			 : getu32(fm, nh64->n_type))
+#define nh_namesz	(fm->cls == ELFCLASS32		\
+			 ? getu32(fm, nh32->n_namesz)	\
+			 : getu32(fm, nh64->n_namesz))
+#define nh_descsz	(fm->cls == ELFCLASS32		\
+			 ? getu32(fm, nh32->n_descsz)	\
+			 : getu32(fm, nh64->n_descsz))
+#define prpsoffsets(i)	(fm->cls == ELFCLASS32		\
 			 ? prpsoffsets32[i]		\
 			 : prpsoffsets64[i])
 
 static void
-doshn(int cls, int swap, int fd, off_t off, int num, size_t size)
-	/*@globals fileSystem @*/
-	/*@modifies fileSystem @*/
+doshn(fmagic fm, off_t off, int num, size_t size)
+	/*@modifies fm @*/
 {
 	Elf32_Shdr sh32;
 	Elf64_Shdr sh64;
 
-	if (lseek(fd, off, SEEK_SET) == -1) {
+	if (lseek(fm->fd, off, SEEK_SET) == -1) {
 		error(EXIT_FAILURE, 0, "lseek failed (%s).\n", strerror(errno));
 		/*@notreached@*/
 	}
 
 	for ( ; num; num--) {
-		if (read(fd, sh_addr, size) == -1) {
+		if (read(fm->fd, sh_addr, size) == -1) {
 			error(EXIT_FAILURE, 0, "read failed (%s).\n", strerror(errno));
 			/*@notreached@*/
 		}
 		if (shs_type == SHT_SYMTAB /* || shs_type == SHT_DYNSYM */) {
-			(void) printf (", not stripped");
+			fmagicPrintf(fm, ", not stripped");
 			return;
 		}
 	}
-	(void) printf (", stripped");
+	fmagicPrintf(fm, ", stripped");
 }
 
 /*
@@ -138,9 +139,8 @@ doshn(int cls, int swap, int fd, off_t off, int num, size_t size)
  * otherwise it's statically linked.
  */
 static void
-dophn_exec(int cls, int swap, int fd, off_t off, int num, size_t size)
-	/*@globals fileSystem @*/
-	/*@modifies fileSystem @*/
+dophn_exec(fmagic fm, off_t off, int num, size_t size)
+	/*@modifies fm @*/
 {
 	Elf32_Phdr ph32;
 	Elf32_Nhdr *nh32 = NULL;
@@ -152,13 +152,13 @@ dophn_exec(int cls, int swap, int fd, off_t off, int num, size_t size)
 	int bufsize;
 	size_t offset, nameoffset;
 
-	if (lseek(fd, off, SEEK_SET) == -1) {
+	if (lseek(fm->fd, off, SEEK_SET) == -1) {
 		error(EXIT_FAILURE, 0, "lseek failed (%s).\n", strerror(errno));
 		/*@notreached@*/
 	}
 
   	for ( ; num; num--) {
-  		if (read(fd, ph_addr, size) == -1) {
+  		if (read(fm->fd, ph_addr, size) == -1) {
   			error(EXIT_FAILURE, 0, "read failed (%s).\n", strerror(errno));
 			/*@notreached@*/
 		}
@@ -175,11 +175,11 @@ dophn_exec(int cls, int swap, int fd, off_t off, int num, size_t size)
 			 * This is a PT_NOTE section; loop through all the notes
 			 * in the section.
 			 */
-			if (lseek(fd, (off_t) ph_offset, SEEK_SET) == -1) {
+			if (lseek(fm->fd, (off_t) ph_offset, SEEK_SET) == -1) {
 				error(EXIT_FAILURE, 0, "lseek failed (%s).\n", strerror(errno));
 				/*@notreached@*/
 			}
-			bufsize = read(fd, nbuf, BUFSIZ);
+			bufsize = read(fm->fd, nbuf, BUFSIZ);
 			if (bufsize == -1) {
 				error(EXIT_FAILURE, 0, ": " "read failed (%s).\n",
 				    strerror(errno));
@@ -189,7 +189,7 @@ dophn_exec(int cls, int swap, int fd, off_t off, int num, size_t size)
 			for (;;) {
 				if (offset >= bufsize)
 					/*@innerbreak@*/ break;
-				if (cls == ELFCLASS32)
+				if (fm->cls == ELFCLASS32)
 					nh32 = (Elf32_Nhdr *)&nbuf[offset];
 				else
 					nh64 = (Elf64_Nhdr *)&nbuf[offset];
@@ -216,32 +216,32 @@ dophn_exec(int cls, int swap, int fd, off_t off, int num, size_t size)
 					uint32_t *desc =
 					    (uint32_t *)&nbuf[offset];
 
-					printf(", for GNU/");
-					switch (getu32(swap, desc[0])) {
+					fmagicPrintf(fm, ", for GNU/");
+					switch (getu32(fm, desc[0])) {
 					case GNU_OS_LINUX:
-						printf("Linux");
+						fmagicPrintf(fm, "Linux");
 						/*@switchbreak@*/ break;
 					case GNU_OS_HURD:
-						printf("Hurd");
+						fmagicPrintf(fm, "Hurd");
 						/*@switchbreak@*/ break;
 					case GNU_OS_SOLARIS:
-						printf("Solaris");
+						fmagicPrintf(fm, "Solaris");
 						/*@switchbreak@*/ break;
 					default:
-						printf("<unknown>");
+						fmagicPrintf(fm, "<unknown>");
 						/*@switchbreak@*/ break;
 					}
-					printf(" %d.%d.%d",
-					    getu32(swap, desc[1]),
-					    getu32(swap, desc[2]),
-					    getu32(swap, desc[3]));
+					fmagicPrintf(fm, " %d.%d.%d",
+					    getu32(fm, desc[1]),
+					    getu32(fm, desc[2]),
+					    getu32(fm, desc[3]));
 				}
 
 				if (nh_namesz == 7 &&
 				    strcmp(&nbuf[nameoffset], "NetBSD") == 0 &&
 				    nh_type == NT_NETBSD_VERSION &&
 				    nh_descsz == 4) {
-					printf(", for NetBSD");
+					fmagicPrintf(fm, ", for NetBSD");
 					/*
 					 * Version number is stuck at 199905,
 					 * and hence is basically content-free.
@@ -252,9 +252,9 @@ dophn_exec(int cls, int swap, int fd, off_t off, int num, size_t size)
 				    strcmp(&nbuf[nameoffset], "FreeBSD") == 0 &&
 				    nh_type == NT_FREEBSD_VERSION &&
 				    nh_descsz == 4) {
-					uint32_t desc = getu32(swap,
+					uint32_t desc = getu32(fm,
 					    *(uint32_t *)&nbuf[offset]);
-					printf(", for FreeBSD");
+					fmagicPrintf(fm, ", for FreeBSD");
 					/*
 					 * Contents is __FreeBSD_version,
 					 * whose relation to OS versions is
@@ -265,10 +265,10 @@ dophn_exec(int cls, int swap, int fd, off_t off, int num, size_t size)
 					 * FreeBSD that use this note.
 					 */
 
-					printf(" %d.%d", desc / 100000,
+					fmagicPrintf(fm, " %d.%d", desc / 100000,
 					    desc / 10000 % 10);
 					if (desc / 1000 % 10 > 0)
-						printf(".%d",
+						fmagicPrintf(fm, ".%d",
 						    desc / 1000 % 10);
 				}
 
@@ -276,14 +276,14 @@ dophn_exec(int cls, int swap, int fd, off_t off, int num, size_t size)
 				    strcmp(&nbuf[nameoffset], "OpenBSD") == 0 &&
 				    nh_type == NT_OPENBSD_VERSION &&
 				    nh_descsz == 4) {
-					printf(", for OpenBSD");
+					fmagicPrintf(fm, ", for OpenBSD");
 					/* Content of note is always 0 */
 				}
 			}
 			/*@switchbreak@*/ break;
 		}
 	}
-	printf(", %s linked%s", linking_style, shared_libraries);
+	fmagicPrintf(fm, ", %s linked%s", linking_style, shared_libraries);
 }
 
 #ifdef ELFCORE
@@ -303,7 +303,7 @@ static size_t	prpsoffsets64[] = {
 #define	NOFFSETS32	(sizeof prpsoffsets32 / sizeof prpsoffsets32[0])
 #define NOFFSETS64	(sizeof prpsoffsets64 / sizeof prpsoffsets64[0])
 
-#define NOFFSETS	(cls == ELFCLASS32 ? NOFFSETS32 : NOFFSETS64)
+#define NOFFSETS	(fm->cls == ELFCLASS32 ? NOFFSETS32 : NOFFSETS64)
 
 /*
  * Look through the program headers of an executable image, searching
@@ -338,9 +338,8 @@ static const char *os_style_names[] = {
 };
 
 static void
-dophn_core(int cls, int swap, int fd, off_t off, int num, size_t size)
-	/*@globals fileSystem @*/
-	/*@modifies fileSystem @*/
+dophn_core(fmagic fm, off_t off, int num, size_t size)
+	/*@modifies fm @*/
 {
 	Elf32_Phdr ph32;
 	Elf32_Nhdr *nh32 = NULL;
@@ -357,11 +356,11 @@ dophn_core(int cls, int swap, int fd, off_t off, int num, size_t size)
 	 * Loop through all the program headers.
 	 */
 	for ( ; num; num--) {
-		if (lseek(fd, off, SEEK_SET) == -1) {
+		if (lseek(fm->fd, off, SEEK_SET) == -1) {
 			error(EXIT_FAILURE, 0, "lseek failed (%s).\n", strerror(errno));
 			/*@notreached@*/
 		}
-		if (read(fd, ph_addr, size) == -1) {
+		if (read(fm->fd, ph_addr, size) == -1) {
 			error(EXIT_FAILURE, 0, "read failed (%s).\n", strerror(errno));
 			/*@notreached@*/
 		}
@@ -373,11 +372,11 @@ dophn_core(int cls, int swap, int fd, off_t off, int num, size_t size)
 		 * This is a PT_NOTE section; loop through all the notes
 		 * in the section.
 		 */
-		if (lseek(fd, (off_t) ph_offset, SEEK_SET) == -1) {
+		if (lseek(fm->fd, (off_t) ph_offset, SEEK_SET) == -1) {
 			error(EXIT_FAILURE, 0, "lseek failed (%s).\n", strerror(errno));
 			/*@notreached@*/
 		}
-		bufsize = read(fd, nbuf, BUFSIZ);
+		bufsize = read(fm->fd, nbuf, BUFSIZ);
 		if (bufsize == -1) {
 			error(EXIT_FAILURE, 0, ": " "read failed (%s).\n", strerror(errno));
 			/*@notreached@*/
@@ -386,7 +385,7 @@ dophn_core(int cls, int swap, int fd, off_t off, int num, size_t size)
 		for (;;) {
 			if (offset >= bufsize)
 				/*@innerbreak@*/ break;
-			if (cls == ELFCLASS32)
+			if (fm->cls == ELFCLASS32)
 				nh32 = (Elf32_Nhdr *)&nbuf[offset];
 			else
 				nh64 = (Elf64_Nhdr *)&nbuf[offset];
@@ -441,7 +440,7 @@ dophn_core(int cls, int swap, int fd, off_t off, int num, size_t size)
 					os_style = OS_STYLE_NETBSD;
 				} else
 					/*@innercontinue@*/ continue;
-				printf(", %s-style", os_style_names[os_style]);
+				fmagicPrintf(fm, ", %s-style", os_style_names[os_style]);
 			}
 
 			if (os_style == OS_STYLE_NETBSD &&
@@ -453,7 +452,7 @@ dophn_core(int cls, int swap, int fd, off_t off, int num, size_t size)
 				 * offset 0x7c, and is up to 32-bytes,
 				 * including the terminating NUL.
 				 */
-				printf(", from '%.31s'", &nbuf[offset + 0x7c]);
+				fmagicPrintf(fm, ", from '%.31s'", &nbuf[offset + 0x7c]);
 				
 				/*
 				 * Extract the signal number.  It is at
@@ -461,7 +460,7 @@ dophn_core(int cls, int swap, int fd, off_t off, int num, size_t size)
 				 */
 				memcpy(&signo, &nbuf[offset + 0x08],
 				    sizeof(signo));
-				printf(" (signal %u)", getu32(swap, signo));
+				fmagicPrintf(fm, " (signal %u)", getu32(fm, signo));
 			} else
 			if (os_style != OS_STYLE_NETBSD &&
 			    nh_type == NT_PRPSINFO) {
@@ -526,7 +525,7 @@ dophn_core(int cls, int swap, int fd, off_t off, int num, size_t size)
 					/*
 					 * Well, that worked.
 					 */
-					printf(", from '%.16s'",
+					fmagicPrintf(fm, ", from '%.16s'",
 					    &nbuf[offset + prpsoffsets(i)]);
 					/*@innerbreak@*/ break;
 
@@ -543,20 +542,18 @@ dophn_core(int cls, int swap, int fd, off_t off, int num, size_t size)
 #endif
 
 void
-tryelf(int fd, unsigned char *buf, int nbytes)
+fmagicE(fmagic fm)
 {
 	union {
 		int32_t l;
 		char c[sizeof (int32_t)];
 	} u;
-	int cls;
-	int swap;
 
 	/*
 	 * If we can't seek, it must be a pipe, socket or fifo.
 	 */
-	if((lseek(fd, (off_t)0, SEEK_SET) == (off_t)-1) && (errno == ESPIPE))
-		fd = pipe2file(fd, buf, nbytes);
+	if((lseek(fm->fd, (off_t)0, SEEK_SET) == (off_t)-1) && (errno == ESPIPE))
+		fm->fd = pipe2file(fm->fd, fm->buf, fm->nb);
 
 	/*
 	 * ELF executables have multiple section headers in arbitrary
@@ -564,97 +561,91 @@ tryelf(int fd, unsigned char *buf, int nbytes)
 	 * Instead we traverse thru all section headers until a symbol table
 	 * one is found or else the binary is stripped.
 	 */
-	if (buf[EI_MAG0] != ELFMAG0
-	    || (buf[EI_MAG1] != ELFMAG1 && buf[EI_MAG1] != OLFMAG1)
-	    || buf[EI_MAG2] != ELFMAG2 || buf[EI_MAG3] != ELFMAG3)
+	if (fm->buf[EI_MAG0] != ELFMAG0
+	    || (fm->buf[EI_MAG1] != ELFMAG1 && fm->buf[EI_MAG1] != OLFMAG1)
+	    || fm->buf[EI_MAG2] != ELFMAG2 || fm->buf[EI_MAG3] != ELFMAG3)
 	    return;
 
 
-	cls = buf[EI_CLASS];
+	fm->cls = fm->buf[EI_CLASS];
 
-	if (cls == ELFCLASS32) {
+	if (fm->cls == ELFCLASS32) {
 		Elf32_Ehdr elfhdr;
-		if (nbytes <= sizeof (Elf32_Ehdr))
+		if (fm->nb <= sizeof (Elf32_Ehdr))
 			return;
 
 
 		u.l = 1;
-		(void) memcpy(&elfhdr, buf, sizeof elfhdr);
-		swap = (u.c[sizeof(int32_t) - 1] + 1) != elfhdr.e_ident[EI_DATA];
+		(void) memcpy(&elfhdr, fm->buf, sizeof elfhdr);
+		fm->swap = (u.c[sizeof(int32_t) - 1] + 1) != elfhdr.e_ident[EI_DATA];
 
-		if (getu16(swap, elfhdr.e_type) == ET_CORE) 
+		if (getu16(fm, elfhdr.e_type) == ET_CORE) 
 #ifdef ELFCORE
-			dophn_core(cls, swap,
-				   fd,
-				   getu32(swap, elfhdr.e_phoff),
-				   getu16(swap, elfhdr.e_phnum), 
-				   getu16(swap, elfhdr.e_phentsize));
+			dophn_core(fm,
+				   getu32(fm, elfhdr.e_phoff),
+				   getu16(fm, elfhdr.e_phnum), 
+				   getu16(fm, elfhdr.e_phentsize));
 #else
 			;
 #endif
 		else {
-			if (getu16(swap, elfhdr.e_type) == ET_EXEC) {
-				dophn_exec(cls, swap,
-					   fd,
-					   getu32(swap, elfhdr.e_phoff),
-					   getu16(swap, elfhdr.e_phnum), 
-					   getu16(swap, elfhdr.e_phentsize));
+			if (getu16(fm, elfhdr.e_type) == ET_EXEC) {
+				dophn_exec(fm,
+					   getu32(fm, elfhdr.e_phoff),
+					   getu16(fm, elfhdr.e_phnum), 
+					   getu16(fm, elfhdr.e_phentsize));
 			}
-			doshn(cls, swap,
-			      fd,
-			      getu32(swap, elfhdr.e_shoff),
-			      getu16(swap, elfhdr.e_shnum),
-			      getu16(swap, elfhdr.e_shentsize));
+			doshn(fm,
+			      getu32(fm, elfhdr.e_shoff),
+			      getu16(fm, elfhdr.e_shnum),
+			      getu16(fm, elfhdr.e_shentsize));
 		}
 		return;
 	}
 
-        if (cls == ELFCLASS64) {
+        if (fm->cls == ELFCLASS64) {
 		Elf64_Ehdr elfhdr;
-		if (nbytes <= sizeof (Elf64_Ehdr))
+		if (fm->nb <= sizeof (Elf64_Ehdr))
 			return;
 
 
 		u.l = 1;
-		(void) memcpy(&elfhdr, buf, sizeof elfhdr);
-		swap = (u.c[sizeof(int32_t) - 1] + 1) != elfhdr.e_ident[EI_DATA];
+		(void) memcpy(&elfhdr, fm->buf, sizeof elfhdr);
+		fm->swap = (u.c[sizeof(int32_t) - 1] + 1) != elfhdr.e_ident[EI_DATA];
 
-		if (getu16(swap, elfhdr.e_type) == ET_CORE) 
+		if (getu16(fm, elfhdr.e_type) == ET_CORE) 
 #ifdef ELFCORE
-			dophn_core(cls, swap,
-				   fd,
+			dophn_core(fm,
 #ifdef USE_ARRAY_FOR_64BIT_TYPES
-				   getu32(swap, elfhdr.e_phoff[1]),
+				   getu32(fm, elfhdr.e_phoff[1]),
 #else
-				   getu64(swap, elfhdr.e_phoff),
+				   getu64(fm, elfhdr.e_phoff),
 #endif
-				   getu16(swap, elfhdr.e_phnum), 
-				   getu16(swap, elfhdr.e_phentsize));
+				   getu16(fm, elfhdr.e_phnum), 
+				   getu16(fm, elfhdr.e_phentsize));
 #else
 			;
 #endif
 		else
 		{
-			if (getu16(swap, elfhdr.e_type) == ET_EXEC) {
-				dophn_exec(cls, swap,
-					   fd,
+			if (getu16(fm, elfhdr.e_type) == ET_EXEC) {
+				dophn_exec(fm,
 #ifdef USE_ARRAY_FOR_64BIT_TYPES
-					   getu32(swap, elfhdr.e_phoff[1]),
+					   getu32(fm, elfhdr.e_phoff[1]),
 #else
-					   getu64(swap, elfhdr.e_phoff),
+					   getu64(fm, elfhdr.e_phoff),
 #endif
-					   getu16(swap, elfhdr.e_phnum), 
-					   getu16(swap, elfhdr.e_phentsize));
+					   getu16(fm, elfhdr.e_phnum), 
+					   getu16(fm, elfhdr.e_phentsize));
 			}
-			doshn(cls, swap,
-			      fd,
+			doshn(fm,
 #ifdef USE_ARRAY_FOR_64BIT_TYPES
-			      getu32(swap, elfhdr.e_shoff[1]),
+			      getu32(fm, elfhdr.e_shoff[1]),
 #else
-			      getu64(swap, elfhdr.e_shoff),
+			      getu64(fm, elfhdr.e_shoff),
 #endif
-			      getu16(swap, elfhdr.e_shnum),
-			      getu16(swap, elfhdr.e_shentsize));
+			      getu16(fm, elfhdr.e_shnum),
+			      getu16(fm, elfhdr.e_shentsize));
 		}
 		return;
 	}
diff --git a/file/softmagic.c b/file/softmagic.c
index 56c5bc211..8b9c6f6d3 100644
--- a/file/softmagic.c
+++ b/file/softmagic.c
@@ -36,7 +36,7 @@ FILE_RCSID("@(#)Id: softmagic.c,v 1.51 2002/07/03 18:26:38 christos Exp ")
 static int32_t
 fmagicSPrint(const fmagic fm, struct magic *m)
 	/*@globals fileSystem @*/
-	/*@modifies fileSystem @*/
+	/*@modifies fm, fileSystem @*/
 {
 	union VALUETYPE * p = &fm->val;
 	uint32_t v;
@@ -45,7 +45,7 @@ fmagicSPrint(const fmagic fm, struct magic *m)
   	switch (m->type) {
   	case BYTE:
 		v = signextend(m, p->b);
-		(void) printf(m->desc, (unsigned char) v);
+		fmagicPrintf(fm, m->desc, (unsigned char) v);
 		t = m->offset + sizeof(char);
 		break;
 
@@ -53,7 +53,7 @@ fmagicSPrint(const fmagic fm, struct magic *m)
   	case BESHORT:
   	case LESHORT:
 		v = signextend(m, p->h);
-		(void) printf(m->desc, (unsigned short) v);
+		fmagicPrintf(fm, m->desc, (unsigned short) v);
 		t = m->offset + sizeof(short);
 		break;
 
@@ -61,14 +61,14 @@ fmagicSPrint(const fmagic fm, struct magic *m)
   	case BELONG:
   	case LELONG:
 		v = signextend(m, p->l);
-		(void) printf(m->desc, (uint32_t) v);
+		fmagicPrintf(fm, m->desc, (uint32_t) v);
 		t = m->offset + sizeof(int32_t);
   		break;
 
   	case STRING:
   	case PSTRING:
 		if (m->reln == '=') {
-			(void) printf(m->desc, m->value.s);
+			fmagicPrintf(fm, m->desc, m->value.s);
 			t = m->offset + strlen(m->value.s);
 		}
 		else {
@@ -77,7 +77,7 @@ fmagicSPrint(const fmagic fm, struct magic *m)
 				if (cp != NULL)
 					*cp = '\0';
 			}
-			(void) printf(m->desc, p->s);
+			fmagicPrintf(fm, m->desc, p->s);
 			t = m->offset + strlen(p->s);
 		}
 		break;
@@ -85,18 +85,18 @@ fmagicSPrint(const fmagic fm, struct magic *m)
 	case DATE:
 	case BEDATE:
 	case LEDATE:
-		(void) printf(m->desc, fmttime(p->l, 1));
+		fmagicPrintf(fm, m->desc, fmttime(p->l, 1));
 		t = m->offset + sizeof(time_t);
 		break;
 
 	case LDATE:
 	case BELDATE:
 	case LELDATE:
-		(void) printf(m->desc, fmttime(p->l, 0));
+		fmagicPrintf(fm, m->desc, fmttime(p->l, 0));
 		t = m->offset + sizeof(time_t);
 		break;
 	case REGEX:
-	  	(void) printf(m->desc, p->s);
+	  	fmagicPrintf(fm, m->desc, p->s);
 		t = m->offset + strlen(p->s);
 		break;
 
@@ -114,8 +114,7 @@ fmagicSPrint(const fmagic fm, struct magic *m)
  */
 static int
 fmagicSConvert(fmagic fm, struct magic *m)
-	/*@globals fileSystem @*/
-	/*@modifies fm, fileSystem @*/
+	/*@modifies fm @*/
 {
 	union VALUETYPE * p = &fm->val;
 
@@ -398,7 +397,7 @@ fmagicSDebug(int32_t offset, char *str, int len)
 static int
 fmagicSGet(fmagic fm, struct magic *m)
 	/*@globals fileSystem @*/
-	/*@modifies fm, s, fileSystem @*/
+	/*@modifies fm, fileSystem @*/
 {
 	unsigned char * buf = fm->buf;
 	int nb = fm->nb;
@@ -1022,7 +1021,7 @@ fmagicSMatch(const fmagic fm)
 
 		if (! firstline) { /* we found another match */
 			/* put a newline and '-' to do some simple formatting */
-			printf("\n- ");
+			fmagicPrintf(fm, "\n- ");
 		}
 
 		if ((cont_level+1) >= tmplen)
@@ -1068,7 +1067,7 @@ fmagicSMatch(const fmagic fm)
 				   && (m->nospflag == 0)
 				   && (m->desc[0] != '\0')
 				   ) {
-					ckfputs(" ", fm);
+					fmagicPrintf(fm, " ");
 					need_separator = 0;
 				}
 				if ((cont_level+1) >= tmplen)
@@ -1097,11 +1096,13 @@ fmagicSMatch(const fmagic fm)
 int
 fmagicS(fmagic fm)
 {
+/*@-branchstate@*/
 	if (fm->mlist != NULL)
 	for (fm->ml = fm->mlist->next; fm->ml != fm->mlist; fm->ml = fm->ml->next) {
 		if (fmagicSMatch(fm))
 			return 1;
 	}
+/*@=branchstate@*/
 
 	return 0;
 }
diff --git a/file/system.h b/file/system.h
index e3880e077..2b2d6f1a9 100644
--- a/file/system.h
+++ b/file/system.h
@@ -43,11 +43,16 @@ extern int errno;
 
 #if HAVE_ERROR && HAVE_ERROR_H
 #include <error.h>
-#else
+#endif
+
+#if defined(__LCLINT__)
+/*@-declundef @*/
 /*@exits@*/
-extern void error(int status, int errnum, const char *f, ...)
+extern void error(int status, int errnum, const char *format, ...)
+	__attribute__ ((__format__ (__printf__, 3, 4)))
 	/*@globals fileSystem @*/
 	/*@modifies fileSystem @*/;
+/*@=declundef @*/
 #endif
 
 #ifdef STDC_HEADERS
@@ -240,8 +245,7 @@ char * xstrdup (const char *str)
  */
 /*@unused@*/ /*@exits@*/ /*@only@*/
 static inline void * vmefail(/*@unused@*/ size_t nb)
-	/*@globals fileSystem @*/
-	/*@modifies fileSystem @*/
+	/*@*/
 {
 	error(EXIT_FAILURE, 0, "out of memory");
 	/*@notreached@*/