8322 nl: misleading-indentation

[unleashed/tickless.git] / usr / src / lib / libbsm / common / getdaent.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 2007 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident   "%Z%%M% %I%     %E% SMI"

#include <ctype.h>
#include <string.h>
#include <stdlib.h>
#include <tsol/label.h>
#include <bsm/devices.h>
#include <bsm/devalloc.h>

extern char *_strdup_null(char *);

static struct _dabuff {
        FILE            *_daf;  /* pointer into /etc/security/device_allocate */
        devalloc_t      _interpdevalloc;
        char            _interpdaline[DA_BUFSIZE + 1];
        char             *_DEVALLOC;
} *__dabuff;

#define daf     (_da->_daf)
#define interpdevalloc  (_da->_interpdevalloc)
#define interpdaline    (_da->_interpdaline)
#define DEVALLOC_FILE   (_da->_DEVALLOC)
static devalloc_t       *da_interpret(char *);

int da_matchname(devalloc_t *, char *);
int da_matchtype(devalloc_t *, char *);

static int system_labeled = 0;

/*
 * trim_white -
 *      trims off leading and trailing white space from input string.
 *      The leading white space is skipped by moving the pointer forward.
 *      The trailing white space is removed by nulling the white space
 *      characters.
 *      returns pointer to non-white string, else returns NULL if input string
 *      is null or if the resulting string has zero length.
 */
char *
trim_white(char *ptr)
{
        char    *tptr;

        if (ptr == NULL)
                return (NULL);
        while (isspace(*ptr))
                ptr++;
        tptr = ptr + strlen(ptr);
        while (tptr != ptr && isspace(tptr[-1]))
                --tptr;
        *tptr = '\0';
        if (*ptr == '\0')
                return (NULL);

        return (ptr);
}

/*
 * pack_white -
 *      trims off multiple occurrences of white space from input string.
 *      returns the number of spaces retained
 */
int
pack_white(char *ptr)
{
        int     cnt = 0;
        char    *tptr, ch;

        if (ptr == NULL)
                return (0);
        tptr = ptr;
        while (isspace(*tptr))
                tptr++;
        for (;;) {
                while ((ch = *tptr) != '\0' && !isspace(ch)) {
                        *ptr++ = ch;
                        tptr++;
                }
                while (isspace(*tptr))
                        tptr++;
                if (*tptr == '\0')
                        break;
                *ptr++ = ' ';
                cnt++;
        }
        *ptr = '\0';

        return (cnt);
}

/*
 * getdadmline -
 *      reads one device_alloc/device_maps line from stream into buff of len
 *      bytes. Continued lines from stream are concatenated into one line in
 *      buff. Comments are removed from buff.
 *      returns the number of characters in buff, else returns 0 if no
 *      characters are read or an error occurred.
 */
int
getdadmline(char *buff, int len, FILE *stream)
{
        int     tmpcnt;
        int     charcnt = 0;
        int     fileerr = 0;
        int     contline = 0;
        char    *cp;
        char    *ccp;

        do {
                cp = buff;
                *cp = NULL;
                do {
                        contline = 0;
                        if (fgets(cp, len - charcnt, stream) == NULL) {
                                fileerr = 1;
                                break;
                        }
                        ccp = strchr(cp, '\n');
                        if (ccp != NULL) {
                                if (ccp != cp && ccp[-1] == '\\') {
                                        ccp--;
                                        contline = 1;
                                }
                                else
                                        contline = 0;
                                *ccp = NULL;
                        }
                        tmpcnt = strlen(cp);
                        cp += tmpcnt;
                        charcnt += tmpcnt;
                } while ((contline) || (charcnt == 0));
                ccp = strpbrk(buff, "#");
                if (ccp != NULL)
                        *ccp = NULL;
                charcnt = strlen(buff);
        } while ((fileerr == 0) && (charcnt == 0));

        if (fileerr && !charcnt)
                return (0);
        else
                return (charcnt);
}

/*
 * _daalloc -
 *      allocates common buffers and structures.
 *      returns pointer to the new structure, else returns NULL on error.
 */
static struct _dabuff *
_daalloc(void)
{
        struct _dabuff  *_da = __dabuff;

        if (_da == NULL) {
                _da = (struct _dabuff *)calloc((unsigned)1,
                    (unsigned)sizeof (*__dabuff));
                if (_da == NULL)
                        return (NULL);
                DEVALLOC_FILE = "/etc/security/device_allocate";
                daf = NULL;
                __dabuff = _da;
                system_labeled = is_system_labeled();
        }

        return (__dabuff);
}

/*
 * getdadmfield -
 *      gets individual fields separated by skip in ptr.
 */
char *
getdadmfield(char *ptr, char *skip)
{
        static char     *tptr = NULL;
        char            *pend;

        /* check for a continuing search */
        if (ptr == NULL)
                ptr = tptr;
        /* check for source end */
        if (ptr == NULL || *ptr == '\0')
                return (NULL);
        /* find terminator */
        pend = strpbrk(ptr, skip);
        /* terminate and set continuation pointer */
        if (pend != NULL) {
                *pend++ = '\0';
                tptr = pend;
        } else
                tptr = NULL;
        /*
         * trim off any surrounding white space, return what's left
         */

        return (trim_white(ptr));
}

/*
 * setdaent -
 *      rewinds the device_allocate file to the begining.
 */

void
setdaent(void)
{
        struct _dabuff  *_da = _daalloc();

        if (_da == NULL)
                return;
        if (daf == NULL)
                daf = fopen(DEVALLOC_FILE, "rF");
        else
                rewind(daf);
}

/*
 * enddaent -
 *      closes device_allocate file.
 */

void
enddaent(void)
{
        struct _dabuff  *_da = _daalloc();

        if (_da == NULL)
                return;
        if (daf != NULL) {
                (void) fclose(daf);
                daf = NULL;
        }
}

/*
 * setdafile -
 *      changes the default device_allocate file to the one specified.
 *      It does not close the previous file. If this is desired, enddaent
 *      should be called prior to setdafile.
 */
void
setdafile(char *file)
{
        struct _dabuff  *_da = _daalloc();

        if (_da == NULL)
                return;
        if (daf != NULL) {
                (void) fclose(daf);
                daf = NULL;
        }
        DEVALLOC_FILE = file;
}

void
freedaent(devalloc_t *dap)
{
        if (dap == NULL)
                return;
        _kva_free(dap->da_devopts);
        dap->da_devopts = NULL;
}

/*
 * getdaon -
 *      checks if device_allocate has string DEVICE_ALLOCATION=ON or
 *      DEVICE_ALLOCATION=OFF string in it.
 *      returns 1 if the string is DEVICE_ALLOCATION=ON, 0 if it is
 *      DEVICE_ALLOCATION=OFF, -1 if neither string present.
 */
int
getdaon()
{
        int             is_on = -1;
        char            line1[DA_BUFSIZE + 1];
        struct _dabuff *_da = _daalloc();

        setdaent();
        if ((_da == NULL) || (daf == NULL)) {
                enddaent();
                return (is_on);
        }
        while (getdadmline(line1, (int)sizeof (line1), daf) != 0) {
                if (strncmp(line1, DA_ON_STR, (strlen(DA_ON_STR) - 1)) == 0) {
                        is_on = 1;
                        break;
                } else if (strncmp(line1, DA_OFF_STR,
                    (strlen(DA_OFF_STR) - 1)) == 0) {
                        is_on = 0;
                        break;
                }
        }
        enddaent();

        return (is_on);
}

/*
 * getdaent -
 *      When first called, returns a pointer to the first devalloc_t
 *      structure in device_allocate; thereafter, it returns a pointer to the
 *      next devalloc_t structure in the file. Thus, successive calls can be
 *      used to search the entire file.
 *      call to getdaent should be bracketed by setdaent and enddaent.
 *      returns NULL on error.
 */
devalloc_t *
getdaent(void)
{
        char            line1[DA_BUFSIZE + 1];
        devalloc_t      *da;
        struct _dabuff  *_da = _daalloc();

        if ((_da == 0) || (daf == NULL))
                return (NULL);

        while (getdadmline(line1, (int)sizeof (line1), daf) != 0) {
                if ((strncmp(line1, DA_ON_STR, (strlen(DA_ON_STR) - 1)) == 0) ||
                    (strncmp(line1, DA_OFF_STR, (strlen(DA_OFF_STR) - 1)) == 0))
                        continue;
                if ((da = da_interpret(line1)) == NULL)
                        continue;
                return (da);
        }

        return (NULL);
}

/*
 * getdanam
 *      searches from the beginning of device_allocate for the device specified
 *      by its name.
 *      call to getdanam should be bracketed by setdaent and enddaent.
 *      returns pointer to devalloc_t for the device if it is found, else
 *      returns NULL if device not found or in case of error.
 */
devalloc_t *
getdanam(char *name)
{
        char            line[DA_BUFSIZE + 1];
        devalloc_t      *da;
        struct _dabuff  *_da = _daalloc();

        if ((name == NULL) || (_da == 0) || (daf == NULL))
                return (NULL);

        while (getdadmline(line, (int)sizeof (line), daf) != 0) {
                if (strstr(line, name) == NULL)
                        continue;
                if ((da = da_interpret(line)) == NULL)
                        continue;
                if (da_matchname(da, name)) {
                        enddaent();
                        return (da);
                }
                freedaent(da);
        }

        return (NULL);
}

/*
 * getdatype -
 *      searches from the beginning of device_allocate for the device specified
 *      by its type.
 *      call to getdatype should be bracketed by setdaent and enddaent.
 *      returns pointer to devalloc_t for the device if it is found, else
 *      returns NULL if device not found or in case of error.
 */
devalloc_t *
getdatype(char *type)
{
        char            line1[DA_BUFSIZE + 1];
        devalloc_t      *da;
        struct _dabuff  *_da = _daalloc();

        if ((type == NULL) || (_da == NULL) || (daf == NULL))
                return (NULL);

        while (getdadmline(line1, (int)sizeof (line1), daf) != 0) {
                if (strstr(line1, type) == NULL)
                        continue;
                if ((da = da_interpret(line1)) == NULL)
                        continue;
                if (da_matchtype(da, type))
                        return (da);
                freedaent(da);
        }

        return (NULL);
}

/*
 * da_matchname -
 *      checks if the specified devalloc_t is for the device specified.
 *      returns 1 if it is, else returns 0.
 */
int
da_matchname(devalloc_t *dap, char *name)
{
        if (dap->da_devname == NULL)
                return (0);

        return ((strcmp(dap->da_devname, name) == 0));
}

/*
 * da_matchtype -
 *      checks if the specified devalloc_t is for the device type specified.
 *      returns 1 if match found, else, returns 0.
 */
int
da_matchtype(devalloc_t *da, char *type)
{
        if (da->da_devtype == NULL)
                return (0);

        return ((strcmp(da->da_devtype, type) == 0));
}

/*
 * da_match -
 *      calls da_matchname or da_matchdev as appropriate.
 */
int
da_match(devalloc_t *dap, da_args *dargs)
{
        if (dargs->devinfo->devname)
                return (da_matchname(dap, dargs->devinfo->devname));
        else if (dargs->devinfo->devtype)
                return (da_matchtype(dap, dargs->devinfo->devtype));

        return (0);
}

/*
 * da_interpret -
 *      parses val and initializes pointers in devalloc_t.
 *      returns pointer to parsed devalloc_t entry, else returns NULL on error.
 */
static devalloc_t  *
da_interpret(char *val)
{
        struct _dabuff  *_da = _daalloc();
        char    *opts;
        int     i;
        kva_t   *kvap;
        kv_t    *kvp;

        if (_da == NULL)
                return (NULL);

        (void) strcpy(interpdaline, val);
        interpdevalloc.da_devname = getdadmfield(interpdaline, KV_DELIMITER);
        interpdevalloc.da_devtype = getdadmfield(NULL, KV_DELIMITER);
        opts = getdadmfield(NULL, KV_DELIMITER);
        (void) getdadmfield(NULL, KV_DELIMITER);        /* reserved field */
        interpdevalloc.da_devauth = getdadmfield(NULL, KV_DELIMITER);
        interpdevalloc.da_devexec = getdadmfield(NULL, KV_DELIMITER);
        interpdevalloc.da_devopts = NULL;
        if (interpdevalloc.da_devname == NULL ||
            interpdevalloc.da_devtype == NULL)
                return (NULL);
        if ((opts != NULL) &&
            (strncmp(opts, DA_RESERVED, strlen(DA_RESERVED)) != 0)) {
                interpdevalloc.da_devopts =
                    _str2kva(opts, KV_ASSIGN, KV_TOKEN_DELIMIT);
        }
        /* remove any extraneous whitespace in the options */
        if ((kvap = interpdevalloc.da_devopts) != NULL) {
                for (i = 0, kvp = kvap->data; i < kvap->length; i++, kvp++) {
                        (void) pack_white(kvp->key);
                        (void) pack_white(kvp->value);
                }
        }

        if (system_labeled) {
                /* if label range is not defined, use the default range. */
                int             i = 0, nlen = 0;
                char            *minstr = NULL, *maxstr = NULL;
                kva_t           *nkvap = NULL;
                kv_t            *ndata = NULL, *odata = NULL;

                if (kvap == NULL) {
                        nlen = 2;       /* minlabel, maxlabel */
                } else {
                        nlen += kvap->length;
                        if ((minstr = kva_match(kvap, DAOPT_MINLABEL)) == NULL)
                                nlen++;
                        if ((maxstr = kva_match(kvap, DAOPT_MAXLABEL)) == NULL)
                                nlen++;
                }
                if ((minstr != NULL) && (maxstr != NULL))
                        /*
                         * label range provided; we don't need to construct
                         * default range.
                         */
                        goto out;
                nkvap = _new_kva(nlen);
                ndata = nkvap->data;
                if (kvap != NULL) {
                        for (i = 0; i < kvap->length; i++) {
                                odata = kvap->data;
                                ndata[i].key = _strdup_null(odata[i].key);
                                ndata[i].value = _strdup_null(odata[i].value);
                                nkvap->length++;
                        }
                }
                if (minstr == NULL) {
                        ndata[i].key = strdup(DAOPT_MINLABEL);
                        ndata[i].value = strdup(DA_DEFAULT_MIN);
                        nkvap->length++;
                        i++;
                }
                if (maxstr == NULL) {
                        ndata[i].key = strdup(DAOPT_MAXLABEL);
                        ndata[i].value = strdup(DA_DEFAULT_MAX);
                        nkvap->length++;
                }
                interpdevalloc.da_devopts = nkvap;
        }

out:
        return (&interpdevalloc);
}