 @@ -1,14 +1,14 @@
-/*      $NetBSD: edquota.c,v 1.45 2012/01/30 19:18:36 dholland Exp $ */
+/*      $NetBSD: edquota.c,v 1.46 2012/01/30 19:19:20 dholland Exp $ */
 /*
  * Copyright (c) 1980, 1990, 1993
  *	The Regents of the University of California.  All rights reserved.
+ *
  * This code is derived from software contributed to Berkeley by
  * Robert Elz at The University of Melbourne.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
 @@ -31,97 +31,100 @@
  * SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
 #ifndef lint
 __COPYRIGHT("@(#) Copyright (c) 1980, 1990, 1993\
  The Regents of the University of California.  All rights reserved.");
 #endif /* not lint */
 #ifndef lint
 #if 0
 static char sccsid[] = "from: @(#)edquota.c	8.3 (Berkeley) 4/27/95";
 #else
-__RCSID("$NetBSD: edquota.c,v 1.45 2012/01/30 19:18:36 dholland Exp $");
+__RCSID("$NetBSD: edquota.c,v 1.46 2012/01/30 19:19:20 dholland Exp $");
 #endif
 #endif /* not lint */
 /*
  * Disk quota editor.
  */
 #include <sys/param.h>
 #include <sys/stat.h>
 #include <sys/file.h>
 #include <sys/wait.h>
 #include <sys/queue.h>
 #include <sys/types.h>
 #include <sys/statvfs.h>
 #include <quota.h>
 #include <quota/quotaprop.h>
 #include <quota/quota.h>
 #include <ufs/ufs/quota1.h>
 #include <assert.h>
 #include <err.h>
 #include <errno.h>
 #include <fstab.h>
 #include <pwd.h>
 #include <grp.h>
 #include <ctype.h>
 #include <signal.h>
 #include <stdbool.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 #include "printquota.h"
 #include "quotautil.h"
 #include "pathnames.h"
 /*
  * XXX. Ideally we shouldn't compile this in, but it'll take some
  * reworking to avoid it and it'll be ok for now.
  */
 #define EDQUOTA_NUMOBJTYPES	2
 #if 0
 static const char *quotagroup = QUOTAGROUP;
 #endif
 #define MAX_TMPSTR	(100+MAXPATHLEN)
 /* flags for quotause */
 #define	FOUND	0x01
 #define	XGRACE	0x02	/* extended grace periods (per-id) */
 #define	DEFAULT	0x04
 struct quotause {
 	struct	quotause *next;
 	long	flags;
-	struct	quotaval qv[QUOTA_NLIMITS];
+	struct	quotaval qv[EDQUOTA_NUMOBJTYPES];
 	char	fsname[MAXPATHLEN + 1];
 	char	implementation[32];
 	char	*qfname;
 };
 struct quotalist {
 	struct quotause *head;
 	struct quotause *tail;
 	char *idtypename;
 };
 static void	usage(void) __dead;
 static int Hflag = 0;
 /* more compact form of constants */
-#define QL_BLK QUOTA_LIMIT_BLOCK
+#define QO_BLK QUOTA_OBJTYPE_BLOCKS
-#define QL_FL  QUOTA_LIMIT_FILE
+#define QO_FL  QUOTA_OBJTYPE_FILES
 ////////////////////////////////////////////////////////////
 // support code
 /*
  * This routine converts a name for a particular quota class to
  * an identifier. This routine must agree with the kernel routine
  * getinoquota as to the interpretation of quota classes.
  */
 static int
 getidbyname(const char *name, int idtype)
+{
 	struct passwd *pw;
 @@ -191,42 +194,44 @@ quotause_destroy(struct quotause *qup)
  */
 static struct quotalist *
 quotalist_create(void)
+{
 	struct quotalist *qlist;
 	qlist = malloc(sizeof(*qlist));
 	if (qlist == NULL) {
 		err(1, "malloc");
+	}
 	qlist->head = NULL;
 	qlist->tail = NULL;
 	qlist->idtypename = NULL;
 	return qlist;
+}
 /*
  * Free a list of quotause structures.
  */
 static void
 quotalist_destroy(struct quotalist *qlist)
+{
 	struct quotause *qup, *nextqup;
 	for (qup = qlist->head; qup; qup = nextqup) {
 		nextqup = qup->next;
 		quotause_destroy(qup);
+	}
 	free(qlist->idtypename);
 	free(qlist);
+}
 #if 0
 static bool
 quotalist_empty(struct quotalist *qlist)
+{
 	return qlist->head == NULL;
+}
 #endif
 static void
 quotalist_append(struct quotalist *qlist, struct quotause *qup)
 @@ -352,55 +357,65 @@ dogetprivs2(struct quotahandle *qh, int
 	qk.qk_id = defaultq ? QUOTA_DEFAULTID : id;
 	qk.qk_objtype = objtype;
 	if (quota_get(qh, &qk, &qup->qv[objtype])) {
 		/* no entry, get default entry */
 		qk.qk_id = QUOTA_DEFAULTID;
 		if (quota_get(qh, &qk, &qup->qv[objtype])) {
 			return -1;
+		}
+	}
 	return 0;
+}
 static struct quotause *
-getprivs2(long id, int idtype, const char *filesys, int defaultq)
+getprivs2(long id, int idtype, const char *filesys, int defaultq,
 	  char **idtypename_p)
+{
 	struct quotause *qup;
 	struct quotahandle *qh;
 	const char *impl;
 	unsigned restrictions;
 	const char *idtypename;
 	qup = quotause_create();
 	strcpy(qup->fsname, filesys);
 	if (defaultq)
 		qup->flags |= DEFAULT;
 	qh = quota_open(filesys);
 	if (qh == NULL) {
 		quotause_destroy(qup);
 		return NULL;
+	}
 	impl = quota_getimplname(qh);
 	if (impl == NULL) {
 		impl = "???";
+	}
 	strlcpy(qup->implementation, impl, sizeof(qup->implementation));
 	restrictions = quota_getrestrictions(qh);
 	if ((restrictions & QUOTA_RESTRICT_UNIFORMGRACE) == 0) {
 		qup->flags |= XGRACE;
+	}
 	if (*idtypename_p == NULL) {
 		idtypename = quota_idtype_getname(qh, idtype);
 		*idtypename_p = strdup(idtypename);
 		if (*idtypename_p == NULL) {
 			errx(1, "Out of memory");
+		}
+	}
 	if (dogetprivs2(qh, idtype, id, defaultq, QUOTA_OBJTYPE_BLOCKS, qup)) {
 		quota_close(qh);
 		quotause_destroy(qup);
 		return NULL;
+	}
 	if (dogetprivs2(qh, idtype, id, defaultq, QUOTA_OBJTYPE_FILES, qup)) {
 		quota_close(qh);
 		quotause_destroy(qup);
 		return NULL;
+	}
 	quota_close(qh);
 @@ -422,34 +437,34 @@ putprivs2(uint32_t id, int idtype, struc
 	} else {
 		snprintf(idname, sizeof(idname), "%s %u",
 			 idtype == QUOTA_IDTYPE_USER ? "uid" : "gid", id);
+	}
 	qh = quota_open(qup->fsname);
 	if (qh == NULL) {
 		err(1, "%s: quota_open", qup->fsname);
+	}
 	qk.qk_idtype = idtype;
 	qk.qk_id = id;
 	qk.qk_objtype = QUOTA_OBJTYPE_BLOCKS;
-	if (quota_put(qh, &qk, &qup->qv[QL_BLK])) {
+	if (quota_put(qh, &qk, &qup->qv[QO_BLK])) {
 		err(1, "%s: quota_put (%s blocks)", qup->fsname, idname);
+	}
 	qk.qk_idtype = idtype;
 	qk.qk_id = id;
 	qk.qk_objtype = QUOTA_OBJTYPE_FILES;
-	if (quota_put(qh, &qk, &qup->qv[QL_FL])) {
+	if (quota_put(qh, &qk, &qup->qv[QO_FL])) {
 		err(1, "%s: quota_put (%s files)", qup->fsname, idname);
+	}
 	quota_close(qh);
+}
 ////////////////////////////////////////////////////////////
 // quota format switch
 /*
  * Collect the requested quota information.
  */
 static struct quotalist *
 @@ -463,27 +478,28 @@ getprivs(long id, int defaultq, int idty
 	qlist = quotalist_create();
 	nfst = getmntinfo(&fst, MNT_WAIT);
 	if (nfst == 0)
 		errx(1, "no filesystems mounted!");
 	for (i = 0; i < nfst; i++) {
 		if ((fst[i].f_flag & ST_QUOTA) == 0)
 			continue;
 		if (filesys &&
 		    strcmp(fst[i].f_mntonname, filesys) != 0 &&
 		    strcmp(fst[i].f_mntfromname, filesys) != 0)
 			continue;
-		qup = getprivs2(id, idtype, fst[i].f_mntonname, defaultq);
+		qup = getprivs2(id, idtype, fst[i].f_mntonname, defaultq,
 				&qlist->idtypename);
 		if (qup == NULL) {
 			/*
 			 * XXX: returning NULL is totally wrong. On
 			 * serious error, abort; on minor error, warn
 			 * and continue.
+			 *
 			 * Note: we cannot warn unconditionally here
 			 * because this case apparently includes "no
 			 * quota entry on this volume" and that causes
 			 * the atf tests to fail. Bletch.
 			 */
 			/*return NULL;*/
 			/*warnx("getprivs2 failed");*/
 @@ -669,83 +685,81 @@ top:
 		if (sigprocmask(SIG_SETMASK, &os, NULL) == -1)
 			err(1, "sigprocmask");
 		if (!WIFEXITED(lst) || WEXITSTATUS(lst) != 0)
 			return 0;
 		return 1;
+	}
+}
 /*
  * Convert a quotause list to an ASCII file.
  */
 static int
 writeprivs(struct quotalist *qlist, int outfd, const char *name,
-    int idtype)
+    int idtype, const char *idtypename)
+{
 	struct quotause *qup;
 	FILE *fd;
 	char b0[32], b1[32], b2[32], b3[32];
 	(void)ftruncate(outfd, 0);
 	(void)lseek(outfd, (off_t)0, SEEK_SET);
 	if ((fd = fdopen(dup(outfd), "w")) == NULL)
 		errx(1, "fdopen");
 	if (name == NULL) {
-		fprintf(fd, "Default %s quotas:\n",
+		fprintf(fd, "Default %s quotas:\n", idtypename);
 		    ufs_quota_class_names[idtype]);
 	} else {
-		fprintf(fd, "Quotas for %s %s:\n",
+		fprintf(fd, "Quotas for %s %s:\n", idtypename, name);
 		    ufs_quota_class_names[idtype], name);
+	}
 	for (qup = qlist->head; qup; qup = qup->next) {
 		struct quotaval *q = qup->qv;
 		fprintf(fd, "%s (%s):\n",
 		     qup->fsname, qup->implementation);
 		if ((qup->flags & DEFAULT) == 0 || (qup->flags & XGRACE) != 0) {
 			fprintf(fd, "\tblocks in use: %s, "
 			    "limits (soft = %s, hard = %s",
-			    intprt(b1, 21, q[QL_BLK].qv_usage,
+			    intprt(b1, 21, q[QO_BLK].qv_usage,
 			    HN_NOSPACE | HN_B, Hflag),
-			    intprt(b2, 21, q[QL_BLK].qv_softlimit,
+			    intprt(b2, 21, q[QO_BLK].qv_softlimit,
 			    HN_NOSPACE | HN_B, Hflag),
-			    intprt(b3, 21, q[QL_BLK].qv_hardlimit,
+			    intprt(b3, 21, q[QO_BLK].qv_hardlimit,
 				HN_NOSPACE | HN_B, Hflag));
 			if (qup->flags & XGRACE)
 				fprintf(fd, ", ");
 		} else
 			fprintf(fd, "\tblocks: (");
 		if (qup->flags & (XGRACE|DEFAULT)) {
 		    fprintf(fd, "grace = %s",
-			timepprt(b0, 21, q[QL_BLK].qv_grace, Hflag));
+			timepprt(b0, 21, q[QO_BLK].qv_grace, Hflag));
+		}
 		fprintf(fd, ")\n");
 		if ((qup->flags & DEFAULT) == 0 || (qup->flags & XGRACE) != 0) {
 			fprintf(fd, "\tinodes in use: %s, "
 			    "limits (soft = %s, hard = %s",
-			    intprt(b1, 21, q[QL_FL].qv_usage,
+			    intprt(b1, 21, q[QO_FL].qv_usage,
 			    HN_NOSPACE, Hflag),
-			    intprt(b2, 21, q[QL_FL].qv_softlimit,
+			    intprt(b2, 21, q[QO_FL].qv_softlimit,
 			    HN_NOSPACE, Hflag),
-			    intprt(b3, 21, q[QL_FL].qv_hardlimit,
+			    intprt(b3, 21, q[QO_FL].qv_hardlimit,
 			     HN_NOSPACE, Hflag));
 			if (qup->flags & XGRACE)
 				fprintf(fd, ", ");
 		} else
 			fprintf(fd, "\tinodes: (");
 		if (qup->flags & (XGRACE|DEFAULT)) {
 		    fprintf(fd, "grace = %s",
-			timepprt(b0, 21, q[QL_FL].qv_grace, Hflag));
+			timepprt(b0, 21, q[QO_FL].qv_grace, Hflag));
+		}
 		fprintf(fd, ")\n");
+	}
 	fclose(fd);
 	return 1;
+}
 /*
  * Merge changes to an ASCII file into a quotause list.
  */
 static int
 readprivs(struct quotalist *qlist, int infd, int dflag)
+{
 @@ -910,108 +924,108 @@ readprivs(struct quotalist *qlist, int i
 			if (cnt == 4) {
 				if (timeprd(stime, &gracei) != 0) {
 					warnx("%s:%s: bad number", fsp, stime);
 					goto out;
+				}
+			}
+		}
 		for (qup = qlist->head; qup; qup = qup->next) {
 			struct quotaval *q = qup->qv;
 			char b1[32], b2[32];
 			if (strcmp(fsp, qup->fsname))
 				continue;
 			if (version == 1 && dflag) {
-				q[QL_BLK].qv_grace = graceb;
+				q[QO_BLK].qv_grace = graceb;
-				q[QL_FL].qv_grace = gracei;
+				q[QO_FL].qv_grace = gracei;
 				qup->flags |= FOUND;
 				continue;
+			}
-			if (strcmp(intprt(b1, 21, q[QL_BLK].qv_usage,
+			if (strcmp(intprt(b1, 21, q[QO_BLK].qv_usage,
 			    HN_NOSPACE | HN_B, Hflag),
 			    scurb) != 0 ||
-			    strcmp(intprt(b2, 21, q[QL_FL].qv_usage,
+			    strcmp(intprt(b2, 21, q[QO_FL].qv_usage,
 			    HN_NOSPACE, Hflag),
 			    scuri) != 0) {
 				warnx("%s: cannot change current allocation",
 				    fsp);
 				break;
+			}
 			/*
 			 * Cause time limit to be reset when the quota
 			 * is next used if previously had no soft limit
 			 * or were under it, but now have a soft limit
 			 * and are over it.
 			 */
-			if (q[QL_BLK].qv_usage &&
+			if (q[QO_BLK].qv_usage &&
-			    q[QL_BLK].qv_usage >= softb &&
+			    q[QO_BLK].qv_usage >= softb &&
-			    (q[QL_BLK].qv_softlimit == 0 ||
+			    (q[QO_BLK].qv_softlimit == 0 ||
-			     q[QL_BLK].qv_usage < q[QL_BLK].qv_softlimit))
+			     q[QO_BLK].qv_usage < q[QO_BLK].qv_softlimit))
-				q[QL_BLK].qv_expiretime = 0;
+				q[QO_BLK].qv_expiretime = 0;
-			if (q[QL_FL].qv_usage &&
+			if (q[QO_FL].qv_usage &&
-			    q[QL_FL].qv_usage >= softi &&
+			    q[QO_FL].qv_usage >= softi &&
-			    (q[QL_FL].qv_softlimit == 0 ||
+			    (q[QO_FL].qv_softlimit == 0 ||
-			     q[QL_FL].qv_usage < q[QL_FL].qv_softlimit))
+			     q[QO_FL].qv_usage < q[QO_FL].qv_softlimit))
-				q[QL_FL].qv_expiretime = 0;
+				q[QO_FL].qv_expiretime = 0;
-			q[QL_BLK].qv_softlimit = softb;
+			q[QO_BLK].qv_softlimit = softb;
-			q[QL_BLK].qv_hardlimit = hardb;
+			q[QO_BLK].qv_hardlimit = hardb;
 			if (version == 2)
-				q[QL_BLK].qv_grace = graceb;
+				q[QO_BLK].qv_grace = graceb;
-			q[QL_FL].qv_softlimit  = softi;
+			q[QO_FL].qv_softlimit  = softi;
-			q[QL_FL].qv_hardlimit  = hardi;
+			q[QO_FL].qv_hardlimit  = hardi;
 			if (version == 2)
-				q[QL_FL].qv_grace = gracei;
+				q[QO_FL].qv_grace = gracei;
 			qup->flags |= FOUND;
+		}
+	}
 out:
 	fclose(fd);
 	/*
 	 * Disable quotas for any filesystems that have not been found.
 	 */
 	for (qup = qlist->head; qup; qup = qup->next) {
 		struct quotaval *q = qup->qv;
 		if (qup->flags & FOUND) {
 			qup->flags &= ~FOUND;
 			continue;
+		}
-		q[QL_BLK].qv_softlimit = UQUAD_MAX;
+		q[QO_BLK].qv_softlimit = UQUAD_MAX;
-		q[QL_BLK].qv_hardlimit = UQUAD_MAX;
+		q[QO_BLK].qv_hardlimit = UQUAD_MAX;
-		q[QL_BLK].qv_grace = 0;
+		q[QO_BLK].qv_grace = 0;
-		q[QL_FL].qv_softlimit = UQUAD_MAX;
+		q[QO_FL].qv_softlimit = UQUAD_MAX;
-		q[QL_FL].qv_hardlimit = UQUAD_MAX;
+		q[QO_FL].qv_hardlimit = UQUAD_MAX;
-		q[QL_FL].qv_grace = 0;
+		q[QO_FL].qv_grace = 0;
+	}
 	return 1;
+}
 ////////////////////////////////////////////////////////////
 // actions
 static void
 replicate(const char *fs, int idtype, const char *protoname,
 	  char **names, int numnames)
+{
 	long protoid, id;
 	struct quotalist *protoprivs;
 	struct quotause *qup;
 	int i;
 	if ((protoid = getidbyname(protoname, idtype)) == -1)
 		exit(1);
 	protoprivs = getprivs(protoid, 0, idtype, fs);
 	for (qup = protoprivs->head; qup; qup = qup->next) {
-		qup->qv[QL_BLK].qv_expiretime = 0;
+		qup->qv[QO_BLK].qv_expiretime = 0;
-		qup->qv[QL_FL].qv_expiretime = 0;
+		qup->qv[QO_FL].qv_expiretime = 0;
+	}
 	for (i=0; i<numnames; i++) {
 		id = getidbyname(names[i], idtype);
 		if (id == -1)
 			continue;
 		putprivs(id, idtype, protoprivs);
+	}
 	/* XXX */
 	/* quotalist_destroy(protoprivs); */
+}
 static void
 assign(const char *fs, int idtype,
 @@ -1063,47 +1077,47 @@ assign(const char *fs, int idtype,
 			dflag = 1;
 		} else {
 			id = getidbyname(names[i], idtype);
 			if (id == -1)
 				continue;
 			dflag = 0;
+		}
 		curprivs = getprivs(id, dflag, idtype, fs);
 		for (lqup = curprivs->head; lqup; lqup = lqup->next) {
 			struct quotaval *q = lqup->qv;
 			if (soft) {
 				if (!dflag && softb &&
-				    q[QL_BLK].qv_usage >= softb &&
+				    q[QO_BLK].qv_usage >= softb &&
-				    (q[QL_BLK].qv_softlimit == 0 ||
+				    (q[QO_BLK].qv_softlimit == 0 ||
-				     q[QL_BLK].qv_usage <
+				     q[QO_BLK].qv_usage <
-				     q[QL_BLK].qv_softlimit))
+				     q[QO_BLK].qv_softlimit))
-					q[QL_BLK].qv_expiretime = 0;
+					q[QO_BLK].qv_expiretime = 0;
 				if (!dflag && softi &&
-				    q[QL_FL].qv_usage >= softb &&
+				    q[QO_FL].qv_usage >= softb &&
-				    (q[QL_FL].qv_softlimit == 0 ||
+				    (q[QO_FL].qv_softlimit == 0 ||
-				     q[QL_FL].qv_usage <
+				     q[QO_FL].qv_usage <
-				     q[QL_FL].qv_softlimit))
+				     q[QO_FL].qv_softlimit))
-					q[QL_FL].qv_expiretime = 0;
+					q[QO_FL].qv_expiretime = 0;
-				q[QL_BLK].qv_softlimit = softb;
+				q[QO_BLK].qv_softlimit = softb;
-				q[QL_FL].qv_softlimit = softi;
+				q[QO_FL].qv_softlimit = softi;
+			}
 			if (hard) {
-				q[QL_BLK].qv_hardlimit = hardb;
+				q[QO_BLK].qv_hardlimit = hardb;
-				q[QL_FL].qv_hardlimit = hardi;
+				q[QO_FL].qv_hardlimit = hardi;
+			}
 			if (grace) {
-				q[QL_BLK].qv_grace = graceb;
+				q[QO_BLK].qv_grace = graceb;
-				q[QL_FL].qv_grace = gracei;
+				q[QO_FL].qv_grace = gracei;
+			}
+		}
 		putprivs(id, idtype, curprivs);
 		quotalist_destroy(curprivs);
+	}
+}
 static void
 clear(const char *fs, int idtype, char **names, int numnames)
+{
 	clearpriv(numnames, names, fs, idtype);
+}
 @@ -1116,27 +1130,28 @@ editone(const char *fs, int idtype, cons
 	int dflag;
 	if (name == NULL) {
 		id = 0;
 		dflag = 1;
 	} else {
 		id = getidbyname(name, idtype);
 		if (id == -1)
 			return;
 		dflag = 0;
+	}
 	curprivs = getprivs(id, dflag, idtype, fs);
-	if (writeprivs(curprivs, tmpfd, name, idtype) == 0)
+	if (writeprivs(curprivs, tmpfd, name, idtype,
 		       curprivs->idtypename) == 0)
 		goto fail;
 	if (editit(tmppath) == 0)
 		goto fail;
 	if (readprivs(curprivs, tmpfd, dflag) == 0)
 		goto fail;
 	putprivs(id, idtype, curprivs);
 fail:
 	quotalist_destroy(curprivs);
+}

 @@ -1,20 +1,18 @@
 #	from: @(#)Makefile	8.1 (Berkeley) 6/6/93
-#	$NetBSD: Makefile,v 1.9 2012/01/30 19:16:36 dholland Exp $
+#	$NetBSD: Makefile,v 1.10 2012/01/30 19:19:20 dholland Exp $
 .include <bsd.own.mk>
 WARNS ?= 4
 PROG=	edquota
 SRCS=	edquota.c
 MAN=	edquota.8
 CPPFLAGS+=-I${NETBSDSRCDIR}/sys -I${NETBSDSRCDIR}/usr.bin/quota
 DPADD=	${LIBQUOTA} ${LIBPROP} ${LIBRPCSVC}
 LDADD=	-lquota -lprop -lrpcsvc
 .PATH:	${NETBSDSRCDIR}/usr.bin/quota
-SRCS+=	printquota.c quotautil.c
+SRCS+=	printquota.c
 .PATH:	${NETBSDSRCDIR}/sys/ufs/ufs
 SRCS+=	quota1_subr.c
 .include <bsd.prog.mk>