port/gen/privlib.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 2015 Gary Mills
 * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
 */

#pragma weak _getprivimplinfo   = getprivimplinfo
#pragma weak _priv_addset   = priv_addset
#pragma weak _priv_allocset = priv_allocset
#pragma weak _priv_copyset  = priv_copyset
#pragma weak _priv_delset   = priv_delset
#pragma weak _priv_emptyset = priv_emptyset
#pragma weak _priv_basicset = priv_basicset
#pragma weak _priv_fillset  = priv_fillset
#pragma weak _priv_freeset  = priv_freeset
#pragma weak _priv_getbyname    = priv_getbyname
#pragma weak _priv_getbynum = priv_getbynum
#pragma weak _priv_getsetbyname = priv_getsetbyname
#pragma weak _priv_getsetbynum  = priv_getsetbynum
#pragma weak _priv_ineffect = priv_ineffect
#pragma weak _priv_intersect    = priv_intersect
#pragma weak _priv_inverse  = priv_inverse
#pragma weak _priv_isemptyset   = priv_isemptyset
#pragma weak _priv_isequalset   = priv_isequalset
#pragma weak _priv_isfullset    = priv_isfullset
#pragma weak _priv_ismember = priv_ismember
#pragma weak _priv_issubset = priv_issubset
#pragma weak _priv_set      = priv_set
#pragma weak _priv_union    = priv_union

#include "lint.h"

#define _STRUCTURED_PROC    1

#include "priv_private.h"
#include "mtlib.h"
#include "libc.h"
#include <errno.h>
#include <stdarg.h>
#include <stdlib.h>
#include <unistd.h>
#include <strings.h>
#include <synch.h>
#include <alloca.h>
#include <atomic.h>
#include <sys/ucred.h>
#include <sys/procfs.h>
#include <sys/param.h>
#include <sys/corectl.h>
#include <priv_utils.h>
#include <zone.h>

/* Include each string only once - until the compiler/linker are fixed */
static const char *permitted    = PRIV_PERMITTED;
static const char *effective    = PRIV_EFFECTIVE;
static const char *limit    = PRIV_LIMIT;
static const char *inheritable  = PRIV_INHERITABLE;
/*
 * Data independent privilege set operations.
 *
 * Only a few functions are provided that do not default to
 * the system implementation of privileges.  A limited set of
 * interfaces is provided that accepts a priv_data_t *
 * argument; this set of interfaces is a private interface between libc
 * and libproc.  It is delivered in order to interpret privilege sets
 * in debuggers in a implementation independent way.  As such, we
 * don't need to provide the bulk of the interfaces, only a few
 * boolean tests (isfull, isempty) the name<->num mappings and
 * set pretty print functions.   The boolean tests are only needed for
 * the latter, so those aren't provided externally.
 *
 * Additionally, we provide the function that maps the kernel implementation
 * structure into a libc private data structure.
 */

priv_data_t *privdata;

static mutex_t pd_lock = DEFAULTMUTEX;

static int
parseninfo(priv_info_names_t *na, char ***buf, int *cp)
{
    char *q;
    int i;

    *buf = libc_malloc(sizeof (char *) * na->cnt);

    if (*buf == NULL)
        return (-1);

    q = na->names;

    for (i = 0; i < na->cnt; i++) {
        int l = strlen(q);

        (*buf)[i] = q;
        q += l + 1;
    }
    *cp = na->cnt;
    return (0);
}

struct strint {
    char *name;
    int rank;
};

static int
strintcmp(const void *a, const void *b)
{
    const struct strint *ap = a;
    const struct strint *bp = b;

    return (strcasecmp(ap->name, bp->name));
}

priv_data_t *
__priv_parse_info(priv_impl_info_t *ip)
{
    priv_data_t *tmp;
    char *x;
    size_t size = PRIV_IMPL_INFO_SIZE(ip);
    int i;

    tmp = libc_malloc(sizeof (*tmp));

    if (tmp == NULL)
        return (NULL);

    (void) memset(tmp, 0, sizeof (*tmp));

    tmp->pd_pinfo = ip;
    tmp->pd_setsize = sizeof (priv_chunk_t) * ip->priv_setsize;
    tmp->pd_ucredsize = UCRED_SIZE(ip);

    x = (char *)ip;
    x += ip->priv_headersize;

    while (x < ((char *)ip) + size) {
        /* LINTED: alignment */
        priv_info_names_t *na = (priv_info_names_t *)x;
        /* LINTED: alignment */
        priv_info_set_t *st = (priv_info_set_t *)x;
        struct strint *tmparr;

        switch (na->info.priv_info_type) {
        case PRIV_INFO_SETNAMES:
            if (parseninfo(na, &tmp->pd_setnames, &tmp->pd_nsets))
                goto out;
            break;
        case PRIV_INFO_PRIVNAMES:
            if (parseninfo(na, &tmp->pd_privnames, &tmp->pd_nprivs))
                goto out;
            /*
             * We compute a sorted index which allows us
             * to present a sorted list of privileges
             * without actually having to sort it each time.
             */
            tmp->pd_setsort = libc_malloc(tmp->pd_nprivs *
                sizeof (int));
            if (tmp->pd_setsort == NULL)
                goto out;

            tmparr = libc_malloc(tmp->pd_nprivs *
                sizeof (struct strint));

            if (tmparr == NULL)
                goto out;

            for (i = 0; i < tmp->pd_nprivs; i++) {
                tmparr[i].rank = i;
                tmparr[i].name = tmp->pd_privnames[i];
            }
            qsort(tmparr, tmp->pd_nprivs, sizeof (struct strint),
                strintcmp);
            for (i = 0; i < tmp->pd_nprivs; i++)
                tmp->pd_setsort[i] = tmparr[i].rank;
            libc_free(tmparr);
            break;
        case PRIV_INFO_BASICPRIVS:
            tmp->pd_basicset = (priv_set_t *)&st->set[0];
            break;
        default:
            /* unknown, ignore */
            break;
        }
        x += na->info.priv_info_size;
    }
    return (tmp);
out:
    libc_free(tmp->pd_setnames);
    libc_free(tmp->pd_privnames);
    libc_free(tmp->pd_setsort);
    libc_free(tmp);
    return (NULL);
}

/*
 * Caller must have allocated d->pd_pinfo and should free it,
 * if necessary.
 */
void
__priv_free_info(priv_data_t *d)
{
    libc_free(d->pd_setnames);
    libc_free(d->pd_privnames);
    libc_free(d->pd_setsort);
    libc_free(d);
}

/*
 * Return with the pd_lock held and data loaded or indicate failure.
 */
int
lock_data(void)
{
    if (__priv_getdata() == NULL)
        return (-1);

    lmutex_lock(&pd_lock);
    return (0);
}

boolean_t
refresh_data(void)
{
    priv_impl_info_t *ip, ii;
    priv_data_t *tmp;
    char *p0, *q0;
    int oldn, newn;
    int i;

    if (getprivinfo(&ii, sizeof (ii)) != 0 ||
        ii.priv_max == privdata->pd_nprivs)
        return (B_FALSE);

    ip = alloca(PRIV_IMPL_INFO_SIZE(&ii));

    (void) getprivinfo(ip, PRIV_IMPL_INFO_SIZE(&ii));

    /* Parse the info; then copy the additional bits */
    tmp = __priv_parse_info(ip);
    if (tmp == NULL)
        return (B_FALSE);

    oldn = privdata->pd_nprivs;
    p0 = privdata->pd_privnames[0];

    newn = tmp->pd_nprivs;
    q0 = tmp->pd_privnames[0];

    /* copy the extra information to the old datastructure */
    (void) memcpy((char *)privdata->pd_pinfo + sizeof (priv_impl_info_t),
        (char *)ip + sizeof (priv_impl_info_t),
        PRIV_IMPL_INFO_SIZE(ip) - sizeof (priv_impl_info_t));

    /* Copy the first oldn pointers */
    (void) memcpy(tmp->pd_privnames, privdata->pd_privnames,
        oldn * sizeof (char *));

    /* Adjust the rest */
    for (i = oldn; i < newn; i++)
        tmp->pd_privnames[i] += p0 - q0;

    /* Install the larger arrays */
    libc_free(privdata->pd_privnames);
    privdata->pd_privnames = tmp->pd_privnames;
    tmp->pd_privnames = NULL;

    libc_free(privdata->pd_setsort);
    privdata->pd_setsort = tmp->pd_setsort;
    tmp->pd_setsort = NULL;

    /* Copy the rest of the data */
    *privdata->pd_pinfo = *ip;

    privdata->pd_nprivs = newn;

    __priv_free_info(tmp);
    return (B_TRUE);
}

void
unlock_data(void)
{
    lmutex_unlock(&pd_lock);
}

static priv_set_t *__priv_allocset(priv_data_t *);

priv_data_t *
__priv_getdata(void)
{
    if (privdata == NULL) {
        lmutex_lock(&pd_lock);
        if (privdata == NULL) {
            priv_data_t *tmp;
            priv_impl_info_t *ip;
            size_t size = sizeof (priv_impl_info_t) + 2048;
            size_t realsize;
            priv_impl_info_t *aip = alloca(size);

            if (getprivinfo(aip, size) != 0)
                goto out;

            realsize = PRIV_IMPL_INFO_SIZE(aip);

            ip = libc_malloc(realsize);

            if (ip == NULL)
                goto out;

            if (realsize <= size) {
                (void) memcpy(ip, aip, realsize);
            } else if (getprivinfo(ip, realsize) != 0) {
                libc_free(ip);
                goto out;
            }

            if ((tmp = __priv_parse_info(ip)) == NULL) {
                libc_free(ip);
                goto out;
            }

            /* Allocate the zoneset just once, here */
            tmp->pd_zoneset = __priv_allocset(tmp);
            if (tmp->pd_zoneset == NULL)
                goto clean;

            if (zone_getattr(getzoneid(), ZONE_ATTR_PRIVSET,
                tmp->pd_zoneset, tmp->pd_setsize)
                == tmp->pd_setsize) {
                membar_producer();
                privdata = tmp;
                goto out;
            }

            priv_freeset(tmp->pd_zoneset);
clean:
            __priv_free_info(tmp);
            libc_free(ip);
        }
out:
        lmutex_unlock(&pd_lock);
    }
    membar_consumer();
    return (privdata);
}

const priv_impl_info_t *
getprivimplinfo(void)
{
    priv_data_t *d;

    LOADPRIVDATA(d);

    return (d->pd_pinfo);
}

static priv_set_t *
priv_vlist(va_list ap)
{
    priv_set_t *pset = priv_allocset();
    const char *priv;

    if (pset == NULL)
        return (NULL);

    priv_emptyset(pset);

    while ((priv = va_arg(ap, const char *)) != NULL) {
        if (priv_addset(pset, priv) < 0) {
            priv_freeset(pset);
            return (NULL);
        }
    }
    return (pset);
}

/*
 * priv_set(op, set, priv_id1, priv_id2, ..., NULL)
 *
 * Library routine to enable a user process to set a specific
 * privilege set appropriately using a single call.  User is
 * required to terminate the list of privileges with NULL.
 */
int
priv_set(priv_op_t op, priv_ptype_t setname, ...)
{
    va_list ap;
    priv_set_t *pset;
    int ret;

    va_start(ap, setname);

    pset = priv_vlist(ap);

    va_end(ap);

    if (pset == NULL)
        return (-1);

    /* All sets */
    if (setname == NULL) {
        priv_data_t *d;
        int set;

        LOADPRIVDATA(d);

        for (set = 0; set < d->pd_nsets; set++)
            if ((ret = syscall(SYS_privsys, PRIVSYS_SETPPRIV, op,
                set, (void *)pset, d->pd_setsize)) != 0)
                break;
    } else {
        ret = setppriv(op, setname, pset);
    }

    priv_freeset(pset);
    return (ret);
}

/*
 * priv_ineffect(privilege).
 * tests the existence of a privilege against the effective set.
 */
boolean_t
priv_ineffect(const char *priv)
{
    priv_set_t *curset;
    boolean_t res;

    curset = priv_allocset();

    if (curset == NULL)
        return (B_FALSE);

    if (getppriv(effective, curset) != 0 ||
        !priv_ismember(curset, priv))
        res = B_FALSE;
    else
        res = B_TRUE;

    priv_freeset(curset);

    return (res);
}

/*
 * The routine __init_daemon_priv() is private to Solaris and is
 * used by daemons to limit the privileges they can use and
 * to set the uid they run under.
 */

static const char root_cp[] = "/core.%f.%t";
static const char daemon_cp[] = "/var/tmp/core.%f.%t";

int
__init_daemon_priv(int flags, uid_t uid, gid_t gid, ...)
{
    priv_set_t *nset;
    priv_set_t *perm = NULL;
    va_list pa;
    priv_data_t *d;
    int ret = -1;
    char buf[1024];

    LOADPRIVDATA(d);

    va_start(pa, gid);

    nset = priv_vlist(pa);

    va_end(pa);

    if (nset == NULL)
        return (-1);

    /* Always add the basic set */
    if (d->pd_basicset != NULL)
        priv_union(d->pd_basicset, nset);

    /*
     * This is not a significant failure: it allows us to start programs
     * with sufficient privileges and with the proper uid.   We don't
     * care enough about the extra groups in that case.
     */
    if (flags & PU_RESETGROUPS)
        (void) setgroups(0, NULL);

    if (gid != (gid_t)-1 && setgid(gid) != 0)
        goto end;

    perm = priv_allocset();
    if (perm == NULL)
        goto end;

    /* E = P */
    (void) getppriv(permitted, perm);
    (void) setppriv(PRIV_SET, effective, perm);

    /* Now reset suid and euid */
    if (uid != (uid_t)-1 && setreuid(uid, uid) != 0)
        goto end;

    /* Check for the limit privs */
    if ((flags & PU_LIMITPRIVS) &&
        setppriv(PRIV_SET, limit, nset) != 0)
        goto end;

    if (flags & PU_CLEARLIMITSET) {
        priv_emptyset(perm);
        if (setppriv(PRIV_SET, limit, perm) != 0)
            goto end;
    }

    /* Remove the privileges from all the other sets */
    if (setppriv(PRIV_SET, permitted, nset) != 0)
        goto end;

    if (!(flags & PU_INHERITPRIVS))
        priv_emptyset(nset);

    ret = setppriv(PRIV_SET, inheritable, nset);
end:
    priv_freeset(nset);
    priv_freeset(perm);

    if (core_get_process_path(buf, sizeof (buf), getpid()) == 0 &&
        strcmp(buf, "core") == 0) {

        if ((uid == (uid_t)-1 ? geteuid() : uid) == 0) {
            (void) core_set_process_path(root_cp, sizeof (root_cp),
                getpid());
        } else {
            (void) core_set_process_path(daemon_cp,
                sizeof (daemon_cp), getpid());
        }
    }
    (void) setpflags(__PROC_PROTECT, 0);

    return (ret);
}

/*
 * The routine __fini_daemon_priv() is private to Solaris and is
 * used by daemons to clear remaining unwanted privileges and
 * reenable core dumps.
 */
void
__fini_daemon_priv(const char *priv, ...)
{
    priv_set_t *nset;
    va_list pa;

    if (priv != NULL) {

        va_start(pa, priv);
        nset = priv_vlist(pa);
        va_end(pa);

        if (nset == NULL)
            return;

        (void) priv_addset(nset, priv);
        (void) setppriv(PRIV_OFF, permitted, nset);
        priv_freeset(nset);
    }

    (void) setpflags(__PROC_PROTECT, 0);
}

/*
 * The routine __init_suid_priv() is private to Solaris and is
 * used by set-uid root programs to limit the privileges acquired
 * to those actually needed.
 */

static priv_set_t *bracketpriv;

int
__init_suid_priv(int flags, ...)
{
    priv_set_t *nset = NULL;
    priv_set_t *tmpset = NULL;
    va_list pa;
    int r = -1;
    uid_t ruid, euid;

    euid = geteuid();

    /* If we're not set-uid root, don't reset the uid */
    if (euid == 0) {
        ruid = getuid();
        /* If we're running as root, keep everything */
        if (ruid == 0)
            return (0);
    }

    /* Can call this only once */
    if (bracketpriv != NULL)
        return (-1);

    va_start(pa, flags);

    nset = priv_vlist(pa);

    va_end(pa);

    if (nset == NULL)
        goto end;

    tmpset = priv_allocset();

    if (tmpset == NULL)
        goto end;

    /* We cannot grow our privileges beyond P, so start there */
    (void) getppriv(permitted, tmpset);

    /* Is the privilege we need even in P? */
    if (!priv_issubset(nset, tmpset))
        goto end;

    bracketpriv = priv_allocset();
    if (bracketpriv == NULL)
        goto end;

    priv_copyset(nset, bracketpriv);

    /* Always add the basic set */
    priv_union(priv_basic(), nset);

    /* But don't add what we don't have */
    priv_intersect(tmpset, nset);

    (void) getppriv(inheritable, tmpset);

    /* And stir in the inheritable privileges */
    priv_union(tmpset, nset);

    if ((r = setppriv(PRIV_SET, effective, tmpset)) != 0)
        goto end;

    if ((r = setppriv(PRIV_SET, permitted, nset)) != 0)
        goto end;

    if (flags & PU_CLEARLIMITSET)
        priv_emptyset(nset);

    if ((flags & (PU_LIMITPRIVS|PU_CLEARLIMITSET)) != 0 &&
        (r = setppriv(PRIV_SET, limit, nset)) != 0)
        goto end;

    if (euid == 0)
        r = setreuid(ruid, ruid);

end:
    priv_freeset(tmpset);
    priv_freeset(nset);
    if (r != 0) {
        /* Fail without leaving uid 0 around */
        if (euid == 0)
            (void) setreuid(ruid, ruid);
        priv_freeset(bracketpriv);
        bracketpriv = NULL;
    }

    return (r);
}

/*
 * Toggle privileges on/off in the effective set.
 */
int
__priv_bracket(priv_op_t op)
{
    /* We're running fully privileged or didn't check errors first time */
    if (bracketpriv == NULL)
        return (0);

    /* Only PRIV_ON and PRIV_OFF are valid */
    if (op == PRIV_SET)
        return (-1);

    return (setppriv(op, effective, bracketpriv));
}

/*
 * Remove privileges from E & P.
 */
void
__priv_relinquish(void)
{
    if (bracketpriv != NULL) {
        (void) setppriv(PRIV_OFF, permitted, bracketpriv);
        priv_freeset(bracketpriv);
        bracketpriv = NULL;
    }
}

/*
 * Use binary search on the ordered list.
 */
int
__priv_getbyname(const priv_data_t *d, const char *name)
{
    char *const *list;
    const int *order;
    int lo = 0;
    int hi;

    if (d == NULL)
        return (-1);

    list = d->pd_privnames;
    order = d->pd_setsort;
    hi = d->pd_nprivs - 1;

    if (strncasecmp(name, "priv_", 5) == 0)
        name += 5;

    do {
        int mid = (lo + hi) / 2;
        int res = strcasecmp(name, list[order[mid]]);

        if (res == 0)
            return (order[mid]);
        else if (res < 0)
            hi = mid - 1;
        else
            lo = mid + 1;
    } while (lo <= hi);

    errno = EINVAL;
    return (-1);
}

int
priv_getbyname(const char *name)
{
    WITHPRIVLOCKED(int, -1, __priv_getbyname(GETPRIVDATA(), name))
}

int
__priv_getsetbyname(const priv_data_t *d, const char *name)
{
    int i;
    int n = d->pd_nsets;
    char *const *list = d->pd_setnames;

    if (strncasecmp(name, "priv_", 5) == 0)
        name += 5;

    for (i = 0; i < n; i++) {
        if (strcasecmp(list[i], name) == 0)
            return (i);
    }

    errno = EINVAL;
    return (-1);
}

int
priv_getsetbyname(const char *name)
{
    /* Not locked: sets don't change */
    return (__priv_getsetbyname(GETPRIVDATA(), name));
}

static const char *
priv_bynum(int i, int n, char **list)
{
    if (i < 0 || i >= n)
        return (NULL);

    return (list[i]);
}

const char *
__priv_getbynum(const priv_data_t *d, int num)
{
    if (d == NULL)
        return (NULL);
    return (priv_bynum(num, d->pd_nprivs, d->pd_privnames));
}

const char *
priv_getbynum(int num)
{
    WITHPRIVLOCKED(const char *, NULL, __priv_getbynum(GETPRIVDATA(), num))
}

const char *
__priv_getsetbynum(const priv_data_t *d, int num)
{
    if (d == NULL)
        return (NULL);
    return (priv_bynum(num, d->pd_nsets, d->pd_setnames));
}

const char *
priv_getsetbynum(int num)
{
    return (__priv_getsetbynum(GETPRIVDATA(), num));
}


/*
 * Privilege manipulation functions
 *
 * Without knowing the details of the privilege set implementation,
 * opaque pointers can be used to manipulate sets at will.
 */

static priv_set_t *
__priv_allocset(priv_data_t *d)
{
    if (d == NULL)
        return (NULL);

    return (libc_malloc(d->pd_setsize));
}

priv_set_t *
priv_allocset(void)
{
    return (__priv_allocset(GETPRIVDATA()));
}

void
priv_freeset(priv_set_t *p)
{
    int er = errno;

    libc_free(p);
    errno = er;
}

void
__priv_emptyset(priv_data_t *d, priv_set_t *set)
{
    (void) memset(set, 0, d->pd_setsize);
}

void
priv_emptyset(priv_set_t *set)
{
    __priv_emptyset(GETPRIVDATA(), set);
}

void
priv_basicset(priv_set_t *set)
{
    priv_copyset(priv_basic(), set);
}

void
__priv_fillset(priv_data_t *d, priv_set_t *set)
{
    (void) memset(set, ~0, d->pd_setsize);
}

void
priv_fillset(priv_set_t *set)
{
    __priv_fillset(GETPRIVDATA(), set);
}


#define PRIV_TEST_BODY_D(d, test) \
    int i; \
\
    for (i = d->pd_pinfo->priv_setsize; i-- > 0; ) \
        if (!(test)) \
            return (B_FALSE); \
\
    return (B_TRUE)

boolean_t
priv_isequalset(const priv_set_t *a, const priv_set_t *b)
{
    priv_data_t *d;

    LOADPRIVDATA(d);

    return ((boolean_t)(memcmp(a, b, d->pd_setsize) == 0));
}

boolean_t
__priv_isemptyset(priv_data_t *d, const priv_set_t *set)
{
    PRIV_TEST_BODY_D(d, ((priv_chunk_t *)set)[i] == 0);
}

boolean_t
priv_isemptyset(const priv_set_t *set)
{
    return (__priv_isemptyset(GETPRIVDATA(), set));
}

boolean_t
__priv_isfullset(priv_data_t *d, const priv_set_t *set)
{
    PRIV_TEST_BODY_D(d, ((priv_chunk_t *)set)[i] == ~(priv_chunk_t)0);
}

boolean_t
priv_isfullset(const priv_set_t *set)
{
    return (__priv_isfullset(GETPRIVDATA(), set));
}

/*
 * Return true if a is a subset of b
 */
boolean_t
__priv_issubset(priv_data_t *d, const priv_set_t *a, const priv_set_t *b)
{
    PRIV_TEST_BODY_D(d, (((priv_chunk_t *)a)[i] | ((priv_chunk_t *)b)[i]) ==
        ((priv_chunk_t *)b)[i]);
}

boolean_t
priv_issubset(const priv_set_t *a, const priv_set_t *b)
{
    return (__priv_issubset(GETPRIVDATA(), a, b));
}

#define PRIV_CHANGE_BODY(a, op, b) \
    int i; \
    priv_data_t *d; \
\
    LOADPRIVDATA(d); \
\
    for (i = 0; i < d->pd_pinfo->priv_setsize; i++) \
        ((priv_chunk_t *)a)[i] op \
            ((priv_chunk_t *)b)[i]

/* B = A ^ B */
void
priv_intersect(const priv_set_t *a, priv_set_t *b)
{
    /* CSTYLED */
    PRIV_CHANGE_BODY(b, &=, a);
}

/* B = A */
void
priv_copyset(const priv_set_t *a, priv_set_t *b)
{
    /* CSTYLED */
    PRIV_CHANGE_BODY(b, =, a);
}

/* B = A v B */
void
priv_union(const priv_set_t *a, priv_set_t *b)
{
    /* CSTYLED */
    PRIV_CHANGE_BODY(b, |=, a);
}

/* A = ! A */
void
priv_inverse(priv_set_t *a)
{
    PRIV_CHANGE_BODY(a, = ~, a);
}

/*
 * Manipulating single privileges.
 */

int
priv_addset(priv_set_t *a, const char *p)
{
    int priv = priv_getbyname(p);

    if (priv < 0)
        return (-1);

    PRIV_ADDSET(a, priv);

    return (0);
}

int
priv_delset(priv_set_t *a, const char *p)
{
    int priv = priv_getbyname(p);

    if (priv < 0)
        return (-1);

    PRIV_DELSET(a, priv);
    return (0);
}

boolean_t
priv_ismember(const priv_set_t *a, const char *p)
{
    int priv = priv_getbyname(p);

    if (priv < 0)
        return (B_FALSE);

    return ((boolean_t)PRIV_ISMEMBER(a, priv));
}