/*
* Convert a quota file from one format to another.
*/
int
quota_convert(struct quotafile *qf, int wordsize)
{
struct quotafile *newqf;
struct dqhdr64 dqh;
struct dqblk dqblk;
struct group *grp;
int serrno, maxid, id, fd;
/*
* Quotas must not be active and quotafile must be open
* for reading and writing.
*/
if ((qf->accmode & O_RDWR) != O_RDWR || qf->fd == -1) {
errno = EBADF;
return (-1);
}
if ((wordsize != 32 && wordsize != 64) ||
wordsize == qf->wordsize) {
errno = EINVAL;
return (-1);
}
maxid = quota_maxid(qf);
if ((newqf = calloc(1, sizeof(*qf))) == NULL) {
errno = ENOMEM;
return (-1);
}
*newqf = *qf;
snprintf(newqf->qfname, MAXPATHLEN + 1, "%s_%d.orig", qf->qfname,
qf->wordsize);
if (rename(qf->qfname, newqf->qfname) < 0) {
free(newqf);
return (-1);
}
if ((newqf->fd = open(qf->qfname, O_RDWR|O_CREAT|O_TRUNC, 0)) < 0) {
serrno = errno;
goto error;
}
newqf->wordsize = wordsize;
if (wordsize == 64) {
memset(&dqh, 0, sizeof(dqh));
memcpy(dqh.dqh_magic, Q_DQHDR64_MAGIC, sizeof(dqh.dqh_magic));
dqh.dqh_version = htobe32(Q_DQHDR64_VERSION);
dqh.dqh_hdrlen = htobe32(sizeof(struct dqhdr64));
dqh.dqh_reclen = htobe32(sizeof(struct dqblk64));
if (write(newqf->fd, &dqh, sizeof(dqh)) != sizeof(dqh)) {
serrno = errno;
goto error;
}
}
grp = getgrnam(QUOTAGROUP);
fchown(newqf->fd, 0, grp ? grp->gr_gid : 0);
fchmod(newqf->fd, 0640);
for (id = 0; id <= maxid; id++) {
if ((quota_read(qf, &dqblk, id)) < 0)
break;
switch (newqf->wordsize) {
case 32:
if ((quota_write32(newqf, &dqblk, id)) < 0)
break;
continue;
case 64:
if ((quota_write64(newqf, &dqblk, id)) < 0)
break;
continue;
default:
errno = EINVAL;
break;
}
}
if (id < maxid) {
serrno = errno;
goto error;
}
/*
* Update the passed in quotafile to reference the new file
* of the converted format size.
*/
fd = qf->fd;
qf->fd = newqf->fd;
newqf->fd = fd;
qf->wordsize = newqf->wordsize;
quota_close(newqf);
return (0);
error:
/* put back the original file */
(void) rename(newqf->qfname, qf->qfname);
quota_close(newqf);
errno = serrno;
return (-1);
}
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);
}
/*
* Free a list of quotause structures.
*/
void
freeprivs(struct quotause *quplist)
{
struct quotause *qup, *nextqup;
for (qup = quplist; qup; qup = nextqup) {
quota_close(qup->qf);
nextqup = qup->next;
free(qup);
}
}
/*
* 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);
}
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);
}
