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

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