static int
quotaonoff(struct fstab *fs, int offmode, int type)
{
struct quotafile *qf;
if ((qf = quota_open(fs, type, O_RDONLY)) == NULL)
return (0);
if (offmode) {
if (quota_off(qf) != 0) {
warn("%s", quota_fsname(qf));
return (1);
}
if (vflag)
printf("%s: quotas turned off\n", quota_fsname(qf));
quota_close(qf);
return(0);
}
if (quota_on(qf) != 0) {
warn("using %s on %s", quota_qfname(qf), quota_fsname(qf));
return (1);
}
if (vflag)
printf("%s: %s quotas turned on with data file %s\n",
quota_fsname(qf), qfextension[type], quota_qfname(qf));
quota_close(qf);
return(0);
}
/*
* Check to see if a particular quota is available.
*/
static int
getufsquota(struct fstab *fs, struct quotause *qup, long id, int quotatype)
{
struct quotafile *qf;
if ((qf = quota_open(fs, quotatype, O_RDONLY)) == NULL)
return (0);
if (quota_read(qf, &qup->dqblk, id) != 0)
return (0);
quota_close(qf);
return (1);
}
/*
* Collect the requested quota information.
*/
struct quotause *
getprivs(long id, int quotatype, char *fspath)
{
struct quotafile *qf;
struct fstab *fs;
struct quotause *qup, *quptail;
struct quotause *quphead;
setfsent();
quphead = quptail = NULL;
while ((fs = getfsent())) {
if (fspath && *fspath && strcmp(fspath, fs->fs_spec) &&
strcmp(fspath, fs->fs_file))
continue;
if (strcmp(fs->fs_vfstype, "ufs"))
continue;
if ((qf = quota_open(fs, quotatype, O_CREAT|O_RDWR)) == NULL) {
if (errno != EOPNOTSUPP)
warn("cannot open quotas on %s", fs->fs_file);
continue;
}
if ((qup = (struct quotause *)calloc(1, sizeof(*qup))) == NULL)
errx(2, "out of memory");
qup->qf = qf;
strncpy(qup->fsname, fs->fs_file, sizeof(qup->fsname));
if (quota_read(qf, &qup->dqblk, id) == -1) {
warn("cannot read quotas on %s", fs->fs_file);
freeprivs(qup);
continue;
}
if (quphead == NULL)
quphead = qup;
else
quptail->next = qup;
quptail = qup;
qup->next = 0;
}
if (quphead == NULL) {
warnx("No quotas on %s", fspath ? fspath : "any filesystems");
}
endfsent();
return (quphead);
}
int
main(int argc, char *argv[])
{
struct fstab *fs;
struct passwd *pw;
struct group *gr;
struct quotafile *qfu, *qfg;
int i, argnum, maxrun, errs, ch;
long done = 0;
char *name;
errs = maxrun = 0;
while ((ch = getopt(argc, argv, "ac:guvl:")) != -1) {
switch(ch) {
case 'a':
aflag++;
break;
case 'c':
if (cflag)
usage();
cflag = atoi(optarg);
break;
case 'g':
gflag++;
break;
case 'u':
uflag++;
break;
case 'v':
vflag++;
break;
case 'l':
maxrun = atoi(optarg);
break;
default:
usage();
}
}
argc -= optind;
argv += optind;
if ((argc == 0 && !aflag) || (argc > 0 && aflag))
usage();
if (cflag && cflag != 32 && cflag != 64)
usage();
if (!gflag && !uflag) {
gflag++;
uflag++;
}
if (gflag) {
setgrent();
while ((gr = getgrent()) != NULL)
(void) addid((u_long)gr->gr_gid, GRPQUOTA, gr->gr_name,
NULL);
endgrent();
}
if (uflag) {
setpwent();
while ((pw = getpwent()) != NULL)
(void) addid((u_long)pw->pw_uid, USRQUOTA, pw->pw_name,
NULL);
endpwent();
}
/*
* The maxrun (-l) option is now deprecated.
*/
if (maxrun > 0)
warnx("the -l option is now deprecated");
if (aflag)
exit(checkfstab(uflag, gflag));
if (setfsent() == 0)
errx(1, "%s: can't open", FSTAB);
while ((fs = getfsent()) != NULL) {
if (((argnum = oneof(fs->fs_file, argv, argc)) >= 0 ||
(argnum = oneof(fs->fs_spec, argv, argc)) >= 0) &&
(name = blockcheck(fs->fs_spec))) {
done |= 1 << argnum;
qfu = NULL;
if (uflag)
qfu = quota_open(fs, USRQUOTA, O_CREAT|O_RDWR);
qfg = NULL;
if (gflag)
qfg = quota_open(fs, GRPQUOTA, O_CREAT|O_RDWR);
if (qfu == NULL && qfg == NULL)
continue;
errs += chkquota(name, qfu, qfg);
if (qfu)
quota_close(qfu);
if (qfg)
quota_close(qfg);
}
}
endfsent();
for (i = 0; i < argc; i++)
if ((done & (1 << i)) == 0)
fprintf(stderr, "%s not found in %s\n",
argv[i], FSTAB);
exit(errs);
}
int
main(int argc, char *argv[])
{
int ch;
FILE *f;
struct quotahandle *qh;
int dflag = 0;
const char *volume = NULL;
const char *dumpfile = NULL;
while ((ch = getopt(argc, argv, "d")) != -1) {
switch (ch) {
case 'd': dflag = 1; break;
default: usage(); break;
}
}
if (optind >= argc) {
usage();
}
volume = argv[optind++];
if (optind < argc) {
dumpfile = argv[optind++];
}
if (optind < argc) {
usage();
}
qh = quota_open(volume);
if (qh == NULL) {
err(EXIT_FAILURE, "quota_open: %s", volume);
}
if (dumpfile != NULL) {
f = fopen(dumpfile, "r");
if (f == NULL) {
err(EXIT_FAILURE, "%s", dumpfile);
}
} else {
f = stdin;
dumpfile = "<stdin>";
}
maketables(qh);
if (dflag) {
struct qklist *seenkeys, *dropkeys;
seenkeys = qklist_create();
dropkeys = qklist_create();
readdumpfile(qh, f, dumpfile, seenkeys);
qklist_sort(seenkeys);
scankeys(qh, seenkeys, dropkeys);
purge(qh, dropkeys);
qklist_destroy(dropkeys);
qklist_destroy(seenkeys);
} else {
readdumpfile(qh, f, dumpfile, NULL);
}
if (f != stdin) {
fclose(f);
}
quota_close(qh);
return EXIT_SUCCESS;
}
int
repquota(struct fstab *fs, int type)
{
struct fileusage *fup;
struct quotafile *qf;
u_long id, maxid;
struct dqblk dqbuf;
static int multiple = 0;
if ((qf = quota_open(fs, type, O_RDONLY)) == NULL) {
if (vflag && !aflag) {
if (multiple++)
printf("\n");
fprintf(stdout, "*** No %s quotas on %s (%s)\n",
qfextension[type], fs->fs_file, fs->fs_spec);
return(1);
}
return(0);
}
if (multiple++)
printf("\n");
if (vflag)
fprintf(stdout, "*** Report for %s quotas on %s (%s)\n",
qfextension[type], fs->fs_file, fs->fs_spec);
printf("%*s Block limits File limits\n",
max(MAXLOGNAME - 1, 10), " ");
printf("User%*s used soft hard grace used soft hard grace\n",
max(MAXLOGNAME - 1, 10), " ");
maxid = quota_maxid(qf);
for (id = 0; id <= maxid; id++) {
if (quota_read(qf, &dqbuf, id) != 0)
break;
if (dqbuf.dqb_curinodes == 0 && dqbuf.dqb_curblocks == 0)
continue;
if ((fup = lookup(id, type)) == 0)
fup = addid(id, type, (char *)0);
printf("%-*s ", max(MAXLOGNAME - 1, 10), fup->fu_name);
printf("%c%c",
dqbuf.dqb_bsoftlimit &&
dqbuf.dqb_curblocks >=
dqbuf.dqb_bsoftlimit ? '+' : '-',
dqbuf.dqb_isoftlimit &&
dqbuf.dqb_curinodes >=
dqbuf.dqb_isoftlimit ? '+' : '-');
prthumanval(dqbuf.dqb_curblocks);
prthumanval(dqbuf.dqb_bsoftlimit);
prthumanval(dqbuf.dqb_bhardlimit);
printf(" %6s",
dqbuf.dqb_bsoftlimit &&
dqbuf.dqb_curblocks >=
dqbuf.dqb_bsoftlimit ?
timeprt(dqbuf.dqb_btime) : "-");
printf(" %7ju %7ju %7ju %6s\n",
(uintmax_t)dqbuf.dqb_curinodes,
(uintmax_t)dqbuf.dqb_isoftlimit,
(uintmax_t)dqbuf.dqb_ihardlimit,
dqbuf.dqb_isoftlimit &&
dqbuf.dqb_curinodes >=
dqbuf.dqb_isoftlimit ?
timeprt(dqbuf.dqb_itime) : "-");
}
quota_close(qf);
return (0);
}