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