/*
 * Copyright (c) 2014-2018, Arm Limited and affiliates.
 * SPDX-License-Identifier: BSD-3-Clause
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of the copyright holder nor the
 *    names of its contributors may be used to endorse or promote products
 *    derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */


#include "nsconfig.h"
#ifdef HAVE_THREAD
#include <ns_types.h>
#include "ns_list.h"
#include "ns_trace.h"
#include "nsdynmemLIB.h"
#include "ns_nvm_helper.h"
#include "randLIB.h"
#include "common_functions.h"
#include "thread_tmfcop_lib.h"
#include "ns_sha256.h"

#include "NWK_INTERFACE/Include/protocol.h"
#include "Service_Libs/blacklist/blacklist.h"

#include "coap_service_api.h"

#include "eventOS_event_timer.h"
#include "thread_discovery.h"
#include "thread_beacon.h"
#include "thread_config.h"
#include "thread_meshcop_lib.h"
#include "thread_commissioning_if.h"
#include "thread_management_if.h"
#include "thread_common.h"
#include "thread_bootstrap.h"
#include "thread_router_bootstrap.h"
#include "thread_network_synch.h"
#include "thread_network_data_lib.h"
#include "thread_joiner_application.h"
#include "6LoWPAN/Thread/thread_ccm.h"
#include "mac_api.h"
#include "6LoWPAN/MAC/mac_helper.h"
#include "thread_nvm_store.h"
#include "thread_management_internal.h"

#define TRACE_GROUP TRACE_GROUP_THREAD_JOINER_APPLICATION

/* List of active/pending configuration dataset TLVs*/
const uint8_t mle_pending_configuration_dataset_tlvs[] = {
    MESHCOP_TLV_ACTIVE_TIME_STAMP,
    MESHCOP_TLV_NETWORK_NAME,
    MESHCOP_TLV_PANID,
    MESHCOP_TLV_CHANNEL,
    MESHCOP_TLV_CHANNEL_MASK,
    MESHCOP_TLV_XPANID,
    MESHCOP_TLV_NETWORK_MESH_LOCAL_ULA,
    MESHCOP_TLV_NETWORK_MASTER_KEY,
    MESHCOP_TLV_PSKC,
    MESHCOP_TLV_SECURITY_POLICY
};

const uint8_t pending_configuration_dataset_tlvs[] = {
    MESHCOP_TLV_PENDING_TIMESTAMP,
    MESHCOP_TLV_ACTIVE_TIME_STAMP,
    MESHCOP_TLV_NETWORK_NAME,
    MESHCOP_TLV_PANID,
    MESHCOP_TLV_CHANNEL,
    MESHCOP_TLV_CHANNEL_MASK,
    MESHCOP_TLV_XPANID,
    MESHCOP_TLV_NETWORK_MESH_LOCAL_ULA,
    MESHCOP_TLV_NETWORK_MASTER_KEY,
    MESHCOP_TLV_PSKC,
    MESHCOP_TLV_SECURITY_POLICY
};

const uint8_t active_configuration_dataset_tlvs[] = {
    MESHCOP_TLV_ACTIVE_TIME_STAMP,
    MESHCOP_TLV_NETWORK_NAME,
    MESHCOP_TLV_PANID,
    MESHCOP_TLV_CHANNEL,
    MESHCOP_TLV_CHANNEL_MASK,
    MESHCOP_TLV_XPANID,
    MESHCOP_TLV_NETWORK_MESH_LOCAL_ULA,
    MESHCOP_TLV_NETWORK_MASTER_KEY,
    MESHCOP_TLV_PSKC,
    MESHCOP_TLV_SECURITY_POLICY
};

const uint8_t mle_active_configuration_dataset_tlvs[] = {
    MESHCOP_TLV_NETWORK_NAME,
    MESHCOP_TLV_PANID,
    MESHCOP_TLV_CHANNEL,
    MESHCOP_TLV_CHANNEL_MASK,
    MESHCOP_TLV_XPANID,
    MESHCOP_TLV_NETWORK_MESH_LOCAL_ULA,
    MESHCOP_TLV_NETWORK_MASTER_KEY,
    MESHCOP_TLV_PSKC,
    MESHCOP_TLV_SECURITY_POLICY
};

const uint8_t entrust_dataset_tlvs[] = {
    MESHCOP_TLV_ACTIVE_TIME_STAMP,
    MESHCOP_TLV_NETWORK_NAME,
    MESHCOP_TLV_CHANNEL_MASK,// Missing specification
    MESHCOP_TLV_XPANID,
    MESHCOP_TLV_NETWORK_MESH_LOCAL_ULA,
    MESHCOP_TLV_NETWORK_MASTER_KEY,
    MESHCOP_TLV_PSKC,
    MESHCOP_TLV_SECURITY_POLICY,
    MESHCOP_TLV_NETWORK_KEY_SEQUENCE
};

const uint8_t meshcop_pending_set_ignore[] = {
    MESHCOP_TLV_BORDER_ROUTER_LOCATOR,
    MESHCOP_TLV_COMMISSIONER_SESSION_ID,
    MESHCOP_TLV_PENDING_TIMESTAMP,
    MESHCOP_TLV_COMMISSIONER_ID,
    MESHCOP_TLV_STEERING_DATA,
    MESHCOP_TLV_DELAY_TIMER,
    MESHCOP_TLV_GET,
    MESHCOP_TLV_COMMISSIONER_UDP_PORT,
    MESHCOP_TLV_JOINER_UDP_PORT,
    MESHCOP_TLV_STATE,
    MESHCOP_TLV_NETWORK_KEY_SEQUENCE
};

const uint8_t meshcop_active_set_ignore[] = {
    MESHCOP_TLV_PENDING_TIMESTAMP,
    MESHCOP_TLV_COMMISSIONER_SESSION_ID,
    MESHCOP_TLV_COMMISSIONER_ID,
    MESHCOP_TLV_STEERING_DATA,
    MESHCOP_TLV_DELAY_TIMER,
    MESHCOP_TLV_NETWORK_KEY_SEQUENCE
};

const uint8_t mle_active_configuration_dataset_ignore_tlvs[] = {
    MESHCOP_TLV_ACTIVE_TIME_STAMP
};

const uint8_t mle_pending_configuration_dataset_ignore_tlvs[] = {
    MESHCOP_TLV_PENDING_TIMESTAMP
};

uint8_t mle_active_configuration_dataset_tlvs_size(void)
{
    return sizeof(mle_active_configuration_dataset_tlvs);
}

uint8_t active_configuration_dataset_tlvs_size(void)
{
    return sizeof(active_configuration_dataset_tlvs);
}

uint8_t mle_active_configuration_dataset_ignore_tlvs_size(void)
{
    return sizeof(mle_active_configuration_dataset_ignore_tlvs);
}

uint8_t mle_pending_configuration_dataset_ignore_tlvs_size(void)
{
    return sizeof(mle_pending_configuration_dataset_ignore_tlvs);
}

uint8_t mle_pending_configuration_dataset_tlvs_size(void)
{
    return sizeof(mle_pending_configuration_dataset_tlvs);
}
uint8_t pending_configuration_dataset_tlvs_size(void)
{
    return sizeof(pending_configuration_dataset_tlvs);
}
uint8_t entrust_dataset_tlvs_size(void)
{
    return sizeof(entrust_dataset_tlvs);
}
#define MAX_OPERATIONAL_DATASET_SIZE 254

typedef struct {
    uint32_t timeout_in_ms;
    uint64_t timestamp;
    uint16_t length;
    uint8_t data[MAX_OPERATIONAL_DATASET_SIZE];
} configuration_set_t;

typedef struct {
    link_configuration_s *configuration_ptr;
    configuration_set_t *active_configuration_ptr;
    configuration_set_t *pending_configuration_ptr;
    configuration_set_t *old_active_configuration_ptr;
    configuration_set_t *next_active_configuration_ptr;
    configuration_set_t *next_pending_configuration_ptr;
    device_configuration_s *device_configuration_ptr;
    uint8_t parent_address[16];
    uint16_t parent_port;
    thread_commission_done_cb *done_cb;
    timeout_t *attach_timeout;
    timeout_t *entrust_timeout;
    uint32_t provisioning_timeout;
    thread_provisioning_status_e provisioning_done;
    bool configuration_valid: 1; //TODO this should???? be put in link configuration
    bool finalisation_done: 1;
    bool nvm_link_configuration_load: 1; // load link configuration settings from NVM in restart
    int8_t interface_id;
    int8_t coap_service_id;
    int8_t secure_coap_service_id;
    bool pending_set_in_sync: 1;
    ns_list_link_t link;
} thread_joiner_t;


static NS_LIST_DEFINE(instance_list, thread_joiner_t, link);

static int thread_joiner_application_nvm_link_config_read(thread_joiner_t *this);
static bool thread_joiner_application_validate_settings(thread_joiner_t *this);
static uint8_t *thread_joiner_application_write_channel(uint8_t *ptr, uint16_t data);

static int stringlen(const char *s, int n)
{
    char *end = memchr(s, 0, n);
    return end ? end - s : n;
}

static char *str_dub(char *str)
{
    char *result_ptr = NULL;
    if (str) {
        result_ptr = ns_dyn_mem_alloc(strlen(str) + 1);
        if (result_ptr) {
            strcpy(result_ptr, str);
        }
    }
    return result_ptr;
}

static thread_joiner_t *thread_joiner_find(int8_t interface_id)
{
    thread_joiner_t *this = NULL;
    ns_list_foreach(thread_joiner_t, cur_ptr, &instance_list) {
        if (cur_ptr->interface_id == interface_id) {
            this = cur_ptr;
            break;
        }
    }
    return this;
}

static thread_joiner_t *thread_joiner_find_by_service(int8_t service_id)
{
    thread_joiner_t *this = NULL;
    ns_list_foreach(thread_joiner_t, cur_ptr, &instance_list) {
        if (cur_ptr->coap_service_id == service_id || cur_ptr->secure_coap_service_id == service_id) {
            this = cur_ptr;
            break;
        }
    }
    return this;
}

static thread_joiner_t *thread_joiner_get(int8_t interface_id)
{
    thread_joiner_t *this = thread_joiner_find(interface_id);
    if (!this) {
        this = ns_dyn_mem_alloc(sizeof(thread_joiner_t));
        if (this) {
            memset(this, 0, sizeof(thread_joiner_t));
            ns_list_add_to_start(&instance_list, this);
            this->interface_id = interface_id;
            this->provisioning_done = PROVISIONING_STATUS_DONE; // Default value for provisioning is done
        }
    }
    return this;
}

static void thread_joiner_application_commission_clean(thread_joiner_t *this)
{
    thread_commissioning_if_pairwise_key_delete_all(this->interface_id);
    memset(this->parent_address, 0, 16);
    this->parent_port = 0;
    coap_service_delete(this->secure_coap_service_id);
    coap_service_delete(this->coap_service_id);
    this->secure_coap_service_id = 0;
    this->coap_service_id = 0;
    eventOS_timeout_cancel(this->attach_timeout);
    eventOS_timeout_cancel(this->entrust_timeout);
    this->attach_timeout = NULL;
    this->entrust_timeout = NULL;
}

//@TODO wrong place move these
//@TODO Steering data is wrongly made it is not part of static configuration
//@TODO PSKc is static data and should always be present not dynamic.
static link_configuration_s *link_configuration_create(void)
{
    link_configuration_s *this = ns_dyn_mem_alloc(sizeof(link_configuration_s));
    if (!this) {
        return NULL;
    }
    memset(this, 0, sizeof(link_configuration_s));
    this->securityPolicy = SECURITY_POLICY_ALL_SECURITY;        // Set all default values ('1') for security policy flags
    this->securityPolicyExt = SECURITY_POLICY_ALL_SECURITY;     // Set all default values
    return this;
}

static void link_configuration_delete(link_configuration_s *this)
{
    if (!this) {
        return;
    }
    ns_dyn_mem_free(this);
}

static void link_configuration_copy(link_configuration_s *this, link_configuration_s *configuration_ptr)
{
    if (!this || !configuration_ptr) {
        return;
    }
    memcpy(this->name, configuration_ptr->name, 16);
    memcpy(this->PSKc, configuration_ptr->PSKc, 16);
    memcpy(this->master_key, configuration_ptr->master_key, 16);
    memcpy(this->mesh_local_ula_prefix, configuration_ptr->mesh_local_ula_prefix, 8);
    memcpy(this->extented_pan_id, configuration_ptr->extented_pan_id, 8);
    memcpy(this->channel_mask, configuration_ptr->channel_mask, 5);
    this->key_rotation = configuration_ptr->key_rotation;
    this->key_sequence = configuration_ptr->key_sequence;
    this->panId = configuration_ptr->panId;
    this->rfChannel = configuration_ptr->rfChannel;
    this->securityPolicy = configuration_ptr->securityPolicy;
    this->securityPolicyExt = configuration_ptr->securityPolicyExt;
    this->timestamp = configuration_ptr->timestamp;
    return;
}
static int link_configuration_update(link_configuration_s *link_configuration, uint8_t *msg_ptr, uint16_t msg_len)
{
    uint8_t *ptr;
    uint16_t len;

    if (!msg_ptr || !link_configuration) {
        return -1;
    }
    len = thread_meshcop_tlv_find(msg_ptr, msg_len, MESHCOP_TLV_NETWORK_NAME, &ptr);
    if (len > 0) {
        memset(link_configuration->name, 0, 16);
        memcpy(link_configuration->name, ptr, (len > 16) ? 16 : len);
    }

    if (thread_meshcop_tlv_find(msg_ptr, msg_len, MESHCOP_TLV_CHANNEL, &ptr) >= 3) {
        //channel_page = channel_ptr[0];
        link_configuration->rfChannel = common_read_16_bit(&ptr[1]);
    }
    if (thread_meshcop_tlv_find(msg_ptr, msg_len, MESHCOP_TLV_CHANNEL_MASK, &ptr) > 5) {
        //channel_page = channel_ptr[0];
        if (ptr[0] == 0 && ptr[1] == 4) {
            link_configuration->channel_page = ptr[0];
            memcpy(link_configuration->channel_mask, &ptr[2], 4);
        } else {
            tr_warn("Invalid channel mask");
        }
    }
    if (thread_meshcop_tlv_find(msg_ptr, msg_len, MESHCOP_TLV_XPANID, &ptr) >= 8) {
        memcpy(link_configuration->extented_pan_id, ptr, 8);
    }

    if (thread_meshcop_tlv_find(msg_ptr, msg_len, MESHCOP_TLV_NETWORK_MESH_LOCAL_ULA, &ptr) >= 8) {
        memcpy(link_configuration->mesh_local_ula_prefix, ptr, 8);
    }

    if (thread_meshcop_tlv_find(msg_ptr, msg_len, MESHCOP_TLV_NETWORK_MASTER_KEY, &ptr) >= 16) {
        memcpy(link_configuration->master_key, ptr, 16);
    }

    if (thread_meshcop_tlv_find(msg_ptr, msg_len, MESHCOP_TLV_ACTIVE_TIME_STAMP, &ptr) >= 8) {
        link_configuration->timestamp = common_read_64_bit(ptr);
    }
    if (thread_meshcop_tlv_find(msg_ptr, msg_len, MESHCOP_TLV_PANID, &ptr) >= 2) {
        link_configuration->panId = common_read_16_bit(ptr);
    }
    if (thread_meshcop_tlv_find(msg_ptr, msg_len, MESHCOP_TLV_PSKC, &ptr) >= 16) {
        memcpy(link_configuration->PSKc, ptr, 16);
    }
    uint16_t tlv_len = thread_meshcop_tlv_find(msg_ptr, msg_len, MESHCOP_TLV_SECURITY_POLICY, &ptr);
    if (tlv_len  >= 3) {
        link_configuration->securityPolicyExt = SECURITY_POLICY_ALL_SECURITY;
        link_configuration->securityPolicy = ptr[2];
        link_configuration->key_rotation = common_read_16_bit(ptr);
        if (tlv_len > 3) {
            link_configuration->securityPolicyExt = ptr[3];
        }
    }

    return 0;
}

static void link_configuration_trace(link_configuration_s *this)
{
    if (!this) {
        return;
    }
    tr_debug("NwkName: %s", trace_array(this->name, 16));
    tr_debug("Mesh ula: %s", trace_array(this->mesh_local_ula_prefix, 8));
    tr_debug("Extendend PanId: %s", trace_array(this->extented_pan_id, 8));
    tr_debug("panid: %"PRIu16", Channel:%"PRIu16", keyRot:%"PRIu16", keySeq:%"PRIu32, this->panId, this->rfChannel, this->key_rotation, this->key_sequence);
    return;
}

static device_configuration_s *device_configuration_create(void)
{
    device_configuration_s *this = ns_dyn_mem_alloc(sizeof(device_configuration_s));
    if (!this) {
        return NULL;
    }
    memset(this, 0, sizeof(device_configuration_s));
    return this;
}

static void device_configuration_delete(device_configuration_s *this)
{
    if (!this) {
        return;
    }
    ns_dyn_mem_free(this->PSKd_ptr);
    ns_dyn_mem_free(this->provisioning_uri_ptr);
    ns_dyn_mem_free(this->vendor_name_ptr);
    ns_dyn_mem_free(this->vendor_model_ptr);
    ns_dyn_mem_free(this->vendor_sw_version_ptr);
    ns_dyn_mem_free(this->vendor_data_ptr);
    ns_dyn_mem_free(this);
}
static void device_configuration_copy(device_configuration_s *this, device_configuration_s *configuration_ptr)
{
    if (!this || !configuration_ptr) {
        return;
    }
    memcpy(this->eui64, configuration_ptr->eui64, 8);
    memcpy(this->extended_random_mac, configuration_ptr->extended_random_mac, 8);
    memcpy(this->mesh_local_eid, configuration_ptr->mesh_local_eid, 8);
    memcpy(this->vendor_stack_version, configuration_ptr->vendor_stack_version, 6);
    //TODO: count PSKc instead and use that
    if (configuration_ptr->PSKd_ptr && configuration_ptr->PSKd_len > 0) {
        this->PSKd_ptr = ns_dyn_mem_alloc(configuration_ptr->PSKd_len);
        if (this->PSKd_ptr) {
            memcpy(this->PSKd_ptr, configuration_ptr->PSKd_ptr, configuration_ptr->PSKd_len);
            this->PSKd_len = configuration_ptr->PSKd_len;
        } else {
            this->PSKd_len = 0;
        }
    }

    this->provisioning_uri_ptr = str_dub(configuration_ptr->provisioning_uri_ptr);
    this->vendor_name_ptr = str_dub(configuration_ptr->vendor_name_ptr);
    this->vendor_model_ptr = str_dub(configuration_ptr->vendor_model_ptr);
    this->vendor_sw_version_ptr = str_dub(configuration_ptr->vendor_sw_version_ptr);

    uint16_t vendor_data_len = configuration_ptr->vendor_data_len;

    if (vendor_data_len) {
        if (vendor_data_len > 64) {
            vendor_data_len = 64;
        }
        this->vendor_data_ptr = ns_dyn_mem_alloc(vendor_data_len);
        if (this->vendor_data_ptr) {
            memcpy(this->vendor_data_ptr, configuration_ptr->vendor_data_ptr, vendor_data_len);
            this->vendor_data_len = vendor_data_len;
        }
    }
    return;
}
static void device_configuration_trace(device_configuration_s *this)
{
    if (!this) {
        return;
    }
    tr_debug("Mesh local eid: %s", trace_array(this->mesh_local_eid, 8));
    tr_debug("extended random: %s", trace_array(this->extended_random_mac, 8));
    tr_debug("uri: %s", this->provisioning_uri_ptr ? this->provisioning_uri_ptr : "(none)");
    tr_debug("name: %s", this->vendor_name_ptr);
    tr_debug("mode: %s", this->vendor_model_ptr);
    tr_debug("version: %s", this->vendor_sw_version_ptr);
    tr_debug("vendor data: %s", trace_array(this->vendor_data_ptr, this->vendor_data_len));
    return;
}

static void device_configuration_validate(device_configuration_s *this)
{
    // Set defaults if not overridden by client
    if (!this->vendor_model_ptr) {
        this->vendor_model_ptr = str_dub(THREAD_VENDOR_MODEL);
    }
    if (!this->vendor_name_ptr) {
        this->vendor_name_ptr = str_dub(THREAD_VENDOR_NAME);
    }
    if (!this->vendor_sw_version_ptr) {
        this->vendor_sw_version_ptr = str_dub(THREAD_SW_VERSION);
    }
    if (memcmp(this->vendor_stack_version, "\0\0\0\0\0\0", 6) == 0) {
        // Empty lets set defaults
        this->vendor_stack_version[0] = (uint8_t)(THREAD_ARM_OUI >> 16);
        this->vendor_stack_version[1] = (uint8_t)(THREAD_ARM_OUI >> 8);
        this->vendor_stack_version[2] = (uint8_t)(THREAD_ARM_OUI);
        this->vendor_stack_version[3] = (uint8_t)(THREAD_BUILD_NUMBER >> 4);
        this->vendor_stack_version[4] = (uint8_t)(((THREAD_BUILD_NUMBER & 0x0f) << 4) | THREAD_REVISION_NUMBER);
        this->vendor_stack_version[5] = (uint8_t)((THREAD_VERSION_MIN  << 4) | THREAD_VERSION_MAJ);
    }
}

static configuration_set_t *configuration_set_copy(configuration_set_t *source_ptr)
{
    configuration_set_t *result_ptr;
    if (!source_ptr) {
        return NULL;
    }
    result_ptr = ns_dyn_mem_alloc(sizeof(configuration_set_t));
    if (!result_ptr) {
        return NULL;
    }
    memcpy(result_ptr->data, source_ptr->data, source_ptr->length);
    result_ptr->length = source_ptr->length;
    result_ptr->timeout_in_ms = source_ptr->timeout_in_ms;
    result_ptr->timestamp = source_ptr->timestamp;
    return result_ptr;
}

static bool configuration_set_tlv_required(uint8_t tlv_id, const uint8_t *tlv_ptr, uint8_t tlv_len)
{
    while (tlv_len) {
        if (tlv_ptr[tlv_len-- -1] == tlv_id) {
            return true;
        }
    }
    return false;
}

static uint16_t configuration_set_length(configuration_set_t *config_ptr, const uint8_t *req_tlv_ptr, uint8_t req_tlv_len, const uint8_t *ignored_tlv_ptr, uint8_t ignored_tlv_len)
{
    const uint8_t *tlv_ptr;
    uint16_t tlv_len;
    int16_t result_len = 0;
    tlv_len = config_ptr->length;
    tlv_ptr = config_ptr->data;

    while (tlv_ptr && tlv_len) {
        if ((!req_tlv_ptr || req_tlv_len == 0 || configuration_set_tlv_required(*tlv_ptr, req_tlv_ptr, req_tlv_len)) &&
                !configuration_set_tlv_required(*tlv_ptr, ignored_tlv_ptr, ignored_tlv_len)) {
            int16_t required_len = thread_meshcop_tlv_length_required(tlv_ptr, tlv_len);
            if (required_len < 0) {
                return 0;
            }
            result_len += required_len;
        }
        tlv_ptr = thread_meshcop_tlv_get_next(tlv_ptr, &tlv_len);
    }

    return result_len;
}

static uint8_t *configuration_set_write(configuration_set_t *config_ptr, uint8_t *ptr, const uint8_t *req_tlv_ptr, uint8_t req_tlv_len, const uint8_t *ignored_tlv_ptr, uint8_t ignored_tlv_len)
{
    const uint8_t *tlv_ptr;
    uint16_t tlv_len;
    tlv_len = config_ptr->length;
    tlv_ptr = config_ptr->data;
    while (tlv_ptr && tlv_len) {
        if ((!req_tlv_ptr || req_tlv_len == 0  || configuration_set_tlv_required(*tlv_ptr, req_tlv_ptr, req_tlv_len)) &&
                !configuration_set_tlv_required(*tlv_ptr, ignored_tlv_ptr, ignored_tlv_len)) {
            int16_t required_len = thread_meshcop_tlv_length_required(tlv_ptr, tlv_len);
            if (required_len < 0 || config_ptr->length + required_len > MAX_OPERATIONAL_DATASET_SIZE) {
                // Source configuration is corrupted or length exceeded
                return ptr;
            }
            memcpy(ptr, tlv_ptr, required_len);
            ptr += required_len;
        }
        tlv_ptr = thread_meshcop_tlv_get_next(tlv_ptr, &tlv_len);
    }
    return ptr;
}

static uint8_t *configuration_set_add_fields(configuration_set_t *destination_ptr, const uint8_t *source_ptr, uint16_t source_len, const uint8_t *required_tlv_ptr, uint8_t required_tlv_len)
{
    uint8_t *ptr;
    ptr = destination_ptr->data + destination_ptr->length;
    while (source_ptr && source_len) {
        if (configuration_set_tlv_required(*source_ptr, required_tlv_ptr, required_tlv_len)) {
            int16_t required_len = thread_meshcop_tlv_length_required(source_ptr, source_len);
            if (required_len < 0 || destination_ptr->length + required_len > MAX_OPERATIONAL_DATASET_SIZE) {
                // Source configuration is corrupted or length exceeded
                return ptr;
            }
            memcpy(ptr, source_ptr, required_len);
            destination_ptr->length += required_len;
            ptr += required_len;
        }
        source_ptr = thread_meshcop_tlv_get_next(source_ptr, &source_len);
    }
    return ptr;
}
static uint8_t *configuration_set_add_all_fields(configuration_set_t *destination_ptr, const uint8_t *source_ptr, uint16_t source_len, const uint8_t *ignored_tlv_ptr, uint8_t ignored_tlv_len)
{
    uint8_t *ptr;
    ptr = destination_ptr->data + destination_ptr->length;
    while (source_ptr && source_len) {
        if (!configuration_set_tlv_required(*source_ptr, ignored_tlv_ptr, ignored_tlv_len)) {
            int16_t required_len = thread_meshcop_tlv_length_required(source_ptr, source_len);
            if (required_len < 0 || destination_ptr->length + required_len > MAX_OPERATIONAL_DATASET_SIZE) {
                // Source configuration is corrupted or length exceeded
                return ptr;
            }
            memcpy(ptr, source_ptr, required_len);
            destination_ptr->length += required_len;
            ptr += required_len;
        }
        source_ptr = thread_meshcop_tlv_get_next(source_ptr, &source_len);
    }
    return ptr;
}
static void configuration_set_copy_missing(configuration_set_t *destination_ptr, configuration_set_t *source_ptr)
{
    uint8_t *tlv_list_ptr;
    uint16_t tlv_list_len = 0;
    if (!source_ptr || !destination_ptr) {
        return;
    }
    thread_meshcop_tlv_list_generate(source_ptr->data, source_ptr->length, NULL, &tlv_list_len);
    if (tlv_list_len == 0) {
        return;
    }
    tlv_list_ptr = ns_dyn_mem_temporary_alloc(tlv_list_len);
    if (!tlv_list_ptr) {
        return;
    }
    thread_meshcop_tlv_list_generate(source_ptr->data, source_ptr->length, tlv_list_ptr, &tlv_list_len);
    tr_debug("list in source: %s", trace_array(tlv_list_ptr, tlv_list_len));

    for (uint8_t n = 0; n < tlv_list_len; n++) {
        if (thread_meshcop_tlv_exist(destination_ptr->data, destination_ptr->length, tlv_list_ptr[n])) {
            // Depending specification 0 length TLVs from source should be also removed
            tlv_list_len = thread_meshcop_tlv_list_remove(tlv_list_ptr, tlv_list_len, tlv_list_ptr[n]);
            n--; // When we remove item from list we stay put
        }
    }
    if (tlv_list_len == 0) {
        // All mandatory TLVs present
        ns_dyn_mem_free(tlv_list_ptr);
        return;
    }
    tr_debug("mandatory TLVs needed: %s", trace_array(tlv_list_ptr, tlv_list_len));
    configuration_set_add_fields(destination_ptr, source_ptr->data, source_ptr->length, tlv_list_ptr, tlv_list_len);
    ns_dyn_mem_free(tlv_list_ptr);
}
static void configuration_set_remove_null_tlv(configuration_set_t *configuration_ptr)
{
    uint8_t *ptr;
    uint8_t *next_ptr;
    uint16_t length;
    if (!configuration_ptr) {
        return;
    }
    length = configuration_ptr->length;
    ptr = configuration_ptr->data;

    do {
        if (thread_meshcop_tlv_length(ptr, length) == 0) {
            // remove this TLV
            configuration_ptr->length -= thread_meshcop_tlv_length_required(ptr, length);
            next_ptr = (uint8_t *)thread_meshcop_tlv_get_next(ptr, &length);
            if (next_ptr) {
                memmove(ptr, next_ptr, length);
            }
        } else {
            ptr = (uint8_t *)thread_meshcop_tlv_get_next(ptr, &length);
        }

    } while (ptr && length);
    return;
}

static void configuration_set_copy_mandatory(configuration_set_t *destination_ptr, configuration_set_t *source_ptr)
{
    uint8_t tlv_list[sizeof(active_configuration_dataset_tlvs)];
    uint16_t tlv_list_len = sizeof(active_configuration_dataset_tlvs);
    if (!source_ptr || !destination_ptr) {
        return;
    }
    memcpy(tlv_list, active_configuration_dataset_tlvs, sizeof(active_configuration_dataset_tlvs));

    for (uint8_t n = 0; n < sizeof(active_configuration_dataset_tlvs); n++) {
        if (0 < thread_meshcop_tlv_find(destination_ptr->data, destination_ptr->length, active_configuration_dataset_tlvs[n], NULL)) {
            // Depending specification 0 length TLVs from source should be also removed
            tlv_list_len = thread_meshcop_tlv_list_remove(tlv_list, tlv_list_len, active_configuration_dataset_tlvs[n]);
        }
    }
    if (tlv_list_len == 0) {
        // All mandatory TLVs present
        return;
    }
    tr_debug("mandatory TLVs needed: %s", trace_array(tlv_list, tlv_list_len));
    configuration_set_add_fields(destination_ptr, source_ptr->data, source_ptr->length, tlv_list, tlv_list_len);
}
static void configuration_set_generate(int8_t interface_id, configuration_set_t *destination_ptr, link_configuration_s *configuration_ptr)
{
    uint8_t *response_ptr;

    if (!destination_ptr || !configuration_ptr) {
        return;
    }
    response_ptr = destination_ptr->data;

    response_ptr = thread_joiner_application_write_channel(response_ptr, configuration_ptr->rfChannel);
    *response_ptr++ = MESHCOP_TLV_CHANNEL_MASK; // type
    *response_ptr++ = 6; // length
    *response_ptr++ = configuration_ptr->channel_page; // channel page
    *response_ptr++ = 4; // channel mask length
    memcpy(response_ptr, configuration_ptr->channel_mask, 4);
    response_ptr += 4;
    response_ptr = thread_tmfcop_tlv_data_write(response_ptr, MESHCOP_TLV_XPANID, 8, configuration_ptr->extented_pan_id);
    response_ptr = thread_tmfcop_tlv_data_write(response_ptr, MESHCOP_TLV_NETWORK_MESH_LOCAL_ULA, 8, configuration_ptr->mesh_local_ula_prefix);
    response_ptr = thread_tmfcop_tlv_data_write(response_ptr, MESHCOP_TLV_NETWORK_MASTER_KEY, 16, configuration_ptr->master_key);
    response_ptr = thread_tmfcop_tlv_data_write_uint16(response_ptr, MESHCOP_TLV_PANID, configuration_ptr->panId);
    response_ptr = thread_tmfcop_tlv_data_write(response_ptr, MESHCOP_TLV_PSKC, 16, configuration_ptr->PSKc);
    response_ptr = thread_tmfcop_tlv_data_write(response_ptr, MESHCOP_TLV_NETWORK_NAME, stringlen((char *)&configuration_ptr->name, 16), configuration_ptr->name);
    *response_ptr++ = MESHCOP_TLV_SECURITY_POLICY; // type
    protocol_interface_info_entry_t *cur = protocol_stack_interface_info_get_by_id(interface_id);
    if (thread_info(cur)->version >= THREAD_VERSION_1_2) {
        *response_ptr++ = 4; // length
        response_ptr = common_write_16_bit(configuration_ptr->key_rotation, response_ptr);
        *response_ptr++ = configuration_ptr->securityPolicy;
        *response_ptr++ = configuration_ptr->securityPolicyExt;
    } else {
        *response_ptr++ = 3; // length
        response_ptr = common_write_16_bit(configuration_ptr->key_rotation, response_ptr);
        *response_ptr++ = configuration_ptr->securityPolicy;
    }
    response_ptr = thread_tmfcop_tlv_data_write_uint64(response_ptr, MESHCOP_TLV_ACTIVE_TIME_STAMP, configuration_ptr->timestamp);
    destination_ptr->length = response_ptr - destination_ptr->data;
}

static bool configuration_set_validate(uint8_t *configuration_set, uint16_t configuration_set_len, bool make_full_validation)
{
    if (thread_meshcop_tlv_find(configuration_set, configuration_set_len, MESHCOP_TLV_NETWORK_MASTER_KEY, NULL) < 16 ||
            thread_meshcop_tlv_find(configuration_set, configuration_set_len, MESHCOP_TLV_NETWORK_MESH_LOCAL_ULA, NULL) < 8 ||
            thread_meshcop_tlv_find(configuration_set, configuration_set_len, MESHCOP_TLV_XPANID, NULL) < 8 ||
            thread_meshcop_tlv_find(configuration_set, configuration_set_len, MESHCOP_TLV_NETWORK_NAME, NULL) == 0 ||
            thread_meshcop_tlv_find(configuration_set, configuration_set_len, MESHCOP_TLV_PSKC, NULL) < 16) {
        // Absolutely minimum we must have is master secret to attach.
        // If commissioner wants to be connected we must have PSKc,Name,Xpanid
        // If there is some fields missing we could attach, but timestamp must be set to 0 which will then cause synchronization
        tr_debug("Not all TLv's included");
        return false;
    }

    if (make_full_validation) {
        if ((thread_meshcop_tlv_find(configuration_set, configuration_set_len, MESHCOP_TLV_CHANNEL, NULL) == 0) ||
                (thread_meshcop_tlv_find(configuration_set, configuration_set_len, MESHCOP_TLV_PANID, NULL) == 0) ||
                (thread_meshcop_tlv_find(configuration_set, configuration_set_len, MESHCOP_TLV_XPANID, NULL) == 0)) {
            tr_debug("Not all TLv's included");
            return false;
        }
    }
    return true;
}

static bool thread_joiner_application_validate_settings(thread_joiner_t *this)
{
    bool new_value_generated = 0;
    if (memcmp(this->device_configuration_ptr->extended_random_mac, ADDR_UNSPECIFIED, 8) == 0) {
        randLIB_get_n_bytes_random(this->device_configuration_ptr->extended_random_mac, 8);
        this->device_configuration_ptr->extended_random_mac[0] |= 2; //Set Local Bit
        this->device_configuration_ptr->extended_random_mac[0] &= ~1; //Clear multicast bit
        new_value_generated = 1;
        tr_info("Generating Random MAC");
    }
    while (addr_iid_reserved(this->device_configuration_ptr->mesh_local_eid) ||
            memcmp(this->device_configuration_ptr->mesh_local_eid, ADDR_SHORT_ADR_SUFFIC, 6) == 0) {
        // addr_iid_reserved checks the all zeroes case.
        randLIB_get_n_bytes_random(this->device_configuration_ptr->mesh_local_eid, 8);
        new_value_generated = 1;
        tr_info("Generating Random ML-EID");
    }
    if (this->configuration_ptr->key_rotation < 1) {
        this->configuration_ptr->key_rotation = 1;
    }
    return new_value_generated;
}

int thread_joiner_application_init(int8_t interface_id, device_configuration_s *device_configuration_ptr, link_configuration_s *default_configuration_ptr)
{
    thread_joiner_t *this;
    uint8_t pskd_len;

    if (!device_configuration_ptr) {
        return -1;
    }
    pskd_len = device_configuration_ptr->PSKd_len;

    if (pskd_len > 32 || pskd_len < 6) {
        return -2;
    }

    this = thread_joiner_get(interface_id);
    if (!this) {
        return -3;
    }

    if (!this->device_configuration_ptr) {
        this->device_configuration_ptr = device_configuration_create();
    }
    if (!this->device_configuration_ptr) {
        tr_error("Joiner Device creation failed");
        return -4;
    }
    device_configuration_copy(this->device_configuration_ptr, device_configuration_ptr);
    device_configuration_validate(this->device_configuration_ptr); // Set defaults if missing
    device_configuration_trace(this->device_configuration_ptr);
    if (memcmp(this->device_configuration_ptr->eui64, "\0\0\0\0\0\0\0\0", 8) == 0) {
        //EUI64 is not set we then read that from Radio
        protocol_interface_info_entry_t *cur = protocol_stack_interface_info_get_by_id(interface_id);

        if (cur && cur->mac_api) {
            cur->mac_api->mac64_get(cur->mac_api, MAC_EXTENDED_READ_ONLY, this->device_configuration_ptr->eui64);
        }
    }
    // Adding entropy for our random seed
    randLIB_add_seed(common_read_64_bit(this->device_configuration_ptr->eui64));

    // create link configuration, could be replaced by configuration settings read from NVM
    if (!this->configuration_ptr) {
        this->configuration_ptr = link_configuration_create();
    }
    this->configuration_valid = false;

    if (!this->configuration_ptr) {
        tr_error("Joiner creation failed");
        device_configuration_delete(this->device_configuration_ptr);
        return -4;
    }
    if (!this->active_configuration_ptr) {
        this->active_configuration_ptr = ns_dyn_mem_alloc(sizeof(configuration_set_t));
    }
    if (!this->active_configuration_ptr) {
        tr_error("Active configuration creation failed");
        device_configuration_delete(this->device_configuration_ptr);
        link_configuration_delete(this->configuration_ptr);
        return -5;
    }
    memset(this->active_configuration_ptr, 0, sizeof(configuration_set_t));

    if (default_configuration_ptr) {
        link_configuration_copy(this->configuration_ptr, default_configuration_ptr);
        thread_joiner_application_validate_settings(this);// Generate all random information
        if (memcmp(this->configuration_ptr->master_key, ADDR_UNSPECIFIED, 16) != 0 ||
                memcmp(this->configuration_ptr->PSKc, ADDR_UNSPECIFIED, 16) != 0) {
            //If no master key or PSKc set we assume not valid configuration for thread network others may be possible to be 0
            //This allows some configurations to be set statically for testing purposes
            this->configuration_valid = true;
            configuration_set_generate(this->interface_id, this->active_configuration_ptr, this->configuration_ptr);
        }
    }
    // Always load link configuration from bootstrap state machine. NVM overrides Static configuration
    this->nvm_link_configuration_load = true;

    link_configuration_trace(this->configuration_ptr);

    return 0;
}

int thread_joiner_application_form_network(int8_t interface_id, uint8_t *commissioning_credentials_ptr, char *name_ptr)
{
    thread_joiner_t *this = thread_joiner_find(interface_id);
    (void)commissioning_credentials_ptr;
    (void)name_ptr;
    tr_debug("Joiner form random network");
    if (!this) {
        return -1;
    }
    /*
     * TODO generate random network parameter and enable commissioner to join the network
     */

    return 0;
}

void thread_joiner_application_deinit(int8_t interface_id)
{
    thread_joiner_t *this = thread_joiner_find(interface_id);
    if (this) {
        ns_list_remove(&instance_list, this);
        link_configuration_delete(this->configuration_ptr);
        device_configuration_delete(this->device_configuration_ptr);
        if (this->pending_configuration_ptr) {
            ns_dyn_mem_free(this->pending_configuration_ptr);
        }
        if (this->next_pending_configuration_ptr) {
            ns_dyn_mem_free(this->next_pending_configuration_ptr);
        }
        if (this->active_configuration_ptr) {
            ns_dyn_mem_free(this->active_configuration_ptr);
        }
        if (this->old_active_configuration_ptr) {
            ns_dyn_mem_free(this->old_active_configuration_ptr);
        }
        ns_dyn_mem_free(this);
    }
}

link_configuration_s *thread_joiner_application_get_config(int8_t interface_id)
{
    thread_joiner_t *this = thread_joiner_find(interface_id);
    if (!this) {
        return NULL;
    }

    if (this->configuration_valid == false) {
        return NULL;
    }
    return this->configuration_ptr;
}

uint8_t *thread_joiner_application_network_name_get(int8_t interface_id)
{
    thread_joiner_t *this = thread_joiner_find(interface_id);
    if (!this) {
        return NULL;
    }
    return this->configuration_ptr->name;
}

static int thread_joiner_application_nvm_link_config_read(thread_joiner_t *this)
{

    // read config from NVM, in case of failure current settings are unchanged.
    int nvm_read_status = thread_nvm_store_active_configuration_read(this->active_configuration_ptr, sizeof(configuration_set_t));
    tr_debug("active conf read %d", nvm_read_status);
    // validate that active configuration settings are valid, even if we couldn't read from nvm.
    if (!configuration_set_validate(this->active_configuration_ptr->data, this->active_configuration_ptr->length, true)) {
        tr_debug("No active configuration avail");
        return -1;
    }
    link_configuration_update(this->configuration_ptr, this->active_configuration_ptr->data, this->active_configuration_ptr->length);

    thread_nvm_fast_data_t fast_data;
    memset(&fast_data, 0, sizeof(thread_nvm_fast_data_t));
    int fast_data_read_ret = thread_nvm_store_fast_data_read(&fast_data);
    tr_info("From NVM %d", fast_data_read_ret);
    tr_info("mac-counter %"PRIu32, fast_data.mac_frame_counter);
    tr_info("mle-counter %"PRIu32, fast_data.mle_frame_counter);
    tr_info("seq-counter %"PRIu32, fast_data.seq_counter);

    if (THREAD_NVM_FILE_SUCCESS == fast_data_read_ret) {
        if (this->configuration_ptr->key_sequence < fast_data.seq_counter) {
            this->configuration_ptr->key_sequence = fast_data.seq_counter;
        }
    }

    fast_data.mac_frame_counter += MAC_FRAME_COUNTER_LIMIT;
    fast_data.mle_frame_counter += MLE_FRAME_COUNTER_LIMIT;
    thread_nvm_store_fast_data_write(&fast_data);

    thread_nvm_store_device_configuration_read(this->device_configuration_ptr->extended_random_mac, this->device_configuration_ptr->mesh_local_eid);
    thread_nvm_store_link_info_read();
    // Generate all random information, if device configuration read failed then the random mac and eid are created.
    bool new_value_generated = thread_joiner_application_validate_settings(this);
    if (new_value_generated) {
        thread_nvm_store_device_configuration_write(this->device_configuration_ptr->extended_random_mac, this->device_configuration_ptr->mesh_local_eid);
    }

    this->configuration_valid = true;
    link_configuration_trace(this->configuration_ptr);

    protocol_interface_info_entry_t *cur = protocol_stack_interface_info_get_by_id(this->interface_id);
    //Add Security to MLE service
    thread_security_prev_key_generate(cur, this->configuration_ptr->master_key, this->configuration_ptr->key_sequence);
    thread_security_key_generate(cur, this->configuration_ptr->master_key, this->configuration_ptr->key_sequence);
    thread_security_next_key_generate(cur, this->configuration_ptr->master_key, this->configuration_ptr->key_sequence);

    // update counters
    mle_service_security_set_frame_counter(this->interface_id, fast_data.mle_frame_counter);
    mac_helper_link_frame_counter_set(this->interface_id, fast_data.mac_frame_counter);

    // this saves all configurations
    if (THREAD_NVM_FILE_SUCCESS != nvm_read_status) {
        thread_joiner_application_configuration_nvm_save(this->interface_id);
    } else {
        tr_info("Reading pending set");
        configuration_set_t *pend_conf_ptr = ns_dyn_mem_alloc(sizeof(configuration_set_t));
        if (pend_conf_ptr) {
            memset(pend_conf_ptr, 0, sizeof(configuration_set_t));
            int pending_ret = thread_nvm_store_pending_configuration_read(pend_conf_ptr, sizeof(configuration_set_t));
            if (THREAD_NVM_FILE_SUCCESS == pending_ret) {
                if (this->pending_configuration_ptr) {
                    ns_dyn_mem_free(this->pending_configuration_ptr);
                }
                this->pending_configuration_ptr = pend_conf_ptr;
                this->pending_configuration_ptr->timeout_in_ms = 0;
                this->pending_set_in_sync = false;
            } else {
                tr_info("Reading pending from NVM error:%d", pending_ret);
                ns_dyn_mem_free(pend_conf_ptr);
            }
        }
    }
    this->nvm_link_configuration_load = false;
    return 0;
}

static int thread_joiner_application_nvm_link_config_delete(thread_joiner_t *this)
{
    if (!this) {
        return -1;
    }
    int ret = thread_nvm_store_pending_configuration_remove();

    if (ret != THREAD_NVM_FILE_SUCCESS) {
        tr_error("Pending configuration delete error: %d", ret);
    }

    ret = thread_nvm_store_active_configuration_remove();

    if (ret != THREAD_NVM_FILE_SUCCESS) {
        tr_error("Active configuration delete error: %d", ret);
    }

    // delete link configuration from cache, device will be restarted after settings are deleted
    this->configuration_valid = false;
    return 0;
}

uint64_t thread_joiner_application_active_timestamp_get(int8_t interface_id)
{
    thread_joiner_t *this = thread_joiner_find(interface_id);
    if (!this) {
        return 0;
    }

    return this->configuration_ptr->timestamp;
}

uint8_t thread_joiner_application_security_policy_get(int8_t interface_id)
{
    thread_joiner_t *this = thread_joiner_find(interface_id);
    if (!this) {
        return 0;
    }

    return this->configuration_ptr->securityPolicy;
}

uint8_t *thread_joiner_application_random_mac_get(int8_t interface_id)
{
    thread_joiner_t *this = thread_joiner_find(interface_id);
    if (!this || !this->device_configuration_ptr) {
        tr_error("thread_joiner_application_random_mac_get NULL parameter ");
        return (uint8_t *)ADDR_UNSPECIFIED;
    }
    return this->device_configuration_ptr->extended_random_mac;
}
uint8_t *thread_joiner_application_ml_eid_get(int8_t interface_id)
{
    thread_joiner_t *this = thread_joiner_find(interface_id);
    if (!this || !this->device_configuration_ptr) {
        tr_error("thread_joiner_application_ml_eid_get parameter NULL");
        return (uint8_t *)ADDR_UNSPECIFIED;
    }
    return this->device_configuration_ptr->mesh_local_eid;
}
void thread_joiner_application_active_timestamp_set(int8_t interface_id, uint64_t timestamp)
{
    thread_joiner_t *this = thread_joiner_find(interface_id);
    uint8_t *timestamp_ptr = NULL;
    if (!this) {
        return;
    }

    thread_meshcop_tlv_find(this->active_configuration_ptr->data, this->active_configuration_ptr->length, MESHCOP_TLV_ACTIVE_TIME_STAMP, &timestamp_ptr);
    if (timestamp_ptr) {
        common_write_64_bit(timestamp, timestamp_ptr);
    }

    //update timestamps in active configuration and link configuration
    this->active_configuration_ptr->timestamp = timestamp;
    this->configuration_ptr->timestamp = timestamp;
    return;
}

void thread_joiner_pending_config_activate(int8_t interface_id)
{
    thread_joiner_t *this = thread_joiner_find(interface_id);

    if (!this || !this->pending_configuration_ptr) {
        tr_error("No pending configuration or joiner!");
        return;
    }

    protocol_interface_info_entry_t *cur = protocol_stack_interface_info_get_by_id(this->interface_id);

    if (!cur) {
        tr_error("No interface information!");
        return;
    }

    /*
     * If pending configuration active timestamp is lower than current active timestamp allow pending configuration activation only
     * if master key is changed by the pending set
     */
    link_configuration_s *link_configuration = thread_joiner_application_get_config(interface_id);

    if (!link_configuration) {
        return;
    }

    // Validate new link configuration
    uint8_t *master_key_ptr = NULL;
    uint64_t pending_active_timestamp = 0;
    thread_meshcop_tlv_data_get_uint64(this->pending_configuration_ptr->data, this->pending_configuration_ptr->length, MESHCOP_TLV_ACTIVE_TIME_STAMP, &pending_active_timestamp);
    thread_meshcop_tlv_find(this->pending_configuration_ptr->data, this->pending_configuration_ptr->length, MESHCOP_TLV_NETWORK_MASTER_KEY, &master_key_ptr);

    if ((pending_active_timestamp < thread_joiner_application_active_timestamp_get(interface_id))) {
        // If new active timestamp is older than current master key must be changed.
        if (!master_key_ptr ||
                memcmp(master_key_ptr, link_configuration->master_key, 16) == 0) {
            tr_info("*** Pending set activation aborted - device has newer active timestamp");
            thread_joiner_application_pending_config_delete(interface_id);
            return;
        }
    }

    if (master_key_ptr && memcmp(master_key_ptr, link_configuration->master_key, 16) != 0) {
        this->configuration_ptr->key_sequence = 0;
        // if write fails, keep going...
        (void)thread_nvm_store_seq_counter_write(this->configuration_ptr->key_sequence);
    }

    tr_info("*** Activating pending configuration.");

    ns_dyn_mem_free(this->old_active_configuration_ptr);
    this->old_active_configuration_ptr = this->active_configuration_ptr;
    this->active_configuration_ptr = this->pending_configuration_ptr;
    this->active_configuration_ptr->timestamp = pending_active_timestamp;
    // All information is copied from old configuration so if configuration is corrupt we dont change anything.
    this->pending_configuration_ptr = NULL;
    thread_nvm_store_pending_configuration_remove();
    configuration_set_copy_mandatory(this->active_configuration_ptr, this->old_active_configuration_ptr);
    link_configuration_update(this->configuration_ptr, this->active_configuration_ptr->data, this->active_configuration_ptr->length);
    link_configuration_trace(this->configuration_ptr);

    thread_joiner_application_configuration_nvm_save(this->interface_id);


    if (thread_link_configuration_activate(cur, this->configuration_ptr) != 0) {
        tr_error("Activating pending configuration failed.");
    }

    tr_info("*** Activating pending configuration done.");
}


void thread_joiner_application_seconds_timer(int8_t interface_id, uint32_t seconds)
{
    thread_joiner_t *this = thread_joiner_find(interface_id);
    //tr_debug("seconds tick for joiner pending timeout in %d",this->pending_timeout_in_ms);
    if (!this) {
        return;
    }
    if (this->provisioning_timeout) {
        if (this->provisioning_timeout < seconds) {
            this->provisioning_done = PROVISIONING_STATUS_NOT_DONE;
        }
        this->provisioning_timeout -= seconds;
    }
    if (!this->pending_configuration_ptr || this->pending_configuration_ptr->timeout_in_ms == 0) {
        return;
    }
    if (this->pending_configuration_ptr->timeout_in_ms > seconds * 1000) {
        this->pending_configuration_ptr->timeout_in_ms -= seconds * 1000;
        return;
    }
    // Activate the pending config
    thread_joiner_pending_config_activate(interface_id);
}

int thread_joiner_application_pending_config_create(int8_t interface_id, uint8_t *data_ptr, uint16_t data_len)
{
    thread_joiner_t *this = thread_joiner_find(interface_id);
    if (!this || data_len > MAX_OPERATIONAL_DATASET_SIZE) {
        return -1;
    }
    if (!this->pending_configuration_ptr) {
        this->pending_configuration_ptr = ns_dyn_mem_alloc(sizeof(configuration_set_t));
    }
    if (!this->pending_configuration_ptr) {
        tr_error("pending configuration creation failed");
        return -2;
    }
    memset(this->pending_configuration_ptr, 0, sizeof(configuration_set_t));
    configuration_set_add_all_fields(this->pending_configuration_ptr, data_ptr, data_len, meshcop_pending_set_ignore, sizeof(meshcop_pending_set_ignore));
    return 0;
}

bool thread_joiner_application_pending_config_exists(int8_t interface_id)
{
    thread_joiner_t *this = thread_joiner_find(interface_id);
    if (!this || !this->pending_configuration_ptr) {
        return false;
    }
    return true;
}

bool thread_joiner_application_pending_delay_timer_in_sync(int8_t interface_id)
{
    thread_joiner_t *this = thread_joiner_find(interface_id);
    if (!this || !this->pending_configuration_ptr) {
        return false;
    }
    return this->pending_set_in_sync;
}

uint64_t thread_joiner_application_pending_config_timestamp_get(int8_t interface_id)
{
    thread_joiner_t *this = thread_joiner_find(interface_id);
    if (!this || !this->pending_configuration_ptr || !this->pending_set_in_sync) {
        return 0;
    }
    return this->pending_configuration_ptr->timestamp;
}

int thread_joiner_application_pending_config_timestamp_set(int8_t interface_id, uint64_t timestamp)
{
    thread_joiner_t *this = thread_joiner_find(interface_id);
    if (!this || !this->pending_configuration_ptr) {
        return -1;
    }
    this->pending_configuration_ptr->timestamp = timestamp;
    return 0;
}


int thread_joiner_application_pending_config_enable(int8_t interface_id, uint32_t timeout_in_ms)
{
    thread_joiner_t *this = thread_joiner_find(interface_id);
    if (!this || !this->pending_configuration_ptr) {
        return -1;
    }
    this->pending_configuration_ptr->timeout_in_ms = timeout_in_ms;
    this->pending_set_in_sync = true;

    if (this->pending_configuration_ptr->timeout_in_ms > THREAD_MAX_DELAY_TIMER_SECONDS * 1000) {
        this->pending_configuration_ptr->timeout_in_ms = THREAD_MAX_DELAY_TIMER_SECONDS * 1000;
    }
    thread_joiner_application_configuration_nvm_save(this->interface_id);

    return 0;
}

uint32_t thread_joiner_application_pending_config_timeout_get(int8_t interface_id)
{
    thread_joiner_t *this = thread_joiner_find(interface_id);
    if (!this || !this->pending_configuration_ptr) {
        return 0;
    }
    return this->pending_configuration_ptr->timeout_in_ms;
}

uint16_t thread_joiner_application_pending_config_length(uint8_t interface_id, uint8_t *req_tlv_ptr, uint8_t req_tlv_len, const uint8_t *ignored_tlv_ptr, uint8_t ignored_tlv_len)
{
    uint16_t result_len;
    thread_joiner_t *this = thread_joiner_find(interface_id);
    if (!this || !this->pending_configuration_ptr) {
        return 0;
    }

    result_len = configuration_set_length(this->pending_configuration_ptr, req_tlv_ptr, req_tlv_len, ignored_tlv_ptr, ignored_tlv_len);

    /* Add pending timestamp if required and not ignored*/
    if (thread_meshcop_tlv_list_type_available(req_tlv_ptr, req_tlv_len, MESHCOP_TLV_PENDING_TIMESTAMP) &&
            !thread_meshcop_tlv_list_type_available(ignored_tlv_ptr, ignored_tlv_len, MESHCOP_TLV_PENDING_TIMESTAMP)) {
        result_len += 10;
    }

    /* Always add delay timer */
    result_len += 6;

    return result_len;
}

uint8_t *thread_joiner_application_pending_config_build(uint8_t interface_id, uint8_t *ptr, uint8_t *req_tlv_ptr, uint8_t req_tlv_len, const uint8_t *ignored_tlv_ptr, uint8_t ignored_tlv_len)
{
    thread_joiner_t *this = thread_joiner_find(interface_id);
    if (!this || !this->pending_configuration_ptr) {
        return ptr;
    }

    /* Build pending config data */
    ptr = configuration_set_write(this->pending_configuration_ptr, ptr, req_tlv_ptr, req_tlv_len, ignored_tlv_ptr, ignored_tlv_len);

    /* Add pending timestamp (len = 10) if required and not ignored */
    if (thread_meshcop_tlv_list_type_available(req_tlv_ptr, req_tlv_len, MESHCOP_TLV_PENDING_TIMESTAMP) &&
            !thread_meshcop_tlv_list_type_available(ignored_tlv_ptr, ignored_tlv_len, MESHCOP_TLV_PENDING_TIMESTAMP)) {
        ptr = thread_meshcop_tlv_data_write_uint64(ptr, MESHCOP_TLV_PENDING_TIMESTAMP, this->pending_configuration_ptr->timestamp);
    }

    /* Always add delay timer (len = 6) */
    ptr = thread_meshcop_tlv_data_write_uint32(ptr, MESHCOP_TLV_DELAY_TIMER, this->pending_configuration_ptr->timeout_in_ms);

    return ptr;
}

uint8_t *thread_joiner_application_pending_config_tlv_list_get(uint8_t interface_id, uint16_t *length)
{
    uint16_t data_list_len = 0;
    uint8_t *result_ptr;
    uint8_t *return_ptr;

    thread_joiner_t *this = thread_joiner_find(interface_id);
    if (!this || !this->pending_configuration_ptr) {
        return NULL;
    }
    *length = 0;
    thread_meshcop_tlv_list_generate(this->pending_configuration_ptr->data, this->pending_configuration_ptr->length, NULL, &data_list_len);
    if (data_list_len == 0) {
        return NULL;
    }

    /* Add also room for pending timestamp */
    *length = data_list_len + 1;
    result_ptr = return_ptr = ns_dyn_mem_alloc(*length);

    if (!result_ptr) {
        return NULL;
    }

    *result_ptr++ = MESHCOP_TLV_PENDING_TIMESTAMP;

    thread_meshcop_tlv_list_generate(this->pending_configuration_ptr->data, this->pending_configuration_ptr->length, result_ptr, &data_list_len);

    return return_ptr;
}

void thread_joiner_application_pending_config_add_missing_fields(uint8_t interface_id)
{
    thread_joiner_t *this = thread_joiner_find(interface_id);
    if (!this || !this->pending_configuration_ptr) {
        return;
    }
    //TODO Specification open here
    // a) copy only mandatory fields
    // b) copy everything but remove zero length tlvs
    //configuration_set_copy_mandatory(this->pending_configuration_ptr, this->active_configuration_ptr);
    configuration_set_copy_missing(this->pending_configuration_ptr, this->active_configuration_ptr);
    configuration_set_remove_null_tlv(this->pending_configuration_ptr);
}


bool thread_joiner_application_old_config_exists(int8_t interface_id)
{
    thread_joiner_t *this = thread_joiner_find(interface_id);
    if (!this || !this->old_active_configuration_ptr) {
        return false;
    }
    return true;
}
void thread_joiner_application_old_config_delete(int8_t interface_id)
{
    thread_joiner_t *this = thread_joiner_find(interface_id);
    if (!this || !this->old_active_configuration_ptr) {
        return;
    }
    ns_dyn_mem_free(this->old_active_configuration_ptr);
    this->old_active_configuration_ptr = NULL;

    return;
}
int thread_joiner_application_old_config_activate(int8_t interface_id)
{
    thread_joiner_t *this = thread_joiner_find(interface_id);
    if (!this || !this->old_active_configuration_ptr) {
        return -1;
    }
    this->active_configuration_ptr = this->old_active_configuration_ptr;
    this->old_active_configuration_ptr = NULL;
    link_configuration_update(this->configuration_ptr, this->active_configuration_ptr->data, this->active_configuration_ptr->length);
    link_configuration_trace(this->configuration_ptr);

    return 0;
}

void thread_joiner_application_pending_config_delete(int8_t interface_id)
{
    thread_joiner_t *this = thread_joiner_find(interface_id);
    if (!this || !this->pending_configuration_ptr) {
        return;
    }
    ns_dyn_mem_free(this->pending_configuration_ptr);
    this->pending_configuration_ptr = NULL;
    thread_joiner_application_configuration_nvm_save(interface_id);
    return;
}

void thread_joiner_application_next_pending_config_save(int8_t interface_id)
{
    thread_joiner_t *this = thread_joiner_find(interface_id);
    if (!this || !this->pending_configuration_ptr) {
        return;
    }
    this->next_pending_configuration_ptr = configuration_set_copy(this->pending_configuration_ptr);
    if (!this->next_pending_configuration_ptr) {
        tr_error("next pending configuration creation failed");
    }
    return;
}
bool thread_joiner_application_next_pending_config_exists(int8_t interface_id)
{
    thread_joiner_t *this = thread_joiner_find(interface_id);
    if (!this || !this->next_pending_configuration_ptr) {
        return false;
    }
    return true;
}

uint16_t thread_joiner_application_next_pending_config_length(int8_t interface_id)
{
    uint16_t response_len = 0;
    thread_joiner_t *this = thread_joiner_find(interface_id);
    if (!this || !this->next_pending_configuration_ptr) {
        return 0;
    }
    response_len += 2 + 8; // Pending timestamp
    response_len += 2 + 4;  // delay timer
    response_len += this->next_pending_configuration_ptr->length;
    return response_len;
}

uint8_t *thread_joiner_application_next_pending_config_build(int8_t interface_id, uint8_t *ptr)
{
    thread_joiner_t *this = thread_joiner_find(interface_id);
    if (!this || !this->next_pending_configuration_ptr) {
        return ptr;
    }
    memcpy(ptr, this->next_pending_configuration_ptr->data, this->next_pending_configuration_ptr->length);
    ptr += this->next_pending_configuration_ptr->length;
    ptr = thread_meshcop_tlv_data_write_uint64(ptr, MESHCOP_TLV_PENDING_TIMESTAMP, this->next_pending_configuration_ptr->timestamp);
    ptr = thread_meshcop_tlv_data_write_uint32(ptr, MESHCOP_TLV_DELAY_TIMER, this->next_pending_configuration_ptr->timeout_in_ms);
    return ptr;
}
void thread_joiner_application_next_pending_config_delete(int8_t interface_id)
{
    thread_joiner_t *this = thread_joiner_find(interface_id);
    if (!this || !this->next_pending_configuration_ptr) {
        return;
    }
    ns_dyn_mem_free(this->next_pending_configuration_ptr);
    this->next_pending_configuration_ptr = NULL;

    return;
}
void thread_joiner_application_next_active_config_save(int8_t interface_id)
{
    thread_joiner_t *this = thread_joiner_find(interface_id);
    if (!this || !this->configuration_ptr) {
        return;
    }
    this->next_active_configuration_ptr = configuration_set_copy(this->active_configuration_ptr);
    if (!this->next_active_configuration_ptr) {
        tr_error("next pending configuration creation failed");
        return;
    }
    return;
}
bool thread_joiner_application_next_active_config_exists(int8_t interface_id)
{
    thread_joiner_t *this = thread_joiner_find(interface_id);
    if (!this || !this->next_active_configuration_ptr) {
        return false;
    }
    return true;
}
uint16_t thread_joiner_application_next_active_config_length(int8_t interface_id)
{
    thread_joiner_t *this = thread_joiner_find(interface_id);
    if (!this || !this->next_active_configuration_ptr) {
        return 0;
    }
    return this->next_active_configuration_ptr->length;
}

uint8_t *thread_joiner_application_next_active_config_write(int8_t interface_id, uint8_t *ptr)
{
    thread_joiner_t *this = thread_joiner_find(interface_id);
    if (!this || !this->next_active_configuration_ptr) {
        return ptr;
    }
    memcpy(ptr, this->next_active_configuration_ptr->data, this->next_active_configuration_ptr->length);
    ptr += this->next_active_configuration_ptr->length;
    return ptr;
}

void thread_joiner_application_next_active_config_delete(int8_t interface_id)
{
    thread_joiner_t *this = thread_joiner_find(interface_id);
    if (!this || !this->next_active_configuration_ptr) {
        return;
    }
    ns_dyn_mem_free(this->next_active_configuration_ptr);
    this->next_active_configuration_ptr = NULL;

    return;
}

device_configuration_s *thread_joiner_application_get_device_config(int8_t interface_id)
{
    thread_joiner_t *this = thread_joiner_find(interface_id);
    if (!this) {
        return NULL;
    }
    return this->device_configuration_ptr;
}

int thread_joiner_application_link_configuration_store(int8_t interface_id, link_configuration_s *link_config)
{
    thread_joiner_t *this = thread_joiner_get(interface_id);

    if (!link_config || !this) {
        return -1;
    }

    if (!this->configuration_ptr) {
        this->configuration_ptr = link_configuration_create();
    }

    thread_joiner_application_validate_settings(this);// Generate all random information
    configuration_set_generate(this->interface_id, this->active_configuration_ptr, link_config);
    link_configuration_update(this->configuration_ptr, this->active_configuration_ptr->data, this->active_configuration_ptr->length);
    this->configuration_ptr->key_sequence = link_config->key_sequence;
    this->configuration_valid = true;
    link_configuration_trace(this->configuration_ptr);

    // store link configuration to NVM. This also stores pending configuration and some other parameters!
    return thread_joiner_application_configuration_nvm_save(this->interface_id);
}

int thread_joiner_application_link_configuration_delete(int8_t interface_id)
{
    thread_joiner_t *this = thread_joiner_get(interface_id);

    // delete link configuration from NVM
    return thread_joiner_application_nvm_link_config_delete(this);
}

bool thread_joiner_application_nvm_link_configuration_load(int8_t interface_id)
{
    thread_joiner_t *this = thread_joiner_find(interface_id);
    if (this && this->nvm_link_configuration_load == true) {
        this->nvm_link_configuration_load = false;
        if (thread_joiner_application_nvm_link_config_read(this) == 0) {
            return true;
        } else {
            tr_error("Failed to read link configuration settings from NVM");
        }
    }
    return false;
}

int thread_joiner_application_provisioning_set(int8_t interface_id, thread_provisioning_status_e status)
{
    thread_joiner_t *this = thread_joiner_find(interface_id);
    if (this) {
        this->provisioning_done = status;
        if (status == PROVISIONING_STATUS_REJECTED) {
            // If commissioner rejects us retry done after some time -> state is changed back to not done
            this->provisioning_timeout = randLIB_get_random_in_range(20, 120);
        } else {
            this->provisioning_timeout = 0;
        }
    }
    return 0;
}

thread_provisioning_status_e thread_joiner_application_provisioning_get(int8_t interface_id)
{
    thread_joiner_t *this = thread_joiner_find(interface_id);
    if (this) {
        return this->provisioning_done;
    }
    return PROVISIONING_STATUS_NOT_DONE;
}

static int joiner_application_security_start_cb(int8_t service_id, uint8_t address[static 16], uint16_t port, uint8_t *pw, uint8_t *pw_len)
{
    int ret = -1;
    tr_debug("Thread joiner security started");
    (void)address;
    (void)port;

    thread_joiner_t *this = thread_joiner_find_by_service(service_id);

    if (this) {
        memcpy(pw, this->device_configuration_ptr->PSKd_ptr, this->device_configuration_ptr->PSKd_len);
        *pw_len = this->device_configuration_ptr->PSKd_len;
        ret = 0;
//        ret = coap_service_security_key_set( service_id, address, port,
//                                             this->device_configuration_ptr->PSKd_ptr,
//                                             this->device_configuration_ptr->PSKd_len );
    }

    return ret;
}

int joiner_application_security_done_cb(int8_t service_id, uint8_t address[16], uint8_t keyblock[40])
{
    thread_joiner_t *this = thread_joiner_find_by_service(service_id);
    uint8_t kek[32];
    int ret;

    tr_debug("Thread joiner security done service: %d, address: %s", service_id, trace_ipv6(address));
    if (!this) {
        return -1;
    }

    ns_sha256(keyblock, 40, kek);

    ret = thread_commissioning_if_pairwise_key_add(this->interface_id, 10000, &address[8], kek);
    if (ret) {
        tr_debug("pairwise key set failed %d", ret);
        //TODO error?
    }
    thread_commissioning_if_enable_security(this->interface_id);
    return 0;
}

static void thread_joiner_attach_cb(void *arg)
{
    thread_joiner_t *this = arg;
    tr_debug("Attach to new network");
    if (!this) {
        return;
    }
    // Cleaning up the joining information
    thread_joiner_application_commission_clean(this);
    if (this->done_cb) {// This is successfull
        this->done_cb(this->interface_id);
    }
}
static void thread_joiner_entrust_timeout_cb(void *arg)
{
    thread_joiner_t *this = arg;
    tr_debug("No valid configuration received in time");
    if (!this) {
        return;
    }
    // Cleaning up the joining information
    thread_joiner_application_commission_clean(this);
    if (this->done_cb) {// Failed
        this->done_cb(this->interface_id);
    }
}

void thread_joiner_attach_if_needed(thread_joiner_t *this)
{
    tr_debug("attach check");
    if (this->finalisation_done && this->configuration_valid) {
        tr_debug("Start attach timer");// one second timer gives time for joiner router to get entrust response
        this->attach_timeout = eventOS_timeout_ms(thread_joiner_attach_cb, 1000, this);
    } else {
        tr_debug("Start entrust timeout");// 30 timer to get credentials
        this->entrust_timeout = eventOS_timeout_ms(thread_joiner_entrust_timeout_cb, 30000, this);
    }
}


int thread_joiner_application_finalisation_cb(int8_t service_id, uint8_t source_address[static 16], uint16_t source_port, sn_coap_hdr_s *response_ptr)
{
    thread_joiner_t *this = thread_joiner_find_by_service(service_id);
    uint8_t result;
    (void)source_address;
    (void)source_port;

    tr_debug("finalisation done");

    if (!this) {
        return -1;
    }

    // CoAP message failed - try to reattach
    if (!response_ptr || !response_ptr->payload_ptr) {
        tr_debug("finalisation failed - no response");
        goto error;
    }

    thci_trace("Device - Joiner|Direction - recv|EUI - %s|Type - JOIN_FIN.resp|Length - %d|Payload - %s", trace_array(this->device_configuration_ptr->eui64, 8), response_ptr->payload_len, trace_array(response_ptr->payload_ptr, response_ptr->payload_len));
    coap_service_close_secure_connection(service_id, this->parent_address, this->parent_port);
    // todo: free certificates
    if (1 <= thread_tmfcop_tlv_data_get_uint8(response_ptr->payload_ptr, response_ptr->payload_len, MESHCOP_TLV_STATE, &result)) {
        //Todo make attach
        this->finalisation_done = true;
        this->provisioning_done = PROVISIONING_STATUS_NOT_DONE;
        if (result == 1) {
            // If accepted no additional actions needed
            tr_debug("Provisioning done");
            this->provisioning_done = PROVISIONING_STATUS_DONE;
        }
        thread_joiner_attach_if_needed(this);
        return 0;
    }
    thci_trace("joinerError");
    tr_debug("finalisation rejected");

error:
    //TODO cant delete as old configuration pointer is in use I quess
//    link_configuration_delete(this->configuration_ptr);
    thread_joiner_application_commission_clean(this);
    this->configuration_valid = false;
    this->done_cb(this->interface_id);
    blacklist_update(source_address, false);
    //This trigger re scan and we try to connect again
    //TODO this needs status code to allow blacklisting of thread network
    return 0;
}
static int thread_joiner_application_send_finalisation(thread_joiner_t *this, uint8_t parent_address[16], uint16_t port)
{
    uint8_t *ptr, *data_ptr;
    uint16_t length;

    tr_debug("Thread joiner finalisation send");
    length = thread_joiner_application_device_configuration_length(this->device_configuration_ptr);
    length += 3;// State

    data_ptr = ptr = ns_dyn_mem_alloc(length);
    if (!ptr) {
        tr_error("Failed to start Commissioning");
        return -1;
    }
    ptr = thread_joiner_application_device_configuration_build(ptr, this->device_configuration_ptr);
    ptr = thread_tmfcop_tlv_data_write_uint8(ptr, MESHCOP_TLV_STATE, 0xff);

    thci_trace("Device - Joiner|Direction - sent|EUI - %s|Type - JOIN_FIN.req|Length - %d|Payload - %s", trace_array(this->device_configuration_ptr->eui64, 8), (int)(ptr - data_ptr), trace_array(data_ptr, ptr - data_ptr));
    coap_service_request_send(this->secure_coap_service_id, COAP_REQUEST_OPTIONS_SECURE_BYPASS, parent_address, port,
                              COAP_MSG_TYPE_CONFIRMABLE, COAP_MSG_CODE_REQUEST_POST, THREAD_URI_JOINER_FINALIZATION, COAP_CT_OCTET_STREAM, data_ptr, ptr - data_ptr, thread_joiner_application_finalisation_cb);

    ns_dyn_mem_free(data_ptr);

    return 0;
}

static uint8_t *thread_joiner_application_write_channel(uint8_t *ptr, uint16_t data)
{
    *ptr++ = MESHCOP_TLV_CHANNEL; // type
    *ptr++ = 3; // length
    *ptr++ = 0; // channel page
    return common_write_16_bit(data, ptr);
}

static int thread_joiner_application_entrust_recv_cb(int8_t service_id, uint8_t source_address[16], uint16_t source_port, sn_coap_hdr_s *request_ptr)
{
    thread_joiner_t *this = thread_joiner_find_by_service(service_id);
    (void)source_address;
    (void)source_port;

    if (!this) {
        return -1;
    }

    if (thread_meshcop_tlv_find(request_ptr->payload_ptr, request_ptr->payload_len, MESHCOP_TLV_NETWORK_MASTER_KEY, NULL) < 16 ||
            thread_meshcop_tlv_find(request_ptr->payload_ptr, request_ptr->payload_len, MESHCOP_TLV_NETWORK_MESH_LOCAL_ULA, NULL) < 8 ||
            thread_meshcop_tlv_find(request_ptr->payload_ptr, request_ptr->payload_len, MESHCOP_TLV_XPANID, NULL) < 8 ||
            thread_meshcop_tlv_find(request_ptr->payload_ptr, request_ptr->payload_len, MESHCOP_TLV_NETWORK_NAME, NULL) == 0 ||
            thread_meshcop_tlv_find(request_ptr->payload_ptr, request_ptr->payload_len, MESHCOP_TLV_PSKC, NULL) < 16) {
        // Absolutely minimum we must have is master secret to attach.
        // If commissioner wants to be connected we must have PSKc,Name,Xpanid
        // If there is some fields missing we could attach, but timestamp must be set to 0 which will then cause synchronization
        tr_debug("Not include all TLv's");
        thci_trace("joinerError");
        return -1;
    }
    uint8_t *result_ptr;
    memcpy(this->active_configuration_ptr->data, request_ptr->payload_ptr, request_ptr->payload_len);
    this->active_configuration_ptr->length = request_ptr->payload_len;

    result_ptr = this->active_configuration_ptr->data + this->active_configuration_ptr->length;

    if (thread_meshcop_tlv_find(this->active_configuration_ptr->data, this->active_configuration_ptr->length, MESHCOP_TLV_ACTIVE_TIME_STAMP, NULL) == 0) {
        result_ptr = thread_meshcop_tlv_data_write_uint64(result_ptr, MESHCOP_TLV_ACTIVE_TIME_STAMP, 0);
    }
    if (thread_meshcop_tlv_find(this->active_configuration_ptr->data, this->active_configuration_ptr->length, MESHCOP_TLV_XPANID, NULL) == 0) {
        result_ptr = thread_meshcop_tlv_data_write(result_ptr, MESHCOP_TLV_XPANID, 8, this->configuration_ptr->extented_pan_id);
    }
    if (thread_meshcop_tlv_find(this->active_configuration_ptr->data, this->active_configuration_ptr->length, MESHCOP_TLV_CHANNEL, NULL) == 0) {
        result_ptr = thread_joiner_application_write_channel(result_ptr, this->configuration_ptr->rfChannel);
    }
    if (thread_meshcop_tlv_find(this->active_configuration_ptr->data, this->active_configuration_ptr->length, MESHCOP_TLV_PANID, NULL) == 0) {
        result_ptr = thread_meshcop_tlv_data_write_uint16(result_ptr, MESHCOP_TLV_PANID, this->configuration_ptr->panId);
    }

    this->active_configuration_ptr->length = result_ptr - this->active_configuration_ptr->data;

    // check if everything is present
    if (!thread_meshcop_tlv_list_present(this->active_configuration_ptr->data, this->active_configuration_ptr->length, mle_active_configuration_dataset_tlvs, sizeof(mle_active_configuration_dataset_tlvs))) {
        // Some fields are missing we need to sync settings during attach
        uint8_t *timestamp_ptr = NULL;
        thread_meshcop_tlv_find(request_ptr->payload_ptr, request_ptr->payload_len, MESHCOP_TLV_ACTIVE_TIME_STAMP, &timestamp_ptr);
        if (timestamp_ptr) {
            common_write_64_bit(0, timestamp_ptr);
        }
    }

    thread_meshcop_tlv_data_get_uint64(this->active_configuration_ptr->data, this->active_configuration_ptr->length, MESHCOP_TLV_ACTIVE_TIME_STAMP, &this->active_configuration_ptr->timestamp);

    uint32_t network_key_seq = 0;
    if (thread_meshcop_tlv_data_get_uint32(request_ptr->payload_ptr, request_ptr->payload_len, MESHCOP_TLV_NETWORK_KEY_SEQUENCE, &network_key_seq)) {
        this->configuration_ptr->key_sequence = network_key_seq;
    }

    /*We must null out the master secret*/
#ifdef THREAD_THCI_SUPPORT
    uint8_t *master_secret_ptr;
    if (thread_meshcop_tlv_find(request_ptr->payload_ptr, request_ptr->payload_len, MESHCOP_TLV_NETWORK_MASTER_KEY, &master_secret_ptr) >= 16) {
        memset(master_secret_ptr, 0, 16);
    }
    thci_trace("Device - Joiner|Direction - recv|EUI - %s|Type - JOIN_ent.req|Length - %d|Payload - %s", trace_array(this->device_configuration_ptr->eui64, 8), request_ptr->payload_len, trace_array(request_ptr->payload_ptr, request_ptr->payload_len));
#endif

    // save link configuration to NVM

    thci_trace("joinerAccepted");
    link_configuration_update(this->configuration_ptr, this->active_configuration_ptr->data, this->active_configuration_ptr->length);
    this->configuration_valid = true;
    thread_joiner_application_configuration_nvm_save(this->interface_id);

    link_configuration_trace(this->configuration_ptr);

#ifdef THREAD_THCI_SUPPORT
    thci_trace("Device - Joiner|Direction - sent|EUI - %s|Type - JOIN_ent.resp|Length - 0|Payload - ", trace_array(this->device_configuration_ptr->eui64, 8));
#endif
    coap_service_response_send(this->coap_service_id, COAP_REQUEST_OPTIONS_NONE, request_ptr, COAP_MSG_CODE_RESPONSE_CHANGED, COAP_CT_OCTET_STREAM, NULL, 0);

    //TODO Add delay timer of 3 seconds and then do attach
    thread_joiner_attach_if_needed(this);

    return 0;
}

int thread_joiner_application_pskd_commission_start(int8_t interface_id, uint8_t parent_address[16], uint16_t joiner_port, uint16_t panid, uint8_t xpanid[8], uint8_t channel, thread_commission_done_cb *done_cb)
{
    protocol_interface_info_entry_t *cur = protocol_stack_interface_info_get_by_id(interface_id);
    thread_joiner_t *this = thread_joiner_find(interface_id);
    if (!this || !done_cb || !cur) {
        return -1;
    }
    if (!this->configuration_ptr) {
        this->configuration_ptr = link_configuration_create();
    }

    if (!this->configuration_ptr) {
        tr_error("Commission start failed");
        return -2;
    }
    this->configuration_valid = false;


    this->coap_service_id = coap_service_initialize(this->interface_id, THREAD_MANAGEMENT_PORT, COAP_SERVICE_OPTIONS_NONE, NULL, NULL);
    coap_service_register_uri(this->coap_service_id, THREAD_URI_JOINER_ENTRUST, COAP_SERVICE_ACCESS_POST_ALLOWED, thread_joiner_application_entrust_recv_cb);

    this->secure_coap_service_id = coap_service_initialize(this->interface_id, THREAD_DEFAULT_JOINER_PORT, COAP_SERVICE_OPTIONS_EPHEMERAL_PORT | COAP_SERVICE_OPTIONS_SECURE | 0x80, joiner_application_security_start_cb, joiner_application_security_done_cb);

    tr_debug("start pskd commissioning: interface %d, parent: %s, port %d", interface_id, trace_ipv6(parent_address), joiner_port);
    // save initial information
    this->configuration_ptr->panId = panid;
    this->configuration_ptr->rfChannel = channel;
    if (xpanid) {
        memcpy(this->configuration_ptr->extented_pan_id, xpanid, 8);
    }

    link_configuration_trace(this->configuration_ptr);
    //TODO this callback needs status for blacklist
    this->done_cb = done_cb;
    memcpy(this->parent_address, parent_address, 16);
    this->parent_port = joiner_port;

    thci_trace("joinerDtlsSessionStarted");
    thread_joiner_application_send_finalisation(this, parent_address, joiner_port);
    return 0;
}

int thread_joiner_application_configuration_nvm_save(int8_t interface_id)
{
    tr_info("thread_joiner_application_configuration_nvm_save");

    thread_joiner_t *this = thread_joiner_find(interface_id);
    if (!this) {
        return -1;
    }

    thread_nvm_store_device_configuration_write(this->device_configuration_ptr->extended_random_mac, this->device_configuration_ptr->mesh_local_eid);
    thread_nvm_store_pending_configuration_write(this->pending_configuration_ptr, sizeof(configuration_set_t));
    thread_nvm_store_seq_counter_write(this->configuration_ptr->key_sequence);
    thread_nvm_store_active_configuration_write(this->active_configuration_ptr, sizeof(configuration_set_t));

    /* allow configuration to be read in bootstrap */
    this->nvm_link_configuration_load = true;
    return 0;
}

int thread_joiner_application_update_configuration(uint8_t interface_id, uint8_t *msg_ptr, uint16_t msg_len, bool include_missing_tlvs)
{
    thread_joiner_t *this = thread_joiner_find(interface_id);
    configuration_set_t *configuration_ptr;
    if (!this) {
        return -1;
    }
    configuration_ptr = ns_dyn_mem_alloc(sizeof(configuration_set_t));
    if (!configuration_ptr) {
        return -2;
    }
    memcpy(configuration_ptr, this->active_configuration_ptr, sizeof(configuration_set_t));
    this->active_configuration_ptr->length = 0;
    configuration_set_add_all_fields(this->active_configuration_ptr, msg_ptr, msg_len, meshcop_active_set_ignore, sizeof(meshcop_active_set_ignore));
    if (include_missing_tlvs) {
        configuration_set_copy_missing(this->active_configuration_ptr, configuration_ptr);
        configuration_set_remove_null_tlv(this->active_configuration_ptr);
    } else {
        configuration_set_copy_mandatory(this->active_configuration_ptr, configuration_ptr);
    }
    thread_meshcop_tlv_data_get_uint64(msg_ptr, msg_len, MESHCOP_TLV_ACTIVE_TIME_STAMP, &this->active_configuration_ptr->timestamp);
    link_configuration_update(this->configuration_ptr, msg_ptr, msg_len);
    // allow 5 seconds delay before state change for data response propagation
    thread_router_bootstrap_delay_reed_jitter(interface_id, 5);
    ns_dyn_mem_free(configuration_ptr);
    thread_joiner_application_configuration_nvm_save(interface_id);

    return 0;
}
uint8_t *thread_joiner_application_active_config_tlv_list_get(uint8_t interface_id, uint16_t *length)
{
    uint8_t *result_ptr;
    thread_joiner_t *this = thread_joiner_find(interface_id);
    if (!this || !this->active_configuration_ptr) {
        return NULL;
    }
    *length = 0;
    thread_meshcop_tlv_list_generate(this->active_configuration_ptr->data, this->active_configuration_ptr->length, NULL, length);
    if (*length == 0) {
        return NULL;
    }
    result_ptr = ns_dyn_mem_alloc(*length);
    if (!result_ptr) {
    }
    thread_meshcop_tlv_list_generate(this->active_configuration_ptr->data, this->active_configuration_ptr->length, result_ptr, length);

    return result_ptr;
}
uint8_t *thread_joiner_application_active_config_params_get(uint8_t interface_id, uint16_t *length)
{
    thread_joiner_t *this = thread_joiner_find(interface_id);
    if (!this || !this->active_configuration_ptr || !length) {
        return NULL;
    }
    *length = this->active_configuration_ptr->length;
    return this->active_configuration_ptr->data;
}

uint16_t thread_joiner_application_active_config_length(uint8_t interface_id, const uint8_t *req_tlv_ptr, uint8_t req_tlv_len, const uint8_t *ignored_tlv_ptr, uint8_t ignored_tlv_len)
{
    thread_joiner_t *this = thread_joiner_find(interface_id);
    if (!this || !this->active_configuration_ptr) {
        return 0;
    }
    return configuration_set_length(this->active_configuration_ptr, req_tlv_ptr, req_tlv_len, ignored_tlv_ptr, ignored_tlv_len);
}

uint8_t *thread_joiner_application_active_config_write(uint8_t interface_id, uint8_t *ptr, const uint8_t *req_tlv_ptr, uint8_t req_tlv_len, const uint8_t *ignored_tlv_ptr, uint8_t ignored_tlv_len)
{
    thread_joiner_t *this = thread_joiner_find(interface_id);
    if (!this || !this->active_configuration_ptr) {
        return ptr;
    }
    return configuration_set_write(this->active_configuration_ptr, ptr, req_tlv_ptr, req_tlv_len, ignored_tlv_ptr, ignored_tlv_len);
}

int thread_joiner_application_device_configuration_length(device_configuration_s *device_configuration)
{
    int length;

    if (!device_configuration) {
        return 0;
    }
    length = 2 + 1 + 2 + 6 + 2 + device_configuration->vendor_data_len;// Status + Stack version + vendor data
    if (device_configuration->provisioning_uri_ptr) {
        length += 2 + strlen(device_configuration->provisioning_uri_ptr);
    }
    if (device_configuration->vendor_name_ptr) {
        length += 2 + strlen(device_configuration->vendor_name_ptr);
    }
    if (device_configuration->vendor_model_ptr) {
        length += 2 + strlen(device_configuration->vendor_model_ptr);
    }
    if (device_configuration->vendor_sw_version_ptr) {
        length += 2 + strlen(device_configuration->vendor_sw_version_ptr);
    }
    return length;
}

uint8_t *thread_joiner_application_device_configuration_build(uint8_t *ptr, device_configuration_s *device_configuration)
{
    if (!ptr || !device_configuration) {
        return ptr;
    }
    ptr = thread_tmfcop_tlv_data_write(ptr, MESHCOP_TLV_VENDOR_STACK_VERSION, 6, device_configuration->vendor_stack_version);
    ptr = thread_tmfcop_tlv_data_write(ptr, MESHCOP_TLV_VENDOR_DATA,
                                       device_configuration->vendor_data_len,
                                       device_configuration->vendor_data_ptr);

    if (device_configuration->provisioning_uri_ptr) {
        ptr = thread_tmfcop_tlv_data_write(ptr, MESHCOP_TLV_PROVISIONING_URL,
                                           strlen(device_configuration->provisioning_uri_ptr),
                                           (uint8_t *)device_configuration->provisioning_uri_ptr);
    }
    if (device_configuration->vendor_name_ptr) {
        ptr = thread_tmfcop_tlv_data_write(ptr, MESHCOP_TLV_VENDOR_NAME,
                                           strlen(device_configuration->vendor_name_ptr),
                                           (uint8_t *)device_configuration->vendor_name_ptr);
    }
    if (device_configuration->vendor_model_ptr) {
        ptr = thread_tmfcop_tlv_data_write(ptr, MESHCOP_TLV_VENDOR_MODEL,
                                           strlen(device_configuration->vendor_model_ptr),
                                           (uint8_t *)device_configuration->vendor_model_ptr);
    }
    if (device_configuration->vendor_sw_version_ptr) {
        ptr = thread_tmfcop_tlv_data_write(ptr, MESHCOP_TLV_VENDOR_SW_VERSION,
                                           strlen(device_configuration->vendor_sw_version_ptr),
                                           (uint8_t *)device_configuration->vendor_sw_version_ptr);
    }
    return ptr;
}

int8_t thread_joiner_application_active_configuration_update(int8_t interface_id, uint8_t *data_ptr, uint16_t data_len, const uint8_t *ignore_ptr, uint8_t ingore_len)
{
    thread_joiner_t *this = thread_joiner_find(interface_id);
    uint64_t timestamp = 0;

    if (!this) {
        return -1;
    }
    configuration_set_add_all_fields(this->active_configuration_ptr, data_ptr, data_len, ignore_ptr, ingore_len);
    thread_meshcop_tlv_data_get_uint64(data_ptr, data_len, MESHCOP_TLV_ACTIVE_TIME_STAMP, &timestamp);
    thread_joiner_application_active_timestamp_set(this->interface_id, timestamp);
    link_configuration_update(this->configuration_ptr, this->active_configuration_ptr->data, this->active_configuration_ptr->length);
    this->configuration_valid = true;
    thread_joiner_application_configuration_nvm_save(this->interface_id);

    link_configuration_trace(this->configuration_ptr);

    return 0;
}
#endif

