granicus.if.org Git - esp-idf/blob - components/bt/bluedroid/stack/btm/btm_dev.c

   1 /******************************************************************************
   2  *
   3  *  Copyright (C) 1999-2012 Broadcom Corporation
   4  *
   5  *  Licensed under the Apache License, Version 2.0 (the "License");
   6  *  you may not use this file except in compliance with the License.
   7  *  You may obtain a copy of the License at:
   8  *
   9  *  http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  *  Unless required by applicable law or agreed to in writing, software
  12  *  distributed under the License is distributed on an "AS IS" BASIS,
  13  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  *  See the License for the specific language governing permissions and
  15  *  limitations under the License.
  16  *
  17  ******************************************************************************/
  18
  19 /******************************************************************************
  20  *
  21  *  This file contains functions for the Bluetooth Device Manager
  22  *
  23  ******************************************************************************/
  24
  25 #include <stdlib.h>
  26 #include <string.h>
  27 //#include <stdio.h>
  28 #include <stddef.h>
  29
  30 #include "bt_types.h"
  31 #include "controller.h"
  32 #include "gki.h"
  33 #include "hcimsgs.h"
  34 #include "btu.h"
  35 #include "btm_api.h"
  36 #include "btm_int.h"
  37 #include "hcidefs.h"
  38 #include "l2c_api.h"
  39
  40 static tBTM_SEC_DEV_REC *btm_find_oldest_dev (void);
  41
  42 /*******************************************************************************
  43 **
  44 ** Function         BTM_SecAddDevice
  45 **
  46 ** Description      Add/modify device.  This function will be normally called
  47 **                  during host startup to restore all required information
  48 **                  stored in the NVRAM.
  49 **
  50 ** Parameters:      bd_addr          - BD address of the peer
  51 **                  dev_class        - Device Class
  52 **                  bd_name          - Name of the peer device.  NULL if unknown.
  53 **                  features         - Remote device's features (up to 3 pages). NULL if not known
  54 **                  trusted_mask     - Bitwise OR of services that do not
  55 **                                     require authorization. (array of UINT32)
  56 **                  link_key         - Connection link key. NULL if unknown.
  57 **
  58 ** Returns          TRUE if added OK, else FALSE
  59 **
  60 *******************************************************************************/
  61 BOOLEAN BTM_SecAddDevice (BD_ADDR bd_addr, DEV_CLASS dev_class, BD_NAME bd_name,
  62                           UINT8 *features, UINT32 trusted_mask[],
  63                           LINK_KEY link_key, UINT8 key_type, tBTM_IO_CAP io_cap,
  64                           UINT8 pin_length)
  65 {
  66     tBTM_SEC_DEV_REC  *p_dev_rec;
  67     int               i, j;
  68     BOOLEAN           found = FALSE;
  69
  70     BTM_TRACE_API("%s, link key type:%x\n", __FUNCTION__,key_type);
  71     p_dev_rec = btm_find_dev (bd_addr);
  72     if (!p_dev_rec)
  73     {
  74         /* There is no device record, allocate one.
  75          * If we can not find an empty spot for this one, let it fail. */
  76         for (i = 0; i < BTM_SEC_MAX_DEVICE_RECORDS; i++)
  77         {
  78             if (!(btm_cb.sec_dev_rec[i].sec_flags & BTM_SEC_IN_USE))
  79             {
  80                 p_dev_rec = &btm_cb.sec_dev_rec[i];
  81
  82                 /* Mark this record as in use and initialize */
  83                 memset (p_dev_rec, 0, sizeof (tBTM_SEC_DEV_REC));
  84                 p_dev_rec->sec_flags = BTM_SEC_IN_USE;
  85                 memcpy (p_dev_rec->bd_addr, bd_addr, BD_ADDR_LEN);
  86                 p_dev_rec->hci_handle = BTM_GetHCIConnHandle (bd_addr, BT_TRANSPORT_BR_EDR);
  87
  88 #if BLE_INCLUDED == TRUE
  89                 /* use default value for background connection params */
  90                 /* update conn params, use default value for background connection params */
  91                 memset(&p_dev_rec->conn_params, 0xff, sizeof(tBTM_LE_CONN_PRAMS));
  92 #endif
  93                 break;
  94             }
  95         }
  96
  97         if (!p_dev_rec)
  98             return(FALSE);
  99     }
 100
 101     p_dev_rec->bond_type = BOND_TYPE_UNKNOWN;           /* Default value */
 102     p_dev_rec->timestamp = btm_cb.dev_rec_count++;
 103
 104     if (dev_class)
 105         memcpy (p_dev_rec->dev_class, dev_class, DEV_CLASS_LEN);
 106
 107     memset(p_dev_rec->sec_bd_name, 0, sizeof(tBTM_BD_NAME));
 108
 109     if (bd_name && bd_name[0])
 110     {
 111         p_dev_rec->sec_flags |= BTM_SEC_NAME_KNOWN;
 112         BCM_STRNCPY_S ((char *)p_dev_rec->sec_bd_name, sizeof (p_dev_rec->sec_bd_name),
 113             (char *)bd_name, BTM_MAX_REM_BD_NAME_LEN);
 114     }
 115
 116     p_dev_rec->num_read_pages = 0;
 117     if (features)
 118     {
 119         memcpy (p_dev_rec->features, features, sizeof (p_dev_rec->features));
 120         for (i = HCI_EXT_FEATURES_PAGE_MAX; i >= 0; i--)
 121         {
 122             for (j = 0; j < HCI_FEATURE_BYTES_PER_PAGE; j++)
 123             {
 124                 if (p_dev_rec->features[i][j] != 0)
 125                 {
 126                     found = TRUE;
 127                     break;
 128                 }
 129             }
 130             if (found)
 131             {
 132                 p_dev_rec->num_read_pages = i + 1;
 133                 break;
 134             }
 135         }
 136     }
 137     else
 138         memset (p_dev_rec->features, 0, sizeof (p_dev_rec->features));
 139
 140     BTM_SEC_COPY_TRUSTED_DEVICE(trusted_mask, p_dev_rec->trusted_mask);
 141
 142     if (link_key)
 143     {
 144         BTM_TRACE_EVENT ("BTM_SecAddDevice()  BDA: %02x:%02x:%02x:%02x:%02x:%02x\n",
 145                           bd_addr[0], bd_addr[1], bd_addr[2],
 146                           bd_addr[3], bd_addr[4], bd_addr[5]);
 147         p_dev_rec->sec_flags |= BTM_SEC_LINK_KEY_KNOWN;
 148         memcpy (p_dev_rec->link_key, link_key, LINK_KEY_LEN);
 149         p_dev_rec->link_key_type = key_type;
 150         p_dev_rec->pin_code_length = pin_length;
 151
 152         if (pin_length >= 16 ||
 153             key_type == BTM_LKEY_TYPE_AUTH_COMB ||
 154             key_type == BTM_LKEY_TYPE_AUTH_COMB_P_256) {
 155             // Set the fiag if the link key was made by using either a 16 digit
 156             // pin or MITM.
 157             p_dev_rec->sec_flags |= BTM_SEC_16_DIGIT_PIN_AUTHED;
 158         }
 159     }
 160
 161 #if defined(BTIF_MIXED_MODE_INCLUDED) && (BTIF_MIXED_MODE_INCLUDED == TRUE)
 162     if (key_type  < BTM_MAX_PRE_SM4_LKEY_TYPE)
 163         p_dev_rec->sm4 = BTM_SM4_KNOWN;
 164     else
 165         p_dev_rec->sm4 = BTM_SM4_TRUE;
 166 #endif
 167
 168     p_dev_rec->rmt_io_caps = io_cap;
 169     p_dev_rec->device_type |= BT_DEVICE_TYPE_BREDR;
 170
 171     return(TRUE);
 172 }
 173
 174
 175 /*******************************************************************************
 176 **
 177 ** Function         BTM_SecDeleteDevice
 178 **
 179 ** Description      Free resources associated with the device.
 180 **
 181 ** Parameters:      bd_addr          - BD address of the peer
 182 **
 183 ** Returns          TRUE if removed OK, FALSE if not found or ACL link is active
 184 **
 185 *******************************************************************************/
 186 BOOLEAN BTM_SecDeleteDevice (BD_ADDR bd_addr)
 187 {
 188     tBTM_SEC_DEV_REC *p_dev_rec;
 189
 190     if (BTM_IsAclConnectionUp(bd_addr, BT_TRANSPORT_LE) ||
 191         BTM_IsAclConnectionUp(bd_addr, BT_TRANSPORT_BR_EDR))
 192     {
 193         BTM_TRACE_WARNING("%s FAILED: Cannot Delete when connection is active\n", __func__);
 194         return FALSE;
 195     }
 196
 197     if ((p_dev_rec = btm_find_dev(bd_addr)) != NULL)
 198     {
 199         btm_sec_free_dev(p_dev_rec);
 200         /* Tell controller to get rid of the link key, if it has one stored */
 201         BTM_DeleteStoredLinkKey (p_dev_rec->bd_addr, NULL);
 202     }
 203
 204     return TRUE;
 205 }
 206
 207 /*******************************************************************************
 208 **
 209 ** Function         BTM_SecReadDevName
 210 **
 211 ** Description      Looks for the device name in the security database for the
 212 **                  specified BD address.
 213 **
 214 ** Returns          Pointer to the name or NULL
 215 **
 216 *******************************************************************************/
 217 char *BTM_SecReadDevName (BD_ADDR bd_addr)
 218 {
 219     char *p_name = NULL;
 220     tBTM_SEC_DEV_REC *p_srec;
 221
 222     if ((p_srec = btm_find_dev(bd_addr)) != NULL)
 223         p_name = (char *)p_srec->sec_bd_name;
 224
 225     return(p_name);
 226 }
 227
 228 /*******************************************************************************
 229 **
 230 ** Function         btm_sec_alloc_dev
 231 **
 232 ** Description      Look for the record in the device database for the record
 233 **                  with specified address
 234 **
 235 ** Returns          Pointer to the record or NULL
 236 **
 237 *******************************************************************************/
 238 tBTM_SEC_DEV_REC *btm_sec_alloc_dev (BD_ADDR bd_addr)
 239 {
 240     tBTM_SEC_DEV_REC *p_dev_rec = NULL;
 241     tBTM_INQ_INFO    *p_inq_info;
 242     int               i;
 243     DEV_CLASS         old_cod;
 244     int               i_new_entry = BTM_SEC_MAX_DEVICE_RECORDS;
 245     int               i_old_entry = BTM_SEC_MAX_DEVICE_RECORDS;
 246     BTM_TRACE_EVENT ("btm_sec_alloc_dev\n");
 247
 248     for (i = 0; i < BTM_SEC_MAX_DEVICE_RECORDS; i++)
 249     {
 250         /* look for old entry where device details are present */
 251         if (!(btm_cb.sec_dev_rec[i].sec_flags & BTM_SEC_IN_USE) &&
 252              (!memcmp (btm_cb.sec_dev_rec[i].bd_addr, bd_addr, BD_ADDR_LEN)))
 253         {
 254             i_old_entry = i;
 255             BTM_TRACE_EVENT ("btm_sec_alloc_dev  old device found\n");
 256             break;
 257         }
 258     }
 259
 260     for (i = 0; i < BTM_SEC_MAX_DEVICE_RECORDS; i++)
 261     {
 262         if (!(btm_cb.sec_dev_rec[i].sec_flags & BTM_SEC_IN_USE))
 263         {
 264             i_new_entry = i;
 265             break;
 266         }
 267     }
 268
 269     if (i_new_entry == BTM_SEC_MAX_DEVICE_RECORDS) {
 270         p_dev_rec = btm_find_oldest_dev();
 271     }
 272     else {
 273         /* if the old device entry not present go with
 274             new entry */
 275         if(i_old_entry == BTM_SEC_MAX_DEVICE_RECORDS) {
 276             p_dev_rec = &btm_cb.sec_dev_rec[i_new_entry];
 277         }
 278         else {
 279             p_dev_rec = &btm_cb.sec_dev_rec[i_old_entry];
 280             memcpy (old_cod, p_dev_rec->dev_class, DEV_CLASS_LEN);
 281         }
 282     }
 283     memset (p_dev_rec, 0, sizeof (tBTM_SEC_DEV_REC));
 284
 285     /* Retain the old COD for device */
 286     if(i_old_entry != BTM_SEC_MAX_DEVICE_RECORDS) {
 287         BTM_TRACE_EVENT ("btm_sec_alloc_dev restoring cod \n");
 288         memcpy (p_dev_rec->dev_class, old_cod, DEV_CLASS_LEN);
 289
 290     }
 291
 292     p_dev_rec->bond_type = BOND_TYPE_UNKNOWN;           /* Default value */
 293     p_dev_rec->sec_flags = BTM_SEC_IN_USE;
 294
 295     /* Check with the BT manager if details about remote device are known */
 296     /* outgoing connection */
 297     if ((p_inq_info = BTM_InqDbRead(bd_addr)) != NULL)
 298     {
 299         memcpy (p_dev_rec->dev_class, p_inq_info->results.dev_class, DEV_CLASS_LEN);
 300
 301 #if BLE_INCLUDED == TRUE
 302         p_dev_rec->device_type = p_inq_info->results.device_type;
 303         p_dev_rec->ble.ble_addr_type = p_inq_info->results.ble_addr_type;
 304
 305         /* update conn params, use default value for background connection params */
 306         memset(&p_dev_rec->conn_params, 0xff, sizeof(tBTM_LE_CONN_PRAMS));
 307 #endif
 308     }
 309     else
 310     {
 311 #if BLE_INCLUDED == TRUE
 312         /* update conn params, use default value for background connection params */
 313         memset(&p_dev_rec->conn_params, 0xff, sizeof(tBTM_LE_CONN_PRAMS));
 314 #endif
 315
 316         if (!memcmp (bd_addr, btm_cb.connecting_bda, BD_ADDR_LEN))
 317             memcpy (p_dev_rec->dev_class, btm_cb.connecting_dc, DEV_CLASS_LEN);
 318     }
 319
 320     memcpy (p_dev_rec->bd_addr, bd_addr, BD_ADDR_LEN);
 321
 322 #if BLE_INCLUDED == TRUE
 323     p_dev_rec->ble_hci_handle = BTM_GetHCIConnHandle (bd_addr, BT_TRANSPORT_LE);
 324 #endif
 325     p_dev_rec->hci_handle = BTM_GetHCIConnHandle (bd_addr, BT_TRANSPORT_BR_EDR);
 326     p_dev_rec->timestamp = btm_cb.dev_rec_count++;
 327
 328     return(p_dev_rec);
 329 }
 330
 331
 332 /*******************************************************************************
 333 **
 334 ** Function         btm_sec_free_dev
 335 **
 336 ** Description      Mark device record as not used
 337 **
 338 *******************************************************************************/
 339 void btm_sec_free_dev (tBTM_SEC_DEV_REC *p_dev_rec)
 340 {
 341     p_dev_rec->bond_type = BOND_TYPE_UNKNOWN;
 342     p_dev_rec->sec_flags = 0;
 343
 344 #if BLE_INCLUDED == TRUE
 345     /* Clear out any saved BLE keys */
 346     btm_sec_clear_ble_keys (p_dev_rec);
 347 #endif
 348
 349
 350 }
 351
 352 /*******************************************************************************
 353 **
 354 ** Function         btm_dev_support_switch
 355 **
 356 ** Description      This function is called by the L2CAP to check if remote
 357 **                  device supports role switch
 358 **
 359 ** Parameters:      bd_addr       - Address of the peer device
 360 **
 361 ** Returns          TRUE if device is known and role switch is supported
 362 **
 363 *******************************************************************************/
 364 BOOLEAN btm_dev_support_switch (BD_ADDR bd_addr)
 365 {
 366     tBTM_SEC_DEV_REC  *p_dev_rec;
 367     UINT8   xx;
 368     BOOLEAN feature_empty = TRUE;
 369
 370 #if BTM_SCO_INCLUDED == TRUE
 371     /* Role switch is not allowed if a SCO is up */
 372     if (btm_is_sco_active_by_bdaddr(bd_addr))
 373         return(FALSE);
 374 #endif
 375     p_dev_rec = btm_find_dev (bd_addr);
 376     if (p_dev_rec && controller_get_interface()->supports_master_slave_role_switch())
 377     {
 378         if (HCI_SWITCH_SUPPORTED(p_dev_rec->features[HCI_EXT_FEATURES_PAGE_0]))
 379         {
 380             BTM_TRACE_DEBUG("btm_dev_support_switch return TRUE (feature found)\n");
 381             return (TRUE);
 382         }
 383
 384         /* If the feature field is all zero, we never received them */
 385         for (xx = 0 ; xx < BD_FEATURES_LEN ; xx++)
 386         {
 387             if (p_dev_rec->features[HCI_EXT_FEATURES_PAGE_0][xx] != 0x00)
 388             {
 389                 feature_empty = FALSE; /* at least one is != 0 */
 390                 break;
 391             }
 392         }
 393
 394         /* If we don't know peer's capabilities, assume it supports Role-switch */
 395         if (feature_empty)
 396         {
 397             BTM_TRACE_DEBUG("btm_dev_support_switch return TRUE (feature empty)\n");
 398             return (TRUE);
 399         }
 400     }
 401
 402     BTM_TRACE_DEBUG("btm_dev_support_switch return FALSE\n");
 403     return(FALSE);
 404 }
 405
 406 /*******************************************************************************
 407 **
 408 ** Function         btm_find_dev_by_handle
 409 **
 410 ** Description      Look for the record in the device database for the record
 411 **                  with specified handle
 412 **
 413 ** Returns          Pointer to the record or NULL
 414 **
 415 *******************************************************************************/
 416 tBTM_SEC_DEV_REC *btm_find_dev_by_handle (UINT16 handle)
 417 {
 418     tBTM_SEC_DEV_REC *p_dev_rec = &btm_cb.sec_dev_rec[0];
 419     int i;
 420
 421     for (i = 0; i < BTM_SEC_MAX_DEVICE_RECORDS; i++, p_dev_rec++)
 422     {
 423         if ((p_dev_rec->sec_flags & BTM_SEC_IN_USE)
 424             && ((p_dev_rec->hci_handle == handle)
 425 #if BLE_INCLUDED == TRUE
 426             ||(p_dev_rec->ble_hci_handle == handle)
 427 #endif
 428                 ))
 429             return(p_dev_rec);
 430     }
 431     return(NULL);
 432 }
 433
 434 /*******************************************************************************
 435 **
 436 ** Function         btm_find_dev
 437 **
 438 ** Description      Look for the record in the device database for the record
 439 **                  with specified BD address
 440 **
 441 ** Returns          Pointer to the record or NULL
 442 **
 443 *******************************************************************************/
 444 tBTM_SEC_DEV_REC *btm_find_dev(BD_ADDR bd_addr)
 445 {
 446     tBTM_SEC_DEV_REC *p_dev_rec = &btm_cb.sec_dev_rec[0];
 447
 448     if (bd_addr)
 449     {
 450         for (uint8_t i = 0; i < BTM_SEC_MAX_DEVICE_RECORDS; i++, p_dev_rec++)
 451         {
 452             if (p_dev_rec->sec_flags & BTM_SEC_IN_USE)
 453             {
 454                 if (!memcmp (p_dev_rec->bd_addr, bd_addr, BD_ADDR_LEN))
 455                     return(p_dev_rec);
 456
 457 #if BLE_INCLUDED == TRUE
 458                 // If a LE random address is looking for device record
 459                 if (!memcmp(p_dev_rec->ble.pseudo_addr, bd_addr, BD_ADDR_LEN))
 460                     return (p_dev_rec);
 461
 462                 if (btm_ble_addr_resolvable(bd_addr, p_dev_rec))
 463                     return(p_dev_rec);
 464 #endif
 465             }
 466         }
 467     }
 468     return(NULL);
 469 }
 470
 471 /*******************************************************************************
 472 **
 473 ** Function         btm_consolidate_dev
 474 **
 475 ** Description      combine security records if identified as same peer
 476 **
 477 ** Returns          none
 478 **
 479 *******************************************************************************/
 480 void btm_consolidate_dev(tBTM_SEC_DEV_REC *p_target_rec)
 481 {
 482 #if BLE_INCLUDED == TRUE
 483     tBTM_SEC_DEV_REC *p_dev_rec = &btm_cb.sec_dev_rec[0];
 484     tBTM_SEC_DEV_REC temp_rec = *p_target_rec;
 485     BD_ADDR dummy_bda = {0};
 486
 487     BTM_TRACE_DEBUG("%s\n", __func__);
 488
 489     for (uint8_t i = 0; i < BTM_SEC_MAX_DEVICE_RECORDS; i++, p_dev_rec++)
 490     {
 491         if (p_target_rec!= p_dev_rec && p_dev_rec->sec_flags & BTM_SEC_IN_USE)
 492         {
 493             if (!memcmp (p_dev_rec->bd_addr, p_target_rec->bd_addr, BD_ADDR_LEN))
 494             {
 495                 memcpy(p_target_rec, p_dev_rec, sizeof(tBTM_SEC_DEV_REC));
 496                 p_target_rec->ble = temp_rec.ble;
 497                 p_target_rec->ble_hci_handle = temp_rec.ble_hci_handle;
 498                 p_target_rec->enc_key_size = temp_rec.enc_key_size;
 499                 p_target_rec->conn_params = temp_rec.conn_params;
 500                 p_target_rec->device_type |= temp_rec.device_type;
 501                 p_target_rec->sec_flags |= temp_rec.sec_flags;
 502
 503                 p_target_rec->new_encryption_key_is_p256 = temp_rec.new_encryption_key_is_p256;
 504                 p_target_rec->no_smp_on_br = temp_rec.no_smp_on_br;
 505                 p_target_rec->bond_type = temp_rec.bond_type;
 506                 /* mark the combined record as unused */
 507                 p_dev_rec->sec_flags &= ~BTM_SEC_IN_USE;
 508                 p_dev_rec->bond_type = BOND_TYPE_UNKNOWN;
 509                 break;
 510             }
 511
 512             /* an RPA device entry is a duplicate of the target record */
 513             if (btm_ble_addr_resolvable(p_dev_rec->bd_addr, p_target_rec))
 514             {
 515                 if (memcmp(p_target_rec->ble.pseudo_addr, p_dev_rec->bd_addr, BD_ADDR_LEN) == 0)
 516                 {
 517                     p_target_rec->ble.ble_addr_type = p_dev_rec->ble.ble_addr_type;
 518                     p_target_rec->device_type |= p_dev_rec->device_type;
 519                     p_dev_rec->sec_flags &= ~BTM_SEC_IN_USE;
 520                     p_dev_rec->bond_type = BOND_TYPE_UNKNOWN;
 521                 }
 522                 break;
 523             }
 524         }
 525     }
 526 #endif
 527 }
 528
 529 /*******************************************************************************
 530 **
 531 ** Function         btm_find_or_alloc_dev
 532 **
 533 ** Description      Look for the record in the device database for the record
 534 **                  with specified BD address
 535 **
 536 ** Returns          Pointer to the record or NULL
 537 **
 538 *******************************************************************************/
 539 tBTM_SEC_DEV_REC *btm_find_or_alloc_dev (BD_ADDR bd_addr)
 540 {
 541     tBTM_SEC_DEV_REC *p_dev_rec;
 542     BTM_TRACE_EVENT ("btm_find_or_alloc_dev\n");
 543     if ((p_dev_rec = btm_find_dev (bd_addr)) == NULL)
 544     {
 545
 546         /* Allocate a new device record or reuse the oldest one */
 547         p_dev_rec = btm_sec_alloc_dev (bd_addr);
 548     }
 549     return(p_dev_rec);
 550 }
 551
 552 /*******************************************************************************
 553 **
 554 ** Function         btm_find_oldest_dev
 555 **
 556 ** Description      Locates the oldest device in use. It first looks for
 557 **                  the oldest non-paired device.  If all devices are paired it
 558 **                  deletes the oldest paired device.
 559 **
 560 ** Returns          Pointer to the record or NULL
 561 **
 562 *******************************************************************************/
 563 tBTM_SEC_DEV_REC *btm_find_oldest_dev (void)
 564 {
 565     tBTM_SEC_DEV_REC *p_dev_rec = &btm_cb.sec_dev_rec[0];
 566     tBTM_SEC_DEV_REC *p_oldest = p_dev_rec;
 567     UINT32       ot = 0xFFFFFFFF;
 568     int i;
 569
 570     /* First look for the non-paired devices for the oldest entry */
 571     for (i = 0; i < BTM_SEC_MAX_DEVICE_RECORDS; i++, p_dev_rec++)
 572     {
 573         if (((p_dev_rec->sec_flags & BTM_SEC_IN_USE) == 0)
 574             || ((p_dev_rec->sec_flags & (BTM_SEC_LINK_KEY_KNOWN |BTM_SEC_LE_LINK_KEY_KNOWN)) != 0))
 575             continue; /* Device is paired so skip it */
 576
 577         if (p_dev_rec->timestamp < ot)
 578         {
 579             p_oldest = p_dev_rec;
 580             ot       = p_dev_rec->timestamp;
 581         }
 582     }
 583
 584     if (ot != 0xFFFFFFFF)
 585         return(p_oldest);
 586
 587     /* All devices are paired; find the oldest */
 588     p_dev_rec = &btm_cb.sec_dev_rec[0];
 589     for (i = 0; i < BTM_SEC_MAX_DEVICE_RECORDS; i++, p_dev_rec++)
 590     {
 591         if ((p_dev_rec->sec_flags & BTM_SEC_IN_USE) == 0)
 592             continue;
 593
 594         if (p_dev_rec->timestamp < ot)
 595         {
 596             p_oldest = p_dev_rec;
 597             ot       = p_dev_rec->timestamp;
 598         }
 599     }
 600     return(p_oldest);
 601 }
 602
 603 /*******************************************************************************
 604 **
 605 ** Function         btm_get_bond_type_dev
 606 **
 607 ** Description      Get the bond type for a device in the device database
 608 **                  with specified BD address
 609 **
 610 ** Returns          The device bond type if known, otherwise BOND_TYPE_UNKNOWN
 611 **
 612 *******************************************************************************/
 613 tBTM_BOND_TYPE btm_get_bond_type_dev(BD_ADDR bd_addr)
 614 {
 615     tBTM_SEC_DEV_REC *p_dev_rec = btm_find_dev(bd_addr);
 616
 617     if (p_dev_rec == NULL)
 618         return BOND_TYPE_UNKNOWN;
 619
 620     return p_dev_rec->bond_type;
 621 }
 622
 623 /*******************************************************************************
 624 **
 625 ** Function         btm_set_bond_type_dev
 626 **
 627 ** Description      Set the bond type for a device in the device database
 628 **                  with specified BD address
 629 **
 630 ** Returns          TRUE on success, otherwise FALSE
 631 **
 632 *******************************************************************************/
 633 BOOLEAN btm_set_bond_type_dev(BD_ADDR bd_addr, tBTM_BOND_TYPE bond_type)
 634 {
 635     tBTM_SEC_DEV_REC *p_dev_rec = btm_find_dev(bd_addr);
 636
 637     if (p_dev_rec == NULL)
 638         return FALSE;
 639
 640     p_dev_rec->bond_type = bond_type;
 641     return TRUE;
 642 }