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. 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 35 static 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 41 static char sccsid[] = "@(#)edquota.c 8.1 (Berkeley) 6/6/93"; 42 #endif /* not lint */ 43 #endif 44 45 #include <sys/cdefs.h> 46 __FBSDID("$FreeBSD$"); 47 48 /* 49 * Disk quota editor. 50 */ 51 52 #include <sys/file.h> 53 #include <sys/mount.h> 54 #include <sys/wait.h> 55 #include <ufs/ufs/quota.h> 56 57 #include <ctype.h> 58 #include <err.h> 59 #include <errno.h> 60 #include <fstab.h> 61 #include <grp.h> 62 #include <inttypes.h> 63 #include <libutil.h> 64 #include <pwd.h> 65 #include <signal.h> 66 #include <stdio.h> 67 #include <stdlib.h> 68 #include <string.h> 69 #include <unistd.h> 70 71 #include "pathnames.h" 72 73 /* Let's be paranoid about block size */ 74 #if 10 > DEV_BSHIFT 75 #define dbtokb(db) \ 76 ((off_t)(db) >> (10-DEV_BSHIFT)) 77 #elif 10 < DEV_BSHIFT 78 #define dbtokb(db) \ 79 ((off_t)(db) << (DEV_BSHIFT-10)) 80 #else 81 #define dbtokb(db) (db) 82 #endif 83 84 const char *qfextension[] = INITQFNAMES; 85 char tmpfil[] = _PATH_TMP; 86 int hflag; 87 88 struct quotause { 89 struct quotause *next; 90 struct quotafile *qf; 91 struct dqblk dqblk; 92 int flags; 93 char fsname[MAXPATHLEN + 1]; 94 }; 95 #define FOUND 0x01 96 97 int alldigits(const char *s); 98 int cvtatos(uint64_t, char *, uint64_t *); 99 char *cvtstoa(uint64_t); 100 uint64_t cvtblkval(uint64_t, char, const char *); 101 uint64_t cvtinoval(uint64_t, char, const char *); 102 int editit(char *); 103 char *fmthumanvalblks(int64_t); 104 char *fmthumanvalinos(int64_t); 105 void freeprivs(struct quotause *); 106 int getentry(const char *, int); 107 struct quotause *getprivs(long, int, char *); 108 void putprivs(long, struct quotause *); 109 int readprivs(struct quotause *, char *); 110 int readtimes(struct quotause *, char *); 111 static void usage(void); 112 int writetimes(struct quotause *, int, int); 113 int writeprivs(struct quotause *, int, char *, int); 114 115 int 116 main(int argc, char *argv[]) 117 { 118 struct quotause *qup, *protoprivs, *curprivs; 119 long id, protoid; 120 int i, quotatype, range, tmpfd; 121 uid_t startuid, enduid; 122 uint64_t lim; 123 char *protoname, *cp, *endpt, *oldoptarg; 124 int eflag = 0, tflag = 0, pflag = 0, ch; 125 char *fspath = NULL; 126 char buf[MAXLOGNAME]; 127 128 if (argc < 2) 129 usage(); 130 if (getuid()) 131 errx(1, "permission denied"); 132 quotatype = USRQUOTA; 133 protoprivs = NULL; 134 curprivs = NULL; 135 protoname = NULL; 136 while ((ch = getopt(argc, argv, "ughtf:p:e:")) != -1) { 137 switch(ch) { 138 case 'f': 139 fspath = optarg; 140 break; 141 case 'p': 142 if (eflag) { 143 warnx("cannot specify both -e and -p"); 144 usage(); 145 /* not reached */ 146 } 147 protoname = optarg; 148 pflag++; 149 break; 150 case 'g': 151 quotatype = GRPQUOTA; 152 break; 153 case 'h': 154 hflag++; 155 break; 156 case 'u': 157 quotatype = USRQUOTA; 158 break; 159 case 't': 160 tflag++; 161 break; 162 case 'e': 163 if (pflag) { 164 warnx("cannot specify both -e and -p"); 165 usage(); 166 /* not reached */ 167 } 168 if ((qup = calloc(1, sizeof(*qup))) == NULL) 169 errx(2, "out of memory"); 170 oldoptarg = optarg; 171 for (i = 0, cp = optarg; 172 (cp = strsep(&optarg, ":")) != NULL; i++) { 173 if (cp != oldoptarg) 174 *(cp - 1) = ':'; 175 if (i > 0 && !isdigit(*cp)) { 176 warnx("incorrect quota specification: " 177 "%s", oldoptarg); 178 usage(); 179 /* Not Reached */ 180 } 181 switch (i) { 182 case 0: 183 strlcpy(qup->fsname, cp, 184 sizeof(qup->fsname)); 185 break; 186 case 1: 187 lim = strtoll(cp, &endpt, 10); 188 qup->dqblk.dqb_bsoftlimit = 189 cvtblkval(lim, *endpt, 190 "block soft limit"); 191 continue; 192 case 2: 193 lim = strtoll(cp, &endpt, 10); 194 qup->dqblk.dqb_bhardlimit = 195 cvtblkval(lim, *endpt, 196 "block hard limit"); 197 continue; 198 case 3: 199 lim = strtoll(cp, &endpt, 10); 200 qup->dqblk.dqb_isoftlimit = 201 cvtinoval(lim, *endpt, 202 "inode soft limit"); 203 continue; 204 case 4: 205 lim = strtoll(cp, &endpt, 10); 206 qup->dqblk.dqb_ihardlimit = 207 cvtinoval(lim, *endpt, 208 "inode hard limit"); 209 continue; 210 default: 211 warnx("incorrect quota specification: " 212 "%s", oldoptarg); 213 usage(); 214 /* Not Reached */ 215 } 216 } 217 if (protoprivs == NULL) { 218 protoprivs = curprivs = qup; 219 } else { 220 curprivs->next = qup; 221 curprivs = qup; 222 } 223 eflag++; 224 break; 225 default: 226 usage(); 227 /* Not Reached */ 228 } 229 } 230 argc -= optind; 231 argv += optind; 232 if (pflag || eflag) { 233 if (pflag) { 234 if ((protoid = getentry(protoname, quotatype)) == -1) 235 exit(1); 236 protoprivs = getprivs(protoid, quotatype, fspath); 237 if (protoprivs == NULL) 238 exit(0); 239 for (qup = protoprivs; qup; qup = qup->next) { 240 qup->dqblk.dqb_btime = 0; 241 qup->dqblk.dqb_itime = 0; 242 } 243 } 244 for (; argc-- > 0; argv++) { 245 if (strspn(*argv, "0123456789-") == strlen(*argv) && 246 (cp = strchr(*argv, '-')) != NULL) { 247 *cp++ = '\0'; 248 startuid = atoi(*argv); 249 enduid = atoi(cp); 250 if (enduid < startuid) 251 errx(1, 252 "ending uid (%d) must be >= starting uid (%d) when using uid ranges", 253 enduid, startuid); 254 range = 1; 255 } else { 256 startuid = enduid = 0; 257 range = 0; 258 } 259 for ( ; startuid <= enduid; startuid++) { 260 if (range) 261 snprintf(buf, sizeof(buf), "%d", 262 startuid); 263 else 264 snprintf(buf, sizeof(buf), "%s", 265 *argv); 266 if ((id = getentry(buf, quotatype)) < 0) 267 continue; 268 if (pflag) { 269 putprivs(id, protoprivs); 270 continue; 271 } 272 for (qup = protoprivs; qup; qup = qup->next) { 273 curprivs = getprivs(id, quotatype, 274 qup->fsname); 275 if (curprivs == NULL) 276 continue; 277 curprivs->dqblk = qup->dqblk; 278 putprivs(id, curprivs); 279 freeprivs(curprivs); 280 } 281 } 282 } 283 if (pflag) 284 freeprivs(protoprivs); 285 exit(0); 286 } 287 tmpfd = mkostemp(tmpfil, O_CLOEXEC); 288 fchown(tmpfd, getuid(), getgid()); 289 if (tflag) { 290 if ((protoprivs = getprivs(0, quotatype, fspath)) != NULL) { 291 if (writetimes(protoprivs, tmpfd, quotatype) != 0 && 292 editit(tmpfil) && readtimes(protoprivs, tmpfil)) 293 putprivs(0L, protoprivs); 294 freeprivs(protoprivs); 295 } 296 close(tmpfd); 297 unlink(tmpfil); 298 exit(0); 299 } 300 for ( ; argc > 0; argc--, argv++) { 301 if ((id = getentry(*argv, quotatype)) == -1) 302 continue; 303 if ((curprivs = getprivs(id, quotatype, fspath)) == NULL) 304 exit(1); 305 if (writeprivs(curprivs, tmpfd, *argv, quotatype) == 0) 306 continue; 307 if (editit(tmpfil) && readprivs(curprivs, tmpfil)) 308 putprivs(id, curprivs); 309 freeprivs(curprivs); 310 } 311 close(tmpfd); 312 unlink(tmpfil); 313 exit(0); 314 } 315 316 static void 317 usage(void) 318 { 319 fprintf(stderr, "%s\n%s\n%s\n%s\n%s\n%s\n%s\n%s\n", 320 "usage: edquota [-uh] [-f fspath] [-p username] username ...", 321 " edquota [-u] -e fspath[:bslim[:bhlim[:islim[:ihlim]]]] [-e ...]", 322 " username ...", 323 " edquota -g [-h] [-f fspath] [-p groupname] groupname ...", 324 " edquota -g -e fspath[:bslim[:bhlim[:islim[:ihlim]]]] [-e ...]", 325 " groupname ...", 326 " edquota [-u] -t [-f fspath]", 327 " edquota -g -t [-f fspath]"); 328 exit(1); 329 } 330 331 /* 332 * This routine converts a name for a particular quota type to 333 * an identifier. This routine must agree with the kernel routine 334 * getinoquota as to the interpretation of quota types. 335 */ 336 int 337 getentry(const char *name, int quotatype) 338 { 339 struct passwd *pw; 340 struct group *gr; 341 342 if (alldigits(name)) 343 return (atoi(name)); 344 switch(quotatype) { 345 case USRQUOTA: 346 if ((pw = getpwnam(name))) 347 return (pw->pw_uid); 348 warnx("%s: no such user", name); 349 sleep(3); 350 break; 351 case GRPQUOTA: 352 if ((gr = getgrnam(name))) 353 return (gr->gr_gid); 354 warnx("%s: no such group", name); 355 sleep(3); 356 break; 357 default: 358 warnx("%d: unknown quota type", quotatype); 359 sleep(3); 360 break; 361 } 362 sleep(1); 363 return (-1); 364 } 365 366 /* 367 * Collect the requested quota information. 368 */ 369 struct quotause * 370 getprivs(long id, int quotatype, char *fspath) 371 { 372 struct quotafile *qf; 373 struct fstab *fs; 374 struct quotause *qup, *quptail; 375 struct quotause *quphead; 376 377 setfsent(); 378 quphead = quptail = NULL; 379 while ((fs = getfsent())) { 380 if (fspath && *fspath && strcmp(fspath, fs->fs_spec) && 381 strcmp(fspath, fs->fs_file)) 382 continue; 383 if (strcmp(fs->fs_vfstype, "ufs")) 384 continue; 385 if ((qf = quota_open(fs, quotatype, O_CREAT|O_RDWR)) == NULL) { 386 if (errno != EOPNOTSUPP) 387 warn("cannot open quotas on %s", fs->fs_file); 388 continue; 389 } 390 if ((qup = (struct quotause *)calloc(1, sizeof(*qup))) == NULL) 391 errx(2, "out of memory"); 392 qup->qf = qf; 393 strlcpy(qup->fsname, fs->fs_file, sizeof(qup->fsname)); 394 if (quota_read(qf, &qup->dqblk, id) == -1) { 395 warn("cannot read quotas on %s", fs->fs_file); 396 freeprivs(qup); 397 continue; 398 } 399 if (quphead == NULL) 400 quphead = qup; 401 else 402 quptail->next = qup; 403 quptail = qup; 404 qup->next = 0; 405 } 406 if (quphead == NULL) { 407 warnx("No quotas on %s", fspath ? fspath : "any filesystems"); 408 } 409 endfsent(); 410 return (quphead); 411 } 412 413 /* 414 * Store the requested quota information. 415 */ 416 void 417 putprivs(long id, struct quotause *quplist) 418 { 419 struct quotause *qup; 420 421 for (qup = quplist; qup; qup = qup->next) 422 if (quota_write_limits(qup->qf, &qup->dqblk, id) == -1) 423 warn("%s", qup->fsname); 424 } 425 426 /* 427 * Take a list of privileges and get it edited. 428 */ 429 int 430 editit(char *tmpf) 431 { 432 long omask; 433 int pid, status; 434 435 omask = sigblock(sigmask(SIGINT)|sigmask(SIGQUIT)|sigmask(SIGHUP)); 436 top: 437 if ((pid = fork()) < 0) { 438 439 if (errno == EPROCLIM) { 440 warnx("you have too many processes"); 441 return(0); 442 } 443 if (errno == EAGAIN) { 444 sleep(1); 445 goto top; 446 } 447 warn("fork"); 448 return (0); 449 } 450 if (pid == 0) { 451 const char *ed; 452 453 sigsetmask(omask); 454 if (setgid(getgid()) != 0) 455 err(1, "setgid failed"); 456 if (setuid(getuid()) != 0) 457 err(1, "setuid failed"); 458 if ((ed = getenv("EDITOR")) == (char *)0) 459 ed = _PATH_VI; 460 execlp(ed, ed, tmpf, (char *)0); 461 err(1, "%s", ed); 462 } 463 waitpid(pid, &status, 0); 464 sigsetmask(omask); 465 if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) 466 return (0); 467 return (1); 468 } 469 470 /* 471 * Convert a quotause list to an ASCII file. 472 */ 473 int 474 writeprivs(struct quotause *quplist, int outfd, char *name, int quotatype) 475 { 476 struct quotause *qup; 477 FILE *fd; 478 479 ftruncate(outfd, 0); 480 lseek(outfd, 0, L_SET); 481 if ((fd = fdopen(dup(outfd), "w")) == NULL) 482 err(1, "%s", tmpfil); 483 fprintf(fd, "Quotas for %s %s:\n", qfextension[quotatype], name); 484 for (qup = quplist; qup; qup = qup->next) { 485 fprintf(fd, "%s: in use: %s, ", qup->fsname, 486 fmthumanvalblks(qup->dqblk.dqb_curblocks)); 487 fprintf(fd, "limits (soft = %s, ", 488 fmthumanvalblks(qup->dqblk.dqb_bsoftlimit)); 489 fprintf(fd, "hard = %s)\n", 490 fmthumanvalblks(qup->dqblk.dqb_bhardlimit)); 491 fprintf(fd, "\tinodes in use: %s, ", 492 fmthumanvalinos(qup->dqblk.dqb_curinodes)); 493 fprintf(fd, "limits (soft = %s, ", 494 fmthumanvalinos(qup->dqblk.dqb_isoftlimit)); 495 fprintf(fd, "hard = %s)\n", 496 fmthumanvalinos(qup->dqblk.dqb_ihardlimit)); 497 } 498 fclose(fd); 499 return (1); 500 } 501 502 char * 503 fmthumanvalblks(int64_t blocks) 504 { 505 static char numbuf[20]; 506 507 if (hflag) { 508 humanize_number(numbuf, blocks < 0 ? 7 : 6, 509 dbtob(blocks), "", HN_AUTOSCALE, HN_NOSPACE); 510 return (numbuf); 511 } 512 snprintf(numbuf, sizeof(numbuf), "%juk", (uintmax_t)dbtokb(blocks)); 513 return(numbuf); 514 } 515 516 char * 517 fmthumanvalinos(int64_t inos) 518 { 519 static char numbuf[20]; 520 521 if (hflag) { 522 humanize_number(numbuf, inos < 0 ? 7 : 6, 523 inos, "", HN_AUTOSCALE, HN_NOSPACE | HN_DIVISOR_1000); 524 return (numbuf); 525 } 526 snprintf(numbuf, sizeof(numbuf), "%ju", (uintmax_t)inos); 527 return(numbuf); 528 } 529 530 /* 531 * Merge changes to an ASCII file into a quotause list. 532 */ 533 int 534 readprivs(struct quotause *quplist, char *inname) 535 { 536 struct quotause *qup; 537 FILE *fd; 538 uintmax_t hardlimit, softlimit, curitems; 539 char hardunits, softunits, curitemunits; 540 int cnt; 541 char *cp; 542 struct dqblk dqblk; 543 char *fsp, line1[BUFSIZ], line2[BUFSIZ]; 544 545 fd = fopen(inname, "r"); 546 if (fd == NULL) { 547 warnx("can't re-read temp file!!"); 548 return (0); 549 } 550 /* 551 * Discard title line, then read pairs of lines to process. 552 */ 553 (void) fgets(line1, sizeof (line1), fd); 554 while (fgets(line1, sizeof (line1), fd) != NULL && 555 fgets(line2, sizeof (line2), fd) != NULL) { 556 if ((fsp = strtok(line1, " \t:")) == NULL) { 557 warnx("%s: bad format", line1); 558 return (0); 559 } 560 if ((cp = strtok((char *)0, "\n")) == NULL) { 561 warnx("%s: %s: bad format", fsp, &fsp[strlen(fsp) + 1]); 562 return (0); 563 } 564 cnt = sscanf(cp, 565 " in use: %ju%c, limits (soft = %ju%c, hard = %ju%c)", 566 &curitems, &curitemunits, &softlimit, &softunits, 567 &hardlimit, &hardunits); 568 /* 569 * The next three check for old-style input formats. 570 */ 571 if (cnt != 6) 572 cnt = sscanf(cp, 573 " in use: %ju%c, limits (soft = %ju%c hard = %ju%c", 574 &curitems, &curitemunits, &softlimit, 575 &softunits, &hardlimit, &hardunits); 576 if (cnt != 6) 577 cnt = sscanf(cp, 578 " in use: %ju%c, limits (soft = %ju%c hard = %ju%c)", 579 &curitems, &curitemunits, &softlimit, 580 &softunits, &hardlimit, &hardunits); 581 if (cnt != 6) 582 cnt = sscanf(cp, 583 " in use: %ju%c, limits (soft = %ju%c, hard = %ju%c", 584 &curitems, &curitemunits, &softlimit, 585 &softunits, &hardlimit, &hardunits); 586 if (cnt != 6) { 587 warnx("%s:%s: bad format", fsp, cp); 588 return (0); 589 } 590 dqblk.dqb_curblocks = cvtblkval(curitems, curitemunits, 591 "current block count"); 592 dqblk.dqb_bsoftlimit = cvtblkval(softlimit, softunits, 593 "block soft limit"); 594 dqblk.dqb_bhardlimit = cvtblkval(hardlimit, hardunits, 595 "block hard limit"); 596 if ((cp = strtok(line2, "\n")) == NULL) { 597 warnx("%s: %s: bad format", fsp, line2); 598 return (0); 599 } 600 cnt = sscanf(&cp[7], 601 " in use: %ju%c limits (soft = %ju%c, hard = %ju%c)", 602 &curitems, &curitemunits, &softlimit, 603 &softunits, &hardlimit, &hardunits); 604 /* 605 * The next three check for old-style input formats. 606 */ 607 if (cnt != 6) 608 cnt = sscanf(&cp[7], 609 " in use: %ju%c limits (soft = %ju%c hard = %ju%c", 610 &curitems, &curitemunits, &softlimit, 611 &softunits, &hardlimit, &hardunits); 612 if (cnt != 6) 613 cnt = sscanf(&cp[7], 614 " in use: %ju%c limits (soft = %ju%c hard = %ju%c)", 615 &curitems, &curitemunits, &softlimit, 616 &softunits, &hardlimit, &hardunits); 617 if (cnt != 6) 618 cnt = sscanf(&cp[7], 619 " in use: %ju%c limits (soft = %ju%c, hard = %ju%c", 620 &curitems, &curitemunits, &softlimit, 621 &softunits, &hardlimit, &hardunits); 622 if (cnt != 6) { 623 warnx("%s: %s: bad format cnt %d", fsp, &cp[7], cnt); 624 return (0); 625 } 626 dqblk.dqb_curinodes = cvtinoval(curitems, curitemunits, 627 "current inode count"); 628 dqblk.dqb_isoftlimit = cvtinoval(softlimit, softunits, 629 "inode soft limit"); 630 dqblk.dqb_ihardlimit = cvtinoval(hardlimit, hardunits, 631 "inode hard limit"); 632 for (qup = quplist; qup; qup = qup->next) { 633 if (strcmp(fsp, qup->fsname)) 634 continue; 635 /* 636 * Cause time limit to be reset when the quota 637 * is next used if previously had no soft limit 638 * or were under it, but now have a soft limit 639 * and are over it. 640 */ 641 if (dqblk.dqb_bsoftlimit && 642 qup->dqblk.dqb_curblocks >= dqblk.dqb_bsoftlimit && 643 (qup->dqblk.dqb_bsoftlimit == 0 || 644 qup->dqblk.dqb_curblocks < 645 qup->dqblk.dqb_bsoftlimit)) 646 qup->dqblk.dqb_btime = 0; 647 if (dqblk.dqb_isoftlimit && 648 qup->dqblk.dqb_curinodes >= dqblk.dqb_isoftlimit && 649 (qup->dqblk.dqb_isoftlimit == 0 || 650 qup->dqblk.dqb_curinodes < 651 qup->dqblk.dqb_isoftlimit)) 652 qup->dqblk.dqb_itime = 0; 653 qup->dqblk.dqb_bsoftlimit = dqblk.dqb_bsoftlimit; 654 qup->dqblk.dqb_bhardlimit = dqblk.dqb_bhardlimit; 655 qup->dqblk.dqb_isoftlimit = dqblk.dqb_isoftlimit; 656 qup->dqblk.dqb_ihardlimit = dqblk.dqb_ihardlimit; 657 qup->flags |= FOUND; 658 /* Humanized input returns only approximate counts */ 659 if (hflag || 660 (dqblk.dqb_curblocks == qup->dqblk.dqb_curblocks && 661 dqblk.dqb_curinodes == qup->dqblk.dqb_curinodes)) 662 break; 663 warnx("%s: cannot change current allocation", fsp); 664 break; 665 } 666 } 667 fclose(fd); 668 /* 669 * Disable quotas for any filesystems that have not been found. 670 */ 671 for (qup = quplist; qup; qup = qup->next) { 672 if (qup->flags & FOUND) { 673 qup->flags &= ~FOUND; 674 continue; 675 } 676 qup->dqblk.dqb_bsoftlimit = 0; 677 qup->dqblk.dqb_bhardlimit = 0; 678 qup->dqblk.dqb_isoftlimit = 0; 679 qup->dqblk.dqb_ihardlimit = 0; 680 } 681 return (1); 682 } 683 684 /* 685 * Convert a quotause list to an ASCII file of grace times. 686 */ 687 int 688 writetimes(struct quotause *quplist, int outfd, int quotatype) 689 { 690 struct quotause *qup; 691 FILE *fd; 692 693 ftruncate(outfd, 0); 694 lseek(outfd, 0, L_SET); 695 if ((fd = fdopen(dup(outfd), "w")) == NULL) 696 err(1, "%s", tmpfil); 697 fprintf(fd, "Time units may be: days, hours, minutes, or seconds\n"); 698 fprintf(fd, "Grace period before enforcing soft limits for %ss:\n", 699 qfextension[quotatype]); 700 for (qup = quplist; qup; qup = qup->next) { 701 fprintf(fd, "%s: block grace period: %s, ", 702 qup->fsname, cvtstoa(qup->dqblk.dqb_btime)); 703 fprintf(fd, "file grace period: %s\n", 704 cvtstoa(qup->dqblk.dqb_itime)); 705 } 706 fclose(fd); 707 return (1); 708 } 709 710 /* 711 * Merge changes of grace times in an ASCII file into a quotause list. 712 */ 713 int 714 readtimes(struct quotause *quplist, char *inname) 715 { 716 struct quotause *qup; 717 FILE *fd; 718 int cnt; 719 char *cp; 720 uintmax_t itime, btime, iseconds, bseconds; 721 char *fsp, bunits[10], iunits[10], line1[BUFSIZ]; 722 723 fd = fopen(inname, "r"); 724 if (fd == NULL) { 725 warnx("can't re-read temp file!!"); 726 return (0); 727 } 728 /* 729 * Discard two title lines, then read lines to process. 730 */ 731 (void) fgets(line1, sizeof (line1), fd); 732 (void) fgets(line1, sizeof (line1), fd); 733 while (fgets(line1, sizeof (line1), fd) != NULL) { 734 if ((fsp = strtok(line1, " \t:")) == NULL) { 735 warnx("%s: bad format", line1); 736 return (0); 737 } 738 if ((cp = strtok((char *)0, "\n")) == NULL) { 739 warnx("%s: %s: bad format", fsp, &fsp[strlen(fsp) + 1]); 740 return (0); 741 } 742 cnt = sscanf(cp, 743 " block grace period: %ju %s file grace period: %ju %s", 744 &btime, bunits, &itime, iunits); 745 if (cnt != 4) { 746 warnx("%s:%s: bad format", fsp, cp); 747 return (0); 748 } 749 if (cvtatos(btime, bunits, &bseconds) == 0) 750 return (0); 751 if (cvtatos(itime, iunits, &iseconds) == 0) 752 return (0); 753 for (qup = quplist; qup; qup = qup->next) { 754 if (strcmp(fsp, qup->fsname)) 755 continue; 756 qup->dqblk.dqb_btime = bseconds; 757 qup->dqblk.dqb_itime = iseconds; 758 qup->flags |= FOUND; 759 break; 760 } 761 } 762 fclose(fd); 763 /* 764 * reset default grace periods for any filesystems 765 * that have not been found. 766 */ 767 for (qup = quplist; qup; qup = qup->next) { 768 if (qup->flags & FOUND) { 769 qup->flags &= ~FOUND; 770 continue; 771 } 772 qup->dqblk.dqb_btime = 0; 773 qup->dqblk.dqb_itime = 0; 774 } 775 return (1); 776 } 777 778 /* 779 * Convert seconds to ASCII times. 780 */ 781 char * 782 cvtstoa(uint64_t secs) 783 { 784 static char buf[20]; 785 786 if (secs % (24 * 60 * 60) == 0) { 787 secs /= 24 * 60 * 60; 788 sprintf(buf, "%ju day%s", (uintmax_t)secs, 789 secs == 1 ? "" : "s"); 790 } else if (secs % (60 * 60) == 0) { 791 secs /= 60 * 60; 792 sprintf(buf, "%ju hour%s", (uintmax_t)secs, 793 secs == 1 ? "" : "s"); 794 } else if (secs % 60 == 0) { 795 secs /= 60; 796 sprintf(buf, "%ju minute%s", (uintmax_t)secs, 797 secs == 1 ? "" : "s"); 798 } else 799 sprintf(buf, "%ju second%s", (uintmax_t)secs, 800 secs == 1 ? "" : "s"); 801 return (buf); 802 } 803 804 /* 805 * Convert ASCII input times to seconds. 806 */ 807 int 808 cvtatos(uint64_t period, char *units, uint64_t *seconds) 809 { 810 811 if (bcmp(units, "second", 6) == 0) 812 *seconds = period; 813 else if (bcmp(units, "minute", 6) == 0) 814 *seconds = period * 60; 815 else if (bcmp(units, "hour", 4) == 0) 816 *seconds = period * 60 * 60; 817 else if (bcmp(units, "day", 3) == 0) 818 *seconds = period * 24 * 60 * 60; 819 else { 820 warnx("%s: bad units, specify %s\n", units, 821 "days, hours, minutes, or seconds"); 822 return (0); 823 } 824 return (1); 825 } 826 827 /* 828 * Convert a limit to number of disk blocks. 829 */ 830 uint64_t 831 cvtblkval(uint64_t limit, char units, const char *itemname) 832 { 833 834 switch(units) { 835 case 'B': 836 case 'b': 837 limit = btodb(limit); 838 break; 839 case '\0': /* historic behavior */ 840 case ',': /* historic behavior */ 841 case ')': /* historic behavior */ 842 case 'K': 843 case 'k': 844 limit *= btodb(1024); 845 break; 846 case 'M': 847 case 'm': 848 limit *= btodb(1048576); 849 break; 850 case 'G': 851 case 'g': 852 limit *= btodb(1073741824); 853 break; 854 case 'T': 855 case 't': 856 limit *= btodb(1099511627776); 857 break; 858 case 'P': 859 case 'p': 860 limit *= btodb(1125899906842624); 861 break; 862 case 'E': 863 case 'e': 864 limit *= btodb(1152921504606846976); 865 break; 866 case ' ': 867 errx(2, "No space permitted between value and units for %s\n", 868 itemname); 869 break; 870 default: 871 errx(2, "%ju%c: unknown units for %s, specify " 872 "none, K, M, G, T, P, or E\n", 873 (uintmax_t)limit, units, itemname); 874 break; 875 } 876 return (limit); 877 } 878 879 /* 880 * Convert a limit to number of inodes. 881 */ 882 uint64_t 883 cvtinoval(uint64_t limit, char units, const char *itemname) 884 { 885 886 switch(units) { 887 case 'B': 888 case 'b': 889 case '\0': /* historic behavior */ 890 case ',': /* historic behavior */ 891 case ')': /* historic behavior */ 892 break; 893 case 'K': 894 case 'k': 895 limit *= 1000; 896 break; 897 case 'M': 898 case 'm': 899 limit *= 1000000; 900 break; 901 case 'G': 902 case 'g': 903 limit *= 1000000000; 904 break; 905 case 'T': 906 case 't': 907 limit *= 1000000000000; 908 break; 909 case 'P': 910 case 'p': 911 limit *= 1000000000000000; 912 break; 913 case 'E': 914 case 'e': 915 limit *= 1000000000000000000; 916 break; 917 case ' ': 918 errx(2, "No space permitted between value and units for %s\n", 919 itemname); 920 break; 921 default: 922 errx(2, "%ju%c: unknown units for %s, specify " 923 "none, K, M, G, T, P, or E\n", 924 (uintmax_t)limit, units, itemname); 925 break; 926 } 927 return (limit); 928 } 929 930 /* 931 * Free a list of quotause structures. 932 */ 933 void 934 freeprivs(struct quotause *quplist) 935 { 936 struct quotause *qup, *nextqup; 937 938 for (qup = quplist; qup; qup = nextqup) { 939 quota_close(qup->qf); 940 nextqup = qup->next; 941 free(qup); 942 } 943 } 944 945 /* 946 * Check whether a string is completely composed of digits. 947 */ 948 int 949 alldigits(const char *s) 950 { 951 int c; 952 953 c = *s++; 954 do { 955 if (!isdigit(c)) 956 return (0); 957 } while ((c = *s++)); 958 return (1); 959 } 960