/*
 * 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) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
 */

#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/sockio.h>
#include <sys/stat.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <net/if.h>
#include <stdio.h>
#include <stdlib.h>
#include <strings.h>
#include <ctype.h>
#include <errno.h>
#include <libintl.h>
#include <locale.h>
#include <fcntl.h>
#include <libdlpi.h>
#include <libdladm.h>
#include <libdlib.h>
#include <libdllink.h>
#include <sys/ib/ibnex/ibnex_devctl.h>

#define DATADM_OP_VIEW          0x0000
#define DATADM_OP_UPDATE        0x0001
#define DATADM_OP_ADD           0x0002
#define DATADM_OP_REMOVE        0x0003
#define DATADM_NUM_OPS          0x0004
#define DATADM_DAT_CONF         "/etc/dat/dat.conf"
#define DATADM_LINESZ           1024
#define DATADM_NUM_SP_TOKENS    7
#define DATADM_NUM_DAT_TOKENS   8
#define DATADM_DRV_NAME         "driver_name"
#define DATADM_MAX_TOKENS       16

/*
 * generic entry
 * placed at the top of all entry types
 */
typedef struct datadm_entry {
        struct datadm_entry     *de_next;
} datadm_entry_t;

/*
 * list structure
 * can be manipulated using datadm_walk_list or
 * datadm_enqueue_entry
 */
typedef struct datadm_list {
        datadm_entry_t          *dl_head;
        datadm_entry_t          *dl_tail;
        uint_t                  dl_count;
} datadm_list_t;

/*
 * internal representation of the version string in
 * dat.conf or service_provider.conf. the format is
 * <dv_name><dv_major>.<dv_minor>
 */
typedef struct datadm_version {
        char    *dv_name;
        uint_t  dv_major;
        uint_t  dv_minor;
} datadm_version_t;

/*
 * each sp_entry corresponds to an entry in dat.conf or
 * service_provider.conf. an sp_entry is processed by the
 * function datadm_process_sp_entry.
 */
typedef struct datadm_sp_entry {
        datadm_entry_t          spe_header;
        char                    *spe_devname;
        datadm_version_t        spe_api_version;
        int                     spe_threadsafe;
        int                     spe_default;
        char                    *spe_libpath;
        datadm_version_t        spe_sp_version;
        char                    *spe_sp_data;
        int                     spe_invalid;
} datadm_sp_entry_t;

/*
 * an hca_entry is created whenever a new hca device is
 * encountered during sp_entry processing. this structure
 * contains two lists. the sp_list holds sp entries that
 * are added when sp entry processing occurs. duplicate
 * sp entries are not added to this list. the ia_list may
 * be built statically using the information in dat.conf or
 * dynamically. similar to the sp_list,
 * the ia_list contains only unique entries.
 */
typedef struct datadm_hca_entry {
        datadm_entry_t          he_header;
        char                    *he_name;
        datadm_list_t           he_sp_list;
        datadm_list_t           he_ia_list;
} datadm_hca_entry_t;

/*
 * an ia_entry is created when a new ia name is encountered
 * during sp_entry processing or when a new ia name is
 * discovered by datadm_build_ia_lists. ia_entry holds the ia
 * device's instance number.
 */
typedef struct datadm_ia_entry {
        datadm_entry_t          iae_header;
        char                    iae_name[MAXLINKNAMELEN];
} datadm_ia_entry_t;

/*
 * a comment entry represents one of the comment lines at the
 * top of dat.conf. a list of these lines are saved during the
 * parsing of dat.conf. these lines are written back to dat.conf
 * when dat.conf gets regenerated.
 */
typedef struct datadm_cmnt_entry {
        datadm_entry_t          cmnt_header;
        char                    *cmnt_line;
} datadm_cmnt_entry_t;

typedef struct datadm_hca_find_by_name {
        char                    *hf_name;
        datadm_hca_entry_t      *hf_hca_entry;
} datadm_hca_find_by_name_t;

/*
 * 2nd argument to datadm_hca_entry_find.
 * hf_hca_entry is filled in if an hca_entry with
 * a matching he_name is found.
 */
typedef struct datadm_hca_find {
        datadm_sp_entry_t       *hf_sp_entry;
        datadm_hca_entry_t      *hf_hca_entry;
} datadm_hca_find_t;

/*
 * 2nd argument to datadm_ia_entry_find.
 * if_ia_entry is filled in if an ia_entry with
 * a matching ia_name is found.
 */
typedef struct datadm_ia_find {
        char                    *if_ia_name;
        datadm_ia_entry_t       *if_ia_entry;
} datadm_ia_find_t;

/*
 * this gets passed to datadm_add_plink.
 */
typedef struct datadm_fill_ia_list {
        datadm_list_t           *ia_hca_list;
        dladm_handle_t          ia_dlh;
        int                     ia_ibnex_fd;
        int                     ia_sock_fd_v4;
        int                     ia_sock_fd_v6;
} datadm_fill_ia_list_t;

/*
 * this defines the commandline parameters specified
 * by the user.
 */
typedef struct datadm_args {
        char                    *da_sp_conf;
        char                    *da_dat_conf;
        int                     da_op_type;
} datadm_args_t;

static datadm_args_t            datadm_args;
static datadm_list_t            datadm_conf_header;
static char                     *datadm_conf_header_default =
        "#\n"
        "# Copyright (c) 2003, 2010, Oracle and/or its affiliates. "
        "All rights reserved.\n"
        "#\n"
        "# DAT configuration file.\n"
        "#\n"
        "# This file is updated using the datadm(8) command.\n"
        "# Do not hand edit this file.\n"
        "# See datadm(8) man page for more details.\n"
        "#\n"
        "# The fields in this file are -\n"
        "#\n"
        "# IAname version threadsafe default library-path provider-version \\\n"
        "# instance-data platform-information\n"
        "#\n";

/*
 * common parsing functions.
 */
typedef int (*datadm_parse_func_t)(char *, void *);
static int datadm_parse_line(char *, char *[], int *);
static int datadm_parse_generic_str(char *, char **);
static int datadm_parse_nonnull_str(char *, char **);
static int datadm_parse_version(char *, datadm_version_t *);
static int datadm_parse_devname(char *, datadm_sp_entry_t *);
static int datadm_parse_api_version(char *, datadm_sp_entry_t *);
static int datadm_parse_threadsafe(char *, datadm_sp_entry_t *);
static int datadm_parse_default(char *, datadm_sp_entry_t *);
static int datadm_parse_libpath(char *, datadm_sp_entry_t *);
static int datadm_parse_sp_version(char *, datadm_sp_entry_t *);
static int datadm_parse_sp_data(char *, datadm_sp_entry_t *);
static int datadm_parse_ia_name(char *, char *);

/*
 * utility functions
 */
static void datadm_enqueue_entry(datadm_list_t *, datadm_entry_t *);
static int datadm_walk_list(datadm_list_t *,
    int (*)(datadm_entry_t *, void *), void *);
static int datadm_str_match(char *, char *);
static int datadm_version_match(datadm_version_t *, datadm_version_t *);
static int datadm_sp_entry_match(datadm_sp_entry_t *, datadm_sp_entry_t *);

/*
 * entry allocation/deallocation
 */
static datadm_sp_entry_t *datadm_alloc_sp_entry(void);
static datadm_ia_entry_t *datadm_alloc_ia_entry(void);
static datadm_hca_entry_t *datadm_alloc_hca_entry(void);
static datadm_cmnt_entry_t *datadm_alloc_cmnt_entry(void);
static void datadm_free_sp_entry(datadm_sp_entry_t *);
static void datadm_free_ia_entry(datadm_ia_entry_t *);
static void datadm_free_hca_entry(datadm_hca_entry_t *);
static void datadm_free_cmnt_entry(datadm_cmnt_entry_t *);


/*
 * high level parsing functions
 */
static int datadm_parse_sp_conf(datadm_list_t *);
static int datadm_parse_dat_conf(datadm_list_t *);
static int datadm_process_sp_entry(datadm_list_t *, datadm_sp_entry_t *,
    char *);

/*
 * ia devices discovery
 */
static int datadm_build_ia_lists(datadm_list_t *);

/*
 * helper function for OP_REMOVE
 */
static void datadm_invalidate_common_sp_entries(datadm_list_t *,
    datadm_list_t *);

/*
 * output generation
 */
static int datadm_generate_dat_conf(datadm_list_t *);
static int datadm_generate_conf_header(FILE *);
static int datadm_generate_conf_entry(FILE *, datadm_ia_entry_t *,
    datadm_sp_entry_t *);

/*
 * datadm operations
 */
static int datadm_view(void);
static int datadm_update(void);
static int datadm_add(void);
static int datadm_remove(void);

/*
 * usage
 */
static void datadm_usage(void);


/*
 * parse function tables
 */
static datadm_parse_func_t datadm_sp_parse_funcs[DATADM_NUM_SP_TOKENS] = {
        (datadm_parse_func_t)datadm_parse_devname,
        (datadm_parse_func_t)datadm_parse_api_version,
        (datadm_parse_func_t)datadm_parse_threadsafe,
        (datadm_parse_func_t)datadm_parse_default,
        (datadm_parse_func_t)datadm_parse_libpath,
        (datadm_parse_func_t)datadm_parse_sp_version,
        (datadm_parse_func_t)datadm_parse_sp_data
};

static datadm_parse_func_t datadm_dat_parse_funcs[DATADM_NUM_DAT_TOKENS] = {
        (datadm_parse_func_t)datadm_parse_ia_name,
        (datadm_parse_func_t)datadm_parse_api_version,
        (datadm_parse_func_t)datadm_parse_threadsafe,
        (datadm_parse_func_t)datadm_parse_default,
        (datadm_parse_func_t)datadm_parse_libpath,
        (datadm_parse_func_t)datadm_parse_sp_version,
        (datadm_parse_func_t)datadm_parse_sp_data,
        (datadm_parse_func_t)datadm_parse_devname
};

/*
 * operation table
 */
static int (*datadm_ops[DATADM_NUM_OPS])(void) = {
        datadm_view,
        datadm_update,
        datadm_add,
        datadm_remove
};

static void
datadm_usage(void)
{
        (void) fprintf(stderr, gettext(
            "usage: datadm -v\n"
            "              -u\n"
            "              -a <service_provider.conf>\n"
            "              -r <service_provider.conf>\n"));
}

static int
datadm_parse_generic_str(char *str, char **strptr)
{
        int     len;

        len = strlen(str);
        *strptr = (char *)malloc(len + 1);
        if (*strptr == NULL) {
                return (-1);
        }
        (void) strcpy(*strptr, str);
        return (0);
}

/*
 * this function strips off leading and trailing
 * whitespaces and returns an error for null or
 * empty strings.
 */
static int
datadm_parse_nonnull_str(char *str, char **strptr)
{
        int     len, i;
        char    *start;

        if (str[0] == '\0') {
                return (-1);
        }
        start = str;
        for (i = 0; str[i] != '\0'; i++) {
                if (!isspace(str[i])) {
                        start = &str[i];
                        break;
                }
        }
        for (; str[i] != '\0'; i++) {
                if (isspace(str[i])) {
                        str[i] = '\0';
                }
        }
        len = strlen(start);
        *strptr = (char *)malloc(len + 1);
        if (*strptr == NULL) {
                return (-1);
        }
        (void) strcpy(*strptr, start);
        return (0);
}

/*
 * parses the api_version and sp_version fields in
 * dat.conf and service_provider.conf
 */
static int
datadm_parse_version(char *str, datadm_version_t *version)
{
        int     i = 0, len;
        int     major_idx, minor_idx;

        len = strlen(str);

        for (i = 0; i < len; i++) {
                if (isdigit(str[i])) break;
        }
        if (i == len) {
                return (-1);
        }
        if (i > 0) {
                version->dv_name = (char *)malloc(i + 1);
                bcopy(str, version->dv_name, i);
                version->dv_name[i] = '\0';
        } else {
                version->dv_name = NULL;
        }
        major_idx = i;

        for (; i < len; i++) {
                if (!isdigit(str[i])) break;
        }
        if (i == len) {
                return (-1);
        }
        if (str[i] != '.') {
                return (-1);
        }
        minor_idx = ++i;
        if (i == len) {
                return (-1);
        }
        for (; i < len; i++) {
                if (!isdigit(str[i])) break;
        }
        if (i != len) {
                return (-1);
        }
        version->dv_major = atoi(str + major_idx);
        version->dv_minor = atoi(str + minor_idx);
        return (0);
}

/*
 * parses the ia_name field in dat.conf
 */
static int
datadm_parse_ia_name(char *str, char *ia_name)
{
        if (strlen(str) >= MAXLINKNAMELEN)
                return (-1);
        (void) strlcpy(ia_name, str, MAXLINKNAMELEN);
        return (0);
}

/*
 * parses the device name, strips leading and trailing spaces.
 * the format should be "driver_name=<dev_name>"
 */
static int
datadm_parse_devname(char *str, datadm_sp_entry_t *sp_entry)
{
        int     len, dlen, i, j = 0;
        char    *drv_name = DATADM_DRV_NAME;

        len = strlen(str);
        dlen = strlen(drv_name);

        /*
         * strip out leading spaces and try to match
         * the expected string
         */
        for (i = 0; i < len; i++) {
                if (isspace(str[i]) && j == 0) {
                        continue;
                } else {
                        if (str[i] == drv_name[j]) {
                                j++;
                                if (j == dlen) {
                                        break;
                                } else {
                                        continue;
                                }
                        } else {
                                break;
                        }
                }
        }

        /*
         * j must be dlen if the matching string is found
         */
        if (j != dlen) {
                return (-1);
        }

        /*
         * skip past the last char of drv_name
         */
        i++;

        /*
         * strip the spaces before the '='
         */
        for (; i < len; i++) {
                if (!isspace(str[i])) {
                        break;
                }
        }

        /*
         * return if the string is too long or if
         * the '=' isn't found
         */
        if (i >= len || str[i] != '=') {
                return (-1);
        }
        i++;
        if (i >= len) {
                /*
                 * no string after the equal
                 */
                return (-1);
        }
        return (datadm_parse_nonnull_str(str + i, &sp_entry->spe_devname));
}

static int
datadm_parse_api_version(char *str, datadm_sp_entry_t *sp_entry)
{
        return (datadm_parse_version(str, &sp_entry->spe_api_version));
}

static int
datadm_parse_threadsafe(char *str, datadm_sp_entry_t *sp_entry)
{
        int retval = 0;

        if (strcmp(str, "threadsafe") == 0) {
                sp_entry->spe_threadsafe = 1;
        } else if (strcmp(str, "nonthreadsafe") == 0) {
                sp_entry->spe_threadsafe = 0;
        } else {
                retval = -1;
        }
        return (retval);
}

static int
datadm_parse_default(char *str, datadm_sp_entry_t *sp_entry)
{
        int retval = 0;

        if (strcmp(str, "default") == 0) {
                sp_entry->spe_default = 1;
        } else if (strcmp(str, "nondefault") == 0) {
                sp_entry->spe_default = 0;
        } else {
                retval = -1;
        }
        return (retval);
}

static int
datadm_parse_libpath(char *str, datadm_sp_entry_t *sp_entry)
{
        return (datadm_parse_nonnull_str(str, &sp_entry->spe_libpath));
}

static int
datadm_parse_sp_version(char *str, datadm_sp_entry_t *sp_entry)
{
        return (datadm_parse_version(str, &sp_entry->spe_sp_version));
}

static int
datadm_parse_sp_data(char *str, datadm_sp_entry_t *sp_entry)
{
        return (datadm_parse_generic_str(str, &sp_entry->spe_sp_data));
}

static void
datadm_enqueue_entry(datadm_list_t *list, datadm_entry_t *entry)
{
        if (list->dl_head == NULL) {
                list->dl_head = entry;
                list->dl_tail = entry;
                list->dl_count = 1;
        } else {
                list->dl_tail->de_next = entry;
                list->dl_tail = entry;
                list->dl_count++;
        }
}

/*
 * iterates through the list applying func on each element.
 * break and return if func returns non-zero.
 */
static int
datadm_walk_list(datadm_list_t *list, int (*func)(datadm_entry_t *, void *),
    void *arg)
{
        datadm_entry_t  *entry;
        int             retval = 0;

        entry = list->dl_head;
        while (entry != NULL) {
                retval = (*func)(entry, arg);
                if (retval != 0) break;
                entry = entry->de_next;
        }
        return (retval);
}

/*
 * iterates through the list applying free_func to each element.
 * list becomes empty when the function returns.
 */
static void
datadm_free_list(datadm_list_t *list, void (*free_func)(datadm_entry_t *))
{
        while (list->dl_head != NULL) {
                datadm_entry_t  *entry;

                entry = list->dl_head;
                list->dl_head = entry->de_next;
                (*free_func)(entry);
        }
        list->dl_count = 0;
        list->dl_tail = NULL;
}

static datadm_sp_entry_t *
datadm_alloc_sp_entry(void)
{
        datadm_sp_entry_t       *sp_entry;

        sp_entry = (datadm_sp_entry_t *)malloc(sizeof (*sp_entry));
        if (sp_entry == NULL) {
                return (NULL);
        }
        bzero(sp_entry, sizeof (*sp_entry));
        return (sp_entry);
}

static void
datadm_free_sp_entry(datadm_sp_entry_t *sp_entry)
{
        if (sp_entry->spe_devname != NULL) {
                free(sp_entry->spe_devname);
                sp_entry->spe_devname = NULL;
        }
        if (sp_entry->spe_api_version.dv_name != NULL) {
                free(sp_entry->spe_api_version.dv_name);
                sp_entry->spe_api_version.dv_name = NULL;
        }
        sp_entry->spe_api_version.dv_major = 0;
        sp_entry->spe_api_version.dv_minor = 0;
        sp_entry->spe_threadsafe = 0;
        sp_entry->spe_default = 0;
        if (sp_entry->spe_libpath != NULL) {
                free(sp_entry->spe_libpath);
                sp_entry->spe_libpath = NULL;
        }
        if (sp_entry->spe_sp_version.dv_name != NULL) {
                free(sp_entry->spe_sp_version.dv_name);
                sp_entry->spe_sp_version.dv_name = NULL;
        }
        sp_entry->spe_sp_version.dv_major = 0;
        sp_entry->spe_sp_version.dv_minor = 0;
        if (sp_entry->spe_sp_data != NULL) {
                free(sp_entry->spe_sp_data);
                sp_entry->spe_sp_data = NULL;
        }
        free(sp_entry);
}

static int
datadm_str_match(char *s1, char *s2)
{
        if (s1 == NULL || s2 == NULL) {
                if (s1 != s2) {
                        return (0);
                }
        } else {
                if (strcmp(s1, s2) != 0) {
                        return (0);
                }
        }
        return (1);
}

static int
datadm_version_match(datadm_version_t *v1, datadm_version_t *v2)
{
        if (!datadm_str_match(v1->dv_name, v2->dv_name)) {
                return (0);
        }
        if (v1->dv_major != v2->dv_major) {
                return (0);
        }
        if (v1->dv_minor != v2->dv_minor) {
                return (0);
        }
        return (1);
}

static int
datadm_sp_entry_match(datadm_sp_entry_t *sp1, datadm_sp_entry_t *sp2)
{
        if (!datadm_str_match(sp1->spe_devname, sp2->spe_devname)) {
                return (0);
        }
        if (!datadm_version_match(&sp1->spe_api_version,
            &sp2->spe_api_version)) {
                return (0);
        }
        if (sp1->spe_threadsafe != sp2->spe_threadsafe) {
                return (0);
        }
        if (sp1->spe_default != sp2->spe_default) {
                return (0);
        }
        if (!datadm_str_match(sp1->spe_libpath, sp2->spe_libpath)) {
                return (0);
        }
        if (!datadm_version_match(&sp1->spe_sp_version,
            &sp2->spe_sp_version)) {
                return (0);
        }
        if (!datadm_str_match(sp1->spe_sp_data, sp2->spe_sp_data)) {
                return (0);
        }
        return (1);
}

static datadm_ia_entry_t *
datadm_alloc_ia_entry(void)
{
        datadm_ia_entry_t       *ia_entry;

        ia_entry = (datadm_ia_entry_t *)malloc(sizeof (*ia_entry));
        if (ia_entry == NULL) {
                return (NULL);
        }
        bzero(ia_entry, sizeof (*ia_entry));
        return (ia_entry);
}

static void
datadm_free_ia_entry(datadm_ia_entry_t *ia_entry)
{
        free(ia_entry);
}

static datadm_hca_entry_t *
datadm_alloc_hca_entry(void)
{
        datadm_hca_entry_t      *hca_entry;

        hca_entry = (datadm_hca_entry_t *)malloc(sizeof (*hca_entry));
        if (hca_entry == NULL) {
                return (NULL);
        }
        bzero(hca_entry, sizeof (*hca_entry));
        return (hca_entry);
}

static void
datadm_free_hca_entry(datadm_hca_entry_t *hca_entry)
{
        if (hca_entry->he_name != NULL) {
                free(hca_entry->he_name);
                hca_entry->he_name = NULL;
        }
        datadm_free_list(&hca_entry->he_sp_list,
            (void (*)(datadm_entry_t *))datadm_free_sp_entry);
        datadm_free_list(&hca_entry->he_ia_list,
            (void (*)(datadm_entry_t *))datadm_free_ia_entry);
        free(hca_entry);
}

static int
datadm_hca_entry_match(datadm_hca_entry_t *h1, datadm_hca_entry_t *h2)
{
        if (!datadm_str_match(h1->he_name, h2->he_name)) {
                return (0);
        }
        return (1);
}

static int
datadm_hca_entry_find(datadm_hca_entry_t *h1, datadm_hca_find_t *hf)
{
        if (datadm_str_match(h1->he_name, hf->hf_sp_entry->spe_devname)) {
                hf->hf_hca_entry = h1;
                return (1);
        }
        return (0);
}

static int
datadm_ia_entry_find(datadm_ia_entry_t *i1, datadm_ia_find_t *iaf)
{
        if (strcmp(i1->iae_name, iaf->if_ia_name) == 0) {
                iaf->if_ia_entry = i1;
                return (1);
        }
        return (0);
}

static datadm_cmnt_entry_t *
datadm_alloc_cmnt_entry(void)
{
        datadm_cmnt_entry_t     *cmnt_entry;

        cmnt_entry = (datadm_cmnt_entry_t *)malloc(sizeof (*cmnt_entry));
        if (cmnt_entry == NULL) {
                return (NULL);
        }
        bzero(cmnt_entry, sizeof (*cmnt_entry));
        return (cmnt_entry);
}

static void
datadm_free_cmnt_entry(datadm_cmnt_entry_t *cmnt_entry)
{
        if (cmnt_entry->cmnt_line != NULL) {
                free(cmnt_entry->cmnt_line);
                cmnt_entry->cmnt_line = NULL;
        }
        free(cmnt_entry);
}

/*
 * tokenizes a line and strips off the quotes from quoted strings
 */
static int
datadm_parse_line(char *line_buf, char *tokens[], int *token_count)
{
        int                     len, i;
        int                     count = 0;
        char                    *start = NULL;

        /* the line must not be longer than DATADM_LINESZ */
        len = strlen(line_buf);
        if (line_buf[len - 1] != '\n') {
                return (-1);
        }
        /* discard blank lines and comments */
        if (len == 1) {
                *token_count = 0;
                return (0);
        }
        if (len >= 2 && line_buf[0] == '#') {
                *token_count = 0;
                return (0);
        }
        /* removes the new line */
        line_buf[len - 1] = '\0';
        len--;

        for (i = 0; i < len; i++) {
                if (start != NULL) {
                        /*
                         * start points to the start of
                         * a new token. if start is '"',
                         * we should expect a quoted
                         * string.
                         */
                        if (*start == '\"') {
                                /*
                                 * keep scanning until we
                                 * hit the end quote.
                                 */
                                if (line_buf[i] != '\"') {
                                        continue;
                                }
                                /*
                                 * skip past the start quote
                                 */
                                start++;
                        } else {
                                /*
                                 * our token is not a quoted
                                 * string. our token ends only
                                 * when we hit a whitespace.
                                 */
                                if (!isspace(line_buf[i])) {
                                        continue;
                                }
                        }
                        /*
                         * nullify the end quote (if any)
                         * and update the tokens array.
                         */
                        line_buf[i] = '\0';
                        tokens[count] = start;
                        start = NULL;
                        count++;
                } else {
                        /*
                         * skip whitespaces
                         */
                        if (isspace(line_buf[i])) {
                                continue;
                        } else {
                                start = &line_buf[i];
                        }
                }
                if (count == DATADM_MAX_TOKENS) {
                        start = NULL;
                        break;
                }
        }
        if (start != NULL) {
                tokens[count] = start;
                start = NULL;
                count++;
        }
        *token_count = count;
        return (0);
}

/*
 * attempts to save sp_entry into hca_list.
 * becomes no-op if sp entry already exists.
 * new hca entries and ia entries are created as needed.
 */
static int
datadm_process_sp_entry(datadm_list_t *hca_list, datadm_sp_entry_t *sp_entry,
    char *ia_name)
{
        datadm_hca_find_t       hca_find;
        datadm_ia_find_t        ia_find;
        datadm_hca_entry_t      *hca_entry;

        hca_find.hf_sp_entry = sp_entry;
        hca_find.hf_hca_entry = NULL;
        (void) datadm_walk_list(hca_list, (int (*)(datadm_entry_t *, void *))
            datadm_hca_entry_find, (void *)&hca_find);

        if (hca_find.hf_hca_entry == NULL) {
                int     dlen;

                /*
                 * hca_entry not found, need to create
                 * and insert one.
                 */
                hca_entry = datadm_alloc_hca_entry();
                if (hca_entry == NULL) {
                        return (-1);
                }
                dlen = strlen(sp_entry->spe_devname);
                hca_entry->he_name = (char *)malloc(dlen + 1);
                if (hca_entry->he_name == NULL) {
                        datadm_free_hca_entry(hca_entry);
                        return (-1);
                }
                (void) strcpy(hca_entry->he_name, sp_entry->spe_devname);
                datadm_enqueue_entry(hca_list, (datadm_entry_t *)hca_entry);
        } else {
                hca_entry = hca_find.hf_hca_entry;
        }
        if (ia_name == NULL) {
                goto put_sp_entry;
        }
        ia_find.if_ia_name = ia_name;
        ia_find.if_ia_entry = NULL;
        (void) datadm_walk_list(&hca_entry->he_ia_list,
            (int (*)(datadm_entry_t *, void *))datadm_ia_entry_find, &ia_find);

        if (ia_find.if_ia_entry == NULL) {
                datadm_ia_entry_t       *ia_entry;

                /*
                 * ia_entry not found, need to create
                 * and insert one.
                 */
                ia_entry = datadm_alloc_ia_entry();
                if (ia_entry == NULL) {
                        return (-1);
                }
                (void) strlcpy(ia_entry->iae_name, ia_name, MAXLINKNAMELEN);
                datadm_enqueue_entry(&hca_entry->he_ia_list,
                    (datadm_entry_t *)ia_entry);
        }

put_sp_entry:;

        if (datadm_walk_list(&hca_entry->he_sp_list,
            (int (*)(datadm_entry_t *, void *))datadm_sp_entry_match,
            (void *)sp_entry)) {
                return (1);
        } else {
                /*
                 * only insert sp_entry if it is not found.
                 */
                datadm_enqueue_entry(&hca_entry->he_sp_list,
                    (datadm_entry_t *)sp_entry);
        }
        return (0);
}

/*
 * parses service_provider.conf
 */
static int
datadm_parse_sp_conf(datadm_list_t *hca_list)
{
        datadm_sp_entry_t       *sp_entry;
        FILE                    *sp_file;
        char                    *sp_conf = datadm_args.da_sp_conf;
        char                    *tokens[DATADM_MAX_TOKENS];
        char                    line_buf[DATADM_LINESZ];
        int                     retval = 0;
        int                     token_count = 0;
        int                     line_count = 0;

        sp_file = fopen(sp_conf, "r");
        if (sp_file == NULL) {
                (void) fprintf(stderr,
                    gettext("datadm: cannot open %s\n"), sp_conf);
                return (-1);
        }

        for (;;) {
                bzero(line_buf, DATADM_LINESZ);
                if (fgets(line_buf, DATADM_LINESZ, sp_file) == NULL) {
                        break;
                }
                token_count = 0;
                line_count++;
                retval = datadm_parse_line(line_buf, tokens, &token_count);
                if (retval != 0) {
                        (void) fprintf(stderr, gettext(
                            "datadm: %s: line %d exceeded max length %d\n"),
                            sp_conf, line_count, DATADM_LINESZ);
                        break;
                }
                if (token_count == 0) continue;
                if (token_count == DATADM_NUM_SP_TOKENS) {
                        int i = 0;

                        sp_entry = datadm_alloc_sp_entry();
                        if (sp_entry == NULL) {
                                retval = -1;
                                break;
                        }

                        /*
                         * sp_entry gets filled incrementally by
                         * each parsing function
                         */
                        for (i = 0; i < DATADM_NUM_SP_TOKENS &&
                            retval == 0; i++) {
                                retval = (*datadm_sp_parse_funcs[i])
                                    (tokens[i], (void *)sp_entry);
                        }
                        if (retval != 0) {
                                (void) fprintf(stderr, gettext(
                                    "datadm: parse error: %s, "
                                    "line %d, token: %s\n"),
                                    sp_conf, line_count, tokens[i - 1]);
                                datadm_free_sp_entry(sp_entry);
                                sp_entry = NULL;
                                break;
                        }

                        retval = datadm_process_sp_entry(hca_list,
                            sp_entry, NULL);
                        if (retval != 0) {
                                datadm_free_sp_entry(sp_entry);
                                if (retval == 1) {
                                        retval = 0;
                                } else {
                                        break;
                                }
                        }
                } else {
                        (void) fprintf(stderr, gettext(
                            "datadm: parse error: %s, line %d, "
                            "# of tokens: %d, expected %d\n"), sp_conf,
                            line_count, token_count, DATADM_NUM_SP_TOKENS);
                        retval = -1;
                        break;
                }
        }
        if (retval != 0) {
                datadm_free_list(hca_list,
                    (void (*)(datadm_entry_t *))datadm_free_hca_entry);
        }
        (void) fclose(sp_file);
        return (retval);
}

/*
 * parses dat.conf
 */
static int
datadm_parse_dat_conf(datadm_list_t *hca_list)
{
        boolean_t               save_header = B_TRUE;
        datadm_sp_entry_t       *sp_entry;
        FILE                    *dat_file;
        char                    *dat_conf = datadm_args.da_dat_conf;
        char                    *tokens[DATADM_MAX_TOKENS];
        char                    line_buf[DATADM_LINESZ];
        int                     retval = 0;
        int                     token_count = 0;
        int                     line_count = 0;

        dat_file = fopen(dat_conf, "r");
        if (dat_file == NULL) {
                /* dat.conf not existing is not an error for OP_ADD */
                if (datadm_args.da_op_type == DATADM_OP_ADD) {
                        return (0);
                }
                (void) fprintf(stderr, gettext("datadm: cannot open %s\n"),
                    dat_conf);
                return (-1);
        }

        for (;;) {
                bzero(line_buf, DATADM_LINESZ);
                if (fgets(line_buf, DATADM_LINESZ, dat_file) == NULL) {
                        break;
                }
                token_count = 0;
                line_count++;
                retval = datadm_parse_line(line_buf, tokens, &token_count);
                if (retval != 0) {
                        (void) fprintf(stderr, gettext(
                            "datadm: %s: line %d exceeded max length %d\n"),
                            dat_conf, line_count, DATADM_LINESZ);
                        break;
                }
                if (token_count == 0) {
                        datadm_cmnt_entry_t     *cmnt_entry;
                        int                     cmnt_len;

                        /*
                         * comments are saved only if they are
                         * at the top of dat.conf.
                         */
                        if (!save_header) continue;
                        cmnt_entry = datadm_alloc_cmnt_entry();
                        if (cmnt_entry == NULL) {
                                perror("datadm: malloc");
                                retval = -1;
                                break;
                        }
                        cmnt_len = strlen(line_buf);
                        cmnt_entry->cmnt_line = (char *)malloc(cmnt_len + 1);
                        if (cmnt_entry->cmnt_line == NULL) {
                                perror("datadm: malloc");
                                datadm_free_cmnt_entry(cmnt_entry);
                                retval = -1;
                                break;
                        }
                        (void) strncpy(cmnt_entry->cmnt_line,
                            line_buf, cmnt_len);
                        cmnt_entry->cmnt_line[cmnt_len] = '\0';
                        datadm_enqueue_entry(&datadm_conf_header,
                            (datadm_entry_t *)cmnt_entry);
                        continue;
                }
                if (token_count == DATADM_NUM_DAT_TOKENS) {
                        int i = 0;
                        char ia_name[MAXLINKNAMELEN];

                        /*
                         * we stop saving comment lines once
                         * we see the first valid line.
                         */
                        save_header = B_FALSE;
                        sp_entry = datadm_alloc_sp_entry();
                        if (sp_entry == NULL) {
                                retval = -1;
                                break;
                        }

                        /*
                         * sp_entry gets filled incrementally by
                         * each parsing function
                         */
                        for (i = 0; i < DATADM_NUM_DAT_TOKENS &&
                            retval == 0; i++) {
                                void    *arg;

                                if (i == 0) {
                                        /*
                                         * the first token (ia name)
                                         * does not belong to an
                                         * sp_entry
                                         */
                                        arg = (void *)ia_name;
                                } else {
                                        arg = (void *)sp_entry;
                                }
                                retval = (*datadm_dat_parse_funcs[i])
                                    (tokens[i], arg);
                        }
                        if (retval != 0) {
                                (void) fprintf(stderr, gettext(
                                    "datadm: parse error: %s, "
                                    "line %d, token: %s\n"), dat_conf,
                                    line_count, tokens[i - 1]);
                                datadm_free_sp_entry(sp_entry);
                                sp_entry = NULL;
                                break;
                        }

                        /*
                         * we ignore the ibds in dat.conf if we are
                         * doing update
                         */
                        if (datadm_args.da_op_type == DATADM_OP_UPDATE) {
                                retval = datadm_process_sp_entry(hca_list,
                                    sp_entry, NULL);
                        } else {
                                retval = datadm_process_sp_entry(hca_list,
                                    sp_entry, ia_name);
                        }
                        if (retval != 0) {
                                datadm_free_sp_entry(sp_entry);
                                if (retval == 1) {
                                        retval = 0;
                                } else {
                                        break;
                                }
                        }
                } else {
                        (void) fprintf(stderr, gettext(
                            "datadm: parse error: %s, line %d, "
                            "# of tokens: %d, expected %d\n"), dat_conf,
                            line_count, token_count, DATADM_NUM_DAT_TOKENS);
                        retval = -1;
                        break;
                }
        }
        if (retval != 0) {
                datadm_free_list(&datadm_conf_header,
                    (void (*)(datadm_entry_t *))datadm_free_cmnt_entry);
                datadm_free_list(hca_list,
                    (void (*)(datadm_entry_t *))datadm_free_hca_entry);
        }
        (void) fclose(dat_file);
        return (retval);
}

/*
 * used by OP_REMOVE to invalidate common sp entries between hl1 and hl2.
 * invalid sp entries will be ignored by datadm_generate_dat_conf.
 */
static void
datadm_invalidate_common_sp_entries(datadm_list_t *hl1, datadm_list_t *hl2)
{
        datadm_entry_t  *he1, *he2;

        he1 = hl1->dl_head;
        while (he1 != NULL) {
                he2 = hl2->dl_head;
                while (he2 != NULL) {
                        datadm_entry_t  *se1, *se2;

                        if (!datadm_hca_entry_match(
                            (datadm_hca_entry_t *)he1,
                            (datadm_hca_entry_t *)he2)) {
                                he2 = he2->de_next;
                                continue;
                        }
                        se1 = ((datadm_hca_entry_t *)he1)->he_sp_list.dl_head;
                        while (se1 != NULL) {
                                se2 = ((datadm_hca_entry_t *)he2)->
                                    he_sp_list.dl_head;
                                while (se2 != NULL) {
                                        if (!datadm_sp_entry_match(
                                            (datadm_sp_entry_t *)se1,
                                            (datadm_sp_entry_t *)se2)) {
                                                se2 = se2->de_next;
                                                continue;
                                        }
                                        ((datadm_sp_entry_t *)se1)->
                                            spe_invalid = 1;
                                        break;
                                }
                                se1 = se1->de_next;
                        }
                        break;
                }
                he1 = he1->de_next;
        }
}

static int
datadm_hca_entry_find_by_name(datadm_hca_entry_t *h1,
    datadm_hca_find_by_name_t *hf)
{
        if (datadm_str_match(h1->he_name, hf->hf_name)) {
                hf->hf_hca_entry = h1;
                return (1);
        }
        return (0);
}

datadm_hca_entry_t *
datadm_hca_lookup_by_name(datadm_list_t *hca_list, char *hca_driver_name)
{
        datadm_hca_find_by_name_t       hf;

        hf.hf_name = hca_driver_name;
        hf.hf_hca_entry = NULL;
        (void) datadm_walk_list(hca_list,
            (int (*)(datadm_entry_t *, void *))datadm_hca_entry_find_by_name,
            &hf);
        return (hf.hf_hca_entry);
}

static boolean_t
datadm_add_plink(char *linkname, datadm_fill_ia_list_t *ia_args)
{
        datalink_class_t        class;
        datalink_id_t           linkid;
        dladm_ib_attr_t         ib_attr;
        ibnex_ctl_query_hca_t   query_hca;
        datadm_hca_entry_t      *hca;
        struct lifreq           req;
        datadm_ia_find_t        ia_find;
        datadm_ia_entry_t       *ia_entry;

        if ((dladm_name2info(ia_args->ia_dlh, linkname, &linkid, NULL, &class,
            NULL) != DLADM_STATUS_OK) ||
            (class != DATALINK_CLASS_PART) ||
            (dladm_part_info(ia_args->ia_dlh, linkid, &ib_attr,
            DLADM_OPT_ACTIVE) != DLADM_STATUS_OK)) {
                return (B_FALSE);
        }

        (void) strlcpy(req.lifr_name, linkname, sizeof (req.lifr_name));
        /*
         * we don't really need to know the ip address.
         * we just want to check if the device is plumbed
         * or not.
         */
        if (ioctl(ia_args->ia_sock_fd_v4, SIOCGLIFADDR, (caddr_t)&req) != 0) {
                /*
                 * we try v6 if the v4 address isn't found.
                 */
                if (ioctl(ia_args->ia_sock_fd_v6, SIOCGLIFADDR,
                    (caddr_t)&req) != 0)
                        return (B_FALSE);
        }

        bzero(&query_hca, sizeof (query_hca));
        query_hca.hca_guid = ib_attr.dia_hca_guid;
        if (ioctl(ia_args->ia_ibnex_fd, IBNEX_CTL_QUERY_HCA, &query_hca) == -1)
                return (B_FALSE);

        if ((hca = datadm_hca_lookup_by_name(ia_args->ia_hca_list,
            query_hca.hca_info.hca_driver_name)) == NULL)
                return (B_FALSE);

        ia_find.if_ia_name = linkname;
        ia_find.if_ia_entry = NULL;
        (void) datadm_walk_list(&hca->he_ia_list,
            (int (*)(datadm_entry_t *, void *))
            datadm_ia_entry_find, &ia_find);

        if (ia_find.if_ia_entry == NULL) {
                /*
                 * we insert an ia entry only if
                 * it is unique.
                 */
                ia_entry = datadm_alloc_ia_entry();
                if (ia_entry != NULL) {
                        (void) strlcpy(ia_entry->iae_name, linkname,
                            MAXLINKNAMELEN);
                        datadm_enqueue_entry(&hca->he_ia_list,
                            (datadm_entry_t *)ia_entry);
                }
        }

        return (B_FALSE);
}

/*
 * build ia lists for each hca_list element
 */
static int
datadm_build_ia_lists(datadm_list_t *hca_list)
{
        dladm_handle_t          dlh;
        datadm_fill_ia_list_t   ia_args;
        int                     rv = -1;
        int                     fd = -1;
        int                     sv4 = -1;
        int                     sv6 = -1;

        if (dladm_open(&dlh) != DLADM_STATUS_OK)
                return (-1);

        if ((fd = open(IBNEX_DEVCTL_DEV, O_RDONLY)) < 0)
                goto out;

        if ((sv4 = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
                perror("datadm: socket");
                goto out;
        }

        if ((sv6 = socket(AF_INET6, SOCK_DGRAM, 0)) < 0) {
                perror("datadm: socket");
                goto out;
        }

        ia_args.ia_hca_list = hca_list;
        ia_args.ia_dlh = dlh;
        ia_args.ia_ibnex_fd = fd;
        ia_args.ia_sock_fd_v4 = sv4;
        ia_args.ia_sock_fd_v6 = sv6;

        dlpi_walk((boolean_t (*) (const char *, void *))datadm_add_plink,
            &ia_args, 0);
        rv = 0;

out:
        if (sv4 != -1)
                (void) close(sv4);
        if (sv6 != -1)
                (void) close(sv6);
        if (fd != -1)
                (void) close(fd);

        dladm_close(dlh);
        return (rv);
}

static int
datadm_generate_conf_entry(FILE *outfile, datadm_ia_entry_t *ia_entry,
    datadm_sp_entry_t *sp_entry)
{
        int     retval;

        retval = fprintf(outfile,
            "%s  %s%d.%d  %s  %s  %s  %s%d.%d  \"%s\"  \"%s%s%s\"\n",
            ia_entry->iae_name,
            (sp_entry->spe_api_version.dv_name ?
            sp_entry->spe_api_version.dv_name : ""),
            sp_entry->spe_api_version.dv_major,
            sp_entry->spe_api_version.dv_minor,
            (sp_entry->spe_threadsafe ? "threadsafe" : "nonthreadsafe"),
            (sp_entry->spe_default ? "default" : "nondefault"),
            sp_entry->spe_libpath,
            (sp_entry->spe_sp_version.dv_name ?
            sp_entry->spe_sp_version.dv_name : ""),
            sp_entry->spe_sp_version.dv_major,
            sp_entry->spe_sp_version.dv_minor,
            sp_entry->spe_sp_data,
            DATADM_DRV_NAME, "=", sp_entry->spe_devname);

        if (retval < 0) {
                return (-1);
        }
        return (0);
}

/*
 * generate dat.conf header
 */
static int
datadm_generate_conf_header(FILE *outfile)
{
        datadm_entry_t          *cep;
        datadm_cmnt_entry_t     *cmnt;
        int                     retval = 0;

        cep = datadm_conf_header.dl_head;
        if (cep == NULL) {
                /*
                 * if dat.conf doesn't have a header, we prepend a
                 * default one.
                 */
                retval = fprintf(outfile, "%s", datadm_conf_header_default);
                goto done;
        }
        while (cep != NULL) {
                cmnt = (datadm_cmnt_entry_t *)cep;
                if (cmnt->cmnt_line != NULL) {
                        int             len;

                        retval = fprintf(outfile, "%s", cmnt->cmnt_line);
                        if (retval < 0) {
                                break;
                        }

                        /*
                         * append a newline if the comment line doesn't
                         * have one.
                         */
                        len = strlen(cmnt->cmnt_line);
                        if (cmnt->cmnt_line[len - 1] != '\n') {
                                retval = fprintf(outfile, "\n");
                                if (retval < 0) {
                                        break;
                                }
                        }
                }
                cep = cep->de_next;
        }
done:;
        if (retval < 0) {
                return (-1);
        }
        return (0);
}

/*
 * outputs dat.conf to stdout or to basedir/etc/dat/dat.conf
 */
static int
datadm_generate_dat_conf(datadm_list_t *hca_list)
{
        FILE                    *outfile = NULL;
        char                    *dat_conf = datadm_args.da_dat_conf;
        datadm_entry_t          *hep;
        int                     retval = 0;

        if (datadm_args.da_op_type == DATADM_OP_VIEW) {
                outfile = stdout;
        } else {
                outfile = fopen(dat_conf, "w+");
                if (outfile == NULL) {
                        (void) fprintf(stderr, gettext(
                            "datadm: cannot open %s: %s\n"),
                            dat_conf, strerror(errno));
                        return (-1);
                }
        }
        if (outfile != stdout) {
                /*
                 * do not generate the header if we are
                 * printing to the screen
                 */
                retval = datadm_generate_conf_header(outfile);
                if (retval != 0) {
                        goto done;
                }
        }
        hep = hca_list->dl_head;
        while (hep != NULL) {
                datadm_entry_t  *iep;

                iep = ((datadm_hca_entry_t *)hep)->he_ia_list.dl_head;
                while (iep != NULL) {
                        datadm_entry_t  *sep;

                        sep = ((datadm_hca_entry_t *)hep)->he_sp_list.dl_head;
                        while (sep != NULL) {
                                if (((datadm_sp_entry_t *)sep)->spe_invalid) {
                                        sep = sep->de_next;
                                        continue;
                                }
                                retval = datadm_generate_conf_entry(outfile,
                                    (datadm_ia_entry_t *)iep,
                                    (datadm_sp_entry_t *)sep);
                                if (retval != 0) {
                                        goto done;
                                }
                                sep = sep->de_next;
                        }
                        iep = iep->de_next;
                }
                hep = hep->de_next;
        }
        retval = fflush(outfile);
done:;
        if (outfile != stdout) {
                (void) fclose(outfile);
        }
        if (retval < 0) {
                perror("datadm: fprintf");
        }
        return (retval);
}

static int
datadm_view(void)
{
        int                     retval = 0;
        datadm_list_t           hca_list;

        bzero(&hca_list, sizeof (hca_list));

        retval = datadm_parse_dat_conf(&hca_list);
        if (retval != 0) {
                goto cleanup;
        }
        retval = datadm_generate_dat_conf(&hca_list);
        if (retval != 0) {
                goto cleanup;
        }

cleanup:;
        datadm_free_list(&datadm_conf_header,
            (void (*)(datadm_entry_t *))datadm_free_cmnt_entry);
        datadm_free_list(&hca_list,
            (void (*)(datadm_entry_t *))datadm_free_hca_entry);
        return (retval);
}

static int
datadm_update(void)
{
        int                     retval = 0;
        datadm_list_t           hca_list;

        bzero(&hca_list, sizeof (hca_list));

        retval = datadm_parse_dat_conf(&hca_list);
        if (retval != 0) {
                goto cleanup;
        }
        retval = datadm_build_ia_lists(&hca_list);
        if (retval != 0) {
                goto cleanup;
        }
        retval = datadm_generate_dat_conf(&hca_list);
        if (retval != 0) {
                goto cleanup;
        }

cleanup:;
        datadm_free_list(&datadm_conf_header,
            (void (*)(datadm_entry_t *))datadm_free_cmnt_entry);
        datadm_free_list(&hca_list,
            (void (*)(datadm_entry_t *))datadm_free_hca_entry);
        return (retval);
}

static int
datadm_add(void)
{
        int                     retval = 0;
        datadm_list_t           hca_list;

        bzero(&hca_list, sizeof (hca_list));

        retval = datadm_parse_dat_conf(&hca_list);
        if (retval != 0) {
                goto cleanup;
        }
        retval = datadm_parse_sp_conf(&hca_list);
        if (retval != 0) {
                goto cleanup;
        }
        retval = datadm_build_ia_lists(&hca_list);
        if (retval != 0) {
                goto cleanup;
        }
        retval = datadm_generate_dat_conf(&hca_list);
        if (retval != 0) {
                goto cleanup;
        }

cleanup:;
        datadm_free_list(&datadm_conf_header,
            (void (*)(datadm_entry_t *))datadm_free_cmnt_entry);
        datadm_free_list(&hca_list,
            (void (*)(datadm_entry_t *))datadm_free_hca_entry);
        return (retval);
}

static int
datadm_remove(void)
{
        int                     retval = 0;
        datadm_list_t           hca_list;
        datadm_list_t           hca_list2;

        bzero(&hca_list, sizeof (hca_list));
        bzero(&hca_list2, sizeof (hca_list2));

        retval = datadm_parse_dat_conf(&hca_list);
        if (retval != 0) {
                goto cleanup;
        }
        retval = datadm_parse_sp_conf(&hca_list2);
        if (retval != 0) {
                goto cleanup;
        }
        datadm_invalidate_common_sp_entries(&hca_list, &hca_list2);

        retval = datadm_generate_dat_conf(&hca_list);
        if (retval != 0) {
                goto cleanup;
        }

cleanup:;
        datadm_free_list(&datadm_conf_header,
            (void (*)(datadm_entry_t *))datadm_free_cmnt_entry);
        datadm_free_list(&hca_list,
            (void (*)(datadm_entry_t *))datadm_free_hca_entry);
        datadm_free_list(&hca_list2,
            (void (*)(datadm_entry_t *))datadm_free_hca_entry);
        return (retval);
}

static int
datadm_locate_dat_conf(char *basedir)
{
        char            *dat_conf;

        if (basedir == NULL) {
                datadm_args.da_dat_conf = DATADM_DAT_CONF;
                return (0);
        }
        dat_conf = (char *)malloc(strlen(basedir) +
            strlen(DATADM_DAT_CONF) + 1);
        if (dat_conf == NULL) {
                return (-1);
        }
        dat_conf[0] = '\0';
        (void) strcat(dat_conf, basedir);
        (void) strcat(dat_conf, DATADM_DAT_CONF);
        datadm_args.da_dat_conf = dat_conf;
        return (0);
}

int
main(int argc, char **argv)
{
        extern char     *optarg;
        extern int      optind;
        char            *basedir = NULL;
        int             c, retval;
        int             op_type = -1, errflg = 0;

        bzero(&datadm_args, sizeof (datadm_args));
        bzero(&datadm_conf_header, sizeof (datadm_conf_header));

        (void) setlocale(LC_ALL, "");
#if !defined(TEXT_DOMAIN)       /* Should be defined by cc -D */
#define TEXT_DOMAIN "SYS_TEST"  /* Use this only if it weren't */
#endif
        (void) textdomain(TEXT_DOMAIN);

        while ((c = getopt(argc, argv, "vua:r:b:")) != EOF) {
                switch (c) {
                case 'v':
                        if (op_type != -1) errflg = 1;
                        op_type = DATADM_OP_VIEW;
                        break;
                case 'u':
                        if (op_type != -1) errflg = 1;
                        op_type = DATADM_OP_UPDATE;
                        break;
                case 'a':
                        if (op_type != -1) errflg = 1;
                        op_type = DATADM_OP_ADD;
                        datadm_args.da_sp_conf = optarg;
                        break;
                case 'r':
                        if (op_type != -1) errflg = 1;
                        op_type = DATADM_OP_REMOVE;
                        datadm_args.da_sp_conf = optarg;
                        break;
                case 'b':
                        basedir = optarg;
                        break;
                default:
                        errflg = 1;
                        break;
                }
                if (errflg != 0) {
                        break;
                }
        }
        if (errflg != 0 || op_type == -1 || optind < argc) {
                datadm_usage();
                return (1);
        }
        datadm_args.da_op_type = op_type;
        if (datadm_locate_dat_conf(basedir)) {
                return (1);
        }

        retval = (*datadm_ops[op_type])();
        return (retval);
}