| /****************************************************************************** |
| * |
| * Copyright (C) 1999-2012 Broadcom Corporation |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at: |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| * |
| ******************************************************************************/ |
| |
| /****************************************************************************** |
| * |
| * This file contains functions for BLE whitelist operation. |
| * |
| ******************************************************************************/ |
| |
| #include <base/logging.h> |
| #include <string.h> |
| #include <unordered_map> |
| |
| #include "bt_types.h" |
| #include "bt_utils.h" |
| #include "btm_int.h" |
| #include "btu.h" |
| #include "device/include/controller.h" |
| #include "hcimsgs.h" |
| #include "l2c_int.h" |
| #include "osi/include/allocator.h" |
| #include "osi/include/osi.h" |
| |
| #ifndef BTM_BLE_SCAN_PARAM_TOUT |
| #define BTM_BLE_SCAN_PARAM_TOUT 50 /* 50 seconds */ |
| #endif |
| |
| static void btm_suspend_wl_activity(tBTM_BLE_WL_STATE wl_state); |
| static void btm_resume_wl_activity(tBTM_BLE_WL_STATE wl_state); |
| |
| // Unfortunately (for now?) we have to maintain a copy of the device whitelist |
| // on the host to determine if a device is pending to be connected or not. This |
| // controls whether the host should keep trying to scan for whitelisted |
| // peripherals or not. |
| // TODO: Move all of this to controller/le/background_list or similar? |
| typedef struct background_connection_t { |
| bt_bdaddr_t address; |
| } background_connection_t; |
| |
| struct KeyEqual { |
| bool operator()(const bt_bdaddr_t* x, const bt_bdaddr_t* y) const { |
| return bdaddr_equals(x, y); |
| } |
| }; |
| |
| static std::unordered_map<bt_bdaddr_t*, background_connection_t*, |
| std::hash<bt_bdaddr_t*>, KeyEqual> |
| background_connections; |
| |
| static void background_connection_add(bt_bdaddr_t* address) { |
| CHECK(address); |
| |
| auto map_iter = background_connections.find(address); |
| if (map_iter == background_connections.end()) { |
| background_connection_t* connection = |
| (background_connection_t*)osi_calloc(sizeof(background_connection_t)); |
| connection->address = *address; |
| background_connections[&(connection->address)] = connection; |
| } |
| } |
| |
| static void background_connection_remove(bt_bdaddr_t* address) { |
| background_connections.erase(address); |
| } |
| |
| static void background_connections_clear() { background_connections.clear(); } |
| |
| static bool background_connections_pending() { |
| for (const auto& map_el : background_connections) { |
| background_connection_t* connection = map_el.second; |
| const bool connected = |
| BTM_IsAclConnectionUp(connection->address.address, BT_TRANSPORT_LE); |
| if (!connected) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| /******************************************************************************* |
| * |
| * Function btm_update_scanner_filter_policy |
| * |
| * Description This function updates the filter policy of scanner |
| ******************************************************************************/ |
| void btm_update_scanner_filter_policy(tBTM_BLE_SFP scan_policy) { |
| tBTM_BLE_INQ_CB* p_inq = &btm_cb.ble_ctr_cb.inq_var; |
| |
| uint32_t scan_interval = |
| !p_inq->scan_interval ? BTM_BLE_GAP_DISC_SCAN_INT : p_inq->scan_interval; |
| uint32_t scan_window = |
| !p_inq->scan_window ? BTM_BLE_GAP_DISC_SCAN_WIN : p_inq->scan_window; |
| |
| BTM_TRACE_EVENT("%s", __func__); |
| |
| p_inq->sfp = scan_policy; |
| p_inq->scan_type = p_inq->scan_type == BTM_BLE_SCAN_MODE_NONE |
| ? BTM_BLE_SCAN_MODE_ACTI |
| : p_inq->scan_type; |
| |
| btm_send_hci_set_scan_params( |
| p_inq->scan_type, (uint16_t)scan_interval, (uint16_t)scan_window, |
| btm_cb.ble_ctr_cb.addr_mgnt_cb.own_addr_type, scan_policy); |
| } |
| /******************************************************************************* |
| * |
| * Function btm_add_dev_to_controller |
| * |
| * Description This function load the device into controller white list |
| ******************************************************************************/ |
| bool btm_add_dev_to_controller(bool to_add, BD_ADDR bd_addr) { |
| tBTM_SEC_DEV_REC* p_dev_rec = btm_find_dev(bd_addr); |
| bool started = false; |
| BD_ADDR dummy_bda = {0}; |
| |
| if (p_dev_rec != NULL && p_dev_rec->device_type & BT_DEVICE_TYPE_BLE) { |
| if (to_add) { |
| if (p_dev_rec->ble.ble_addr_type == BLE_ADDR_PUBLIC || |
| !BTM_BLE_IS_RESOLVE_BDA(bd_addr)) { |
| btsnd_hcic_ble_add_white_list(p_dev_rec->ble.ble_addr_type, bd_addr); |
| started = true; |
| p_dev_rec->ble.in_controller_list |= BTM_WHITE_LIST_BIT; |
| } else if (memcmp(p_dev_rec->ble.static_addr, bd_addr, BD_ADDR_LEN) != |
| 0 && |
| memcmp(p_dev_rec->ble.static_addr, dummy_bda, BD_ADDR_LEN) != |
| 0) { |
| btsnd_hcic_ble_add_white_list(p_dev_rec->ble.static_addr_type, |
| p_dev_rec->ble.static_addr); |
| started = true; |
| p_dev_rec->ble.in_controller_list |= BTM_WHITE_LIST_BIT; |
| } |
| } else { |
| if (p_dev_rec->ble.ble_addr_type == BLE_ADDR_PUBLIC || |
| !BTM_BLE_IS_RESOLVE_BDA(bd_addr)) { |
| btsnd_hcic_ble_remove_from_white_list(p_dev_rec->ble.ble_addr_type, |
| bd_addr); |
| started = true; |
| } |
| |
| if (memcmp(p_dev_rec->ble.static_addr, dummy_bda, BD_ADDR_LEN) != 0 && |
| memcmp(p_dev_rec->ble.static_addr, bd_addr, BD_ADDR_LEN) != 0) { |
| btsnd_hcic_ble_remove_from_white_list(p_dev_rec->ble.static_addr_type, |
| p_dev_rec->ble.static_addr); |
| started = true; |
| } |
| |
| p_dev_rec->ble.in_controller_list &= ~BTM_WHITE_LIST_BIT; |
| } |
| } else { |
| /* not a known device, i.e. attempt to connect to device never seen before |
| */ |
| uint8_t addr_type = |
| BTM_IS_PUBLIC_BDA(bd_addr) ? BLE_ADDR_PUBLIC : BLE_ADDR_RANDOM; |
| btsnd_hcic_ble_remove_from_white_list(addr_type, bd_addr); |
| started = true; |
| if (to_add) btsnd_hcic_ble_add_white_list(addr_type, bd_addr); |
| } |
| |
| return started; |
| } |
| /******************************************************************************* |
| * |
| * Function btm_execute_wl_dev_operation |
| * |
| * Description execute the pending whitelist device operation (loading or |
| * removing) |
| ******************************************************************************/ |
| bool btm_execute_wl_dev_operation(void) { |
| tBTM_BLE_WL_OP* p_dev_op = btm_cb.ble_ctr_cb.wl_op_q; |
| uint8_t i = 0; |
| bool rt = true; |
| |
| for (i = 0; i < BTM_BLE_MAX_BG_CONN_DEV_NUM && rt; i++, p_dev_op++) { |
| if (p_dev_op->in_use) { |
| rt = btm_add_dev_to_controller(p_dev_op->to_add, p_dev_op->bd_addr); |
| memset(p_dev_op, 0, sizeof(tBTM_BLE_WL_OP)); |
| } else |
| break; |
| } |
| return rt; |
| } |
| /******************************************************************************* |
| * |
| * Function btm_enq_wl_dev_operation |
| * |
| * Description enqueue the pending whitelist device operation (loading or |
| * removing). |
| ******************************************************************************/ |
| void btm_enq_wl_dev_operation(bool to_add, BD_ADDR bd_addr) { |
| tBTM_BLE_WL_OP* p_dev_op = btm_cb.ble_ctr_cb.wl_op_q; |
| uint8_t i = 0; |
| |
| for (i = 0; i < BTM_BLE_MAX_BG_CONN_DEV_NUM; i++, p_dev_op++) { |
| if (p_dev_op->in_use && !memcmp(p_dev_op->bd_addr, bd_addr, BD_ADDR_LEN)) { |
| p_dev_op->to_add = to_add; |
| return; |
| } else if (!p_dev_op->in_use) |
| break; |
| } |
| if (i != BTM_BLE_MAX_BG_CONN_DEV_NUM) { |
| p_dev_op->in_use = true; |
| p_dev_op->to_add = to_add; |
| memcpy(p_dev_op->bd_addr, bd_addr, BD_ADDR_LEN); |
| } else { |
| BTM_TRACE_ERROR("max pending WL operation reached, discard"); |
| } |
| return; |
| } |
| |
| /******************************************************************************* |
| * |
| * Function btm_update_dev_to_white_list |
| * |
| * Description This function adds or removes a device into/from |
| * the white list. |
| * |
| ******************************************************************************/ |
| bool btm_update_dev_to_white_list(bool to_add, BD_ADDR bd_addr) { |
| tBTM_BLE_CB* p_cb = &btm_cb.ble_ctr_cb; |
| |
| if (to_add && p_cb->white_list_avail_size == 0) { |
| BTM_TRACE_ERROR("%s Whitelist full, unable to add device", __func__); |
| return false; |
| } |
| |
| if (to_add) |
| background_connection_add((bt_bdaddr_t*)bd_addr); |
| else |
| background_connection_remove((bt_bdaddr_t*)bd_addr); |
| |
| btm_suspend_wl_activity(p_cb->wl_state); |
| btm_enq_wl_dev_operation(to_add, bd_addr); |
| 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(); |
| background_connections_clear(); |
| } |
| |
| /******************************************************************************* |
| * |
| * Function btm_ble_clear_white_list_complete |
| * |
| * Description Indicates white list cleared. |
| * |
| ******************************************************************************/ |
| void btm_ble_clear_white_list_complete(uint8_t* p_data, |
| UNUSED_ATTR uint16_t evt_len) { |
| tBTM_BLE_CB* p_cb = &btm_cb.ble_ctr_cb; |
| uint8_t status; |
| |
| BTM_TRACE_EVENT("btm_ble_clear_white_list_complete"); |
| STREAM_TO_UINT8(status, p_data); |
| |
| if (status == HCI_SUCCESS) |
| 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_t 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 White list element added |
| * |
| ******************************************************************************/ |
| void btm_ble_add_2_white_list_complete(uint8_t status) { |
| BTM_TRACE_EVENT("%s status=%d", __func__, status); |
| if (status == HCI_SUCCESS) --btm_cb.ble_ctr_cb.white_list_avail_size; |
| } |
| |
| /******************************************************************************* |
| * |
| * Function btm_ble_remove_from_white_list_complete |
| * |
| * Description White list element removal complete |
| * |
| ******************************************************************************/ |
| void btm_ble_remove_from_white_list_complete(uint8_t* p, |
| UNUSED_ATTR uint16_t evt_len) { |
| BTM_TRACE_EVENT("%s status=%d", __func__, *p); |
| if (*p == HCI_SUCCESS) ++btm_cb.ble_ctr_cb.white_list_avail_size; |
| } |
| |
| void btm_send_hci_create_connection( |
| uint16_t scan_int, uint16_t scan_win, uint8_t init_filter_policy, |
| uint8_t addr_type_peer, BD_ADDR bda_peer, uint8_t addr_type_own, |
| uint16_t conn_int_min, uint16_t conn_int_max, uint16_t conn_latency, |
| uint16_t conn_timeout, uint16_t min_ce_len, uint16_t max_ce_len, |
| uint8_t initiating_phys) { |
| if (controller_get_interface()->supports_ble_extended_advertising()) { |
| EXT_CONN_PHY_CFG phy_cfg[3]; // maximum three phys |
| |
| int phy_cnt = |
| std::bitset<std::numeric_limits<uint8_t>::digits>(initiating_phys) |
| .count(); |
| |
| LOG_ASSERT(phy_cnt < 3) << "More than three phys provided"; |
| // TODO(jpawlowski): tune parameters for different transports |
| for (int i = 0; i < phy_cnt; i++) { |
| phy_cfg[i].scan_int = scan_int; |
| phy_cfg[i].scan_win = scan_win; |
| phy_cfg[i].conn_int_min = conn_int_min; |
| phy_cfg[i].conn_int_max = conn_int_max; |
| phy_cfg[i].conn_latency = conn_latency; |
| phy_cfg[i].sup_timeout = conn_timeout; |
| phy_cfg[i].min_ce_len = min_ce_len; |
| phy_cfg[i].max_ce_len = max_ce_len; |
| } |
| |
| addr_type_peer &= ~BLE_ADDR_TYPE_ID_BIT; |
| btsnd_hcic_ble_ext_create_conn(init_filter_policy, addr_type_own, |
| addr_type_peer, bda_peer, initiating_phys, |
| phy_cfg); |
| } else { |
| btsnd_hcic_ble_create_ll_conn(scan_int, scan_win, init_filter_policy, |
| addr_type_peer, bda_peer, addr_type_own, |
| conn_int_min, conn_int_max, conn_latency, |
| conn_timeout, min_ce_len, max_ce_len); |
| } |
| } |
| |
| /******************************************************************************* |
| * |
| * Function btm_ble_start_auto_conn |
| * |
| * Description This function is to start/stop auto connection procedure. |
| * |
| * Parameters start: true to start; false to stop. |
| * |
| * Returns void |
| * |
| ******************************************************************************/ |
| bool btm_ble_start_auto_conn(bool start) { |
| tBTM_BLE_CB* p_cb = &btm_cb.ble_ctr_cb; |
| BD_ADDR dummy_bda = {0}; |
| bool exec = true; |
| uint16_t scan_int; |
| uint16_t scan_win; |
| uint8_t own_addr_type = p_cb->addr_mgnt_cb.own_addr_type; |
| uint8_t peer_addr_type = BLE_ADDR_PUBLIC; |
| |
| uint8_t phy = PHY_LE_1M; |
| if (controller_get_interface()->supports_ble_2m_phy()) phy |= PHY_LE_2M; |
| if (controller_get_interface()->supports_ble_coded_phy()) phy |= PHY_LE_CODED; |
| |
| if (start) { |
| if (p_cb->conn_state == BLE_CONN_IDLE && background_connections_pending() && |
| btm_ble_topology_check(BTM_BLE_STATE_INIT)) { |
| p_cb->wl_state |= BTM_BLE_WL_INIT; |
| |
| btm_execute_wl_dev_operation(); |
| |
| #if (BLE_PRIVACY_SPT == TRUE) |
| btm_ble_enable_resolving_list_for_platform(BTM_BLE_RL_INIT); |
| #endif |
| scan_int = (p_cb->scan_int == BTM_BLE_SCAN_PARAM_UNDEF) |
| ? BTM_BLE_SCAN_SLOW_INT_1 |
| : p_cb->scan_int; |
| scan_win = (p_cb->scan_win == BTM_BLE_SCAN_PARAM_UNDEF) |
| ? BTM_BLE_SCAN_SLOW_WIN_1 |
| : p_cb->scan_win; |
| |
| #if (BLE_PRIVACY_SPT == TRUE) |
| if (btm_cb.ble_ctr_cb.rl_state != BTM_BLE_RL_IDLE && |
| controller_get_interface()->supports_ble_privacy()) { |
| own_addr_type |= BLE_ADDR_TYPE_ID_BIT; |
| peer_addr_type |= BLE_ADDR_TYPE_ID_BIT; |
| } |
| #endif |
| |
| btm_send_hci_create_connection( |
| scan_int, /* uint16_t scan_int */ |
| scan_win, /* uint16_t scan_win */ |
| 0x01, /* uint8_t white_list */ |
| peer_addr_type, /* uint8_t addr_type_peer */ |
| dummy_bda, /* BD_ADDR bda_peer */ |
| own_addr_type, /* uint8_t addr_type_own */ |
| BTM_BLE_CONN_INT_MIN_DEF, /* uint16_t conn_int_min */ |
| BTM_BLE_CONN_INT_MAX_DEF, /* uint16_t conn_int_max */ |
| BTM_BLE_CONN_SLAVE_LATENCY_DEF, /* uint16_t conn_latency */ |
| BTM_BLE_CONN_TIMEOUT_DEF, /* uint16_t conn_timeout */ |
| 0, /* uint16_t min_len */ |
| 0, /* uint16_t max_len */ |
| phy); |
| btm_ble_set_conn_st(BLE_BG_CONN); |
| } else { |
| exec = false; |
| } |
| } else { |
| if (p_cb->conn_state == BLE_BG_CONN) { |
| btsnd_hcic_ble_create_conn_cancel(); |
| btm_ble_set_conn_st(BLE_CONN_CANCEL); |
| p_cb->wl_state &= ~BTM_BLE_WL_INIT; |
| } else { |
| BTM_TRACE_DEBUG("conn_st = %d, not in auto conn state, cannot stop", |
| p_cb->conn_state); |
| exec = false; |
| } |
| } |
| return exec; |
| } |
| |
| /******************************************************************************* |
| * |
| * Function btm_ble_suspend_bg_conn |
| * |
| * Description This function is to suspend an active background connection |
| * procedure. |
| * |
| * Parameters none. |
| * |
| * Returns none. |
| * |
| ******************************************************************************/ |
| bool btm_ble_suspend_bg_conn(void) { |
| BTM_TRACE_EVENT("%s", __func__); |
| |
| if (btm_cb.ble_ctr_cb.bg_conn_type == BTM_BLE_CONN_AUTO) |
| return btm_ble_start_auto_conn(false); |
| |
| return false; |
| } |
| /******************************************************************************* |
| * |
| * Function btm_suspend_wl_activity |
| * |
| * Description This function is to suspend white list related activity |
| * |
| * Returns none. |
| * |
| ******************************************************************************/ |
| static void btm_suspend_wl_activity(tBTM_BLE_WL_STATE wl_state) { |
| if (wl_state & BTM_BLE_WL_INIT) { |
| btm_ble_start_auto_conn(false); |
| } |
| if (wl_state & BTM_BLE_WL_ADV) { |
| btm_ble_stop_adv(); |
| } |
| } |
| /******************************************************************************* |
| * |
| * Function btm_resume_wl_activity |
| * |
| * Description This function is to resume white list related activity |
| * |
| * Returns none. |
| * |
| ******************************************************************************/ |
| static void btm_resume_wl_activity(tBTM_BLE_WL_STATE wl_state) { |
| btm_ble_resume_bg_conn(); |
| |
| if (wl_state & BTM_BLE_WL_ADV) { |
| btm_ble_start_adv(); |
| } |
| } |
| /******************************************************************************* |
| * |
| * Function btm_ble_resume_bg_conn |
| * |
| * Description This function is to resume a background auto connection |
| * procedure. |
| * |
| * Parameters none. |
| * |
| * Returns none. |
| * |
| ******************************************************************************/ |
| bool btm_ble_resume_bg_conn(void) { |
| tBTM_BLE_CB* p_cb = &btm_cb.ble_ctr_cb; |
| if (p_cb->bg_conn_type == BTM_BLE_CONN_AUTO) { |
| return btm_ble_start_auto_conn(true); |
| } |
| |
| return false; |
| } |
| /******************************************************************************* |
| * |
| * Function btm_ble_get_conn_st |
| * |
| * Description This function get BLE connection state |
| * |
| * Returns connection state |
| * |
| ******************************************************************************/ |
| tBTM_BLE_CONN_ST btm_ble_get_conn_st(void) { |
| return btm_cb.ble_ctr_cb.conn_state; |
| } |
| /******************************************************************************* |
| * |
| * Function btm_ble_set_conn_st |
| * |
| * Description This function set BLE connection state |
| * |
| * Returns None. |
| * |
| ******************************************************************************/ |
| void btm_ble_set_conn_st(tBTM_BLE_CONN_ST new_st) { |
| btm_cb.ble_ctr_cb.conn_state = new_st; |
| |
| if (new_st == BLE_BG_CONN || new_st == BLE_DIR_CONN) |
| btm_ble_set_topology_mask(BTM_BLE_STATE_INIT_BIT); |
| else |
| btm_ble_clear_topology_mask(BTM_BLE_STATE_INIT_BIT); |
| } |
| |
| /******************************************************************************* |
| * |
| * Function btm_ble_enqueue_direct_conn_req |
| * |
| * Description This function enqueue the direct connection request |
| * |
| * Returns None. |
| * |
| ******************************************************************************/ |
| void btm_ble_enqueue_direct_conn_req(void* p_param) { |
| tBTM_BLE_CONN_REQ* p = |
| (tBTM_BLE_CONN_REQ*)osi_malloc(sizeof(tBTM_BLE_CONN_REQ)); |
| |
| p->p_param = p_param; |
| |
| fixed_queue_enqueue(btm_cb.ble_ctr_cb.conn_pending_q, p); |
| } |
| /******************************************************************************* |
| * |
| * Function btm_ble_dequeue_direct_conn_req |
| * |
| * Description This function dequeues the direct connection request |
| * |
| * Returns None. |
| * |
| ******************************************************************************/ |
| void btm_ble_dequeue_direct_conn_req(BD_ADDR rem_bda) { |
| if (fixed_queue_is_empty(btm_cb.ble_ctr_cb.conn_pending_q)) return; |
| |
| list_t* list = fixed_queue_get_list(btm_cb.ble_ctr_cb.conn_pending_q); |
| for (const list_node_t* node = list_begin(list); node != list_end(list); |
| node = list_next(node)) { |
| tBTM_BLE_CONN_REQ* p_req = (tBTM_BLE_CONN_REQ*)list_node(node); |
| tL2C_LCB* p_lcb = (tL2C_LCB*)p_req->p_param; |
| if ((p_lcb == NULL) || (!p_lcb->in_use)) { |
| continue; |
| } |
| // If BD address matches |
| if (!memcmp(rem_bda, p_lcb->remote_bd_addr, BD_ADDR_LEN)) { |
| fixed_queue_try_remove_from_queue(btm_cb.ble_ctr_cb.conn_pending_q, |
| p_req); |
| l2cu_release_lcb((tL2C_LCB*)p_req->p_param); |
| osi_free((void*)p_req); |
| break; |
| } |
| } |
| } |
| /******************************************************************************* |
| * |
| * Function btm_send_pending_direct_conn |
| * |
| * Description This function send the pending direct connection request in |
| * queue |
| * |
| * Returns true if started, false otherwise |
| * |
| ******************************************************************************/ |
| bool btm_send_pending_direct_conn(void) { |
| tBTM_BLE_CONN_REQ* p_req; |
| bool rt = false; |
| |
| p_req = (tBTM_BLE_CONN_REQ*)fixed_queue_try_dequeue( |
| btm_cb.ble_ctr_cb.conn_pending_q); |
| if (p_req != NULL) { |
| tL2C_LCB* p_lcb = (tL2C_LCB*)(p_req->p_param); |
| /* Ignore entries that might have been released while queued. */ |
| if (p_lcb->in_use) rt = l2cble_init_direct_conn(p_lcb); |
| osi_free(p_req); |
| } |
| |
| return rt; |
| } |
