Initialize white list size after stack reset

The white list size is not currently set correctly, preventing devices
from being added to the LE whitelist, thus completely breaking
re-connects.

This fixes the white list management and propagates the correct reason
code for HID close events to make sure a device is re-added to the white
list if necessary.

Bug: 20290744
Change-Id: I46d7254ff3568c9964688cb192b9deb6b7d3062d

diff --git a/bta/gatt/bta_gattc_act.c b/bta/gatt/bta_gattc_act.c
index 38d05a4..aa9fcae 100755 (executable)
--- a/bta/gatt/bta_gattc_act.c
+++ b/bta/gatt/bta_gattc_act.c
@@ -811,6 +811,7 @@ void bta_gattc_close(tBTA_GATTC_CLCB *p_clcb, tBTA_GATTC_DATA *p_data)
     else if (p_data->hdr.event == BTA_GATTC_INT_DISCONN_EVT)
     {
         cb_data.close.status = p_data->int_conn.reason;
+        cb_data.close.reason = p_data->int_conn.reason;
     }
 
     if(p_cback)

diff --git a/bta/jv/bta_jv_act.c b/bta/jv/bta_jv_act.c
index a182672..363a1ad 100644 (file)
--- a/bta/jv/bta_jv_act.c
+++ b/bta/jv/bta_jv_act.c
@@ -24,6 +24,7 @@
 #include <hardware/bluetooth.h>
 #include <arpa/inet.h>
 #include <pthread.h>
+#include <stdlib.h>
 
 #include "bt_types.h"
 #include "gki.h"

diff --git a/bta/sdp/bta_sdp_act.c b/bta/sdp/bta_sdp_act.c
index e45042c..cbb1fcb 100644 (file)
--- a/bta/sdp/bta_sdp_act.c
+++ b/bta/sdp/bta_sdp_act.c
@@ -23,6 +23,8 @@
 #include <hardware/bluetooth.h>
 #include <hardware/bt_sdp.h>
 #include <arpa/inet.h>
+#include <stdlib.h>
+#include <string.h>
 
 #include "bt_types.h"
 #include "gki.h"
@@ -34,7 +36,6 @@
 #include "btm_api.h"
 #include "btm_int.h"
 #include "sdp_api.h"
-#include <string.h>
 
 /*****************************************************************************
 **  Constants

diff --git a/device/include/controller.h b/device/include/controller.h
index 2acca1b..3e181b9 100644 (file)
--- a/device/include/controller.h
+++ b/device/include/controller.h
@@ -71,6 +71,8 @@ typedef struct controller_t {
   uint16_t (*get_acl_buffer_count_classic)(void);
   uint8_t (*get_acl_buffer_count_ble)(void);
 
+  uint8_t (*get_ble_white_list_size)(void);
+
   uint8_t (*get_ble_resolving_list_max_size)(void);
   void (*set_ble_resolving_list_max_size)(int resolving_list_max_size);
 } controller_t;

diff --git a/device/src/controller.c b/device/src/controller.c
index 02edc4f..62051d5 100644 (file)
--- a/device/src/controller.c
+++ b/device/src/controller.c
@@ -407,6 +407,12 @@ static uint8_t get_acl_buffer_count_ble(void) {
   return acl_buffer_count_ble;
 }
 
+static uint8_t get_ble_white_list_size(void) {
+  assert(readable);
+  assert(ble_supported);
+  return ble_white_list_size;
+}
+
 static uint8_t get_ble_resolving_list_max_size(void) {
   assert(readable);
   assert(ble_supported);
@@ -455,6 +461,8 @@ static const controller_t interface = {
   get_acl_buffer_count_classic,
   get_acl_buffer_count_ble,
 
+  get_ble_white_list_size,
+
   get_ble_resolving_list_max_size,
   set_ble_resolving_list_max_size
 };

diff --git a/stack/btm/btm_ble_bgconn.c b/stack/btm/btm_ble_bgconn.c
index a83a3c7..093a9ee 100644 (file)
--- a/stack/btm/btm_ble_bgconn.c
+++ b/stack/btm/btm_ble_bgconn.c
@@ -177,53 +177,50 @@ void btm_enq_wl_dev_operation(BOOLEAN to_add, BD_ADDR bd_addr)
     }
     return;
 }
+
 /*******************************************************************************
 **
 ** Function         btm_update_dev_to_white_list
 **
-** Description      This function adds a device into white list.
+** Description      This function adds or removes a device into/from
+**                  the white list.
+**
 *******************************************************************************/
 BOOLEAN btm_update_dev_to_white_list(BOOLEAN to_add, BD_ADDR bd_addr)
 {
-    /* look up the sec device record, and find the address */
     tBTM_BLE_CB *p_cb = &btm_cb.ble_ctr_cb;
-    UINT8       wl_state = p_cb->wl_state;
 
-    if ((to_add && p_cb->num_empty_filter == 0) ||
-        (!to_add && p_cb->num_empty_filter == p_cb->max_filter_entries))
+    if (to_add && p_cb->white_list_avail_size == 0)
     {
-        BTM_TRACE_ERROR("WL full or empty, unable to update to WL. num_entry available: %d",
-                          p_cb->num_empty_filter);
+        BTM_TRACE_ERROR("%s Whitelist full, unable to add device", __func__);
         return FALSE;
     }
 
-    btm_suspend_wl_activity(wl_state);
-
-    /* enq pending WL device operation */
+    btm_suspend_wl_activity(p_cb->wl_state);
     btm_enq_wl_dev_operation(to_add, bd_addr);
-
-    btm_resume_wl_activity(wl_state);
-
+    btm_resume_wl_activity(p_cb->wl_state);
     return TRUE;
 }
+
 /*******************************************************************************
 **
 ** Function         btm_ble_clear_white_list
 **
 ** Description      This function clears the white list.
+**
 *******************************************************************************/
 void btm_ble_clear_white_list (void)
 {
     BTM_TRACE_EVENT ("btm_ble_clear_white_list");
     btsnd_hcic_ble_clear_white_list();
-    memset(&btm_cb.ble_ctr_cb.bg_dev_list, 0, (sizeof(tBTM_LE_BG_CONN_DEV)*BTM_BLE_MAX_BG_CONN_DEV_NUM));
 }
 
 /*******************************************************************************
 **
 ** Function         btm_ble_clear_white_list_complete
 **
-** Description      This function clears the white list complete.
+** Description      Indicates white list cleared.
+**
 *******************************************************************************/
 void btm_ble_clear_white_list_complete(UINT8 *p_data, UINT16 evt_len)
 {
@@ -235,125 +232,57 @@ void btm_ble_clear_white_list_complete(UINT8 *p_data, UINT16 evt_len)
     STREAM_TO_UINT8  (status, p_data);
 
     if (status == HCI_SUCCESS)
-        p_cb->num_empty_filter = p_cb->max_filter_entries;
+        p_cb->white_list_avail_size = controller_get_interface()->get_ble_white_list_size();
+}
 
+/*******************************************************************************
+**
+** Function         btm_ble_white_list_init
+**
+** Description      Initialize white list size
+**
+*******************************************************************************/
+void btm_ble_white_list_init(UINT8 white_list_size)
+{
+    BTM_TRACE_DEBUG("%s white_list_size = %d", __func__, white_list_size);
+    btm_cb.ble_ctr_cb.white_list_avail_size = white_list_size;
 }
+
 /*******************************************************************************
 **
 ** Function         btm_ble_add_2_white_list_complete
 **
-** Description      This function read the current white list size.
+** Description      White list element added
+**
 *******************************************************************************/
 void btm_ble_add_2_white_list_complete(UINT8 status)
 {
-    tBTM_BLE_CB *p_cb = &btm_cb.ble_ctr_cb;
-    BTM_TRACE_EVENT ("btm_ble_add_2_white_list_complete");
-
+    BTM_TRACE_EVENT("%s status=%d", __func__, status);
     if (status == HCI_SUCCESS)
-    {
-        p_cb->num_empty_filter --;
-    }
+        --btm_cb.ble_ctr_cb.white_list_avail_size;
 }
+
 /*******************************************************************************
 **
 ** Function         btm_ble_remove_from_white_list_complete
 **
-** Description      This function remove the white list element complete.
+** Description      White list element removal complete
+**
 *******************************************************************************/
 void btm_ble_remove_from_white_list_complete(UINT8 *p, UINT16 evt_len)
 {
-    tBTM_BLE_CB *p_cb = &btm_cb.ble_ctr_cb;
     UNUSED(evt_len);
-
-    BTM_TRACE_EVENT ("btm_ble_remove_from_white_list_complete");
+    BTM_TRACE_EVENT ("%s status=%d", __func__, *p);
     if (*p == HCI_SUCCESS)
-    {
-        p_cb->num_empty_filter ++;
-    }
+        ++btm_cb.ble_ctr_cb.white_list_avail_size;
 }
-/*******************************************************************************
-**
-** Function         btm_ble_count_unconn_dev_in_whitelist
-**
-** Description      This function find the number of un-connected background device
-*******************************************************************************/
-UINT8 btm_ble_count_unconn_dev_in_whitelist(void)
-{
-    tBTM_BLE_CB *p_cb = &btm_cb.ble_ctr_cb;
-    UINT8 i, count = 0;
-
-    for (i = 0; i < BTM_BLE_MAX_BG_CONN_DEV_NUM; i ++)
-    {
-        if (p_cb->bg_dev_list[i].in_use &&
-            !BTM_IsAclConnectionUp(p_cb->bg_dev_list[i].bd_addr, BT_TRANSPORT_LE))
-        {
-            count ++;
-        }
-    }
-    return count;
 
-}
-/*******************************************************************************
-**
-** Function         btm_update_bg_conn_list
-**
-** Description      This function update the local background connection device list.
-*******************************************************************************/
-BOOLEAN btm_update_bg_conn_list(BOOLEAN to_add, BD_ADDR bd_addr)
+static UINT8 btm_ble_count_dev_in_whitelist(void)
 {
-    tBTM_BLE_CB             *p_cb = &btm_cb.ble_ctr_cb;
-    tBTM_LE_BG_CONN_DEV     *p_bg_dev = &p_cb->bg_dev_list[0], *p_next, *p_cur;
-    UINT8                   i, j;
-    BOOLEAN             ret = FALSE;
-
-    BTM_TRACE_EVENT ("btm_update_bg_conn_list");
-
-    if ((to_add && (p_cb->bg_dev_num == BTM_BLE_MAX_BG_CONN_DEV_NUM || p_cb->num_empty_filter == 0)))
-    {
-        BTM_TRACE_DEBUG("num_empty_filter = %d", p_cb->num_empty_filter);
-        return ret;
-    }
-
-    /* Look for existing device to add/remove attribute */
-    for (i = 0; i < BTM_BLE_MAX_BG_CONN_DEV_NUM; i ++, p_bg_dev ++)
-    {
-        if (p_bg_dev->in_use && memcmp(p_bg_dev->bd_addr, bd_addr, BD_ADDR_LEN) == 0)
-        {
-            if (!to_add)
-            {
-                memset(p_bg_dev, 0, sizeof(tBTM_LE_BG_CONN_DEV));
-                if (p_cb->bg_dev_num < BTM_BLE_MAX_BG_CONN_DEV_NUM)
-                {
-                    /* The entry being removed is not at the highest index of the array: shift */
-                    p_cur = p_bg_dev;
-                    p_next = p_bg_dev + 1;
-                    for (j = i + 1 ;j < BTM_BLE_MAX_BG_CONN_DEV_NUM && p_next->in_use ;
-                                            j ++, p_cur ++, p_next ++ )
-                    {
-                        memcpy(p_cur, p_next, sizeof(tBTM_LE_BG_CONN_DEV));
-                        memset(p_next, 0, sizeof(tBTM_LE_BG_CONN_DEV));
-                    }
-                }
-                p_cb->bg_dev_num --;
-            }
-            ret = TRUE;
-            break;
-        }
-        else if (!p_bg_dev->in_use && to_add)
-        {
-            BTM_TRACE_DEBUG("add new WL entry in bg_dev_list");
-
-            memcpy(p_bg_dev->bd_addr, bd_addr, BD_ADDR_LEN);
-            p_bg_dev->in_use = TRUE;
-            p_cb->bg_dev_num ++;
-
-            ret = TRUE;
-            break;
-        }
-    }
-
-
-    return ret;
+    const uint8_t white_list_size = controller_get_interface()->get_ble_white_list_size();
+    if (white_list_size == 0)
+        return 0;
+    return white_list_size - btm_cb.ble_ctr_cb.white_list_avail_size;
 }
 
 /*******************************************************************************
@@ -379,7 +308,7 @@ BOOLEAN btm_ble_start_auto_conn(BOOLEAN start)
 
     if (start)
     {
-        if (p_cb->conn_state == BLE_CONN_IDLE && btm_ble_count_unconn_dev_in_whitelist() > 0
+        if (p_cb->conn_state == BLE_CONN_IDLE && btm_ble_count_dev_in_whitelist() > 0
             && btm_ble_topology_check(BTM_BLE_STATE_INIT))
         {
             p_cb->wl_state  |= BTM_BLE_WL_INIT;
@@ -493,7 +422,7 @@ BOOLEAN btm_ble_start_select_conn(BOOLEAN start,tBTM_BLE_SEL_CBACK   *p_select_c
                 BTM_TRACE_ERROR("peripheral device cannot initiate passive scan for a selective connection");
                 return FALSE;
             }
-            else if (p_cb->bg_dev_num > 0 && btm_ble_count_unconn_dev_in_whitelist() > 0 )
+            else if (btm_ble_count_dev_in_whitelist() > 0)
             {
 
                 if (!btsnd_hcic_ble_set_scan_enable(TRUE, TRUE)) /* duplicate filtering enabled */
@@ -701,7 +630,7 @@ void btm_ble_enqueue_direct_conn_req(void *p_param)
 ** Returns          TRUE if started, FALSE otherwise
 **
 *******************************************************************************/
-BOOLEAN btm_send_pending_direct_conn(void )
+BOOLEAN btm_send_pending_direct_conn(void)
 {
     tBTM_BLE_CONN_REQ *p_req;
     BOOLEAN     rt = FALSE;

diff --git a/stack/btm/btm_ble_gap.c b/stack/btm/btm_ble_gap.c
index e77f701..46953db 100644 (file)
--- a/stack/btm/btm_ble_gap.c
+++ b/stack/btm/btm_ble_gap.c
@@ -800,14 +800,8 @@ void BTM_BleClearBgConnDev(void)
 *******************************************************************************/
 BOOLEAN BTM_BleUpdateBgConnDev(BOOLEAN add_remove, BD_ADDR   remote_bda)
 {
-    BOOLEAN ret = FALSE;
-    BTM_TRACE_EVENT (" BTM_BleUpdateBgConnDev");
-
-    /* update white list */
-    if (btm_update_bg_conn_list(add_remove, remote_bda))
-        ret = btm_update_dev_to_white_list(add_remove, remote_bda);
-
-    return ret;
+    BTM_TRACE_EVENT("%s() add=%d", __func__, add_remove);
+    return btm_update_dev_to_white_list(add_remove, remote_bda);
 }
 
 /*******************************************************************************

diff --git a/stack/btm/btm_ble_int.h b/stack/btm/btm_ble_int.h
index cb37ff4..9d5c493 100644 (file)
--- a/stack/btm/btm_ble_int.h
+++ b/stack/btm/btm_ble_int.h
@@ -304,11 +304,8 @@ typedef struct
     tBTM_BLE_SEL_CBACK  *p_select_cback;
 
     /* white list information */
-    UINT8                   num_empty_filter;      /* Number of entries in white list */
-    UINT8                   max_filter_entries;    /* Maximum number of entries that can be stored */
+    UINT8                   white_list_avail_size;
     tBTM_BLE_WL_STATE       wl_state;
-    UINT8                   bg_dev_num;
-    tBTM_LE_BG_CONN_DEV     bg_dev_list[BTM_BLE_MAX_BG_CONN_DEV_NUM];
 
     BUFFER_Q                conn_pending_q;
     tBTM_BLE_CONN_ST        conn_state;
@@ -392,7 +389,6 @@ extern UINT8 btm_ble_read_sec_key_size(BD_ADDR bd_addr);
 
 /* white list function */
 extern BOOLEAN btm_update_dev_to_white_list(BOOLEAN to_add, BD_ADDR bd_addr);
-extern BOOLEAN btm_update_bg_conn_list(BOOLEAN to_add, BD_ADDR bd_addr);
 extern void btm_update_scanner_filter_policy(tBTM_BLE_SFP scan_policy);
 extern void btm_update_adv_filter_policy(tBTM_BLE_AFP adv_policy);
 extern void btm_ble_clear_white_list (void);
@@ -400,6 +396,7 @@ extern void btm_read_white_list_size_complete(UINT8 *p, UINT16 evt_len);
 extern void btm_ble_add_2_white_list_complete(UINT8 status);
 extern void btm_ble_remove_from_white_list_complete(UINT8 *p, UINT16 evt_len);
 extern void btm_ble_clear_white_list_complete(UINT8 *p, UINT16 evt_len);
+extern void btm_ble_white_list_init(UINT8 white_list_size);
 
 /* background connection function */
 extern void btm_ble_suspend_bg_conn(void);
@@ -408,7 +405,6 @@ extern void btm_ble_initiate_select_conn(BD_ADDR bda);
 extern BOOLEAN btm_ble_start_auto_conn(BOOLEAN start);
 extern BOOLEAN btm_ble_start_select_conn(BOOLEAN start,tBTM_BLE_SEL_CBACK   *p_select_cback);
 extern BOOLEAN btm_ble_renew_bg_conn_params(BOOLEAN add, BD_ADDR bd_addr);
-extern UINT8 btm_ble_count_unconn_dev_in_whitelist(void);
 extern void btm_write_dir_conn_wl(BD_ADDR target_addr);
 extern void btm_ble_update_mode_operation(UINT8 link_role, BD_ADDR bda, UINT8 status);
 extern BOOLEAN btm_execute_wl_dev_operation(void);

diff --git a/stack/btm/btm_devctl.c b/stack/btm/btm_devctl.c
index 4e46bac..e635cd1 100644 (file)
--- a/stack/btm/btm_devctl.c
+++ b/stack/btm/btm_devctl.c
@@ -162,10 +162,8 @@ static void reset_complete(void *result) {
 
 #if (BLE_INCLUDED == TRUE)
   btm_cb.ble_ctr_cb.conn_state = BLE_CONN_IDLE;
-  btm_cb.ble_ctr_cb.bg_dev_num = 0;
   btm_cb.ble_ctr_cb.bg_conn_type = BTM_BLE_CONN_NONE;
   btm_cb.ble_ctr_cb.p_select_cback = NULL;
-  memset(&btm_cb.ble_ctr_cb.bg_dev_list, 0, (sizeof(tBTM_LE_BG_CONN_DEV)*BTM_BLE_MAX_BG_CONN_DEV_NUM));
   gatt_reset_bgdev_list();
   btm_ble_multi_adv_init();
 #endif
@@ -179,13 +177,14 @@ static void reset_complete(void *result) {
   /* Set up the BLE privacy settings */
   if (controller->supports_ble() && controller->supports_ble_privacy() &&
       controller->get_ble_resolving_list_max_size() > 0) {
-      btm_ble_resolving_list_init (controller->get_ble_resolving_list_max_size());
+      btm_ble_resolving_list_init(controller->get_ble_resolving_list_max_size());
       /* set the default random private address timeout */
       btsnd_hcic_ble_set_rand_priv_addr_timeout(BTM_BLE_PRIVATE_ADDR_INT);
   }
 #endif
 
   if (controller->supports_ble()) {
+    btm_ble_white_list_init(controller->get_ble_white_list_size());
     l2c_link_processs_ble_num_bufs(controller->get_acl_buffer_count_ble());
   }
 #endif