bt-service/bt-service-adapter-le.c

   1 /*
   2  * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *              http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 #include <stdio.h>
  19 #include <dbus/dbus.h>
  20 #include <gio/gio.h>
  21 #include <glib.h>
  22 #include <dlog.h>
  23 #include <string.h>
  24 #include <vconf.h>
  25 #include <syspopup_caller.h>
  26 #include <aul.h>
  27
  28 #include "bt-internal-types.h"
  29 #include "bt-service-common.h"
  30 #include "bt-service-event.h"
  31 #include "bt-service-adapter.h"
  32 #include "bt-service-adapter-le.h"
  33 #include "bt-service-util.h"
  34
  35
  36 #define BT_ADV_INTERVAL_MIN 20 /* msec */
  37 #define BT_ADV_INTERVAL_MAX 10240
  38 #define BT_ADV_INTERVAL_SPLIT 0.625
  39 #define BT_DEFAULT_ADV_MIN_INTERVAL 500
  40 #define BT_DEFAULT_ADV_MAX_INTERVAL 500
  41 #define BT_ADV_FILTER_POLICY_DEFAULT    0x00
  42 #define BT_ADV_TYPE_DEFAULT     0x00
  43 #define BT_ADV_FILTER_POLICY_ALLOW_SCAN_CONN_WL_ONLY    0x03
  44
  45 typedef struct {
  46         int adv_inst_max;
  47         int rpa_offloading;
  48         int max_filter;
  49 } bt_adapter_le_feature_info_t;
  50
  51 typedef struct {
  52         char *sender;
  53         int adv_handle;
  54         gboolean is_advertising;
  55         guint hold_timer_id;
  56 } bt_adapter_le_adv_slot_t;
  57
  58 typedef struct {
  59         char *sender;
  60         GSList *filter_list;
  61         gboolean is_scanning;
  62         gboolean stop_pending;
  63 } bt_adapter_le_scanner_t;
  64
  65 static bluetooth_advertising_params_t adv_params = {
  66         BT_DEFAULT_ADV_MIN_INTERVAL,
  67         BT_DEFAULT_ADV_MAX_INTERVAL,
  68         BT_ADV_FILTER_POLICY_DEFAULT,
  69         BT_ADV_TYPE_DEFAULT};
  70 static bluetooth_advertising_data_t adv_data = { {0} };
  71 static int adv_data_len;
  72 static bluetooth_scan_resp_data_t resp_data = { {0} };
  73 static int resp_data_len;
  74
  75 static bt_adapter_le_feature_info_t le_feature_info = { 1, 0, 0 };
  76 static bt_adapter_le_adv_slot_t *le_adv_slot = NULL;
  77
  78 GSList *scanner_list = NULL;
  79 static gboolean is_le_set_scan_parameter = FALSE;
  80 static gboolean is_le_scanning = FALSE;
  81 static gboolean scan_filter_enabled = FALSE;
  82 static bt_le_scan_type_t le_scan_type = BT_LE_PASSIVE_SCAN;
  83
  84 static GSList *gatt_client_senders = NULL;
  85
  86
  87 gboolean _bt_is_set_scan_parameter(void)
  88 {
  89         return is_le_set_scan_parameter;
  90 }
  91
  92 void _bt_init_gatt_client_senders(void)
  93 {
  94         _bt_clear_request_list();
  95 }
  96
  97 int _bt_insert_gatt_client_sender(char *sender)
  98 {
  99         char *info;
 100
 101         retv_if(sender == NULL, BLUETOOTH_ERROR_INVALID_PARAM);
 102
 103         info = g_strdup(sender);
 104         retv_if(info == NULL, BLUETOOTH_ERROR_MEMORY_ALLOCATION);
 105
 106         gatt_client_senders = g_slist_append(gatt_client_senders, info);
 107
 108         BT_DBG("insert sender: %s", sender);
 109
 110         return BLUETOOTH_ERROR_NONE;
 111 }
 112
 113 int _bt_delete_gatt_client_sender(char *sender)
 114 {
 115         GSList *l;
 116         char *info;
 117
 118         BT_DBG("remove sender: %s", sender);
 119
 120         for (l = gatt_client_senders; l != NULL; l = g_slist_next(l)) {
 121                 info = l->data;
 122                 if (info == NULL)
 123                         continue;
 124
 125                 if (g_strcmp0(info, sender) == 0) {
 126                         BT_DBG("remove info");
 127                         gatt_client_senders = g_slist_remove(gatt_client_senders, info);
 128                         g_free(info);
 129                         return BLUETOOTH_ERROR_NONE;
 130                 }
 131         }
 132
 133         return BLUETOOTH_ERROR_NOT_FOUND;
 134 }
 135
 136 void _bt_clear_gatt_client_senders(void)
 137 {
 138         if (gatt_client_senders) {
 139                 g_slist_foreach(gatt_client_senders, (GFunc)g_free, NULL);
 140                 g_slist_free(gatt_client_senders);
 141                 gatt_client_senders = NULL;
 142         }
 143 }
 144 #if 0
 145 static void __bt_send_foreach_event(gpointer data, gpointer user_data)
 146 {
 147         char *sender = data;
 148         GVariant *param = user_data;
 149
 150         _bt_send_event_to_dest(sender, BT_DEVICE_EVENT, BLUETOOTH_EVENT_GATT_CHAR_VAL_CHANGED,
 151                                         param);
 152 }
 153 #endif
 154 void _bt_send_char_value_changed_event(void *param)
 155 {
 156 #if 0
 157         g_slist_foreach(gatt_client_senders, __bt_send_foreach_event,
 158                                         (gpointer)param);
 159 #else
 160         _bt_send_event(BT_DEVICE_EVENT, BLUETOOTH_EVENT_GATT_CHAR_VAL_CHANGED, param);
 161 #endif
 162 }
 163
 164 void __bt_free_le_adv_slot(void)
 165 {
 166         int i;
 167
 168         if (le_adv_slot == NULL)
 169                 return;
 170
 171         for (i = 0; i < le_feature_info.adv_inst_max; i++) {
 172                 if (le_adv_slot[i].sender)
 173                         g_free(le_adv_slot[i].sender);
 174                 if (le_adv_slot[i].hold_timer_id > 0)
 175                         g_source_remove(le_adv_slot[i].hold_timer_id);
 176         }
 177         g_free(le_adv_slot);
 178         le_adv_slot = NULL;
 179 }
 180
 181 int _bt_le_set_max_packet_len(void)
 182 {
 183         int result = BLUETOOTH_ERROR_NONE;
 184         int tx_octets, tx_time;
 185         bluetooth_le_read_maximum_data_length_t max_len = {0};
 186
 187         if (BLUETOOTH_ERROR_NONE != _bt_le_read_maximum_data_length(&max_len))
 188                 return BLUETOOTH_ERROR_INTERNAL;
 189
 190         if (max_len.max_tx_octets > BT_LE_TX_LEN_DEFAULT) {
 191                 tx_octets =  max_len.max_tx_octets > BT_LE_TX_LEN_MAX ?
 192                                 BT_LE_TX_LEN_MAX : max_len.max_tx_octets;
 193                 tx_time = BT_LE_TX_TIME_MAX;
 194
 195                 result = _bt_le_write_host_suggested_default_data_length(tx_octets, tx_time);
 196
 197                 BT_DBG("Wrote max packet size : result[%d], MAX[%d], set[%d]",
 198                                 result, max_len.max_tx_octets, tx_octets);
 199         }
 200
 201         return result;
 202 }
 203
 204 gboolean _bt_update_le_feature_support(const char *item, const char *value)
 205 {
 206         if (item == NULL || value == NULL)
 207                 return FALSE;
 208
 209         if (!le_adv_slot)
 210                 _bt_service_adapter_le_init();
 211
 212         if (g_strcmp0(item, "adv_inst_max") == 0) {
 213                 int slot_num;
 214
 215                 slot_num = atoi(value);
 216                 retv_if(slot_num < 0, FALSE);
 217
 218                 if (slot_num != le_feature_info.adv_inst_max) {
 219                         __bt_free_le_adv_slot();
 220                         le_feature_info.adv_inst_max = slot_num;
 221                         BT_INFO("Advertising instance max : %d", le_feature_info.adv_inst_max);
 222                         le_adv_slot = g_malloc0(sizeof(bt_adapter_le_adv_slot_t) * le_feature_info.adv_inst_max);
 223                 }
 224         } else if (g_strcmp0(item, "rpa_offloading") == 0) {
 225                 le_feature_info.rpa_offloading = atoi(value);
 226                 BT_INFO("RPA offloading : %d", le_feature_info.rpa_offloading);
 227         } else if (g_strcmp0(item, "max_filter") == 0) {
 228                 le_feature_info.max_filter = atoi(value);
 229                 BT_INFO("BLE Scan max filter : %d", le_feature_info.max_filter);
 230         } else {
 231                 BT_DBG("No registered item");
 232                 return FALSE;
 233         }
 234
 235         return TRUE;
 236 }
 237
 238 static gboolean __bt_is_factory_test_mode(void)
 239 {
 240         int mode = 0;
 241
 242         if (vconf_get_bool(VCONFKEY_BT_DUT_MODE, &mode)) {
 243                 BT_ERR("Get the DUT Mode fail");
 244                 return TRUE;
 245         }
 246
 247         if (mode != FALSE) {
 248                 BT_INFO("DUT Test Mode !!");
 249                 return TRUE;
 250         }
 251
 252         return FALSE;
 253 }
 254
 255 int __bt_get_available_adv_slot_id(const char *sender, int adv_handle, gboolean use_reserved_slot)
 256 {
 257         int i;
 258
 259         if (le_adv_slot == NULL) {
 260                 BT_ERR("le_adv_slot is NULL");
 261                 return -1;
 262         }
 263
 264         BT_DBG("adv_inst_max : %d", le_feature_info.adv_inst_max);
 265
 266         for (i = 0; i < le_feature_info.adv_inst_max; i++) {
 267                 if (le_adv_slot[i].sender == NULL)
 268                         continue;
 269                 if ((g_strcmp0(le_adv_slot[i].sender, sender) == 0) && (le_adv_slot[i].adv_handle == adv_handle))
 270                         return i;
 271         }
 272
 273         if (le_feature_info.adv_inst_max <= 1)
 274                 i = 0;
 275         else if (use_reserved_slot == TRUE)
 276                 i = 1;
 277         else
 278                 i = 2;
 279
 280         for (; i < le_feature_info.adv_inst_max; i++) {
 281                 if (le_adv_slot[i].sender == NULL)
 282                         return i;
 283         }
 284
 285         return -1;
 286 }
 287
 288 static void __bt_register_adv_slot_owner(const char *sender, int adv_handle, int slot_id)
 289 {
 290         if (le_adv_slot[slot_id].sender == NULL) {
 291                 le_adv_slot[slot_id].sender = strdup(sender);
 292                 le_adv_slot[slot_id].adv_handle = adv_handle;
 293         }
 294 }
 295
 296 void _bt_unregister_adv_slot_owner(int slot_id)
 297 {
 298         if (le_adv_slot[slot_id].hold_timer_id > 0) {
 299                 BT_INFO("Hold state adv is not unregistered");
 300                 return;
 301         }
 302
 303         g_free(le_adv_slot[slot_id].sender);
 304         le_adv_slot[slot_id].sender = NULL;
 305         le_adv_slot[slot_id].adv_handle = 0;
 306 }
 307
 308 const char* _bt_get_adv_slot_owner(int slot_id)
 309 {
 310         if (le_adv_slot == NULL)
 311                 return NULL;
 312
 313         return le_adv_slot[slot_id].sender;
 314 }
 315
 316 int _bt_get_adv_slot_adv_handle(int slot_id)
 317 {
 318         if (le_adv_slot == NULL)
 319                 return 0;
 320
 321         return le_adv_slot[slot_id].adv_handle;
 322 }
 323
 324 void _bt_set_advertising_status(int slot_id, gboolean mode)
 325 {
 326         le_adv_slot[slot_id].is_advertising = mode;
 327 }
 328
 329 gboolean _bt_is_advertising(void)
 330 {
 331         gboolean status = FALSE;
 332         int i;
 333
 334         if (le_adv_slot == NULL)
 335                 return FALSE;
 336
 337         for (i = 0; i < le_feature_info.adv_inst_max; i++) {
 338                 if (le_adv_slot[i].is_advertising == TRUE)
 339                         status = TRUE;
 340         }
 341
 342         return status;
 343 }
 344
 345 void _bt_stop_advertising_by_terminated_process(const char* terminated_name)
 346 {
 347         int i;
 348
 349         if (le_adv_slot == NULL)
 350                 return;
 351
 352         for (i = 0; i < le_feature_info.adv_inst_max; i++) {
 353                 if (le_adv_slot[i].sender != NULL) {
 354                         if (strcasecmp(terminated_name, le_adv_slot[i].sender) == 0) {
 355                                 BT_ERR("Stop advertising by terminated process(%s).", terminated_name);
 356                                 _bt_set_advertising(terminated_name, le_adv_slot[i].adv_handle, FALSE, FALSE);
 357                         }
 358                 }
 359         }
 360 }
 361
 362 gboolean _bt_get_advertising_params(bluetooth_advertising_params_t *params)
 363 {
 364         if (params == NULL)
 365                 return FALSE;
 366
 367         memcpy(params, &adv_params, sizeof(bluetooth_advertising_params_t));
 368
 369         return TRUE;
 370 }
 371
 372 int _bt_set_advertising(const char *sender, int adv_handle, gboolean enable, gboolean use_reserved_slot)
 373 {
 374         GDBusProxy *proxy;
 375         GError *error = NULL;
 376         GVariant *ret;
 377         int slot_id;
 378
 379         if (__bt_is_factory_test_mode()) {
 380                 BT_ERR("Unable to start advertising in factory binary !!");
 381                 return BLUETOOTH_ERROR_NOT_SUPPORT;
 382         }
 383
 384         if (_bt_adapter_get_status() != BT_ACTIVATED &&
 385                 _bt_adapter_get_le_status() != BT_LE_ACTIVATED) {
 386                 return BLUETOOTH_ERROR_DEVICE_NOT_ENABLED;
 387         }
 388
 389         slot_id = __bt_get_available_adv_slot_id(sender, adv_handle, use_reserved_slot);
 390         if (slot_id == -1) {
 391                 BT_ERR("There is NO available slot!!");
 392                 return BLUETOOTH_ERROR_NO_RESOURCES;
 393         }
 394
 395         if (le_adv_slot[slot_id].is_advertising == TRUE && enable == TRUE)
 396                 return BLUETOOTH_ERROR_IN_PROGRESS;
 397
 398         if (le_adv_slot[slot_id].hold_timer_id > 0) {
 399                 g_source_remove(le_adv_slot[slot_id].hold_timer_id);
 400                 le_adv_slot[slot_id].hold_timer_id = 0;
 401                 _bt_unregister_adv_slot_owner(slot_id);
 402         }
 403
 404         if (le_adv_slot[slot_id].is_advertising == FALSE && enable == FALSE)
 405                 return BLUETOOTH_ERROR_NOT_IN_OPERATION;
 406
 407         proxy = _bt_get_adapter_proxy();
 408         retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
 409
 410         ret = g_dbus_proxy_call_sync(proxy, "SetAdvertising",
 411                                 g_variant_new("(bi)", enable, slot_id),
 412                                 G_DBUS_CALL_FLAGS_NONE,
 413                                 -1,
 414                                 NULL,
 415                                 &error);
 416
 417         if (error) {
 418                 BT_ERR("SetAdvertising Fail: %s", error->message);
 419                 g_clear_error(&error);
 420                 return BLUETOOTH_ERROR_INTERNAL;
 421         }
 422
 423         if (enable == TRUE)
 424                 __bt_register_adv_slot_owner(sender, adv_handle, slot_id);
 425
 426         le_adv_slot[slot_id].is_advertising = enable;
 427         BT_INFO_C("### Set advertising [%d], Slot id [%d]", enable, slot_id);
 428
 429         if (ret)
 430                 g_variant_unref(ret);
 431
 432         return BLUETOOTH_ERROR_NONE;
 433 }
 434
 435 int _bt_set_custom_advertising(const char *sender, int adv_handle,
 436                                 gboolean enable, bluetooth_advertising_params_t *params, gboolean use_reserved_slot)
 437 {
 438         GDBusProxy *proxy;
 439         GVariant *ret;
 440         GError *error = NULL;
 441         guint32 min = 0;
 442         guint32 max = 0;
 443         int slot_id;
 444
 445         BT_CHECK_PARAMETER(params, return);
 446
 447         if (__bt_is_factory_test_mode()) {
 448                 BT_ERR("Unable to start advertising in factory binary !!");
 449                 return BLUETOOTH_ERROR_NOT_SUPPORT;
 450         }
 451
 452         if (_bt_adapter_get_status() != BT_ACTIVATED &&
 453                 _bt_adapter_get_le_status() != BT_LE_ACTIVATED) {
 454                 return BLUETOOTH_ERROR_DEVICE_NOT_ENABLED;
 455         }
 456
 457         slot_id = __bt_get_available_adv_slot_id(sender, adv_handle, use_reserved_slot);
 458         if (slot_id == -1) {
 459                 BT_ERR("There is NO available slot!!");
 460                 return BLUETOOTH_ERROR_NO_RESOURCES;
 461         }
 462
 463         if (le_adv_slot[slot_id].is_advertising == TRUE && enable == TRUE)
 464                 return BLUETOOTH_ERROR_IN_PROGRESS;
 465
 466         if (le_adv_slot[slot_id].hold_timer_id > 0) {
 467                 g_source_remove(le_adv_slot[slot_id].hold_timer_id);
 468                 le_adv_slot[slot_id].hold_timer_id = 0;
 469                 _bt_unregister_adv_slot_owner(slot_id);
 470         }
 471
 472         if (le_adv_slot[slot_id].is_advertising == FALSE && enable == FALSE)
 473                 return BLUETOOTH_ERROR_NOT_IN_OPERATION;
 474
 475         proxy = _bt_get_adapter_proxy();
 476         retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
 477
 478         if (params->interval_min > params->interval_max ||
 479                         params->interval_min < BT_ADV_INTERVAL_MIN ||
 480                         params->interval_max > BT_ADV_INTERVAL_MAX)
 481                 return BLUETOOTH_ERROR_INVALID_PARAM;
 482
 483         if (params->filter_policy > BLUETOOTH_ALLOW_SCAN_CONN_WHITE_LIST)
 484                 return BLUETOOTH_ERROR_INVALID_PARAM;
 485
 486         if (params->type  == BLUETOOTH_ADV_CONNECTABLE_DIRECT_HIGH ||
 487                         params->type == BLUETOOTH_ADV_CONNECTABLE_DIRECT_LOW ||
 488                         params->type == BLUETOOTH_ADV_NON_CONNECTABLE)
 489                 return BLUETOOTH_ERROR_NOT_SUPPORT;
 490
 491         if (params->tx_power_level > 1 ||
 492                         params->tx_power_level < -127)
 493                 return BLUETOOTH_ERROR_INVALID_PARAM;
 494
 495         min = params->interval_min / BT_ADV_INTERVAL_SPLIT;
 496         max = params->interval_max / BT_ADV_INTERVAL_SPLIT;
 497
 498         ret = g_dbus_proxy_call_sync(proxy, "SetAdvertisingParameters",
 499                         g_variant_new("(uuuuii)", min, max,
 500                         params->filter_policy, params->type,
 501                         params->tx_power_level, slot_id),
 502                         G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
 503
 504         if (error) {
 505                 BT_ERR("SetAdvertisingParameters Fail: %s", error->message);
 506                 g_clear_error(&error);
 507                 return BLUETOOTH_ERROR_INTERNAL;
 508         }
 509
 510         adv_params.interval_min = params->interval_min;
 511         adv_params.interval_max = params->interval_max;
 512         adv_params.filter_policy = params->filter_policy;
 513         adv_params.type = params->type;
 514         adv_params.tx_power_level = params->tx_power_level;
 515
 516         if (ret)
 517                 g_variant_unref(ret);
 518
 519         ret = g_dbus_proxy_call_sync(proxy, "SetAdvertising",
 520                                 g_variant_new("(bi)", enable, slot_id),
 521                                 G_DBUS_CALL_FLAGS_NONE,
 522                                 -1,
 523                                 NULL,
 524                                 &error);
 525
 526         if (error) {
 527                 BT_ERR("SetAdvertising Fail: %s", error->message);
 528                 g_clear_error(&error);
 529                 return BLUETOOTH_ERROR_INTERNAL;
 530         }
 531
 532         if (enable == TRUE)
 533                 __bt_register_adv_slot_owner(sender, adv_handle, slot_id);
 534
 535         le_adv_slot[slot_id].is_advertising = enable;
 536         BT_INFO_C("### Set advertising [%d], Slot id [%d]", enable, slot_id);
 537         if (ret)
 538                 g_variant_unref(ret);
 539
 540         return BLUETOOTH_ERROR_NONE;
 541 }
 542
 543 static gboolean __bt_hold_current_advertising_timeout_cb(gpointer user_data)
 544 {
 545         GDBusProxy *proxy;
 546         GError *error = NULL;
 547         GVariant *ret;
 548
 549         BT_INFO("Restart advertising stopped by bt-service");
 550
 551         le_adv_slot[0].hold_timer_id = 0;
 552
 553         proxy = _bt_get_adapter_proxy();
 554         retv_if(proxy == NULL, FALSE);
 555
 556         ret = g_dbus_proxy_call_sync(proxy, "SetAdvertising",
 557                                 g_variant_new("(bi)", TRUE, 0),
 558                                 G_DBUS_CALL_FLAGS_NONE,
 559                                 -1,
 560                                 NULL,
 561                                 &error);
 562
 563         if (error) {
 564                 BT_ERR("SetAdvertising Fail: %s", error->message);
 565                 g_clear_error(&error);
 566                 return FALSE;
 567         }
 568
 569         if (ret)
 570                 g_variant_unref(ret);
 571
 572         return FALSE;
 573 }
 574
 575 int _bt_hold_current_advertising(void)
 576 {
 577         GDBusProxy *proxy;
 578         GError *error = NULL;
 579         GVariant *ret;
 580
 581         if (le_adv_slot[0].sender && le_adv_slot[0].is_advertising == TRUE) {
 582                 BT_INFO("Stop current advertising by bt-service");
 583
 584                 proxy = _bt_get_adapter_proxy();
 585                 retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
 586
 587                 ret = g_dbus_proxy_call_sync(proxy, "SetAdvertising",
 588                                         g_variant_new("(bi)", FALSE, 0),
 589                                         G_DBUS_CALL_FLAGS_NONE,
 590                                         -1,
 591                                         NULL,
 592                                         &error);
 593
 594                 if (error) {
 595                         BT_ERR("SetAdvertising Fail: %s", error->message);
 596                         g_clear_error(&error);
 597                         return BLUETOOTH_ERROR_INTERNAL;
 598                 }
 599
 600                 if (ret)
 601                         g_variant_unref(ret);
 602
 603                 le_adv_slot[0].hold_timer_id = g_timeout_add(2000,
 604                                 __bt_hold_current_advertising_timeout_cb, NULL);
 605         } else {
 606                 BT_INFO("It's NOT advertising");
 607                 return BLUETOOTH_ERROR_NOT_IN_OPERATION;
 608         }
 609
 610         return BLUETOOTH_ERROR_NONE;
 611 }
 612
 613 static int __bt_get_ad_data_by_type(char *in_data, int in_len,
 614                 char in_type, char **data, int *data_len)
 615 {
 616         if (in_data == NULL || data == NULL || data_len == NULL)
 617                 return BLUETOOTH_ERROR_INTERNAL;
 618
 619         if (in_len < 0)
 620                 return BLUETOOTH_ERROR_INTERNAL;
 621
 622         int i;
 623         int len = 0;
 624         int type = 0;
 625
 626         for (i = 0; i < in_len; i++) {
 627                 len = in_data[i];
 628                 if (len <= 0 || i + 1 >= in_len) {
 629                         BT_ERR("Invalid advertising data");
 630                         return BLUETOOTH_ERROR_INTERNAL;
 631                 }
 632
 633                 type = in_data[i + 1];
 634                 if (type == in_type) {
 635                         i = i + 2;
 636                         len--;
 637                         break;
 638                 }
 639
 640                 i += len;
 641                 len = 0;
 642         }
 643
 644         if (i + len > in_len) {
 645                 BT_ERR("Invalid advertising data");
 646                 return BLUETOOTH_ERROR_INTERNAL;
 647         } else if (len == 0) {
 648                 BT_DBG("AD Type 0x%02x data is not set", in_type);
 649                 *data = NULL;
 650                 *data_len = 0;
 651                 return BLUETOOTH_ERROR_NONE;
 652         }
 653
 654         *data = g_memdup(&in_data[i], len);
 655         if (*data == NULL)
 656                 return BLUETOOTH_ERROR_OUT_OF_MEMORY;
 657         *data_len = len;
 658
 659         return BLUETOOTH_ERROR_NONE;
 660 }
 661
 662 int _bt_get_advertising_data(bluetooth_advertising_data_t *adv, int *length)
 663 {
 664         BT_CHECK_PARAMETER(adv, return);
 665         BT_CHECK_PARAMETER(length, return);
 666
 667         memcpy(adv, &adv_data, sizeof(adv_data));
 668         *length = adv_data_len;
 669
 670         return BLUETOOTH_ERROR_NONE;
 671 }
 672
 673 int _bt_set_advertising_data(const char *sender, int adv_handle,
 674                                 bluetooth_advertising_data_t *adv, int length, gboolean use_reserved_slot)
 675 {
 676         GDBusProxy *proxy;
 677         GError *error = NULL;
 678         GVariant *ret, *ad_data, *param = NULL;
 679         GVariant *temp = NULL;
 680         GVariantBuilder *builder;
 681         int i;
 682         char *old_mdata = NULL;
 683         char *new_mdata = NULL;
 684         int old_len = 0;
 685         int new_len = 0;
 686         int slot_id;
 687
 688         if (__bt_is_factory_test_mode()) {
 689                 BT_ERR("Unable to set advertising data in factory binary !!");
 690                 return BLUETOOTH_ERROR_NOT_SUPPORT;
 691         }
 692
 693         BT_CHECK_PARAMETER(adv, return);
 694
 695         if (_bt_adapter_get_status() != BT_ACTIVATED &&
 696                 _bt_adapter_get_le_status() != BT_LE_ACTIVATED) {
 697                 return BLUETOOTH_ERROR_DEVICE_NOT_ENABLED;
 698         }
 699
 700         proxy = _bt_get_adapter_proxy();
 701         retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
 702
 703         slot_id = __bt_get_available_adv_slot_id(sender, adv_handle, use_reserved_slot);
 704         if (slot_id == -1) {
 705                 BT_ERR("There is NO available slot!!");
 706                 return BLUETOOTH_ERROR_NO_RESOURCES;
 707         }
 708
 709         builder = g_variant_builder_new(G_VARIANT_TYPE("ay"));
 710         for (i = 0; i < length; i++)
 711                 g_variant_builder_add(builder, "y", adv->data[i]);
 712
 713         temp = g_variant_new("ay", builder);
 714         g_variant_builder_unref(builder);
 715         ret = g_dbus_proxy_call_sync(proxy, "SetAdvertisingData",
 716                                 g_variant_new("(@ayi)", temp, slot_id),
 717                                 G_DBUS_CALL_FLAGS_NONE,
 718                                 -1, NULL, &error);
 719
 720         if (error) {
 721                 BT_ERR("SetAdvertisingData Fail: %s", error->message);
 722                 g_clear_error(&error);
 723                 return BLUETOOTH_ERROR_INTERNAL;
 724         }
 725
 726         __bt_register_adv_slot_owner(sender, adv_handle, slot_id);
 727
 728         __bt_get_ad_data_by_type((char *)adv_data.data, adv_data_len, 0xff,
 729                         &old_mdata, &old_len);
 730         __bt_get_ad_data_by_type((char *)adv->data, length, 0xff,
 731                         &new_mdata, &new_len);
 732         if (old_len != new_len ||
 733                         (old_mdata && new_mdata &&
 734                          memcmp(old_mdata, new_mdata, new_len))) {
 735                 ad_data = g_variant_new_from_data((const GVariantType *)"ay",
 736                                 new_mdata, new_len, TRUE, NULL, NULL);
 737                 param = g_variant_new("(@ay)", ad_data);
 738                 _bt_send_event(BT_ADAPTER_EVENT,
 739                                 BLUETOOTH_EVENT_ADVERTISING_MANUFACTURER_DATA_CHANGED,
 740                                 param);
 741         }
 742         g_free(new_mdata);
 743         g_free(old_mdata);
 744
 745         memset(&adv_data, 0x00, sizeof(bluetooth_advertising_data_t));
 746         memcpy(&adv_data, adv, length);
 747         adv_data_len = length;
 748
 749         BT_INFO("Set advertising data");
 750         if (ret)
 751                 g_variant_unref(ret);
 752
 753         return BLUETOOTH_ERROR_NONE;
 754 }
 755
 756 int _bt_get_scan_response_data(bluetooth_scan_resp_data_t *response, int *length)
 757 {
 758         BT_CHECK_PARAMETER(response, return);
 759         BT_CHECK_PARAMETER(length, return);
 760
 761         memcpy(response, &resp_data, sizeof(resp_data));
 762         *length = resp_data_len;
 763
 764         return BLUETOOTH_ERROR_NONE;
 765 }
 766
 767 int _bt_set_scan_response_data(const char *sender, int adv_handle,
 768                                 bluetooth_scan_resp_data_t *response, int length, gboolean use_reserved_slot)
 769 {
 770         GDBusProxy *proxy;
 771         GError *error = NULL;
 772         GVariant *ret, *scan_data,  *param = NULL;
 773         GVariant *temp = NULL;
 774         GVariantBuilder *builder;
 775         int i;
 776         char *old_mdata = NULL;
 777         char *new_mdata = NULL;
 778         int old_len = 0;
 779         int new_len = 0;
 780         int slot_id;
 781
 782         if (__bt_is_factory_test_mode()) {
 783                 BT_ERR("Unable to set scan response list in factory binary !!");
 784                 return BLUETOOTH_ERROR_NOT_SUPPORT;
 785         }
 786
 787         BT_CHECK_PARAMETER(response, return);
 788
 789         if (_bt_adapter_get_status() != BT_ACTIVATED &&
 790                 _bt_adapter_get_le_status() != BT_LE_ACTIVATED) {
 791                 return BLUETOOTH_ERROR_DEVICE_NOT_ENABLED;
 792         }
 793
 794         proxy = _bt_get_adapter_proxy();
 795         retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
 796
 797         slot_id = __bt_get_available_adv_slot_id(sender, adv_handle, use_reserved_slot);
 798         if (slot_id == -1) {
 799                 BT_ERR("There is NO available slot!!");
 800                 return BLUETOOTH_ERROR_NO_RESOURCES;
 801         }
 802         builder = g_variant_builder_new(G_VARIANT_TYPE("ay"));
 803         for (i = 0; i < length; i++)
 804                 g_variant_builder_add(builder, "y", response->data[i]);
 805
 806         temp = g_variant_new("ay", builder);
 807         g_variant_builder_unref(builder);
 808         ret = g_dbus_proxy_call_sync(proxy, "SetScanRespData",
 809                                 g_variant_new("(@ayi)", temp, slot_id),
 810                                 G_DBUS_CALL_FLAGS_NONE,
 811                                 -1, NULL, &error);
 812
 813         if (error) {
 814                 BT_ERR("SetScanRespData Fail: %s", error->message);
 815                 g_clear_error(&error);
 816                 return BLUETOOTH_ERROR_INTERNAL;
 817         }
 818
 819         __bt_register_adv_slot_owner(sender, adv_handle, slot_id);
 820
 821         /* Compare with previous scan resp data */
 822         __bt_get_ad_data_by_type((char *)resp_data.data, resp_data_len, 0xff,
 823                         &old_mdata, &old_len);
 824         __bt_get_ad_data_by_type((char *)response->data, length, 0xff,
 825                         &new_mdata, &new_len);
 826         if (old_len != new_len ||
 827                         (old_mdata && new_mdata &&
 828                          memcmp(old_mdata, new_mdata, new_len))) {
 829                 scan_data = g_variant_new_from_data((const GVariantType *)"ay",
 830                                         new_mdata, new_len, TRUE, NULL, NULL);
 831                 param = g_variant_new("(@ay)", scan_data);
 832                 _bt_send_event(BT_ADAPTER_EVENT,
 833                                 BLUETOOTH_EVENT_SCAN_RESPONSE_MANUFACTURER_DATA_CHANGED,
 834                                 param);
 835         }
 836         g_free(new_mdata);
 837         g_free(old_mdata);
 838
 839         memset(&resp_data, 0x00, sizeof(bluetooth_scan_resp_data_t));
 840         memcpy(&resp_data, response, length);
 841         resp_data_len = length;
 842
 843         if (ret)
 844                 g_variant_unref(ret);
 845         BT_INFO("Set scan response data");
 846         return BLUETOOTH_ERROR_NONE;
 847 }
 848
 849 int _bt_set_scan_parameters(bluetooth_le_scan_params_t *params)
 850 {
 851         GDBusProxy *proxy;
 852         GError *error = NULL;
 853         GVariant *ret;
 854         guint32 itv = 0;
 855         guint32 win = 0;
 856
 857         BT_CHECK_PARAMETER(params, return);
 858
 859         if (_bt_adapter_get_status() != BT_ACTIVATED &&
 860                 _bt_adapter_get_le_status() != BT_LE_ACTIVATED) {
 861                 return BLUETOOTH_ERROR_DEVICE_NOT_ENABLED;
 862         }
 863
 864         proxy = _bt_get_adapter_proxy();
 865         retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
 866
 867         if (params->interval < BT_LE_SCAN_INTERVAL_MIN || params->interval > BT_LE_SCAN_INTERVAL_MAX)
 868                 return BLUETOOTH_ERROR_INVALID_PARAM;
 869
 870         if (params->window < BT_LE_SCAN_WINDOW_MIN || params->window > BT_LE_SCAN_WINDOW_MAX)
 871                 return BLUETOOTH_ERROR_INVALID_PARAM;
 872
 873         if (params->window > params->interval)
 874                 return BLUETOOTH_ERROR_INVALID_PARAM;
 875
 876         itv = params->interval / BT_ADV_INTERVAL_SPLIT;
 877         win = params->window / BT_ADV_INTERVAL_SPLIT;
 878
 879         ret = g_dbus_proxy_call_sync(proxy, "SetScanParameters",
 880                         g_variant_new("(uuu)", params->type, itv, win),
 881                         G_DBUS_CALL_FLAGS_NONE, -1,
 882                         NULL, &error);
 883
 884         if (error) {
 885                 BT_ERR("SetScanParameters Fail: %s", error->message);
 886                 g_clear_error(&error);
 887                 return BLUETOOTH_ERROR_INTERNAL;
 888         }
 889
 890         _bt_set_le_scan_type(params->type);
 891
 892         is_le_set_scan_parameter = TRUE;
 893
 894         if (ret)
 895                 g_variant_unref(ret);
 896         BT_INFO("Set scan parameters");
 897         return BLUETOOTH_ERROR_NONE;
 898 }
 899
 900 bt_adapter_le_scanner_t* __bt_find_scanner_from_list(const char *sender)
 901 {
 902         GSList *l;
 903         bt_adapter_le_scanner_t *scanner;
 904
 905         for (l = scanner_list; l != NULL; l = g_slist_next(l)) {
 906                 scanner = l->data;
 907                 if (g_strcmp0(scanner->sender, sender) == 0)
 908                         return scanner;
 909         }
 910
 911         return NULL;
 912 }
 913
 914 int __bt_get_available_scan_filter_slot_id(void)
 915 {
 916         GSList *l;
 917         bt_adapter_le_scanner_t *scanner;
 918         GSList *fl;
 919         bluetooth_le_scan_filter_t *filter_data;
 920         gboolean *slot_check_list = NULL;
 921         int i;
 922
 923         if (le_feature_info.max_filter == 0) {
 924                 BT_ERR("Scan filter is NOT Supported");
 925                 return -1;
 926         }
 927         slot_check_list = g_malloc0(sizeof(gboolean) * le_feature_info.max_filter);
 928
 929         for (l = scanner_list; l != NULL; l = g_slist_next(l)) {
 930                 scanner = l->data;
 931                 for (fl = scanner->filter_list; fl != NULL; fl = g_slist_next(fl)) {
 932                         filter_data = fl->data;
 933                         if (filter_data->slot_id < le_feature_info.max_filter)
 934                                 slot_check_list[filter_data->slot_id] = TRUE;
 935                 }
 936         }
 937
 938         for (i = 0; i < le_feature_info.max_filter; i++) {
 939                 if (slot_check_list[i] == FALSE) {
 940                         g_free(slot_check_list);
 941                         return i;
 942                 }
 943         }
 944
 945         BT_ERR("There is NO available slot for scan filter.");
 946         g_free(slot_check_list);
 947         return -1;
 948 }
 949
 950 gboolean _bt_is_scan_filter_supported(void)
 951 {
 952         if (le_feature_info.max_filter > 0)
 953                 return TRUE;
 954
 955         return FALSE;
 956 }
 957
 958 int _bt_register_scan_filter(const char *sender, bluetooth_le_scan_filter_t *filter, int *slot_id)
 959 {
 960         GDBusProxy *proxy;
 961         GError *error = NULL;
 962         GVariant *ret, *param;
 963         GVariant *arr_uuid_param = NULL, *arr_uuid_mask_param = NULL;
 964         GVariant *arr_data_param = NULL, *arr_data_mask_param = NULL;
 965         GArray *arr_uuid = NULL;
 966         GArray *arr_uuid_mask = NULL;
 967         GArray *arr_data = NULL;
 968         GArray *arr_data_mask = NULL;
 969         bt_adapter_le_scanner_t *scanner = NULL;
 970         bluetooth_le_scan_filter_t *filter_data = NULL;
 971         int feature_selection = 0;
 972
 973         *slot_id = __bt_get_available_scan_filter_slot_id();
 974         if (*slot_id == -1)
 975                 return BLUETOOTH_ERROR_NO_RESOURCES;
 976
 977         proxy = _bt_get_adapter_proxy();
 978         retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
 979
 980         if (filter->added_features & BLUETOOTH_LE_SCAN_FILTER_FEATURE_DEVICE_ADDRESS) {
 981                 char address[BT_ADDRESS_STRING_SIZE] = { 0 };
 982                 feature_selection |= BLUETOOTH_LE_SCAN_FILTER_FEATURE_DEVICE_ADDRESS;
 983
 984                 _bt_convert_addr_type_to_string(address, filter->device_address.addr);
 985
 986                 arr_uuid_param = g_variant_new_from_data((const GVariantType *)"ay",
 987                                                                                         NULL, 0, TRUE, NULL, NULL);
 988                 arr_uuid_mask_param = g_variant_new_from_data((const GVariantType *)"ay",
 989                                                                                         NULL, 0, TRUE, NULL, NULL);
 990                 arr_data_param = g_variant_new_from_data((const GVariantType *)"ay",
 991                                                                                         NULL, 0, TRUE, NULL, NULL);
 992                 arr_data_mask_param = g_variant_new_from_data((const GVariantType *)"ay",
 993                                                                                         NULL, 0, TRUE, NULL, NULL);
 994
 995                 param = g_variant_new("(iiiiii@ay@aysu@ay@ay)",
 996                                         0,      // client_if
 997                                         0,      // action (Add - 0x00, Delete - 0x01, Clear - 0x02)
 998                                         BLUETOOTH_LE_SCAN_FILTER_FEATURE_DEVICE_ADDRESS,        // filter_type
 999                                         *slot_id,       // filter_index
1000                                         0,      // company_id
1001                                         0,      // company_id_mask
1002                                         arr_uuid_param, // p_uuid
1003                                         arr_uuid_mask_param,    // p_uuid_mask
1004                                         address,        // string
1005                                         0,      // address_type
1006                                         arr_data_param, // p_data
1007                                         arr_data_mask_param);   // p_mask
1008
1009                 ret = g_dbus_proxy_call_sync(proxy, "scan_filter_add_remove",
1010                                                         param, G_DBUS_CALL_FLAGS_NONE,
1011                                                         -1, NULL, &error);
1012
1013                 if (error) {
1014                         BT_ERR("scan_filter_add_remove Fail: %s", error->message);
1015                         g_clear_error(&error);
1016                 }
1017                 if (ret)
1018                         g_variant_unref(ret);
1019         }
1020
1021         if (filter->added_features & BLUETOOTH_LE_SCAN_FILTER_FEATURE_DEVICE_NAME) {
1022                 feature_selection |= BLUETOOTH_LE_SCAN_FILTER_FEATURE_DEVICE_NAME;
1023
1024                 arr_uuid_param = g_variant_new_from_data((const GVariantType *)"ay",
1025                                                                                         NULL, 0, TRUE, NULL, NULL);
1026                 arr_uuid_mask_param = g_variant_new_from_data((const GVariantType *)"ay",
1027                                                                                         NULL, 0, TRUE, NULL, NULL);
1028                 arr_data_param = g_variant_new_from_data((const GVariantType *)"ay",
1029                                                                                         NULL, 0, TRUE, NULL, NULL);
1030                 arr_data_mask_param = g_variant_new_from_data((const GVariantType *)"ay",
1031                                                                                         NULL, 0, TRUE, NULL, NULL);
1032
1033                 param = g_variant_new("(iiiiii@ay@aysu@ay@ay)",
1034                                         0,      // client_if
1035                                         0,      // action (Add - 0x00, Delete - 0x01, Clear - 0x02)
1036                                         BLUETOOTH_LE_SCAN_FILTER_FEATURE_DEVICE_NAME,   // filter_type
1037                                         *slot_id,       // filter_index
1038                                         0,      // company_id
1039                                         0,      // company_id_mask
1040                                         arr_uuid_param, // p_uuid
1041                                         arr_uuid_mask_param,    // p_uuid_mask
1042                                         filter->device_name,    // string
1043                                         0,      // address_type
1044                                         arr_data_param, // p_data
1045                                         arr_data_mask_param);
1046
1047                 ret = g_dbus_proxy_call_sync(proxy, "scan_filter_add_remove",
1048                                                 param, G_DBUS_CALL_FLAGS_NONE,
1049                                                 -1, NULL, &error);
1050
1051                 if (error) {
1052                         BT_ERR("scan_filter_add_remove Fail: %s", error->message);
1053                         g_clear_error(&error);
1054                 }
1055                 if (ret)
1056                         g_variant_unref(ret);
1057         }
1058
1059         if (filter->added_features & BLUETOOTH_LE_SCAN_FILTER_FEATURE_SERVICE_UUID) {
1060                 feature_selection |= BLUETOOTH_LE_SCAN_FILTER_FEATURE_SERVICE_UUID;
1061
1062                 arr_uuid = g_array_new(TRUE, TRUE, sizeof(guint8));
1063                 arr_uuid_mask = g_array_new(TRUE, TRUE, sizeof(guint8));
1064
1065                 g_array_append_vals(arr_uuid, filter->service_uuid.data.data, filter->service_uuid.data_len * sizeof(guint8));
1066                 g_array_append_vals(arr_uuid_mask, filter->service_uuid_mask.data.data, filter->service_uuid_mask.data_len * sizeof(guint8));
1067
1068                 arr_uuid_param = g_variant_new_from_data((const GVariantType *)"ay",
1069                                                         arr_uuid->data, arr_uuid->len, TRUE, NULL, NULL);
1070                 arr_uuid_mask_param = g_variant_new_from_data((const GVariantType *)"ay",
1071                                                         arr_uuid_mask->data, arr_uuid_mask->len, TRUE, NULL, NULL);
1072                 arr_data_param = g_variant_new_from_data((const GVariantType *)"ay",
1073                                                                                         NULL, 0, TRUE, NULL, NULL);
1074                 arr_data_mask_param = g_variant_new_from_data((const GVariantType *)"ay",
1075                                                                                         NULL, 0, TRUE, NULL, NULL);
1076
1077                 param = g_variant_new("(iiiiii@ay@aysu@ay@ay)",
1078                                         0,      // client_if
1079                                         0,      // action (Add - 0x00, Delete - 0x01, Clear - 0x02)
1080                                         BLUETOOTH_LE_SCAN_FILTER_FEATURE_SERVICE_UUID,  // filter_type
1081                                         *slot_id,       // filter_index
1082                                         0,      // company_id
1083                                         0,      // company_id_mask
1084                                         arr_uuid_param, // p_uuid
1085                                         arr_uuid_mask_param,    // p_uuid_mask
1086                                         NULL,   // string
1087                                         0,      // address_type
1088                                         arr_data_param, // p_data
1089                                         arr_data_mask_param);
1090
1091                 ret = g_dbus_proxy_call_sync(proxy, "scan_filter_add_remove",
1092                                                 param, G_DBUS_CALL_FLAGS_NONE,
1093                                                 -1, NULL, &error);
1094
1095                 if (error) {
1096                         BT_ERR("scan_filter_add_remove Fail: %s", error->message);
1097                         g_clear_error(&error);
1098                 }
1099                 if (ret)
1100                         g_variant_unref(ret);
1101
1102                 g_array_free(arr_uuid, TRUE);
1103                 g_array_free(arr_uuid_mask, TRUE);
1104         }
1105
1106         if (filter->added_features & BLUETOOTH_LE_SCAN_FILTER_FEATURE_SERVICE_SOLICITATION_UUID) {
1107                 feature_selection |= BLUETOOTH_LE_SCAN_FILTER_FEATURE_SERVICE_SOLICITATION_UUID;
1108
1109                 arr_uuid = g_array_new(TRUE, TRUE, sizeof(guint8));
1110                 arr_uuid_mask = g_array_new(TRUE, TRUE, sizeof(guint8));
1111
1112                 g_array_append_vals(arr_uuid, filter->service_solicitation_uuid.data.data, filter->service_solicitation_uuid.data_len * sizeof(guint8));
1113                 g_array_append_vals(arr_uuid_mask, filter->service_solicitation_uuid_mask.data.data, filter->service_solicitation_uuid_mask.data_len * sizeof(guint8));
1114
1115                 arr_uuid_param = g_variant_new_from_data((const GVariantType *)"ay",
1116                                                         arr_uuid->data, arr_uuid->len, TRUE, NULL, NULL);
1117                 arr_uuid_mask_param = g_variant_new_from_data((const GVariantType *)"ay",
1118                                                         arr_uuid_mask->data, arr_uuid_mask->len, TRUE, NULL, NULL);
1119                 arr_data_param = g_variant_new_from_data((const GVariantType *)"ay",
1120                                                                                         NULL, 0, TRUE, NULL, NULL);
1121                 arr_data_mask_param = g_variant_new_from_data((const GVariantType *)"ay",
1122                                                                                         NULL, 0, TRUE, NULL, NULL);
1123
1124                 param = g_variant_new("(iiiiii@ay@aysu@ay@ay)",
1125                                         0,      // client_if
1126                                         0,      // action (Add - 0x00, Delete - 0x01, Clear - 0x02)
1127                                         BLUETOOTH_LE_SCAN_FILTER_FEATURE_SERVICE_SOLICITATION_UUID,     // filter_type
1128                                         *slot_id,       // filter_index
1129                                         0,      // company_id
1130                                         0,      // company_id_mask
1131                                         arr_uuid_param, // p_uuid
1132                                         arr_uuid_mask_param,    // p_uuid_mask
1133                                         NULL,   // string
1134                                         0,      // address_type
1135                                         arr_data_param, // p_data
1136                                         arr_data_mask_param);
1137
1138                 ret = g_dbus_proxy_call_sync(proxy, "scan_filter_add_remove", param,
1139                                 G_DBUS_CALL_FLAGS_NONE,
1140                                 -1, NULL, &error);
1141
1142                 if (error) {
1143                         BT_ERR("scan_filter_add_remove Fail: %s", error->message);
1144                         g_clear_error(&error);
1145                 }
1146                 if (ret)
1147                         g_variant_unref(ret);
1148
1149                 g_array_free(arr_uuid, TRUE);
1150                 g_array_free(arr_uuid_mask, TRUE);
1151         }
1152
1153         if (filter->added_features & BLUETOOTH_LE_SCAN_FILTER_FEATURE_SERVICE_DATA) {
1154                 feature_selection |= BLUETOOTH_LE_SCAN_FILTER_FEATURE_SERVICE_DATA;
1155
1156                 arr_data = g_array_new(TRUE, TRUE, sizeof(guint8));
1157                 arr_data_mask = g_array_new(TRUE, TRUE, sizeof(guint8));
1158
1159                 g_array_append_vals(arr_data, filter->service_data.data.data, filter->service_data.data_len * sizeof(guint8));
1160                 g_array_append_vals(arr_data_mask, filter->service_data_mask.data.data, filter->service_data_mask.data_len * sizeof(guint8));
1161
1162                 arr_uuid_param = g_variant_new_from_data((const GVariantType *)"ay",
1163                                                                                         NULL, 0, TRUE, NULL, NULL);
1164                 arr_uuid_mask_param = g_variant_new_from_data((const GVariantType *)"ay",
1165                                                                                         NULL, 0, TRUE, NULL, NULL);
1166                 arr_data_param = g_variant_new_from_data((const GVariantType *)"ay",
1167                                                         arr_data->data, arr_data->len, TRUE, NULL, NULL);
1168                 arr_data_mask_param = g_variant_new_from_data((const GVariantType *)"ay",
1169                                                         arr_data_mask->data, arr_data_mask->len, TRUE, NULL, NULL);
1170
1171                 param = g_variant_new("(iiiiii@ay@aysu@ay@ay)",
1172                                         0,      // client_if
1173                                         0,      // action (Add - 0x00, Delete - 0x01, Clear - 0x02)
1174                                         BLUETOOTH_LE_SCAN_FILTER_FEATURE_SERVICE_DATA,  // filter_type
1175                                         *slot_id,       // filter_index
1176                                         0,      // company_id
1177                                         0,      // company_id_mask
1178                                         arr_uuid_param, // p_uuid
1179                                         arr_uuid_mask_param,    // p_uuid_mask
1180                                         NULL,   // string
1181                                         0,      // address_type
1182                                         arr_data_param, // p_data
1183                                         arr_data_mask_param);
1184
1185                 ret = g_dbus_proxy_call_sync(proxy, "scan_filter_add_remove", param,
1186                                 G_DBUS_CALL_FLAGS_NONE,
1187                                 -1, NULL, &error);
1188
1189                 if (error) {
1190                         BT_ERR("scan_filter_add_remove Fail: %s", error->message);
1191                         g_clear_error(&error);
1192                 }
1193                 if (ret)
1194                         g_variant_unref(ret);
1195
1196                 g_array_free(arr_data, TRUE);
1197                 g_array_free(arr_data_mask, TRUE);
1198         }
1199
1200         if (filter->added_features & BLUETOOTH_LE_SCAN_FILTER_FEATURE_MANUFACTURER_DATA) {
1201                 feature_selection |= BLUETOOTH_LE_SCAN_FILTER_FEATURE_MANUFACTURER_DATA;
1202
1203                 arr_data = g_array_new(TRUE, TRUE, sizeof(guint8));
1204                 arr_data_mask = g_array_new(TRUE, TRUE, sizeof(guint8));
1205
1206                 g_array_append_vals(arr_data, filter->manufacturer_data.data.data, filter->manufacturer_data.data_len * sizeof(guint8));
1207                 g_array_append_vals(arr_data_mask, filter->manufacturer_data_mask.data.data, filter->manufacturer_data_mask.data_len * sizeof(guint8));
1208
1209                 arr_uuid_param = g_variant_new_from_data((const GVariantType *)"ay",
1210                                                                                         NULL, 0, TRUE, NULL, NULL);
1211                 arr_uuid_mask_param = g_variant_new_from_data((const GVariantType *)"ay",
1212                                                                                         NULL, 0, TRUE, NULL, NULL);
1213                 arr_data_param = g_variant_new_from_data((const GVariantType *)"ay",
1214                                                         arr_data->data, arr_data->len, TRUE, NULL, NULL);
1215                 arr_data_mask_param = g_variant_new_from_data((const GVariantType *)"ay",
1216                                                         arr_data_mask->data, arr_data_mask->len, TRUE, NULL, NULL);
1217
1218                 param = g_variant_new("(iiiiii@ay@aysu@ay@ay)",
1219                                         0,      // client_if
1220                                         0,      // action (Add - 0x00, Delete - 0x01, Clear - 0x02)
1221                                         BLUETOOTH_LE_SCAN_FILTER_FEATURE_MANUFACTURER_DATA,     // filter_type
1222                                         *slot_id,       // filter_index
1223                                         filter->manufacturer_id,        // company_id
1224                                         0xFFFF, // company_id_mask
1225                                         arr_uuid_param, // p_uuid
1226                                         arr_uuid_mask_param,    // p_uuid_mask
1227                                         NULL,   // string
1228                                         0,      // address_type
1229                                         arr_data_param, // p_data
1230                                         arr_data_mask_param);
1231
1232                 ret = g_dbus_proxy_call_sync(proxy, "scan_filter_add_remove", param,
1233                                 G_DBUS_CALL_FLAGS_NONE,
1234                                 -1, NULL, &error);
1235
1236                 if (error) {
1237                         BT_ERR("scan_filter_add_remove Fail: %s", error->message);
1238                         g_clear_error(&error);
1239                 }
1240                 if (ret)
1241                         g_variant_unref(ret);
1242
1243                 g_array_free(arr_data, TRUE);
1244                 g_array_free(arr_data_mask, TRUE);
1245         }
1246
1247         BT_DBG("Filter selection %.2x", feature_selection);
1248
1249         param = g_variant_new("(iiiiiiiiiiii)",
1250                                 0,      // client_if
1251                                 0,      // action (Add - 0x00, Delete - 0x01, Clear - 0x02)
1252                                 *slot_id,       // filter_index
1253                                 feature_selection,      // feat_seln
1254                                 0,      // list_logic_type (OR - 0x00, AND - 0x01)
1255                                 1,      // filt_logic_type (OR - 0x00, AND - 0x01)
1256                                 -127,   // rssi_high_thres
1257                                 -127,   // rssi_low_thres
1258                                 0,      // dely_mode (Immediate - 0x00, on found - 0x01, batched - 0x02)
1259                                 0,      // found_timeout
1260                                 0,      // lost_timeout
1261                                 0);     // found_timeout_cnt
1262         ret = g_dbus_proxy_call_sync(proxy, "scan_filter_param_setup",
1263                                 param, G_DBUS_CALL_FLAGS_NONE,
1264                                 -1, NULL, &error);
1265
1266         if (error) {
1267                 BT_ERR("scan_filter_add_remove Fail: %s", error->message);
1268                 g_clear_error(&error);
1269         }
1270
1271         scanner = __bt_find_scanner_from_list(sender);
1272         if (scanner == NULL) {
1273                 scanner = g_malloc0(sizeof(bt_adapter_le_scanner_t));
1274                 scanner->sender = g_strdup(sender);
1275                 scanner_list = g_slist_append(scanner_list, scanner);
1276         }
1277
1278
1279         if (scanner) {
1280                 filter_data = g_malloc0(sizeof(bluetooth_le_scan_filter_t));
1281                 memcpy(filter_data, filter, sizeof(bluetooth_le_scan_filter_t));
1282                 filter_data->slot_id = *slot_id;
1283
1284                 scanner->filter_list = g_slist_append(scanner->filter_list, filter_data);
1285         }
1286
1287         if (ret)
1288                 g_variant_unref(ret);
1289         return BLUETOOTH_ERROR_NONE;
1290 }
1291
1292 int _bt_unregister_scan_filter(const char *sender, int slot_id)
1293 {
1294         GDBusProxy *proxy;
1295         GError *error = NULL;
1296         GVariant *ret;
1297         bt_adapter_le_scanner_t *scanner = NULL;
1298         bluetooth_le_scan_filter_t *filter_data = NULL;
1299         GSList *l;
1300         gboolean is_slot_id_found = FALSE;
1301
1302         scanner = __bt_find_scanner_from_list(sender);
1303         if (scanner == NULL) {
1304                 BT_ERR("There is NO available scanner.");
1305                 return BLUETOOTH_ERROR_NOT_FOUND;
1306         }
1307
1308         for (l = scanner->filter_list; l != NULL; l = g_slist_next(l)) {
1309                 filter_data = l->data;
1310                 if (filter_data->slot_id == slot_id) {
1311                         is_slot_id_found = TRUE;
1312                         break;
1313                 }
1314         }
1315         if (is_slot_id_found == FALSE) {
1316                 BT_ERR("There is NO registered slot.");
1317                 return BLUETOOTH_ERROR_NOT_FOUND;
1318         }
1319
1320         proxy = _bt_get_adapter_proxy();
1321         retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
1322
1323         ret = g_dbus_proxy_call_sync(proxy, "scan_filter_clear",
1324                                 g_variant_new("(ii)", 0, slot_id),
1325                                 G_DBUS_CALL_FLAGS_NONE,
1326                                 -1, NULL, &error);
1327
1328         if (error) {
1329                 BT_ERR("scan_filter_clear Fail: %s", error->message);
1330                 g_clear_error(&error);
1331         }
1332
1333         scanner->filter_list = g_slist_remove(scanner->filter_list, filter_data);
1334         g_free(filter_data);
1335
1336         if (ret)
1337                 g_variant_unref(ret);
1338         return BLUETOOTH_ERROR_NONE;
1339 }
1340
1341 int _bt_unregister_all_scan_filters(const char *sender)
1342 {
1343         GDBusProxy *proxy;
1344         GError *error = NULL;
1345         GVariant *ret;
1346         bt_adapter_le_scanner_t *scanner = NULL;
1347         bluetooth_le_scan_filter_t *filter_data = NULL;
1348         GSList *l;
1349
1350         scanner = __bt_find_scanner_from_list(sender);
1351         if (scanner == NULL) {
1352                 BT_ERR("There is NO available scanner.");
1353                 return BLUETOOTH_ERROR_NOT_FOUND;
1354         }
1355
1356         proxy = _bt_get_adapter_proxy();
1357         retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
1358
1359         for (l = scanner->filter_list; l != NULL; l = g_slist_next(l)) {
1360                 filter_data = l->data;
1361
1362                 ret = g_dbus_proxy_call_sync(proxy, "scan_filter_clear",
1363                                         g_variant_new("(ii)", 0, filter_data->slot_id),
1364                                         G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
1365
1366                 if (error) {
1367                         BT_ERR("scan_filter_clear Fail: %s", error->message);
1368                         g_clear_error(&error);
1369                 }
1370                 if (ret)
1371                         g_variant_unref(ret);
1372         }
1373
1374         g_slist_free_full(scanner->filter_list, g_free);
1375         scanner->filter_list = NULL;
1376
1377         return BLUETOOTH_ERROR_NONE;
1378 }
1379
1380 static gboolean __start_le_scan_timeout(gpointer user_data)
1381 {
1382         char *sender = (char *)user_data;
1383         _bt_start_le_scan(sender);
1384
1385         return FALSE;
1386 }
1387
1388
1389 int _bt_start_le_scan(const char *sender)
1390 {
1391         GDBusProxy *proxy;
1392         GError *error = NULL;
1393         GVariant *ret;
1394         bt_adapter_le_scanner_t *scanner = __bt_find_scanner_from_list(sender);
1395
1396         if (scanner == NULL) {
1397                 scanner = g_malloc0(sizeof(bt_adapter_le_scanner_t));
1398                 scanner->sender = g_strdup(sender);
1399                 scanner_list = g_slist_append(scanner_list, scanner);
1400         }
1401
1402         if (scanner->stop_pending == TRUE) {
1403                 BT_DBG("Waiting LEDiscoveryFinished");
1404                 g_timeout_add(500, (GSourceFunc)__start_le_scan_timeout, scanner->sender);
1405                 return BLUETOOTH_ERROR_NONE;
1406         }
1407
1408         if (scanner->is_scanning == TRUE) {
1409                 BT_ERR("BT is already in LE scanning");
1410                 return BLUETOOTH_ERROR_IN_PROGRESS;
1411         }
1412         scanner->is_scanning = TRUE;
1413
1414         proxy = _bt_get_adapter_proxy();
1415         retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
1416
1417         if (_bt_is_le_scanning()) {
1418                 if (scan_filter_enabled == TRUE) {
1419                         if (scanner->filter_list == NULL) {
1420                                 ret = g_dbus_proxy_call_sync(proxy, "scan_filter_enable",
1421                                                 g_variant_new("(ib)", 0, FALSE),
1422                                                 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
1423
1424                                 if (error) {
1425                                         BT_ERR("scan_filter_enable Fail: %s", error->message);
1426                                         g_clear_error(&error);
1427                                 }
1428
1429                                 if (ret)
1430                                         g_variant_unref(ret);
1431                                 BT_INFO("Disable LE Scan Filter");
1432                                 scan_filter_enabled = FALSE;
1433                         } else {
1434                                 BT_INFO("LE Filter Scan is continue");
1435                         }
1436                 } else {
1437                         BT_INFO("LE Full Scan is already on progress");
1438                 }
1439                 return BLUETOOTH_ERROR_NONE;
1440         } else {
1441                 if (is_le_set_scan_parameter == FALSE) {
1442                         /* Set default scan parameter same with BT_ADAPTER_LE_SCAN_MODE_LOW_ENERGY */
1443                         bluetooth_le_scan_params_t scan_params;
1444                         scan_params.type = BT_LE_ACTIVE_SCAN;
1445                         scan_params.interval = 5000;
1446                         scan_params.window = 500;
1447                         _bt_set_scan_parameters(&scan_params);
1448                 }
1449
1450                 if (scanner->filter_list == NULL) {
1451                         BT_INFO("Start LE Full Scan");
1452                         scan_filter_enabled = FALSE;
1453                 } else {
1454                         ret = g_dbus_proxy_call_sync(proxy, "scan_filter_enable",
1455                                         g_variant_new("(ib)", 0, TRUE),
1456                                         G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
1457
1458                         if (error) {
1459                                 BT_ERR("scan_filter_enable Fail: %s", error->message);
1460                                 g_clear_error(&error);
1461                         }
1462
1463                         if (ret)
1464                                 g_variant_unref(ret);
1465                         BT_INFO("Enable LE Scan Filter");
1466                         scan_filter_enabled = TRUE;
1467                 }
1468         }
1469
1470         ret = g_dbus_proxy_call_sync(proxy, "StartLEDiscovery",
1471                                 NULL, G_DBUS_CALL_FLAGS_NONE,
1472                                 -1, NULL, &error);
1473
1474         if (error) {
1475                 BT_ERR("StartLEDiscovery Fail: %s", error->message);
1476                 g_clear_error(&error);
1477                 return BLUETOOTH_ERROR_INTERNAL;
1478         }
1479
1480         if (ret)
1481                 g_variant_unref(ret);
1482         return BLUETOOTH_ERROR_NONE;
1483 }
1484
1485 int _bt_stop_le_scan(const char *sender)
1486 {
1487         GDBusProxy *proxy;
1488         GError *error = NULL;
1489         GVariant *ret;
1490         bt_adapter_le_scanner_t *scan_sender = __bt_find_scanner_from_list(sender);
1491         bt_adapter_le_scanner_t *scanner;
1492         GSList *l;
1493         gboolean next_scanning = FALSE;
1494         gboolean need_scan_filter = TRUE;
1495
1496         if (scan_sender == NULL || scan_sender->is_scanning == FALSE)
1497                 return BLUETOOTH_ERROR_NOT_IN_OPERATION;
1498
1499         scan_sender->is_scanning = FALSE;
1500         scan_sender->stop_pending = TRUE;
1501
1502         for (l = scanner_list; l != NULL; l = g_slist_next(l)) {
1503                 scanner = l->data;
1504                 if (scanner->is_scanning == TRUE) {
1505                         next_scanning = TRUE;
1506                         if (scanner->filter_list == NULL)
1507                                 need_scan_filter = FALSE;
1508                 }
1509         }
1510
1511         proxy = _bt_get_adapter_proxy();
1512         retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
1513
1514         if (next_scanning == TRUE) {
1515                 if (scan_filter_enabled == FALSE && need_scan_filter == TRUE) {
1516                         ret = g_dbus_proxy_call_sync(proxy, "scan_filter_enable",
1517                                         g_variant_new("(ib)", 0, TRUE),
1518                                         G_DBUS_CALL_FLAGS_NONE,
1519                                         -1, NULL, &error);
1520
1521                         if (error) {
1522                                 BT_ERR("scan_filter_enable Fail: %s", error->message);
1523                                 g_clear_error(&error);
1524                         }
1525
1526                         if (ret)
1527                                 g_variant_unref(ret);
1528                         BT_INFO("Enable LE Scan Filter");
1529                         scan_filter_enabled = TRUE;
1530                 }
1531                 BT_INFO("next_scanning exists. Keep the LE scanning");
1532                 scan_sender->stop_pending = FALSE;
1533                 return BLUETOOTH_ERROR_NONE;
1534         } else {
1535                 if (scan_filter_enabled == TRUE) {
1536                         ret = g_dbus_proxy_call_sync(proxy, "scan_filter_enable",
1537                                         g_variant_new("(ib)", 0, FALSE),
1538                                         G_DBUS_CALL_FLAGS_NONE,
1539                                         -1, NULL, &error);
1540
1541                         if (error) {
1542                                 BT_ERR("scan_filter_enable Fail: %s", error->message);
1543                                 g_clear_error(&error);
1544                         }
1545
1546                         if (ret)
1547                                 g_variant_unref(ret);
1548                         BT_INFO("Disable LE Scan Filter");
1549                 } else {
1550                         BT_INFO("Just stop LE scan");
1551                 }
1552         }
1553
1554         ret = g_dbus_proxy_call_sync(proxy, "StopLEDiscovery",
1555                                 NULL, G_DBUS_CALL_FLAGS_NONE,
1556                                 -1, NULL, &error);
1557         if (ret == NULL) {
1558                 BT_ERR("LE Scan stop failed");
1559                 return BLUETOOTH_ERROR_INTERNAL;
1560         }
1561
1562         scan_filter_enabled = FALSE;
1563         is_le_set_scan_parameter = FALSE;
1564         if (ret)
1565                 g_variant_unref(ret);
1566         return BLUETOOTH_ERROR_NONE;
1567 }
1568
1569 void _bt_disable_all_scanner_status(void)
1570 {
1571         GSList *l;
1572         bt_adapter_le_scanner_t *scanner;
1573
1574         for (l = scanner_list; l != NULL; l = g_slist_next(l)) {
1575                 scanner = l->data;
1576                 scanner->is_scanning = FALSE;
1577                 scanner->stop_pending = FALSE;
1578         }
1579 }
1580
1581 static void __bt_free_le_scanner(void)
1582 {
1583         GSList *l;
1584         bt_adapter_le_scanner_t *scanner;
1585
1586         for (l = scanner_list; l != NULL; l = g_slist_next(l)) {
1587                 scanner = l->data;
1588                 g_free(scanner->sender);
1589                 g_slist_free_full(scanner->filter_list, g_free);
1590                 g_free(scanner);
1591         }
1592
1593         g_slist_free(scanner_list);
1594         scanner_list = NULL;
1595
1596         scan_filter_enabled = FALSE;
1597         is_le_scanning = FALSE;
1598         is_le_set_scan_parameter = FALSE;
1599 }
1600
1601 void _bt_set_le_scan_status(gboolean mode)
1602 {
1603         BT_DBG("set is_le_scanning : %d -> %d", is_le_scanning, mode);
1604         is_le_scanning = mode;
1605 }
1606
1607 gboolean _bt_is_le_scanning(void)
1608 {
1609         return is_le_scanning;
1610 }
1611
1612 void _bt_set_le_scan_type(bt_le_scan_type_t type)
1613 {
1614         le_scan_type = type;
1615 }
1616
1617 bt_le_scan_type_t _bt_get_le_scan_type(void)
1618 {
1619         return le_scan_type;
1620 }
1621
1622 static gboolean __bt_check_scan_result_uuid(const char *adv_data,
1623                 int adv_data_len, const char *svc_uuid, int uuid_len,
1624                 const char *uuid_mask, char ad_type)
1625 {
1626         char *data = NULL;
1627         int data_len = 0;
1628         int i;
1629
1630         __bt_get_ad_data_by_type((char*)adv_data, adv_data_len,
1631                         ad_type, &data, &data_len);
1632         if (data != NULL) {
1633                 for (i = 0; i < data_len; i += uuid_len) {
1634                         if (uuid_len > (data_len - i))
1635                                 break;
1636
1637                         if (_bt_byte_arr_cmp_with_mask(data + i,
1638                                 svc_uuid, uuid_mask, uuid_len) == 0) {
1639                                 g_free(data);
1640                                 return TRUE;
1641                         }
1642                 }
1643                 g_free(data);
1644         }
1645
1646         return FALSE;
1647 }
1648
1649 static gboolean __bt_check_scan_result_with_filter(const char *device_address,
1650                 const char *adv_data, int adv_data_len,
1651                 const char *scan_data, int scan_data_len,
1652                 const bt_adapter_le_scanner_t *scanner)
1653 {
1654         GSList *l;
1655         bluetooth_le_scan_filter_t *filter_data = NULL;
1656         char *data = NULL;
1657         int data_len = 0;
1658         gboolean is_matched = FALSE;
1659
1660         if (scanner->filter_list == NULL) {
1661                 BT_INFO("This scanner is on Full Scan.");
1662                 return TRUE;
1663         }
1664
1665         for (l = scanner->filter_list; l != NULL; l = g_slist_next(l)) {
1666                 filter_data = l->data;
1667
1668                 if (filter_data->added_features &
1669                         BLUETOOTH_LE_SCAN_FILTER_FEATURE_DEVICE_ADDRESS) {
1670                         char address[BT_ADDRESS_STRING_SIZE] = { 0 };
1671
1672                         _bt_convert_addr_type_to_string(address,
1673                                         filter_data->device_address.addr);
1674                         if (strncmp(address, device_address,
1675                                         BT_ADDRESS_STRING_SIZE) != 0)
1676                                 continue;
1677                 }
1678
1679                 if (filter_data->added_features &
1680                         BLUETOOTH_LE_SCAN_FILTER_FEATURE_SERVICE_UUID) {
1681                         is_matched = FALSE;
1682
1683                         if (__bt_check_scan_result_uuid(adv_data,
1684                                 adv_data_len,
1685                                 (char*)filter_data->service_uuid.data.data,
1686                                 filter_data->service_uuid.data_len,
1687                                 (char*)filter_data->service_uuid_mask.data.data,
1688                                 BT_LE_AD_TYPE_INCOMP_LIST_16_BIT_SERVICE_CLASS_UUIDS)
1689                                 == TRUE)
1690                                 is_matched = TRUE;
1691                         if (__bt_check_scan_result_uuid(adv_data,
1692                                 adv_data_len,
1693                                 (char*)filter_data->service_uuid.data.data,
1694                                 filter_data->service_uuid.data_len,
1695                                 (char*)filter_data->service_uuid_mask.data.data,
1696                                 BT_LE_AD_TYPE_COMP_LIST_16_BIT_SERVICE_CLASS_UUIDS)
1697                                 == TRUE)
1698                                 is_matched = TRUE;
1699                         if (__bt_check_scan_result_uuid(adv_data,
1700                                 adv_data_len,
1701                                 (char*)filter_data->service_uuid.data.data,
1702                                 filter_data->service_uuid.data_len,
1703                                 (char*)filter_data->service_uuid_mask.data.data,
1704                                 BT_LE_AD_TYPE_INCOMP_LIST_128_BIT_SERVICE_CLASS_UUIDS)
1705                                 == TRUE)
1706                                 is_matched = TRUE;
1707                         if (__bt_check_scan_result_uuid(adv_data,
1708                                 adv_data_len,
1709                                 (char*)filter_data->service_uuid.data.data,
1710                                 filter_data->service_uuid.data_len,
1711                                 (char*)filter_data->service_uuid_mask.data.data,
1712                                 BT_LE_AD_TYPE_COMP_LIST_128_BIT_SERVICE_CLASS_UUIDS)
1713                                 == TRUE)
1714                                 is_matched = TRUE;
1715                         if (__bt_check_scan_result_uuid(scan_data,
1716                                 scan_data_len,
1717                                 (char*)filter_data->service_uuid.data.data,
1718                                 filter_data->service_uuid.data_len,
1719                                 (char*)filter_data->service_uuid_mask.data.data,
1720                                 BT_LE_AD_TYPE_INCOMP_LIST_16_BIT_SERVICE_CLASS_UUIDS)
1721                                 == TRUE)
1722                                 is_matched = TRUE;
1723                         if (__bt_check_scan_result_uuid(scan_data,
1724                                 scan_data_len,
1725                                 (char*)filter_data->service_uuid.data.data,
1726                                 filter_data->service_uuid.data_len,
1727                                 (char*)filter_data->service_uuid_mask.data.data,
1728                                 BT_LE_AD_TYPE_COMP_LIST_16_BIT_SERVICE_CLASS_UUIDS)
1729                                 == TRUE)
1730                                 is_matched = TRUE;
1731                         if (__bt_check_scan_result_uuid(scan_data,
1732                                 scan_data_len,
1733                                 (char*)filter_data->service_uuid.data.data,
1734                                 filter_data->service_uuid.data_len,
1735                                 (char*)filter_data->service_uuid_mask.data.data,
1736                                 BT_LE_AD_TYPE_INCOMP_LIST_128_BIT_SERVICE_CLASS_UUIDS)
1737                                 == TRUE)
1738                                 is_matched = TRUE;
1739                         if (__bt_check_scan_result_uuid(scan_data,
1740                                 scan_data_len,
1741                                 (char*)filter_data->service_uuid.data.data,
1742                                 filter_data->service_uuid.data_len,
1743                                 (char*)filter_data->service_uuid_mask.data.data,
1744                                 BT_LE_AD_TYPE_COMP_LIST_128_BIT_SERVICE_CLASS_UUIDS)
1745                                 == TRUE)
1746                                 is_matched = TRUE;
1747
1748                         if (is_matched == FALSE)
1749                                 continue;
1750                 }
1751                 if (filter_data->added_features &
1752                         BLUETOOTH_LE_SCAN_FILTER_FEATURE_SERVICE_SOLICITATION_UUID) {
1753                         is_matched = FALSE;
1754
1755                         if (__bt_check_scan_result_uuid(adv_data,
1756                                 adv_data_len,
1757                                 (char*)filter_data->service_solicitation_uuid.data.data,
1758                                 filter_data->service_solicitation_uuid.data_len,
1759                                 (char*)filter_data->service_solicitation_uuid_mask.data.data,
1760                                 BT_LE_AD_TYPE_LIST_16_BIT_SERVICE_SOLICITATION_UUIDS)
1761                                 == TRUE)
1762                                 is_matched = TRUE;
1763                         if (__bt_check_scan_result_uuid(adv_data,
1764                                 adv_data_len,
1765                                 (char*)filter_data->service_solicitation_uuid.data.data,
1766                                 filter_data->service_solicitation_uuid.data_len,
1767                                 (char*)filter_data->service_solicitation_uuid_mask.data.data,
1768                                 BT_LE_AD_TYPE_LIST_128_BIT_SERVICE_SOLICITATION_UUIDS)
1769                                 == TRUE)
1770                                 is_matched = TRUE;
1771                         if (__bt_check_scan_result_uuid(scan_data,
1772                                 scan_data_len,
1773                                 (char*)filter_data->service_solicitation_uuid.data.data,
1774                                 filter_data->service_solicitation_uuid.data_len,
1775                                 (char*)filter_data->service_solicitation_uuid_mask.data.data,
1776                                 BT_LE_AD_TYPE_LIST_16_BIT_SERVICE_SOLICITATION_UUIDS)
1777                                 == TRUE)
1778                                 is_matched = TRUE;
1779                         if (__bt_check_scan_result_uuid(scan_data,
1780                                 scan_data_len,
1781                                 (char*)filter_data->service_solicitation_uuid.data.data,
1782                                 filter_data->service_solicitation_uuid.data_len,
1783                                 (char*)filter_data->service_solicitation_uuid_mask.data.data,
1784                                 BT_LE_AD_TYPE_LIST_128_BIT_SERVICE_SOLICITATION_UUIDS)
1785                                 == TRUE)
1786                                 is_matched = TRUE;
1787
1788                         if (is_matched == FALSE)
1789                                 continue;
1790                 }
1791                 if (filter_data->added_features &
1792                         BLUETOOTH_LE_SCAN_FILTER_FEATURE_DEVICE_NAME) {
1793                         char name[BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX] = {0, };
1794                         data = NULL;
1795                         data_len = 0;
1796                         is_matched = FALSE;
1797
1798                         __bt_get_ad_data_by_type((char*)adv_data, adv_data_len,
1799                                         BT_LE_AD_TYPE_COMPLETE_LOCAL_NAME,
1800                                         &data, &data_len);
1801                         if (data != NULL) {
1802                                 if (data_len >= BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX)
1803                                         data_len = BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX - 1;
1804                                 memcpy(name, data, data_len);
1805                                 name[data_len] = '\0';
1806                                 g_free(data);
1807                                 data = NULL;
1808                                 if (strncmp(filter_data->device_name,
1809                                                 name, data_len) == 0)
1810                                         is_matched = TRUE;
1811                         }
1812                         __bt_get_ad_data_by_type((char*)scan_data,
1813                                 scan_data_len,
1814                                 BT_LE_AD_TYPE_COMPLETE_LOCAL_NAME,
1815                                 &data, &data_len);
1816                         if (data != NULL) {
1817                                 if (data_len >= BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX)
1818                                         data_len = BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX - 1;
1819                                 memcpy(name, data, data_len);
1820                                 name[data_len] = '\0';
1821                                 g_free(data);
1822                                 data = NULL;
1823                                 if (strncmp(filter_data->device_name,
1824                                                 name, data_len) == 0)
1825                                         is_matched = TRUE;
1826                         }
1827
1828                         if (is_matched == FALSE)
1829                                 continue;
1830                 }
1831                 if (filter_data->added_features &
1832                         BLUETOOTH_LE_SCAN_FILTER_FEATURE_MANUFACTURER_DATA) {
1833                         data = NULL;
1834                         data_len = 0;
1835                         is_matched = FALSE;
1836
1837                         __bt_get_ad_data_by_type((char*)adv_data,
1838                                 adv_data_len,
1839                                 BT_LE_AD_TYPE_MANUFACTURER_SPECIFIC_DATA,
1840                                 &data, &data_len);
1841
1842                         if (data != NULL) {
1843                                 int manufacturer_id;
1844                                 manufacturer_id = (data[1] << 8) + data[0];
1845
1846                                 if (filter_data->manufacturer_id == manufacturer_id) {
1847                                         if (filter_data->manufacturer_data.data_len == 0) {
1848                                                 is_matched = TRUE;
1849                                         } else {
1850                                                 if (data_len >= BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX)
1851                                                         data_len = BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX - 1;
1852                                                 if (_bt_byte_arr_cmp_with_mask(data + 2,
1853                                                         (char*)filter_data->manufacturer_data.data.data,
1854                                                         (char*)filter_data->manufacturer_data_mask.data.data,
1855                                                         data_len - 2) == 0) {
1856                                                         is_matched = TRUE;
1857                                                 }
1858                                         }
1859                                 }
1860                                 g_free(data);
1861                                 data = NULL;
1862                         }
1863                         __bt_get_ad_data_by_type((char*)scan_data,
1864                                 scan_data_len,
1865                                 BT_LE_AD_TYPE_MANUFACTURER_SPECIFIC_DATA,
1866                                 &data, &data_len);
1867
1868                         if (data != NULL) {
1869                                 int manufacturer_id;
1870                                 manufacturer_id = (data[1] << 8) + data[0];
1871
1872                                 if (filter_data->manufacturer_id == manufacturer_id) {
1873                                         if (filter_data->manufacturer_data.data_len == 0) {
1874                                                 is_matched = TRUE;
1875                                         } else {
1876                                                 if (data_len >= BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX)
1877                                                         data_len = BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX - 1;
1878                                                 if (_bt_byte_arr_cmp_with_mask(data + 2,
1879                                                         (char*)filter_data->manufacturer_data.data.data,
1880                                                         (char*)filter_data->manufacturer_data_mask.data.data,
1881                                                         data_len - 2) == 0) {
1882                                                         is_matched = TRUE;
1883                                                 }
1884                                         }
1885                                 }
1886                                 g_free(data);
1887                                 data = NULL;
1888                         }
1889
1890                         if (is_matched == FALSE)
1891                                 continue;
1892                 }
1893                 if (filter_data->added_features &
1894                         BLUETOOTH_LE_SCAN_FILTER_FEATURE_SERVICE_DATA) {
1895                         data = NULL;
1896                         data_len = 0;
1897                         is_matched = FALSE;
1898
1899                         __bt_get_ad_data_by_type((char*)adv_data,
1900                                 adv_data_len,
1901                                 BT_LE_AD_TYPE_SERVICE_DATA,
1902                                 &data, &data_len);
1903                         if (data != NULL) {
1904                                 if (data_len >= BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX)
1905                                         data_len = BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX - 1;
1906                                 if (_bt_byte_arr_cmp_with_mask(data,
1907                                         (char*)filter_data->service_data.data.data,
1908                                         (char*)filter_data->service_data_mask.data.data,
1909                                         data_len) == 0) {
1910                                         is_matched = TRUE;
1911                                 }
1912                                 g_free(data);
1913                                 data = NULL;
1914                         }
1915                         __bt_get_ad_data_by_type((char*)scan_data,
1916                                 scan_data_len,
1917                                 BT_LE_AD_TYPE_SERVICE_DATA,
1918                                 &data, &data_len);
1919                         if (data != NULL) {
1920                                 if (data_len >= BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX)
1921                                         data_len = BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX - 1;
1922                                 if (_bt_byte_arr_cmp_with_mask(data,
1923                                         (char*)filter_data->service_data.data.data,
1924                                         (char*)filter_data->service_data_mask.data.data,
1925                                         data_len) == 0) {
1926                                         is_matched = TRUE;
1927                                 }
1928                                 g_free(data);
1929                                 data = NULL;
1930                         }
1931
1932                         if (is_matched == FALSE)
1933                                 continue;
1934                 }
1935
1936                 BT_INFO("The scan result is conformable.");
1937                 return TRUE;
1938         }
1939
1940         BT_INFO("The scan result is NOT conformable.");
1941         return FALSE;
1942 }
1943
1944 void _bt_send_scan_result_event(const bt_remote_le_dev_info_t *le_dev_info,
1945                                 const bt_le_adv_info_t *adv_info)
1946 {
1947         int result = BLUETOOTH_ERROR_NONE;
1948         GSList *l;
1949         GVariant *scan_data_param, *adv_data_param;
1950         GVariant *param;
1951         bt_adapter_le_scanner_t *scanner = NULL;
1952         const char *adv_data = NULL;
1953         int adv_data_len = 0;
1954         const char *scan_data = NULL;
1955         int scan_data_len = 0;
1956
1957         ret_if(le_dev_info == NULL);
1958         if (_bt_get_le_scan_type() == BT_LE_ACTIVE_SCAN)
1959                 ret_if(adv_info == NULL);
1960
1961         if (_bt_get_le_scan_type() == BT_LE_PASSIVE_SCAN) {
1962                 adv_data = le_dev_info->adv_data;
1963                 adv_data_len = le_dev_info->adv_data_len;
1964                 scan_data = le_dev_info->adv_data;
1965                 scan_data_len = 0;
1966         } else {
1967                 adv_data = adv_info->data;
1968                 adv_data_len = adv_info->data_len;
1969                 scan_data = le_dev_info->adv_data;
1970                 scan_data_len = le_dev_info->adv_data_len;
1971         }
1972
1973         for (l = scanner_list; l != NULL; l = g_slist_next(l)) {
1974                 scanner = l->data;
1975                 if (scanner->is_scanning == FALSE)
1976                         continue;
1977
1978                 if (__bt_check_scan_result_with_filter(le_dev_info->address,
1979                         adv_data, adv_data_len, scan_data, scan_data_len,
1980                         scanner) == FALSE)
1981                         continue;
1982
1983                 adv_data_param = g_variant_new_from_data((const GVariantType *)"ay",
1984                                                         adv_data, adv_data_len, TRUE, NULL, NULL);
1985                 scan_data_param = g_variant_new_from_data((const GVariantType *)"ay",
1986                                                         scan_data, scan_data_len, TRUE, NULL, NULL);
1987
1988                 param = g_variant_new("(isnnn@ayn@ay)",
1989                                         result,
1990                                         le_dev_info->address,
1991                                         le_dev_info->addr_type,
1992                                         le_dev_info->rssi,
1993                                         adv_data_len,
1994                                         adv_data_param,
1995                                         scan_data_len,
1996                                         scan_data_param);
1997
1998 #if 0
1999                 _bt_send_event_to_dest(scanner->sender, BT_LE_ADAPTER_EVENT,
2000                                 BLUETOOTH_EVENT_REMOTE_LE_DEVICE_FOUND, param);
2001 #else
2002                 _bt_send_event(BT_LE_ADAPTER_EVENT, BLUETOOTH_EVENT_REMOTE_LE_DEVICE_FOUND, param);
2003 #endif
2004         }
2005 }
2006
2007 void _bt_send_ibeacon_scan_result_event(const bt_remote_ibeacon_dev_info_t *ibeacon_dev_info)
2008 {
2009         int result = BLUETOOTH_ERROR_NONE;
2010         GSList *l;
2011         GVariant *param;
2012         bt_adapter_le_scanner_t *scanner = NULL;
2013
2014         ret_if(ibeacon_dev_info == NULL);
2015         BT_DBG("_bt_send_ibeacon_scan_result_event");
2016
2017         for (l = scanner_list; l != NULL; l = g_slist_next(l)) {
2018                 scanner = l->data;
2019                 if (scanner->is_scanning == FALSE)
2020                         continue;
2021
2022                 param = g_variant_new("(isnnnsnnn)",
2023                                         result,
2024                                         ibeacon_dev_info->address,
2025                                         ibeacon_dev_info->addr_type,
2026                                         ibeacon_dev_info->company_id,
2027                                         ibeacon_dev_info->ibeacon_type,
2028                                         ibeacon_dev_info->uuid,
2029                                         ibeacon_dev_info->major_id,
2030                                         ibeacon_dev_info->minor_id,
2031                                         ibeacon_dev_info->measured_power);
2032
2033                 _bt_send_event(BT_LE_ADAPTER_EVENT, BLUETOOTH_EVENT_REMOTE_IBEACON_DEVICE_FOUND, param);
2034         }
2035 }
2036
2037 int _bt_add_white_list(bluetooth_device_address_t *device_address, bluetooth_device_address_type_t address_type)
2038 {
2039         GDBusProxy *proxy;
2040         char address[BT_ADDRESS_STRING_SIZE] = { 0 };
2041         GError *error = NULL;
2042         GVariant *ret;
2043
2044         if (__bt_is_factory_test_mode()) {
2045                 BT_ERR("Unable to add white list in factory binary !!");
2046                 return BLUETOOTH_ERROR_NOT_SUPPORT;
2047         }
2048
2049         BT_CHECK_PARAMETER(device_address, return);
2050
2051         if (address_type != BLUETOOTH_DEVICE_PUBLIC_ADDRESS &&
2052                 address_type != BLUETOOTH_DEVICE_RANDOM_ADDRESS)
2053                 return BLUETOOTH_ERROR_INVALID_PARAM;
2054
2055         _bt_convert_addr_type_to_string(address, device_address->addr);
2056
2057         proxy = _bt_get_adapter_proxy();
2058         retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
2059
2060         ret = g_dbus_proxy_call_sync(proxy, "AddDeviceWhiteList",
2061                           g_variant_new("(su)", address, address_type),
2062                           G_DBUS_CALL_FLAGS_NONE, -1,
2063                           NULL, &error);
2064
2065         if (error) {
2066                 BT_ERR("AddDeviceWhiteList Fail: %s", error->message);
2067                 g_clear_error(&error);
2068                 return BLUETOOTH_ERROR_INTERNAL;
2069         }
2070
2071         if (ret)
2072                 g_variant_unref(ret);
2073         BT_INFO("Add white list");
2074
2075         return BLUETOOTH_ERROR_NONE;
2076 }
2077
2078 int _bt_remove_white_list(bluetooth_device_address_t *device_address, bluetooth_device_address_type_t address_type)
2079 {
2080         GDBusProxy *proxy;
2081         char address[BT_ADDRESS_STRING_SIZE] = { 0 };
2082         GError *error = NULL;
2083         GVariant *ret;
2084
2085         if (__bt_is_factory_test_mode()) {
2086                 BT_ERR("Unable to remove white list in factory binary !!");
2087                 return BLUETOOTH_ERROR_NOT_SUPPORT;
2088         }
2089
2090         BT_CHECK_PARAMETER(device_address, return);
2091
2092         if (address_type != BLUETOOTH_DEVICE_PUBLIC_ADDRESS &&
2093                 address_type != BLUETOOTH_DEVICE_RANDOM_ADDRESS)
2094                 return BLUETOOTH_ERROR_INVALID_PARAM;
2095
2096         _bt_convert_addr_type_to_string(address, device_address->addr);
2097
2098         proxy = _bt_get_adapter_proxy();
2099         retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
2100
2101         ret = g_dbus_proxy_call_sync(proxy, "RemoveDeviceWhiteList",
2102                           g_variant_new("(su)", address, address_type),
2103                           G_DBUS_CALL_FLAGS_NONE, -1,
2104                           NULL, &error);
2105
2106         if (error) {
2107                 BT_ERR("RemoveDeviceWhiteList Fail: %s", error->message);
2108                 g_clear_error(&error);
2109                 return BLUETOOTH_ERROR_INTERNAL;
2110         }
2111
2112         if (ret)
2113                 g_variant_unref(ret);
2114         BT_INFO("Remove white list");
2115
2116         return BLUETOOTH_ERROR_NONE;
2117 }
2118
2119 int _bt_clear_white_list(void)
2120 {
2121         GDBusProxy *proxy;
2122         GError *error = NULL;
2123         GVariant *ret;
2124
2125         if (__bt_is_factory_test_mode()) {
2126                 BT_ERR("Unable to clear white list in factory binary !!");
2127                 return BLUETOOTH_ERROR_NOT_SUPPORT;
2128         }
2129
2130         proxy = _bt_get_adapter_proxy();
2131         retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
2132
2133         ret = g_dbus_proxy_call_sync(proxy, "ClearDeviceWhiteList",
2134                                 NULL, G_DBUS_CALL_FLAGS_NONE,
2135                                 -1, NULL, &error);
2136
2137         if (error) {
2138                 BT_ERR("ClearDeviceWhiteList Fail: %s", error->message);
2139                 g_clear_error(&error);
2140                 return BLUETOOTH_ERROR_INTERNAL;
2141         }
2142         if (ret)
2143                 g_variant_unref(ret);
2144
2145         BT_INFO("Clear white list");
2146
2147         return BLUETOOTH_ERROR_NONE;
2148 }
2149
2150 int _bt_initialize_ipsp(void)
2151 {
2152         BT_DBG("+");
2153         GDBusProxy *proxy;
2154         GError *error = NULL;
2155         GVariant *ret;
2156
2157         if (_bt_adapter_get_status() != BT_ACTIVATED &&
2158                 _bt_adapter_get_le_status() != BT_LE_ACTIVATED) {
2159                 return BLUETOOTH_ERROR_DEVICE_NOT_ENABLED;
2160         }
2161
2162         proxy = _bt_get_adapter_proxy();
2163         retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
2164
2165         ret = g_dbus_proxy_call_sync(proxy, "InitializeIpsp",
2166                                 NULL, G_DBUS_CALL_FLAGS_NONE,
2167                                 -1, NULL, &error);
2168         if (error) {
2169                 BT_ERR("Initialize IPSP Failed :[%s]", error->message);
2170                 g_clear_error(&error);
2171                 return BLUETOOTH_ERROR_INTERNAL;
2172         }
2173         if (ret)
2174                 g_variant_unref(ret);
2175
2176         BT_INFO("IPSP initialization called successfully");
2177
2178         return BLUETOOTH_ERROR_NONE;
2179 }
2180
2181 int _bt_deinitialize_ipsp(void)
2182 {
2183         BT_DBG("+");
2184         GDBusProxy *proxy;
2185         GError *error = NULL;
2186         GVariant *ret;
2187
2188         if (_bt_adapter_get_status() != BT_ACTIVATED &&
2189                 _bt_adapter_get_le_status() != BT_LE_ACTIVATED) {
2190                 return BLUETOOTH_ERROR_DEVICE_NOT_ENABLED;
2191         }
2192
2193         proxy = _bt_get_adapter_proxy();
2194         retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
2195
2196         ret = g_dbus_proxy_call_sync(proxy, "DeinitializeIpsp",
2197                                 NULL, G_DBUS_CALL_FLAGS_NONE,
2198                                 -1, NULL, &error);
2199         if (error) {
2200                 BT_ERR("De-Initialize IPSP Failed :[%s]", error->message);
2201                 g_clear_error(&error);
2202                 return BLUETOOTH_ERROR_INTERNAL;
2203         }
2204         if (ret)
2205                 g_variant_unref(ret);
2206
2207         BT_INFO("IPSP De-initialization called successfully");
2208
2209         return BLUETOOTH_ERROR_NONE;
2210 }
2211
2212 int _bt_le_read_maximum_data_length(
2213                 bluetooth_le_read_maximum_data_length_t *max_le_datalength)
2214 {
2215         GError *error = NULL;
2216         GDBusProxy *proxy;
2217         GVariant *reply = NULL;
2218         guint16 max_tx_octets, max_tx_time;
2219         guint16 max_rx_octets, max_rx_time;
2220
2221         proxy = _bt_get_adapter_proxy();
2222         retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
2223
2224         reply = g_dbus_proxy_call_sync(proxy, "LEReadMaximumDataLength",
2225                         NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
2226
2227         if (reply == NULL) {
2228                 BT_ERR("LEReadMaximumDataLength dBUS-RPC failed");
2229                 if (error != NULL) {
2230                         BT_ERR("D-Bus API failure: errCode[%x], message[%s]",
2231                                         error->code, error->message);
2232                         g_clear_error(&error);
2233                 }
2234                 return BLUETOOTH_ERROR_INTERNAL;
2235         }
2236
2237         g_variant_get(reply, "(qqqq)", &max_tx_octets, &max_tx_time,
2238                                 &max_rx_octets, &max_rx_time);
2239
2240         max_le_datalength->max_tx_octets = max_tx_octets;
2241         max_le_datalength->max_tx_time = max_tx_time;
2242         max_le_datalength->max_rx_octets = max_rx_octets;
2243         max_le_datalength->max_rx_time = max_rx_time;
2244
2245         g_variant_unref(reply);
2246
2247         return BLUETOOTH_ERROR_NONE;
2248 }
2249 int _bt_le_write_host_suggested_default_data_length(
2250         const unsigned int def_tx_Octets, const unsigned int def_tx_Time)
2251 {
2252         GError *error = NULL;
2253         GDBusProxy *proxy;
2254         GVariant *reply = NULL;
2255
2256         proxy = _bt_get_adapter_proxy();
2257         retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
2258
2259         reply = g_dbus_proxy_call_sync(proxy,
2260                         "LEWriteHostSuggestedDataLength",
2261                         g_variant_new("(qq)", def_tx_Octets, def_tx_Time),
2262                         G_DBUS_CALL_FLAGS_NONE,
2263                         -1,
2264                         NULL,
2265                         &error);
2266
2267         if (reply == NULL) {
2268                 BT_ERR("_bt_le_write_host_suggested_default_data_length dBUS-RPC failed");
2269                 if (error != NULL) {
2270                         BT_ERR("D-Bus API failure: errCode[%x], message[%s]",
2271                                         error->code, error->message);
2272                         g_clear_error(&error);
2273                 }
2274                 return BLUETOOTH_ERROR_INTERNAL;
2275         }
2276
2277         g_variant_unref(reply);
2278
2279         return BLUETOOTH_ERROR_NONE;
2280 }
2281
2282 int _bt_le_read_host_suggested_default_data_length(
2283                 bluetooth_le_read_host_suggested_data_length_t *def_data_length)
2284 {
2285         GError *error = NULL;
2286         GDBusProxy *proxy;
2287         GVariant *reply = NULL;
2288         guint16 def_tx_octets, def_tx_time;
2289
2290         proxy = _bt_get_adapter_proxy();
2291         retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
2292
2293         reply = g_dbus_proxy_call_sync(proxy, "LEReadHostSuggestedDataLength",
2294                         NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
2295
2296         if (reply == NULL) {
2297                 BT_ERR("LEReadHostSuggestedDataLength dBUS-RPC failed");
2298                 if (error != NULL) {
2299                         BT_ERR("D-Bus API failure: errCode[%x], message[%s]",
2300                                         error->code, error->message);
2301                         g_clear_error(&error);
2302                 }
2303                 return BLUETOOTH_ERROR_INTERNAL;
2304         }
2305
2306         g_variant_get(reply, "(qq)", &def_tx_octets, &def_tx_time);
2307
2308         def_data_length->def_tx_octets = def_tx_octets;
2309         def_data_length->def_tx_time = def_tx_time;
2310
2311         g_variant_unref(reply);
2312
2313         return BLUETOOTH_ERROR_NONE;
2314 }
2315
2316 int _bt_le_set_data_length(bluetooth_device_address_t *device_address,
2317         const unsigned int max_tx_Octets, const unsigned int max_tx_Time)
2318 {
2319         GError *error = NULL;
2320         guint16 txOctets = max_tx_Octets;
2321         guint16 txTime = max_tx_Time;
2322         char address[BT_ADDRESS_STRING_SIZE] = { 0 };
2323         gchar *device_path = NULL;
2324         GDBusConnection *conn;
2325         GDBusProxy *device_proxy;
2326
2327         _bt_convert_addr_type_to_string(address, device_address->addr);
2328
2329         device_path = _bt_get_device_object_path(address);
2330
2331         if (device_path == NULL) {
2332                 BT_DBG("Device path is null");
2333                 return BLUETOOTH_ERROR_INTERNAL;
2334         }
2335
2336         conn = _bt_gdbus_get_system_gconn();
2337         if (conn == NULL) {
2338                 BT_ERR("conn == NULL");
2339                 g_free(device_path);
2340                 return BLUETOOTH_ERROR_INTERNAL;
2341         }
2342
2343         device_proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
2344                                                                 NULL, BT_BLUEZ_NAME,
2345                                                                 device_path, BT_DEVICE_INTERFACE,  NULL, NULL);
2346
2347         g_free(device_path);
2348         retv_if(device_proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
2349
2350         g_dbus_proxy_call_sync(device_proxy,
2351                                         "LESetDataLength",
2352                                         g_variant_new("(qq)", txOctets, txTime),
2353                                         G_DBUS_CALL_FLAGS_NONE,
2354                                         -1,
2355                                         NULL,
2356                                         &error);
2357
2358         g_object_unref(device_proxy);
2359
2360         if (error) {
2361                  BT_ERR("LESetDataLength error: [%s]", error->message);
2362                  g_error_free(error);
2363                  return BLUETOOTH_ERROR_INTERNAL;
2364         }
2365
2366         return BLUETOOTH_ERROR_NONE;
2367 }
2368
2369 int _bt_service_adapter_le_init(void)
2370 {
2371         le_adv_slot = g_malloc0(sizeof(bt_adapter_le_adv_slot_t) * le_feature_info.adv_inst_max);
2372
2373         return BLUETOOTH_ERROR_NONE;
2374 }
2375
2376 void _bt_service_adapter_le_deinit(void)
2377 {
2378         __bt_free_le_adv_slot();
2379         __bt_free_le_scanner();
2380 }