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