tsol/lslabels/lslabels.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.
 */


/*
 *  lslabels - Display all labels dominating the specified label.
 */

#include <errno.h>
#include <libintl.h>
#include <locale.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <stropts.h>

#include <sys/param.h>

#include <tsol/label.h>
#include <sys/tsol/label_macro.h>
#include <iso/limits_iso.h>

#if !defined(TEXT_DOMAIN)
#define TEXT_DOMAIN  "SYS_TEST"
#endif  /* !defined(TEXT_DOMAIN) */

int hflg = 0;           /* true if hex output */

/*
 * Compartment mask macros.
 */

typedef uint32_t comp_chunk_t;

#define __NBWRD     (CHAR_BIT * sizeof (comp_chunk_t))
#define COMP_BITS   (CHAR_BIT * sizeof (Compartments_t))
#define compmask(n) (1 << ((__NBWRD - 1) - ((n) % __NBWRD)))
#define compword(n) ((n)/__NBWRD)

#define COMP_ADDSET(a, p)   ((comp_chunk_t *)(a))[compword(p)] |= \
                    compmask(p)
#define COMP_DELSET(a, p)   ((comp_chunk_t *)(a))[compword(p)] &= \
                    ~compmask(p)
#define COMP_ISMEMBER(a, p) ((((comp_chunk_t *)(a))[compword(p)] & \
                    compmask(p)) != 0)

/* Need functions to test if bit is on */


void
bitfinder(m_label_t label, int next_bit) {
    char *labelstr = NULL;

    Compartments_t *comps = &label.compartments;

    while (next_bit < COMP_BITS) {
        if (COMP_ISMEMBER(comps, next_bit)) {
            bitfinder(label, next_bit + 1);
            COMP_DELSET(comps, next_bit);

            if (label_to_str(&label, &labelstr, M_LABEL,
                LONG_NAMES) == 0) {
                m_label_t *label2 = NULL;
                int err;

                if (str_to_label(labelstr, &label2, MAC_LABEL,
                    L_NO_CORRECTION, &err) == 0) {
                    if (!hflg) {
                        (void) printf("%s\n", labelstr);
                    } else {
                        free(labelstr);
                        (void) label_to_str(&label,
                            &labelstr, M_INTERNAL, 0);
                        (void) printf("%s\n", labelstr);
                    }
                    m_label_free(label2);
                }
                free(labelstr);
            }
            bitfinder(label, next_bit + 1);
            break;
        }
        next_bit++;
        }
}

static void
label_error(const char *ascii, const int err)
{
    if (errno == EINVAL) {
        switch (err) {
        case M_BAD_STRING:
            (void) fprintf(stderr,
                gettext("lslabels: bad string %s\n"), ascii);
        break;
        case M_BAD_LABEL:
            (void) fprintf(stderr,
                gettext("lslabels: bad previous label\n"));
        break;
        default:
            (void) fprintf(stderr,
                gettext("lslabels: parsing error found in "
                "\"%s\" at position %d\n"), ascii, err);
        break;
        }
    } else {
        perror("lslabels");
    }
    exit(1);
    /*NOTREACHED*/
}

int
main(int argc, char **argv)
{
    int errflg = 0;         /* true if arg error */
    m_label_t *label = NULL;    /* binary labels */
    char ascii[PIPE_BUF];       /* human readable label */
    char *labelstr = NULL;      /* external label to start from */
    int err = 0;            /* label error */
    int c;
    int mode = M_LABEL;
    _Classification *level;

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

    opterr = 0;
    while ((c = getopt(argc, argv, "h")) != EOF) {

        switch (c) {
        case 'h':
            hflg++;
            mode = M_INTERNAL;
            break;

        default:
            errflg++;
            break;
        }
    }

    argc -= optind - 1;
    if (errflg || argc > 2) {

        (void) fprintf(stderr,
            gettext("usage: %s [-h] [label]\n"),
            argv[0]);
        exit(1);
        /*NOTREACHED*/
    }

    if (argc == 2) {
        /* use label on command line */

        (void) strlcpy(ascii, argv[optind], sizeof (ascii));
    } else {
        /* read label from standard input */
        if ((c = read(STDIN_FILENO, ascii, sizeof (ascii))) <= 0) {
            perror(gettext("reading ASCII coded label"));
            exit(1);
            /*NOTREACHED*/
        }

        /*
         * replace '\n' or (end of buffer) with end of string.
         */
        ascii[c-1] = '\0';

        /*
         * flush any remaining input past the size of the buffer.
         */
        (void) ioctl(STDIN_FILENO, I_FLUSH, FLUSHR);
    }

    if (str_to_label(ascii, &label, MAC_LABEL, L_NO_CORRECTION,
        &err) == -1) {
        label_error(ascii, err);
    }
    if (label_to_str(label, &labelstr, mode,
        DEF_NAMES) == 0) {
        (void) printf("%s\n", labelstr);
    }

    level =  &label->classification.class_u.class_chunk;
    while (*level > 0) {
        bitfinder(*label, 0);
        *level -= 1;
    }
    m_label_free(label);

    return (0);     /* really exit(0); */
}