dmake: do not set MAKEFLAGS=k

[unleashed/tickless.git] / usr / src / cmd / picl / plugins / sun4u / blade / fruaccess / fru_access.c

/*
 * 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 <limits.h>
#include <alloca.h>
#include "fru_access_impl.h"

#pragma init(initialize_fruaccess)      /* .init section */

static  hash_obj_t      *hash_table[TABLE_SIZE];

/*
 * seeprom is the driver_name for the SEEPROM device drivers in excalibur
 * Define the devfsadm command to load the seeprom drivers if open fails.
 */

static  char    devfsadm_cmd[] = "/usr/sbin/devfsadm -i seeprom";

/* this routine initialize the hash table. */

static void
initialize_fruaccess(void)
{
        int     count;
        for (count = 0; count < TABLE_SIZE; count++) {
                hash_table[count] = NULL;
        }
}

/*
 * called to lookup hash object for specified handle in the hash table.
 *
 */

static hash_obj_t *
lookup_handle_object(handle_t   handle, int object_type)
{
        handle_t        index_to_hash;
        hash_obj_t      *first_hash_obj;
        hash_obj_t      *next_hash_obj;

        index_to_hash   = (handle % TABLE_SIZE);

        first_hash_obj = hash_table[index_to_hash];
        for (next_hash_obj = first_hash_obj; next_hash_obj != NULL;
                                next_hash_obj = next_hash_obj->next) {
                if ((handle == next_hash_obj->obj_hdl) &&
                                (object_type == next_hash_obj->object_type)) {
                                return (next_hash_obj);
                }
        }
        return (NULL);
}

/* called to allocate container hash object */

static hash_obj_t *
create_container_hash_object(void)
{
        hash_obj_t              *hash_obj;
        container_obj_t         *cont_obj;

        cont_obj        = malloc(sizeof (container_obj_t));
        if (cont_obj == NULL) {
                return (NULL);
        }

        hash_obj = malloc(sizeof (hash_obj_t));
        if (hash_obj == NULL) {
                free(cont_obj);
                return (NULL);
        }

        cont_obj->sec_obj_list  = NULL;

        hash_obj->object_type   = CONTAINER_TYPE;
        hash_obj->u.cont_obj    = cont_obj;
        hash_obj->next  = NULL;
        hash_obj->prev  = NULL;

        return (hash_obj);
}

/* called to allocate section hash object */

static hash_obj_t *
create_section_hash_object(void)
{
        hash_obj_t              *hash_obj;
        section_obj_t           *sec_obj;

        sec_obj = malloc(sizeof (section_obj_t));
        if (sec_obj == NULL) {
                return (NULL);
        }

        hash_obj = malloc(sizeof (hash_obj_t));
        if (hash_obj == NULL) {
                free(sec_obj);
                return (NULL);
        }

        sec_obj->next           = NULL;
        sec_obj->seg_obj_list   = NULL;

        hash_obj->u.sec_obj     = sec_obj;
        hash_obj->object_type   = SECTION_TYPE;
        hash_obj->next          = NULL;
        hash_obj->prev          = NULL;

        return (hash_obj);
}

/* called to allocate segment hash object */

static hash_obj_t *
create_segment_hash_object(void)
{
        hash_obj_t              *hash_obj;
        segment_obj_t           *seg_obj;

        seg_obj = malloc(sizeof (segment_obj_t));
        if (seg_obj == NULL) {
                return (NULL);
        }

        hash_obj = malloc(sizeof (hash_obj_t));
        if (hash_obj == NULL) {
                free(seg_obj);
                return (NULL);
        }

        seg_obj->next           = NULL;
        seg_obj->pkt_obj_list   = NULL;

        hash_obj->object_type   = SEGMENT_TYPE;
        hash_obj->u.seg_obj     = seg_obj;
        hash_obj->next          = NULL;
        hash_obj->prev          = NULL;

        return (hash_obj);
}

/* called to allocate packet hash object */

static hash_obj_t *
create_packet_hash_object(void)
{
        hash_obj_t              *hash_obj;
        packet_obj_t            *pkt_obj;

        pkt_obj = malloc(sizeof (packet_obj_t));
        if (pkt_obj == NULL) {
                return (NULL);
        }

        hash_obj        = malloc(sizeof (hash_obj_t));
        if (hash_obj == NULL) {
                free(pkt_obj);
                return (NULL);
        }

        pkt_obj->next           = NULL;

        hash_obj->object_type   = PACKET_TYPE;
        hash_obj->u.pkt_obj     = pkt_obj;
        hash_obj->next          = NULL;
        hash_obj->prev          = NULL;

        return (hash_obj);
}

/* called to add allocated hash object into the hash table */

static void
add_hashobject_to_hashtable(hash_obj_t *hash_obj)
{
        handle_t                index_to_hash;
        static  uint64_t        handle_count    = 0;

        hash_obj->obj_hdl = ++handle_count;     /* store the handle */

        /* where to add ? */
        index_to_hash   = ((hash_obj->obj_hdl) % TABLE_SIZE);

        hash_obj->next  = hash_table[index_to_hash];
        hash_table[index_to_hash] = hash_obj;   /* hash obj. added */

        if (hash_obj->next != NULL) {
                hash_obj->next->prev = hash_obj;
        }
}

/* called to add section object list into the section list */

static void
add_to_sec_object_list(hash_obj_t *parent_obj, hash_obj_t *child_obj)
{
        hash_obj_t      *next_hash;

        child_obj->u.sec_obj->cont_hdl = parent_obj->obj_hdl;
        if (parent_obj->u.cont_obj->sec_obj_list == NULL) {
                parent_obj->u.cont_obj->sec_obj_list = child_obj;
                return;
        }

        for (next_hash = parent_obj->u.cont_obj->sec_obj_list;
                        next_hash->u.sec_obj->next != NULL;
                        next_hash = next_hash->u.sec_obj->next) {
                ;
        }

        next_hash->u.sec_obj->next      = child_obj;
}

/* called to add segment object list into segment list */

static void
add_to_seg_object_list(hash_obj_t *parent_obj, hash_obj_t *child_obj)
{
        hash_obj_t      *next_hash;

        child_obj->u.seg_obj->section_hdl = parent_obj->obj_hdl;
        if (parent_obj->u.sec_obj->seg_obj_list == NULL) {
                parent_obj->u.sec_obj->seg_obj_list = child_obj;
                return;
        }

        for (next_hash = parent_obj->u.sec_obj->seg_obj_list;
                        next_hash->u.seg_obj->next != NULL;
                        next_hash = next_hash->u.seg_obj->next) {
                ;
        }

        next_hash->u.seg_obj->next      = child_obj;
}

/* called to add packet object list into packet list */

static void
add_to_pkt_object_list(hash_obj_t *parent_obj, hash_obj_t *child_obj)
{
        hash_obj_t      *next_hash;

        /* add the packet object in the end of list */
        child_obj->u.pkt_obj->segment_hdl = parent_obj->obj_hdl;

        if (parent_obj->u.seg_obj->pkt_obj_list == NULL) {
                parent_obj->u.seg_obj->pkt_obj_list = child_obj;
                return;
        }

        for (next_hash = parent_obj->u.seg_obj->pkt_obj_list;
                        next_hash->u.pkt_obj->next != NULL;
                        next_hash = next_hash->u.pkt_obj->next) {
                        ;
        }

        next_hash->u.pkt_obj->next = child_obj;
}

static void
copy_segment_layout(segment_t   *seghdr, void   *layout)
{
        segment_layout_t        *seg_layout;

        seg_layout      = (segment_layout_t *)layout;
        (void) memcpy(seghdr->name, &seg_layout->name, SEG_NAME_LEN);
        seghdr->descriptor = GET_SEGMENT_DESCRIPTOR;
        seghdr->offset  = seg_layout->offset;
        seghdr->length  = seg_layout->length;
}

static hash_obj_t *
get_container_hash_object(int   object_type, handle_t   handle)
{
        hash_obj_t      *hash_obj;

        switch (object_type) {
        case    CONTAINER_TYPE  :
                break;
        case    SECTION_TYPE    :
                hash_obj = lookup_handle_object(handle, CONTAINER_TYPE);
                if (hash_obj == NULL) {
                        return (NULL);
                }
                break;
        case    SEGMENT_TYPE    :
                hash_obj = lookup_handle_object(handle, SECTION_TYPE);
                if (hash_obj == NULL) {
                        return (NULL);
                }
                hash_obj = lookup_handle_object(hash_obj->u.sec_obj->cont_hdl,
                                                        CONTAINER_TYPE);
                break;
        case    PACKET_TYPE     :
                break;
        default :
                return (NULL);
        }
        return (hash_obj);
}


static void
sort_offsettbl(int      segcnt, seg_info_t      *offset_tbl)
{
        int             cntx;
        int             cnty;
        seg_info_t      tmp;

        for (cntx = 0; cntx < segcnt+2; cntx++) {
                for (cnty = cntx+1; cnty < segcnt + 2; cnty++) {
                        if (offset_tbl[cntx].offset >
                                        offset_tbl[cnty].offset) {
                                (void) memcpy(&tmp, &offset_tbl[cnty],
                                                sizeof (seg_info_t));
                                (void) memcpy(&offset_tbl[cnty],
                                &offset_tbl[cntx], sizeof (seg_info_t));

                                (void) memcpy(&offset_tbl[cntx], &tmp,
                                                sizeof (seg_info_t));
                        }
                }
        }
}

/*
 * Description : move_segment_data() reads the segment data and writes it
 *      back to the new segment offset.
 */

static void
move_segment_data(void *seghdr, int newoffset, container_hdl_t contfd)
{
        int                     ret;
        char                    *buffer;
        segment_layout_t        *segment;

        segment = (segment_layout_t *)seghdr;

        buffer = alloca(segment->length);
        if (buffer == NULL) {
                return;
        }

        ret = pread(contfd, buffer,
                        segment->length, segment->offset);
        if (ret != segment->length) {
                return;
        }

        segment->offset = newoffset;

        ret = pwrite(contfd, buffer, segment->length, segment->offset);
        if (ret != segment->length) {
                return;
        }
}

/*
 * Description : pack_segment_data() moves the segment data if there is
 *              a hole between two segments.
 */

static void
pack_segment_data(char *seghdr, int segcnt, container_hdl_t contfd,
                                                seg_info_t *offset_tbl)
{
        int     cnt;
        int     diff;
        int     newoffset;

        for (cnt = segcnt + 1; cnt > 0; cnt--) {
                if (!offset_tbl[cnt - 1].fixed) {
                        if (offset_tbl[cnt].offset
                                - (offset_tbl[cnt -1 ].offset
                                        + offset_tbl[cnt - 1].length) > 0) {

                                diff = offset_tbl[cnt].offset -
                                        (offset_tbl[cnt - 1].offset
                                        + offset_tbl[cnt - 1].length);
                                newoffset = offset_tbl[cnt - 1].offset
                                                                + diff;

                                move_segment_data(seghdr, newoffset,
                                                                contfd);

                                offset_tbl[cnt - 1].offset = newoffset;

                                sort_offsettbl(segcnt, offset_tbl);
                        }
                }
        }
}

/*
 * Description : build_offset_tbl() builds the offset table by reading all the
 *              segment header. it makes two more entry into the table one for
 *              section size and another with start of the section after the
 *              segment header.
 */

static int
build_offset_tbl(void   *seghdr, int segcnt, int secsize,
                                                seg_info_t *offset_tbl)
{
        int                     cnt;
        fru_segdesc_t           segdesc;
        segment_layout_t        *segment;

        for (cnt = 0; cnt < segcnt; cnt++) {
                segment = (segment_layout_t *)(seghdr) + cnt;

                (void) memcpy(&segdesc, &segment->descriptor,
                                                sizeof (uint32_t));
                offset_tbl[cnt].segnum = cnt;
                offset_tbl[cnt].offset = segment->offset;
                offset_tbl[cnt].length = segment->length;
                offset_tbl[cnt].fixed = segdesc.field.fixed;
        }

        /* upper boundary of segment area (lower address bytes) */
        offset_tbl[cnt].segnum = -1;
        offset_tbl[cnt].offset = sizeof (section_layout_t) + ((cnt + 1)
                                        * sizeof (segment_layout_t));

        offset_tbl[cnt].length = 0;
        offset_tbl[cnt].fixed  = 1;
        /* lower boundary of segment area (higher address bytes) */

        offset_tbl[cnt+1].segnum = -1;
        offset_tbl[cnt+1].offset = secsize;
        offset_tbl[cnt+1].length = 0;
        offset_tbl[cnt+1].fixed = 1;
        return (0);
}

static int
hole_discovery(int bytes, int segcnt, int *totsize, seg_info_t *offset_tbl)
{
        int cnt = 0;

        *totsize = 0;
        for (cnt = segcnt + 1; cnt > 0; cnt--) {
                if (bytes <= offset_tbl[cnt].offset -
                                (offset_tbl[cnt - 1].offset +
                                        offset_tbl[cnt - 1].length)) {
                        return (offset_tbl[cnt].offset - bytes);
                }

                *totsize += offset_tbl[cnt].offset -
                                (offset_tbl[cnt - 1].offset +
                                        offset_tbl[cnt - 1].length);
        }
        return (0);
}


/*
 * Description : segment_hdr_present() verify space for new segment header to
 *              be added.
 */

static int
segment_hdr_present(int segoffset, int size, seg_info_t *offset_tbl)
{
        if ((segoffset + size) <= offset_tbl[0].offset)
                return (0);
        else
                return (-1);
}

/*
 * Description : find_offset() is called from fru_add_segment routine to find
 *              a valid offset.
 */

static int
find_offset(char *seghdr, int segcnt, int secsize, int *sectionoffset,
                int segsize, int fix, container_hdl_t contfd)
{
        int             ret;
        int             newoffset;
        int             totsize = 0;
        seg_info_t      *offset_tbl;

        if (segcnt == 0) {
                if (!fix) {     /* if not fixed segment */
                        *sectionoffset = secsize - segsize;
                }
                return (0);
        }

        /*
         * two extra segment info structure are allocated for start of segment
         * and other end of segment. first segment offset is first available
         * space and length is 0. second segment offset is is segment length and
         * offset is 0. build_offset_tbl() explains how upper boundary and lower
         * boudary segment area are initialized in seg_info_t table.
         */

        offset_tbl    = malloc((segcnt + 2) * sizeof (seg_info_t));
        if (offset_tbl == NULL) {
                return (-1);
        }

        /* read all the segment header to make offset table */
        ret = build_offset_tbl(seghdr, segcnt, secsize, offset_tbl);
        if (ret != 0) {
                free(offset_tbl);
                return (-1);
        }

        /* sort the table */
        sort_offsettbl(segcnt, offset_tbl);

        /* new segment header offset */
        newoffset = sizeof (section_layout_t) + segcnt *
                                                sizeof (segment_layout_t);

        /* do? new segment header overlap any existing data */
        ret = segment_hdr_present(newoffset, sizeof (segment_layout_t),
                                                                offset_tbl);
        if (ret != 0) { /* make room for new segment if possible */

        /* look for hole in order to move segment data */
                if (offset_tbl[0].fixed == SEGMENT_FIXED) { /* fixed segment */
                        free(offset_tbl);
                        return (-1);
                }

                newoffset = hole_discovery(offset_tbl[0].length,
                                        segcnt, &totsize, offset_tbl);
                if (newoffset != 0) { /* found new offset */
                                /* now new offset */
                        offset_tbl[0].offset = newoffset;

                        /* move the segment data */
                        move_segment_data(seghdr, newoffset, contfd);
                        /* again sort the offset table */
                        sort_offsettbl(segcnt, offset_tbl);
                } else {
                        /* pack the existing hole */
                        if (totsize > offset_tbl[0].length) {
                                pack_segment_data(seghdr, segcnt,
                                                        contfd, offset_tbl);
                        } else {
                                free(offset_tbl);
                                return (-1);
                        }
                }
        }

        totsize = 0;
        newoffset = hole_discovery(segsize, segcnt, &totsize, offset_tbl);

        if (newoffset == 0) { /* No hole found */
                if (totsize >= segsize) {
                        pack_segment_data(seghdr, segcnt, contfd,
                                                                offset_tbl);
                        newoffset = hole_discovery(segsize, segcnt,
                                                        &totsize, offset_tbl);
                        if (newoffset != 0) {
                                *sectionoffset = newoffset;
                                free(offset_tbl);
                                return (0);
                        }
                }
        } else {
                *sectionoffset = newoffset;
                free(offset_tbl);
                return (0);
        }
        free(offset_tbl);
        return (-1);
}

static char *
tokenizer(char *buf, char *separator, char **nextBuf, char *matched)
{
        int i = 0;
        int j = 0;

        for (i = 0; buf[i] != '\0'; i++) {
                for (j = 0; j < strlen(separator); j++) {
                        if (buf[i] == separator[j]) {
                                buf[i] = '\0';
                                *nextBuf = &(buf[i+1]);
                                *matched = separator[j];
                                return (buf);
                        }
                }
        }

        *nextBuf = buf;
        *matched = '\0';
        return (NULL);
}

static int
get_container_info(const char *def_file, const char *cont_desc_str,
                                                container_info_t *cont_info)
{
        char    *item;
        char    *token;
        char    *field;
        char    matched;
        char    buf[1024];
        int     foundIt = 0;
        FILE    *file = fopen(def_file, "r");

        if (file == NULL)
                return (-1);

        cont_info->num_sections = 0;

        while (fgets(buf, sizeof (buf), file) != NULL) {
                /* ignore all comments */
                token = tokenizer(buf, "#", &field, &matched);
                /* find the names */
                token = tokenizer(buf, ":", &field, &matched);
                if (token != 0x00) {
                        token = tokenizer(token, "|", &item, &matched);
                        while (token != 0x00) {
                                if (strcmp(token, cont_desc_str) == 0) {
                                        foundIt = 1;
                                        goto found;
                                }
                                token = tokenizer(item, "|", &item, &matched);
                        }
                        /* check the last remaining item */
                        if ((item != 0x00) &&
                                        (strcmp(item, cont_desc_str) == 0)) {
                                foundIt = 1;
                                goto found;
                        }
                }
        }

found :
        if (foundIt == 1) {
                token = tokenizer(field, ":", &field, &matched);
                if (token == 0x00) {
                        (void) fclose(file);
                        return (-1);
                }
                cont_info->header_ver = (headerrev_t)atoi(token);

                token = tokenizer(field, ":\n", &field, &matched);
                while (token != 0x00) {
                        token = tokenizer(token, ",", &item, &matched);
                        if (token == 0x00) {
                                (void) fclose(file);
                                return (-1);
                        }
                        if (atoi(token) == 1) {
                                cont_info->section_info[cont_info->
                                num_sections].description.field.read_only = 1;
                        } else if (atoi(token) == 0) {
                                cont_info->section_info[cont_info->
                                num_sections].description.field.read_only = 0;
                        } else {
                                (void) fclose(file);
                                return (-1);
                        }

                        token = tokenizer(item, ",", &item, &matched);
                        if (token == 0x00) {
                                (void) fclose(file);
                                return (-1);
                        }

                        if (atoi(token) == 1) {
                                cont_info->section_info[cont_info->
                                num_sections].description.field.chk_type = 1;
                        } else if (atoi(token) == 0) {
                                cont_info->section_info[cont_info->
                                num_sections].description.field.chk_type = 0;
                        } else {
                                (void) fclose(file);
                                return (-1);
                        }


                        token = tokenizer(item, ",", &item, &matched);
                        if (token == 0x00) {
                                (void) fclose(file);
                                return (-1);
                        }

                        cont_info->section_info[cont_info->num_sections].
                                        address = atoi(token);


                        if (item == '\0') {
                                (void) fclose(file);
                                return (-1);
                        }
                        cont_info->section_info[cont_info->num_sections].size =
                                                                atoi(item);
                        (cont_info->num_sections)++;

                        token = tokenizer(field, ":\n ", &field, &matched);
                }
        }
        (void) fclose(file);
        return (0);
}

/*
 * Description :fru_open_container() opens the container associated with a fru.
 *              it's called by data plugin module before creating container
 *              property.  it calls picltree library routine to get the
 *              device path and driver binding name for the fru to get the
 *              corresponding fru name that describe the fru layout.
 *
 * Arguments   :picl_hdl_t      fru
 *              A handle for PICL tree node of class "fru" representing the
 *              FRU with the container to open.
 *
 * Return      :
 *              On Success, a Positive integer container handle. is returned
 *              for use in subsequent fru operations;on error, 0 is returned
 *              and "errno" is set appropriately.
 */

container_hdl_t
fru_open_container(picl_nodehdl_t fruhdl)
{
        int                     retval;
        int                     count;
        char                    *bname;
        char                    devpath[PATH_MAX];
        hash_obj_t              *cont_hash_obj;
        hash_obj_t              *sec_hash_obj;
        picl_nodehdl_t          tmphdl;
        picl_prophdl_t          prophdl;
        ptree_propinfo_t        propinfo;
        container_info_t        cont_info;

        /* Get property handle of _seeprom_source under fru node */
        retval = ptree_get_propval_by_name(fruhdl, PICL_REFPROP_SEEPROM_SRC,
                                                &tmphdl, sizeof (tmphdl));
        if (retval != PICL_SUCCESS) {
                return (NULL);
        }

        /* Get the device path of the fru */
        retval = ptree_get_propval_by_name(tmphdl, PICL_PROP_DEVICEPATH,
                                                        devpath, PATH_MAX);
        if (retval != PICL_SUCCESS) {
                return (NULL);
        }

        retval = ptree_get_prop_by_name(tmphdl, PICL_PROP_BINDING_NAME,
                                                                &prophdl);
        if (retval != PICL_SUCCESS) {
                return (NULL);
        }

        retval = ptree_get_propinfo(prophdl, &propinfo);
        if (retval != PICL_SUCCESS) {
                return (NULL);
        }

        bname = alloca(propinfo.piclinfo.size);
        if (bname == NULL) {
                return (NULL);
        }

        /* get the driver binding name */
        retval = ptree_get_propval(prophdl, bname, propinfo.piclinfo.size);
        if (retval != PICL_SUCCESS) {
                return (NULL);
        }

        cont_hash_obj   = create_container_hash_object();
        if (cont_hash_obj == NULL) {
                return (NULL);
        }

        add_hashobject_to_hashtable(cont_hash_obj);

        (void) strlcpy(cont_hash_obj->u.cont_obj->device_pathname, devpath,
                                                        sizeof (devpath));

        /* takes driver binding name as to get container information */
        retval = get_container_info(CONTAINER_CONF_FILE, bname, &cont_info);
        if (retval < 0) {
                return (NULL);
        }

        cont_hash_obj->u.cont_obj->num_of_section =  cont_info.num_sections;
        cont_hash_obj->u.cont_obj->sec_obj_list = NULL;

        for (count = 0; count < cont_info.num_sections; count++) {
                sec_hash_obj = create_section_hash_object();
                if (sec_hash_obj == NULL) {
                        return (NULL);
                }

                add_hashobject_to_hashtable(sec_hash_obj);

                sec_hash_obj->u.sec_obj->section.offset =
                                cont_info.section_info[count].address;

                sec_hash_obj->u.sec_obj->section.protection =
                cont_info.section_info[count].description.field.read_only;

                sec_hash_obj->u.sec_obj->checksum_method =
                cont_info.section_info[count].description.field.chk_type;

                sec_hash_obj->u.sec_obj->section.length =
                                        cont_info.section_info[count].size;

                sec_hash_obj->u.sec_obj->section.version = cont_info.header_ver;

                add_to_sec_object_list(cont_hash_obj, sec_hash_obj);
        }
        return (cont_hash_obj->obj_hdl);
}

static int
verify_header_crc8(headerrev_t head_ver, unsigned char *bytes, int length)
{
        int             crc_offset = 0;
        unsigned char   orig_crc8 = 0;
        unsigned char   calc_crc8 = 0;

        switch (head_ver) {
                case SECTION_HDR_VER:
                        crc_offset = 4;
                        break;
                default:
                        errno = EINVAL;
                        return (0);
        }

        orig_crc8 = bytes[crc_offset];
        bytes[crc_offset] = 0x00; /* clear for calc */
        calc_crc8 = compute_crc8(bytes, length);
        bytes[crc_offset] = orig_crc8; /* restore */

        return (orig_crc8 == calc_crc8);
}

/*
 * Description  :
 *              fru_get_num_sections() returns number of sections in a
 *              container. it calls get_container_index() to get the container
 *              index number in the container list.
 *
 * Arguments    :
 *              container_hdl_t : container handle.
 *
 * Return       :
 *              int
 *              On success, returns number of sections in a container.
 *
 */
/*ARGSUSED*/
int
fru_get_num_sections(container_hdl_t container, door_cred_t *cred)
{
        hash_obj_t              *hash_object;

        hash_object     = lookup_handle_object(container, CONTAINER_TYPE);
        if (hash_object == NULL) {
                return (-1);
        }

        return (hash_object->u.cont_obj->num_of_section);
}

/*
 * called from fru_get_sections()
 */

static void
get_section(int fd, hash_obj_t *sec_hash, section_t *section)
{
        int                     retval;
        int                     size;
        int                     count;
        uint16_t                hdrver;
        hash_obj_t              *seg_hash;
        unsigned char           *buffer;
        section_obj_t           *sec_obj;
        section_layout_t        sec_hdr;
        segment_layout_t        *seg_hdr;
        segment_layout_t        *seg_buf;

        sec_obj = sec_hash->u.sec_obj;
        if (sec_obj == NULL) {
                return;
        }

        /* populate section_t */
        section->handle = sec_hash->obj_hdl;
        section->offset = sec_obj->section.offset;
        section->length = sec_obj->section.length;
        section->protection = sec_obj->section.protection;
        section->version = sec_obj->section.version;
        sec_obj->num_of_segment = 0;

        /* read section header layout */
        retval = pread(fd, &sec_hdr, sizeof (sec_hdr),
                                                sec_obj->section.offset);
        if (retval != sizeof (sec_hdr)) {
                return;
        }

        hdrver  = GET_SECTION_HDR_VERSION;

        if ((sec_hdr.headertag != SECTION_HDR_TAG) &&
                                        (hdrver != section->version)) {
                return;
        }

        /* size = section layout + total sizeof segment header */
        size    = sizeof (sec_hdr) + ((sec_hdr.segmentcount)
                                        * sizeof (segment_layout_t));

        buffer  = alloca(size);
        if (buffer == NULL) {
                return;
        }

        /* segment header buffer */
        seg_buf = alloca(size - sizeof (sec_hdr));
        if (seg_buf == NULL) {
                return;
        }

        /* read segment header */
        retval = pread(fd, seg_buf, size - sizeof (sec_hdr),
                                sec_obj->section.offset + sizeof (sec_hdr));
        if (retval != (size - sizeof (sec_hdr))) {
                return;
        }

        /* copy section header layout */
        (void) memcpy(buffer, &sec_hdr, sizeof (sec_hdr));

        /* copy segment header layout */
        (void) memcpy(buffer + sizeof (sec_hdr), seg_buf, size -
                                                        sizeof (sec_hdr));

        /* verify crc8 */
        retval = verify_header_crc8(hdrver, buffer, size);
        if (retval != TRUE) {
                return;
        }


        section->version = hdrver;
        sec_obj->section.version = hdrver;

        seg_hdr = (segment_layout_t *)seg_buf;

        for (count = 0; count < sec_hdr.segmentcount; count++, seg_hdr++) {
                seg_hash = create_segment_hash_object();
                if (seg_hash == NULL) {
                        return;
                }

                add_hashobject_to_hashtable(seg_hash);

                copy_segment_layout(&seg_hash->u.seg_obj->segment, seg_hdr);

                add_to_seg_object_list(sec_hash, seg_hash);

                sec_obj->num_of_segment++;
        }
}


static int
call_devfsadm(void)
{
        char            *phys_path;
        di_node_t       root_node;
        di_node_t       prom_node;
        di_node_t       f_node;

        if ((root_node = di_init("/", DINFOCPYALL)) == DI_NODE_NIL) {
                return (-1);
        }

        f_node = di_drv_first_node(PICL_CLASS_SEEPROM, root_node);
        if (f_node != DI_NODE_NIL) {
                phys_path = di_devfs_path(f_node);
                if ((prom_node = di_init(phys_path, DINFOMINOR))
                                                        != DI_NODE_NIL) {
                        di_fini(prom_node);
                        di_fini(root_node);
                        (void) pclose(popen(devfsadm_cmd, "r"));
                        return (0);
                }
        }
        di_fini(root_node);
        return (-1);
}

/*
 * Description  :
 *              fru_get_sections() fills an array of section structures passed
 *              as an argument.
 *
 * Arguments    :
 *              container_hdl_t : container handle(device descriptor).
 *              section_t       : array of section structure.
 *              int             : maximum number of section in a container.
 *
 * Returns      :
 *              int
 *              On success,the number of section structures written is returned;
 *              on error, -1 is returned and "errno" is set appropriately.
 *
 */

/* ARGSUSED */
int
fru_get_sections(container_hdl_t container, section_t *section, int maxsec,
                                                        door_cred_t *cred)
{
        int             device_fd;
        int             retrys = 1;
        int             count;
        hash_obj_t      *cont_object;
        hash_obj_t      *sec_hash;

        cont_object     = lookup_handle_object(container, CONTAINER_TYPE);
        if (cont_object == NULL) {
                return (-1);
        }

        if (cont_object->u.cont_obj->num_of_section > maxsec) {
                return (-1);
        }

        sec_hash = cont_object->u.cont_obj->sec_obj_list;
        if (sec_hash == NULL) {
                return (-1);
        }

        do {
                device_fd = open(cont_object->u.cont_obj->device_pathname,
                                                                O_RDWR);
                if (device_fd >= 0) {
                        break;
                }
        } while ((retrys-- > 0) && (call_devfsadm() == 0));

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

        for (count = 0; count < cont_object->u.cont_obj->num_of_section;
                                                count++, section++) {
                section->version = -1;
                /* populate section_t */
                get_section(device_fd, sec_hash, section);
                sec_hash = sec_hash->u.sec_obj->next;
        }

        (void) close(device_fd);

        return (count);
}

/*
 * Description  :
 *              fru_get_num_segments() returns the current number of segments
 *              in a section.
 *
 * Arguments    :
 *              section_hdl_t : section header holding section information.
 *
 * Return       :
 *              int
 *              On success, the number of segments in the argument section is
 *              returned; on error -1 is returned.
 */
/*ARGSUSED*/
int
fru_get_num_segments(section_hdl_t section, door_cred_t *cred)
{
        hash_obj_t      *sec_object;
        section_obj_t   *sec_obj;

        sec_object      = lookup_handle_object(section, SECTION_TYPE);
        if (sec_object == NULL) {
                return (-1);
        }

        sec_obj = sec_object->u.sec_obj;
        if (sec_obj == NULL) {
                return (-1);
        }

        return (sec_obj->num_of_segment);
}

/*
 * Description  :
 *              fru_get_segments() fills an array of structures representing the
 *              segments in a section.
 *
 * Arguments    :
 *              section_hdl_t : holds section number.
 *              segment_t : on success will hold segment information.
 *              int     : maximum number of segment.
 *
 * Return       :
 *              int
 *              On success, the number of segment structures written is
 *              returned; on errno -1 is returned.
 */

/* ARGSUSED */
int
fru_get_segments(section_hdl_t section, segment_t *segment, int maxseg,
                                                door_cred_t *cred)
{
        int             count;
        hash_obj_t      *sec_object;
        hash_obj_t      *seg_object;
        section_obj_t   *sec_obj;

        sec_object = lookup_handle_object(section, SECTION_TYPE);
        if (sec_object == NULL) {
                return (-1);
        }

        sec_obj = sec_object->u.sec_obj;
        if (sec_obj == NULL) {
                return (-1);
        }

        if (sec_obj->num_of_segment > maxseg) {
                return (-1);
        }

        seg_object      = sec_object->u.sec_obj->seg_obj_list;
        if (seg_object == NULL) {
                return (-1);
        }

        for (count = 0; count < sec_obj->num_of_segment; count++) {

                /* populate segment_t */
                segment->handle = seg_object->obj_hdl;
                (void) memcpy(segment->name,
                        seg_object->u.seg_obj->segment.name, SEG_NAME_LEN);
                segment->descriptor = seg_object->u.seg_obj->segment.descriptor;

                segment->offset = seg_object->u.seg_obj->segment.offset;
                segment->length = seg_object->u.seg_obj->segment.length;
                seg_object = seg_object->u.seg_obj->next;
                segment++;
        }
        return (0);
}

/*
 * Description  :
 *              fru_add_segment() adds a segment to a section.
 *
 * Arguments    :
 *              section_hdl_t section
 *              A handle for the section in which to add the segment.
 *
 *              segment_t *segment
 *              On entry, the "handle" component of "segment" is ignored and the
 *              remaining components specify the parameters of the segment to be
 *              added.  On return, the "handle" component is set to the handle
 *              for the added segment. The segment offset is mandatory for FIXED
 *              segments; otherwise, the offset is advisory.
 *
 * Return       :
 *              int
 *              On success, 0 is returned; on error -1 is returned.
 *
 */

int
fru_add_segment(section_hdl_t section, segment_t *segment,
                                section_hdl_t *newsection, door_cred_t *cred)
{
        int             fd;
        int             retval;
        int             offset;
        int             sec_size;
        int             seg_cnt;
        int             bufsize;
        int             new_seg_offset;
        int             new_seg_length;
        int             fixed_segment;
        char            trailer[]       = { 0x0c, 0x00, 0x00, 0x00, 0x00 };
        hash_obj_t      *cont_hash;
        hash_obj_t      *sec_hash;
        hash_obj_t      *seg_hash;
        fru_segdesc_t   *new_seg_desc;
        unsigned char   *crcbuf;
        section_layout_t sec_layout;
        segment_layout_t *seg_layout;
        segment_layout_t *segment_buf;

        /* check the effective uid of the client */
        if (cred->dc_euid != 0) {
                errno = EPERM;
                return (-1);    /* not a root */
        }

        /* section hash */
        sec_hash = lookup_handle_object(section, SECTION_TYPE);
        if (sec_hash == NULL) {
                return (-1);
        }

        /* check for read-only section */
        if (sec_hash->u.sec_obj->section.protection == READ_ONLY_SECTION) {
                errno = EPERM;
                return (-1);
        }

        /* look for duplicate segment */
        seg_hash = sec_hash->u.sec_obj->seg_obj_list;
        while (seg_hash != NULL) {
                if (strncmp(segment->name, seg_hash->u.seg_obj->segment.name,
                                        SEG_NAME_LEN) == 0) {
                        errno = EEXIST;
                        return (-1); /* can't add duplicate segment */
                }
                seg_hash = seg_hash->u.seg_obj->next;
        }

        /* get the container hash */
        cont_hash = lookup_handle_object(sec_hash->u.sec_obj->cont_hdl,
                                                        CONTAINER_TYPE);
        if (cont_hash == NULL) {
                return (-1);
        }

        /* open the container */
        fd = open(cont_hash->u.cont_obj->device_pathname, O_RDWR);
        if (fd < 0) {
                return (-1);
        }

        /* section start here */
        offset  = sec_hash->u.sec_obj->section.offset;

        /* read section header layout */
        retval = pread(fd, &sec_layout, sizeof (sec_layout), offset);
        if (retval != sizeof (sec_layout)) {
                (void) close(fd);
                return (-1);
        }

        /* check for valid section header */
        if (sec_layout.headertag != SECTION_HDR_TAG) {
                /* write a new one */
                sec_layout.headertag            = SECTION_HDR_TAG;
                sec_layout.headerversion[0]     = SECTION_HDR_VER_BIT0;
                sec_layout.headerversion[1]     = SECTION_HDR_VER_BIT1;
                sec_layout.headerlength         = sizeof (sec_layout);
                sec_layout.segmentcount         = 0;
        }

        /* section size */
        sec_size        = sec_hash->u.sec_obj->section.length;

        /* number of segment in the section */
        seg_cnt = sec_layout.segmentcount;

        /* total sizeof segment + new segment */
        bufsize =       sizeof (segment_layout_t) * (seg_cnt + 1);
        segment_buf = alloca(bufsize);
        if (segment_buf == NULL) {
                return (-1);
        }

        /* read entire segment header */
        retval = pread(fd, segment_buf,  (bufsize - sizeof (segment_layout_t)),
                                        offset + sizeof (section_layout_t));
        if (retval != (bufsize - sizeof (segment_layout_t))) {
                (void) close(fd);
                return (-1);
        }

        new_seg_offset  = segment->offset; /* new segment offset */
        new_seg_length  = segment->length; /* new segment length */

        new_seg_desc    = (fru_segdesc_t *)&segment->descriptor;

        fixed_segment   = new_seg_desc->field.fixed;

        /* get new offset for new segment to be addedd */
        retval = find_offset((char *)segment_buf, seg_cnt, sec_size,
                        &new_seg_offset, new_seg_length, fixed_segment, fd);

        if (retval != 0)        {
                (void) close(fd);
                errno = EAGAIN;
                return (-1);
        }

        /* copy new segment data in segment layout */
        seg_layout      = (segment_layout_t *)(segment_buf + seg_cnt);
        (void) memcpy(&seg_layout->name, segment->name, SEG_NAME_LEN);
        (void) memcpy(seg_layout->descriptor, &segment->descriptor,
                                                sizeof (uint32_t));
        seg_layout->length      = segment->length;
        seg_layout->offset      = new_seg_offset; /* new segment offset */

        sec_layout.segmentcount += 1;

        crcbuf  = alloca(sizeof (section_layout_t) + bufsize);
        if (crcbuf == NULL) {
                (void) close(fd);
                return (-1);
        }

        sec_layout.headercrc8 = 0;
        sec_layout.headerlength += sizeof (segment_layout_t);

        (void) memcpy(crcbuf, (char *)&sec_layout, sizeof (section_layout_t));
        (void) memcpy(crcbuf + sizeof (section_layout_t), segment_buf, bufsize);

        sec_layout.headercrc8 = compute_crc8(crcbuf, bufsize +
                                                sizeof (section_layout_t));

        /* write section header */
        retval = pwrite(fd, &sec_layout, sizeof (section_layout_t), offset);
        if (retval != sizeof (section_layout_t)) {
                (void) close(fd);
                return (-1);
        }

        /* write segment header */
        retval = pwrite(fd, segment_buf, bufsize, offset +
                                                sizeof (section_layout_t));
        if (retval != bufsize) {
                (void) close(fd);
                return (-1);
        }

        /* write segment trailer */
        retval = pwrite(fd, &trailer, sizeof (trailer), new_seg_offset);
        if (retval != sizeof (trailer)) {
                (void) close(fd);
                return (-1);
        }

        (void) close(fd);

        /* create new segment hash object */
        seg_hash        = create_segment_hash_object();
        if (seg_hash == NULL) {
                return (-1);
        }

        add_hashobject_to_hashtable(seg_hash);

        copy_segment_layout(&seg_hash->u.seg_obj->segment, seg_layout);

        add_to_seg_object_list(sec_hash, seg_hash);

        sec_hash->u.sec_obj->num_of_segment += 1;
        seg_hash->u.seg_obj->trailer_offset = new_seg_offset;
        *newsection     = section; /* return the new section handle */
        return (0);
}

static void
free_pkt_object_list(hash_obj_t *hash_obj)
{
        hash_obj_t      *next_obj;
        hash_obj_t      *free_obj;

        next_obj = hash_obj->u.seg_obj->pkt_obj_list;
        while (next_obj != NULL) {
                free_obj = next_obj;
                next_obj = next_obj->u.pkt_obj->next;
                /* if prev is NULL it's the first object in the list */
                if (free_obj->prev == NULL) {
                        hash_table[(free_obj->obj_hdl % TABLE_SIZE)] =
                                        free_obj->next;
                        if (free_obj->next != NULL) {
                                free_obj->next->prev = free_obj->prev;
                        }
                } else {
                        free_obj->prev->next = free_obj->next;
                        if (free_obj->next != NULL) {
                                free_obj->next->prev = free_obj->prev;
                        }
                }
                free(free_obj->u.pkt_obj);
                free(free_obj);
        }

        hash_obj->u.seg_obj->pkt_obj_list = NULL;
}

static void
free_segment_hash(handle_t      handle, hash_obj_t      *sec_hash)
{
        hash_obj_t      *seg_hash;
        hash_obj_t      *next_hash;

        seg_hash        = sec_hash->u.sec_obj->seg_obj_list;
        if (seg_hash == NULL) {
                return;
        }

        if (seg_hash->obj_hdl == handle) {
                sec_hash->u.sec_obj->seg_obj_list = seg_hash->u.seg_obj->next;
        } else {
                while (seg_hash->obj_hdl != handle) {
                        next_hash       = seg_hash;
                        seg_hash = seg_hash->u.seg_obj->next;
                        if (seg_hash == NULL) {
                                return;
                        }
                }
                next_hash->u.seg_obj->next = seg_hash->u.seg_obj->next;
        }

        if (seg_hash->prev == NULL) {
                hash_table[(seg_hash->obj_hdl % TABLE_SIZE)] = seg_hash->next;
                if (seg_hash->next != NULL) {
                        seg_hash->next->prev = NULL;
                }
        } else {
                seg_hash->prev->next = seg_hash->next;
                if (seg_hash->next != NULL) {
                        seg_hash->next->prev = seg_hash->prev;
                }
        }

        free_pkt_object_list(seg_hash);
        free(seg_hash->u.seg_obj);
        free(seg_hash);
}

/*
 * Description  :
 *              fru_delete_segment() deletes a segment from a section; the
 *              associated container data is not altered.
 *
 * Arguments    : segment_hdl_t segment handle.
 *                section_hdl_t new section handle.
 *
 * Return       :
 *              int
 *              On success, 0 returned; On error -1 is returned.
 */

int
fru_delete_segment(segment_hdl_t segment, section_hdl_t *newsection,
                                                        door_cred_t *cred)
{
        int                     num_of_seg;
        int                     bufsize;
        int                     count;
        int                     retval;
        int                     fd;
        int                     segnum;
        hash_obj_t              *seg_hash;
        hash_obj_t              *sec_hash;
        hash_obj_t              *cont_hash;
        hash_obj_t              *tmp_hash;
        unsigned char           *buffer;
        fru_segdesc_t           *desc;
        segment_layout_t        *seg_buf;
        section_layout_t        *sec_layout;
        segment_layout_t        *seg_layout;
        segment_layout_t        *next_layout;

        /* check the effective uid of the client */
        if (cred->dc_euid != 0) {
                errno = EPERM;
                return (-1);    /* not a root */
        }

        seg_hash = lookup_handle_object(segment, SEGMENT_TYPE);
        if (seg_hash == NULL) {
                return (-1);
        }

        desc    = (fru_segdesc_t *)&seg_hash->u.seg_obj->segment.descriptor;
        if (!(desc->field.field_perm & SEGMENT_DELETE)) {
                errno = EPERM;
                return (-1); /* can't delete this segment */
        }

        sec_hash = lookup_handle_object(seg_hash->u.seg_obj->section_hdl,
                                                SECTION_TYPE);
        if (sec_hash == NULL) {
                return (-1);
        }

        if (sec_hash->u.sec_obj->section.protection == READ_ONLY_SECTION) {
                errno = EPERM;
                return (-1);
        }

        num_of_seg      = sec_hash->u.sec_obj->num_of_segment;

        bufsize = (sizeof (segment_layout_t) * num_of_seg);

        seg_buf = alloca(bufsize);
        if (seg_buf == NULL) {
                return (-1);
        }

        segnum  = 0;
        for (tmp_hash = sec_hash->u.sec_obj->seg_obj_list; tmp_hash != NULL;
                        tmp_hash = tmp_hash->u.seg_obj->next) {
                if (tmp_hash->obj_hdl == segment) {
                        break;
                }
                segnum++;
        }

        cont_hash = lookup_handle_object(sec_hash->u.sec_obj->cont_hdl,
                                                CONTAINER_TYPE);
        if (cont_hash == NULL) {
                return (-1);
        }

        fd  = open(cont_hash->u.cont_obj->device_pathname, O_RDWR);
        if (fd < 0) {
                return (-1);
        }

        sec_layout      = alloca(sizeof (section_layout_t));
        if (sec_layout == NULL) {
                (void) close(fd);
                return (-1);
        }

        /* read section layout header */
        retval = pread(fd, sec_layout, sizeof (section_layout_t),
                                        sec_hash->u.sec_obj->section.offset);
        if (retval != sizeof (section_layout_t)) {
                (void) close(fd);
                return (-1);
        }

        /* read segment header layout */
        retval = pread(fd, seg_buf, bufsize,
                        sec_hash->u.sec_obj->section.offset +
                                                sizeof (section_layout_t));
        if (retval != bufsize) {
                (void) close(fd);
                return (-1);
        }

        seg_layout = (segment_layout_t *)(seg_buf + segnum);
        next_layout     = seg_layout;
        for (count = segnum; count < sec_hash->u.sec_obj->num_of_segment-1;
                                                                count++) {
                next_layout++;
                (void) memcpy(seg_layout, next_layout,
                                                sizeof (segment_layout_t));
                seg_layout++;
        }

        (void) memset(seg_layout, '\0', sizeof (segment_layout_t));

        sec_layout->headercrc8 = 0;

        sec_layout->headerlength -= sizeof (segment_layout_t);
        sec_layout->segmentcount -= 1;

        buffer = alloca(sec_layout->headerlength);
        if (buffer == NULL) {
                (void) close(fd);
                return (-1);
        }

        (void) memcpy(buffer, sec_layout, sizeof (section_layout_t));
        (void) memcpy(buffer + sizeof (section_layout_t), seg_buf, bufsize
                                                - sizeof (segment_layout_t));
        sec_layout->headercrc8 = compute_crc8(buffer,
                                                sec_layout->headerlength);

        /* write section header with update crc8 and header length */
        retval = pwrite(fd, sec_layout, sizeof (section_layout_t),
                                        sec_hash->u.sec_obj->section.offset);
        if (retval != sizeof (section_layout_t)) {
                (void) close(fd);
                return (-1);
        }

        /* write the update segment header */
        retval = pwrite(fd, seg_buf, bufsize,
                sec_hash->u.sec_obj->section.offset +
                                                sizeof (section_layout_t));
        (void) close(fd);
        if (retval != bufsize) {
                return (-1);
        }

        free_segment_hash(segment, sec_hash);

        *newsection     = sec_hash->obj_hdl;
        sec_hash->u.sec_obj->num_of_segment = sec_layout->segmentcount;

        return (0);
}

/*
 * Description  :
 *              fru_read_segment() reads the raw contents of a segment.
 *
 * Arguments    : segment_hdl_t : segment handle.
 *               void * : buffer containing segment data when function returns.
 *              size_t :number of bytes.
 *
 * Return       :
 *              int
 *              On success, the number of bytes read is returned;
 *
 * Notes        :
 *              Segments containing packets can be read in structured fashion
 *              using the fru_get_packets() and fru_get_payload() primitives;the
 *              entire byte range of a segment can be read using
 *              fru_read_segment().
 */
/*ARGSUSED*/
ssize_t
fru_read_segment(segment_hdl_t segment, void *buffer, size_t nbytes,
                door_cred_t *cred)
{
        int             fd;
        int             retval;
        hash_obj_t      *seg_hash;
        hash_obj_t      *sec_hash;
        hash_obj_t      *cont_hash;

        /* segment hash object */
        seg_hash = lookup_handle_object(segment, SEGMENT_TYPE);
        if (seg_hash == NULL) {
                return (-1);
        }

        /* section hash object */
        sec_hash = lookup_handle_object(seg_hash->u.seg_obj->section_hdl,
                                                        SECTION_TYPE);
        if (sec_hash == NULL) {
                return (-1);
        }

        /* container hash object */
        cont_hash = lookup_handle_object(sec_hash->u.sec_obj->cont_hdl,
                                                        CONTAINER_TYPE);
        if (cont_hash == NULL) {
                return (-1);
        }

        if (seg_hash->u.seg_obj->segment.length < nbytes) {
                return (-1);
        }

        fd = open(cont_hash->u.cont_obj->device_pathname, O_RDWR);
        if (fd < 0) {
                return (-1);
        }

        retval = pread(fd, buffer, nbytes, seg_hash->u.seg_obj->segment.offset);
        (void) close(fd);
        if (retval != nbytes) {
                return (-1);
        }
        return (nbytes);
}

/*
 * Description  :
 *              fru_write_segment() writes a raw segment.
 *
 * Arguments    : segment_hdl_t :segment handle.
 *               const void * : data buffer.
 *               size_t : number of bytes.
 *               segment_hdl_t : new segment handle.
 *
 * Returns      :
 *              int
 *              On success, the number of bytes written is returned
 *
 */
/*ARGSUSED*/
int
fru_write_segment(segment_hdl_t segment, const void *data, size_t nbytes,
                                segment_hdl_t *newsegment, door_cred_t *cred)
{
        return (ENOTSUP);
}


static int
get_packet(int device_fd, void *buffer, int size, int offset)
{
        int     retval;

        retval = pread(device_fd, (char *)buffer, size, offset);
        if (retval != -1) {
                return (0);
        }
        return (-1);
}

/*
 * Description  :
 *              get_payload() populates a buffer with the packets payload
 *
 * Arguments    : hash_obj_t : packet.
 *                int  : device file descriptor
 *                uint8_t* : pointer to a pre allocated buffer
 *
 *
 * Return       :
 *              int
 *              On success, 0 is returned; on failure
 *              -1 returned.
 */
int
get_payload(int device_fd, hash_obj_t *packet, uint8_t *payload)
{
        int             retval;
        packet_obj_t    *packet_object;


        packet_object = packet->u.pkt_obj;
        if (packet_object == NULL) {
                return (-1);
        }

        /* Get the data */
        retval = pread(device_fd, payload, packet_object->paylen,
                        packet_object->payload_offset);
        if (retval != packet_object->paylen) {
            free(payload);
            return (-1);
        }

        return (0);

}


static uint32_t
get_checksum_crc(int device_fd, hash_obj_t      *seg_hash, int data_size)
{
        int             checksum;
        int             offset = 0;
        int             retval;
        uint8_t         *payload;
        uint32_t        crc;
        hash_obj_t      *sec_hash;
        hash_obj_t      *pkt_hash;
        unsigned char   *buffer;

        sec_hash = lookup_handle_object(seg_hash->u.seg_obj->section_hdl,
                                                        SECTION_TYPE);
        if (sec_hash == NULL) {
                return ((uint32_t)-1);
        }

        buffer = alloca(data_size);
        if (buffer == NULL) {
                return ((uint32_t)-1);
        }

        /* traverse the packet object list for all the tags and payload */
        for (pkt_hash = seg_hash->u.seg_obj->pkt_obj_list; pkt_hash != NULL;
                                pkt_hash = pkt_hash->u.pkt_obj->next) {
                (void) memcpy(buffer + offset, &pkt_hash->u.pkt_obj->tag,
                                        pkt_hash->u.pkt_obj->tag_size);
                offset += pkt_hash->u.pkt_obj->tag_size;

                /* read packet payload */
                payload = malloc(pkt_hash->u.pkt_obj->paylen);
                if (payload == NULL) {
                    return ((uint32_t)-1);
                }
                retval = get_payload(device_fd, pkt_hash, payload);
                if (retval == -1) {
                    free(payload);
                    return ((uint32_t)-1);
                }
                (void) memcpy(buffer + offset, payload,
                                        pkt_hash->u.pkt_obj->paylen);
                offset += pkt_hash->u.pkt_obj->paylen;
                free(payload);
        }

        checksum        = sec_hash->u.sec_obj->checksum_method;

        if (checksum == CRC32_SECTION) { /* read-only section */
                crc = compute_crc32(buffer, data_size);
        } else {                /* read/write section */
                crc = compute_checksum32(buffer, data_size);
        }
        return (crc);   /* computed crc */
}

static int
get_packets(hash_obj_t *seg_hash, int device_fd, int offset, int length)
{
        int             tag_size;
        int             paylen;
        int             retval;
        int             seg_limit = 0;
        int             pktcnt  = 0;
        char            *data;
        uint32_t        crc;
        uint32_t        origcrc;
        fru_tag_t       tag;
        hash_obj_t      *pkt_hash_obj;
        fru_segdesc_t   *segdesc;
        fru_tagtype_t   tagtype;

        retval = get_packet(device_fd, &tag, sizeof (fru_tag_t), offset);
        if (retval == -1) {
                return (-1);
        }

        seg_hash->u.seg_obj->trailer_offset = offset;

        data    = (char *)&tag;
        while (data[0] != SEG_TRAILER_TAG) {
                tagtype = get_tag_type(&tag); /* verify tag type */
                if (tagtype == -1) {
                        return (-1);
                }

                tag_size = get_tag_size(tagtype);
                if (tag_size == -1) {
                        return (-1);
                }

                seg_limit += tag_size;
                if (seg_limit > length) {
                        return (-1);
                }

                paylen = get_payload_length((void *)&tag);
                if (paylen == -1) {
                        return (-1);
                }

                seg_limit += paylen;
                if (seg_limit > length) {
                        return (-1);
                }

                pkt_hash_obj = create_packet_hash_object();
                if (pkt_hash_obj == NULL) {
                        return (-1);
                }

                offset += tag_size;

                /* don't change this */
                pkt_hash_obj->u.pkt_obj->tag.raw_data = 0;
                (void) memcpy(&pkt_hash_obj->u.pkt_obj->tag, &tag, tag_size);
                pkt_hash_obj->u.pkt_obj->paylen = paylen;
                pkt_hash_obj->u.pkt_obj->tag_size = tag_size;
                pkt_hash_obj->u.pkt_obj->payload_offset = offset;

                offset += paylen;

                add_hashobject_to_hashtable(pkt_hash_obj);
                add_to_pkt_object_list(seg_hash, pkt_hash_obj);

                pktcnt++;

                retval = get_packet(device_fd, &tag, sizeof (fru_tag_t),
                                                                        offset);
                if (retval == -1) {
                        return (retval);
                }

                data    = (char *)&tag;
        }

        segdesc = (fru_segdesc_t *)&seg_hash->u.seg_obj->segment.descriptor;

        seg_hash->u.seg_obj->trailer_offset = offset;

        if (!segdesc->field.ignore_checksum)  {
                crc = get_checksum_crc(device_fd, seg_hash, seg_limit);
                offset  = seg_hash->u.seg_obj->segment.offset;

                retval = pread(device_fd, &origcrc, sizeof (origcrc),
                                                offset + seg_limit + 1);
                if (retval != sizeof (origcrc)) {
                        return (-1);
                }

                if (origcrc != crc) {
                        seg_hash->u.seg_obj->trailer_offset = offset;
                        return (-1);
                }
        }

        return (pktcnt);
}

/*
 * Description  :
 *              fru_get_num_packets() returns the current number of packets
 *              in a segment.
 *
 * Arguments    : segment_hdl_t : segment handle.
 *
 * Return       :
 *              int
 *              On success, the number of packets is returned;
 *              -1 on failure.
 */
/*ARGSUSED*/
int
fru_get_num_packets(segment_hdl_t segment, door_cred_t *cred)
{
        int             device_fd;
        int             pktcnt;
        int             length;
        uint16_t        offset;
        hash_obj_t      *cont_hash_obj;
        hash_obj_t      *seg_hash;
        fru_segdesc_t   *segdesc;
        segment_obj_t   *segment_object;

        seg_hash        = lookup_handle_object(segment, SEGMENT_TYPE);
        if (seg_hash == NULL) {
                return (-1);
        }

        segment_object  = seg_hash->u.seg_obj;
        if (segment_object == NULL) {
                return (-1);
        }


        segdesc = (fru_segdesc_t *)&segment_object->segment.descriptor;
        if (segdesc->field.opaque) {
                return (0);
        }

        offset = segment_object->segment.offset;
        length = segment_object->segment.length;

        cont_hash_obj   = get_container_hash_object(SEGMENT_TYPE,
                                                segment_object->section_hdl);

        if (cont_hash_obj == NULL) {
                return (-1);
        }

        if (seg_hash->u.seg_obj->pkt_obj_list != NULL) {
                return (segment_object->num_of_packets);
        }

        segment_object->num_of_packets = 0;
        device_fd = open(cont_hash_obj->u.cont_obj->device_pathname,
                                                                O_RDWR);
        if (device_fd < 0) {
                return (-1);
        }

        pktcnt = get_packets(seg_hash, device_fd, offset,
                                                        length);
        if (pktcnt == -1) {
                free_pkt_object_list(seg_hash);
                seg_hash->u.seg_obj->pkt_obj_list = NULL;
        }

        segment_object->num_of_packets = pktcnt;
        (void) close(device_fd);

        return (segment_object->num_of_packets);
}


/*
 * Description  :
 *              fru_get_packets() fills an array of structures representing the
 *              packets in a segment.
 *
 * Arguments    : segment_hdl_t : segment handle.
 *              packet_t        : packet buffer.
 *              int     : maximum number of packets.
 *
 * Return       :
 *              int
 *              On success, the number of packet structures written is returned;
 *              On failure -1 is returned;
 *
 */
/*ARGSUSED*/
int
fru_get_packets(segment_hdl_t segment, packet_t *packet, int maxpackets,
                                                        door_cred_t *cred)
{
        int             count;
        hash_obj_t      *seg_hash_obj;
        hash_obj_t      *pkt_hash_obj;

        /* segment hash object */
        seg_hash_obj    = lookup_handle_object(segment, SEGMENT_TYPE);
        if (seg_hash_obj == NULL) {
                return (-1);
        }

        if (seg_hash_obj->u.seg_obj->num_of_packets != maxpackets) {
                return (-1);
        }

        pkt_hash_obj    = seg_hash_obj->u.seg_obj->pkt_obj_list;
        if (pkt_hash_obj == NULL) {
                return (-1);
        }

        for (count = 0; count < maxpackets; count++, packet++) {
                packet->handle  = pkt_hash_obj->obj_hdl;
                packet->tag = 0;
                (void) memcpy(&packet->tag, &pkt_hash_obj->u.pkt_obj->tag,
                                pkt_hash_obj->u.pkt_obj->tag_size);
                pkt_hash_obj = pkt_hash_obj->u.pkt_obj->next;
        }

        return (0);
}

/*
 * Description  :
 *              fru_get_payload() copies the contents of a packet's payload.
 *
 * Arguments    : packet_hdl_t : packet handle.
 *              void *  : payload buffer.
 *              size_t  : sizeof the buffer.
 *
 * Return       :
 *              int
 *              On success, the number of bytes copied is returned; On error
 *              -1 returned.
 */
/*ARGSUSED*/
ssize_t
fru_get_payload(packet_hdl_t packet, void *buffer, size_t nbytes,
                                                door_cred_t *cred)
{
        int             retval;
        int             device_fd;
        uint8_t         *payload;
        hash_obj_t      *packet_hash_obj;
        hash_obj_t      *segment_hash_obj;
        hash_obj_t      *container_hash_obj;

        /* packet hash object */
        packet_hash_obj = lookup_handle_object(packet, PACKET_TYPE);
        if (packet_hash_obj == NULL) {
                return (-1);
        }

        payload = malloc(packet_hash_obj->u.pkt_obj->paylen);
        if (payload == NULL) {
            return (-1);
        }

        /* lookup the segment hash object */
        segment_hash_obj =
            lookup_handle_object(packet_hash_obj->u.pkt_obj->segment_hdl,
            SEGMENT_TYPE);
        if (segment_hash_obj == NULL) {
            free(payload);
            return (-1);
        }

        /* Get the container hash object to get the seeprom device path */
        container_hash_obj      = get_container_hash_object(SEGMENT_TYPE,
                                    segment_hash_obj->u.seg_obj->section_hdl);
        if (container_hash_obj == NULL) {
            free(payload);
            return (-1);
        }

        /* Open the seeprom device */
        device_fd = open(container_hash_obj->u.cont_obj->device_pathname,
                                                                O_RDWR);
        if (device_fd < 0) {
            free(payload);
            return (-1);
        }


        /* Call to get the payload  */
        retval  = get_payload(device_fd, packet_hash_obj, payload);
        if (retval == -1) {
            free(payload);
            (void) close(device_fd);
            return (-1);
        }


        /* verify payload length */
        if (nbytes != packet_hash_obj->u.pkt_obj->paylen) {
            free(payload);
            (void) close(device_fd);
            return (-1);
        }

        (void) memcpy(buffer, payload, nbytes);
        free(payload);
        (void) close(device_fd);
        return (nbytes);
}

/*
 * Description  :
 *              fru_update_payload() writes the contents of a packet's payload.
 *
 * Arguments    : packet_hdl_t : packet handle.
 *              const void * : data buffer.
 *              size_t  : buffer size.
 *              packet_hdl_t    : new packet handle.
 *
 * Return       :
 *              int
 *              On success, 0 is returned; on failure
 *              -1 is returned.
 */

int
fru_update_payload(packet_hdl_t packet, const void *data, size_t nbytes,
                                packet_hdl_t *newpacket, door_cred_t *cred)
{
        int             fd;
        int             segment_offset;
        int             trailer_offset;
        int             retval;
        uint32_t        crc;
        hash_obj_t      *pkt_hash;
        hash_obj_t      *seg_hash;
        hash_obj_t      *sec_hash;
        hash_obj_t      *cont_hash;
        fru_segdesc_t   *desc;

        /* check the effective uid of the client */
        if (cred->dc_euid != 0) {
                errno = EPERM;
                return (-1);    /* not a root */
        }

        /* packet hash object */
        pkt_hash = lookup_handle_object(packet, PACKET_TYPE);
        if (pkt_hash == NULL) {
                return (-1);
        }

        /* segment hash object */
        seg_hash = lookup_handle_object(pkt_hash->u.pkt_obj->segment_hdl,
                                                SEGMENT_TYPE);
        if (seg_hash == NULL) {
                return (-1);
        }

        /* check for write perm. */
        desc    = (fru_segdesc_t *)&seg_hash->u.seg_obj->segment.descriptor;
        if (!(desc->field.field_perm & SEGMENT_WRITE)) {
                errno = EPERM;
                return (-1); /* write not allowed */
        }

        sec_hash = lookup_handle_object(seg_hash->u.seg_obj->section_hdl,
                                                SECTION_TYPE);
        if (sec_hash == NULL) {
                return (-1);
        }

        if (sec_hash->u.sec_obj->section.protection == READ_ONLY_SECTION) {
                errno = EPERM;
                return (-1);            /* read-only section */
        }

        cont_hash = lookup_handle_object(sec_hash->u.sec_obj->cont_hdl,
                                                CONTAINER_TYPE);
        if (cont_hash == NULL) {
                return (-1);
        }

        if (pkt_hash->u.pkt_obj->paylen != nbytes) {
                return (-1);
        }

        fd      = open(cont_hash->u.cont_obj->device_pathname, O_RDWR);
        if (fd < 0) {
                return (-1);
        }

        trailer_offset  = seg_hash->u.seg_obj->trailer_offset;
        segment_offset  = seg_hash->u.seg_obj->segment.offset;

        crc = get_checksum_crc(fd, seg_hash, (trailer_offset - segment_offset));
        retval = pwrite(fd, data, nbytes, pkt_hash->u.pkt_obj->payload_offset);
        if (retval != nbytes) {
                (void) close(fd);
                return (-1);
        }

        retval = pwrite(fd, &crc, sizeof (crc), trailer_offset + 1);
        (void) close(fd);
        if (retval != sizeof (crc)) {
                return (-1);
        }
        *newpacket      = packet;
        return (0);
}

/*
 * Description  :
 *              fru_append_packet() appends a packet to a segment.
 *
 * Arguments    :
 *              segment_hdl_t segment
 *              A handle for the segment to which the packet will be appended.
 *
 *              packet_t *packet
 *              On entry, the "tag" component of "packet" specifies the tag
 *              value for the added packet; the "handle" component is ignored.
 *              On return, the "handle" component is set to the handle of the
 *              appended packet.
 *
 *              const void *payload
 *              A pointer to the caller's buffer containing the payload data for
 *              the appended packet.
 *
 *              size_t nbytes
 *              The size of the caller buffer.
 *
 * Return       :
 *              int
 *              On success, 0 is returned; on error -1 is returned;
 */

int
fru_append_packet(segment_hdl_t segment, packet_t *packet, const void *payload,
                size_t nbytes, segment_hdl_t *newsegment, door_cred_t *cred)
{
        int             trailer_offset;
        int             tag_size;
        int             fd;
        int             retval;
        char            trailer[] = {0x0c, 0x00, 0x00, 0x00, 0x00};
        uint32_t        crc;
        hash_obj_t      *seg_hash;
        hash_obj_t      *sec_hash;
        hash_obj_t      *pkt_hash;
        hash_obj_t      *cont_hash;
        fru_tagtype_t   tagtype;
        fru_segdesc_t   *desc;

        /* check the effective uid of the client */
        if (cred->dc_euid != 0) {
                errno = EPERM;
                return (-1);    /* not a root */
        }

        seg_hash = lookup_handle_object(segment, SEGMENT_TYPE);
        if (seg_hash == NULL) {
                return (-1);
        }

        /* check for write perm. */
        desc    = (fru_segdesc_t *)&seg_hash->u.seg_obj->segment.descriptor;
        if (!(desc->field.field_perm & SEGMENT_WRITE)) {
                errno = EPERM;
                return (-1); /* write not allowed */
        }

        sec_hash = lookup_handle_object(seg_hash->u.seg_obj->section_hdl,
                                                        SECTION_TYPE);
        if (sec_hash == NULL) {
                return (-1);
        }

        if (sec_hash->u.sec_obj->section.protection == READ_ONLY_SECTION) {
                errno = EPERM;
                return (-1);            /* read-only section */
        }

        trailer_offset  = seg_hash->u.seg_obj->trailer_offset;

        /*
         * if trailer offset is 0 than parse the segment data to get the trailer
         * offset to compute the remaining space left in the segment area for
         * new packet to be added.
         */
        if (trailer_offset == 0) {
                (void) fru_get_num_packets(segment, cred);
                trailer_offset  = seg_hash->u.seg_obj->trailer_offset;
        }

        tagtype = get_tag_type((void *)&packet->tag);
        if (tagtype == -1) {
                return (-1);
        }

        tag_size        = get_tag_size(tagtype);
        if (tag_size == -1) {
                return (-1);
        }

        if (seg_hash->u.seg_obj->segment.length >
                ((trailer_offset - seg_hash->u.seg_obj->segment.offset) +
                        tag_size + nbytes + sizeof (char)
                                                + sizeof (uint32_t))) {
                /* create new packet hash */
                pkt_hash = create_packet_hash_object();
                if (pkt_hash == NULL) {
                        return (-1);
                }

                /* tag initialization */
                (void) memcpy(&pkt_hash->u.pkt_obj->tag, &packet->tag,
                                                                tag_size);
                pkt_hash->u.pkt_obj->tag_size   = tag_size;
                pkt_hash->u.pkt_obj->paylen     = nbytes;
                pkt_hash->u.pkt_obj->payload_offset = trailer_offset + tag_size;

                /* add to hash table */
                add_hashobject_to_hashtable(pkt_hash);

                add_to_pkt_object_list(seg_hash, pkt_hash);

                cont_hash = lookup_handle_object(sec_hash->u.sec_obj->cont_hdl,
                                                                CONTAINER_TYPE);
                if (cont_hash == NULL) {
                        return (-1);
                }

                fd = open(cont_hash->u.cont_obj->device_pathname, O_RDWR);
                if (fd < 0) {
                        return (-1);
                }

                /* update the trailer offset  */
                trailer_offset += tag_size + nbytes;

                /* calculate new checksum */
                crc = get_checksum_crc(fd, seg_hash, (trailer_offset -
                                        seg_hash->u.seg_obj->segment.offset));

                retval = pwrite(fd, &packet->tag, tag_size, trailer_offset
                                                        - (tag_size + nbytes));
                if (retval != tag_size) {
                        (void) close(fd);
                        return (-1);
                }

                retval = pwrite(fd, payload, nbytes, trailer_offset - nbytes);
                if (retval != nbytes) {
                        (void) close(fd);
                        return (-1);
                }

                retval = pwrite(fd, trailer, sizeof (trailer), trailer_offset);
                if (retval != sizeof (trailer)) {
                        (void) close(fd);
                        return (-1);
                }

                retval = pwrite(fd, &crc, sizeof (crc), trailer_offset + 1);
                (void) close(fd);
                if (retval != sizeof (crc)) {
                        return (-1);
                }

                seg_hash->u.seg_obj->trailer_offset = trailer_offset;
                seg_hash->u.seg_obj->num_of_packets += 1;

                *newsegment     = segment;      /* return new segment handle */
                return (0);
        } else {
                errno = EAGAIN;
        }

        return (-1);
}

static void
adjust_packets(int      fd, hash_obj_t  *free_obj, hash_obj_t   *object_list)
{
        int             retval;
        uint8_t         *payload;
        uint32_t        new_offset;
        hash_obj_t      *hash_ptr;


        new_offset = free_obj->u.pkt_obj->payload_offset
                                        - free_obj->u.pkt_obj->tag_size;
        for (hash_ptr = object_list; hash_ptr != NULL;
                                hash_ptr = hash_ptr->u.pkt_obj->next) {

                payload = malloc(hash_ptr->u.pkt_obj->paylen);
                if (payload == NULL) {
                    return;
                }
                retval = get_payload(fd, hash_ptr, payload);
                if (retval == -1) {
                    free(payload);
                    return;
                }

                retval = pwrite(fd, &hash_ptr->u.pkt_obj->tag,
                                hash_ptr->u.pkt_obj->tag_size, new_offset);
                if (retval != hash_ptr->u.pkt_obj->tag_size) {
                    free(payload);
                    return;
                }
                new_offset += hash_ptr->u.pkt_obj->tag_size;
                hash_ptr->u.pkt_obj->payload_offset = new_offset;
                retval = pwrite(fd, payload,
                                hash_ptr->u.pkt_obj->paylen, new_offset);
                if (retval != hash_ptr->u.pkt_obj->paylen) {
                    free(payload);
                    return;
                }
                new_offset += hash_ptr->u.pkt_obj->paylen;
                free(payload);
        }
}

static void
free_packet_object(handle_t     handle, hash_obj_t *seg_hash)
{
        hash_obj_t      *pkt_hash;
        hash_obj_t      *next_hash;

        pkt_hash        = seg_hash->u.seg_obj->pkt_obj_list;
        if (pkt_hash == NULL) {
                return;
        }

        if (pkt_hash->obj_hdl == handle) {
                seg_hash->u.seg_obj->pkt_obj_list = pkt_hash->u.pkt_obj->next;
        } else {
                while (pkt_hash->obj_hdl != handle) {
                        next_hash = pkt_hash;
                        pkt_hash = pkt_hash->u.pkt_obj->next;
                        if (pkt_hash == NULL) {
                                return;
                        }
                }
                next_hash->u.pkt_obj->next = pkt_hash->u.pkt_obj->next;
        }

        if (pkt_hash->prev == NULL) {
                hash_table[(pkt_hash->obj_hdl % TABLE_SIZE)] = pkt_hash->next;
                if (pkt_hash->next != NULL) {
                        pkt_hash->next->prev = NULL;
                }
        } else {
                pkt_hash->prev->next = pkt_hash->next;
                if (pkt_hash->next != NULL) {
                        pkt_hash->next->prev = pkt_hash->prev;
                }
        }

        free(pkt_hash->u.pkt_obj);
        free(pkt_hash);
}

/*
 * Description  :
 *              fru_delete_packet() deletes a packet from a segment.
 *
 * Arguments    : packet_hdl_t : packet number to be deleted.
 *              segment_hdl_t : new segment handler.
 *
 * Return       :
 *              int
 *              On success, 0 is returned; on error, -1.
 *
 * NOTES
 *              Packets are adjacent; thus, deleting a packet requires moving
 *              succeeding packets to compact the resulting hole.
 */

int
fru_delete_packet(packet_hdl_t packet, segment_hdl_t *newsegment,
                                                door_cred_t *cred)
{
        int             retval;
        int             fd;
        char            trailer[] = { 0x0c, 0x00, 0x00, 0x00, 0x00};
        uint32_t        crc;
        hash_obj_t      *tmp_obj;
        hash_obj_t      *pkt_hash;
        hash_obj_t      *sec_hash;
        hash_obj_t      *cont_hash;
        hash_obj_t      *prev_obj;
        hash_obj_t      *seg_hash;
        fru_segdesc_t   *desc;

        /* check the effective uid of the client */
        if (cred->dc_euid != 0) {
                errno = EPERM;
                return (-1);    /* not a root */
        }

        /* packet hash object */
        pkt_hash = lookup_handle_object(packet, PACKET_TYPE);
        if (pkt_hash == NULL) {
                return (-1);
        }

        /* segment hash object */
        seg_hash = lookup_handle_object(pkt_hash->u.pkt_obj->segment_hdl,
                                                        SEGMENT_TYPE);
        if (seg_hash == NULL) {
                return (-1);
        }

        /* check for write perm. */
        desc    = (fru_segdesc_t *)&seg_hash->u.seg_obj->segment.descriptor;
        if (!(desc->field.field_perm & SEGMENT_WRITE)) {
                errno = EPERM;
                return (-1); /* write not allowed */
        }

        /* section hash object */
        sec_hash = lookup_handle_object(seg_hash->u.seg_obj->section_hdl,
                                                        SECTION_TYPE);
        if (sec_hash == NULL) {
                return (-1);
        }

        if (sec_hash->u.sec_obj->section.protection == READ_ONLY_SECTION) {
                errno = EPERM;
                return (-1);            /* read-only section */
        }

        prev_obj        = seg_hash->u.seg_obj->pkt_obj_list;
        if (prev_obj == NULL) {
                return (-1);
        }

        /* container hash object */
        cont_hash = lookup_handle_object(sec_hash->u.sec_obj->cont_hdl,
                                                        CONTAINER_TYPE);
        if (cont_hash == NULL) {
                return (-1);
        }

        fd = open(cont_hash->u.cont_obj->device_pathname, O_RDWR);
        if (fd < 0) {
                return (-1);
        }

        if (prev_obj->obj_hdl == packet) { /* first object to be deleted */
                adjust_packets(fd, prev_obj, prev_obj->u.pkt_obj->next);
                seg_hash->u.seg_obj->trailer_offset -=
                        (prev_obj->u.pkt_obj->tag_size
                                        + prev_obj->u.pkt_obj->paylen);
                free_packet_object(packet, seg_hash);
        } else {
                for (tmp_obj = prev_obj;
                        tmp_obj != NULL; tmp_obj = tmp_obj->u.pkt_obj->next) {
                        /* found the object */
                        if (tmp_obj->obj_hdl == packet) {
                                adjust_packets(fd, tmp_obj,
                                                tmp_obj->u.pkt_obj->next);
                                seg_hash->u.seg_obj->trailer_offset -=
                                        (tmp_obj->u.pkt_obj->tag_size
                                                + tmp_obj->u.pkt_obj->paylen);
                                free_packet_object(packet, seg_hash);
                        }
                }
        }

        seg_hash->u.seg_obj->num_of_packets -= 1;

        /* calculate checksum */
        crc = get_checksum_crc(fd, seg_hash,
                                (seg_hash->u.seg_obj->trailer_offset
                                - seg_hash->u.seg_obj->segment.offset));
        /* write trailer at new offset */
        retval = pwrite(fd, &trailer, sizeof (trailer),
                                        seg_hash->u.seg_obj->trailer_offset);
        if (retval != sizeof (trailer)) {
                (void) close(fd);
                return (-1);
        }

        /* write the checksum value */
        retval = pwrite(fd, &crc, sizeof (crc),
                                seg_hash->u.seg_obj->trailer_offset + 1);
        (void) close(fd);
        if (retval != sizeof (crc)) {
                return (-1);
        }

        *newsegment = seg_hash->obj_hdl; /* return new segment handle */
        return (0);
}

/*
 * Description :
 *              fru_close_container() removes the association between a
 *              container and its handle. this routines free's up all the
 *              hash object contained under container.
 *
 * Arguments   :
 *              container_hdl_t holds the file descriptor of the fru.
 *
 * Return      :
 *              int
 *              return 0.
 *
 */

/* ARGSUSED */
int
fru_close_container(container_hdl_t container)
{
        hash_obj_t      *hash_obj;
        hash_obj_t      *prev_hash;
        hash_obj_t      *sec_hash_obj;
        handle_t        obj_hdl;

        /* lookup for container hash object */
        hash_obj = lookup_handle_object(container, CONTAINER_TYPE);
        if (hash_obj == NULL) {
                return (0);
        }

        /* points to section object list */
        sec_hash_obj = hash_obj->u.cont_obj->sec_obj_list;

        /* traverse section object list */
        while (sec_hash_obj != NULL) {

                /* traverse segment hash object in the section */
                while (sec_hash_obj->u.sec_obj->seg_obj_list != NULL) {
                        /* object handle of the segment hash object */
                        obj_hdl =
                        sec_hash_obj->u.sec_obj->seg_obj_list->obj_hdl;
                        free_segment_hash(obj_hdl, sec_hash_obj);
                }

                /* going to free section hash object, relink the hash object */
                if (sec_hash_obj->prev == NULL) {
                        hash_table[(sec_hash_obj->obj_hdl % TABLE_SIZE)]
                                                        = sec_hash_obj->next;
                        if (sec_hash_obj->next != NULL) {
                                sec_hash_obj->next->prev = NULL;
                        }
                } else {
                        sec_hash_obj->prev->next = sec_hash_obj->next;
                        if (sec_hash_obj->next != NULL) {
                                sec_hash_obj->next->prev = sec_hash_obj->prev;
                        }
                }

                free(sec_hash_obj->u.sec_obj); /* free section hash object */

                prev_hash = sec_hash_obj;

                sec_hash_obj = sec_hash_obj->u.sec_obj->next;

                free(prev_hash); /* free section hash */
        }

        /* free container hash object */
        if (hash_obj->prev == NULL) {
                hash_table[(sec_hash_obj->obj_hdl % TABLE_SIZE)] =
                                                        hash_obj->next;
                if (hash_obj->next != NULL) {
                        hash_obj->next->prev = NULL;
                }
        } else {
                hash_obj->prev->next = hash_obj->next;
                if (hash_obj->next != NULL) {
                        hash_obj->next->prev = hash_obj->prev;
                }
        }

        free(hash_obj->u.cont_obj);
        free(hash_obj);
        return (0);
}

/*
 * Description :
 *              fru_is_data_available() checks to see if the frudata
 *              is available on a fru.
 *
 * Arguments   :
 *              picl_nodehdl_t holds the picl node handle of the fru.
 *
 * Return      :
 *              int
 *              return 1: if FRUID information is available
 *              return 0: if FRUID information is not present
 *
 */

/* ARGSUSED */
int
fru_is_data_available(picl_nodehdl_t fru)
{
        return (0);
}