SMP: Use tSMP_INT_DATA instead of void

Test: pairing sanity
Change-Id: Ie3a2f94ddd718344219760cef7f1477bd4d09e00

diff --git a/stack/smp/smp_act.cc b/stack/smp/smp_act.cc
index 1ce5264..a867906 100644 (file)
--- a/stack/smp/smp_act.cc
+++ b/stack/smp/smp_act.cc
@@ -47,7 +47,9 @@ static bool pts_test_send_authentication_complete_failure(tSMP_CB* p_cb) {
   if (reason == SMP_PAIR_AUTH_FAIL || reason == SMP_PAIR_FAIL_UNKNOWN ||
       reason == SMP_PAIR_NOT_SUPPORT || reason == SMP_PASSKEY_ENTRY_FAIL ||
       reason == SMP_REPEATED_ATTEMPTS) {
-    smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &reason);
+    tSMP_INT_DATA smp_int_data;
+    smp_int_data.status = reason;
+    smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &smp_int_data);
     return true;
   }
   return false;
@@ -215,8 +217,8 @@ void smp_send_app_cback(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
  * Description  pairing failure to peer device if needed.
  ******************************************************************************/
 void smp_send_pair_fail(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
-  p_cb->status = *(uint8_t*)p_data;
-  p_cb->failure = *(uint8_t*)p_data;
+  p_cb->status = p_data->status;
+  p_cb->failure = p_data->status;
 
   SMP_TRACE_DEBUG("%s: status=%d failure=%d ", __func__, p_cb->status,
                   p_cb->failure);
@@ -320,7 +322,7 @@ void smp_send_dhkey_check(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
  * Description send Keypress Notification command to the peer
  ******************************************************************************/
 void smp_send_keypress_notification(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
-  p_cb->local_keypress_notification = *(uint8_t*)p_data;
+  p_cb->local_keypress_notification = p_data->status;
   smp_send_cmd(SMP_OPCODE_PAIR_KEYPR_NOTIF, p_cb);
 }
 
@@ -411,7 +413,6 @@ void smp_send_ltk_reply(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
 void smp_proc_sec_req(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
   tBTM_LE_AUTH_REQ auth_req = *(tBTM_LE_AUTH_REQ*)p_data;
   tBTM_BLE_SEC_REQ_ACT sec_req_act;
-  uint8_t reason;
 
   SMP_TRACE_DEBUG("%s: auth_req=0x%x", __func__, auth_req);
 
@@ -434,8 +435,9 @@ void smp_proc_sec_req(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
       /* respond to non SC pairing request as failure in SC only mode */
       if (p_cb->secure_connections_only_mode_required &&
           (auth_req & SMP_SC_SUPPORT_BIT) == 0) {
-        reason = SMP_PAIR_AUTH_FAIL;
-        smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &reason);
+        tSMP_INT_DATA smp_int_data;
+        smp_int_data.status = SMP_PAIR_AUTH_FAIL;
+        smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &smp_int_data);
       } else {
         /* initialize local i/r key to be default keys */
         p_cb->peer_auth_req = auth_req;
@@ -459,7 +461,7 @@ void smp_proc_sec_req(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
  * Description  process security grant.
  ******************************************************************************/
 void smp_proc_sec_grant(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
-  uint8_t res = *(uint8_t*)p_data;
+  uint8_t res = p_data->status;
   SMP_TRACE_DEBUG("%s", __func__);
   if (res != SMP_SUCCESS) {
     smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, p_data);
@@ -476,7 +478,7 @@ void smp_proc_sec_grant(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
  ******************************************************************************/
 void smp_proc_pair_fail(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
   SMP_TRACE_DEBUG("%s", __func__);
-  p_cb->status = *(uint8_t*)p_data;
+  p_cb->status = p_data->status;
 
   /* Cancel pending auth complete timer if set */
   alarm_cancel(p_cb->delayed_auth_timer_ent);
@@ -487,8 +489,7 @@ void smp_proc_pair_fail(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
  * Description  Process the SMP pairing request/response from peer device
  ******************************************************************************/
 void smp_proc_pair_cmd(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
-  uint8_t* p = (uint8_t*)p_data;
-  uint8_t reason = SMP_ENC_KEY_SIZE;
+  uint8_t* p = p_data->p_data;
   tBTM_SEC_DEV_REC* p_dev_rec = btm_find_dev(p_cb->pairing_bda);
 
   SMP_TRACE_DEBUG("%s", __func__);
@@ -506,8 +507,9 @@ void smp_proc_pair_cmd(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
   STREAM_TO_UINT8(p_cb->peer_r_key, p);
 
   if (smp_command_has_invalid_parameters(p_cb)) {
-    reason = SMP_INVALID_PARAMETERS;
-    smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &reason);
+    tSMP_INT_DATA smp_int_data;
+    smp_int_data.status = SMP_INVALID_PARAMETERS;
+    smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &smp_int_data);
     return;
   }
 
@@ -535,8 +537,9 @@ void smp_proc_pair_cmd(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
         SMP_TRACE_ERROR(
             "%s: pairing failed - slave requires secure connection only mode",
             __func__);
-        reason = SMP_PAIR_AUTH_FAIL;
-        smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &reason);
+        tSMP_INT_DATA smp_int_data;
+        smp_int_data.status = SMP_PAIR_AUTH_FAIL;
+        smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &smp_int_data);
         return;
       }
 
@@ -556,8 +559,9 @@ void smp_proc_pair_cmd(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
       SMP_TRACE_ERROR(
           "Master requires secure connection only mode "
           "but it can't be provided -> Master fails pairing");
-      reason = SMP_PAIR_AUTH_FAIL;
-      smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &reason);
+      tSMP_INT_DATA smp_int_data;
+      smp_int_data.status = SMP_PAIR_AUTH_FAIL;
+      smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &smp_int_data);
       return;
     }
 
@@ -574,13 +578,14 @@ void smp_proc_pair_cmd(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
  * Description  process pairing confirm from peer device
  ******************************************************************************/
 void smp_proc_confirm(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
-  uint8_t* p = (uint8_t*)p_data;
-  uint8_t reason = SMP_INVALID_PARAMETERS;
+  uint8_t* p = p_data->p_data;
 
   SMP_TRACE_DEBUG("%s", __func__);
 
   if (smp_command_has_invalid_parameters(p_cb)) {
-    smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &reason);
+    tSMP_INT_DATA smp_int_data;
+    smp_int_data.status = SMP_INVALID_PARAMETERS;
+    smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &smp_int_data);
     return;
   }
 
@@ -597,13 +602,14 @@ void smp_proc_confirm(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
  * Description  process pairing initializer from peer device
  ******************************************************************************/
 void smp_proc_init(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
-  uint8_t* p = (uint8_t*)p_data;
-  uint8_t reason = SMP_INVALID_PARAMETERS;
+  uint8_t* p = p_data->p_data;
 
   SMP_TRACE_DEBUG("%s", __func__);
 
   if (smp_command_has_invalid_parameters(p_cb)) {
-    smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &reason);
+    tSMP_INT_DATA smp_int_data;
+    smp_int_data.status = SMP_INVALID_PARAMETERS;
+    smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &smp_int_data);
     return;
   }
 
@@ -616,13 +622,14 @@ void smp_proc_init(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
  * Description  process pairing random (nonce) from peer device
  ******************************************************************************/
 void smp_proc_rand(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
-  uint8_t* p = (uint8_t*)p_data;
-  uint8_t reason = SMP_INVALID_PARAMETERS;
+  uint8_t* p = p_data->p_data;
 
   SMP_TRACE_DEBUG("%s", __func__);
 
   if (smp_command_has_invalid_parameters(p_cb)) {
-    smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &reason);
+    tSMP_INT_DATA smp_int_data;
+    smp_int_data.status = SMP_INVALID_PARAMETERS;
+    smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &smp_int_data);
     return;
   }
 
@@ -639,13 +646,14 @@ void smp_proc_rand(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
  *
  ******************************************************************************/
 void smp_process_pairing_public_key(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
-  uint8_t* p = (uint8_t*)p_data;
-  uint8_t reason = SMP_INVALID_PARAMETERS;
+  uint8_t* p = p_data->p_data;
 
   SMP_TRACE_DEBUG("%s", __func__);
 
   if (smp_command_has_invalid_parameters(p_cb)) {
-    smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &reason);
+    tSMP_INT_DATA smp_int_data;
+    smp_int_data.status = SMP_INVALID_PARAMETERS;
+    smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &smp_int_data);
     return;
   }
 
@@ -661,13 +669,14 @@ void smp_process_pairing_public_key(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
  * Description  process pairing commitment from peer device
  ******************************************************************************/
 void smp_process_pairing_commitment(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
-  uint8_t* p = (uint8_t*)p_data;
-  uint8_t reason = SMP_INVALID_PARAMETERS;
+  uint8_t* p = p_data->p_data;
 
   SMP_TRACE_DEBUG("%s", __func__);
 
   if (smp_command_has_invalid_parameters(p_cb)) {
-    smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &reason);
+    tSMP_INT_DATA smp_int_data;
+    smp_int_data.status = SMP_INVALID_PARAMETERS;
+    smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &smp_int_data);
     return;
   }
 
@@ -683,13 +692,14 @@ void smp_process_pairing_commitment(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
  * Description  process DHKey Check from peer device
  ******************************************************************************/
 void smp_process_dhkey_check(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
-  uint8_t* p = (uint8_t*)p_data;
-  uint8_t reason = SMP_INVALID_PARAMETERS;
+  uint8_t* p = p_data->p_data;
 
   SMP_TRACE_DEBUG("%s", __func__);
 
   if (smp_command_has_invalid_parameters(p_cb)) {
-    smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &reason);
+    tSMP_INT_DATA smp_int_data;
+    smp_int_data.status = SMP_INVALID_PARAMETERS;
+    smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &smp_int_data);
     return;
   }
 
@@ -705,14 +715,15 @@ void smp_process_dhkey_check(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
  * Description  process pairing keypress notification from peer device
  ******************************************************************************/
 void smp_process_keypress_notification(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
-  uint8_t* p = (uint8_t*)p_data;
-  uint8_t reason = SMP_INVALID_PARAMETERS;
+  uint8_t* p = p_data->p_data;
 
   SMP_TRACE_DEBUG("%s", __func__);
-  p_cb->status = *(uint8_t*)p_data;
+  p_cb->status = p_data->status;
 
   if (smp_command_has_invalid_parameters(p_cb)) {
-    smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &reason);
+    tSMP_INT_DATA smp_int_data;
+    smp_int_data.status = SMP_INVALID_PARAMETERS;
+    smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &smp_int_data);
     return;
   }
 
@@ -730,15 +741,15 @@ void smp_process_keypress_notification(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
  *              BR/EDR transport.
  ******************************************************************************/
 void smp_br_process_pairing_command(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
-  uint8_t* p = (uint8_t*)p_data;
-  uint8_t reason = SMP_ENC_KEY_SIZE;
+  uint8_t* p = p_data->p_data;
   tBTM_SEC_DEV_REC* p_dev_rec = btm_find_dev(p_cb->pairing_bda);
 
   SMP_TRACE_DEBUG("%s", __func__);
   /* rejecting BR pairing request over non-SC BR link */
   if (!p_dev_rec->new_encryption_key_is_p256 && p_cb->role == HCI_ROLE_SLAVE) {
-    reason = SMP_XTRANS_DERIVE_NOT_ALLOW;
-    smp_br_state_machine_event(p_cb, SMP_BR_AUTH_CMPL_EVT, &reason);
+    tSMP_INT_DATA smp_int_data;
+    smp_int_data.status = SMP_XTRANS_DERIVE_NOT_ALLOW;
+    smp_br_state_machine_event(p_cb, SMP_BR_AUTH_CMPL_EVT, &smp_int_data);
     return;
   }
 
@@ -756,8 +767,9 @@ void smp_br_process_pairing_command(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
   STREAM_TO_UINT8(p_cb->peer_r_key, p);
 
   if (smp_command_has_invalid_parameters(p_cb)) {
-    reason = SMP_INVALID_PARAMETERS;
-    smp_br_state_machine_event(p_cb, SMP_BR_AUTH_CMPL_EVT, &reason);
+    tSMP_INT_DATA smp_int_data;
+    smp_int_data.status = SMP_INVALID_PARAMETERS;
+    smp_br_state_machine_event(p_cb, SMP_BR_AUTH_CMPL_EVT, &smp_int_data);
     return;
   }
 
@@ -789,9 +801,8 @@ void smp_br_process_pairing_command(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
  * Description  process security grant in case of pairing over BR/EDR transport.
  ******************************************************************************/
 void smp_br_process_security_grant(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
-  uint8_t res = *(uint8_t*)p_data;
   SMP_TRACE_DEBUG("%s", __func__);
-  if (res != SMP_SUCCESS) {
+  if (p_data->status != SMP_SUCCESS) {
     smp_br_state_machine_event(p_cb, SMP_BR_AUTH_CMPL_EVT, p_data);
   } else {
     /* otherwise, start pairing; send IO request callback */
@@ -805,8 +816,6 @@ void smp_br_process_security_grant(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
  *              before starting the distribution/derivation
  ******************************************************************************/
 void smp_br_check_authorization_request(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
-  uint8_t reason = SMP_SUCCESS;
-
   SMP_TRACE_DEBUG("%s rcvs i_keys=0x%x r_keys=0x%x (i-initiator r-responder)",
                   __func__, p_cb->local_i_key, p_cb->local_r_key);
 
@@ -840,7 +849,9 @@ void smp_br_check_authorization_request(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
     if (p_cb->role == HCI_ROLE_MASTER && p_cb->local_r_key == 0)
       smp_key_distribution_by_transport(p_cb, NULL);
   } else {
-    smp_br_state_machine_event(p_cb, SMP_BR_AUTH_CMPL_EVT, &reason);
+    tSMP_INT_DATA smp_int_data;
+    smp_int_data.status = SMP_SUCCESS;
+    smp_br_state_machine_event(p_cb, SMP_BR_AUTH_CMPL_EVT, &smp_int_data);
   }
 }
 
@@ -850,7 +861,6 @@ void smp_br_check_authorization_request(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
  *              used.
  ******************************************************************************/
 void smp_br_select_next_key(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
-  uint8_t reason = SMP_SUCCESS;
   SMP_TRACE_DEBUG("%s role=%d (0-master) r_keys=0x%x i_keys=0x%x", __func__,
                   p_cb->role, p_cb->local_r_key, p_cb->local_i_key);
 
@@ -862,10 +872,13 @@ void smp_br_select_next_key(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
   if (!p_cb->local_i_key && !p_cb->local_r_key) {
     /* state check to prevent re-entrance */
     if (smp_get_br_state() == SMP_BR_STATE_BOND_PENDING) {
-      if (p_cb->total_tx_unacked == 0)
-        smp_br_state_machine_event(p_cb, SMP_BR_AUTH_CMPL_EVT, &reason);
-      else
+      if (p_cb->total_tx_unacked == 0) {
+        tSMP_INT_DATA smp_int_data;
+        smp_int_data.status = SMP_SUCCESS;
+        smp_br_state_machine_event(p_cb, SMP_BR_AUTH_CMPL_EVT, &smp_int_data);
+      } else {
         p_cb->wait_for_authorization_complete = true;
+      }
     }
   }
 }
@@ -875,7 +888,7 @@ void smp_br_select_next_key(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
  * Description  process encryption information from peer device
  ******************************************************************************/
 void smp_proc_enc_info(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
-  uint8_t* p = (uint8_t*)p_data;
+  uint8_t* p = p_data->p_data;
 
   SMP_TRACE_DEBUG("%s", __func__);
   STREAM_TO_ARRAY(p_cb->ltk, p, BT_OCTET16_LEN);
@@ -887,7 +900,7 @@ void smp_proc_enc_info(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
  * Description  process master ID from slave device
  ******************************************************************************/
 void smp_proc_master_id(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
-  uint8_t* p = (uint8_t*)p_data;
+  uint8_t* p = p_data->p_data;
   tBTM_LE_PENC_KEYS le_key;
 
   SMP_TRACE_DEBUG("%s", __func__);
@@ -914,7 +927,7 @@ void smp_proc_master_id(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
  * Description  process identity information from peer device
  ******************************************************************************/
 void smp_proc_id_info(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
-  uint8_t* p = (uint8_t*)p_data;
+  uint8_t* p = p_data->p_data;
 
   SMP_TRACE_DEBUG("%s", __func__);
   STREAM_TO_ARRAY(p_cb->tk, p, BT_OCTET16_LEN); /* reuse TK for IRK */
@@ -926,7 +939,7 @@ void smp_proc_id_info(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
  * Description  process identity address from peer device
  ******************************************************************************/
 void smp_proc_id_addr(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
-  uint8_t* p = (uint8_t*)p_data;
+  uint8_t* p = p_data->p_data;
   tBTM_LE_PID_KEYS pid_key;
 
   SMP_TRACE_DEBUG("%s", __func__);
@@ -963,7 +976,7 @@ void smp_proc_srk_info(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
   le_key.sec_level = p_cb->sec_level;
 
   /* get peer CSRK */
-  maybe_non_aligned_memcpy(le_key.csrk, p_data, BT_OCTET16_LEN);
+  maybe_non_aligned_memcpy(le_key.csrk, p_data->p_data, BT_OCTET16_LEN);
 
   /* initialize the peer counter */
   le_key.counter = 0;
@@ -980,8 +993,6 @@ void smp_proc_srk_info(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
  * Description  process compare value
  ******************************************************************************/
 void smp_proc_compare(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
-  uint8_t reason;
-
   SMP_TRACE_DEBUG("%s", __func__);
   if (!memcmp(p_cb->rconfirm, p_data->key.p_data, BT_OCTET16_LEN)) {
     /* compare the max encryption key size, and save the smaller one for the
@@ -1000,8 +1011,10 @@ void smp_proc_compare(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
     }
 
   } else {
-    reason = p_cb->failure = SMP_CONFIRM_VALUE_ERR;
-    smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &reason);
+    tSMP_INT_DATA smp_int_data;
+    smp_int_data.status = SMP_CONFIRM_VALUE_ERR;
+    p_cb->failure = SMP_CONFIRM_VALUE_ERR;
+    smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &smp_int_data);
   }
 }
 
@@ -1029,7 +1042,6 @@ void smp_proc_sl_key(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
  ******************************************************************************/
 void smp_start_enc(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
   tBTM_STATUS cmd;
-  uint8_t reason = SMP_ENC_FAIL;
 
   SMP_TRACE_DEBUG("%s", __func__);
   if (p_data != NULL)
@@ -1037,8 +1049,11 @@ void smp_start_enc(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
   else
     cmd = btm_ble_start_encrypt(p_cb->pairing_bda, false, NULL);
 
-  if (cmd != BTM_CMD_STARTED && cmd != BTM_BUSY)
-    smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &reason);
+  if (cmd != BTM_CMD_STARTED && cmd != BTM_BUSY) {
+    tSMP_INT_DATA smp_int_data;
+    smp_int_data.status = SMP_ENC_FAIL;
+    smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &smp_int_data);
+  }
 }
 
 /*******************************************************************************
@@ -1056,11 +1071,12 @@ void smp_proc_discard(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
  * Description   encryption success
  ******************************************************************************/
 void smp_enc_cmpl(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
-  uint8_t enc_enable = *(uint8_t*)p_data;
-  uint8_t reason = enc_enable ? SMP_SUCCESS : SMP_ENC_FAIL;
+  uint8_t enc_enable = p_data->status;
 
   SMP_TRACE_DEBUG("%s", __func__);
-  smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &reason);
+  tSMP_INT_DATA smp_int_data;
+  smp_int_data.status = enc_enable ? SMP_SUCCESS : SMP_ENC_FAIL;
+  smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &smp_int_data);
 }
 
 /*******************************************************************************
@@ -1068,8 +1084,7 @@ void smp_enc_cmpl(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
  * Description  check authentication request
  ******************************************************************************/
 void smp_check_auth_req(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
-  uint8_t enc_enable = *(uint8_t*)p_data;
-  uint8_t reason = enc_enable ? SMP_SUCCESS : SMP_ENC_FAIL;
+  uint8_t enc_enable = p_data->status;
 
   SMP_TRACE_DEBUG(
       "%s rcvs enc_enable=%d i_keys=0x%x r_keys=0x%x (i-initiator r-responder)",
@@ -1106,16 +1121,21 @@ void smp_check_auth_req(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
          (p_cb->loc_auth_req & SMP_AUTH_BOND)) &&*/
         (p_cb->local_i_key || p_cb->local_r_key)) {
       smp_sm_event(p_cb, SMP_BOND_REQ_EVT, NULL);
-    } else
-      smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &reason);
+    } else {
+      tSMP_INT_DATA smp_int_data;
+      smp_int_data.status = enc_enable ? SMP_SUCCESS : SMP_ENC_FAIL;
+      smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &smp_int_data);
+    }
   } else if (enc_enable == 0) {
+    tSMP_INT_DATA smp_int_data;
+    smp_int_data.status = enc_enable ? SMP_SUCCESS : SMP_ENC_FAIL;
     /* if failed for encryption after pairing, send callback */
     if (p_cb->flags & SMP_PAIR_FLAG_ENC_AFTER_PAIR)
-      smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &reason);
+      smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &smp_int_data);
     /* if enc failed for old security information */
     /* if master device, clean up and abck to idle; slave device do nothing */
     else if (p_cb->role == HCI_ROLE_MASTER) {
-      smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &reason);
+      smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &smp_int_data);
     }
   }
 }
@@ -1190,10 +1210,8 @@ void smp_key_distribution(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
  *
  ******************************************************************************/
 void smp_decide_association_model(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
-  uint8_t failure = SMP_UNKNOWN_IO_CAP;
   uint8_t int_evt = 0;
-  tSMP_KEY key;
-  tSMP_INT_DATA* p = NULL;
+  tSMP_INT_DATA smp_int_data;
 
   SMP_TRACE_DEBUG("%s Association Model = %d", __func__,
                   p_cb->selected_association_model);
@@ -1205,17 +1223,17 @@ void smp_decide_association_model(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
           ((p_cb->loc_auth_req & SMP_AUTH_YN_BIT) == 0)) {
         SMP_TRACE_ERROR(
             "IO capability does not meet authentication requirement");
-        failure = SMP_PAIR_AUTH_FAIL;
-        p = (tSMP_INT_DATA*)&failure;
+        smp_int_data.status = SMP_PAIR_AUTH_FAIL;
         int_evt = SMP_AUTH_CMPL_EVT;
       } else {
         p_cb->sec_level = SMP_SEC_UNAUTHENTICATE;
         SMP_TRACE_EVENT("p_cb->sec_level =%d (SMP_SEC_UNAUTHENTICATE) ",
                         p_cb->sec_level);
 
+        tSMP_KEY key;
         key.key_type = SMP_KEY_TYPE_TK;
         key.p_data = p_cb->tk;
-        p = (tSMP_INT_DATA*)&key;
+        smp_int_data.key = key;
 
         memset(p_cb->tk, 0, BT_OCTET16_LEN);
         /* TK, ready  */
@@ -1260,7 +1278,7 @@ void smp_decide_association_model(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
 
     case SMP_MODEL_OUT_OF_RANGE:
       SMP_TRACE_ERROR("Association Model = SMP_MODEL_OUT_OF_RANGE (failed)");
-      p = (tSMP_INT_DATA*)&failure;
+      smp_int_data.status = SMP_UNKNOWN_IO_CAP;
       int_evt = SMP_AUTH_CMPL_EVT;
       break;
 
@@ -1268,12 +1286,12 @@ void smp_decide_association_model(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
       SMP_TRACE_ERROR(
           "Association Model = %d (SOMETHING IS WRONG WITH THE CODE)",
           p_cb->selected_association_model);
-      p = (tSMP_INT_DATA*)&failure;
+      smp_int_data.status = SMP_UNKNOWN_IO_CAP;
       int_evt = SMP_AUTH_CMPL_EVT;
   }
 
   SMP_TRACE_EVENT("sec_level=%d ", p_cb->sec_level);
-  if (int_evt) smp_sm_event(p_cb, int_evt, p);
+  if (int_evt) smp_sm_event(p_cb, int_evt, &smp_int_data);
 }
 
 /*******************************************************************************
@@ -1281,7 +1299,6 @@ void smp_decide_association_model(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
  * Description  process IO response for a slave device.
  ******************************************************************************/
 void smp_process_io_response(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
-  uint8_t reason = SMP_PAIR_AUTH_FAIL;
 
   SMP_TRACE_DEBUG("%s", __func__);
   if (p_cb->flags & SMP_PAIR_FLAGS_WE_STARTED_DD) {
@@ -1299,7 +1316,9 @@ void smp_process_io_response(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
       SMP_TRACE_ERROR(
           "Slave requires secure connection only mode "
           "but it can't be provided -> Slave fails pairing");
-      smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &reason);
+      tSMP_INT_DATA smp_int_data;
+      smp_int_data.status = SMP_PAIR_AUTH_FAIL;
+      smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &smp_int_data);
       return;
     }
 
@@ -1524,15 +1543,15 @@ void smp_process_local_nonce(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
  * Note         It is supposed to be called in SC phase1.
  ******************************************************************************/
 void smp_process_peer_nonce(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
-  uint8_t reason;
-
   SMP_TRACE_DEBUG("%s start ", __func__);
 
   // PTS Testing failure modes
   if (p_cb->cert_failure == SMP_CONFIRM_VALUE_ERR) {
     SMP_TRACE_ERROR("%s failure case = %d", __func__, p_cb->cert_failure);
-    reason = p_cb->failure = SMP_CONFIRM_VALUE_ERR;
-    smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &reason);
+    tSMP_INT_DATA smp_int_data;
+    smp_int_data.status = SMP_CONFIRM_VALUE_ERR;
+    p_cb->failure = SMP_CONFIRM_VALUE_ERR;
+    smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &smp_int_data);
     return;
   }
   // PTS Testing failure modes (for LT)
@@ -1540,8 +1559,10 @@ void smp_process_peer_nonce(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
       (p_cb->selected_association_model == SMP_MODEL_SEC_CONN_JUSTWORKS) &&
       (p_cb->role == HCI_ROLE_SLAVE)) {
     SMP_TRACE_ERROR("%s failure case = %d", __func__, p_cb->cert_failure);
-    reason = p_cb->failure = SMP_NUMERIC_COMPAR_FAIL;
-    smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &reason);
+    tSMP_INT_DATA smp_int_data;
+    smp_int_data.status = SMP_NUMERIC_COMPAR_FAIL;
+    p_cb->failure = SMP_NUMERIC_COMPAR_FAIL;
+    smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &smp_int_data);
     return;
   }
 
@@ -1551,8 +1572,10 @@ void smp_process_peer_nonce(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
       /* in these models only master receives commitment */
       if (p_cb->role == HCI_ROLE_MASTER) {
         if (!smp_check_commitment(p_cb)) {
-          reason = p_cb->failure = SMP_CONFIRM_VALUE_ERR;
-          smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &reason);
+          tSMP_INT_DATA smp_int_data;
+          smp_int_data.status = SMP_CONFIRM_VALUE_ERR;
+          p_cb->failure = SMP_CONFIRM_VALUE_ERR;
+          smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &smp_int_data);
           break;
         }
       } else {
@@ -1573,8 +1596,10 @@ void smp_process_peer_nonce(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
     case SMP_MODEL_SEC_CONN_PASSKEY_DISP:
       if (!smp_check_commitment(p_cb) &&
           p_cb->cert_failure != SMP_NUMERIC_COMPAR_FAIL) {
-        reason = p_cb->failure = SMP_CONFIRM_VALUE_ERR;
-        smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &reason);
+        tSMP_INT_DATA smp_int_data;
+        smp_int_data.status = SMP_CONFIRM_VALUE_ERR;
+        p_cb->failure = SMP_CONFIRM_VALUE_ERR;
+        smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &smp_int_data);
         break;
       }
 
@@ -1613,14 +1638,15 @@ void smp_process_peer_nonce(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
  *              received from the peer DHKey check value.
  ******************************************************************************/
 void smp_match_dhkey_checks(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
-  uint8_t reason = SMP_DHKEY_CHK_FAIL;
 
   SMP_TRACE_DEBUG("%s", __func__);
 
   if (memcmp(p_data->key.p_data, p_cb->remote_dhkey_check, BT_OCTET16_LEN)) {
     SMP_TRACE_WARNING("dhkey chcks do no match");
-    p_cb->failure = reason;
-    smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &reason);
+    tSMP_INT_DATA smp_int_data;
+    smp_int_data.status = SMP_DHKEY_CHK_FAIL;
+    p_cb->failure = SMP_DHKEY_CHK_FAIL;
+    smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &smp_int_data);
     return;
   }
 
@@ -1737,11 +1763,12 @@ void smp_process_secure_connection_oob_data(tSMP_CB* p_cb,
     memcpy(p_cb->remote_commitment, p_sc_oob_data->peer_oob_data.commitment,
            sizeof(p_cb->remote_commitment));
 
-    uint8_t reason = SMP_CONFIRM_VALUE_ERR;
     /* check commitment */
     if (!smp_check_commitment(p_cb)) {
-      p_cb->failure = reason;
-      smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &reason);
+      tSMP_INT_DATA smp_int_data;
+      smp_int_data.status = SMP_CONFIRM_VALUE_ERR;
+      p_cb->failure = SMP_CONFIRM_VALUE_ERR;
+      smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &smp_int_data);
       return;
     }
 
@@ -1843,7 +1870,9 @@ void smp_link_encrypted(const RawAddress& bda, uint8_t encr_enable) {
       btm_ble_update_sec_key_size(bda, p_cb->loc_enc_size);
     }
 
-    smp_sm_event(&smp_cb, SMP_ENCRYPTED_EVT, &encr_enable);
+    tSMP_INT_DATA smp_int_data;
+    smp_int_data.status = encr_enable;
+    smp_sm_event(&smp_cb, SMP_ENCRYPTED_EVT, &smp_int_data);
   }
 }
 
@@ -1934,7 +1963,9 @@ void smp_derive_link_key_from_long_term_key(tSMP_CB* p_cb,
   SMP_TRACE_DEBUG("%s", __func__);
   if (!smp_calculate_link_key_from_long_term_key(p_cb)) {
     SMP_TRACE_ERROR("%s failed", __func__);
-    smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &status);
+    tSMP_INT_DATA smp_int_data;
+    smp_int_data.status = status;
+    smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &smp_int_data);
     return;
   }
 }
@@ -1956,7 +1987,9 @@ void smp_br_process_link_key(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
   SMP_TRACE_DEBUG("%s", __func__);
   if (!smp_calculate_long_term_key_from_link_key(p_cb)) {
     SMP_TRACE_ERROR("%s: failed", __func__);
-    smp_sm_event(p_cb, SMP_BR_AUTH_CMPL_EVT, &status);
+    tSMP_INT_DATA smp_int_data;
+    smp_int_data.status = status;
+    smp_sm_event(p_cb, SMP_BR_AUTH_CMPL_EVT, &smp_int_data);
     return;
   }
 

diff --git a/stack/smp/smp_api.cc b/stack/smp/smp_api.cc
index f6a87dd..e18bd29 100644 (file)
--- a/stack/smp/smp_api.cc
+++ b/stack/smp/smp_api.cc
@@ -132,7 +132,6 @@ bool SMP_Register(tSMP_CALLBACK* p_cback) {
  ******************************************************************************/
 tSMP_STATUS SMP_Pair(const RawAddress& bd_addr) {
   tSMP_CB* p_cb = &smp_cb;
-  uint8_t status = SMP_PAIR_INTERNAL_ERR;
 
   SMP_TRACE_EVENT("%s state=%d br_state=%d flag=0x%x ", __func__, p_cb->state,
                   p_cb->br_state, p_cb->flags);
@@ -145,9 +144,11 @@ tSMP_STATUS SMP_Pair(const RawAddress& bd_addr) {
     p_cb->pairing_bda = bd_addr;
 
     if (!L2CA_ConnectFixedChnl(L2CAP_SMP_CID, bd_addr)) {
+      tSMP_INT_DATA smp_int_data;
+      smp_int_data.status = SMP_PAIR_INTERNAL_ERR;
       SMP_TRACE_ERROR("%s: L2C connect fixed channel failed.", __func__);
-      smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &status);
-      return status;
+      smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &smp_int_data);
+      return SMP_PAIR_INTERNAL_ERR;
     }
 
     return SMP_STARTED;
@@ -169,7 +170,6 @@ tSMP_STATUS SMP_Pair(const RawAddress& bd_addr) {
  ******************************************************************************/
 tSMP_STATUS SMP_BR_PairWith(const RawAddress& bd_addr) {
   tSMP_CB* p_cb = &smp_cb;
-  uint8_t status = SMP_PAIR_INTERNAL_ERR;
 
   SMP_TRACE_EVENT("%s state=%d br_state=%d flag=0x%x ", __func__, p_cb->state,
                   p_cb->br_state, p_cb->flags);
@@ -187,8 +187,10 @@ tSMP_STATUS SMP_BR_PairWith(const RawAddress& bd_addr) {
 
   if (!L2CA_ConnectFixedChnl(L2CAP_SMP_BR_CID, bd_addr)) {
     SMP_TRACE_ERROR("%s: L2C connect fixed channel failed.", __func__);
-    smp_br_state_machine_event(p_cb, SMP_BR_AUTH_CMPL_EVT, &status);
-    return status;
+    tSMP_INT_DATA smp_int_data;
+    smp_int_data.status = SMP_PAIR_INTERNAL_ERR;
+    smp_br_state_machine_event(p_cb, SMP_BR_AUTH_CMPL_EVT, &smp_int_data);
+    return SMP_PAIR_INTERNAL_ERR;
   }
 
   return SMP_STARTED;
@@ -208,7 +210,6 @@ tSMP_STATUS SMP_BR_PairWith(const RawAddress& bd_addr) {
 bool SMP_PairCancel(const RawAddress& bd_addr) {
   tSMP_CB* p_cb = &smp_cb;
   uint8_t err_code = SMP_PAIR_FAIL_UNKNOWN;
-  bool status = false;
 
   // PTS SMP failure test cases
   if (p_cb->cert_failure == SMP_PASSKEY_ENTRY_FAIL ||
@@ -220,11 +221,13 @@ bool SMP_PairCancel(const RawAddress& bd_addr) {
   if (p_cb->state != SMP_STATE_IDLE && p_cb->pairing_bda == bd_addr) {
     p_cb->is_pair_cancel = true;
     SMP_TRACE_DEBUG("Cancel Pairing: set fail reason Unknown");
-    smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &err_code);
-    status = true;
+    tSMP_INT_DATA smp_int_data;
+    smp_int_data.status = SMP_PAIR_FAIL_UNKNOWN;
+    smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &smp_int_data);
+    return true;
   }
 
-  return status;
+  return false;
 }
 /*******************************************************************************
  *
@@ -252,7 +255,10 @@ void SMP_SecurityGrant(const RawAddress& bd_addr, uint8_t res) {
     /* clear the SMP_SEC_REQUEST_EVT event after get grant */
     /* avoid generating duplicate pair request */
     smp_cb.cb_evt = 0;
-    smp_br_state_machine_event(&smp_cb, SMP_BR_API_SEC_GRANT_EVT, &res);
+    tSMP_INT_DATA smp_int_data;
+    smp_int_data.status = res;
+    smp_br_state_machine_event(&smp_cb, SMP_BR_API_SEC_GRANT_EVT,
+                               &smp_int_data);
     return;
   }
 
@@ -262,7 +268,9 @@ void SMP_SecurityGrant(const RawAddress& bd_addr, uint8_t res) {
   /* clear the SMP_SEC_REQUEST_EVT event after get grant */
   /* avoid generate duplicate pair request */
   smp_cb.cb_evt = 0;
-  smp_sm_event(&smp_cb, SMP_API_SEC_GRANT_EVT, &res);
+  tSMP_INT_DATA smp_int_data;
+  smp_int_data.status = res;
+  smp_sm_event(&smp_cb, SMP_API_SEC_GRANT_EVT, &smp_int_data);
 }
 
 /*******************************************************************************
@@ -283,7 +291,6 @@ void SMP_SecurityGrant(const RawAddress& bd_addr, uint8_t res) {
 void SMP_PasskeyReply(const RawAddress& bd_addr, uint8_t res,
                       uint32_t passkey) {
   tSMP_CB* p_cb = &smp_cb;
-  uint8_t failure = SMP_PASSKEY_ENTRY_FAIL;
 
   SMP_TRACE_EVENT("SMP_PasskeyReply: Key: %d  Result:%d", passkey, res);
 
@@ -308,11 +315,15 @@ void SMP_PasskeyReply(const RawAddress& bd_addr, uint8_t res,
         "SMP_PasskeyReply() - Wrong key len: %d or passkey entry fail",
         passkey);
     /* send pairing failure */
-    smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &failure);
+    tSMP_INT_DATA smp_int_data;
+    smp_int_data.status = SMP_PASSKEY_ENTRY_FAIL;
+    smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &smp_int_data);
 
   } else if (p_cb->selected_association_model ==
              SMP_MODEL_SEC_CONN_PASSKEY_ENT) {
-    smp_sm_event(&smp_cb, SMP_SC_KEY_READY_EVT, &passkey);
+    tSMP_INT_DATA smp_int_data;
+    smp_int_data.passkey = passkey;
+    smp_sm_event(&smp_cb, SMP_SC_KEY_READY_EVT, &smp_int_data);
   } else {
     smp_convert_string_to_tk(p_cb->tk, passkey);
   }
@@ -334,7 +345,6 @@ void SMP_PasskeyReply(const RawAddress& bd_addr, uint8_t res,
  ******************************************************************************/
 void SMP_ConfirmReply(const RawAddress& bd_addr, uint8_t res) {
   tSMP_CB* p_cb = &smp_cb;
-  uint8_t failure = SMP_NUMERIC_COMPAR_FAIL;
 
   SMP_TRACE_EVENT("%s: Result:%d", __func__, res);
 
@@ -357,7 +367,9 @@ void SMP_ConfirmReply(const RawAddress& bd_addr, uint8_t res) {
   if (res != SMP_SUCCESS) {
     SMP_TRACE_WARNING("%s() - Numeric Comparison fails", __func__);
     /* send pairing failure */
-    smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &failure);
+    tSMP_INT_DATA smp_int_data;
+    smp_int_data.status = SMP_NUMERIC_COMPAR_FAIL;
+    smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &smp_int_data);
   } else {
     smp_sm_event(p_cb, SMP_SC_NC_OK_EVT, NULL);
   }
@@ -378,7 +390,6 @@ void SMP_ConfirmReply(const RawAddress& bd_addr, uint8_t res) {
 void SMP_OobDataReply(const RawAddress& bd_addr, tSMP_STATUS res, uint8_t len,
                       uint8_t* p_data) {
   tSMP_CB* p_cb = &smp_cb;
-  uint8_t failure = SMP_OOB_FAIL;
   tSMP_KEY key;
 
   SMP_TRACE_EVENT("%s State: %d  res:%d", __func__, smp_cb.state, res);
@@ -388,7 +399,9 @@ void SMP_OobDataReply(const RawAddress& bd_addr, tSMP_STATUS res, uint8_t len,
     return;
 
   if (res != SMP_SUCCESS || len == 0 || !p_data) {
-    smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &failure);
+    tSMP_INT_DATA smp_int_data;
+    smp_int_data.status = SMP_OOB_FAIL;
+    smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &smp_int_data);
   } else {
     if (len > BT_OCTET16_LEN) len = BT_OCTET16_LEN;
 
@@ -397,7 +410,9 @@ void SMP_OobDataReply(const RawAddress& bd_addr, tSMP_STATUS res, uint8_t len,
     key.key_type = SMP_KEY_TYPE_TK;
     key.p_data = p_cb->tk;
 
-    smp_sm_event(&smp_cb, SMP_KEY_READY_EVT, &key);
+    tSMP_INT_DATA smp_int_data;
+    smp_int_data.key = key;
+    smp_sm_event(&smp_cb, SMP_KEY_READY_EVT, &smp_int_data);
   }
 }
 
@@ -414,11 +429,12 @@ void SMP_OobDataReply(const RawAddress& bd_addr, tSMP_STATUS res, uint8_t len,
 void SMP_SecureConnectionOobDataReply(uint8_t* p_data) {
   tSMP_CB* p_cb = &smp_cb;
 
-  uint8_t failure = SMP_OOB_FAIL;
   tSMP_SC_OOB_DATA* p_oob = (tSMP_SC_OOB_DATA*)p_data;
   if (!p_oob) {
     SMP_TRACE_ERROR("%s received no data", __func__);
-    smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &failure);
+    tSMP_INT_DATA smp_int_data;
+    smp_int_data.status = SMP_OOB_FAIL;
+    smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &smp_int_data);
     return;
   }
 
@@ -450,14 +466,17 @@ void SMP_SecureConnectionOobDataReply(uint8_t* p_data) {
       break;
   }
 
+  tSMP_INT_DATA smp_int_data;
   if (data_missing) {
-    smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &failure);
+    smp_int_data.status = SMP_OOB_FAIL;
+    smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &smp_int_data);
     return;
   }
 
   p_cb->sc_oob_data = *p_oob;
 
-  smp_sm_event(&smp_cb, SMP_SC_OOB_DATA_EVT, p_data);
+  smp_int_data.p_data = p_data;
+  smp_sm_event(&smp_cb, SMP_SC_OOB_DATA_EVT, &smp_int_data);
 }
 
 /*******************************************************************************
@@ -526,7 +545,9 @@ void SMP_KeypressNotification(const RawAddress& bd_addr, uint8_t value) {
     return;
   }
 
-  smp_sm_event(p_cb, SMP_KEYPRESS_NOTIFICATION_EVENT, &value);
+  tSMP_INT_DATA smp_int_data;
+  smp_int_data.status = value;
+  smp_sm_event(p_cb, SMP_KEYPRESS_NOTIFICATION_EVENT, &smp_int_data);
 }
 
 /*******************************************************************************

diff --git a/stack/smp/smp_br_main.cc b/stack/smp/smp_br_main.cc
index 260b9c4..6525c9e 100644 (file)
--- a/stack/smp/smp_br_main.cc
+++ b/stack/smp/smp_br_main.cc
@@ -296,7 +296,7 @@ const char* smp_get_br_event_name(tSMP_BR_EVENT event) {
  *
  ******************************************************************************/
 void smp_br_state_machine_event(tSMP_CB* p_cb, tSMP_BR_EVENT event,
-                                void* p_data) {
+                                tSMP_INT_DATA* p_data) {
   tSMP_BR_STATE curr_state = p_cb->br_state;
   tSMP_BR_SM_TBL state_table;
   uint8_t action, entry;
@@ -343,7 +343,7 @@ void smp_br_state_machine_event(tSMP_CB* p_cb, tSMP_BR_EVENT event,
   for (uint8_t i = 0; i < SMP_BR_NUM_ACTIONS; i++) {
     action = state_table[entry - 1][i];
     if (action != SMP_BR_SM_NO_ACTION) {
-      (*smp_br_sm_action[action])(p_cb, (tSMP_INT_DATA*)p_data);
+      (*smp_br_sm_action[action])(p_cb, p_data);
     } else {
       break;
     }

diff --git a/stack/smp/smp_int.h b/stack/smp/smp_int.h
index fc8717f..2cf94b5 100644 (file)
--- a/stack/smp/smp_int.h
+++ b/stack/smp/smp_int.h
@@ -221,6 +221,7 @@ typedef struct {
 typedef union {
   uint8_t* p_data; /* uint8_t type data pointer */
   tSMP_KEY key;
+  uint8_t status;
   uint16_t reason;
   uint32_t passkey;
   tSMP_OOB_DATA_TYPE req_oob_type;
@@ -341,7 +342,8 @@ extern tSMP_CB smp_cb;
 extern void smp_init(void);
 
 /* smp main */
-extern void smp_sm_event(tSMP_CB* p_cb, tSMP_EVENT event, void* p_data);
+extern void smp_sm_event(tSMP_CB* p_cb, tSMP_EVENT event,
+                         tSMP_INT_DATA* p_data);
 
 extern void smp_proc_sec_request(tSMP_CB* p_cb, tSMP_INT_DATA* p_data);
 extern void smp_set_fail_nc(bool enable);
@@ -366,14 +368,12 @@ extern void smp_f5_calc_chk(uint8_t* w, uint8_t* n1, uint8_t* n2, uint8_t* a1,
 extern void smp_f6_calc_chk(uint8_t* w, uint8_t* n1, uint8_t* n2, uint8_t* r,
                             uint8_t* iocap, uint8_t* a1, uint8_t* a2,
                             uint8_t* mac);
-/* smp_main */
-extern void smp_sm_event(tSMP_CB* p_cb, tSMP_EVENT event, void* p_data);
 extern tSMP_STATE smp_get_state(void);
 extern void smp_set_state(tSMP_STATE state);
 
 /* smp_br_main */
 extern void smp_br_state_machine_event(tSMP_CB* p_cb, tSMP_BR_EVENT event,
-                                       void* p_data);
+                                       tSMP_INT_DATA* p_data);
 extern tSMP_BR_STATE smp_get_br_state(void);
 extern void smp_set_br_state(tSMP_BR_STATE state);
 

diff --git a/stack/smp/smp_keys.cc b/stack/smp/smp_keys.cc
index 06e4d87..6a07eb7 100644 (file)
--- a/stack/smp/smp_keys.cc
+++ b/stack/smp/smp_keys.cc
@@ -172,7 +172,6 @@ bool smp_encrypt_data(uint8_t* key, uint8_t key_len, uint8_t* plain_text,
  ******************************************************************************/
 void smp_proc_passkey(tSMP_CB* p_cb, BT_OCTET8 rand) {
   uint8_t* tt = p_cb->tk;
-  tSMP_KEY key;
   uint32_t passkey; /* 19655 test number; */
   uint8_t* pp = rand;
 
@@ -187,18 +186,24 @@ void smp_proc_passkey(tSMP_CB* p_cb, BT_OCTET8 rand) {
   memset(p_cb->tk, 0, BT_OCTET16_LEN);
   UINT32_TO_STREAM(tt, passkey);
 
-  key.key_type = SMP_KEY_TYPE_TK;
-  key.p_data = p_cb->tk;
-
   if (p_cb->p_callback) {
+    tSMP_EVT_DATA smp_evt_data;
+    smp_evt_data.passkey = passkey;
     (*p_cb->p_callback)(SMP_PASSKEY_NOTIF_EVT, p_cb->pairing_bda,
-                        (tSMP_EVT_DATA*)&passkey);
+                        &smp_evt_data);
   }
 
   if (p_cb->selected_association_model == SMP_MODEL_SEC_CONN_PASSKEY_DISP) {
-    smp_sm_event(&smp_cb, SMP_KEY_READY_EVT, &passkey);
+    tSMP_INT_DATA smp_int_data;
+    smp_int_data.passkey = passkey;
+    smp_sm_event(&smp_cb, SMP_KEY_READY_EVT, &smp_int_data);
   } else {
-    smp_sm_event(p_cb, SMP_KEY_READY_EVT, (tSMP_INT_DATA*)&key);
+    tSMP_KEY key;
+    key.key_type = SMP_KEY_TYPE_TK;
+    key.p_data = p_cb->tk;
+    tSMP_INT_DATA smp_int_data;
+    smp_int_data.key = key;
+    smp_sm_event(p_cb, SMP_KEY_READY_EVT, &smp_int_data);
   }
 }
 
@@ -230,7 +235,6 @@ void smp_generate_passkey(tSMP_CB* p_cb, UNUSED_ATTR tSMP_INT_DATA* p_data) {
  ******************************************************************************/
 void smp_generate_stk(tSMP_CB* p_cb, UNUSED_ATTR tSMP_INT_DATA* p_data) {
   tSMP_ENC output;
-  tSMP_STATUS status = SMP_PAIR_FAIL_UNKNOWN;
 
   SMP_TRACE_DEBUG("%s", __func__);
 
@@ -242,7 +246,9 @@ void smp_generate_stk(tSMP_CB* p_cb, UNUSED_ATTR tSMP_INT_DATA* p_data) {
     memcpy(output.param_buf, p_cb->ltk, SMP_ENCRYT_DATA_SIZE);
   } else if (!smp_calculate_legacy_short_term_key(p_cb, &output)) {
     SMP_TRACE_ERROR("%s failed", __func__);
-    smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &status);
+    tSMP_INT_DATA smp_int_data;
+    smp_int_data.status = SMP_PAIR_FAIL_UNKNOWN;
+    smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &smp_int_data);
     return;
   }
 
@@ -258,7 +264,6 @@ void smp_compute_csrk(uint16_t div, tSMP_CB* p_cb) {
   uint16_t r = 1;
   uint8_t* p = buffer;
   tSMP_ENC output;
-  tSMP_STATUS status = SMP_PAIR_FAIL_UNKNOWN;
 
   p_cb->div = div;
 
@@ -270,10 +275,12 @@ void smp_compute_csrk(uint16_t div, tSMP_CB* p_cb) {
 
   if (!SMP_Encrypt(er, BT_OCTET16_LEN, buffer, 4, &output)) {
     SMP_TRACE_ERROR("smp_generate_csrk failed");
+    tSMP_INT_DATA smp_int_data;
+    smp_int_data.status = SMP_PAIR_FAIL_UNKNOWN;
     if (p_cb->smp_over_br) {
-      smp_br_state_machine_event(p_cb, SMP_BR_AUTH_CMPL_EVT, &status);
+      smp_br_state_machine_event(p_cb, SMP_BR_AUTH_CMPL_EVT, &smp_int_data);
     } else {
-      smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &status);
+      smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &smp_int_data);
     }
   } else {
     memcpy((void*)p_cb->csrk, output.param_buf, BT_OCTET16_LEN);
@@ -481,7 +488,9 @@ static void smp_generate_confirm(tSMP_CB* p_cb) {
   tSMP_ENC output;
   tSMP_STATUS status = smp_calculate_comfirm(p_cb, p_cb->rand, &output);
   if (status != SMP_SUCCESS) {
-    smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &status);
+    tSMP_INT_DATA smp_int_data;
+    smp_int_data.status = status;
+    smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &smp_int_data);
     return;
   }
   tSMP_KEY key;
@@ -490,7 +499,9 @@ static void smp_generate_confirm(tSMP_CB* p_cb) {
                                       16);
   key.key_type = SMP_KEY_TYPE_CFM;
   key.p_data = output.param_buf;
-  smp_sm_event(p_cb, SMP_KEY_READY_EVT, &key);
+  tSMP_INT_DATA smp_int_data;
+  smp_int_data.key = key;
+  smp_sm_event(p_cb, SMP_KEY_READY_EVT, &smp_int_data);
 }
 
 /*******************************************************************************
@@ -541,7 +552,9 @@ void smp_generate_compare(tSMP_CB* p_cb, UNUSED_ATTR tSMP_INT_DATA* p_data) {
   tSMP_ENC output;
   tSMP_STATUS status = smp_calculate_comfirm(p_cb, p_cb->rrand, &output);
   if (status != SMP_SUCCESS) {
-    smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &status);
+    tSMP_INT_DATA smp_int_data;
+    smp_int_data.status = status;
+    smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &smp_int_data);
     return;
   }
   tSMP_KEY key;
@@ -549,7 +562,9 @@ void smp_generate_compare(tSMP_CB* p_cb, UNUSED_ATTR tSMP_INT_DATA* p_data) {
                                       "Remote Confirm generated", 16);
   key.key_type = SMP_KEY_TYPE_CMP;
   key.p_data = output.param_buf;
-  smp_sm_event(p_cb, SMP_KEY_READY_EVT, &key);
+  tSMP_INT_DATA smp_int_data;
+  smp_int_data.key = key;
+  smp_sm_event(p_cb, SMP_KEY_READY_EVT, &smp_int_data);
 }
 
 /*******************************************************************************
@@ -574,7 +589,9 @@ static void smp_process_stk(tSMP_CB* p_cb, tSMP_ENC* p) {
   key.key_type = SMP_KEY_TYPE_STK;
   key.p_data = p->param_buf;
 
-  smp_sm_event(p_cb, SMP_KEY_READY_EVT, &key);
+  tSMP_INT_DATA smp_int_data;
+  smp_int_data.key = key;
+  smp_sm_event(p_cb, SMP_KEY_READY_EVT, &smp_int_data);
 }
 
 /**
@@ -595,7 +612,9 @@ static void smp_process_ediv(tSMP_CB* p_cb, tSMP_ENC* p) {
   key.key_type = SMP_KEY_TYPE_LTK;
   key.p_data = p->param_buf;
 
-  smp_sm_event(p_cb, SMP_KEY_READY_EVT, &key);
+  tSMP_INT_DATA smp_int_data;
+  smp_int_data.key = key;
+  smp_sm_event(p_cb, SMP_KEY_READY_EVT, &smp_int_data);
 }
 
 /**
@@ -611,8 +630,9 @@ static void smp_generate_y(tSMP_CB* p_cb, BT_OCTET8 rand) {
   tSMP_ENC output;
   if (!SMP_Encrypt(dhk, BT_OCTET16_LEN, rand, BT_OCTET8_LEN, &output)) {
     SMP_TRACE_ERROR("%s failed", __func__);
-    tSMP_STATUS status = SMP_PAIR_FAIL_UNKNOWN;
-    smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &status);
+    tSMP_INT_DATA smp_int_data;
+    smp_int_data.status = SMP_PAIR_FAIL_UNKNOWN;
+    smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &smp_int_data);
   } else {
     smp_process_ediv(p_cb, &output);
   }
@@ -633,8 +653,9 @@ static void smp_generate_ltk_cont(uint16_t div, tSMP_CB* p_cb) {
   if (!SMP_Encrypt(er, BT_OCTET16_LEN, (uint8_t*)&p_cb->div, sizeof(uint16_t),
                    &output)) {
     SMP_TRACE_ERROR("%s failed", __func__);
-    tSMP_STATUS status = SMP_PAIR_FAIL_UNKNOWN;
-    smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &status);
+    tSMP_INT_DATA smp_int_data;
+    smp_int_data.status = SMP_PAIR_FAIL_UNKNOWN;
+    smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &smp_int_data);
   } else {
     /* mask the LTK */
     smp_mask_enc_key(p_cb->loc_enc_size, output.param_buf);
@@ -1052,16 +1073,19 @@ void smp_calculate_numeric_comparison_display_number(tSMP_CB* p_cb,
   }
 
   if (p_cb->number_to_display >= (BTM_MAX_PASSKEY_VAL + 1)) {
-    uint8_t reason;
-    reason = p_cb->failure = SMP_PAIR_FAIL_UNKNOWN;
-    smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &reason);
+    tSMP_INT_DATA smp_int_data;
+    smp_int_data.status = SMP_PAIR_FAIL_UNKNOWN;
+    p_cb->failure = SMP_PAIR_FAIL_UNKNOWN;
+    smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &smp_int_data);
     return;
   }
 
   SMP_TRACE_EVENT("Number to display in numeric comparison = %d",
                   p_cb->number_to_display);
   p_cb->cb_evt = SMP_NC_REQ_EVT;
-  smp_sm_event(p_cb, SMP_SC_DSPL_NC_EVT, &p_cb->number_to_display);
+  tSMP_INT_DATA smp_int_data;
+  smp_int_data.passkey = p_cb->number_to_display;
+  smp_sm_event(p_cb, SMP_SC_DSPL_NC_EVT, &smp_int_data);
   return;
 }
 
@@ -1503,7 +1527,6 @@ void smp_calculate_peer_dhkey_check(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
   BT_OCTET16 param_buf;
   bool ret;
   tSMP_KEY key;
-  tSMP_STATUS status = SMP_PAIR_FAIL_UNKNOWN;
 
   SMP_TRACE_DEBUG("%s", __func__);
 
@@ -1522,10 +1545,14 @@ void smp_calculate_peer_dhkey_check(tSMP_CB* p_cb, tSMP_INT_DATA* p_data) {
 #endif
     key.key_type = SMP_KEY_TYPE_PEER_DHK_CHCK;
     key.p_data = param_buf;
-    smp_sm_event(p_cb, SMP_SC_KEY_READY_EVT, &key);
+    tSMP_INT_DATA smp_int_data;
+    smp_int_data.key = key;
+    smp_sm_event(p_cb, SMP_SC_KEY_READY_EVT, &smp_int_data);
   } else {
     SMP_TRACE_EVENT("peer DHKey check calculation failed");
-    smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &status);
+    tSMP_INT_DATA smp_int_data;
+    smp_int_data.status = SMP_PAIR_FAIL_UNKNOWN;
+    smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &smp_int_data);
   }
 }
 

diff --git a/stack/smp/smp_l2c.cc b/stack/smp/smp_l2c.cc
index 6111f10..7efc628 100644 (file)
--- a/stack/smp/smp_l2c.cc
+++ b/stack/smp/smp_l2c.cc
@@ -183,7 +183,9 @@ static void smp_data_received(uint16_t channel, const RawAddress& bd_addr,
 
     p_cb->rcvd_cmd_code = cmd;
     p_cb->rcvd_cmd_len = (uint8_t)p_buf->len;
-    smp_sm_event(p_cb, cmd, p);
+    tSMP_INT_DATA smp_int_data;
+    smp_int_data.p_data = p;
+    smp_sm_event(p_cb, cmd, &smp_int_data);
   }
 
   osi_free(p_buf);
@@ -204,12 +206,14 @@ static void smp_tx_complete_callback(uint16_t cid, uint16_t num_pkt) {
   else
     SMP_TRACE_ERROR("Unexpected %s: num_pkt = %d", __func__, num_pkt);
 
-  uint8_t reason = SMP_SUCCESS;
   if (p_cb->total_tx_unacked == 0 && p_cb->wait_for_authorization_complete) {
-    if (cid == L2CAP_SMP_CID)
-      smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &reason);
-    else
-      smp_br_state_machine_event(p_cb, SMP_BR_AUTH_CMPL_EVT, &reason);
+    tSMP_INT_DATA smp_int_data;
+    smp_int_data.status = SMP_SUCCESS;
+    if (cid == L2CAP_SMP_CID) {
+      smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &smp_int_data);
+    } else {
+      smp_br_state_machine_event(p_cb, SMP_BR_AUTH_CMPL_EVT, &smp_int_data);
+    }
   }
 }
 
@@ -304,7 +308,9 @@ static void smp_br_data_received(uint16_t channel, const RawAddress& bd_addr,
 
     p_cb->rcvd_cmd_code = cmd;
     p_cb->rcvd_cmd_len = (uint8_t)p_buf->len;
-    smp_br_state_machine_event(p_cb, cmd, p);
+    tSMP_INT_DATA smp_int_data;
+    smp_int_data.p_data = p;
+    smp_br_state_machine_event(p_cb, cmd, &smp_int_data);
   }
 
   osi_free(p_buf);

diff --git a/stack/smp/smp_main.cc b/stack/smp/smp_main.cc
index 829a5d4..49b2ff6 100644 (file)
--- a/stack/smp/smp_main.cc
+++ b/stack/smp/smp_main.cc
@@ -950,7 +950,7 @@ tSMP_STATE smp_get_state(void) { return smp_cb.state; }
  * Returns      void.
  *
  ******************************************************************************/
-void smp_sm_event(tSMP_CB* p_cb, tSMP_EVENT event, void* p_data) {
+void smp_sm_event(tSMP_CB* p_cb, tSMP_EVENT event, tSMP_INT_DATA* p_data) {
   uint8_t curr_state = p_cb->state;
   tSMP_SM_TBL state_table;
   uint8_t action, entry, i;
@@ -997,7 +997,7 @@ void smp_sm_event(tSMP_CB* p_cb, tSMP_EVENT event, void* p_data) {
   for (i = 0; i < SMP_NUM_ACTIONS; i++) {
     action = state_table[entry - 1][i];
     if (action != SMP_SM_NO_ACTION) {
-      (*smp_sm_action[action])(p_cb, (tSMP_INT_DATA*)p_data);
+      (*smp_sm_action[action])(p_cb, p_data);
     } else {
       break;
     }

diff --git a/stack/smp/smp_utils.cc b/stack/smp/smp_utils.cc
index 8bdce6b..0509289 100644 (file)
--- a/stack/smp/smp_utils.cc
+++ b/stack/smp/smp_utils.cc
@@ -332,7 +332,6 @@ bool smp_send_msg_to_L2CAP(const RawAddress& rem_bda, BT_HDR* p_toL2CAP) {
 bool smp_send_cmd(uint8_t cmd_code, tSMP_CB* p_cb) {
   BT_HDR* p_buf;
   bool sent = false;
-  uint8_t failure = SMP_PAIR_INTERNAL_ERR;
   SMP_TRACE_EVENT("smp_send_cmd on l2cap cmd_code=0x%x", cmd_code);
   if (cmd_code <= (SMP_OPCODE_MAX + 1 /* for SMP_OPCODE_PAIR_COMMITM */) &&
       smp_cmd_build_act[cmd_code] != NULL) {
@@ -346,10 +345,12 @@ bool smp_send_cmd(uint8_t cmd_code, tSMP_CB* p_cb) {
   }
 
   if (!sent) {
+    tSMP_INT_DATA smp_int_data;
+    smp_int_data.status = SMP_PAIR_INTERNAL_ERR;
     if (p_cb->smp_over_br) {
-      smp_br_state_machine_event(p_cb, SMP_BR_AUTH_CMPL_EVT, &failure);
+      smp_br_state_machine_event(p_cb, SMP_BR_AUTH_CMPL_EVT, &smp_int_data);
     } else {
-      smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &failure);
+      smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &smp_int_data);
     }
   }
   return sent;
@@ -366,15 +367,16 @@ bool smp_send_cmd(uint8_t cmd_code, tSMP_CB* p_cb) {
  ******************************************************************************/
 void smp_rsp_timeout(UNUSED_ATTR void* data) {
   tSMP_CB* p_cb = &smp_cb;
-  uint8_t failure = SMP_RSP_TIMEOUT;
 
   SMP_TRACE_EVENT("%s state:%d br_state:%d", __func__, p_cb->state,
                   p_cb->br_state);
 
+  tSMP_INT_DATA smp_int_data;
+  smp_int_data.status = SMP_RSP_TIMEOUT;
   if (p_cb->smp_over_br) {
-    smp_br_state_machine_event(p_cb, SMP_BR_AUTH_CMPL_EVT, &failure);
+    smp_br_state_machine_event(p_cb, SMP_BR_AUTH_CMPL_EVT, &smp_int_data);
   } else {
-    smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &failure);
+    smp_sm_event(p_cb, SMP_AUTH_CMPL_EVT, &smp_int_data);
   }
 }
 
@@ -394,9 +396,10 @@ void smp_delayed_auth_complete_timeout(UNUSED_ATTR void* data) {
    * the state is still in bond pending.
    */
   if (smp_get_state() == SMP_STATE_BOND_PENDING) {
-    uint8_t reason = SMP_SUCCESS;
     SMP_TRACE_EVENT("%s sending delayed auth complete.", __func__);
-    smp_sm_event(&smp_cb, SMP_AUTH_CMPL_EVT, &reason);
+    tSMP_INT_DATA smp_int_data;
+    smp_int_data.status = SMP_SUCCESS;
+    smp_sm_event(&smp_cb, SMP_AUTH_CMPL_EVT, &smp_int_data);
   }
 }
 
@@ -788,7 +791,9 @@ void smp_convert_string_to_tk(BT_OCTET16 tk, uint32_t passkey) {
   key.key_type = SMP_KEY_TYPE_TK;
   key.p_data = tk;
 
-  smp_sm_event(&smp_cb, SMP_KEY_READY_EVT, &key);
+  tSMP_INT_DATA smp_int_data;
+  smp_int_data.key = key;
+  smp_sm_event(&smp_cb, SMP_KEY_READY_EVT, &smp_int_data);
 }
 
 /*******************************************************************************
@@ -1523,7 +1528,9 @@ bool smp_request_oob_data(tSMP_CB* p_cb) {
 
   p_cb->req_oob_type = req_oob_type;
   p_cb->cb_evt = SMP_SC_OOB_REQ_EVT;
-  smp_sm_event(p_cb, SMP_TK_REQ_EVT, &req_oob_type);
+  tSMP_INT_DATA smp_int_data;
+  smp_int_data.req_oob_type = req_oob_type;
+  smp_sm_event(p_cb, SMP_TK_REQ_EVT, &smp_int_data);
 
   return true;
 }