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

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