#if HAVE_CRT
#define _CRTDBG_MAP_ALLOC 
#include <stdlib.h> 
#include <crtdbg.h>
#endif //HAVE_CRT
/*
* Copyright (C) 2020, University of the Basque Country (UPV/EHU)
* Contact for licensing options: <licensing-mcpttclient(at)mcopenplatform(dot)com>
*
* The original file was part of Open Source Doubango Framework
* Copyright (C) 2010-2011 Mamadou Diop.
* Copyright (C) 2012 Doubango Telecom <http://doubango.org>
*
* This file is part of Open Source Doubango Framework.
*
* DOUBANGO is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* DOUBANGO is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with DOUBANGO.
*
*/

#include "tinybfcp/tbfcp_attr.h"

#include "tnet_endianness.h"

#include "tsk_memory.h"
#include "tsk_debug.h"

#define kWithoutPadding		tsk_false
#define kWithPadding		tsk_true

#define ALIGN_ON_32BITS(size_in_octes) if (((size_in_octes) & 3)) (size_in_octes) += (4 - ((size_in_octes) & 3));
#define ALIGN_ON_32BITS_AND_SET_PADDING_ZEROS(p_buffer, size_in_octes) \
	if (((size_in_octes) & 3)) { \
		int c = (4 - ((size_in_octes) & 3)); \
		memset(p_buffer, 0, c); \
		(size_in_octes) += c; \
	}


static enum tbfcp_attribute_format_e _tbfcp_attr_get_format(enum tbfcp_attribute_type_e type)
{
    switch (type) {
    case tbfcp_attribute_type_BENEFICIARY_ID:
        case tbfcp_attribute_type_FLOOR_ID:
            case tbfcp_attribute_type_FLOOR_REQUEST_ID:
                    return tbfcp_attribute_format_Unsigned16;
    case tbfcp_attribute_type_PRIORITY:
    case tbfcp_attribute_type_REQUEST_STATUS:
        return tbfcp_attribute_format_OctetString16;
    case tbfcp_attribute_type_ERROR_CODE:
    case tbfcp_attribute_type_ERROR_INFO:
    case tbfcp_attribute_type_PARTICIPANT_PROVIDED_INFO:
    case tbfcp_attribute_type_STATUS_INFO:
    case tbfcp_attribute_type_SUPPORTED_ATTRIBUTES:
    case tbfcp_attribute_type_SUPPORTED_PRIMITIVES:
    case tbfcp_attribute_type_USER_DISPLAY_NAME:
    case tbfcp_attribute_type_USER_URI:
        return tbfcp_attribute_format_OctetString;
    case tbfcp_attribute_type_BENEFICIARY_INFORMATION:
    case tbfcp_attribute_type_FLOOR_REQUEST_INFORMATION:
    case tbfcp_attribute_type_REQUESTED_BY_INFORMATION:
    case tbfcp_attribute_type_FLOOR_REQUEST_STATUS:
    case tbfcp_attribute_type_OVERALL_REQUEST_STATUS:
        return tbfcp_attribute_format_Grouped;
    default:
        return tbfcp_attribute_format_Unknown;

    }
}

static int _tbfcp_attr_get_size_in_octetunits(const tbfcp_attr_t* pc_self, tsk_bool_t with_padding, tsk_size_t* p_size)
{
    if (!pc_self || !p_size) {
        TSK_DEBUG_ERROR("Invalid parameter");
        return -1;
    }
    switch (pc_self->format) {
    case tbfcp_attribute_format_Unsigned16:
    case tbfcp_attribute_format_OctetString16: {
        *p_size = (TBFCP_ATTR_HDR_SIZE_IN_OCTETS + 2);
        if (with_padding) {
            ALIGN_ON_32BITS(*p_size);
        }
        return 0;
    }
    case tbfcp_attribute_format_OctetString: {
        *p_size = (TBFCP_ATTR_HDR_SIZE_IN_OCTETS + ((const tbfcp_attr_octetstring_t*)pc_self)->OctetStringLength);
		if (with_padding) {
			ALIGN_ON_32BITS(*p_size);
		}
        return 0;
    }
    case tbfcp_attribute_format_Grouped: {
        int ret;
        tsk_size_t n_size;
        const tbfcp_attr_grouped_t* _pc_self = (const tbfcp_attr_grouped_t*)pc_self;
        const tsk_list_item_t* pc_item;
        const tbfcp_attr_t* pc_attr;
        *p_size = TBFCP_ATTR_HDR_SIZE_IN_OCTETS + _pc_self->extra_hdr_size_in_octets;
        tsk_list_foreach(pc_item, _pc_self->p_list_attrs) {
            if ((pc_attr = (const tbfcp_attr_t*)pc_item->data)) {
                if ((ret = tbfcp_attr_get_size_in_octetunits_without_padding(pc_attr, &n_size))) {
                    return ret;
                }
                *p_size += n_size;
            }
        }
        if (with_padding) {
            ALIGN_ON_32BITS(*p_size);
        }
        return 0;
    }
    default: {
        TSK_DEBUG_WARN("Attribute format=%d is unknown. Don't be surprised if something goes wrong.", pc_self->format);
        *p_size = (TBFCP_ATTR_HDR_SIZE_IN_OCTETS + pc_self->hdr.length);
        if (with_padding) {
            ALIGN_ON_32BITS(*p_size);
        }
        return 0;
    }
    }
}

int tbfcp_attr_get_size_in_octetunits_without_padding(const tbfcp_attr_t* pc_self, tsk_size_t* p_size)
{
    return _tbfcp_attr_get_size_in_octetunits(pc_self, kWithoutPadding, p_size);
}

int tbfcp_attr_get_size_in_octetunits_with_padding(const tbfcp_attr_t* pc_self, tsk_size_t* p_size)
{
    return _tbfcp_attr_get_size_in_octetunits(pc_self, kWithPadding, p_size);
}

static int _tbfcp_attr_write(const tbfcp_attr_t* pc_self, uint8_t* p_buff_ptr, tsk_size_t n_buff_size, tsk_bool_t with_padding, tsk_size_t *p_written)
{
    tsk_size_t n_min_req_size;
    int ret;
    if (!pc_self || !p_buff_ptr || !n_buff_size || !p_written) {
        TSK_DEBUG_ERROR("Invalid parameter");
        return -1;
    }
    if ((ret = _tbfcp_attr_get_size_in_octetunits(pc_self, with_padding, &n_min_req_size))) {
        return ret;
    }
    if (n_min_req_size > n_buff_size) {
        TSK_DEBUG_ERROR("Buffer too short %u<%u", n_buff_size, n_min_req_size);
        return -2;
    }

    p_buff_ptr[0] = ((uint8_t)pc_self->hdr.type) << 1;
    p_buff_ptr[0] |= (pc_self->hdr.M & 0x01);

    switch (pc_self->format) {
    case tbfcp_attribute_format_Unsigned16:
    case tbfcp_attribute_format_OctetString16: {
        *p_written = TBFCP_ATTR_HDR_SIZE_IN_OCTETS + 2;
        p_buff_ptr[1] = (uint8_t)*p_written;
        if (pc_self->format == tbfcp_attribute_format_Unsigned16) {
            *((uint16_t*)&p_buff_ptr[2]) = tnet_htons(((const tbfcp_attr_unsigned16_t*)pc_self)->Unsigned16);
        }
        else {
            p_buff_ptr[2] = ((const tbfcp_attr_octetstring16_t*)pc_self)->OctetString16[0];
            p_buff_ptr[3] = ((const tbfcp_attr_octetstring16_t*)pc_self)->OctetString16[1];
        }
        if (with_padding) {
            ALIGN_ON_32BITS_AND_SET_PADDING_ZEROS(&p_buff_ptr[*p_written], *p_written);
        }
        return 0;
    }
    case tbfcp_attribute_format_OctetString: {
        const tbfcp_attr_octetstring_t* _pc_self = (const tbfcp_attr_octetstring_t*)pc_self;
        *p_written = TBFCP_ATTR_HDR_SIZE_IN_OCTETS + ((_pc_self->OctetStringLength && _pc_self->OctetString) ? _pc_self->OctetStringLength : 0);
        p_buff_ptr[1] = (uint8_t)*p_written;
        if (_pc_self->OctetStringLength && _pc_self->OctetString) {
            memcpy(&p_buff_ptr[2], _pc_self->OctetString, _pc_self->OctetStringLength);
        }
        if (with_padding) {
            ALIGN_ON_32BITS_AND_SET_PADDING_ZEROS(&p_buff_ptr[*p_written], *p_written);
        }
        return 0;
    }
    case tbfcp_attribute_format_Grouped: {
        int ret;
        tsk_size_t n_written;
        const tbfcp_attr_grouped_t* _pc_self = (const tbfcp_attr_grouped_t*)pc_self;
        const tsk_list_item_t* pc_item;
        const tbfcp_attr_t* pc_attr;
        if (_pc_self->extra_hdr_size_in_octets && _pc_self->extra_hdr_size_in_octets != 2) {
            TSK_DEBUG_ERROR("extra_hdr_size_in_octets=%u not valid", _pc_self->extra_hdr_size_in_octets); // for now only 2byte extra values is supported
            return -2;
        }
        if ((ret = tbfcp_attr_get_size_in_octetunits_without_padding(pc_self, p_written))) {
            return ret;
        }
        p_buff_ptr[1] = (uint8_t)*p_written;
        p_buff_ptr += 2;
        n_buff_size -= 2;
        if (_pc_self->extra_hdr_size_in_octets) {
            *((uint16_t*)p_buff_ptr) = tnet_htons_2(&_pc_self->extra_hdr);
            p_buff_ptr += _pc_self->extra_hdr_size_in_octets;
            n_buff_size -= _pc_self->extra_hdr_size_in_octets;
        }
        tsk_list_foreach(pc_item, _pc_self->p_list_attrs) {
            if ((pc_attr = (const tbfcp_attr_t*)pc_item->data)) {
                if ((ret = _tbfcp_attr_write(pc_attr, p_buff_ptr, n_buff_size, kWithoutPadding, &n_written))) {
                    return ret;
                }
                p_buff_ptr += n_written;
                n_buff_size -= n_written;
            }
        }
        if (with_padding) {
            ALIGN_ON_32BITS_AND_SET_PADDING_ZEROS(&p_buff_ptr[*p_written], *p_written);
        }
        return 0;
    }
    default: {
        TSK_DEBUG_ERROR("Attribute format=%d is unknown.", pc_self->format);
        return -2;
    }
    }
}

int tbfcp_attr_write_without_padding(const tbfcp_attr_t* pc_self, uint8_t* p_buff_ptr, tsk_size_t n_buff_size, tsk_size_t *p_written)
{
    return _tbfcp_attr_write(pc_self, p_buff_ptr, n_buff_size, kWithoutPadding, p_written);
}

int tbfcp_attr_write_with_padding(const tbfcp_attr_t* pc_self, uint8_t* p_buff_ptr, tsk_size_t n_buff_size, tsk_size_t *p_written)
{
    return _tbfcp_attr_write(pc_self, p_buff_ptr, n_buff_size, kWithPadding, p_written);
}

int tbfcp_attr_read(const uint8_t* pc_buff_ptr, tsk_size_t n_buff_size, tsk_size_t *p_consumed_octets, tbfcp_attr_t** pp_attr)
{
    uint8_t M, Length, PadLength;
    tbfcp_attribute_type_t Type;
    tbfcp_attribute_format_t Format;
    int ret;
    if (!pc_buff_ptr || !n_buff_size || !pp_attr || !p_consumed_octets) {
        TSK_DEBUG_ERROR("Invalid parameter");
        return -1;
    }
    if (n_buff_size < TBFCP_ATTR_HDR_SIZE_IN_OCTETS) {
        TSK_DEBUG_ERROR("Buffer too short(%u)", n_buff_size);
        return -2;
    }

    Length = pc_buff_ptr[1];
    if (Length > n_buff_size) {
        TSK_DEBUG_ERROR("Buffer too short(%u). Length=%u", n_buff_size, Length);
        return -3;
    }

    PadLength = (Length & 0x03) ? (4 - (Length & 0x03)) : 0;

    *pp_attr = tsk_null;
    *p_consumed_octets = Length + PadLength;

    Type = (pc_buff_ptr[0] >> 1) & 0x7F;
    M = (pc_buff_ptr[0] & 0x01);
    Format = _tbfcp_attr_get_format(Type);
    if (Format == tbfcp_attribute_format_Unknown) {
        return 0;
    }

    if (Format == tbfcp_attribute_format_Unsigned16) {
        uint16_t Unsigned16 = tnet_ntohs_2(&pc_buff_ptr[2]);
        if ((ret = tbfcp_attr_unsigned16_create(Type, M, Unsigned16, (tbfcp_attr_unsigned16_t**)pp_attr))) {
            return ret;
        }
    }
    else if (Format == tbfcp_attribute_format_OctetString16) {
        uint8_t OctetString16[2];
        OctetString16[0] = pc_buff_ptr[2];
        OctetString16[1] = pc_buff_ptr[3];
        if ((ret = tbfcp_attr_octetstring16_create(Type, M, OctetString16, (tbfcp_attr_octetstring16_t**)pp_attr))) {
            return ret;
        }
    }
    else if (Format == tbfcp_attribute_format_OctetString) {
        const uint8_t *OctetString = &pc_buff_ptr[TBFCP_ATTR_HDR_SIZE_IN_OCTETS];
        uint8_t OctetStringLength = (Length - TBFCP_ATTR_HDR_SIZE_IN_OCTETS);
        if ((ret = tbfcp_attr_octetstring_create(Type, M, OctetString, OctetStringLength, (tbfcp_attr_octetstring_t**)pp_attr))) {
            return ret;
        }
    }
    else if (Format == tbfcp_attribute_format_Grouped) {
        tbfcp_attr_grouped_t* p_attr;
        if ((ret = tbfcp_attr_grouped_create(Type, M, &p_attr))) {
            return ret;
        }
        *pp_attr = (tbfcp_attr_t*)p_attr;
        switch (Type) {
        case tbfcp_attribute_type_BENEFICIARY_INFORMATION: {
            p_attr->extra_hdr_size_in_octets = 2;
            p_attr->extra_hdr.BeneficiaryID = tnet_ntohs_2(&pc_buff_ptr[2]);
            break;
        }
        case tbfcp_attribute_type_FLOOR_REQUEST_INFORMATION: {
            p_attr->extra_hdr_size_in_octets = 2;
            p_attr->extra_hdr.FloorRequestID = tnet_ntohs_2(&pc_buff_ptr[2]);
            break;
        }
        case tbfcp_attribute_type_REQUESTED_BY_INFORMATION: {
            p_attr->extra_hdr_size_in_octets = 2;
            p_attr->extra_hdr.RequestedbyID = tnet_ntohs_2(&pc_buff_ptr[2]);
            break;
        }
        case tbfcp_attribute_type_FLOOR_REQUEST_STATUS: {
            p_attr->extra_hdr_size_in_octets = 2;
            p_attr->extra_hdr.FloorID = tnet_ntohs_2(&pc_buff_ptr[2]);
            break;
        }
        case tbfcp_attribute_type_OVERALL_REQUEST_STATUS: {
            p_attr->extra_hdr_size_in_octets = 2;
            p_attr->extra_hdr.FloorRequestID = tnet_ntohs_2(&pc_buff_ptr[2]);
            break;
        }
        default: {
            return 0;
        }
        }
        if ((TBFCP_ATTR_HDR_SIZE_IN_OCTETS + p_attr->extra_hdr_size_in_octets) < Length) {
            tsk_size_t n_consumed_octets, PayloadLength = Length;
            PayloadLength -= TBFCP_ATTR_HDR_SIZE_IN_OCTETS + p_attr->extra_hdr_size_in_octets;
            pc_buff_ptr += TBFCP_ATTR_HDR_SIZE_IN_OCTETS + p_attr->extra_hdr_size_in_octets;
            if (PayloadLength >= TBFCP_ATTR_HDR_SIZE_IN_OCTETS) {
                do {
                    if ((ret = tbfcp_attr_read(pc_buff_ptr, PayloadLength, &n_consumed_octets, (tbfcp_attr_t**)&p_attr))) {
                        break;
                    }
                    if ((ret = tbfcp_attr_grouped_add_attr((tbfcp_attr_grouped_t*)(*pp_attr), (tbfcp_attr_t**)&p_attr))) {
                        TSK_OBJECT_SAFE_FREE(p_attr);
                        break;
                    }
                    pc_buff_ptr += n_consumed_octets;
                    PayloadLength -= n_consumed_octets;
                }
                while (PayloadLength >= TBFCP_ATTR_HDR_SIZE_IN_OCTETS);
            }
        }
    }
    else {
        TSK_DEBUG_ERROR("%d not valid attribute format", Format);
        return -4;
    }
    return 0;
}


static int _tbfcp_attr_init(tbfcp_attr_t* p_self, tbfcp_attribute_type_t type, unsigned M, uint8_t length)
{
    if (!p_self) {
        TSK_DEBUG_ERROR("Invalid parameter");
        return -1;
    }
    if (!p_self->pc_base) {
        p_self->pc_base = p_self;
    }
    p_self->hdr.type = type;
    p_self->hdr.M = M;
    p_self->hdr.length = length;
    if ((p_self->format = _tbfcp_attr_get_format(type)) == tbfcp_attribute_format_Unknown) {
        TSK_DEBUG_WARN("Attribute type=%d is unknown...setting its format to UNKNOWN. Don't be surprised if something goes wrong.", type);
    }

    return 0;
}


/*************** tbfcp_attr_unsigned16 *******************/
int tbfcp_attr_unsigned16_create(tbfcp_attribute_type_t type, unsigned M, uint16_t Unsigned16, tbfcp_attr_unsigned16_t** pp_self)
{
    extern const tsk_object_def_t *tbfcp_attr_unsigned16_def_t;
    tbfcp_attr_unsigned16_t* p_self;
    int ret;
    if (!pp_self) {
        TSK_DEBUG_ERROR("Invalid parameter");
        return -1;
    }
    if (!(p_self = tsk_object_new(tbfcp_attr_unsigned16_def_t))) {
        TSK_DEBUG_ERROR("Failed to create 'tbfcp_attr_unsigned16_def_t' object");
        return -2;
    }
    if ((ret = _tbfcp_attr_init(TBFCP_ATTR(p_self), type, M, TBFCP_ATTR_HDR_SIZE_IN_OCTETS + 2))) {
        TSK_OBJECT_SAFE_FREE(p_self);
        return -3;
    }
    if (TBFCP_ATTR(p_self)->format != tbfcp_attribute_format_Unsigned16) {
        TSK_DEBUG_ERROR("Format mismatch");
        TSK_OBJECT_SAFE_FREE(p_self);
        return -4;
    }
    p_self->Unsigned16 = Unsigned16;
    *pp_self = p_self;
    return 0;
}

static tsk_object_t* tbfcp_attr_unsigned16_ctor(tsk_object_t * self, va_list * app)
{
    tbfcp_attr_unsigned16_t *p_u16 = (tbfcp_attr_unsigned16_t *)self;
    if (p_u16) {
    }
    return self;
}
static tsk_object_t* tbfcp_attr_unsigned16_dtor(tsk_object_t * self)
{
    tbfcp_attr_unsigned16_t *p_u16 = (tbfcp_attr_unsigned16_t *)self;
    if (p_u16) {
        TSK_DEBUG_INFO("*** BFCP Attribute(Unsigned16) destroyed ***");

    }
    return self;
}
static int tbfcp_attr_unsigned16_cmp(const tsk_object_t *_att1, const tsk_object_t *_att2)
{
    const tbfcp_attr_unsigned16_t *pc_att1 = (const tbfcp_attr_unsigned16_t *)_att1;
    const tbfcp_attr_unsigned16_t *pc_att2 = (const tbfcp_attr_unsigned16_t *)_att2;

    return (int)(pc_att1-pc_att2);
}
static const tsk_object_def_t tbfcp_attr_unsigned16_def_s = {
    sizeof(tbfcp_attr_unsigned16_t),
    tbfcp_attr_unsigned16_ctor,
    tbfcp_attr_unsigned16_dtor,
    tbfcp_attr_unsigned16_cmp,
};
const tsk_object_def_t *tbfcp_attr_unsigned16_def_t = &tbfcp_attr_unsigned16_def_s;




/*************** tbfcp_attr_octetstring16 *******************/
int tbfcp_attr_octetstring16_create(tbfcp_attribute_type_t type, unsigned M, uint8_t OctetString16[2], tbfcp_attr_octetstring16_t** pp_self)
{
    extern const tsk_object_def_t *tbfcp_attr_octetstring16_def_t;
    tbfcp_attr_octetstring16_t* p_self;
    int ret;
    if (!pp_self) {
        TSK_DEBUG_ERROR("Invalid parameter");
        return -1;
    }
    if (!(p_self = tsk_object_new(tbfcp_attr_octetstring16_def_t))) {
        TSK_DEBUG_ERROR("Failed to create 'tbfcp_attr_octetstring16_def_t' object");
        return -2;
    }
    if ((ret = _tbfcp_attr_init(TBFCP_ATTR(p_self), type, M, TBFCP_ATTR_HDR_SIZE_IN_OCTETS + 2))) {
        TSK_OBJECT_SAFE_FREE(p_self);
        return -3;
    }
    if (TBFCP_ATTR(p_self)->format != tbfcp_attribute_format_OctetString16) {
        TSK_DEBUG_ERROR("Format mismatch");
        TSK_OBJECT_SAFE_FREE(p_self);
        return -4;
    }
    p_self->OctetString16[0] = OctetString16[0];
    p_self->OctetString16[1] = OctetString16[1];
    *pp_self = p_self;
    return 0;
}

static tsk_object_t* tbfcp_attr_octetstring16_ctor(tsk_object_t * self, va_list * app)
{
    tbfcp_attr_octetstring16_t *p_os16 = (tbfcp_attr_octetstring16_t *)self;
    if (p_os16) {
    }
    return self;
}
static tsk_object_t* tbfcp_attr_octetstring16_dtor(tsk_object_t * self)
{
    tbfcp_attr_octetstring16_t *p_os16 = (tbfcp_attr_octetstring16_t *)self;
    if (p_os16) {
        TSK_DEBUG_INFO("*** BFCP Attribute(OctetString16) destroyed ***");

    }
    return self;
}
static int tbfcp_attr_octetstring16_cmp(const tsk_object_t *_att1, const tsk_object_t *_att2)
{
    const tbfcp_attr_octetstring16_t *pc_att1 = (const tbfcp_attr_octetstring16_t *)_att1;
    const tbfcp_attr_octetstring16_t *pc_att2 = (const tbfcp_attr_octetstring16_t *)_att2;

    return (int)(pc_att1-pc_att2);
}
static const tsk_object_def_t tbfcp_attr_octetstring16_def_s = {
    sizeof(tbfcp_attr_octetstring16_t),
    tbfcp_attr_octetstring16_ctor,
    tbfcp_attr_octetstring16_dtor,
    tbfcp_attr_octetstring16_cmp,
};
const tsk_object_def_t *tbfcp_attr_octetstring16_def_t = &tbfcp_attr_octetstring16_def_s;


/*************** tbfcp_attr_octetstring *******************/
int tbfcp_attr_octetstring_create(tbfcp_attribute_type_t type, unsigned M, const uint8_t *OctetString, uint8_t OctetStringLength, tbfcp_attr_octetstring_t** pp_self)
{
    extern const tsk_object_def_t *tbfcp_attr_octetstring_def_t;
    tbfcp_attr_octetstring_t* p_self;
    int ret;
    if (!pp_self) {
        TSK_DEBUG_ERROR("Invalid parameter");
        return -1;
    }
    if (!(p_self = tsk_object_new(tbfcp_attr_octetstring_def_t))) {
        TSK_DEBUG_ERROR("Failed to create 'tbfcp_attr_octetstring_def_t' object");
        return -2;
    }
    if ((ret = _tbfcp_attr_init(TBFCP_ATTR(p_self), type, M, (TBFCP_ATTR_HDR_SIZE_IN_OCTETS + OctetStringLength)))) {
        TSK_OBJECT_SAFE_FREE(p_self);
        return -3;
    }
    if (TBFCP_ATTR(p_self)->format != tbfcp_attribute_format_OctetString) {
        TSK_DEBUG_ERROR("Format mismatch");
        TSK_OBJECT_SAFE_FREE(p_self);
        return -4;
    }
    if (OctetStringLength) {
		#if HAVE_CRT //Debug memory
        if (!(p_self->OctetString = malloc(OctetStringLength))) {
		
		#else
        if (!(p_self->OctetString = tsk_malloc(OctetStringLength))) {
		
		#endif //HAVE_CRT
            TSK_DEBUG_ERROR("Failed to alloc %u octets", OctetStringLength);
            TSK_OBJECT_SAFE_FREE(p_self);
            return -5;
        }
        if (OctetString) {
            memcpy(p_self->OctetString, OctetString, OctetStringLength);
        }
        p_self->OctetStringLength = OctetStringLength;
    }
    else {
        TBFCP_ATTR(p_self)->hdr.length = TBFCP_ATTR_HDR_SIZE_IN_OCTETS;
        p_self->OctetStringLength = 0;
    }
    *pp_self = p_self;
    return 0;
}

static tsk_object_t* tbfcp_attr_octetstring_ctor(tsk_object_t * self, va_list * app)
{
    tbfcp_attr_octetstring_t *p_os = (tbfcp_attr_octetstring_t *)self;
    if (p_os) {
    }
    return self;
}
static tsk_object_t* tbfcp_attr_octetstring_dtor(tsk_object_t * self)
{
    tbfcp_attr_octetstring_t *p_os = (tbfcp_attr_octetstring_t *)self;
    if (p_os) {
        TSK_DEBUG_INFO("*** BFCP Attribute(OctetString) destroyed ***");
        TSK_SAFE_FREE(p_os->OctetString);
    }
    return self;
}
static int tbfcp_attr_octetstring_cmp(const tsk_object_t *_att1, const tsk_object_t *_att2)
{
    const tbfcp_attr_octetstring_t *pc_att1 = (const tbfcp_attr_octetstring_t *)_att1;
    const tbfcp_attr_octetstring_t *pc_att2 = (const tbfcp_attr_octetstring_t *)_att2;

    return (int)(pc_att1-pc_att2);
}
static const tsk_object_def_t tbfcp_attr_octetstring_def_s = {
    sizeof(tbfcp_attr_octetstring_t),
    tbfcp_attr_octetstring_ctor,
    tbfcp_attr_octetstring_dtor,
    tbfcp_attr_octetstring_cmp,
};
const tsk_object_def_t *tbfcp_attr_octetstring_def_t = &tbfcp_attr_octetstring_def_s;



/*************** tbfcp_attr_grouped *******************/
int tbfcp_attr_grouped_create(tbfcp_attribute_type_t type, unsigned M, tbfcp_attr_grouped_t** pp_self)
{
    extern const tsk_object_def_t *tbfcp_attr_grouped_def_t;
    tbfcp_attr_grouped_t* p_self;
    int ret;
    if (!pp_self) {
        TSK_DEBUG_ERROR("Invalid parameter");
        return -1;
    }
    if (!(p_self = tsk_object_new(tbfcp_attr_grouped_def_t))) {
        TSK_DEBUG_ERROR("Failed to create 'tbfcp_attr_grouped_def_t' object");
        return -2;
    }
    if ((ret = _tbfcp_attr_init(TBFCP_ATTR(p_self), type, M, TBFCP_ATTR_HDR_SIZE_IN_OCTETS + 0))) {
        TSK_OBJECT_SAFE_FREE(p_self);
        return -3;
    }
    if (TBFCP_ATTR(p_self)->format != tbfcp_attribute_format_Grouped) {
        TSK_DEBUG_ERROR("Format mismatch");
        TSK_OBJECT_SAFE_FREE(p_self);
        return -4;
    }
    if (!(p_self->p_list_attrs = tsk_list_create())) {
        TSK_DEBUG_ERROR("Failed to create empty list");
        TSK_OBJECT_SAFE_FREE(p_self);
        return -5;
    }

    *pp_self = p_self;
    return 0;
}

int tbfcp_attr_grouped_create_u16(tbfcp_attribute_type_t type, unsigned M, uint16_t extra_hdr_u16_val, tbfcp_attr_grouped_t** pp_self)
{
    int ret;
    if ((ret = tbfcp_attr_grouped_create(type, M, pp_self))) {
        return ret;
    }
    *((uint16_t*)&(*pp_self)->extra_hdr) = extra_hdr_u16_val;
    (*pp_self)->extra_hdr_size_in_octets = 2;
    return 0;
}

int tbfcp_attr_grouped_add_attr(tbfcp_attr_grouped_t* p_self, tbfcp_attr_t** p_attr)
{
    if (!p_self || !p_attr) {
        TSK_DEBUG_ERROR("Invalid parameter");
        return -1;
    }
    tsk_list_push_back_data(p_self->p_list_attrs, (void**)p_attr);
    return 0;
}

int tbfcp_attr_grouped_find_at(const struct tbfcp_attr_grouped_s* pc_self, enum tbfcp_attribute_format_e e_format, tsk_size_t u_index, const struct tbfcp_attr_s** ppc_attr)
{
	tsk_size_t _u_index = 0;
	const tsk_list_item_t *pc_item;
	const struct tbfcp_attr_s* pc_attr;
	if (!pc_self || !ppc_attr) {
		TSK_DEBUG_ERROR("Invalid parameter");
		return -1;
	}
	*ppc_attr = tsk_null;
	tsk_list_foreach(pc_item, pc_self->p_list_attrs) {
		pc_attr = (const struct tbfcp_attr_s*)pc_item->data;
		if (!pc_attr || pc_attr->format != e_format) {
			continue;
		}
		if (_u_index++ >= u_index) {
			*ppc_attr = pc_attr;
			break;
		}
	}
	return 0;
}

static tsk_object_t* tbfcp_attr_grouped_ctor(tsk_object_t * self, va_list * app)
{
    tbfcp_attr_grouped_t *p_gr = (tbfcp_attr_grouped_t *)self;
    if (p_gr) {
    }
    return self;
}
static tsk_object_t* tbfcp_attr_grouped_dtor(tsk_object_t * self)
{
    tbfcp_attr_grouped_t *p_gr = (tbfcp_attr_grouped_t *)self;
    if (p_gr) {
        TSK_DEBUG_INFO("*** BFCP Attribute(Grouped) destroyed ***");
        TSK_OBJECT_SAFE_FREE(p_gr->p_list_attrs);
    }
    return self;
}
static int tbfcp_attr_grouped_cmp(const tsk_object_t *_att1, const tsk_object_t *_att2)
{
    const tbfcp_attr_grouped_t *pc_att1 = (const tbfcp_attr_grouped_t *)_att1;
    const tbfcp_attr_grouped_t *pc_att2 = (const tbfcp_attr_grouped_t *)_att2;

    return (int)(pc_att1-pc_att2);
}
static const tsk_object_def_t tbfcp_attr_grouped_def_s = {
    sizeof(tbfcp_attr_grouped_t),
    tbfcp_attr_grouped_ctor,
    tbfcp_attr_grouped_dtor,
    tbfcp_attr_grouped_cmp,
};
const tsk_object_def_t *tbfcp_attr_grouped_def_t = &tbfcp_attr_grouped_def_s;