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