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

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