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 38 static const char copyright[] = 39 "@(#) Copyright (c) 1980, 1990, 1993\n\ 40 The Regents of the University of California. All rights reserved.\n"; 41 #endif 42 43 #ifndef lint 44 static const char sccsid[] = "from: @(#)quota.c 8.1 (Berkeley) 6/6/93"; 45 #endif /* not lint */ 46 47 /* 48 * Disk quota reporting program. 49 */ 50 #include <sys/cdefs.h> 51 __FBSDID("$FreeBSD$"); 52 53 #include <sys/param.h> 54 #include <sys/types.h> 55 #include <sys/file.h> 56 #include <sys/stat.h> 57 #include <sys/mount.h> 58 #include <sys/socket.h> 59 60 #include <rpc/rpc.h> 61 #include <rpc/pmap_prot.h> 62 #include <rpcsvc/rquota.h> 63 64 #include <ufs/ufs/quota.h> 65 66 #include <ctype.h> 67 #include <err.h> 68 #include <fstab.h> 69 #include <grp.h> 70 #include <netdb.h> 71 #include <pwd.h> 72 #include <stdio.h> 73 #include <stdlib.h> 74 #include <string.h> 75 #include <unistd.h> 76 77 const char *qfname = QUOTAFILENAME; 78 const char *qfextension[] = INITQFNAMES; 79 80 struct quotause { 81 struct quotause *next; 82 long flags; 83 struct dqblk dqblk; 84 char fsname[MAXPATHLEN + 1]; 85 }; 86 #define FOUND 0x01 87 88 static const char *timeprt(time_t seconds); 89 static struct quotause *getprivs(long id, int quotatype); 90 static void usage(void); 91 static void showuid(u_long uid); 92 static void showgid(u_long gid); 93 static int alldigits(char *s); 94 static void showusrname(char *name); 95 static void showgrpname(char *name); 96 static void showquotas(int type, u_long id, const char *name); 97 static void heading(int type, u_long id, const char *name, const char *tag); 98 static struct quotause *getprivs(long id, int quotatype); 99 static int ufshasquota(struct fstab *fs, int type, char **qfnamep); 100 static int getufsquota(struct fstab *fs, struct quotause *qup, long id, 101 int quotatype); 102 static int getnfsquota(struct statfs *fst, struct quotause *qup, long id, 103 int quotatype); 104 static int callaurpc(char *host, int prognum, int versnum, int procnum, 105 xdrproc_t inproc, char *in, xdrproc_t outproc, char *out); 106 static int alldigits(char *s); 107 108 int qflag; 109 int vflag; 110 111 int 112 main(int argc, char *argv[]) 113 { 114 int ngroups; 115 gid_t mygid, gidset[NGROUPS]; 116 int i, gflag = 0, uflag = 0; 117 char ch; 118 119 while ((ch = getopt(argc, argv, "ugvq")) != -1) { 120 switch(ch) { 121 case 'g': 122 gflag++; 123 break; 124 case 'u': 125 uflag++; 126 break; 127 case 'v': 128 vflag++; 129 break; 130 case 'q': 131 qflag++; 132 break; 133 default: 134 usage(); 135 } 136 } 137 argc -= optind; 138 argv += optind; 139 if (!uflag && !gflag) 140 uflag++; 141 if (argc == 0) { 142 if (uflag) 143 showuid(getuid()); 144 if (gflag) { 145 mygid = getgid(); 146 ngroups = getgroups(NGROUPS, gidset); 147 if (ngroups < 0) 148 err(1, "getgroups"); 149 showgid(mygid); 150 for (i = 0; i < ngroups; i++) 151 if (gidset[i] != mygid) 152 showgid(gidset[i]); 153 } 154 return(0); 155 } 156 if (uflag && gflag) 157 usage(); 158 if (uflag) { 159 for (; argc > 0; argc--, argv++) { 160 if (alldigits(*argv)) 161 showuid(atoi(*argv)); 162 else 163 showusrname(*argv); 164 } 165 return(0); 166 } 167 if (gflag) { 168 for (; argc > 0; argc--, argv++) { 169 if (alldigits(*argv)) 170 showgid(atoi(*argv)); 171 else 172 showgrpname(*argv); 173 } 174 } 175 return(0); 176 } 177 178 static void 179 usage(void) 180 { 181 182 fprintf(stderr, "%s\n%s\n%s\n", 183 "usage: quota [-guqv]", 184 " quota [-qv] -u username ...", 185 " quota [-qv] -g groupname ..."); 186 exit(1); 187 } 188 189 /* 190 * Print out quotas for a specified user identifier. 191 */ 192 static void 193 showuid(u_long uid) 194 { 195 struct passwd *pwd = getpwuid(uid); 196 u_long myuid; 197 const char *name; 198 199 if (pwd == NULL) 200 name = "(no account)"; 201 else 202 name = pwd->pw_name; 203 myuid = getuid(); 204 if (uid != myuid && myuid != 0) { 205 printf("quota: %s (uid %lu): permission denied\n", name, uid); 206 return; 207 } 208 showquotas(USRQUOTA, uid, name); 209 } 210 211 /* 212 * Print out quotas for a specifed user name. 213 */ 214 static void 215 showusrname(char *name) 216 { 217 struct passwd *pwd = getpwnam(name); 218 u_long myuid; 219 220 if (pwd == NULL) { 221 warnx("%s: unknown user", name); 222 return; 223 } 224 myuid = getuid(); 225 if (pwd->pw_uid != myuid && myuid != 0) { 226 warnx("%s (uid %u): permission denied", name, pwd->pw_uid); 227 return; 228 } 229 showquotas(USRQUOTA, pwd->pw_uid, name); 230 } 231 232 /* 233 * Print out quotas for a specified group identifier. 234 */ 235 static void 236 showgid(u_long gid) 237 { 238 struct group *grp = getgrgid(gid); 239 int ngroups; 240 gid_t mygid, gidset[NGROUPS]; 241 int i; 242 const char *name; 243 244 if (grp == NULL) 245 name = "(no entry)"; 246 else 247 name = grp->gr_name; 248 mygid = getgid(); 249 ngroups = getgroups(NGROUPS, gidset); 250 if (ngroups < 0) { 251 warn("getgroups"); 252 return; 253 } 254 if (gid != mygid) { 255 for (i = 0; i < ngroups; i++) 256 if (gid == gidset[i]) 257 break; 258 if (i >= ngroups && getuid() != 0) { 259 warnx("%s (gid %lu): permission denied", name, gid); 260 return; 261 } 262 } 263 showquotas(GRPQUOTA, gid, name); 264 } 265 266 /* 267 * Print out quotas for a specifed group name. 268 */ 269 static void 270 showgrpname(char *name) 271 { 272 struct group *grp = getgrnam(name); 273 int ngroups; 274 gid_t mygid, gidset[NGROUPS]; 275 int i; 276 277 if (grp == NULL) { 278 warnx("%s: unknown group", name); 279 return; 280 } 281 mygid = getgid(); 282 ngroups = getgroups(NGROUPS, gidset); 283 if (ngroups < 0) { 284 warn("getgroups"); 285 return; 286 } 287 if (grp->gr_gid != mygid) { 288 for (i = 0; i < ngroups; i++) 289 if (grp->gr_gid == gidset[i]) 290 break; 291 if (i >= ngroups && getuid() != 0) { 292 warnx("%s (gid %u): permission denied", name, 293 grp->gr_gid); 294 return; 295 } 296 } 297 showquotas(GRPQUOTA, grp->gr_gid, name); 298 } 299 300 static void 301 showquotas(int type, u_long id, const char *name) 302 { 303 struct quotause *qup; 304 struct quotause *quplist; 305 const char *msgi, *msgb; 306 const char *nam; 307 int lines = 0; 308 static time_t now; 309 310 if (now == 0) 311 time(&now); 312 quplist = getprivs(id, type); 313 for (qup = quplist; qup; qup = qup->next) { 314 if (!vflag && 315 qup->dqblk.dqb_isoftlimit == 0 && 316 qup->dqblk.dqb_ihardlimit == 0 && 317 qup->dqblk.dqb_bsoftlimit == 0 && 318 qup->dqblk.dqb_bhardlimit == 0) 319 continue; 320 msgi = (char *)0; 321 if (qup->dqblk.dqb_ihardlimit && 322 qup->dqblk.dqb_curinodes >= qup->dqblk.dqb_ihardlimit) 323 msgi = "File limit reached on"; 324 else if (qup->dqblk.dqb_isoftlimit && 325 qup->dqblk.dqb_curinodes >= qup->dqblk.dqb_isoftlimit) { 326 if (qup->dqblk.dqb_itime > now) 327 msgi = "In file grace period on"; 328 else 329 msgi = "Over file quota on"; 330 } 331 msgb = (char *)0; 332 if (qup->dqblk.dqb_bhardlimit && 333 qup->dqblk.dqb_curblocks >= qup->dqblk.dqb_bhardlimit) 334 msgb = "Block limit reached on"; 335 else if (qup->dqblk.dqb_bsoftlimit && 336 qup->dqblk.dqb_curblocks >= qup->dqblk.dqb_bsoftlimit) { 337 if (qup->dqblk.dqb_btime > now) 338 msgb = "In block grace period on"; 339 else 340 msgb = "Over block quota on"; 341 } 342 if (qflag) { 343 if ((msgi != (char *)0 || msgb != (char *)0) && 344 lines++ == 0) 345 heading(type, id, name, ""); 346 if (msgi != (char *)0) 347 printf("\t%s %s\n", msgi, qup->fsname); 348 if (msgb != (char *)0) 349 printf("\t%s %s\n", msgb, qup->fsname); 350 continue; 351 } 352 if (vflag || 353 qup->dqblk.dqb_curblocks || 354 qup->dqblk.dqb_curinodes) { 355 if (lines++ == 0) 356 heading(type, id, name, ""); 357 nam = qup->fsname; 358 if (strlen(qup->fsname) > 15) { 359 printf("%s\n", qup->fsname); 360 nam = ""; 361 } 362 printf("%15s%8lu%c%7lu%8lu%8s" 363 , nam 364 , (u_long) (dbtob(qup->dqblk.dqb_curblocks) 365 / 1024) 366 , (msgb == (char *)0) ? ' ' : '*' 367 , (u_long) (dbtob(qup->dqblk.dqb_bsoftlimit) 368 / 1024) 369 , (u_long) (dbtob(qup->dqblk.dqb_bhardlimit) 370 / 1024) 371 , (msgb == (char *)0) ? "" 372 :timeprt(qup->dqblk.dqb_btime)); 373 printf("%8lu%c%7lu%8lu%8s\n" 374 , qup->dqblk.dqb_curinodes 375 , (msgi == (char *)0) ? ' ' : '*' 376 , qup->dqblk.dqb_isoftlimit 377 , qup->dqblk.dqb_ihardlimit 378 , (msgi == (char *)0) ? "" 379 : timeprt(qup->dqblk.dqb_itime) 380 ); 381 continue; 382 } 383 } 384 if (!qflag && lines == 0) 385 heading(type, id, name, "none"); 386 } 387 388 static void 389 heading(int type, u_long id, const char *name, const char *tag) 390 { 391 392 printf("Disk quotas for %s %s (%cid %lu): %s\n", qfextension[type], 393 name, *qfextension[type], id, tag); 394 if (!qflag && tag[0] == '\0') { 395 printf("%15s%8s %7s%8s%8s%8s %7s%8s%8s\n" 396 , "Filesystem" 397 , "usage" 398 , "quota" 399 , "limit" 400 , "grace" 401 , "files" 402 , "quota" 403 , "limit" 404 , "grace" 405 ); 406 } 407 } 408 409 /* 410 * Calculate the grace period and return a printable string for it. 411 */ 412 static const char * 413 timeprt(time_t seconds) 414 { 415 time_t hours, minutes; 416 static char buf[20]; 417 static time_t now; 418 419 if (now == 0) 420 time(&now); 421 if (now > seconds) 422 return ("none"); 423 seconds -= now; 424 minutes = (seconds + 30) / 60; 425 hours = (minutes + 30) / 60; 426 if (hours >= 36) { 427 sprintf(buf, "%lddays", (hours + 12) / 24); 428 return (buf); 429 } 430 if (minutes >= 60) { 431 sprintf(buf, "%2ld:%ld", minutes / 60, minutes % 60); 432 return (buf); 433 } 434 sprintf(buf, "%2ld", minutes); 435 return (buf); 436 } 437 438 /* 439 * Collect the requested quota information. 440 */ 441 static struct quotause * 442 getprivs(long id, int quotatype) 443 { 444 struct quotause *qup, *quptail; 445 struct fstab *fs; 446 struct quotause *quphead; 447 struct statfs *fst; 448 int nfst, i; 449 450 qup = quphead = (struct quotause *)0; 451 452 nfst = getmntinfo(&fst, MNT_WAIT); 453 if (nfst == 0) 454 errx(2, "no filesystems mounted!"); 455 setfsent(); 456 for (i=0; i<nfst; i++) { 457 if (qup == NULL) { 458 if ((qup = (struct quotause *)malloc(sizeof *qup)) 459 == NULL) 460 errx(2, "out of memory"); 461 } 462 if (strcmp(fst[i].f_fstypename, "nfs") == 0) { 463 if (getnfsquota(&fst[i], qup, id, quotatype) 464 == 0) 465 continue; 466 } else if (strcmp(fst[i].f_fstypename, "ufs") == 0) { 467 /* 468 * XXX 469 * UFS filesystems must be in /etc/fstab, and must 470 * indicate that they have quotas on (?!) This is quite 471 * unlike SunOS where quotas can be enabled/disabled 472 * on a filesystem independent of /etc/fstab, and it 473 * will still print quotas for them. 474 */ 475 if ((fs = getfsspec(fst[i].f_mntfromname)) == NULL) 476 continue; 477 if (getufsquota(fs, qup, id, quotatype) == 0) 478 continue; 479 } else 480 continue; 481 strcpy(qup->fsname, fst[i].f_mntonname); 482 if (quphead == NULL) 483 quphead = qup; 484 else 485 quptail->next = qup; 486 quptail = qup; 487 quptail->next = 0; 488 qup = NULL; 489 } 490 if (qup) 491 free(qup); 492 endfsent(); 493 return (quphead); 494 } 495 496 /* 497 * Check to see if a particular quota is to be enabled. 498 */ 499 static int 500 ufshasquota(struct fstab *fs, int type, char **qfnamep) 501 { 502 static char initname, usrname[100], grpname[100]; 503 static char buf[BUFSIZ]; 504 char *opt, *cp; 505 506 if (!initname) { 507 sprintf(usrname, "%s%s", qfextension[USRQUOTA], qfname); 508 sprintf(grpname, "%s%s", qfextension[GRPQUOTA], qfname); 509 initname = 1; 510 } 511 strcpy(buf, fs->fs_mntops); 512 for (opt = strtok(buf, ","); opt; opt = strtok(NULL, ",")) { 513 if ((cp = index(opt, '='))) 514 *cp++ = '\0'; 515 if (type == USRQUOTA && strcmp(opt, usrname) == 0) 516 break; 517 if (type == GRPQUOTA && strcmp(opt, grpname) == 0) 518 break; 519 } 520 if (!opt) 521 return (0); 522 if (cp) { 523 *qfnamep = cp; 524 return (1); 525 } 526 (void) sprintf(buf, "%s/%s.%s", fs->fs_file, qfname, qfextension[type]); 527 *qfnamep = buf; 528 return (1); 529 } 530 531 static int 532 getufsquota(struct fstab *fs, struct quotause *qup, long id, int quotatype) 533 { 534 char *qfpathname; 535 int fd, qcmd; 536 537 qcmd = QCMD(Q_GETQUOTA, quotatype); 538 if (!ufshasquota(fs, quotatype, &qfpathname)) 539 return (0); 540 541 if (quotactl(fs->fs_file, qcmd, id, (char *)&qup->dqblk) != 0) { 542 if ((fd = open(qfpathname, O_RDONLY)) < 0) { 543 warn("%s", qfpathname); 544 return (0); 545 } 546 (void) lseek(fd, (off_t)(id * sizeof(struct dqblk)), L_SET); 547 switch (read(fd, &qup->dqblk, sizeof(struct dqblk))) { 548 case 0: /* EOF */ 549 /* 550 * Convert implicit 0 quota (EOF) 551 * into an explicit one (zero'ed dqblk) 552 */ 553 bzero((caddr_t)&qup->dqblk, sizeof(struct dqblk)); 554 break; 555 case sizeof(struct dqblk): /* OK */ 556 break; 557 default: /* ERROR */ 558 warn("read error: %s", qfpathname); 559 close(fd); 560 return (0); 561 } 562 close(fd); 563 } 564 return (1); 565 } 566 567 static int 568 getnfsquota(struct statfs *fst, struct quotause *qup, long id, int quotatype) 569 { 570 struct getquota_args gq_args; 571 struct getquota_rslt gq_rslt; 572 struct dqblk *dqp = &qup->dqblk; 573 struct timeval tv; 574 char *cp; 575 576 if (fst->f_flags & MNT_LOCAL) 577 return (0); 578 579 /* 580 * rpc.rquotad does not support group quotas 581 */ 582 if (quotatype != USRQUOTA) 583 return (0); 584 585 /* 586 * must be some form of "hostname:/path" 587 */ 588 cp = strchr(fst->f_mntfromname, ':'); 589 if (cp == NULL) { 590 warnx("cannot find hostname for %s", fst->f_mntfromname); 591 return (0); 592 } 593 594 *cp = '\0'; 595 if (*(cp+1) != '/') { 596 *cp = ':'; 597 return (0); 598 } 599 600 gq_args.gqa_pathp = cp + 1; 601 gq_args.gqa_uid = id; 602 if (callaurpc(fst->f_mntfromname, RQUOTAPROG, RQUOTAVERS, 603 RQUOTAPROC_GETQUOTA, xdr_getquota_args, (char *)&gq_args, 604 xdr_getquota_rslt, (char *)&gq_rslt) != 0) { 605 *cp = ':'; 606 return (0); 607 } 608 609 switch (gq_rslt.status) { 610 case Q_NOQUOTA: 611 break; 612 case Q_EPERM: 613 warnx("quota permission error, host: %s", 614 fst->f_mntfromname); 615 break; 616 case Q_OK: 617 gettimeofday(&tv, NULL); 618 /* blocks*/ 619 dqp->dqb_bhardlimit = 620 gq_rslt.getquota_rslt_u.gqr_rquota.rq_bhardlimit * 621 gq_rslt.getquota_rslt_u.gqr_rquota.rq_bsize / DEV_BSIZE; 622 dqp->dqb_bsoftlimit = 623 gq_rslt.getquota_rslt_u.gqr_rquota.rq_bsoftlimit * 624 gq_rslt.getquota_rslt_u.gqr_rquota.rq_bsize / DEV_BSIZE; 625 dqp->dqb_curblocks = 626 gq_rslt.getquota_rslt_u.gqr_rquota.rq_curblocks * 627 gq_rslt.getquota_rslt_u.gqr_rquota.rq_bsize / DEV_BSIZE; 628 /* inodes */ 629 dqp->dqb_ihardlimit = 630 gq_rslt.getquota_rslt_u.gqr_rquota.rq_fhardlimit; 631 dqp->dqb_isoftlimit = 632 gq_rslt.getquota_rslt_u.gqr_rquota.rq_fsoftlimit; 633 dqp->dqb_curinodes = 634 gq_rslt.getquota_rslt_u.gqr_rquota.rq_curfiles; 635 /* grace times */ 636 dqp->dqb_btime = 637 tv.tv_sec + gq_rslt.getquota_rslt_u.gqr_rquota.rq_btimeleft; 638 dqp->dqb_itime = 639 tv.tv_sec + gq_rslt.getquota_rslt_u.gqr_rquota.rq_ftimeleft; 640 *cp = ':'; 641 return (1); 642 default: 643 warnx("bad rpc result, host: %s", fst->f_mntfromname); 644 break; 645 } 646 *cp = ':'; 647 return (0); 648 } 649 650 static int 651 callaurpc(char *host, int prognum, int versnum, int procnum, 652 xdrproc_t inproc, char *in, xdrproc_t outproc, char *out) 653 { 654 struct sockaddr_in server_addr; 655 enum clnt_stat clnt_stat; 656 struct hostent *hp; 657 struct timeval timeout, tottimeout; 658 659 CLIENT *client = NULL; 660 int sock = RPC_ANYSOCK; 661 662 if ((hp = gethostbyname(host)) == NULL) 663 return ((int) RPC_UNKNOWNHOST); 664 timeout.tv_usec = 0; 665 timeout.tv_sec = 6; 666 bcopy(hp->h_addr, &server_addr.sin_addr, 667 MIN(hp->h_length,(int)sizeof(server_addr.sin_addr))); 668 server_addr.sin_family = AF_INET; 669 server_addr.sin_port = 0; 670 671 if ((client = clntudp_create(&server_addr, prognum, 672 versnum, timeout, &sock)) == NULL) 673 return ((int) rpc_createerr.cf_stat); 674 675 client->cl_auth = authunix_create_default(); 676 tottimeout.tv_sec = 25; 677 tottimeout.tv_usec = 0; 678 clnt_stat = clnt_call(client, procnum, inproc, in, 679 outproc, out, tottimeout); 680 681 return ((int) clnt_stat); 682 } 683 684 static int 685 alldigits(char *s) 686 { 687 int c; 688 689 c = *s++; 690 do { 691 if (!isdigit(c)) 692 return (0); 693 } while ((c = *s++)); 694 return (1); 695 } 696