[unix-history] / usr / src / usr.bin / quota / quota.c

/*
 * Copyright (c) 1980 Regents of the University of California.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms are permitted
 * provided that the above copyright notice and this paragraph are
 * duplicated in all such forms and that any documentation,
 * advertising materials, and other materials related to such
 * distribution and use acknowledge that the software was developed
 * by the University of California, Berkeley.  The name of the
 * University may not be used to endorse or promote products derived
 * from this software without specific prior written permission.
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
 * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 */

#ifndef lint
char copyright[] =
"@(#) Copyright (c) 1980 Regents of the University of California.\n\
 All rights reserved.\n";
#endif /* not lint */

#ifndef lint
static char sccsid[] = "@(#)quota.c	5.6 (Berkeley) %G%";
#endif /* not lint */

/*
 * Disk quota reporting program.
 */
#include <stdio.h>
#include <fstab.h>
#include <ctype.h>
#include <pwd.h>
#include <errno.h>

#include <sys/param.h>
#include <sys/quota.h>
#include <sys/file.h>
#include <sys/stat.h>

int	qflag;
int	vflag;
int	done;
int	morethanone;
char	*qfname = "quotas";

main(argc, argv)
	char *argv[];
{
	register char *cp;
	extern int errno;

	if (quota(Q_SYNC, 0, 0, (caddr_t)0) < 0 && errno == EINVAL) {
		fprintf(stderr, "There are no quotas on this system\n");
		exit(0);
	}
	argc--,argv++;
	while (argc > 0) {
		if (argv[0][0] == '-')
			for (cp = &argv[0][1]; *cp; cp++) switch (*cp) {

			case 'v':
				vflag++;
				break;

			case 'q':
				qflag++;
				break;

			default:
				fprintf(stderr, "quota: %c: unknown option\n",
					*cp);
				exit(1);
			}
		else
			break;
		argc--, argv++;
	}
	morethanone = argc > 1;
	if (argc == 0) {
		showuid(getuid());
		exit(0);
	}
	for (; argc > 0; argc--, argv++) {
		if (alldigits(*argv))
			showuid(atoi(*argv));
		else
			showname(*argv);
	}
}

showuid(uid)
	int uid;
{
	struct passwd *pwd = getpwuid(uid);

	if (pwd == NULL)
		showquotas(uid, "(no account)");
	else
		showquotas(uid, pwd->pw_name);
}

showname(name)
	char *name;
{
	struct passwd *pwd = getpwnam(name);

	if (pwd == NULL) {
		fprintf(stderr, "quota: %s: unknown user\n", name);
		return;
	}
	showquotas(pwd->pw_uid, name);
}

showquotas(uid, name)
	int uid;
	char *name;
{
	register struct fstab *fs;
	register char *msgi, *msgb;
	register enab = 1;
	dev_t	fsdev;
	struct	stat statb;
	struct	dqblk dqblk;
	int myuid, fd;
	char qfilename[MAXPATHLEN + 1], iwarn[8], dwarn[8];

	myuid = getuid();
	if (uid != myuid && myuid != 0) {
		printf("quota: %s (uid %d): permission denied\n", name, uid);
		return;
	}
	done = 0;
	(void) setfsent();
	while (fs = getfsent()) {
		if (stat(fs->fs_spec, &statb) < 0)
			continue;
		msgi = msgb = (char *) 0;
		fsdev = statb.st_rdev;
		(void) sprintf(qfilename, "%s/%s", fs->fs_file, qfname);
		if (stat(qfilename, &statb) < 0 || statb.st_dev != fsdev)
			continue;
		if (quota(Q_GETDLIM, uid, fsdev, (caddr_t)&dqblk) != 0) {
			fd = open(qfilename, O_RDONLY);
			if (fd < 0)
				continue;
			(void) lseek(fd, (off_t)(uid * sizeof (dqblk)), L_SET);
			switch (read(fd, (char *)&dqblk, sizeof dqblk)) {
			case 0:			/* EOF */
				/*
				 * Convert implicit 0 quota (EOF)
				 * into an explicit one (zero'ed dqblk).
				 */
				bzero((caddr_t)&dqblk, sizeof dqblk);
				break;

			case sizeof dqblk:	/* OK */
				break;

			default:		/* ERROR */
				fprintf(stderr, "quota: read error in ");
				perror(qfilename);
				(void) close(fd);
				continue;
			}
			(void) close(fd);
			if (!vflag && dqblk.dqb_isoftlimit == 0 &&
			    dqblk.dqb_bsoftlimit == 0)
				continue;
			enab = 0;
		}
		if (dqblk.dqb_ihardlimit &&
		    dqblk.dqb_curinodes >= dqblk.dqb_ihardlimit)
			msgi = "File count limit reached on %s";
		else if (enab && dqblk.dqb_iwarn == 0)
			msgi = "Out of inode warnings on %s";
		else if (dqblk.dqb_isoftlimit &&
		    dqblk.dqb_curinodes >= dqblk.dqb_isoftlimit)
			msgi = "Too many files on %s";
		if (dqblk.dqb_bhardlimit &&
		    dqblk.dqb_curblocks >= dqblk.dqb_bhardlimit)
			msgb = "Block limit reached on %s";
		else if (enab && dqblk.dqb_bwarn == 0)
			msgb = "Out of block warnings on %s";
		else if (dqblk.dqb_bsoftlimit &&
		    dqblk.dqb_curblocks >= dqblk.dqb_bsoftlimit)
			msgb = "Over disc quota on %s";
		if (dqblk.dqb_iwarn < MAX_IQ_WARN)
			(void) sprintf(iwarn, "%d", dqblk.dqb_iwarn);
		else
			iwarn[0] = '\0';
		if (dqblk.dqb_bwarn < MAX_DQ_WARN)
			(void) sprintf(dwarn, "%d", dqblk.dqb_bwarn);
		else
			dwarn[0] = '\0';
		if (qflag) {
			if (msgi != (char *)0 || msgb != (char *)0)
				heading(uid, name);
			if (msgi != (char *)0)
				xprintf(msgi, fs->fs_file);
			if (msgb != (char *)0)
				xprintf(msgb, fs->fs_file);
			continue;
		}
		if (vflag || dqblk.dqb_curblocks || dqblk.dqb_curinodes) {
			heading(uid, name);
			printf("%10s%8d%c%7d%8d%8s%8d%c%7d%8d%8s\n"
				, fs->fs_file
				, dbtob(dqblk.dqb_curblocks) / 1024
				, (msgb == (char *)0) ? ' ' : '*'
				, dbtob(dqblk.dqb_bsoftlimit) / 1024
				, dbtob(dqblk.dqb_bhardlimit) / 1024
				, dwarn
				, dqblk.dqb_curinodes
				, (msgi == (char *)0) ? ' ' : '*'
				, dqblk.dqb_isoftlimit
				, dqblk.dqb_ihardlimit
				, iwarn
			);
		}
	}
	(void) endfsent();
	if (!done && !qflag) {
		if (morethanone)
			(void) putchar('\n');
		xprintf("Disc quotas for %s (uid %d):", name, uid);
		xprintf("none.");
	}
	xprintf((char *)0);
}

heading(uid, name)
	int uid;
	char *name;
{

	if (done++)
		return;
	xprintf((char *)0);
	if (qflag) {
		if (!morethanone)
			return;
		xprintf("User %s (uid %d):", name, uid);
		xprintf((char *)0);
		return;
	}
	(void) putchar('\n');
	xprintf("Disc quotas for %s (uid %d):", name, uid);
	xprintf((char *)0);
	printf("%10s%8s %7s%8s%8s%8s %7s%8s%8s\n"
		, "Filsys"
		, "current"
		, "quota"
		, "limit"
		, "#warns"
		, "files"
		, "quota"
		, "limit"
		, "#warns"
	);
}

/*VARARGS1*/
xprintf(fmt, arg1, arg2, arg3, arg4, arg5, arg6)
	char *fmt;
{
	char	buf[100];
	static int column;

	if (fmt == 0 && column || column >= 40) {
		(void) putchar('\n');
		column = 0;
	}
	if (fmt == 0)
		return;
	(void) sprintf(buf, fmt, arg1, arg2, arg3, arg4, arg5, arg6);
	if (column != 0 && strlen(buf) < 39)
		while (column++ < 40)
			(void) putchar(' ');
	else if (column) {
		(void) putchar('\n');
		column = 0;
	}
	printf("%s", buf);
	column += strlen(buf);
}

alldigits(s)
	register char *s;
{
	register c;

	c = *s++;
	do {
		if (!isdigit(c))
			return (0);
	} while (c = *s++);
	return (1);
}
Commit	Line	Data
2a18434a KM	1	/*
2a18434a KM	2	* Copyright (c) 1980 Regents of the University of California.
f9ac90b4 KB	3	* All rights reserved.
	4	*
	5	* Redistribution and use in source and binary forms are permitted
5e8b0e60 KB	6	* provided that the above copyright notice and this paragraph are
	7	* duplicated in all such forms and that any documentation,
	8	* advertising materials, and other materials related to such
	9	* distribution and use acknowledge that the software was developed
	10	* by the University of California, Berkeley. The name of the
	11	* University may not be used to endorse or promote products derived
	12	* from this software without specific prior written permission.
	13	* THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
	14	* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
	15	* WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
2a18434a KM	16	*/
	17
	18	#ifndef lint
	19	char copyright[] =
	20	"@(#) Copyright (c) 1980 Regents of the University of California.\n\
	21	All rights reserved.\n";
f9ac90b4	22	#endif /* not lint */
2a18434a	23
304d49a2	24	#ifndef lint
5e8b0e60	25	static char sccsid[] = "@(#)quota.c 5.6 (Berkeley) %G%";
f9ac90b4	26	#endif /* not lint */
304d49a2 KM	27
	28	/*
	29	* Disk quota reporting program.
	30	*/
	31	#include <stdio.h>
	32	#include <fstab.h>
	33	#include <ctype.h>
	34	#include <pwd.h>
879c30d3	35	#include <errno.h>
304d49a2 KM	36
304d49a2 KM	37	#include <sys/param.h>
304d49a2 KM	38	#include <sys/quota.h>
	39	#include <sys/file.h>
	40	#include <sys/stat.h>
	41
	42	int qflag;
	43	int vflag;
	44	int done;
	45	int morethanone;
a233b96c	46	char *qfname = "quotas";
304d49a2 KM	47
	48	main(argc, argv)
	49	char *argv[];
	50	{
	51	register char *cp;
879c30d3	52	extern int errno;
304d49a2	53
509d661f	54	if (quota(Q_SYNC, 0, 0, (caddr_t)0) < 0 && errno == EINVAL) {
879c30d3 KM	55	fprintf(stderr, "There are no quotas on this system\n");
	56	exit(0);
	57	}
304d49a2 KM	58	argc--,argv++;
	59	while (argc > 0) {
	60	if (argv[0][0] == '-')
	61	for (cp = &argv[0][1]; cp; cp++) switch (cp) {
	62
	63	case 'v':
	64	vflag++;
	65	break;
	66
	67	case 'q':
	68	qflag++;
	69	break;
	70
	71	default:
	72	fprintf(stderr, "quota: %c: unknown option\n",
	73	*cp);
	74	exit(1);
	75	}
	76	else
	77	break;
	78	argc--, argv++;
	79	}
	80	morethanone = argc > 1;
	81	if (argc == 0) {
	82	showuid(getuid());
	83	exit(0);
	84	}
	85	for (; argc > 0; argc--, argv++) {
	86	if (alldigits(*argv))
	87	showuid(atoi(*argv));
	88	else
	89	showname(*argv);
	90	}
	91	}
	92
	93	showuid(uid)
	94	int uid;
	95	{
	96	struct passwd *pwd = getpwuid(uid);
	97
	98	if (pwd == NULL)
	99	showquotas(uid, "(no account)");
	100	else
	101	showquotas(uid, pwd->pw_name);
	102	}
	103
	104	showname(name)
	105	char *name;
	106	{
	107	struct passwd *pwd = getpwnam(name);
	108
	109	if (pwd == NULL) {
	110	fprintf(stderr, "quota: %s: unknown user\n", name);
	111	return;
	112	}
	113	showquotas(pwd->pw_uid, name);
	114	}
	115
	116	showquotas(uid, name)
	117	int uid;
	118	char *name;
	119	{
304d49a2	120	register struct fstab *fs;
509d661f	121	register char msgi, msgb;
879c30d3 KM	122	register enab = 1;
	123	dev_t fsdev;
	124	struct stat statb;
	125	struct dqblk dqblk;
	126	int myuid, fd;
	127	char qfilename[MAXPATHLEN + 1], iwarn[8], dwarn[8];
304d49a2 KM	128
	129	myuid = getuid();
	130	if (uid != myuid && myuid != 0) {
	131	printf("quota: %s (uid %d): permission denied\n", name, uid);
	132	return;
	133	}
	134	done = 0;
509d661f	135	(void) setfsent();
304d49a2	136	while (fs = getfsent()) {
304d49a2 KM	137	if (stat(fs->fs_spec, &statb) < 0)
304d49a2 KM	138	continue;
509d661f	139	msgi = msgb = (char *) 0;
304d49a2	140	fsdev = statb.st_rdev;
a233b96c KM	141	(void) sprintf(qfilename, "%s/%s", fs->fs_file, qfname);
a233b96c KM	142	if (stat(qfilename, &statb) < 0 \|\| statb.st_dev != fsdev)
304d49a2	143	continue;
509d661f	144	if (quota(Q_GETDLIM, uid, fsdev, (caddr_t)&dqblk) != 0) {
879c30d3	145	fd = open(qfilename, O_RDONLY);
304d49a2 KM	146	if (fd < 0)
304d49a2 KM	147	continue;
509d661f JL	148	(void) lseek(fd, (off_t)(uid * sizeof (dqblk)), L_SET);
509d661f JL	149	switch (read(fd, (char *)&dqblk, sizeof dqblk)) {
605f81f3 S	150	case 0: /* EOF */
	151	/*
	152	* Convert implicit 0 quota (EOF)
	153	* into an explicit one (zero'ed dqblk).
	154	*/
	155	bzero((caddr_t)&dqblk, sizeof dqblk);
	156	break;
	157
	158	case sizeof dqblk: /* OK */
	159	break;
	160
	161	default: /* ERROR */
	162	fprintf(stderr, "quota: read error in ");
	163	perror(qfilename);
509d661f	164	(void) close(fd);
304d49a2 KM	165	continue;
304d49a2 KM	166	}
509d661f	167	(void) close(fd);
605f81f3	168	if (!vflag && dqblk.dqb_isoftlimit == 0 &&
304d49a2 KM	169	dqblk.dqb_bsoftlimit == 0)
	170	continue;
	171	enab = 0;
	172	}
	173	if (dqblk.dqb_ihardlimit &&
	174	dqblk.dqb_curinodes >= dqblk.dqb_ihardlimit)
	175	msgi = "File count limit reached on %s";
	176	else if (enab && dqblk.dqb_iwarn == 0)
	177	msgi = "Out of inode warnings on %s";
	178	else if (dqblk.dqb_isoftlimit &&
	179	dqblk.dqb_curinodes >= dqblk.dqb_isoftlimit)
	180	msgi = "Too many files on %s";
	181	if (dqblk.dqb_bhardlimit &&
	182	dqblk.dqb_curblocks >= dqblk.dqb_bhardlimit)
	183	msgb = "Block limit reached on %s";
	184	else if (enab && dqblk.dqb_bwarn == 0)
	185	msgb = "Out of block warnings on %s";
	186	else if (dqblk.dqb_bsoftlimit &&
	187	dqblk.dqb_curblocks >= dqblk.dqb_bsoftlimit)
	188	msgb = "Over disc quota on %s";
	189	if (dqblk.dqb_iwarn < MAX_IQ_WARN)
509d661f	190	(void) sprintf(iwarn, "%d", dqblk.dqb_iwarn);
304d49a2 KM	191	else
	192	iwarn[0] = '\0';
	193	if (dqblk.dqb_bwarn < MAX_DQ_WARN)
509d661f	194	(void) sprintf(dwarn, "%d", dqblk.dqb_bwarn);
304d49a2 KM	195	else
	196	dwarn[0] = '\0';
	197	if (qflag) {
	198	if (msgi != (char )0 \|\| msgb != (char )0)
	199	heading(uid, name);
	200	if (msgi != (char *)0)
	201	xprintf(msgi, fs->fs_file);
	202	if (msgb != (char *)0)
	203	xprintf(msgb, fs->fs_file);
	204	continue;
	205	}
	206	if (vflag \|\| dqblk.dqb_curblocks \|\| dqblk.dqb_curinodes) {
	207	heading(uid, name);
c085c6e0	208	printf("%10s%8d%c%7d%8d%8s%8d%c%7d%8d%8s\n"
304d49a2	209	, fs->fs_file
285a6d40	210	, dbtob(dqblk.dqb_curblocks) / 1024
304d49a2	211	, (msgb == (char )0) ? ' ' : ''
285a6d40 JB	212	, dbtob(dqblk.dqb_bsoftlimit) / 1024
285a6d40 JB	213	, dbtob(dqblk.dqb_bhardlimit) / 1024
304d49a2 KM	214	, dwarn
	215	, dqblk.dqb_curinodes
	216	, (msgi == (char )0) ? ' ' : ''
	217	, dqblk.dqb_isoftlimit
96b539f0	218	, dqblk.dqb_ihardlimit
304d49a2 KM	219	, iwarn
	220	);
	221	}
	222	}
509d661f	223	(void) endfsent();
304d49a2 KM	224	if (!done && !qflag) {
304d49a2 KM	225	if (morethanone)
509d661f	226	(void) putchar('\n');
304d49a2 KM	227	xprintf("Disc quotas for %s (uid %d):", name, uid);
	228	xprintf("none.");
	229	}
605f81f3	230	xprintf((char *)0);
304d49a2 KM	231	}
	232
	233	heading(uid, name)
	234	int uid;
	235	char *name;
	236	{
	237
	238	if (done++)
	239	return;
605f81f3	240	xprintf((char *)0);
304d49a2 KM	241	if (qflag) {
	242	if (!morethanone)
	243	return;
	244	xprintf("User %s (uid %d):", name, uid);
605f81f3	245	xprintf((char *)0);
304d49a2 KM	246	return;
304d49a2 KM	247	}
509d661f	248	(void) putchar('\n');
304d49a2	249	xprintf("Disc quotas for %s (uid %d):", name, uid);
605f81f3	250	xprintf((char *)0);
c085c6e0	251	printf("%10s%8s %7s%8s%8s%8s %7s%8s%8s\n"
304d49a2 KM	252	, "Filsys"
	253	, "current"
	254	, "quota"
	255	, "limit"
	256	, "#warns"
	257	, "files"
	258	, "quota"
	259	, "limit"
	260	, "#warns"
	261	);
	262	}
	263
605f81f3	264	/VARARGS1/
304d49a2 KM	265	xprintf(fmt, arg1, arg2, arg3, arg4, arg5, arg6)
	266	char *fmt;
	267	{
	268	char buf[100];
	269	static int column;
	270
	271	if (fmt == 0 && column \|\| column >= 40) {
509d661f	272	(void) putchar('\n');
304d49a2 KM	273	column = 0;
	274	}
	275	if (fmt == 0)
	276	return;
509d661f	277	(void) sprintf(buf, fmt, arg1, arg2, arg3, arg4, arg5, arg6);
304d49a2 KM	278	if (column != 0 && strlen(buf) < 39)
304d49a2 KM	279	while (column++ < 40)
509d661f	280	(void) putchar(' ');
304d49a2	281	else if (column) {
509d661f	282	(void) putchar('\n');
304d49a2 KM	283	column = 0;
	284	}
	285	printf("%s", buf);
	286	column += strlen(buf);
	287	}
	288
	289	alldigits(s)
	290	register char *s;
	291	{
	292	register c;
	293
	294	c = *s++;
	295	do {
	296	if (!isdigit(c))
	297	return (0);
	298	} while (c = *s++);
	299	return (1);
	300	}