1 files changed, 110 insertions, 210 deletions

diff --git a/usr.sbin/quot/quot.c b/usr.sbin/quot/quot.c
index 4152c498371a..879580f649b9 100644
--- a/usr.sbin/quot/quot.c
+++ b/usr.sbin/quot/quot.c
@@ -32,19 +32,21 @@
  */
 
 #include <sys/param.h>
-#include <sys/stdint.h>
 #include <sys/mount.h>
 #include <sys/disklabel.h>
 #include <ufs/ufs/dinode.h>
 #include <ufs/ffs/fs.h>
 
 #include <err.h>
+#include <errno.h>
 #include <fcntl.h>
 #include <fstab.h>
-#include <errno.h>
 #include <libufs.h>
+#include <mntopts.h>
 #include <paths.h>
 #include <pwd.h>
+#include <stdbool.h>
+#include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -52,16 +54,16 @@
 #include <unistd.h>
 
 /* some flags of what to do: */
-static char estimate;
-static char count;
-static char unused;
-static void (*func)(int, struct fs *, char *);
+static bool all;
+static bool count;
+static bool noname;
+static bool unused;
+static void (*func)(int, struct fs *);
 static long blocksize;
 static char *header;
 static int headerlen;
 
 static union dinode *get_inode(int, struct fs *, ino_t);
-static int	virtualblocks(struct fs *, union dinode *);
 static int	isfree(struct fs *, union dinode *);
 static void	inituser(void);
 static void	usrrehash(void);
@@ -69,9 +71,9 @@ static struct user *user(uid_t);
 static int	cmpusers(const void *, const void *);
 static void	uses(uid_t, daddr_t, time_t);
 static void	initfsizes(void);
-static void	dofsizes(int, struct fs *, char *);
-static void	douser(int, struct fs *, char *);
-static void	donames(int, struct fs *, char *);
+static void	dofsizes(int, struct fs *);
+static void	douser(int, struct fs *);
+static void	donames(int, struct fs *);
 static void	usage(void);
 static void	quot(char *, char *);
 
@@ -86,11 +88,7 @@ static void	quot(char *, char *);
  * Due to the size of modern disks, we must cast intermediate
  * values to 64 bits to prevent potential overflows.
  */
-#ifdef	COMPAT
-#define	SIZE(n)	(n)
-#else
-#define	SIZE(n) ((int)(((quad_t)(n) * 512 + blocksize - 1)/blocksize))
-#endif
+#define	SIZE(n) ((int)(((intmax_t)(n) * 512 + blocksize - 1) / blocksize))
 
 #define	INOCNT(fs)	((fs)->fs_ipg)
 #define	INOSZ(fs) \
@@ -104,29 +102,26 @@ static void	quot(char *, char *);
 static union dinode *
 get_inode(int fd, struct fs *super, ino_t ino)
 {
-	static caddr_t ipbuf;
+	static union dinode *ipbuf;
 	static struct cg *cgp;
 	static ino_t last;
-	static int cg;
+	static unsigned long cg;
 	struct ufs2_dinode *di2;
+	off_t off;
 
 	if (fd < 0) {		/* flush cache */
-		if (ipbuf) {
-			free(ipbuf);
-			ipbuf = 0;
-			if (super != NULL && super->fs_magic == FS_UFS2_MAGIC) {
-				free(cgp);
-				cgp = 0;
-			}
-		}
-		return 0;
+		free(ipbuf);
+		ipbuf = NULL;
+		free(cgp);
+		cgp = NULL;
+		return (NULL);
 	}
 
-	if (!ipbuf || ino < last || ino >= last + INOCNT(super)) {
+	if (ipbuf == NULL || ino < last || ino >= last + INOCNT(super)) {
 		if (super->fs_magic == FS_UFS2_MAGIC &&
-		    (!cgp || cg != ino_to_cg(super, ino))) {
+		    (cgp == NULL || cg != ino_to_cg(super, ino))) {
 			cg = ino_to_cg(super, ino);
-			if (!cgp && !(cgp = malloc(super->fs_cgsize)))
+			if (cgp == NULL && (cgp = malloc(super->fs_cgsize)) == NULL)
 				errx(1, "allocate cg");
 			if (lseek(fd, (off_t)cgtod(super, cg) << super->fs_fshift, 0) < 0)
 				err(1, "lseek cg");
@@ -135,12 +130,12 @@ get_inode(int fd, struct fs *super, ino_t ino)
 			if (!cg_chkmagic(cgp))
 				errx(1, "cg has bad magic");
 		}
-		if (!ipbuf
-		    && !(ipbuf = malloc(INOSZ(super))))
+		if (ipbuf == NULL && (ipbuf = malloc(INOSZ(super))) == NULL)
 			errx(1, "allocate inodes");
 		last = rounddown(ino, INOCNT(super));
-		if (lseek(fd, (off_t)ino_to_fsba(super, last) << super->fs_fshift, 0) < (off_t)0
-		    || read(fd, ipbuf, INOSZ(super)) != (ssize_t)INOSZ(super))
+		off = (off_t)ino_to_fsba(super, last) << super->fs_fshift;
+		if (lseek(fd, off, SEEK_SET) != off ||
+		    read(fd, ipbuf, INOSZ(super)) != (ssize_t)INOSZ(super))
 			err(1, "read inodes");
 	}
 
@@ -150,55 +145,13 @@ get_inode(int fd, struct fs *super, ino_t ino)
 	di2 = &((struct ufs2_dinode *)ipbuf)[ino % INOCNT(super)];
 	/* If the inode is unused, it might be unallocated too, so zero it. */
 	if (isclr(cg_inosused(cgp), ino % super->fs_ipg))
-		bzero(di2, sizeof (*di2));
+		memset(di2, 0, sizeof(*di2));
 	return ((union dinode *)di2);
 }
 
-#ifdef	COMPAT
-#define	actualblocks(fs, dp)	(DIP(fs, dp, di_blocks) / 2)
-#else
-#define	actualblocks(fs, dp)	DIP(fs, dp, di_blocks)
-#endif
-
-static int virtualblocks(struct fs *super, union dinode *dp)
-{
-	off_t nblk, sz;
-
-	sz = DIP(super, dp, di_size);
-#ifdef	COMPAT
-	if (lblkno(super,sz) >= UFS_NDADDR) {
-		nblk = blkroundup(super,sz);
-		if (sz == nblk)
-			nblk += super->fs_bsize;
-	}
-
-	return sz / 1024;
-
-#else	/* COMPAT */
-
-	if (lblkno(super,sz) >= UFS_NDADDR) {
-		nblk = blkroundup(super,sz);
-		sz = lblkno(super,nblk);
-		sz = (sz - UFS_NDADDR + NINDIR(super) - 1) / NINDIR(super);
-		while (sz > 0) {
-			nblk += sz * super->fs_bsize;
-			/* sz - 1 rounded up */
-			sz = (sz - 1 + NINDIR(super) - 1) / NINDIR(super);
-		}
-	} else
-		nblk = fragroundup(super,sz);
-
-	return nblk / 512;
-#endif	/* COMPAT */
-}
-
 static int
 isfree(struct fs *super, union dinode *dp)
 {
-#ifdef	COMPAT
-	return (DIP(super, dp, di_mode) & IFMT) == 0;
-#else	/* COMPAT */
-
 	switch (DIP(super, dp, di_mode) & IFMT) {
 	case IFIFO:
 	case IFLNK:		/* should check FASTSYMLINK? */
@@ -214,7 +167,6 @@ isfree(struct fs *super, union dinode *dp)
 	default:
 		errx(1, "unknown IFMT 0%o", DIP(super, dp, di_mode) & IFMT);
 	}
-#endif
 }
 
 static struct user {
@@ -234,10 +186,9 @@ inituser(void)
 	int i;
 	struct user *usr;
 
-	if (!nusers) {
+	if (nusers == 0) {
 		nusers = 8;
-		if (!(users =
-		    (struct user *)calloc(nusers,sizeof(struct user))))
+		if ((users = calloc(nusers, sizeof(*users))) == NULL)
 			errx(1, "allocate users");
 	} else {
 		for (usr = users, i = nusers; --i >= 0; usr++) {
@@ -255,14 +206,13 @@ usrrehash(void)
 	struct user *svusr;
 
 	svusr = users;
-	nusers <<= 1;
-	if (!(users = (struct user *)calloc(nusers,sizeof(struct user))))
+	nusers *= 2;
+	if ((users = calloc(nusers, sizeof(*users))) == NULL)
 		errx(1, "allocate users");
-	for (usr = svusr, i = nusers >> 1; --i >= 0; usr++) {
-		for (usrn = users + (usr->uid&(nusers - 1)); usrn->name;
-		    usrn--) {
+	for (usr = svusr, i = nusers / 2; --i >= 0; usr++) {
+		for (usrn = users + usr->uid % nusers; usrn->name; usrn--) {
 			if (usrn <= users)
-				usrn = users + nusers;
+				usrn += nusers;
 		}
 		*usrn = *usr;
 	}
@@ -272,33 +222,24 @@ static struct user *
 user(uid_t uid)
 {
 	struct user *usr;
-	int i;
 	struct passwd *pwd;
+	int i;
 
 	while (1) {
-		for (usr = users + (uid&(nusers - 1)), i = nusers; --i >= 0;
-		    usr--) {
-			if (!usr->name) {
+		for (usr = users + uid % nusers, i = nusers; --i >= 0; usr--) {
+			if (usr->name == NULL) {
 				usr->uid = uid;
-
-				if (!(pwd = getpwuid(uid))) {
-					if ((usr->name = (char *)malloc(7)))
-						sprintf(usr->name,"#%d",uid);
-				} else {
-					if ((usr->name = (char *)
-					    malloc(strlen(pwd->pw_name) + 1)))
-						strcpy(usr->name,pwd->pw_name);
-				}
-				if (!usr->name)
+				if (noname || (pwd = getpwuid(uid)) == NULL)
+					asprintf(&usr->name, "#%u", uid);
+				else
+					usr->name = strdup(pwd->pw_name);
+				if (usr->name == NULL)
 					errx(1, "allocate users");
-
-				return usr;
-
-			} else if (usr->uid == uid)
-				return usr;
-
+			}
+			if (usr->uid == uid)
+				return (usr);
 			if (usr <= users)
-				usr = users + nusers;
+				usr += nusers;
 		}
 		usrrehash();
 	}
@@ -307,15 +248,16 @@ user(uid_t uid)
 static int
 cmpusers(const void *v1, const void *v2)
 {
-	const struct user *u1, *u2;
-	u1 = (const struct user *)v1;
-	u2 = (const struct user *)v2;
+	const struct user *u1 = v1, *u2 = v2;
 
-	return u2->space - u1->space;
+	return (u2->space > u1->space ? 1 :
+	    u2->space < u1->space ? -1 :
+	    u1->uid > u2->uid ? 1 :
+	    u1->uid < u2->uid ? -1 : 0);
 }
 
-#define	sortusers(users)	(qsort((users),nusers,sizeof(struct user), \
-				    cmpusers))
+#define	sortusers(users)						\
+	qsort((users), nusers, sizeof(struct user), cmpusers)
 
 static void
 uses(uid_t uid, daddr_t blks, time_t act)
@@ -338,12 +280,8 @@ uses(uid_t uid, daddr_t blks, time_t act)
 		usr->spc30 += blks;
 }
 
-#ifdef	COMPAT
-#define	FSZCNT	500
-#else
 #define	FSZCNT	512
-#endif
-struct fsizes {
+static struct fsizes {
 	struct fsizes *fsz_next;
 	daddr_t fsz_first, fsz_last;
 	ino_t fsz_count[FSZCNT];
@@ -365,7 +303,7 @@ initfsizes(void)
 }
 
 static void
-dofsizes(int fd, struct fs *super, char *name)
+dofsizes(int fd, struct fs *super)
 {
 	ino_t inode, maxino;
 	union dinode *dp;
@@ -374,39 +312,18 @@ dofsizes(int fd, struct fs *super, char *name)
 	int i;
 
 	maxino = super->fs_ncg * super->fs_ipg - 1;
-#ifdef	COMPAT
-	if (!(fsizes = (struct fsizes *)malloc(sizeof(struct fsizes))))
-		errx(1, "allocate fsize structure");
-#endif	/* COMPAT */
 	for (inode = 0; inode < maxino; inode++) {
-		errno = 0;
-		if ((dp = get_inode(fd,super,inode))
-#ifdef	COMPAT
-		    && ((DIP(super, dp, di_mode) & IFMT) == IFREG
-			|| (DIP(super, dp, di_mode) & IFMT) == IFDIR)
-#else	/* COMPAT */
-		    && !isfree(super, dp)
-#endif	/* COMPAT */
+		if ((dp = get_inode(fd, super, inode)) != NULL &&
+		    !isfree(super, dp)
 		    ) {
-			sz = estimate ? virtualblocks(super, dp) :
-			    actualblocks(super, dp);
-#ifdef	COMPAT
-			if (sz >= FSZCNT) {
-				fsizes->fsz_count[FSZCNT-1]++;
-				fsizes->fsz_sz[FSZCNT-1] += sz;
-			} else {
-				fsizes->fsz_count[sz]++;
-				fsizes->fsz_sz[sz] += sz;
-			}
-#else	/* COMPAT */
+			sz = DIP(super, dp, di_blocks);
 			ksz = SIZE(sz);
 			for (fsp = &fsizes; (fp = *fsp); fsp = &fp->fsz_next) {
 				if (ksz < fp->fsz_last)
 					break;
 			}
-			if (!fp || ksz < fp->fsz_first) {
-				if (!(fp = (struct fsizes *)
-				    malloc(sizeof(struct fsizes))))
+			if (fp == NULL || ksz < fp->fsz_first) {
+				if ((fp = malloc(sizeof(*fp))) == NULL)
 					errx(1, "allocate fsize structure");
 				fp->fsz_next = *fsp;
 				*fsp = fp;
@@ -419,25 +336,23 @@ dofsizes(int fd, struct fs *super, char *name)
 			}
 			fp->fsz_count[ksz % FSZCNT]++;
 			fp->fsz_sz[ksz % FSZCNT] += sz;
-#endif	/* COMPAT */
-		} else if (errno) {
-			err(1, "%s", name);
 		}
 	}
 	sz = 0;
-	for (fp = fsizes; fp; fp = fp->fsz_next) {
+	for (fp = fsizes; fp != NULL; fp = fp->fsz_next) {
 		for (i = 0; i < FSZCNT; i++) {
-			if (fp->fsz_count[i])
+			if (fp->fsz_count[i] != 0) {
 				printf("%jd\t%jd\t%d\n",
 				    (intmax_t)(fp->fsz_first + i),
 				    (intmax_t)fp->fsz_count[i],
 				    SIZE(sz += fp->fsz_sz[i]));
+			}
 		}
 	}
 }
 
 static void
-douser(int fd, struct fs *super, char *name)
+douser(int fd, struct fs *super)
 {
 	ino_t inode, maxino;
 	struct user *usr, *usrs;
@@ -446,38 +361,35 @@ douser(int fd, struct fs *super, char *name)
 
 	maxino = super->fs_ncg * super->fs_ipg - 1;
 	for (inode = 0; inode < maxino; inode++) {
-		errno = 0;
-		if ((dp = get_inode(fd,super,inode))
-		    && !isfree(super, dp))
+		if ((dp = get_inode(fd, super, inode)) != NULL &&
+		    !isfree(super, dp)) {
 			uses(DIP(super, dp, di_uid),
-			    estimate ? virtualblocks(super, dp) :
-				actualblocks(super, dp),
+			    DIP(super, dp, di_blocks),
 			    DIP(super, dp, di_atime));
-		else if (errno) {
-			err(1, "%s", name);
 		}
 	}
-	if (!(usrs = (struct user *)malloc(nusers * sizeof(struct user))))
+	if ((usrs = malloc(nusers * sizeof(*usrs))) == NULL)
 		errx(1, "allocate users");
-	bcopy(users,usrs,nusers * sizeof(struct user));
+	memcpy(usrs, users, nusers * sizeof(*usrs));
 	sortusers(usrs);
 	for (usr = usrs, n = nusers; --n >= 0 && usr->count; usr++) {
-		printf("%5d",SIZE(usr->space));
+		printf("%5d", SIZE(usr->space));
 		if (count)
-			printf("\t%5ld",usr->count);
-		printf("\t%-8s",usr->name);
-		if (unused)
+			printf("\t%5ld", usr->count);
+		printf("\t%-8s", usr->name);
+		if (unused) {
 			printf("\t%5d\t%5d\t%5d",
-			       SIZE(usr->spc30),
-			       SIZE(usr->spc60),
-			       SIZE(usr->spc90));
+			    SIZE(usr->spc30),
+			    SIZE(usr->spc60),
+			    SIZE(usr->spc90));
+		}
 		printf("\n");
 	}
 	free(usrs);
 }
 
 static void
-donames(int fd, struct fs *super, char *name)
+donames(int fd, struct fs *super)
 {
 	int c;
 	ino_t maxino;
@@ -488,18 +400,18 @@ donames(int fd, struct fs *super, char *name)
 	/* first skip the name of the filesystem */
 	while ((c = getchar()) != EOF && (c < '0' || c > '9'))
 		while ((c = getchar()) != EOF && c != '\n');
-	ungetc(c,stdin);
+	ungetc(c, stdin);
 	while (scanf("%ju", &inode) == 1) {
 		if (inode > maxino) {
 			warnx("illegal inode %ju", inode);
 			return;
 		}
-		errno = 0;
-		if ((dp = get_inode(fd,super,inode))
-		    && !isfree(super, dp)) {
-			printf("%s\t",user(DIP(super, dp, di_uid))->name);
+		if ((dp = get_inode(fd, super, inode)) != NULL &&
+		    !isfree(super, dp)) {
+			printf("%s\t", user(DIP(super, dp, di_uid))->name);
 			/* now skip whitespace */
-			while ((c = getchar()) == ' ' || c == '\t');
+			while ((c = getchar()) == ' ' || c == '\t')
+				/* nothing */;
 			/* and print out the remainder of the input line */
 			while (c != EOF && c != '\n') {
 				putchar(c);
@@ -507,11 +419,9 @@ donames(int fd, struct fs *super, char *name)
 			}
 			putchar('\n');
 		} else {
-			if (errno) {
-				err(1, "%s", name);
-			}
 			/* skip this line */
-			while ((c = getchar()) != EOF && c != '\n');
+			while ((c = getchar()) != EOF && c != '\n')
+				/* nothing */;
 		}
 		if (c == EOF)
 			break;
@@ -521,11 +431,7 @@ donames(int fd, struct fs *super, char *name)
 static void
 usage(void)
 {
-#ifdef	COMPAT
-	fprintf(stderr, "usage: quot [-cfhnv] [-a | filesystem ...]\n");
-#else	/* COMPAT */
-	fprintf(stderr, "usage: quot [-cfhknv] [-a | filesystem ...]\n");
-#endif	/* COMPAT */
+	fprintf(stderr, "usage: quot [-cfknv] [-a | filesystem ...]\n");
 	exit(1);
 }
 
@@ -538,7 +444,7 @@ quot(char *name, char *mp)
 	get_inode(-1, NULL, 0);		/* flush cache */
 	inituser();
 	initfsizes();
-	if ((fd = open(name,0)) < 0) {
+	if ((fd = open(name, 0)) < 0) {
 		warn("%s", name);
 		close(fd);
 		return;
@@ -555,11 +461,11 @@ quot(char *name, char *mp)
 		close(fd);
 		return;
 	}
-	printf("%s:",name);
+	printf("%s:", name);
 	if (mp)
-		printf(" (%s)",mp);
+		printf(" (%s)", mp);
 	putchar('\n');
-	(*func)(fd, fs, name);
+	(*func)(fd, fs);
 	free(fs);
 	close(fd);
 }
@@ -567,40 +473,36 @@ quot(char *name, char *mp)
 int
 main(int argc, char *argv[])
 {
-	char all = 0;
 	struct statfs *mp;
-	struct fstab *fs;
-	int cnt;
-	int ch;
+	int ch, cnt;
 
 	func = douser;
-#ifndef	COMPAT
-	header = getbsize(&headerlen,&blocksize);
-#endif
-	while ((ch = getopt(argc, argv, "acfhknv")) != -1) {
+	header = getbsize(&headerlen, &blocksize);
+	while ((ch = getopt(argc, argv, "acfhkNnv")) != -1) {
 		switch (ch) {
 		case 'a':
-			all = 1;
+			all = true;
 			break;
 		case 'c':
 			func = dofsizes;
 			break;
 		case 'f':
-			count = 1;
+			count = true;
 			break;
 		case 'h':
-			estimate = 1;
+			/* ignored for backward compatibility */
 			break;
-#ifndef	COMPAT
 		case 'k':
 			blocksize = 1024;
 			break;
-#endif	/* COMPAT */
+		case 'N':
+			noname = true;
+			break;
 		case 'n':
 			func = donames;
 			break;
 		case 'v':
-			unused = 1;
+			unused = true;
 			break;
 		default:
 			usage();
@@ -613,18 +515,16 @@ main(int argc, char *argv[])
 		usage();
 
 	if (all) {
-		cnt = getmntinfo(&mp,MNT_NOWAIT);
-		for (; --cnt >= 0; mp++) {
-			if (!strncmp(mp->f_fstypename, "ufs", MFSNAMELEN))
+		for (cnt = getmntinfo(&mp, MNT_NOWAIT); --cnt >= 0; mp++)
+			if (strncmp(mp->f_fstypename, "ufs", MFSNAMELEN) == 0)
 				quot(mp->f_mntfromname, mp->f_mntonname);
-		}
 	}
-	while (--argc >= 0) {
-		if ((fs = getfsfile(*argv)) != NULL)
-			quot(fs->fs_spec, 0);
+	while (argc-- > 0) {
+		if ((mp = getmntpoint(*argv)) != NULL)
+			quot(mp->f_mntfromname, mp->f_mntonname);
 		else
-			quot(*argv,0);
+			quot(*argv, 0);
 		argv++;
 	}
-	return 0;
+	return (0);
 }