/*
 * This file and its contents are supplied under the terms of the
 * Common Development and Distribution License ("CDDL"), version 1.0.
 * You may only use this file in accordance with the terms of version
 * 1.0 of the CDDL.
 *
 * A full copy of the text of the CDDL should have accompanied this
 * source.  A copy of the CDDL is also available via the Internet at
 * http://www.illumos.org/license/CDDL.
 */

/* Copyright 2015, Richard Lowe. */

#include <sys/secflags.h>
#include <sys/types.h>

#if defined(_KERNEL)
#include <sys/kmem.h>
#include <sys/sunddi.h>
#else
#include "lint.h"               /* libc header */
#include <stdio.h>
#include <stdlib.h>
#include <strings.h>
#endif

secflagset_t
secflag_to_bit(secflag_t secflag)
{
        return (1 << secflag);
}

boolean_t
secflag_isset(secflagset_t flags, secflag_t sf)
{
        return ((flags & secflag_to_bit(sf)) != 0);
}

void
secflag_clear(secflagset_t *flags, secflag_t sf)
{
        *flags &= ~secflag_to_bit(sf);
}

void
secflag_set(secflagset_t *flags, secflag_t sf)
{
        *flags |= secflag_to_bit(sf);
}

boolean_t
secflags_isempty(secflagset_t flags)
{
        return (flags == 0);
}

void
secflags_zero(secflagset_t *flags)
{
        *flags = 0;
}

void
secflags_fullset(secflagset_t *flags)
{
        *flags = PROC_SEC_MASK;
}

void
secflags_copy(secflagset_t *dst, const secflagset_t *src)
{
        *dst = *src;
}

boolean_t
secflags_issubset(secflagset_t a, secflagset_t b)
{
        return (!(a & ~b));
}

boolean_t
secflags_issuperset(secflagset_t a, secflagset_t b)
{
        return (secflags_issubset(b, a));
}

boolean_t
secflags_intersection(secflagset_t a, secflagset_t b)
{
        return (a & b);
}

void
secflags_union(secflagset_t *a, const secflagset_t *b)
{
        *a |= *b;
}

void
secflags_difference(secflagset_t *a, const secflagset_t *b)
{
        *a &= ~*b;
}

boolean_t
psecflags_validate_delta(const psecflags_t *sf, const secflagdelta_t *delta)
{
        if (delta->psd_ass_active) {
                /*
                 * If there's a bit in lower not in args, or a bit args not in
                 * upper
                 */
                if (!secflags_issubset(delta->psd_assign, sf->psf_upper) ||
                    !secflags_issuperset(delta->psd_assign, sf->psf_lower)) {
                        return (B_FALSE);
                }

                if (!secflags_issubset(delta->psd_assign, PROC_SEC_MASK))
                        return (B_FALSE);
        } else {
                /* If we're adding a bit not in upper */
                if (!secflags_isempty(delta->psd_add)) {
                        if (!secflags_issubset(delta->psd_add, sf->psf_upper)) {
                                return (B_FALSE);
                        }
                }

                /* If we're removing a bit that's in lower */
                if (!secflags_isempty(delta->psd_rem)) {
                        if (secflags_intersection(delta->psd_rem,
                            sf->psf_lower)) {
                                return (B_FALSE);
                        }
                }

                if (!secflags_issubset(delta->psd_add, PROC_SEC_MASK) ||
                    !secflags_issubset(delta->psd_rem, PROC_SEC_MASK))
                        return (B_FALSE);
        }

        return (B_TRUE);
}

boolean_t
psecflags_validate(const psecflags_t *sf)
{
        if (!secflags_issubset(sf->psf_lower, PROC_SEC_MASK) ||
            !secflags_issubset(sf->psf_inherit, PROC_SEC_MASK) ||
            !secflags_issubset(sf->psf_effective, PROC_SEC_MASK) ||
            !secflags_issubset(sf->psf_upper, PROC_SEC_MASK))
                return (B_FALSE);

        if (!secflags_issubset(sf->psf_lower, sf->psf_inherit))
                return (B_FALSE);
        if (!secflags_issubset(sf->psf_lower, sf->psf_upper))
                return (B_FALSE);
        if (!secflags_issubset(sf->psf_inherit, sf->psf_upper))
                return (B_FALSE);

        return (B_TRUE);
}

void
psecflags_default(psecflags_t *sf)
{
        secflags_zero(&sf->psf_effective);
        secflags_zero(&sf->psf_inherit);
        secflags_zero(&sf->psf_lower);
        secflags_fullset(&sf->psf_upper);
}

static struct flagdesc {
        secflag_t value;
        const char *name;
} flagdescs[] = {
        { PROC_SEC_ASLR,                "aslr" },
        { PROC_SEC_FORBIDNULLMAP,       "forbidnullmap" },
        { PROC_SEC_NOEXECSTACK,         "noexecstack" },
        { 0x0, NULL }
};

boolean_t
secflag_by_name(const char *str, secflag_t *ret)
{
        struct flagdesc *fd;

        for (fd = flagdescs; fd->name != NULL; fd++) {
                if (strcasecmp(str, fd->name) == 0) {
                        *ret = fd->value;
                        return (B_TRUE);
                }
        }

        return (B_FALSE);
}

const char *
secflag_to_str(secflag_t sf)
{
        struct flagdesc *fd;

        for (fd = flagdescs; fd->name != NULL; fd++) {
                if (sf == fd->value)
                        return (fd->name);
        }

        return (NULL);
}

void
secflags_to_str(secflagset_t flags, char *buf, size_t buflen)
{
        struct flagdesc *fd;

        if (buflen >= 1)
                buf[0] = '\0';

        if (flags == 0) {
                (void) strlcpy(buf, "none", buflen);
                return;
        }

        for (fd = flagdescs; fd->name != NULL; fd++) {
                if (secflag_isset(flags, fd->value)) {
                        if (buf[0] != '\0')
                                (void) strlcat(buf, ",", buflen);
                        (void) strlcat(buf, fd->name, buflen);
                }

                secflag_clear(&flags, fd->value);
        }

        if (flags != 0) {       /* unknown flags */
                char hexbuf[19]; /* 0x%16 PRIx64 */

                (void) snprintf(hexbuf, sizeof (hexbuf), "0x%16" PRIx64, flags);
                if (buf[0] != '\0')
                        (void) strlcat(buf, ",", buflen);
                (void) strlcat(buf, hexbuf, buflen);
        }
}