bt-api/bt-adapter-le.c

   1 /*
   2  * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *              http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 #include <stdio.h>
  19 #include <vconf.h>
  20
  21 #include "bluetooth-api.h"
  22 #include "bt-internal-types.h"
  23
  24 #include "bt-common.h"
  25 #include "bt-request-sender.h"
  26 #include "bt-event-handler.h"
  27
  28 static gboolean is_le_scanning = FALSE;
  29
  30 BT_EXPORT_API int bluetooth_check_adapter_le(void)
  31 {
  32         int ret;
  33         int value;
  34
  35         ret = _bt_get_adapter_path(_bt_gdbus_get_system_gconn(), NULL);
  36
  37         if (ret != BLUETOOTH_ERROR_NONE) {
  38                 return BLUETOOTH_ADAPTER_LE_DISABLED;
  39         }
  40
  41         ret = vconf_get_int(VCONFKEY_BT_LE_STATUS, &value);
  42         if (ret != 0) {
  43                 BT_ERR("fail to get vconf key!");
  44                 return ret;
  45         }
  46
  47         BT_DBG("value : %d", value);
  48         return value == VCONFKEY_BT_LE_STATUS_ON ? BLUETOOTH_ADAPTER_LE_ENABLED :
  49                                                 BLUETOOTH_ADAPTER_LE_DISABLED;
  50 }
  51
  52 BT_EXPORT_API int bluetooth_enable_adapter_le(void)
  53 {
  54         int result;
  55
  56         retv_if(bluetooth_check_adapter_le() == BLUETOOTH_ADAPTER_LE_ENABLED,
  57                                 BLUETOOTH_ERROR_DEVICE_ALREADY_ENABLED);
  58
  59         BT_INIT_PARAMS();
  60         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
  61
  62         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_ENABLE_ADAPTER_LE,
  63                 in_param1, in_param2, in_param3, in_param4, &out_param);
  64
  65         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
  66         return result;
  67 }
  68
  69 BT_EXPORT_API int bluetooth_disable_adapter_le(void)
  70 {
  71         int result;
  72         retv_if(bluetooth_check_adapter_le() == BLUETOOTH_ADAPTER_LE_DISABLED,
  73                                 BLUETOOTH_ERROR_DEVICE_NOT_ENABLED);
  74
  75         BT_INIT_PARAMS();
  76         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
  77
  78         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DISABLE_ADAPTER_LE,
  79                 in_param1, in_param2, in_param3, in_param4, &out_param);
  80
  81         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
  82
  83         return result;
  84 }
  85
  86 void _bt_set_le_scan_status(gboolean mode)
  87 {
  88         BT_DBG("set LE scan mode : %d", mode);
  89         is_le_scanning = mode;
  90 }
  91
  92 BT_EXPORT_API gboolean bluetooth_is_le_scanning(void)
  93 {
  94         return is_le_scanning;
  95 }
  96
  97 BT_EXPORT_API int bluetooth_start_le_discovery(void)
  98 {
  99         int result;
 100
 101         BT_CHECK_ENABLED_ANY(return);
 102
 103         BT_INIT_PARAMS();
 104         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 105
 106         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_START_LE_DISCOVERY,
 107                 in_param1, in_param2, in_param3, in_param4, &out_param);
 108
 109         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 110
 111         if (result == BLUETOOTH_ERROR_NONE)
 112                 _bt_set_le_scan_status(TRUE);
 113
 114         return result;
 115 }
 116
 117 BT_EXPORT_API int bluetooth_stop_le_discovery(void)
 118 {
 119         int result;
 120
 121         BT_CHECK_ENABLED_ANY(return);
 122
 123         BT_INIT_PARAMS();
 124         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 125
 126         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_STOP_LE_DISCOVERY,
 127                 in_param1, in_param2, in_param3, in_param4, &out_param);
 128
 129         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 130
 131         if (result == BLUETOOTH_ERROR_NONE)
 132                 _bt_set_le_scan_status(FALSE);
 133
 134         return result;
 135 }
 136
 137 BT_EXPORT_API int bluetooth_is_le_discovering(void)
 138 {
 139         int result;
 140         int is_discovering = FALSE;
 141
 142         BT_CHECK_ENABLED_ANY(return);
 143
 144         BT_INIT_PARAMS();
 145         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 146
 147         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_IS_LE_DISCOVERYING,
 148                 in_param1, in_param2, in_param3, in_param4, &out_param);
 149
 150         if (result == BLUETOOTH_ERROR_NONE) {
 151                 is_discovering = g_array_index(out_param,
 152                                 int, 0);
 153         } else {
 154                 BT_ERR("Fail to send request");
 155         }
 156
 157         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 158
 159         return is_discovering;
 160 }
 161
 162 BT_EXPORT_API int bluetooth_register_scan_filter(bluetooth_le_scan_filter_t *filter, int *slot_id)
 163 {
 164         int result;
 165
 166         BT_CHECK_ENABLED_ANY(return);
 167
 168         BT_INIT_PARAMS();
 169         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 170
 171         g_array_append_vals(in_param1, filter, sizeof(bluetooth_le_scan_filter_t));
 172
 173         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_REGISTER_SCAN_FILTER,
 174                 in_param1, in_param2, in_param3, in_param4, &out_param);
 175
 176         if (result == BLUETOOTH_ERROR_NONE) {
 177                 *slot_id = g_array_index(out_param, int, 0);
 178         } else {
 179                 BT_ERR("Fail to send request");
 180         }
 181
 182         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 183
 184         return result;
 185 }
 186
 187 BT_EXPORT_API int bluetooth_unregister_scan_filter(int slot_id)
 188 {
 189         int result;
 190
 191         BT_CHECK_ENABLED_ANY(return);
 192
 193         BT_INIT_PARAMS();
 194         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 195
 196         g_array_append_vals(in_param1, &slot_id, sizeof(int));
 197
 198         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_UNREGISTER_SCAN_FILTER,
 199                 in_param1, in_param2, in_param3, in_param4, &out_param);
 200
 201         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 202
 203         return result;
 204 }
 205
 206 BT_EXPORT_API int bluetooth_unregister_all_scan_filters(void)
 207 {
 208         int result;
 209
 210         BT_CHECK_ENABLED_ANY(return);
 211
 212         BT_INIT_PARAMS();
 213         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 214
 215         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_UNREGISTER_ALL_SCAN_FILTERS,
 216                 in_param1, in_param2, in_param3, in_param4, &out_param);
 217
 218         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 219
 220         return result;
 221 }
 222
 223 #ifdef TIZEN_WEARABLE
 224 gboolean __bluetooth_is_privileged_process(void)
 225 {
 226         FILE *fp = NULL;
 227         char path[30] = {0, };
 228         char buf[256] = {0, };
 229
 230         snprintf(path, sizeof(path), "/proc/%d/cmdline", getpid());
 231         fp = fopen(path, "r");
 232         if (fp == NULL)
 233                 return FALSE;
 234
 235         if (fgets(buf, 256, fp) != NULL) {
 236                 if (strstr(buf, "weconnd") != NULL) {
 237                         fclose(fp);
 238                         return TRUE;
 239                 }
 240         }
 241
 242         fclose(fp);
 243         return FALSE;
 244 }
 245 #endif
 246
 247 BT_EXPORT_API int bluetooth_set_advertising(int handle, gboolean enable)
 248 {
 249         int result;
 250         gboolean use_reserved_slot = FALSE;
 251
 252         BT_CHECK_ENABLED_ANY(return);
 253
 254 #ifdef TIZEN_WEARABLE
 255         use_reserved_slot = __bluetooth_is_privileged_process();
 256 #endif
 257
 258         BT_INIT_PARAMS();
 259         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 260
 261         g_array_append_vals(in_param1, &handle, sizeof(int));
 262         g_array_append_vals(in_param2, &enable, sizeof(gboolean));
 263         g_array_append_vals(in_param3, &use_reserved_slot, sizeof(gboolean));
 264
 265         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_SET_ADVERTISING,
 266                 in_param1, in_param2, in_param3, in_param4, &out_param);
 267
 268         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 269
 270         return result;
 271 }
 272
 273 BT_EXPORT_API int bluetooth_set_custom_advertising(int handle, gboolean enable,
 274                                                 bluetooth_advertising_params_t *params)
 275 {
 276         int result;
 277         gboolean use_reserved_slot = FALSE;
 278
 279         BT_CHECK_ENABLED_ANY(return);
 280
 281 #ifdef TIZEN_WEARABLE
 282         use_reserved_slot = __bluetooth_is_privileged_process();
 283 #endif
 284
 285         BT_INIT_PARAMS();
 286         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 287
 288         g_array_append_vals(in_param1, &handle, sizeof(int));
 289         g_array_append_vals(in_param2, &enable, sizeof(gboolean));
 290         g_array_append_vals(in_param3, params, sizeof(bluetooth_advertising_params_t));
 291         g_array_append_vals(in_param4, &use_reserved_slot, sizeof(gboolean));
 292
 293         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_SET_CUSTOM_ADVERTISING,
 294                 in_param1, in_param2, in_param3, in_param4, &out_param);
 295
 296         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 297
 298         return result;
 299 }
 300
 301 BT_EXPORT_API int bluetooth_get_advertising_data(bluetooth_advertising_data_t *adv_data, int *length)
 302 {
 303         int result;
 304         guint8 *data;
 305
 306         BT_CHECK_PARAMETER(adv_data, return);
 307         BT_CHECK_PARAMETER(length, return);
 308         BT_CHECK_ENABLED_ANY(return);
 309
 310         BT_INIT_PARAMS();
 311         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 312
 313         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_GET_ADVERTISING_DATA,
 314                 in_param1, in_param2, in_param3, in_param4, &out_param);
 315
 316         if (result == BLUETOOTH_ERROR_NONE) {
 317                 data = &g_array_index(out_param, guint8, 0);
 318                 *length = out_param->len;
 319
 320                 memset(adv_data, 0x00, sizeof(bluetooth_advertising_data_t));
 321                 memcpy(adv_data->data, data, *length);
 322         }
 323
 324         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 325
 326         return result;
 327 }
 328
 329 BT_EXPORT_API int bluetooth_set_advertising_data(int handle, const bluetooth_advertising_data_t *value, int length)
 330 {
 331         int result;
 332         gboolean use_reserved_slot = FALSE;
 333
 334         BT_CHECK_PARAMETER(value, return);
 335         BT_CHECK_ENABLED_ANY(return);
 336
 337         if (length > BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX - 3)
 338                 return BLUETOOTH_ERROR_INVALID_PARAM;
 339
 340 #ifdef TIZEN_WEARABLE
 341         use_reserved_slot = __bluetooth_is_privileged_process();
 342 #endif
 343
 344         BT_INIT_PARAMS();
 345         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 346
 347         g_array_append_vals(in_param1, &handle, sizeof(int));
 348         g_array_append_vals(in_param2, value, sizeof(bluetooth_advertising_data_t));
 349         g_array_append_vals(in_param3, &length, sizeof(int));
 350         g_array_append_vals(in_param4, &use_reserved_slot, sizeof(gboolean));
 351
 352         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_SET_ADVERTISING_DATA,
 353                 in_param1, in_param2, in_param3, in_param4, &out_param);
 354
 355         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 356
 357         return result;
 358 }
 359
 360 BT_EXPORT_API int bluetooth_get_scan_response_data(bluetooth_scan_resp_data_t *value, int *length)
 361 {
 362         int result;
 363         guint8 *data;
 364
 365         BT_CHECK_PARAMETER(value, return);
 366         BT_CHECK_PARAMETER(length, return);
 367         BT_CHECK_ENABLED_ANY(return);
 368
 369         BT_INIT_PARAMS();
 370         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 371
 372         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_GET_SCAN_RESPONSE_DATA,
 373                 in_param1, in_param2, in_param3, in_param4, &out_param);
 374
 375         if (result == BLUETOOTH_ERROR_NONE) {
 376                 data = &g_array_index(out_param, guint8, 0);
 377                 *length = out_param->len;
 378
 379                 memset(value, 0x00, sizeof(bluetooth_scan_resp_data_t));
 380                 memcpy(value->data, data, *length);
 381         }
 382
 383         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 384
 385         return result;
 386 }
 387
 388 BT_EXPORT_API int bluetooth_set_scan_response_data(int handle,
 389                         const bluetooth_scan_resp_data_t *value, int length)
 390 {
 391         int result;
 392         gboolean use_reserved_slot = FALSE;
 393
 394         BT_CHECK_PARAMETER(value, return);
 395         BT_CHECK_ENABLED_ANY(return);
 396
 397         if (length > BLUETOOTH_SCAN_RESP_DATA_LENGTH_MAX)
 398                 return BLUETOOTH_ERROR_INVALID_PARAM;
 399
 400 #ifdef TIZEN_WEARABLE
 401         use_reserved_slot = __bluetooth_is_privileged_process();
 402 #endif
 403
 404         BT_INIT_PARAMS();
 405         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 406
 407         g_array_append_vals(in_param1, &handle, sizeof(int));
 408         g_array_append_vals(in_param2, value, length);
 409         g_array_append_vals(in_param3, &length, sizeof(int));
 410         g_array_append_vals(in_param4, &use_reserved_slot, sizeof(gboolean));
 411
 412         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_SET_SCAN_RESPONSE_DATA,
 413                 in_param1, in_param2, in_param3, in_param4, &out_param);
 414
 415         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 416
 417         return result;
 418 }
 419
 420 BT_EXPORT_API int bluetooth_set_scan_parameters(bluetooth_le_scan_params_t *params)
 421 {
 422         int result;
 423
 424         BT_CHECK_ENABLED_ANY(return);
 425
 426         BT_INIT_PARAMS();
 427         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 428
 429         g_array_append_vals(in_param1, params, sizeof(bluetooth_le_scan_params_t));
 430
 431         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_SET_SCAN_PARAMETERS,
 432                 in_param1, in_param2, in_param3, in_param4, &out_param);
 433
 434         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 435
 436         return result;
 437 }
 438
 439 BT_EXPORT_API int bluetooth_is_advertising(gboolean *is_advertising)
 440 {
 441         int result;
 442
 443         BT_CHECK_ENABLED_ANY(return);
 444
 445         BT_INIT_PARAMS();
 446         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 447
 448         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_IS_ADVERTISING,
 449                 in_param1, in_param2, in_param3, in_param4, &out_param);
 450
 451         if (result == BLUETOOTH_ERROR_NONE) {
 452                 *is_advertising = g_array_index(out_param, int, 0);
 453         } else {
 454                 BT_ERR("Fail to send request");
 455         }
 456
 457         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 458
 459         return result;
 460 }
 461
 462 BT_EXPORT_API int bluetooth_add_white_list(bluetooth_device_address_t *address, bluetooth_device_address_type_t address_type)
 463 {
 464         int result;
 465
 466         BT_CHECK_PARAMETER(address, return);
 467         BT_CHECK_ENABLED_ANY(return);
 468
 469         BT_INIT_PARAMS();
 470         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 471
 472         g_array_append_vals(in_param1, address, sizeof(bluetooth_device_address_t));
 473         g_array_append_vals(in_param2, &address_type, sizeof(int));
 474
 475         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_ADD_WHITE_LIST,
 476                 in_param1, in_param2, in_param3, in_param4, &out_param);
 477
 478         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 479
 480         return result;
 481 }
 482
 483 BT_EXPORT_API int bluetooth_remove_white_list(bluetooth_device_address_t *address, bluetooth_device_address_type_t address_type)
 484 {
 485         int result;
 486
 487         BT_CHECK_PARAMETER(address, return);
 488         BT_CHECK_ENABLED_ANY(return);
 489
 490         BT_INIT_PARAMS();
 491         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 492
 493         g_array_append_vals(in_param1, address, sizeof(bluetooth_device_address_t));
 494         g_array_append_vals(in_param2, &address_type, sizeof(int));
 495
 496         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_REMOVE_WHITE_LIST,
 497                 in_param1, in_param2, in_param3, in_param4, &out_param);
 498
 499         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 500
 501         return result;
 502 }
 503
 504 BT_EXPORT_API int bluetooth_clear_white_list(void)
 505 {
 506         int result;
 507
 508         BT_CHECK_ENABLED_ANY(return);
 509
 510         BT_INIT_PARAMS();
 511         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 512
 513         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_CLEAR_WHITE_LIST,
 514                 in_param1, in_param2, in_param3, in_param4, &out_param);
 515
 516         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 517
 518         return result;
 519 }
 520
 521 BT_EXPORT_API int bluetooth_enable_le_privacy(gboolean enable_privacy)
 522 {
 523         int result;
 524
 525         BT_CHECK_ENABLED_ANY(return);
 526
 527         BT_INIT_PARAMS();
 528         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 529
 530         g_array_append_vals(in_param1, &enable_privacy, sizeof(gboolean));
 531
 532         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_SET_LE_PRIVACY,
 533                 in_param1, in_param2, in_param3, in_param4, &out_param);
 534
 535         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 536
 537         return result;
 538 }
 539
 540 BT_EXPORT_API int bluetooth_check_privilege_advertising_parameter(void)
 541 {
 542         if (_bt_check_privilege(BT_CHECK_PRIVILEGE, BT_SET_ADVERTISING_PARAMETERS)
 543                      == BLUETOOTH_ERROR_PERMISSION_DEINED) {
 544                 BT_ERR("Don't have a privilege to use this API");
 545                 return BLUETOOTH_ERROR_PERMISSION_DEINED;
 546         }
 547
 548         return BLUETOOTH_ERROR_NONE;
 549 }
 550
 551 BT_EXPORT_API int bluetooth_le_register_callback(bluetooth_cb_func_ptr callback_ptr, void *user_data)
 552 {
 553         int ret;
 554
 555         ret = _bt_register_event(BT_LE_ADAPTER_EVENT, (void *)callback_ptr, user_data);
 556         if (ret != BLUETOOTH_ERROR_NONE &&
 557             ret != BLUETOOTH_ERROR_ALREADY_INITIALIZED) {
 558                 BT_ERR("Fail to register BT_LE_ADAPTER_EVENT event : %d", ret);
 559                 return ret;
 560         }
 561
 562         return BLUETOOTH_ERROR_NONE;
 563 }
 564
 565 BT_EXPORT_API int bluetooth_le_unregister_callback(void)
 566 {
 567         _bt_unregister_event(BT_LE_ADAPTER_EVENT);
 568
 569         return BLUETOOTH_ERROR_NONE;
 570 }
 571
 572 BT_EXPORT_API int bluetooth_le_read_maximum_data_length(
 573                         bluetooth_le_read_maximum_data_length_t *max_le_datalength)
 574 {
 575         BT_CHECK_ENABLED_ANY(return);
 576         BT_INIT_PARAMS();
 577         int result;
 578         bluetooth_le_read_maximum_data_length_t *datalength = NULL;
 579
 580         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 581
 582         result = _bt_send_request(BT_BLUEZ_SERVICE,
 583                 BT_LE_READ_MAXIMUM_DATA_LENGTH,
 584                 in_param1, in_param2, in_param3, in_param4, &out_param);
 585
 586         if (result == BLUETOOTH_ERROR_NONE) {
 587                 datalength = &g_array_index(out_param,
 588                         bluetooth_le_read_maximum_data_length_t, 0);
 589                 max_le_datalength->max_tx_octets  = datalength->max_tx_octets;
 590                 max_le_datalength->max_tx_time = datalength->max_tx_time;
 591                 max_le_datalength->max_rx_octets = datalength->max_rx_octets;
 592                 max_le_datalength->max_rx_time = datalength->max_rx_time;
 593         }
 594
 595         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 596
 597         return result;
 598 }
 599
 600 BT_EXPORT_API int bluetooth_le_write_host_suggested_default_data_length(
 601         const unsigned int def_tx_Octets, const unsigned int def_tx_Time)
 602 {
 603         BT_CHECK_ENABLED_ANY(return);
 604         BT_INIT_PARAMS();
 605
 606         int result;
 607
 608         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 609
 610         g_array_append_vals(in_param1, &def_tx_Octets, sizeof(guint));
 611         g_array_append_vals(in_param2, &def_tx_Time, sizeof(guint));
 612
 613         result = _bt_send_request(BT_BLUEZ_SERVICE,
 614                 BT_LE_WRITE_HOST_SUGGESTED_DATA_LENGTH,
 615                 in_param1, in_param2, in_param3, in_param4, &out_param);
 616
 617         if (result != BLUETOOTH_ERROR_NONE) {
 618                 BT_ERR("Failed to Write the host suggested default data length values : %d", result);
 619         }
 620
 621         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 622
 623         return result;
 624 }
 625
 626 BT_EXPORT_API int bluetooth_le_read_suggested_default_data_length(
 627         bluetooth_le_read_host_suggested_data_length_t *le_data_length)
 628 {
 629         BT_CHECK_ENABLED_ANY(return);
 630         BT_INIT_PARAMS();
 631
 632         int result;
 633         bluetooth_le_read_host_suggested_data_length_t *data_values = NULL;
 634         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 635
 636         result = _bt_send_request(BT_BLUEZ_SERVICE,
 637                 BT_LE_READ_HOST_SUGGESTED_DATA_LENGTH,
 638                 in_param1, in_param2, in_param3, in_param4, &out_param);
 639
 640         if (result == BLUETOOTH_ERROR_NONE) {
 641                 data_values = &g_array_index(out_param,
 642                         bluetooth_le_read_host_suggested_data_length_t, 0);
 643
 644                 le_data_length->def_tx_octets = data_values->def_tx_octets;
 645                 le_data_length->def_tx_time = data_values->def_tx_time;
 646         }
 647
 648         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 649
 650         return result;
 651 }
 652
 653 BT_EXPORT_API int bluetooth_le_set_data_length(bluetooth_device_address_t *address,
 654         const unsigned int max_tx_octets, const unsigned int max_tx_time)
 655 {
 656         BT_CHECK_ENABLED_ANY(return);
 657         BT_INIT_PARAMS();
 658
 659         int result;
 660
 661         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 662
 663         g_array_append_vals(in_param1, address, sizeof(bluetooth_device_address_t));
 664         g_array_append_vals(in_param2, &max_tx_octets, sizeof(guint));
 665         g_array_append_vals(in_param3, &max_tx_time, sizeof(guint));
 666
 667         result = _bt_send_request(BT_BLUEZ_SERVICE,
 668                 BT_LE_SET_DATA_LENGTH,
 669                 in_param1, in_param2, in_param3, in_param4, &out_param);
 670
 671         if (result != BLUETOOTH_ERROR_NONE) {
 672                 BT_ERR("Failed to Set data length values : %d", result);
 673         }
 674
 675         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 676
 677         return result;
 678 }