src/bluetooth-adapter.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 #include <glib.h>
  18 #include <string.h>
  19 #include <stdlib.h>
  20 #include <ctype.h>
  21 #include <dlog.h>
  22 #include <stdio.h>
  23 #include <stdbool.h>
  24 #include <arpa/inet.h>
  25 #include <bluetooth-api.h>
  26
  27 #include "bluetooth.h"
  28 #include "bluetooth_internal.h"
  29 #include "bluetooth_private.h"
  30
  31 #define BT_CHECK_LE_SUPPORT() \
  32 { \
  33         BT_CHECK_SUPPORTED_FEATURE(BT_FEATURE_COMMON); \
  34         BT_CHECK_SUPPORTED_FEATURE(BT_FEATURE_LE); \
  35 }
  36
  37 #define BT_CHECK_LE_5_0_SUPPORT() \
  38 { \
  39         BT_CHECK_SUPPORTED_FEATURE(BT_FEATURE_LE); \
  40         BT_CHECK_SUPPORTED_FEATURE(BT_FEATURE_LE_5_0); \
  41 }
  42
  43 static bt_scan_filter_h pxp_linkloss_alert_filter;
  44 static bt_scan_filter_h pxp_immediate_alert_filter;
  45 static bt_scan_filter_h pxp_signal_loss_filter;
  46
  47 static GSList *advertiser_list;
  48 static GSList *scan_filter_list;
  49 static int scan_filter_id;
  50
  51 /* LCOV_EXCL_START */
  52 int bt_adapter_enable(void)
  53 {
  54         int error_code = BT_ERROR_NONE;
  55
  56         BT_CHECK_SUPPORTED_FEATURE(BT_FEATURE_COMMON);
  57         BT_CHECK_INIT_STATUS();
  58         error_code = _bt_get_error_code(bluetooth_enable_adapter());
  59         if (error_code != BT_ERROR_NONE) { /* LCOV_EXCL_LINE */
  60                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code),
  61                                         error_code); /* LCOV_EXCL_LINE */
  62         } /* LCOV_EXCL_LINE */
  63         return error_code;
  64 }
  65
  66 int bt_adapter_read_battery_info(bt_battery_info_s *battery_data)
  67 {
  68         bt_battery_data data;
  69         int error_code = BT_ERROR_NONE;
  70
  71         BT_CHECK_SUPPORTED_FEATURE(BT_FEATURE_COMMON);
  72         BT_CHECK_INIT_STATUS();
  73         BT_CHECK_INPUT_PARAMETER(battery_data);
  74         memset(&data, 0, sizeof(bt_battery_data));
  75
  76         error_code = _bt_get_error_code(bluetooth_read_battery_data(&data));
  77
  78         if (error_code != BT_ERROR_NONE) { /* LCOV_EXCL_LINE */
  79                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code),
  80                         error_code); /* LCOV_EXCL_LINE */
  81                 return error_code;
  82         } /* LCOV_EXCL_LINE */
  83
  84         battery_data->session_start_time = data.session_start_time;
  85         battery_data->session_end_time = data.session_end_time;
  86         battery_data->session_scan_time = data.session_scan_time;
  87         battery_data->session_connected_time = data.session_connected_time;
  88         battery_data->tx_time = data.tx_time;
  89         battery_data->rx_time = data.rx_time;
  90         battery_data->idle_time = data.idle_time;
  91         battery_data->atm_list = data.atm_list;
  92
  93         BT_DBG("Battery Data in application layer: %ld %ld %d %d",
  94                 battery_data->session_start_time, battery_data->session_end_time,
  95                         battery_data->session_scan_time, battery_data->session_connected_time);
  96
  97         if(data.atm_list == NULL) {
  98                 BT_DBG("No data transaction in this session");
  99                 return error_code;
 100         }
 101
 102         BT_DBG("App-wise data transaction details:");
 103         for (GSList *l = battery_data->atm_list; l != NULL; l = g_slist_next(l)) {
 104                 bt_battery_app_info_s *t = (bt_battery_app_info_s *)(l->data);
 105                 BT_DBG("%ld %ld %d %d %u", (long int)(t->uid), (long int)(t->pid), t->rx_bytes, t->tx_bytes, t->time);
 106         }
 107
 108         return error_code;
 109 }
 110
 111 int bt_adapter_disable(void)
 112 {
 113         int error_code = BT_ERROR_NONE;
 114
 115         BT_CHECK_SUPPORTED_FEATURE(BT_FEATURE_COMMON);
 116         BT_CHECK_INIT_STATUS();
 117         error_code = _bt_get_error_code(bluetooth_disable_adapter());
 118         if (error_code != BT_ERROR_NONE) { /* LCOV_EXCL_LINE */
 119                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code),
 120                                         error_code); /* LCOV_EXCL_LINE */
 121         } /* LCOV_EXCL_LINE */
 122         return error_code;
 123 }
 124
 125 int bt_adapter_recover(void)
 126 {
 127         int error_code = BT_ERROR_NONE;
 128
 129         BT_CHECK_SUPPORTED_FEATURE(BT_FEATURE_COMMON);
 130         BT_CHECK_INIT_STATUS();
 131         error_code = _bt_get_error_code(bluetooth_recover_adapter());
 132         if (error_code != BT_ERROR_NONE) { /* LCOV_EXCL_LINE */
 133                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code),
 134                                         error_code); /* LCOV_EXCL_LINE */
 135         } /* LCOV_EXCL_LINE */
 136         return error_code;
 137 }
 138
 139 int bt_adapter_reset(void)
 140 {
 141         int error_code = BT_ERROR_NONE;
 142
 143         BT_CHECK_SUPPORTED_FEATURE(BT_FEATURE_COMMON);
 144         BT_CHECK_INIT_STATUS();
 145         error_code = _bt_get_error_code(bluetooth_reset_adapter());
 146         if (error_code != BT_ERROR_NONE) { /* LCOV_EXCL_LINE */
 147                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code),
 148                                         error_code); /* LCOV_EXCL_LINE */
 149         } /* LCOV_EXCL_LINE */
 150         return error_code;
 151 }
 152 /* LCOV_EXCL_STOP */
 153
 154 int bt_adapter_get_state(bt_adapter_state_e *adapter_state)
 155 {
 156         BT_CHECK_SUPPORTED_FEATURE(BT_FEATURE_COMMON);
 157         BT_CHECK_INIT_STATUS();
 158         BT_CHECK_INPUT_PARAMETER(adapter_state);
 159
 160         *adapter_state = bluetooth_check_adapter();
 161         return BT_ERROR_NONE;
 162 }
 163
 164 /* LCOV_EXCL_START */
 165 int bt_adapter_le_enable(void)
 166 {
 167         int error_code = BT_ERROR_NONE;
 168
 169         BT_CHECK_SUPPORTED_FEATURE(BT_FEATURE_COMMON);
 170         BT_CHECK_INIT_STATUS();
 171         error_code = _bt_get_error_code(bluetooth_enable_adapter_le());
 172         if (error_code != BT_ERROR_NONE) { /* LCOV_EXCL_LINE */
 173                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code),
 174                                         error_code); /* LCOV_EXCL_LINE */
 175         } /* LCOV_EXCL_LINE */
 176         return error_code;
 177 }
 178
 179 int bt_adapter_le_disable(void)
 180 {
 181         int error_code = BT_ERROR_NONE;
 182
 183         BT_CHECK_SUPPORTED_FEATURE(BT_FEATURE_COMMON);
 184         BT_CHECK_INIT_STATUS();
 185
 186         error_code = _bt_get_error_code(bluetooth_disable_adapter_le());
 187         if (error_code != BT_ERROR_NONE) { /* LCOV_EXCL_LINE */
 188                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code),
 189                                         error_code); /* LCOV_EXCL_LINE */
 190         } /* LCOV_EXCL_LINE */
 191         return error_code;
 192 }
 193
 194 int bt_adapter_le_get_state(bt_adapter_le_state_e *adapter_le_state)
 195 {
 196         BT_CHECK_SUPPORTED_FEATURE(BT_FEATURE_COMMON);
 197         BT_CHECK_INIT_STATUS();
 198         BT_CHECK_INPUT_PARAMETER(adapter_le_state);
 199
 200         *adapter_le_state = bluetooth_check_adapter_le();
 201         return BT_ERROR_NONE;
 202 }
 203 /* LCOV_EXCL_STOP */
 204
 205 int bt_adapter_get_address(char **address)
 206 {
 207         bluetooth_device_address_t loc_address = { {0} };
 208         int error_code = BT_ERROR_NONE;
 209
 210         BT_CHECK_SUPPORTED_FEATURE(BT_FEATURE_COMMON);
 211         BT_CHECK_INIT_STATUS();
 212         BT_CHECK_INPUT_PARAMETER(address);
 213
 214         error_code = _bt_get_error_code(bluetooth_get_local_address(&loc_address));
 215         if (error_code != BT_ERROR_NONE) { /* LCOV_EXCL_LINE */
 216                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), /* LCOV_EXCL_LINE */
 217                                         error_code); /* LCOV_EXCL_LINE */
 218                 return error_code; /* LCOV_EXCL_LINE */
 219         }
 220
 221         error_code = _bt_convert_address_to_string(address, &loc_address);
 222         if (error_code != BT_ERROR_NONE) { /* LCOV_EXCL_LINE */
 223                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), /* LCOV_EXCL_LINE */
 224                                         error_code); /* LCOV_EXCL_LINE */
 225                 return error_code; /* LCOV_EXCL_LINE */
 226         }
 227
 228         return BT_ERROR_NONE;
 229 }
 230
 231 /* LCOV_EXCL_START */
 232 int bt_adapter_get_version(char **version)
 233 {
 234         int ret = BT_ERROR_NONE;
 235         bluetooth_version_t loc_ver = { { 0 } };
 236
 237         BT_CHECK_SUPPORTED_FEATURE(BT_FEATURE_COMMON);
 238         BT_CHECK_INIT_STATUS();
 239         BT_CHECK_INPUT_PARAMETER(version);
 240
 241         ret = _bt_get_error_code(bluetooth_get_local_version(&loc_ver));
 242         if (ret != BT_ERROR_NONE) { /* LCOV_EXCL_LINE */
 243                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret),
 244                                                 ret); /* LCOV_EXCL_LINE */
 245                 return ret; /* LCOV_EXCL_LINE */
 246         }
 247
 248         *version = strdup(loc_ver.version);
 249         if (*version == NULL) {
 250                 BT_ERR("OUT_OF_MEMORY(0x%08x)", BT_ERROR_OUT_OF_MEMORY);
 251                 return BT_ERROR_OUT_OF_MEMORY;
 252         }
 253
 254         return BT_ERROR_NONE;
 255 }
 256 /* LCOV_EXCL_STOP */
 257
 258 #define BT_ADAPTER_FIRMWARE_INFO_FILE_PATH "/var/lib/bluetooth/bcmtool_log"
 259 #define BT_ADAPTER_STACK_INFO_FILE_PATH "/usr/etc/bluetooth/stack_info"
 260 #define BT_ADAPTER_MAX_BUFFER_SIZE (32767 * 1000)
 261
 262 /* LCOV_EXCL_START */
 263 int bt_adapter_get_local_info(char **chipset, char **firmware,
 264                         char **stack_version, char **profiles)
 265 {
 266         BT_CHECK_SUPPORTED_FEATURE(BT_FEATURE_COMMON);
 267         BT_CHECK_INIT_STATUS();
 268
 269         int ret = BT_ERROR_NONE;
 270         FILE *fp = NULL;
 271         char *buf = NULL;
 272         long lsize;
 273         size_t result;
 274         char *info_start = NULL;
 275         char *info_end = NULL;
 276         long info_size;
 277         char *local_chipset = NULL;
 278         char *local_firmware = NULL;
 279         char *local_stack_version = NULL;
 280         char *local_profiles = NULL;
 281
 282         BT_CHECK_SUPPORTED_FEATURE(BT_FEATURE_COMMON);
 283         BT_CHECK_INIT_STATUS();
 284         BT_CHECK_INPUT_PARAMETER(chipset);
 285         BT_CHECK_INPUT_PARAMETER(firmware);
 286         BT_CHECK_INPUT_PARAMETER(stack_version);
 287         BT_CHECK_INPUT_PARAMETER(profiles);
 288
 289         if ((fp = fopen(BT_ADAPTER_FIRMWARE_INFO_FILE_PATH, "r")) == NULL) {
 290                 BT_ERR("fopen() is failed(%s)",
 291                         BT_ADAPTER_FIRMWARE_INFO_FILE_PATH);
 292
 293                 local_firmware = (char *)malloc(sizeof(char) *1);
 294                 if (local_firmware == NULL) {
 295                         ret = BT_ERROR_OUT_OF_MEMORY;
 296                         BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret),
 297                                                                         ret);
 298                         goto ERROR;
 299                 }
 300                 local_firmware[0] = '\0';
 301                 local_chipset = (char *)malloc(sizeof(char) *1);
 302                 if (local_chipset == NULL) {
 303                         ret = BT_ERROR_OUT_OF_MEMORY;
 304                         BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret),
 305                                                                         ret);
 306                         goto ERROR;
 307                 }
 308                 local_chipset[0] = '\0';
 309         } else {
 310                 fseek(fp, 0, SEEK_END);
 311                 lsize = ftell(fp);
 312                 if (lsize < 0) {
 313                         BT_ERR("ftell() error(0x%lx)", lsize);
 314                         ret = BT_ERROR_OPERATION_FAILED;
 315                         goto ERROR;
 316                 }
 317                 buf = (char *)malloc(sizeof(char) *(lsize + 1));
 318                 if (buf == NULL) {
 319                         ret = BT_ERROR_OUT_OF_MEMORY;
 320                         BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret),
 321                                                                         ret);
 322                         goto ERROR;
 323                 }
 324                 fseek(fp, 0, SEEK_SET);
 325                 result = fread(buf, 1, lsize, fp);
 326                 buf[lsize] = '\0';
 327
 328                 if (result != lsize)
 329                         BT_ERR("fread() error");
 330
 331                 info_start = strstr(buf, "bluetooth");
 332                 if (info_start == NULL) {
 333                         BT_ERR("strstr() error info_start is NULL");
 334                         ret = BT_ERROR_OPERATION_FAILED;
 335                         goto ERROR;
 336                 }
 337                 info_start += 10;
 338                 info_end = strstr(buf, "hcd");
 339                 if (info_end == NULL) {
 340                         BT_ERR("strstr() error info_end is NULL");
 341                         ret = BT_ERROR_OPERATION_FAILED;
 342                         goto ERROR;
 343                 }
 344                 info_size = info_end - info_start - 1;
 345                 if (info_size < 0) {
 346                         BT_ERR("info_size is invalid(%ld)", info_size);
 347                         ret = BT_ERROR_OPERATION_FAILED;
 348                         goto ERROR;
 349                 }
 350
 351                 local_firmware = (char *)malloc(sizeof(char) *(info_size + 1));
 352                 if (local_firmware == NULL) {
 353                         ret = BT_ERROR_OUT_OF_MEMORY;
 354                         BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret),
 355                                                                         ret);
 356                         goto ERROR;
 357                 }
 358
 359                 strncpy(local_firmware, info_start, info_size);
 360                 local_firmware[info_size] = '\0';
 361
 362                 info_end = strchr(buf, '_');
 363                 if (info_end == NULL) {
 364                         BT_ERR("strchr() error info_end is NULL");
 365                         ret = BT_ERROR_OPERATION_FAILED;
 366                         goto ERROR;
 367                 }
 368                 info_size = info_end - info_start;
 369
 370                 local_chipset = (char *)malloc(sizeof(char) *(info_size + 1));
 371                 if (local_chipset == NULL) {
 372                         ret = BT_ERROR_OUT_OF_MEMORY;
 373                         BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret),
 374                                                                         ret);
 375                         goto ERROR;
 376                 }
 377
 378                 strncpy(local_chipset, info_start, info_size);
 379                 local_chipset[info_size] = '\0';
 380
 381                 if (buf)
 382                         free(buf);
 383                 buf = NULL;
 384                 fclose(fp);
 385         }
 386
 387         if ((fp = fopen(BT_ADAPTER_STACK_INFO_FILE_PATH, "r")) == NULL) {
 388                 BT_ERR("fopen() error");
 389                 ret = BT_ERROR_OPERATION_FAILED;
 390                 goto ERROR;
 391         }
 392
 393         fseek(fp, 0, SEEK_END);
 394         lsize = ftell(fp);
 395         if (lsize < 0) {
 396                 BT_ERR("ftell() error(0x%lx)", lsize);
 397                 ret = BT_ERROR_OPERATION_FAILED;
 398                 goto ERROR;
 399         }
 400         buf = (char *)malloc(sizeof(char) *(lsize + 1));
 401         if (buf == NULL) {
 402                 ret = BT_ERROR_OUT_OF_MEMORY;
 403                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
 404                 goto ERROR;
 405         }
 406         fseek(fp, 0, SEEK_SET);
 407         result = fread(buf, 1, lsize, fp);
 408         buf[lsize] = '\0';
 409
 410         if (result != lsize) {
 411                 BT_ERR("fread() error(0x%zd)", result);
 412                 ret = BT_ERROR_OPERATION_FAILED;
 413                 goto ERROR;
 414         }
 415
 416         info_start = buf;
 417         info_end = strchr(buf, ',');
 418         if (info_end == NULL) {
 419                 BT_ERR("strchr() error info_end is NULL");
 420                 ret = BT_ERROR_OPERATION_FAILED;
 421                 goto ERROR;
 422         }
 423         info_size = info_end - info_start;
 424
 425         if (info_size < 0 || info_size > BT_ADAPTER_MAX_BUFFER_SIZE) {
 426                 BT_ERR("info size is incorrect: %ld", info_size);
 427                 ret = BT_ERROR_OPERATION_FAILED;
 428                 goto ERROR;
 429         }
 430
 431         local_stack_version = (char *)malloc(sizeof(char) *(info_size + 1));
 432         if (local_stack_version == NULL) {
 433                 ret = BT_ERROR_OUT_OF_MEMORY;
 434                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
 435                 goto ERROR;
 436         }
 437
 438         strncpy(local_stack_version, info_start, info_size);
 439         local_stack_version[info_size] = '\0';
 440
 441         info_start = info_end + 2;
 442         info_size = lsize - info_size - 3;
 443
 444         if (info_size < 0 || info_size > BT_ADAPTER_MAX_BUFFER_SIZE) {
 445                 BT_ERR("info size is incorrect: %ld", info_size);
 446                 ret = BT_ERROR_OPERATION_FAILED;
 447                 goto ERROR;
 448         }
 449
 450         local_profiles = (char *)malloc(sizeof(char) *(info_size + 1));
 451         if (local_profiles == NULL) {
 452                 ret = BT_ERROR_OUT_OF_MEMORY;
 453                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
 454                 goto ERROR;
 455         }
 456
 457         strncpy(local_profiles, info_start, info_size);
 458         local_profiles[info_size] = '\0';
 459
 460         if (buf)
 461                 free(buf);
 462         fclose(fp);
 463
 464         *chipset = local_chipset;
 465         *firmware = local_firmware;
 466         *stack_version = local_stack_version;
 467         *profiles = local_profiles;
 468
 469         return BT_ERROR_NONE;
 470
 471 ERROR:
 472         if (local_chipset)
 473                 free(local_chipset);
 474         if (local_firmware)
 475                 free(local_firmware);
 476         if (local_stack_version)
 477                 free(local_stack_version);
 478         if (buf)
 479                 free(buf);
 480         if (fp)
 481                 fclose(fp);
 482         return ret;
 483 }
 484 /* LCOV_EXCL_STOP */
 485
 486 int bt_adapter_get_name(char **name)
 487 {
 488         int ret = BT_ERROR_NONE;
 489         bluetooth_device_name_t loc_name = { {0} };
 490
 491         BT_CHECK_SUPPORTED_FEATURE(BT_FEATURE_COMMON);
 492         BT_CHECK_INIT_STATUS();
 493         BT_CHECK_INPUT_PARAMETER(name);
 494
 495         ret = _bt_get_error_code(bluetooth_get_local_name(&loc_name));
 496         if (ret != BT_ERROR_NONE) { /* LCOV_EXCL_LINE */
 497                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), /* LCOV_EXCL_LINE */
 498                                                 ret); /* LCOV_EXCL_LINE */
 499                 return ret; /* LCOV_EXCL_LINE */
 500         }
 501
 502         *name = strdup(loc_name.name);
 503         if (*name == NULL) {
 504                 BT_ERR("OUT_OF_MEMORY(0x%08x)", /* LCOV_EXCL_LINE */
 505                                 BT_ERROR_OUT_OF_MEMORY); /* LCOV_EXCL_LINE */
 506                 return BT_ERROR_OUT_OF_MEMORY;
 507         }
 508
 509         return BT_ERROR_NONE;
 510 }
 511
 512 int bt_adapter_set_name(const char *name)
 513 {
 514         bluetooth_device_name_t loc_name = { {0} };
 515         int ret = BT_ERROR_NONE;
 516
 517         BT_CHECK_SUPPORTED_FEATURE(BT_FEATURE_COMMON);
 518         BT_CHECK_INIT_STATUS();
 519         BT_CHECK_INPUT_PARAMETER(name);
 520
 521         strncpy(loc_name.name, name, BLUETOOTH_DEVICE_NAME_LENGTH_MAX);
 522         loc_name.name[BLUETOOTH_DEVICE_NAME_LENGTH_MAX] = '\0';
 523
 524         ret = _bt_get_error_code(bluetooth_set_local_name(&loc_name));
 525         if (ret != BT_ERROR_NONE) { /* LCOV_EXCL_LINE */
 526                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), /* LCOV_EXCL_LINE */
 527                                                 ret); /* LCOV_EXCL_LINE */
 528         } /* LCOV_EXCL_LINE */
 529
 530         return ret;
 531 }
 532
 533 /* LCOV_EXCL_START */
 534 int bt_adapter_get_visibility(bt_adapter_visibility_mode_e *mode, int *duration)
 535 {
 536         bluetooth_discoverable_mode_t discoverable_mode = BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE;
 537         int ret = BT_ERROR_NONE;
 538
 539         BT_CHECK_SUPPORTED_FEATURE(BT_FEATURE_COMMON);
 540         BT_CHECK_INIT_STATUS();
 541         BT_CHECK_INPUT_PARAMETER(mode);
 542
 543         ret = _bt_get_error_code(bluetooth_get_discoverable_mode(&discoverable_mode));
 544         if (ret != BT_ERROR_NONE) { /* LCOV_EXCL_LINE */
 545                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret),
 546                                                 ret); /* LCOV_EXCL_LINE */
 547                 return ret; /* LCOV_EXCL_LINE */
 548         }
 549
 550         *mode = _bt_get_bt_visibility_mode_e(discoverable_mode);
 551
 552         if (duration)
 553                 *duration = 0;
 554
 555         if (discoverable_mode == BLUETOOTH_DISCOVERABLE_MODE_TIME_LIMITED_DISCOVERABLE) {
 556                 if (duration == NULL)
 557                         return BT_ERROR_NONE;
 558                 ret = bluetooth_get_timeout_value(duration);
 559                 if (ret != BT_ERROR_NONE) { /* LCOV_EXCL_LINE */
 560                         BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret),
 561                                                 ret); /* LCOV_EXCL_LINE */
 562                 } /* LCOV_EXCL_LINE */
 563         }
 564
 565         return ret;
 566 }
 567
 568 int bt_adapter_set_visibility(bt_adapter_visibility_mode_e visibility_mode,
 569                                                         int timeout_sec)
 570 {
 571         bluetooth_discoverable_mode_t discoverable_mode = BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE;
 572         int error_code = BT_ERROR_NONE;
 573
 574         BT_CHECK_SUPPORTED_FEATURE(BT_FEATURE_COMMON);
 575         BT_CHECK_INIT_STATUS();
 576         switch (visibility_mode) {
 577         case BT_ADAPTER_VISIBILITY_MODE_LIMITED_DISCOVERABLE:
 578                 discoverable_mode = BLUETOOTH_DISCOVERABLE_MODE_TIME_LIMITED_DISCOVERABLE;
 579                 break;
 580         case BT_ADAPTER_VISIBILITY_MODE_NON_DISCOVERABLE:
 581                 discoverable_mode = BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE;
 582                 timeout_sec = 0;
 583                 break;
 584         case BT_ADAPTER_VISIBILITY_MODE_GENERAL_DISCOVERABLE:
 585                 discoverable_mode = BLUETOOTH_DISCOVERABLE_MODE_GENERAL_DISCOVERABLE;
 586                 timeout_sec = 0;
 587                 break;
 588         default:
 589                 BT_ERR("INVALID_PARAMETER(0x%08x)", BT_ERROR_INVALID_PARAMETER);
 590                 return BT_ERROR_INVALID_PARAMETER;
 591         }
 592
 593         error_code = _bt_get_error_code(bluetooth_set_discoverable_mode(
 594                                         discoverable_mode, timeout_sec));
 595         if (error_code != BT_ERROR_NONE) { /* LCOV_EXCL_LINE */
 596                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code),
 597                                         error_code); /* LCOV_EXCL_LINE */
 598         } /* LCOV_EXCL_LINE */
 599
 600         return error_code;
 601 }
 602
 603 int bt_adapter_set_connectable_changed_cb(bt_adapter_connectable_changed_cb callback,
 604                                                         void *user_data)
 605 {
 606         BT_CHECK_SUPPORTED_FEATURE(BT_FEATURE_COMMON);
 607         BT_CHECK_INIT_STATUS();
 608         BT_CHECK_INPUT_PARAMETER(callback);
 609         _bt_set_cb(BT_EVENT_CONNECTABLE_CHANGED_EVENT, callback, user_data);
 610         return BT_ERROR_NONE;
 611 }
 612
 613 int bt_adapter_unset_connectable_changed_cb(void)
 614 {
 615         BT_CHECK_SUPPORTED_FEATURE(BT_FEATURE_COMMON);
 616         BT_CHECK_INIT_STATUS();
 617         _bt_unset_cb(BT_EVENT_CONNECTABLE_CHANGED_EVENT);
 618         return BT_ERROR_NONE;
 619 }
 620
 621 int bt_adapter_init_battery_monitor(bt_adapter_disable_battery_cb callback,
 622                                                         void *user_data)
 623 {
 624         BT_CHECK_SUPPORTED_FEATURE(BT_FEATURE_COMMON);
 625         BT_CHECK_INIT_STATUS();
 626         //BT_CHECK_INPUT_PARAMETER(callback); Callback functionality to be implemented in a later version
 627
 628         int ret = bluetooth_set_battery_monitor_state(TRUE);
 629         if (ret != BT_ERROR_NONE) {
 630                 BT_ERR("Battery monitor could not be activated");
 631                 return BT_ERROR_OPERATION_FAILED;
 632         }
 633
 634         if (callback != NULL) /*Callback functionality to be implemented in a later version*/
 635                 _bt_set_cb(BT_EVENT_ADAPTER_DISABLED_BATTERY_DATA, callback, user_data);
 636
 637         return BT_ERROR_NONE;
 638 }
 639
 640 int bt_adapter_deinit_battery_monitor(void)
 641 {
 642         BT_CHECK_SUPPORTED_FEATURE(BT_FEATURE_COMMON);
 643         BT_CHECK_INIT_STATUS();
 644
 645         int ret = bluetooth_set_battery_monitor_state(FALSE);
 646         if (ret != BT_ERROR_NONE) {
 647                 BT_ERR("Battery monitor could not be deactivated");
 648                 return BT_ERROR_OPERATION_FAILED;
 649         }
 650
 651         _bt_unset_cb(BT_EVENT_ADAPTER_DISABLED_BATTERY_DATA);
 652         return BT_ERROR_NONE;
 653 }
 654
 655 int bt_adapter_get_connectable(bool *connectable)
 656 {
 657         gboolean is_connectable = FALSE;
 658         int ret = BT_ERROR_NONE;
 659
 660         BT_CHECK_SUPPORTED_FEATURE(BT_FEATURE_COMMON);
 661         BT_CHECK_INIT_STATUS();
 662         BT_CHECK_INPUT_PARAMETER(connectable);
 663
 664         ret = _bt_get_error_code(bluetooth_is_connectable(&is_connectable));
 665         if (ret != BT_ERROR_NONE) {
 666                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
 667                 return ret;
 668         }
 669
 670         *connectable = is_connectable ? true : false;
 671
 672         return BT_ERROR_NONE;
 673 }
 674
 675 int bt_adapter_set_connectable(bool connectable)
 676 {
 677         int error_code = BT_ERROR_NONE;
 678
 679         BT_CHECK_SUPPORTED_FEATURE(BT_FEATURE_COMMON);
 680         BT_CHECK_INIT_STATUS();
 681
 682         error_code = _bt_get_error_code(bluetooth_set_connectable(connectable));
 683         if (error_code != BT_ERROR_NONE) { /* LCOV_EXCL_LINE */
 684                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code),
 685                                         error_code); /* LCOV_EXCL_LINE */
 686         } /* LCOV_EXCL_LINE */
 687
 688         return error_code;
 689 }
 690 /* LCOV_EXCL_STOP */
 691
 692 int bt_adapter_foreach_bonded_device(bt_adapter_bonded_device_cb foreach_cb,
 693                                                         void *user_data)
 694 {
 695         GPtrArray *dev_list = NULL;
 696         bt_device_info_s *dev_info = NULL;
 697         bluetooth_device_info_t *ptr = NULL;
 698         int ret = BT_ERROR_NONE;
 699         int i = 0;
 700
 701         BT_CHECK_SUPPORTED_FEATURE(BT_FEATURE_COMMON);
 702         BT_CHECK_INIT_STATUS();
 703         BT_CHECK_INPUT_PARAMETER(foreach_cb);
 704
 705         dev_list = g_ptr_array_new();
 706         if (dev_list == NULL) {
 707                 BT_ERR("OUT_OF_MEMORY(0x%08x)", /* LCOV_EXCL_LINE */
 708                                 BT_ERROR_OUT_OF_MEMORY); /* LCOV_EXCL_LINE */
 709                 return BT_ERROR_OUT_OF_MEMORY;
 710         }
 711
 712         ret = _bt_get_error_code(bluetooth_get_bonded_device_list(&dev_list));
 713         if (ret != BT_ERROR_NONE) {
 714                 BT_ERR("%s(0x%08x) : Failed to get bonded device list", /* LCOV_EXCL_LINE */
 715                 _bt_convert_error_to_string(ret), ret); /* LCOV_EXCL_LINE */
 716                 g_ptr_array_free(dev_list, TRUE);
 717                 return ret;
 718         }
 719
 720         for (i = 0; i < dev_list->len; i++) { /* LCOV_EXCL_LINE */
 721                 ptr = g_ptr_array_index(dev_list, i);
 722                 if (ptr != NULL) {
 723                         ret = _bt_get_bt_device_info_s(&dev_info,
 724                                         (bluetooth_device_info_t *)ptr);
 725                         if (ret != BT_ERROR_NONE) {
 726                                 BT_ERR("%s(0x%08x) : Failed to get device info", /* LCOV_EXCL_LINE */
 727                                         _bt_convert_error_to_string(ret),
 728                                         ret); /* LCOV_EXCL_LINE */
 729                                 break;
 730                         }
 731
 732                         if (!foreach_cb(dev_info, user_data)) {
 733                                 _bt_free_bt_device_info_s(dev_info);
 734                                 break;
 735                         }
 736                         _bt_free_bt_device_info_s(dev_info); /* LCOV_EXCL_LINE */
 737                 } else {
 738                         BT_ERR("OPERATION_FAILED(0x%08x)", /* LCOV_EXCL_LINE */
 739                         BT_ERROR_OPERATION_FAILED); /* LCOV_EXCL_LINE */
 740                         ret = BT_ERROR_OPERATION_FAILED;
 741                         break;
 742                 }
 743         }
 744
 745         g_ptr_array_foreach(dev_list, (GFunc)g_free, NULL);
 746         g_ptr_array_free(dev_list, TRUE);
 747
 748         return ret;
 749 }
 750
 751 int bt_adapter_get_bonded_device_info(const char *remote_address,
 752                                         bt_device_info_s **device_info)
 753 {
 754         int ret;
 755         bluetooth_device_address_t addr_hex = { {0,} };
 756         bluetooth_device_info_t *info;
 757
 758         BT_CHECK_SUPPORTED_FEATURE(BT_FEATURE_COMMON);
 759         BT_CHECK_INIT_STATUS();
 760         BT_CHECK_INPUT_PARAMETER(remote_address); /* LCOV_EXCL_START */
 761
 762         info = (bluetooth_device_info_t *)malloc(sizeof(bluetooth_device_info_t));
 763         if (info == NULL)
 764                 return BT_ERROR_OUT_OF_MEMORY;
 765
 766         _bt_convert_address_to_hex(&addr_hex, remote_address);
 767
 768         ret = _bt_get_error_code(bluetooth_get_bonded_device(&addr_hex, info));
 769         if (ret != BT_ERROR_NONE) {
 770                 BT_ERR("%s(0x%08x) : Failed to run function",
 771                                 _bt_convert_error_to_string(ret),
 772                                 ret);
 773         } else {
 774                 ret = _bt_get_bt_device_info_s(device_info, info);
 775                 if (ret != BT_ERROR_NONE) {
 776                         BT_ERR("%s(0x%08x) : Failed to get device info",
 777                                         _bt_convert_error_to_string(ret),
 778                                         ret);
 779                 }
 780         }
 781
 782         free(info);
 783
 784         return ret; /* LCOV_EXCL_STOP */
 785 }
 786
 787 int bt_adapter_free_device_info(bt_device_info_s *device_info)
 788 {
 789         BT_CHECK_SUPPORTED_FEATURE(BT_FEATURE_COMMON);
 790         BT_CHECK_INIT_STATUS();
 791         BT_CHECK_INPUT_PARAMETER(device_info);
 792
 793         _bt_free_bt_device_info_s(device_info); /* LCOV_EXCL_LINE */
 794
 795         return BT_ERROR_NONE; /* LCOV_EXCL_LINE */
 796 }
 797
 798 int bt_adapter_is_service_used(const char *service_uuid, bool *used)
 799 {
 800         int ret = BT_ERROR_NONE;
 801         gboolean is_used = FALSE;
 802
 803         BT_CHECK_SUPPORTED_FEATURE(BT_FEATURE_COMMON);
 804         BT_CHECK_INIT_STATUS();
 805         BT_CHECK_INPUT_PARAMETER(service_uuid);
 806         BT_CHECK_INPUT_PARAMETER(used);
 807
 808         if (strcmp(service_uuid, OPP_UUID) == 0) {
 809                 *used = bluetooth_obex_server_is_activated();
 810         } else {
 811                 ret = _bt_get_error_code(bluetooth_is_service_used(
 812                                         service_uuid, /* LCOV_EXCL_LINE */
 813                                         &is_used));
 814                 *used = is_used ? true : false; /* LCOV_EXCL_LINE */
 815         }
 816         /* TODO: MAP? see above */
 817
 818         if (ret != BT_ERROR_NONE) { /* LCOV_EXCL_LINE */
 819                 BT_ERR("%s(0x%08x) : Failed to run function",
 820                                 _bt_convert_error_to_string(ret),
 821                                 ret); /* LCOV_EXCL_LINE */
 822         } /* LCOV_EXCL_LINE */
 823
 824         return ret;
 825 }
 826
 827 /* LCOV_EXCL_START */
 828 int bt_adapter_foreach_profile_connected_devices(const char *profile_uuid,
 829         bt_adapter_profile_connected_devices_cb callback, void *user_data)
 830 {
 831         char *uuid128;
 832         GPtrArray *addr_list = NULL;
 833         bluetooth_device_address_t *remote_addr = NULL;
 834         char *remote_address = NULL;
 835         int ret = BT_ERROR_NONE;
 836         int i = 0;
 837
 838         BT_CHECK_SUPPORTED_FEATURE(BT_FEATURE_COMMON);
 839         BT_CHECK_INIT_STATUS();
 840         BT_CHECK_INPUT_PARAMETER(profile_uuid);
 841         BT_CHECK_INPUT_PARAMETER(callback);
 842
 843         uuid128 = _bt_convert_uuid_to_uuid128(profile_uuid);
 844         if (uuid128 == NULL) {
 845                 BT_ERR("Wrong type of uuid : %s", profile_uuid);
 846                 return BT_ERROR_INVALID_PARAMETER;
 847         }
 848
 849         addr_list = g_ptr_array_new();
 850         if (addr_list == NULL) {
 851                 BT_ERR("OUT_OF_MEMORY(0x%08x)", BT_ERROR_OUT_OF_MEMORY);
 852                 g_free(uuid128);
 853                 return BT_ERROR_OUT_OF_MEMORY;
 854         }
 855
 856         ret = _bt_get_error_code(
 857                 bluetooth_get_profile_connected_device_list(uuid128, &addr_list));
 858         g_free(uuid128);
 859         if (ret != BT_ERROR_NONE) {
 860                 BT_ERR("%s(0x%08x) : Failed to get profile connected device list",
 861                                 _bt_convert_error_to_string(ret), ret);
 862                 g_ptr_array_free(addr_list, TRUE);
 863                 return ret;
 864         }
 865
 866         for (i = 0; i < addr_list->len; i++) {
 867                 remote_addr = g_ptr_array_index(addr_list, i);
 868                 if (remote_addr != NULL) {
 869                         ret = _bt_convert_address_to_string(&remote_address, remote_addr);
 870                         if (ret != BT_ERROR_NONE) {
 871                                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
 872                                 break;
 873                         }
 874
 875                         if (!callback(remote_address, user_data)) {
 876                                 g_free(remote_address);
 877                                 break;
 878                         }
 879                         g_free(remote_address);
 880                 } else {
 881                         BT_ERR("OPERATION_FAILED(0x%08x)", BT_ERROR_OPERATION_FAILED);
 882                         ret = BT_ERROR_OPERATION_FAILED;
 883                         break;
 884                 }
 885         }
 886
 887         g_ptr_array_foreach(addr_list, (GFunc)g_free, NULL);
 888         g_ptr_array_free(addr_list, TRUE);
 889
 890         return ret;
 891 }
 892 /* LCOV_EXCL_STOP */
 893
 894 int bt_adapter_set_state_changed_cb(bt_adapter_state_changed_cb callback,
 895                                                         void *user_data)
 896 {
 897         BT_CHECK_SUPPORTED_FEATURE(BT_FEATURE_COMMON);
 898         BT_CHECK_INIT_STATUS();
 899         BT_CHECK_INPUT_PARAMETER(callback);
 900
 901         _bt_set_cb(BT_EVENT_STATE_CHANGED, callback, user_data);
 902
 903         return BT_ERROR_NONE;
 904 }
 905
 906 /* LCOV_EXCL_START */
 907 int bt_adapter_le_set_state_changed_cb(bt_adapter_le_state_changed_cb callback,
 908                                                         void *user_data)
 909 {
 910         BT_CHECK_SUPPORTED_FEATURE(BT_FEATURE_COMMON);
 911         BT_CHECK_INIT_STATUS();
 912         BT_CHECK_INPUT_PARAMETER(callback);
 913
 914         _bt_le_adapter_init();
 915         _bt_set_cb(BT_EVENT_LE_STATE_CHANGED, callback, user_data);
 916         return BT_ERROR_NONE;
 917 }
 918 /* LCOV_EXCL_STOP */
 919
 920 int bt_adapter_set_name_changed_cb(bt_adapter_name_changed_cb callback,
 921                                                         void *user_data)
 922 {
 923         BT_CHECK_SUPPORTED_FEATURE(BT_FEATURE_COMMON);
 924         BT_CHECK_INIT_STATUS();
 925         BT_CHECK_INPUT_PARAMETER(callback);
 926
 927         _bt_set_cb(BT_EVENT_NAME_CHANGED, callback, user_data);
 928
 929         return BT_ERROR_NONE;
 930 }
 931
 932 int bt_adapter_set_visibility_mode_changed_cb(bt_adapter_visibility_mode_changed_cb callback,
 933                                                         void *user_data)
 934 {
 935         BT_CHECK_SUPPORTED_FEATURE(BT_FEATURE_COMMON);
 936         BT_CHECK_INIT_STATUS();
 937         BT_CHECK_INPUT_PARAMETER(callback);
 938
 939         _bt_set_cb(BT_EVENT_VISIBILITY_MODE_CHANGED, callback, user_data);
 940
 941         return BT_ERROR_NONE;
 942 }
 943
 944 int bt_adapter_set_device_discovery_state_changed_cb(bt_adapter_device_discovery_state_changed_cb callback,
 945                                                         void *user_data)
 946 {
 947         BT_CHECK_SUPPORTED_FEATURE(BT_FEATURE_COMMON);
 948         BT_CHECK_INIT_STATUS();
 949         BT_CHECK_INPUT_PARAMETER(callback);
 950
 951         _bt_set_cb(BT_EVENT_DEVICE_DISCOVERY_STATE_CHANGED, callback, user_data);
 952
 953         return BT_ERROR_NONE;
 954 }
 955
 956 int bt_adapter_unset_state_changed_cb(void)
 957 {
 958         BT_CHECK_SUPPORTED_FEATURE(BT_FEATURE_COMMON);
 959         BT_CHECK_INIT_STATUS();
 960         _bt_unset_cb(BT_EVENT_STATE_CHANGED);
 961         return BT_ERROR_NONE;
 962 }
 963
 964 /* LCOV_EXCL_START */
 965 int bt_adapter_le_unset_state_changed_cb(void)
 966 {
 967         BT_CHECK_LE_SUPPORT();
 968         BT_CHECK_INIT_STATUS();
 969         _bt_unset_cb(BT_EVENT_LE_STATE_CHANGED);
 970         _bt_le_adapter_deinit();
 971         return BT_ERROR_NONE;
 972 }
 973 /* LCOV_EXCL_STOP */
 974
 975 int bt_adapter_unset_name_changed_cb(void)
 976 {
 977         BT_CHECK_SUPPORTED_FEATURE(BT_FEATURE_COMMON);
 978         BT_CHECK_INIT_STATUS();
 979         _bt_unset_cb(BT_EVENT_NAME_CHANGED);
 980         return BT_ERROR_NONE;
 981 }
 982
 983 int bt_adapter_unset_visibility_mode_changed_cb(void)
 984 {
 985         BT_CHECK_SUPPORTED_FEATURE(BT_FEATURE_COMMON);
 986         BT_CHECK_INIT_STATUS();
 987         _bt_unset_cb(BT_EVENT_VISIBILITY_MODE_CHANGED);
 988         return BT_ERROR_NONE;
 989 }
 990
 991 int bt_adapter_set_visibility_duration_changed_cb(bt_adapter_visibility_duration_changed_cb callback,
 992                                                         void *user_data)
 993 {
 994         BT_CHECK_SUPPORTED_FEATURE(BT_FEATURE_COMMON);
 995         BT_CHECK_INIT_STATUS();
 996         BT_CHECK_INPUT_PARAMETER(callback);
 997
 998         _bt_set_cb(BT_EVENT_VISIBILITY_DURATION_CHANGED, callback, user_data);
 999
1000         return BT_ERROR_NONE;
1001 }
1002
1003 int bt_adapter_unset_visibility_duration_changed_cb(void)
1004 {
1005         BT_CHECK_SUPPORTED_FEATURE(BT_FEATURE_COMMON);
1006         BT_CHECK_INIT_STATUS();
1007         _bt_unset_cb(BT_EVENT_VISIBILITY_DURATION_CHANGED);
1008         return BT_ERROR_NONE;
1009 }
1010
1011 int bt_adapter_unset_device_discovery_state_changed_cb(void)
1012 {
1013         BT_CHECK_SUPPORTED_FEATURE(BT_FEATURE_COMMON);
1014         BT_CHECK_INIT_STATUS();
1015         _bt_unset_cb(BT_EVENT_DEVICE_DISCOVERY_STATE_CHANGED);
1016         return BT_ERROR_NONE;
1017 }
1018
1019 int bt_adapter_start_device_discovery(void)
1020 {
1021         int error_code = BT_ERROR_NONE;
1022
1023         BT_CHECK_SUPPORTED_FEATURE(BT_FEATURE_COMMON);
1024         BT_CHECK_INIT_STATUS();
1025         error_code = _bt_get_error_code(bluetooth_start_discovery(0, 0,
1026                                         BLUETOOTH_DEVICE_MAJOR_MASK_MISC));
1027         if (error_code != BT_ERROR_NONE) { /* LCOV_EXCL_LINE */
1028                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code),
1029                                         error_code); /* LCOV_EXCL_LINE */
1030         } /* LCOV_EXCL_LINE */
1031         return error_code;
1032 }
1033
1034 int bt_adapter_stop_device_discovery(void)
1035 {
1036         int error_code = BT_ERROR_NONE;
1037
1038         BT_CHECK_SUPPORTED_FEATURE(BT_FEATURE_COMMON);
1039         BT_CHECK_INIT_STATUS();
1040         error_code = _bt_get_error_code(bluetooth_cancel_discovery());
1041         if (error_code != BT_ERROR_NONE) { /* LCOV_EXCL_LINE */
1042                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code),
1043                                         error_code); /* LCOV_EXCL_LINE */
1044         } /* LCOV_EXCL_LINE */
1045         return error_code;
1046 }
1047
1048 int bt_adapter_is_discovering(bool *is_discovering)
1049 {
1050         int ret = 0;
1051
1052         BT_CHECK_SUPPORTED_FEATURE(BT_FEATURE_COMMON);
1053         BT_CHECK_INIT_STATUS();
1054         BT_CHECK_INPUT_PARAMETER(is_discovering);
1055
1056         ret = bluetooth_is_discovering();
1057         if (ret >= BLUETOOTH_ERROR_BASE) {
1058                 *is_discovering = (ret == 1) ? true : false;
1059                 return BT_ERROR_NONE;
1060         } else {
1061                 ret = _bt_get_error_code(ret); /* LCOV_EXCL_LINE */
1062                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret),
1063                                                 ret); /* LCOV_EXCL_LINE */
1064                 return ret; /* LCOV_EXCL_LINE */
1065         }
1066 }
1067
1068 /* LCOV_EXCL_START */
1069 int bt_adapter_le_is_discovering(bool *is_discovering)
1070 {
1071         int ret = 0;
1072
1073         BT_CHECK_LE_SUPPORT();
1074         BT_CHECK_INIT_STATUS();
1075         BT_CHECK_INPUT_PARAMETER(is_discovering);
1076
1077         ret = bluetooth_is_le_discovering();
1078         if (ret >= BLUETOOTH_ERROR_BASE) {
1079                 *is_discovering = (ret == 1) ? true : false;
1080                 return BT_ERROR_NONE;
1081         } else {
1082                 ret = _bt_get_error_code(ret); /* LCOV_EXCL_LINE */
1083                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret),
1084                                                 ret); /* LCOV_EXCL_LINE */
1085                 return ret; /* LCOV_EXCL_LINE */
1086         }
1087 }
1088 /* LCOV_EXCL_STOP */
1089
1090 int bt_adapter_get_local_oob_data(unsigned char **hash,
1091                                         unsigned char **randomizer,
1092                                         int *hash_len, int *randomizer_len)
1093 {
1094         int ret = BT_ERROR_NONE;
1095
1096         BT_CHECK_SUPPORTED_FEATURE(BT_FEATURE_OOB);
1097         BT_CHECK_INIT_STATUS();
1098         BT_CHECK_INPUT_PARAMETER(hash);
1099         BT_CHECK_INPUT_PARAMETER(randomizer);
1100         BT_CHECK_INPUT_PARAMETER(hash_len);
1101         BT_CHECK_INPUT_PARAMETER(randomizer_len);
1102
1103         bt_oob_data_t oob_data;
1104
1105         ret = _bt_get_error_code(bluetooth_oob_read_local_data(&oob_data));
1106         if (BT_ERROR_NONE == ret) {
1107                 if (oob_data.hash_len > BLUETOOTH_OOB_DATA_LENGTH)
1108                         oob_data.hash_len = BLUETOOTH_OOB_DATA_LENGTH;
1109
1110                 if (oob_data.randomizer_len > BLUETOOTH_OOB_DATA_LENGTH)
1111                         oob_data.randomizer_len = BLUETOOTH_OOB_DATA_LENGTH;
1112
1113                 *hash = g_memdup(oob_data.hash, oob_data.hash_len);
1114                 *randomizer = g_memdup(oob_data.randomizer,
1115                                                 oob_data.randomizer_len);
1116                 *hash_len = oob_data.hash_len;
1117                 *randomizer_len = oob_data.randomizer_len;
1118         } else {
1119                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret),
1120                                                 ret); /* LCOV_EXCL_LINE */
1121         }
1122         return ret;
1123 }
1124
1125 int bt_adapter_set_remote_oob_data(const char *remote_address,
1126                                 unsigned char *hash, unsigned char *randomizer,
1127                                 int hash_len, int randomizer_len)
1128 {
1129         int ret = BT_ERROR_NONE;
1130         bluetooth_device_address_t addr_hex = { {0,} };
1131         bt_oob_data_t oob_data = { {0},};
1132         int len;
1133
1134         BT_CHECK_SUPPORTED_FEATURE(BT_FEATURE_OOB);
1135         BT_CHECK_INIT_STATUS();
1136         BT_CHECK_INPUT_PARAMETER(remote_address); /* LCOV_EXCL_START */
1137
1138         _bt_convert_address_to_hex(&addr_hex, remote_address);
1139
1140         if (hash && randomizer) {
1141                 len = hash_len < BLUETOOTH_OOB_DATA_LENGTH ?
1142                         hash_len : BLUETOOTH_OOB_DATA_LENGTH;
1143                 memcpy(oob_data.hash, hash, len);
1144                 oob_data.hash_len = len;
1145
1146                 len = randomizer_len < BLUETOOTH_OOB_DATA_LENGTH ?
1147                         randomizer_len : BLUETOOTH_OOB_DATA_LENGTH;
1148                 memcpy(oob_data.randomizer, randomizer, len);
1149                 oob_data.randomizer_len = len;
1150         } else {
1151                 return BT_ERROR_INVALID_PARAMETER;
1152         }
1153
1154         ret = _bt_get_error_code(bluetooth_oob_add_remote_data(&addr_hex,
1155                                         BLUETOOTH_BDADDR_BREDR,
1156                                         &oob_data));
1157         if (BT_ERROR_NONE != ret) {
1158                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret),
1159                                                 ret);
1160         }
1161         return ret; /* LCOV_EXCL_STOP */
1162 }
1163
1164 int bt_adapter_get_local_oob_ext_data(unsigned char **hash192, unsigned char **randomizer192,
1165                 int *hash192_len, int *randomizer192_len,
1166                 unsigned char **hash256, unsigned char **randomizer256,
1167                 int *hash256_len, int *randomizer256_len)
1168 {
1169         int ret = BT_ERROR_NONE;
1170
1171         BT_CHECK_SUPPORTED_FEATURE(BT_FEATURE_OOB);
1172         BT_CHECK_INIT_STATUS();
1173         BT_CHECK_INPUT_PARAMETER(hash192);
1174         BT_CHECK_INPUT_PARAMETER(randomizer192);
1175         BT_CHECK_INPUT_PARAMETER(hash192_len);
1176         BT_CHECK_INPUT_PARAMETER(randomizer192_len);
1177         BT_CHECK_INPUT_PARAMETER(hash256);
1178         BT_CHECK_INPUT_PARAMETER(randomizer256);
1179         BT_CHECK_INPUT_PARAMETER(hash256_len);
1180         BT_CHECK_INPUT_PARAMETER(randomizer256_len);
1181
1182         bt_oob_data_t oob_data;
1183
1184         ret = _bt_get_error_code(bluetooth_oob_read_local_data(&oob_data));
1185         if (BT_ERROR_NONE == ret) {
1186                 *hash192 = *randomizer192 = NULL;
1187                 *hash192_len = *randomizer192_len = 0;
1188
1189                 *hash256 = *randomizer256 = NULL;
1190                 *hash256_len = *randomizer256_len = 0;
1191
1192                 if (oob_data.hash_len && oob_data.randomizer_len) {
1193                         *hash192 = g_memdup(oob_data.hash, oob_data.hash_len);
1194                         *randomizer192 = g_memdup(oob_data.randomizer,
1195                                         oob_data.randomizer_len);
1196
1197                         *hash192_len = oob_data.hash_len;
1198                         *randomizer192_len = oob_data.randomizer_len;
1199                 }
1200
1201                 if (oob_data.hash256_len && oob_data.randomizer256_len) {
1202                         *hash256 = g_memdup(oob_data.hash256, oob_data.hash256_len);
1203                         *randomizer256 = g_memdup(oob_data.randomizer256,
1204                                         oob_data.randomizer256_len);
1205
1206                         *hash256_len = oob_data.hash256_len;
1207                         *randomizer256_len = oob_data.randomizer256_len;
1208                 }
1209         } else {
1210                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
1211         }
1212
1213         return ret;
1214 }
1215
1216 int bt_adapter_set_remote_oob_ext_data(const char *remote_address,
1217                 const unsigned char *hash192, const unsigned char *randomizer192,
1218                 int hash192_len, int randomizer192_len,
1219                 const unsigned char *hash256, const unsigned char *randomizer256,
1220                 int hash256_len, int randomizer256_len)
1221 {
1222         int ret = BT_ERROR_NONE;
1223         bluetooth_device_address_t addr_hex = { {0,} };
1224         bt_oob_data_t oob_data = { {0},};
1225         int len;
1226
1227         BT_CHECK_SUPPORTED_FEATURE(BT_FEATURE_OOB);
1228         BT_CHECK_INIT_STATUS();
1229         BT_CHECK_INPUT_PARAMETER(remote_address);
1230
1231         /* LCOV_EXCL_START */
1232         if ((!hash192 || !randomizer192) && (!hash256 || !randomizer256))
1233                 return BT_ERROR_INVALID_PARAMETER;
1234
1235         _bt_convert_address_to_hex(&addr_hex, remote_address);
1236
1237         if (hash192 && randomizer192) {
1238                 len = hash192_len < BLUETOOTH_OOB_DATA_LENGTH ?
1239                         hash192_len : BLUETOOTH_OOB_DATA_LENGTH;
1240                 memcpy(oob_data.hash, hash192, len);
1241                 oob_data.hash_len = len;
1242
1243                 len = randomizer192_len < BLUETOOTH_OOB_DATA_LENGTH ?
1244                         randomizer192_len : BLUETOOTH_OOB_DATA_LENGTH;
1245                 memcpy(oob_data.randomizer, randomizer192, len);
1246                 oob_data.randomizer_len = len;
1247         }
1248
1249         if (hash256 && randomizer256) {
1250                 len = hash256_len < BLUETOOTH_OOB_DATA_LENGTH ?
1251                         hash256_len : BLUETOOTH_OOB_DATA_LENGTH;
1252                 memcpy(oob_data.hash256, hash256, len);
1253                 oob_data.hash256_len = len;
1254
1255                 len = randomizer256_len < BLUETOOTH_OOB_DATA_LENGTH ?
1256                         randomizer256_len : BLUETOOTH_OOB_DATA_LENGTH;
1257                 memcpy(oob_data.randomizer256, randomizer256, len);
1258                 oob_data.randomizer256_len = len;
1259         }
1260
1261         ret = _bt_get_error_code(bluetooth_oob_add_remote_data(&addr_hex,
1262                                 BLUETOOTH_BDADDR_BREDR, &oob_data));
1263         if (BT_ERROR_NONE != ret)
1264                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
1265
1266         return ret; /* LCOV_EXCL_STOP */
1267 }
1268
1269 /* LCOV_EXCL_START */
1270 int bt_adapter_le_get_local_oob_ext_data(char **local_address, bt_device_address_type_e *address_type,
1271                 unsigned char **confirmation, unsigned char **random,
1272                 int *confirmation_len, int *random_len)
1273 {
1274         int ret = BT_ERROR_NONE;
1275         unsigned char *eir_data = NULL;
1276         unsigned char *field_data = NULL;
1277         int eir_len = 0;
1278         int field_len = 0;
1279         bt_oob_data_t oob_data;
1280
1281         #define EIR_FLAGS               0x01
1282         #define EIR_LE_BDADDR           0x1B
1283         #define EIR_LE_ROLE             0x1C
1284         #define EIR_LE_SC_CONFIRM       0x22
1285         #define EIR_LE_SC_RANDOM        0x23
1286
1287         BT_CHECK_SUPPORTED_FEATURE(BT_FEATURE_OOB);
1288         BT_CHECK_INIT_STATUS();
1289         BT_CHECK_INPUT_PARAMETER(local_address);
1290         BT_CHECK_INPUT_PARAMETER(address_type);
1291         BT_CHECK_INPUT_PARAMETER(confirmation);
1292         BT_CHECK_INPUT_PARAMETER(random);
1293         BT_CHECK_INPUT_PARAMETER(confirmation_len);
1294         BT_CHECK_INPUT_PARAMETER(random_len);
1295
1296
1297         ret = _bt_get_error_code(bluetooth_le_oob_read_local_data(&oob_data));
1298         if (BT_ERROR_NONE == ret) {
1299                 eir_data = oob_data.eir;
1300                 eir_len = oob_data.eir_len;
1301
1302                 while (eir_len > 1) {
1303                         BT_DBG("eir_data [%02x %02x ...]", eir_data[0], eir_data[1]);
1304                         field_len = eir_data[0];
1305                         if (eir_data[1] == EIR_LE_BDADDR || eir_data[1] == EIR_LE_SC_CONFIRM || eir_data[1] == EIR_LE_SC_RANDOM) {
1306                                 field_data = g_malloc0(sizeof(char) * field_len - 1);
1307                                 memcpy(field_data, &eir_data[2], field_len - 1);
1308
1309                                 if (eir_data[1] == EIR_LE_BDADDR) {
1310                                         char address[18] = { 0, };
1311                                         snprintf(address, 18, "%02X:%02X:%02X:%02X:%02X:%02X",
1312                                                         field_data[5], field_data[4], field_data[3], field_data[2], field_data[1], field_data[0]);
1313                                         *local_address = strdup(address);
1314                                         *address_type = field_data[6];
1315                                         g_free(field_data);
1316                                 } else if (eir_data[1] == EIR_LE_SC_CONFIRM) {
1317                                         *confirmation = field_data;
1318                                         *confirmation_len = field_len - 1;
1319                                 } else if (eir_data[1] == EIR_LE_SC_RANDOM) {
1320                                         *random = field_data;
1321                                         *random_len = field_len - 1;
1322                                 }
1323                         }
1324
1325                         eir_len = eir_len - field_len - 1;
1326                         eir_data += field_len + 1;
1327                 }
1328         } else {
1329                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
1330         }
1331
1332         return ret;
1333 }
1334 /* LCOV_EXCL_STOP */
1335
1336 /* LCOV_EXCL_START */
1337 int bt_adapter_le_set_remote_oob_ext_data(const char *remote_address,
1338                 bt_device_address_type_e address_type,
1339                 const unsigned char *hash256, const unsigned char *randomizer256,
1340                 int hash256_len, int randomizer256_len)
1341 {
1342         int ret = BT_ERROR_NONE;
1343         bluetooth_device_address_t addr_hex = { {0,} };
1344         bt_oob_data_t oob_data = { {0},};
1345         bluetooth_bdaddr_type_e addr_type = BLUETOOTH_BDADDR_LE_PUBLIC;
1346         int len;
1347
1348         BT_CHECK_SUPPORTED_FEATURE(BT_FEATURE_OOB);
1349         BT_CHECK_INIT_STATUS();
1350         BT_CHECK_INPUT_PARAMETER(remote_address);
1351
1352         if (!hash256 || !randomizer256)
1353                 return BT_ERROR_INVALID_PARAMETER;
1354
1355         _bt_convert_address_to_hex(&addr_hex, remote_address);
1356
1357         if (hash256 && randomizer256) {
1358                 len = hash256_len < BLUETOOTH_OOB_DATA_LENGTH ?
1359                         hash256_len : BLUETOOTH_OOB_DATA_LENGTH;
1360                 memcpy(oob_data.hash256, hash256, len);
1361                 oob_data.hash256_len = len;
1362
1363                 len = randomizer256_len < BLUETOOTH_OOB_DATA_LENGTH ?
1364                         randomizer256_len : BLUETOOTH_OOB_DATA_LENGTH;
1365                 memcpy(oob_data.randomizer256, randomizer256, len);
1366                 oob_data.randomizer256_len = len;
1367         }
1368
1369         addr_type = (address_type == BT_DEVICE_PUBLIC_ADDRESS) ?
1370                                         BLUETOOTH_BDADDR_LE_PUBLIC : BLUETOOTH_BDADDR_LE_RANDOM;
1371
1372         ret = _bt_get_error_code(bluetooth_le_oob_add_remote_data(&addr_hex,
1373                                 addr_type, &oob_data));
1374         if (BT_ERROR_NONE != ret)
1375                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
1376
1377         return ret;
1378 }
1379 /* LCOV_EXCL_STOP */
1380
1381 int bt_adapter_remove_remote_oob_data(const char *remote_address)
1382 {
1383         int ret = BT_ERROR_NONE;
1384         bluetooth_device_address_t addr_hex = { {0,} };
1385
1386         BT_CHECK_SUPPORTED_FEATURE(BT_FEATURE_OOB);
1387         BT_CHECK_INIT_STATUS();
1388         BT_CHECK_INPUT_PARAMETER(remote_address);
1389
1390         _bt_convert_address_to_hex(&addr_hex,
1391                                 remote_address); /* LCOV_EXCL_LINE */
1392
1393         ret = _bt_get_error_code(bluetooth_oob_remove_remote_data(
1394                                                 &addr_hex)); /* LCOV_EXCL_LINE */
1395         if (BT_ERROR_NONE != ret) { /* LCOV_EXCL_LINE */
1396                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret),
1397                                                 ret); /* LCOV_EXCL_LINE */
1398         } /* LCOV_EXCL_LINE */
1399         return ret; /* LCOV_EXCL_LINE */
1400 }
1401
1402 /* LCOV_EXCL_START */
1403 int bt_adapter_set_manufacturer_data(char *data, int len)
1404 {
1405
1406         int ret;
1407         bluetooth_manufacturer_data_t m_data = { 0 };
1408
1409         BT_CHECK_SUPPORTED_FEATURE(BT_FEATURE_COMMON);
1410         BT_CHECK_INIT_STATUS();
1411         BT_CHECK_INPUT_PARAMETER(data);
1412
1413         if (len + 2 > sizeof(m_data.data) || len < 0)
1414                 return BT_ERROR_INVALID_PARAMETER;
1415
1416         m_data.data_len = len;
1417         m_data.data[0] = len + 1;
1418         m_data.data[1] = 0xFF;
1419
1420         memcpy(&m_data.data[2], data, len);
1421
1422         ret = _bt_get_error_code(bluetooth_set_manufacturer_data(&m_data));
1423         if (ret != BT_ERROR_NONE) {
1424                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret),
1425                                                 ret);
1426         }
1427
1428         return ret;
1429 }
1430
1431 int bt_adapter_parse_manufacturer_data(bt_manufacturer_data *data, char *manufacturer_data, int manufacturer_data_len)
1432 {
1433
1434         int cursor, name_len;
1435
1436         BT_CHECK_SUPPORTED_FEATURE(BT_FEATURE_COMMON);
1437         BT_CHECK_INIT_STATUS();
1438         BT_CHECK_INPUT_PARAMETER(data);
1439         BT_CHECK_INPUT_PARAMETER(manufacturer_data);
1440
1441         if (manufacturer_data_len < 30) {
1442                 BT_ERR("minimum Size of the smasung specific manufacturer data is greater than 30 ");
1443                 return BT_ERROR_INVALID_PARAMETER;
1444         }
1445         if (manufacturer_data[0] != 0x00 || manufacturer_data[1] != 0x75) {
1446                 BT_ERR("This is not a samsung specific manufaturer data");
1447                 return BT_ERROR_INVALID_PARAMETER;
1448         }
1449
1450         cursor = 2;
1451
1452 /* control and version */
1453         data->version = manufacturer_data[cursor++];
1454
1455 /* service ID */
1456         data->service_id = manufacturer_data[cursor++];
1457
1458 /* Samsung discovery version */
1459         data->discovery_version = manufacturer_data[cursor++];
1460
1461 /* associated service ID */
1462         data->associated_service_id = manufacturer_data[cursor++];
1463
1464 /* Proxamity and locality */
1465         /* type */
1466         data->proximity_locality_type = manufacturer_data[cursor++];
1467
1468         /* info */
1469         data->proximity_locality_info = manufacturer_data[cursor++];
1470
1471 /* Device */
1472         /* type */
1473         data->device_type = manufacturer_data[cursor++];
1474
1475         /* icon */
1476         data->device_icon = manufacturer_data[cursor++];
1477
1478         /* Authentication info */
1479         memcpy(data->auth_info, &(manufacturer_data[cursor]), 5);
1480         cursor = cursor + 5;
1481
1482 /* Connectivity */
1483         /* address type */
1484         data->addr_type = manufacturer_data[cursor++];
1485
1486         /* addr1 */
1487         memcpy(data->addr1, &(manufacturer_data[cursor]), 6);
1488         cursor = cursor + 6;
1489
1490         /* addr2 */
1491         memcpy(data->addr2, &(manufacturer_data[cursor]), 6);
1492         cursor = cursor + 6;
1493
1494         /* channel info */
1495         data->channel_info = manufacturer_data[cursor++];
1496
1497
1498 /* Associated service data */
1499         data->associated_service_data_len = manufacturer_data[cursor++];
1500         if (data->associated_service_data_len) {
1501                 data->associated_service_data_val = g_malloc0(data->associated_service_data_len);
1502                 memcpy(data->associated_service_data_val, &(manufacturer_data[cursor]),
1503                                                 data->associated_service_data_len);
1504
1505                 cursor = cursor + data->associated_service_data_len;
1506         }
1507
1508 /* name : include the null termination */
1509         name_len = manufacturer_data_len - cursor;
1510         if (name_len > 0) {
1511                 data->name = g_malloc0(name_len + 1);
1512                 memcpy(data->name, &(manufacturer_data[cursor]), name_len);
1513                 data->name[name_len] = '\0';
1514         }
1515         return BT_ERROR_NONE;
1516 }
1517
1518 int bt_adapter_free_manufacturer_data(bt_manufacturer_data *data)
1519 {
1520         BT_CHECK_INPUT_PARAMETER(data);
1521         g_free(data->associated_service_data_val);
1522         g_free(data->name);
1523         return BT_ERROR_NONE;
1524 }
1525
1526 int bt_adapter_set_manufacturer_data_changed_cb(
1527                 bt_adapter_manufacturer_data_changed_cb callback,
1528                 void *user_data)
1529 {
1530         BT_CHECK_SUPPORTED_FEATURE(BT_FEATURE_COMMON);
1531         BT_CHECK_INIT_STATUS();
1532         BT_CHECK_INPUT_PARAMETER(callback);
1533
1534         _bt_set_cb(BT_EVENT_MANUFACTURER_DATA_CHANGED,
1535                         callback, user_data);
1536
1537         return BT_ERROR_NONE;
1538 }
1539
1540 int bt_adapter_unset_manufacturer_data_changed_cb(void)
1541 {
1542         BT_CHECK_SUPPORTED_FEATURE(BT_FEATURE_COMMON);
1543         BT_CHECK_INIT_STATUS();
1544         _bt_unset_cb(BT_EVENT_MANUFACTURER_DATA_CHANGED);
1545         return BT_ERROR_NONE;
1546 }
1547
1548 int bt_adapter_set_passkey_notification(
1549                 bt_adapter_passkey_notification_cb callback, void *user_data)
1550 {
1551         int ret = BT_ERROR_NONE;
1552
1553         BT_CHECK_SUPPORTED_FEATURE(BT_FEATURE_COMMON);
1554         BT_CHECK_INIT_STATUS();
1555         BT_CHECK_INPUT_PARAMETER(callback);
1556
1557         ret = _bt_get_error_code(bluetooth_set_passkey_notification(TRUE));
1558         if (ret == BT_ERROR_NONE) {
1559                 _bt_set_cb(BT_EVENT_PASSKEY_NOTIFICATION_EVENT,
1560                                 callback, user_data);
1561         } else {
1562                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
1563         }
1564
1565         return ret;
1566 }
1567
1568 int bt_adapter_unset_passkey_notification(void)
1569 {
1570         int ret = BT_ERROR_NONE;
1571
1572         BT_CHECK_SUPPORTED_FEATURE(BT_FEATURE_COMMON);
1573         BT_CHECK_INIT_STATUS();
1574
1575         ret = _bt_get_error_code(bluetooth_set_passkey_notification(FALSE));
1576         if (ret != BT_ERROR_NONE)
1577                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
1578
1579         _bt_unset_cb(BT_EVENT_PASSKEY_NOTIFICATION_EVENT);
1580
1581         return ret;
1582 }
1583
1584 int bt_adapter_le_add_white_list(const char *address,
1585                                 bt_device_address_type_e address_type)
1586 {
1587         int error_code = BT_ERROR_NONE;
1588         bluetooth_device_address_t addr_hex = { {0,} };
1589
1590         BT_CHECK_LE_SUPPORT();
1591         BT_CHECK_INIT_STATUS();
1592         BT_CHECK_INPUT_PARAMETER(address);
1593         _bt_convert_address_to_hex(&addr_hex, address);
1594
1595         error_code = _bt_get_error_code(bluetooth_add_white_list(&addr_hex,
1596                                                                 address_type));
1597         if (error_code != BT_ERROR_NONE) { /* LCOV_EXCL_LINE */
1598                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code),
1599                                         error_code); /* LCOV_EXCL_LINE */
1600         } /* LCOV_EXCL_LINE */
1601
1602         return error_code;
1603 }
1604
1605 int bt_adapter_le_remove_white_list(const char *address, bt_device_address_type_e address_type)
1606 {
1607         int error_code = BT_ERROR_NONE;
1608         bluetooth_device_address_t addr_hex = { {0,} };
1609
1610         BT_CHECK_SUPPORTED_FEATURE(BT_FEATURE_COMMON);
1611         BT_CHECK_INIT_STATUS();
1612         BT_CHECK_INPUT_PARAMETER(address);
1613         _bt_convert_address_to_hex(&addr_hex, address);
1614
1615         error_code = _bt_get_error_code(bluetooth_remove_white_list(&addr_hex,
1616                                                                 address_type));
1617         if (error_code != BT_ERROR_NONE) { /* LCOV_EXCL_LINE */
1618                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code),
1619                                         error_code); /* LCOV_EXCL_LINE */
1620         } /* LCOV_EXCL_LINE */
1621
1622         return error_code;
1623 }
1624 /* LCOV_EXCL_STOP */
1625
1626 int bt_adapter_le_set_scan_mode(bt_adapter_le_scan_mode_e scan_mode)
1627 {
1628         int ret = BT_ERROR_NONE;
1629         bluetooth_le_scan_params_t scan_params;
1630
1631         BT_CHECK_LE_SUPPORT();
1632         BT_CHECK_INIT_STATUS();
1633
1634         scan_params.type = BT_ADAPTER_LE_ACTIVE_SCAN;
1635
1636         if (scan_mode == BT_ADAPTER_LE_SCAN_MODE_BALANCED) {
1637                 scan_params.interval = 5000;
1638                 scan_params.window = 2000;
1639         } else if (scan_mode == BT_ADAPTER_LE_SCAN_MODE_LOW_LATENCY) {
1640                 scan_params.interval = 5000;
1641                 scan_params.window = 5000;
1642         } else if (scan_mode == BT_ADAPTER_LE_SCAN_MODE_LOW_ENERGY) {
1643                 scan_params.interval = 5000;
1644                 scan_params.window = 500;
1645         } else
1646                 return BT_ERROR_INVALID_PARAMETER;
1647
1648         ret = _bt_get_error_code(bluetooth_set_scan_parameters(&scan_params));
1649         if (ret != BT_ERROR_NONE) { /* LCOV_EXCL_LINE */
1650                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret),
1651                                                 ret); /* LCOV_EXCL_LINE */
1652         } /* LCOV_EXCL_LINE */
1653         return ret;
1654 }
1655
1656 /* LCOV_EXCL_START */
1657 int bt_adapter_le_set_scan_type(bt_adapter_le_scan_type_e scan_type)
1658 {
1659         int ret = BT_ERROR_NONE;
1660
1661         BT_CHECK_LE_SUPPORT();
1662         BT_CHECK_INIT_STATUS();
1663
1664         ret = _bt_get_error_code(bluetooth_set_scan_type(scan_type));
1665         if (ret != BT_ERROR_NONE) { /* LCOV_EXCL_LINE */
1666                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret),
1667                                                 ret); /* LCOV_EXCL_LINE */
1668         } /* LCOV_EXCL_LINE */
1669         return ret;
1670 }
1671 /* LCOV_EXCL_STOP */
1672
1673 /* LCOV_EXCL_START */
1674 int bt_adapter_le_set_customized_scan_mode(float scan_interval, float scan_window)
1675 {
1676         int ret = BT_ERROR_NONE;
1677         bluetooth_le_scan_params_t scan_params;
1678
1679         BT_CHECK_INIT_STATUS();
1680
1681         scan_params.type = BT_ADAPTER_LE_ACTIVE_SCAN;
1682         scan_params.interval = scan_interval;
1683         scan_params.window = scan_window;
1684
1685         ret = _bt_get_error_code(bluetooth_set_scan_parameters(&scan_params));
1686         if (ret != BT_ERROR_NONE)
1687                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
1688
1689         return ret;
1690 }
1691 /* LCOV_EXCL_STOP */
1692
1693 int bt_adapter_le_create_advertiser(bt_advertiser_h *advertiser)
1694 {
1695         bt_advertiser_s *__adv = NULL;
1696
1697         BT_CHECK_LE_SUPPORT();
1698         BT_CHECK_INIT_STATUS();
1699         BT_CHECK_INPUT_PARAMETER(advertiser);
1700
1701         __adv = (bt_advertiser_s *)g_malloc0(sizeof(bt_advertiser_s));
1702         __adv->handle = GPOINTER_TO_INT(__adv);
1703
1704         *advertiser = (bt_advertiser_h)__adv;
1705
1706         advertiser_list = g_slist_append(advertiser_list, __adv);
1707
1708         return BT_ERROR_NONE;
1709 }
1710
1711 int bt_adapter_le_destroy_advertiser(bt_advertiser_h advertiser)
1712 {
1713         int ret = BT_ERROR_NONE;
1714         int error_code;
1715         gboolean is_advertising = FALSE;
1716
1717         bt_advertiser_s *__adv = (bt_advertiser_s *)advertiser;
1718
1719         BT_CHECK_LE_SUPPORT();
1720         BT_CHECK_INIT_STATUS();
1721         BT_CHECK_INPUT_PARAMETER(advertiser);
1722
1723         _bt_unset_cb(BT_EVENT_ADVERTISING_STATE_CHANGED);
1724
1725         /* This operation is not related to the result */
1726         error_code = bluetooth_is_advertising(&is_advertising);
1727
1728         if (is_advertising == TRUE) {
1729                 error_code = bluetooth_set_advertising(__adv->handle, FALSE);
1730
1731                 ret = _bt_get_error_code(error_code);
1732
1733                 if (ret != BT_ERROR_NONE) {
1734                         BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret),
1735                                                         ret); /* LCOV_EXCL_LINE */
1736
1737                         if (ret == BT_ERROR_NOT_IN_PROGRESS) {
1738                                 /* Other advertising handle is in there */
1739                                 ret = BT_ERROR_NONE;
1740                         }
1741 #ifdef TIZEN_FEATURE_TCT_TMP_SUPPORT
1742                 if (ret == BT_ERROR_NOT_SUPPORTED)
1743                         ret = BT_ERROR_NONE;
1744 #endif
1745                 }
1746         }
1747
1748         advertiser_list = g_slist_remove(advertiser_list, __adv);
1749
1750         /* Free advertising data */
1751         g_free(__adv->adv_data);
1752         g_free(__adv->scan_rsp_data);
1753         g_free(__adv);
1754
1755         return ret;
1756 }
1757
1758 /* LCOV_EXCL_START */
1759 static int __bt_remove_ad_data_by_type(char *in_data, unsigned int in_len,
1760                 char in_type, char **data, unsigned int *data_len)
1761 {
1762         if (in_data == NULL || data == NULL || data_len == NULL)
1763                 return BT_ERROR_OPERATION_FAILED;
1764
1765         int i;
1766         int len = 0;
1767         int type = 0;
1768         char *p;
1769
1770         for (i = 0; i < in_len; i++) {
1771                 len = in_data[i];
1772                 if (len <= 0 || i + 1 >= in_len) {
1773                         BT_ERR("Invalid advertising data");
1774                         return BT_ERROR_OPERATION_FAILED;
1775                 }
1776
1777                 type = in_data[i + 1];
1778                 if (type == in_type) {
1779                         i = i + 2;
1780                         len--;
1781                         break;
1782                 }
1783
1784                 i += len;
1785                 len = 0;
1786         }
1787
1788         if (i + len > in_len) {
1789                 BT_ERR("Invalid advertising data");
1790                 return BT_ERROR_OPERATION_FAILED;
1791         } else if (len == 0) {
1792                 BT_INFO("AD Type 0x%02x data is not set", in_type);
1793                 return BT_ERROR_OPERATION_FAILED;
1794         }
1795
1796         p = (char *)malloc(sizeof(char) *(in_len - len));
1797         if (p == NULL)
1798                 return BT_ERROR_OUT_OF_MEMORY;
1799
1800         memcpy(p, in_data, sizeof(char) *i);
1801         memcpy(p + i, in_data + i + len, sizeof(char) *(in_len - len - i));
1802
1803         *data = p;
1804         *data_len = in_len - len;
1805
1806         return BT_ERROR_NONE;
1807 }
1808 /* LCOV_EXCL_STOP */
1809
1810 static int bt_adapter_le_add_advertising_data(bt_advertiser_h advertiser,
1811                 bt_adapter_le_packet_type_e pkt_type,
1812                 bt_adapter_le_advertising_data_type_e data_type,
1813                 void *data, unsigned int data_size)
1814 {
1815         bt_advertiser_s *__adv = (bt_advertiser_s *)advertiser;
1816         char **p;
1817         unsigned int *len;
1818         unsigned int *system_data_len;
1819         char *new_p;
1820         int adv_flag_len = 0;
1821         int adv_ext_len = 0;
1822
1823         BT_CHECK_LE_SUPPORT();
1824         BT_CHECK_INIT_STATUS();
1825         if ((data == NULL || data_size == 0) &&
1826                 (data_type != BT_ADAPTER_LE_ADVERTISING_DATA_LOCAL_NAME &&
1827                 data_type != BT_ADAPTER_LE_ADVERTISING_DATA_TX_POWER_LEVEL)) {
1828                 BT_ERR("empty data for packet type %d",
1829                                         pkt_type); /* LCOV_EXCL_LINE */
1830                 return BT_ERROR_INVALID_PARAMETER; /* LCOV_EXCL_LINE */
1831         }
1832
1833         BT_CHECK_INPUT_PARAMETER(advertiser);
1834
1835         if (pkt_type == BT_ADAPTER_LE_PACKET_ADVERTISING) {
1836                 p = &__adv->adv_data;
1837                 len = &__adv->adv_data_len;
1838                 system_data_len = &__adv->adv_system_data_len;
1839                 adv_flag_len = 3;
1840         } else if (pkt_type == BT_ADAPTER_LE_PACKET_SCAN_RESPONSE) {
1841                 p = &__adv->scan_rsp_data;
1842                 len = &__adv->scan_rsp_data_len;
1843                 system_data_len = &__adv->scan_rsp_system_data_len;
1844         } else
1845                 return BT_ERROR_INVALID_PARAMETER;
1846
1847         if (data_type == BT_ADAPTER_LE_ADVERTISING_DATA_LOCAL_NAME ||
1848                 data_type == BT_ADAPTER_LE_ADVERTISING_DATA_TX_POWER_LEVEL)
1849                 adv_ext_len = *system_data_len + 1;
1850
1851         /* 2 bytes are required for Length and AD Type */
1852         if (adv_flag_len + *len + adv_ext_len + data_size + 2 > 31) {
1853                 BT_ERR("Quota exceeded"); /* LCOV_EXCL_LINE */
1854                 return BT_ERROR_QUOTA_EXCEEDED; /* LCOV_EXCL_LINE */
1855         }
1856
1857         if (*len == 0)
1858                 *p = NULL;
1859
1860         new_p = realloc(*p, sizeof(char) *(*len + data_size + 2));
1861         if (new_p == NULL)
1862                 return BT_ERROR_OUT_OF_MEMORY;
1863
1864         new_p[*len] = data_size + 1;
1865         new_p[*len + 1] = data_type;
1866         if ((data != NULL) && (data_size != 0))
1867                 memcpy(new_p + (*len + 2), data, data_size);
1868
1869         *p = new_p;
1870         *len += data_size + 2;
1871
1872         if (data_type == BT_ADAPTER_LE_ADVERTISING_DATA_LOCAL_NAME ||
1873                 data_type == BT_ADAPTER_LE_ADVERTISING_DATA_TX_POWER_LEVEL)
1874                 *system_data_len += 1;
1875
1876         return BT_ERROR_NONE;
1877 }
1878
1879 /* LCOV_EXCL_START */
1880 static int bt_adapter_le_remove_advertising_data(bt_advertiser_h advertiser,
1881                 bt_adapter_le_packet_type_e pkt_type,
1882                 bt_adapter_le_advertising_data_type_e data_type)
1883 {
1884         int ret = BT_ERROR_NONE;
1885         bt_advertiser_s *__adv = (bt_advertiser_s *)advertiser;
1886         char **p;
1887         unsigned int *len;
1888         unsigned int *system_data_len;
1889         char *new_p = NULL;
1890         unsigned int new_len = 0;
1891
1892         BT_CHECK_LE_SUPPORT();
1893         BT_CHECK_INIT_STATUS();
1894         BT_CHECK_INPUT_PARAMETER(advertiser);
1895
1896         switch (pkt_type) {
1897         case BT_ADAPTER_LE_PACKET_ADVERTISING:
1898                 p = &__adv->adv_data;
1899                 len = &__adv->adv_data_len;
1900                 system_data_len = &__adv->adv_system_data_len;
1901                 break;
1902
1903         case BT_ADAPTER_LE_PACKET_SCAN_RESPONSE:
1904                 p = &__adv->scan_rsp_data;
1905                 len = &__adv->scan_rsp_data_len;
1906                 system_data_len = &__adv->scan_rsp_system_data_len;
1907                 break;
1908
1909         default:
1910                 BT_ERR("Unknown LE packet type : %d",
1911                                         pkt_type);
1912                 return BT_ERROR_INVALID_PARAMETER;
1913         }
1914
1915         ret = __bt_remove_ad_data_by_type(*p, *len, data_type, &new_p, &new_len);
1916         if (ret != BT_ERROR_NONE)
1917                 return ret;
1918
1919         free(*p);
1920         *p = new_p;
1921         *len = new_len;
1922
1923         if (data_type == BT_ADAPTER_LE_ADVERTISING_DATA_LOCAL_NAME ||
1924                 data_type == BT_ADAPTER_LE_ADVERTISING_DATA_TX_POWER_LEVEL)
1925                 *system_data_len -= 1;
1926
1927         return ret;
1928 }
1929 /* LCOV_EXCL_STOP */
1930
1931 static int __bt_convert_string_to_uuid(const char *string,
1932                                         char **uuid, int *bit)
1933 {
1934         char *data;
1935
1936         if (strlen(string) == 4)  { /* 16 bit uuid */
1937                 unsigned short val;
1938                 data = g_malloc0(sizeof(char) * 2);
1939
1940                 val = (unsigned short)strtoul(string, NULL, 16);
1941                 val = htons(val);
1942                 memcpy(data, &val, 2);
1943                 *uuid = data;
1944                 *bit = 16; /* LCOV_EXCL_START */
1945         } else if (strlen(string) == 36)  { /* 128 bit uuid */
1946                 if (string[8] != '-' || string[13] != '-' ||
1947                         string[18] != '-' || string[23] != '-') {
1948                         BT_ERR("Invalid UUID");
1949                         return BT_ERROR_INVALID_PARAMETER;
1950                 }
1951
1952                 char str_ptr[37] = { 0 };
1953                 char *ptr[7];
1954                 char *next_ptr;
1955                 int idx = 0;
1956
1957                 unsigned int val0, val4;
1958                 unsigned short val1, val2, val3, val5;
1959                 data = g_malloc0(sizeof(char) * 16);
1960
1961                 /* UUID format : %08x-%04hx-%04hx-%04hx-%08x%04hx */
1962                 strncpy(str_ptr, string, 36);
1963
1964                 ptr[idx++] = strtok_r(str_ptr, "-", &next_ptr);
1965                 while ((ptr[idx++] = strtok_r(NULL, "-", &next_ptr)) != NULL) {
1966                         BT_INFO("ptr : %s", ptr[idx - 1]);
1967                         if (idx == 5)
1968                                 break;
1969                 }
1970
1971                 /* ptr[4] contain "08x" and "04hx" */
1972                 ptr[5] = g_malloc0(sizeof(char) * 8);
1973                 ptr[6] = g_malloc0(sizeof(char) * 4);
1974                 strncpy(ptr[5], ptr[4], 8);
1975                 strncpy(ptr[6], ptr[4] + 8, 4);
1976
1977                 val0 = (unsigned int)strtoul(ptr[0], NULL, 16);
1978                 val1 = (unsigned short)strtoul(ptr[1], NULL, 16);
1979                 val2 = (unsigned short)strtoul(ptr[2], NULL, 16);
1980                 val3 = (unsigned short)strtoul(ptr[3], NULL, 16);
1981                 val4 = (unsigned int)strtoul(ptr[5], NULL, 16);
1982                 val5 = (unsigned short)strtoul(ptr[6], NULL, 16);
1983
1984                 val0 = htonl(val0);
1985                 val1 = htons(val1);
1986                 val2 = htons(val2);
1987                 val3 = htons(val3);
1988                 val4 = htonl(val4);
1989                 val5 = htons(val5);
1990
1991                 BT_INFO("%x, %x, %x, %x, %x, %x", val0, val1, val2, val3, val4, val5);
1992
1993                 memcpy(data, &val0, 4);
1994                 memcpy(data + 4, &val1, 2);
1995                 memcpy(data + 6, &val2, 2);
1996                 memcpy(data + 8, &val3, 2);
1997                 memcpy(data + 10, &val4, 4);
1998                 memcpy(data + 14, &val5, 2);
1999
2000                 *uuid = data;
2001                 *bit = 128;
2002
2003                 g_free(ptr[5]);
2004                 g_free(ptr[6]);
2005         } else {
2006                 BT_ERR("Invalid UUID");
2007                 return BT_ERROR_INVALID_PARAMETER;
2008         }
2009
2010         return BT_ERROR_NONE; /* LCOV_EXCL_STOP */
2011 }
2012
2013 static int __bt_convert_byte_ordering(char *data, int data_len,
2014                                         char **converted_data)
2015 {
2016         char *swp;
2017         int i, j;
2018
2019         /* Convert to little endian */
2020         swp = g_malloc0(data_len);
2021         for (i = 0, j = data_len - 1; i < data_len; i++, j--)
2022                 swp[i] = data[j];
2023
2024         *converted_data = swp;
2025
2026         return BT_ERROR_NONE;
2027 }
2028
2029 static int __bt_find_adv_data_type(bt_advertiser_h advertiser,
2030                         bt_adapter_le_packet_type_e pkt_type,
2031                         bt_adapter_le_advertising_data_type_e data_type,
2032                         char **data_ptr, int *data_len)
2033 {
2034         int type;
2035         int len;
2036         int i;
2037         char *adv_data = NULL;
2038         int adv_len = 0;
2039         bt_advertiser_s *__adv = (bt_advertiser_s *)advertiser;
2040
2041         if (pkt_type == BT_ADAPTER_LE_PACKET_ADVERTISING) {
2042                 adv_data = __adv->adv_data;
2043                 adv_len = __adv->adv_data_len;
2044         } else if (pkt_type == BT_ADAPTER_LE_PACKET_SCAN_RESPONSE) {
2045                 adv_data = __adv->scan_rsp_data;
2046                 adv_len = __adv->scan_rsp_data_len;
2047         } else
2048                 return BT_ERROR_INVALID_PARAMETER;
2049
2050         if (!adv_data)
2051                 return BT_ERROR_OPERATION_FAILED;
2052
2053         for (i = 0; i < adv_len ; i++) { /* LCOV_EXCL_START */
2054                 len = adv_data[i];
2055                 type = adv_data[i + 1];
2056
2057                 if (type == data_type) {
2058                         *data_ptr = &adv_data[i];
2059                         *data_len = len;
2060                         return BT_ERROR_NONE;
2061                 } else {
2062                         i = i + adv_data[i]; /* LCOV_EXCL_STOP */
2063                 }
2064         }
2065
2066         return BT_ERROR_NONE;
2067 }
2068
2069
2070 /* LCOV_EXCL_START */
2071 static int __bt_append_adv_type_data(bt_advertiser_h advertiser,
2072                         bt_adapter_le_packet_type_e pkt_type,
2073                         char *new_data, int new_data_len,
2074                         bt_adapter_le_advertising_data_type_e data_type,
2075                         char *data_ptr, int data_len)
2076 {
2077         int type;
2078         int len;
2079         int dest_type;
2080         int i;
2081         char *new_adv = NULL;
2082         char *adv_data = NULL;
2083         int adv_len = 0;
2084         int adv_flag_len = 0;
2085         int system_data_len = 0;
2086         bt_advertiser_s *__adv = (bt_advertiser_s *)advertiser;
2087
2088         if (pkt_type == BT_ADAPTER_LE_PACKET_ADVERTISING) {
2089                 adv_data = __adv->adv_data;
2090                 adv_len = __adv->adv_data_len;
2091                 system_data_len = __adv->adv_system_data_len;
2092                 adv_flag_len = 3;
2093         } else if (pkt_type == BT_ADAPTER_LE_PACKET_SCAN_RESPONSE) {
2094                 adv_data = __adv->scan_rsp_data;
2095                 adv_len = __adv->scan_rsp_data_len;
2096                 system_data_len = __adv->scan_rsp_system_data_len;
2097         } else
2098                 return BT_ERROR_INVALID_PARAMETER;
2099
2100         if (!adv_data)
2101                 return BT_ERROR_OPERATION_FAILED;
2102
2103         dest_type = data_ptr[1];
2104
2105         if (data_type != dest_type) {
2106                 BT_ERR("Invalid data type");
2107                 return BT_ERROR_INVALID_PARAMETER;
2108         }
2109
2110         if (adv_flag_len + adv_len + system_data_len + new_data_len > 31) {
2111                 BT_ERR("Quota exceeded");
2112                 return BT_ERROR_QUOTA_EXCEEDED;
2113         }
2114
2115         new_adv = g_malloc0(adv_len + new_data_len);
2116
2117         for (i = 0; i < adv_len; i++) {
2118                 len = adv_data[i];
2119                 type = adv_data[i + 1];
2120
2121                 if (type == dest_type) {
2122                         int rest_data_len;
2123
2124                         memcpy(new_adv + i, &adv_data[i], len + 1);
2125                         memcpy(new_adv + i + len + 1, new_data, new_data_len);
2126                         new_adv[i] += new_data_len;
2127
2128                         rest_data_len = adv_len - (i  + len + 1);
2129                         if (rest_data_len > 0)
2130                                 memcpy(new_adv + i + len + 1 + new_data_len,
2131                                         &adv_data[i + len + 1], rest_data_len);
2132
2133                         break;
2134                 } else {
2135                         memcpy(new_adv + i, &adv_data[i], len + 1);
2136                         i = i + len;
2137                 }
2138         }
2139
2140         if (pkt_type == BT_ADAPTER_LE_PACKET_ADVERTISING) {
2141                 g_free(__adv->adv_data);
2142                 __adv->adv_data = new_adv;
2143                 __adv->adv_data_len += new_data_len;
2144         } else if (pkt_type == BT_ADAPTER_LE_PACKET_SCAN_RESPONSE) {
2145                 g_free(__adv->scan_rsp_data);
2146                 __adv->scan_rsp_data = new_adv;
2147                 __adv->scan_rsp_data_len += new_data_len;
2148         }
2149
2150         return BT_ERROR_NONE;
2151 }
2152 /* LCOV_EXCL_STOP */
2153
2154 int bt_adapter_le_add_advertising_service_uuid(bt_advertiser_h advertiser,
2155                 bt_adapter_le_packet_type_e pkt_type, const char *uuid)
2156 {
2157         int ret = BT_ERROR_NONE;
2158         bt_adapter_le_advertising_data_type_e data_type = 0;
2159         int byte_len = 0;
2160         int uuid_bit = 0;
2161         char *uuid_ptr = NULL;
2162         char *data_ptr = NULL;
2163         char *converted_uuid = NULL;
2164         int data_len = 0;
2165
2166         BT_CHECK_LE_SUPPORT();
2167         BT_CHECK_INIT_STATUS();
2168         BT_CHECK_INPUT_PARAMETER(advertiser);
2169         BT_CHECK_INPUT_PARAMETER(uuid);
2170
2171         ret = __bt_convert_string_to_uuid(uuid, &uuid_ptr, &uuid_bit);
2172         if (ret != BT_ERROR_NONE)
2173                 return ret;
2174
2175         if (uuid_bit == 16) {
2176                 byte_len = 2;
2177                 data_type = BT_ADAPTER_LE_ADVERTISING_DATA_INCOMP_LIST_16_BIT_SERVICE_CLASS_UUIDS;
2178         } else if (uuid_bit == 128) { /* LCOV_EXCL_LINE */
2179                 byte_len = 16; /* LCOV_EXCL_LINE */
2180                 data_type = BT_ADAPTER_LE_ADVERTISING_DATA_INCOMP_LIST_128_BIT_SERVICE_CLASS_UUIDS; /* LCOV_EXCL_LINE */
2181         }
2182
2183         __bt_convert_byte_ordering(uuid_ptr, byte_len, &converted_uuid);
2184         g_free(uuid_ptr);
2185
2186         __bt_find_adv_data_type(advertiser, pkt_type, data_type, &data_ptr, &data_len);
2187         if (data_ptr) {
2188                 ret = __bt_append_adv_type_data(advertiser, pkt_type,
2189                                                 converted_uuid, byte_len,
2190                                                 data_type, data_ptr,
2191                                                 data_len); /* LCOV_EXCL_LINE */
2192         } else {
2193                 ret = bt_adapter_le_add_advertising_data(advertiser, pkt_type,
2194                                                         data_type, converted_uuid,
2195                                                         byte_len);
2196         }
2197         g_free(converted_uuid);
2198
2199         return ret;
2200 }
2201
2202 int bt_adapter_le_add_advertising_service_solicitation_uuid(bt_advertiser_h advertiser,
2203                 bt_adapter_le_packet_type_e pkt_type, const char *uuid)
2204 {
2205         int ret = BT_ERROR_NONE;
2206         bt_adapter_le_advertising_data_type_e data_type = 0;
2207         int byte_len = 0;
2208         int uuid_bit = 0;
2209         char *uuid_ptr = NULL;
2210         char *data_ptr = NULL;
2211         char *converted_uuid = NULL;
2212         int data_len = 0;
2213
2214         BT_CHECK_LE_SUPPORT();
2215         BT_CHECK_INIT_STATUS();
2216         BT_CHECK_INPUT_PARAMETER(advertiser);
2217         BT_CHECK_INPUT_PARAMETER(uuid);
2218
2219         ret = __bt_convert_string_to_uuid(uuid, &uuid_ptr, &uuid_bit);
2220         if (ret != BT_ERROR_NONE)
2221                 return ret;
2222
2223         if (uuid_bit == 16) {
2224                 byte_len = 2;
2225                 data_type = BT_ADAPTER_LE_ADVERTISING_DATA_16_BIT_SERVICE_SOLICITATION_UUIDS;
2226         } else if (uuid_bit == 128) { /* LCOV_EXCL_LINE */
2227                 byte_len = 16; /* LCOV_EXCL_LINE */
2228                 data_type = BT_ADAPTER_LE_ADVERTISING_DATA_128_BIT_SERVICE_SOLICITATION_UUIDS; /* LCOV_EXCL_LINE */
2229         }
2230
2231         __bt_convert_byte_ordering(uuid_ptr, byte_len, &converted_uuid);
2232         g_free(uuid_ptr);
2233
2234         __bt_find_adv_data_type(advertiser, pkt_type, data_type, &data_ptr, &data_len);
2235         if (data_ptr) {
2236                 ret = __bt_append_adv_type_data(advertiser, pkt_type,
2237                                                 converted_uuid, byte_len,
2238                                                 data_type, data_ptr,
2239                                                 data_len); /* LCOV_EXCL_LINE */
2240         } else {
2241                 ret = bt_adapter_le_add_advertising_data(advertiser, pkt_type,
2242                                                         data_type, converted_uuid,
2243                                                         byte_len);
2244         }
2245         g_free(converted_uuid);
2246
2247         return ret;
2248 }
2249
2250 static int __bt_find_uuid_in_service_data(bt_advertiser_h advertiser,
2251                         bt_adapter_le_packet_type_e pkt_type, char * uuid, bool *exist)
2252 {
2253         int type;
2254         int len;
2255         int i;
2256         char *adv_data = NULL;
2257         int adv_len = 0;
2258         bt_advertiser_s *__adv = (bt_advertiser_s *)advertiser;
2259         bt_adapter_le_advertising_data_type_e data_type = BT_ADAPTER_LE_ADVERTISING_DATA_SERVICE_DATA;
2260
2261         if (pkt_type == BT_ADAPTER_LE_PACKET_ADVERTISING) {
2262
2263                 adv_data = __adv->adv_data;
2264                 adv_len = __adv->adv_data_len;
2265         } else if (pkt_type == BT_ADAPTER_LE_PACKET_SCAN_RESPONSE) {
2266                 adv_data = __adv->scan_rsp_data;
2267                 adv_len = __adv->scan_rsp_data_len;
2268         } else
2269                 return BT_ERROR_INVALID_PARAMETER;
2270
2271         if (!adv_data) {
2272                 BT_INFO("Currently there is no advertisement data");
2273                 return BT_ERROR_NONE;
2274         }
2275
2276         i = 0;
2277         while (i < adv_len) {
2278                 len = adv_data[i];
2279                 type = adv_data[i + 1];
2280
2281                 if (type == data_type) {
2282                         if (!memcmp((adv_data + i + 2), uuid, 2)) {
2283                                 BT_INFO("uuid matched");
2284                                 *exist = true;
2285                                 return BT_ERROR_NONE;
2286                         }
2287                 }
2288
2289                 i = len  + 1;
2290         }
2291
2292         *exist = false;
2293         return BT_ERROR_NONE;
2294 }
2295
2296 int bt_adapter_le_add_advertising_service_data(bt_advertiser_h advertiser,
2297                 bt_adapter_le_packet_type_e pkt_type, const char *uuid,
2298                 const char *service_data, int service_data_len)
2299 {
2300         int ret = BT_ERROR_NONE;
2301         char *adv_data = NULL;
2302         int uuid_bit;
2303         char *uuid_ptr;
2304         int byte_len = 0;
2305         char *converted_uuid = NULL;
2306         bool exist = false;
2307
2308         BT_CHECK_LE_SUPPORT();
2309         BT_CHECK_INIT_STATUS();
2310         BT_CHECK_INPUT_PARAMETER(advertiser);
2311         BT_CHECK_INPUT_PARAMETER(service_data);
2312
2313         BT_INFO("Service Data uuid[%s]", uuid);
2314         ret = __bt_convert_string_to_uuid(uuid, &uuid_ptr, &uuid_bit);
2315         if (ret != BT_ERROR_NONE)
2316                 return ret;
2317
2318         if (uuid_bit == 16) {
2319                 byte_len = 2;
2320         } else if (uuid_bit == 128) { /* LCOV_EXCL_LINE */
2321                 BT_ERR("128 bit UUID is not supported"); /* LCOV_EXCL_LINE */
2322                 g_free(uuid_ptr); /* LCOV_EXCL_LINE */
2323                 return BT_ERROR_INVALID_PARAMETER; /* LCOV_EXCL_LINE */
2324         }
2325
2326         __bt_convert_byte_ordering(uuid_ptr, byte_len, &converted_uuid);
2327         g_free(uuid_ptr);
2328
2329         ret = __bt_find_uuid_in_service_data(advertiser, pkt_type, converted_uuid, &exist);
2330         if (ret != BT_ERROR_NONE)
2331                 return ret;
2332
2333         if (exist) {
2334                 BT_INFO("Aleady existed");
2335                 return BT_ERROR_ALREADY_DONE;
2336         }
2337
2338         adv_data = g_malloc0(sizeof(char) *(service_data_len + 2));
2339
2340         memcpy(adv_data, converted_uuid, 2);
2341         memcpy(adv_data + 2, service_data, service_data_len);
2342
2343         ret = bt_adapter_le_add_advertising_data(advertiser,
2344                 pkt_type, BT_ADAPTER_LE_ADVERTISING_DATA_SERVICE_DATA,
2345                 adv_data, service_data_len + 2);
2346
2347         g_free(adv_data);
2348         g_free(converted_uuid);
2349
2350         return ret;
2351 }
2352
2353 int bt_adapter_le_set_advertising_appearance(bt_advertiser_h advertiser,
2354                 bt_adapter_le_packet_type_e pkt_type, int appearance)
2355 {
2356         int ret = BT_ERROR_NONE;
2357         char *data_ptr = NULL;
2358         int data_len;
2359
2360         BT_CHECK_LE_SUPPORT();
2361         BT_CHECK_INIT_STATUS();
2362         BT_CHECK_INPUT_PARAMETER(advertiser);
2363
2364         __bt_find_adv_data_type(advertiser, pkt_type, BT_ADAPTER_LE_ADVERTISING_DATA_APPEARANCE,
2365                                 &data_ptr, &data_len);
2366         if (data_ptr) {
2367                 BT_ERR("Aleady existed"); /* LCOV_EXCL_LINE */
2368                 return BT_ERROR_ALREADY_DONE; /* LCOV_EXCL_LINE */
2369         }
2370
2371         ret = bt_adapter_le_add_advertising_data(advertiser,
2372                 pkt_type, BT_ADAPTER_LE_ADVERTISING_DATA_APPEARANCE, &appearance, 2);
2373
2374         return ret;
2375 }
2376
2377 int bt_adapter_le_add_advertising_manufacturer_data(bt_advertiser_h advertiser,
2378                 bt_adapter_le_packet_type_e pkt_type, int manufacturer_id,
2379                 const char *manufacturer_data, int manufacturer_data_len)
2380 {
2381         int ret = BT_ERROR_NONE;
2382         char *data_ptr = NULL;
2383         int data_len;
2384         char *adv_data = NULL;
2385
2386         BT_CHECK_LE_SUPPORT();
2387         BT_CHECK_INIT_STATUS();
2388         BT_CHECK_INPUT_PARAMETER(advertiser);
2389         BT_CHECK_INPUT_PARAMETER(manufacturer_data);
2390
2391         __bt_find_adv_data_type(advertiser, pkt_type,
2392                                 BT_ADAPTER_LE_ADVERTISING_DATA_MANUFACTURER_SPECIFIC_DATA,
2393                                 &data_ptr, &data_len);
2394         if (data_ptr) {
2395                 BT_ERR("Aleady existed"); /* LCOV_EXCL_LINE */
2396                 return BT_ERROR_ALREADY_DONE; /* LCOV_EXCL_LINE */
2397         }
2398
2399         adv_data = g_malloc0(sizeof(char) *(manufacturer_data_len + 2));
2400
2401         adv_data[0] = manufacturer_id & 0xffffffff;
2402         adv_data[1] = (manufacturer_id & 0xff00) >> 8;
2403         memcpy(adv_data + 2, manufacturer_data, manufacturer_data_len);
2404
2405         ret = bt_adapter_le_add_advertising_data(advertiser,
2406                 pkt_type, BT_ADAPTER_LE_ADVERTISING_DATA_MANUFACTURER_SPECIFIC_DATA,
2407                 adv_data, manufacturer_data_len + 2);
2408
2409         g_free(adv_data);
2410
2411         return ret;
2412 }
2413
2414 int bt_adapter_le_set_advertising_device_name(bt_advertiser_h advertiser,
2415                 bt_adapter_le_packet_type_e pkt_type, bool include_name)
2416 {
2417         int ret = BT_ERROR_NONE;
2418         char *data_ptr = NULL;
2419         int data_len;
2420
2421         BT_CHECK_LE_SUPPORT();
2422         BT_CHECK_INIT_STATUS();
2423         BT_CHECK_INPUT_PARAMETER(advertiser);
2424
2425         if (!include_name) {
2426                 ret = bt_adapter_le_remove_advertising_data(advertiser,
2427                                 pkt_type, /* LCOV_EXCL_LINE */
2428                                 BT_ADAPTER_LE_ADVERTISING_DATA_LOCAL_NAME);
2429                 return ret;
2430         }
2431
2432         __bt_find_adv_data_type(advertiser, pkt_type,
2433                                 BT_ADAPTER_LE_ADVERTISING_DATA_LOCAL_NAME,
2434                                 &data_ptr, &data_len);
2435         if (data_ptr) {
2436                 BT_ERR("Aleady existed"); /* LCOV_EXCL_LINE */
2437                 return BT_ERROR_ALREADY_DONE; /* LCOV_EXCL_LINE */
2438         }
2439
2440         ret = bt_adapter_le_add_advertising_data(advertiser,
2441                                 pkt_type,
2442                                 BT_ADAPTER_LE_ADVERTISING_DATA_LOCAL_NAME,
2443                 NULL, 0);
2444
2445         return ret;
2446 }
2447
2448 int bt_adapter_le_set_advertising_tx_power_level(bt_advertiser_h advertiser,
2449                 bt_adapter_le_packet_type_e pkt_type, bool include_tx_power)
2450 {
2451         int ret = BT_ERROR_NONE;
2452         char *data_ptr = NULL;
2453         int data_len;
2454
2455         BT_CHECK_LE_SUPPORT();
2456         BT_CHECK_INIT_STATUS();
2457         BT_CHECK_INPUT_PARAMETER(advertiser);
2458
2459         if (!include_tx_power) {
2460                 ret = bt_adapter_le_remove_advertising_data(advertiser,
2461                                 pkt_type, /* LCOV_EXCL_LINE */
2462                                 BT_ADAPTER_LE_ADVERTISING_DATA_TX_POWER_LEVEL);
2463                 return ret;
2464         }
2465
2466         __bt_find_adv_data_type(advertiser, pkt_type,
2467                                 BT_ADAPTER_LE_ADVERTISING_DATA_TX_POWER_LEVEL,
2468                                 &data_ptr, &data_len);
2469         if (data_ptr) {
2470                 BT_ERR("Aleady existed"); /* LCOV_EXCL_LINE */
2471                 return BT_ERROR_ALREADY_DONE; /* LCOV_EXCL_LINE */
2472         }
2473
2474         ret = bt_adapter_le_add_advertising_data(advertiser,
2475                                 pkt_type,
2476                                 BT_ADAPTER_LE_ADVERTISING_DATA_TX_POWER_LEVEL,
2477                 NULL, 0);
2478
2479         return ret;
2480 }
2481
2482 int bt_adapter_le_clear_advertising_data(bt_advertiser_h advertiser,
2483                 bt_adapter_le_packet_type_e pkt_type)
2484 {
2485         int ret = BT_ERROR_NONE;
2486         bt_advertiser_s *__adv = (bt_advertiser_s *)advertiser;
2487         char **p;
2488         unsigned int *len;
2489         unsigned int *system_data_len;
2490
2491         BT_CHECK_LE_SUPPORT();
2492         BT_CHECK_INIT_STATUS();
2493         BT_CHECK_INPUT_PARAMETER(advertiser);
2494
2495         switch (pkt_type) {
2496         case BT_ADAPTER_LE_PACKET_ADVERTISING:
2497                 p = &__adv->adv_data;
2498                 len = &__adv->adv_data_len;
2499                 system_data_len = &__adv->adv_system_data_len;
2500                 break;
2501
2502         case BT_ADAPTER_LE_PACKET_SCAN_RESPONSE:
2503                 p = &__adv->scan_rsp_data;
2504                 len = &__adv->scan_rsp_data_len;
2505                 system_data_len = &__adv->scan_rsp_system_data_len;
2506                 break;
2507
2508         default:
2509                 BT_ERR("Unknown LE packet type : %d",
2510                                         pkt_type); /* LCOV_EXCL_LINE */
2511                 return BT_ERROR_INVALID_PARAMETER; /* LCOV_EXCL_LINE */
2512         }
2513
2514         if (*p) {
2515                 free(*p);
2516                 *p = NULL;
2517         }
2518         *len = 0;
2519         *system_data_len = 0;
2520
2521         return ret;
2522 }
2523
2524 int bt_adapter_le_stop_advertising(bt_advertiser_h advertiser)
2525 {
2526         int ret = BT_ERROR_NONE;
2527         bt_advertiser_s *__adv = (bt_advertiser_s *)advertiser;
2528
2529         BT_CHECK_LE_SUPPORT();
2530         BT_CHECK_INIT_STATUS();
2531         BT_CHECK_INPUT_PARAMETER(advertiser);
2532
2533         ret = _bt_get_error_code(bluetooth_set_advertising(__adv->handle,
2534                                                                 FALSE));
2535         if (ret != BT_ERROR_NONE) {
2536                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret),
2537                                                 ret); /* LCOV_EXCL_LINE */
2538         }
2539
2540         return ret;
2541 }
2542
2543 int bt_adapter_le_start_advertising_new(bt_advertiser_h advertiser,
2544                 bt_adapter_le_advertising_state_changed_cb cb, void *user_data)
2545 {
2546         int ret = BT_ERROR_NONE;
2547         int error_code;
2548         bt_advertiser_s *__adv = (bt_advertiser_s *)advertiser;
2549         bluetooth_advertising_data_t adv = { {0} };
2550         bluetooth_scan_resp_data_t resp = { {0} };
2551         bluetooth_advertising_params_t param;
2552         float interval = 500;
2553
2554         BT_CHECK_LE_SUPPORT();
2555         BT_CHECK_INIT_STATUS();
2556         BT_CHECK_INPUT_PARAMETER(advertiser);
2557
2558         if (__adv->adv_data_len > 0 &&
2559                 __adv->adv_data) { /* LCOV_EXCL_START */
2560                 memcpy(adv.data, __adv->adv_data, __adv->adv_data_len);
2561                 error_code = bluetooth_set_advertising_data(__adv->handle,
2562                                         &adv, __adv->adv_data_len);
2563                 ret = _bt_get_error_code(error_code);
2564                 if (ret != BT_ERROR_NONE) {
2565                         BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret),
2566                                                 ret); /* LCOV_EXCL_STOP */
2567                         return ret;
2568                 }
2569         }
2570
2571         if (__adv->scan_rsp_data_len > 0 &&
2572                 __adv->scan_rsp_data) { /* LCOV_EXCL_START */
2573                 memcpy(resp.data, __adv->scan_rsp_data, __adv->scan_rsp_data_len);
2574                 error_code = bluetooth_set_scan_response_data(__adv->handle,
2575                                         &resp, __adv->scan_rsp_data_len);
2576                 ret = _bt_get_error_code(error_code);
2577                 if (ret != BT_ERROR_NONE) {
2578                         BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret),
2579                                                 ret); /* LCOV_EXCL_STOP */
2580                         return ret;
2581                 }
2582         }
2583
2584         if (__adv->adv_params.mode == BT_ADAPTER_LE_ADVERTISING_MODE_BALANCED)
2585                 interval = 500;
2586         else if (__adv->adv_params.mode == BT_ADAPTER_LE_ADVERTISING_MODE_LOW_LATENCY)
2587                 interval = 150;
2588         else if (__adv->adv_params.mode == BT_ADAPTER_LE_ADVERTISING_MODE_LOW_ENERGY)
2589                 interval = 1000;
2590
2591         param.interval_min = interval;
2592         param.interval_max = interval;
2593         param.filter_policy = __adv->adv_params.filter_policy;
2594         param.type = __adv->adv_params.type;
2595         param.tx_power_level = __adv->adv_params.tx_power_level;
2596         error_code = bluetooth_set_custom_advertising(__adv->handle,
2597                                         TRUE, &param);
2598
2599         ret = _bt_get_error_code(error_code);
2600         if (ret != BT_ERROR_NONE) {
2601                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret),
2602                                                 ret); /* LCOV_EXCL_LINE */
2603                 return ret;
2604         }
2605
2606         __adv->cb = cb;
2607         __adv->user_data = user_data;
2608
2609         return ret;
2610 }
2611
2612 void _bt_adapter_le_invoke_advertising_state_cb(int handle, int result,
2613                                 bt_adapter_le_advertising_state_e adv_state)
2614 {
2615         const GSList *l = NULL;
2616
2617         for (l = advertiser_list; l; l = g_slist_next(l)) {
2618                 bt_advertiser_s *__adv = (bt_advertiser_s *)l->data;
2619                 if (__adv->handle == handle) {
2620                         if (__adv->cb == NULL) {
2621                                 BT_ERR("advertiser cb is NULL"); /* LCOV_EXCL_LINE */
2622                                 return; /* LCOV_EXCL_LINE */
2623                         }
2624
2625                         __adv->cb(result, (bt_advertiser_h)__adv,
2626                                         adv_state, __adv->user_data);
2627                         return;
2628                 }
2629         }
2630
2631         BT_ERR("No available advertiser"); /* LCOV_EXCL_LINE */
2632 }
2633
2634 int bt_adapter_le_set_advertising_mode(bt_advertiser_h advertiser,
2635                 bt_adapter_le_advertising_mode_e mode)
2636 {
2637         int error_code = BT_ERROR_NONE;
2638         bt_advertiser_s *__adv = (bt_advertiser_s *)advertiser;
2639
2640         BT_CHECK_LE_SUPPORT();
2641         BT_CHECK_INIT_STATUS();
2642         BT_CHECK_INPUT_PARAMETER(advertiser);
2643
2644         if (mode < BT_ADAPTER_LE_ADVERTISING_MODE_BALANCED ||
2645                 mode > BT_ADAPTER_LE_ADVERTISING_MODE_LOW_ENERGY)
2646                 return BT_ERROR_INVALID_PARAMETER;
2647
2648         error_code = _bt_get_error_code(bluetooth_check_privilege_advertising_parameter());
2649         if (error_code != BT_ERROR_NONE) {
2650                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code),
2651                                         error_code); /* LCOV_EXCL_LINE */
2652                 return BT_ERROR_PERMISSION_DENIED; /* LCOV_EXCL_LINE */
2653         }
2654
2655         /* TODO : Before set the mode, check the inprogress status */
2656         __adv->adv_params.mode = mode;
2657
2658         return error_code;
2659 }
2660
2661 /* LCOV_EXCL_START */
2662 int bt_adapter_le_set_advertising_filter_policy(bt_advertiser_h advertiser,
2663                 bt_adapter_le_advertising_filter_policy_e filter_policy)
2664 {
2665         int error_code = BT_ERROR_NONE;
2666         bt_advertiser_s *__adv = (bt_advertiser_s *)advertiser;
2667
2668         BT_CHECK_LE_SUPPORT();
2669         BT_CHECK_INIT_STATUS();
2670         BT_CHECK_INPUT_PARAMETER(advertiser);
2671
2672         if (filter_policy < BT_ADAPTER_LE_ADVERTISING_FILTER_DEFAULT ||
2673                 filter_policy > BT_ADAPTER_LE_ADVERTISING_FILTER_ALLOW_SCAN_CONN_WL)
2674                 return BT_ERROR_INVALID_PARAMETER;
2675
2676         error_code = _bt_get_error_code(bluetooth_check_privilege_advertising_parameter());
2677         if (error_code != BT_ERROR_NONE) {
2678                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code),
2679                                         error_code);
2680                 return BT_ERROR_PERMISSION_DENIED;
2681         }
2682
2683         /* TODO : Before set the filter policy, check the inprogress status */
2684         __adv->adv_params.filter_policy = filter_policy;
2685
2686         return error_code;
2687 }
2688 /* LCOV_EXCL_STOP */
2689
2690 int bt_adapter_le_set_advertising_connectable(bt_advertiser_h advertiser,
2691                                                         bool connectable)
2692 {
2693         int error_code = BT_ERROR_NONE;
2694         bt_advertiser_s *__adv = (bt_advertiser_s *)advertiser;
2695
2696         BT_CHECK_LE_SUPPORT();
2697         BT_CHECK_INIT_STATUS();
2698         BT_CHECK_INPUT_PARAMETER(advertiser);
2699
2700         error_code = _bt_get_error_code(
2701                         bluetooth_check_privilege_advertising_parameter());
2702         if (error_code != BT_ERROR_NONE) {
2703                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code),
2704                                         error_code); /* LCOV_EXCL_LINE */
2705                 return BT_ERROR_PERMISSION_DENIED; /* LCOV_EXCL_LINE */
2706         }
2707
2708         if (connectable)
2709                 __adv->adv_params.type = BT_ADAPTER_LE_ADVERTISING_CONNECTABLE; /* LCOV_EXCL_LINE */
2710         else
2711                 __adv->adv_params.type = BT_ADAPTER_LE_ADVERTISING_SCANNABLE;
2712
2713         /* TODO : Before set the type, check the inprogress status */
2714
2715         return error_code;
2716 }
2717
2718 /* LCOV_EXCL_START */
2719 int bt_adapter_le_set_advertising_custom_tx_power_level(bt_advertiser_h advertiser,
2720                                                         int tx_power_level)
2721 {
2722         int error_code = BT_ERROR_NONE;
2723         bt_advertiser_s *__adv = (bt_advertiser_s *)advertiser;
2724
2725         BT_CHECK_LE_SUPPORT();
2726         BT_CHECK_INIT_STATUS();
2727         BT_CHECK_INPUT_PARAMETER(advertiser);
2728
2729         error_code = _bt_get_error_code(
2730                         bluetooth_check_privilege_advertising_parameter());
2731         if (error_code != BT_ERROR_NONE) {
2732                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code),
2733                                         error_code); /* LCOV_EXCL_LINE */
2734                 return BT_ERROR_PERMISSION_DENIED; /* LCOV_EXCL_LINE */
2735         }
2736
2737         __adv->adv_params.tx_power_level = tx_power_level;
2738
2739         return error_code;
2740 }
2741 /* LCOV_EXCL_STOP */
2742
2743 /* LCOV_EXCL_START */
2744 int bt_adapter_le_enable_privacy(bool enable_privacy)
2745 {
2746         int error_code = BT_ERROR_NONE;
2747
2748         BT_CHECK_LE_SUPPORT();
2749         BT_CHECK_INIT_STATUS();
2750
2751         error_code = _bt_get_error_code(
2752                                 bluetooth_enable_le_privacy(enable_privacy));
2753
2754         if (error_code != BT_ERROR_NONE) {
2755                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code),
2756                                         error_code);
2757         }
2758         return error_code;
2759 }
2760
2761 int bt_adapter_le_set_static_random_address(bool enable)
2762 {
2763         int error_code = BT_ERROR_NONE;
2764
2765         BT_CHECK_LE_SUPPORT();
2766         BT_CHECK_INIT_STATUS();
2767
2768         error_code = _bt_get_error_code(bluetooth_set_le_static_random_address(enable));
2769
2770         if (error_code != BT_ERROR_NONE)
2771                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code);
2772
2773         return error_code;
2774 }
2775
2776 static void __bt_adapter_le_convert_scan_filter(
2777                                         bluetooth_le_scan_filter_t *dest,
2778                                         bt_le_scan_filter_s *src)
2779 {
2780         int bit;
2781         char *data;
2782         char *converted_uuid = NULL;
2783
2784         memset(dest, 0x00, sizeof(bluetooth_le_scan_filter_t));
2785
2786         if (src->device_address) {
2787                 dest->added_features |= BLUETOOTH_LE_SCAN_FILTER_FEATURE_DEVICE_ADDRESS;
2788                 _bt_convert_address_to_hex(&dest->device_address,
2789                                                 src->device_address);
2790         }
2791
2792         if (src->device_name) {
2793                 dest->added_features |= BLUETOOTH_LE_SCAN_FILTER_FEATURE_DEVICE_NAME;
2794                 strncpy(dest->device_name, src->device_name,
2795                                 BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX - 1);
2796                 dest->device_name[BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX - 1] = '\0';
2797         }
2798
2799         if (src->service_uuid) {
2800                 if (__bt_convert_string_to_uuid(src->service_uuid,
2801                         &data, &bit) == BT_ERROR_NONE) {
2802                         dest->added_features |= BLUETOOTH_LE_SCAN_FILTER_FEATURE_SERVICE_UUID;
2803                         if (bit == 16)
2804                                 dest->service_uuid.data_len = 2;
2805                         else
2806                                 dest->service_uuid.data_len = 16;
2807
2808                         if (__bt_convert_byte_ordering(data, dest->service_uuid.data_len,
2809                                         &converted_uuid) == BT_ERROR_NONE) {
2810                                 memcpy(dest->service_uuid.data.data, converted_uuid,
2811                                         dest->service_uuid.data_len);
2812                                 g_free(converted_uuid);
2813                                 converted_uuid = NULL;
2814                         }
2815                         g_free(data);
2816                         data = NULL;
2817
2818                         dest->service_uuid_mask.data_len = dest->service_uuid.data_len;
2819                         if (src->service_uuid_mask) {
2820                                 __bt_convert_string_to_uuid(src->service_uuid_mask, &data, &bit);
2821
2822                                 if (__bt_convert_byte_ordering(data, dest->service_uuid_mask.data_len,
2823                                                 &converted_uuid) == BT_ERROR_NONE) {
2824                                         memcpy(dest->service_uuid_mask.data.data, converted_uuid,
2825                                                 dest->service_uuid_mask.data_len);
2826                                         g_free(converted_uuid);
2827                                         converted_uuid = NULL;
2828                                 }
2829                                 g_free(data);
2830                                 data = NULL;
2831                         } else {
2832                                 memset(dest->service_uuid_mask.data.data, 0xFF,
2833                                         dest->service_uuid_mask.data_len);
2834                         }
2835                 }
2836         }
2837
2838         if (src->service_solicitation_uuid) {
2839                 if (__bt_convert_string_to_uuid(src->service_solicitation_uuid,
2840                         &data, &bit) == BT_ERROR_NONE) {
2841                         dest->added_features |= BLUETOOTH_LE_SCAN_FILTER_FEATURE_SERVICE_SOLICITATION_UUID;
2842
2843                         if (bit == 16)
2844                                 dest->service_solicitation_uuid.data_len = 2;
2845                         else
2846                                 dest->service_solicitation_uuid.data_len = 16;
2847
2848                         if (__bt_convert_byte_ordering(data, dest->service_solicitation_uuid.data_len,
2849                                         &converted_uuid) == BT_ERROR_NONE) {
2850                                 memcpy(dest->service_solicitation_uuid.data.data,
2851                                         converted_uuid, dest->service_solicitation_uuid.data_len);
2852                                 g_free(converted_uuid);
2853                                 converted_uuid = NULL;
2854                         }
2855                         g_free(data);
2856                         data = NULL;
2857
2858                         dest->service_solicitation_uuid_mask.data_len = dest->service_solicitation_uuid.data_len;
2859                         if (src->service_solicitation_uuid_mask) {
2860                                 __bt_convert_string_to_uuid(src->service_solicitation_uuid_mask, &data, &bit);
2861
2862                                 if (__bt_convert_byte_ordering(data, dest->service_solicitation_uuid_mask.data_len,
2863                                                 &converted_uuid) == BT_ERROR_NONE) {
2864                                         memcpy(dest->service_solicitation_uuid_mask.data.data,
2865                                                 converted_uuid, dest->service_solicitation_uuid_mask.data_len);
2866                                         g_free(converted_uuid);
2867                                         converted_uuid = NULL;
2868                                 }
2869                                 g_free(data);
2870                                 data = NULL;
2871                         } else {
2872                                 memset(dest->service_solicitation_uuid_mask.data.data, 0xFF, dest->service_solicitation_uuid_mask.data_len);
2873                         }
2874                 }
2875         }
2876
2877         if (src->service_data_uuid) {
2878                 int uuid_len;
2879                 if (__bt_convert_string_to_uuid(src->service_data_uuid, &data, &bit) == BT_ERROR_NONE) {
2880                         dest->added_features |= BLUETOOTH_LE_SCAN_FILTER_FEATURE_SERVICE_DATA;
2881                         if (bit == 16)
2882                                 uuid_len = 2;
2883                         else
2884                                 uuid_len = 16;
2885
2886                         if (__bt_convert_byte_ordering(data, uuid_len, &converted_uuid)
2887                                         == BT_ERROR_NONE) {
2888                                 memcpy(dest->service_data.data.data, converted_uuid, uuid_len);
2889                                 g_free(converted_uuid);
2890                                 converted_uuid = NULL;
2891                         }
2892                         g_free(data);
2893                         data = NULL;
2894
2895                         memcpy(dest->service_data.data.data + uuid_len, src->service_data, src->service_data_len);
2896                         dest->service_data.data_len = uuid_len + src->service_data_len;
2897
2898                         dest->service_data_mask.data_len = dest->service_data.data_len;
2899                         memset(dest->service_data_mask.data.data, 0xFF, uuid_len);
2900                         if (src->service_data_mask)
2901                                 memcpy(dest->service_data_mask.data.data + uuid_len, src->service_data_mask, src->service_data_len);
2902                         else
2903                                 memset(dest->service_data_mask.data.data + uuid_len, 0xFF, src->service_data_len);
2904                 }
2905         }
2906
2907         if (src->manufacturer_id > -1) {
2908                 dest->added_features |= BLUETOOTH_LE_SCAN_FILTER_FEATURE_MANUFACTURER_DATA;
2909                 dest->manufacturer_id = src->manufacturer_id;
2910
2911                 if (src->manufacturer_data) {
2912                         memcpy(dest->manufacturer_data.data.data,
2913                                 src->manufacturer_data,
2914                                 src->manufacturer_data_len);
2915                         dest->manufacturer_data.data_len = src->manufacturer_data_len;
2916
2917                         dest->manufacturer_data_mask.data_len = src->manufacturer_data_len;
2918                         if (src->manufacturer_data_mask)
2919                                 memcpy(dest->manufacturer_data_mask.data.data,
2920                                         src->manufacturer_data_mask,
2921                                         src->manufacturer_data_len);
2922                         else
2923                                 memset(dest->manufacturer_data_mask.data.data,
2924                                         0xFF, src->manufacturer_data_len);
2925                 }
2926         }
2927 }
2928
2929 static bt_le_scan_filter_s *__bt_adapter_le_duplicate_scan_filter(
2930                                         const bt_le_scan_filter_s *src)
2931 {
2932         bt_le_scan_filter_s *filter = g_malloc0(sizeof(bt_le_scan_filter_s));
2933
2934         filter->filter_id = src->filter_id;
2935         filter->device_address = g_strdup(src->device_address);
2936         filter->device_name = g_strdup(src->device_name);
2937         filter->service_uuid = g_strdup(src->service_uuid);
2938         filter->service_uuid_mask = g_strdup(src->service_uuid_mask);
2939         filter->service_solicitation_uuid = g_strdup(src->service_solicitation_uuid);
2940         filter->service_solicitation_uuid_mask = g_strdup(src->service_solicitation_uuid_mask);
2941         filter->service_data_uuid = g_strdup(src->service_data_uuid);
2942         filter->service_data = g_memdup(src->service_data, src->service_data_len);
2943         filter->service_data_len = src->service_data_len;
2944         filter->service_data_mask = g_memdup(src->service_data_mask, src->service_data_len);
2945         filter->manufacturer_id = src->manufacturer_id;
2946         filter->manufacturer_data = g_memdup(src->manufacturer_data, src->manufacturer_data_len);
2947         filter->manufacturer_data_len = src->manufacturer_data_len;
2948         filter->manufacturer_data_mask = g_memdup(src->manufacturer_data_mask, src->manufacturer_data_len);
2949
2950         return filter;
2951 }
2952
2953 static void __bt_adapter_le_free_scan_filter(bt_le_scan_filter_s *filter)
2954 {
2955         if (filter == NULL)
2956                 return;
2957
2958         g_free(filter->device_address);
2959         g_free(filter->device_name);
2960         g_free(filter->service_uuid);
2961         g_free(filter->service_uuid_mask);
2962         g_free(filter->service_solicitation_uuid);
2963         g_free(filter->service_solicitation_uuid_mask);
2964         g_free(filter->service_data_uuid);
2965         g_free(filter->service_data);
2966         g_free(filter->service_data_mask);
2967         g_free(filter->manufacturer_data);
2968         g_free(filter->manufacturer_data_mask);
2969         g_free(filter);
2970 }
2971 /* LCOV_EXCL_STOP */
2972
2973 int bt_adapter_le_start_scan(bt_adapter_le_scan_result_cb cb, void *user_data)
2974 {
2975         int error_code = BT_ERROR_NONE;
2976         GSList *l;
2977
2978         BT_CHECK_LE_SUPPORT();
2979         BT_CHECK_INIT_STATUS();
2980         BT_CHECK_INPUT_PARAMETER(cb);
2981
2982         _bt_le_adapter_init();
2983
2984         for (l = scan_filter_list; l != NULL; l = l->next) {
2985                 bluetooth_le_scan_filter_t filter;
2986                 bt_le_scan_filter_s *__filter = l->data;
2987                 __bt_adapter_le_convert_scan_filter(&filter, __filter);
2988
2989                 error_code = _bt_get_error_code(bluetooth_register_scan_filter(&filter));
2990                 if (error_code != BT_ERROR_NONE) {
2991                         BT_ERR("Scan filter error %s(0x%08x)",
2992                                         _bt_convert_error_to_string(error_code),
2993                                         error_code); /* LCOV_EXCL_LINE */
2994                 }
2995         }
2996
2997         error_code = _bt_get_error_code(bluetooth_start_le_discovery());
2998         if (error_code != BT_ERROR_NONE) {
2999                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code); /* LCOV_EXCL_LINE */
3000                 return error_code;
3001         }
3002
3003         _bt_set_cb(BT_EVENT_LE_SCAN_RESULT_UPDATED, cb, user_data);
3004         return error_code;
3005 }
3006
3007 int bt_adapter_le_stop_scan(void)
3008 {
3009         int error_code = BT_ERROR_NONE;
3010
3011         BT_CHECK_LE_SUPPORT();
3012         BT_CHECK_INIT_STATUS();
3013
3014         error_code = _bt_get_error_code(bluetooth_stop_le_discovery());
3015         if (error_code != BT_ERROR_NONE) {
3016                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code); /* LCOV_EXCL_LINE */
3017                 return error_code;
3018         }
3019
3020         _bt_unset_cb(BT_EVENT_LE_SCAN_RESULT_UPDATED);
3021         _bt_le_adapter_deinit();
3022         return error_code;
3023 }
3024
3025 int bt_adapter_le_get_scan_result_service_uuids(const bt_adapter_le_device_scan_result_info_s *info,
3026                         bt_adapter_le_packet_type_e pkt_type,
3027                         char ***uuids, int *count)
3028 {
3029         BT_CHECK_LE_SUPPORT();
3030         BT_CHECK_INIT_STATUS();
3031         BT_CHECK_INPUT_PARAMETER(info);
3032         BT_CHECK_INPUT_PARAMETER(uuids); /* LCOV_EXCL_START */
3033         BT_CHECK_INPUT_PARAMETER(count);
3034
3035         int adv_length = 0;
3036         char *adv_data = NULL;
3037         char *remain_data = NULL;
3038         int remain_len = 0;
3039         int field_len = 0;
3040         int uuid_size = 0;
3041         int uuid_count = 0;
3042         int uuid_index = 0;
3043         int i;
3044
3045         if (pkt_type == BT_ADAPTER_LE_PACKET_ADVERTISING) {
3046                 adv_data = info->adv_data;
3047                 adv_length = info->adv_data_len;
3048         } else if (pkt_type == BT_ADAPTER_LE_PACKET_SCAN_RESPONSE) {
3049                 adv_data = info->scan_data;
3050                 adv_length = info->scan_data_len;
3051         } else
3052                 return BT_ERROR_INVALID_PARAMETER;
3053
3054         if (!adv_data || adv_length < 3)
3055                 return BT_ERROR_NO_DATA;
3056
3057         remain_data = adv_data;
3058         remain_len = adv_length;
3059         field_len = 0;
3060         while (remain_len > 0) {
3061                 field_len = remain_data[0];
3062                 if (remain_data[1] == BT_ADAPTER_LE_ADVERTISING_DATA_INCOMP_LIST_16_BIT_SERVICE_CLASS_UUIDS ||
3063                         remain_data[1] == BT_ADAPTER_LE_ADVERTISING_DATA_COMP_LIST_16_BIT_SERVICE_CLASS_UUIDS)
3064                         uuid_count += (field_len - 1) / 2;
3065                 else if (remain_data[1] == BT_ADAPTER_LE_ADVERTISING_DATA_INCOMP_LIST_128_BIT_SERVICE_CLASS_UUIDS ||
3066                         remain_data[1] == BT_ADAPTER_LE_ADVERTISING_DATA_COMP_LIST_128_BIT_SERVICE_CLASS_UUIDS)
3067                         uuid_count += (field_len - 1) / 16;
3068
3069                 remain_len = remain_len - field_len - 1;
3070                 remain_data += field_len + 1;
3071         }
3072
3073         if (uuid_count == 0)
3074                 return BT_ERROR_NO_DATA;
3075
3076         *uuids = g_malloc0(sizeof(char *) *uuid_count);
3077
3078         *count = uuid_count;
3079
3080         remain_data = adv_data;
3081         remain_len = adv_length;
3082         field_len = 0;
3083         while (remain_len) {
3084                 field_len = remain_data[0];
3085                 if (remain_data[1] == BT_ADAPTER_LE_ADVERTISING_DATA_INCOMP_LIST_16_BIT_SERVICE_CLASS_UUIDS ||
3086                         remain_data[1] == BT_ADAPTER_LE_ADVERTISING_DATA_COMP_LIST_16_BIT_SERVICE_CLASS_UUIDS)
3087                         uuid_size = 2;
3088                 else if (remain_data[1] == BT_ADAPTER_LE_ADVERTISING_DATA_INCOMP_LIST_128_BIT_SERVICE_CLASS_UUIDS ||
3089                         remain_data[1] == BT_ADAPTER_LE_ADVERTISING_DATA_COMP_LIST_128_BIT_SERVICE_CLASS_UUIDS)
3090                         uuid_size = 16;
3091                 else
3092                         uuid_size = 0;
3093
3094                 if (uuid_size != 0) {
3095                         for (i = 0; i < (field_len - 1); i += uuid_size) {
3096                                 if (uuid_size == 2) {
3097                                         (*uuids)[uuid_index] = g_malloc0(sizeof(char) * 4 + 1);
3098                                         snprintf((*uuids)[uuid_index], 5,
3099                                                         "%2.2X%2.2X",
3100                                                         remain_data[i+3],
3101                                                         remain_data[i+2]);
3102                                 } else {
3103                                         (*uuids)[uuid_index] = g_malloc0(sizeof(char) * 36 + 1);
3104                                         snprintf((*uuids)[uuid_index], 37, "%2.2X%2.2X%2.2X%2.2X-%2.2X%2.2X-%2.2X%2.2X-%2.2X%2.2X-%2.2X%2.2X%2.2X%2.2X%2.2X%2.2X",
3105                                                 remain_data[i+17], remain_data[i+16], remain_data[i+15], remain_data[i+14],
3106                                                 remain_data[i+13], remain_data[i+12], remain_data[i+11], remain_data[i+10], remain_data[i+9], remain_data[i+8],
3107                                                 remain_data[i+7], remain_data[i+6], remain_data[i+5], remain_data[i+4], remain_data[i+3], remain_data[i+2]);
3108                                 }
3109                                 uuid_index++;
3110                         }
3111                 }
3112
3113                 remain_len = remain_len - field_len - 1;
3114                 remain_data += field_len + 1;
3115         }
3116
3117         return BT_ERROR_NONE;
3118 } /* LCOV_EXCL_STOP */
3119
3120 int bt_adapter_le_get_scan_result_device_name(const bt_adapter_le_device_scan_result_info_s *info,
3121                         bt_adapter_le_packet_type_e pkt_type, char **name)
3122 {
3123         BT_CHECK_LE_SUPPORT();
3124         BT_CHECK_INIT_STATUS();
3125         BT_CHECK_INPUT_PARAMETER(info); /* LCOV_EXCL_START */
3126         BT_CHECK_INPUT_PARAMETER(name);
3127
3128         int adv_length = 0;
3129         char *adv_data = NULL;
3130         int field_len = 0;
3131
3132         if (pkt_type == BT_ADAPTER_LE_PACKET_ADVERTISING) {
3133                 adv_data = info->adv_data;
3134                 adv_length = info->adv_data_len;
3135         } else if (pkt_type == BT_ADAPTER_LE_PACKET_SCAN_RESPONSE) {
3136                 adv_data = info->scan_data;
3137                 adv_length = info->scan_data_len;
3138         } else
3139                 return BT_ERROR_INVALID_PARAMETER;
3140
3141         if (!adv_data || adv_length < 3)
3142                 return BT_ERROR_NO_DATA;
3143
3144         while (adv_length > 0) {
3145                 field_len = adv_data[0];
3146                 if (adv_data[1] == BT_ADAPTER_LE_ADVERTISING_DATA_LOCAL_NAME ||
3147                         adv_data[1] == BT_ADAPTER_LE_ADVERTISING_DATA_SHORT_LOCAL_NAME) {
3148
3149                         if (field_len <= 0) {
3150                                 BT_ERR("Wrong field len for name");
3151                                 return BT_ERROR_NO_DATA;
3152                         }
3153
3154                         *name = g_malloc0(sizeof(char) *field_len);
3155                         memcpy(*name, &adv_data[2], field_len - 1);
3156
3157                         return BT_ERROR_NONE;
3158                 }
3159
3160                 adv_length = adv_length - field_len - 1;
3161                 adv_data += field_len + 1;
3162         }
3163
3164         return BT_ERROR_NO_DATA; /* LCOV_EXCL_STOP */
3165 }
3166
3167 int bt_adapter_le_get_scan_result_tx_power_level(const bt_adapter_le_device_scan_result_info_s *info,
3168                         bt_adapter_le_packet_type_e pkt_type, int *power_level)
3169 {
3170         BT_CHECK_LE_SUPPORT();
3171         BT_CHECK_INIT_STATUS();
3172         BT_CHECK_INPUT_PARAMETER(info); /* LCOV_EXCL_START */
3173         BT_CHECK_INPUT_PARAMETER(power_level);
3174
3175         int adv_length = 0;
3176         char *adv_data = NULL;
3177         int field_len = 0;
3178
3179         if (pkt_type == BT_ADAPTER_LE_PACKET_ADVERTISING) {
3180                 adv_data = info->adv_data;
3181                 adv_length = info->adv_data_len;
3182         } else if (pkt_type == BT_ADAPTER_LE_PACKET_SCAN_RESPONSE) {
3183                 adv_data = info->scan_data;
3184                 adv_length = info->scan_data_len;
3185         } else
3186                 return BT_ERROR_INVALID_PARAMETER;
3187
3188         if (!adv_data || adv_length < 3)
3189                 return BT_ERROR_NO_DATA;
3190
3191         while (adv_length > 0) {
3192                 field_len = adv_data[0];
3193                 if (adv_data[1] == BT_ADAPTER_LE_ADVERTISING_DATA_TX_POWER_LEVEL) {
3194                         if (adv_data[2] & 0x80)
3195                                 *power_level = 0xffffff00 | adv_data[2];
3196                         else
3197                                 *power_level = (int)adv_data[2];
3198
3199                         return BT_ERROR_NONE;
3200                 }
3201
3202                 adv_length = adv_length - field_len - 1;
3203                 adv_data += field_len + 1;
3204         }
3205
3206         return BT_ERROR_NO_DATA; /* LCOV_EXCL_STOP */
3207 }
3208
3209 int bt_adapter_le_get_scan_result_service_solicitation_uuids(const bt_adapter_le_device_scan_result_info_s *info,
3210                         bt_adapter_le_packet_type_e pkt_type,
3211                         char ***uuids, int *count)
3212 {
3213         BT_CHECK_LE_SUPPORT();
3214         BT_CHECK_INIT_STATUS();
3215         BT_CHECK_INPUT_PARAMETER(info); /* LCOV_EXCL_START */
3216         BT_CHECK_INPUT_PARAMETER(uuids);
3217         BT_CHECK_INPUT_PARAMETER(count);
3218
3219         int adv_length = 0;
3220         char *adv_data = NULL;
3221         char *remain_data = NULL;
3222         int remain_len = 0;
3223         int field_len = 0;
3224         int uuid_size = 0;
3225         int uuid_count = 0;
3226         int uuid_index = 0;
3227         int i;
3228
3229         if (pkt_type == BT_ADAPTER_LE_PACKET_ADVERTISING) {
3230                 adv_data = info->adv_data;
3231                 adv_length = info->adv_data_len;
3232         } else if (pkt_type == BT_ADAPTER_LE_PACKET_SCAN_RESPONSE) {
3233                 adv_data = info->scan_data;
3234                 adv_length = info->scan_data_len;
3235         } else
3236                 return BT_ERROR_INVALID_PARAMETER;
3237
3238         if (!adv_data || adv_length < 3)
3239                 return BT_ERROR_NO_DATA;
3240
3241         remain_data = adv_data;
3242         remain_len = adv_length;
3243         field_len = 0;
3244         while (remain_len > 0) {
3245                 field_len = remain_data[0];
3246                 if (remain_data[1] == BT_ADAPTER_LE_ADVERTISING_DATA_16_BIT_SERVICE_SOLICITATION_UUIDS)
3247                         uuid_count += (field_len - 1) / 2;
3248                 else if (remain_data[1] == BT_ADAPTER_LE_ADVERTISING_DATA_128_BIT_SERVICE_SOLICITATION_UUIDS)
3249                         uuid_count += (field_len - 1) / 16;
3250
3251                 remain_len = remain_len - field_len - 1;
3252                 remain_data += field_len + 1;
3253         }
3254
3255         if (uuid_count == 0)
3256                 return BT_ERROR_NO_DATA;
3257
3258         *uuids = g_malloc0(sizeof(char *) * uuid_count);
3259         *count = uuid_count;
3260
3261         remain_data = adv_data;
3262         remain_len = adv_length;
3263         field_len = 0;
3264         while (remain_len > 0) {
3265                 field_len = remain_data[0];
3266                 if (remain_data[1] == BT_ADAPTER_LE_ADVERTISING_DATA_16_BIT_SERVICE_SOLICITATION_UUIDS)
3267                         uuid_size = 2;
3268                 else if (remain_data[1] == BT_ADAPTER_LE_ADVERTISING_DATA_128_BIT_SERVICE_SOLICITATION_UUIDS)
3269                         uuid_size = 16;
3270                 else
3271                         uuid_size = 0;
3272
3273                 if (uuid_size != 0) {
3274                         for (i = 0; i < (field_len - 1); i += uuid_size) {
3275                                 if (uuid_size == 2) {
3276                                         (*uuids)[uuid_index] = g_malloc0(sizeof(char) * 4 + 1);
3277                                         snprintf((*uuids)[uuid_index], 5,
3278                                                 "%2.2X%2.2X", remain_data[i+3],
3279                                                 remain_data[i+2]);
3280                                 } else {
3281                                         (*uuids)[uuid_index] = g_malloc0(sizeof(char) * 36 + 1);
3282                                         snprintf((*uuids)[uuid_index], 37, "%2.2X%2.2X%2.2X%2.2X-%2.2X%2.2X-%2.2X%2.2X-%2.2X%2.2X-%2.2X%2.2X%2.2X%2.2X%2.2X%2.2X",
3283                                                 remain_data[i+17], remain_data[i+16], remain_data[i+15], remain_data[i+14],
3284                                                 remain_data[i+13], remain_data[i+12], remain_data[i+11], remain_data[i+10], remain_data[i+9], remain_data[i+8],
3285                                                 remain_data[i+7], remain_data[i+6], remain_data[i+5], remain_data[i+4], remain_data[i+3], remain_data[i+2]);
3286                                 }
3287                                 uuid_index++;
3288                         }
3289                 }
3290
3291                 remain_len = remain_len - field_len - 1;
3292                 remain_data += field_len + 1;
3293         }
3294
3295         return BT_ERROR_NONE; /* LCOV_EXCL_STOP */
3296 }
3297
3298 int bt_adapter_le_get_scan_result_service_data_list(const bt_adapter_le_device_scan_result_info_s *info,
3299                         bt_adapter_le_packet_type_e pkt_type,
3300                         bt_adapter_le_service_data_s **data_list, int *count)
3301 {
3302         BT_CHECK_LE_SUPPORT();
3303         BT_CHECK_INIT_STATUS();
3304         BT_CHECK_INPUT_PARAMETER(info); /* LCOV_EXCL_START */
3305         BT_CHECK_INPUT_PARAMETER(count);
3306
3307         int adv_length = 0;
3308         char *adv_data = NULL;
3309         char *remain_data = NULL;
3310         int remain_len = 0;
3311         int field_len = 0;
3312         int data_count = 0;
3313         int data_index = 0;
3314
3315         if (pkt_type == BT_ADAPTER_LE_PACKET_ADVERTISING) {
3316                 adv_data = info->adv_data;
3317                 adv_length = info->adv_data_len;
3318         } else if (pkt_type == BT_ADAPTER_LE_PACKET_SCAN_RESPONSE) {
3319                 adv_data = info->scan_data;
3320                 adv_length = info->scan_data_len;
3321         } else
3322                 return BT_ERROR_INVALID_PARAMETER;
3323
3324         if (!adv_data || adv_length < 3)
3325                 return BT_ERROR_NO_DATA;
3326
3327         remain_data = adv_data;
3328         remain_len = adv_length;
3329         field_len = 0;
3330         while (remain_len > 0) {
3331                 field_len = remain_data[0];
3332                 if (remain_data[1] == BT_ADAPTER_LE_ADVERTISING_DATA_SERVICE_DATA ||
3333                          remain_data[1] == BT_ADAPTER_LE_ADVERTISING_DATA_128_BIT_SERVICE_DATA)
3334                         data_count++;
3335
3336                 remain_len = remain_len - field_len - 1;
3337                 remain_data += field_len + 1;
3338         }
3339
3340         if (data_count == 0)
3341                 return BT_ERROR_NO_DATA;
3342
3343         *data_list = g_malloc0(sizeof(bt_adapter_le_service_data_s) * data_count);
3344         *count = data_count;
3345
3346         remain_data = adv_data;
3347         remain_len = adv_length;
3348         field_len = 0;
3349         while (remain_len > 0) {
3350                 field_len = remain_data[0];
3351
3352                 if (remain_data[1] == BT_ADAPTER_LE_ADVERTISING_DATA_SERVICE_DATA) {
3353                         (*data_list)[data_index].service_uuid = g_malloc0(sizeof(char) * 4 + 1);
3354                         snprintf((*data_list)[data_index].service_uuid, 5,
3355                                 "%2.2X%2.2X", remain_data[3], remain_data[2]);
3356
3357                         (*data_list)[data_index].service_data = g_memdup(
3358                                                         &remain_data[4], field_len - 3);
3359                         (*data_list)[data_index].service_data_len = field_len - 3;
3360
3361                         data_index++;
3362                 } else if (remain_data[1] == BT_ADAPTER_LE_ADVERTISING_DATA_128_BIT_SERVICE_DATA) {
3363                         (*data_list)[data_index].service_uuid = g_malloc0(sizeof(char) * 36 + 1);
3364                         snprintf((*data_list)[data_index].service_uuid, 37,
3365                                 "%2.2X%2.2X%2.2X%2.2X-%2.2X%2.2X-%2.2X%2.2X-%2.2X%2.2X-%2.2X%2.2X%2.2X%2.2X%2.2X%2.2X",
3366                                                 remain_data[17], remain_data[16],
3367                                                 remain_data[15], remain_data[14],
3368                                                 remain_data[13], remain_data[12],
3369                                                 remain_data[11], remain_data[10],
3370                                                 remain_data[9], remain_data[8],
3371                                                 remain_data[7], remain_data[6],
3372                                                 remain_data[5], remain_data[4],
3373                                                 remain_data[3], remain_data[2]);
3374
3375                         (*data_list)[data_index].service_data = g_memdup(
3376                                                         &remain_data[18], field_len - 17);
3377                         (*data_list)[data_index].service_data_len = field_len - 17;
3378
3379                         data_index++;
3380                 }
3381
3382                 remain_len = remain_len - field_len - 1;
3383                 remain_data += field_len + 1;
3384         }
3385
3386         return BT_ERROR_NONE; /* LCOV_EXCL_STOP */
3387 }
3388
3389 int bt_adapter_le_free_service_data_list(bt_adapter_le_service_data_s *data_list,
3390                                         int count)
3391 {
3392         int i;
3393
3394         BT_CHECK_LE_SUPPORT();
3395         BT_CHECK_INIT_STATUS();
3396         BT_CHECK_INPUT_PARAMETER(data_list); /* LCOV_EXCL_START */
3397
3398         for (i = 0; i < count; i++) {
3399                 g_free(data_list[i].service_uuid);
3400                 g_free(data_list[i].service_data);
3401         }
3402         g_free(data_list);
3403
3404         return BT_ERROR_NONE; /* LCOV_EXCL_STOP */
3405 }
3406
3407 int bt_adapter_le_get_scan_result_appearance(const bt_adapter_le_device_scan_result_info_s *info,
3408                         bt_adapter_le_packet_type_e pkt_type, int *appearance)
3409 {
3410         BT_CHECK_LE_SUPPORT();
3411         BT_CHECK_INIT_STATUS();
3412         BT_CHECK_INPUT_PARAMETER(info); /* LCOV_EXCL_START */
3413         BT_CHECK_INPUT_PARAMETER(appearance);
3414
3415         int adv_length = 0;
3416         char *adv_data = NULL;
3417         int field_len = 0;
3418
3419         if (pkt_type == BT_ADAPTER_LE_PACKET_ADVERTISING) {
3420                 adv_data = info->adv_data;
3421                 adv_length = info->adv_data_len;
3422         } else if (pkt_type == BT_ADAPTER_LE_PACKET_SCAN_RESPONSE) {
3423                 adv_data = info->scan_data;
3424                 adv_length = info->scan_data_len;
3425         } else
3426                 return BT_ERROR_INVALID_PARAMETER;
3427
3428         if (!adv_data || adv_length < 3)
3429                 return BT_ERROR_NO_DATA;
3430
3431         while (adv_length > 0) {
3432                 field_len = adv_data[0];
3433                 if (adv_data[1] == BT_ADAPTER_LE_ADVERTISING_DATA_APPEARANCE) {
3434                         *appearance = adv_data[3] << 8;
3435                         *appearance += adv_data[2];
3436
3437
3438                         return BT_ERROR_NONE;
3439                 }
3440
3441                 adv_length = adv_length - field_len - 1;
3442                 adv_data += field_len + 1;
3443         }
3444
3445         return BT_ERROR_NO_DATA; /* LCOV_EXCL_STOP */
3446 }
3447
3448
3449 int bt_adapter_le_get_scan_result_manufacturer_data(const bt_adapter_le_device_scan_result_info_s *info,
3450                         bt_adapter_le_packet_type_e pkt_type,
3451                         int *manufacturer_id, char **manufacturer_data,
3452                         int *manufacturer_data_len)
3453 {
3454         BT_CHECK_LE_SUPPORT();
3455         BT_CHECK_INIT_STATUS();
3456         BT_CHECK_INPUT_PARAMETER(info);
3457         BT_CHECK_INPUT_PARAMETER(manufacturer_id); /* LCOV_EXCL_START */
3458         BT_CHECK_INPUT_PARAMETER(manufacturer_data);
3459         BT_CHECK_INPUT_PARAMETER(manufacturer_data_len);
3460
3461         int adv_length = 0;
3462         char *adv_data = NULL;
3463         char *remain_data = NULL;
3464         int remain_len = 0;
3465         int field_len = 0;
3466
3467         if (pkt_type == BT_ADAPTER_LE_PACKET_ADVERTISING) {
3468                 adv_data = info->adv_data;
3469                 adv_length = info->adv_data_len;
3470         } else if (pkt_type == BT_ADAPTER_LE_PACKET_SCAN_RESPONSE) {
3471                 adv_data = info->scan_data;
3472                 adv_length = info->scan_data_len;
3473         } else
3474                 return BT_ERROR_INVALID_PARAMETER;
3475
3476         if (!adv_data || adv_length < 3)
3477                 return BT_ERROR_NO_DATA;
3478
3479         remain_data = adv_data;
3480         remain_len = adv_length;
3481         field_len = 0;
3482         while (remain_len > 0) {
3483                 field_len = remain_data[0];
3484                 if ((uint64_t)(remain_data[1] & 0xff) == BT_ADAPTER_LE_ADVERTISING_DATA_MANUFACTURER_SPECIFIC_DATA) {
3485                         if (field_len < 3 || (remain_len - 1 < field_len)) {
3486                                 /* Manufacturer Specific Data (2 or more octets)
3487                                     - The first 2 octets contain the Company Identifier
3488                                       Code followed by additional manufacturer specific data
3489
3490                                    |field_len|0xff|Company ID (2 bytes)|data (size: field_len - 3|
3491
3492                                    And field_len should be smaller than "remain_len - 1"
3493                                 */
3494
3495                                 return BT_ERROR_NO_DATA;
3496                         }
3497
3498                         *manufacturer_id = remain_data[3] << 8;
3499                         *manufacturer_id += remain_data[2];
3500
3501                         *manufacturer_data = g_memdup(&remain_data[4], field_len - 3);
3502                         *manufacturer_data_len = field_len - 3;
3503
3504                         return BT_ERROR_NONE;
3505                 }
3506
3507                 remain_len = remain_len - field_len - 1;
3508                 remain_data += field_len + 1;
3509         }
3510
3511         return BT_ERROR_NO_DATA; /* LCOV_EXCL_STOP */
3512 }
3513
3514 int bt_adapter_le_free_ibeacon_report(bt_adapter_le_ibeacon_scan_result_info_s *ibeacon_info)
3515 {
3516
3517         BT_CHECK_LE_SUPPORT();
3518         BT_CHECK_INIT_STATUS();
3519         BT_CHECK_INPUT_PARAMETER(ibeacon_info); /* LCOV_EXCL_START */
3520
3521         g_free(ibeacon_info->uuid);
3522
3523         g_free(ibeacon_info);
3524
3525         return BT_ERROR_NONE; /* LCOV_EXCL_STOP */
3526 }
3527
3528 int bt_adapter_le_get_scan_result_ibeacon_report(const bt_adapter_le_device_scan_result_info_s *info,
3529                         bt_adapter_le_packet_type_e pkt_type, bt_adapter_le_ibeacon_scan_result_info_s **ibeacon_info)
3530 {
3531         int manufacturer_id;
3532         char *manufacturer_data = NULL;
3533         int manufacturer_data_len;
3534
3535         BT_CHECK_LE_SUPPORT();
3536         BT_CHECK_INIT_STATUS();
3537         BT_CHECK_INPUT_PARAMETER(info);
3538
3539         if (bt_adapter_le_get_scan_result_manufacturer_data(
3540                         info, pkt_type, &manufacturer_id, &manufacturer_data,
3541                         &manufacturer_data_len) != BT_ERROR_NONE)
3542                         return BT_ERROR_NO_DATA;
3543
3544         if (manufacturer_data == NULL)
3545                 return BT_ERROR_NO_DATA;
3546
3547         if (manufacturer_data_len < 23) {
3548                 g_free(manufacturer_data);
3549                 return BT_ERROR_NO_DATA;
3550         }
3551
3552         if (manufacturer_id != COMPANY_ID_APPLE) {
3553                 g_free(manufacturer_data);
3554                 return BT_ERROR_NO_DATA;
3555         }
3556
3557         *ibeacon_info = g_malloc0(sizeof(bt_adapter_le_ibeacon_scan_result_info_s));
3558
3559         (*ibeacon_info)->company_id = manufacturer_id;
3560         (*ibeacon_info)->ibeacon_type = manufacturer_data[1] << 8;
3561         (*ibeacon_info)->ibeacon_type += manufacturer_data[0];
3562
3563         (*ibeacon_info)->uuid = g_malloc0(sizeof(char) * 36 + 1);
3564
3565         snprintf((*ibeacon_info)->uuid, 37, "%2.2X%2.2X%2.2X%2.2X-%2.2X%2.2X-%2.2X%2.2X-%2.2X%2.2X-%2.2X%2.2X%2.2X%2.2X%2.2X%2.2X",
3566                 manufacturer_data[17], manufacturer_data[16], manufacturer_data[15], manufacturer_data[14],
3567                 manufacturer_data[13], manufacturer_data[12], manufacturer_data[11], manufacturer_data[10], manufacturer_data[9], manufacturer_data[8],
3568                 manufacturer_data[7], manufacturer_data[6], manufacturer_data[5], manufacturer_data[4], manufacturer_data[3], manufacturer_data[2]);
3569
3570         (*ibeacon_info)->major_id = manufacturer_data[19] << 8;
3571         (*ibeacon_info)->major_id += manufacturer_data[18];
3572
3573         (*ibeacon_info)->minor_id = manufacturer_data[21] << 8;
3574         (*ibeacon_info)->minor_id += manufacturer_data[20];
3575
3576         (*ibeacon_info)->measured_power = manufacturer_data[22];
3577
3578         g_free(manufacturer_data);
3579
3580         return BT_ERROR_NONE;
3581 }
3582
3583 int bt_adapter_le_scan_filter_create(bt_scan_filter_h *scan_filter)
3584 {
3585         bt_le_scan_filter_s *__filter = NULL;
3586
3587         BT_CHECK_LE_SUPPORT();
3588         BT_CHECK_INIT_STATUS();
3589         BT_CHECK_INPUT_PARAMETER(scan_filter);
3590
3591         __filter = (bt_le_scan_filter_s *)g_malloc0(sizeof(bt_le_scan_filter_s));
3592
3593         __filter->filter_id = scan_filter_id++;
3594         __filter->manufacturer_id = -1;
3595         *scan_filter = (bt_scan_filter_h)__filter;
3596
3597         return BT_ERROR_NONE;
3598 }
3599
3600 int bt_adapter_le_scan_filter_destroy(bt_scan_filter_h scan_filter)
3601 {
3602         bt_le_scan_filter_s *__filter = (bt_le_scan_filter_s *)scan_filter;
3603
3604         BT_CHECK_LE_SUPPORT();
3605         BT_CHECK_INIT_STATUS();
3606         BT_CHECK_INPUT_PARAMETER(scan_filter);
3607
3608         __bt_adapter_le_free_scan_filter(__filter);
3609
3610         return BT_ERROR_NONE;
3611 }
3612
3613 int bt_adapter_le_scan_filter_set_device_address(bt_scan_filter_h scan_filter,
3614                                                         const char *address)
3615 {
3616         bt_le_scan_filter_s *__filter = (bt_le_scan_filter_s *)scan_filter;
3617
3618         BT_CHECK_LE_SUPPORT();
3619         BT_CHECK_INIT_STATUS();
3620         BT_CHECK_INPUT_PARAMETER(scan_filter);
3621         BT_CHECK_INPUT_PARAMETER(address);
3622
3623         g_free(__filter->device_address);
3624
3625         __filter->device_address = strdup(address);
3626
3627         return BT_ERROR_NONE;
3628 }
3629
3630 int bt_adapter_le_scan_filter_set_device_name(bt_scan_filter_h scan_filter, const char *name)
3631 {
3632         bt_le_scan_filter_s *__filter = (bt_le_scan_filter_s *)scan_filter;
3633
3634         BT_CHECK_LE_SUPPORT();
3635         BT_CHECK_INIT_STATUS();
3636         BT_CHECK_INPUT_PARAMETER(scan_filter);
3637         BT_CHECK_INPUT_PARAMETER(name);
3638
3639         if (strlen(name) > 29) {
3640                 BT_ERR("INVALID_PARAMETER(0x%08x)",
3641                         BT_ERROR_INVALID_PARAMETER);
3642                 return BT_ERROR_INVALID_PARAMETER;
3643         }
3644
3645         g_free(__filter->device_name);
3646
3647         __filter->device_name = strdup(name);
3648
3649         return BT_ERROR_NONE;
3650 }
3651
3652 int bt_adapter_le_scan_filter_set_service_uuid(bt_scan_filter_h scan_filter,
3653                                                         const char *uuid)
3654 {
3655         bt_le_scan_filter_s *__filter = (bt_le_scan_filter_s *)scan_filter;
3656
3657         BT_CHECK_LE_SUPPORT();
3658         BT_CHECK_INIT_STATUS();
3659         BT_CHECK_INPUT_PARAMETER(scan_filter);
3660         BT_CHECK_INPUT_PARAMETER(uuid);
3661
3662         g_free(__filter->service_uuid);
3663         g_free(__filter->service_uuid_mask);
3664
3665         __filter->service_uuid = strdup(uuid);
3666         __filter->service_uuid_mask = NULL;
3667
3668         return BT_ERROR_NONE;
3669 }
3670
3671 int bt_adapter_le_scan_filter_set_service_uuid_with_mask(bt_scan_filter_h scan_filter,
3672                         const char *uuid, const char *mask)
3673 {
3674         bt_le_scan_filter_s *__filter = (bt_le_scan_filter_s *)scan_filter;
3675
3676         BT_CHECK_LE_SUPPORT();
3677         BT_CHECK_INIT_STATUS();
3678         BT_CHECK_INPUT_PARAMETER(scan_filter);
3679         BT_CHECK_INPUT_PARAMETER(uuid);
3680         BT_CHECK_INPUT_PARAMETER(mask);
3681
3682         if (strlen(uuid) != strlen(mask)) {
3683                 BT_ERR("INVALID_PARAMETER(0x%08x)",
3684                         BT_ERROR_INVALID_PARAMETER); /* LCOV_EXCL_LINE */
3685                 return BT_ERROR_INVALID_PARAMETER;
3686         }
3687
3688         g_free(__filter->service_uuid);
3689         g_free(__filter->service_uuid_mask);
3690
3691         __filter->service_uuid = strdup(uuid);
3692         __filter->service_uuid_mask = strdup(mask);
3693
3694         return BT_ERROR_NONE;
3695 }
3696
3697 int bt_adapter_le_scan_filter_set_service_solicitation_uuid(bt_scan_filter_h scan_filter,
3698                                                         const char *uuid)
3699 {
3700         bt_le_scan_filter_s *__filter = (bt_le_scan_filter_s *)scan_filter;
3701
3702         BT_CHECK_LE_SUPPORT();
3703         BT_CHECK_INIT_STATUS();
3704         BT_CHECK_INPUT_PARAMETER(scan_filter);
3705         BT_CHECK_INPUT_PARAMETER(uuid);
3706
3707         g_free(__filter->service_solicitation_uuid);
3708         g_free(__filter->service_solicitation_uuid_mask);
3709
3710         __filter->service_solicitation_uuid = strdup(uuid);
3711         __filter->service_solicitation_uuid_mask = NULL;
3712
3713         return BT_ERROR_NONE;
3714 }
3715
3716 int bt_adapter_le_scan_filter_set_service_solicitation_uuid_with_mask(bt_scan_filter_h scan_filter,
3717                         const char *uuid, const char *mask)
3718 {
3719         bt_le_scan_filter_s *__filter = (bt_le_scan_filter_s *)scan_filter;
3720
3721         BT_CHECK_LE_SUPPORT();
3722         BT_CHECK_INIT_STATUS();
3723         BT_CHECK_INPUT_PARAMETER(scan_filter);
3724         BT_CHECK_INPUT_PARAMETER(uuid);
3725         BT_CHECK_INPUT_PARAMETER(mask);
3726
3727         if (strlen(uuid) != strlen(mask)) {
3728                 BT_ERR("INVALID_PARAMETER(0x%08x)",
3729                         BT_ERROR_INVALID_PARAMETER); /* LCOV_EXCL_LINE */
3730                 return BT_ERROR_INVALID_PARAMETER;
3731         }
3732
3733         g_free(__filter->service_solicitation_uuid);
3734         g_free(__filter->service_solicitation_uuid_mask);
3735
3736         __filter->service_solicitation_uuid = strdup(uuid);
3737         __filter->service_solicitation_uuid_mask = strdup(mask);
3738
3739         return BT_ERROR_NONE;
3740 }
3741
3742 int bt_adapter_le_scan_filter_set_service_data(bt_scan_filter_h scan_filter,
3743                         const char *uuid, const char *data,
3744                         unsigned int data_len)
3745 {
3746         bt_le_scan_filter_s *__filter = (bt_le_scan_filter_s *)scan_filter;
3747
3748         BT_CHECK_LE_SUPPORT();
3749         BT_CHECK_INIT_STATUS();
3750         BT_CHECK_INPUT_PARAMETER(scan_filter);
3751         BT_CHECK_INPUT_PARAMETER(uuid);
3752         BT_CHECK_INPUT_PARAMETER(data);
3753
3754         if (data_len > 27) {
3755                 BT_ERR("INVALID_PARAMETER(0x%08x)",
3756                         BT_ERROR_INVALID_PARAMETER); /* LCOV_EXCL_LINE */
3757                 return BT_ERROR_INVALID_PARAMETER;
3758         }
3759
3760         g_free(__filter->service_data_uuid);
3761         g_free(__filter->service_data);
3762         g_free(__filter->service_data_mask);
3763
3764         __filter->service_data_uuid = strdup(uuid);
3765         __filter->service_data = g_memdup(data, data_len);
3766         __filter->service_data_len = data_len;
3767         __filter->service_data_mask = NULL;
3768
3769         return BT_ERROR_NONE;
3770 }
3771
3772 int bt_adapter_le_scan_filter_set_service_data_with_mask(bt_scan_filter_h scan_filter,
3773                         const char *uuid, const char *data, unsigned int data_len,
3774                         const char *mask, unsigned int mask_len)
3775 {
3776         bt_le_scan_filter_s *__filter = (bt_le_scan_filter_s *)scan_filter;
3777
3778         BT_CHECK_LE_SUPPORT();
3779         BT_CHECK_INIT_STATUS();
3780         BT_CHECK_INPUT_PARAMETER(scan_filter);
3781         BT_CHECK_INPUT_PARAMETER(uuid);
3782         BT_CHECK_INPUT_PARAMETER(data);
3783         BT_CHECK_INPUT_PARAMETER(mask);
3784
3785         if (data_len != mask_len || data_len > 27) {
3786                 BT_ERR("INVALID_PARAMETER(0x%08x)",
3787                         BT_ERROR_INVALID_PARAMETER); /* LCOV_EXCL_LINE */
3788                 return BT_ERROR_INVALID_PARAMETER;
3789         }
3790
3791         g_free(__filter->service_data_uuid);
3792         g_free(__filter->service_data);
3793         g_free(__filter->service_data_mask);
3794
3795         __filter->service_data_uuid = strdup(uuid);
3796         __filter->service_data = g_memdup(data, data_len);
3797         __filter->service_data_len = data_len;
3798         __filter->service_data_mask = g_memdup(mask, data_len);
3799
3800         return BT_ERROR_NONE;
3801 }
3802
3803 int bt_adapter_le_scan_filter_set_manufacturer_data(bt_scan_filter_h scan_filter,
3804                         int manufacturer_id, const char *data,
3805                         unsigned int data_len)
3806 {
3807         bt_le_scan_filter_s *__filter = (bt_le_scan_filter_s *)scan_filter;
3808
3809         BT_CHECK_LE_SUPPORT();
3810         BT_CHECK_INIT_STATUS();
3811         BT_CHECK_INPUT_PARAMETER(scan_filter);
3812
3813         if (manufacturer_id < 0 || manufacturer_id > 0xFFFF) {
3814                 BT_ERR("manufacturer_id is %.8x(0x%08x)", manufacturer_id,
3815                         BT_ERROR_INVALID_PARAMETER); /* LCOV_EXCL_LINE */
3816                 return BT_ERROR_INVALID_PARAMETER;
3817         }
3818
3819         if (data_len > 27) {
3820                 BT_ERR("INVALID_PARAMETER(0x%08x)",
3821                         BT_ERROR_INVALID_PARAMETER); /* LCOV_EXCL_LINE */
3822                 return BT_ERROR_INVALID_PARAMETER;
3823         }
3824
3825         g_free(__filter->manufacturer_data);
3826         g_free(__filter->manufacturer_data_mask);
3827
3828         __filter->manufacturer_id = manufacturer_id;
3829         if (data != NULL) {
3830                 __filter->manufacturer_data = g_memdup(data, data_len);
3831                 __filter->manufacturer_data_len = data_len;
3832         } else {
3833                 __filter->manufacturer_data = NULL;
3834                 __filter->manufacturer_data_len = 0;
3835         }
3836         __filter->manufacturer_data_mask = NULL;
3837
3838         return BT_ERROR_NONE;
3839 }
3840
3841 int bt_adapter_le_scan_filter_set_manufacturer_data_with_mask(bt_scan_filter_h scan_filter,
3842                         int manufacturer_id, const char *data,
3843                         unsigned int data_len, const char *mask,
3844                         unsigned int mask_len)
3845 {
3846         bt_le_scan_filter_s *__filter = (bt_le_scan_filter_s *)scan_filter;
3847
3848         BT_CHECK_LE_SUPPORT();
3849         BT_CHECK_INIT_STATUS();
3850         BT_CHECK_INPUT_PARAMETER(scan_filter);
3851         BT_CHECK_INPUT_PARAMETER(data);
3852         BT_CHECK_INPUT_PARAMETER(mask);
3853
3854         if (manufacturer_id < 0 || manufacturer_id > 0xFFFF) {
3855                 BT_ERR("manufacturer_id is %.8x(0x%08x)", manufacturer_id,
3856                         BT_ERROR_INVALID_PARAMETER); /* LCOV_EXCL_LINE */
3857                 return BT_ERROR_INVALID_PARAMETER;
3858         }
3859
3860         if (data_len != mask_len || data_len > 27) {
3861                 BT_ERR("INVALID_PARAMETER(0x%08x)",
3862                         BT_ERROR_INVALID_PARAMETER); /* LCOV_EXCL_LINE */
3863                 return BT_ERROR_INVALID_PARAMETER;
3864         }
3865
3866         g_free(__filter->manufacturer_data);
3867         g_free(__filter->manufacturer_data_mask);
3868
3869         __filter->manufacturer_id = manufacturer_id;
3870         __filter->manufacturer_data = g_memdup(data, data_len);
3871         __filter->manufacturer_data_len = data_len;
3872         __filter->manufacturer_data_mask = g_memdup(mask, data_len);
3873
3874         return BT_ERROR_NONE;
3875 }
3876
3877 int bt_adapter_le_scan_filter_register(bt_scan_filter_h scan_filter)
3878 {
3879         bt_le_scan_filter_s *__filter = (bt_le_scan_filter_s *)scan_filter;
3880         GSList *l;
3881
3882         BT_CHECK_LE_SUPPORT();
3883         BT_CHECK_INIT_STATUS();
3884         BT_CHECK_INPUT_PARAMETER(scan_filter);
3885         if (bluetooth_is_le_scanning() == TRUE) {
3886                 BT_ERR("NOW_IN_PROGRESS(0x%08x)",
3887                         BT_ERROR_NOW_IN_PROGRESS); /* LCOV_EXCL_LINE */
3888                 return BT_ERROR_NOW_IN_PROGRESS;
3889         }
3890
3891         for (l = scan_filter_list; l != NULL; l = l->next) {
3892                 bt_le_scan_filter_s *filter = l->data;
3893                 if (__filter->filter_id == filter->filter_id) {
3894                         scan_filter_list = g_slist_remove(scan_filter_list, filter);
3895                         __bt_adapter_le_free_scan_filter(filter);
3896                         break;
3897                 }
3898         }
3899
3900         scan_filter_list = g_slist_append(scan_filter_list,
3901                         __bt_adapter_le_duplicate_scan_filter(__filter));
3902
3903         return BT_ERROR_NONE;
3904 }
3905
3906 int bt_adapter_le_scan_filter_unregister(bt_scan_filter_h scan_filter)
3907 {
3908         bt_le_scan_filter_s *__filter = (bt_le_scan_filter_s *)scan_filter;
3909         GSList *l;
3910
3911         BT_CHECK_LE_SUPPORT();
3912         BT_CHECK_INIT_STATUS();
3913         BT_CHECK_INPUT_PARAMETER(scan_filter);
3914         if (bluetooth_is_le_scanning() == TRUE) {
3915                 BT_ERR("NOW_IN_PROGRESS(0x%08x)",
3916                         BT_ERROR_NOW_IN_PROGRESS); /* LCOV_EXCL_LINE */
3917                 return BT_ERROR_NOW_IN_PROGRESS;
3918         }
3919
3920         for (l = scan_filter_list; l != NULL; l = l->next) {
3921                 bt_le_scan_filter_s *filter = l->data;
3922                 if (__filter->filter_id == filter->filter_id) {
3923                         scan_filter_list = g_slist_remove(scan_filter_list, filter);
3924                         __bt_adapter_le_free_scan_filter(filter);
3925                         break;
3926                 }
3927         }
3928
3929         return BT_ERROR_NONE;
3930 }
3931
3932 int bt_adapter_le_scan_filter_unregister_all(void)
3933 {
3934         int error_code = BT_ERROR_NONE;
3935
3936         BT_CHECK_LE_SUPPORT();
3937         BT_CHECK_INIT_STATUS();
3938
3939         if (bluetooth_is_le_scanning() == TRUE) {
3940                 BT_ERR("NOW_IN_PROGRESS(0x%08x)",
3941                         BT_ERROR_NOW_IN_PROGRESS); /* LCOV_EXCL_LINE */
3942                 return BT_ERROR_NOW_IN_PROGRESS;
3943         }
3944
3945         g_slist_free_full(scan_filter_list, (GDestroyNotify)__bt_adapter_le_free_scan_filter);
3946         scan_filter_list = NULL;
3947
3948         return error_code;
3949 }
3950
3951 /* LCOV_EXCL_START */
3952 int bt_adapter_le_read_maximum_data_length(
3953                 int *max_tx_octets, int *max_tx_time,
3954                 int *max_rx_octets, int *max_rx_time)
3955 {
3956         int ret = BT_ERROR_NONE;
3957
3958         BT_CHECK_SUPPORTED_FEATURE(BT_FEATURE_COMMON);
3959         BT_CHECK_INIT_STATUS();
3960
3961         bluetooth_le_read_maximum_data_length_t max_le_datalength;
3962
3963         ret = _bt_get_error_code(
3964                 bluetooth_le_read_maximum_data_length(&max_le_datalength));
3965
3966         if (ret != BT_ERROR_NONE) {
3967                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret),
3968                                                 ret); /* LCOV_EXCL_LINE */
3969                 return ret;
3970         }
3971
3972         *max_tx_octets = max_le_datalength.max_tx_octets;
3973         *max_tx_time = max_le_datalength.max_tx_time;
3974         *max_rx_octets = max_le_datalength.max_rx_octets;
3975         *max_rx_time = max_le_datalength.max_rx_time;
3976
3977         return ret;
3978 }
3979
3980 int bt_adapter_le_write_host_suggested_default_data_length(
3981                         const unsigned int def_tx_Octets,
3982                         const unsigned int def_tx_Time)
3983 {
3984         int ret = BT_ERROR_NONE;
3985
3986         BT_CHECK_SUPPORTED_FEATURE(BT_FEATURE_COMMON);
3987         BT_CHECK_INIT_STATUS();
3988
3989         /*Range for host suggested txtime is 0x001B-0x00FB  and
3990         txocets is 0x0148- 0x0848 as per BT 4.2 spec*/
3991         if (((def_tx_Octets < 27 || def_tx_Octets > 251) ||
3992                 (def_tx_Time < 328 || def_tx_Time > 2120)) ||
3993                 ((def_tx_Octets < 0x001B || def_tx_Octets > 0x00FB) ||
3994                 (def_tx_Time < 0x0148 || def_tx_Time > 0x0848))) {
3995                 return BT_ERROR_INVALID_PARAMETER;
3996         }
3997
3998         ret = _bt_get_error_code(
3999                 bluetooth_le_write_host_suggested_default_data_length(
4000                                         def_tx_Octets, def_tx_Time));
4001
4002         if (ret != BT_ERROR_NONE)
4003                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret),
4004                                                 ret); /* LCOV_EXCL_LINE */
4005
4006         return ret;
4007 }
4008
4009 int bt_adapter_le_read_suggested_default_data_length(
4010         unsigned int *def_tx_Octets,  unsigned int *def_tx_Time)
4011 {
4012         int ret = BT_ERROR_NONE;
4013
4014         BT_CHECK_SUPPORTED_FEATURE(BT_FEATURE_COMMON);
4015         BT_CHECK_INIT_STATUS();
4016
4017         bluetooth_le_read_host_suggested_data_length_t data_values;
4018
4019         ret = _bt_get_error_code(
4020                 bluetooth_le_read_suggested_default_data_length(&data_values));
4021
4022         if (ret != BT_ERROR_NONE) {
4023                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret),
4024                                                 ret); /* LCOV_EXCL_LINE */
4025                 return ret;
4026         }
4027
4028         *def_tx_Octets = data_values.def_tx_octets;
4029         *def_tx_Time = data_values.def_tx_time;
4030
4031         return ret;
4032 }
4033
4034 int bt_adapter_force_hcidump(int timeout)
4035 {
4036         int error_code = BT_ERROR_NONE;
4037
4038         BT_CHECK_LE_SUPPORT();
4039         BT_CHECK_INIT_STATUS();
4040
4041         error_code = _bt_get_error_code(bluetooth_force_hcidump(timeout));
4042
4043         if (error_code != BT_ERROR_NONE)
4044                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code);
4045
4046         return error_code;
4047 }
4048
4049 int bt_adapter_set_authentication_req_cb(bt_adapter_authentication_req_cb callback,
4050                                                         void *user_data)
4051 {
4052         BT_CHECK_INIT_STATUS();
4053         _bt_set_cb(BT_EVENT_AUTHENTICATION_REQUEST, callback, user_data);
4054         return BT_ERROR_NONE;
4055 }
4056
4057 int bt_adapter_set_authentication_request_cb(bt_adapter_authentication_request_cb callback,
4058                                                         void *user_data)
4059 {
4060         BT_CHECK_INIT_STATUS();
4061         BT_INFO("Setting callback for bt_adapter_authentication_request_cb for event %d", BT_EVENT_AUTHENTICATION_REQUEST_NEW);
4062         _bt_set_cb(BT_EVENT_AUTHENTICATION_REQUEST_NEW, callback, user_data);
4063         return BT_ERROR_NONE;
4064 }
4065
4066 int bt_adapter_unset_authentication_req_cb(void)
4067 {
4068         BT_CHECK_INIT_STATUS();
4069         _bt_unset_cb(BT_EVENT_AUTHENTICATION_REQUEST);
4070         return BT_ERROR_NONE;
4071 }
4072
4073 int bt_adapter_unset_authentication_request_cb(void)
4074 {
4075         BT_CHECK_INIT_STATUS();
4076         _bt_unset_cb(BT_EVENT_AUTHENTICATION_REQUEST_NEW);
4077         return BT_ERROR_NONE;
4078 }
4079
4080 int bt_adapter_le_scan_filter_set_ibeacon(bt_scan_filter_h scan_filter)
4081 {
4082         bt_le_scan_filter_s *__filter = (bt_le_scan_filter_s *)scan_filter;
4083         int ibeacon_manufacturer_id = COMPANY_ID_APPLE;
4084
4085         BT_CHECK_LE_SUPPORT();
4086         BT_CHECK_INIT_STATUS();
4087         BT_CHECK_INPUT_PARAMETER(scan_filter);
4088
4089         BT_INFO("");
4090
4091         g_free(__filter->manufacturer_data);
4092         g_free(__filter->manufacturer_data_mask);
4093
4094         __filter->manufacturer_id = ibeacon_manufacturer_id;
4095         __filter->manufacturer_data = NULL;
4096         __filter->manufacturer_data_len = 0;
4097         __filter->manufacturer_data_mask = NULL;
4098
4099         return BT_ERROR_NONE;
4100 }
4101
4102 int bt_adapter_le_scan_filter_set_proximity_uuid(bt_scan_filter_h scan_filter)
4103 {
4104         int ret;
4105
4106         BT_CHECK_LE_SUPPORT();
4107         BT_CHECK_INIT_STATUS();
4108         BT_CHECK_INPUT_PARAMETER(scan_filter);
4109
4110         /* register Linkloss alert scan filter */
4111         ret = bt_adapter_le_scan_filter_create(&pxp_linkloss_alert_filter);
4112         if (ret == BT_ERROR_NONE) {
4113
4114                 ret = bt_adapter_le_scan_filter_set_service_uuid(pxp_linkloss_alert_filter, PXP_LINK_LOSS_SVC_UUID);
4115                 if (ret == BT_ERROR_NONE)
4116                         ret = bt_adapter_le_scan_filter_register(pxp_linkloss_alert_filter);
4117                 if (ret != BT_ERROR_NONE) {
4118                         BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
4119
4120                         ret = bt_adapter_le_scan_filter_destroy(pxp_linkloss_alert_filter);
4121                         if (ret != BT_ERROR_NONE)
4122                                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
4123
4124                         pxp_linkloss_alert_filter = NULL;
4125                 }
4126         } else {
4127                 return BT_ERROR_OPERATION_FAILED;
4128         }
4129
4130         /* register Immediate alert scan filter */
4131         ret = bt_adapter_le_scan_filter_create(&pxp_immediate_alert_filter);
4132         if (ret == BT_ERROR_NONE) {
4133
4134                 ret = bt_adapter_le_scan_filter_set_service_uuid(pxp_immediate_alert_filter, PXP_IMMEDIATE_ALERT_SVC_UUID);
4135                 if (ret == BT_ERROR_NONE)
4136                         ret = bt_adapter_le_scan_filter_register(pxp_immediate_alert_filter);
4137                 if (ret != BT_ERROR_NONE) {
4138                         BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
4139
4140                         ret = bt_adapter_le_scan_filter_destroy(pxp_immediate_alert_filter);
4141                         if (ret != BT_ERROR_NONE)
4142                                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
4143
4144                         pxp_immediate_alert_filter = NULL;
4145                 }
4146         } else {
4147                 return BT_ERROR_OPERATION_FAILED;
4148         }
4149
4150         /* register Signal loss scan filter */
4151         ret = bt_adapter_le_scan_filter_create(&pxp_signal_loss_filter);
4152         if (ret == BT_ERROR_NONE) {
4153
4154                 ret = bt_adapter_le_scan_filter_set_service_uuid(pxp_signal_loss_filter, PXP_TX_POWER_SVC_UUID);
4155                 if (ret == BT_ERROR_NONE)
4156                         ret = bt_adapter_le_scan_filter_register(pxp_signal_loss_filter);
4157                 if (ret != BT_ERROR_NONE) {
4158                         BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
4159
4160                         ret = bt_adapter_le_scan_filter_destroy(pxp_signal_loss_filter);
4161                         if (ret != BT_ERROR_NONE)
4162                                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
4163
4164                         pxp_signal_loss_filter = NULL;
4165                 }
4166         } else {
4167                 return BT_ERROR_OPERATION_FAILED;
4168         }
4169         return ret;
4170 }
4171
4172 int bt_adapter_le_scan_filter_unset_proximity_uuid(bt_scan_filter_h scan_filter)
4173 {
4174         int ret = BT_ERROR_NONE;
4175
4176         BT_CHECK_LE_SUPPORT();
4177         BT_CHECK_INIT_STATUS();
4178         BT_CHECK_INPUT_PARAMETER(scan_filter);
4179
4180         /* unregister Linkloss alert scan filter */
4181         if (pxp_linkloss_alert_filter) {
4182
4183                 ret = bt_adapter_le_scan_filter_unregister(pxp_linkloss_alert_filter);
4184                 if (ret != BT_ERROR_NONE)
4185                         BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
4186
4187                 ret = bt_adapter_le_scan_filter_destroy(pxp_linkloss_alert_filter);
4188                 if (ret != BT_ERROR_NONE)
4189                         BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
4190
4191                 pxp_linkloss_alert_filter = NULL;
4192         }
4193
4194         /* unregister Immediate alert scan filter */
4195         if (pxp_immediate_alert_filter) {
4196
4197                 ret = bt_adapter_le_scan_filter_unregister(pxp_immediate_alert_filter);
4198                 if (ret != BT_ERROR_NONE)
4199                         BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
4200
4201                 ret = bt_adapter_le_scan_filter_destroy(pxp_immediate_alert_filter);
4202                 if (ret != BT_ERROR_NONE)
4203                         BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
4204
4205                 pxp_immediate_alert_filter = NULL;
4206         }
4207
4208         /* unregister Signal loss scan filter */
4209         if (pxp_signal_loss_filter) {
4210
4211                 ret = bt_adapter_le_scan_filter_unregister(pxp_signal_loss_filter);
4212                 if (ret != BT_ERROR_NONE)
4213                         BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
4214
4215                 ret = bt_adapter_le_scan_filter_destroy(pxp_signal_loss_filter);
4216                 if (ret != BT_ERROR_NONE)
4217                         BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
4218
4219                 pxp_signal_loss_filter = NULL;
4220         }
4221
4222         return ret;
4223 }
4224 /* LCOV_EXCL_STOP */
4225
4226 int bt_adapter_le_scan_filter_set_type(bt_scan_filter_h scan_filter,
4227                         bt_adapter_le_scan_filter_type_e mode)
4228 {
4229         if (mode == BT_ADAPTER_LE_SCAN_FILTER_TYPE_IBEACON)
4230                 return bt_adapter_le_scan_filter_set_ibeacon(scan_filter);
4231         else if (mode == BT_ADAPTER_LE_SCAN_FILTER_TYPE_PROXIMITY_UUID) /* LCOV_EXCL_LINE */
4232                 return bt_adapter_le_scan_filter_set_proximity_uuid(scan_filter); /* LCOV_EXCL_LINE */
4233         else
4234                 return BT_ERROR_INVALID_PARAMETER;
4235 }
4236
4237 /* LCOV_EXCL_START */
4238 int bt_adapter_passkey_reply(char *passkey, bool authentication_reply)
4239 {
4240         BT_CHECK_INIT_STATUS();
4241         BT_CHECK_INPUT_PARAMETER(passkey); /* LCOV_EXCL_LINE */
4242         int error_code = BT_ERROR_NONE; /* LCOV_EXCL_LINE */
4243         error_code = _bt_get_error_code(bluetooth_passkey_reply(passkey, authentication_reply)); /* LCOV_EXCL_LINE */
4244         if (error_code != BT_ERROR_NONE) /* LCOV_EXCL_LINE */
4245                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code); /* LCOV_EXCL_LINE */
4246
4247         return error_code;
4248 }
4249
4250 int bt_adapter_passkey_confirmation_reply(bool confirmation_reply)
4251 {
4252         BT_CHECK_INIT_STATUS();
4253
4254         int error_code = BT_ERROR_NONE; /* LCOV_EXCL_LINE */
4255         error_code = _bt_get_error_code(bluetooth_passkey_confirmation_reply(confirmation_reply)); /* LCOV_EXCL_LINE */
4256         if (error_code != BT_ERROR_NONE) /* LCOV_EXCL_LINE */
4257                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code); /* LCOV_EXCL_LINE */
4258
4259         return error_code;
4260 }
4261 /* LCOV_EXCL_STOP */
4262
4263 int bt_adapter_le_is_2m_phy_supported(bool *is_supported)
4264 {
4265         int ret = BT_ERROR_NONE;
4266         gboolean support = FALSE;
4267
4268         BT_CHECK_LE_5_0_SUPPORT();
4269         BT_CHECK_INIT_STATUS();
4270         BT_CHECK_INPUT_PARAMETER(is_supported);
4271
4272         ret = _bt_get_error_code(bluetooth_is_le_2m_phy_supported(&support));
4273         if (ret != BT_ERROR_NONE) {
4274                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
4275                 return ret;
4276         }
4277
4278         *is_supported = support ? true : false;
4279
4280         return BT_ERROR_NONE;
4281 }
4282
4283 int bt_adapter_le_is_coded_phy_supported(bool *is_supported)
4284 {
4285         int ret = BT_ERROR_NONE;
4286         gboolean support = FALSE;
4287
4288         BT_CHECK_LE_5_0_SUPPORT();
4289         BT_CHECK_INIT_STATUS();
4290         BT_CHECK_INPUT_PARAMETER(is_supported);
4291
4292         ret = _bt_get_error_code(bluetooth_is_le_coded_phy_supported(&support));
4293         if (ret != BT_ERROR_NONE) {
4294                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
4295                 return ret;
4296         }
4297
4298         *is_supported = support ? true : false;
4299
4300         return BT_ERROR_NONE;
4301 }
4302
4303 /* LCOV_EXCL_START */
4304 int bt_adapter_le_is_scan_filter_supported(bool *is_supported)
4305 {
4306         int ret = BT_ERROR_NONE;
4307         gboolean support = FALSE;
4308
4309         BT_CHECK_ADAPTER_STATUS();
4310         BT_CHECK_INIT_STATUS();
4311         BT_CHECK_INPUT_PARAMETER(is_supported);
4312
4313         ret = _bt_get_error_code(bluetooth_is_scan_filter_supported(&support));
4314
4315         if (ret != BT_ERROR_NONE) {
4316                 BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
4317                 return ret;
4318         }
4319
4320         *is_supported = support ? true : false;
4321
4322         return BT_ERROR_NONE;
4323 }
4324 /* LCOV_EXCL_STOP */