/*
 * 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 2010 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include <strings.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <strings.h>
#include <note.h>
#include <errno.h>
#include <sys/mdesc.h>
#include <sys/mdesc_impl.h>
#include <sys/sysmacros.h>
#include "mdesc_mutable.h"

static void md_free_prop(mmd_t *mdp, md_prop_t *propp);
static void md_free_string(mmd_t *mdp, md_string_t *msp);
static void md_free_data_block(mmd_t *mdp, md_data_block_t *mdbp);

static uint32_t
md_byte_hash(uint8_t *bp, int len)
{
        uint32_t hash = 0;
        int i;

        for (i = 0; i < len; i++) {
                /* 5 bit rotation */
                hash = (hash >> 27) | (hash << 5) | bp[i];
        }

        return (hash);
}

static md_string_t *
md_find_string(mmd_t *mdp, char *strp, uint32_t *hashp)
{
        md_string_t *msp;
        uint32_t hash;

        hash = md_byte_hash((uint8_t *)strp, strlen(strp));

        if (hashp != NULL)
                *hashp = hash;

        CHAIN_ITER(mdp->string_list, msp) {
                if (msp->hash == hash && strcmp(msp->strp, strp) == 0)
                        return (msp);
        }

        return (NULL);
}

static md_string_t *
md_new_string(mmd_t *mdp, char *strp)
{
        md_string_t *msp;
        uint32_t hash;

        msp = md_find_string(mdp, strp, &hash);
        if (msp == NULL) {
                msp = calloc(1, sizeof (md_string_t));
                if (msp == NULL)
                        return (NULL);
                msp->strp = strdup(strp);
                if (msp->strp == NULL) {
                        free(msp);
                        return (NULL);
                }
                msp->size = strlen(strp) + 1;
                msp->hash = hash;
                msp->ref_cnt = 0;
                msp->build_offset = MD_OFFSET_UNDEF;
                CHAIN_ADD(mdp->string_list, msp);
        }
        msp->ref_cnt++;

        return (msp);
}

static md_data_block_t *
md_find_data_block(mmd_t *mdp, uint8_t *datap, int len, uint32_t *hashp)
{
        md_data_block_t *dbp;
        uint32_t hash;

        hash = md_byte_hash(datap, len);

        if (hashp != NULL)
                *hashp = hash;

        CHAIN_ITER(mdp->data_block_list, dbp) {
                if (dbp->size == len &&
                    dbp->hash == hash && bcmp(dbp->datap, datap, len) == 0)
                        return (dbp);
        }

        return (NULL);
}

static md_data_block_t *
md_new_data_block(mmd_t *mdp, uint8_t *bufp, int len)
{
        md_data_block_t *dbp;
        uint32_t        hash;

        dbp = md_find_data_block(mdp, bufp, len, &hash);
        if (dbp == NULL) {
                dbp = calloc(1, sizeof (md_data_block_t));
                if (dbp == NULL)
                        return (NULL);
                dbp->datap = malloc(len);
                if (dbp->datap == NULL) {
                        free(dbp);
                        return (NULL);
                }
                (void) memcpy(dbp->datap, bufp, len);
                dbp->size = len;
                dbp->hash = hash;
                dbp->ref_cnt = 0;
                dbp->build_offset = MD_OFFSET_UNDEF;
                CHAIN_ADD(mdp->data_block_list, dbp);
        }
        dbp->ref_cnt++;

        return (dbp);
}

md_node_t *
md_new_node(mmd_t *mdp, char *sp)
{
        md_node_t *nodep;

        nodep = calloc(1, sizeof (md_node_t));
        if (nodep == NULL)
                return (NULL);
        nodep->typep = md_new_string(mdp, sp);
        if (nodep->typep == NULL) {
                free(nodep);
                return (NULL);
        }
        CHAIN_ADD(mdp->node_list, nodep);

        return (nodep);
}

static md_prop_t *
md_new_property(mmd_t *mdp, md_node_t *nodep, uint8_t type, char *sp)
{
        md_prop_t *propp;

        propp = calloc(1, sizeof (md_prop_t));
        if (propp == NULL)
                return (NULL);
        propp->type = type;
        propp->sp = md_new_string(mdp, sp);
        if (propp->sp == NULL) {
                free(propp);
                return (NULL);
        }

        CHAIN_ADD(nodep->prop_list, propp);

        return (propp);
}

int
md_add_value_property(mmd_t *mdp, md_node_t *nodep, char *sp, uint64_t value)
{
        md_prop_t *propp;

        propp = md_new_property(mdp, nodep, MDET_PROP_VAL, sp);
        if (propp == NULL)
                return (ENOMEM);
        propp->d.value = value;
        return (0);
}

int
md_add_string_property(mmd_t *mdp, md_node_t *nodep, char *sp, char *bufp)
{
        md_prop_t *propp;
        md_data_block_t *dbp;

        dbp = md_new_data_block(mdp, (uint8_t *)bufp, strlen(bufp) + 1);
        if (dbp == NULL)
                return (ENOMEM);
        propp = md_new_property(mdp, nodep, MDET_PROP_STR, sp);
        if (propp == NULL) {
                md_free_data_block(mdp, dbp);
                return (ENOMEM);
        }
        propp->d.dbp = dbp;
        return (0);
}

int
md_add_data_property(mmd_t *mdp, md_node_t *nodep, char *sp, int len,
    uint8_t *bufp)
{
        md_prop_t *propp;
        md_data_block_t *dbp;

        dbp = md_new_data_block(mdp, bufp, len);
        if (dbp == NULL)
                return (ENOMEM);

        propp = md_new_property(mdp, nodep, MDET_PROP_DAT, sp);
        if (propp == NULL) {
                md_free_data_block(mdp, dbp);
                return (ENOMEM);
        }
        propp->d.dbp = dbp;
        return (0);
}

static int
md_add_arc_property(mmd_t *mdp, md_node_t *nodep, char *arcnamep,
    md_node_t *tgtnodep)
{
        md_prop_t *propp;

        propp = md_new_property(mdp, nodep, MDET_PROP_ARC, arcnamep);
        if (propp == NULL)
                return (ENOMEM);
        propp->d.arc.is_ptr = B_TRUE;
        propp->d.arc.val.nodep = tgtnodep;
        return (0);
}

md_node_t *
md_link_new_node(mmd_t *mdp, char *nodenamep, md_node_t *parentnodep,
    char *linktonewp, char *linkbackp)
{
        md_node_t *nodep;

        nodep = md_new_node(mdp, nodenamep);
        if (nodep == NULL)
                return (NULL);

        ASSERT(linktonewp != NULL);
        ASSERT(parentnodep != NULL && !parentnodep->deleted);

        if (md_add_arc_property(mdp, parentnodep, linktonewp, nodep) != 0) {
                return (NULL);
        }

        if (linkbackp != NULL) {
                if (md_add_arc_property(mdp,
                    nodep, linkbackp, parentnodep) != 0) {
                        return (NULL);
                }
        }

        return (nodep);
}

void
md_destroy(mmd_t *mdp)
{
        md_node_t *nodep;

        for (nodep = CHAIN_START(mdp->node_list); nodep != NULL; ) {
                md_node_t *tmp_nodep;

                tmp_nodep = nodep->nextp;
                md_free_node(mdp, nodep);

                nodep = tmp_nodep;
        }

        /* should have deleted all the string refs by here */
        ASSERT(CHAIN_LENGTH(mdp->string_list) == 0);
        free(mdp);
}

void
md_free_node(mmd_t *mdp, md_node_t *nodep)
{
        md_prop_t *propp;

        if (nodep->typep != NULL)
                md_free_string(mdp, nodep->typep);

        for (propp = CHAIN_START(nodep->prop_list); propp != NULL; ) {
                md_prop_t *tmp_propp;

                tmp_propp = propp->nextp;
                md_free_prop(mdp, propp);

                propp = tmp_propp;
        }

        free(nodep);
}

static void
md_free_prop(mmd_t *mdp, md_prop_t *propp)
{
        if (propp->sp != NULL)
                md_free_string(mdp, propp->sp);

        switch (propp->type) {
        case MDET_PROP_VAL:
                break;

        case MDET_PROP_ARC:
                break;

        case MDET_PROP_STR:
        case MDET_PROP_DAT:
                md_free_data_block(mdp, propp->d.dbp);
                break;

        default:
                ASSERT(B_FALSE);
        }

        free(propp);
}

static void
md_free_string(mmd_t *mdp, md_string_t *msp)
{
        ASSERT(msp->ref_cnt > 0);

        msp->ref_cnt--;

        if (msp->ref_cnt == 0) {
                free(msp->strp);
                mdp->string_list.startp = msp->nextp;
                free(msp);
        }
}

static void
md_free_data_block(mmd_t *mdp, md_data_block_t *mdbp)
{
        ASSERT(mdbp->ref_cnt > 0);

        mdbp->ref_cnt--;

        if (mdbp->ref_cnt == 0) {
                free(mdbp->datap);
                mdp->data_block_list.startp = mdbp->nextp;
                free(mdbp);
        }
}

mmd_t *
md_new_md(void)
{
        return ((mmd_t *)calloc(1, sizeof (mmd_t)));
}

static void
md_fix_name(md_element_t *mdep, md_prop_t *propp)
{
        mdep->name_len = htomd8(propp->sp->size - 1);
        mdep->name_offset = htomd32(propp->sp->build_offset);
}

void
create_mde(md_element_t *mdep, int type, md_node_t *nodep, md_prop_t *propp)
{
        (void) memset(mdep, 0, MD_ELEMENT_SIZE);
        mdep->tag = htomd8(type);

        switch (type) {
        case MDET_NODE:
                mdep->d.prop_idx = htomd32(nodep->next_index);
                mdep->name_len = htomd8(nodep->typep->size - 1);
                mdep->name_offset = htomd32(nodep->typep->build_offset);
                break;

        case MDET_PROP_ARC:
                ASSERT(propp->d.arc.is_ptr);
                mdep->d.prop_idx = htomd64(propp->d.arc.val.nodep->build_index);
                md_fix_name(mdep, propp);
                break;

        case MDET_PROP_VAL:
                mdep->d.prop_val = htomd64(propp->d.value);
                md_fix_name(mdep, propp);
                break;

        case MDET_PROP_STR:
        case MDET_PROP_DAT:
                mdep->d.prop_data.offset = htomd32(propp->d.dbp->build_offset);
                mdep->d.prop_data.len = htomd32(propp->d.dbp->size);
                md_fix_name(mdep, propp);
                break;

        case MDET_NULL:
        case MDET_NODE_END:
        case MDET_LIST_END:
                break;

        default:
                ASSERT(B_FALSE);
        }
}

int
md_gen_bin(mmd_t *mdp, uint8_t **bufvalp)
{
        uint32_t offset;
        md_node_t *nodep;
        md_data_block_t *mdbp;
        md_string_t *msp;
        md_header_t *mdhp;
        md_element_t *mdep;
        uint32_t strings_size;
        uint32_t data_block_size;
        int total_size;
        uint8_t *bufferp;
        uint8_t *string_bufferp;
        uint8_t *data_block_bufferp;

        /*
         * Skip through strings to compute offsets.
         */
        offset = 0;
        for (msp = CHAIN_START(mdp->string_list); msp != NULL;
            msp = msp->nextp) {
                msp->build_offset = offset;
                offset += msp->size;
        }
        strings_size = P2ROUNDUP(offset, MD_ALIGNMENT_SIZE);

        /*
         * Skip through data blocks to compute offsets.
         */

        offset = 0;
        for (mdbp = CHAIN_START(mdp->data_block_list); mdbp != NULL;
            mdbp = mdbp->nextp) {
                mdbp->build_offset = offset;
                offset += mdbp->size;
                offset = P2ROUNDUP(offset, MD_ALIGNMENT_SIZE);
        }
        data_block_size = P2ROUNDUP(offset, MD_ALIGNMENT_SIZE);

        /*
         * Compute the MD elements required to build the element list.
         * For each node there is a node start and end, and one
         * element for each property.
         */

        offset = 0;
        for (nodep = CHAIN_START(mdp->node_list); nodep != NULL;
            nodep = nodep->nextp) {
                nodep->build_index = offset;
                offset += 2 + CHAIN_LENGTH(nodep->prop_list);
                nodep->next_index = offset;
        }
        offset += 1;    /* add the LIST_END element */

        total_size = MD_HEADER_SIZE + offset * MD_ELEMENT_SIZE +
            strings_size + data_block_size;

        /*
         * Allocate output buffer.
         */

        bufferp = calloc(total_size, sizeof (uint8_t));
        if (bufferp == NULL)
                return (0);

        /* LINTED */
        mdhp = (md_header_t *)bufferp;

        string_bufferp = bufferp + MD_HEADER_SIZE + offset * MD_ELEMENT_SIZE;
        data_block_bufferp = string_bufferp + strings_size;

        mdhp->transport_version = htomd32(MD_TRANSPORT_VERSION);
        mdhp->node_blk_sz = htomd32(offset * MD_ELEMENT_SIZE);
        mdhp->name_blk_sz = htomd32(strings_size);
        mdhp->data_blk_sz = htomd32(data_block_size);

        /*
         * Build the element list.
         * For each node there is a node start and end, and one
         * element for each property.
         */

        offset = 0;
        /* LINTED */
        mdep = (md_element_t *)(bufferp + MD_HEADER_SIZE);
        for (nodep = CHAIN_START(mdp->node_list); nodep != NULL;
            nodep = nodep->nextp) {
                md_prop_t *propp;

                create_mde(mdep, MDET_NODE, nodep, NULL);
                mdep++;

                for (propp = CHAIN_START(nodep->prop_list); propp != NULL;
                    propp = propp->nextp) {
                        create_mde(mdep, propp->type, nodep, propp);
                        mdep++;
                }

                create_mde(mdep, MDET_NODE_END, NULL, NULL);
                mdep++;
        }

        create_mde(mdep, MDET_LIST_END, NULL, NULL);
        mdep++;

        /*
         * Quick sanity check.
         */

        ASSERT(((uint8_t *)mdep) == ((uint8_t *)string_bufferp));

        /*
         * Skip through strings and stash them..
         */

        offset = 0;
        for (msp = CHAIN_START(mdp->string_list); msp != NULL;
            msp = msp->nextp) {
                (void) memcpy(string_bufferp + msp->build_offset, msp->strp,
                    msp->size);
        }

        /*
         * Skip through data blocks and stash them.
         */

        offset = 0;
        for (mdbp = CHAIN_START(mdp->data_block_list); mdbp != NULL;
            mdbp = mdbp->nextp) {
                (void) memcpy(data_block_bufferp + mdbp->build_offset,
                    mdbp->datap, mdbp->size);
        }

        *bufvalp = bufferp;
        return (total_size);
}