cmd/datadm/datadm.c

	datadm.c revision 7c478bd95313f5f23a4c958a745db2134aa03244
/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (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 2004 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

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

#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/sockio.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 <libdevinfo.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_IA_NAME      "ibd"
#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 using libdevinfo. 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_fill_ia_list. ia_entry holds the ia
 * device's instance number.
 */
typedef struct datadm_ia_entry {
    datadm_entry_t      iae_header;
    int         iae_devnum;
} 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;

/*
 * 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_devnum is found.
 */
typedef struct datadm_ia_find {
    int         if_ia_devnum;
    datadm_ia_entry_t   *if_ia_entry;
} datadm_ia_find_t;

/*
 * this gets passed to datadm_fill_ia_list.
 * we do this to avoid regenerating the device
 * tree for each hca_entry we process.
 */
typedef struct datadm_fill_ia_list {
    di_node_t       ia_root_node;
    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 2004 Sun Microsystems, Inc.  All rights reserved.\n"
    "# Use is subject to license terms.\n"
    "#\n"
    "# ident \"@(#)dat.conf   1.1     03/08/26 SMI\"\n"
    "#\n"
    "# DAT configuration file.\n"
    "#\n"
    "# This file is updated using the datadm(1) command.\n"
    "# Do not hand edit this file.\n"
    "# See datadm(1) 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 *, int *);

/*
 * 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 *, int);

/*
 * ia devices discovery
 */
static int datadm_build_ia_lists(datadm_list_t *);
static int datadm_fill_ia_list(datadm_hca_entry_t *, datadm_fill_ia_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, int *ia_devnum)
{
    int len;
    int i, start;

    len = strlen(DATADM_IA_NAME);
    if (strncmp(str, DATADM_IA_NAME, len) != 0) {
        return (-1);
    }
    start = i = len;
    len = strlen(str);
    if (str[i] == '\0') {
        return (-1);
    }
    for (; i < len; i++) {
        if (!isdigit(str[i])) break;
    }
    if (i != len) {
        return (-1);
    }
    *ia_devnum = atoi(str + start);
    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 (sp2->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 (i1->iae_devnum == iaf->if_ia_devnum) {
        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,
    int ia_devnum)
{
    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_devnum == -1) {
        goto put_sp_entry;
    }
    ia_find.if_ia_devnum = ia_devnum;
    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);
        }
        ia_entry->iae_devnum = ia_devnum;
        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, -1);
            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;
            int ia_devnum = -1;

            /*
             * 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_devnum;
                } 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) {
                ia_devnum = -1;
            }
            retval = datadm_process_sp_entry(hca_list, sp_entry,
                ia_devnum);
            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);
}

/*
 * discovers all ibd devices under a particular hca
 */
static int
datadm_fill_ia_list(datadm_hca_entry_t *hca, datadm_fill_ia_list_t *args)
{
    di_node_t   root_node;
    di_node_t   hca_node;
    int     retval = 0;
    int     sv4, sv6;

    root_node = args->ia_root_node;
    sv4 = args->ia_sock_fd_v4;
    sv6 = args->ia_sock_fd_v6;

    hca_node = di_drv_first_node(hca->he_name, root_node);
    if (hca_node == DI_NODE_NIL) {
        return (0);
    }
    while (hca_node != DI_NODE_NIL) {
        di_node_t   ibd_node;

        ibd_node = di_drv_first_node(DATADM_IA_NAME, hca_node);
        while (ibd_node != DI_NODE_NIL) {
            datadm_ia_find_t    ia_find;
            datadm_ia_entry_t   *ia_entry;
            struct lifreq       req;
            int         devnum, rval;

            devnum = di_instance(ibd_node);
            if (devnum == -1) {
                ibd_node = di_drv_next_node(ibd_node);
                continue;
            }

            (void) snprintf(req.lifr_name, sizeof (req.lifr_name),
                "%s%d", DATADM_IA_NAME, devnum);
            /*
             * we don't really need to know the ip address.
             * we just want to check if the device is plumbed
             * or not.
             */
            rval = ioctl(sv4, SIOCGLIFADDR, (caddr_t)&req);
            if (rval != 0) {
                /*
                 * we try v6 if the v4 address isn't found.
                 */
                rval = ioctl(sv6, SIOCGLIFADDR, (caddr_t)&req);
                if (rval != 0) {
                    ibd_node = di_drv_next_node(ibd_node);
                    continue;
                }
            }
            ia_find.if_ia_devnum = devnum;
            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) {
                    retval = -1;
                    break;
                }
                ia_entry->iae_devnum = devnum;
                datadm_enqueue_entry(&hca->he_ia_list,
                    (datadm_entry_t *)ia_entry);
            } else {
                ia_entry = ia_find.if_ia_entry;
            }
            ibd_node = di_drv_next_node(ibd_node);
        }
        hca_node = di_drv_next_node(hca_node);
    }
    if (retval != 0) {
        datadm_free_list(&hca->he_ia_list,
            (void (*)(datadm_entry_t *))datadm_free_ia_entry);
    }
    return (0);
}

/*
 * 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;
    }
}

/*
 * applies datadm_fill_ia_list on each hca_list element
 */
static int
datadm_build_ia_lists(datadm_list_t *hca_list)
{
    datadm_fill_ia_list_t   ia_args;
    di_node_t       root_node;
    int         retval = 0;
    int         sv4, sv6;

    root_node = di_init("/", DINFOCPYALL);
    if (root_node == DI_NODE_NIL) {
        perror("datadm: di_init");
        return (-1);
    }
    sv4 = socket(AF_INET, SOCK_DGRAM, 0);
    if (sv4 < 0) {
        perror("datadm: socket");
        di_fini(root_node);
        return (-1);
    }
    sv6 = socket(AF_INET6, SOCK_DGRAM, 0);
    if (sv6 < 0) {
        perror("datadm: socket");
        di_fini(root_node);
        return (-1);
    }
    ia_args.ia_root_node = root_node;
    ia_args.ia_sock_fd_v4 = sv4;
    ia_args.ia_sock_fd_v6 = sv6;

    retval = datadm_walk_list(hca_list,
        (int (*)(datadm_entry_t *, void *))datadm_fill_ia_list, &ia_args);

    (void) close(sv4);
    (void) close(sv6);
    di_fini(root_node);
    return (retval);
}

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%d  %s%d.%d  %s  %s  %s  %s%d.%d  \"%s\"  \"%s%s%s\"\n",
        DATADM_IA_NAME, ia_entry->iae_devnum,
        (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);
}