1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25
26 /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
27 /* All Rights Reserved */
28
29 /*
30 * University Copyright- Copyright (c) 1982, 1986, 1988
31 * The Regents of the University of California
32 * All Rights Reserved
33 *
34 * University Acknowledgment- Portions of this document are derived from
35 * software developed by the University of California, Berkeley, and its
36 * contributors.
37 */
38
39 /*
40 * Disk quota reporting program.
41 */
42 #include <stdio.h>
43 #include <sys/mnttab.h>
44 #include <ctype.h>
45 #include <pwd.h>
46 #include <errno.h>
47 #include <fcntl.h>
48 #include <memory.h>
49 #include <sys/time.h>
50 #include <sys/param.h>
51 #include <sys/types.h>
52 #include <sys/sysmacros.h>
53 #include <sys/mntent.h>
54 #include <sys/file.h>
55 #include <sys/stat.h>
56 #include <sys/fs/ufs_quota.h>
57 #include <priv_utils.h>
58 #include <locale.h>
59 #include <rpc/rpc.h>
60 #include <netdb.h>
61 #include <rpcsvc/rquota.h>
62 #include <zone.h>
63 #include "../../nfs/lib/replica.h"
64 #include <dlfcn.h>
65 #include <libzfs.h>
66
67 int vflag;
68 int nolocalquota;
69
70 extern int optind;
71 extern char *optarg;
72
73 #define QFNAME "quotas"
74
75 #if DEV_BSIZE < 1024
76 #define kb(x) ((x) / (1024 / DEV_BSIZE))
77 #else
78 #define kb(x) ((x) * (DEV_BSIZE / 1024))
79 #endif
80
81 #if !defined(TEXT_DOMAIN) /* Should be defined by cc -D */
82 #define TEXT_DOMAIN "SYS_TEST" /* Use this only if it weren't */
83 #endif
84
85 static void zexit(int);
86 static int getzfsquota(char *, char *, struct dqblk *);
87 static int getnfsquota(char *, char *, uid_t, struct dqblk *);
88 static void showuid(uid_t);
89 static void showquotas(uid_t, char *);
90 static void warn(struct mnttab *, struct dqblk *);
91 static void heading(uid_t, char *);
92 static void prquota(struct mnttab *, struct dqblk *);
93 static void fmttime(char *, long);
94
95 static libzfs_handle_t *(*_libzfs_init)(void);
96 static void (*_libzfs_fini)(libzfs_handle_t *);
97 static zfs_handle_t *(*_zfs_open)(libzfs_handle_t *, const char *, int);
98 static void (*_zfs_close)(zfs_handle_t *);
99 static int (*_zfs_prop_get_userquota_int)(zfs_handle_t *, const char *,
100 uint64_t *);
101 static libzfs_handle_t *g_zfs = NULL;
102
103 /*
104 * Dynamically check for libzfs, in case the user hasn't installed the SUNWzfs
105 * packages. 'quota' utility supports zfs as an option.
106 */
107 static void
108 load_libzfs(void)
109 {
110 void *hdl;
111
112 if (g_zfs != NULL)
113 return;
114
115 if ((hdl = dlopen("libzfs.so", RTLD_LAZY)) != NULL) {
116 _libzfs_init = (libzfs_handle_t *(*)(void))dlsym(hdl,
117 "libzfs_init");
118 _libzfs_fini = (void (*)())dlsym(hdl, "libzfs_fini");
119 _zfs_open = (zfs_handle_t *(*)())dlsym(hdl, "zfs_open");
120 _zfs_close = (void (*)())dlsym(hdl, "zfs_close");
121 _zfs_prop_get_userquota_int = (int (*)())
122 dlsym(hdl, "zfs_prop_get_userquota_int");
123
124 if (_libzfs_init && _libzfs_fini && _zfs_open &&
125 _zfs_close && _zfs_prop_get_userquota_int)
126 g_zfs = _libzfs_init();
127 }
128 }
129
130 int
131 main(int argc, char *argv[])
132 {
133 int opt;
134 int i;
135 int status = 0;
136
137 (void) setlocale(LC_ALL, "");
138 (void) textdomain(TEXT_DOMAIN);
139
140 /*
141 * PRIV_FILE_DAC_READ is needed to read the QFNAME file
142 * Clear all other privleges from the limit set, and add
143 * the required privilege to the bracketed set.
144 */
145
146 if (__init_suid_priv(PU_CLEARLIMITSET, PRIV_FILE_DAC_READ,
147 NULL) == -1) {
148 (void) fprintf(stderr,
149 gettext("Insufficient privileges, "
150 "quota must be set-uid root or have "
151 "file_dac_read privileges\n"));
152
153 exit(1);
154 }
155
156 load_libzfs();
157
158 while ((opt = getopt(argc, argv, "vV")) != EOF) {
159 switch (opt) {
160
161 case 'v':
162 vflag++;
163 break;
164
165 case 'V': /* Print command line */
166 {
167 char *opt_text;
168 int opt_count;
169
170 (void) fprintf(stdout, "quota -F UFS ");
171 for (opt_count = 1; opt_count < argc; opt_count++) {
172 opt_text = argv[opt_count];
173 if (opt_text)
174 (void) fprintf(stdout, " %s ",
175 opt_text);
176 }
177 (void) fprintf(stdout, "\n");
178 }
179 break;
180
181 case '?':
182 fprintf(stderr, "usage: quota [-v] [username]\n");
183 zexit(32);
184 }
185 }
186 if (quotactl(Q_ALLSYNC, NULL, (uid_t)0, NULL) < 0 && errno == EINVAL) {
187 if (vflag)
188 fprintf(stderr, "There are no quotas on this system\n");
189 nolocalquota++;
190 }
191 if (argc == optind) {
192 showuid(getuid());
193 zexit(0);
194 }
195 for (i = optind; i < argc; i++) {
196 if (alldigits(argv[i])) {
197 showuid((uid_t)atoi(argv[i]));
198 } else
199 status |= showname(argv[i]);
200 }
201 __priv_relinquish();
202 return (status);
203 }
204
205 static void
206 showuid(uid_t uid)
207 {
208 struct passwd *pwd = getpwuid(uid);
209
210 if (uid == 0) {
211 if (vflag)
212 printf("no disk quota for uid 0\n");
213 return;
214 }
215 if (pwd == NULL)
216 showquotas(uid, "(no account)");
217 else
218 showquotas(uid, pwd->pw_name);
219 }
220
221 int
222 showname(char *name)
223 {
224 struct passwd *pwd = getpwnam(name);
225
226 if (pwd == NULL) {
227 fprintf(stderr, "quota: %s: unknown user\n", name);
228 return (32);
229 }
230 if (pwd->pw_uid == 0) {
231 if (vflag)
232 printf("no disk quota for %s (uid 0)\n", name);
233 return (0);
234 }
235 showquotas(pwd->pw_uid, name);
236 return (0);
237 }
238
239 static void
240 showquotas(uid_t uid, char *name)
241 {
242 struct mnttab mnt;
243 FILE *mtab;
244 struct dqblk dqblk;
245 uid_t myuid;
246 struct failed_srv {
247 char *serv_name;
248 struct failed_srv *next;
249 };
250 struct failed_srv *failed_srv_list = NULL;
251 int rc;
252 char my_zonename[ZONENAME_MAX];
253 zoneid_t my_zoneid = getzoneid();
254
255 myuid = getuid();
256 if (uid != myuid && myuid != 0) {
257 printf("quota: %s (uid %d): permission denied\n", name, uid);
258 zexit(32);
259 }
260
261 memset(my_zonename, '\0', ZONENAME_MAX);
262 getzonenamebyid(my_zoneid, my_zonename, ZONENAME_MAX);
263
264 if (vflag)
265 heading(uid, name);
266 mtab = fopen(MNTTAB, "r");
267 while (getmntent(mtab, &mnt) == NULL) {
268 if (strcmp(mnt.mnt_fstype, MNTTYPE_ZFS) == 0) {
269 bzero(&dqblk, sizeof (dqblk));
270 if (getzfsquota(name, mnt.mnt_special, &dqblk))
271 continue;
272 } else if (strcmp(mnt.mnt_fstype, MNTTYPE_UFS) == 0) {
273 if (nolocalquota ||
274 (quotactl(Q_GETQUOTA,
275 mnt.mnt_mountp, uid, &dqblk) != 0 &&
276 !(vflag && getdiskquota(&mnt, uid, &dqblk))))
277 continue;
278 } else if (strcmp(mnt.mnt_fstype, MNTTYPE_NFS) == 0) {
279
280 struct replica *rl;
281 int count;
282 char *mntopt = NULL;
283
284 /*
285 * Skip checking quotas for file systems mounted
286 * in other zones. Zone names will be passed in
287 * following format from hasmntopt():
288 * "zone=<zone-name>,<mnt options...>"
289 */
290 if ((mntopt = hasmntopt(&mnt, MNTOPT_ZONE)) &&
291 (my_zonename[0] != '\0')) {
292 mntopt += strcspn(mntopt, "=") + 1;
293 if (strncmp(mntopt, my_zonename,
294 strcspn(mntopt, ",")) != 0)
295 continue;
296 }
297
298 if (hasopt(MNTOPT_NOQUOTA, mnt.mnt_mntopts))
299 continue;
300
301 /*
302 * Skip quota processing if mounted with public
303 * option. We are not likely to be able to pierce
304 * a fire wall to contact the quota server.
305 */
306 if (hasopt(MNTOPT_PUBLIC, mnt.mnt_mntopts))
307 continue;
308
309 rl = parse_replica(mnt.mnt_special, &count);
310
311 if (rl == NULL) {
312
313 if (count < 0)
314 fprintf(stderr, "cannot find hostname "
315 "and/or pathname for %s\n",
316 mnt.mnt_mountp);
317 else
318 fprintf(stderr, "no memory to parse "
319 "mnttab entry for %s\n",
320 mnt.mnt_mountp);
321 continue;
322 }
323
324 /*
325 * We skip quota reporting on mounts with replicas
326 * for the following reasons:
327 *
328 * (1) Very little point in reporting quotas on
329 * a set of read-only replicas ... how will the
330 * user correct the problem?
331 *
332 * (2) Which replica would we report the quota
333 * for? If we pick the current replica, what
334 * happens when a fail over event occurs? The
335 * next time quota is run, the quota will look
336 * all different, or there won't even be one.
337 * This has the potential to break scripts.
338 *
339 * If we prnt quouta for all replicas, how do
340 * we present the output without breaking scripts?
341 */
342
343 if (count > 1) {
344 free_replica(rl, count);
345 continue;
346 }
347
348 /*
349 * Skip file systems mounted using public fh.
350 * We are not likely to be able to pierce
351 * a fire wall to contact the quota server.
352 */
353 if (strcmp(rl[0].host, "nfs") == 0 &&
354 strncmp(rl[0].path, "//", 2) == 0) {
355 free_replica(rl, count);
356 continue;
357 }
358
359 /*
360 * Skip getting quotas from failing servers
361 */
362 if (failed_srv_list != NULL) {
363 struct failed_srv *tmp_list;
364 int found_failed = 0;
365 size_t len = strlen(rl[0].host);
366
367 tmp_list = failed_srv_list;
368 do {
369 if (strncasecmp(rl[0].host,
370 tmp_list->serv_name, len) == 0) {
371 found_failed = 1;
372 break;
373 }
374 } while ((tmp_list = tmp_list->next) != NULL);
375 if (found_failed) {
376 free_replica(rl, count);
377 continue;
378 }
379 }
380
381 rc = getnfsquota(rl[0].host, rl[0].path, uid, &dqblk);
382 if (rc != RPC_SUCCESS) {
383 size_t len;
384 struct failed_srv *tmp_srv;
385
386 /*
387 * Failed to get quota from this server. Add
388 * this server to failed_srv_list and skip
389 * getting quotas for other mounted filesystems
390 * from this server.
391 */
392 if (rc == RPC_TIMEDOUT || rc == RPC_CANTSEND) {
393 len = strlen(rl[0].host);
394 tmp_srv = (struct failed_srv *)malloc(
395 sizeof (struct failed_srv));
396 tmp_srv->serv_name = (char *)malloc(
397 len * sizeof (char) + 1);
398 strncpy(tmp_srv->serv_name, rl[0].host,
399 len);
400 tmp_srv->serv_name[len] = '\0';
401
402 tmp_srv->next = failed_srv_list;
403 failed_srv_list = tmp_srv;
404 }
405
406 free_replica(rl, count);
407 continue;
408 }
409
410 free_replica(rl, count);
411 } else {
412 continue;
413 }
414 if (dqblk.dqb_bsoftlimit == 0 && dqblk.dqb_bhardlimit == 0 &&
415 dqblk.dqb_fsoftlimit == 0 && dqblk.dqb_fhardlimit == 0)
416 continue;
417 if (vflag)
418 prquota(&mnt, &dqblk);
419 else
420 warn(&mnt, &dqblk);
421 }
422
423 /*
424 * Free list of failed servers
425 */
426 while (failed_srv_list != NULL) {
427 struct failed_srv *tmp_srv = failed_srv_list;
428
429 failed_srv_list = failed_srv_list->next;
430 free(tmp_srv->serv_name);
431 free(tmp_srv);
432 }
433
434 fclose(mtab);
435 }
436
437 static void
438 warn(struct mnttab *mntp, struct dqblk *dqp)
439 {
440 struct timeval tv;
441
442 time(&(tv.tv_sec));
443 tv.tv_usec = 0;
444 if (dqp->dqb_bhardlimit &&
445 dqp->dqb_curblocks >= dqp->dqb_bhardlimit) {
446 printf("Block limit reached on %s\n", mntp->mnt_mountp);
447 } else if (dqp->dqb_bsoftlimit &&
448 dqp->dqb_curblocks >= dqp->dqb_bsoftlimit) {
449 if (dqp->dqb_btimelimit == 0) {
450 printf("Over disk quota on %s, remove %luK\n",
451 mntp->mnt_mountp,
452 kb(dqp->dqb_curblocks - dqp->dqb_bsoftlimit + 1));
453 } else if (dqp->dqb_btimelimit > tv.tv_sec) {
454 char btimeleft[80];
455
456 fmttime(btimeleft, dqp->dqb_btimelimit - tv.tv_sec);
457 printf("Over disk quota on %s, remove %luK within %s\n",
458 mntp->mnt_mountp,
459 kb(dqp->dqb_curblocks - dqp->dqb_bsoftlimit + 1),
460 btimeleft);
461 } else {
462 printf(
463 "Over disk quota on %s, time limit has expired, remove %luK\n",
464 mntp->mnt_mountp,
465 kb(dqp->dqb_curblocks - dqp->dqb_bsoftlimit + 1));
466 }
467 }
468 if (dqp->dqb_fhardlimit &&
469 dqp->dqb_curfiles >= dqp->dqb_fhardlimit) {
470 printf("File count limit reached on %s\n", mntp->mnt_mountp);
471 } else if (dqp->dqb_fsoftlimit &&
472 dqp->dqb_curfiles >= dqp->dqb_fsoftlimit) {
473 if (dqp->dqb_ftimelimit == 0) {
474 printf("Over file quota on %s, remove %lu file%s\n",
475 mntp->mnt_mountp,
476 dqp->dqb_curfiles - dqp->dqb_fsoftlimit + 1,
477 ((dqp->dqb_curfiles - dqp->dqb_fsoftlimit + 1) > 1 ?
478 "s" : ""));
479 } else if (dqp->dqb_ftimelimit > tv.tv_sec) {
480 char ftimeleft[80];
481
482 fmttime(ftimeleft, dqp->dqb_ftimelimit - tv.tv_sec);
483 printf(
484 "Over file quota on %s, remove %lu file%s within %s\n",
485 mntp->mnt_mountp,
486 dqp->dqb_curfiles - dqp->dqb_fsoftlimit + 1,
487 ((dqp->dqb_curfiles - dqp->dqb_fsoftlimit + 1) > 1 ?
488 "s" : ""), ftimeleft);
489 } else {
490 printf(
491 "Over file quota on %s, time limit has expired, remove %lu file%s\n",
492 mntp->mnt_mountp,
493 dqp->dqb_curfiles - dqp->dqb_fsoftlimit + 1,
494 ((dqp->dqb_curfiles - dqp->dqb_fsoftlimit + 1) > 1 ?
495 "s" : ""));
496 }
497 }
498 }
499
500 static void
501 heading(uid_t uid, char *name)
502 {
503 printf("Disk quotas for %s (uid %ld):\n", name, (long)uid);
504 printf("%-12s %7s%7s%7s%12s%7s%7s%7s%12s\n",
505 "Filesystem",
506 "usage",
507 "quota",
508 "limit",
509 "timeleft",
510 "files",
511 "quota",
512 "limit",
513 "timeleft");
514 }
515
516 static void
517 prquota(struct mnttab *mntp, struct dqblk *dqp)
518 {
519 struct timeval tv;
520 char ftimeleft[80], btimeleft[80];
521 char *cp;
522
523 time(&(tv.tv_sec));
524 tv.tv_usec = 0;
525 if (dqp->dqb_bsoftlimit && dqp->dqb_curblocks >= dqp->dqb_bsoftlimit) {
526 if (dqp->dqb_btimelimit == 0) {
527 strlcpy(btimeleft, "NOT STARTED", sizeof (btimeleft));
528 } else if (dqp->dqb_btimelimit > tv.tv_sec) {
529 fmttime(btimeleft, dqp->dqb_btimelimit - tv.tv_sec);
530 } else {
531 strlcpy(btimeleft, "EXPIRED", sizeof (btimeleft));
532 }
533 } else {
534 btimeleft[0] = '\0';
535 }
536 if (dqp->dqb_fsoftlimit && dqp->dqb_curfiles >= dqp->dqb_fsoftlimit) {
537 if (dqp->dqb_ftimelimit == 0) {
538 strlcpy(ftimeleft, "NOT STARTED", sizeof (ftimeleft));
539 } else if (dqp->dqb_ftimelimit > tv.tv_sec) {
540 fmttime(ftimeleft, dqp->dqb_ftimelimit - tv.tv_sec);
541 } else {
542 strlcpy(ftimeleft, "EXPIRED", sizeof (ftimeleft));
543 }
544 } else {
545 ftimeleft[0] = '\0';
546 }
547 if (strlen(mntp->mnt_mountp) > 12) {
548 printf("%s\n", mntp->mnt_mountp);
549 cp = "";
550 } else {
551 cp = mntp->mnt_mountp;
552 }
553
554 if (dqp->dqb_curfiles == 0 &&
555 dqp->dqb_fsoftlimit == 0 && dqp->dqb_fhardlimit == 0) {
556 printf("%-12.12s %7d %6d %6d %11s %6s %6s %6s %11s\n",
557 cp,
558 kb(dqp->dqb_curblocks),
559 kb(dqp->dqb_bsoftlimit),
560 kb(dqp->dqb_bhardlimit),
561 "-",
562 "-",
563 "-",
564 "-",
565 "-");
566 } else {
567 printf("%-12.12s %7d %6d %6d %11s %6d %6d %6d %11s\n",
568 cp,
569 kb(dqp->dqb_curblocks),
570 kb(dqp->dqb_bsoftlimit),
571 kb(dqp->dqb_bhardlimit),
572 btimeleft,
573 dqp->dqb_curfiles,
574 dqp->dqb_fsoftlimit,
575 dqp->dqb_fhardlimit,
576 ftimeleft);
577 }
578 }
579
580 static void
581 fmttime(char *buf, long time)
582 {
583 int i;
584 static struct {
585 int c_secs; /* conversion units in secs */
586 char *c_str; /* unit string */
587 } cunits [] = {
588 {60*60*24*28, "months"},
589 {60*60*24*7, "weeks"},
590 {60*60*24, "days"},
591 {60*60, "hours"},
592 {60, "mins"},
593 {1, "secs"}
594 };
595
596 if (time <= 0) {
597 strlcpy(buf, "EXPIRED", sizeof (*buf));
598 return;
599 }
600 for (i = 0; i < sizeof (cunits)/sizeof (cunits[0]); i++) {
601 if (time >= cunits[i].c_secs)
602 break;
603 }
604 snprintf(buf, sizeof (*buf), "%.1f %s",
605 (double)time/cunits[i].c_secs, cunits[i].c_str);
606 }
607
608 int
609 alldigits(char *s)
610 {
611 int c;
612
613 c = *s++;
614 do {
615 if (!isdigit(c))
616 return (0);
617 } while (c = *s++);
618 return (1);
619 }
620
621 int
622 getdiskquota(struct mnttab *mntp, uid_t uid, struct dqblk *dqp)
623 {
624 int fd;
625 dev_t fsdev;
626 struct stat64 statb;
627 char qfilename[MAXPATHLEN];
628
629 if (stat64(mntp->mnt_special, &statb) < 0 ||
630 (statb.st_mode & S_IFMT) != S_IFBLK)
631 return (0);
632 fsdev = statb.st_rdev;
633 (void) snprintf(qfilename, sizeof (qfilename), "%s/%s",
634 mntp->mnt_mountp, QFNAME);
635 if (stat64(qfilename, &statb) < 0 || statb.st_dev != fsdev)
636 return (0);
637 (void) __priv_bracket(PRIV_ON);
638 fd = open64(qfilename, O_RDONLY);
639 (void) __priv_bracket(PRIV_OFF);
640 if (fd < 0)
641 return (0);
642 (void) llseek(fd, (offset_t)dqoff(uid), L_SET);
643 switch (read(fd, dqp, sizeof (struct dqblk))) {
644 case 0: /* EOF */
645 /*
646 * Convert implicit 0 quota (EOF)
647 * into an explicit one (zero'ed dqblk).
648 */
649 memset((caddr_t)dqp, 0, sizeof (struct dqblk));
650 break;
651
652 case sizeof (struct dqblk): /* OK */
653 break;
654
655 default: /* ERROR */
656 close(fd);
657 return (0);
658 }
659 close(fd);
660 return (1);
661 }
662
663 int
664 quotactl(int cmd, char *mountp, uid_t uid, caddr_t addr)
665 {
666 int fd;
667 int status;
668 struct quotctl quota;
669 char qfile[MAXPATHLEN];
670
671 FILE *fstab;
672 struct mnttab mnt;
673
674
675 if ((mountp == NULL) && (cmd == Q_ALLSYNC)) {
676 /*
677 * Find the mount point of any mounted file system. This is
678 * because the ioctl that implements the quotactl call has
679 * to go to a real file, and not to the block device.
680 */
681 if ((fstab = fopen(MNTTAB, "r")) == NULL) {
682 fprintf(stderr, "%s: ", MNTTAB);
683 perror("open");
684 zexit(32);
685 }
686 fd = -1;
687 while ((status = getmntent(fstab, &mnt)) == NULL) {
688 if (strcmp(mnt.mnt_fstype, MNTTYPE_UFS) != 0 ||
689 hasopt(MNTOPT_RO, mnt.mnt_mntopts))
690 continue;
691 if ((strlcpy(qfile, mnt.mnt_mountp,
692 sizeof (qfile)) >= sizeof (qfile)) ||
693 (strlcat(qfile, "/" QFNAME, sizeof (qfile)) >=
694 sizeof (qfile))) {
695 continue;
696 }
697 (void) __priv_bracket(PRIV_ON);
698 fd = open64(qfile, O_RDONLY);
699 (void) __priv_bracket(PRIV_OFF);
700 if (fd != -1)
701 break;
702 }
703 fclose(fstab);
704 if (fd == -1) {
705 errno = ENOENT;
706 return (-1);
707 }
708 } else {
709 if (mountp == NULL || mountp[0] == '\0') {
710 errno = ENOENT;
711 return (-1);
712 }
713 if ((strlcpy(qfile, mountp, sizeof (qfile)) >= sizeof
714 (qfile)) ||
715 (strlcat(qfile, "/" QFNAME, sizeof (qfile)) >= sizeof
716 (qfile))) {
717 errno = ENOENT;
718 return (-1);
719 }
720 (void) __priv_bracket(PRIV_ON);
721 fd = open64(qfile, O_RDONLY);
722 (void) __priv_bracket(PRIV_OFF);
723 if (fd < 0)
724 return (-1);
725 } /* else */
726 quota.op = cmd;
727 quota.uid = uid;
728 quota.addr = addr;
729 status = ioctl(fd, Q_QUOTACTL, "a);
730 if (fd != 0)
731 close(fd);
732 return (status);
733 }
734
735
736 /*
737 * Return 1 if opt appears in optlist
738 */
739 int
740 hasopt(char *opt, char *optlist)
741 {
742 char *value;
743 char *opts[2];
744
745 opts[0] = opt;
746 opts[1] = NULL;
747
748 if (optlist == NULL)
749 return (0);
750 while (*optlist != '\0') {
751 if (getsubopt(&optlist, opts, &value) == 0)
752 return (1);
753 }
754 return (0);
755 }
756
757 /*
758 * If there are no quotas available, then getnfsquota() returns
759 * RPC_SYSTEMERROR to caller.
760 */
761 static int
762 getnfsquota(char *hostp, char *path, uid_t uid, struct dqblk *dqp)
763 {
764 struct getquota_args gq_args;
765 struct getquota_rslt gq_rslt;
766 struct rquota *rquota;
767 extern char *strchr();
768 int rpc_err;
769
770 gq_args.gqa_pathp = path;
771 gq_args.gqa_uid = uid;
772 rpc_err = callaurpc(hostp, RQUOTAPROG, RQUOTAVERS,
773 (vflag? RQUOTAPROC_GETQUOTA: RQUOTAPROC_GETACTIVEQUOTA),
774 xdr_getquota_args, &gq_args, xdr_getquota_rslt, &gq_rslt);
775 if (rpc_err != RPC_SUCCESS) {
776 return (rpc_err);
777 }
778 switch (gq_rslt.status) {
779 case Q_OK:
780 {
781 struct timeval tv;
782 u_longlong_t limit;
783
784 rquota = &gq_rslt.getquota_rslt_u.gqr_rquota;
785
786 if (!vflag && rquota->rq_active == FALSE) {
787 return (RPC_SYSTEMERROR);
788 }
789 gettimeofday(&tv, NULL);
790 limit = (u_longlong_t)(rquota->rq_bhardlimit) *
791 rquota->rq_bsize / DEV_BSIZE;
792 dqp->dqb_bhardlimit = limit;
793 limit = (u_longlong_t)(rquota->rq_bsoftlimit) *
794 rquota->rq_bsize / DEV_BSIZE;
795 dqp->dqb_bsoftlimit = limit;
796 limit = (u_longlong_t)(rquota->rq_curblocks) *
797 rquota->rq_bsize / DEV_BSIZE;
798 dqp->dqb_curblocks = limit;
799 dqp->dqb_fhardlimit = rquota->rq_fhardlimit;
800 dqp->dqb_fsoftlimit = rquota->rq_fsoftlimit;
801 dqp->dqb_curfiles = rquota->rq_curfiles;
802 dqp->dqb_btimelimit =
803 tv.tv_sec + rquota->rq_btimeleft;
804 dqp->dqb_ftimelimit =
805 tv.tv_sec + rquota->rq_ftimeleft;
806 return (RPC_SUCCESS);
807 }
808
809 case Q_NOQUOTA:
810 return (RPC_SYSTEMERROR);
811
812 case Q_EPERM:
813 fprintf(stderr, "quota permission error, host: %s\n", hostp);
814 return (RPC_AUTHERROR);
815
816 default:
817 fprintf(stderr, "bad rpc result, host: %s\n", hostp);
818 return (RPC_CANTDECODEARGS);
819 }
820
821 /* NOTREACHED */
822 }
823
824 int
825 callaurpc(char *host, int prognum, int versnum, int procnum,
826 xdrproc_t inproc, char *in, xdrproc_t outproc, char *out)
827 {
828 static enum clnt_stat clnt_stat;
829 struct timeval tottimeout = {20, 0};
830
831 static CLIENT *cl = NULL;
832 static int oldprognum, oldversnum;
833 static char oldhost[MAXHOSTNAMELEN+1];
834
835 /*
836 * Cache the client handle in case there are lots
837 * of entries in the /etc/mnttab for the same
838 * server. If the server returns an error, don't
839 * make further calls.
840 */
841 if (cl == NULL || oldprognum != prognum || oldversnum != versnum ||
842 strcmp(oldhost, host) != 0) {
843 if (cl) {
844 clnt_destroy(cl);
845 cl = NULL;
846 }
847 cl = clnt_create_timed(host, prognum, versnum, "udp",
848 &tottimeout);
849 if (cl == NULL)
850 return ((int)RPC_TIMEDOUT);
851 if ((cl->cl_auth = authunix_create_default()) == NULL) {
852 clnt_destroy(cl);
853 return (RPC_CANTSEND);
854 }
855 oldprognum = prognum;
856 oldversnum = versnum;
857 (void) strlcpy(oldhost, host, sizeof (oldhost));
858 clnt_stat = RPC_SUCCESS;
859 }
860
861 if (clnt_stat != RPC_SUCCESS)
862 return ((int)clnt_stat); /* don't bother retrying */
863
864 clnt_stat = clnt_call(cl, procnum, inproc, in,
865 outproc, out, tottimeout);
866
867 return ((int)clnt_stat);
868 }
869
870 static int
871 getzfsquota(char *user, char *dataset, struct dqblk *zq)
872 {
873 zfs_handle_t *zhp = NULL;
874 char propname[ZFS_MAXPROPLEN];
875 uint64_t userquota, userused;
876
877 if (g_zfs == NULL)
878 return (1);
879
880 if ((zhp = _zfs_open(g_zfs, dataset, ZFS_TYPE_DATASET)) == NULL)
881 return (1);
882
883 (void) snprintf(propname, sizeof (propname), "userquota@%s", user);
884 if (_zfs_prop_get_userquota_int(zhp, propname, &userquota) != 0) {
885 _zfs_close(zhp);
886 return (1);
887 }
888
889 (void) snprintf(propname, sizeof (propname), "userused@%s", user);
890 if (_zfs_prop_get_userquota_int(zhp, propname, &userused) != 0) {
891 _zfs_close(zhp);
892 return (1);
893 }
894
895 zq->dqb_bhardlimit = userquota / DEV_BSIZE;
896 zq->dqb_bsoftlimit = userquota / DEV_BSIZE;
897 zq->dqb_curblocks = userused / DEV_BSIZE;
898 _zfs_close(zhp);
899 return (0);
900 }
901
902 static void
903 zexit(int n)
904 {
905 if (g_zfs != NULL)
906 _libzfs_fini(g_zfs);
907 exit(n);
908 }