libdladm/common/linkprop.c

	linkprop.c revision 948f2876ce2a3010558f4f6937e16086ebcd36f2
/*
 * 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 <stdlib.h>
#include <strings.h>
#include <errno.h>
#include <ctype.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/dld.h>
#include <sys/zone.h>
#include <fcntl.h>
#include <unistd.h>
#include <libdevinfo.h>
#include <zone.h>
#include <libdllink.h>
#include <libdladm_impl.h>
#include <libdlwlan.h>
#include <dlfcn.h>
#include <link.h>

static dladm_status_t   i_dladm_set_prop_db(const char *, const char *,
                char **, uint_t);
static dladm_status_t   i_dladm_get_prop_db(const char *, const char *,
                char **, uint_t *);
static dladm_status_t   i_dladm_get_prop_temp(const char *, dladm_prop_type_t,
                const char *, char **, uint_t *);
static dladm_status_t   i_dladm_set_prop_temp(const char *, const char *,
                char **, uint_t, uint_t, char **);
static boolean_t    i_dladm_is_prop_temponly(const char *prop_name,
                char **);

typedef struct val_desc {
    char    *vd_name;
    void    *vd_val;
} val_desc_t;

struct prop_desc;

typedef dladm_status_t  pd_getf_t(const char *, char **, uint_t *);
typedef dladm_status_t  pd_setf_t(const char *, val_desc_t *, uint_t);
typedef dladm_status_t  pd_checkf_t(struct prop_desc *, char **,
                uint_t, val_desc_t **);

static pd_getf_t    do_get_zone;
static pd_setf_t    do_set_zone;
static pd_checkf_t  do_check_zone;

typedef struct prop_desc {
    char        *pd_name;
    val_desc_t  pd_defval;
    val_desc_t  *pd_modval;
    uint_t      pd_nmodval;
    boolean_t   pd_temponly;
    pd_setf_t   *pd_set;
    pd_getf_t   *pd_getmod;
    pd_getf_t   *pd_get;
    pd_checkf_t *pd_check;
} prop_desc_t;

static prop_desc_t  prop_table[] = {
    { "zone",   { "", NULL }, NULL, 0, B_TRUE,
        do_set_zone, NULL,
        do_get_zone, do_check_zone}
};

#define MAX_PROPS   (sizeof (prop_table) / sizeof (prop_desc_t))

dladm_status_t
dladm_set_prop(const char *link, const char *prop_name, char **prop_val,
    uint_t val_cnt, uint_t flags, char **errprop)
{
    dladm_status_t      status = DLADM_STATUS_BADARG;

    if (link == NULL || (prop_val == NULL && val_cnt > 0) ||
        (prop_val != NULL && val_cnt == 0) || flags == 0)
        return (DLADM_STATUS_BADARG);

    if ((flags & DLADM_OPT_TEMP) != 0) {
        status = i_dladm_set_prop_temp(link, prop_name, prop_val,
            val_cnt, flags, errprop);
        if (status == DLADM_STATUS_TEMPONLY &&
            (flags & DLADM_OPT_PERSIST) != 0)
            return (DLADM_STATUS_TEMPONLY);

        if (status == DLADM_STATUS_NOTFOUND) {
            status = DLADM_STATUS_BADARG;
            if (dladm_wlan_is_valid(link)) {
                status = dladm_wlan_set_prop(link, prop_name,
                    prop_val, val_cnt, errprop);
            }
        }
        if (status != DLADM_STATUS_OK)
            return (status);
    }
    if ((flags & DLADM_OPT_PERSIST) != 0) {
        if (i_dladm_is_prop_temponly(prop_name, errprop))
            return (DLADM_STATUS_TEMPONLY);

        status = i_dladm_set_prop_db(link, prop_name,
            prop_val, val_cnt);
    }
    return (status);
}

dladm_status_t
dladm_walk_prop(const char *link, void *arg,
    boolean_t (*func)(void *, const char *))
{
    int i;

    if (link == NULL || func == NULL)
        return (DLADM_STATUS_BADARG);

    /* For wifi links, show wifi properties first */
    if (dladm_wlan_is_valid(link)) {
        dladm_status_t  status;

        status = dladm_wlan_walk_prop(link, arg, func);
        if (status != DLADM_STATUS_OK)
            return (status);
    }

    /* Then show data-link properties if there are any */
    for (i = 0; i < MAX_PROPS; i++) {
        if (!func(arg, prop_table[i].pd_name))
            break;
    }
    return (DLADM_STATUS_OK);
}

dladm_status_t
dladm_get_prop(const char *link, dladm_prop_type_t type,
    const char *prop_name, char **prop_val, uint_t *val_cntp)
{
    dladm_status_t status;

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

    if (type == DLADM_PROP_VAL_PERSISTENT) {
        if (i_dladm_is_prop_temponly(prop_name, NULL))
            return (DLADM_STATUS_TEMPONLY);
        return (i_dladm_get_prop_db(link, prop_name,
            prop_val, val_cntp));
    }

    status = i_dladm_get_prop_temp(link, type, prop_name,
        prop_val, val_cntp);
    if (status != DLADM_STATUS_NOTFOUND)
        return (status);

    if (dladm_wlan_is_valid(link)) {
        return (dladm_wlan_get_prop(link, type, prop_name,
            prop_val, val_cntp));
    }
    return (DLADM_STATUS_BADARG);
}

/*
 * Data structures used for implementing persistent link properties
 */
typedef struct linkprop_val {
    const char      *lv_name;
    struct linkprop_val *lv_nextval;
} linkprop_val_t;

typedef struct linkprop_info {
    const char      *li_name;
    struct linkprop_info    *li_nextprop;
    struct linkprop_val *li_val;
} linkprop_info_t;

typedef struct linkprop_db_state    linkprop_db_state_t;

typedef boolean_t (*linkprop_db_op_t)(linkprop_db_state_t *,
    char *, linkprop_info_t *, dladm_status_t *);

struct linkprop_db_state {
    linkprop_db_op_t    ls_op;
    const char      *ls_link;
    const char      *ls_propname;
    char            **ls_propval;
    uint_t          *ls_valcntp;
};

static void
free_linkprops(linkprop_info_t *lip)
{
    linkprop_info_t *lip_next;
    linkprop_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 link property database.
 * Each entry has this format:
 * <linkname>   <prop0>=<val0>,...,<valn>;...;<propn>=<val0>,...,<valn>;
 */
static void
generate_linkprop_line(linkprop_db_state_t *lsp, char *buf,
    linkprop_info_t *listp, dladm_status_t *statusp)
{
    char        tmpbuf[MAXLINELEN];
    char        *ptr, *lim = tmpbuf + MAXLINELEN;
    linkprop_info_t *lip = listp;
    linkprop_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", lsp->ls_link);
    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_linkprop_db() will first scan the db for an entry matching the
 * specified link. 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_linkprop_db(). If no entry matches the specified link, listp
 * will be NULL; a new entry will be generated in this case and it will
 * contain only the property information in lsp.
 */
static boolean_t
process_linkprop_set(linkprop_db_state_t *lsp, char *buf,
    linkprop_info_t *listp, dladm_status_t *statusp)
{
    dladm_status_t  status;
    linkprop_info_t *lastp = NULL, *lip = listp, *nlip = NULL;
    linkprop_val_t  **lvpp;
    int     i;

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

    /*
     * Find the linkprop 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 linkprop is not found, append it to the list.
         */
        if ((nlip = malloc(sizeof (linkprop_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 {
        linkprop_val_t  *lvp, *lvp_next;

        /*
         * If the linkprop 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 linkprop with the specified values.
     */
    for (i = 0; i < *lsp->ls_valcntp; i++) {
        if ((*lvpp = malloc(sizeof (linkprop_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_linkprop_line(lsp, buf, listp, statusp);
    } else {
        generate_linkprop_line(lsp, buf, nlip, statusp);
        free_linkprops(nlip);
    }
    return (B_FALSE);

fail:
    *statusp = status;
    if (listp == NULL)
        free_linkprops(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 link 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 */
static boolean_t
process_linkprop_get(linkprop_db_state_t *lsp, char *buf,
    linkprop_info_t *listp, dladm_status_t *statusp)
{
    linkprop_info_t *lip = listp;
    linkprop_val_t  *lvp;
    uint_t      valcnt = 0;

    /*
     * Find the linkprop 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_linkprop_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 link properties.
 * Unlike the other routines, this gets called for every entry in the
 * database. lsp->ls_link is not user-specified but instead is set to
 * the current link being processed.
 */
/* ARGSUSED */
static boolean_t
process_linkprop_init(linkprop_db_state_t *lsp, char *buf,
    linkprop_info_t *listp, dladm_status_t *statusp)
{
    dladm_status_t  status = DLADM_STATUS_OK;
    linkprop_info_t *lip = listp;
    linkprop_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 = dladm_set_prop(lsp->ls_link, lip->li_name,
            propval, valcnt, DLADM_OPT_TEMP, 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_linkprops(char *buf, linkprop_info_t **lipp)
{
    int         i, len;
    char            *curr;
    linkprop_info_t     *lip = NULL;
    linkprop_info_t     **tailp = lipp;
    linkprop_val_t      *lvp = NULL;
    linkprop_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 linkprop_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 linkprop_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_linkprops(*lipp);
    *lipp = NULL;
    return (-1);
}

static boolean_t
process_linkprop_line(linkprop_db_state_t *lsp, char *buf,
    dladm_status_t *statusp)
{
    linkprop_info_t     *lip = NULL;
    int         i, len, llen;
    char            *str, *lasts;
    boolean_t       cont, nolink = 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_link != NULL) {
        /*
         * Skip links 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 link.
         */
        llen = strlen(lsp->ls_link);
        if (strncmp(str, lsp->ls_link, llen) != 0 ||
            !isspace(str[llen]))
            return (B_TRUE);
    } else {
        /*
         * If a link is not specified, find the link name
         * and assign it to lsp->ls_link.
         */
        if (strtok_r(str, " \n\t", &lasts) == NULL)
            goto fail;

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

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

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

    cont = (*lsp->ls_op)(lsp, buf, lip, statusp);
    free_linkprops(lip);
    if (nolink)
        lsp->ls_link = NULL;
    return (cont);

fail:
    free_linkprops(lip);
    if (nolink)
        lsp->ls_link = NULL;

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

static dladm_status_t
process_linkprop_db(void *arg, FILE *fp, FILE *nfp)
{
    linkprop_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_linkprop_line().
     * If this is a write operation and buf is not truncated, buf will
     * be written to disk. process_linkprop_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_linkprop_line(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_linkprop_set) {
        /*
         * If the specified link is not found above, we add the
         * link and its properties to the configuration file.
         */
        (void) (*lsp->ls_op)(lsp, buf, NULL, &status);
        if (status == DLADM_STATUS_OK && fputs(buf, nfp) == EOF)
            status = dladm_errno2status(errno);
    }

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

    return (status);
}

#define LINKPROP_RW_DB(statep, writeop) \
    (i_dladm_rw_db("/etc/dladm/linkprop.conf", \
    S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH, process_linkprop_db, \
    (statep), (writeop)))

static dladm_status_t
i_dladm_set_prop_db(const char *link, const char *prop_name,
    char **prop_val, uint_t val_cnt)
{
    linkprop_db_state_t state;

    state.ls_op = process_linkprop_set;
    state.ls_link = link;
    state.ls_propname = prop_name;
    state.ls_propval = prop_val;
    state.ls_valcntp = &val_cnt;

    return (LINKPROP_RW_DB(&state, B_TRUE));
}

static dladm_status_t
i_dladm_get_prop_db(const char *link, const char *prop_name,
    char **prop_val, uint_t *val_cntp)
{
    linkprop_db_state_t state;

    state.ls_op = process_linkprop_get;
    state.ls_link = link;
    state.ls_propname = prop_name;
    state.ls_propval = prop_val;
    state.ls_valcntp = val_cntp;

    return (LINKPROP_RW_DB(&state, B_FALSE));
}

dladm_status_t
dladm_init_linkprop(void)
{
    linkprop_db_state_t state;

    state.ls_op = process_linkprop_init;
    state.ls_link = NULL;
    state.ls_propname = NULL;
    state.ls_propval = NULL;
    state.ls_valcntp = NULL;

    return (LINKPROP_RW_DB(&state, B_FALSE));
}

static dladm_status_t
i_dladm_get_zoneid(const char *link, zoneid_t *zidp)
{
    int fd;
    dld_hold_vlan_t dhv;

    if ((fd = open(DLD_CONTROL_DEV, O_RDWR)) < 0)
        return (dladm_errno2status(errno));

    bzero(&dhv, sizeof (dld_hold_vlan_t));
    (void) strlcpy(dhv.dhv_name, link, IFNAMSIZ);
    dhv.dhv_zid = -1;

    if (i_dladm_ioctl(fd, DLDIOCZIDGET, &dhv, sizeof (dhv)) < 0 &&
        errno != ENOENT) {
        dladm_status_t status = dladm_errno2status(errno);

        (void) close(fd);
        return (status);
    }

    if (errno == ENOENT)
        *zidp = GLOBAL_ZONEID;
    else
        *zidp = dhv.dhv_zid;

    (void) close(fd);
    return (DLADM_STATUS_OK);
}

typedef int (*zone_get_devroot_t)(char *, char *, size_t);

static int
i_dladm_get_zone_dev(char *zone_name, char *dev, size_t devlen)
{
    char            root[MAXPATHLEN];
    zone_get_devroot_t  real_zone_get_devroot;
    void            *dlhandle;
    void            *sym;
    int         ret;

    if ((dlhandle = dlopen("libzonecfg.so.1", RTLD_LAZY)) == NULL)
        return (-1);

    if ((sym = dlsym(dlhandle, "zone_get_devroot")) == NULL) {
        (void) dlclose(dlhandle);
        return (-1);
    }

    real_zone_get_devroot = (zone_get_devroot_t)sym;

    if ((ret = real_zone_get_devroot(zone_name, root, sizeof (root))) == 0)
        (void) snprintf(dev, devlen, "%s%s", root, "/dev");
    (void) dlclose(dlhandle);
    return (ret);
}

static dladm_status_t
i_dladm_add_deventry(zoneid_t zid, const char *link)
{
    char        path[MAXPATHLEN];
    di_prof_t   prof = NULL;
    char        zone_name[ZONENAME_MAX];
    dladm_status_t  status;

    if (getzonenamebyid(zid, zone_name, sizeof (zone_name)) < 0)
        return (dladm_errno2status(errno));
    if (i_dladm_get_zone_dev(zone_name, path, sizeof (path)) != 0)
        return (dladm_errno2status(errno));
    if (di_prof_init(path, &prof) != 0)
        return (dladm_errno2status(errno));

    status = DLADM_STATUS_OK;
    if (di_prof_add_dev(prof, link) != 0) {
        status = dladm_errno2status(errno);
        goto cleanup;
    }
    if (di_prof_commit(prof) != 0)
        status = dladm_errno2status(errno);
cleanup:
    if (prof)
        di_prof_fini(prof);

    return (status);
}

static dladm_status_t
i_dladm_remove_deventry(zoneid_t zid, const char *link)
{
    char        path[MAXPATHLEN];
    di_prof_t   prof = NULL;
    char        zone_name[ZONENAME_MAX];
    dladm_status_t  status;

    if (getzonenamebyid(zid, zone_name, sizeof (zone_name)) < 0)
        return (dladm_errno2status(errno));
    if (i_dladm_get_zone_dev(zone_name, path, sizeof (path)) != 0)
        return (dladm_errno2status(errno));
    if (di_prof_init(path, &prof) != 0)
        return (dladm_errno2status(errno));

    status = DLADM_STATUS_OK;
    if (di_prof_add_exclude(prof, link) != 0) {
        status = dladm_errno2status(errno);
        goto cleanup;
    }
    if (di_prof_commit(prof) != 0)
        status = dladm_errno2status(errno);
cleanup:
    if (prof)
        di_prof_fini(prof);

    return (status);
}

static dladm_status_t
do_get_zone(const char *link, char **prop_val, uint_t *val_cnt)
{
    char        zone_name[ZONENAME_MAX];
    zoneid_t    zid;
    dladm_status_t  status;

    status = i_dladm_get_zoneid(link, &zid);
    if (status != DLADM_STATUS_OK)
        return (status);

    *val_cnt = 1;
    if (zid != GLOBAL_ZONEID) {
        if (getzonenamebyid(zid, zone_name, sizeof (zone_name)) < 0)
            return (dladm_errno2status(errno));

        (void) strncpy(*prop_val, zone_name, DLADM_PROP_VAL_MAX);
    } else {
        *prop_val[0] = '\0';
    }

    return (DLADM_STATUS_OK);
}

static dladm_status_t
do_set_zone(const char *link, val_desc_t *vdp, uint_t val_cnt)
{
    dladm_status_t  status;
    zoneid_t    zid_old, zid_new;

    if (val_cnt != 1)
        return (DLADM_STATUS_BADVALCNT);

    status = i_dladm_get_zoneid(link, &zid_old);
    if (status != DLADM_STATUS_OK)
        return (status);

    /* Do nothing if setting to current value */
    zid_new = (intptr_t)(void *)vdp->vd_val;
    if (zid_new == zid_old)
        return (DLADM_STATUS_OK);

    if (zid_old != GLOBAL_ZONEID) {
        if (dladm_rele_link(link, GLOBAL_ZONEID, B_TRUE) < 0)
            return (dladm_errno2status(errno));

        if (zone_remove_datalink(zid_old, (char *)link) != 0 &&
            errno != ENXIO) {
            status = dladm_errno2status(errno);
            goto rollback1;
        }

        status = i_dladm_remove_deventry(zid_old, link);
        if (status != DLADM_STATUS_OK)
            goto rollback2;
    }

    if (zid_new != GLOBAL_ZONEID) {
        if (zone_add_datalink(zid_new, (char *)link) != 0) {
            status = dladm_errno2status(errno);
            goto rollback3;
        }

        if (dladm_hold_link(link, zid_new, B_TRUE) < 0) {
            (void) zone_remove_datalink(zid_new, (char *)link);
            status = dladm_errno2status(errno);
            goto rollback3;
        }

        status = i_dladm_add_deventry(zid_new, link);
        if (status != DLADM_STATUS_OK) {
            (void) dladm_rele_link(link, GLOBAL_ZONEID, B_FALSE);
            (void) zone_remove_datalink(zid_new, (char *)link);
            goto rollback3;
        }
    }
    return (DLADM_STATUS_OK);

rollback3:
    if (zid_old != GLOBAL_ZONEID)
        (void) i_dladm_add_deventry(zid_old, link);
rollback2:
    if (zid_old != GLOBAL_ZONEID)
        (void) zone_add_datalink(zid_old, (char *)link);
rollback1:
    (void) dladm_hold_link(link, zid_old, B_FALSE);
cleanexit:
    return (status);
}

/* ARGSUSED */
static dladm_status_t
do_check_zone(prop_desc_t *pdp, char **prop_val, uint_t val_cnt,
    val_desc_t **vdpp)
{
    zoneid_t    zid;
    val_desc_t  *vdp = NULL;

    if (val_cnt != 1)
        return (DLADM_STATUS_BADVALCNT);

    if ((zid = getzoneidbyname(*prop_val)) == -1)
        return (DLADM_STATUS_BADVAL);

    if (zid != GLOBAL_ZONEID) {
        ushort_t    flags;

        if (zone_getattr(zid, ZONE_ATTR_FLAGS, &flags,
            sizeof (flags)) < 0) {
            return (dladm_errno2status(errno));
        }

        if (!(flags & ZF_NET_EXCL)) {
            return (DLADM_STATUS_BADVAL);
        }
    }

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

    vdp->vd_val = (void *)(uintptr_t)zid;
    *vdpp = vdp;
    return (DLADM_STATUS_OK);
}

static dladm_status_t
i_dladm_get_prop_temp(const char *link, dladm_prop_type_t type,
    const char *prop_name, char **prop_val, uint_t *val_cntp)
{
    int         i;
    dladm_status_t  status;
    uint_t      cnt;
    prop_desc_t *pdp;

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

    for (i = 0; i < MAX_PROPS; i++)
        if (strcasecmp(prop_name, prop_table[i].pd_name) == 0)
            break;

    if (i == MAX_PROPS)
        return (DLADM_STATUS_NOTFOUND);

    pdp = &prop_table[i];
    status = DLADM_STATUS_OK;

    switch (type) {
    case DLADM_PROP_VAL_CURRENT:
        status = pdp->pd_get(link, 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(link, 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(const char *link, prop_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(link, vdp, cnt);

    free(vdp);
    return (status);
}

static dladm_status_t
i_dladm_set_prop_temp(const char *link, const char *prop_name, char **prop_val,
    uint_t val_cnt, uint_t flags, char **errprop)
{
    int         i;
    dladm_status_t  status = DLADM_STATUS_OK;
    boolean_t   found = B_FALSE;

    for (i = 0; i < MAX_PROPS; i++) {
        prop_desc_t *pdp = &prop_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(link, 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);
}

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

    for (i = 0; i < MAX_PROPS; i++) {
        prop_desc_t *pdp = &prop_table[i];

        if (prop_name != NULL &&
            (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);
}