ufs/quota/quota.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*  Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
/*    All Rights Reserved   */

/*
 * University Copyright- Copyright (c) 1982, 1986, 1988
 * The Regents of the University of California
 * All Rights Reserved
 *
 * University Acknowledgment- Portions of this document are derived from
 * software developed by the University of California, Berkeley, and its
 * contributors.
 */

/*
 * Disk quota reporting program.
 */
#include <stdio.h>
#include <sys/mnttab.h>
#include <ctype.h>
#include <pwd.h>
#include <errno.h>
#include <fcntl.h>
#include <memory.h>
#include <sys/time.h>
#include <sys/param.h>
#include <sys/types.h>
#include <sys/sysmacros.h>
#include <sys/mntent.h>
#include <sys/file.h>
#include <sys/stat.h>
#include <sys/fs/ufs_quota.h>
#include <priv_utils.h>
#include <locale.h>
#include <rpc/rpc.h>
#include <netdb.h>
#include <rpcsvc/rquota.h>
#include <zone.h>
#include "../../nfs/lib/replica.h"
#include <dlfcn.h>
#include <libzfs.h>

int vflag;
int nolocalquota;

extern int  optind;
extern char *optarg;

#define QFNAME  "quotas"

#if DEV_BSIZE < 1024
#define kb(x)   ((x) / (1024 / DEV_BSIZE))
#else
#define kb(x)   ((x) * (DEV_BSIZE / 1024))
#endif

#if !defined(TEXT_DOMAIN)   /* Should be defined by cc -D */
#define TEXT_DOMAIN "SYS_TEST"  /* Use this only if it weren't */
#endif

static void zexit(int);
static int getzfsquota(char *, char *, struct dqblk *);
static int getnfsquota(char *, char *, uid_t, struct dqblk *);
static void showuid(uid_t);
static void showquotas(uid_t, char *);
static void warn(struct mnttab *, struct dqblk *);
static void heading(uid_t, char *);
static void prquota(struct mnttab *, struct dqblk *);
static void fmttime(char *, long);

static libzfs_handle_t *(*_libzfs_init)(void);
static void (*_libzfs_fini)(libzfs_handle_t *);
static zfs_handle_t *(*_zfs_open)(libzfs_handle_t *, const char *, int);
static void (*_zfs_close)(zfs_handle_t *);
static int (*_zfs_prop_get_userquota_int)(zfs_handle_t *, const char *,
    uint64_t *);
static libzfs_handle_t *g_zfs = NULL;

/*
 * Dynamically check for libzfs, in case the user hasn't installed the SUNWzfs
 * packages.  'quota' utility supports zfs as an option.
 */
static void
load_libzfs(void)
{
    void *hdl;

    if (g_zfs != NULL)
        return;

    if ((hdl = dlopen("libzfs.so", RTLD_LAZY)) != NULL) {
        _libzfs_init = (libzfs_handle_t *(*)(void))dlsym(hdl,
            "libzfs_init");
        _libzfs_fini = (void (*)())dlsym(hdl, "libzfs_fini");
        _zfs_open = (zfs_handle_t *(*)())dlsym(hdl, "zfs_open");
        _zfs_close = (void (*)())dlsym(hdl, "zfs_close");
        _zfs_prop_get_userquota_int = (int (*)())
            dlsym(hdl, "zfs_prop_get_userquota_int");

        if (_libzfs_init && _libzfs_fini && _zfs_open &&
            _zfs_close && _zfs_prop_get_userquota_int)
            g_zfs = _libzfs_init();
    }
}

int
main(int argc, char *argv[])
{
    int opt;
    int i;
    int status = 0;

    (void) setlocale(LC_ALL, "");
    (void) textdomain(TEXT_DOMAIN);

    /*
     * PRIV_FILE_DAC_READ is needed to read the QFNAME file
     * Clear all other privleges from the limit set, and add
     * the required privilege to the bracketed set.
     */

    if (__init_suid_priv(PU_CLEARLIMITSET, PRIV_FILE_DAC_READ,
        NULL) == -1) {
        (void) fprintf(stderr,
            gettext("Insufficient privileges, "
            "quota must be set-uid root or have "
            "file_dac_read privileges\n"));

        exit(1);
    }

    load_libzfs();

    while ((opt = getopt(argc, argv, "vV")) != EOF) {
        switch (opt) {

        case 'v':
            vflag++;
            break;

        case 'V':       /* Print command line */
            {
            char    *opt_text;
            int opt_count;

            (void) fprintf(stdout, "quota -F UFS ");
            for (opt_count = 1; opt_count < argc; opt_count++) {
                opt_text = argv[opt_count];
                if (opt_text)
                    (void) fprintf(stdout, " %s ",
                        opt_text);
            }
            (void) fprintf(stdout, "\n");
            }
            break;

        case '?':
            fprintf(stderr, "usage: quota [-v] [username]\n");
            zexit(32);
        }
    }
    if (quotactl(Q_ALLSYNC, NULL, (uid_t)0, NULL) < 0 && errno == EINVAL) {
        if (vflag)
            fprintf(stderr, "There are no quotas on this system\n");
        nolocalquota++;
    }
    if (argc == optind) {
        showuid(getuid());
        zexit(0);
    }
    for (i = optind; i < argc; i++) {
        if (alldigits(argv[i])) {
            showuid((uid_t)atoi(argv[i]));
        } else
            status |= showname(argv[i]);
    }
    __priv_relinquish();
    return (status);
}

static void
showuid(uid_t uid)
{
    struct passwd *pwd = getpwuid(uid);

    if (uid == 0) {
        if (vflag)
            printf("no disk quota for uid 0\n");
        return;
    }
    if (pwd == NULL)
        showquotas(uid, "(no account)");
    else
        showquotas(uid, pwd->pw_name);
}

int
showname(char *name)
{
    struct passwd *pwd = getpwnam(name);

    if (pwd == NULL) {
        fprintf(stderr, "quota: %s: unknown user\n", name);
        return (32);
    }
    if (pwd->pw_uid == 0) {
        if (vflag)
            printf("no disk quota for %s (uid 0)\n", name);
        return (0);
    }
    showquotas(pwd->pw_uid, name);
    return (0);
}

static void
showquotas(uid_t uid, char *name)
{
    struct mnttab mnt;
    FILE *mtab;
    struct dqblk dqblk;
    uid_t myuid;
    struct failed_srv {
        char *serv_name;
        struct failed_srv *next;
    };
    struct failed_srv *failed_srv_list = NULL;
    int rc;
    char    my_zonename[ZONENAME_MAX];
    zoneid_t my_zoneid = getzoneid();

    myuid = getuid();
    if (uid != myuid && myuid != 0) {
        printf("quota: %s (uid %d): permission denied\n", name, uid);
        zexit(32);
    }

    memset(my_zonename, '\0', ZONENAME_MAX);
    getzonenamebyid(my_zoneid, my_zonename, ZONENAME_MAX);

    if (vflag)
        heading(uid, name);
    mtab = fopen(MNTTAB, "r");
    while (getmntent(mtab, &mnt) == NULL) {
        if (strcmp(mnt.mnt_fstype, MNTTYPE_ZFS) == 0) {
            bzero(&dqblk, sizeof (dqblk));
            if (getzfsquota(name, mnt.mnt_special, &dqblk))
                continue;
        } else if (strcmp(mnt.mnt_fstype, MNTTYPE_UFS) == 0) {
            if (nolocalquota ||
                (quotactl(Q_GETQUOTA,
                mnt.mnt_mountp, uid, &dqblk) != 0 &&
                !(vflag && getdiskquota(&mnt, uid, &dqblk))))
                continue;
        } else if (strcmp(mnt.mnt_fstype, MNTTYPE_NFS) == 0) {

            struct replica *rl;
            int count;
            char *mntopt = NULL;

            /*
             * Skip checking quotas for file systems mounted
             * in other zones. Zone names will be passed in
             * following format from hasmntopt():
             * "zone=<zone-name>,<mnt options...>"
             */
            if ((mntopt = hasmntopt(&mnt, MNTOPT_ZONE)) &&
                (my_zonename[0] != '\0')) {
                mntopt += strcspn(mntopt, "=") + 1;
                if (strncmp(mntopt, my_zonename,
                    strcspn(mntopt, ",")) != 0)
                    continue;
            }

            if (hasopt(MNTOPT_NOQUOTA, mnt.mnt_mntopts))
                continue;

            /*
             * Skip quota processing if mounted with public
             * option. We are not likely to be able to pierce
             * a fire wall to contact the quota server.
             */
            if (hasopt(MNTOPT_PUBLIC, mnt.mnt_mntopts))
                continue;

            rl = parse_replica(mnt.mnt_special, &count);

            if (rl == NULL) {

                if (count < 0)
                    fprintf(stderr, "cannot find hostname "
                        "and/or pathname for %s\n",
                        mnt.mnt_mountp);
                else
                    fprintf(stderr, "no memory to parse "
                        "mnttab entry for %s\n",
                        mnt.mnt_mountp);
                continue;
            }

            /*
             * We skip quota reporting on mounts with replicas
             * for the following reasons:
             *
             * (1) Very little point in reporting quotas on
             * a set of read-only replicas ... how will the
             * user correct the problem?
             *
             * (2) Which replica would we report the quota
             * for? If we pick the current replica, what
             * happens when a fail over event occurs? The
             * next time quota is run, the quota will look
             * all different, or there won't even be one.
             * This has the potential to break scripts.
             *
             * If we prnt quouta for all replicas, how do
             * we present the output without breaking scripts?
             */

            if (count > 1) {
                free_replica(rl, count);
                continue;
            }

            /*
             * Skip file systems mounted using public fh.
             * We are not likely to be able to pierce
             * a fire wall to contact the quota server.
             */
            if (strcmp(rl[0].host, "nfs") == 0 &&
                strncmp(rl[0].path, "//", 2) == 0) {
                free_replica(rl, count);
                continue;
            }

            /*
             * Skip getting quotas from failing servers
             */
            if (failed_srv_list != NULL) {
                struct failed_srv *tmp_list;
                int found_failed = 0;
                size_t len = strlen(rl[0].host);

                tmp_list = failed_srv_list;
                do {
                    if (strncasecmp(rl[0].host,
                        tmp_list->serv_name, len) == 0) {
                        found_failed = 1;
                        break;
                    }
                } while ((tmp_list = tmp_list->next) != NULL);
                if (found_failed) {
                    free_replica(rl, count);
                    continue;
                }
            }

            rc = getnfsquota(rl[0].host, rl[0].path, uid, &dqblk);
            if (rc != RPC_SUCCESS) {
                size_t len;
                struct failed_srv *tmp_srv;

                /*
                 * Failed to get quota from this server. Add
                 * this server to failed_srv_list and skip
                 * getting quotas for other mounted filesystems
                 * from this server.
                 */
                if (rc == RPC_TIMEDOUT || rc == RPC_CANTSEND) {
                    len = strlen(rl[0].host);
                    tmp_srv = (struct failed_srv *)malloc(
                        sizeof (struct failed_srv));
                    tmp_srv->serv_name = (char *)malloc(
                        len * sizeof (char) + 1);
                    strncpy(tmp_srv->serv_name, rl[0].host,
                        len);
                    tmp_srv->serv_name[len] = '\0';

                    tmp_srv->next = failed_srv_list;
                    failed_srv_list = tmp_srv;
                }

                free_replica(rl, count);
                continue;
            }

            free_replica(rl, count);
        } else {
            continue;
        }
        if (dqblk.dqb_bsoftlimit == 0 && dqblk.dqb_bhardlimit == 0 &&
            dqblk.dqb_fsoftlimit == 0 && dqblk.dqb_fhardlimit == 0)
            continue;
        if (vflag)
            prquota(&mnt, &dqblk);
        else
            warn(&mnt, &dqblk);
    }

    /*
     * Free list of failed servers
     */
    while (failed_srv_list != NULL) {
        struct failed_srv *tmp_srv = failed_srv_list;

        failed_srv_list = failed_srv_list->next;
        free(tmp_srv->serv_name);
        free(tmp_srv);
    }

    fclose(mtab);
}

static void
warn(struct mnttab *mntp, struct dqblk *dqp)
{
    struct timeval tv;

    time(&(tv.tv_sec));
    tv.tv_usec = 0;
    if (dqp->dqb_bhardlimit &&
        dqp->dqb_curblocks >= dqp->dqb_bhardlimit) {
        printf("Block limit reached on %s\n", mntp->mnt_mountp);
    } else if (dqp->dqb_bsoftlimit &&
        dqp->dqb_curblocks >= dqp->dqb_bsoftlimit) {
        if (dqp->dqb_btimelimit == 0) {
            printf("Over disk quota on %s, remove %luK\n",
                mntp->mnt_mountp,
                kb(dqp->dqb_curblocks - dqp->dqb_bsoftlimit + 1));
        } else if (dqp->dqb_btimelimit > tv.tv_sec) {
            char btimeleft[80];

            fmttime(btimeleft, dqp->dqb_btimelimit - tv.tv_sec);
            printf("Over disk quota on %s, remove %luK within %s\n",
                mntp->mnt_mountp,
                kb(dqp->dqb_curblocks - dqp->dqb_bsoftlimit + 1),
                btimeleft);
        } else {
            printf(
        "Over disk quota on %s, time limit has expired, remove %luK\n",
                mntp->mnt_mountp,
                kb(dqp->dqb_curblocks - dqp->dqb_bsoftlimit + 1));
        }
    }
    if (dqp->dqb_fhardlimit &&
        dqp->dqb_curfiles >= dqp->dqb_fhardlimit) {
        printf("File count limit reached on %s\n", mntp->mnt_mountp);
    } else if (dqp->dqb_fsoftlimit &&
        dqp->dqb_curfiles >= dqp->dqb_fsoftlimit) {
        if (dqp->dqb_ftimelimit == 0) {
            printf("Over file quota on %s, remove %lu file%s\n",
                mntp->mnt_mountp,
                dqp->dqb_curfiles - dqp->dqb_fsoftlimit + 1,
                ((dqp->dqb_curfiles - dqp->dqb_fsoftlimit + 1) > 1 ?
                "s" : ""));
        } else if (dqp->dqb_ftimelimit > tv.tv_sec) {
            char ftimeleft[80];

            fmttime(ftimeleft, dqp->dqb_ftimelimit - tv.tv_sec);
            printf(
"Over file quota on %s, remove %lu file%s within %s\n",
                mntp->mnt_mountp,
                dqp->dqb_curfiles - dqp->dqb_fsoftlimit + 1,
                ((dqp->dqb_curfiles - dqp->dqb_fsoftlimit + 1) > 1 ?
                "s" : ""), ftimeleft);
        } else {
            printf(
"Over file quota on %s, time limit has expired, remove %lu file%s\n",
                mntp->mnt_mountp,
                dqp->dqb_curfiles - dqp->dqb_fsoftlimit + 1,
                ((dqp->dqb_curfiles - dqp->dqb_fsoftlimit + 1) > 1 ?
                "s" : ""));
        }
    }
}

static void
heading(uid_t uid, char *name)
{
    printf("Disk quotas for %s (uid %ld):\n", name, (long)uid);
    printf("%-12s %7s%7s%7s%12s%7s%7s%7s%12s\n",
        "Filesystem",
        "usage",
        "quota",
        "limit",
        "timeleft",
        "files",
        "quota",
        "limit",
        "timeleft");
}

static void
prquota(struct mnttab *mntp, struct dqblk *dqp)
{
    struct timeval tv;
    char ftimeleft[80], btimeleft[80];
    char *cp;

    time(&(tv.tv_sec));
    tv.tv_usec = 0;
    if (dqp->dqb_bsoftlimit && dqp->dqb_curblocks >= dqp->dqb_bsoftlimit) {
        if (dqp->dqb_btimelimit == 0) {
            strlcpy(btimeleft, "NOT STARTED", sizeof (btimeleft));
        } else if (dqp->dqb_btimelimit > tv.tv_sec) {
            fmttime(btimeleft, dqp->dqb_btimelimit - tv.tv_sec);
        } else {
            strlcpy(btimeleft, "EXPIRED", sizeof (btimeleft));
        }
    } else {
        btimeleft[0] = '\0';
    }
    if (dqp->dqb_fsoftlimit && dqp->dqb_curfiles >= dqp->dqb_fsoftlimit) {
        if (dqp->dqb_ftimelimit == 0) {
            strlcpy(ftimeleft, "NOT STARTED", sizeof (ftimeleft));
        } else if (dqp->dqb_ftimelimit > tv.tv_sec) {
            fmttime(ftimeleft, dqp->dqb_ftimelimit - tv.tv_sec);
        } else {
            strlcpy(ftimeleft, "EXPIRED", sizeof (ftimeleft));
        }
    } else {
        ftimeleft[0] = '\0';
    }
    if (strlen(mntp->mnt_mountp) > 12) {
        printf("%s\n", mntp->mnt_mountp);
        cp = "";
    } else {
        cp = mntp->mnt_mountp;
    }

    if (dqp->dqb_curfiles == 0 &&
        dqp->dqb_fsoftlimit == 0 && dqp->dqb_fhardlimit == 0) {
        printf("%-12.12s %7d %6d %6d %11s %6s %6s %6s %11s\n",
            cp,
            kb(dqp->dqb_curblocks),
            kb(dqp->dqb_bsoftlimit),
            kb(dqp->dqb_bhardlimit),
            "-",
            "-",
            "-",
            "-",
            "-");
    } else {
        printf("%-12.12s %7d %6d %6d %11s %6d %6d %6d %11s\n",
            cp,
            kb(dqp->dqb_curblocks),
            kb(dqp->dqb_bsoftlimit),
            kb(dqp->dqb_bhardlimit),
            btimeleft,
            dqp->dqb_curfiles,
            dqp->dqb_fsoftlimit,
            dqp->dqb_fhardlimit,
            ftimeleft);
    }
}

static void
fmttime(char *buf, long time)
{
    int i;
    static struct {
        int c_secs;     /* conversion units in secs */
        char *c_str;        /* unit string */
    } cunits [] = {
        {60*60*24*28, "months"},
        {60*60*24*7, "weeks"},
        {60*60*24, "days"},
        {60*60, "hours"},
        {60, "mins"},
        {1, "secs"}
    };

    if (time <= 0) {
        strlcpy(buf, "EXPIRED", sizeof (*buf));
        return;
    }
    for (i = 0; i < sizeof (cunits)/sizeof (cunits[0]); i++) {
        if (time >= cunits[i].c_secs)
            break;
    }
    snprintf(buf, sizeof (*buf), "%.1f %s",
        (double)time/cunits[i].c_secs, cunits[i].c_str);
}

int
alldigits(char *s)
{
    int c;

    c = *s++;
    do {
        if (!isdigit(c))
            return (0);
    } while (c = *s++);
    return (1);
}

int
getdiskquota(struct mnttab *mntp, uid_t uid, struct dqblk *dqp)
{
    int fd;
    dev_t fsdev;
    struct stat64 statb;
    char qfilename[MAXPATHLEN];

    if (stat64(mntp->mnt_special, &statb) < 0 ||
        (statb.st_mode & S_IFMT) != S_IFBLK)
        return (0);
    fsdev = statb.st_rdev;
    (void) snprintf(qfilename, sizeof (qfilename), "%s/%s",
        mntp->mnt_mountp, QFNAME);
    if (stat64(qfilename, &statb) < 0 || statb.st_dev != fsdev)
        return (0);
    (void) __priv_bracket(PRIV_ON);
    fd = open64(qfilename, O_RDONLY);
    (void) __priv_bracket(PRIV_OFF);
    if (fd < 0)
        return (0);
    (void) llseek(fd, (offset_t)dqoff(uid), L_SET);
    switch (read(fd, dqp, sizeof (struct dqblk))) {
    case 0:             /* EOF */
        /*
         * Convert implicit 0 quota (EOF)
         * into an explicit one (zero'ed dqblk).
         */
        memset((caddr_t)dqp, 0, sizeof (struct dqblk));
        break;

    case sizeof (struct dqblk): /* OK */
        break;

    default:            /* ERROR */
        close(fd);
        return (0);
    }
    close(fd);
    return (1);
}

int
quotactl(int cmd, char *mountp, uid_t uid, caddr_t addr)
{
    int     fd;
    int     status;
    struct quotctl  quota;
    char        qfile[MAXPATHLEN];

    FILE        *fstab;
    struct mnttab   mnt;


    if ((mountp == NULL) && (cmd == Q_ALLSYNC)) {
    /*
     * Find the mount point of any mounted file system. This is
     * because the ioctl that implements the quotactl call has
     * to go to a real file, and not to the block device.
     */
        if ((fstab = fopen(MNTTAB, "r")) == NULL) {
            fprintf(stderr, "%s: ", MNTTAB);
            perror("open");
            zexit(32);
        }
        fd = -1;
        while ((status = getmntent(fstab, &mnt)) == NULL) {
            if (strcmp(mnt.mnt_fstype, MNTTYPE_UFS) != 0 ||
                hasopt(MNTOPT_RO, mnt.mnt_mntopts))
                continue;
            if ((strlcpy(qfile, mnt.mnt_mountp,
                sizeof (qfile)) >= sizeof (qfile)) ||
                (strlcat(qfile, "/" QFNAME, sizeof (qfile)) >=
                sizeof (qfile))) {
                continue;
            }
            (void) __priv_bracket(PRIV_ON);
            fd = open64(qfile, O_RDONLY);
            (void) __priv_bracket(PRIV_OFF);
            if (fd != -1)
                break;
        }
        fclose(fstab);
        if (fd == -1) {
            errno = ENOENT;
            return (-1);
        }
    } else {
        if (mountp == NULL || mountp[0] == '\0') {
            errno = ENOENT;
            return (-1);
        }
        if ((strlcpy(qfile, mountp, sizeof (qfile)) >= sizeof
            (qfile)) ||
            (strlcat(qfile, "/" QFNAME, sizeof (qfile)) >= sizeof
            (qfile))) {
            errno = ENOENT;
            return (-1);
        }
        (void) __priv_bracket(PRIV_ON);
        fd = open64(qfile, O_RDONLY);
        (void) __priv_bracket(PRIV_OFF);
        if (fd < 0)
            return (-1);
    }   /* else */
    quota.op = cmd;
    quota.uid = uid;
    quota.addr = addr;
    status = ioctl(fd, Q_QUOTACTL, &quota);
    if (fd != 0)
        close(fd);
    return (status);
}


/*
 * Return 1 if opt appears in optlist
 */
int
hasopt(char *opt, char *optlist)
{
    char *value;
    char *opts[2];

    opts[0] = opt;
    opts[1] = NULL;

    if (optlist == NULL)
        return (0);
    while (*optlist != '\0') {
        if (getsubopt(&optlist, opts, &value) == 0)
            return (1);
    }
    return (0);
}

/*
 * If there are no quotas available, then getnfsquota() returns
 * RPC_SYSTEMERROR to caller.
 */
static int
getnfsquota(char *hostp, char *path, uid_t uid, struct dqblk *dqp)
{
    struct getquota_args gq_args;
    struct getquota_rslt gq_rslt;
    struct rquota *rquota;
    extern char *strchr();
    int rpc_err;

    gq_args.gqa_pathp = path;
    gq_args.gqa_uid = uid;
    rpc_err = callaurpc(hostp, RQUOTAPROG, RQUOTAVERS,
        (vflag? RQUOTAPROC_GETQUOTA: RQUOTAPROC_GETACTIVEQUOTA),
        xdr_getquota_args, &gq_args, xdr_getquota_rslt, &gq_rslt);
    if (rpc_err != RPC_SUCCESS) {
        return (rpc_err);
    }
    switch (gq_rslt.status) {
    case Q_OK:
        {
        struct timeval tv;
        u_longlong_t limit;

        rquota = &gq_rslt.getquota_rslt_u.gqr_rquota;

        if (!vflag && rquota->rq_active == FALSE) {
            return (RPC_SYSTEMERROR);
        }
        gettimeofday(&tv, NULL);
        limit = (u_longlong_t)(rquota->rq_bhardlimit) *
            rquota->rq_bsize / DEV_BSIZE;
        dqp->dqb_bhardlimit = limit;
        limit = (u_longlong_t)(rquota->rq_bsoftlimit) *
            rquota->rq_bsize / DEV_BSIZE;
        dqp->dqb_bsoftlimit = limit;
        limit = (u_longlong_t)(rquota->rq_curblocks) *
            rquota->rq_bsize / DEV_BSIZE;
        dqp->dqb_curblocks = limit;
        dqp->dqb_fhardlimit = rquota->rq_fhardlimit;
        dqp->dqb_fsoftlimit = rquota->rq_fsoftlimit;
        dqp->dqb_curfiles = rquota->rq_curfiles;
        dqp->dqb_btimelimit =
            tv.tv_sec + rquota->rq_btimeleft;
        dqp->dqb_ftimelimit =
            tv.tv_sec + rquota->rq_ftimeleft;
        return (RPC_SUCCESS);
        }

    case Q_NOQUOTA:
        return (RPC_SYSTEMERROR);

    case Q_EPERM:
        fprintf(stderr, "quota permission error, host: %s\n", hostp);
        return (RPC_AUTHERROR);

    default:
        fprintf(stderr, "bad rpc result, host: %s\n",  hostp);
        return (RPC_CANTDECODEARGS);
    }

    /* NOTREACHED */
}

int
callaurpc(char *host, int prognum, int versnum, int procnum,
        xdrproc_t inproc, char *in, xdrproc_t outproc, char *out)
{
    static enum clnt_stat clnt_stat;
    struct timeval tottimeout = {20, 0};

    static CLIENT *cl = NULL;
    static int oldprognum, oldversnum;
    static char oldhost[MAXHOSTNAMELEN+1];

    /*
     * Cache the client handle in case there are lots
     * of entries in the /etc/mnttab for the same
     * server. If the server returns an error, don't
     * make further calls.
     */
    if (cl == NULL || oldprognum != prognum || oldversnum != versnum ||
        strcmp(oldhost, host) != 0) {
        if (cl) {
            clnt_destroy(cl);
            cl = NULL;
        }
        cl = clnt_create_timed(host, prognum, versnum, "udp",
            &tottimeout);
        if (cl == NULL)
            return ((int)RPC_TIMEDOUT);
        if ((cl->cl_auth = authunix_create_default()) == NULL) {
            clnt_destroy(cl);
            return (RPC_CANTSEND);
        }
        oldprognum = prognum;
        oldversnum = versnum;
        (void) strlcpy(oldhost, host, sizeof (oldhost));
        clnt_stat = RPC_SUCCESS;
    }

    if (clnt_stat != RPC_SUCCESS)
        return ((int)clnt_stat);    /* don't bother retrying */

    clnt_stat = clnt_call(cl, procnum, inproc, in,
        outproc, out, tottimeout);

    return ((int)clnt_stat);
}

static int
getzfsquota(char *user, char *dataset, struct dqblk *zq)
{
    zfs_handle_t *zhp = NULL;
    char propname[ZFS_MAXPROPLEN];
    uint64_t userquota, userused;

    if (g_zfs == NULL)
        return (1);

    if ((zhp = _zfs_open(g_zfs, dataset, ZFS_TYPE_DATASET)) == NULL)
        return (1);

    (void) snprintf(propname, sizeof (propname), "userquota@%s", user);
    if (_zfs_prop_get_userquota_int(zhp, propname, &userquota) != 0) {
        _zfs_close(zhp);
        return (1);
    }

    (void) snprintf(propname, sizeof (propname), "userused@%s", user);
    if (_zfs_prop_get_userquota_int(zhp, propname, &userused) != 0) {
        _zfs_close(zhp);
        return (1);
    }

    zq->dqb_bhardlimit = userquota / DEV_BSIZE;
    zq->dqb_bsoftlimit = userquota / DEV_BSIZE;
    zq->dqb_curblocks = userused / DEV_BSIZE;
    _zfs_close(zhp);
    return (0);
}

static void
zexit(int n)
{
    if (g_zfs != NULL)
        _libzfs_fini(g_zfs);
    exit(n);
}