lib/picld_pluginutil/picld_pluginutil.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * This module implements the routine to parse the configuration file.
 */


#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include <ctype.h>
#include <alloca.h>
#include <limits.h>
#include <sys/utsname.h>
#include <sys/systeminfo.h>
#include <sys/types.h>
#include <libintl.h>
#include <syslog.h>
#include <locale.h>
#include <picl.h>
#include <picltree.h>
#include "picld_pluginutil.h"
#include "picld_pluginutil_impl.h"

/* error codes returned from syntax checking */
#define EC_SYNTAX_OK        0
#define EC_INSUFFICIENT_TOKEN   1
#define EC_SYNTAX_ERR       2
#define EC_UNSUPPORTED      3
#define EC_PATH_ERR     4
#define EC_NODE_MISMATCH    5
#define EC_FAILURE      6
#define EC_PICL_ERR     7
#define EC_TABLE_MISMATCH   8
#define EC_ROW_MISMATCH     9
#define EC_ROW_EMPTY        10

/*
 * Error message texts
 */
static  char    *err_msg[] = {
    "%s: Syntax OK",                    /* 0 */
    "%s::%s[line %d]: Insufficient token\n",        /* 1 */
    "%s::%s[line %d]: Syntax error\n",          /* 2 */
    "%s::%s[line %d]: Unsupported or missing version\n",    /* 3 */
    "%s::%s[line %d]: Illegal use of nodepath or namepath\n",   /* 4 */
    "%s::%s[line %d]: Node and endnode mismatch\n",     /* 5 */
    "%s::%s[line %d]: General system failure\n",        /* 6 */
    "%s: PICL error code %d\n",             /* 7 */
    "%s::%s[line %d]: Table and endtable mismatch\n",   /* 8 */
    "%s::%s[line %d]: Row and endrow mismatch\n",       /* 9 */
    "%s::%s[line %d]: Row has no entries \n"        /* 10 */
};

/* token per directive */
#define TOK_CLASSPATH   0
#define TOK_NAMEPATH    1
#define TOK_NODE    2
#define TOK_ENDNODE 3
#define TOK_PROP    4
#define TOK_REFPROP 5
#define TOK_VERSION 6
#define TOK_REFNODE 7
#define TOK_VERBOSE 8
#define TOK_TABLE   9
#define TOK_ENDTABLE    10
#define TOK_ROW     11
#define TOK_ENDROW  12

static const char   *tokens[] = {
    "_class",   /* _CLASS:<classpath> */
    "name",     /* NAME:<namepath> */
    "node",     /* NODE <name> <class> */
    "endnode",  /* ENDNODE */
    "prop",     /* PROP <name> <type> <access_mode> <size> <value> */
    "refprop",  /* REFPROP <prop> <destnode> */
    "version",  /* VERSION <version_number> */
    "refnode",  /* REFNODE <node> <class> WITH <destnode> */
    "verbose",  /* VERBOSE <level> */
    "table",    /* TABLE   <table_prop_name> */
    "endtable", /* ENDTABLE */
    "row",      /* ROW  */
    "endrow"    /* ENDROW */
};

#define BUF_SIZE_MAX    1024

/*
 * print error message
 */
/*VARARGS2*/
static void
verbose_log(int pri, const char *fmt, ...)
{
    va_list ap;

    va_start(ap, fmt);
    vsyslog(pri, fmt, ap);
    va_end(ap);
}

/*
 * Undo the commands which have created valid node/prop handle
 * The undo order is from last command to the first command.
 */
static void
undo_commands(cmdbuf_t *cmds, int last_cmd_index)
{
    int         i;
    command_t   *com = cmds->commands;

    for (i = last_cmd_index; i >= 0; i--) {
        switch (com[i].type) {
        case TOK_NODE:
            if (com[i].nodecmd_nodeh == NULL)
                break;

            (void) ptree_delete_node(com[i].nodecmd_nodeh);
            (void) ptree_destroy_node(com[i].nodecmd_nodeh);
            break;
        case TOK_REFNODE:
            if (com[i].refnodecmd_nodeh == NULL)
                break;
            (void) ptree_delete_node(com[i].refnodecmd_nodeh);
            (void) ptree_destroy_node(com[i].refnodecmd_nodeh);
            break;
        case TOK_PROP:
            if (com[i].propcmd_proph == NULL)
                break;
            (void) ptree_delete_prop(com[i].propcmd_proph);
            (void) ptree_destroy_prop(com[i].propcmd_proph);
            break;
        case TOK_REFPROP:
            if (com[i].refpropcmd_proph == NULL)
                break;
            (void) ptree_delete_prop(com[i].refpropcmd_proph);
            (void) ptree_destroy_prop(com[i].refpropcmd_proph);
            break;
        case TOK_TABLE:
            if ((com[i].tablecmd_tblh == NULL) ||
                (com[i].tablecmd_newtbl == 0))
                break;
            (void) ptree_delete_prop(com[i].tablecmd_tblh);
            (void) ptree_destroy_prop(com[i].tablecmd_tblh);
            break;
        case TOK_ENDTABLE:
            /*FALLTHROUGH*/
        case TOK_ROW:
            /*FALLTHROUGH*/
        case TOK_ENDROW:
            /*FALLTHROUGH*/
        case TOK_NAMEPATH:
            /*FALLTHROUGH*/
        case TOK_CLASSPATH:
            /*FALLTHROUGH*/
        case TOK_ENDNODE:
            /*FALLTHROUGH*/
        case TOK_VERBOSE:
            /*FALLTHROUGH*/
        default:
            break;
        }
    }
}

/*
 * Get the token index from the tokens table
 */
static int
get_token_id(char *t)
{
    int i;

    for (i = 0; i < sizeof (tokens)/ sizeof (char *); ++i)
        if (strcasecmp(tokens[i], t) == 0)
            return (i);

    return (-1);
}

/*
 * Check the version syntax and set the version_no
 *
 * VERSION <version_num> --   specify the configuration version
 */
static int
parse_version(cmdbuf_t *cmds, char *line)
{
    char    *tok;
    char    *vertok;
    char    *last;
    char    *endptr;

    /* get the VERSION directive */
    tok = strtok_r(line, WHITESPACE, &last);
    if (tok == NULL)
        return (EC_INSUFFICIENT_TOKEN);

    /* get the version number */
    vertok = strtok_r(last, WHITESPACE, &last);
    if (vertok == NULL)
        return (EC_INSUFFICIENT_TOKEN);

    cmds->version_no = (float)strtod(vertok, &endptr);
    if (endptr != (vertok + strlen(vertok)))
        return (EC_UNSUPPORTED);

    if (cmds->version_no > (float)SUPPORTED_VERSION_NUM)
        return (EC_UNSUPPORTED);

    /* check if more tokens */
    tok = strtok_r(last, WHITESPACE, &last);
    if (tok != NULL)
        return (EC_SYNTAX_ERR);

    return (EC_SYNTAX_OK);
}

/*
 * free path_cmd_t
 */
static void
free_path(command_t *command)
{
    free(command->pathcmd_name);
}

/*
 * Check the path syntax
 * NAMEPATH:<namepath> --     gives the anchor node
 * or
 * CLASSPATH:<classpath> --   gives the anchor node
 */
static int
parse_path(char *line, command_t *command)
{
    char    *tok;
    char    *pathtok;
    char    *last;

    pathtok = strtok_r(line, WHITESPACE, &last);
    if (pathtok == NULL)
        return (EC_INSUFFICIENT_TOKEN);

    /* check if more tokens */
    tok = strtok_r(last, WHITESPACE, &last);
    if (tok != NULL)
        return (EC_SYNTAX_ERR);

    command->pathcmd_name = strdup(pathtok);
    if (command->pathcmd_name == NULL)
        return (EC_FAILURE);

    return (EC_SYNTAX_OK);
}

/*
 * Process the path command and return PICL node handle
 */
static int
process_path(command_t *command, picl_nodehdl_t *nodeh)
{
    int err;

    err = ptree_get_node_by_path(command->pathcmd_name, nodeh);
    return (err);
}

/*
 * free node_cmd_t
 */
static void
free_node(command_t *command)
{
    free(command->nodecmd_nodename);
    free(command->nodecmd_classname);
}

/*
 * Check the NODE syntax
 * NODE <name> <class>
 */
static int
parse_node(char *line, command_t *command)
{
    char    *tok;
    char    *nametok;
    char    *classtok;
    char    *last;

    /* get the NODE directive */
    tok = strtok_r(line, WHITESPACE, &last);
    if (tok == NULL)
        return (EC_INSUFFICIENT_TOKEN);

    /* get name */
    nametok = strtok_r(last, WHITESPACE, &last);
    if (nametok == NULL)
        return (EC_INSUFFICIENT_TOKEN);

    classtok = strtok_r(last, WHITESPACE, &last);
    if (classtok == NULL)
        return (EC_INSUFFICIENT_TOKEN);

    /* check if more tokens */
    tok = strtok_r(last, WHITESPACE, &last);
    if (tok != NULL)
        return (EC_SYNTAX_ERR);

    command->nodecmd_nodename = strdup(nametok);
    command->nodecmd_classname = strdup(classtok);
    command->nodecmd_nodeh = NULL;
    if ((command->nodecmd_nodename == NULL) ||
        (command->nodecmd_classname == NULL))
        return (EC_FAILURE);

    return (EC_SYNTAX_OK);
}

/*
 * Process the NODE command and return PICL node handle
 */
static int
process_node(command_t *command, picl_nodehdl_t parh, picl_nodehdl_t *nodeh)
{
    int err;

    err = ptree_create_and_add_node(parh, command->nodecmd_nodename,
        command->nodecmd_classname, nodeh);

    if (err == PICL_SUCCESS)
        command->nodecmd_nodeh = *nodeh;

    return (err);
}

/*
 * get the PICL property type
 */
static int
getpicltype(char *type)
{
    if (strcasecmp(type, KEYWORD_INT_TYPE) == 0)
        return (PICL_PTYPE_INT);
    else if (strcasecmp(type, KEYWORD_UINT_TYPE) == 0)
        return (PICL_PTYPE_UNSIGNED_INT);
    else if (strcasecmp(type, KEYWORD_FLOAT_TYPE) == 0)
        return (PICL_PTYPE_FLOAT);
    else if (strcasecmp(type, KEYWORD_STRING_TYPE) == 0)
        return (PICL_PTYPE_CHARSTRING);
    else if (strcasecmp(type, KEYWORD_VOID_TYPE) == 0)
        return (PICL_PTYPE_VOID);
    else
        return (-1);
}

/*
 * get the PICL accessmode mode
 */
static int
getpiclmode(char *mode)
{
    if (strcasecmp(mode, KEYWORD_READ_MODE) == 0)
        return (PICL_READ);
    else if (strcasecmp(mode, KEYWORD_WRITE_MODE) == 0)
        return (PICL_WRITE);
    else if (strcasecmp(mode, KEYWORD_READWRITE_MODE) == 0)
        return (PICL_READ|PICL_WRITE);
    else
        return (-1);
}

/*
 * check if the size and value are valid given by the prop type
 */
static int
validate_size_and_cvt_val(void *outbuf, size_t size, int type, char *val)
{
    int64_t     llval;
    int32_t     intval;
    int16_t     sval;
    int8_t      cval;
    uint64_t    ullval;
    uint32_t    uintval;
    uint16_t    usval;
    uint8_t     ucval;
    float       fval;
    double      dval;
    char        *endptr;

    switch (type) {
    case PICL_PTYPE_CHARSTRING:
        break;
    case PICL_PTYPE_INT:
        switch (size) {
        case sizeof (int64_t):
            llval = strtoll(val, &endptr, 0);
            if (endptr != (val + strlen(val)))
                return (EC_SYNTAX_ERR);
            (void) memcpy(outbuf, &llval, size);
            break;
        case sizeof (int32_t):
            intval = strtol(val, &endptr, 0);
            if (endptr != (val + strlen(val)))
                return (EC_SYNTAX_ERR);
            (void) memcpy(outbuf, &intval, size);
            break;
        case sizeof (int16_t):
            sval = (int16_t)strtol(val, &endptr, 0);
            if (endptr != (val + strlen(val)))
                return (EC_SYNTAX_ERR);
            (void) memcpy(outbuf, &sval, size);
            break;
        case sizeof (int8_t):
            cval = (int8_t)strtol(val, &endptr, 0);
            if (endptr != (val + strlen(val)))
                return (EC_SYNTAX_ERR);
            (void) memcpy(outbuf, &cval, size);
            break;
        default:    /* invalid size */
            return (EC_SYNTAX_ERR);
        }
        break;
    case PICL_PTYPE_UNSIGNED_INT:
        switch (size) {
        case sizeof (uint64_t):
            ullval = strtoull(val, &endptr, 0);
            if (endptr != (val + strlen(val)))
                return (EC_SYNTAX_ERR);
            (void) memcpy(outbuf, &ullval, size);
            break;
        case sizeof (uint32_t):
            uintval = strtoul(val, &endptr, 0);
            if (endptr != (val + strlen(val)))
                return (EC_SYNTAX_ERR);
            (void) memcpy(outbuf, &uintval, size);
            break;
        case sizeof (uint16_t):
            usval = (uint16_t)strtoul(val, &endptr, 0);
            if (endptr != (val + strlen(val)))
                return (EC_SYNTAX_ERR);
            (void) memcpy(outbuf, &usval, size);
            break;
        case sizeof (uint8_t):
            ucval = (uint8_t)strtoul(val, &endptr, 0);
            if (endptr != (val + strlen(val)))
                return (EC_SYNTAX_ERR);
            (void) memcpy(outbuf, &ucval, size);
            break;
        default:    /* invalid size */
            return (EC_SYNTAX_ERR);
        }
        break;
    case PICL_PTYPE_FLOAT:
        switch (size) {
        case sizeof (double):
            dval = strtod(val, &endptr);
            if (endptr != (val + strlen(val)))
                return (EC_SYNTAX_ERR);
            (void) memcpy(outbuf, &dval, size);
            break;
        case sizeof (float):
            fval = (float)strtod(val, &endptr);
            if (endptr != (val + strlen(val)))
                return (EC_SYNTAX_ERR);
            (void) memcpy(outbuf, &fval, size);
            break;
        default:    /* invalid size */
            return (EC_SYNTAX_ERR);
        }
        break;
    default:    /* not supported type */
        return (EC_SYNTAX_ERR);
    }

    return (EC_SYNTAX_OK);
}

/*
 * free prop_cmd_t
 */
static void
free_prop(command_t *command)
{
    free(command->propcmd_pname);
    if (command->propcmd_type != PICL_PTYPE_VOID)
        free(command->propcmd_valbuf);
}

/*
 * return the string token in two double quotes
 * The current version won't support multiple-line string
 */
static int
get_string_token(char *line, char **valtok)
{
    char    *optr;  /* ptr to the open quote */
    char    *cptr;  /* ptr to the close quote */
    char    *ptr;
    char    *tmpbuf;

    if (line == NULL)
        return (EC_INSUFFICIENT_TOKEN);

    /* skipping leading white spaces */
    optr = line;
    while ((*optr == ' ') || (*optr == '\t') || (*optr == '\n'))
        optr++;

    /* reach end of string */
    if (*optr == '\0')
        return (EC_INSUFFICIENT_TOKEN);

    /* it's not an open double quote */
    if (*optr != '"')
        return (EC_SYNTAX_ERR);

    /* skipping ending white spaces */
    cptr = line + strlen(line) - 1;
    while ((*cptr == ' ') || (*cptr == '\t') || (*cptr == '\n'))
        cptr--;

    /* it's not an close double quote */
    if (*cptr != '"')
        return (EC_SYNTAX_ERR);

    /* close double quote is missing */
    if (cptr == optr)
        return (EC_SYNTAX_ERR);

    /* replace close qoute by null to make a string */
    *cptr = '\0';
    /* move the begin pointer to the first char of string */
    optr++;

    tmpbuf = malloc(strlen(optr) + 1);
    if (tmpbuf == NULL)
        return (EC_FAILURE);

    for (ptr = tmpbuf; *optr != '\0'; ptr++, optr++) {
        /* if escape character, go to next character */
        if (*optr == '\\') {
            optr++;
            if (*optr == '\0') {    /* for exampe, "xxx\" */
                free(tmpbuf);
                return (EC_SYNTAX_ERR);
            }
        }
        *ptr = *optr;
    }

    *ptr = '\0';
    *valtok = tmpbuf;
    return (EC_SYNTAX_OK);
}

/*
 * Check the PROP syntax
 * PROP <name> <type> <access_mode> [<size> <value>]
 * supported prop types: void, int, uint, float, string
 * supported prop access_modes: r, w, rw
 * For void prop, <size> and <value> are not needed
 * For string prop, <size> will be set the actual string size if <size>
 * is 0
 */
static int
parse_prop(char *line, command_t *command)
{
    char    *tok;
    char    *pnametok;
    int typetok;
    size_t  sizetok;
    int modetok;
    char    *valtok;
    char    *last;
    char    *endptr;
    int err;

    /* get the PROP directive */
    tok = strtok_r(line, WHITESPACE, &last);
    if (tok == NULL)
        return (EC_INSUFFICIENT_TOKEN);

    /* get the property name */
    pnametok = strtok_r(last, WHITESPACE, &last);
    if (pnametok == NULL)
        return (EC_INSUFFICIENT_TOKEN);

    /* get the type */
    tok = strtok_r(last, WHITESPACE, &last);
    if (tok == NULL)
        return (EC_INSUFFICIENT_TOKEN);

    if ((typetok = getpicltype(tok)) < 0)
        return (EC_SYNTAX_ERR);

    /* get mode */
    tok = strtok_r(last, WHITESPACE, &last);
    if (tok == NULL)
        return (EC_INSUFFICIENT_TOKEN);

    if ((modetok = getpiclmode(tok)) < 0)
        return (EC_SYNTAX_ERR);

    if (typetok == PICL_PTYPE_VOID) {
        /* ignore the rest of arguments */
        command->propcmd_valbuf = NULL;
        command->propcmd_pname = strdup(pnametok);
        if (command->propcmd_pname == NULL)
            return (EC_FAILURE);
        command->propcmd_type = typetok;
        command->propcmd_accessmode = modetok;
        command->propcmd_size = 0;
        command->propcmd_proph = NULL;
        return (EC_SYNTAX_OK);
    }

    /* get size */
    tok = strtok_r(last, WHITESPACE, &last);
    if (tok == NULL)
        return (EC_INSUFFICIENT_TOKEN);

    sizetok = (size_t)strtol(tok, &endptr, 0);
    if (endptr != (tok + strlen(tok)))
        return (EC_SYNTAX_ERR);

    /* get val */
    if (typetok == PICL_PTYPE_CHARSTRING) {
        err = get_string_token(last, &valtok);
        if (err != EC_SYNTAX_OK)
            return (err);
        if (sizetok == 0)
            sizetok = strlen(valtok) + 1;
        command->propcmd_valbuf = valtok;
    } else {
        valtok = strtok_r(last, WHITESPACE, &last);
        if (valtok == NULL)
            return (EC_INSUFFICIENT_TOKEN);
        /* check if more tokens */
        tok = strtok_r(last, WHITESPACE, &last);
        if (tok != NULL)
            return (EC_SYNTAX_ERR);
        command->propcmd_valbuf = malloc(sizetok);
        if (command->propcmd_valbuf == NULL)
            return (EC_FAILURE);
        err = validate_size_and_cvt_val(command->propcmd_valbuf,
            sizetok, typetok, valtok);
        if (err != EC_SYNTAX_OK) {
            free(command->propcmd_valbuf);
            return (err);
        }
    }

    command->propcmd_pname = strdup(pnametok);
    if (command->propcmd_pname == NULL)
        return (EC_FAILURE);
    command->propcmd_type = typetok;
    command->propcmd_accessmode = modetok;
    command->propcmd_size = sizetok;
    command->propcmd_proph = NULL;
    return (EC_SYNTAX_OK);
}

/*
 * Add a property to the row, the row gets added to the node at endrow
 */
static int
add_proph_to_row(command_t *command, picl_prophdl_t proph)
{
    if (command->rowcmd_index >= command->rowcmd_nproph)
        return (PICL_FAILURE);
    command->rowcmd_prophs[command->rowcmd_index] = proph;
    command->rowcmd_index++;
    return (PICL_SUCCESS);
}

/*
 * Process the PROP command and add the specified property under the given
 * node handle
 */
static int
process_prop(cmdbuf_t *cmds, command_t *command, picl_nodehdl_t nodeh)
{
    ptree_propinfo_t    propinfo;
    picl_prophdl_t      proph;
    int         err;

    /* prop in discarded row */
    if (cmds->inside_row_block &&
        cmds->commands[cmds->current_row].rowcmd_nproph == 0)
        return (PICL_SUCCESS);

    err = ptree_init_propinfo(&propinfo, PTREE_PROPINFO_VERSION,
        command->propcmd_type, command->propcmd_accessmode,
        command->propcmd_size, command->propcmd_pname, NULL,
        NULL);

    if (err != PICL_SUCCESS)
        return (err);

    err = ptree_create_prop(&propinfo, command->propcmd_valbuf, &proph);

    if (err != PICL_SUCCESS)
        return (err);

    command->propcmd_proph = proph;

    if (cmds->inside_row_block) {
        err = add_proph_to_row(&cmds->commands[cmds->current_row],
            proph);
    } else {
        err = ptree_add_prop(nodeh, proph);
    }

    return (err);
}

/*
 * free refnode_cmd_t
 */
static void
free_refnode(command_t *command)
{
    free(command->refnodecmd_name);
    free(command->refnodecmd_class);
    free(command->refnodecmd_dstnode);
}

/*
 * Check the REFNODE syntax
 *
 * REFNODE <name> <class> with <destnode> -- if <destnode> exists,
 * create node with nodename <name> and piclclass <class>
 */
static int
parse_refnode(char *line, command_t *command)
{
    char    *tok;
    char    *dsttok;
    char    *classnm;
    char    *nodenm;
    char    *last;

    /* get the directive */
    tok = strtok_r(line, WHITESPACE, &last);
    if (tok == NULL)
        return (EC_INSUFFICIENT_TOKEN);

    /* get the nodename */
    nodenm = strtok_r(last, WHITESPACE, &last);
    if (nodenm == NULL)
        return (EC_INSUFFICIENT_TOKEN);

    /* get the class */
    classnm = strtok_r(last, WHITESPACE, &last);
    if (classnm == NULL)
        return (EC_INSUFFICIENT_TOKEN);

    /* get the WITH keyword */
    tok = strtok_r(last, WHITESPACE, &last);
    if (tok == NULL)
        return (EC_INSUFFICIENT_TOKEN);

    if (strcasecmp(tok, KEYWORD_WITH_STR) != 0)
        return (EC_SYNTAX_ERR);

    /* get the dst node */
    dsttok = strtok_r(last, WHITESPACE, &last);
    if (dsttok == NULL)
        return (EC_INSUFFICIENT_TOKEN);

    /* check if more tokens */
    tok = strtok_r(last, WHITESPACE, &last);
    if (tok != NULL)
        return (EC_SYNTAX_ERR);

    command->refnodecmd_name = strdup(nodenm);
    command->refnodecmd_class = strdup(classnm);
    command->refnodecmd_dstnode = strdup(dsttok);
    command->refnodecmd_nodeh = NULL;
    if ((command->refnodecmd_name == NULL) ||
        (command->refnodecmd_class == NULL) ||
        (command->refnodecmd_dstnode == NULL))
        return (EC_FAILURE);

    return (EC_SYNTAX_OK);
}

/*
 * Process the REFNODE command
 */
static int
process_refnode(command_t *command, picl_nodehdl_t parh)
{
    picl_nodehdl_t  dsth;
    picl_nodehdl_t  nodeh;
    int     err;

    if ((ptree_get_node_by_path(command->refnodecmd_dstnode,
        &dsth) == PICL_SUCCESS)) {
        err = ptree_create_and_add_node(parh, command->refnodecmd_name,
            command->refnodecmd_class, &nodeh);
        if (err == PICL_SUCCESS)
            command->refnodecmd_nodeh = nodeh;

        return (err);
    }

    return (PICL_SUCCESS);
}

/*
 * free refprop_cmd_t
 */
static void
free_refprop(command_t *command)
{
    free(command->refpropcmd_pname);
    free(command->refpropcmd_dstnode);
}

/*
 * Check the REFPROP syntax
 *
 * REFPROP <prop> <destnode> -- creates a reference property to <destnode>
 */
static int
parse_refprop(char *line, command_t *command)
{
    char    *tok;
    char    *pnametok;
    char    *dsttok;
    char    *last;

    /* get the REFPROP directive */
    tok = strtok_r(line, WHITESPACE, &last);
    if (tok == NULL)
        return (EC_INSUFFICIENT_TOKEN);

    /* get the propname  */
    pnametok = strtok_r(last, WHITESPACE, &last);
    if (pnametok == NULL)
        return (EC_INSUFFICIENT_TOKEN);

    dsttok = strtok_r(last, WHITESPACE, &last);
    if (dsttok == NULL)
        return (EC_INSUFFICIENT_TOKEN);

    /* check if more tokens */
    tok = strtok_r(last, WHITESPACE, &last);
    if (tok != NULL)
        return (EC_SYNTAX_ERR);

    command->refpropcmd_pname = strdup(pnametok);
    command->refpropcmd_dstnode = strdup(dsttok);
    command->refpropcmd_proph = NULL;
    if ((command->refpropcmd_pname == NULL) ||
        (command->refpropcmd_dstnode == NULL))
        return (EC_FAILURE);

    return (EC_SYNTAX_OK);
}

/*
 * Process the REFPROP command
 */
static int
process_refprop(cmdbuf_t *cmds, command_t *command, picl_nodehdl_t nodeh)
{
    int         err;
    picl_nodehdl_t      dsth;
    picl_prophdl_t      proph;
    ptree_propinfo_t    propinfo;

    /* refprop in discarded row */
    if (cmds->inside_row_block &&
        cmds->commands[cmds->current_row].rowcmd_nproph == 0)
        return (PICL_SUCCESS);

    /* try finding the refprop's dstnode */
    err = ptree_get_node_by_path(command->refpropcmd_dstnode, &dsth);

    /* dstnode doesn't exist, return */
    if (err != PICL_SUCCESS)
        return (err);

    /* dstnode exists, try adding the refprop to nodeh */
    err = ptree_init_propinfo(&propinfo, PTREE_PROPINFO_VERSION,
        PICL_PTYPE_REFERENCE, PICL_READ, sizeof (picl_nodehdl_t),
        command->refpropcmd_pname, NULL, NULL);

    if (err != PICL_SUCCESS)
        return (err);

    err = ptree_create_prop(&propinfo, &dsth, &proph);

    if (err != PICL_SUCCESS)
        return (err);

    command->refpropcmd_proph = proph;

    if (cmds->inside_row_block) {
        err = add_proph_to_row(&cmds->commands[cmds->current_row],
            proph);
    } else {
        err = ptree_add_prop(nodeh, proph);
    }

    return (err);
}

/*
 * free table_cmd_t
 */
static void
free_table(command_t *command)
{
    if (command->tablecmd_tname)
        free(command->tablecmd_tname);
}

/*
 * Check the TABLE syntax
 * TABLE <table_prop_name>
 *
 */
static int
parse_table(char *line, command_t *command)
{
    char    *tok = NULL;
    char    *tnametok = NULL;
    char    *last = NULL;

    /* get the TABLE directive */
    tok = strtok_r(line, WHITESPACE, &last);
    if (tok == NULL)
        return (EC_INSUFFICIENT_TOKEN);

    /* get the property name */
    tnametok = strtok_r(last, WHITESPACE, &last);
    if (tnametok == NULL)
        return (EC_INSUFFICIENT_TOKEN);

    command->tablecmd_tname = strdup(tnametok);
    if (command->tablecmd_tname == NULL)
        return (EC_FAILURE);

    command->tablecmd_newtbl = 0;
    command->tablecmd_tblh = NULL;

    return (EC_SYNTAX_OK);
}

/*
 * Process the TABLE command and add the specified property under the given
 * node handle
 */
static int
process_table(command_t *command, picl_nodehdl_t nodeh)
{
    int         err;
    picl_prophdl_t      tblh;
    picl_prophdl_t      proph;
    ptree_propinfo_t    propinfo;

    /* find if table already exists */
    err = ptree_get_prop_by_name(nodeh, command->tablecmd_tname, &tblh);
    if (err == PICL_SUCCESS) {
        err = ptree_get_propinfo(tblh, &propinfo);
        if (err != PICL_SUCCESS)
            return (err);
        /* prop with the same name as table? */
        if (propinfo.piclinfo.type != PICL_PTYPE_TABLE)
            return (EC_SYNTAX_ERR);
        command->tablecmd_newtbl = 0;
        command->tablecmd_tblh = tblh;
        return (PICL_SUCCESS);
    }

    /* init and create a new table */
    err = ptree_init_propinfo(&propinfo, PTREE_PROPINFO_VERSION,
        PICL_PTYPE_TABLE, PICL_READ|PICL_WRITE,
        sizeof (picl_prophdl_t), command->tablecmd_tname, NULL, NULL);
    if (err != PICL_SUCCESS)
        return (err);

    err = ptree_create_table(&tblh);
    if (err != PICL_SUCCESS)
        return (err);

    command->tablecmd_newtbl = 1;
    command->tablecmd_tblh = tblh;

    err = ptree_create_prop(&propinfo, &tblh, &proph);
    if (err != PICL_SUCCESS)
        return (err);

    err = ptree_add_prop(nodeh, proph);

    return (err);
}

/*
 * Process the ROW command by alloc'ing space to store the prop handles for
 * the whole row. The number of props in the row gets known while parsing.
 */
static int
process_row(command_t *command)
{
    command->rowcmd_index = 0;
    command->rowcmd_prophs =
        malloc(command->rowcmd_nproph * sizeof (picl_prophdl_t));

    if (command->rowcmd_prophs == NULL)
        return (PICL_FAILURE);

    return (PICL_SUCCESS);
}

/*
 * Process the ENDROW command. If a valid row, add the row to the ptree.
 */
static int
process_endrow(cmdbuf_t *cmds)
{
    int     err;
    int     i;
    command_t   *curr_row;

    curr_row = &cmds->commands[cmds->current_row];

    /* if nproph == 0, some row prop had problems, don't add  */
    if (curr_row->rowcmd_nproph == 0) {
        for (i = 0; i < curr_row->rowcmd_index; i++) {
            (void) ptree_delete_prop(curr_row->rowcmd_prophs[i]);
            (void) ptree_destroy_prop(curr_row->rowcmd_prophs[i]);
        }
        err = PICL_SUCCESS;
    } else
        err = ptree_add_row_to_table(
            cmds->commands[cmds->current_tbl].tablecmd_tblh,
            curr_row->rowcmd_nproph,
            curr_row->rowcmd_prophs);

    /* let go the space alloc'd in process_row */
    free(curr_row->rowcmd_prophs);
    curr_row->rowcmd_prophs = NULL;

    return (err);
}

/*
 * Check the VERBOSE syntax
 * VERBOSE <level>
 */
static int
parse_verbose(cmdbuf_t *cmds, char *line, command_t *command)
{
    char    *tok;
    char    *level;
    char    *last;
    char    *endptr;
    int verbose_level;

    /* get the VERBOSE directive */
    tok = strtok_r(line, WHITESPACE, &last);
    if (tok == NULL)
        return (EC_INSUFFICIENT_TOKEN);

    /* get verbose level */
    level = strtok_r(last, WHITESPACE, &last);
    if (level == NULL)
        return (EC_INSUFFICIENT_TOKEN);
    verbose_level = strtol(level, &endptr, 0);
    if (endptr != (level + strlen(level)))
        return (EC_SYNTAX_ERR);

    /* check if more tokens */
    tok = strtok_r(last, WHITESPACE, &last);
    if (tok != NULL)
        return (EC_SYNTAX_ERR);

    cmds->verbose = verbose_level;
    command->verbosecmd_level = verbose_level;

    return (EC_SYNTAX_OK);
}

/*
 * Process the VERBOSE command to set the verbose level
 */
static int
process_verbose(cmdbuf_t *cmds, command_t *command)
{
    cmds->verbose = command->verbosecmd_level;
    return (PICL_SUCCESS);
}

/*
 * parse and tokenize the line
 */
static int
parse_and_tokenize_line(cmdbuf_t *cmds, char *buf, command_t *command)
{
    char        rec[RECORD_SIZE_MAX];
    char        *tok;
    int     err;
    char        *last;
    int     id;

    (void) strcpy(rec, buf);
    tok = strtok_r(rec, RECORD_WHITESPACE, &last);
    if (tok == NULL)
        return (EC_INSUFFICIENT_TOKEN);

    id = get_token_id(tok);

    (void) strcpy(rec, buf);

    switch (id) {
    case TOK_VERSION:
        err = parse_version(cmds, rec);
        break;
    case TOK_CLASSPATH:
    case TOK_NAMEPATH:
        if (cmds->inside_node_block != 0)
            return (EC_PATH_ERR);

        err = parse_path(rec, command);
        if (err != EC_SYNTAX_OK)
            return (err);
        break;
    case TOK_NODE:
        /* Check for NODE outside of TABLE, ROW */
        if ((cmds->inside_table_block != 0) ||
            (cmds->inside_row_block != 0))
            return (EC_SYNTAX_ERR);
        err = parse_node(rec, command);
        if (err != EC_SYNTAX_OK)
            return (err);
        cmds->inside_node_block++;
        break;
    case TOK_ENDNODE:
        /* Check for ENDNODE outside of TABLE, ROW */
        if ((cmds->inside_table_block != 0) ||
            (cmds->inside_row_block != 0))
            return (EC_SYNTAX_ERR);
        cmds->inside_node_block--;
        err = EC_SYNTAX_OK;
        break;
    case TOK_PROP:
        /* Check if inside TABLE, but not in ROW */
        if ((cmds->inside_table_block != 0) &&
            (cmds->inside_row_block == 0))
            return (EC_SYNTAX_ERR);
        err = parse_prop(rec, command);
        if (err != EC_SYNTAX_OK)
            return (err);
        if (cmds->inside_row_block) {
            cmds->commands[cmds->current_row].rowcmd_nproph++;
        }
        break;
    case TOK_REFNODE:
        err = parse_refnode(rec, command);
        if (err != EC_SYNTAX_OK)
            return (err);
        break;
    case TOK_REFPROP:
        /* Check if inside TABLE, but not in ROW */
        if ((cmds->inside_table_block != 0) &&
            (cmds->inside_row_block == 0))
            return (EC_SYNTAX_ERR);
        err = parse_refprop(rec, command);
        if (err != EC_SYNTAX_OK)
            return (err);
        if (cmds->inside_row_block) {
            cmds->commands[cmds->current_row].rowcmd_nproph++;
        }
        break;
    case TOK_TABLE:
        /* Table/Row supported in version 1.1 and above */
        if (cmds->version_no < (float)SUPPORTED_VERSION_NUM)
            return (EC_UNSUPPORTED);
        if (cmds->inside_table_block != 0)
            return (EC_SYNTAX_ERR);
        err = parse_table(rec, command);
        if (err != EC_SYNTAX_OK)
            return (err);
        cmds->inside_table_block = 1;
        break;
    case TOK_ENDTABLE:
        /* Check for ENDTABLE before TABLE */
        if (cmds->inside_table_block == 0)
            return (EC_SYNTAX_ERR);

        cmds->inside_table_block = 0;

        break;
    case TOK_ROW:
        /* Check for ROW outside of TABLE, ROW inside ROW */
        if ((cmds->inside_table_block == 0) ||
            (cmds->inside_row_block != 0))
            return (EC_SYNTAX_ERR);
        cmds->inside_row_block = 1;
        break;
    case TOK_ENDROW:
        /* Check for ENDROW outside of TABLE, ENDROW before ROW */
        if ((cmds->inside_table_block == 0) ||
            (cmds->inside_row_block == 0))
            return (EC_SYNTAX_ERR);
        else
            err = EC_SYNTAX_OK;

        cmds->inside_row_block = 0;

        /* error if row is empty */
        if (cmds->commands[cmds->current_row].rowcmd_nproph <= 0)
            return (EC_ROW_EMPTY);
        break;
    case TOK_VERBOSE:
        err = parse_verbose(cmds, rec, command);
        if (err != EC_SYNTAX_OK)
            return (err);
        break;
    default:    /* unsupported command */
        return (EC_SYNTAX_ERR);
    }

    command->type = id;
    return (EC_SYNTAX_OK);
}

/*
 * Check the syntax and save the tokens in the commands buffer
 */
static int
check_line_syntax(cmdbuf_t *cmds, char *buf)
{
    int     err;
    command_t   command;

    (void) memset(&command, 0, sizeof (command_t));
    err = parse_and_tokenize_line(cmds, buf, &command);
    if (err != EC_SYNTAX_OK)
        return (err);

    /*
     * don't add and count version command in the command buffer
     */
    if (command.type == TOK_VERSION)
        return (EC_SYNTAX_OK);

    /*
     * check if the commands buffer has been filled
     * If it is full, reallocate the buffer.
     */
    if (cmds->count == cmds->allocated) {
        cmds->commands = realloc(cmds->commands,
            sizeof (command_t) * (cmds->allocated + PER_ALLOC_COUNT));
        if (cmds->commands == NULL)
            return (EC_FAILURE);
        cmds->allocated += PER_ALLOC_COUNT;
    }

    cmds->commands[cmds->count] = command;  /* copy */

    /*
     * make a note of the row/endrow command, to keep track of # of props
     */
    if (command.type == TOK_ROW)
        cmds->current_row = cmds->count;

    if (command.type == TOK_ENDROW)
        cmds->current_row = 0;

    cmds->count++;

    return (EC_SYNTAX_OK);
}

/*
 * get the line control information
 * return 1 if it's the line control information, else return 0
 */
static int
get_line_control_info(char *buf, uint32_t *linenum, char *filename)
{
    char        *ptr;
    char        *last;
    uint32_t    num;
    char        *fname;
    char        *endptr;

    /* skip # and get next string */
    ptr = strtok_r(buf + 1, WHITESPACE, &last);
    if (ptr == NULL) {
        return (0);
    }

    num = strtoul(ptr, &endptr, 0);

    /*
     * It's not the line control information
     */
    if (endptr != (ptr + strlen(ptr))) {
        return (0);
    }

    /*
     * get the filename
     */

    /* get the beginning double quote */
    last = strchr(last, '"');
    if (last == NULL)
        return (0);

    last++;

    /* get the ending double quote */
    fname = strtok_r(last, DOUBLE_QUOTE, &last);
    if (fname == NULL)
        return (0);

    *linenum = num;
    (void) strlcpy(filename, fname, PATH_MAX);
    return (1);
}

/*
 * check the syntax of the configuration file
 */
static int
check_conffile_syntax(cmdbuf_t *cmds, FILE *fp)
{
    char        lbuf[RECORD_SIZE_MAX];
    char        buf[RECORD_SIZE_MAX];
    uint32_t    linenum;
    char        cppfile[PATH_MAX] = "";
    int     err = EC_SYNTAX_OK;

    linenum = 0;
    while (fgets(buf, sizeof (buf), fp) != NULL) {
        /*
         * get cpp line control information, if any
         */
        if (buf[0] == '#') {
            if (!get_line_control_info(buf, &linenum, cppfile))
                ++linenum;
            continue;
        }

        ++linenum;
        /*
         * skip line whose first char is a newline char
         */
        if (buf[0] == '\n') {
            continue;
        }

        if (err == EC_SYNTAX_OK)
            (void) strlcpy(lbuf, buf, RECORD_SIZE_MAX);
        else if (strlcat(lbuf, buf, RECORD_SIZE_MAX) >=
            RECORD_SIZE_MAX) {  /* buffer overflow */
            err = EC_FAILURE;
            break;
        }

        err = check_line_syntax(cmds, lbuf);
        if ((err != EC_INSUFFICIENT_TOKEN) && (err != EC_SYNTAX_OK))
            break;
    }

    if (err != EC_SYNTAX_OK) {
        if (cmds->verbose) {
            verbose_log(LOG_ERR, err_msg[err],
                cmds->fname, cppfile, linenum);
        }
        return (err);
    }

    /*
     * check if the version has been set
     */
    if (cmds->version_no > (float)SUPPORTED_VERSION_NUM) {
        if (cmds->verbose) {
            verbose_log(LOG_ERR, err_msg[EC_UNSUPPORTED],
                cmds->fname, cppfile, linenum);
        }
        return (EC_UNSUPPORTED);
    }

    /*
     * check if node and endnode command mismatch
     */
    if (cmds->inside_node_block != 0) {
        if (cmds->verbose) {
            verbose_log(LOG_ERR, err_msg[EC_NODE_MISMATCH],
                cmds->fname, cppfile, linenum);
        }
        return (EC_NODE_MISMATCH);
    }

    /*
     * check if row and endrow command mismatch
     */
    if (cmds->inside_row_block != 0) {
        if (cmds->verbose) {
            verbose_log(LOG_ERR, err_msg[EC_ROW_MISMATCH],
                cmds->fname, cppfile, linenum);
        }
        return (EC_ROW_MISMATCH);
    }

    /*
     * check if table and endtable command mismatch
     */
    if (cmds->inside_table_block != 0) {
        if (cmds->verbose) {
            verbose_log(LOG_ERR, err_msg[EC_TABLE_MISMATCH],
                cmds->fname, cppfile, linenum);
        }
        return (EC_TABLE_MISMATCH);
    }

    return (EC_SYNTAX_OK);
}

/*
 * If classpath/namepath given is not found in the picl tree,
 * skip the whole blocks until next valid classpath or namepath
 */
static void
skip_to_next_valid_path(cmdbuf_t *cmds, int starting_index,
    picl_nodehdl_t *parent, int *last_processed_index)
{
    int err;
    int index;

    for (index = starting_index; index < cmds->count; ++index) {
        switch (cmds->commands[index].type) {
        case TOK_CLASSPATH:
        case TOK_NAMEPATH:
            err = process_path(&cmds->commands[index], parent);
            if (err == PICL_SUCCESS) {
                *last_processed_index = index;
                return;
            }
        default:
            /* skipped this line */
            break;
        }
    }

    /* reach last command  */
    *last_processed_index = cmds->count - 1;
}

/*
 * Process the command buffer and return last command index and the new head of
 * the handle list
 */
static int
process_commands(cmdbuf_t *cmds, int starting_index, picl_nodehdl_t parent,
    int *last_processed_index)
{
    int     err;
    int     index;
    picl_nodehdl_t  rooth;
    picl_nodehdl_t  nodeh;
    command_t   *commands = cmds->commands;

    for (index = starting_index; index < cmds->count; ++index) {
        switch (commands[index].type) {
        case TOK_CLASSPATH:
        case TOK_NAMEPATH:
            err = process_path(&commands[index], &rooth);
            if (err != PICL_SUCCESS) {
                index++;
                (void) skip_to_next_valid_path(cmds, index,
                    &rooth, &index);
            }
            parent = rooth;
            continue;
        case TOK_NODE:
            err = process_node(&commands[index], parent, &nodeh);
            if (err == PICL_SUCCESS) {
                index++;
                err = process_commands(cmds, index, nodeh,
                    &index);
            }
            break;
        case TOK_ENDNODE:
            *last_processed_index = index;
            return (PICL_SUCCESS);
        case TOK_PROP:
            err =  process_prop(cmds, &commands[index], parent);
            break;
        case TOK_REFPROP:
            err = process_refprop(cmds, &commands[index], parent);
            /* no reference node */
            if (err == PICL_NOTNODE) {
                err = PICL_SUCCESS; /* discard prop */
                /* discard row by setting nproph = 0 */
                if (cmds->inside_row_block)
                    cmds->commands[cmds->current_row]
                        .rowcmd_nproph = 0;
            }
            break;
        case TOK_REFNODE:
            err =  process_refnode(&commands[index], parent);
            break;
        case TOK_TABLE:
            cmds->inside_table_block = 1;
            err = process_table(&commands[index], parent);
            cmds->current_tbl = index;
            break;
        case TOK_ENDTABLE:
            cmds->inside_table_block = 0;
            cmds->current_tbl = 0;
            break;
        case TOK_ROW:
            cmds->inside_row_block = 1;
            err = process_row(&commands[index]);
            cmds->current_row = index;
            break;
        case TOK_ENDROW:
            err = process_endrow(cmds);
            cmds->inside_row_block = 0;
            cmds->current_row = 0;
            break;
        case TOK_VERBOSE:
            err = process_verbose(cmds, &commands[index]);
            break;
        default:    /* won't reach here */
            err =  PICL_FAILURE;
            break;
        }

        if ((err != PICL_SUCCESS) && (err != PICL_PROPEXISTS)) {
            *last_processed_index = index;
            return (err);
        }
    }

    /* reach last command */
    *last_processed_index = cmds->count - 1;
    return (PICL_SUCCESS);
}

/*
 * clean up the commands buffer
 */
static void
clean_up(cmdbuf_t *cmds)
{
    int cmd_index;

    for (cmd_index = 0; cmd_index < cmds->count; cmd_index++) {
        switch (cmds->commands[cmd_index].type) {
        case TOK_CLASSPATH:
        case TOK_NAMEPATH:
            free_path(&cmds->commands[cmd_index]);
            break;
        case TOK_NODE:
            free_node(&cmds->commands[cmd_index]);
            break;
        case TOK_PROP:
            free_prop(&cmds->commands[cmd_index]);
            break;
        case TOK_REFPROP:
            free_refprop(&cmds->commands[cmd_index]);
            break;
        case TOK_REFNODE:
            free_refnode(&cmds->commands[cmd_index]);
            break;
        case TOK_TABLE:
            free_table(&cmds->commands[cmd_index]);
            break;
        case TOK_ENDTABLE:
        case TOK_ROW:
        case TOK_ENDROW:
        case TOK_ENDNODE:
        case TOK_VERBOSE:
        default:
            break;
        }
    }
    if (cmds->commands)
        free(cmds->commands);
}

/*
 * Parse the configuration file and create nodes/properties under nh
 *
 * It checks the syntax first.  If there is any syntax error,
 * it returns 1 and won't continue processing the file to add nodes or props.
 *
 * If any error happens during command processing, all nodes
 * and properties just created will be deleted, i.e. undo
 * commands which have been processed.  It returns 1.
 *
 * If success, return 0.
 */
int
picld_pluginutil_parse_config_file(picl_nodehdl_t nh, const char *filename)
{
    FILE        *ifp;
    int     last_processed_index;
    int     err;
    cmdbuf_t    *cmds;

    /* set correct locale for use inside pluginutil */
    setlocale(LC_ALL, "C");

    /*
     * Initialize the command buffer
     */

    cmds = malloc(sizeof (*cmds));
    if (cmds == NULL) {
        setlocale(LC_ALL, "");
        return (1);
    }

    memset(cmds, 0, sizeof (cmdbuf_t));

    cmds->fname = filename;

    ifp = fopen(filename, "r");
    if (ifp == NULL) {
        setlocale(LC_ALL, "");
        free(cmds);
        return (1);
    }

    /*
     * check the syntax of the configuration file
     */
    err = check_conffile_syntax(cmds, ifp);

    (void) fclose(ifp);

    if (err != EC_SYNTAX_OK) {
        clean_up(cmds);
        free(cmds);
        setlocale(LC_ALL, "");
        return (1);
    }

    /*
     * Process the commands
     */
    err = process_commands(cmds, STARTING_INDEX, nh, &last_processed_index);

    /*
     * If any PICL error, remove the newly created node/prop
     * handles from the PICL tree.
     */
    if (err != PICL_SUCCESS) {
        undo_commands(cmds, last_processed_index);
        if (cmds->verbose)
            verbose_log(LOG_ERR, err_msg[EC_PICL_ERR], filename,
                err);
    }

    clean_up(cmds);
    free(cmds);

    /* reset the locale */
    setlocale(LC_ALL, "");

    return ((err == PICL_SUCCESS) ? 0 : 1);
}