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