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