libdladm/common/propfuncs.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 (c) 2008, 2011, Oracle and/or its affiliates. All rights reserved.
 */

#include <stdlib.h>
#include <strings.h>
#include <errno.h>
#include <ctype.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/dld.h>
#include <fcntl.h>
#include <unistd.h>
#include <libdladm_impl.h>
#include <libdlflow_impl.h>

/*
 * XXX duplicate defines
 */
#define DLADM_PROP_VAL_MAX  32
#define DLADM_MAX_PROPS     32

static void
free_props(prop_db_info_t *lip)
{
    prop_db_info_t  *lip_next;
    prop_val_t  *lvp, *lvp_next;

    for (; lip != NULL; lip = lip_next) {
        lip_next = lip->li_nextprop;
        for (lvp = lip->li_val; lvp != NULL; lvp = lvp_next) {
            lvp_next = lvp->lv_nextval;
            free(lvp);
        }
        free(lip);
    }
}

/*
 * Generate an entry in the property database.
 * Each entry has this format:
 * <name>   <prop0>=<val0>,...,<valn>;...;<propn>=<val0>,...,<valn>;
 */
static void
generate_prop_line(const char *name, char *buf,
    prop_db_info_t *listp, dladm_status_t *statusp)
{
    char        tmpbuf[MAXLINELEN];
    char        *ptr, *lim = tmpbuf + MAXLINELEN;
    prop_db_info_t  *lip = listp;
    prop_val_t  *lvp = NULL;

    /*
     * Delete line if there are no properties left.
     */
    if (lip == NULL ||
        (lip->li_val == NULL && lip->li_nextprop == NULL)) {
        buf[0] = '\0';
        return;
    }
    ptr = tmpbuf;
    ptr += snprintf(ptr, BUFLEN(lim, ptr), "%s\t", name);
    for (; lip != NULL; lip = lip->li_nextprop) {
        /*
         * Skip properties without values.
         */
        if (lip->li_val == NULL)
            continue;

        ptr += snprintf(ptr, BUFLEN(lim, ptr), "%s=", lip->li_name);
        for (lvp = lip->li_val; lvp != NULL; lvp = lvp->lv_nextval) {
            ptr += snprintf(ptr, BUFLEN(lim, ptr), "%s%c",
                lvp->lv_name,
                ((lvp->lv_nextval == NULL) ? ';' : ','));
        }
    }
    if (ptr > lim) {
        *statusp = DLADM_STATUS_TOOSMALL;
        return;
    }
    (void) snprintf(buf, MAXLINELEN, "%s\n", tmpbuf);
}

/*
 * This function is used to update or create an entry in the persistent db.
 * process_prop_db() will first scan the db for an entry matching the
 * specified name. If a match is found, this function is invoked with the
 * entry's contents (buf) and its linked-list representation (listp). lsp
 * holds the name and values of the property to be added or updated; this
 * information will be merged with listp. Subsequently, an updated entry
 * will be written to buf, which will in turn be written to disk by
 * process_prop_db(). If no entry matches the specified name, listp
 * will be NULL; a new entry will be generated in this case and it will
 * contain only the property information in lsp.
 */
/* ARGSUSED */
boolean_t
process_prop_set(dladm_handle_t handle, prop_db_state_t *lsp, char *buf,
    prop_db_info_t *listp, dladm_status_t *statusp)
{
    dladm_status_t  status;
    prop_db_info_t  *lastp = NULL, *lip = listp, *nlip = NULL;
    prop_val_t  **lvpp;
    int     i;

    if (lsp->ls_propname == NULL) {
        buf[0] = '\0';
        return (B_FALSE);
    }

    /*
     * Find the prop we want to change.
     */
    for (; lip != NULL; lip = lip->li_nextprop) {
        if (strcmp(lip->li_name, lsp->ls_propname) == 0)
            break;

        lastp = lip;
    }

    if (lip == NULL) {
        /*
         * If the prop is not found, append it to the list.
         */
        if ((nlip = malloc(sizeof (prop_db_info_t))) == NULL) {
            status = DLADM_STATUS_NOMEM;
            goto fail;
        }
        /*
         * nlip will need to be freed later if there is no list to
         * append to.
         */
        if (lastp != NULL)
            lastp->li_nextprop = nlip;
        nlip->li_name = lsp->ls_propname;
        nlip->li_nextprop = NULL;
        nlip->li_val = NULL;
        lvpp = &nlip->li_val;
    } else {
        prop_val_t  *lvp, *lvp_next;

        /*
         * If the prop is found, delete the existing values from it.
         */
        for (lvp = lip->li_val; lvp != NULL; lvp = lvp_next) {
            lvp_next = lvp->lv_nextval;
            free(lvp);
        }
        lip->li_val = NULL;
        lvpp = &lip->li_val;
    }

    /*
     * Fill our prop with the specified values.
     */
    for (i = 0; i < *lsp->ls_valcntp; i++) {
        if ((*lvpp = malloc(sizeof (prop_val_t))) == NULL) {
            status = DLADM_STATUS_NOMEM;
            goto fail;
        }
        (*lvpp)->lv_name = lsp->ls_propval[i];
        (*lvpp)->lv_nextval = NULL;
        lvpp = &(*lvpp)->lv_nextval;
    }

    if (listp != NULL) {
        generate_prop_line(lsp->ls_name, buf, listp, statusp);
    } else {
        generate_prop_line(lsp->ls_name, buf, nlip, statusp);
        free_props(nlip);
    }
    return (B_FALSE);

fail:
    *statusp = status;
    if (listp == NULL)
        free_props(nlip);

    return (B_FALSE);
}

/*
 * This function is used for retrieving the values for a specific property.
 * It gets called if an entry matching the specified name exists in the db.
 * The entry is converted into a linked-list listp. This list is then scanned
 * for the specified property name; if a matching property exists, its
 * associated values are copied to the array lsp->ls_propval.
 */
/* ARGSUSED */
boolean_t
process_prop_get(dladm_handle_t handle, prop_db_state_t *lsp, char *buf,
    prop_db_info_t *listp, dladm_status_t *statusp)
{
    prop_db_info_t  *lip = listp;
    prop_val_t  *lvp;
    uint_t      valcnt = 0;

    /*
     * Find the prop we want to get.
     */
    for (; lip != NULL; lip = lip->li_nextprop) {
        if (strcmp(lip->li_name, lsp->ls_propname) == 0)
            break;
    }
    if (lip == NULL) {
        *statusp = DLADM_STATUS_NOTFOUND;
        return (B_FALSE);
    }

    for (lvp = lip->li_val; lvp != NULL; lvp = lvp->lv_nextval) {
        (void) strncpy(lsp->ls_propval[valcnt], lvp->lv_name,
            DLADM_PROP_VAL_MAX);

        if (++valcnt >= *lsp->ls_valcntp && lvp->lv_nextval != NULL) {
            *statusp = DLADM_STATUS_TOOSMALL;
            return (B_FALSE);
        }
    }
    /*
     * This function is meant to be called at most once for each call
     * to process_prop_db(). For this reason, it's ok to overwrite
     * the caller's valcnt array size with the actual number of values
     * returned.
     */
    *lsp->ls_valcntp = valcnt;
    return (B_FALSE);
}

/*
 * This is used for initializing properties.
 * Unlike the other routines, this gets called for every entry in the
 * database. lsp->ls_name is not user-specified but instead is set to
 * the current name being processed.
 */
/* ARGSUSED */
boolean_t
process_prop_init(dladm_handle_t handle, prop_db_state_t *lsp, char *buf,
    prop_db_info_t *listp, dladm_status_t *statusp)
{
    dladm_status_t  status = DLADM_STATUS_OK;
    prop_db_info_t  *lip = listp;
    prop_val_t  *lvp;
    uint_t      valcnt, i;
    char        **propval;

    for (; lip != NULL; lip = lip->li_nextprop) {
        /*
         * Construct the propval array and fill it with
         * values from listp.
         */
        for (lvp = lip->li_val, valcnt = 0;
            lvp != NULL; lvp = lvp->lv_nextval, valcnt++) {
        }

        propval = malloc(sizeof (char *) * valcnt);
        if (propval == NULL) {
            *statusp = DLADM_STATUS_NOMEM;
            break;
        }
        lvp = lip->li_val;
        for (i = 0; i < valcnt; i++, lvp = lvp->lv_nextval)
            propval[i] = (char *)lvp->lv_name;

        status = (*lsp->ls_initop)(handle, lsp->ls_name, lip->li_name,
            propval, valcnt, DLADM_OPT_ACTIVE, NULL);

        /*
         * We continue with initializing other properties even
         * after encountering an error. This error will be
         * propagated to the caller via 'statusp'.
         */
        if (status != DLADM_STATUS_OK)
            *statusp = status;

        free(propval);
    }
    return (B_TRUE);
}

static int
parse_props(char *buf, prop_db_info_t **lipp)
{
    int         i, len;
    char            *curr;
    prop_db_info_t      *lip = NULL;
    prop_db_info_t      **tailp = lipp;
    prop_val_t      *lvp = NULL;
    prop_val_t      **vtailp = NULL;

    curr = buf;
    len = strlen(buf);
    for (i = 0; i < len; i++) {
        char        c = buf[i];
        boolean_t   match = (c == '=' || c == ',' || c == ';');

        /*
         * Move to the next character if there is no match and
         * if we have not reached the last character.
         */
        if (!match && i != len - 1)
            continue;

        if (match) {
            /*
             * Nul-terminate the string pointed to by 'curr'.
             */
            buf[i] = '\0';
            if (*curr == '\0')
                goto fail;
        }

        if (lip != NULL) {
            /*
             * We get here after we have processed the "<prop>="
             * pattern. The pattern we are now interested in is
             * "<val0>,<val1>,...,<valn>;". For each value we
             * find, a prop_val_t will be allocated and
             * added to the current 'lip'.
             */
            if (c == '=')
                goto fail;

            lvp = malloc(sizeof (*lvp));
            if (lvp == NULL)
                goto fail;

            lvp->lv_name = curr;
            lvp->lv_nextval = NULL;
            *vtailp = lvp;
            vtailp = &lvp->lv_nextval;

            if (c == ';') {
                tailp = &lip->li_nextprop;
                vtailp = NULL;
                lip = NULL;
            }
        } else {
            /*
             * lip == NULL indicates that 'curr' must be refering
             * to a property name. We allocate a new prop_db_info_t
             * append it to the list given by the caller.
             */
            if (c != '=')
                goto fail;

            lip = malloc(sizeof (*lip));
            if (lip == NULL)
                goto fail;

            lip->li_name = curr;
            lip->li_val = NULL;
            lip->li_nextprop = NULL;
            *tailp = lip;
            vtailp = &lip->li_val;
        }
        curr = buf + i + 1;
    }
    /*
     * The list must be non-empty and the last character must be ';'.
     */
    if (*lipp == NULL || lip != NULL)
        goto fail;

    return (0);

fail:
    free_props(*lipp);
    *lipp = NULL;
    return (-1);
}

static boolean_t
process_prop_line(dladm_handle_t handle, prop_db_state_t *lsp, char *buf,
    dladm_status_t *statusp)
{
    prop_db_info_t      *lip = NULL;
    int         i, len, llen;
    char            *str, *lasts;
    boolean_t       cont, noname = B_FALSE;

    /*
     * Skip leading spaces, blank lines, and comments.
     */
    len = strlen(buf);
    for (i = 0; i < len; i++) {
        if (!isspace(buf[i]))
            break;
    }
    if (i == len || buf[i] == '#')
        return (B_TRUE);

    str = buf + i;
    if (lsp->ls_name != NULL) {
        /*
         * Skip names we're not interested in.
         * Note that strncmp() and isspace() are used here
         * instead of strtok() and strcmp() because we don't
         * want to modify buf in case it does not contain the
         * specified name.
         */
        llen = strlen(lsp->ls_name);
        if (strncmp(str, lsp->ls_name, llen) != 0 ||
            !isspace(str[llen]))
            return (B_TRUE);
    } else {
        /*
         * If a name is not specified, find the name
         * and assign it to lsp->ls_name.
         */
        if (strtok_r(str, " \n\t", &lasts) == NULL)
            goto fail;

        llen = strlen(str);
        lsp->ls_name = str;
        noname = B_TRUE;
    }
    str += llen + 1;
    if (str >= buf + len)
        goto fail;

    /*
     * Now find the list of properties.
     */
    if ((str = strtok_r(str, " \n\t", &lasts)) == NULL)
        goto fail;

    if (parse_props(str, &lip) < 0)
        goto fail;

    cont = (*lsp->ls_op)(handle, lsp, buf, lip, statusp);
    free_props(lip);
    if (noname)
        lsp->ls_name = NULL;
    return (cont);

fail:
    free_props(lip);
    if (noname)
        lsp->ls_name = NULL;

    /*
     * Delete corrupted line.
     */
    buf[0] = '\0';
    return (B_TRUE);
}

dladm_status_t
process_prop_db(dladm_handle_t handle, void *arg, FILE *fp, FILE *nfp)
{
    prop_db_state_t *lsp = arg;
    dladm_status_t      status = DLADM_STATUS_OK;
    char            buf[MAXLINELEN];
    boolean_t       cont = B_TRUE;

    /*
     * This loop processes each line of the configuration file.
     * buf can potentially be modified by process_prop_line().
     * If this is a write operation and buf is not truncated, buf will
     * be written to disk. process_prop_line() will no longer be
     * called after it returns B_FALSE; at which point the remainder
     * of the file will continue to be read and, if necessary, written
     * to disk as well.
     */
    while (fgets(buf, MAXLINELEN, fp) != NULL) {
        if (cont)
            cont = process_prop_line(handle, lsp, buf, &status);

        if (nfp != NULL && buf[0] != '\0' && fputs(buf, nfp) == EOF) {
            status = dladm_errno2status(errno);
            break;
        }
    }

    if (status != DLADM_STATUS_OK || !cont)
        return (status);

    if (lsp->ls_op == process_prop_set) {
        /*
         * If the specified name is not found above, we add the
         * name and its properties to the configuration file.
         */
        (void) (*lsp->ls_op)(handle, lsp, buf, NULL, &status);
        if (status == DLADM_STATUS_OK && fputs(buf, nfp) == EOF)
            status = dladm_errno2status(errno);
    }

    if (lsp->ls_op == process_prop_get)
        status = DLADM_STATUS_NOTFOUND;

    return (status);
}

dladm_status_t
i_dladm_get_prop_temp(dladm_handle_t handle, const char *name,
    dladm_prop_type_t type, const char *prop_name, char **prop_val,
    uint_t *val_cntp, prop_table_t *prop_tbl)
{
    int         i;
    dladm_status_t  status;
    uint_t      cnt;
    fprop_desc_t    *pdp;

    if (name == NULL || prop_name == NULL || prop_val == NULL ||
        val_cntp == NULL || *val_cntp == 0)
        return (DLADM_STATUS_BADARG);

    for (i = 0; i < prop_tbl->pt_size; i++)
        if (strcasecmp(prop_name, prop_tbl->pt_table[i].pd_name) == 0)
            break;

    if (i == prop_tbl->pt_size)
        return (DLADM_STATUS_NOTFOUND);

    pdp = &prop_tbl->pt_table[i];
    status = DLADM_STATUS_OK;

    switch (type) {
    case DLADM_PROP_VAL_CURRENT:
        status = pdp->pd_get(handle, name, prop_val, val_cntp);
        break;
    case DLADM_PROP_VAL_DEFAULT:
        if (pdp->pd_defval.vd_name == NULL) {
            status = DLADM_STATUS_NOTSUP;
            break;
        }
        (void) strcpy(*prop_val, pdp->pd_defval.vd_name);
        *val_cntp = 1;
        break;

    case DLADM_PROP_VAL_MODIFIABLE:
        if (pdp->pd_getmod != NULL) {
            status = pdp->pd_getmod(handle, name, prop_val,
                val_cntp);
            break;
        }
        cnt = pdp->pd_nmodval;
        if (cnt == 0) {
            status = DLADM_STATUS_NOTSUP;
        } else if (cnt > *val_cntp) {
            status = DLADM_STATUS_TOOSMALL;
        } else {
            for (i = 0; i < cnt; i++) {
                (void) strcpy(prop_val[i],
                    pdp->pd_modval[i].vd_name);
            }
            *val_cntp = cnt;
        }
        break;
    default:
        status = DLADM_STATUS_BADARG;
        break;
    }

    return (status);
}

static dladm_status_t
i_dladm_set_one_prop_temp(dladm_handle_t handle, const char *name,
    fprop_desc_t *pdp, char **prop_val, uint_t val_cnt, uint_t flags)
{
    dladm_status_t  status;
    val_desc_t  *vdp = NULL;
    uint_t      cnt;

    if (pdp->pd_temponly && (flags & DLADM_OPT_PERSIST) != 0)
        return (DLADM_STATUS_TEMPONLY);

    if (pdp->pd_set == NULL)
        return (DLADM_STATUS_PROPRDONLY);

    if (prop_val != NULL) {
        if (pdp->pd_check != NULL)
            status = pdp->pd_check(pdp, prop_val, val_cnt, &vdp);
        else
            status = DLADM_STATUS_BADARG;

        if (status != DLADM_STATUS_OK)
            return (status);

        cnt = val_cnt;
    } else {
        if (pdp->pd_defval.vd_name == NULL)
            return (DLADM_STATUS_NOTSUP);

        if ((vdp = malloc(sizeof (val_desc_t))) == NULL)
            return (DLADM_STATUS_NOMEM);

        (void) memcpy(vdp, &pdp->pd_defval, sizeof (val_desc_t));
        cnt = 1;
    }

    status = pdp->pd_set(handle, name, vdp, cnt);

    free(vdp);
    return (status);
}

dladm_status_t
i_dladm_set_prop_temp(dladm_handle_t handle, const char *name,
    const char *prop_name, char **prop_val, uint_t val_cnt, uint_t flags,
    char **errprop, prop_table_t *prop_tbl)
{
    int         i;
    dladm_status_t  status = DLADM_STATUS_OK;
    boolean_t   found = B_FALSE;

    for (i = 0; i < prop_tbl->pt_size; i++) {
        fprop_desc_t    *pdp = &prop_tbl->pt_table[i];
        dladm_status_t  s;

        if (prop_name != NULL &&
            (strcasecmp(prop_name, pdp->pd_name) != 0))
            continue;

        found = B_TRUE;
        s = i_dladm_set_one_prop_temp(handle, name, pdp, prop_val,
            val_cnt, flags);

        if (prop_name != NULL) {
            status = s;
            break;
        } else {
            if (s != DLADM_STATUS_OK &&
                s != DLADM_STATUS_NOTSUP) {
                if (errprop != NULL)
                    *errprop = pdp->pd_name;
                status = s;
                break;
            }
        }
    }

    if (!found)
        status = DLADM_STATUS_NOTFOUND;

    return (status);
}

boolean_t
i_dladm_is_prop_temponly(const char *prop_name, char **errprop,
    prop_table_t *prop_tbl)
{
    int         i;

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

    for (i = 0; i < prop_tbl->pt_size; i++) {
        fprop_desc_t    *pdp = &prop_tbl->pt_table[i];

        if (strcasecmp(prop_name, pdp->pd_name) != 0)
            continue;

        if (errprop != NULL)
            *errprop = pdp->pd_name;

        if (pdp->pd_temponly)
            return (B_TRUE);
    }

    return (B_FALSE);
}
void
dladm_free_props(dladm_arg_list_t *list)
{
    dladm_free_args(list);
}

dladm_status_t
dladm_parse_props(char *str, dladm_arg_list_t **listp, boolean_t novalues)
{
    if (dladm_parse_args(str, listp, novalues) != DLADM_STATUS_OK)
        goto fail;

    return (DLADM_STATUS_OK);

fail:
    dladm_free_args(*listp);
    return (DLADM_STATUS_PROP_PARSE_ERR);
}