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
 912                 if (trigger_bond_info) {
 913                         __bt_ignore_auto_pairing_request(trigger_bond_info->addr);
 914                         BT_ERR("Create Bond procedure could not suceed, check if cancelled by User");
 915                         if (trigger_bond_info->is_cancelled_by_user) {
 916                                 BT_ERR("Bonding is cancelled by user");
 917                                 result = BLUETOOTH_ERROR_CANCEL_BY_USER;
 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_DBG("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_DBG("ACL Connected event Received");
1066                 __bt_device_acl_state_changed_callback((event_dev_conn_status_t *)event_data, TRUE, 0);
1067                 break;
1068         }
1069         case OAL_EVENT_DEVICE_ACL_DISCONNECTED: {
1070                 BT_DBG("ACL Disconnected event Received");
1071                 __bt_device_acl_state_changed_callback((event_dev_conn_status_t *)event_data, FALSE, 0);
1072                 break;
1073         }
1074         case OAL_EVENT_DEVICE_LE_CONNECTED: {
1075                 BT_DBG("LE Connected event Received");
1076                 __bt_device_acl_state_changed_callback((event_dev_conn_status_t *)event_data, TRUE, 1);
1077                 break;
1078         }
1079         case OAL_EVENT_DEVICE_LE_DISCONNECTED: {
1080                 BT_DBG("LE Disconnected event Received");
1081                 __bt_device_acl_state_changed_callback((event_dev_conn_status_t *)event_data, FALSE, 1);
1082                 break;
1083         }
1084         case OAL_EVENT_DEVICE_PIN_REQUEST: {
1085                 BT_INFO("PIN Request Received");
1086                 __bt_device_pin_request_callback((remote_device_t*)event_data);
1087                 break;
1088         }
1089         case OAL_EVENT_DEVICE_PASSKEY_ENTRY_REQUEST: {
1090                 BT_INFO("Passkey Entry request Received");
1091                 __bt_device_ssp_passkey_entry_callback((remote_device_t*)event_data);
1092                 break;
1093         }
1094         case OAL_EVENT_DEVICE_PASSKEY_CONFIRMATION_REQUEST:{
1095                 BT_INFO("Passkey Confirmation Request Received");
1096                 __bt_device_ssp_passkey_confirmation_callback((event_dev_passkey_t *)event_data);
1097                 break;
1098         }
1099         case OAL_EVENT_DEVICE_PASSKEY_DISPLAY: {
1100                 BT_INFO("Passkey Display Request Received");
1101                 __bt_device_ssp_passkey_display_callback((event_dev_passkey_t *)event_data);
1102                 break;
1103         }
1104         case OAL_EVENT_DEVICE_SSP_CONSENT_REQUEST: {
1105                 BT_INFO("SSP Consent Request Received");
1106                  __bt_device_ssp_consent_callback((remote_device_t*)event_data);
1107                 break;
1108         }
1109         case OAL_EVENT_DEVICE_SERVICES: {
1110                 BT_INFO("Remote Device Services Received");
1111                 __bt_device_services_callback((event_dev_services_t*)event_data);
1112                 break;
1113         }
1114         case OAL_EVENT_DEVICE_AUTHORIZE_REQUEST: {
1115                 BT_INFO("Remote Device Authorization Request");
1116                 __bt_device_authorization_request_callback((event_dev_authorize_req_t*)event_data);
1117                 break;
1118         }
1119         case OAL_EVENT_DEVICE_TRUSTED: {
1120                 BT_INFO("Remote Device Trusted");
1121                 __bt_device_trusted_callback(TRUE, (event_dev_trust_t*)event_data);
1122                 break;
1123         }
1124         case OAL_EVENT_DEVICE_UNTRUSTED: {
1125                 BT_INFO("Remote Device UnTrusted");
1126                 __bt_device_trusted_callback(FALSE, (event_dev_trust_t*)event_data);
1127                 break;
1128         }
1129         case OAL_EVENT_DEVICE_NAME: {
1130                 remote_device_t *rem_dev = event_data;
1131                 gchar address[BT_ADDRESS_STR_LEN];
1132
1133                 _bt_convert_addr_type_to_string(address, rem_dev->address.addr);
1134                 BT_INFO("Remote Device name Received");
1135                 BT_INFO("Name: %s, Address: %s", rem_dev->name, address);
1136
1137                 /* Update local cache */
1138                 _bt_update_remote_dev_property(address, DEV_PROP_NAME, (void *)rem_dev->name);
1139                 break;
1140         }
1141         case OAL_EVENT_DEVICE_TRUSTED_PROFILES_CHANGED: {
1142                 event_device_trusted_profiles_t *ev = event_data;
1143                 char address[BT_ADDRESS_STRING_SIZE];
1144
1145                 ret_if(NULL == ev);
1146
1147                 _bt_convert_addr_type_to_string(address, ev->address.addr);
1148                 _bt_send_event(BT_DEVICE_EVENT,
1149                                 BLUETOOTH_EVENT_SUPPORTED_PROFILE_TRUSTED,
1150                                 g_variant_new("(isi)", BLUETOOTH_ERROR_NONE,
1151                                         address, ev->trust_val));
1152                 break;
1153         }
1154         case OAL_EVENT_RSSI_MONITORING_ENABLED: {
1155                 event_dev_rssi_info_t *ev = event_data;
1156                 char address[BT_ADDRESS_STRING_SIZE];
1157                 GVariant *param;
1158
1159                 ret_if(NULL == ev);
1160
1161                 _bt_convert_addr_type_to_string(address, ev->address.addr);
1162                 param = g_variant_new("(isib)", BLUETOOTH_ERROR_NONE,
1163                                 address, ev->link_type, TRUE);
1164                 _bt_send_event(BT_DEVICE_EVENT, BLUETOOTH_EVENT_RSSI_ENABLED, param);
1165                 break;
1166         }
1167         case OAL_EVENT_RSSI_MONITORING_DISABLED: {
1168                 event_dev_rssi_info_t *ev = event_data;
1169                 char address[BT_ADDRESS_STRING_SIZE];
1170                 GVariant *param;
1171
1172                 ret_if(NULL == ev);
1173
1174                 _bt_convert_addr_type_to_string(address, ev->address.addr);
1175                 param = g_variant_new("(isib)", BLUETOOTH_ERROR_NONE,
1176                                 address, ev->link_type, FALSE);
1177                 _bt_send_event(BT_DEVICE_EVENT, BLUETOOTH_EVENT_RSSI_ENABLED, param);
1178                 break;
1179         }
1180         case OAL_EVENT_RSSI_ALERT_RECEIVED: {
1181                 event_dev_rssi_info_t *ev = event_data;
1182                 char address[BT_ADDRESS_STRING_SIZE];
1183                 GVariant *param;
1184
1185                 ret_if(NULL == ev);
1186
1187                 _bt_convert_addr_type_to_string(address, ev->address.addr);
1188                 param = g_variant_new("(isiii)", BLUETOOTH_ERROR_NONE,
1189                                 address, ev->link_type, ev->alert_type, ev->rssi);
1190                 _bt_send_event(BT_DEVICE_EVENT, BLUETOOTH_EVENT_RSSI_ALERT, param);
1191                 break;
1192         }
1193         case OAL_EVENT_RAW_RSSI_RECEIVED: {
1194                 event_dev_rssi_info_t *ev = event_data;
1195                 char address[BT_ADDRESS_STRING_SIZE];
1196                 GVariant *param;
1197
1198                 ret_if(NULL == ev);
1199
1200                 _bt_convert_addr_type_to_string(address, ev->address.addr);
1201                 param = g_variant_new("(isii)", BLUETOOTH_ERROR_NONE,
1202                                 address, ev->link_type, ev->rssi);
1203                 _bt_send_event(BT_DEVICE_EVENT, BLUETOOTH_EVENT_RAW_RSSI, param);
1204                 break;
1205         }
1206         case OAL_EVENT_DEVICE_DBFW_PLUS_INFO: {
1207                 __bt_device_dbfw_plus_info_callback((event_dev_dbfw_plus_info_t*)event_data);
1208                 break;
1209         }
1210         default:
1211                 BT_INFO("Unhandled event..");
1212         }
1213 }
1214
1215 /* Legacy Pairing event handler */
1216 static void __bt_device_pin_request_callback(remote_device_t* pin_req_event)
1217 {
1218         GVariant *param;
1219         char address[BT_ADDRESS_STRING_SIZE];
1220         char pin_code[BLUETOOTH_PIN_CODE_MAX_LENGTH + 1];
1221         bool incoming = false;
1222         BT_DBG("+");
1223
1224         _bt_convert_addr_type_to_string(address, pin_req_event->address.addr);
1225
1226         BT_INFO("Address[%s]", address);
1227         BT_INFO("Name[%s]", pin_req_event->name);
1228         BT_INFO("COD[%d]", pin_req_event->cod);
1229
1230         if (trigger_pairing_info) {
1231                 /* BTAPI support only one pairing at a time */
1232                 BT_ERR("Already Pairing address [%s]", trigger_pairing_info->addr);
1233                 BT_ERR("New PIN request address [%s]", address);
1234                 device_reject_pin_request(&pin_req_event->address);
1235                 return;
1236         }
1237
1238         /* If user initiated bonding and auto response is possible, just reply with default 0000*/
1239         if (_bt_is_bonding_device_address(address) == TRUE &&
1240                         _bt_agent_is_auto_response(pin_req_event->cod, address, pin_req_event->name)) {
1241                 /* Note: Currently even if SYSPOPUP is supported, we use Fixed PIN "0000" for basic pairing
1242                    as BT SYSPOPUP is currently not working for PIN KEY entry in Tizen platform. This needs
1243                    to be checked and fixed apropriately */
1244                 _bt_set_autopair_status_in_bonding_info(TRUE);
1245                 device_accept_pin_request(&pin_req_event->address, "0000");
1246         } else if (_bt_agent_is_hid_keyboard(pin_req_event->cod)) {
1247                 BT_DBG("Remote Device is HID keyboard Type..");
1248                 char str_passkey[BT_PASSKEY_MAX_LENGTH + 1] = { 0 };
1249
1250                 if (_bt_agent_generate_passkey(str_passkey,
1251                                         BT_PASSKEY_MAX_LENGTH) != 0) {
1252                         device_reject_pin_request(&pin_req_event->address);
1253                         goto done;
1254                 }
1255                 device_accept_pin_request(&pin_req_event->address, str_passkey);
1256
1257                 BT_DBG("Send BLUETOOTH_EVENT_KEYBOARD_PASSKEY_DISPLAY");
1258
1259                 if(trigger_bond_info == NULL)
1260                         incoming = true;
1261
1262                 param = g_variant_new("(bsss)", incoming, address, pin_req_event->name, str_passkey);
1263                 _bt_send_event(BT_ADAPTER_EVENT,
1264                                 BLUETOOTH_EVENT_KEYBOARD_PASSKEY_DISPLAY, param);
1265                 BT_DBG("Key board pairing in process");
1266         } else if (BLUETOOTH_ERROR_NONE == __bt_get_device_pin_code(address, pin_code)) {
1267                 BT_DBG("Use stored PIN code [%s]", pin_code);
1268                 device_accept_pin_request(&pin_req_event->address, pin_code);
1269         } else {
1270                 if (_bt_is_bonding_device_address(address) == TRUE) {
1271                         BT_DBG("Show Pin entry");
1272                         trigger_pairing_info = g_malloc0(sizeof(bt_pairing_data_t));
1273                         trigger_pairing_info->addr = g_strdup(address);
1274                         trigger_pairing_info->is_ssp = FALSE;
1275
1276                         BT_DBG("Send BLUETOOTH_EVENT_PIN_REQUEST");
1277
1278                         if(trigger_bond_info == NULL)
1279                                 incoming = true;
1280
1281                         param = g_variant_new("(bss)", incoming, address, pin_req_event->name);
1282                         _bt_send_event(BT_ADAPTER_EVENT,
1283                                         BLUETOOTH_EVENT_PIN_REQUEST, param);
1284                 }
1285         }
1286
1287 done:
1288         _bt_agent_release_memory();
1289         BT_DBG("-");
1290 }
1291
1292 /* SSP Pairing event handler */
1293 static void __bt_device_ssp_passkey_entry_callback(remote_device_t* dev_info)
1294 {
1295         GVariant *param;
1296         gchar address[BT_ADDRESS_STR_LEN];
1297         char *p_addr;
1298         gchar *name;
1299         bool incoming = false;
1300
1301         BT_DBG("+");
1302
1303         _bt_convert_addr_type_to_string(address, dev_info->address.addr);
1304         p_addr = address;
1305         name = dev_info->name;
1306
1307         BT_INFO("Address[%s]", address);
1308         BT_INFO("Name[%s]", name);
1309         BT_INFO("COD[%d]", dev_info->cod);
1310
1311         if (trigger_pairing_info) {
1312                 /* BTAPI support only one pairing at a time */
1313                 BT_ERR("Already Pairing address [%s]", trigger_pairing_info->addr);
1314                 BT_ERR("New PIN request address [%s]", address);
1315                 device_reject_pin_request(&dev_info->address);
1316                 BT_DBG("-");
1317                 return;
1318         }
1319
1320         /* Set pairing data */
1321         trigger_pairing_info = g_malloc0(sizeof(bt_pairing_data_t));
1322         trigger_pairing_info->addr = g_strdup(address);
1323         trigger_pairing_info->is_ssp = TRUE;
1324
1325         if(trigger_bond_info == NULL)
1326                 incoming = true;
1327
1328         param = g_variant_new("(bss)", incoming, p_addr, name);
1329         _bt_send_event(BT_ADAPTER_EVENT,
1330                         BLUETOOTH_EVENT_PASSKEY_REQUEST, param);
1331         BT_DBG("-");
1332 }
1333
1334 static void __bt_device_ssp_passkey_confirmation_callback(event_dev_passkey_t *dev_info)
1335 {
1336         GVariant *param;
1337         gchar address[BT_ADDRESS_STR_LEN];
1338         char *p_addr;
1339         gchar *name;
1340         char str_passkey[7];
1341         bool incoming = false; /*Stores if bonding request is incoming(true) or outgoing(false) */
1342         BT_DBG("+");
1343
1344         _bt_convert_addr_type_to_string(address, dev_info->device_info.address.addr);
1345         p_addr = address;
1346         name = dev_info->device_info.name;
1347
1348         BT_INFO("Address[%s]", address);
1349         BT_INFO("Name[%s]", name);
1350         BT_INFO("COD[%d]", dev_info->device_info.cod);
1351
1352         if (trigger_pairing_info) {
1353                 /* BTAPI support only one pairing at a time */
1354                 BT_ERR("Already Pairing address [%s]", trigger_pairing_info->addr);
1355                 BT_ERR("New PIN request address [%s]", address);
1356                 device_reject_pin_request(&dev_info->device_info.address);
1357                 BT_DBG("-");
1358                 return;
1359         }
1360
1361         /* Set pairing data */
1362         trigger_pairing_info = g_malloc0(sizeof(bt_pairing_data_t));
1363         trigger_pairing_info->addr = g_strdup(address);
1364         trigger_pairing_info->is_ssp = TRUE;
1365
1366         BT_DBG("Send BLUETOOTH_EVENT_PASSKEY_CONFIRMATION");
1367         snprintf(str_passkey, sizeof(str_passkey), "%.6d", dev_info->pass_key);
1368
1369         /*Storing if bond is incoming or outgoing*/
1370         if(trigger_bond_info == NULL)
1371                 incoming = true;
1372
1373         param = g_variant_new("(bsss)", incoming, p_addr, name, str_passkey);
1374         _bt_send_event(BT_ADAPTER_EVENT,
1375                         BLUETOOTH_EVENT_PASSKEY_CONFIRM_REQUEST, param);
1376         BT_DBG("-");
1377 }
1378
1379 static void __bt_device_ssp_passkey_display_callback(event_dev_passkey_t *dev_info)
1380 {
1381         GVariant *param;
1382         gchar address[BT_ADDRESS_STR_LEN];
1383         char *p_addr;
1384         gchar *name;
1385         char str_passkey[7];
1386         bool incoming = false;
1387         BT_DBG("+");
1388
1389         _bt_convert_addr_type_to_string(address, dev_info->device_info.address.addr);
1390         p_addr = address;
1391         name = dev_info->device_info.name;
1392
1393         BT_INFO("Address[%s]", address);
1394         BT_INFO("Name[%s]", name);
1395         BT_INFO("COD[%d]", dev_info->device_info.cod);
1396
1397         if (trigger_pairing_info) {
1398                 /* BTAPI support only one pairing at a time */
1399                 BT_ERR("Already Pairing address [%s]", trigger_pairing_info->addr);
1400                 BT_ERR("New PIN request address [%s]", address);
1401                 device_reject_pin_request(&dev_info->device_info.address);
1402                 BT_DBG("-");
1403                 return;
1404         }
1405
1406         /* Set pairing data */
1407         trigger_pairing_info = g_malloc0(sizeof(bt_pairing_data_t));
1408         trigger_pairing_info->addr = g_strdup(address);
1409         trigger_pairing_info->is_ssp = TRUE;
1410
1411         BT_DBG("Send BLUETOOTH_EVENT_KEYBOARD_PASSKEY_DISPLAY");
1412         snprintf(str_passkey, sizeof(str_passkey), "%06d", dev_info->pass_key);
1413
1414         if(trigger_bond_info == NULL)
1415                 incoming = true;
1416
1417         param = g_variant_new("(bsss)", incoming, p_addr, name, str_passkey);
1418
1419         if (passkey_watcher) {
1420                 BT_INFO("Send passkey to %s", passkey_watcher);
1421                 _bt_send_event_to_dest(passkey_watcher, BT_ADAPTER_EVENT,
1422                                 BLUETOOTH_EVENT_PASSKEY_NOTIFICATION, param);
1423         } else {
1424                 _bt_send_event(BT_ADAPTER_EVENT,
1425                                 BLUETOOTH_EVENT_KEYBOARD_PASSKEY_DISPLAY, param);
1426         }
1427         BT_DBG("-");
1428 }
1429
1430 static void __bt_device_ssp_consent_callback(remote_device_t* dev_info)
1431 {
1432         gchar address[BT_ADDRESS_STR_LEN];
1433         gchar *name;
1434         int local_major;
1435         int local_minor;
1436         int cod;
1437         BT_DBG("+");
1438
1439         _bt_convert_addr_type_to_string(address, dev_info->address.addr);
1440         name = dev_info->name;
1441         cod = dev_info->cod;
1442
1443         BT_INFO("Address[%s]", address);
1444         BT_INFO("Name[%s]", name);
1445         BT_INFO("COD[%d]", cod);
1446
1447         if (trigger_pairing_info) {
1448                 /* BTAPI support only one pairing at a time */
1449                 BT_ERR("Already Pairing address [%s]", trigger_pairing_info->addr);
1450                 BT_ERR("New PIN request address [%s]", address);
1451                 device_reject_pin_request(&dev_info->address);
1452                 BT_DBG("-");
1453                 return;
1454         }
1455
1456         /* Set pairing data */
1457         trigger_pairing_info = g_malloc0(sizeof(bt_pairing_data_t));
1458         trigger_pairing_info->addr = g_strdup(address);
1459         trigger_pairing_info->is_ssp = TRUE;
1460
1461         local_major = ((cod >> 8) & 0x001f);
1462         local_minor = (cod & 0x00fc);
1463         BT_DBG("SSP_CONSENT: Major type=[0x%x] and Minor type=[0x%x]", local_major, local_minor);
1464
1465         /*TODO: BLUETOOTH_EVENT_SSP_CONSENT_REQUEST to be handled in Tizen */
1466         BT_DBG("-");
1467 }
1468
1469 static void __bt_device_acl_state_changed_callback(event_dev_conn_status_t *acl_event,
1470                 gboolean connected, unsigned char type)
1471 {
1472         gchar address[BT_ADDRESS_STR_LEN];
1473         int disc_reason = 0;
1474         GVariant *param = NULL;
1475         bt_device_conn_info_t conn_info;
1476
1477         _bt_convert_addr_type_to_string(address, acl_event->address.addr);
1478
1479         _bt_logging_connection(connected, type);
1480
1481         disc_reason = acl_event->status;
1482
1483         if (connected) {
1484                 BT_PERMANENT_LOG("Connected %s %s", !type ? "EDR" : "LE", address + 12);
1485                 param = g_variant_new("(isy)", BLUETOOTH_ERROR_NONE, address, type);
1486                 _bt_send_event(BT_DEVICE_EVENT,
1487                                 BLUETOOTH_EVENT_DEVICE_CONNECTED,
1488                                 param);
1489         } else {
1490                 BT_PERMANENT_LOG("Disconnected %s(%d) %s", !type ? "EDR" : "LE",  disc_reason, address + 12);
1491                 param = g_variant_new("(isyi)", disc_reason, address, type, dbfw_rssi);
1492                 _bt_send_event(BT_DEVICE_EVENT,
1493                                 BLUETOOTH_EVENT_DEVICE_DISCONNECTED,
1494                                 param);
1495         }
1496
1497         conn_info.connected = connected;
1498         conn_info.type = type;
1499         /* Update local cache */
1500         _bt_update_remote_dev_property(address, DEV_PROP_CONNECTED, (void *)&conn_info);
1501
1502 #ifdef TIZEN_GATT_CLIENT
1503         /*handle LE connected device info*/
1504         if (type)
1505                 _bt_handle_le_connected_dev_info(address, connected);
1506 #endif
1507
1508 }
1509
1510 static void __bt_device_remote_device_found_callback(gpointer event_data, gboolean is_ble)
1511 {
1512         bt_remote_dev_info_t *dev_info = NULL;
1513         int result = BLUETOOTH_ERROR_NONE;
1514         GVariant *param = NULL;
1515         GVariant *uuids = NULL;
1516         GVariant *manufacturer_data = NULL;
1517         GVariantBuilder *builder = NULL;
1518         unsigned int i;
1519
1520         ret_if(_bt_is_discovering() == FALSE);
1521         ret_if(event_data == NULL);
1522
1523         dev_info = g_malloc0(sizeof(bt_remote_dev_info_t));
1524
1525         if (is_ble) {
1526                 event_ble_dev_found_t * oal_ble_dev = event_data;
1527                 BT_INFO("Device type [%d]", oal_ble_dev->device_info.type);
1528
1529                 _bt_copy_remote_dev(dev_info, &oal_ble_dev->device_info);
1530
1531                 dev_info->manufacturer_data_len = oal_ble_dev->adv_len;
1532                 if (dev_info->manufacturer_data_len)
1533                         dev_info->manufacturer_data = g_memdup(oal_ble_dev->adv_data,
1534                                         dev_info->manufacturer_data_len);
1535                 else
1536                         dev_info->manufacturer_data = NULL;
1537                 BT_DBG("----Advertising Data Length: %d", dev_info->manufacturer_data_len);
1538         } else {
1539                 event_dev_found_t * oal_dev = event_data;
1540                 _bt_copy_remote_dev(dev_info, &oal_dev->device_info);
1541         }
1542
1543         /* If Remote device name is NULL or still RNR is not done then display address as name. */
1544         if (dev_info->name == NULL)
1545                 dev_info->name = g_strdup(dev_info->address);
1546         BT_DBG("Name %s", dev_info->name);
1547
1548         builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
1549         for (i = 0; i < dev_info->uuid_count; i++)
1550                 g_variant_builder_add(builder, "s", dev_info->uuids[i]);
1551
1552         uuids = g_variant_new("as", builder);
1553         g_variant_builder_unref(builder);
1554
1555         manufacturer_data = g_variant_new_from_data(G_VARIANT_TYPE_BYTESTRING,
1556                         dev_info->manufacturer_data,
1557                         dev_info->manufacturer_data_len,
1558                         TRUE,
1559                         NULL, NULL);
1560
1561         param = g_variant_new("(isunsbub@asn@ay)", result,
1562                         dev_info->address,
1563                         dev_info->class,
1564                         dev_info->rssi,
1565                         dev_info->name,
1566                         dev_info->paired,
1567                         dev_info->connected,
1568                         dev_info->trust,
1569                         uuids,
1570                         dev_info->manufacturer_data_len,
1571                         manufacturer_data);
1572
1573         _bt_send_event(BT_ADAPTER_EVENT,
1574                         BLUETOOTH_EVENT_REMOTE_DEVICE_FOUND,
1575                         param);
1576
1577         _bt_free_remote_dev(dev_info);
1578 }
1579
1580 static void __bt_device_trusted_callback(gboolean trusted, event_dev_trust_t* info)
1581 {
1582         gchar address[BT_ADDRESS_STR_LEN];
1583         int result = BLUETOOTH_ERROR_NONE;
1584         GVariant *param = NULL;
1585         int event;
1586
1587         _bt_convert_addr_type_to_string(address, info->address.addr);
1588
1589         /* Update local cache */
1590         _bt_update_remote_dev_property(address, DEV_PROP_TRUST, (void *)&trusted);
1591
1592         param = g_variant_new("(is)", result, address);
1593         event = trusted ? BLUETOOTH_EVENT_DEVICE_AUTHORIZED :
1594                 BLUETOOTH_EVENT_DEVICE_UNAUTHORIZED;
1595         /* Send event to application */
1596         _bt_send_event(BT_DEVICE_EVENT,
1597                         event,
1598                         param);
1599
1600 }
1601
1602 static void __bt_free_pairing_info(bt_pairing_data_t **p_info)
1603 {
1604         bt_pairing_data_t * info = *p_info;
1605         if (info) {
1606                 if (info->addr)
1607                         g_free(info->addr);
1608
1609                 g_free(info);
1610         }
1611         *p_info = NULL;
1612 }
1613
1614 static void __bt_free_bond_info(uint8_t type)
1615 {
1616         switch (type) {
1617         case BT_DEVICE_BOND_INFO:
1618                 if (!trigger_bond_info)
1619                         break;
1620
1621                 if (trigger_bond_info->addr)
1622                         g_free(trigger_bond_info->addr);
1623                 if (trigger_bond_info->dev_addr)
1624                         g_free(trigger_bond_info->dev_addr);
1625                 if (trigger_bond_info->dev_info)
1626                         _bt_free_remote_dev(trigger_bond_info->dev_info);
1627                 g_free(trigger_bond_info);
1628                 trigger_bond_info = NULL;
1629                 break;
1630         case BT_DEVICE_INCOMING_BOND_INFO:
1631                 if (!incoming_bond_info)
1632                         break;
1633
1634                 if (incoming_bond_info->dev_info)
1635                         _bt_free_remote_dev(incoming_bond_info->dev_info);
1636                 g_free(incoming_bond_info);
1637                 incoming_bond_info = NULL;
1638                 break;
1639         case BT_DEVICE_UNBOND_INFO:
1640                 if (!trigger_unbond_info)
1641                         break;
1642
1643                 if (trigger_unbond_info->addr)
1644                         g_free(trigger_unbond_info->addr);
1645                 if (trigger_unbond_info->dev_addr)
1646                         g_free(trigger_unbond_info->dev_addr);
1647                 if (trigger_unbond_info->dev_info)
1648                         _bt_free_remote_dev(trigger_unbond_info->dev_info);
1649                 g_free(trigger_unbond_info);
1650                 trigger_unbond_info = NULL;
1651                 break;
1652         }
1653 }
1654
1655 static void __bt_free_service_search_info(bt_service_search_info_data_t **p_info)
1656 {
1657         bt_service_search_info_data_t * info = *p_info;
1658         if (info) {
1659                 if (info->addr) {
1660                         g_free(info->addr);
1661                         info->addr = NULL;
1662                 }
1663
1664                 if (info->dev_addr) {
1665                         g_free(info->dev_addr);
1666                         info->dev_addr = NULL;
1667                 }
1668
1669                 if (info->dev_info) {
1670                         _bt_free_remote_dev(info->dev_info);
1671                         info->dev_info = NULL;
1672                 }
1673
1674                 g_free(info);
1675         }
1676         *p_info = NULL;
1677 }
1678
1679 static int __bt_device_handle_bond_state(void)
1680 {
1681         BT_INFO("Current Bond state: %d", bt_device_bond_state);
1682         int ret = OAL_STATUS_INTERNAL_ERROR;
1683
1684         switch (bt_device_bond_state) {
1685         case BT_DEVICE_BOND_STATE_CANCEL_DISCOVERY:
1686                 /*TODO:Bonding during discovery: Unhandled!!*/
1687                 BT_INFO("Bonding during discovery: Unhandled!!");
1688                 break;
1689         case BT_DEVICE_BOND_STATE_DISCOVERY_CANCELLED:
1690                 /*TODO:Bonding during discovery: Unhandled!!*/
1691                 BT_INFO("Bonding during discovery: Unhandled!!");
1692                 break;
1693         case BT_DEVICE_BOND_STATE_REMOVE_BONDING:
1694                 bt_device_bond_state = BT_DEVICE_BOND_STATE_REMOVED_BONDING;
1695                 ret = device_destroy_bond((bt_address_t *)trigger_bond_info->dev_addr);
1696                 if (ret != OAL_STATUS_SUCCESS)
1697                         ret = __bt_device_handle_bond_state();
1698                 break;
1699         case BT_DEVICE_BOND_STATE_REMOVED_BONDING:
1700                 bt_device_bond_state = BT_DEVICE_BOND_STATE_NONE;
1701                 ret = device_create_bond((bt_address_t *)trigger_bond_info->dev_addr, trigger_bond_info->conn_type);
1702                 /* Bonding procedure was started but unfortunately could not complete.
1703                    Basically removed bonding was success, but create bond request could not proceed
1704                    So lets cleanup the context */
1705                 if (ret != OAL_STATUS_SUCCESS) {
1706                         BT_ERR("Create Bond procedure could not suceed");
1707                         __bt_device_handle_pending_requests(BLUETOOTH_ERROR_INTERNAL, BT_BOND_DEVICE,
1708                                         trigger_bond_info->addr, BT_ADDRESS_STRING_SIZE);
1709                         __bt_free_bond_info(BT_DEVICE_BOND_INFO);
1710                         __bt_free_pairing_info(&trigger_pairing_info);
1711                 }
1712                 break;
1713         case BT_DEVICE_BOND_STATE_NONE:
1714                 BT_INFO("Create Bond failed!!");
1715                 if (trigger_bond_info) {
1716                         __bt_device_handle_pending_requests(BLUETOOTH_ERROR_INTERNAL, BT_BOND_DEVICE,
1717                                         trigger_bond_info->addr, BT_ADDRESS_STRING_SIZE);
1718                         __bt_free_bond_info(BT_DEVICE_BOND_INFO);
1719                         __bt_free_pairing_info(&trigger_pairing_info);
1720                 }
1721                 break;
1722         default:
1723                 break;
1724         }
1725
1726         if (ret != OAL_STATUS_SUCCESS)
1727                 return BLUETOOTH_ERROR_INTERNAL;
1728         else
1729                 return BLUETOOTH_ERROR_NONE;
1730 }
1731
1732 int _bt_device_get_bonded_device_info(bluetooth_device_address_t *addr)
1733 {
1734         int result;
1735         bt_address_t bd_addr;
1736
1737         BT_DBG("+");
1738
1739         retv_if(!addr, BLUETOOTH_ERROR_INVALID_PARAM);
1740
1741         memcpy(bd_addr.addr, addr, BLUETOOTH_ADDRESS_LENGTH);
1742         result = device_query_attributes(&bd_addr);
1743         if (result != OAL_STATUS_SUCCESS) {
1744                 BT_ERR("device_query_attributes error: [%d]", result);
1745                 return BLUETOOTH_ERROR_INTERNAL;
1746         }
1747
1748         BT_DBG("-");
1749         return BLUETOOTH_ERROR_NONE;
1750 }
1751
1752 int _bt_set_alias(bluetooth_device_address_t *device_address, const char *alias)
1753 {
1754         int ret;
1755         char address[BT_ADDRESS_STRING_SIZE];
1756
1757         BT_DBG("+");
1758         BT_CHECK_PARAMETER(alias, return);
1759
1760         ret = device_set_alias((bt_address_t *)device_address, (char *)alias);
1761         if (ret != OAL_STATUS_SUCCESS) {
1762                 BT_ERR("device_set_alias: %d", ret);
1763                 return BLUETOOTH_ERROR_INTERNAL;
1764         }
1765
1766         /* Update local cache */
1767         _bt_convert_addr_type_to_string(address, device_address->addr);
1768         _bt_update_remote_dev_property(address, DEV_PROP_ALIAS, (void *)alias);
1769
1770         BT_DBG("-");
1771         return BLUETOOTH_ERROR_NONE;
1772 }
1773
1774 int _bt_bond_device(bluetooth_device_address_t *device_address,
1775                 unsigned short conn_type, GArray **out_param1)
1776 {
1777         int result = BLUETOOTH_ERROR_NONE;
1778         char address[BT_ADDRESS_STRING_SIZE] = { 0 };
1779         bluetooth_device_info_t dev_info;
1780         const char *stack_name = NULL;
1781         BT_DBG("+");
1782
1783         retv_if(device_address == NULL, BLUETOOTH_ERROR_INVALID_PARAM);
1784
1785         /* If bonding or discovery already going on */
1786         if (trigger_bond_info || _bt_is_discovering()) {
1787                 BT_ERR("Device is buzy, bonding can not proceed now..");
1788                 result = BLUETOOTH_ERROR_DEVICE_BUSY;
1789                 goto fail;
1790         }
1791
1792         /*TODO: If unbonding with same device going on */
1793         _bt_convert_addr_type_to_string(address, device_address->addr);
1794
1795         trigger_bond_info = g_malloc0(sizeof(bt_bond_data_t));
1796         trigger_bond_info->addr = g_strdup(address);
1797         trigger_bond_info->conn_type = conn_type;
1798         trigger_bond_info->is_device_creating = TRUE;
1799         trigger_bond_info->dev_addr = g_memdup(device_address, sizeof(bluetooth_device_address_t));
1800         trigger_bond_info->dev_info = NULL;
1801
1802         /* Ready to initiate bonding */
1803
1804         stack_name = oal_get_stack_name();
1805         if (stack_name && !g_strcmp0(stack_name, "bluez")) {
1806                 BT_DBG("[bluez] Create bond by type %d", conn_type);
1807                 bt_device_bond_state = BT_DEVICE_BOND_STATE_REMOVED_BONDING;
1808         } else {
1809                 /* In Tizen, we will first remove bond and then attempt to create bond to keep
1810                    consistency with bluedroid. Even if remove bond fails due to device not already
1811                    bonded, then straight away create bond is triggered. This is because, remove bond
1812                    is handled differently in bluedroid and bluez. In Bluez, if device is
1813                    already removed, remove bond call fails.
1814                    However in bluedroid, remove bond on already removed device returns success. So we will
1815                    handle the cases transparently */
1816                 bt_device_bond_state = BT_DEVICE_BOND_STATE_REMOVE_BONDING;
1817         }
1818
1819         bond_retry_count = 0;
1820         result = __bt_device_handle_bond_state();
1821
1822         if (result != BLUETOOTH_ERROR_NONE)
1823                 goto fail;
1824
1825         BT_DBG("-");
1826         return result;
1827
1828 fail:
1829         memset(&dev_info, 0x00, sizeof(bluetooth_device_info_t));
1830         memcpy(dev_info.device_address.addr, device_address->addr,
1831                         BLUETOOTH_ADDRESS_LENGTH);
1832
1833         g_array_append_vals(*out_param1, &dev_info,
1834                         sizeof(bluetooth_device_info_t));
1835         __bt_free_bond_info(BT_DEVICE_BOND_INFO);
1836
1837         BT_DBG("-");
1838         return result;
1839 }
1840
1841 int _bt_unbond_device(bluetooth_device_address_t *device_address,
1842                 GArray **out_param1)
1843 {
1844         int result = OAL_STATUS_SUCCESS;
1845         char address[BT_ADDRESS_STRING_SIZE] = { 0 };
1846         bluetooth_device_info_t dev_info;
1847         BT_INFO("+");
1848
1849         retv_if(device_address == NULL, BLUETOOTH_ERROR_INVALID_PARAM);
1850
1851         _bt_convert_addr_type_to_string(address, device_address->addr);
1852
1853         trigger_unbond_info = g_malloc0(sizeof(bt_bond_data_t));
1854         trigger_unbond_info->addr = g_malloc0(BT_ADDRESS_STRING_SIZE);
1855         trigger_unbond_info->addr = g_strdup(address);
1856         trigger_unbond_info->dev_addr = g_memdup(device_address, sizeof(bluetooth_device_address_t));
1857
1858         /* Check if Bonding is already going on, we should not abruptly remove bonding*/
1859         if (trigger_bond_info && strncmp(trigger_bond_info->addr, trigger_unbond_info->addr, BT_ADDRESS_STRING_SIZE) == 0) {
1860                 BT_ERR("Bonding with same device already ongoing");
1861                 result = BLUETOOTH_ERROR_PERMISSION_DEINED;
1862                 goto fail;
1863         }
1864
1865         result = device_destroy_bond((bt_address_t *)device_address);
1866         if (result != OAL_STATUS_SUCCESS)
1867                 goto fail;
1868
1869         return BLUETOOTH_ERROR_NONE;
1870
1871 fail:
1872         memset(&dev_info, 0x00, sizeof(bluetooth_device_info_t));
1873         _bt_convert_addr_string_to_type(dev_info.device_address.addr,
1874                         trigger_unbond_info->addr);
1875
1876         g_array_append_vals(*out_param1, &dev_info,
1877                         sizeof(bluetooth_device_info_t));
1878         __bt_free_bond_info(BT_DEVICE_UNBOND_INFO);
1879
1880         if (result == OAL_STATUS_NOT_PAIRED)
1881                 return BLUETOOTH_ERROR_NOT_PAIRED;
1882
1883         return BLUETOOTH_ERROR_INTERNAL;
1884 }
1885
1886 int _bt_cancel_bonding(void)
1887 {
1888         int result = OAL_STATUS_SUCCESS;
1889         BT_INFO("+");
1890
1891         retv_if(trigger_bond_info == NULL, BLUETOOTH_ERROR_NOT_IN_OPERATION);
1892
1893         result = device_stop_bond((bt_address_t *)trigger_bond_info->dev_addr);
1894
1895         if (result == OAL_STATUS_SUCCESS)
1896                 trigger_bond_info->is_cancelled_by_user = TRUE;
1897
1898         return result;
1899 }
1900
1901 int _bt_passkey_reply(const char *passkey, gboolean cnfm_reply)
1902 {
1903         bluetooth_device_address_t device_address;
1904         int ret = OAL_STATUS_SUCCESS;
1905         BT_INFO("reply: %d", cnfm_reply);
1906
1907         retv_if(trigger_pairing_info == NULL, BLUETOOTH_ERROR_INTERNAL);
1908         retv_if(trigger_pairing_info->addr == NULL, BLUETOOTH_ERROR_INTERNAL);
1909
1910         _bt_convert_addr_string_to_type(device_address.addr, trigger_pairing_info->addr);
1911
1912         if (trigger_pairing_info->is_ssp) {
1913                 if (cnfm_reply)
1914                         ret = device_accept_passkey_entry((bt_address_t *)&device_address, atoi(passkey));
1915                 else
1916                         ret = device_reject_passkey_entry((bt_address_t *)&device_address);
1917                 trigger_pairing_info->is_ssp = FALSE;
1918         } else {
1919                 if (cnfm_reply)
1920                         ret = device_accept_pin_request((bt_address_t *)&device_address, passkey);
1921                 else
1922                         ret = device_reject_pin_request((bt_address_t *)&device_address);
1923         }
1924
1925         __bt_free_pairing_info(&trigger_pairing_info);
1926
1927         if (ret != OAL_STATUS_SUCCESS) {
1928                 BT_ERR("_bt_device_handle_passkey_reply: err [%d]", ret);
1929                 return BLUETOOTH_ERROR_INTERNAL;
1930         }
1931
1932         BT_INFO("-");
1933         return BLUETOOTH_ERROR_NONE;
1934 }
1935
1936 int _bt_passkey_confirmation_reply(gboolean cnfm_reply)
1937 {
1938         BT_INFO("BT_PASSKEY_CONFIRMATION_REPLY");
1939         bluetooth_device_address_t device_address;
1940         int ret = OAL_STATUS_SUCCESS;
1941         BT_INFO("reply: %d", cnfm_reply);
1942
1943         retv_if(trigger_pairing_info == NULL, BLUETOOTH_ERROR_INTERNAL);
1944         retv_if(trigger_pairing_info->addr == NULL, BLUETOOTH_ERROR_INTERNAL);
1945
1946         _bt_convert_addr_string_to_type(device_address.addr, trigger_pairing_info->addr);
1947
1948         ret = device_reply_passkey_confirmation((bt_address_t *)&device_address, cnfm_reply);
1949
1950         __bt_free_pairing_info(&trigger_pairing_info);
1951         if (ret != OAL_STATUS_SUCCESS) {
1952                 BT_ERR("_bt_device_handle_passkey_confirmation_reply: err [%d]", ret);
1953                 return BLUETOOTH_ERROR_INTERNAL;
1954         }
1955
1956         BT_INFO("-");
1957         return BLUETOOTH_ERROR_NONE;
1958 }
1959
1960 gboolean _bt_device_is_pairing(void)
1961 {
1962         return (trigger_pairing_info) ? TRUE : FALSE;
1963 }
1964
1965 gboolean _bt_device_is_bonding(void)
1966 {
1967         return (trigger_bond_info) ? TRUE : FALSE;
1968 }
1969
1970 gboolean _bt_is_bonding_device_address(const char *address)
1971 {
1972         if (trigger_bond_info == NULL || trigger_bond_info->addr == NULL)
1973                 return FALSE;
1974
1975         if (g_strcmp0(trigger_bond_info->addr, address) == 0) {
1976                 BT_DBG("[%s]  is bonding device", address);
1977                 return TRUE;
1978         }
1979
1980         BT_DBG("[%s]  is NOT bonding device", address);
1981         return FALSE;
1982 }
1983
1984 void _bt_set_autopair_status_in_bonding_info(gboolean is_autopair)
1985 {
1986         ret_if(trigger_bond_info == NULL);
1987         trigger_bond_info->is_autopair = is_autopair;
1988 }
1989
1990 int _bt_search_device(bluetooth_device_address_t *device_address)
1991 {
1992         int result = OAL_STATUS_SUCCESS;
1993         BT_DBG("+");
1994
1995         BT_CHECK_PARAMETER(device_address, return);
1996
1997         if (trigger_bond_info) {
1998                 BT_ERR("Bonding in progress");
1999                 return BLUETOOTH_ERROR_DEVICE_BUSY;
2000         }
2001
2002         if (service_search_info) {
2003                 BT_ERR("Service searching in progress");
2004                 return BLUETOOTH_ERROR_DEVICE_BUSY;
2005         }
2006
2007         /* allocate user data so that it can be retrieved in callback */
2008         service_search_info = g_malloc0(sizeof(bt_service_search_info_data_t));
2009         service_search_info->addr = g_malloc0(BT_ADDRESS_STRING_SIZE);
2010         service_search_info->dev_addr = g_memdup(device_address, sizeof(bluetooth_device_address_t));
2011
2012         _bt_convert_addr_type_to_string(service_search_info->addr,
2013                         device_address->addr);
2014
2015         result = device_query_services((bt_address_t *)device_address);
2016
2017         if (result != OAL_STATUS_SUCCESS) {
2018                 BT_ERR("Device Service Search Failed..: %d", result);
2019                 __bt_free_service_search_info(&service_search_info);
2020                 return BLUETOOTH_ERROR_INTERNAL;
2021         }
2022         return BLUETOOTH_ERROR_NONE;
2023 }
2024
2025 int _bt_cancel_search_device(void)
2026 {
2027         int ret = OAL_STATUS_SUCCESS;
2028         retv_if(service_search_info == NULL, BLUETOOTH_ERROR_NOT_IN_OPERATION);
2029
2030         ret = device_stop_query_sevices((bt_address_t *)service_search_info->dev_addr);
2031
2032         if (ret != OAL_STATUS_SUCCESS) {
2033                 BT_ERR("SDP Cancel request failed [%d]", ret);
2034                 return BLUETOOTH_ERROR_INTERNAL;
2035         }
2036
2037         __bt_device_handle_pending_requests(BLUETOOTH_ERROR_CANCEL_BY_USER, BT_SEARCH_SERVICE,
2038                         service_search_info->addr, BT_ADDRESS_STRING_SIZE);
2039
2040         __bt_free_service_search_info(&service_search_info);
2041
2042         return BLUETOOTH_ERROR_NONE;
2043         BT_DBG("-");
2044 }
2045
2046 int _bt_set_authorization(bluetooth_device_address_t *device_address,
2047                 gboolean authorize)
2048 {
2049         int ret = OAL_STATUS_SUCCESS;
2050         BT_DBG("+");
2051
2052         BT_CHECK_PARAMETER(device_address, return);
2053         BT_INFO("Device to be Trusted? [%d]", authorize);
2054
2055         ret = device_set_authorized((bt_address_t*)device_address, authorize);
2056         if (ret != OAL_STATUS_SUCCESS) {
2057                 BT_ERR("device_set_authorized: %d", ret);
2058                 return BLUETOOTH_ERROR_INTERNAL;
2059         }
2060
2061         return BLUETOOTH_ERROR_NONE;
2062 }
2063
2064 gboolean _bt_is_device_connected(bluetooth_device_address_t *device_address, int svc_type)
2065 {
2066         gboolean is_connected;
2067         oal_service_t svc_id;
2068
2069         retv_if(device_address == NULL, BLUETOOTH_ERROR_INVALID_PARAM);
2070
2071         /*
2072          * TODO: While adding support for new profiles, need to add more
2073          * <svc_type, svc_id> mapping here.
2074          */
2075         switch (svc_type) {
2076         case BT_PROFILE_CONN_HID:
2077                 svc_id = HID_SERVICE_ID;
2078                 break;
2079         case BT_PROFILE_CONN_A2DP:
2080                 svc_id = A2DP_SERVICE_ID; /* Remote is A2DP Sink */
2081                 break;
2082         case BT_PROFILE_CONN_A2DP_SINK:
2083                 svc_id = A2DP_SRC_SERVICE_ID; /* Remote is A2DP Source*/
2084                 break;
2085         case BT_PROFILE_CONN_HSP:
2086                 svc_id = HFP_HS_SERVICE_ID; /* Remote is HFP HF Unit */
2087                 break;
2088 #ifdef TIZEN_GATT_CLIENT
2089         case BT_PROFILE_CONN_GATT:
2090                 return _bt_is_remote_gatt_device_connected(device_address); /* Remote is GATT client or Server */
2091 #endif
2092         default:
2093                 BT_DBG("Unknown svc_type: %d", svc_type);
2094                 return FALSE;
2095         }
2096
2097         is_connected = device_get_svc_conn_state((bt_address_t*)device_address, svc_id);
2098
2099         BT_DBG("svc_type: %d, is_connected: %s",
2100                         svc_type, is_connected ? "TRUE" : "FALSE");
2101
2102         return is_connected;
2103 }
2104
2105 int _bt_rfcomm_reply_conn_authorization(char *address, gboolean reply)
2106 {
2107         bt_address_t bd_addr;
2108         int res;
2109
2110         BT_DBG("+");
2111
2112         retv_if(NULL == address, BLUETOOTH_ERROR_INVALID_PARAM);
2113         _bt_convert_addr_string_to_type(bd_addr.addr, address);
2114         res = device_reply_auth_request(&bd_addr, 0, reply, FALSE);
2115         if (res != OAL_STATUS_SUCCESS) {
2116                 BT_ERR("authorize_response: %d", res);
2117                 return BLUETOOTH_ERROR_INTERNAL;
2118         }
2119
2120         BT_DBG("-");
2121         return BLUETOOTH_ERROR_NONE;
2122 }
2123
2124 int _bt_enable_rssi(bluetooth_device_address_t *addr, int link_type,
2125                 int low_threshold, int in_range_threshold, int high_threshold)
2126 {
2127         int result;
2128         bt_address_t bd_addr;
2129
2130         BT_DBG("+");
2131
2132         retv_if(!addr, BLUETOOTH_ERROR_INVALID_PARAM);
2133
2134         memcpy(bd_addr.addr, addr, BLUETOOTH_ADDRESS_LENGTH);
2135         result = device_enable_rssi_monitoring(&bd_addr, link_type,
2136                         low_threshold, in_range_threshold, high_threshold);
2137         if (result != OAL_STATUS_SUCCESS) {
2138                 BT_ERR("device_get_connected_link_rssi_strength error: [%d]", result);
2139                 return BLUETOOTH_ERROR_INTERNAL;
2140         }
2141
2142         BT_DBG("-");
2143         return BLUETOOTH_ERROR_NONE;
2144 }
2145
2146 int _bt_get_rssi_strength(bluetooth_device_address_t *addr, int link_type)
2147 {
2148         int result;
2149         bt_address_t bd_addr;
2150
2151         BT_DBG("+");
2152
2153         retv_if(!addr, BLUETOOTH_ERROR_INVALID_PARAM);
2154
2155         memcpy(bd_addr.addr, addr, BLUETOOTH_ADDRESS_LENGTH);
2156         result = device_get_connected_link_rssi_strength(&bd_addr, link_type);
2157         if (result != OAL_STATUS_SUCCESS) {
2158                 BT_ERR("device_get_connected_link_rssi_strength error: [%d]", result);
2159                 return BLUETOOTH_ERROR_INTERNAL;
2160         }
2161
2162         BT_DBG("-");
2163         return BLUETOOTH_ERROR_NONE;
2164 }
2165
2166 int _bt_set_passkey_notification(const char *sender, gboolean enable)
2167 {
2168         int result;
2169
2170         BT_INFO("Set passkey notification(sender:%s, %s)",
2171                         sender, enable ? "Enable" : "Disable");
2172
2173         result = device_enable_gap_auth_notifications(OAL_PASSKEY_DISPLAY, enable);
2174         if (OAL_STATUS_SUCCESS != result) {
2175                 BT_ERR("device_enable_gap_auth_notifications error: [%d]", result);
2176                 return BLUETOOTH_ERROR_INTERNAL;
2177         }
2178
2179         g_free(passkey_watcher);
2180         if (enable == TRUE)
2181                 passkey_watcher = g_strdup(sender);
2182         else
2183                 passkey_watcher = NULL;
2184
2185         return BLUETOOTH_ERROR_NONE;
2186 }
2187
2188 static int __bt_get_device_pin_code(const char *address, char *pin_code)
2189 {
2190         GSList *l = NULL;
2191
2192         BT_CHECK_PARAMETER(address, return);
2193         BT_CHECK_PARAMETER(pin_code, return);
2194
2195         for (l = pin_info_list; l != NULL; l = l->next) {
2196                 bt_pin_code_info_t *pin_info = l->data;
2197
2198                 if (!pin_info || !pin_info->address)
2199                         continue;
2200
2201                 if (g_strcmp0(pin_info->address, address) == 0) {
2202                         g_strlcpy(pin_code, pin_info->pin_code,
2203                                         BLUETOOTH_PIN_CODE_MAX_LENGTH + 1);
2204                         return BLUETOOTH_ERROR_NONE;
2205                 }
2206         }
2207
2208         return BLUETOOTH_ERROR_NOT_FOUND;
2209 }
2210
2211 int _bt_set_pin_code(bluetooth_device_address_t *device_address,
2212                 bluetooth_device_pin_code_t *pin_code)
2213 {
2214         char address[BT_ADDRESS_STRING_SIZE] = { 0 };
2215         bt_pin_code_info_t *pin_info = NULL;
2216         GSList *l = NULL;
2217
2218         BT_CHECK_PARAMETER(device_address, return);
2219         BT_CHECK_PARAMETER(pin_code, return);
2220         retv_if(g_slist_length(pin_info_list) >= BT_DEVICE_PIN_CODE_SLOT_MAX,
2221                         BLUETOOTH_ERROR_NO_RESOURCES);
2222
2223         _bt_convert_addr_type_to_string(address, device_address->addr);
2224
2225         for (l = pin_info_list; l != NULL; l = l->next) {
2226                 pin_info = l->data;
2227
2228                 if (!pin_info || !pin_info->address)
2229                         continue;
2230
2231                 if (g_strcmp0(pin_info->address, address) == 0) {
2232                         g_free(pin_info->pin_code);
2233                         pin_info->pin_code = g_strdup(pin_code->pin_code);
2234                         return BLUETOOTH_ERROR_NONE;
2235                 }
2236         }
2237
2238         pin_info = g_malloc0(sizeof(bt_pin_code_info_t));
2239         pin_info->address = g_strdup(address);
2240         pin_info->pin_code = g_strdup(pin_code->pin_code);
2241         pin_info_list = g_slist_append(pin_info_list, pin_info);
2242
2243         return BLUETOOTH_ERROR_NONE;
2244 }
2245
2246 int _bt_unset_pin_code(bluetooth_device_address_t *device_address)
2247 {
2248         char address[BT_ADDRESS_STRING_SIZE] = { 0 };
2249         bt_pin_code_info_t *pin_info = NULL;
2250         GSList *l = NULL;
2251
2252         BT_DBG("+");
2253
2254         BT_CHECK_PARAMETER(device_address, return);
2255
2256         _bt_convert_addr_type_to_string(address, device_address->addr);
2257
2258         for (l = pin_info_list; l != NULL; l = l->next) {
2259                 pin_info = l->data;
2260
2261                 if (!pin_info || !pin_info->address)
2262                         continue;
2263
2264                 if (g_strcmp0(pin_info->address, address) == 0) {
2265                         pin_info_list = g_slist_remove(pin_info_list, pin_info);
2266                         g_free(pin_info->address);
2267                         g_free(pin_info->pin_code);
2268                         g_free(pin_info);
2269                         break;
2270                 }
2271         }
2272
2273         BT_DBG("-");
2274         return BLUETOOTH_ERROR_NONE;
2275 }
2276
2277 int _bt_device_get_ida(bluetooth_device_address_t *device_address, bluetooth_device_address_t *id_address)
2278 {
2279         int result = BLUETOOTH_ERROR_NONE;
2280         char address[BT_ADDRESS_STRING_SIZE] = { 0 };
2281
2282         _bt_convert_addr_type_to_string(address, device_address->addr);
2283
2284         BT_DBG("getting IDA for remote device: [%s]", address);
2285
2286         result = device_get_ida((bt_address_t*)device_address, (bt_address_t*)id_address);
2287
2288         if (result != OAL_STATUS_SUCCESS) {
2289                 BT_ERR("device_get_ida Failed %d", result);
2290                 return BLUETOOTH_ERROR_INTERNAL;
2291         }
2292
2293         return result;
2294 }
2295
2296 #ifdef TIZEN_GATT_CLIENT
2297 static bt_connected_le_dev_t *__bt_get_le_connected_dev_info(const char *address)
2298 {
2299         GSList *l = NULL;
2300         bt_connected_le_dev_t *dev;
2301
2302         if (!address)
2303                 return NULL;
2304
2305         for (l = le_connected_dev_list; l; l = g_slist_next(l)) {
2306                 dev = l->data;
2307
2308                 if (g_strcmp0(dev->address, address) == 0)
2309                         return dev;
2310         }
2311         return NULL;
2312 }
2313
2314 static void __bt_le_conn_param_free(void *data)
2315 {
2316         bt_le_conn_param_t *param = (bt_le_conn_param_t *)data;
2317
2318         BT_DBG("%s", param->sender);
2319         g_free(param->sender);
2320         g_free(param);
2321 }
2322
2323 static void _bt_add_le_connected_dev_info(const char *address)
2324 {
2325         bt_connected_le_dev_t *dev = NULL;
2326
2327         if (!address)
2328                 return;
2329
2330         dev = g_malloc0(sizeof(bt_connected_le_dev_t));
2331         dev->address = g_strdup(address);
2332
2333         le_connected_dev_list = g_slist_append(le_connected_dev_list, dev);
2334
2335         return;
2336 }
2337
2338 static void _bt_remove_le_connected_dev_info(const char *address)
2339 {
2340         bt_connected_le_dev_t *dev = NULL;
2341
2342         if (!address)
2343                 return;
2344
2345         dev = __bt_get_le_connected_dev_info(address);
2346         if (!dev)
2347                 return;
2348
2349         g_slist_free_full(dev->senders, __bt_le_conn_param_free);
2350         le_connected_dev_list = g_slist_remove(le_connected_dev_list, dev);
2351         g_free(dev->address);
2352         g_free(dev);
2353
2354         return;
2355 }
2356
2357 static void _bt_handle_le_connected_dev_info(const char *address, gboolean connected)
2358 {
2359         BT_DBG("update le_connected_dev_list");
2360
2361         if (connected)
2362                 _bt_add_le_connected_dev_info(address);
2363         else
2364                 _bt_remove_le_connected_dev_info(address);
2365 }
2366
2367 static bt_le_conn_param_t *__bt_get_le_conn_param_info(bt_connected_le_dev_t *dev, const char *sender)
2368 {
2369         GSList *l = NULL;
2370         bt_le_conn_param_t *param = NULL;
2371
2372         if (!dev || !sender)
2373                 return NULL;
2374
2375         for (l = dev->senders; l; l = g_slist_next(l)) {
2376                 param = l->data;
2377                 if (g_strcmp0(param->sender, sender) == 0)
2378                         return param;
2379         }
2380
2381         return NULL;
2382 }
2383
2384 static gint __bt_compare_le_conn_param_key(gpointer *a, gpointer *b)
2385 {
2386         bt_le_conn_param_t *parama = (bt_le_conn_param_t *)a;
2387         bt_le_conn_param_t *paramb = (bt_le_conn_param_t *)b;
2388
2389         return parama->key > paramb->key;
2390 }
2391
2392
2393 int _bt_add_le_conn_param_info(const char *address, const char *sender,
2394                 float interval_min, float interval_max, guint16 latency, guint16 time_out)
2395 {
2396         bt_connected_le_dev_t *dev = NULL;
2397         bt_le_conn_param_t *param = NULL;
2398         bt_le_conn_param_t *data = NULL;
2399
2400         if (!address || !sender)
2401                 return BLUETOOTH_ERROR_INVALID_PARAM;
2402
2403         dev = __bt_get_le_connected_dev_info(address);
2404         if (!dev)
2405                 return BLUETOOTH_ERROR_INTERNAL;
2406
2407         param = __bt_get_le_conn_param_info(dev, sender);
2408
2409         data = g_malloc0(sizeof(bt_le_conn_param_t));
2410         data->sender = g_strdup(sender);
2411         data->interval_min = interval_min;
2412         data->interval_max = interval_max;
2413         data->latency = latency;
2414         data->time_out = time_out;
2415         data->key = interval_min + (interval_max - interval_min)/2;
2416
2417         if (param == NULL) {
2418                 BT_DBG("Add param %s %s %f %f", address, sender, interval_min, interval_max);
2419                 dev->senders = g_slist_append(dev->senders, data);
2420         } else {
2421                 BT_DBG("Update param %s %s %f %f", address, sender, interval_min, interval_max);
2422                 dev->senders = g_slist_remove(dev->senders, param);
2423                 g_free(param->sender);
2424                 g_free(param);
2425                 dev->senders = g_slist_append(dev->senders, data);
2426         }
2427
2428         /* Sorting. First element have the minimum interval */
2429         dev->senders = g_slist_sort(dev->senders,
2430                         (GCompareFunc)__bt_compare_le_conn_param_key);
2431
2432         return BLUETOOTH_ERROR_NONE;
2433 }
2434
2435
2436 static int __bt_le_set_conn_parameter(const char *address,
2437                 float interval_min, float interval_max,
2438                 guint16 latency, guint16 time_out)
2439 {
2440         bt_address_t dev_addr = { {0} };
2441         guint32 min, max, to;
2442
2443         BT_INFO("Min interval: %f, Max interval: %f, Latency: %u, Supervision timeout: %u",
2444                         interval_min, interval_max, latency, time_out);
2445
2446         min = interval_min / BT_LE_CONN_INTERVAL_SPLIT;
2447         max = interval_max / BT_LE_CONN_INTERVAL_SPLIT;
2448         to = time_out / BT_LE_CONN_TO_SPLIT;
2449
2450         BT_INFO("updating: Min interval: %d, Max interval: %d, Latency: %d, Supervision timeout: %d",
2451                         min, max, latency, to);
2452
2453         _bt_convert_addr_string_to_type(dev_addr.addr, address);
2454
2455         return gattc_conn_param_update(&dev_addr, min, max, latency, to);
2456 }
2457
2458 int _bt_remove_le_conn_param_info(const char *address, const char *sender)
2459 {
2460         bt_connected_le_dev_t *dev = NULL;
2461         bt_le_conn_param_t *param = NULL;
2462
2463         if (!address || !sender)
2464                 return BLUETOOTH_ERROR_INVALID_PARAM;
2465
2466         dev = __bt_get_le_connected_dev_info(address);
2467         if (!dev)
2468                 return BLUETOOTH_ERROR_INTERNAL;
2469
2470         param = __bt_get_le_conn_param_info(dev, sender);
2471         if (param) {
2472                 BT_DBG("Remove param %s %s ", address, sender);
2473                 dev->senders = g_slist_remove(dev->senders, param);
2474                 g_free(param->sender);
2475                 g_free(param);
2476         }
2477
2478         return BLUETOOTH_ERROR_NONE;
2479 }
2480
2481 int _bt_get_le_connection_parameter(bluetooth_le_connection_mode_t mode,
2482                 bluetooth_le_connection_param_t *param)
2483 {
2484         if (param == NULL)
2485                 return BLUETOOTH_ERROR_INVALID_PARAM;
2486
2487         memset(param, 0x00, sizeof(bluetooth_le_connection_param_t));
2488
2489         switch (mode) {
2490         case BLUETOOTH_LE_CONNECTION_MODE_BALANCED:
2491                 param->interval_min = BT_LE_CONN_PARAM_BALANCED_MIN_INTERVAL;
2492                 param->interval_max = BT_LE_CONN_PARAM_BALANCED_MAX_INTERVAL;
2493                 param->latency = BT_LE_CONN_PARAM_BALANCED_SLAVE_LATENCY;
2494                 param->timeout = BT_LE_CONN_PARAM_DEFAULT_SUPERVISION_TIMEOUT;
2495                 break;
2496
2497         case BLUETOOTH_LE_CONNECTION_MODE_LOW_LATENCY:
2498                 param->interval_min = BT_LE_CONN_PARAM_LOW_LATENCY_MIN_INTERVAL;
2499                 param->interval_max = BT_LE_CONN_PARAM_LOW_LATENCY_MAX_INTERVAL;
2500                 param->latency = BT_LE_CONN_PARAM_LOW_LATENCY_SLAVE_LATENCY;
2501                 param->timeout = BT_LE_CONN_PARAM_DEFAULT_SUPERVISION_TIMEOUT;
2502                 break;
2503
2504         case BLUETOOTH_LE_CONNECTION_MODE_LOW_POWER:
2505                 param->interval_min = BT_LE_CONN_PARAM_LOW_POWER_MIN_INTERVAL;
2506                 param->interval_max = BT_LE_CONN_PARAM_LOW_POWER_MAX_INTERVAL;
2507                 param->latency = BT_LE_CONN_PARAM_LOW_POWER_SLAVE_LATENCY;
2508                 param->timeout = BT_LE_CONN_PARAM_DEFAULT_SUPERVISION_TIMEOUT;
2509                 break;
2510
2511         default:
2512                 BT_ERR("Unhandled mode : %d", mode);
2513                 break;
2514         }
2515
2516         return BLUETOOTH_ERROR_NONE;
2517 }
2518
2519 int _bt_le_connection_update(const char *sender,
2520                 unsigned char *device_address,
2521                 float interval_min, float interval_max,
2522                 guint16 latency, guint16 time_out)
2523 {
2524         char address[BT_ADDRESS_STRING_SIZE] = { 0 };
2525         guint32 min_supervision_to;
2526         bt_connected_le_dev_t *dev = NULL;
2527         bt_le_conn_param_t *param = NULL;
2528         int ret = BLUETOOTH_ERROR_NONE;
2529
2530         BT_CHECK_PARAMETER(device_address, return);
2531
2532         BT_INFO("Sender %s, Min interval: %f, Max interval: %f, Latency: %u, Supervision timeout: %u",
2533                         sender, interval_min, interval_max, latency, time_out);
2534
2535         if (interval_min > interval_max ||
2536                         interval_min < BT_LE_CONN_INTERVAL_MIN ||
2537                         interval_max > BT_LE_CONN_INTERVAL_MAX) {
2538                 ret = BLUETOOTH_ERROR_INVALID_PARAM;
2539                 goto fail;
2540         }
2541
2542         if (time_out < BT_LE_CONN_SUPER_TO_MIN ||
2543                         time_out > BT_LE_CONN_SUPER_TO_MAX) {
2544                 ret = BLUETOOTH_ERROR_INVALID_PARAM;
2545                 goto fail;
2546         }
2547
2548         if (latency > BT_LE_CONN_SLAVE_LATENCY_MAX) {
2549                 ret = BLUETOOTH_ERROR_INVALID_PARAM;
2550                 goto fail;
2551         }
2552
2553         /*
2554          * The Supervision_Timeout in milliseconds shall be larger than
2555          * (1 + Conn_Latency) * Conn_Interval_Max * 2,
2556          * where Conn_Interval_Max is given in milliseconds.
2557          */
2558
2559         min_supervision_to = (1 + latency) * interval_max * 2;
2560         if (time_out <= min_supervision_to) {
2561                 ret = BLUETOOTH_ERROR_INVALID_PARAM;
2562                 goto fail;
2563         }
2564
2565         _bt_convert_addr_type_to_string(address, device_address);
2566         BT_DBG("Remote device address: %s", address);
2567
2568         _bt_add_le_conn_param_info(address, sender, interval_min, interval_max, 0, 2000);
2569
2570         dev = __bt_get_le_connected_dev_info(address);
2571         if (dev == NULL) {
2572                 BT_ERR("device not found in the list");
2573                 ret = BLUETOOTH_ERROR_NOT_CONNECTED;
2574                 goto fail;
2575         }
2576
2577         if (g_slist_length(dev->senders) == 1)
2578                 goto update;
2579         else {
2580                 param = dev->senders->data;
2581
2582                 BT_DBG("dev %f, param %f, input %f", dev->interval_min, param->interval_min, interval_min);
2583
2584                 if (dev->interval_min == param->interval_min && dev->interval_max == param->interval_max) {
2585                         BT_DBG("Skip due to same interval");
2586                         return ret;
2587                 }
2588
2589                 interval_min = param->interval_min;
2590                 interval_max = param->interval_max;
2591         }
2592
2593 update:
2594         ret = __bt_le_set_conn_parameter(address, interval_min, interval_max, latency, time_out);
2595
2596         if (ret != OAL_STATUS_SUCCESS) {
2597                 _bt_remove_le_conn_param_info(address, sender);
2598                 BT_DBG("fail to update the LE connection parameter");
2599                 ret = BLUETOOTH_ERROR_INTERNAL;
2600                 goto fail;
2601         }
2602
2603         dev->interval_min = interval_min;
2604         dev->interval_max = interval_max;
2605
2606         return BLUETOOTH_ERROR_NONE;
2607 fail:
2608         return ret;
2609 }
2610
2611 int _bt_disconnect_device(bluetooth_device_address_t *device_address)
2612 {
2613         int result = OAL_STATUS_SUCCESS;
2614
2615         BT_DBG("+");
2616
2617         retv_if(!device_address, BLUETOOTH_ERROR_INVALID_PARAM);
2618
2619         result = device_disconnect((bt_address_t *)device_address);
2620         if (result != OAL_STATUS_SUCCESS) {
2621                 BT_DBG("Failed to disconnect device");
2622                 return BLUETOOTH_ERROR_INTERNAL;
2623         }
2624
2625         BT_DBG("-");
2626         return BLUETOOTH_ERROR_NONE;
2627 }
2628
2629 static gboolean __bt_ignore_auto_pairing_request(const char *address)
2630 {
2631         gchar *buffer;
2632         char **lines;
2633         int i;
2634         char lap_address[BT_LOWER_ADDRESS_LENGTH + 1] = {0,};
2635         char *temp_buffer;
2636         FILE *fp;
2637         long size;
2638         size_t result;
2639
2640         BT_DBG("+\n");
2641
2642         if (address == NULL)
2643                 return FALSE;
2644
2645         /* Get the LAP(Lower Address part) */
2646         /* User BT_LOWER_ADDRESS_LENGTH+1 for lap_address to accomodate
2647            a "," */
2648         snprintf(lap_address, sizeof(lap_address), ",%s", address);
2649
2650         fp = fopen(BT_AGENT_AUTO_PAIR_BLACKLIST_FILE, "r");
2651
2652         if (fp == NULL) {
2653                 BT_ERR("fopen failed \n");
2654                 return FALSE;
2655         }
2656
2657         fseek(fp, 0, SEEK_END);
2658         size = ftell(fp);
2659         rewind(fp);
2660
2661         if (size < 0) {
2662                 BT_ERR("Get file size failed \n");
2663                 fclose(fp);
2664                 return FALSE;
2665         }
2666
2667         buffer = g_malloc0(sizeof(char) * size);
2668         result = fread((char *)buffer, 1, size, fp);
2669         fclose(fp);
2670         if (result != size) {
2671                 BT_ERR("Read Error\n");
2672                 g_free(buffer);
2673                 return FALSE;
2674         }
2675
2676         BT_DBG("Buffer = %s\n", buffer);
2677
2678         lines = g_strsplit_set(buffer, BT_AGENT_NEW_LINE, 0);
2679         g_free(buffer);
2680
2681         if (lines == NULL)
2682                 return FALSE;
2683
2684         /* Write the data and insert new device data */
2685         for (i = 0; lines[i] != NULL; i++) {
2686                 if (g_str_has_prefix(lines[i], "AddressBlacklist")) {
2687                         temp_buffer = g_strconcat(lines[i], lap_address, NULL);
2688                         g_free(lines[i]);
2689                         lines[i] = temp_buffer;
2690                 }
2691         }
2692         buffer = g_strjoinv(BT_AGENT_NEW_LINE, lines);
2693         g_strfreev(lines);
2694         /* Fix : NULL_RETURNS */
2695         retv_if(buffer == NULL, FALSE);
2696
2697         fp = fopen(BT_AGENT_AUTO_PAIR_BLACKLIST_FILE, "w");
2698
2699         if (fp == NULL) {
2700                 BT_ERR("fopen failed \n");
2701                 g_free(buffer);
2702                 return FALSE;
2703         }
2704
2705         BT_DBG("Buffer = %s\n", buffer);
2706         fwrite(buffer, 1, strlen(buffer), fp);
2707         fclose(fp);
2708
2709         g_free(buffer);
2710
2711         BT_DBG("-\n");
2712
2713         return FALSE;
2714 }
2715 #endif