Whitelist enabled in rnf51822 , but after restart the firmware unable to connect phone that are added in whitelist

[NIDHIN K]

I have created a whitelist in nrf51822 device its working fine. But i stored whitelist details (pp_irk and pp_addr) to an external flash memory( bacause i not using peer manager). once i bond and connect any phone irk details will store to whitelist  and memory. so after that i can only able to connect that phone only    (because i have set initially  whitelist.addr_count=1, whitelist.irk_count=1) ,  upto this everything is working fine.

But after firmware restart i cant able to connect that previously bonded phone. if i delete the bond information from my phone then its ok i can able to connect. i don't know why its happening ??

i found one thing that is , all the phone don't have this issue

after calling ble_advertising_whitelist_reply(&whitelist);    i have read whitelist.addr_count , whitelist.irk_count. 

if whitelist.addr_count=1 and  whitelist.irk_count=0 at this condition i dont have the above issue , only when whitelist.irk_count=1

pls anybody help me to solve this issue , i also attach my code

static void on_adv_evt(ble_adv_evt_t ble_adv_evt) {

    SEGGER_RTT_printf(0,"on_adv_evt\r\n");
    uint32_t err_code;

    switch (ble_adv_evt)
    {
        case BLE_ADV_EVT_IDLE:
            //Restart advertisement
            SEGGER_RTT_printf(0,"BLE_ADV_EVT_IDLE\r\n");
            uint32_t err_code = ble_advertising_start(BLE_ADV_MODE_FAST);
            APP_ERROR_CHECK(err_code);
            break;

        case BLE_ADV_EVT_FAST:
            SEGGER_RTT_printf(0,"BLE_ADV_EVT_FAST\r\n");
            break;

        case BLE_ADV_EVT_WHITELIST_REQUEST:
            SEGGER_RTT_printf(0,"BLE_ADV_EVT_WHITELIST_REQUEST\r\n");

            ble_gap_whitelist_t  whitelist;
            ble_gap_irk_t*          p_whitelist_irk[2];
            ble_gap_addr_t*      p_whitelist_addr[1];
            static ble_gap_irk_t whitelist_sensor_2;
            static ble_gap_addr_t       whitelist_sensor_1;
            static ble_gap_irk_t       whitelist_motog = {{0x87,0x8B,0x1B,0xFD,0xEC,0xED,0x14,0x2C,0xFE,0xC0,0x8B,0x7F,0x01,0x4A,0xEF,0x79}};
            static ble_gap_irk_t       whitelist_lenovo = {{0x2B,0x01,0xC2,0x99,0x61,0xCF,0xBF,0x4B,0xDD,0x6E,0xC0,0x80,0x85,0x2B,0x01,0x90}};

            if(whitelist_irk_count >= 1 && whitelist_addr_count==0){

                SEGGER_RTT_printf(0,"11111\r\n");
                for(char i=0;i<16;i++){
                    whitelist_sensor_2.irk[i]=whitelist_buf[i];
                }
                p_whitelist_irk[0]      = &whitelist_sensor_2;
                p_whitelist_irk[1]      = &whitelist_motog;
                whitelist.addr_count    = 0;
                whitelist.pp_addrs      = NULL;
                whitelist.pp_irks       = p_whitelist_irk;
                whitelist.irk_count     = 2;

                SEGGER_RTT_printf(0,"1addr_count=%d , irk_count=%d\r\n",whitelist.addr_count,whitelist.irk_count);
                for (int i=0;i<16;i++){
                    SEGGER_RTT_printf(0,"pp_irks[%d]=%02x\r\n",i,p_whitelist_irk[0]->irk[i]);
                }
                for (int i=0;i<16;i++){
                    SEGGER_RTT_printf(0,"pp_irks[%d]=%02x\r\n",i,p_whitelist_irk[1]->irk[i]);
                }
                err_code = ble_advertising_whitelist_reply(&whitelist);
                APP_ERROR_CHECK(err_code);

            }
            else if(whitelist_addr_count==1){
                SEGGER_RTT_printf(0,"222222\r\n");

                whitelist_sensor_1.addr_type=BLE_GAP_ADDR_TYPE_RANDOM_STATIC;
                for(char i=0;i<6;i++){
                    whitelist_sensor_1.addr[i]=whitelist_buf[i];
                }
                p_whitelist_addr[0]     = &whitelist_sensor_1;
                p_whitelist_irk[0]      = &whitelist_motog;
                whitelist.addr_count    = 1;
                whitelist.pp_addrs      = p_whitelist_addr;
                whitelist.pp_irks       = p_whitelist_irk;
                whitelist.irk_count     = 1;

                SEGGER_RTT_printf(0,"2addr_count=%d , irk_count=%d\r\n",whitelist.addr_count,whitelist.irk_count);
                for (int i=0;i<6;i++){
                    SEGGER_RTT_printf(0,"pp_addrs[%d]=%02x\r\n",i,p_whitelist_addr[0]->addr[i]);
                }
                err_code = ble_advertising_whitelist_reply(&whitelist);
                APP_ERROR_CHECK(err_code);

            }
            else{
                SEGGER_RTT_printf(0,"333333\r\n");

                uint8_t buffr[2];
                whitelist.addr_count = 1;
                whitelist.irk_count  = 2;
                whitelist.pp_addrs   = p_whitelist_addr;
                whitelist.pp_irks    = p_whitelist_irk;

                err_code = dm_whitelist_create(&m_app_handle, &whitelist);

                whitelist_irk_count=whitelist.irk_count;
                whitelist_addr_count=whitelist.addr_count;

                if(whitelist.irk_count >= 1){
                    SEGGER_RTT_printf(0,"writing irk count \r\n");

                    sectorErase(0x7FE000);
                    /* handling session number storing*/
                    buffr[0] = (uint8_t)((session_num & 0x00FF) >> 0);
                    buffr[1] = (uint8_t)((session_num & 0xFF00) >> 8);
                    writeByteBuffer(buffr , 2, 0x7FE000);

                    writeByteBuffer(p_whitelist_irk[0]->irk , 16, 0x7FE102);
                    for(char i=0;i<16;i++){
                        whitelist_buf[i]=p_whitelist_irk[0]->irk[i];
                    }

                    /* store irk and addr count */
                    buffr[0]=whitelist.irk_count;
                    buffr[1]=whitelist.addr_count;
                    SEGGER_RTT_printf(0,"[W]addr_count=%d , irk_count=%d\r\n",whitelist.addr_count,whitelist.irk_count);
                    writeByteBuffer(buffr , 2, 0x7FE100);

                }else if(whitelist.addr_count==1){
                    SEGGER_RTT_printf(0,"writing addr count \r\n");

                    sectorErase(0x7FE000);
                    /* handling session number storing*/
                    buffr[0] = (uint8_t)((session_num & 0x00FF) >> 0);
                    buffr[1] = (uint8_t)((session_num & 0xFF00) >> 8);
                    writeByteBuffer(buffr , 2, 0x7FE000);

                    writeByteBuffer(p_whitelist_addr[0]->addr , 6, 0x7FE102);
                    for(char i=0;i<6;i++){
                        whitelist_buf[i]=p_whitelist_addr[0]->addr[i];
                    }

                    /* store irk and addr count */
                    buffr[0]=whitelist.irk_count;
                    buffr[1]=whitelist.addr_count;
                    SEGGER_RTT_printf(0,"[W]addr_count=%d , irk_count=%d\r\n",whitelist.addr_count,whitelist.irk_count);
                    writeByteBuffer(buffr , 2, 0x7FE100);
                }


                err_code = ble_advertising_whitelist_reply(&whitelist);
                APP_ERROR_CHECK(err_code);
            }

            break;


        default:
            break;
    }

}

uint32_t advertising_init(void) {
    uint32_t err_code;
    ble_advdata_t advdata;

    // Build advertising data struct to pass into @ref ble_advertising_init.
    memset(&advdata, 0, sizeof(advdata));

    advdata.name_type = BLE_ADVDATA_FULL_NAME;
    advdata.include_appearance = true;
    advdata.flags = BLE_GAP_ADV_FLAG_BR_EDR_NOT_SUPPORTED;
    advdata.uuids_complete.uuid_cnt = sizeof(m_adv_uuids)
            / sizeof(m_adv_uuids[0]);
    advdata.uuids_complete.p_uuids = m_adv_uuids;

    ble_adv_modes_config_t options = { 0 };
    options.ble_adv_whitelist_enabled = BLE_ADV_WHITELIST_ENABLED;
    options.ble_adv_fast_enabled = BLE_ADV_FAST_ENABLED;
    options.ble_adv_fast_interval = APP_ADV_INTERVAL;
    options.ble_adv_fast_timeout = APP_ADV_TIMEOUT_IN_SECONDS;

    err_code = ble_advertising_init(&advdata, NULL, &options, on_adv_evt, NULL);
    return err_code;
}

[Vidar Berg]

Hi,

Have you compared the content of the whitelist before and after reset to ensure that the data is the same? The fact that it fails after a reset indicates that the data may have been retrieved/stored incorrectly on the ext. flash. Do you see the same behavior if you restart whitelist advertising without doing a reset in-between?

[NIDHIN K]

Yes both data are same before and after reset. i have checked whitelist.pp_irks, whitelist.irk_count data are same after reset also that means memory storage has no any issue. My exact issue is, i think my whitelist is working because i can able to connect only previously bonded phone( cant able to connect any other phone)but  problem is i need to delete bond information from phone after reset nrf51822. i used motog5s plus.

[Vidar Berg]

Hi,

It sounds like the whitelist filtering is working as intended, and that the problem may be that the bonding information is lost on the 51 side. Phones will normally send a new bonding request to the peripheral after existing bond information has been cleared.

I would suggest to debug the app and check if it replies with the correct keys after a reset. Message sequence chart for encrypting the link with existing keys can be found here: http://infocenter.nordicsemi.com/topic/com.nordic.infocenter.s130.api.v2.0.1/group___b_l_e___g_a_p___p_e_r_i_p_h___e_n_c___m_s_c.html?cp=3_7_2_1_0_2_1_3_8_5 

[NIDHIN K]

Only we need to store whitelist.pp_irks, whitelist.irk_count ,whitelist.pp_addrs, whitelist.addr_count these four parameter right??

Or anything else we need to store in memory ??

Because we are passing only these 4 params in this function ble_advertising_whitelist_reply(&whitelist);

After reset occurs i have  read back from ext.flash and load these four parameter.

[Vidar Berg]

Bonding information also include encryption key (LTK), ediv, and rand, which is needed to encrypt the link when you re-connect, please refer to the MSC I linked to in my previous reply.

I think it would be easier to modify the peer manager/fstorage backend to use ext. flash than it would be to create a custom "peer manager" from scratch.