示例#1
0
文件: dynmemtest.cpp 项目: betzw/mbed
TEST(dynmem, test_both_allocs_with_hole_usage) {
    uint16_t size = 112;
    mem_stat_t info;
    void *p[size];
    uint8_t *heap = (uint8_t*)malloc(size);
    CHECK(NULL != heap);
    reset_heap_error();
    ns_dyn_mem_init(heap, size, &heap_fail_callback, &info);
    CHECK(!heap_have_failed());

    void *ptr = ns_dyn_mem_alloc(15);
    void *ptr2 = ns_dyn_mem_alloc(4);

    ns_dyn_mem_free(ptr);
    ns_dyn_mem_free(ptr2);
    CHECK(info.heap_sector_allocated_bytes == 0);

    void *ptr3 = ns_dyn_mem_temporary_alloc(15);
    void *ptr4 = ns_dyn_mem_temporary_alloc(5);

    ns_dyn_mem_free(ptr3);
    ns_dyn_mem_free(ptr4);


    CHECK(info.heap_sector_allocated_bytes == 0);

    free(heap);
}
示例#2
0
文件: dynmemtest.cpp 项目: betzw/mbed
TEST(dynmem, not_negative_stats)
{
    uint16_t size = 1000;
    mem_stat_t info;
    uint8_t *heap = (uint8_t*)malloc(size);
    void *p;
    CHECK(NULL != heap);
    reset_heap_error();
    ns_dyn_mem_init(heap, size, &heap_fail_callback, &info);
    CHECK(!heap_have_failed());
    CHECK(info.heap_sector_allocated_bytes == 0);
    ns_dyn_mem_alloc(8);
    p = ns_dyn_mem_alloc(8);
    ns_dyn_mem_alloc(8);
    CHECK(info.heap_sector_allocated_bytes >= 24);
    int16_t last_value = info.heap_sector_allocated_bytes;
    ns_dyn_mem_free(p);
    CHECK(info.heap_sector_allocated_bytes >= 16);
    CHECK(info.heap_sector_allocated_bytes < last_value);
    last_value = info.heap_sector_allocated_bytes;
    for (int i=0; i<10; i++) {
        p = ns_dyn_mem_alloc(1);
        ns_dyn_mem_free(p);
    }
    CHECK(info.heap_sector_allocated_bytes == last_value);
    free(heap);
}
示例#3
0
文件: dynmemtest.cpp 项目: betzw/mbed
TEST(dynmem, ns_dyn_mem_alloc)
{
    uint16_t size = 1000;
    mem_stat_t info;
    void *p[size];
    uint8_t *heap = (uint8_t*)malloc(size);
    CHECK(NULL != heap);
    reset_heap_error();
    ns_dyn_mem_init(heap, size, &heap_fail_callback, &info);
    CHECK(!heap_have_failed());
    int block = 1;

    int i;
    for (i=0; i<size; i++) {
        p[i] = ns_dyn_mem_alloc(block);
        if (!p[i])
            break;
    }
    CHECK(!heap_have_failed());
    CHECK(info.heap_alloc_fail_cnt == 1);
    CHECK(info.heap_sector_alloc_cnt == i);
    CHECK(info.heap_sector_allocated_bytes == info.heap_sector_allocated_bytes_max);

    for (; i>=0; i--) {
        ns_dyn_mem_free(p[i]);
    }
    CHECK(!heap_have_failed());
    CHECK(info.heap_sector_alloc_cnt == 0);
    free(heap);
}
示例#4
0
coap_security_t *coap_security_create(int8_t socket_id, int8_t timer_id, uint8_t *address_ptr, uint16_t port, SecureConnectionMode mode,
                                          send_cb *send_cb,
                                          receive_cb *receive_cb,
                                          start_timer_cb *start_timer_cb,
                                          timer_status_cb *timer_status_cb)
{
    if( !address_ptr || send_cb == NULL || receive_cb == NULL || start_timer_cb == NULL || timer_status_cb == NULL){
        return NULL;
    }
    coap_security_t *this = ns_dyn_mem_alloc(sizeof(coap_security_t));
    if( !this ){
        return NULL;
    }
    memset(this, 0, sizeof(coap_security_t));
    if( -1 == coap_security_handler_init(this) ){
        ns_dyn_mem_free(this);
        return NULL;
    }
    this->_remote_port = port;
    memcpy(this->_remote_address, address_ptr, 16);
    this->_conn_mode = mode;
    memset(this->_pw, 0, 64);
    this->_pw_len = 0;
    this->_socket_id = socket_id;
    this->_timer_id = timer_id;
    this->_send_cb = send_cb;
    this->_receive_cb = receive_cb;
    this->_start_timer_cb = start_timer_cb;
    this->_timer_status_cb = timer_status_cb;

    return this;
}
示例#5
0
int8_t ws_pae_controller_init(protocol_interface_info_entry_t *interface_ptr)
{
    if (!interface_ptr) {
        return -1;
    }

    if (ws_pae_controller_get(interface_ptr) != NULL) {
        return 0;
    }

    pae_controller_t *controller = ns_dyn_mem_alloc(sizeof(pae_controller_t));
    if (!controller) {
        return -1;
    }

    memset(controller->target_eui_64, 0, 8);
    memset(controller->br_eui_64, 0, 8);
    controller->interface_ptr = interface_ptr;
    controller->auth_completed = NULL;
    controller->key_insert = NULL;
    controller->pae_delete = NULL;
    controller->pae_timer = NULL;
    controller->pae_br_addr_write = NULL;
    controller->pae_br_addr_read = NULL;

    sec_prot_keys_gtks_init(&controller->gtks);
    sec_prot_certs_init(&controller->certs);

    ns_list_add_to_end(&pae_controller_list, controller);

    return 0;
}
示例#6
0
int8_t net_nvm_wpan_params_storage_enable(int8_t interface_id, wpan_params_updated *nvm_update_cb, wpan_params_get *nvm_get_cb)
{

    protocol_interface_info_entry_t *cur = protocol_stack_interface_info_get_by_id(interface_id);
    if (!cur || !nvm_update_cb || !nvm_get_cb) {
        return -1;
    }

    if (cur->nwk_wpan_nvm_api) {
        return 0;
    }
    cur->nwk_wpan_nvm_api = ns_dyn_mem_alloc(sizeof(nwk_wpan_nvm_api_t));
    if (!cur->nwk_wpan_nvm_api) {
        return -2;
    }

    cur->nwk_wpan_nvm_api->interface = cur;
    cur->nwk_wpan_nvm_api->params.pan_id = 0xffff;
    cur->nwk_wpan_nvm_api->NVM_GET = nvm_get_cb;
    cur->nwk_wpan_nvm_api->NVM_PUSH = nvm_update_cb;
    cur->nwk_wpan_nvm_api->nvm_params_get_cb = nwk_nvm_params_get_cb;
    cur->nwk_wpan_nvm_api->nvm_params_update_cb = nwk_nvm_params_update_cb;

    return 0;
}
coap_security_t *coap_security_create(int8_t socket_id, int8_t timer_id, void *handle, SecureConnectionMode mode,
                                          send_cb *socket_cb,
                                          receive_cb *receive_data_cb,
                                          start_timer_cb *timer_start_cb,
                                          timer_status_cb *timer_stat_cb)
{
    if (socket_cb == NULL || receive_data_cb == NULL || timer_start_cb == NULL || timer_stat_cb == NULL) {
        return NULL;
    }
    coap_security_t *this = ns_dyn_mem_alloc(sizeof(coap_security_t));
    if( !this ){
        return NULL;
    }
    memset(this, 0, sizeof(coap_security_t));
    if (-1 == coap_security_handler_init(this)) {
        ns_dyn_mem_free(this);
        return NULL;
    }
    this->_handle = handle;
    this->_conn_mode = mode;
    memset(this->_pw, 0, 64);
    this->_pw_len = 0;
    this->_socket_id = socket_id;
    this->_timer_id = timer_id;
    this->_send_cb = socket_cb;
    this->_receive_cb = receive_data_cb;
    this->_start_timer_cb = timer_start_cb;
    this->_timer_status_cb = timer_stat_cb;

    return this;
}
示例#8
0
/**
 * Load balance border router class allocate
 */
static lb_monitor_internal_t *lb_border_router_api_allocate(lb_internal_t *api)
{
    if (!api->lb_border_router) {
        api->lb_border_router = ns_dyn_mem_alloc(sizeof(lb_monitor_internal_t));
    }
    return api->lb_border_router;
}
示例#9
0
文件: dynmemtest.cpp 项目: betzw/mbed
TEST(dynmem, corrupted_memory)
{
    uint16_t size = 1000;
    mem_stat_t info;
    uint8_t *heap = (uint8_t*)malloc(size);
    uint8_t *ptr = heap;
    CHECK(NULL != heap);
    reset_heap_error();
    ns_dyn_mem_init(heap, size, &heap_fail_callback, &info);
    CHECK(!heap_have_failed());
    int *pt = (int *)ns_dyn_mem_alloc(8);
    CHECK(!heap_have_failed());
    pt -= 2;
    *pt = 0;
    ns_dyn_mem_alloc(8);
    CHECK(NS_DYN_MEM_HEAP_SECTOR_CORRUPTED == current_heap_error);
    free(heap);
}
示例#10
0
/*
 * \brief Configure mesh network
 *
 */
void thread_tasklet_configure_and_connect_to_network(void)
{
    int8_t status;
    link_configuration_s* temp_link_config=NULL;


    if (MBED_CONF_MBED_MESH_API_THREAD_DEVICE_TYPE == MESH_DEVICE_TYPE_THREAD_MINIMAL_END_DEVICE) {
            thread_tasklet_data_ptr->operating_mode = NET_6LOWPAN_HOST;
    }
    else if (MBED_CONF_MBED_MESH_API_THREAD_DEVICE_TYPE == MESH_DEVICE_TYPE_THREAD_SLEEPY_END_DEVICE) {
        thread_tasklet_data_ptr->operating_mode = NET_6LOWPAN_SLEEPY_HOST;
    } else {
        thread_tasklet_data_ptr->operating_mode = NET_6LOWPAN_ROUTER;
    }

    arm_nwk_interface_configure_6lowpan_bootstrap_set(
        thread_tasklet_data_ptr->nwk_if_id,
        thread_tasklet_data_ptr->operating_mode,
        NET_6LOWPAN_THREAD);
        
    thread_tasklet_data_ptr->channel_list.channel_page = (channel_page_e)MBED_CONF_MBED_MESH_API_THREAD_CONFIG_CHANNEL_PAGE;
    thread_tasklet_data_ptr->channel_list.channel_mask[0] = MBED_CONF_MBED_MESH_API_THREAD_CONFIG_CHANNEL_MASK;
    
    TRACE_DETAIL("channel page: %d", thread_tasklet_data_ptr->channel_list.channel_page);
    TRACE_DETAIL("channel mask: 0x%.8lx", thread_tasklet_data_ptr->channel_list.channel_mask[0]);

    // PSKd
    const char PSKd[] = MBED_CONF_MBED_MESH_API_THREAD_PSKD;
    MBED_ASSERT(sizeof(PSKd) > 5 && sizeof(PSKd) < 33);

    char *dyn_buf = ns_dyn_mem_alloc(sizeof(PSKd));
    strcpy(dyn_buf, PSKd);
    ns_dyn_mem_free(device_configuration.PSKd_ptr);
    device_configuration.PSKd_ptr = (uint8_t*)dyn_buf;
    device_configuration.PSKd_len = sizeof(PSKd) - 1;  
    
    if (true == MBED_CONF_MBED_MESH_API_THREAD_USE_STATIC_LINK_CONFIG) {
        read_link_configuration();
        temp_link_config = &thread_tasklet_data_ptr->link_config;
    }
    
    thread_management_node_init(thread_tasklet_data_ptr->nwk_if_id,
                           &thread_tasklet_data_ptr->channel_list,
                           &device_configuration,
                           temp_link_config);

    status = arm_nwk_interface_up(thread_tasklet_data_ptr->nwk_if_id);

    if (status >= 0) {
        thread_tasklet_data_ptr->tasklet_state = TASKLET_STATE_BOOTSTRAP_STARTED;
        tr_info("Start Thread bootstrap (%s mode)", thread_tasklet_data_ptr->operating_mode == NET_6LOWPAN_SLEEPY_HOST ? "SED" : "Router");
    } else {
        thread_tasklet_data_ptr->tasklet_state = TASKLET_STATE_BOOTSTRAP_FAILED;
        tr_err("Bootstrap start failed, %d", status);
        thread_tasklet_network_state_changed(MESH_BOOTSTRAP_START_FAILED);
    }
}
示例#11
0
文件: nd_tasklet.c 项目: betzw/mbed
void nd_tasklet_init(void)
{
    if (tasklet_data_ptr == NULL) {
        // memory allocation will not fail as memory was just initialized
        tasklet_data_ptr = ns_dyn_mem_alloc(sizeof(tasklet_data_str_t));
        tasklet_data_ptr->tasklet_state = TASKLET_STATE_CREATED;
        tasklet_data_ptr->network_interface_id = INVALID_INTERFACE_ID;
    }
}
示例#12
0
void thread_tasklet_init(void)
{
    if (thread_tasklet_data_ptr == NULL) {
        thread_tasklet_data_ptr = ns_dyn_mem_alloc(sizeof(thread_tasklet_data_str_t));
        memset(thread_tasklet_data_ptr, 0, sizeof(thread_tasklet_data_str_t));
        thread_tasklet_data_ptr->tasklet_state = TASKLET_STATE_CREATED;
        thread_tasklet_data_ptr->nwk_if_id = INVALID_INTERFACE_ID;
    }
}
示例#13
0
文件: dynmemtest.cpp 项目: betzw/mbed
TEST(dynmem, test_merge_corrupted_previous_block) {
    uint16_t size = 1000;
    uint8_t *heap = (uint8_t*)malloc(size);
    uint8_t *p;
    CHECK(NULL != heap);
    reset_heap_error();
    ns_dyn_mem_init(heap, size, &heap_fail_callback, NULL);
    CHECK(!heap_have_failed());

    int *ptr = (int *)ns_dyn_mem_alloc(4);
    int *ptr2 = (int *)ns_dyn_mem_alloc(4);
    ns_dyn_mem_free(ptr);
    ptr = ptr2 - 2;
    *ptr = -2;
    ns_dyn_mem_free(ptr2);

    CHECK(NS_DYN_MEM_HEAP_SECTOR_CORRUPTED == current_heap_error);

    free(heap);
}
示例#14
0
文件: dynmemtest.cpp 项目: betzw/mbed
TEST(dynmem, no_big_enough_sector) {
    uint16_t size = 112;
    mem_stat_t info;
    uint8_t *heap = (uint8_t*)malloc(size);
    uint8_t *ptr = heap;
    CHECK(NULL != heap);
    reset_heap_error();
    ns_dyn_mem_init(heap, size, &heap_fail_callback, &info);
    CHECK(!heap_have_failed());
    int *pt = (int *)ns_dyn_mem_alloc(8);
    pt = (int *)ns_dyn_mem_alloc(8);
    ns_dyn_mem_alloc(8);
    ns_dyn_mem_temporary_alloc(8);
    ns_dyn_mem_temporary_alloc(8);

    ns_dyn_mem_free(pt);

    pt = (int *)ns_dyn_mem_temporary_alloc(32);
    CHECK(NULL == pt);
    free(heap);
}
示例#15
0
pana_session_t *pana_session_allocate(void)
{
    pana_session_t *p_session =   ns_dyn_mem_alloc(sizeof(pana_session_t));
    if (p_session) {
        memset(p_session, 0, sizeof(pana_session_t));
        p_session->session_ready = false;
        p_session->key_warp = false;
        p_session->user_server = false;
        p_session->eap_id_seq = randLIB_get_8bit(); //Take Random EAP ID
    }
    return p_session;
}
示例#16
0
文件: dynmemtest.cpp 项目: betzw/mbed
TEST(dynmem, different_sizes)
{
    reset_heap_error();
    for (uint16_t size = 1000; size<32768; size++) {
        mem_stat_t info;
        uint8_t *heap = (uint8_t*)malloc(size);
        ns_dyn_mem_init(heap, size, &heap_fail_callback, &info);
        CHECK(info.heap_sector_size >= (size-72));
        CHECK(!heap_have_failed());
        CHECK(ns_dyn_mem_alloc(10));
        free(heap);
    }
}
示例#17
0
static dhcpv6_gua_server_entry_s *libdhcpv6_server_entry_allocate(void)
{
    dhcpv6_gua_server_entry_s *entry = ns_dyn_mem_alloc(sizeof(dhcpv6_gua_server_entry_s));
    if (entry) {
        entry->clientIdSequence = 0;
        entry->enableAddressMapping = false;
        entry->enableAddressAutonous = true;
        entry->clientIdDefaultSuffics = 0x0000000;
        entry->maxSuppertedClients = 200;
        entry->validLifetime = 7200;
        ns_list_init(&entry->allocatedAddressList);
    }
    return entry;
}
示例#18
0
文件: dynmemtest.cpp 项目: betzw/mbed
TEST(dynmem, test_invalid_pointer_freed) {
    uint16_t size = 92;
    uint8_t *heap = (uint8_t*)malloc(size);
    CHECK(NULL != heap);
    reset_heap_error();
    ns_dyn_mem_init(heap, size, &heap_fail_callback, NULL);
    int *ptr = (int *)ns_dyn_mem_alloc(4);
    ptr--;
    *ptr = 16;
    ptr++;
    ns_dyn_mem_free(ptr);
    CHECK(NS_DYN_MEM_POINTER_NOT_VALID == current_heap_error);

    free(heap);
}
示例#19
0
文件: dynmemtest.cpp 项目: betzw/mbed
TEST(dynmem, too_big)
{
    uint16_t size = 1000;
    mem_stat_t info;
    uint8_t *heap = (uint8_t*)malloc(size);
    uint8_t *ptr = heap;
    CHECK(NULL != heap);
    reset_heap_error();
    ns_dyn_mem_init(heap, size, &heap_fail_callback, &info);
    CHECK(!heap_have_failed());
    ns_dyn_mem_alloc(size);
    CHECK(heap_have_failed());
    CHECK(NS_DYN_MEM_ALLOCATE_SIZE_NOT_VALID == current_heap_error);
    free(heap);
}
示例#20
0
uint8_t thread_tasklet_device_pskd_set(const char *pskd)
{
    int len = strlen(pskd);
    if(len < 6 || len > 32) {
        return MESH_ERROR_PARAM;
    }
    char *dyn_buf = ns_dyn_mem_alloc(strlen(pskd)+1);
    if (!dyn_buf) {
        return MESH_ERROR_MEMORY;
    }
    strcpy(dyn_buf, pskd);
    ns_dyn_mem_free(device_configuration.PSKd_ptr);
    device_configuration.PSKd_ptr = (uint8_t*)dyn_buf;
    device_configuration.PSKd_len = strlen(pskd);
    return 0;
}
示例#21
0
thread_network_dynamic_data_entry_t *thread_network_synch_create(int8_t interfaceId)
{
    thread_network_dynamic_data_entry_t *newEntry = ns_dyn_mem_alloc(sizeof(thread_network_dynamic_data_entry_t));
    if (newEntry) {
        tr_debug("Allocate New Store");
        newEntry->interfaceId = interfaceId;
        newEntry->networ_dynamic_data_parameters.thread_attached_state = THREAD_STATE_NETWORK_DISCOVER;
        newEntry->networ_dynamic_data_parameters.shortAddress = 0xfffe;
        newEntry->networ_dynamic_data_parameters.leader_private_data = NULL;
        newEntry->networ_dynamic_data_parameters.thread_endnode_parent = NULL;
        for (int i = 0; i < THREAD_MAX_CHILD_COUNT; ++i) {
            memset(&newEntry->networ_dynamic_data_parameters.children[i], 0, sizeof(thread_sync_child_info_t));
        }
        ns_list_add_to_end(&thread_network_dynamic_data_info, newEntry);
    }
    return newEntry;
}
示例#22
0
// XXX: a ns_dyn_mem_realloc() would be nice to have
uint8_t *mac_helper_beacon_payload_reallocate(protocol_interface_info_entry_t *interface, uint8_t len)
{

    if (len == interface->mac_parameters->mac_beacon_payload_size) {
        // no change to size, return the existing buff
        //Set allways length to zero for safe beacon payload manipulate
        mac_helper_beacon_payload_length_set_to_mac(interface, 0);
        return interface->mac_parameters->mac_beacon_payload;
    }

    if (len == 0) {
        //SET MAC beacon payload to length to zero
        mac_helper_beacon_payload_length_set_to_mac(interface, 0);
        ns_dyn_mem_free(interface->mac_parameters->mac_beacon_payload);
        interface->mac_parameters->mac_beacon_payload = NULL;
        interface->mac_parameters->mac_beacon_payload_size = 0;
        return NULL;
    }

    tr_debug("mac_helper_beacon_payload_reallocate, old len: %d, new: %d", interface->mac_parameters->mac_beacon_payload_size, len);

    uint8_t *temp_buff = ns_dyn_mem_alloc(len);

    if (temp_buff == NULL) {
        // no need to proceed, could not allocate more space
        return NULL;
    }

    //SET MAC beacon payload to length to zero
    mac_helper_beacon_payload_length_set_to_mac(interface, 0);

    // copy data into new buffer before freeing old one
    if (interface->mac_parameters->mac_beacon_payload_size > 0) {
        const uint8_t min_len = MIN(len, interface->mac_parameters->mac_beacon_payload_size);

        memcpy(temp_buff, interface->mac_parameters->mac_beacon_payload, min_len);
        ns_dyn_mem_free(interface->mac_parameters->mac_beacon_payload);
    }

    //Set New Length and pointer to MAC

    interface->mac_parameters->mac_beacon_payload = temp_buff;
    interface->mac_parameters->mac_beacon_payload_size = len;

    return interface->mac_parameters->mac_beacon_payload;
}
示例#23
0
/**
 * Allocate notified network class
 */
static bool load_balance_network_class_allocate(lb_internal_t *lb_store_ptr, uint16_t beacon_max_payload_length)
{
    ns_dyn_mem_free(lb_store_ptr->notified_network);
    lb_store_ptr->beacon_max_payload_length = 0;
    if (beacon_max_payload_length) {
        lb_store_ptr->notified_network = ns_dyn_mem_alloc(sizeof(lb_network_t) + beacon_max_payload_length);
        if (!lb_store_ptr->notified_network) {
            return false;
        }
        lb_store_ptr->notified_network->network_switch_accepted = false;
        lb_store_ptr->notified_network->priority = 0xff;
        lb_store_ptr->notified_network->state = LB_NWK_SWITCH_IDLE;
        lb_store_ptr->notified_network->state_timer = 0;
        lb_store_ptr->beacon_max_payload_length = beacon_max_payload_length;

    }
    return true;
}
示例#24
0
文件: dynmemtest.cpp 项目: betzw/mbed
TEST(dynmem, over_by_one)
{
    uint16_t size = 1000;
    mem_stat_t info;
    uint8_t *heap = (uint8_t*)malloc(size);
    uint8_t *p;
    CHECK(NULL != heap);
    reset_heap_error();
    ns_dyn_mem_init(heap, size, &heap_fail_callback, &info);
    CHECK(!heap_have_failed());
    p = (uint8_t *)ns_dyn_mem_alloc(100);
    CHECK(p);
    p[100] = 0xff;
    ns_dyn_mem_free(p);
    CHECK(heap_have_failed());
    CHECK(NS_DYN_MEM_HEAP_SECTOR_CORRUPTED == current_heap_error);
    free(heap);
}
示例#25
0
文件: dynmemtest.cpp 项目: betzw/mbed
TEST(dynmem, double_free)
{
    uint16_t size = 1000;
    mem_stat_t info;
    uint8_t *heap = (uint8_t*)malloc(size);
    void *p;
    CHECK(NULL != heap);
    reset_heap_error();
    ns_dyn_mem_init(heap, size, &heap_fail_callback, &info);
    CHECK(!heap_have_failed());
    p = ns_dyn_mem_alloc(100);
    CHECK(p);
    ns_dyn_mem_free(p);
    CHECK(!heap_have_failed());
    ns_dyn_mem_free(p);
    CHECK(heap_have_failed());
    CHECK(NS_DYN_MEM_DOUBLE_FREE == current_heap_error);
    free(heap);
}
示例#26
0
int8_t mac_helper_nwk_id_filter_set(const uint8_t *nw_id, nwk_filter_params_s *filter)
{
    if (!filter) {
        return -1;
    }
    int8_t ret_val = 0;
    if (nw_id) {
        if (filter->beacon_nwk_id_filter == 0) {
            filter->beacon_nwk_id_filter = ns_dyn_mem_alloc(16);
        }
        if (filter->beacon_nwk_id_filter) {
            memcpy(filter->beacon_nwk_id_filter, nw_id, 16);
        } else {
            ret_val = -1;
        }
    } else {
        ns_dyn_mem_free(filter->beacon_nwk_id_filter);
        filter->beacon_nwk_id_filter = 0;
    }
    return ret_val;
}
示例#27
0
文件: dynmemtest.cpp 项目: betzw/mbed
TEST(dynmem, not_from_this_heap)
{
    uint16_t size = 1000;
    mem_stat_t info;
    uint8_t *heap = (uint8_t*)malloc(size);
    uint8_t *p;
    CHECK(NULL != heap);
    reset_heap_error();
    ns_dyn_mem_init(heap, size, &heap_fail_callback, &info);
    CHECK(!heap_have_failed());
    p = (uint8_t *)ns_dyn_mem_alloc(100);
    CHECK(p);
    ns_dyn_mem_free(&heap[-1]);
    CHECK(heap_have_failed());
    CHECK(NS_DYN_MEM_POINTER_NOT_VALID == current_heap_error);
    reset_heap_error();
    ns_dyn_mem_free(&heap[1001]);
    CHECK(heap_have_failed());
    CHECK(NS_DYN_MEM_POINTER_NOT_VALID == current_heap_error);
    free(heap);
}
示例#28
0
int ns_file_system_set_root_path(const char *root_path)
{
    char *new_root_path;

    if (root_path == NULL) {
        // File system usage disabled
        ns_dyn_mem_free(file_system_root);
        file_system_root = NULL;
        return 0;
    }

    new_root_path = ns_dyn_mem_alloc(strlen(root_path) + 1);
    if (!new_root_path) {
        // mem alloc failed
        return -2;
    }

    ns_dyn_mem_free(file_system_root);
    file_system_root = new_root_path;
    strcpy(file_system_root, root_path);

    return 0;
}
示例#29
0
/**
 * Allocate Load balance class base
 */
static lb_internal_t *load_balance_class_allocate(void)
{
    if (lb_store) {
        if (lb_store->lb_user_parent_id) {
            return NULL;
        }
        return lb_store;
    }

    lb_internal_t *store = ns_dyn_mem_alloc(sizeof(lb_internal_t));
    if (store) {

        store->lb_api = &lb_api;
        lb_api.lb_beacon_notify = lb_beacon_notify;
        lb_api.lb_enable = lb_enable;
        lb_api.lb_initialize = lb_api_initialize;
        lb_api.lb_seconds_tick_update = lb_second_ticks;

        store->lb_border_router = NULL;
        store->load_balance_beacon_tx_cb = NULL;
        store->lb_nwk_switch_cb = NULL;
        store->lb_priority_get_cb = NULL;
        store->lb_user_parent_id = NULL;
        store->notified_network = NULL;
        store->lb_access_switch_cb = NULL;
        store->beacon_max_payload_length = 0;
        store->nwk_switch_threshold_max = 0;
        store->nwk_switch_threshold_min = 0;
        store->nwk_maX_P = 25;
        store->load_balance_activate = false;
        store->time_to_next_beacon = 0;
        store->triggle_period = 0;
        lb_store = store;
    }

    return store;
}
示例#30
0
文件: dynmemtest.cpp 项目: betzw/mbed
//NOTE! This test must be last!
TEST(dynmem, uninitialized_test){
    void *p = ns_dyn_mem_alloc(4);
    ns_dyn_mem_free(p);
    CHECK(p == NULL);
}