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