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