-

4 files changed, 2491 insertions, 0 deletions

diff --git a/tinyBFCP/src/tbfcp_attr.c b/tinyBFCP/src/tbfcp_attr.c
new file mode 100644
index 0000000..7b5359a
--- /dev/null
+++ b/tinyBFCP/src/tbfcp_attr.c
@@ -0,0 +1,674 @@
+/* Copyright (C) 2014 Mamadou DIOP.
+*
+* 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 Lesser 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 (!(p_self->OctetString = tsk_malloc(OctetStringLength))) {
+            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;
diff --git a/tinyBFCP/src/tbfcp_pkt.c b/tinyBFCP/src/tbfcp_pkt.c
new file mode 100644
index 0000000..0adff65
--- /dev/null
+++ b/tinyBFCP/src/tbfcp_pkt.c
@@ -0,0 +1,585 @@
+/* Copyright (C) 2014 Mamadou DIOP.
+*
+* 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 Lesser General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with DOUBANGO.
+*
+*/
+#include "tinybfcp/tbfcp_pkt.h"
+
+#include "tnet_endianness.h"
+
+#include "tsk_debug.h"
+
+#define SWITCH_CASE_TAKE_ATTR(type, cat, field) \
+		case (type): \
+		if (!p_self->##field) { \
+			p_self->##field = (cat)*pp_attr, *pp_attr = tsk_null; \
+            return 0; \
+        } \
+        break;
+
+static int _tbfcp_pkt_add_attr(tbfcp_pkt_t* p_self, tbfcp_attr_t** pp_attr)
+{
+    if (!p_self || !pp_attr || !*pp_attr) {
+        TSK_DEBUG_ERROR("Invalid parameter");
+        return -1;
+    }
+    tsk_list_push_back_data(p_self->p_list_attrs, (void**)pp_attr);
+    return 0;
+}
+
+static int _tbfcp_pkt_deinit(tbfcp_pkt_t *p_self)
+{
+    if (!p_self) {
+        TSK_DEBUG_ERROR("Invalid parameter");
+        return -1;
+    }
+
+    TSK_OBJECT_SAFE_FREE(p_self->p_list_attrs);
+    return 0;
+}
+
+static int _tbfcp_pkt_init(tbfcp_pkt_t *p_self, tbfcp_primitive_t primitive, uint32_t conf_id, uint16_t transac_id, uint16_t user_id)
+{
+    if (!p_self) {
+        TSK_DEBUG_ERROR("Invalid parameter");
+        return -1;
+    }
+
+    if (!p_self->p_list_attrs && !(p_self->p_list_attrs = tsk_list_create())) {
+        TSK_DEBUG_ERROR("Failed to create list");
+        return -2;
+    }
+    if (!p_self->f_add_attr) {
+        p_self->f_add_attr = _tbfcp_pkt_add_attr;
+    }
+
+    p_self->hdr.ver = TBFCP_VERSION;
+    p_self->hdr.reserved = 0;
+    p_self->hdr.primitive = primitive;
+    p_self->hdr.conf_id = conf_id;
+    p_self->hdr.transac_id = transac_id;
+    p_self->hdr.user_id = user_id;
+
+    return 0;
+}
+#define _tbfcp_pkt_init_empty(p_self, primitive) _tbfcp_pkt_init((p_self), (primitive), 0, 0, 0)
+
+static int _tbfcp_pkt_init_2(tbfcp_pkt_t *p_self, tbfcp_primitive_t primitive)
+{
+    if (!p_self) {
+        TSK_DEBUG_ERROR("Invalid parameter");
+        return -1;
+    }
+
+    if (!p_self->p_list_attrs && !(p_self->p_list_attrs = tsk_list_create())) {
+        TSK_DEBUG_ERROR("Failed to create list");
+        return -2;
+    }
+
+    p_self->hdr.ver = TBFCP_VERSION;
+    p_self->hdr.reserved = 0;
+    p_self->hdr.primitive = primitive;
+
+    return 0;
+}
+
+int tbfcp_pkt_add_attr(tbfcp_pkt_t* p_self, tbfcp_attr_t** pp_attr)
+{
+    if (!p_self || !pp_attr || !*pp_attr) {
+        TSK_DEBUG_ERROR("Invalid parameter");
+        return -1;
+    }
+    if (p_self->f_add_attr) {
+        return p_self->f_add_attr(p_self, pp_attr);
+    }
+    return _tbfcp_pkt_add_attr(p_self, pp_attr);
+}
+
+
+int tbfcp_pkt_create_empty(tbfcp_primitive_t primitive, tbfcp_pkt_t** pp_self)
+{
+    extern const tsk_object_def_t *tbfcp_pkt_def_t;
+    tbfcp_pkt_t* p_self;
+    int ret;
+
+    if (!pp_self) {
+        TSK_DEBUG_ERROR("Invalid parameter");
+        return -1;
+    }
+    if (!(p_self = tsk_object_new(tbfcp_pkt_def_t))) {
+        TSK_DEBUG_ERROR("Failed to create object 'tbfcp_pkt_def_t'");
+        return -2;
+    }
+    if ((ret = _tbfcp_pkt_init_empty(p_self, primitive))) {
+        TSK_OBJECT_SAFE_FREE(p_self);
+        return ret;
+    }
+    *pp_self = p_self;
+    return 0;
+}
+
+int tbfcp_pkt_create(tbfcp_primitive_t primitive, uint32_t conf_id, uint16_t transac_id, uint16_t user_id, tbfcp_pkt_t** pp_self)
+{
+    int ret;
+
+    if ((ret = tbfcp_pkt_create_empty(primitive, pp_self))) {
+        return ret;
+    }
+    if ((ret = _tbfcp_pkt_init((*pp_self), primitive, conf_id, transac_id, user_id))) {
+        TSK_OBJECT_SAFE_FREE((*pp_self));
+        return ret;
+    }
+    return ret;
+}
+
+int tbfcp_pkt_get_size_in_octetunits_without_padding(const tbfcp_pkt_t* pc_self, tsk_size_t* p_size)
+{
+    const tsk_list_item_t* pc_item;
+    const tbfcp_attr_t* pc_attr;
+    tsk_size_t n_size;
+    int ret;
+    if (!pc_self || !p_size) {
+        TSK_DEBUG_ERROR("Invalid parameter");
+        return -1;
+    }
+    *p_size = TBFCP_PKT_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;
+        }
+    }
+    return 0;
+}
+
+int tbfcp_pkt_get_size_in_octetunits_with_padding(const tbfcp_pkt_t* pc_self, tsk_size_t* p_size)
+{
+    const tsk_list_item_t* pc_item;
+    const tbfcp_attr_t* pc_attr;
+    tsk_size_t n_size;
+    int ret;
+    if (!pc_self || !p_size) {
+        TSK_DEBUG_ERROR("Invalid parameter");
+        return -1;
+    }
+    *p_size = TBFCP_PKT_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_with_padding(pc_attr, &n_size))) {
+                return ret;
+            }
+            *p_size += n_size;
+        }
+    }
+    return 0;
+}
+
+int tbfcp_pkt_write_with_padding(const tbfcp_pkt_t* pc_self, uint8_t* p_buff_ptr, tsk_size_t n_buff_size, tsk_size_t *p_written)
+{
+    const tsk_list_item_t* pc_item;
+    const tbfcp_attr_t* pc_attr;
+    tsk_size_t n_size;
+    int ret;
+    if (!pc_self || !p_buff_ptr || !n_buff_size || !p_written) {
+        TSK_DEBUG_ERROR("Invalid parameter");
+        return -1;
+    }
+    if ((ret = tbfcp_pkt_get_size_in_octetunits_with_padding(pc_self, p_written))) {
+        return ret;
+    }
+    if ((n_buff_size < *p_written)) {
+        TSK_DEBUG_ERROR("Buffer too short: %u<%u", n_buff_size, *p_written);
+        return -1;
+    }
+
+    p_buff_ptr[0] = (((uint8_t)pc_self->hdr.ver) << 5) | (pc_self->hdr.reserved & 0x7F);
+    p_buff_ptr[1] = (uint8_t)pc_self->hdr.primitive;
+	*((uint32_t*)&p_buff_ptr[2]) = tnet_htons((unsigned short)((*p_written - TBFCP_PKT_HDR_SIZE_IN_OCTETS) >> 2));
+    *((uint32_t*)&p_buff_ptr[4]) = (uint32_t)tnet_htonl(pc_self->hdr.conf_id);
+    *((uint16_t*)&p_buff_ptr[8]) = tnet_htons(pc_self->hdr.transac_id);
+    *((uint16_t*)&p_buff_ptr[10]) = tnet_htons(pc_self->hdr.user_id);
+
+    p_buff_ptr += TBFCP_PKT_HDR_SIZE_IN_OCTETS;
+    n_buff_size -= TBFCP_PKT_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_with_padding(pc_attr, p_buff_ptr, n_buff_size, &n_size))) {
+                return ret;
+            }
+            p_buff_ptr += n_size;
+            n_buff_size -= n_size;
+        }
+    }
+    return 0;
+}
+
+// Useful to check TCP stream contains at least a complete BFCP packet
+int tbfcp_pkt_is_complete(const uint8_t* pc_buff_ptr, tsk_size_t n_buff_size, tsk_bool_t *pb_is_complete)
+{
+    if (!pb_is_complete) {
+        TSK_DEBUG_ERROR("Invalid parameter");
+        return -1;
+    }
+    *pb_is_complete = tsk_false;
+    if (pc_buff_ptr && n_buff_size >= TBFCP_PKT_HDR_SIZE_IN_OCTETS) {
+        tsk_size_t n_paylen_in_octets = (tnet_ntohs_2(&pc_buff_ptr[2]) << 2);
+        *pb_is_complete = ((n_buff_size - TBFCP_PKT_HDR_SIZE_IN_OCTETS) >= n_paylen_in_octets);
+    }
+    return 0;
+}
+
+int tbfcp_pkt_read(const uint8_t* pc_buff_ptr, tsk_size_t n_buff_size, tbfcp_pkt_t** pp_pkt)
+{
+    tsk_bool_t b_is_complete;
+    tsk_size_t PayloadLengthInOctets;
+    tbfcp_primitive_t Primitive;
+    uint32_t ConferenceID;
+    uint16_t TransactionID, UserID;
+    int ret, Ver;
+    if (!pc_buff_ptr || !n_buff_size || !pp_pkt) {
+        TSK_DEBUG_ERROR("Invalid parameter");
+        return -1;
+    }
+    if ((ret = tbfcp_pkt_is_complete(pc_buff_ptr, n_buff_size, &b_is_complete))) {
+        return ret;
+    }
+    if (!b_is_complete) {
+        TSK_DEBUG_ERROR("Buffer too short(%u)", n_buff_size);
+        return -2;
+    }
+    Ver = (pc_buff_ptr[0] >> 5) & 0x07;
+    if (Ver != TBFCP_VERSION) {
+        TSK_DEBUG_ERROR("Version(%d)<>%d", Ver, TBFCP_VERSION);
+        return -3;
+    }
+    Primitive = (tbfcp_primitive_t)pc_buff_ptr[1];
+    PayloadLengthInOctets = (tnet_ntohs_2(&pc_buff_ptr[2]) << 2);
+    ConferenceID = (uint32_t)tnet_ntohl_2(&pc_buff_ptr[4]);
+    TransactionID = tnet_ntohs_2(&pc_buff_ptr[8]);
+    UserID = tnet_ntohs_2(&pc_buff_ptr[10]);
+
+    if((ret = tbfcp_pkt_create(Primitive, ConferenceID, TransactionID, UserID, pp_pkt))) {
+        return ret;
+    }
+
+    if (PayloadLengthInOctets > 0) {
+        tbfcp_attr_t* p_attr;
+        tsk_size_t n_consumed_octets;
+        pc_buff_ptr += TBFCP_PKT_HDR_SIZE_IN_OCTETS;
+        do {
+            if ((ret = tbfcp_attr_read(pc_buff_ptr, PayloadLengthInOctets, &n_consumed_octets, &p_attr))) {
+                return ret;
+            }
+            if ((ret = tbfcp_pkt_add_attr((*pp_pkt), &p_attr))) {
+                TSK_OBJECT_SAFE_FREE((*pp_pkt));
+                return ret;
+            }
+            PayloadLengthInOctets -= n_consumed_octets;
+            pc_buff_ptr += n_consumed_octets;
+        }
+        while (PayloadLengthInOctets >= TBFCP_ATTR_HDR_SIZE_IN_OCTETS);
+    }
+
+    return 0;
+}
+
+int tbfcp_pkt_attr_find_at(const struct tbfcp_pkt_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_pkt_ctor(tsk_object_t * self, va_list * app)
+{
+    tbfcp_pkt_t *p_pkt = (tbfcp_pkt_t *)self;
+    if (p_pkt) {
+        p_pkt->f_add_attr = _tbfcp_pkt_add_attr;
+        if (!(p_pkt->p_list_attrs = tsk_list_create())) {
+            TSK_DEBUG_ERROR("Failed to create list");
+            return tsk_null;
+        }
+    }
+    return self;
+}
+static tsk_object_t* tbfcp_pkt_dtor(tsk_object_t * self)
+{
+    tbfcp_pkt_t *p_pkt = (tbfcp_pkt_t *)self;
+    if (p_pkt) {
+        TSK_DEBUG_INFO("*** BFCP Packet destroyed ***");
+        TSK_OBJECT_SAFE_FREE(p_pkt->p_list_attrs);
+    }
+
+    return self;
+}
+static int tbfcp_pkt_cmp(const tsk_object_t *_pk1, const tsk_object_t *_pk2)
+{
+    const tbfcp_pkt_t *pc_pk1 = (const tbfcp_pkt_t *)_pk1;
+    const tbfcp_pkt_t *pc_pk2 = (const tbfcp_pkt_t *)_pk2;
+
+    return (int)(pc_pk1-pc_pk2);
+}
+static const tsk_object_def_t tbfcp_pkt_def_s = {
+    sizeof(tbfcp_pkt_t),
+    tbfcp_pkt_ctor,
+    tbfcp_pkt_dtor,
+    tbfcp_pkt_cmp,
+};
+const tsk_object_def_t *tbfcp_pkt_def_t = &tbfcp_pkt_def_s;
+
+
+/***** rfc4582 - 5.3.1.  FloorRequest *****/
+int tbfcp_pkt_create_FloorRequest_2(uint32_t conf_id, uint16_t transac_id, uint16_t user_id, uint16_t floor_id, tbfcp_pkt_t** pp_self)
+{
+    int ret;
+    tbfcp_attr_unsigned16_t* p_floor_id;
+    if ((ret = tbfcp_pkt_create_FloorRequest(conf_id, transac_id, user_id, pp_self))) {
+        return ret;
+    }
+    if ((ret = tbfcp_attr_unsigned16_create(tbfcp_attribute_type_FLOOR_ID, kBfcpFieldMYes, floor_id, &p_floor_id))) {
+        return ret;
+    }
+    if ((ret = tbfcp_pkt_add_attr(*pp_self, (tbfcp_attr_t**)&p_floor_id))) {
+        TSK_OBJECT_SAFE_FREE(p_floor_id);
+        return ret;
+    }
+    return 0;
+}
+
+/***** rfc4582 - 5.3.2.  FloorRelease  *****/
+int tbfcp_pkt_create_FloorRelease_2(uint32_t conf_id, uint16_t transac_id, uint16_t user_id, uint16_t floor_req_id, tbfcp_pkt_t** pp_self)
+{
+    int ret;
+    tbfcp_attr_unsigned16_t* p_floor_req_id;
+    if ((ret = tbfcp_pkt_create_FloorRelease(conf_id, transac_id, user_id, pp_self))) {
+        return ret;
+    }
+    if ((ret = tbfcp_attr_unsigned16_create(tbfcp_attribute_type_FLOOR_REQUEST_ID, kBfcpFieldMYes, floor_req_id, &p_floor_req_id))) {
+        return ret;
+    }
+    if ((ret = tbfcp_pkt_add_attr(*pp_self, (tbfcp_attr_t**)&p_floor_req_id))) {
+        TSK_OBJECT_SAFE_FREE(p_floor_req_id);
+        return ret;
+    }
+    return 0;
+}
+
+/**** rfc4582 - 5.3.4.  FloorRequestStatus *****/
+int tbfcp_pkt_create_FloorRequestStatus_2(uint32_t conf_id, uint16_t transac_id, uint16_t user_id, uint16_t floor_req_id, tbfcp_pkt_t** pp_self)
+{
+    int ret;
+    tbfcp_attr_grouped_t* p_floor_req_info;
+    if ((ret = tbfcp_pkt_create_FloorRequestStatus(conf_id, transac_id, user_id, pp_self))) {
+        return ret;
+    }
+    if ((ret = tbfcp_attr_grouped_create_u16(tbfcp_attribute_type_FLOOR_REQUEST_INFORMATION, kBfcpFieldMNo, floor_req_id, &p_floor_req_info))) {
+        return ret;
+    }
+    if ((ret = tbfcp_pkt_add_attr(*pp_self, (tbfcp_attr_t**)&p_floor_req_info))) {
+        TSK_OBJECT_SAFE_FREE(p_floor_req_info);
+        return ret;
+    }
+    return 0;
+}
+
+/**** 5.3.12.  HelloAck ***/
+int tbfcp_pkt_create_HelloAck_2(uint32_t conf_id, uint16_t transac_id, uint16_t user_id, struct tbfcp_pkt_s** pp_self)
+{
+    tsk_size_t u;
+    int ret;
+    tbfcp_attr_octetstring_t *p_supp_attr, *p_supp_prim;
+    static const uint8_t* kNullOctetStringPtr = tsk_null;
+    static const tbfcp_primitive_t __supp_prims[] = {
+        tbfcp_primitive_FloorRequest,
+        tbfcp_primitive_FloorRelease,
+        tbfcp_primitive_FloorRequestQuery,
+        tbfcp_primitive_FloorRequestStatus,
+        tbfcp_primitive_UserQuery,
+        tbfcp_primitive_UserStatus,
+        tbfcp_primitive_FloorQuery,
+        tbfcp_primitive_FloorStatus,
+        tbfcp_primitive_ChairAction,
+        tbfcp_primitive_ChairActionAck,
+        tbfcp_primitive_Hello,
+        tbfcp_primitive_HelloAck,
+        tbfcp_primitive_Error,
+    };
+    static const tsk_size_t __supp_prims_count = sizeof(__supp_prims)/sizeof(__supp_prims[0]);
+    static const tbfcp_attribute_type_t __supp_attrs[] = {
+        tbfcp_attribute_type_BENEFICIARY_ID,
+        tbfcp_attribute_type_FLOOR_ID,
+        tbfcp_attribute_type_FLOOR_REQUEST_ID,
+        tbfcp_attribute_type_PRIORITY,
+        tbfcp_attribute_type_REQUEST_STATUS,
+        tbfcp_attribute_type_ERROR_CODE,
+        tbfcp_attribute_type_ERROR_INFO,
+        tbfcp_attribute_type_PARTICIPANT_PROVIDED_INFO,
+        tbfcp_attribute_type_STATUS_INFO,
+        tbfcp_attribute_type_SUPPORTED_ATTRIBUTES,
+        tbfcp_attribute_type_SUPPORTED_PRIMITIVES,
+        tbfcp_attribute_type_USER_DISPLAY_NAME,
+        tbfcp_attribute_type_USER_URI,
+        tbfcp_attribute_type_BENEFICIARY_INFORMATION,
+        tbfcp_attribute_type_FLOOR_REQUEST_INFORMATION,
+        tbfcp_attribute_type_REQUESTED_BY_INFORMATION,
+        tbfcp_attribute_type_FLOOR_REQUEST_STATUS,
+        tbfcp_attribute_type_OVERALL_REQUEST_STATUS,
+    };
+    static const tsk_size_t __supp_attrs_count = sizeof(__supp_attrs)/sizeof(__supp_attrs[0]);
+
+    if ((ret = tbfcp_pkt_create_HelloAck(conf_id, transac_id, user_id, pp_self))) {
+        return ret;
+    }
+    /* SUPPORTED-ATTRIBUTES */
+    if ((ret = tbfcp_attr_octetstring_create(tbfcp_attribute_type_SUPPORTED_ATTRIBUTES, kBfcpFieldMNo, kNullOctetStringPtr, (uint8_t)__supp_attrs_count, &p_supp_attr))) {
+        return ret;
+    }
+    for (u = 0; u < p_supp_attr->OctetStringLength; ++u) {
+        p_supp_attr->OctetString[u] = (__supp_attrs[u] << 1/*R*/);
+    }
+    if ((ret = tbfcp_pkt_add_attr(*pp_self, (tbfcp_attr_t**)&p_supp_attr))) {
+        TSK_OBJECT_SAFE_FREE(p_supp_attr);
+        return ret;
+    }
+    /* SUPPORTED-PRIMITIVES */
+    if ((ret = tbfcp_attr_octetstring_create(tbfcp_attribute_type_SUPPORTED_PRIMITIVES, kBfcpFieldMNo, kNullOctetStringPtr, (uint8_t)__supp_prims_count, &p_supp_prim))) {
+        return ret;
+    }
+    for (u = 0; u < p_supp_prim->OctetStringLength; ++u) {
+        p_supp_prim->OctetString[u] = __supp_prims[u];
+    }
+    if ((ret = tbfcp_pkt_add_attr(*pp_self, (tbfcp_attr_t**)&p_supp_prim))) {
+        TSK_OBJECT_SAFE_FREE(p_supp_prim);
+        return ret;
+    }
+    return 0;
+}
+
+#if 0
+/***** rfc4582 - 5.3.1.  FloorRequest *****/
+static int _tbfcp_pkt_FloorRequest_add_attr(tbfcp_pkt_t* _p_self, tbfcp_attr_t** pp_attr)
+{
+    tbfcp_pkt_FloorRequest_t* p_self = (tbfcp_pkt_FloorRequest_t*)_p_self;
+    if (!p_self || !pp_attr || !*pp_attr) {
+        TSK_DEBUG_ERROR("Invalid parameter");
+        return -1;
+    }
+    switch ((*pp_attr)->hdr.type) {
+        SWITCH_CASE_TAKE_ATTR(tbfcp_attribute_type_FLOOR_ID, struct tbfcp_attr_unsigned16_s*, p_floor_id);
+        SWITCH_CASE_TAKE_ATTR(tbfcp_attribute_type_BENEFICIARY_ID, struct tbfcp_attr_unsigned16_s*, p_beneficiary_id);
+        SWITCH_CASE_TAKE_ATTR(tbfcp_attribute_type_PARTICIPANT_PROVIDED_INFO, struct tbfcp_attr_octetstring_s*, p_participant_provided_info);
+        SWITCH_CASE_TAKE_ATTR(tbfcp_attribute_type_PRIORITY, struct tbfcp_attr_octetstring16_s*, p_priority);
+    }
+    return _tbfcp_pkt_add_attr(_p_self, pp_attr);
+}
+
+int tbfcp_pkt_FloorRequest_create_empty(tbfcp_pkt_FloorRequest_t** pp_self)
+{
+    extern const tsk_object_def_t *tbfcp_pkt_FloorRequest_def_t;
+    tbfcp_pkt_FloorRequest_t* p_self;
+    int ret;
+
+    if (!pp_self) {
+        TSK_DEBUG_ERROR("Invalid parameter");
+        return -1;
+    }
+    if (!(p_self = tsk_object_new(tbfcp_pkt_FloorRequest_def_t))) {
+        TSK_DEBUG_ERROR("Failed to create object 'tbfcp_pkt_FloorRequest_def_t'");
+        return -2;
+    }
+    if ((ret = _tbfcp_pkt_init_empty_FloorRequest(p_self))) {
+        TSK_OBJECT_SAFE_FREE(p_self);
+        return ret;
+    }
+    *pp_self = p_self;
+    return 0;
+}
+
+int tbfcp_pkt_FloorRequest_create(uint32_t conf_id, uint16_t transac_id, uint16_t user_id, uint16_t floor_id, tbfcp_pkt_FloorRequest_t** pp_self)
+{
+    int ret;
+
+    if ((ret = tbfcp_pkt_FloorRequest_create_empty(pp_self))) {
+        return ret;
+    }
+    if ((ret = _tbfcp_pkt_init_FloorRequest((*pp_self), conf_id, transac_id, user_id))) {
+        TSK_OBJECT_SAFE_FREE((*pp_self));
+        return ret;
+    }
+    if ((ret = tbfcp_attr_unsigned16_create(tbfcp_attribute_type_FLOOR_ID, kBfcpFieldMYes, floor_id, &(*pp_self)->p_floor_id))) {
+        TSK_OBJECT_SAFE_FREE((*pp_self));
+        return ret;
+    }
+    return ret;
+}
+
+static tsk_object_t* tbfcp_pkt_FloorRequest_ctor(tsk_object_t * self, va_list * app)
+{
+    tbfcp_pkt_FloorRequest_t *p_pkt = (tbfcp_pkt_FloorRequest_t *)self;
+    if (p_pkt) {
+        TBFCP_PKT(p_pkt)->f_add_attr = _tbfcp_pkt_FloorRequest_add_attr;
+    }
+    return self;
+}
+static tsk_object_t* tbfcp_pkt_FloorRequest_dtor(tsk_object_t * self)
+{
+    tbfcp_pkt_FloorRequest_t *p_pkt = (tbfcp_pkt_FloorRequest_t *)self;
+    if (p_pkt) {
+        TSK_DEBUG_INFO("*** BFCP Packet(FloorRequest) destroyed ***");
+        _tbfcp_pkt_deinit(TBFCP_PKT(p_pkt)); // dtor(base)
+        TSK_OBJECT_SAFE_FREE(p_pkt->p_floor_id);
+        TSK_OBJECT_SAFE_FREE(p_pkt->p_beneficiary_id);
+        TSK_OBJECT_SAFE_FREE(p_pkt->p_participant_provided_info);
+        TSK_OBJECT_SAFE_FREE(p_pkt->p_priority);
+    }
+
+    return self;
+}
+static int tbfcp_pkt_FloorRequest_cmp(const tsk_object_t *_pk1, const tsk_object_t *_pk2)
+{
+    const tbfcp_pkt_FloorRequest_t *pc_pk1 = (const tbfcp_pkt_FloorRequest_t *)_pk1;
+    const tbfcp_pkt_FloorRequest_t *pc_pk2 = (const tbfcp_pkt_FloorRequest_t *)_pk2;
+
+    return (int)(pc_pk1-pc_pk2);
+}
+static const tsk_object_def_t tbfcp_pkt_FloorRequest_def_s = {
+    sizeof(tbfcp_pkt_FloorRequest_t),
+    tbfcp_pkt_FloorRequest_ctor,
+    tbfcp_pkt_FloorRequest_dtor,
+    tbfcp_pkt_FloorRequest_cmp,
+};
+const tsk_object_def_t *tbfcp_pkt_FloorRequest_def_t = &tbfcp_pkt_FloorRequest_def_s;
+#endif
\ No newline at end of file
diff --git a/tinyBFCP/src/tbfcp_session.c b/tinyBFCP/src/tbfcp_session.c
new file mode 100644
index 0000000..0a2169b
--- /dev/null
+++ b/tinyBFCP/src/tbfcp_session.c
@@ -0,0 +1,1041 @@
+/* Copyright (C) 2014 Mamadou DIOP.
+*
+* 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 Lesser General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with DOUBANGO.
+*
+*/
+#include "tinybfcp/tbfcp_session.h"
+#include "tinybfcp/tbfcp_pkt.h"
+#include "tinybfcp/tbfcp_utils.h"
+
+#include "tsk_time.h"
+#include "tsk_timer.h"
+#include "tsk_object.h"
+#include "tsk_memory.h"
+#include "tsk_safeobj.h"
+#include "tsk_debug.h"
+
+typedef struct tbfcp_udp_pkt_s {
+	TSK_DECLARE_OBJECT;
+	struct {
+		tsk_timer_id_t u_id;
+		uint64_t u_timeout;
+	} timer;
+	tbfcp_pkt_t *p_pkt;
+} tbfcp_udp_pkt_t;
+typedef tsk_list_t tbfcp_udp_pkts_L_t;
+
+typedef struct tbfcp_session_s {
+    TSK_DECLARE_OBJECT;
+
+    tsk_bool_t b_started;
+    tsk_bool_t b_stopping;
+    tsk_bool_t b_prepared;
+
+	tbfcp_udp_pkts_L_t *p_list_udp_pkts;
+
+	struct {
+		tbfcp_session_callback_f f_fun;
+		struct tbfcp_session_event_xs e;
+	} cb;
+
+	// Values received from the server in the 200 OK. Attributes from rfc4583
+	struct {
+		uint32_t u_conf_id;
+		uint16_t u_user_id;
+		uint16_t u_floor_id;
+	} 
+	conf_ids;
+
+	enum tbfcp_role_e e_role_local;
+	enum tbfcp_role_e e_role_remote;
+
+	enum tbfcp_setup_e e_setup_local;
+	enum tbfcp_setup_e e_setup_remote;
+
+    enum tnet_socket_type_e e_socket_type;
+    char* p_local_ip;
+    tnet_port_t u_local_port;
+
+    char* p_local_public_ip;
+    tnet_port_t u_local_public_port;
+
+    char* p_remote_ip;
+    tnet_port_t u_remote_port;
+    struct sockaddr_storage remote_addr;
+
+	struct tnet_nat_ctx_s* p_natt_ctx;
+    struct tnet_ice_ctx_s* p_ice_ctx;
+    struct tnet_transport_s* p_transport;
+
+    uint8_t* p_buff_send_ptr;
+    tsk_size_t u_buff_send_size;
+
+    struct {
+        tsk_timer_manager_handle_t* ph_global;
+        tsk_timer_id_t id_T1; // For UDP only
+        uint64_t u_timeout_T1;
+        tsk_timer_id_t id_T2; // For UDP only
+        uint64_t u_timeout_T2;
+        tsk_timer_id_t id_TcpReconnect; // For TCP/TLS only
+        uint64_t u_timeout_TcpReconnect;
+    } timer;
+
+    TSK_DECLARE_SAFEOBJ;
+} tbfcp_session_t;
+
+typedef enum _bfcp_timer_type_e {
+    _bfcp_timer_type_T1, // draft-ietf-bfcpbis-rfc4582bis-11 - 4.16.  Timer Values (8.3.3) - Initial request retransmission timer (0.5s)
+    _bfcp_timer_type_T2, // draft-ietf-bfcpbis-rfc4582bis-11 - 4.16.  Timer Values (8.3.3) - Response retransmission timer (10s)
+    _bfcp_timer_type_TcpReconnect, // Try to reconnect the TCP/TLS socket every X seconds if unexpectedly disconnected
+}
+_bfcp_timer_type_t;
+
+static int _tbfcp_udp_pkt_create(const tbfcp_pkt_t *pc_pkt, tbfcp_udp_pkt_t** pp_pkt);
+
+static int _tbfcp_session_send_pkt(tbfcp_session_t* p_self, const tbfcp_pkt_t* pc_pkt);
+static int _tbfcp_session_send_Hello(struct tbfcp_session_s* p_self);
+static int _tbfcp_session_send_HelloAck(struct tbfcp_session_s* p_self, const tbfcp_pkt_t *pc_hello);
+static int _tbfcp_session_send_FloorRequest(struct tbfcp_session_s* p_self);
+static int _tbfcp_session_process_incoming_pkt(struct tbfcp_session_s* p_self, const tbfcp_pkt_t *pc_pkt);
+static int _tbfcp_session_socket_type_make_valid(enum tnet_socket_type_e e_in_st, enum tnet_socket_type_e *pe_out_st);
+static int _tbfcp_session_timer_callback(const void* pc_arg, tsk_timer_id_t timer_id);
+static int _tbfcp_session_timer_schedule(struct tbfcp_session_s* p_self, _bfcp_timer_type_t e_timer, uint64_t u_timeout);
+static int _tbfcp_session_transport_layer_dgram_cb(const tnet_transport_event_t* e);
+static int _tbfcp_session_transport_layer_stream_cb(const tnet_transport_event_t* e);
+
+#define _tbfcp_session_raise(_p_self, _e_type, _pc_pkt) \
+	if ((_p_self)->cb.f_fun) { \
+		(_p_self)->cb.e.e_type = (_e_type); \
+		(_p_self)->cb.e.pc_pkt = (_pc_pkt); \
+		(_p_self)->cb.f_fun(&_p_self->cb.e); \
+	}
+#define _tbfcp_session_raise_inf_inc_msg(_p_self, _pc_pkt) _tbfcp_session_raise(_p_self, tbfcp_session_event_type_inf_inc_msg, _pc_pkt)
+#define _tbfcp_session_raise_err_send_timedout(_p_self, _pc_pkt) _tbfcp_session_raise(_p_self, tbfcp_session_event_type_err_send_timedout, _pc_pkt)
+
+static int __pred_find_udp_pkt_by_timer(const tsk_list_item_t *item, const void *u64_id) {
+	if (item && item->data) {
+		return (int)(((const struct tbfcp_udp_pkt_s *)item->data)->timer.u_id - *((const uint64_t*)u64_id));
+	}
+	return -1;
+}
+static int __pred_find_udp_pkt_by_transac_id(const tsk_list_item_t *item, const void *u16_transac_id) {
+	if (item && item->data) {
+		return (int)(((const struct tbfcp_udp_pkt_s *)item->data)->p_pkt->hdr.transac_id - *((const uint16_t*)u16_transac_id));
+	}
+	return -1;
+}
+
+int tbfcp_session_create(tnet_socket_type_t e_socket_type, const char* pc_local_ip, tbfcp_session_t** pp_self)
+{
+    extern const tsk_object_def_t *tbfcp_session_def_t;
+    int ret;
+    tnet_socket_type_t e_st;
+    tbfcp_session_t* p_self;
+
+    if (!pp_self) {
+        TSK_DEBUG_ERROR("Invalid parameter");
+        return -1;
+    }
+    if ((ret = _tbfcp_session_socket_type_make_valid(e_socket_type, &e_st))) {
+        return ret;
+    }
+    if (!(p_self = tsk_object_new(tbfcp_session_def_t))) {
+        TSK_DEBUG_ERROR("Failed to create 'tbfcp_session_def_t' object");
+        return -2;
+    }
+    p_self->e_socket_type = e_st;
+    tsk_strupdate(&p_self->p_local_ip, pc_local_ip);
+    *pp_self = p_self;
+    return 0;
+}
+
+int tbfcp_session_create_2(struct tnet_ice_ctx_s* p_ice_ctx, tbfcp_session_t** pp_self)
+{
+    tnet_socket_type_t e_st;
+    const char* pc_local_ip;
+    int ret;
+    if (!pp_self || !p_ice_ctx) {
+        TSK_DEBUG_ERROR("Invalid parameter");
+        return -1;
+    }
+
+    // TODO: ICE expect RTP and RTCP comp-ids only
+    TSK_DEBUG_ERROR("Not supported yet");
+    return -2;
+
+    // TODO: For now ICE works with UDP (and DTLS) only
+    e_st = tnet_ice_ctx_use_ipv6(p_ice_ctx) ? tnet_socket_type_udp_ipv4 : tnet_socket_type_udp_ipv6;
+    pc_local_ip = tnet_ice_ctx_use_ipv6(p_ice_ctx) ? "::1" : "127.0.0.1";
+    if ((ret = _tbfcp_session_socket_type_make_valid(e_st, &e_st))) {
+        return ret;
+    }
+    if ((ret = tbfcp_session_create(e_st, pc_local_ip, pp_self))) {
+        return ret;
+    }
+    (*pp_self)->p_ice_ctx = tsk_object_ref(p_ice_ctx);
+    return 0;
+}
+
+int tbfcp_session_set_callback(struct tbfcp_session_s* p_self, tbfcp_session_callback_f f_fun, const void* pc_usr_data)
+{
+	if (!p_self) {
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return -1;
+	}
+	p_self->cb.f_fun = f_fun;
+	p_self->cb.e.pc_usr_data = pc_usr_data;
+	return 0;
+}
+
+int tbfcp_session_set_ice_ctx(tbfcp_session_t* p_self, struct tnet_ice_ctx_s* p_ice_ctx)
+{
+    if (!p_self) {
+        TSK_DEBUG_ERROR("Invalid parameter");
+        return -1;
+    }
+    TSK_OBJECT_SAFE_FREE(p_self->p_ice_ctx);
+    if (p_ice_ctx) {
+        p_self->p_ice_ctx = tsk_object_ref(p_ice_ctx);
+    }
+    return 0;
+}
+
+int tbfcp_session_prepare(tbfcp_session_t* p_self)
+{
+    int ret = 0;
+    const char *bfcp_local_ip;
+    tnet_port_t bfcp_local_port;
+
+    if (!p_self) {
+        TSK_DEBUG_ERROR("Invalid parameter");
+        return -1;
+    }
+
+    // lock()
+    tsk_safeobj_lock(p_self);
+
+    if (p_self->b_prepared) {
+        TSK_DEBUG_INFO("BFCP session already prepared");
+        goto bail;
+    }
+    if (p_self->p_transport) {
+        TSK_DEBUG_ERROR("BFCP session already has a transport. Unexpected.");
+        ret = -2;
+        goto bail;
+    }
+
+    bfcp_local_ip = TNET_SOCKET_HOST_ANY;
+    bfcp_local_port = TNET_SOCKET_PORT_ANY;
+
+    /*if (p_self->p_ice_ctx) {
+        // Get Sockets when the transport is started
+        bfcp_local_ip = tnet_ice_ctx_use_ipv6(p_self->p_ice_ctx) ? "::1" : "127.0.0.1";
+    }
+    else*/ {
+        // create transport
+        if (!p_self->p_transport && !(p_self->p_transport = tnet_transport_create(p_self->p_local_ip, p_self->u_local_port, p_self->e_socket_type, kBfcpTransportFriendlyName))) {
+            TSK_DEBUG_ERROR("Failed to create %s Transport", kBfcpTransportFriendlyName);
+            return -3;
+        }
+        // set transport callback
+		if ((ret = tnet_transport_set_callback(p_self->p_transport, TNET_SOCKET_TYPE_IS_DGRAM(p_self->e_socket_type) ? _tbfcp_session_transport_layer_dgram_cb : _tbfcp_session_transport_layer_stream_cb, p_self))) {
+            goto bail;
+        }
+        bfcp_local_ip = p_self->p_transport->master->ip;
+        bfcp_local_port = p_self->p_transport->master->port;
+    }
+
+    tsk_strupdate(&p_self->p_local_public_ip, bfcp_local_ip);
+    p_self->u_local_public_port = bfcp_local_port;
+
+    p_self->b_prepared = tsk_true;
+
+bail:
+    // unlock()
+    tsk_safeobj_unlock(p_self);
+    return ret;
+}
+
+int tbfcp_session_start(tbfcp_session_t* p_self)
+{
+    int ret;
+    if (!p_self) {
+        TSK_DEBUG_ERROR("Invalid parameter");
+        return -1;
+    }
+
+    // lock()
+    tsk_safeobj_lock(p_self);
+
+    if (p_self->b_started) {
+        TSK_DEBUG_INFO("BFCP session already started");
+        ret = 0;
+        goto bail;
+    }
+
+    if (!p_self->b_prepared) {
+        TSK_DEBUG_ERROR("BFCP session not prepared yet");
+        ret = -2;
+        goto bail;
+    }
+
+    // start global timer manager - nothing will be done if already started by another component
+    if ((ret = tsk_timer_manager_start(p_self->timer.ph_global))) {
+        TSK_DEBUG_ERROR("Failed to start timer");
+        goto bail;
+    }
+
+    // check remote IP address validity
+    if ((tsk_striequals(p_self->p_remote_ip, "0.0.0.0") || tsk_striequals(p_self->p_remote_ip, "::"))) { // most likely loopback testing
+        tnet_ip_t source = {0};
+        tsk_bool_t updated = tsk_false;
+        if (p_self->p_transport && p_self->p_transport->master) {
+            updated = (tnet_getbestsource(p_self->p_transport->master->ip, p_self->p_transport->master->port, p_self->p_transport->master->type, &source) == 0);
+        }
+        // Not allowed to send data to "0.0.0.0"
+        TSK_DEBUG_INFO("BFCP remote IP contains not allowed value ...changing to '%s'", updated ? source : "oops");
+        if (updated) {
+            tsk_strupdate(&p_self->p_remote_ip, source);
+        }
+    }
+    // init remote remote addr
+    if ((ret = tnet_sockaddr_init(p_self->p_remote_ip, p_self->u_remote_port, p_self->p_transport->master->type, &p_self->remote_addr))) {
+        tnet_transport_shutdown(p_self->p_transport);
+        TSK_OBJECT_SAFE_FREE(p_self->p_transport);
+        TSK_DEBUG_ERROR("Invalid BFCP host:port [%s:%u]", p_self->p_remote_ip, p_self->u_remote_port);
+        goto bail;
+    }
+	if ((ret = tnet_transport_set_natt_ctx(p_self->p_transport, p_self->p_natt_ctx))) {
+		TSK_DEBUG_ERROR("Failed to start to set NATT ctx for the %s transport", kBfcpTransportFriendlyName);
+		goto bail;
+	}
+
+    // start the transport
+    if ((ret = tnet_transport_start(p_self->p_transport))) {
+        TSK_DEBUG_ERROR("Failed to start the %s transport", kBfcpTransportFriendlyName);
+        goto bail;
+    }
+
+    p_self->b_started = tsk_true;
+
+	// Send hello now if UDP/DTLS. Otherwise (TCP/TLS), wait for the connection to complete.
+	//if (TNET_SOCKET_TYPE_IS_DGRAM(p_self->e_socket_type)) {
+	//	if ((ret = _tbfcp_session_send_Hello(p_self))) {
+	//		goto bail;
+	//	}
+	//}
+
+bail:
+    // unlock()
+    tsk_safeobj_unlock(p_self);
+    return ret;
+}
+
+int tbfcp_session_pause(tbfcp_session_t* p_self)
+{
+	int ret = 0;
+    if (!p_self) {
+        TSK_DEBUG_ERROR("Invalid parameter");
+        return -1;
+    }
+
+	// lock()
+    tsk_safeobj_lock(p_self);
+
+	goto bail;
+
+bail:
+	// unlock()
+    tsk_safeobj_unlock(p_self);
+    return ret;
+}
+
+int tbfcp_session_stop(tbfcp_session_t* p_self)
+{
+    int ret = 0;
+    if (!p_self) {
+        TSK_DEBUG_ERROR("Invalid parameter");
+        return -1;
+    }
+
+	// FIXME: send FloorRelease if a FloorRequest is pending
+
+    // lock()
+    tsk_safeobj_lock(p_self);
+
+    // stop the session if not already done
+    if (!p_self->b_started) {
+        TSK_DEBUG_INFO("BFCP session already stopped");
+        goto bail;
+    }
+
+	// remove all pending udp packets
+	tsk_list_clear_items(p_self->p_list_udp_pkts);
+
+    p_self->b_stopping = tsk_true;
+    // this is a global timer shared by many components -> stopping it won't remove
+    // all scheduled items as it could continue running if still used
+    if (TSK_TIMER_ID_IS_VALID(p_self->timer.id_T1)) {
+        tsk_timer_manager_cancel(p_self->timer.ph_global, p_self->timer.id_T1);
+        p_self->timer.id_T1 = TSK_INVALID_TIMER_ID;
+    }
+    if (TSK_TIMER_ID_IS_VALID(p_self->timer.id_T2)) {
+        tsk_timer_manager_cancel(p_self->timer.ph_global, p_self->timer.id_T2);
+        p_self->timer.id_T2 = TSK_INVALID_TIMER_ID;
+    }
+    if (TSK_TIMER_ID_IS_VALID(p_self->timer.id_TcpReconnect)) {
+        tsk_timer_manager_cancel(p_self->timer.ph_global, p_self->timer.id_TcpReconnect);
+        p_self->timer.id_TcpReconnect = TSK_INVALID_TIMER_ID;
+    }
+
+    // free transport to force next call to start() to create new one with new sockets
+    if (p_self->p_transport) {
+        tnet_transport_shutdown(p_self->p_transport);
+        TSK_OBJECT_SAFE_FREE(p_self->p_transport);
+    }
+
+    p_self->b_started = tsk_false;
+    p_self->b_stopping = tsk_false;
+	p_self->b_prepared = tsk_false;
+
+bail:
+    // unlock()
+    tsk_safeobj_unlock(p_self);
+    return ret;
+}
+
+int tbfcp_session_set_natt_ctx(tbfcp_session_t* p_self, struct tnet_nat_ctx_s* p_natt_ctx)
+{
+	if (!p_self) {
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return -1;
+	}
+	TSK_OBJECT_SAFE_FREE(p_self->p_natt_ctx);
+	p_self->p_natt_ctx = tsk_object_ref(p_natt_ctx);
+	return 0;
+}
+
+int tbfcp_session_set_remote_address(tbfcp_session_t* p_self, const char* pc_ip, tnet_port_t u_port)
+{
+    if (!p_self || !pc_ip /*|| u_port < 1024*/) {
+        TSK_DEBUG_ERROR("Invalid parameter");
+        return -1;
+    }
+    // if ICE is enabled then, these values will be updated when the session start()s and call ice_init()
+    tsk_strupdate(&p_self->p_remote_ip, pc_ip);
+    p_self->u_remote_port = u_port;
+    return 0;
+}
+
+int tbfcp_session_set_remote_role(tbfcp_session_t* p_self, enum tbfcp_role_e e_role_remote)
+{
+	tsk_bool_t b_is_role_acceptable;
+	int ret;
+	if (!p_self) {
+        TSK_DEBUG_ERROR("Invalid parameter");
+        return -1;
+    }
+	if ((ret = tbfcp_utils_is_role_acceptable(p_self->e_role_local, e_role_remote, &b_is_role_acceptable))) {
+		return ret;
+	}
+	if (!b_is_role_acceptable) {
+		TSK_DEBUG_ERROR("%d not acceptable as remote role because local role = %d", e_role_remote, p_self->e_role_local);
+		return -2;
+	}
+	p_self->e_role_remote = e_role_remote;
+	return 0;
+}
+
+int tbfcp_session_set_remote_setup(struct tbfcp_session_s* p_self, enum tbfcp_setup_e e_setup_remote)
+{
+	tsk_bool_t b_is_setup_acceptable;
+	int ret;
+	if (!p_self) {
+        TSK_DEBUG_ERROR("Invalid parameter");
+        return -1;
+    }
+	if ((ret = tbfcp_utils_is_setup_acceptable(p_self->e_setup_local, e_setup_remote, &b_is_setup_acceptable))) {
+		return ret;
+	}
+	if (!b_is_setup_acceptable) {
+		TSK_DEBUG_ERROR("%d not acceptable as remote setup because local setup = %d", e_setup_remote, p_self->e_setup_local);
+		return -2;
+	}
+	p_self->e_setup_remote = e_setup_remote;
+	return 0;
+}
+
+int tbfcp_session_set_conf_ids(tbfcp_session_t* p_self, uint32_t u_conf_id, uint16_t u_user_id, uint16_t u_floor_id)
+{
+	if (!p_self) {
+        TSK_DEBUG_ERROR("Invalid parameter");
+        return -1;
+    }
+	p_self->conf_ids.u_conf_id = u_conf_id;
+	p_self->conf_ids.u_user_id = u_user_id;
+	p_self->conf_ids.u_floor_id = u_floor_id;
+	return 0;
+}
+
+int tbfcp_session_get_profile(const tbfcp_session_t* pc_self, const char** ppc_profile)
+{
+    if (!pc_self) {
+        TSK_DEBUG_ERROR("Invalid parameter");
+        return -1;
+    }
+    return tbfcp_utils_get_profile(pc_self->e_socket_type, ppc_profile);
+}
+
+int tbfcp_session_get_local_role(const tbfcp_session_t* pc_self, enum tbfcp_role_e *pe_role_local)
+{
+	if (!pc_self || !pe_role_local) {
+        TSK_DEBUG_ERROR("Invalid parameter");
+        return -1;
+    }
+	*pe_role_local = pc_self->e_role_local;
+	return 0;
+}
+
+int tbfcp_session_get_local_setup(const struct tbfcp_session_s* pc_self, enum tbfcp_setup_e *pe_setup_local)
+{
+	if (!pc_self || !pe_setup_local) {
+        TSK_DEBUG_ERROR("Invalid parameter");
+        return -1;
+    }
+	*pe_setup_local = pc_self->e_setup_local;
+	return 0;
+}
+
+int tbfcp_session_get_local_address(const tbfcp_session_t* pc_self, const char** ppc_ip, tnet_port_t *pu_port)
+{
+	if (!pc_self || !ppc_ip || !pu_port) {
+        TSK_DEBUG_ERROR("Invalid parameter");
+        return -1;
+    }
+	*ppc_ip = pc_self->p_local_public_ip;
+	*pu_port = pc_self->u_local_public_port;
+	return 0;
+}
+
+int tbfcp_session_create_pkt_Hello(struct tbfcp_session_s* p_self, struct tbfcp_pkt_s** pp_pkt)
+{
+	int ret;
+	if (!p_self || !pp_pkt) {
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return -1;
+	}
+	// lock()
+    tsk_safeobj_lock(p_self);
+	if ((ret = tbfcp_pkt_create_Hello(p_self->conf_ids.u_conf_id, tbfcp_utils_rand_u16(), p_self->conf_ids.u_user_id, pp_pkt))) {
+		goto bail;
+	}
+
+bail:
+	// lock()
+    tsk_safeobj_unlock(p_self);
+	return ret;
+}
+
+int tbfcp_session_create_pkt_FloorRequest(struct tbfcp_session_s* p_self, struct tbfcp_pkt_s** pp_pkt)
+{
+	int ret;
+	if (!p_self || !pp_pkt) {
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return -1;
+	}
+	// lock()
+    tsk_safeobj_lock(p_self);
+	if ((ret = tbfcp_pkt_create_FloorRequest_2(p_self->conf_ids.u_conf_id, tbfcp_utils_rand_u16(), p_self->conf_ids.u_user_id, p_self->conf_ids.u_floor_id, pp_pkt))) {
+		goto bail;
+	}
+
+bail:
+	// lock()
+    tsk_safeobj_unlock(p_self);
+	return ret;
+}
+
+int tbfcp_session_create_pkt_FloorRelease(struct tbfcp_session_s* p_self, struct tbfcp_pkt_s** pp_pkt)
+{
+		int ret;
+	if (!p_self || !pp_pkt) {
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return -1;
+	}
+	// lock()
+    tsk_safeobj_lock(p_self);
+	if ((ret = tbfcp_pkt_create_FloorRelease_2(p_self->conf_ids.u_conf_id, tbfcp_utils_rand_u16(), p_self->conf_ids.u_user_id, p_self->conf_ids.u_floor_id, pp_pkt))) {
+		goto bail;
+	}
+
+bail:
+	// lock()
+    tsk_safeobj_unlock(p_self);
+	return ret;
+}
+
+static int _tbfcp_session_send_buff(tbfcp_session_t* p_self, const void* pc_buff_ptr, tsk_size_t u_buff_size)
+{
+    int ret = 0;
+    tsk_size_t u_sent_bytes = 0;
+    if (!p_self || !pc_buff_ptr || !u_buff_size) {
+        TSK_DEBUG_ERROR("Invalid parameter");
+        return -1;
+    }
+
+    // lock()
+    tsk_safeobj_lock(p_self);
+
+    if (!p_self->b_started) {
+        TSK_DEBUG_ERROR("BFCP session not started");
+        ret = -2;
+        goto bail;
+    }
+
+    if (TNET_SOCKET_TYPE_IS_DGRAM(p_self->e_socket_type)) {
+        u_sent_bytes = tnet_transport_sendto(p_self->p_transport, p_self->p_transport->master->fd, (const struct sockaddr *)&p_self->remote_addr, pc_buff_ptr, u_buff_size);
+    }
+    else {
+		TSK_DEBUG_ERROR("Not implemented yet");
+		ret = -3;
+		goto bail;
+    }
+
+    if (u_sent_bytes != u_buff_size) {
+        TSK_DEBUG_ERROR("Failed to send %u bytes. Only %u sent", u_buff_size, u_sent_bytes);
+        ret = -2;
+        goto bail;
+    }
+
+bail:
+    // unlock()
+    tsk_safeobj_unlock(p_self);
+    return ret;
+}
+
+int tbfcp_session_send_pkt(tbfcp_session_t* p_self, const tbfcp_pkt_t* pc_pkt)
+{
+    int ret = 0;
+	tbfcp_udp_pkt_t *p_udp_pkt = tsk_null;
+    if (!p_self || !pc_pkt) {
+        TSK_DEBUG_ERROR("Invalid parameter");
+        return -1;
+    }
+
+    // lock()
+    tsk_safeobj_lock(p_self);
+
+    if (TNET_SOCKET_TYPE_IS_DGRAM(p_self->e_socket_type)) {
+		const tsk_list_item_t* pc_item = tsk_list_find_item_by_pred(p_self->p_list_udp_pkts, __pred_find_udp_pkt_by_transac_id, &pc_pkt->hdr.transac_id);
+		if (pc_item) {
+			p_udp_pkt = tsk_object_ref(TSK_OBJECT(pc_item->data));
+		} else {
+			tbfcp_udp_pkt_t *_p_udp_pkt = tsk_null;
+			if ((ret = _tbfcp_udp_pkt_create(pc_pkt, &_p_udp_pkt))) {
+				goto bail;
+			}
+			p_udp_pkt = tsk_object_ref(_p_udp_pkt);
+			tsk_list_push_back_data(p_self->p_list_udp_pkts, (void**)&_p_udp_pkt);
+		}
+	}
+	else {
+	}
+
+	if ((ret = _tbfcp_session_send_pkt(p_self, pc_pkt))) {
+		goto bail;
+	}
+	if (p_udp_pkt) {
+		p_udp_pkt->timer.u_id = tsk_timer_manager_schedule(p_self->timer.ph_global, p_udp_pkt->timer.u_timeout, _tbfcp_session_timer_callback, p_self);
+		p_udp_pkt->timer.u_timeout += kBfcpTimerT1;
+	}
+
+bail:
+	TSK_OBJECT_SAFE_FREE(p_udp_pkt);
+    // unlock()
+    tsk_safeobj_unlock(p_self);
+    return ret;
+}
+
+int _tbfcp_session_send_pkt(tbfcp_session_t* p_self, const tbfcp_pkt_t* pc_pkt)
+{
+    int ret;
+    tsk_size_t u_min_size;
+    if (!p_self || !pc_pkt) {
+        TSK_DEBUG_ERROR("Invalid parameter");
+        return -1;
+    }
+
+    // lock()
+    tsk_safeobj_lock(p_self);
+
+    if (!p_self->b_started) {
+        TSK_DEBUG_ERROR("BFCP session not started");
+        ret = -2;
+        goto bail;
+    }
+    if ((ret = tbfcp_pkt_get_size_in_octetunits_with_padding(pc_pkt, &u_min_size))) {
+        goto bail;
+    }
+    u_min_size += kBfcpBuffMinPad;
+    if (p_self->u_buff_send_size < u_min_size) {
+        if (!(p_self->p_buff_send_ptr = tsk_realloc(p_self->p_buff_send_ptr, u_min_size))) {
+            TSK_DEBUG_ERROR("Failed to allocate buffer with size = %u", u_min_size);
+            ret = -3;
+            p_self->u_buff_send_size = 0;
+            goto bail;
+        }
+        p_self->u_buff_send_size = u_min_size;
+    }
+
+    if ((ret = tbfcp_pkt_write_with_padding(pc_pkt, p_self->p_buff_send_ptr, p_self->u_buff_send_size, &u_min_size))) {
+        goto bail;
+    }
+    if ((ret = _tbfcp_session_send_buff(p_self, p_self->p_buff_send_ptr, u_min_size))) {
+        goto bail;
+    }
+
+bail:
+    // unlock()
+    tsk_safeobj_unlock(p_self);
+    return ret;
+}
+
+int _tbfcp_session_send_Hello(tbfcp_session_t* p_self)
+{
+	tbfcp_pkt_t* p_pkt = tsk_null;
+	int ret;
+	if (!p_self) {
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return -1;
+	}
+	if ((ret = tbfcp_pkt_create_Hello(p_self->conf_ids.u_conf_id, tbfcp_utils_rand_u16(), p_self->conf_ids.u_user_id, &p_pkt))) {
+		goto bail;
+	}
+	if ((ret = tbfcp_session_send_pkt(p_self, p_pkt))) {
+		goto bail;
+	}
+	
+bail:
+	TSK_OBJECT_SAFE_FREE(p_pkt);
+	return ret;
+}
+
+int _tbfcp_session_send_HelloAck(tbfcp_session_t* p_self, const tbfcp_pkt_t *pc_hello)
+{
+	tbfcp_pkt_t* p_pkt = tsk_null;
+	int ret;
+	if (!p_self || !pc_hello) {
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return -1;
+	}
+	if ((ret = tbfcp_pkt_create_HelloAck_2(pc_hello->hdr.conf_id, pc_hello->hdr.transac_id, pc_hello->hdr.user_id, &p_pkt))) {
+		goto bail;
+	}
+	if ((ret = _tbfcp_session_send_pkt(p_self, p_pkt))) {
+		goto bail;
+	}
+	
+bail:
+	TSK_OBJECT_SAFE_FREE(p_pkt);
+	return ret;
+}
+
+static int _tbfcp_session_send_FloorRequest(tbfcp_session_t* p_self)
+{
+	tbfcp_pkt_t* p_pkt = tsk_null;
+	int ret;
+	if (!p_self) {
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return -1;
+	}
+	if ((ret = tbfcp_pkt_create_FloorRequest_2(p_self->conf_ids.u_conf_id, tbfcp_utils_rand_u16(), p_self->conf_ids.u_user_id, p_self->conf_ids.u_floor_id, &p_pkt))) {
+		goto bail;
+	}
+	if ((ret = tbfcp_session_send_pkt(p_self, p_pkt))) {
+		goto bail;
+	}
+	
+bail:
+	TSK_OBJECT_SAFE_FREE(p_pkt);
+	return ret;
+}
+
+static int _tbfcp_session_process_incoming_pkt(tbfcp_session_t* p_self, const tbfcp_pkt_t *pc_pkt)
+{
+	int ret = 0;
+    if (!p_self || !pc_pkt) {
+        TSK_DEBUG_ERROR("Invalid parameter");
+        return -1;
+    }
+
+    // lock()
+    tsk_safeobj_lock(p_self);
+
+	switch (pc_pkt->hdr.primitive) {
+		case tbfcp_primitive_Hello:
+			if ((ret = _tbfcp_session_send_HelloAck(p_self, pc_pkt))) {
+				goto bail;
+			}
+			break;
+		case tbfcp_primitive_HelloAck:
+        default:
+			break;
+	}
+
+	// raise event
+	_tbfcp_session_raise_inf_inc_msg(p_self, pc_pkt);
+	// remove request
+	tsk_list_remove_item_by_pred(p_self->p_list_udp_pkts, __pred_find_udp_pkt_by_transac_id, &pc_pkt->hdr.transac_id);
+
+bail:
+    // unlock()
+    tsk_safeobj_unlock(p_self);
+    return ret;
+}
+
+// clear junks (e.g. IPSec)
+static int _tbfcp_session_socket_type_make_valid(enum tnet_socket_type_e e_in_st, enum tnet_socket_type_e *pe_out_st)
+{
+    if (!pe_out_st) {
+        TSK_DEBUG_ERROR("Invalid parameter");
+        return -1;
+    }
+    if (TNET_SOCKET_TYPE_IS_DTLS(e_in_st) || TNET_SOCKET_TYPE_IS_UDP(e_in_st) || TNET_SOCKET_TYPE_IS_TLS(e_in_st) || TNET_SOCKET_TYPE_IS_TCP(e_in_st)) {
+        *pe_out_st = e_in_st;
+    }
+    else {
+        *pe_out_st = kBfcpTransportDefault;
+    }
+    return 0;
+}
+
+static int _tbfcp_session_timer_schedule(tbfcp_session_t* p_self, _bfcp_timer_type_t e_timer, uint64_t u_timeout)
+{
+    int ret = 0;
+    if (!p_self) {
+        TSK_DEBUG_ERROR("Invalid parameter");
+        return -1;
+    }
+
+    tsk_safeobj_lock(p_self); // must
+    switch (e_timer) {
+    case _bfcp_timer_type_T1:
+        if (!TSK_TIMER_ID_IS_VALID(p_self->timer.id_T1)) {
+            p_self->timer.id_T1 = tsk_timer_mgr_global_schedule(u_timeout, _tbfcp_session_timer_callback, p_self);
+        }
+        else {
+            TSK_DEBUG_ERROR("T1 timer is still valid");
+            ret = -3;
+        }
+        break;
+    case _bfcp_timer_type_T2:
+        if (!TSK_TIMER_ID_IS_VALID(p_self->timer.id_T2)) {
+            p_self->timer.id_T2 = tsk_timer_mgr_global_schedule(u_timeout, _tbfcp_session_timer_callback, p_self);
+        }
+        else {
+            TSK_DEBUG_ERROR("T2 timer is still valid");
+            ret = -3;
+        }
+        break;
+    case _bfcp_timer_type_TcpReconnect:
+        if (!TSK_TIMER_ID_IS_VALID(p_self->timer.id_TcpReconnect)) {
+            p_self->timer.id_TcpReconnect = tsk_timer_mgr_global_schedule(u_timeout, _tbfcp_session_timer_callback, p_self);
+        }
+        else {
+            TSK_DEBUG_ERROR("TcpReconnect timer is still valid");
+            ret = -3;
+        }
+        break;
+    default:
+        TSK_DEBUG_ERROR("%d not valid BFCP timer", e_timer);
+        ret = -2;
+        break;
+    }
+    tsk_safeobj_unlock(p_self);
+    return ret;
+}
+
+static int _tbfcp_session_timer_callback(const void* pc_arg, tsk_timer_id_t timer_id)
+{
+    tbfcp_session_t* p_session = (tbfcp_session_t*)pc_arg;
+	const tsk_list_item_t* pc_item;
+    tsk_safeobj_lock(p_session); // must
+	if (!p_session->b_started) goto bail;
+	pc_item = tsk_list_find_item_by_pred(p_session->p_list_udp_pkts, __pred_find_udp_pkt_by_timer, &timer_id);
+	if (pc_item) {
+		tbfcp_udp_pkt_t* pc_udp_pkt = (tbfcp_udp_pkt_t*)pc_item->data;
+		if (pc_udp_pkt->timer.u_timeout <= kBfcpTimerT1Max) {
+			tbfcp_session_send_pkt(p_session, pc_udp_pkt->p_pkt);
+		}
+		else {
+			// raise event
+			_tbfcp_session_raise_err_send_timedout(p_session, pc_udp_pkt->p_pkt);
+			// remove pkt
+			tsk_list_remove_item_by_pred(p_session->p_list_udp_pkts, __pred_find_udp_pkt_by_timer, &timer_id);
+		}
+	}
+#if 0
+    if (p_session->timer.id_T1 == timer_id) {
+        p_session->timer.id_T1 = TSK_INVALID_TIMER_ID;
+        // OnExpire(session, EVENT_BYE);
+    }
+    else if (p_session->timer.id_T2 == timer_id) {
+        p_session->timer.id_T2 = TSK_INVALID_TIMER_ID;
+        // OnExpire(session, EVENT_REPORT);
+    }
+#endif
+bail:
+    tsk_safeobj_unlock(p_session);
+    return 0;
+}
+
+static int _tbfcp_session_transport_layer_dgram_cb(const tnet_transport_event_t* e)
+{
+    tbfcp_session_t* p_session = (tbfcp_session_t*)e->callback_data;
+	int ret;
+	tbfcp_pkt_t* p_pkt = tsk_null;
+	switch(e->type){
+		case event_data: {
+				break;
+			}
+		case event_closed:
+		case event_connected:
+		default:{
+				return 0;
+			}
+	}
+
+	if ((ret = tbfcp_pkt_read(e->data, e->size, &p_pkt))) {
+		goto bail;
+	}
+	if ((ret = _tbfcp_session_process_incoming_pkt(p_session, p_pkt))) {
+		goto bail;
+	}
+
+bail:
+	TSK_OBJECT_SAFE_FREE(p_pkt);
+    return ret;
+}
+
+static int _tbfcp_session_transport_layer_stream_cb(const tnet_transport_event_t* e)
+{
+	// tbfcp_session_t* p_session = (tbfcp_session_t*)e->callback_data;
+	TSK_DEBUG_ERROR("Not implemented yet");
+	return -1;
+}
+
+static tsk_object_t* tbfcp_session_ctor(tsk_object_t * self, va_list * app)
+{
+    tbfcp_session_t *p_session = (tbfcp_session_t *)self;
+    if (p_session) {
+        p_session->timer.id_T1 = TSK_INVALID_TIMER_ID;
+        p_session->timer.id_T2 = TSK_INVALID_TIMER_ID;
+		if (!(p_session->p_list_udp_pkts = tsk_list_create())) {
+			TSK_DEBUG_ERROR("Failed to create en empty list");
+			return tsk_null;
+		}
+        // get a handle for the global timer manager
+        if (!(p_session->timer.ph_global = tsk_timer_mgr_global_ref())) {
+            TSK_DEBUG_ERROR("Failed to get a reference to the global timer");
+            return tsk_null;
+        }
+        p_session->u_local_port = TNET_SOCKET_PORT_ANY;
+		p_session->e_role_local = kBfcpRoleDefault;
+		p_session->e_setup_local = kBfcpSetupDefault;
+        tsk_safeobj_init(p_session);
+    }
+    return self;
+}
+static tsk_object_t* tbfcp_session_dtor(tsk_object_t * self)
+{
+    tbfcp_session_t *p_session = (tbfcp_session_t *)self;
+    if (p_session) {
+        TSK_DEBUG_INFO("*** BFCP session destroyed ***");
+        // stop the session if not already done
+        tbfcp_session_stop(p_session);
+        // release the handle for the global timer manager
+        tsk_timer_mgr_global_unref(&p_session->timer.ph_global);
+        
+        TSK_FREE(p_session->p_local_ip);
+        TSK_FREE(p_session->p_local_public_ip);
+        TSK_FREE(p_session->p_remote_ip);
+        TSK_FREE(p_session->p_buff_send_ptr);
+		TSK_OBJECT_SAFE_FREE(p_session->p_natt_ctx);
+        TSK_OBJECT_SAFE_FREE(p_session->p_ice_ctx);
+        TSK_OBJECT_SAFE_FREE(p_session->p_transport);
+		TSK_OBJECT_SAFE_FREE(p_session->p_list_udp_pkts);
+        tsk_safeobj_deinit(p_session);
+    }
+
+    return self;
+}
+static int tbfcp_session_cmp(const tsk_object_t *_pss1, const tsk_object_t *_pss2)
+{
+    const tbfcp_session_t *pc_ss1 = (const tbfcp_session_t *)_pss1;
+    const tbfcp_session_t *pc_ss2 = (const tbfcp_session_t *)_pss2;
+    return (int)(pc_ss1 - pc_ss2);
+}
+static const tsk_object_def_t tbfcp_session_def_s = {
+    sizeof(tbfcp_session_t),
+    tbfcp_session_ctor,
+    tbfcp_session_dtor,
+    tbfcp_session_cmp,
+};
+const tsk_object_def_t *tbfcp_session_def_t = &tbfcp_session_def_s;
+
+
+
+static int _tbfcp_udp_pkt_create(const tbfcp_pkt_t *pc_pkt, tbfcp_udp_pkt_t** pp_pkt)
+{
+	extern const tsk_object_def_t *tbfcp_udp_pkt_def_t;
+	if (!pc_pkt || !pp_pkt) {
+		TSK_DEBUG_ERROR("Invalid parameter");
+		return -1;
+	}
+	*pp_pkt = tsk_object_new(tbfcp_udp_pkt_def_t);
+	if (!(*pp_pkt)) {
+		TSK_DEBUG_ERROR("Failed to create object with type= 'tbfcp_udp_pkt_def_t'");
+		return -2;
+	}
+	(*pp_pkt)->p_pkt = tsk_object_ref(TSK_OBJECT(pc_pkt));
+	return 0;
+}
+
+static tsk_object_t* tbfcp_udp_pkt_ctor(tsk_object_t * self, va_list * app)
+{
+    tbfcp_udp_pkt_t *p_udp_pkt = (tbfcp_udp_pkt_t *)self;
+    if (p_udp_pkt) {
+        p_udp_pkt->timer.u_timeout = kBfcpTimerT1;
+		p_udp_pkt->timer.u_id = TSK_INVALID_TIMER_ID;
+    }
+    return self;
+}
+static tsk_object_t* tbfcp_udp_pkt_dtor(tsk_object_t * self)
+{
+    tbfcp_udp_pkt_t *p_udp_pkt = (tbfcp_udp_pkt_t *)self;
+    if (p_udp_pkt) {
+		TSK_OBJECT_SAFE_FREE(p_udp_pkt->p_pkt);
+		TSK_DEBUG_INFO("*** tbfcp_udp_pkt_t destroyed ***");
+    }
+    return self;
+}
+static const tsk_object_def_t tbfcp_udp_pkt_def_s = {
+    sizeof(tbfcp_udp_pkt_t),
+    tbfcp_udp_pkt_ctor,
+    tbfcp_udp_pkt_dtor,
+    tsk_null,
+};
+const tsk_object_def_t *tbfcp_udp_pkt_def_t = &tbfcp_udp_pkt_def_s;
diff --git a/tinyBFCP/src/tbfcp_utils.c b/tinyBFCP/src/tbfcp_utils.c
new file mode 100644
index 0000000..7c0ff25
--- /dev/null
+++ b/tinyBFCP/src/tbfcp_utils.c
@@ -0,0 +1,191 @@
+/* Copyright (C) 2014 Mamadou DIOP.
+*
+* 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 Lesser General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with DOUBANGO.
+*
+*/
+#include "tinybfcp/tbfcp_utils.h"
+
+#include "tinynet.h"
+#include "tsk_string.h"
+#include "tsk_debug.h"
+
+int tbfcp_utils_get_profile(enum tnet_socket_type_e e_socket_type, const char** ppc_profile)
+{
+    if (!ppc_profile) {
+        TSK_DEBUG_ERROR("Invalid parameter");
+        return -1;
+    }
+
+    if (TNET_SOCKET_TYPE_IS_DTLS(e_socket_type)) {
+        *ppc_profile = kBfcpProfileDTLS;
+        return 0;
+    }
+    if (TNET_SOCKET_TYPE_IS_UDP(e_socket_type)) {
+        *ppc_profile = kBfcpProfileUDP;
+        return 0;
+    }
+    if (TNET_SOCKET_TYPE_IS_TLS(e_socket_type)) {
+        *ppc_profile = kBfcpProfileTLS;
+        return 0;
+    }
+    if (TNET_SOCKET_TYPE_IS_TCP(e_socket_type)) {
+        *ppc_profile = kBfcpProfileTCP;
+        return 0;
+    }
+    TSK_DEBUG_ERROR("%d not supported as valid socket type for BFCP sessions", e_socket_type);
+    return -2;
+}
+
+int tbfcp_utils_get_role(enum tbfcp_role_e e_role, const char** ppc_role)
+{
+    if (!ppc_role) {
+        TSK_DEBUG_ERROR("Invalid parameter");
+        return -1;
+    }
+    switch (e_role) {
+    case tbfcp_role_c_only:
+        *ppc_role = kBfcpRoleC;
+        return 0;
+    case tbfcp_role_s_only:
+        *ppc_role = kBfcpRoleS;
+        return 0;
+    case tbfcp_role_c_s:
+        *ppc_role = kBfcpRoleCS;
+        return 0;
+    default:
+        TSK_DEBUG_ERROR("%d not valid BFCP role", e_role);
+        return -2;
+    }
+}
+
+int tbfcp_utils_parse_role(const char* pc_role, enum tbfcp_role_e* pe_role)
+{
+    if (!pc_role || !pe_role) {
+        TSK_DEBUG_ERROR("Invalid parameter");
+        return -1;
+    }
+    if (tsk_striequals(pc_role, kBfcpRoleC)) {
+        *pe_role = tbfcp_role_c_only;
+        return 0;
+    }
+    if (tsk_striequals(pc_role, kBfcpRoleS)) {
+        *pe_role = tbfcp_role_s_only;
+        return 0;
+    }
+    if (tsk_striequals(pc_role, kBfcpRoleCS)) {
+        *pe_role = tbfcp_role_c_s;
+        return 0;
+    }
+    TSK_DEBUG_ERROR("%s not valid BFCP role", pc_role);
+    return -2;
+}
+
+int tbfcp_utils_get_setup(enum tbfcp_role_e e_setup, const char** ppc_setup)
+{
+	if (!ppc_setup) {
+        TSK_DEBUG_ERROR("Invalid parameter");
+        return -1;
+    }
+    switch (e_setup) {
+    case tbfcp_setup_actpass:
+        *ppc_setup = kBfcpSetupActPass;
+        return 0;
+    case tbfcp_setup_active:
+        *ppc_setup = kBfcpSetupActive;
+        return 0;
+    case tbfcp_setup_passive:
+        *ppc_setup = kBfcpSetupPassive;
+        return 0;
+    default:
+        TSK_DEBUG_ERROR("%d not valid BFCP setup", e_setup);
+        return -2;
+    }
+}
+
+int tbfcp_utils_parse_setup(const char* pc_setup, enum tbfcp_setup_e* pe_setup)
+{
+	if (!pc_setup || !pe_setup) {
+        TSK_DEBUG_ERROR("Invalid parameter");
+        return -1;
+    }
+    if (tsk_striequals(pc_setup, kBfcpSetupActPass)) {
+        *pe_setup = tbfcp_setup_actpass;
+        return 0;
+    }
+    if (tsk_striequals(pc_setup, kBfcpSetupActive)) {
+        *pe_setup = tbfcp_setup_active;
+        return 0;
+    }
+    if (tsk_striequals(pc_setup, kBfcpSetupPassive)) {
+        *pe_setup = tbfcp_setup_passive;
+        return 0;
+    }
+    TSK_DEBUG_ERROR("%s not valid BFCP setup", pc_setup);
+    return -2;
+}
+
+int tbfcp_utils_is_role_acceptable(enum tbfcp_role_e e_role_local, enum tbfcp_role_e e_role_proposed, tsk_bool_t *pb_acceptable)
+{
+	if (!pb_acceptable) {
+		TSK_DEBUG_ERROR("Invalid parameter");
+        return -1;
+	}
+	switch (e_role_local) {
+		case tbfcp_role_c_only:
+			*pb_acceptable = (e_role_proposed == tbfcp_role_s_only || e_role_proposed == tbfcp_role_c_s);
+			break;
+		case tbfcp_role_s_only:
+			*pb_acceptable = (e_role_proposed == tbfcp_role_c_only || e_role_proposed == tbfcp_role_c_s);
+			break;
+		case tbfcp_role_c_s:
+			*pb_acceptable = tsk_true;
+			break;
+		default:
+			*pb_acceptable = tsk_false;
+			break;
+	}
+	return 0;
+}
+
+int tbfcp_utils_is_setup_acceptable(enum tbfcp_setup_e e_setup_local, enum tbfcp_setup_e e_setup_proposed, tsk_bool_t *pb_acceptable)
+{
+	if (!pb_acceptable) {
+		TSK_DEBUG_ERROR("Invalid parameter");
+        return -1;
+	}
+	switch (e_setup_local) {
+		case tbfcp_setup_active:
+			*pb_acceptable = (e_setup_proposed == tbfcp_setup_passive || e_setup_proposed == tbfcp_setup_actpass);
+			break;
+		case tbfcp_setup_passive:
+			*pb_acceptable = (e_setup_proposed == tbfcp_setup_active || e_setup_proposed == tbfcp_setup_actpass);
+			break;
+		case tbfcp_setup_actpass:
+			*pb_acceptable = tsk_true;
+			break;
+		default:
+			*pb_acceptable = tsk_false;
+			break;
+	}
+	return 0;
+}
+
+uint16_t tbfcp_utils_rand_u16()
+{
+	static long __rand = 0;
+	long num = tsk_atomic_inc(&__rand);
+	return ((num % 0xFF) << 8) | (tsk_time_epoch() % 0xFF);
+}