bt-service-adaptation/services/device/bt-service-core-device.c

   1 /*
   2  * Copyright (c) 2015 2016 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Contact: Anupam Roy <anupam.r@samsung.com>
   5  *
   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
   9  *
  10  *              http://www.apache.org/licenses/LICENSE-2.0
  11  *
  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.
  17  *
  18  */
  19
  20 #include <stdio.h>
  21 #include <gio/gio.h>
  22 #include <glib.h>
  23 #include <dlog.h>
  24 #include <string.h>
  25 #include <vconf.h>
  26 #include <vconf-internal-keys.h>
  27 #include <bundle.h>
  28 #include <bundle_internal.h>
  29 #include <eventsystem.h>
  30
  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"
  46 #endif
  47 #include "bt-service-device-internal.h"
  48
  49 #ifdef TIZEN_GATT_CLIENT
  50 #include "bt-service-gatt.h"
  51 #endif
  52
  53 /* OAL headers */
  54 #include <oal-event.h>
  55 #include <oal-manager.h>
  56 #include <oal-adapter-mgr.h>
  57 #include <oal-device-mgr.h>
  58
  59 #define MAX_BOND_RETRY_COUNT 3
  60 #define BT_PASSKEY_MAX_LENGTH 4
  61
  62 #define BT_LE_CONN_PARAM_DEFAULT_SUPERVISION_TIMEOUT    6000    /* msec */
  63
  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 */
  67
  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 */
  71
  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 */
  75
  76 /* Bonding Info structure */
  77 typedef struct {
  78         int result;
  79         char *addr;
  80         gboolean is_autopair;
  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;
  86 } bt_bond_data_t;
  87
  88 /* Searching Info structure */
  89 typedef struct {
  90         int result;
  91         char *addr;
  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;
  96
  97 /* Pairing Info structure */
  98 typedef struct {
  99         char *addr;
 100         gboolean is_autopair;
 101         int is_ssp;
 102 } bt_pairing_data_t;
 103
 104 typedef struct {
 105         char addr[BT_ADDRESS_STRING_SIZE];
 106         bt_remote_dev_info_t *dev_info;
 107 } bt_incoming_bond_data_t;
 108
 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;
 114
 115 bt_incoming_bond_data_t *incoming_bond_info;
 116
 117 typedef enum {
 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
 126 } bt_bond_state_e;
 127
 128 typedef enum {
 129         BT_DEVICE_BOND_INFO,
 130         BT_DEVICE_INCOMING_BOND_INFO,
 131         BT_DEVICE_UNBOND_INFO
 132 } bt_bond_info_e;
 133
 134 /* BT device bond state variable */
 135 static bt_bond_state_e bt_device_bond_state;
 136 static int bond_retry_count;
 137
 138 static char *passkey_watcher;
 139 static GSList *pin_info_list = NULL;
 140
 141 /** DBFW+ Event Code */
 142 typedef enum {
 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;
 151
 152 static int dbfw_rssi;
 153
 154 #ifdef TIZEN_GATT_CLIENT
 155 typedef struct {
 156         char *address;
 157         float interval_min;
 158         float interval_max;
 159         GSList *senders;
 160 } bt_connected_le_dev_t;
 161
 162 typedef struct {
 163         char *sender;
 164         float interval_min;
 165         float interval_max;
 166         guint16 latency;
 167         guint16 time_out;
 168         float key;
 169 } bt_le_conn_param_t;
 170
 171 static GSList *le_connected_dev_list = NULL;
 172
 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 */
 180
 181 static void _bt_handle_le_connected_dev_info(const char *address, gboolean connected);
 182 #endif
 183
 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);
 187
 188
 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);
 199
 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);
 206
 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);
 209
 210 static void __bt_device_trusted_callback(gboolean trusted, event_dev_trust_t* info);
 211
 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);
 214
 215 gboolean _bt_is_device_creating(void)
 216 {
 217         if (!trigger_bond_info)
 218                 return FALSE;
 219         return trigger_bond_info->is_device_creating;
 220 }
 221
 222 void _bt_device_state_handle_callback_set_request(void)
 223 {
 224         _bt_service_register_event_handler_callback(
 225                         BT_DEVICE_MODULE, __bt_device_event_handler);
 226 }
 227
 228 void __bt_device_handle_pending_requests(int result, int service_function,
 229                 void *user_data, unsigned int size)
 230 {
 231         GSList *l;
 232         GArray *out_param;
 233         invocation_info_t *req_info = NULL;
 234
 235         BT_DBG("+");
 236
 237         /* Get method invocation context */
 238         for (l = _bt_get_invocation_list(); l != NULL; ) {
 239                 req_info = l->data;
 240                 l = g_slist_next(l);
 241                 if (req_info == NULL || req_info->service_function != service_function)
 242                         continue;
 243
 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!!");
 249                                 return;
 250                         } else {
 251                                 BT_INFO("Found info request addr [%s]", (char*)req_info->user_data);
 252                                 bt_sdp_info_t sdp_info;
 253
 254                                 memset(&sdp_info, 0x00, sizeof(bt_sdp_info_t));
 255                                 _bt_convert_addr_string_to_type(sdp_info.device_addr.addr, address);
 256
 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);
 260
 261                                 g_free(req_info->user_data);
 262                                 _bt_free_info_from_invocation_list(req_info);
 263                                 g_array_free(out_param, TRUE);
 264                         }
 265                         break;
 266                 }
 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!!");
 271                                 return;
 272                         } else {
 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,
 277                                                 address);
 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);
 282
 283                                 g_free(req_info->user_data);
 284                                 _bt_free_info_from_invocation_list(req_info);
 285                                 g_array_free(out_param, TRUE);
 286                         }
 287                         break;
 288                 }
 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!!");
 293                                 return;
 294                         } else {
 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);
 302
 303                                 g_free(req_info->user_data);
 304                                 _bt_free_info_from_invocation_list(req_info);
 305                                 g_array_free(out_param, TRUE);
 306                         }
 307                         break;
 308                 }
 309                 default:
 310                         BT_ERR("Unhandled case");
 311                         break;
 312                 }
 313         }
 314         BT_INFO("-");
 315 }
 316
 317 /*
 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)
 322  */
 323 static void __bt_device_remote_properties_callback(event_dev_properties_t *oal_dev_props)
 324 {
 325         bt_remote_dev_info_t *rem_info = NULL;
 326
 327         BT_DBG("+");
 328         rem_info = g_malloc0(sizeof(bt_remote_dev_info_t));
 329         _bt_copy_remote_dev(rem_info, &(oal_dev_props->device_info));
 330
 331         if (oal_dev_props->adv_len > 0) {
 332                 int k;
 333
 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);
 340
 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]);
 344                 }
 345         } else {
 346                 rem_info->manufacturer_data = NULL;
 347                 rem_info->manufacturer_data_len = 0;
 348         }
 349
 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);
 362                 }
 363
 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);
 377                 }
 378
 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);
 381         }
 382
 383         /* Add device to bonded list */
 384         _bt_service_add_device_to_bonded_list(rem_info);
 385
 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;
 396
 397                         /* TODO*/
 398                         service_search_info->dev_info->manufacturer_data = NULL;
 399                         service_search_info->dev_info->manufacturer_data_len = 0;
 400
 401                         __bt_handle_ongoing_device_service_search(service_search_info->dev_info);
 402                 }
 403         }
 404
 405         _bt_free_remote_dev(rem_info);
 406         BT_DBG("-");
 407 }
 408
 409 static int __get_oal_trusted_profile(bluetooth_trusted_profile_t profile)
 410 {
 411         switch (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;
 424         default:
 425                 return 0;
 426         }
 427 }
 428
 429 int _bt_set_trust_profile(bluetooth_device_address_t *addr,
 430                 bluetooth_trusted_profile_t profile, gboolean trust)
 431 {
 432         int result;
 433         bt_address_t bd_addr;
 434         oal_trusted_profile_e oal_profile;
 435
 436         BT_DBG("+");
 437
 438         retv_if(!addr, BLUETOOTH_ERROR_INVALID_PARAM);
 439
 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);
 443
 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;
 448         }
 449
 450         BT_DBG("-");
 451         return BLUETOOTH_ERROR_NONE;
 452 }
 453
 454 int _bt_get_trust_profile(bluetooth_device_address_t *addr,
 455                 bluetooth_trusted_profile_t profile, guint *trust)
 456 {
 457         int result;
 458         bt_address_t bd_addr;
 459         oal_trusted_profile_e oal_profile;
 460
 461         BT_DBG("+");
 462
 463         retv_if(!addr, BLUETOOTH_ERROR_INVALID_PARAM);
 464
 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);
 468
 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;
 473         }
 474
 475         BT_DBG("-");
 476         return BLUETOOTH_ERROR_NONE;
 477 }
 478
 479 static void __bt_handle_ongoing_device_service_search(bt_remote_dev_info_t *remote_dev_info)
 480 {
 481         GVariant *param = NULL;
 482         GVariant *uuids = NULL;
 483         GVariantBuilder *builder = NULL;
 484         GVariant *manufacturer_data;
 485         unsigned int i = 0;
 486         char *name = NULL;
 487
 488         BT_INFO("Send Service Search request event");
 489
 490         if (remote_dev_info->alias)
 491                 name = remote_dev_info->alias;
 492         else
 493                 name = remote_dev_info->name;
 494
 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]);
 499         }
 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,
 504                         TRUE, NULL, NULL);
 505
 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,
 511                         name,
 512                         remote_dev_info->paired,
 513                         remote_dev_info->connected,
 514                         remote_dev_info->trust,
 515                         uuids,
 516                         remote_dev_info->manufacturer_data_len,
 517                         manufacturer_data);
 518         /* Send the event to application */
 519         _bt_send_event(BT_ADAPTER_EVENT,
 520                         BLUETOOTH_EVENT_SERVICE_SEARCHED,
 521                         param);
 522
 523         __bt_free_service_search_info(&service_search_info);
 524         BT_DBG("-");
 525 }
 526
 527 static void __bt_device_services_callback(event_dev_services_t* uuid_list)
 528 {
 529         bt_remote_dev_info_t *rem_info = NULL;
 530         unsigned int i;
 531         BT_DBG("+");
 532
 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;
 536
 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");
 542                 else
 543                         BT_ERR("_bt_device_get_bonded_device_info failed");
 544         }
 545
 546         if (service_search_info == NULL) {
 547                 /* Send reply */
 548                 BT_DBG("searching_info == NULL");
 549                 return;
 550         }
 551
 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");
 555                 return;
 556         }
 557
 558         rem_info = g_malloc0(sizeof(bt_remote_dev_info_t));
 559         memset(rem_info, 0x00, sizeof(bt_remote_dev_info_t));
 560
 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);
 563
 564         rem_info->uuid_count = uuid_list->num;
 565
 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);
 570
 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]);
 576         }
 577
 578         /* Update local cache */
 579         _bt_update_remote_dev_property(rem_info->address, DEV_PROP_SERVICES, (void *)rem_info);
 580
 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);
 584
 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;
 589
 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");
 593         } else {
 594                 BT_DBG("Possibly internal stack error in bonded device info query, perform cleanup");
 595                 __bt_free_service_search_info(&service_search_info);
 596         }
 597         BT_DBG("-");
 598 }
 599
 600 static void __bt_device_authorization_request_callback(event_dev_authorize_req_t* auth_event)
 601 {
 602         oal_service_t service_d = auth_event->service_id;
 603         gchar address[BT_ADDRESS_STR_LEN];
 604         int res;
 605
 606         _bt_convert_addr_type_to_string(address, auth_event->address.addr);
 607
 608         BT_INFO("service_d: %d", service_d);
 609
 610         switch (service_d) {
 611         case HID_SERVICE_ID:
 612                 BT_INFO("Incoming HID Profile conn Req from device addr [%s]", address);
 613                 break;
 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);
 617                 return;
 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);
 621                 break;
 622         case AVRCP_SERVICE_ID:
 623                 BT_INFO("Incoming AVRCP (Remote) Profile conn Req from device addr [%s]", address);
 624                 break;
 625         case AVRCP_CT_SERVICE_ID:
 626                 BT_INFO("Incoming AVRCP (Controller) Profile conn Req from device addr [%s]", address);
 627                 break;
 628 #ifdef TIZEN_FEATURE_BT_OBEX
 629         case OPP_SERVICE_ID: {
 630                 GVariant *param = NULL;
 631                 char *name = NULL;
 632
 633                 if (_bt_obex_server_is_custom() == false) {
 634                         /* Allow the connection for native OPP server */
 635                         break;
 636                 }
 637
 638                 name = g_strdup(address);
 639
 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);
 645                 g_free(name);
 646                 return;
 647         }
 648 #endif
 649         case HSP_SERVICE_ID:
 650                 BT_INFO("Incoming HSP_SERVICE_ID conn Req from device addr [%s]", address);
 651                 break;
 652         case HFP_SERVICE_ID:
 653                 BT_INFO("Incoming HFP_SERVICE_ID conn Req from device addr [%s]", address);
 654                 break;
 655         case SAP_SERVICE_ID:
 656                 BT_INFO("Incoming SAP_SERVICE_ID conn Req from device addr [%s]", address);
 657                 break;
 658         case HSP_HS_SERVICE_ID:
 659                 BT_INFO("Incoming HSP_HS_SERVICE_ID conn Req from device addr [%s]", address);
 660                 break;
 661         case HFP_HS_SERVICE_ID:
 662                 BT_INFO("Incoming HFP_HS_SERVICE_ID conn Req from device addr [%s]", address);
 663                 break;
 664 #ifdef TIZEN_BT_HAL
 665         case IOTIVITY_SERVICE_ID:
 666                 BT_INFO("Incoming IOTIVITY_SERVICE_ID conn Req from device addr [%s]", address);
 667                 break;
 668 #endif
 669         default:
 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);
 675                 return;
 676         }
 677
 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);
 683         BT_INFO("-");
 684 }
 685
 686 static void __bt_handle_ongoing_bond(bt_remote_dev_info_t *remote_dev_info, gboolean incoming_bond)
 687 {
 688         GVariant *param = NULL;
 689
 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;
 696                 unsigned int i = 0;
 697                 char *name = NULL;
 698
 699                 if (remote_dev_info->alias)
 700                         name = remote_dev_info->alias;
 701                 else
 702                         name = remote_dev_info->name;
 703
 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]);
 708                 }
 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,
 713                                 TRUE, NULL, NULL);
 714
 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,
 720                                 name,
 721                                 remote_dev_info->paired,
 722                                 remote_dev_info->connected,
 723                                 remote_dev_info->trust,
 724                                 uuids,
 725                                 remote_dev_info->manufacturer_data_len,
 726                                 manufacturer_data);
 727                 /* Send the event to application */
 728                 _bt_send_event(BT_ADAPTER_EVENT,
 729                                 BLUETOOTH_EVENT_BONDING_FINISHED,
 730                                 param);
 731                 BT_PERMANENT_LOG("Paired %s", remote_dev_info->address + 12);
 732                 BT_INFO_C("### Paired %s", remote_dev_info->address);
 733                 if (incoming_bond) {
 734                         __bt_free_bond_info(BT_DEVICE_INCOMING_BOND_INFO);
 735                 } else {
 736                         __bt_free_bond_info(BT_DEVICE_BOND_INFO);
 737                         __bt_free_pairing_info(&trigger_pairing_info);
 738                 }
 739         } else {
 740                 BT_INFO("Lets wait for more remote device properties");
 741         }
 742 }
 743
 744 static void __handle_incoming_bond_created_event(bt_address_t *bd_addr)
 745 {
 746         char address[BT_ADDRESS_STRING_SIZE];
 747         bluetooth_device_address_t dev_addr;
 748
 749         /*
 750          * BlueZ sends paired signal for each paired device, during activation,
 751          * We should ignore this, otherwise application thinks that a new device
 752          * got paired
 753          */
 754         if (_bt_adapter_get_status() != BT_ACTIVATED) {
 755                 BT_DBG("BT is not activated, so ignore this");
 756                 return;
 757         }
 758
 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));
 762         } else {
 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));
 768                 }
 769         }
 770
 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;
 774
 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");
 778         } else {
 779                 BT_ERR("Bonded device info query failed");
 780                 __bt_free_bond_info(BT_DEVICE_INCOMING_BOND_INFO);
 781         }
 782
 783 }
 784
 785 static void __bt_device_handle_bond_completion_event(bt_address_t *bd_addr)
 786 {
 787         gchar address[BT_ADDRESS_STR_LEN];
 788         bluetooth_device_address_t dev_addr;
 789
 790         if (trigger_bond_info == NULL) {
 791                 /* Send reply */
 792                 BT_DBG("trigger_bond_info == NULL, Handle incomming bond event");
 793                 __handle_incoming_bond_created_event(bd_addr);
 794                 return;
 795         }
 796
 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);
 802                 return;
 803         }
 804
 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);
 815
 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);
 820         } else {
 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);
 826
 827                 __bt_free_bond_info(BT_DEVICE_BOND_INFO);
 828                 __bt_free_pairing_info(&trigger_pairing_info);
 829         }
 830 }
 831
 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)
 840 {
 841         char address[BT_ADDRESS_STRING_SIZE];
 842
 843         BT_INFO("+");
 844
 845         _bt_convert_addr_type_to_string(address, bd_addr->addr);
 846         _bt_service_remove_device_from_bonded_list(address);
 847
 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,
 856                                 param);
 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();
 863         }
 864         BT_INFO("-");
 865 }
 866
 867 static void __bt_device_handle_bond_failed_event(event_dev_bond_failed_t* bond_fail_event)
 868 {
 869         BT_INFO("+");
 870         oal_status_t status = bond_fail_event->status;
 871         BT_INFO("Bonding failed, reason: %d", status);
 872
 873         switch (status) {
 874         case OAL_STATUS_RMT_DEVICE_DOWN:
 875         {
 876                 if (trigger_bond_info) {
 877                         BT_INFO("OAL_STATUS_RMT_DEVICE_DOWN:Lets retry bonding!! retry count [%d]",
 878                                         bond_retry_count);
 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;
 889                                 } else
 890                                         bond_retry_count++;
 891                         } else {
 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;
 898                         }
 899                 }
 900                 break;
 901         }
 902         case OAL_STATUS_AUTH_FAILED:
 903         {
 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");
 908
 909                 BT_INFO("add device in pairing black list");
 910                 _bt_set_autopair_status_in_bonding_info(FALSE);
 911                 __bt_ignore_auto_pairing_request(trigger_bond_info->addr);
 912
 913                 if (trigger_bond_info) {
 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;
 918                         }
 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);
 922                 }
 923
 924                 __bt_free_pairing_info(&trigger_pairing_info);
 925                 break;
 926         }
 927         case OAL_STATUS_INTERNAL_ERROR:
 928         {
 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,
 938                                         param);
 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);
 946                                 }
 947                         }
 948                 }
 949
 950                 __bt_free_pairing_info(&trigger_pairing_info);
 951                 break;
 952         }
 953         default:
 954         {
 955                 BT_ERR("Unknown status of Bond failed event status [%d]", status);
 956                 break;
 957         }
 958
 959         }
 960         BT_INFO("-");
 961 }
 962
 963 static gboolean __bt_device_init_dbfw_rssi_cb(gpointer user_data)
 964 {
 965         dbfw_rssi = 0;
 966         return FALSE;
 967 }
 968
 969 static void __bt_device_parse_dbfw_set_rssi(unsigned char *data, uint32_t length)
 970 {
 971         ret_if(length < 5);
 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);
 975 }
 976
 977 static void __bt_device_dbfw_plus_info_callback(event_dev_dbfw_plus_info_t *dbfw_info)
 978 {
 979         char evt_str[18];
 980         char *data_str = NULL;
 981         int i;
 982
 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';
 987
 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);
 993                         break;
 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)");
 997                         break;
 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)");
1001                         break;
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)");
1005                         break;
1006                 case BT_DBFW_PLUS_EVENT_CODE_A2DP_INFO:
1007                         BT_DBG("## Event Code: A2DP Info");
1008                         snprintf(evt_str, 18, "[DBFW]A2DP");
1009                         break;
1010                 case BT_DBFW_PLUS_EVENT_CODE_HFP_INFO:
1011                         BT_DBG("## Event Code: HFP Info");
1012                         snprintf(evt_str, 18, "[DBFW]HFP");
1013                         break;
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");
1017                         break;
1018                 default:
1019                         BT_DBG("## Unknown event code (0x%02x)", dbfw_info->event_code);
1020                         snprintf(evt_str, 18, "[DBFW]0x%02X", dbfw_info->event_code);
1021                         break;
1022         }
1023
1024         BT_PERMANENT_LOG("%s 0x%s", evt_str, data_str);
1025         g_free(data_str);
1026 }
1027
1028 static void __bt_device_event_handler(int event_type, gpointer event_data)
1029 {
1030         int eventcheck = OAL_EVENT_DEVICE_PROPERTIES;
1031         BT_INFO("event [%d] Event check = [%d]", event_type, eventcheck);
1032
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);
1037                 break;
1038         }
1039         case OAL_EVENT_ADAPTER_INQUIRY_RESULT_BLE: {
1040                 BT_INFO("Dual Device Found");
1041                 __bt_device_remote_device_found_callback(event_data, FALSE);
1042                 break;
1043         }
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);
1047                 break;
1048         }
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);
1052                 break;
1053         }
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);
1057                 break;
1058         }
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);
1062                 break;
1063         }
1064         case OAL_EVENT_DEVICE_ACL_CONNECTED: {
1065                 BT_INFO("ACL Connected event Received");
1066                 event_dev_conn_status_t* param = event_data;
1067                 __bt_device_acl_state_changed_callback(param, TRUE, 0);
1068                 break;
1069         }
1070         case OAL_EVENT_DEVICE_ACL_DISCONNECTED: {
1071                 BT_INFO("ACL Disconnected event Received");
1072                 __bt_device_acl_state_changed_callback((event_dev_conn_status_t *)event_data, FALSE, 0);
1073                 break;
1074         }
1075         case OAL_EVENT_DEVICE_LE_CONNECTED: {
1076                 BT_INFO("LE Connected event Received");
1077                 event_dev_conn_status_t* param = event_data;
1078                 __bt_device_acl_state_changed_callback(param, TRUE, 1);
1079                 break;
1080         }
1081         case OAL_EVENT_DEVICE_LE_DISCONNECTED: {
1082                 BT_INFO("LE Disconnected event Received");
1083                 __bt_device_acl_state_changed_callback((event_dev_conn_status_t *)event_data, FALSE, 1);
1084                 break;
1085         }
1086         case OAL_EVENT_DEVICE_PIN_REQUEST: {
1087                 BT_INFO("PIN Request Received");
1088                 __bt_device_pin_request_callback((remote_device_t*)event_data);
1089                 break;
1090         }
1091         case OAL_EVENT_DEVICE_PASSKEY_ENTRY_REQUEST: {
1092                 BT_INFO("Passkey Entry request Received");
1093                 __bt_device_ssp_passkey_entry_callback((remote_device_t*)event_data);
1094                 break;
1095         }
1096         case OAL_EVENT_DEVICE_PASSKEY_CONFIRMATION_REQUEST:{
1097                 BT_INFO("Passkey Confirmation Request Received");
1098                 __bt_device_ssp_passkey_confirmation_callback((event_dev_passkey_t *)event_data);
1099                 break;
1100         }
1101         case OAL_EVENT_DEVICE_PASSKEY_DISPLAY: {
1102                 BT_INFO("Passkey Display Request Received");
1103                 __bt_device_ssp_passkey_display_callback((event_dev_passkey_t *)event_data);
1104                 break;
1105         }
1106         case OAL_EVENT_DEVICE_SSP_CONSENT_REQUEST: {
1107                 BT_INFO("SSP Consent Request Received");
1108                  __bt_device_ssp_consent_callback((remote_device_t*)event_data);
1109                 break;
1110         }
1111         case OAL_EVENT_DEVICE_SERVICES: {
1112                 BT_INFO("Remote Device Services Received");
1113                 __bt_device_services_callback((event_dev_services_t*)event_data);
1114                 break;
1115         }
1116         case OAL_EVENT_DEVICE_AUTHORIZE_REQUEST: {
1117                 BT_INFO("Remote Device Authorization Request");
1118                 __bt_device_authorization_request_callback((event_dev_authorize_req_t*)event_data);
1119                 break;
1120         }
1121         case OAL_EVENT_DEVICE_TRUSTED: {
1122                 BT_INFO("Remote Device Trusted");
1123                 __bt_device_trusted_callback(TRUE, (event_dev_trust_t*)event_data);
1124                 break;
1125         }
1126         case OAL_EVENT_DEVICE_UNTRUSTED: {
1127                 BT_INFO("Remote Device UnTrusted");
1128                 __bt_device_trusted_callback(FALSE, (event_dev_trust_t*)event_data);
1129                 break;
1130         }
1131         case OAL_EVENT_DEVICE_NAME: {
1132                 remote_device_t *rem_dev = event_data;
1133                 gchar address[BT_ADDRESS_STR_LEN];
1134
1135                 _bt_convert_addr_type_to_string(address, rem_dev->address.addr);
1136                 BT_INFO("Remote Device name Received");
1137                 BT_INFO("Name: %s, Address: %s", rem_dev->name, address);
1138
1139                 /* Update local cache */
1140                 _bt_update_remote_dev_property(address, DEV_PROP_NAME, (void *)rem_dev->name);
1141                 break;
1142         }
1143         case OAL_EVENT_DEVICE_TRUSTED_PROFILES_CHANGED: {
1144                 event_device_trusted_profiles_t *ev = event_data;
1145                 char address[BT_ADDRESS_STRING_SIZE];
1146
1147                 ret_if(NULL == ev);
1148
1149                 _bt_convert_addr_type_to_string(address, ev->address.addr);
1150                 _bt_send_event(BT_DEVICE_EVENT,
1151                                 BLUETOOTH_EVENT_SUPPORTED_PROFILE_TRUSTED,
1152                                 g_variant_new("(isi)", BLUETOOTH_ERROR_NONE,
1153                                         address, ev->trust_val));
1154                 break;
1155         }
1156         case OAL_EVENT_RSSI_MONITORING_ENABLED: {
1157                 event_dev_rssi_info_t *ev = event_data;
1158                 char address[BT_ADDRESS_STRING_SIZE];
1159                 GVariant *param;
1160
1161                 ret_if(NULL == ev);
1162
1163                 _bt_convert_addr_type_to_string(address, ev->address.addr);
1164                 param = g_variant_new("(isib)", BLUETOOTH_ERROR_NONE,
1165                                 address, ev->link_type, TRUE);
1166                 _bt_send_event(BT_DEVICE_EVENT, BLUETOOTH_EVENT_RSSI_ENABLED, param);
1167                 break;
1168         }
1169         case OAL_EVENT_RSSI_MONITORING_DISABLED: {
1170                 event_dev_rssi_info_t *ev = event_data;
1171                 char address[BT_ADDRESS_STRING_SIZE];
1172                 GVariant *param;
1173
1174                 ret_if(NULL == ev);
1175
1176                 _bt_convert_addr_type_to_string(address, ev->address.addr);
1177                 param = g_variant_new("(isib)", BLUETOOTH_ERROR_NONE,
1178                                 address, ev->link_type, FALSE);
1179                 _bt_send_event(BT_DEVICE_EVENT, BLUETOOTH_EVENT_RSSI_ENABLED, param);
1180                 break;
1181         }
1182         case OAL_EVENT_RSSI_ALERT_RECEIVED: {
1183                 event_dev_rssi_info_t *ev = event_data;
1184                 char address[BT_ADDRESS_STRING_SIZE];
1185                 GVariant *param;
1186
1187                 ret_if(NULL == ev);
1188
1189                 _bt_convert_addr_type_to_string(address, ev->address.addr);
1190                 param = g_variant_new("(isiii)", BLUETOOTH_ERROR_NONE,
1191                                 address, ev->link_type, ev->alert_type, ev->rssi);
1192                 _bt_send_event(BT_DEVICE_EVENT, BLUETOOTH_EVENT_RSSI_ALERT, param);
1193                 break;
1194         }
1195         case OAL_EVENT_RAW_RSSI_RECEIVED: {
1196                 event_dev_rssi_info_t *ev = event_data;
1197                 char address[BT_ADDRESS_STRING_SIZE];
1198                 GVariant *param;
1199
1200                 ret_if(NULL == ev);
1201
1202                 _bt_convert_addr_type_to_string(address, ev->address.addr);
1203                 param = g_variant_new("(isii)", BLUETOOTH_ERROR_NONE,
1204                                 address, ev->link_type, ev->rssi);
1205                 _bt_send_event(BT_DEVICE_EVENT, BLUETOOTH_EVENT_RAW_RSSI, param);
1206                 break;
1207         }
1208         case OAL_EVENT_DEVICE_DBFW_PLUS_INFO: {
1209                 __bt_device_dbfw_plus_info_callback((event_dev_dbfw_plus_info_t*)event_data);
1210                 break;
1211         }
1212         default:
1213                 BT_INFO("Unhandled event..");
1214         }
1215 }
1216
1217 /* Legacy Pairing event handler */
1218 static void __bt_device_pin_request_callback(remote_device_t* pin_req_event)
1219 {
1220         GVariant *param;
1221         char address[BT_ADDRESS_STRING_SIZE];
1222         char pin_code[BLUETOOTH_PIN_CODE_MAX_LENGTH + 1];
1223         bool incoming = false;
1224         BT_DBG("+");
1225
1226         _bt_convert_addr_type_to_string(address, pin_req_event->address.addr);
1227
1228         BT_INFO("Address[%s]", address);
1229         BT_INFO("Name[%s]", pin_req_event->name);
1230         BT_INFO("COD[%d]", pin_req_event->cod);
1231
1232         if (trigger_pairing_info) {
1233                 /* BTAPI support only one pairing at a time */
1234                 BT_ERR("Already Pairing address [%s]", trigger_pairing_info->addr);
1235                 BT_ERR("New PIN request address [%s]", address);
1236                 device_reject_pin_request(&pin_req_event->address);
1237                 return;
1238         }
1239
1240         /* If user initiated bonding and auto response is possible, just reply with default 0000*/
1241         if (_bt_is_bonding_device_address(address) == TRUE &&
1242                         _bt_agent_is_auto_response(pin_req_event->cod, address, pin_req_event->name)) {
1243                 /* Note: Currently even if SYSPOPUP is supported, we use Fixed PIN "0000" for basic pairing
1244                    as BT SYSPOPUP is currently not working for PIN KEY entry in Tizen platform. This needs
1245                    to be checked and fixed apropriately */
1246                 _bt_set_autopair_status_in_bonding_info(TRUE);
1247                 device_accept_pin_request(&pin_req_event->address, "0000");
1248         } else if (_bt_agent_is_hid_keyboard(pin_req_event->cod)) {
1249                 BT_DBG("Remote Device is HID keyboard Type..");
1250                 char str_passkey[BT_PASSKEY_MAX_LENGTH + 1] = { 0 };
1251
1252                 if (_bt_agent_generate_passkey(str_passkey,
1253                                         BT_PASSKEY_MAX_LENGTH) != 0) {
1254                         device_reject_pin_request(&pin_req_event->address);
1255                         goto done;
1256                 }
1257                 device_accept_pin_request(&pin_req_event->address, str_passkey);
1258
1259                 BT_DBG("Send BLUETOOTH_EVENT_KEYBOARD_PASSKEY_DISPLAY");
1260
1261                 if(trigger_bond_info == NULL)
1262                         incoming = true;
1263
1264                 param = g_variant_new("(bsss)", incoming, address, pin_req_event->name, str_passkey);
1265                 _bt_send_event(BT_ADAPTER_EVENT,
1266                                 BLUETOOTH_EVENT_KEYBOARD_PASSKEY_DISPLAY, param);
1267                 BT_DBG("Key board pairing in process");
1268         } else if (BLUETOOTH_ERROR_NONE == __bt_get_device_pin_code(address, pin_code)) {
1269                 BT_DBG("Use stored PIN code [%s]", pin_code);
1270                 device_accept_pin_request(&pin_req_event->address, pin_code);
1271         } else {
1272                 if (_bt_is_bonding_device_address(address) == TRUE) {
1273                         BT_DBG("Show Pin entry");
1274                         trigger_pairing_info = g_malloc0(sizeof(bt_pairing_data_t));
1275                         trigger_pairing_info->addr = g_strdup(address);
1276                         trigger_pairing_info->is_ssp = FALSE;
1277
1278                         BT_DBG("Send BLUETOOTH_EVENT_PIN_REQUEST");
1279
1280                         if(trigger_bond_info == NULL)
1281                                 incoming = true;
1282
1283                         param = g_variant_new("(bss)", incoming, address, pin_req_event->name);
1284                         _bt_send_event(BT_ADAPTER_EVENT,
1285                                         BLUETOOTH_EVENT_PIN_REQUEST, param);
1286                 }
1287         }
1288
1289 done:
1290         _bt_agent_release_memory();
1291         BT_DBG("-");
1292 }
1293
1294 /* SSP Pairing event handler */
1295 static void __bt_device_ssp_passkey_entry_callback(remote_device_t* dev_info)
1296 {
1297         GVariant *param;
1298         gchar address[BT_ADDRESS_STR_LEN];
1299         char *p_addr;
1300         gchar *name;
1301         bool incoming = false;
1302
1303         BT_DBG("+");
1304
1305         _bt_convert_addr_type_to_string(address, dev_info->address.addr);
1306         p_addr = address;
1307         name = dev_info->name;
1308
1309         BT_INFO("Address[%s]", address);
1310         BT_INFO("Name[%s]", name);
1311         BT_INFO("COD[%d]", dev_info->cod);
1312
1313         if (trigger_pairing_info) {
1314                 /* BTAPI support only one pairing at a time */
1315                 BT_ERR("Already Pairing address [%s]", trigger_pairing_info->addr);
1316                 BT_ERR("New PIN request address [%s]", address);
1317                 device_reject_pin_request(&dev_info->address);
1318                 BT_DBG("-");
1319                 return;
1320         }
1321
1322         /* Set pairing data */
1323         trigger_pairing_info = g_malloc0(sizeof(bt_pairing_data_t));
1324         trigger_pairing_info->addr = g_strdup(address);
1325         trigger_pairing_info->is_ssp = TRUE;
1326
1327         if(trigger_bond_info == NULL)
1328                 incoming = true;
1329
1330         param = g_variant_new("(bss)", incoming, p_addr, name);
1331         _bt_send_event(BT_ADAPTER_EVENT,
1332                         BLUETOOTH_EVENT_PASSKEY_REQUEST, param);
1333         BT_DBG("-");
1334 }
1335
1336 static void __bt_device_ssp_passkey_confirmation_callback(event_dev_passkey_t *dev_info)
1337 {
1338         GVariant *param;
1339         gchar address[BT_ADDRESS_STR_LEN];
1340         char *p_addr;
1341         gchar *name;
1342         char str_passkey[7];
1343         bool incoming = false; /*Stores if bonding request is incoming(true) or outgoing(false) */
1344         BT_DBG("+");
1345
1346         _bt_convert_addr_type_to_string(address, dev_info->device_info.address.addr);
1347         p_addr = address;
1348         name = dev_info->device_info.name;
1349
1350         BT_INFO("Address[%s]", address);
1351         BT_INFO("Name[%s]", name);
1352         BT_INFO("COD[%d]", dev_info->device_info.cod);
1353
1354         if (trigger_pairing_info) {
1355                 /* BTAPI support only one pairing at a time */
1356                 BT_ERR("Already Pairing address [%s]", trigger_pairing_info->addr);
1357                 BT_ERR("New PIN request address [%s]", address);
1358                 device_reject_pin_request(&dev_info->device_info.address);
1359                 BT_DBG("-");
1360                 return;
1361         }
1362
1363         /* Set pairing data */
1364         trigger_pairing_info = g_malloc0(sizeof(bt_pairing_data_t));
1365         trigger_pairing_info->addr = g_strdup(address);
1366         trigger_pairing_info->is_ssp = TRUE;
1367
1368         BT_DBG("Send BLUETOOTH_EVENT_PASSKEY_CONFIRMATION");
1369         snprintf(str_passkey, sizeof(str_passkey), "%.6d", dev_info->pass_key);
1370
1371         /*Storing if bond is incoming or outgoing*/
1372         if(trigger_bond_info == NULL)
1373                 incoming = true;
1374
1375         param = g_variant_new("(bsss)", incoming, p_addr, name, str_passkey);
1376         _bt_send_event(BT_ADAPTER_EVENT,
1377                         BLUETOOTH_EVENT_PASSKEY_CONFIRM_REQUEST, param);
1378         BT_DBG("-");
1379 }
1380
1381 static void __bt_device_ssp_passkey_display_callback(event_dev_passkey_t *dev_info)
1382 {
1383         GVariant *param;
1384         gchar address[BT_ADDRESS_STR_LEN];
1385         char *p_addr;
1386         gchar *name;
1387         char str_passkey[7];
1388         bool incoming = false;
1389         BT_DBG("+");
1390
1391         _bt_convert_addr_type_to_string(address, dev_info->device_info.address.addr);
1392         p_addr = address;
1393         name = dev_info->device_info.name;
1394
1395         BT_INFO("Address[%s]", address);
1396         BT_INFO("Name[%s]", name);
1397         BT_INFO("COD[%d]", dev_info->device_info.cod);
1398
1399         if (trigger_pairing_info) {
1400                 /* BTAPI support only one pairing at a time */
1401                 BT_ERR("Already Pairing address [%s]", trigger_pairing_info->addr);
1402                 BT_ERR("New PIN request address [%s]", address);
1403                 device_reject_pin_request(&dev_info->device_info.address);
1404                 BT_DBG("-");
1405                 return;
1406         }
1407
1408         /* Set pairing data */
1409         trigger_pairing_info = g_malloc0(sizeof(bt_pairing_data_t));
1410         trigger_pairing_info->addr = g_strdup(address);
1411         trigger_pairing_info->is_ssp = TRUE;
1412
1413         BT_DBG("Send BLUETOOTH_EVENT_KEYBOARD_PASSKEY_DISPLAY");
1414         snprintf(str_passkey, sizeof(str_passkey), "%06d", dev_info->pass_key);
1415
1416         if(trigger_bond_info == NULL)
1417                 incoming = true;
1418
1419         param = g_variant_new("(bsss)", incoming, p_addr, name, str_passkey);
1420
1421         if (passkey_watcher) {
1422                 BT_INFO("Send passkey to %s", passkey_watcher);
1423                 _bt_send_event_to_dest(passkey_watcher, BT_ADAPTER_EVENT,
1424                                 BLUETOOTH_EVENT_PASSKEY_NOTIFICATION, param);
1425         } else {
1426                 _bt_send_event(BT_ADAPTER_EVENT,
1427                                 BLUETOOTH_EVENT_KEYBOARD_PASSKEY_DISPLAY, param);
1428         }
1429         BT_DBG("-");
1430 }
1431
1432 static void __bt_device_ssp_consent_callback(remote_device_t* dev_info)
1433 {
1434         gchar address[BT_ADDRESS_STR_LEN];
1435         gchar *name;
1436         int local_major;
1437         int local_minor;
1438         int cod;
1439         BT_DBG("+");
1440
1441         _bt_convert_addr_type_to_string(address, dev_info->address.addr);
1442         name = dev_info->name;
1443         cod = dev_info->cod;
1444
1445         BT_INFO("Address[%s]", address);
1446         BT_INFO("Name[%s]", name);
1447         BT_INFO("COD[%d]", cod);
1448
1449         if (trigger_pairing_info) {
1450                 /* BTAPI support only one pairing at a time */
1451                 BT_ERR("Already Pairing address [%s]", trigger_pairing_info->addr);
1452                 BT_ERR("New PIN request address [%s]", address);
1453                 device_reject_pin_request(&dev_info->address);
1454                 BT_DBG("-");
1455                 return;
1456         }
1457
1458         /* Set pairing data */
1459         trigger_pairing_info = g_malloc0(sizeof(bt_pairing_data_t));
1460         trigger_pairing_info->addr = g_strdup(address);
1461         trigger_pairing_info->is_ssp = TRUE;
1462
1463         local_major = ((cod >> 8) & 0x001f);
1464         local_minor = (cod & 0x00fc);
1465         BT_DBG("SSP_CONSENT: Major type=[0x%x] and Minor type=[0x%x]", local_major, local_minor);
1466
1467         /*TODO: BLUETOOTH_EVENT_SSP_CONSENT_REQUEST to be handled in Tizen */
1468         BT_DBG("-");
1469 }
1470
1471 static int __bt_oal_status_to_bt_error(int oal_status)
1472 {
1473         int ret = 0;
1474
1475         switch (oal_status) {
1476         case OAL_STATUS_SUCCESS:
1477                 ret = BLUETOOTH_ERROR_NONE;
1478                 break;
1479         case OAL_STATUS_CONN_TIMEOUT:
1480         case OAL_STATUS_LINK_LOSS:
1481                 BT_INFO("Connection Timeout");
1482                 ret = BLUETOOTH_ERROR_CONNECTION_TIMEOUT;
1483                 break;
1484 #ifdef TIZEN_BT_HAL
1485         case OAL_STATUS_CONN_TERM_LOCAL_HOST:
1486                 ret = BLUETOOTH_ERROR_LOCAL_HOST_TERM;
1487                 break;
1488         case OAL_STATUS_CONN_TERM_RMT_HOST:
1489                 ret = BLUETOOTH_ERROR_REMOTE_USER_TERM;
1490                 break;
1491 #endif
1492         case OAL_STATUS_INTERNAL_ERROR:
1493                 ret = BLUETOOTH_ERROR_INTERNAL;
1494                 break;
1495         default:
1496                 ret = BLUETOOTH_ERROR_INTERNAL;
1497                 break;
1498         }
1499         return ret;
1500 }
1501
1502 static void __bt_device_acl_state_changed_callback(event_dev_conn_status_t *acl_event,
1503                 gboolean connected, unsigned char type)
1504 {
1505         gchar address[BT_ADDRESS_STR_LEN];
1506         int result = BLUETOOTH_ERROR_NONE;
1507         GVariant *param = NULL;
1508         bt_device_conn_info_t conn_info;
1509
1510         BT_DBG("+");
1511         _bt_convert_addr_type_to_string(address, acl_event->address.addr);
1512
1513         _bt_logging_connection(connected, type);
1514
1515         result = __bt_oal_status_to_bt_error(acl_event->status);
1516         BT_INFO("Result [0x%x]", result);
1517
1518         if (connected) {
1519                 param = g_variant_new("(isy)", result, address, type);
1520                 _bt_send_event(BT_DEVICE_EVENT,
1521                                 BLUETOOTH_EVENT_DEVICE_CONNECTED,
1522                                 param);
1523         } else {
1524                 param = g_variant_new("(isyi)", result, address, type, dbfw_rssi);
1525                 _bt_send_event(BT_DEVICE_EVENT,
1526                                 BLUETOOTH_EVENT_DEVICE_DISCONNECTED,
1527                                 param);
1528         }
1529         BT_PERMANENT_LOG("%sonnected %s %s",
1530                 connected ? "C" : "Disc", !type ? "EDR" : "LE", address + 12);
1531
1532         conn_info.connected = connected;
1533         conn_info.type = type;
1534         /* Update local cache */
1535         _bt_update_remote_dev_property(address, DEV_PROP_CONNECTED, (void *)&conn_info);
1536
1537 #ifdef TIZEN_GATT_CLIENT
1538         /*handle LE connected device info*/
1539         if (type) {
1540                 BT_DBG("handle LE connected device info");
1541                 _bt_handle_le_connected_dev_info(address, connected);
1542         }
1543 #endif
1544
1545         BT_DBG("-");
1546 }
1547
1548 static void __bt_device_remote_device_found_callback(gpointer event_data, gboolean is_ble)
1549 {
1550         bt_remote_dev_info_t *dev_info = NULL;
1551         int result = BLUETOOTH_ERROR_NONE;
1552         GVariant *param = NULL;
1553         GVariant *uuids = NULL;
1554         GVariant *manufacturer_data = NULL;
1555         GVariantBuilder *builder = NULL;
1556         unsigned int i;
1557
1558         ret_if(_bt_is_discovering() == FALSE);
1559         ret_if(event_data == NULL);
1560
1561         dev_info = g_malloc0(sizeof(bt_remote_dev_info_t));
1562
1563         if (is_ble) {
1564                 event_ble_dev_found_t * oal_ble_dev = event_data;
1565                 BT_INFO("Device type [%d]", oal_ble_dev->device_info.type);
1566
1567                 _bt_copy_remote_dev(dev_info, &oal_ble_dev->device_info);
1568
1569                 dev_info->manufacturer_data_len = oal_ble_dev->adv_len;
1570                 if (dev_info->manufacturer_data_len)
1571                         dev_info->manufacturer_data = g_memdup(oal_ble_dev->adv_data,
1572                                         dev_info->manufacturer_data_len);
1573                 else
1574                         dev_info->manufacturer_data = NULL;
1575                 BT_DBG("----Advertising Data Length: %d", dev_info->manufacturer_data_len);
1576         } else {
1577                 event_dev_found_t * oal_dev = event_data;
1578                 _bt_copy_remote_dev(dev_info, &oal_dev->device_info);
1579         }
1580
1581         /* If Remote device name is NULL or still RNR is not done then display address as name. */
1582         if (dev_info->name == NULL)
1583                 dev_info->name = g_strdup(dev_info->address);
1584         BT_DBG("Name %s", dev_info->name);
1585
1586         builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
1587         for (i = 0; i < dev_info->uuid_count; i++)
1588                 g_variant_builder_add(builder, "s", dev_info->uuids[i]);
1589
1590         uuids = g_variant_new("as", builder);
1591         g_variant_builder_unref(builder);
1592
1593         manufacturer_data = g_variant_new_from_data(G_VARIANT_TYPE_BYTESTRING,
1594                         dev_info->manufacturer_data,
1595                         dev_info->manufacturer_data_len,
1596                         TRUE,
1597                         NULL, NULL);
1598
1599         param = g_variant_new("(isunsbub@asn@ay)", result,
1600                         dev_info->address,
1601                         dev_info->class,
1602                         dev_info->rssi,
1603                         dev_info->name,
1604                         dev_info->paired,
1605                         dev_info->connected,
1606                         dev_info->trust,
1607                         uuids,
1608                         dev_info->manufacturer_data_len,
1609                         manufacturer_data);
1610
1611         _bt_send_event(BT_ADAPTER_EVENT,
1612                         BLUETOOTH_EVENT_REMOTE_DEVICE_FOUND,
1613                         param);
1614
1615         _bt_free_remote_dev(dev_info);
1616 }
1617
1618 static void __bt_device_trusted_callback(gboolean trusted, event_dev_trust_t* info)
1619 {
1620         gchar address[BT_ADDRESS_STR_LEN];
1621         int result = BLUETOOTH_ERROR_NONE;
1622         GVariant *param = NULL;
1623         int event;
1624
1625         _bt_convert_addr_type_to_string(address, info->address.addr);
1626
1627         /* Update local cache */
1628         _bt_update_remote_dev_property(address, DEV_PROP_TRUST, (void *)&trusted);
1629
1630         param = g_variant_new("(is)", result, address);
1631         event = trusted ? BLUETOOTH_EVENT_DEVICE_AUTHORIZED :
1632                 BLUETOOTH_EVENT_DEVICE_UNAUTHORIZED;
1633         /* Send event to application */
1634         _bt_send_event(BT_DEVICE_EVENT,
1635                         event,
1636                         param);
1637
1638 }
1639
1640 static void __bt_free_pairing_info(bt_pairing_data_t **p_info)
1641 {
1642         bt_pairing_data_t * info = *p_info;
1643         if (info) {
1644                 if (info->addr)
1645                         g_free(info->addr);
1646
1647                 g_free(info);
1648         }
1649         *p_info = NULL;
1650 }
1651
1652 static void __bt_free_bond_info(uint8_t type)
1653 {
1654         switch (type) {
1655         case BT_DEVICE_BOND_INFO:
1656                 if (!trigger_bond_info)
1657                         break;
1658
1659                 if (trigger_bond_info->addr)
1660                         g_free(trigger_bond_info->addr);
1661                 if (trigger_bond_info->dev_addr)
1662                         g_free(trigger_bond_info->dev_addr);
1663                 if (trigger_bond_info->dev_info)
1664                         _bt_free_remote_dev(trigger_bond_info->dev_info);
1665                 g_free(trigger_bond_info);
1666                 trigger_bond_info = NULL;
1667                 break;
1668         case BT_DEVICE_INCOMING_BOND_INFO:
1669                 if (!incoming_bond_info)
1670                         break;
1671
1672                 if (incoming_bond_info->dev_info)
1673                         _bt_free_remote_dev(incoming_bond_info->dev_info);
1674                 g_free(incoming_bond_info);
1675                 incoming_bond_info = NULL;
1676                 break;
1677         case BT_DEVICE_UNBOND_INFO:
1678                 if (!trigger_unbond_info)
1679                         break;
1680
1681                 if (trigger_unbond_info->addr)
1682                         g_free(trigger_unbond_info->addr);
1683                 if (trigger_unbond_info->dev_addr)
1684                         g_free(trigger_unbond_info->dev_addr);
1685                 if (trigger_unbond_info->dev_info)
1686                         _bt_free_remote_dev(trigger_unbond_info->dev_info);
1687                 g_free(trigger_unbond_info);
1688                 trigger_unbond_info = NULL;
1689                 break;
1690         }
1691 }
1692
1693 static void __bt_free_service_search_info(bt_service_search_info_data_t **p_info)
1694 {
1695         bt_service_search_info_data_t * info = *p_info;
1696         if (info) {
1697                 if (info->addr) {
1698                         g_free(info->addr);
1699                         info->addr = NULL;
1700                 }
1701
1702                 if (info->dev_addr) {
1703                         g_free(info->dev_addr);
1704                         info->dev_addr = NULL;
1705                 }
1706
1707                 if (info->dev_info) {
1708                         _bt_free_remote_dev(info->dev_info);
1709                         info->dev_info = NULL;
1710                 }
1711
1712                 g_free(info);
1713         }
1714         *p_info = NULL;
1715 }
1716
1717 static int __bt_device_handle_bond_state(void)
1718 {
1719         BT_INFO("Current Bond state: %d", bt_device_bond_state);
1720         int ret = OAL_STATUS_INTERNAL_ERROR;
1721
1722         switch (bt_device_bond_state) {
1723         case BT_DEVICE_BOND_STATE_CANCEL_DISCOVERY:
1724                 /*TODO:Bonding during discovery: Unhandled!!*/
1725                 BT_INFO("Bonding during discovery: Unhandled!!");
1726                 break;
1727         case BT_DEVICE_BOND_STATE_DISCOVERY_CANCELLED:
1728                 /*TODO:Bonding during discovery: Unhandled!!*/
1729                 BT_INFO("Bonding during discovery: Unhandled!!");
1730                 break;
1731         case BT_DEVICE_BOND_STATE_REMOVE_BONDING:
1732                 bt_device_bond_state = BT_DEVICE_BOND_STATE_REMOVED_BONDING;
1733                 ret = device_destroy_bond((bt_address_t *)trigger_bond_info->dev_addr);
1734                 if (ret != OAL_STATUS_SUCCESS)
1735                         ret = __bt_device_handle_bond_state();
1736                 break;
1737         case BT_DEVICE_BOND_STATE_REMOVED_BONDING:
1738                 bt_device_bond_state = BT_DEVICE_BOND_STATE_NONE;
1739                 ret = device_create_bond((bt_address_t *)trigger_bond_info->dev_addr, trigger_bond_info->conn_type);
1740                 /* Bonding procedure was started but unfortunately could not complete.
1741                    Basically removed bonding was success, but create bond request could not proceed
1742                    So lets cleanup the context */
1743                 if (ret != OAL_STATUS_SUCCESS) {
1744                         BT_ERR("Create Bond procedure could not suceed");
1745                         __bt_device_handle_pending_requests(BLUETOOTH_ERROR_INTERNAL, BT_BOND_DEVICE,
1746                                         trigger_bond_info->addr, BT_ADDRESS_STRING_SIZE);
1747                         __bt_free_bond_info(BT_DEVICE_BOND_INFO);
1748                         __bt_free_pairing_info(&trigger_pairing_info);
1749                 }
1750                 break;
1751         case BT_DEVICE_BOND_STATE_NONE:
1752                 BT_INFO("Create Bond failed!!");
1753                 if (trigger_bond_info) {
1754                         __bt_device_handle_pending_requests(BLUETOOTH_ERROR_INTERNAL, BT_BOND_DEVICE,
1755                                         trigger_bond_info->addr, BT_ADDRESS_STRING_SIZE);
1756                         __bt_free_bond_info(BT_DEVICE_BOND_INFO);
1757                         __bt_free_pairing_info(&trigger_pairing_info);
1758                 }
1759                 break;
1760         default:
1761                 break;
1762         }
1763
1764         if (ret != OAL_STATUS_SUCCESS)
1765                 return BLUETOOTH_ERROR_INTERNAL;
1766         else
1767                 return BLUETOOTH_ERROR_NONE;
1768 }
1769
1770 int _bt_device_get_bonded_device_info(bluetooth_device_address_t *addr)
1771 {
1772         int result;
1773         bt_address_t bd_addr;
1774
1775         BT_DBG("+");
1776
1777         retv_if(!addr, BLUETOOTH_ERROR_INVALID_PARAM);
1778
1779         memcpy(bd_addr.addr, addr, BLUETOOTH_ADDRESS_LENGTH);
1780         result = device_query_attributes(&bd_addr);
1781         if (result != OAL_STATUS_SUCCESS) {
1782                 BT_ERR("device_query_attributes error: [%d]", result);
1783                 return BLUETOOTH_ERROR_INTERNAL;
1784         }
1785
1786         BT_DBG("-");
1787         return BLUETOOTH_ERROR_NONE;
1788 }
1789
1790 int _bt_set_alias(bluetooth_device_address_t *device_address, const char *alias)
1791 {
1792         int ret;
1793         char address[BT_ADDRESS_STRING_SIZE];
1794
1795         BT_DBG("+");
1796         BT_CHECK_PARAMETER(alias, return);
1797
1798         ret = device_set_alias((bt_address_t *)device_address, (char *)alias);
1799         if (ret != OAL_STATUS_SUCCESS) {
1800                 BT_ERR("device_set_alias: %d", ret);
1801                 return BLUETOOTH_ERROR_INTERNAL;
1802         }
1803
1804         /* Update local cache */
1805         _bt_convert_addr_type_to_string(address, device_address->addr);
1806         _bt_update_remote_dev_property(address, DEV_PROP_ALIAS, (void *)alias);
1807
1808         BT_DBG("-");
1809         return BLUETOOTH_ERROR_NONE;
1810 }
1811
1812 int _bt_bond_device(bluetooth_device_address_t *device_address,
1813                 unsigned short conn_type, GArray **out_param1)
1814 {
1815         int result = BLUETOOTH_ERROR_NONE;
1816         char address[BT_ADDRESS_STRING_SIZE] = { 0 };
1817         bluetooth_device_info_t dev_info;
1818         const char *stack_name = NULL;
1819         BT_DBG("+");
1820
1821         retv_if(device_address == NULL, BLUETOOTH_ERROR_INVALID_PARAM);
1822
1823         /* If bonding or discovery already going on */
1824         if (trigger_bond_info || _bt_is_discovering()) {
1825                 BT_ERR("Device is buzy, bonding can not proceed now..");
1826                 result = BLUETOOTH_ERROR_DEVICE_BUSY;
1827                 goto fail;
1828         }
1829
1830         /*TODO: If unbonding with same device going on */
1831         _bt_convert_addr_type_to_string(address, device_address->addr);
1832
1833         trigger_bond_info = g_malloc0(sizeof(bt_bond_data_t));
1834         trigger_bond_info->addr = g_strdup(address);
1835         trigger_bond_info->conn_type = conn_type;
1836         trigger_bond_info->is_device_creating = TRUE;
1837         trigger_bond_info->dev_addr = g_memdup(device_address, sizeof(bluetooth_device_address_t));
1838         trigger_bond_info->dev_info = NULL;
1839
1840         /* Ready to initiate bonding */
1841
1842         stack_name = oal_get_stack_name();
1843         if (stack_name && !g_strcmp0(stack_name, "bluez")) {
1844                 BT_DBG("[bluez] Create bond by type %d", conn_type);
1845                 bt_device_bond_state = BT_DEVICE_BOND_STATE_REMOVED_BONDING;
1846         } else {
1847                 /* In Tizen, we will first remove bond and then attempt to create bond to keep
1848                    consistency with bluedroid. Even if remove bond fails due to device not already
1849                    bonded, then straight away create bond is triggered. This is because, remove bond
1850                    is handled differently in bluedroid and bluez. In Bluez, if device is
1851                    already removed, remove bond call fails.
1852                    However in bluedroid, remove bond on already removed device returns success. So we will
1853                    handle the cases transparently */
1854                 bt_device_bond_state = BT_DEVICE_BOND_STATE_REMOVE_BONDING;
1855         }
1856
1857         bond_retry_count = 0;
1858         result = __bt_device_handle_bond_state();
1859
1860         if (result != BLUETOOTH_ERROR_NONE)
1861                 goto fail;
1862
1863         BT_DBG("-");
1864         return result;
1865
1866 fail:
1867         memset(&dev_info, 0x00, sizeof(bluetooth_device_info_t));
1868         memcpy(dev_info.device_address.addr, device_address->addr,
1869                         BLUETOOTH_ADDRESS_LENGTH);
1870
1871         g_array_append_vals(*out_param1, &dev_info,
1872                         sizeof(bluetooth_device_info_t));
1873         __bt_free_bond_info(BT_DEVICE_BOND_INFO);
1874
1875         BT_DBG("-");
1876         return result;
1877 }
1878
1879 int _bt_unbond_device(bluetooth_device_address_t *device_address,
1880                 GArray **out_param1)
1881 {
1882         int result = OAL_STATUS_SUCCESS;
1883         char address[BT_ADDRESS_STRING_SIZE] = { 0 };
1884         bluetooth_device_info_t dev_info;
1885         BT_INFO("+");
1886
1887         retv_if(device_address == NULL, BLUETOOTH_ERROR_INVALID_PARAM);
1888
1889         _bt_convert_addr_type_to_string(address, device_address->addr);
1890
1891         trigger_unbond_info = g_malloc0(sizeof(bt_bond_data_t));
1892         trigger_unbond_info->addr = g_malloc0(BT_ADDRESS_STRING_SIZE);
1893         trigger_unbond_info->addr = g_strdup(address);
1894         trigger_unbond_info->dev_addr = g_memdup(device_address, sizeof(bluetooth_device_address_t));
1895
1896         /* Check if Bonding is already going on, we should not abruptly remove bonding*/
1897         if (trigger_bond_info && strncmp(trigger_bond_info->addr, trigger_unbond_info->addr, BT_ADDRESS_STRING_SIZE) == 0) {
1898                 BT_ERR("Bonding with same device already ongoing");
1899                 result = BLUETOOTH_ERROR_PERMISSION_DEINED;
1900                 goto fail;
1901         }
1902
1903         result = device_destroy_bond((bt_address_t *)device_address);
1904         if (result != OAL_STATUS_SUCCESS)
1905                 goto fail;
1906
1907         return result;
1908
1909 fail:
1910         memset(&dev_info, 0x00, sizeof(bluetooth_device_info_t));
1911         _bt_convert_addr_string_to_type(dev_info.device_address.addr,
1912                         trigger_unbond_info->addr);
1913
1914         g_array_append_vals(*out_param1, &dev_info,
1915                         sizeof(bluetooth_device_info_t));
1916         __bt_free_bond_info(BT_DEVICE_UNBOND_INFO);
1917
1918         return result;
1919 }
1920
1921 int _bt_cancel_bonding(void)
1922 {
1923         int result = OAL_STATUS_SUCCESS;
1924         BT_INFO("+");
1925
1926         retv_if(trigger_bond_info == NULL, BLUETOOTH_ERROR_NOT_IN_OPERATION);
1927
1928         result = device_stop_bond((bt_address_t *)trigger_bond_info->dev_addr);
1929
1930         if (result == OAL_STATUS_SUCCESS)
1931                 trigger_bond_info->is_cancelled_by_user = TRUE;
1932
1933         return result;
1934 }
1935
1936 int _bt_passkey_reply(const char *passkey, gboolean cnfm_reply)
1937 {
1938         bluetooth_device_address_t device_address;
1939         int ret = OAL_STATUS_SUCCESS;
1940         BT_INFO("reply: %d", cnfm_reply);
1941
1942         retv_if(trigger_pairing_info == NULL, BLUETOOTH_ERROR_INTERNAL);
1943         retv_if(trigger_pairing_info->addr == NULL, BLUETOOTH_ERROR_INTERNAL);
1944
1945         _bt_convert_addr_string_to_type(device_address.addr, trigger_pairing_info->addr);
1946
1947         if (trigger_pairing_info->is_ssp) {
1948                 if (cnfm_reply)
1949                         ret = device_accept_passkey_entry((bt_address_t *)&device_address, atoi(passkey));
1950                 else
1951                         ret = device_reject_passkey_entry((bt_address_t *)&device_address);
1952                 trigger_pairing_info->is_ssp = FALSE;
1953         } else {
1954                 if (cnfm_reply)
1955                         ret = device_accept_pin_request((bt_address_t *)&device_address, passkey);
1956                 else
1957                         ret = device_reject_pin_request((bt_address_t *)&device_address);
1958         }
1959
1960         __bt_free_pairing_info(&trigger_pairing_info);
1961
1962         if (ret != OAL_STATUS_SUCCESS) {
1963                 BT_ERR("_bt_device_handle_passkey_reply: err [%d]", ret);
1964                 return BLUETOOTH_ERROR_INTERNAL;
1965         }
1966
1967         BT_INFO("-");
1968         return BLUETOOTH_ERROR_NONE;
1969 }
1970
1971 int _bt_passkey_confirmation_reply(gboolean cnfm_reply)
1972 {
1973         BT_INFO("BT_PASSKEY_CONFIRMATION_REPLY");
1974         bluetooth_device_address_t device_address;
1975         int ret = OAL_STATUS_SUCCESS;
1976         BT_INFO("reply: %d", cnfm_reply);
1977
1978         retv_if(trigger_pairing_info == NULL, BLUETOOTH_ERROR_INTERNAL);
1979         retv_if(trigger_pairing_info->addr == NULL, BLUETOOTH_ERROR_INTERNAL);
1980
1981         _bt_convert_addr_string_to_type(device_address.addr, trigger_pairing_info->addr);
1982
1983         ret = device_reply_passkey_confirmation((bt_address_t *)&device_address, cnfm_reply);
1984
1985         __bt_free_pairing_info(&trigger_pairing_info);
1986         if (ret != OAL_STATUS_SUCCESS) {
1987                 BT_ERR("_bt_device_handle_passkey_confirmation_reply: err [%d]", ret);
1988                 return BLUETOOTH_ERROR_INTERNAL;
1989         }
1990
1991         BT_INFO("-");
1992         return BLUETOOTH_ERROR_NONE;
1993 }
1994
1995 gboolean _bt_device_is_pairing(void)
1996 {
1997         return (trigger_pairing_info) ? TRUE : FALSE;
1998 }
1999
2000 gboolean _bt_device_is_bonding(void)
2001 {
2002         return (trigger_bond_info) ? TRUE : FALSE;
2003 }
2004
2005 gboolean _bt_is_bonding_device_address(const char *address)
2006 {
2007         if (trigger_bond_info == NULL || trigger_bond_info->addr == NULL)
2008                 return FALSE;
2009
2010         if (g_strcmp0(trigger_bond_info->addr, address) == 0) {
2011                 BT_DBG("[%s]  is bonding device", address);
2012                 return TRUE;
2013         }
2014
2015         BT_DBG("[%s]  is NOT bonding device", address);
2016         return FALSE;
2017 }
2018
2019 void _bt_set_autopair_status_in_bonding_info(gboolean is_autopair)
2020 {
2021         ret_if(trigger_bond_info == NULL);
2022         trigger_bond_info->is_autopair = is_autopair;
2023 }
2024
2025 int _bt_search_device(bluetooth_device_address_t *device_address)
2026 {
2027         int result = OAL_STATUS_SUCCESS;
2028         BT_DBG("+");
2029
2030         BT_CHECK_PARAMETER(device_address, return);
2031
2032         if (trigger_bond_info) {
2033                 BT_ERR("Bonding in progress");
2034                 return BLUETOOTH_ERROR_DEVICE_BUSY;
2035         }
2036
2037         if (service_search_info) {
2038                 BT_ERR("Service searching in progress");
2039                 return BLUETOOTH_ERROR_DEVICE_BUSY;
2040         }
2041
2042         /* allocate user data so that it can be retrieved in callback */
2043         service_search_info = g_malloc0(sizeof(bt_service_search_info_data_t));
2044         service_search_info->addr = g_malloc0(BT_ADDRESS_STRING_SIZE);
2045         service_search_info->dev_addr = g_memdup(device_address, sizeof(bluetooth_device_address_t));
2046
2047         _bt_convert_addr_type_to_string(service_search_info->addr,
2048                         device_address->addr);
2049
2050         result = device_query_services((bt_address_t *)device_address);
2051
2052         if (result != OAL_STATUS_SUCCESS) {
2053                 BT_ERR("Device Service Search Failed..: %d", result);
2054                 __bt_free_service_search_info(&service_search_info);
2055                 return BLUETOOTH_ERROR_INTERNAL;
2056         }
2057         return BLUETOOTH_ERROR_NONE;
2058 }
2059
2060 int _bt_cancel_search_device(void)
2061 {
2062         int ret = OAL_STATUS_SUCCESS;
2063         retv_if(service_search_info == NULL, BLUETOOTH_ERROR_NOT_IN_OPERATION);
2064
2065         ret = device_stop_query_sevices((bt_address_t *)service_search_info->dev_addr);
2066
2067         if (ret != OAL_STATUS_SUCCESS) {
2068                 BT_ERR("SDP Cancel request failed [%d]", ret);
2069                 return BLUETOOTH_ERROR_INTERNAL;
2070         }
2071
2072         __bt_device_handle_pending_requests(BLUETOOTH_ERROR_CANCEL_BY_USER, BT_SEARCH_SERVICE,
2073                         service_search_info->addr, BT_ADDRESS_STRING_SIZE);
2074
2075         __bt_free_service_search_info(&service_search_info);
2076
2077         return BLUETOOTH_ERROR_NONE;
2078         BT_DBG("-");
2079 }
2080
2081 int _bt_set_authorization(bluetooth_device_address_t *device_address,
2082                 gboolean authorize)
2083 {
2084         int ret = OAL_STATUS_SUCCESS;
2085         BT_DBG("+");
2086
2087         BT_CHECK_PARAMETER(device_address, return);
2088         BT_INFO("Device to be Trusted? [%d]", authorize);
2089
2090         ret = device_set_authorized((bt_address_t*)device_address, authorize);
2091         if (ret != OAL_STATUS_SUCCESS) {
2092                 BT_ERR("device_set_authorized: %d", ret);
2093                 return BLUETOOTH_ERROR_INTERNAL;
2094         }
2095
2096         return BLUETOOTH_ERROR_NONE;
2097 }
2098
2099 gboolean _bt_is_device_connected(bluetooth_device_address_t *device_address, int svc_type)
2100 {
2101         gboolean is_connected;
2102         oal_service_t svc_id;
2103
2104         retv_if(device_address == NULL, BLUETOOTH_ERROR_INVALID_PARAM);
2105
2106         /*
2107          * TODO: While adding support for new profiles, need to add more
2108          * <svc_type, svc_id> mapping here.
2109          */
2110         switch (svc_type) {
2111         case BT_PROFILE_CONN_HID:
2112                 svc_id = HID_SERVICE_ID;
2113                 break;
2114         case BT_PROFILE_CONN_A2DP:
2115                 svc_id = A2DP_SERVICE_ID; /* Remote is A2DP Sink */
2116                 break;
2117         case BT_PROFILE_CONN_A2DP_SINK:
2118                 svc_id = A2DP_SRC_SERVICE_ID; /* Remote is A2DP Source*/
2119                 break;
2120         case BT_PROFILE_CONN_HSP:
2121                 svc_id = HFP_HS_SERVICE_ID; /* Remote is HFP HF Unit */
2122                 break;
2123 #ifdef TIZEN_GATT_CLIENT
2124         case BT_PROFILE_CONN_GATT:
2125                 return _bt_is_remote_gatt_device_connected(device_address); /* Remote is GATT client or Server */
2126 #endif
2127         default:
2128                 BT_DBG("Unknown svc_type: %d", svc_type);
2129                 return FALSE;
2130         }
2131
2132         is_connected = device_get_svc_conn_state((bt_address_t*)device_address, svc_id);
2133
2134         BT_DBG("svc_type: %d, is_connected: %s",
2135                         svc_type, is_connected ? "TRUE" : "FALSE");
2136
2137         return is_connected;
2138 }
2139
2140 int _bt_rfcomm_reply_conn_authorization(char *address, gboolean reply)
2141 {
2142         bt_address_t bd_addr;
2143         int res;
2144
2145         BT_DBG("+");
2146
2147         retv_if(NULL == address, BLUETOOTH_ERROR_INVALID_PARAM);
2148         _bt_convert_addr_string_to_type(bd_addr.addr, address);
2149         res = device_reply_auth_request(&bd_addr, 0, reply, FALSE);
2150         if (res != OAL_STATUS_SUCCESS) {
2151                 BT_ERR("authorize_response: %d", res);
2152                 return BLUETOOTH_ERROR_INTERNAL;
2153         }
2154
2155         BT_DBG("-");
2156         return BLUETOOTH_ERROR_NONE;
2157 }
2158
2159 int _bt_enable_rssi(bluetooth_device_address_t *addr, int link_type,
2160                 int low_threshold, int in_range_threshold, int high_threshold)
2161 {
2162         int result;
2163         bt_address_t bd_addr;
2164
2165         BT_DBG("+");
2166
2167         retv_if(!addr, BLUETOOTH_ERROR_INVALID_PARAM);
2168
2169         memcpy(bd_addr.addr, addr, BLUETOOTH_ADDRESS_LENGTH);
2170         result = device_enable_rssi_monitoring(&bd_addr, link_type,
2171                         low_threshold, in_range_threshold, high_threshold);
2172         if (result != OAL_STATUS_SUCCESS) {
2173                 BT_ERR("device_get_connected_link_rssi_strength error: [%d]", result);
2174                 return BLUETOOTH_ERROR_INTERNAL;
2175         }
2176
2177         BT_DBG("-");
2178         return BLUETOOTH_ERROR_NONE;
2179 }
2180
2181 int _bt_get_rssi_strength(bluetooth_device_address_t *addr, int link_type)
2182 {
2183         int result;
2184         bt_address_t bd_addr;
2185
2186         BT_DBG("+");
2187
2188         retv_if(!addr, BLUETOOTH_ERROR_INVALID_PARAM);
2189
2190         memcpy(bd_addr.addr, addr, BLUETOOTH_ADDRESS_LENGTH);
2191         result = device_get_connected_link_rssi_strength(&bd_addr, link_type);
2192         if (result != OAL_STATUS_SUCCESS) {
2193                 BT_ERR("device_get_connected_link_rssi_strength error: [%d]", result);
2194                 return BLUETOOTH_ERROR_INTERNAL;
2195         }
2196
2197         BT_DBG("-");
2198         return BLUETOOTH_ERROR_NONE;
2199 }
2200
2201 int _bt_set_passkey_notification(const char *sender, gboolean enable)
2202 {
2203         int result;
2204
2205         BT_INFO("Set passkey notification(sender:%s, %s)",
2206                         sender, enable ? "Enable" : "Disable");
2207
2208         result = device_enable_gap_auth_notifications(OAL_PASSKEY_DISPLAY, enable);
2209         if (OAL_STATUS_SUCCESS != result) {
2210                 BT_ERR("device_enable_gap_auth_notifications error: [%d]", result);
2211                 return BLUETOOTH_ERROR_INTERNAL;
2212         }
2213
2214         g_free(passkey_watcher);
2215         if (enable == TRUE)
2216                 passkey_watcher = g_strdup(sender);
2217         else
2218                 passkey_watcher = NULL;
2219
2220         return BLUETOOTH_ERROR_NONE;
2221 }
2222
2223 static int __bt_get_device_pin_code(const char *address, char *pin_code)
2224 {
2225         GSList *l = NULL;
2226
2227         BT_CHECK_PARAMETER(address, return);
2228         BT_CHECK_PARAMETER(pin_code, return);
2229
2230         for (l = pin_info_list; l != NULL; l = l->next) {
2231                 bt_pin_code_info_t *pin_info = l->data;
2232
2233                 if (!pin_info || !pin_info->address)
2234                         continue;
2235
2236                 if (g_strcmp0(pin_info->address, address) == 0) {
2237                         g_strlcpy(pin_code, pin_info->pin_code,
2238                                         BLUETOOTH_PIN_CODE_MAX_LENGTH + 1);
2239                         return BLUETOOTH_ERROR_NONE;
2240                 }
2241         }
2242
2243         return BLUETOOTH_ERROR_NOT_FOUND;
2244 }
2245
2246 int _bt_set_pin_code(bluetooth_device_address_t *device_address,
2247                 bluetooth_device_pin_code_t *pin_code)
2248 {
2249         char address[BT_ADDRESS_STRING_SIZE] = { 0 };
2250         bt_pin_code_info_t *pin_info = NULL;
2251         GSList *l = NULL;
2252
2253         BT_CHECK_PARAMETER(device_address, return);
2254         BT_CHECK_PARAMETER(pin_code, return);
2255         retv_if(g_slist_length(pin_info_list) >= BT_DEVICE_PIN_CODE_SLOT_MAX,
2256                         BLUETOOTH_ERROR_NO_RESOURCES);
2257
2258         _bt_convert_addr_type_to_string(address, device_address->addr);
2259
2260         for (l = pin_info_list; l != NULL; l = l->next) {
2261                 pin_info = l->data;
2262
2263                 if (!pin_info || !pin_info->address)
2264                         continue;
2265
2266                 if (g_strcmp0(pin_info->address, address) == 0) {
2267                         g_free(pin_info->pin_code);
2268                         pin_info->pin_code = g_strdup(pin_code->pin_code);
2269                         return BLUETOOTH_ERROR_NONE;
2270                 }
2271         }
2272
2273         pin_info = g_malloc0(sizeof(bt_pin_code_info_t));
2274         pin_info->address = g_strdup(address);
2275         pin_info->pin_code = g_strdup(pin_code->pin_code);
2276         pin_info_list = g_slist_append(pin_info_list, pin_info);
2277
2278         return BLUETOOTH_ERROR_NONE;
2279 }
2280
2281 int _bt_unset_pin_code(bluetooth_device_address_t *device_address)
2282 {
2283         char address[BT_ADDRESS_STRING_SIZE] = { 0 };
2284         bt_pin_code_info_t *pin_info = NULL;
2285         GSList *l = NULL;
2286
2287         BT_DBG("+");
2288
2289         BT_CHECK_PARAMETER(device_address, return);
2290
2291         _bt_convert_addr_type_to_string(address, device_address->addr);
2292
2293         for (l = pin_info_list; l != NULL; l = l->next) {
2294                 pin_info = l->data;
2295
2296                 if (!pin_info || !pin_info->address)
2297                         continue;
2298
2299                 if (g_strcmp0(pin_info->address, address) == 0) {
2300                         pin_info_list = g_slist_remove(pin_info_list, pin_info);
2301                         g_free(pin_info->address);
2302                         g_free(pin_info->pin_code);
2303                         g_free(pin_info);
2304                         break;
2305                 }
2306         }
2307
2308         BT_DBG("-");
2309         return BLUETOOTH_ERROR_NONE;
2310 }
2311
2312 #ifdef TIZEN_GATT_CLIENT
2313 static bt_connected_le_dev_t *__bt_get_le_connected_dev_info(const char *address)
2314 {
2315         GSList *l = NULL;
2316         bt_connected_le_dev_t *dev;
2317
2318         if (!address)
2319                 return NULL;
2320
2321         for (l = le_connected_dev_list; l; l = g_slist_next(l)) {
2322                 dev = l->data;
2323
2324                 if (g_strcmp0(dev->address, address) == 0)
2325                         return dev;
2326         }
2327         return NULL;
2328 }
2329
2330 static void __bt_le_conn_param_free(void *data)
2331 {
2332         bt_le_conn_param_t *param = (bt_le_conn_param_t *)data;
2333
2334         BT_DBG("%s", param->sender);
2335         g_free(param->sender);
2336         g_free(param);
2337 }
2338
2339 static void _bt_add_le_connected_dev_info(const char *address)
2340 {
2341         bt_connected_le_dev_t *dev = NULL;
2342
2343         if (!address)
2344                 return;
2345
2346         dev = g_malloc0(sizeof(bt_connected_le_dev_t));
2347         dev->address = g_strdup(address);
2348
2349         le_connected_dev_list = g_slist_append(le_connected_dev_list, dev);
2350
2351         return;
2352 }
2353
2354 static void _bt_remove_le_connected_dev_info(const char *address)
2355 {
2356         bt_connected_le_dev_t *dev = NULL;
2357
2358         if (!address)
2359                 return;
2360
2361         dev = __bt_get_le_connected_dev_info(address);
2362         if (!dev)
2363                 return;
2364
2365         g_slist_free_full(dev->senders, __bt_le_conn_param_free);
2366         le_connected_dev_list = g_slist_remove(le_connected_dev_list, dev);
2367         g_free(dev->address);
2368         g_free(dev);
2369
2370         return;
2371 }
2372
2373
2374 static void _bt_handle_le_connected_dev_info(const char *address, gboolean connected)
2375 {
2376         BT_DBG("+");
2377
2378         if (connected)
2379                 _bt_add_le_connected_dev_info(address);
2380         else
2381                 _bt_remove_le_connected_dev_info(address);
2382 }
2383
2384 static bt_le_conn_param_t *__bt_get_le_conn_param_info(bt_connected_le_dev_t *dev, const char *sender)
2385 {
2386         GSList *l = NULL;
2387         bt_le_conn_param_t *param = NULL;
2388
2389         if (!dev || !sender)
2390                 return NULL;
2391
2392         for (l = dev->senders; l; l = g_slist_next(l)) {
2393                 param = l->data;
2394                 if (g_strcmp0(param->sender, sender) == 0)
2395                         return param;
2396         }
2397
2398         return NULL;
2399 }
2400
2401 static gint __bt_compare_le_conn_param_key(gpointer *a, gpointer *b)
2402 {
2403         bt_le_conn_param_t *parama = (bt_le_conn_param_t *)a;
2404         bt_le_conn_param_t *paramb = (bt_le_conn_param_t *)b;
2405
2406         return parama->key > paramb->key;
2407 }
2408
2409
2410 int _bt_add_le_conn_param_info(const char *address, const char *sender,
2411                 float interval_min, float interval_max, guint16 latency, guint16 time_out)
2412 {
2413         bt_connected_le_dev_t *dev = NULL;
2414         bt_le_conn_param_t *param = NULL;
2415         bt_le_conn_param_t *data = NULL;
2416
2417         BT_DBG("+");
2418
2419         if (!address || !sender)
2420                 return BLUETOOTH_ERROR_INVALID_PARAM;
2421
2422         dev = __bt_get_le_connected_dev_info(address);
2423         if (!dev)
2424                 return BLUETOOTH_ERROR_INTERNAL;
2425
2426         param = __bt_get_le_conn_param_info(dev, sender);
2427
2428         data = g_malloc0(sizeof(bt_le_conn_param_t));
2429         data->sender = g_strdup(sender);
2430         data->interval_min = interval_min;
2431         data->interval_max = interval_max;
2432         data->latency = latency;
2433         data->time_out = time_out;
2434         data->key = interval_min + (interval_max - interval_min)/2;
2435
2436         if (param == NULL) {
2437                 BT_DBG("Add param %s %s %f %f", address, sender, interval_min, interval_max);
2438                 dev->senders = g_slist_append(dev->senders, data);
2439         } else {
2440                 BT_DBG("Update param %s %s %f %f", address, sender, interval_min, interval_max);
2441                 dev->senders = g_slist_remove(dev->senders, param);
2442                 g_free(param->sender);
2443                 g_free(param);
2444                 dev->senders = g_slist_append(dev->senders, data);
2445         }
2446
2447         /* Sorting. First element have the minimum interval */
2448         dev->senders = g_slist_sort(dev->senders,
2449                         (GCompareFunc)__bt_compare_le_conn_param_key);
2450
2451         return BLUETOOTH_ERROR_NONE;
2452 }
2453
2454
2455 static int __bt_le_set_conn_parameter(const char *address,
2456                 float interval_min, float interval_max,
2457                 guint16 latency, guint16 time_out)
2458 {
2459         bt_address_t dev_addr = { {0} };
2460         guint32 min, max, to;
2461
2462         BT_INFO("Min interval: %f, Max interval: %f, Latency: %u, Supervision timeout: %u",
2463                         interval_min, interval_max, latency, time_out);
2464
2465         min = interval_min / BT_LE_CONN_INTERVAL_SPLIT;
2466         max = interval_max / BT_LE_CONN_INTERVAL_SPLIT;
2467         to = time_out / BT_LE_CONN_TO_SPLIT;
2468
2469         BT_INFO("updating: Min interval: %d, Max interval: %d, Latency: %d, Supervision timeout: %d",
2470                         min, max, latency, to);
2471
2472         _bt_convert_addr_string_to_type(dev_addr.addr, address);
2473
2474         return gattc_conn_param_update(&dev_addr, min, max, latency, to);
2475 }
2476
2477 int _bt_remove_le_conn_param_info(const char *address, const char *sender)
2478 {
2479         bt_connected_le_dev_t *dev = NULL;
2480         bt_le_conn_param_t *param = NULL;
2481
2482         if (!address || !sender)
2483                 return BLUETOOTH_ERROR_INVALID_PARAM;
2484
2485         dev = __bt_get_le_connected_dev_info(address);
2486         if (!dev)
2487                 return BLUETOOTH_ERROR_INTERNAL;
2488
2489         param = __bt_get_le_conn_param_info(dev, sender);
2490         if (param) {
2491                 BT_DBG("Remove param %s %s ", address, sender);
2492                 dev->senders = g_slist_remove(dev->senders, param);
2493                 g_free(param->sender);
2494                 g_free(param);
2495         }
2496
2497         return BLUETOOTH_ERROR_NONE;
2498 }
2499
2500 int _bt_get_le_connection_parameter(bluetooth_le_connection_mode_t mode,
2501                 bluetooth_le_connection_param_t *param)
2502 {
2503         if (param == NULL)
2504                 return BLUETOOTH_ERROR_INVALID_PARAM;
2505
2506         memset(param, 0x00, sizeof(bluetooth_le_connection_param_t));
2507
2508         switch (mode) {
2509         case BLUETOOTH_LE_CONNECTION_MODE_BALANCED:
2510                 param->interval_min = BT_LE_CONN_PARAM_BALANCED_MIN_INTERVAL;
2511                 param->interval_max = BT_LE_CONN_PARAM_BALANCED_MAX_INTERVAL;
2512                 param->latency = BT_LE_CONN_PARAM_BALANCED_SLAVE_LATENCY;
2513                 param->timeout = BT_LE_CONN_PARAM_DEFAULT_SUPERVISION_TIMEOUT;
2514                 break;
2515
2516         case BLUETOOTH_LE_CONNECTION_MODE_LOW_LATENCY:
2517                 param->interval_min = BT_LE_CONN_PARAM_LOW_LATENCY_MIN_INTERVAL;
2518                 param->interval_max = BT_LE_CONN_PARAM_LOW_LATENCY_MAX_INTERVAL;
2519                 param->latency = BT_LE_CONN_PARAM_LOW_LATENCY_SLAVE_LATENCY;
2520                 param->timeout = BT_LE_CONN_PARAM_DEFAULT_SUPERVISION_TIMEOUT;
2521                 break;
2522
2523         case BLUETOOTH_LE_CONNECTION_MODE_LOW_POWER:
2524                 param->interval_min = BT_LE_CONN_PARAM_LOW_POWER_MIN_INTERVAL;
2525                 param->interval_max = BT_LE_CONN_PARAM_LOW_POWER_MAX_INTERVAL;
2526                 param->latency = BT_LE_CONN_PARAM_LOW_POWER_SLAVE_LATENCY;
2527                 param->timeout = BT_LE_CONN_PARAM_DEFAULT_SUPERVISION_TIMEOUT;
2528                 break;
2529
2530         default:
2531                 BT_ERR("Unhandled mode : %d", mode);
2532                 break;
2533         }
2534
2535         return BLUETOOTH_ERROR_NONE;
2536 }
2537
2538 int _bt_le_connection_update(const char *sender,
2539                 unsigned char *device_address,
2540                 float interval_min, float interval_max,
2541                 guint16 latency, guint16 time_out)
2542 {
2543         char address[BT_ADDRESS_STRING_SIZE] = { 0 };
2544         guint32 min_supervision_to;
2545         bt_connected_le_dev_t *dev = NULL;
2546         bt_le_conn_param_t *param = NULL;
2547         int ret = BLUETOOTH_ERROR_NONE;
2548
2549         BT_CHECK_PARAMETER(device_address, return);
2550
2551         BT_INFO("Sender %s, Min interval: %f, Max interval: %f, Latency: %u, Supervision timeout: %u",
2552                         sender, interval_min, interval_max, latency, time_out);
2553
2554         if (interval_min > interval_max ||
2555                         interval_min < BT_LE_CONN_INTERVAL_MIN ||
2556                         interval_max > BT_LE_CONN_INTERVAL_MAX) {
2557                 ret = BLUETOOTH_ERROR_INVALID_PARAM;
2558                 goto fail;
2559         }
2560
2561         if (time_out < BT_LE_CONN_SUPER_TO_MIN ||
2562                         time_out > BT_LE_CONN_SUPER_TO_MAX) {
2563                 ret = BLUETOOTH_ERROR_INVALID_PARAM;
2564                 goto fail;
2565         }
2566
2567         if (latency > BT_LE_CONN_SLAVE_LATENCY_MAX) {
2568                 ret = BLUETOOTH_ERROR_INVALID_PARAM;
2569                 goto fail;
2570         }
2571
2572         /*
2573          * The Supervision_Timeout in milliseconds shall be larger than
2574          * (1 + Conn_Latency) * Conn_Interval_Max * 2,
2575          * where Conn_Interval_Max is given in milliseconds.
2576          */
2577
2578         min_supervision_to = (1 + latency) * interval_max * 2;
2579         if (time_out <= min_supervision_to) {
2580                 ret = BLUETOOTH_ERROR_INVALID_PARAM;
2581                 goto fail;
2582         }
2583
2584         _bt_convert_addr_type_to_string(address, device_address);
2585         BT_DBG("Remote device address: %s", address);
2586
2587         _bt_add_le_conn_param_info(address, sender, interval_min, interval_max, 0, 2000);
2588
2589         dev = __bt_get_le_connected_dev_info(address);
2590         if (dev == NULL) {
2591                 BT_DBG("device not found in the list");
2592                 ret = BLUETOOTH_ERROR_NOT_CONNECTED;
2593                 goto fail;
2594         }
2595
2596         if (g_slist_length(dev->senders) == 1)
2597                 goto update;
2598         else {
2599                 param = dev->senders->data;
2600
2601                 BT_DBG("dev %f, param %f, input %f", dev->interval_min, param->interval_min, interval_min);
2602
2603                 if (dev->interval_min == param->interval_min && dev->interval_max == param->interval_max) {
2604                         BT_DBG("Skip due to same interval");
2605                         return ret;
2606                 }
2607
2608                 interval_min = param->interval_min;
2609                 interval_max = param->interval_max;
2610         }
2611
2612 update:
2613         ret = __bt_le_set_conn_parameter(address, interval_min, interval_max, latency, time_out);
2614
2615         if (ret != OAL_STATUS_SUCCESS) {
2616                 _bt_remove_le_conn_param_info(address, sender);
2617                 BT_DBG("fail to update the LE connection parameter");
2618                 ret = BLUETOOTH_ERROR_INTERNAL;
2619                 goto fail;
2620         }
2621
2622         BT_DBG("updated LE connection parameter");
2623         dev->interval_min = interval_min;
2624         dev->interval_max = interval_max;
2625
2626         return BLUETOOTH_ERROR_NONE;
2627 fail:
2628         return ret;
2629 }
2630
2631 int _bt_disconnect_device(bluetooth_device_address_t *device_address)
2632 {
2633         int result = OAL_STATUS_SUCCESS;
2634
2635         BT_DBG("+");
2636
2637         retv_if(!device_address, BLUETOOTH_ERROR_INVALID_PARAM);
2638
2639         result = device_disconnect((bt_address_t *)device_address);
2640         if (result != OAL_STATUS_SUCCESS) {
2641                 BT_DBG("Failed to disconnect device");
2642                 return BLUETOOTH_ERROR_INTERNAL;
2643         }
2644
2645         BT_DBG("-");
2646         return BLUETOOTH_ERROR_NONE;
2647 }
2648
2649 static gboolean __bt_ignore_auto_pairing_request(const char *address)
2650 {
2651         gchar *buffer;
2652         char **lines;
2653         int i;
2654         char lap_address[BT_LOWER_ADDRESS_LENGTH + 1] = {0,};
2655         char *temp_buffer;
2656         FILE *fp;
2657         long size;
2658         size_t result;
2659
2660         BT_DBG("+\n");
2661
2662         if (address == NULL)
2663                 return FALSE;
2664
2665         /* Get the LAP(Lower Address part) */
2666         /* User BT_LOWER_ADDRESS_LENGTH+1 for lap_address to accomodate
2667            a "," */
2668         snprintf(lap_address, sizeof(lap_address), ",%s", address);
2669
2670         fp = fopen(BT_AGENT_AUTO_PAIR_BLACKLIST_FILE, "r");
2671
2672         if (fp == NULL) {
2673                 BT_ERR("fopen failed \n");
2674                 return FALSE;
2675         }
2676
2677         fseek(fp, 0, SEEK_END);
2678         size = ftell(fp);
2679         rewind(fp);
2680
2681         if (size < 0) {
2682                 BT_ERR("Get file size failed \n");
2683                 fclose(fp);
2684                 return FALSE;
2685         }
2686
2687         buffer = g_malloc0(sizeof(char) * size);
2688         result = fread((char *)buffer, 1, size, fp);
2689         fclose(fp);
2690         if (result != size) {
2691                 BT_ERR("Read Error\n");
2692                 g_free(buffer);
2693                 return FALSE;
2694         }
2695
2696         BT_DBG("Buffer = %s\n", buffer);
2697
2698         lines = g_strsplit_set(buffer, BT_AGENT_NEW_LINE, 0);
2699         g_free(buffer);
2700
2701         if (lines == NULL)
2702                 return FALSE;
2703
2704         /* Write the data and insert new device data */
2705         for (i = 0; lines[i] != NULL; i++) {
2706                 if (g_str_has_prefix(lines[i], "AddressBlacklist")) {
2707                         temp_buffer = g_strconcat(lines[i], lap_address, NULL);
2708                         g_free(lines[i]);
2709                         lines[i] = temp_buffer;
2710                 }
2711         }
2712         buffer = g_strjoinv(BT_AGENT_NEW_LINE, lines);
2713         g_strfreev(lines);
2714         /* Fix : NULL_RETURNS */
2715         retv_if(buffer == NULL, FALSE);
2716
2717         fp = fopen(BT_AGENT_AUTO_PAIR_BLACKLIST_FILE, "w");
2718
2719         if (fp == NULL) {
2720                 BT_ERR("fopen failed \n");
2721                 g_free(buffer);
2722                 return FALSE;
2723         }
2724
2725         BT_DBG("Buffer = %s\n", buffer);
2726         fwrite(buffer, 1, strlen(buffer), fp);
2727         fclose(fp);
2728
2729         g_free(buffer);
2730
2731         BT_DBG("-\n");
2732
2733         return FALSE;
2734 }
2735 #endif