repquota.c revision 36993 
1/*
2 * Copyright (c) 1980, 1990, 1993
3 *	The Regents of the University of California.  All rights reserved.
4 *
5 * This code is derived from software contributed to Berkeley by
6 * Robert Elz at The University of Melbourne.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 * 1. Redistributions of source code must retain the above copyright
12 *    notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 *    notice, this list of conditions and the following disclaimer in the
15 *    documentation and/or other materials provided with the distribution.
16 * 3. All advertising materials mentioning features or use of this software
17 *    must display the following acknowledgement:
18 *	This product includes software developed by the University of
19 *	California, Berkeley and its contributors.
20 * 4. Neither the name of the University nor the names of its contributors
21 *    may be used to endorse or promote products derived from this software
22 *    without specific prior written permission.
23 *
24 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
25 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
28 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
29 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
30 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
31 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
33 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34 * SUCH DAMAGE.
35 */
36
37#ifndef lint
38static const char copyright[] =
39"@(#) Copyright (c) 1980, 1990, 1993\n\
40	The Regents of the University of California.  All rights reserved.\n";
41#endif /* not lint */
42
43#ifndef lint
44#if 0
45static char sccsid[] = "@(#)repquota.c	8.1 (Berkeley) 6/6/93";
46#endif
47static const char rcsid[] =
48	"$Id: repquota.c,v 1.5 1997/10/13 11:05:07 charnier Exp $";
49#endif /* not lint */
50
51/*
52 * Quota report
53 */
54#include <sys/param.h>
55#include <sys/stat.h>
56#include <ufs/ufs/quota.h>
57#include <err.h>
58#include <errno.h>
59#include <fstab.h>
60#include <grp.h>
61#include <pwd.h>
62#include <stdio.h>
63#include <stdlib.h>
64#include <string.h>
65#include <unistd.h>
66#include <utmp.h>
67
68#define max(a,b) ((a) >= (b) ? (a) : (b))
69
70char *qfname = QUOTAFILENAME;
71char *qfextension[] = INITQFNAMES;
72
73struct fileusage {
74	struct	fileusage *fu_next;
75	struct	dqblk fu_dqblk;
76	u_long	fu_id;
77	char	fu_name[1];
78	/* actually bigger */
79};
80#define FUHASH 1024	/* must be power of two */
81struct fileusage *fuhead[MAXQUOTAS][FUHASH];
82struct fileusage *lookup();
83struct fileusage *addid();
84u_long highid[MAXQUOTAS];	/* highest addid()'ed identifier per type */
85
86int	vflag;			/* verbose */
87int	aflag;			/* all file systems */
88
89int hasquota __P((struct fstab *, int, char **));
90int oneof __P((char *, char *[], int));
91int repquota __P((struct fstab *, int, char *));
92char *timeprt __P((time_t));
93static void usage __P((void));
94
95int
96main(argc, argv)
97	int argc;
98	char **argv;
99{
100	register struct fstab *fs;
101	register struct passwd *pw;
102	register struct group *gr;
103	int gflag = 0, uflag = 0, errs = 0;
104	long i, argnum, done = 0;
105	char ch, *qfnp;
106
107	while ((ch = getopt(argc, argv, "aguv")) != -1) {
108		switch(ch) {
109		case 'a':
110			aflag++;
111			break;
112		case 'g':
113			gflag++;
114			break;
115		case 'u':
116			uflag++;
117			break;
118		case 'v':
119			vflag++;
120			break;
121		default:
122			usage();
123		}
124	}
125	argc -= optind;
126	argv += optind;
127	if (argc == 0 && !aflag)
128		usage();
129	if (!gflag && !uflag) {
130		if (aflag)
131			gflag++;
132		uflag++;
133	}
134	if (gflag) {
135		setgrent();
136		while ((gr = getgrent()) != 0)
137			(void) addid((u_long)gr->gr_gid, GRPQUOTA, gr->gr_name);
138		endgrent();
139	}
140	if (uflag) {
141		setpwent();
142		while ((pw = getpwent()) != 0)
143			(void) addid((u_long)pw->pw_uid, USRQUOTA, pw->pw_name);
144		endpwent();
145	}
146	setfsent();
147	while ((fs = getfsent()) != NULL) {
148		if (strcmp(fs->fs_vfstype, "ufs"))
149			continue;
150		if (aflag) {
151			if (gflag && hasquota(fs, GRPQUOTA, &qfnp))
152				errs += repquota(fs, GRPQUOTA, qfnp);
153			if (uflag && hasquota(fs, USRQUOTA, &qfnp))
154				errs += repquota(fs, USRQUOTA, qfnp);
155			continue;
156		}
157		if ((argnum = oneof(fs->fs_file, argv, argc)) >= 0 ||
158		    (argnum = oneof(fs->fs_spec, argv, argc)) >= 0) {
159			done |= 1 << argnum;
160			if (gflag && hasquota(fs, GRPQUOTA, &qfnp))
161				errs += repquota(fs, GRPQUOTA, qfnp);
162			if (uflag && hasquota(fs, USRQUOTA, &qfnp))
163				errs += repquota(fs, USRQUOTA, qfnp);
164		}
165	}
166	endfsent();
167	for (i = 0; i < argc; i++)
168		if ((done & (1 << i)) == 0)
169			warnx("%s not found in fstab", argv[i]);
170	exit(errs);
171}
172
173static void
174usage()
175{
176	fprintf(stderr, "%s\n%s\n",
177		"usage: repquota [-v] [-g] [-u] -a",
178		"       repquota [-v] [-g] [-u] filesystem ...");
179	exit(1);
180}
181
182int
183repquota(fs, type, qfpathname)
184	register struct fstab *fs;
185	int type;
186	char *qfpathname;
187{
188	register struct fileusage *fup;
189	FILE *qf;
190	u_long id;
191	struct dqblk dqbuf;
192	static struct dqblk zerodqblk;
193	static int warned = 0;
194	static int multiple = 0;
195
196	if (quotactl(fs->fs_file, QCMD(Q_SYNC, type), 0, 0) < 0 &&
197	    errno == EOPNOTSUPP && !warned && vflag) {
198		warned++;
199		fprintf(stdout,
200		    "*** Warning: Quotas are not compiled into this kernel\n");
201	}
202	if (multiple++)
203		printf("\n");
204	if (vflag)
205		fprintf(stdout, "*** Report for %s quotas on %s (%s)\n",
206		    qfextension[type], fs->fs_file, fs->fs_spec);
207	if ((qf = fopen(qfpathname, "r")) == NULL) {
208		warn("%s", qfpathname);
209		return (1);
210	}
211	for (id = 0; ; id++) {
212		fread(&dqbuf, sizeof(struct dqblk), 1, qf);
213		if (feof(qf))
214			break;
215		if (dqbuf.dqb_curinodes == 0 && dqbuf.dqb_curblocks == 0)
216			continue;
217		if ((fup = lookup(id, type)) == 0)
218			fup = addid(id, type, (char *)0);
219		fup->fu_dqblk = dqbuf;
220	}
221	fclose(qf);
222	printf("%*s              Block limits                 File limits\n",
223		max(UT_NAMESIZE,10), " ");
224	printf("User%*s  used    soft    hard  grace    used  soft  hard  grace\n",
225		max(UT_NAMESIZE,10), " ");
226	for (id = 0; id <= highid[type]; id++) {
227		fup = lookup(id, type);
228		if (fup == 0)
229			continue;
230		if (fup->fu_dqblk.dqb_curinodes == 0 &&
231		    fup->fu_dqblk.dqb_curblocks == 0)
232			continue;
233		printf("%-*s", max(UT_NAMESIZE,10), fup->fu_name);
234		printf("%c%c%8lu%8lu%8lu%7s",
235			fup->fu_dqblk.dqb_bsoftlimit &&
236			    fup->fu_dqblk.dqb_curblocks >=
237			    fup->fu_dqblk.dqb_bsoftlimit ? '+' : '-',
238			fup->fu_dqblk.dqb_isoftlimit &&
239			    fup->fu_dqblk.dqb_curinodes >=
240			    fup->fu_dqblk.dqb_isoftlimit ? '+' : '-',
241			(u_long)(dbtob(fup->fu_dqblk.dqb_curblocks) / 1024),
242			(u_long)(dbtob(fup->fu_dqblk.dqb_bsoftlimit) / 1024),
243			(u_long)(dbtob(fup->fu_dqblk.dqb_bhardlimit) / 1024),
244			fup->fu_dqblk.dqb_bsoftlimit &&
245			    fup->fu_dqblk.dqb_curblocks >=
246			    fup->fu_dqblk.dqb_bsoftlimit ?
247			    timeprt(fup->fu_dqblk.dqb_btime) : "");
248		printf("  %6lu%6lu%6lu%7s\n",
249			fup->fu_dqblk.dqb_curinodes,
250			fup->fu_dqblk.dqb_isoftlimit,
251			fup->fu_dqblk.dqb_ihardlimit,
252			fup->fu_dqblk.dqb_isoftlimit &&
253			    fup->fu_dqblk.dqb_curinodes >=
254			    fup->fu_dqblk.dqb_isoftlimit ?
255			    timeprt(fup->fu_dqblk.dqb_itime) : "");
256		fup->fu_dqblk = zerodqblk;
257	}
258	return (0);
259}
260
261/*
262 * Check to see if target appears in list of size cnt.
263 */
264int
265oneof(target, list, cnt)
266	register char *target, *list[];
267	int cnt;
268{
269	register int i;
270
271	for (i = 0; i < cnt; i++)
272		if (strcmp(target, list[i]) == 0)
273			return (i);
274	return (-1);
275}
276
277/*
278 * Check to see if a particular quota is to be enabled.
279 */
280int
281hasquota(fs, type, qfnamep)
282	register struct fstab *fs;
283	int type;
284	char **qfnamep;
285{
286	register char *opt;
287	char *cp;
288	static char initname, usrname[100], grpname[100];
289	static char buf[BUFSIZ];
290
291	if (!initname) {
292		sprintf(usrname, "%s%s", qfextension[USRQUOTA], qfname);
293		sprintf(grpname, "%s%s", qfextension[GRPQUOTA], qfname);
294		initname = 1;
295	}
296	strcpy(buf, fs->fs_mntops);
297	for (opt = strtok(buf, ","); opt; opt = strtok(NULL, ",")) {
298		if ((cp = index(opt, '=')))
299			*cp++ = '\0';
300		if (type == USRQUOTA && strcmp(opt, usrname) == 0)
301			break;
302		if (type == GRPQUOTA && strcmp(opt, grpname) == 0)
303			break;
304	}
305	if (!opt)
306		return (0);
307	if (cp) {
308		*qfnamep = cp;
309		return (1);
310	}
311	(void) sprintf(buf, "%s/%s.%s", fs->fs_file, qfname, qfextension[type]);
312	*qfnamep = buf;
313	return (1);
314}
315
316/*
317 * Routines to manage the file usage table.
318 *
319 * Lookup an id of a specific type.
320 */
321struct fileusage *
322lookup(id, type)
323	u_long id;
324	int type;
325{
326	register struct fileusage *fup;
327
328	for (fup = fuhead[type][id & (FUHASH-1)]; fup != 0; fup = fup->fu_next)
329		if (fup->fu_id == id)
330			return (fup);
331	return ((struct fileusage *)0);
332}
333
334/*
335 * Add a new file usage id if it does not already exist.
336 */
337struct fileusage *
338addid(id, type, name)
339	u_long id;
340	int type;
341	char *name;
342{
343	struct fileusage *fup, **fhp;
344	int len;
345
346	if ((fup = lookup(id, type)))
347		return (fup);
348	if (name)
349		len = strlen(name);
350	else
351		len = 10;
352	if ((fup = (struct fileusage *)calloc(1, sizeof(*fup) + len)) == NULL)
353		errx(1, "out of memory for fileusage structures");
354	fhp = &fuhead[type][id & (FUHASH - 1)];
355	fup->fu_next = *fhp;
356	*fhp = fup;
357	fup->fu_id = id;
358	if (id > highid[type])
359		highid[type] = id;
360	if (name) {
361		bcopy(name, fup->fu_name, len + 1);
362	} else {
363		sprintf(fup->fu_name, "%lu", id);
364	}
365	return (fup);
366}
367
368/*
369 * Calculate the grace period and return a printable string for it.
370 */
371char *
372timeprt(seconds)
373	time_t seconds;
374{
375	time_t hours, minutes;
376	static char buf[20];
377	static time_t now;
378
379	if (now == 0)
380		time(&now);
381	if (now > seconds)
382		return ("none");
383	seconds -= now;
384	minutes = (seconds + 30) / 60;
385	hours = (minutes + 30) / 60;
386	if (hours >= 36) {
387		sprintf(buf, "%lddays", (hours + 12) / 24);
388		return (buf);
389	}
390	if (minutes >= 60) {
391		sprintf(buf, "%2ld:%ld", minutes / 60, minutes % 60);
392		return (buf);
393	}
394	sprintf(buf, "%2ld", minutes);
395	return (buf);
396}
397