2 * Copyright (c) 2015 2016 Samsung Electronics Co., Ltd All Rights Reserved
4 * Contact: Anupam Roy <anupam.r@samsung.com>
6 * Licensed under the Apache License, Version 2.0 (the "License");
7 * you may not use this file except in compliance with the License.
8 * You may obtain a copy of the License at
10 * http://www.apache.org/licenses/LICENSE-2.0
12 * Unless required by applicable law or agreed to in writing, software
13 * distributed under the License is distributed on an "AS IS" BASIS,
14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 * See the License for the specific language governing permissions and
16 * limitations under the License.
26 #include <vconf-internal-keys.h>
28 #include <bundle_internal.h>
29 #include <eventsystem.h>
31 /*bt-service headers */
32 #include "bt-internal-types.h"
33 #include "bt-service-common.h"
34 #include "bt-service-util.h"
35 #include "bt-service-main.h"
36 #include "bt-service-core-device.h"
37 #include "bt-service-core-adapter.h"
38 #include "bt-service-event-receiver.h"
39 #include "bt-request-handler.h"
40 #include "bt-service-event.h"
41 #include "bt-service-agent-util.h"
42 #include "bt-service-a2dp-src.h"
43 #include "bt-service-a2dp-sink.h"
44 #ifdef TIZEN_FEATURE_BT_OBEX
45 #include "bt-service-obex-server.h"
47 #include "bt-service-device-internal.h"
49 #ifdef TIZEN_GATT_CLIENT
50 #include "bt-service-gatt.h"
54 #include <oal-event.h>
55 #include <oal-manager.h>
56 #include <oal-adapter-mgr.h>
57 #include <oal-device-mgr.h>
59 #define MAX_BOND_RETRY_COUNT 3
60 #define BT_PASSKEY_MAX_LENGTH 4
62 #define BT_LE_CONN_PARAM_DEFAULT_SUPERVISION_TIMEOUT 6000 /* msec */
64 #define BT_LE_CONN_PARAM_BALANCED_MIN_INTERVAL 30 /* msec */
65 #define BT_LE_CONN_PARAM_BALANCED_MAX_INTERVAL 50 /* msec */
66 #define BT_LE_CONN_PARAM_BALANCED_SLAVE_LATENCY 0 /* event */
68 #define BT_LE_CONN_PARAM_LOW_LATENCY_MIN_INTERVAL 10 /* msec */
69 #define BT_LE_CONN_PARAM_LOW_LATENCY_MAX_INTERVAL 30 /* msec */
70 #define BT_LE_CONN_PARAM_LOW_LATENCY_SLAVE_LATENCY 0 /* event */
72 #define BT_LE_CONN_PARAM_LOW_POWER_MIN_INTERVAL 80 /* msec */
73 #define BT_LE_CONN_PARAM_LOW_POWER_MAX_INTERVAL 100 /* msec */
74 #define BT_LE_CONN_PARAM_LOW_POWER_SLAVE_LATENCY 2 /* event */
76 /* Bonding Info structure */
81 unsigned short conn_type;
82 gboolean is_cancelled_by_user;
83 gboolean is_device_creating;
84 bluetooth_device_address_t *dev_addr;
85 bt_remote_dev_info_t *dev_info;
88 /* Searching Info structure */
92 gboolean is_cancelled_by_user;
93 bluetooth_device_address_t *dev_addr;
94 bt_remote_dev_info_t *dev_info;
95 } bt_service_search_info_data_t;
97 /* Pairing Info structure */
100 gboolean is_autopair;
105 char addr[BT_ADDRESS_STRING_SIZE];
106 bt_remote_dev_info_t *dev_info;
107 } bt_incoming_bond_data_t;
109 /* Bonding and Pairing Informations */
110 bt_bond_data_t *trigger_bond_info;
111 bt_bond_data_t *trigger_unbond_info;
112 bt_pairing_data_t *trigger_pairing_info;
113 bt_service_search_info_data_t *service_search_info;
115 bt_incoming_bond_data_t *incoming_bond_info;
118 BT_DEVICE_BOND_STATE_NONE,
119 BT_DEVICE_BOND_STATE_CANCEL_DISCOVERY,
120 BT_DEVICE_BOND_STATE_DISCOVERY_CANCELLED,
121 BT_DEVICE_BOND_STATE_REMOVE_BONDING,
122 BT_DEVICE_BOND_STATE_REMOVED_BONDING,
123 BT_DEVICE_BOND_STATE_STARTED,
124 BT_DEVICE_BOND_STATE_WAIT_PROP,
125 BT_DEVICE_BOND_STATE_WAIT_DID
130 BT_DEVICE_INCOMING_BOND_INFO,
131 BT_DEVICE_UNBOND_INFO
134 /* BT device bond state variable */
135 static bt_bond_state_e bt_device_bond_state;
136 static int bond_retry_count;
138 static char *passkey_watcher;
139 static GSList *pin_info_list = NULL;
141 /** DBFW+ Event Code */
143 BT_DBFW_PLUS_EVENT_CODE_LINK_LOSS_INFO = 0x10,
144 BT_DBFW_PLUS_EVENT_CODE_LINK_LOSS_CLOCK_INFO = 0x11,
145 BT_DBFW_PLUS_EVENT_CODE_LINK_LOSS_PAGE_SLOTS = 0x12,
146 BT_DBFW_PLUS_EVENT_CODE_LINK_LOSS_LMP_TRACE = 0x13,
147 BT_DBFW_PLUS_EVENT_CODE_A2DP_INFO = 0x20,
148 BT_DBFW_PLUS_EVENT_CODE_HFP_INFO = 0x31,
149 BT_DBFW_PLUS_EVENT_CODE_HFP_SCO_PACKET_TYPE_INFO = 0x32,
150 } bt_dbfw_plus_event_code_t;
152 static int dbfw_rssi;
154 #ifdef TIZEN_GATT_CLIENT
160 } bt_connected_le_dev_t;
169 } bt_le_conn_param_t;
171 static GSList *le_connected_dev_list = NULL;
173 #define BT_LE_CONN_INTERVAL_MIN 7.5 /* msec */
174 #define BT_LE_CONN_INTERVAL_MAX 4000 /* msec */
175 #define BT_LE_CONN_SUPER_TO_MIN 100 /* msec */
176 #define BT_LE_CONN_SUPER_TO_MAX 32000 /* msec */
177 #define BT_LE_CONN_SLAVE_LATENCY_MAX 499
178 #define BT_LE_CONN_TO_SPLIT 10 /* msec */
179 #define BT_LE_CONN_INTERVAL_SPLIT 1.25 /* msec */
181 static void _bt_handle_le_connected_dev_info(const char *address, gboolean connected);
184 /* Forward declaration */
185 static void __bt_device_event_handler(int event_type, gpointer event_data);
186 static void __bt_device_remote_device_found_callback(gpointer event_data, gboolean is_ble);
189 static int __bt_device_handle_bond_state(void);
190 static void __bt_free_bond_info(uint8_t type);
191 static void __bt_free_service_search_info(bt_service_search_info_data_t **p_info);
192 static void __bt_device_handle_bond_completion_event(bt_address_t *bd_addr);
193 static void __bt_device_handle_bond_removal_event(bt_address_t *bd_addr);
194 static void __bt_device_handle_bond_failed_event(event_dev_bond_failed_t* bond_fail_event);
195 static void __bt_handle_ongoing_bond(bt_remote_dev_info_t *remote_dev_info, gboolean incoming_bond);
196 static void __bt_device_acl_state_changed_callback(event_dev_conn_status_t *acl_event,
197 gboolean connected, unsigned char type);
198 static void __bt_free_pairing_info(bt_pairing_data_t **p_info);
200 static void __bt_device_ssp_consent_callback(remote_device_t* dev_info);
201 static void __bt_device_pin_request_callback(remote_device_t* pin_req_event);
202 static void __bt_device_ssp_passkey_display_callback(event_dev_passkey_t *dev_info);
203 static void __bt_device_ssp_passkey_confirmation_callback(event_dev_passkey_t *dev_info);
204 static void __bt_device_ssp_passkey_entry_callback(remote_device_t* dev_info);
205 static void __bt_device_authorization_request_callback(event_dev_authorize_req_t* auth_event);
207 static void __bt_device_services_callback(event_dev_services_t* uuid_list);
208 static void __bt_handle_ongoing_device_service_search(bt_remote_dev_info_t *remote_dev_info);
210 static void __bt_device_trusted_callback(gboolean trusted, event_dev_trust_t* info);
212 static int __bt_get_device_pin_code(const char *address, char *pin_code);
213 static gboolean __bt_ignore_auto_pairing_request(const char *address);
215 gboolean _bt_is_device_creating(void)
217 if (!trigger_bond_info)
219 return trigger_bond_info->is_device_creating;
222 void _bt_device_state_handle_callback_set_request(void)
224 _bt_service_register_event_handler_callback(
225 BT_DEVICE_MODULE, __bt_device_event_handler);
228 void __bt_device_handle_pending_requests(int result, int service_function,
229 void *user_data, unsigned int size)
233 invocation_info_t *req_info = NULL;
237 /* Get method invocation context */
238 for (l = _bt_get_invocation_list(); l != NULL; ) {
241 if (req_info == NULL || req_info->service_function != service_function)
244 switch (service_function) {
245 case BT_SEARCH_SERVICE: {
246 char *address = (char *)user_data;
247 if (strncmp((char*)req_info->user_data, address, BT_ADDRESS_STRING_SIZE)) {
248 BT_ERR("Unexpected: Info request pending for a different address!!");
251 BT_INFO("Found info request addr [%s]", (char*)req_info->user_data);
252 bt_sdp_info_t sdp_info;
254 memset(&sdp_info, 0x00, sizeof(bt_sdp_info_t));
255 _bt_convert_addr_string_to_type(sdp_info.device_addr.addr, address);
257 out_param = g_array_new(FALSE, FALSE, sizeof(gchar));
258 g_array_append_vals(out_param, &sdp_info, sizeof(bt_sdp_info_t));
259 _bt_service_method_return(req_info->context, out_param, result);
261 g_free(req_info->user_data);
262 _bt_free_info_from_invocation_list(req_info);
263 g_array_free(out_param, TRUE);
267 case BT_BOND_DEVICE: {
268 char *address = (char *)user_data;
269 if (strncmp((char*)req_info->user_data, address, BT_ADDRESS_STRING_SIZE)) {
270 BT_ERR("Unexpected: Info request pending for a different address!!");
273 BT_INFO("Found info request addr [%s]", (char*)req_info->user_data);
274 bluetooth_device_info_t dev_info;
275 memset(&dev_info, 0x00, sizeof(bluetooth_device_info_t));
276 _bt_convert_addr_string_to_type(dev_info.device_address.addr,
278 out_param = g_array_new(FALSE, FALSE, sizeof(gchar));
279 g_array_append_vals(out_param, &dev_info,
280 sizeof(bluetooth_device_info_t));
281 _bt_service_method_return(req_info->context, out_param, result);
283 g_free(req_info->user_data);
284 _bt_free_info_from_invocation_list(req_info);
285 g_array_free(out_param, TRUE);
289 case BT_UNBOND_DEVICE: {
290 char *address = (char *)user_data;
291 if (strncmp((char*)req_info->user_data, address, BT_ADDRESS_STRING_SIZE)) {
292 BT_ERR("Unexpected: Info request pending for a different address!!");
295 BT_INFO("Found info request addr [%s]", (char*)req_info->user_data);
296 bluetooth_device_address_t dev_addr;
297 _bt_convert_addr_string_to_type(dev_addr.addr, address);
298 out_param = g_array_new(FALSE, FALSE, sizeof(gchar));
299 g_array_append_vals(out_param, &dev_addr,
300 sizeof(bluetooth_device_address_t));
301 _bt_service_method_return(req_info->context, out_param, result);
303 g_free(req_info->user_data);
304 _bt_free_info_from_invocation_list(req_info);
305 g_array_free(out_param, TRUE);
310 BT_ERR("Unhandled case");
318 * Remote device properties are received on all following conditions
319 * a. When Bonding in on-going
320 * b. When device properties are updated\changed for a connected device
321 * (due to SDP or any other reason)
323 static void __bt_device_remote_properties_callback(event_dev_properties_t *oal_dev_props)
325 bt_remote_dev_info_t *rem_info = NULL;
328 rem_info = g_malloc0(sizeof(bt_remote_dev_info_t));
329 _bt_copy_remote_dev(rem_info, &(oal_dev_props->device_info));
331 if (oal_dev_props->adv_len > 0) {
334 rem_info->manufacturer_data_len = oal_dev_props->adv_len;
335 rem_info->manufacturer_data =
336 g_memdup(oal_dev_props->adv_data,
337 oal_dev_props->adv_len);
338 BT_DBG("----Advertising Data Length: %d",
339 rem_info->manufacturer_data_len);
341 for (k = 0; k < rem_info->manufacturer_data_len; k++) {
342 BT_INFO("Check data[%d] = [[0x%x]",
343 k, oal_dev_props->adv_data[k]);
346 rem_info->manufacturer_data = NULL;
347 rem_info->manufacturer_data_len = 0;
350 /* a. Check if bonding is on-going, if yes, we MUST update the bonding device properties */
351 if (trigger_bond_info && !strcmp(trigger_bond_info->addr, rem_info->address)) {
352 BT_INFO("Bonding is ongoing, try update properties");
353 if (!trigger_bond_info->dev_info ||
354 (!trigger_bond_info->dev_info->name &&
355 !trigger_bond_info->dev_info->alias) ||
356 !trigger_bond_info->dev_info->address ||
357 trigger_bond_info->dev_info->uuid_count == 0) {
358 BT_INFO("Complete data is not present, Assigning rem_info");
359 if (!trigger_bond_info->dev_info)
360 trigger_bond_info->dev_info = g_malloc0(sizeof(bt_remote_dev_info_t));
361 _bt_copy_remote_dev_info(trigger_bond_info->dev_info, rem_info);
364 BT_DBG("Bonding dev addr has matched with remote dev properties address [%s]", rem_info->address);
365 __bt_handle_ongoing_bond(trigger_bond_info->dev_info, FALSE);
366 } else if (incoming_bond_info && !g_strcmp0(incoming_bond_info->addr, rem_info->address)) {
367 BT_INFO("Incoming Bond is ongoing, try update properties");
368 if (!incoming_bond_info->dev_info ||
369 (!incoming_bond_info->dev_info->name &&
370 !incoming_bond_info->dev_info->alias) ||
371 !incoming_bond_info->dev_info->address ||
372 incoming_bond_info->dev_info->uuid_count == 0) {
373 BT_INFO("Complete data is not present, Assigning rem_info");
374 if (!incoming_bond_info->dev_info)
375 incoming_bond_info->dev_info = g_malloc0(sizeof(bt_remote_dev_info_t));
376 _bt_copy_remote_dev_info(incoming_bond_info->dev_info, rem_info);
379 BT_DBG("Incoming Bond addr matches with remote dev properties address [%s]", rem_info->address);
380 __bt_handle_ongoing_bond(incoming_bond_info->dev_info, TRUE);
383 /* Add device to bonded list */
384 _bt_service_add_device_to_bonded_list(rem_info);
386 /* Handle SDP Device properties update */
387 if (service_search_info && service_search_info->dev_info) {
388 if (!strcmp(service_search_info->addr, rem_info->address)) {
389 BT_DBG("Properties received and SDP request pending, fill device properties and send event");
390 service_search_info->dev_info->class = rem_info->class;
391 service_search_info->dev_info->paired = rem_info->paired;
392 service_search_info->dev_info->connected = rem_info->connected;
393 service_search_info->dev_info->rssi = rem_info->rssi;
394 service_search_info->dev_info->addr_type = rem_info->addr_type;
395 service_search_info->dev_info->trust = rem_info->trust;
398 service_search_info->dev_info->manufacturer_data = NULL;
399 service_search_info->dev_info->manufacturer_data_len = 0;
401 __bt_handle_ongoing_device_service_search(service_search_info->dev_info);
405 _bt_free_remote_dev(rem_info);
409 static int __get_oal_trusted_profile(bluetooth_trusted_profile_t profile)
412 case TRUSTED_PROFILE_PBAP:
413 return OAL_TRUSTED_PROFILE_PBAP;
414 case TRUSTED_PROFILE_MAP:
415 return OAL_TRUSTED_PROFILE_MAP;
416 case TRUSTED_PROFILE_SAP:
417 return OAL_TRUSTED_PROFILE_SAP;
418 case TRUSTED_PROFILE_HFP_HF:
419 return OAL_TRUSTED_PROFILE_HFP_HF;
420 case TRUSTED_PROFILE_A2DP:
421 return OAL_TRUSTED_PROFILE_A2DP;
422 case TRUSTED_PROFILE_ALL:
423 return OAL_TRUSTED_PROFILE_ALL;
429 int _bt_set_trust_profile(bluetooth_device_address_t *addr,
430 bluetooth_trusted_profile_t profile, gboolean trust)
433 bt_address_t bd_addr;
434 oal_trusted_profile_e oal_profile;
438 retv_if(!addr, BLUETOOTH_ERROR_INVALID_PARAM);
440 memcpy(bd_addr.addr, addr, BLUETOOTH_ADDRESS_LENGTH);
441 oal_profile = __get_oal_trusted_profile(profile);
442 retv_if(0 == oal_profile, BLUETOOTH_ERROR_NOT_SUPPORT);
444 result = device_set_trust_profile(&bd_addr, oal_profile, trust);
445 if (result != OAL_STATUS_SUCCESS) {
446 BT_ERR("device_set_trust_profile error: [%d]", result);
447 return BLUETOOTH_ERROR_INTERNAL;
451 return BLUETOOTH_ERROR_NONE;
454 int _bt_get_trust_profile(bluetooth_device_address_t *addr,
455 bluetooth_trusted_profile_t profile, guint *trust)
458 bt_address_t bd_addr;
459 oal_trusted_profile_e oal_profile;
463 retv_if(!addr, BLUETOOTH_ERROR_INVALID_PARAM);
465 memcpy(bd_addr.addr, addr, BLUETOOTH_ADDRESS_LENGTH);
466 oal_profile = __get_oal_trusted_profile(profile);
467 retv_if(0 == oal_profile, BLUETOOTH_ERROR_NOT_SUPPORT);
469 result = device_get_trust_profile(&bd_addr, oal_profile, trust);
470 if (result != OAL_STATUS_SUCCESS) {
471 BT_ERR("device_set_trust_profile error: [%d]", result);
472 return BLUETOOTH_ERROR_INTERNAL;
476 return BLUETOOTH_ERROR_NONE;
479 static void __bt_handle_ongoing_device_service_search(bt_remote_dev_info_t *remote_dev_info)
481 GVariant *param = NULL;
482 GVariant *uuids = NULL;
483 GVariantBuilder *builder = NULL;
484 GVariant *manufacturer_data;
488 BT_INFO("Send Service Search request event");
490 if (remote_dev_info->alias)
491 name = remote_dev_info->alias;
493 name = remote_dev_info->name;
495 builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
496 for (i = 0; i < remote_dev_info->uuid_count; i++) {
497 g_variant_builder_add(builder, "s",
498 remote_dev_info->uuids[i]);
500 uuids = g_variant_new("as", builder);
501 g_variant_builder_unref(builder);
502 manufacturer_data = g_variant_new_from_data((const GVariantType *)"ay",
503 remote_dev_info->manufacturer_data, remote_dev_info->manufacturer_data_len,
506 param = g_variant_new("(isunsbub@asn@ay)",
507 BLUETOOTH_ERROR_NONE,
508 remote_dev_info->address,
509 remote_dev_info->class,
510 remote_dev_info->rssi,
512 remote_dev_info->paired,
513 remote_dev_info->connected,
514 remote_dev_info->trust,
516 remote_dev_info->manufacturer_data_len,
518 /* Send the event to application */
519 _bt_send_event(BT_ADAPTER_EVENT,
520 BLUETOOTH_EVENT_SERVICE_SEARCHED,
523 __bt_free_service_search_info(&service_search_info);
527 static void __bt_device_services_callback(event_dev_services_t* uuid_list)
529 bt_remote_dev_info_t *rem_info = NULL;
533 if (trigger_bond_info && _bt_compare_adddress(trigger_bond_info->dev_addr,
534 (bluetooth_device_address_t *)&uuid_list->address) == TRUE) {
535 bluetooth_device_address_t *dev_addr = trigger_bond_info->dev_addr;
537 BT_DBG("Bonding dev addr has matched");
538 /* Bonding ongoing, Query device properties again */
539 if (BLUETOOTH_ERROR_NONE ==
540 _bt_device_get_bonded_device_info(dev_addr))
541 BT_DBG("_bt_device_get_bonded_device_info success");
543 BT_ERR("_bt_device_get_bonded_device_info failed");
546 if (service_search_info == NULL) {
548 BT_DBG("searching_info == NULL");
552 if (_bt_compare_adddress(service_search_info->dev_addr,
553 (bluetooth_device_address_t *)&uuid_list->address) == FALSE) {
554 BT_DBG("This device is not queried");
558 rem_info = g_malloc0(sizeof(bt_remote_dev_info_t));
559 memset(rem_info, 0x00, sizeof(bt_remote_dev_info_t));
561 rem_info->address = g_new0(char, BT_ADDRESS_STRING_SIZE);
562 _bt_convert_addr_type_to_string(rem_info->address, uuid_list->address.addr);
564 rem_info->uuid_count = uuid_list->num;
566 BT_INFO("Address [%s]", rem_info->address);
567 BT_INFO("Number of UUID's [%d]", rem_info->uuid_count);
568 if (rem_info->uuid_count > 0)
569 rem_info->uuids = g_new0(char *, rem_info->uuid_count);
571 /* Fill Remote Device Service List list */
572 for (i = 0; i < rem_info->uuid_count; i++) {
573 rem_info->uuids[i] = g_malloc0(BLUETOOTH_UUID_STRING_MAX);
574 _bt_uuid_to_string((service_uuid_t *)&uuid_list->service_list[i].uuid, rem_info->uuids[i]);
575 BT_DBG("UUID value=%s", rem_info->uuids[i]);
578 /* Update local cache */
579 _bt_update_remote_dev_property(rem_info->address, DEV_PROP_SERVICES, (void *)rem_info);
581 BT_DBG("DBUS return");
582 __bt_device_handle_pending_requests(BLUETOOTH_ERROR_NONE, BT_SEARCH_SERVICE,
583 service_search_info->addr, BT_ADDRESS_STRING_SIZE);
585 /* Save UUID List of remote devices */
586 if (service_search_info->dev_info)
587 _bt_free_remote_dev(service_search_info->dev_info);
588 service_search_info->dev_info = rem_info;
590 /* Query Other device properties */
591 if (_bt_device_get_bonded_device_info(service_search_info->dev_addr) == BLUETOOTH_ERROR_NONE) {
592 BT_DBG("Bonded device info query posted to stack successfully");
594 BT_DBG("Possibly internal stack error in bonded device info query, perform cleanup");
595 __bt_free_service_search_info(&service_search_info);
600 static void __bt_device_authorization_request_callback(event_dev_authorize_req_t* auth_event)
602 oal_service_t service_d = auth_event->service_id;
603 gchar address[BT_ADDRESS_STR_LEN];
606 _bt_convert_addr_type_to_string(address, auth_event->address.addr);
608 BT_INFO("service_d: %d", service_d);
612 BT_INFO("Incoming HID Profile conn Req from device addr [%s]", address);
614 case A2DP_SERVICE_ID:
615 BT_INFO("Incoming A2DP(Remote Sink) profile conn Req from device addr [%s]", address);
616 _bt_a2dp_src_handle_incoming_authorization(address, service_d);
618 case A2DP_SRC_SERVICE_ID:
619 BT_INFO("Incoming A2DP(Remote Source) Profile conn Req from device addr [%s]", address);
620 _bt_a2dp_sink_handle_incoming_authorization(address, service_d);
622 case AVRCP_SERVICE_ID:
623 BT_INFO("Incoming AVRCP (Remote) Profile conn Req from device addr [%s]", address);
625 case AVRCP_CT_SERVICE_ID:
626 BT_INFO("Incoming AVRCP (Controller) Profile conn Req from device addr [%s]", address);
628 #ifdef TIZEN_FEATURE_BT_OBEX
629 case OPP_SERVICE_ID: {
630 GVariant *param = NULL;
633 if (_bt_obex_server_is_custom() == false) {
634 /* Allow the connection for native OPP server */
638 name = g_strdup(address);
640 BT_INFO("Incoming OPP conn Req from device addr [%s]", address);
641 _bt_obex_server_set_pending_conn_auth_device_addr(address);
642 param = g_variant_new("(iss)", BLUETOOTH_ERROR_NONE, address, name);
643 _bt_send_event(BT_OPP_SERVER_EVENT,
644 BLUETOOTH_EVENT_OBEX_SERVER_CONNECTION_AUTHORIZE, param);
650 BT_INFO("Incoming HSP_SERVICE_ID conn Req from device addr [%s]", address);
653 BT_INFO("Incoming HFP_SERVICE_ID conn Req from device addr [%s]", address);
656 BT_INFO("Incoming SAP_SERVICE_ID conn Req from device addr [%s]", address);
658 case HSP_HS_SERVICE_ID:
659 BT_INFO("Incoming HSP_HS_SERVICE_ID conn Req from device addr [%s]", address);
661 case HFP_HS_SERVICE_ID:
662 BT_INFO("Incoming HFP_HS_SERVICE_ID conn Req from device addr [%s]", address);
665 case IOTIVITY_SERVICE_ID:
666 BT_INFO("Incoming IOTIVITY_SERVICE_ID conn Req from device addr [%s]", address);
670 /* For now, reject authorization for any service apart from above switch cases */
671 BT_INFO("Incoming Profile conn req with service ID [%d] from device addr [%s]", service_d, address);
672 res = device_reply_auth_request((bt_address_t*)&auth_event->address, service_d, FALSE, FALSE);
673 if (res != OAL_STATUS_SUCCESS)
674 BT_ERR("authorize_response: %d", res);
678 /* Auto accept authorization request for HID, A2DP and AVRCP profiles */
679 BT_INFO("Auto Accept authorization");
680 res = device_reply_auth_request((bt_address_t*)&auth_event->address, service_d, TRUE, FALSE);
681 if (res != OAL_STATUS_SUCCESS)
682 BT_ERR("authorize_response: %d", res);
686 static void __bt_handle_ongoing_bond(bt_remote_dev_info_t *remote_dev_info, gboolean incoming_bond)
688 GVariant *param = NULL;
690 if ((remote_dev_info->name || remote_dev_info->alias)
691 && remote_dev_info->address
692 && remote_dev_info->uuids) {
693 GVariant *uuids = NULL;
694 GVariantBuilder *builder = NULL;
695 GVariant *manufacturer_data;
699 if (remote_dev_info->alias)
700 name = remote_dev_info->alias;
702 name = remote_dev_info->name;
704 builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
705 for (i = 0; i < remote_dev_info->uuid_count; i++) {
706 g_variant_builder_add(builder, "s",
707 remote_dev_info->uuids[i]);
709 uuids = g_variant_new("as", builder);
710 g_variant_builder_unref(builder);
711 manufacturer_data = g_variant_new_from_data((const GVariantType *)"ay",
712 remote_dev_info->manufacturer_data, remote_dev_info->manufacturer_data_len,
715 param = g_variant_new("(isunsbub@asn@ay)",
716 BLUETOOTH_ERROR_NONE,
717 remote_dev_info->address,
718 remote_dev_info->class,
719 remote_dev_info->rssi,
721 remote_dev_info->paired,
722 remote_dev_info->connected,
723 remote_dev_info->trust,
725 remote_dev_info->manufacturer_data_len,
727 /* Send the event to application */
728 _bt_send_event(BT_ADAPTER_EVENT,
729 BLUETOOTH_EVENT_BONDING_FINISHED,
731 BT_PERMANENT_LOG("Paired %s", remote_dev_info->address + 12);
732 BT_INFO_C("### Paired %s", remote_dev_info->address);
734 __bt_free_bond_info(BT_DEVICE_INCOMING_BOND_INFO);
736 __bt_free_bond_info(BT_DEVICE_BOND_INFO);
737 __bt_free_pairing_info(&trigger_pairing_info);
740 BT_INFO("Lets wait for more remote device properties");
744 static void __handle_incoming_bond_created_event(bt_address_t *bd_addr)
746 char address[BT_ADDRESS_STRING_SIZE];
747 bluetooth_device_address_t dev_addr;
750 * BlueZ sends paired signal for each paired device, during activation,
751 * We should ignore this, otherwise application thinks that a new device
754 if (_bt_adapter_get_status() != BT_ACTIVATED) {
755 BT_DBG("BT is not activated, so ignore this");
759 _bt_convert_addr_type_to_string(address, bd_addr->addr);
760 if (!incoming_bond_info) {
761 incoming_bond_info = g_malloc0(sizeof(bt_incoming_bond_data_t));
763 if (g_strcmp0(incoming_bond_info->addr, address)) {
764 BT_DBG("Previous Bond address: [%s] differs from new address: [%s]",
765 address, incoming_bond_info->addr);
766 __bt_free_bond_info(BT_DEVICE_INCOMING_BOND_INFO);
767 incoming_bond_info = g_malloc0(sizeof(bt_incoming_bond_data_t));
771 BT_INFO("Incoming bond successfully completed");
772 g_strlcpy(incoming_bond_info->addr, address, BT_ADDRESS_STRING_SIZE);
773 incoming_bond_info->dev_info = NULL;
775 _bt_convert_addr_string_to_type(dev_addr.addr, incoming_bond_info->addr);
776 if (BLUETOOTH_ERROR_NONE == _bt_device_get_bonded_device_info(&dev_addr)) {
777 BT_DBG("Bonded device info query posted to stack successfully");
779 BT_ERR("Bonded device info query failed");
780 __bt_free_bond_info(BT_DEVICE_INCOMING_BOND_INFO);
785 static void __bt_device_handle_bond_completion_event(bt_address_t *bd_addr)
787 gchar address[BT_ADDRESS_STR_LEN];
788 bluetooth_device_address_t dev_addr;
790 if (trigger_bond_info == NULL) {
792 BT_DBG("trigger_bond_info == NULL, Handle incomming bond event");
793 __handle_incoming_bond_created_event(bd_addr);
797 _bt_convert_addr_type_to_string(address, bd_addr->addr);
798 if (g_strcmp0(trigger_bond_info->addr, address)) {
799 BT_DBG("Bonding address= [%s] is different from requested address =[%s]",
800 address, trigger_bond_info->addr);
801 __handle_incoming_bond_created_event(bd_addr);
805 BT_INFO("Bonding successfully completed");
806 /* Bonding state will be cleaned up & BONDING FINISHED EVENT
807 will be sent only when Properties are fetched from stack
808 Till that time lets not free trigger_bond_info.
809 However it is possible that while fetching device properties, internal
810 stack error can occur which can lead to no valid properties or
811 no properties at all. So in such cases, we must not wait for properties,
812 otherwise, it can lead to infinite wait */
813 _bt_convert_addr_string_to_type(dev_addr.addr,
814 trigger_bond_info->addr);
816 if (_bt_device_get_bonded_device_info(&dev_addr) == BLUETOOTH_ERROR_NONE) {
817 BT_DBG("BOnded device info query posted to stack successfully");
818 __bt_device_handle_pending_requests(BLUETOOTH_ERROR_NONE, BT_BOND_DEVICE,
819 trigger_bond_info->addr, BT_ADDRESS_STRING_SIZE);
821 BT_DBG("Possibly internal stack error in bonded device info query, perform cleanup");
822 __bt_device_handle_pending_requests(BLUETOOTH_ERROR_INTERNAL, BT_BOND_DEVICE,
823 trigger_bond_info->addr, BT_ADDRESS_STRING_SIZE);
824 /* Destroy if at all device got bonded at stack level */
825 device_destroy_bond((bt_address_t *)trigger_bond_info->dev_addr);
827 __bt_free_bond_info(BT_DEVICE_BOND_INFO);
828 __bt_free_pairing_info(&trigger_pairing_info);
832 /**********************************************************************************************
833 * Bond removal event can be triggered for following reasons -
834 * a. If Bonding procedure if failed (for Auth failed, Page timeout, cancelled by user etc)
835 * b. If Application requests for explicitly removing the bond
836 * c. When application attempt to create bond,bond is removed first which triggers this event
837 * c. is in-line with Bluedroid bond create\emoval architecture
838 *********************************************************************************************/
839 static void __bt_device_handle_bond_removal_event(bt_address_t *bd_addr)
841 char address[BT_ADDRESS_STRING_SIZE];
845 _bt_convert_addr_type_to_string(address, bd_addr->addr);
846 _bt_service_remove_device_from_bonded_list(address);
848 if (trigger_unbond_info) {
849 BT_INFO("Bond removal request successfully handled, return DBUS and send event");
850 GVariant *param = NULL;
851 __bt_device_handle_pending_requests(BLUETOOTH_ERROR_NONE, BT_UNBOND_DEVICE,
852 trigger_unbond_info->addr, BT_ADDRESS_STRING_SIZE);
853 param = g_variant_new("(is)", BLUETOOTH_ERROR_NONE, trigger_unbond_info->addr);
854 _bt_send_event(BT_ADAPTER_EVENT,
855 BLUETOOTH_EVENT_BONDED_DEVICE_REMOVED,
857 BT_PERMANENT_LOG("Unpaired %s", trigger_unbond_info->addr + 12);
858 __bt_free_bond_info(BT_DEVICE_UNBOND_INFO);
859 __bt_free_pairing_info(&trigger_pairing_info);
860 } else if (trigger_bond_info) {
861 BT_ERR("Bonding was removed");
862 __bt_device_handle_bond_state();
867 static void __bt_device_handle_bond_failed_event(event_dev_bond_failed_t* bond_fail_event)
870 oal_status_t status = bond_fail_event->status;
871 BT_INFO("Bonding failed, reason: %d", status);
874 case OAL_STATUS_RMT_DEVICE_DOWN:
876 if (trigger_bond_info) {
877 BT_INFO("OAL_STATUS_RMT_DEVICE_DOWN:Lets retry bonding!! retry count [%d]",
879 int ret = OAL_STATUS_SUCCESS;
880 if (bond_retry_count < MAX_BOND_RETRY_COUNT) {
881 ret = device_create_bond((bt_address_t *)trigger_bond_info->dev_addr, trigger_bond_info->conn_type);
882 if (ret != OAL_STATUS_SUCCESS) {
883 BT_ERR("Create Bond procedure could not suceed");
884 __bt_device_handle_pending_requests(BLUETOOTH_ERROR_INTERNAL, BT_BOND_DEVICE,
885 trigger_bond_info->addr, BT_ADDRESS_STRING_SIZE);
886 __bt_free_bond_info(BT_DEVICE_BOND_INFO);
887 __bt_free_pairing_info(&trigger_pairing_info);
888 bond_retry_count = 0;
892 BT_ERR("Create Bond failed MAX_BOND_RETRY_COUNT TIMES!!");
893 __bt_device_handle_pending_requests(BLUETOOTH_ERROR_INTERNAL, BT_BOND_DEVICE,
894 trigger_bond_info->addr, BT_ADDRESS_STRING_SIZE);
895 __bt_free_bond_info(BT_DEVICE_BOND_INFO);
896 __bt_free_pairing_info(&trigger_pairing_info);
897 bond_retry_count = 0;
902 case OAL_STATUS_AUTH_FAILED:
904 /*TODO Auto pairing status set & ignore auto pairing logics can be done at this point.
905 To be considered later*/
906 int result = BLUETOOTH_ERROR_INTERNAL;
907 BT_INFO("BT_OPERATION_STATUS_AUTH_FAILED");
909 BT_INFO("add device in pairing black list");
910 _bt_set_autopair_status_in_bonding_info(FALSE);
912 if (trigger_bond_info) {
913 __bt_ignore_auto_pairing_request(trigger_bond_info->addr);
914 BT_ERR("Create Bond procedure could not suceed, check if cancelled by User");
915 if (trigger_bond_info->is_cancelled_by_user) {
916 BT_ERR("Bonding is cancelled by user");
917 result = BLUETOOTH_ERROR_CANCEL_BY_USER;
919 __bt_device_handle_pending_requests(result, BT_BOND_DEVICE,
920 trigger_bond_info->addr, BT_ADDRESS_STRING_SIZE);
921 __bt_free_bond_info(BT_DEVICE_BOND_INFO);
924 __bt_free_pairing_info(&trigger_pairing_info);
927 case OAL_STATUS_INTERNAL_ERROR:
929 BT_INFO("OAL_STATUS_INTERNAL_ERROR");
930 if (trigger_unbond_info) {
931 BT_INFO("Bond removal request failed, return DBUS and send event");
932 GVariant *param = NULL;
933 __bt_device_handle_pending_requests(BLUETOOTH_ERROR_INTERNAL, BT_UNBOND_DEVICE,
934 trigger_unbond_info->addr, BT_ADDRESS_STRING_SIZE);
935 param = g_variant_new("(is)", BLUETOOTH_ERROR_INTERNAL, trigger_unbond_info->addr);
936 _bt_send_event(BT_ADAPTER_EVENT,
937 BLUETOOTH_EVENT_BONDED_DEVICE_REMOVED,
939 __bt_free_bond_info(BT_DEVICE_UNBOND_INFO);
940 } else if (trigger_bond_info) {
941 if (__bt_device_handle_bond_state() != BLUETOOTH_ERROR_NONE) {
942 if (trigger_bond_info) {
943 __bt_device_handle_pending_requests(BLUETOOTH_ERROR_INTERNAL, BT_BOND_DEVICE,
944 trigger_bond_info->addr, BT_ADDRESS_STRING_SIZE);
945 __bt_free_bond_info(BT_DEVICE_BOND_INFO);
950 __bt_free_pairing_info(&trigger_pairing_info);
955 BT_ERR("Unknown status of Bond failed event status [%d]", status);
963 static gboolean __bt_device_init_dbfw_rssi_cb(gpointer user_data)
969 static void __bt_device_parse_dbfw_set_rssi(unsigned char *data, uint32_t length)
972 dbfw_rssi = 0xFFFFFF00 | data[4];
973 BT_INFO("dbfw_rssi = %d", dbfw_rssi);
974 g_timeout_add(1000, __bt_device_init_dbfw_rssi_cb, NULL);
977 static void __bt_device_dbfw_plus_info_callback(event_dev_dbfw_plus_info_t *dbfw_info)
980 char *data_str = NULL;
983 data_str = g_malloc0(dbfw_info->length * 2 + 1);
984 for (i = 0; i < dbfw_info->length; i++)
985 snprintf(&data_str[i * 2], 3, "%02X", dbfw_info->data[i]);
986 data_str[i * 2] = '\0';
988 switch(dbfw_info->event_code) {
989 case BT_DBFW_PLUS_EVENT_CODE_LINK_LOSS_INFO:
990 BT_DBG("## Event Code: Linkloss Debug Info");
991 snprintf(evt_str, 18, "[DBFW]Linkloss(D)");
992 __bt_device_parse_dbfw_set_rssi(dbfw_info->data, dbfw_info->length);
994 case BT_DBFW_PLUS_EVENT_CODE_LINK_LOSS_CLOCK_INFO:
995 BT_DBG("## Event Code: Linkloss Clock Info");
996 snprintf(evt_str, 18, "[DBFW]Linkloss(C)");
998 case BT_DBFW_PLUS_EVENT_CODE_LINK_LOSS_PAGE_SLOTS:
999 BT_DBG("## Event Code: Linkloss Page slots");
1000 snprintf(evt_str, 18, "[DBFW]Linkloss(P)");
1002 case BT_DBFW_PLUS_EVENT_CODE_LINK_LOSS_LMP_TRACE:
1003 BT_DBG("## Event Code: Linkloss LMP trace");
1004 snprintf(evt_str, 18, "[DBFW]Linkloss(L)");
1006 case BT_DBFW_PLUS_EVENT_CODE_A2DP_INFO:
1007 BT_DBG("## Event Code: A2DP Info");
1008 snprintf(evt_str, 18, "[DBFW]A2DP");
1010 case BT_DBFW_PLUS_EVENT_CODE_HFP_INFO:
1011 BT_DBG("## Event Code: HFP Info");
1012 snprintf(evt_str, 18, "[DBFW]HFP");
1014 case BT_DBFW_PLUS_EVENT_CODE_HFP_SCO_PACKET_TYPE_INFO:
1015 BT_DBG("## Event Code: HFP SCO Packet Type");
1016 snprintf(evt_str, 18, "[DBFW]SCO");
1019 BT_DBG("## Unknown event code (0x%02x)", dbfw_info->event_code);
1020 snprintf(evt_str, 18, "[DBFW]0x%02X", dbfw_info->event_code);
1024 BT_PERMANENT_LOG("%s 0x%s", evt_str, data_str);
1028 static void __bt_device_event_handler(int event_type, gpointer event_data)
1030 int eventcheck = OAL_EVENT_DEVICE_PROPERTIES;
1031 BT_DBG("event [%d] Event check = [%d]", event_type, eventcheck);
1033 switch (event_type) {
1034 case OAL_EVENT_ADAPTER_INQUIRY_RESULT_BREDR_ONLY: {
1035 BT_INFO("BREDR Device Found");
1036 __bt_device_remote_device_found_callback(event_data, FALSE);
1039 case OAL_EVENT_ADAPTER_INQUIRY_RESULT_BLE: {
1040 BT_INFO("Dual Device Found");
1041 __bt_device_remote_device_found_callback(event_data, FALSE);
1044 case OAL_EVENT_DEVICE_PROPERTIES: {
1045 BT_INFO("Remote Device properties Received");
1046 __bt_device_remote_properties_callback((event_dev_properties_t *)event_data);
1049 case OAL_EVENT_DEVICE_BONDING_SUCCESS: {
1050 BT_INFO("Bonding Success event Received");
1051 __bt_device_handle_bond_completion_event((bt_address_t *)event_data);
1054 case OAL_EVENT_DEVICE_BONDING_REMOVED: {
1055 BT_INFO("Bonding Removed event Received");
1056 __bt_device_handle_bond_removal_event((bt_address_t *)event_data);
1059 case OAL_EVENT_DEVICE_BONDING_FAILED: {
1060 BT_INFO("Bonding Failed event Received");
1061 __bt_device_handle_bond_failed_event((event_dev_bond_failed_t*) event_data);
1064 case OAL_EVENT_DEVICE_ACL_CONNECTED: {
1065 BT_DBG("ACL Connected event Received");
1066 __bt_device_acl_state_changed_callback((event_dev_conn_status_t *)event_data, TRUE, 0);
1069 case OAL_EVENT_DEVICE_ACL_DISCONNECTED: {
1070 BT_DBG("ACL Disconnected event Received");
1071 __bt_device_acl_state_changed_callback((event_dev_conn_status_t *)event_data, FALSE, 0);
1074 case OAL_EVENT_DEVICE_LE_CONNECTED: {
1075 BT_DBG("LE Connected event Received");
1076 __bt_device_acl_state_changed_callback((event_dev_conn_status_t *)event_data, TRUE, 1);
1079 case OAL_EVENT_DEVICE_LE_DISCONNECTED: {
1080 BT_DBG("LE Disconnected event Received");
1081 __bt_device_acl_state_changed_callback((event_dev_conn_status_t *)event_data, FALSE, 1);
1084 case OAL_EVENT_DEVICE_PIN_REQUEST: {
1085 BT_INFO("PIN Request Received");
1086 __bt_device_pin_request_callback((remote_device_t*)event_data);
1089 case OAL_EVENT_DEVICE_PASSKEY_ENTRY_REQUEST: {
1090 BT_INFO("Passkey Entry request Received");
1091 __bt_device_ssp_passkey_entry_callback((remote_device_t*)event_data);
1094 case OAL_EVENT_DEVICE_PASSKEY_CONFIRMATION_REQUEST:{
1095 BT_INFO("Passkey Confirmation Request Received");
1096 __bt_device_ssp_passkey_confirmation_callback((event_dev_passkey_t *)event_data);
1099 case OAL_EVENT_DEVICE_PASSKEY_DISPLAY: {
1100 BT_INFO("Passkey Display Request Received");
1101 __bt_device_ssp_passkey_display_callback((event_dev_passkey_t *)event_data);
1104 case OAL_EVENT_DEVICE_SSP_CONSENT_REQUEST: {
1105 BT_INFO("SSP Consent Request Received");
1106 __bt_device_ssp_consent_callback((remote_device_t*)event_data);
1109 case OAL_EVENT_DEVICE_SERVICES: {
1110 BT_INFO("Remote Device Services Received");
1111 __bt_device_services_callback((event_dev_services_t*)event_data);
1114 case OAL_EVENT_DEVICE_AUTHORIZE_REQUEST: {
1115 BT_INFO("Remote Device Authorization Request");
1116 __bt_device_authorization_request_callback((event_dev_authorize_req_t*)event_data);
1119 case OAL_EVENT_DEVICE_TRUSTED: {
1120 BT_INFO("Remote Device Trusted");
1121 __bt_device_trusted_callback(TRUE, (event_dev_trust_t*)event_data);
1124 case OAL_EVENT_DEVICE_UNTRUSTED: {
1125 BT_INFO("Remote Device UnTrusted");
1126 __bt_device_trusted_callback(FALSE, (event_dev_trust_t*)event_data);
1129 case OAL_EVENT_DEVICE_NAME: {
1130 remote_device_t *rem_dev = event_data;
1131 gchar address[BT_ADDRESS_STR_LEN];
1133 _bt_convert_addr_type_to_string(address, rem_dev->address.addr);
1134 BT_INFO("Remote Device name Received");
1135 BT_INFO("Name: %s, Address: %s", rem_dev->name, address);
1137 /* Update local cache */
1138 _bt_update_remote_dev_property(address, DEV_PROP_NAME, (void *)rem_dev->name);
1141 case OAL_EVENT_DEVICE_TRUSTED_PROFILES_CHANGED: {
1142 event_device_trusted_profiles_t *ev = event_data;
1143 char address[BT_ADDRESS_STRING_SIZE];
1147 _bt_convert_addr_type_to_string(address, ev->address.addr);
1148 _bt_send_event(BT_DEVICE_EVENT,
1149 BLUETOOTH_EVENT_SUPPORTED_PROFILE_TRUSTED,
1150 g_variant_new("(isi)", BLUETOOTH_ERROR_NONE,
1151 address, ev->trust_val));
1154 case OAL_EVENT_RSSI_MONITORING_ENABLED: {
1155 event_dev_rssi_info_t *ev = event_data;
1156 char address[BT_ADDRESS_STRING_SIZE];
1161 _bt_convert_addr_type_to_string(address, ev->address.addr);
1162 param = g_variant_new("(isib)", BLUETOOTH_ERROR_NONE,
1163 address, ev->link_type, TRUE);
1164 _bt_send_event(BT_DEVICE_EVENT, BLUETOOTH_EVENT_RSSI_ENABLED, param);
1167 case OAL_EVENT_RSSI_MONITORING_DISABLED: {
1168 event_dev_rssi_info_t *ev = event_data;
1169 char address[BT_ADDRESS_STRING_SIZE];
1174 _bt_convert_addr_type_to_string(address, ev->address.addr);
1175 param = g_variant_new("(isib)", BLUETOOTH_ERROR_NONE,
1176 address, ev->link_type, FALSE);
1177 _bt_send_event(BT_DEVICE_EVENT, BLUETOOTH_EVENT_RSSI_ENABLED, param);
1180 case OAL_EVENT_RSSI_ALERT_RECEIVED: {
1181 event_dev_rssi_info_t *ev = event_data;
1182 char address[BT_ADDRESS_STRING_SIZE];
1187 _bt_convert_addr_type_to_string(address, ev->address.addr);
1188 param = g_variant_new("(isiii)", BLUETOOTH_ERROR_NONE,
1189 address, ev->link_type, ev->alert_type, ev->rssi);
1190 _bt_send_event(BT_DEVICE_EVENT, BLUETOOTH_EVENT_RSSI_ALERT, param);
1193 case OAL_EVENT_RAW_RSSI_RECEIVED: {
1194 event_dev_rssi_info_t *ev = event_data;
1195 char address[BT_ADDRESS_STRING_SIZE];
1200 _bt_convert_addr_type_to_string(address, ev->address.addr);
1201 param = g_variant_new("(isii)", BLUETOOTH_ERROR_NONE,
1202 address, ev->link_type, ev->rssi);
1203 _bt_send_event(BT_DEVICE_EVENT, BLUETOOTH_EVENT_RAW_RSSI, param);
1206 case OAL_EVENT_DEVICE_DBFW_PLUS_INFO: {
1207 __bt_device_dbfw_plus_info_callback((event_dev_dbfw_plus_info_t*)event_data);
1211 BT_INFO("Unhandled event..");
1215 /* Legacy Pairing event handler */
1216 static void __bt_device_pin_request_callback(remote_device_t* pin_req_event)
1219 char address[BT_ADDRESS_STRING_SIZE];
1220 char pin_code[BLUETOOTH_PIN_CODE_MAX_LENGTH + 1];
1221 bool incoming = false;
1224 _bt_convert_addr_type_to_string(address, pin_req_event->address.addr);
1226 BT_INFO("Address[%s]", address);
1227 BT_INFO("Name[%s]", pin_req_event->name);
1228 BT_INFO("COD[%d]", pin_req_event->cod);
1230 if (trigger_pairing_info) {
1231 /* BTAPI support only one pairing at a time */
1232 BT_ERR("Already Pairing address [%s]", trigger_pairing_info->addr);
1233 BT_ERR("New PIN request address [%s]", address);
1234 device_reject_pin_request(&pin_req_event->address);
1238 /* If user initiated bonding and auto response is possible, just reply with default 0000*/
1239 if (_bt_is_bonding_device_address(address) == TRUE &&
1240 _bt_agent_is_auto_response(pin_req_event->cod, address, pin_req_event->name)) {
1241 /* Note: Currently even if SYSPOPUP is supported, we use Fixed PIN "0000" for basic pairing
1242 as BT SYSPOPUP is currently not working for PIN KEY entry in Tizen platform. This needs
1243 to be checked and fixed apropriately */
1244 _bt_set_autopair_status_in_bonding_info(TRUE);
1245 device_accept_pin_request(&pin_req_event->address, "0000");
1246 } else if (_bt_agent_is_hid_keyboard(pin_req_event->cod)) {
1247 BT_DBG("Remote Device is HID keyboard Type..");
1248 char str_passkey[BT_PASSKEY_MAX_LENGTH + 1] = { 0 };
1250 if (_bt_agent_generate_passkey(str_passkey,
1251 BT_PASSKEY_MAX_LENGTH) != 0) {
1252 device_reject_pin_request(&pin_req_event->address);
1255 device_accept_pin_request(&pin_req_event->address, str_passkey);
1257 BT_DBG("Send BLUETOOTH_EVENT_KEYBOARD_PASSKEY_DISPLAY");
1259 if(trigger_bond_info == NULL)
1262 param = g_variant_new("(bsss)", incoming, address, pin_req_event->name, str_passkey);
1263 _bt_send_event(BT_ADAPTER_EVENT,
1264 BLUETOOTH_EVENT_KEYBOARD_PASSKEY_DISPLAY, param);
1265 BT_DBG("Key board pairing in process");
1266 } else if (BLUETOOTH_ERROR_NONE == __bt_get_device_pin_code(address, pin_code)) {
1267 BT_DBG("Use stored PIN code [%s]", pin_code);
1268 device_accept_pin_request(&pin_req_event->address, pin_code);
1270 if (_bt_is_bonding_device_address(address) == TRUE) {
1271 BT_DBG("Show Pin entry");
1272 trigger_pairing_info = g_malloc0(sizeof(bt_pairing_data_t));
1273 trigger_pairing_info->addr = g_strdup(address);
1274 trigger_pairing_info->is_ssp = FALSE;
1276 BT_DBG("Send BLUETOOTH_EVENT_PIN_REQUEST");
1278 if(trigger_bond_info == NULL)
1281 param = g_variant_new("(bss)", incoming, address, pin_req_event->name);
1282 _bt_send_event(BT_ADAPTER_EVENT,
1283 BLUETOOTH_EVENT_PIN_REQUEST, param);
1288 _bt_agent_release_memory();
1292 /* SSP Pairing event handler */
1293 static void __bt_device_ssp_passkey_entry_callback(remote_device_t* dev_info)
1296 gchar address[BT_ADDRESS_STR_LEN];
1299 bool incoming = false;
1303 _bt_convert_addr_type_to_string(address, dev_info->address.addr);
1305 name = dev_info->name;
1307 BT_INFO("Address[%s]", address);
1308 BT_INFO("Name[%s]", name);
1309 BT_INFO("COD[%d]", dev_info->cod);
1311 if (trigger_pairing_info) {
1312 /* BTAPI support only one pairing at a time */
1313 BT_ERR("Already Pairing address [%s]", trigger_pairing_info->addr);
1314 BT_ERR("New PIN request address [%s]", address);
1315 device_reject_pin_request(&dev_info->address);
1320 /* Set pairing data */
1321 trigger_pairing_info = g_malloc0(sizeof(bt_pairing_data_t));
1322 trigger_pairing_info->addr = g_strdup(address);
1323 trigger_pairing_info->is_ssp = TRUE;
1325 if(trigger_bond_info == NULL)
1328 param = g_variant_new("(bss)", incoming, p_addr, name);
1329 _bt_send_event(BT_ADAPTER_EVENT,
1330 BLUETOOTH_EVENT_PASSKEY_REQUEST, param);
1334 static void __bt_device_ssp_passkey_confirmation_callback(event_dev_passkey_t *dev_info)
1337 gchar address[BT_ADDRESS_STR_LEN];
1340 char str_passkey[7];
1341 bool incoming = false; /*Stores if bonding request is incoming(true) or outgoing(false) */
1344 _bt_convert_addr_type_to_string(address, dev_info->device_info.address.addr);
1346 name = dev_info->device_info.name;
1348 BT_INFO("Address[%s]", address);
1349 BT_INFO("Name[%s]", name);
1350 BT_INFO("COD[%d]", dev_info->device_info.cod);
1352 if (trigger_pairing_info) {
1353 /* BTAPI support only one pairing at a time */
1354 BT_ERR("Already Pairing address [%s]", trigger_pairing_info->addr);
1355 BT_ERR("New PIN request address [%s]", address);
1356 device_reject_pin_request(&dev_info->device_info.address);
1361 /* Set pairing data */
1362 trigger_pairing_info = g_malloc0(sizeof(bt_pairing_data_t));
1363 trigger_pairing_info->addr = g_strdup(address);
1364 trigger_pairing_info->is_ssp = TRUE;
1366 BT_DBG("Send BLUETOOTH_EVENT_PASSKEY_CONFIRMATION");
1367 snprintf(str_passkey, sizeof(str_passkey), "%.6d", dev_info->pass_key);
1369 /*Storing if bond is incoming or outgoing*/
1370 if(trigger_bond_info == NULL)
1373 param = g_variant_new("(bsss)", incoming, p_addr, name, str_passkey);
1374 _bt_send_event(BT_ADAPTER_EVENT,
1375 BLUETOOTH_EVENT_PASSKEY_CONFIRM_REQUEST, param);
1379 static void __bt_device_ssp_passkey_display_callback(event_dev_passkey_t *dev_info)
1382 gchar address[BT_ADDRESS_STR_LEN];
1385 char str_passkey[7];
1386 bool incoming = false;
1389 _bt_convert_addr_type_to_string(address, dev_info->device_info.address.addr);
1391 name = dev_info->device_info.name;
1393 BT_INFO("Address[%s]", address);
1394 BT_INFO("Name[%s]", name);
1395 BT_INFO("COD[%d]", dev_info->device_info.cod);
1397 if (trigger_pairing_info) {
1398 /* BTAPI support only one pairing at a time */
1399 BT_ERR("Already Pairing address [%s]", trigger_pairing_info->addr);
1400 BT_ERR("New PIN request address [%s]", address);
1401 device_reject_pin_request(&dev_info->device_info.address);
1406 /* Set pairing data */
1407 trigger_pairing_info = g_malloc0(sizeof(bt_pairing_data_t));
1408 trigger_pairing_info->addr = g_strdup(address);
1409 trigger_pairing_info->is_ssp = TRUE;
1411 BT_DBG("Send BLUETOOTH_EVENT_KEYBOARD_PASSKEY_DISPLAY");
1412 snprintf(str_passkey, sizeof(str_passkey), "%06d", dev_info->pass_key);
1414 if(trigger_bond_info == NULL)
1417 param = g_variant_new("(bsss)", incoming, p_addr, name, str_passkey);
1419 if (passkey_watcher) {
1420 BT_INFO("Send passkey to %s", passkey_watcher);
1421 _bt_send_event_to_dest(passkey_watcher, BT_ADAPTER_EVENT,
1422 BLUETOOTH_EVENT_PASSKEY_NOTIFICATION, param);
1424 _bt_send_event(BT_ADAPTER_EVENT,
1425 BLUETOOTH_EVENT_KEYBOARD_PASSKEY_DISPLAY, param);
1430 static void __bt_device_ssp_consent_callback(remote_device_t* dev_info)
1432 gchar address[BT_ADDRESS_STR_LEN];
1439 _bt_convert_addr_type_to_string(address, dev_info->address.addr);
1440 name = dev_info->name;
1441 cod = dev_info->cod;
1443 BT_INFO("Address[%s]", address);
1444 BT_INFO("Name[%s]", name);
1445 BT_INFO("COD[%d]", cod);
1447 if (trigger_pairing_info) {
1448 /* BTAPI support only one pairing at a time */
1449 BT_ERR("Already Pairing address [%s]", trigger_pairing_info->addr);
1450 BT_ERR("New PIN request address [%s]", address);
1451 device_reject_pin_request(&dev_info->address);
1456 /* Set pairing data */
1457 trigger_pairing_info = g_malloc0(sizeof(bt_pairing_data_t));
1458 trigger_pairing_info->addr = g_strdup(address);
1459 trigger_pairing_info->is_ssp = TRUE;
1461 local_major = ((cod >> 8) & 0x001f);
1462 local_minor = (cod & 0x00fc);
1463 BT_DBG("SSP_CONSENT: Major type=[0x%x] and Minor type=[0x%x]", local_major, local_minor);
1465 /*TODO: BLUETOOTH_EVENT_SSP_CONSENT_REQUEST to be handled in Tizen */
1469 static void __bt_device_acl_state_changed_callback(event_dev_conn_status_t *acl_event,
1470 gboolean connected, unsigned char type)
1472 gchar address[BT_ADDRESS_STR_LEN];
1473 int disc_reason = 0;
1474 GVariant *param = NULL;
1475 bt_device_conn_info_t conn_info;
1477 _bt_convert_addr_type_to_string(address, acl_event->address.addr);
1479 _bt_logging_connection(connected, type);
1481 disc_reason = acl_event->status;
1484 BT_PERMANENT_LOG("Connected %s %s", !type ? "EDR" : "LE", address + 12);
1485 param = g_variant_new("(isy)", BLUETOOTH_ERROR_NONE, address, type);
1486 _bt_send_event(BT_DEVICE_EVENT,
1487 BLUETOOTH_EVENT_DEVICE_CONNECTED,
1490 BT_PERMANENT_LOG("Disconnected %s(%d) %s", !type ? "EDR" : "LE", disc_reason, address + 12);
1491 param = g_variant_new("(isyi)", disc_reason, address, type, dbfw_rssi);
1492 _bt_send_event(BT_DEVICE_EVENT,
1493 BLUETOOTH_EVENT_DEVICE_DISCONNECTED,
1497 conn_info.connected = connected;
1498 conn_info.type = type;
1499 /* Update local cache */
1500 _bt_update_remote_dev_property(address, DEV_PROP_CONNECTED, (void *)&conn_info);
1502 #ifdef TIZEN_GATT_CLIENT
1503 /*handle LE connected device info*/
1505 _bt_handle_le_connected_dev_info(address, connected);
1510 static void __bt_device_remote_device_found_callback(gpointer event_data, gboolean is_ble)
1512 bt_remote_dev_info_t *dev_info = NULL;
1513 int result = BLUETOOTH_ERROR_NONE;
1514 GVariant *param = NULL;
1515 GVariant *uuids = NULL;
1516 GVariant *manufacturer_data = NULL;
1517 GVariantBuilder *builder = NULL;
1520 ret_if(_bt_is_discovering() == FALSE);
1521 ret_if(event_data == NULL);
1523 dev_info = g_malloc0(sizeof(bt_remote_dev_info_t));
1526 event_ble_dev_found_t * oal_ble_dev = event_data;
1527 BT_INFO("Device type [%d]", oal_ble_dev->device_info.type);
1529 _bt_copy_remote_dev(dev_info, &oal_ble_dev->device_info);
1531 dev_info->manufacturer_data_len = oal_ble_dev->adv_len;
1532 if (dev_info->manufacturer_data_len)
1533 dev_info->manufacturer_data = g_memdup(oal_ble_dev->adv_data,
1534 dev_info->manufacturer_data_len);
1536 dev_info->manufacturer_data = NULL;
1537 BT_DBG("----Advertising Data Length: %d", dev_info->manufacturer_data_len);
1539 event_dev_found_t * oal_dev = event_data;
1540 _bt_copy_remote_dev(dev_info, &oal_dev->device_info);
1543 /* If Remote device name is NULL or still RNR is not done then display address as name. */
1544 if (dev_info->name == NULL)
1545 dev_info->name = g_strdup(dev_info->address);
1546 BT_DBG("Name %s", dev_info->name);
1548 builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
1549 for (i = 0; i < dev_info->uuid_count; i++)
1550 g_variant_builder_add(builder, "s", dev_info->uuids[i]);
1552 uuids = g_variant_new("as", builder);
1553 g_variant_builder_unref(builder);
1555 manufacturer_data = g_variant_new_from_data(G_VARIANT_TYPE_BYTESTRING,
1556 dev_info->manufacturer_data,
1557 dev_info->manufacturer_data_len,
1561 param = g_variant_new("(isunsbub@asn@ay)", result,
1567 dev_info->connected,
1570 dev_info->manufacturer_data_len,
1573 _bt_send_event(BT_ADAPTER_EVENT,
1574 BLUETOOTH_EVENT_REMOTE_DEVICE_FOUND,
1577 _bt_free_remote_dev(dev_info);
1580 static void __bt_device_trusted_callback(gboolean trusted, event_dev_trust_t* info)
1582 gchar address[BT_ADDRESS_STR_LEN];
1583 int result = BLUETOOTH_ERROR_NONE;
1584 GVariant *param = NULL;
1587 _bt_convert_addr_type_to_string(address, info->address.addr);
1589 /* Update local cache */
1590 _bt_update_remote_dev_property(address, DEV_PROP_TRUST, (void *)&trusted);
1592 param = g_variant_new("(is)", result, address);
1593 event = trusted ? BLUETOOTH_EVENT_DEVICE_AUTHORIZED :
1594 BLUETOOTH_EVENT_DEVICE_UNAUTHORIZED;
1595 /* Send event to application */
1596 _bt_send_event(BT_DEVICE_EVENT,
1602 static void __bt_free_pairing_info(bt_pairing_data_t **p_info)
1604 bt_pairing_data_t * info = *p_info;
1614 static void __bt_free_bond_info(uint8_t type)
1617 case BT_DEVICE_BOND_INFO:
1618 if (!trigger_bond_info)
1621 if (trigger_bond_info->addr)
1622 g_free(trigger_bond_info->addr);
1623 if (trigger_bond_info->dev_addr)
1624 g_free(trigger_bond_info->dev_addr);
1625 if (trigger_bond_info->dev_info)
1626 _bt_free_remote_dev(trigger_bond_info->dev_info);
1627 g_free(trigger_bond_info);
1628 trigger_bond_info = NULL;
1630 case BT_DEVICE_INCOMING_BOND_INFO:
1631 if (!incoming_bond_info)
1634 if (incoming_bond_info->dev_info)
1635 _bt_free_remote_dev(incoming_bond_info->dev_info);
1636 g_free(incoming_bond_info);
1637 incoming_bond_info = NULL;
1639 case BT_DEVICE_UNBOND_INFO:
1640 if (!trigger_unbond_info)
1643 if (trigger_unbond_info->addr)
1644 g_free(trigger_unbond_info->addr);
1645 if (trigger_unbond_info->dev_addr)
1646 g_free(trigger_unbond_info->dev_addr);
1647 if (trigger_unbond_info->dev_info)
1648 _bt_free_remote_dev(trigger_unbond_info->dev_info);
1649 g_free(trigger_unbond_info);
1650 trigger_unbond_info = NULL;
1655 static void __bt_free_service_search_info(bt_service_search_info_data_t **p_info)
1657 bt_service_search_info_data_t * info = *p_info;
1664 if (info->dev_addr) {
1665 g_free(info->dev_addr);
1666 info->dev_addr = NULL;
1669 if (info->dev_info) {
1670 _bt_free_remote_dev(info->dev_info);
1671 info->dev_info = NULL;
1679 static int __bt_device_handle_bond_state(void)
1681 BT_INFO("Current Bond state: %d", bt_device_bond_state);
1682 int ret = OAL_STATUS_INTERNAL_ERROR;
1684 switch (bt_device_bond_state) {
1685 case BT_DEVICE_BOND_STATE_CANCEL_DISCOVERY:
1686 /*TODO:Bonding during discovery: Unhandled!!*/
1687 BT_INFO("Bonding during discovery: Unhandled!!");
1689 case BT_DEVICE_BOND_STATE_DISCOVERY_CANCELLED:
1690 /*TODO:Bonding during discovery: Unhandled!!*/
1691 BT_INFO("Bonding during discovery: Unhandled!!");
1693 case BT_DEVICE_BOND_STATE_REMOVE_BONDING:
1694 bt_device_bond_state = BT_DEVICE_BOND_STATE_REMOVED_BONDING;
1695 ret = device_destroy_bond((bt_address_t *)trigger_bond_info->dev_addr);
1696 if (ret != OAL_STATUS_SUCCESS)
1697 ret = __bt_device_handle_bond_state();
1699 case BT_DEVICE_BOND_STATE_REMOVED_BONDING:
1700 bt_device_bond_state = BT_DEVICE_BOND_STATE_NONE;
1701 ret = device_create_bond((bt_address_t *)trigger_bond_info->dev_addr, trigger_bond_info->conn_type);
1702 /* Bonding procedure was started but unfortunately could not complete.
1703 Basically removed bonding was success, but create bond request could not proceed
1704 So lets cleanup the context */
1705 if (ret != OAL_STATUS_SUCCESS) {
1706 BT_ERR("Create Bond procedure could not suceed");
1707 __bt_device_handle_pending_requests(BLUETOOTH_ERROR_INTERNAL, BT_BOND_DEVICE,
1708 trigger_bond_info->addr, BT_ADDRESS_STRING_SIZE);
1709 __bt_free_bond_info(BT_DEVICE_BOND_INFO);
1710 __bt_free_pairing_info(&trigger_pairing_info);
1713 case BT_DEVICE_BOND_STATE_NONE:
1714 BT_INFO("Create Bond failed!!");
1715 if (trigger_bond_info) {
1716 __bt_device_handle_pending_requests(BLUETOOTH_ERROR_INTERNAL, BT_BOND_DEVICE,
1717 trigger_bond_info->addr, BT_ADDRESS_STRING_SIZE);
1718 __bt_free_bond_info(BT_DEVICE_BOND_INFO);
1719 __bt_free_pairing_info(&trigger_pairing_info);
1726 if (ret != OAL_STATUS_SUCCESS)
1727 return BLUETOOTH_ERROR_INTERNAL;
1729 return BLUETOOTH_ERROR_NONE;
1732 int _bt_device_get_bonded_device_info(bluetooth_device_address_t *addr)
1735 bt_address_t bd_addr;
1739 retv_if(!addr, BLUETOOTH_ERROR_INVALID_PARAM);
1741 memcpy(bd_addr.addr, addr, BLUETOOTH_ADDRESS_LENGTH);
1742 result = device_query_attributes(&bd_addr);
1743 if (result != OAL_STATUS_SUCCESS) {
1744 BT_ERR("device_query_attributes error: [%d]", result);
1745 return BLUETOOTH_ERROR_INTERNAL;
1749 return BLUETOOTH_ERROR_NONE;
1752 int _bt_set_alias(bluetooth_device_address_t *device_address, const char *alias)
1755 char address[BT_ADDRESS_STRING_SIZE];
1758 BT_CHECK_PARAMETER(alias, return);
1760 ret = device_set_alias((bt_address_t *)device_address, (char *)alias);
1761 if (ret != OAL_STATUS_SUCCESS) {
1762 BT_ERR("device_set_alias: %d", ret);
1763 return BLUETOOTH_ERROR_INTERNAL;
1766 /* Update local cache */
1767 _bt_convert_addr_type_to_string(address, device_address->addr);
1768 _bt_update_remote_dev_property(address, DEV_PROP_ALIAS, (void *)alias);
1771 return BLUETOOTH_ERROR_NONE;
1774 int _bt_bond_device(bluetooth_device_address_t *device_address,
1775 unsigned short conn_type, GArray **out_param1)
1777 int result = BLUETOOTH_ERROR_NONE;
1778 char address[BT_ADDRESS_STRING_SIZE] = { 0 };
1779 bluetooth_device_info_t dev_info;
1780 const char *stack_name = NULL;
1783 retv_if(device_address == NULL, BLUETOOTH_ERROR_INVALID_PARAM);
1785 /* If bonding or discovery already going on */
1786 if (trigger_bond_info || _bt_is_discovering()) {
1787 BT_ERR("Device is buzy, bonding can not proceed now..");
1788 result = BLUETOOTH_ERROR_DEVICE_BUSY;
1792 /*TODO: If unbonding with same device going on */
1793 _bt_convert_addr_type_to_string(address, device_address->addr);
1795 trigger_bond_info = g_malloc0(sizeof(bt_bond_data_t));
1796 trigger_bond_info->addr = g_strdup(address);
1797 trigger_bond_info->conn_type = conn_type;
1798 trigger_bond_info->is_device_creating = TRUE;
1799 trigger_bond_info->dev_addr = g_memdup(device_address, sizeof(bluetooth_device_address_t));
1800 trigger_bond_info->dev_info = NULL;
1802 /* Ready to initiate bonding */
1804 stack_name = oal_get_stack_name();
1805 if (stack_name && !g_strcmp0(stack_name, "bluez")) {
1806 BT_DBG("[bluez] Create bond by type %d", conn_type);
1807 bt_device_bond_state = BT_DEVICE_BOND_STATE_REMOVED_BONDING;
1809 /* In Tizen, we will first remove bond and then attempt to create bond to keep
1810 consistency with bluedroid. Even if remove bond fails due to device not already
1811 bonded, then straight away create bond is triggered. This is because, remove bond
1812 is handled differently in bluedroid and bluez. In Bluez, if device is
1813 already removed, remove bond call fails.
1814 However in bluedroid, remove bond on already removed device returns success. So we will
1815 handle the cases transparently */
1816 bt_device_bond_state = BT_DEVICE_BOND_STATE_REMOVE_BONDING;
1819 bond_retry_count = 0;
1820 result = __bt_device_handle_bond_state();
1822 if (result != BLUETOOTH_ERROR_NONE)
1829 memset(&dev_info, 0x00, sizeof(bluetooth_device_info_t));
1830 memcpy(dev_info.device_address.addr, device_address->addr,
1831 BLUETOOTH_ADDRESS_LENGTH);
1833 g_array_append_vals(*out_param1, &dev_info,
1834 sizeof(bluetooth_device_info_t));
1835 __bt_free_bond_info(BT_DEVICE_BOND_INFO);
1841 int _bt_unbond_device(bluetooth_device_address_t *device_address,
1842 GArray **out_param1)
1844 int result = OAL_STATUS_SUCCESS;
1845 char address[BT_ADDRESS_STRING_SIZE] = { 0 };
1846 bluetooth_device_info_t dev_info;
1849 retv_if(device_address == NULL, BLUETOOTH_ERROR_INVALID_PARAM);
1851 _bt_convert_addr_type_to_string(address, device_address->addr);
1853 trigger_unbond_info = g_malloc0(sizeof(bt_bond_data_t));
1854 trigger_unbond_info->addr = g_malloc0(BT_ADDRESS_STRING_SIZE);
1855 trigger_unbond_info->addr = g_strdup(address);
1856 trigger_unbond_info->dev_addr = g_memdup(device_address, sizeof(bluetooth_device_address_t));
1858 /* Check if Bonding is already going on, we should not abruptly remove bonding*/
1859 if (trigger_bond_info && strncmp(trigger_bond_info->addr, trigger_unbond_info->addr, BT_ADDRESS_STRING_SIZE) == 0) {
1860 BT_ERR("Bonding with same device already ongoing");
1861 result = BLUETOOTH_ERROR_PERMISSION_DEINED;
1865 result = device_destroy_bond((bt_address_t *)device_address);
1866 if (result != OAL_STATUS_SUCCESS)
1869 return BLUETOOTH_ERROR_NONE;
1872 memset(&dev_info, 0x00, sizeof(bluetooth_device_info_t));
1873 _bt_convert_addr_string_to_type(dev_info.device_address.addr,
1874 trigger_unbond_info->addr);
1876 g_array_append_vals(*out_param1, &dev_info,
1877 sizeof(bluetooth_device_info_t));
1878 __bt_free_bond_info(BT_DEVICE_UNBOND_INFO);
1880 if (result == OAL_STATUS_NOT_PAIRED)
1881 return BLUETOOTH_ERROR_NOT_PAIRED;
1883 return BLUETOOTH_ERROR_INTERNAL;
1886 int _bt_cancel_bonding(void)
1888 int result = OAL_STATUS_SUCCESS;
1891 retv_if(trigger_bond_info == NULL, BLUETOOTH_ERROR_NOT_IN_OPERATION);
1893 result = device_stop_bond((bt_address_t *)trigger_bond_info->dev_addr);
1895 if (result == OAL_STATUS_SUCCESS)
1896 trigger_bond_info->is_cancelled_by_user = TRUE;
1901 int _bt_passkey_reply(const char *passkey, gboolean cnfm_reply)
1903 bluetooth_device_address_t device_address;
1904 int ret = OAL_STATUS_SUCCESS;
1905 BT_INFO("reply: %d", cnfm_reply);
1907 retv_if(trigger_pairing_info == NULL, BLUETOOTH_ERROR_INTERNAL);
1908 retv_if(trigger_pairing_info->addr == NULL, BLUETOOTH_ERROR_INTERNAL);
1910 _bt_convert_addr_string_to_type(device_address.addr, trigger_pairing_info->addr);
1912 if (trigger_pairing_info->is_ssp) {
1914 ret = device_accept_passkey_entry((bt_address_t *)&device_address, atoi(passkey));
1916 ret = device_reject_passkey_entry((bt_address_t *)&device_address);
1917 trigger_pairing_info->is_ssp = FALSE;
1920 ret = device_accept_pin_request((bt_address_t *)&device_address, passkey);
1922 ret = device_reject_pin_request((bt_address_t *)&device_address);
1925 __bt_free_pairing_info(&trigger_pairing_info);
1927 if (ret != OAL_STATUS_SUCCESS) {
1928 BT_ERR("_bt_device_handle_passkey_reply: err [%d]", ret);
1929 return BLUETOOTH_ERROR_INTERNAL;
1933 return BLUETOOTH_ERROR_NONE;
1936 int _bt_passkey_confirmation_reply(gboolean cnfm_reply)
1938 BT_INFO("BT_PASSKEY_CONFIRMATION_REPLY");
1939 bluetooth_device_address_t device_address;
1940 int ret = OAL_STATUS_SUCCESS;
1941 BT_INFO("reply: %d", cnfm_reply);
1943 retv_if(trigger_pairing_info == NULL, BLUETOOTH_ERROR_INTERNAL);
1944 retv_if(trigger_pairing_info->addr == NULL, BLUETOOTH_ERROR_INTERNAL);
1946 _bt_convert_addr_string_to_type(device_address.addr, trigger_pairing_info->addr);
1948 ret = device_reply_passkey_confirmation((bt_address_t *)&device_address, cnfm_reply);
1950 __bt_free_pairing_info(&trigger_pairing_info);
1951 if (ret != OAL_STATUS_SUCCESS) {
1952 BT_ERR("_bt_device_handle_passkey_confirmation_reply: err [%d]", ret);
1953 return BLUETOOTH_ERROR_INTERNAL;
1957 return BLUETOOTH_ERROR_NONE;
1960 gboolean _bt_device_is_pairing(void)
1962 return (trigger_pairing_info) ? TRUE : FALSE;
1965 gboolean _bt_device_is_bonding(void)
1967 return (trigger_bond_info) ? TRUE : FALSE;
1970 gboolean _bt_is_bonding_device_address(const char *address)
1972 if (trigger_bond_info == NULL || trigger_bond_info->addr == NULL)
1975 if (g_strcmp0(trigger_bond_info->addr, address) == 0) {
1976 BT_DBG("[%s] is bonding device", address);
1980 BT_DBG("[%s] is NOT bonding device", address);
1984 void _bt_set_autopair_status_in_bonding_info(gboolean is_autopair)
1986 ret_if(trigger_bond_info == NULL);
1987 trigger_bond_info->is_autopair = is_autopair;
1990 int _bt_search_device(bluetooth_device_address_t *device_address)
1992 int result = OAL_STATUS_SUCCESS;
1995 BT_CHECK_PARAMETER(device_address, return);
1997 if (trigger_bond_info) {
1998 BT_ERR("Bonding in progress");
1999 return BLUETOOTH_ERROR_DEVICE_BUSY;
2002 if (service_search_info) {
2003 BT_ERR("Service searching in progress");
2004 return BLUETOOTH_ERROR_DEVICE_BUSY;
2007 /* allocate user data so that it can be retrieved in callback */
2008 service_search_info = g_malloc0(sizeof(bt_service_search_info_data_t));
2009 service_search_info->addr = g_malloc0(BT_ADDRESS_STRING_SIZE);
2010 service_search_info->dev_addr = g_memdup(device_address, sizeof(bluetooth_device_address_t));
2012 _bt_convert_addr_type_to_string(service_search_info->addr,
2013 device_address->addr);
2015 result = device_query_services((bt_address_t *)device_address);
2017 if (result != OAL_STATUS_SUCCESS) {
2018 BT_ERR("Device Service Search Failed..: %d", result);
2019 __bt_free_service_search_info(&service_search_info);
2020 return BLUETOOTH_ERROR_INTERNAL;
2022 return BLUETOOTH_ERROR_NONE;
2025 int _bt_cancel_search_device(void)
2027 int ret = OAL_STATUS_SUCCESS;
2028 retv_if(service_search_info == NULL, BLUETOOTH_ERROR_NOT_IN_OPERATION);
2030 ret = device_stop_query_sevices((bt_address_t *)service_search_info->dev_addr);
2032 if (ret != OAL_STATUS_SUCCESS) {
2033 BT_ERR("SDP Cancel request failed [%d]", ret);
2034 return BLUETOOTH_ERROR_INTERNAL;
2037 __bt_device_handle_pending_requests(BLUETOOTH_ERROR_CANCEL_BY_USER, BT_SEARCH_SERVICE,
2038 service_search_info->addr, BT_ADDRESS_STRING_SIZE);
2040 __bt_free_service_search_info(&service_search_info);
2042 return BLUETOOTH_ERROR_NONE;
2046 int _bt_set_authorization(bluetooth_device_address_t *device_address,
2049 int ret = OAL_STATUS_SUCCESS;
2052 BT_CHECK_PARAMETER(device_address, return);
2053 BT_INFO("Device to be Trusted? [%d]", authorize);
2055 ret = device_set_authorized((bt_address_t*)device_address, authorize);
2056 if (ret != OAL_STATUS_SUCCESS) {
2057 BT_ERR("device_set_authorized: %d", ret);
2058 return BLUETOOTH_ERROR_INTERNAL;
2061 return BLUETOOTH_ERROR_NONE;
2064 gboolean _bt_is_device_connected(bluetooth_device_address_t *device_address, int svc_type)
2066 gboolean is_connected;
2067 oal_service_t svc_id;
2069 retv_if(device_address == NULL, BLUETOOTH_ERROR_INVALID_PARAM);
2072 * TODO: While adding support for new profiles, need to add more
2073 * <svc_type, svc_id> mapping here.
2076 case BT_PROFILE_CONN_HID:
2077 svc_id = HID_SERVICE_ID;
2079 case BT_PROFILE_CONN_A2DP:
2080 svc_id = A2DP_SERVICE_ID; /* Remote is A2DP Sink */
2082 case BT_PROFILE_CONN_A2DP_SINK:
2083 svc_id = A2DP_SRC_SERVICE_ID; /* Remote is A2DP Source*/
2085 case BT_PROFILE_CONN_HSP:
2086 svc_id = HFP_HS_SERVICE_ID; /* Remote is HFP HF Unit */
2088 #ifdef TIZEN_GATT_CLIENT
2089 case BT_PROFILE_CONN_GATT:
2090 return _bt_is_remote_gatt_device_connected(device_address); /* Remote is GATT client or Server */
2093 BT_DBG("Unknown svc_type: %d", svc_type);
2097 is_connected = device_get_svc_conn_state((bt_address_t*)device_address, svc_id);
2099 BT_DBG("svc_type: %d, is_connected: %s",
2100 svc_type, is_connected ? "TRUE" : "FALSE");
2102 return is_connected;
2105 int _bt_rfcomm_reply_conn_authorization(char *address, gboolean reply)
2107 bt_address_t bd_addr;
2112 retv_if(NULL == address, BLUETOOTH_ERROR_INVALID_PARAM);
2113 _bt_convert_addr_string_to_type(bd_addr.addr, address);
2114 res = device_reply_auth_request(&bd_addr, 0, reply, FALSE);
2115 if (res != OAL_STATUS_SUCCESS) {
2116 BT_ERR("authorize_response: %d", res);
2117 return BLUETOOTH_ERROR_INTERNAL;
2121 return BLUETOOTH_ERROR_NONE;
2124 int _bt_enable_rssi(bluetooth_device_address_t *addr, int link_type,
2125 int low_threshold, int in_range_threshold, int high_threshold)
2128 bt_address_t bd_addr;
2132 retv_if(!addr, BLUETOOTH_ERROR_INVALID_PARAM);
2134 memcpy(bd_addr.addr, addr, BLUETOOTH_ADDRESS_LENGTH);
2135 result = device_enable_rssi_monitoring(&bd_addr, link_type,
2136 low_threshold, in_range_threshold, high_threshold);
2137 if (result != OAL_STATUS_SUCCESS) {
2138 BT_ERR("device_get_connected_link_rssi_strength error: [%d]", result);
2139 return BLUETOOTH_ERROR_INTERNAL;
2143 return BLUETOOTH_ERROR_NONE;
2146 int _bt_get_rssi_strength(bluetooth_device_address_t *addr, int link_type)
2149 bt_address_t bd_addr;
2153 retv_if(!addr, BLUETOOTH_ERROR_INVALID_PARAM);
2155 memcpy(bd_addr.addr, addr, BLUETOOTH_ADDRESS_LENGTH);
2156 result = device_get_connected_link_rssi_strength(&bd_addr, link_type);
2157 if (result != OAL_STATUS_SUCCESS) {
2158 BT_ERR("device_get_connected_link_rssi_strength error: [%d]", result);
2159 return BLUETOOTH_ERROR_INTERNAL;
2163 return BLUETOOTH_ERROR_NONE;
2166 int _bt_set_passkey_notification(const char *sender, gboolean enable)
2170 BT_INFO("Set passkey notification(sender:%s, %s)",
2171 sender, enable ? "Enable" : "Disable");
2173 result = device_enable_gap_auth_notifications(OAL_PASSKEY_DISPLAY, enable);
2174 if (OAL_STATUS_SUCCESS != result) {
2175 BT_ERR("device_enable_gap_auth_notifications error: [%d]", result);
2176 return BLUETOOTH_ERROR_INTERNAL;
2179 g_free(passkey_watcher);
2181 passkey_watcher = g_strdup(sender);
2183 passkey_watcher = NULL;
2185 return BLUETOOTH_ERROR_NONE;
2188 static int __bt_get_device_pin_code(const char *address, char *pin_code)
2192 BT_CHECK_PARAMETER(address, return);
2193 BT_CHECK_PARAMETER(pin_code, return);
2195 for (l = pin_info_list; l != NULL; l = l->next) {
2196 bt_pin_code_info_t *pin_info = l->data;
2198 if (!pin_info || !pin_info->address)
2201 if (g_strcmp0(pin_info->address, address) == 0) {
2202 g_strlcpy(pin_code, pin_info->pin_code,
2203 BLUETOOTH_PIN_CODE_MAX_LENGTH + 1);
2204 return BLUETOOTH_ERROR_NONE;
2208 return BLUETOOTH_ERROR_NOT_FOUND;
2211 int _bt_set_pin_code(bluetooth_device_address_t *device_address,
2212 bluetooth_device_pin_code_t *pin_code)
2214 char address[BT_ADDRESS_STRING_SIZE] = { 0 };
2215 bt_pin_code_info_t *pin_info = NULL;
2218 BT_CHECK_PARAMETER(device_address, return);
2219 BT_CHECK_PARAMETER(pin_code, return);
2220 retv_if(g_slist_length(pin_info_list) >= BT_DEVICE_PIN_CODE_SLOT_MAX,
2221 BLUETOOTH_ERROR_NO_RESOURCES);
2223 _bt_convert_addr_type_to_string(address, device_address->addr);
2225 for (l = pin_info_list; l != NULL; l = l->next) {
2228 if (!pin_info || !pin_info->address)
2231 if (g_strcmp0(pin_info->address, address) == 0) {
2232 g_free(pin_info->pin_code);
2233 pin_info->pin_code = g_strdup(pin_code->pin_code);
2234 return BLUETOOTH_ERROR_NONE;
2238 pin_info = g_malloc0(sizeof(bt_pin_code_info_t));
2239 pin_info->address = g_strdup(address);
2240 pin_info->pin_code = g_strdup(pin_code->pin_code);
2241 pin_info_list = g_slist_append(pin_info_list, pin_info);
2243 return BLUETOOTH_ERROR_NONE;
2246 int _bt_unset_pin_code(bluetooth_device_address_t *device_address)
2248 char address[BT_ADDRESS_STRING_SIZE] = { 0 };
2249 bt_pin_code_info_t *pin_info = NULL;
2254 BT_CHECK_PARAMETER(device_address, return);
2256 _bt_convert_addr_type_to_string(address, device_address->addr);
2258 for (l = pin_info_list; l != NULL; l = l->next) {
2261 if (!pin_info || !pin_info->address)
2264 if (g_strcmp0(pin_info->address, address) == 0) {
2265 pin_info_list = g_slist_remove(pin_info_list, pin_info);
2266 g_free(pin_info->address);
2267 g_free(pin_info->pin_code);
2274 return BLUETOOTH_ERROR_NONE;
2277 int _bt_device_get_ida(bluetooth_device_address_t *device_address, bluetooth_device_address_t *id_address)
2279 int result = BLUETOOTH_ERROR_NONE;
2280 char address[BT_ADDRESS_STRING_SIZE] = { 0 };
2282 _bt_convert_addr_type_to_string(address, device_address->addr);
2284 BT_DBG("getting IDA for remote device: [%s]", address);
2286 result = device_get_ida((bt_address_t*)device_address, (bt_address_t*)id_address);
2288 if (result != OAL_STATUS_SUCCESS) {
2289 BT_ERR("device_get_ida Failed %d", result);
2290 return BLUETOOTH_ERROR_INTERNAL;
2296 #ifdef TIZEN_GATT_CLIENT
2297 static bt_connected_le_dev_t *__bt_get_le_connected_dev_info(const char *address)
2300 bt_connected_le_dev_t *dev;
2305 for (l = le_connected_dev_list; l; l = g_slist_next(l)) {
2308 if (g_strcmp0(dev->address, address) == 0)
2314 static void __bt_le_conn_param_free(void *data)
2316 bt_le_conn_param_t *param = (bt_le_conn_param_t *)data;
2318 BT_DBG("%s", param->sender);
2319 g_free(param->sender);
2323 static void _bt_add_le_connected_dev_info(const char *address)
2325 bt_connected_le_dev_t *dev = NULL;
2330 dev = g_malloc0(sizeof(bt_connected_le_dev_t));
2331 dev->address = g_strdup(address);
2333 le_connected_dev_list = g_slist_append(le_connected_dev_list, dev);
2338 static void _bt_remove_le_connected_dev_info(const char *address)
2340 bt_connected_le_dev_t *dev = NULL;
2345 dev = __bt_get_le_connected_dev_info(address);
2349 g_slist_free_full(dev->senders, __bt_le_conn_param_free);
2350 le_connected_dev_list = g_slist_remove(le_connected_dev_list, dev);
2351 g_free(dev->address);
2357 static void _bt_handle_le_connected_dev_info(const char *address, gboolean connected)
2359 BT_DBG("update le_connected_dev_list");
2362 _bt_add_le_connected_dev_info(address);
2364 _bt_remove_le_connected_dev_info(address);
2367 static bt_le_conn_param_t *__bt_get_le_conn_param_info(bt_connected_le_dev_t *dev, const char *sender)
2370 bt_le_conn_param_t *param = NULL;
2372 if (!dev || !sender)
2375 for (l = dev->senders; l; l = g_slist_next(l)) {
2377 if (g_strcmp0(param->sender, sender) == 0)
2384 static gint __bt_compare_le_conn_param_key(gpointer *a, gpointer *b)
2386 bt_le_conn_param_t *parama = (bt_le_conn_param_t *)a;
2387 bt_le_conn_param_t *paramb = (bt_le_conn_param_t *)b;
2389 return parama->key > paramb->key;
2393 int _bt_add_le_conn_param_info(const char *address, const char *sender,
2394 float interval_min, float interval_max, guint16 latency, guint16 time_out)
2396 bt_connected_le_dev_t *dev = NULL;
2397 bt_le_conn_param_t *param = NULL;
2398 bt_le_conn_param_t *data = NULL;
2400 if (!address || !sender)
2401 return BLUETOOTH_ERROR_INVALID_PARAM;
2403 dev = __bt_get_le_connected_dev_info(address);
2405 return BLUETOOTH_ERROR_INTERNAL;
2407 param = __bt_get_le_conn_param_info(dev, sender);
2409 data = g_malloc0(sizeof(bt_le_conn_param_t));
2410 data->sender = g_strdup(sender);
2411 data->interval_min = interval_min;
2412 data->interval_max = interval_max;
2413 data->latency = latency;
2414 data->time_out = time_out;
2415 data->key = interval_min + (interval_max - interval_min)/2;
2417 if (param == NULL) {
2418 BT_DBG("Add param %s %s %f %f", address, sender, interval_min, interval_max);
2419 dev->senders = g_slist_append(dev->senders, data);
2421 BT_DBG("Update param %s %s %f %f", address, sender, interval_min, interval_max);
2422 dev->senders = g_slist_remove(dev->senders, param);
2423 g_free(param->sender);
2425 dev->senders = g_slist_append(dev->senders, data);
2428 /* Sorting. First element have the minimum interval */
2429 dev->senders = g_slist_sort(dev->senders,
2430 (GCompareFunc)__bt_compare_le_conn_param_key);
2432 return BLUETOOTH_ERROR_NONE;
2436 static int __bt_le_set_conn_parameter(const char *address,
2437 float interval_min, float interval_max,
2438 guint16 latency, guint16 time_out)
2440 bt_address_t dev_addr = { {0} };
2441 guint32 min, max, to;
2443 BT_INFO("Min interval: %f, Max interval: %f, Latency: %u, Supervision timeout: %u",
2444 interval_min, interval_max, latency, time_out);
2446 min = interval_min / BT_LE_CONN_INTERVAL_SPLIT;
2447 max = interval_max / BT_LE_CONN_INTERVAL_SPLIT;
2448 to = time_out / BT_LE_CONN_TO_SPLIT;
2450 BT_INFO("updating: Min interval: %d, Max interval: %d, Latency: %d, Supervision timeout: %d",
2451 min, max, latency, to);
2453 _bt_convert_addr_string_to_type(dev_addr.addr, address);
2455 return gattc_conn_param_update(&dev_addr, min, max, latency, to);
2458 int _bt_remove_le_conn_param_info(const char *address, const char *sender)
2460 bt_connected_le_dev_t *dev = NULL;
2461 bt_le_conn_param_t *param = NULL;
2463 if (!address || !sender)
2464 return BLUETOOTH_ERROR_INVALID_PARAM;
2466 dev = __bt_get_le_connected_dev_info(address);
2468 return BLUETOOTH_ERROR_INTERNAL;
2470 param = __bt_get_le_conn_param_info(dev, sender);
2472 BT_DBG("Remove param %s %s ", address, sender);
2473 dev->senders = g_slist_remove(dev->senders, param);
2474 g_free(param->sender);
2478 return BLUETOOTH_ERROR_NONE;
2481 int _bt_get_le_connection_parameter(bluetooth_le_connection_mode_t mode,
2482 bluetooth_le_connection_param_t *param)
2485 return BLUETOOTH_ERROR_INVALID_PARAM;
2487 memset(param, 0x00, sizeof(bluetooth_le_connection_param_t));
2490 case BLUETOOTH_LE_CONNECTION_MODE_BALANCED:
2491 param->interval_min = BT_LE_CONN_PARAM_BALANCED_MIN_INTERVAL;
2492 param->interval_max = BT_LE_CONN_PARAM_BALANCED_MAX_INTERVAL;
2493 param->latency = BT_LE_CONN_PARAM_BALANCED_SLAVE_LATENCY;
2494 param->timeout = BT_LE_CONN_PARAM_DEFAULT_SUPERVISION_TIMEOUT;
2497 case BLUETOOTH_LE_CONNECTION_MODE_LOW_LATENCY:
2498 param->interval_min = BT_LE_CONN_PARAM_LOW_LATENCY_MIN_INTERVAL;
2499 param->interval_max = BT_LE_CONN_PARAM_LOW_LATENCY_MAX_INTERVAL;
2500 param->latency = BT_LE_CONN_PARAM_LOW_LATENCY_SLAVE_LATENCY;
2501 param->timeout = BT_LE_CONN_PARAM_DEFAULT_SUPERVISION_TIMEOUT;
2504 case BLUETOOTH_LE_CONNECTION_MODE_LOW_POWER:
2505 param->interval_min = BT_LE_CONN_PARAM_LOW_POWER_MIN_INTERVAL;
2506 param->interval_max = BT_LE_CONN_PARAM_LOW_POWER_MAX_INTERVAL;
2507 param->latency = BT_LE_CONN_PARAM_LOW_POWER_SLAVE_LATENCY;
2508 param->timeout = BT_LE_CONN_PARAM_DEFAULT_SUPERVISION_TIMEOUT;
2512 BT_ERR("Unhandled mode : %d", mode);
2516 return BLUETOOTH_ERROR_NONE;
2519 int _bt_le_connection_update(const char *sender,
2520 unsigned char *device_address,
2521 float interval_min, float interval_max,
2522 guint16 latency, guint16 time_out)
2524 char address[BT_ADDRESS_STRING_SIZE] = { 0 };
2525 guint32 min_supervision_to;
2526 bt_connected_le_dev_t *dev = NULL;
2527 bt_le_conn_param_t *param = NULL;
2528 int ret = BLUETOOTH_ERROR_NONE;
2530 BT_CHECK_PARAMETER(device_address, return);
2532 BT_INFO("Sender %s, Min interval: %f, Max interval: %f, Latency: %u, Supervision timeout: %u",
2533 sender, interval_min, interval_max, latency, time_out);
2535 if (interval_min > interval_max ||
2536 interval_min < BT_LE_CONN_INTERVAL_MIN ||
2537 interval_max > BT_LE_CONN_INTERVAL_MAX) {
2538 ret = BLUETOOTH_ERROR_INVALID_PARAM;
2542 if (time_out < BT_LE_CONN_SUPER_TO_MIN ||
2543 time_out > BT_LE_CONN_SUPER_TO_MAX) {
2544 ret = BLUETOOTH_ERROR_INVALID_PARAM;
2548 if (latency > BT_LE_CONN_SLAVE_LATENCY_MAX) {
2549 ret = BLUETOOTH_ERROR_INVALID_PARAM;
2554 * The Supervision_Timeout in milliseconds shall be larger than
2555 * (1 + Conn_Latency) * Conn_Interval_Max * 2,
2556 * where Conn_Interval_Max is given in milliseconds.
2559 min_supervision_to = (1 + latency) * interval_max * 2;
2560 if (time_out <= min_supervision_to) {
2561 ret = BLUETOOTH_ERROR_INVALID_PARAM;
2565 _bt_convert_addr_type_to_string(address, device_address);
2566 BT_DBG("Remote device address: %s", address);
2568 _bt_add_le_conn_param_info(address, sender, interval_min, interval_max, 0, 2000);
2570 dev = __bt_get_le_connected_dev_info(address);
2572 BT_ERR("device not found in the list");
2573 ret = BLUETOOTH_ERROR_NOT_CONNECTED;
2577 if (g_slist_length(dev->senders) == 1)
2580 param = dev->senders->data;
2582 BT_DBG("dev %f, param %f, input %f", dev->interval_min, param->interval_min, interval_min);
2584 if (dev->interval_min == param->interval_min && dev->interval_max == param->interval_max) {
2585 BT_DBG("Skip due to same interval");
2589 interval_min = param->interval_min;
2590 interval_max = param->interval_max;
2594 ret = __bt_le_set_conn_parameter(address, interval_min, interval_max, latency, time_out);
2596 if (ret != OAL_STATUS_SUCCESS) {
2597 _bt_remove_le_conn_param_info(address, sender);
2598 BT_DBG("fail to update the LE connection parameter");
2599 ret = BLUETOOTH_ERROR_INTERNAL;
2603 dev->interval_min = interval_min;
2604 dev->interval_max = interval_max;
2606 return BLUETOOTH_ERROR_NONE;
2611 int _bt_disconnect_device(bluetooth_device_address_t *device_address)
2613 int result = OAL_STATUS_SUCCESS;
2617 retv_if(!device_address, BLUETOOTH_ERROR_INVALID_PARAM);
2619 result = device_disconnect((bt_address_t *)device_address);
2620 if (result != OAL_STATUS_SUCCESS) {
2621 BT_DBG("Failed to disconnect device");
2622 return BLUETOOTH_ERROR_INTERNAL;
2626 return BLUETOOTH_ERROR_NONE;
2629 static gboolean __bt_ignore_auto_pairing_request(const char *address)
2634 char lap_address[BT_LOWER_ADDRESS_LENGTH + 1] = {0,};
2642 if (address == NULL)
2645 /* Get the LAP(Lower Address part) */
2646 /* User BT_LOWER_ADDRESS_LENGTH+1 for lap_address to accomodate
2648 snprintf(lap_address, sizeof(lap_address), ",%s", address);
2650 fp = fopen(BT_AGENT_AUTO_PAIR_BLACKLIST_FILE, "r");
2653 BT_ERR("fopen failed \n");
2657 fseek(fp, 0, SEEK_END);
2662 BT_ERR("Get file size failed \n");
2667 buffer = g_malloc0(sizeof(char) * size);
2668 result = fread((char *)buffer, 1, size, fp);
2670 if (result != size) {
2671 BT_ERR("Read Error\n");
2676 BT_DBG("Buffer = %s\n", buffer);
2678 lines = g_strsplit_set(buffer, BT_AGENT_NEW_LINE, 0);
2684 /* Write the data and insert new device data */
2685 for (i = 0; lines[i] != NULL; i++) {
2686 if (g_str_has_prefix(lines[i], "AddressBlacklist")) {
2687 temp_buffer = g_strconcat(lines[i], lap_address, NULL);
2689 lines[i] = temp_buffer;
2692 buffer = g_strjoinv(BT_AGENT_NEW_LINE, lines);
2694 /* Fix : NULL_RETURNS */
2695 retv_if(buffer == NULL, FALSE);
2697 fp = fopen(BT_AGENT_AUTO_PAIR_BLACKLIST_FILE, "w");
2700 BT_ERR("fopen failed \n");
2705 BT_DBG("Buffer = %s\n", buffer);
2706 fwrite(buffer, 1, strlen(buffer), fp);