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