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

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