bt-api/bt-dpm.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 <vconf.h>
  19
  20 #include "bluetooth-api.h"
  21 #include "bt-internal-types.h"
  22 #include "bt-common.h"
  23 #include "bt-request-sender.h"
  24 #include "bt-event-handler.h"
  25 #include "bt-event-handler.h"
  26 #include "bt-dpm.h"
  27
  28 BT_EXPORT_API int bluetooth_dpm_is_mode_allowed(void)
  29 {
  30         int value;
  31         /* check VCONFKEY_BT_STATUS */
  32         if (vconf_get_int(VCONFKEY_BT_DPM_STATUS, &value) != 0) {
  33                 BT_ERR("fail to get vconf key!");
  34                 return BLUETOOTH_ERROR_INTERNAL;
  35         }
  36         if (value != VCONFKEY_BT_DPM_STATUS_RESTRICTED)
  37                 return BLUETOOTH_ERROR_NONE;
  38         else
  39                 return BLUETOOTH_ERROR_PERMISSION_DEINED;
  40 }
  41
  42 static bt_dpm_status_e _bt_check_dpm_handsfree_only(void)
  43 {
  44         bt_dpm_allow_t mode;
  45
  46         bluetooth_dpm_get_allow_mode(&mode);
  47
  48         return (mode == BLUETOOTH_DPM_HANDSFREE_ONLY ? BT_DPM_RESTRICTED : BT_DPM_ALLOWED);
  49 }
  50
  51 static bt_dpm_status_e _bt_check_dpm_pairing_restriction(void)
  52 {
  53         bt_dpm_status_t dpm_status = BLUETOOTH_DPM_ALLOWED;
  54
  55         bluetooth_dpm_get_pairing_state(&dpm_status);
  56
  57         return (dpm_status == BLUETOOTH_DPM_RESTRICTED ? BT_DPM_RESTRICTED : BT_DPM_ALLOWED);
  58 }
  59
  60 static bt_dpm_status_e _bt_check_dpm_desktop_connectivity_restriction(void)
  61 {
  62         bt_dpm_status_t dpm_status = BLUETOOTH_DPM_ALLOWED;
  63
  64         bluetooth_dpm_get_desktop_connectivity_state(&dpm_status);
  65
  66         return (dpm_status == BLUETOOTH_DPM_RESTRICTED ? BT_DPM_RESTRICTED : BT_DPM_ALLOWED);
  67 }
  68
  69 static bt_dpm_status_e _bt_check_dpm_blocklist_device(bluetooth_device_address_t *address)
  70 {
  71         int ret = BLUETOOTH_DPM_RESULT_SUCCESS;
  72         bt_dpm_device_list_t dev_list;
  73         char device_address[BT_ADDRESS_STRING_SIZE] = { 0 };
  74
  75         _bt_convert_addr_type_to_string(device_address,
  76                         (unsigned char *)address->addr);
  77
  78         ret = bluetooth_dpm_get_devices_from_blocklist(&dev_list);
  79         if (ret == BLUETOOTH_DPM_RESULT_SUCCESS) {
  80                 int i = 0;
  81                 for (i = 0; i < dev_list.count; i++) {
  82                         char temp_address[BT_ADDRESS_STRING_SIZE] = { 0 };
  83                         _bt_convert_addr_type_to_string(temp_address,
  84                         (unsigned char *)dev_list.addresses[i].addr);
  85                         if (g_strcmp0(device_address, temp_address) == 0)
  86                                 return BT_DPM_RESTRICTED;
  87                 }
  88         } else {
  89                 return BT_DPM_NO_SERVICE;
  90         }
  91         return BT_DPM_ALLOWED;
  92 }
  93
  94 static bt_dpm_status_e _bt_check_dpm_blocklist_uuid(char *uuid)
  95 {
  96         bt_dpm_status_e bt_dpm_status = BT_DPM_ALLOWED;
  97         bt_dpm_status_t dpm_status = BLUETOOTH_DPM_ALLOWED;
  98         bt_dpm_profile_t dpm_profile = BLUETOOTH_DPM_PROFILE_NONE;
  99         bt_dpm_uuids_list_t uuid_list;
 100         int ret = BLUETOOTH_DPM_RESULT_SUCCESS;
 101         retv_if(!uuid, bt_dpm_status);
 102
 103         ret = bluetooth_dpm_get_uuids_from_blocklist(&uuid_list);
 104         if (ret == BLUETOOTH_DPM_RESULT_SUCCESS) {
 105                 int i = 0;
 106                 for (i = 0; i < uuid_list.count; i++) {
 107                         if (g_strcmp0(uuid, uuid_list.uuids[i]) == 0)
 108                                 return BT_DPM_RESTRICTED;
 109                 }
 110         } else {
 111                 return BT_DPM_NO_SERVICE;
 112         }
 113
 114         if (g_strcmp0(BT_OPP_UUID, uuid) == 0) {
 115                 bt_dpm_status_t dpm_status = BLUETOOTH_DPM_ALLOWED;
 116                 bluetooth_dpm_get_data_transfer_state(&dpm_status);
 117                 return (dpm_status == BLUETOOTH_DPM_RESTRICTED ? BT_DPM_RESTRICTED : BT_DPM_ALLOWED);
 118         }
 119         /* TODO: MAP? see above */
 120
 121         /* ++ check MDM profile restriction ++ */
 122         if (g_strcmp0(BT_A2DP_UUID, uuid) == 0)
 123                 dpm_profile = BLUETOOTH_DPM_POLICY_A2DP_PROFILE_STATE;
 124         else if (g_strcmp0(BT_AVRCP_TARGET_UUID, uuid) == 0)
 125                 dpm_profile = BLUETOOTH_DPM_POLICY_AVRCP_PROFILE_STATE;
 126         else if (g_strcmp0(BT_HFP_AUDIO_GATEWAY_UUID, uuid) == 0)
 127                 dpm_profile = BLUETOOTH_DPM_POLICY_HFP_PROFILE_STATE;
 128         else if (g_strcmp0(BT_HSP_AUDIO_GATEWAY_UUID, uuid) == 0)
 129                 dpm_profile = BLUETOOTH_DPM_POLICY_HSP_PROFILE_STATE;
 130         else if (g_strcmp0(BT_OBEX_PSE_UUID, uuid) == 0)
 131                 dpm_profile = BLUETOOTH_DPM_POLICY_PBAP_PROFILE_STATE;
 132
 133         if (dpm_profile != BLUETOOTH_DPM_PROFILE_NONE) {
 134                 ret = bluetooth_dpm_get_profile_state(dpm_profile, &dpm_status);
 135                 return (dpm_status == BLUETOOTH_DPM_RESTRICTED ? BT_DPM_RESTRICTED : BT_DPM_ALLOWED);
 136         }
 137         /* -- check DPM profile restriction -- */
 138
 139         return bt_dpm_status;
 140 }
 141
 142 static bt_dpm_status_e _bt_check_dpm_transfer_restriction(void)
 143 {
 144         bt_dpm_status_e dpm_status = BT_DPM_ALLOWED;
 145         bt_dpm_status_t dpm_value = BLUETOOTH_DPM_ALLOWED;
 146
 147         dpm_status = _bt_check_dpm_blocklist_uuid(BT_OPP_UUID);
 148         /* TODO: MAP? see above */
 149
 150         if (dpm_status == BT_DPM_NO_SERVICE || dpm_status == BT_DPM_RESTRICTED)
 151                 return dpm_status;
 152
 153         bluetooth_dpm_get_data_transfer_state(&dpm_value);
 154
 155         return (dpm_value == BLUETOOTH_DPM_RESTRICTED ? BT_DPM_RESTRICTED : BT_DPM_ALLOWED);
 156 }
 157
 158 static bt_dpm_status_e _bt_check_dpm_hsp_restriction(void)
 159 {
 160         bt_dpm_status_e dpm_status = BT_DPM_ALLOWED;
 161
 162         dpm_status = _bt_check_dpm_blocklist_uuid(BT_HFP_AUDIO_GATEWAY_UUID);
 163
 164         if (dpm_status == BT_DPM_NO_SERVICE || dpm_status == BT_DPM_RESTRICTED)
 165                 return dpm_status;
 166
 167         dpm_status = _bt_check_dpm_blocklist_uuid(BT_HSP_AUDIO_GATEWAY_UUID);
 168         if (dpm_status == BT_DPM_NO_SERVICE || dpm_status == BT_DPM_RESTRICTED)
 169                 return dpm_status;
 170
 171         return dpm_status;
 172 }
 173
 174 static bt_dpm_status_e _bt_check_dpm_a2dp_restriction(void)
 175 {
 176         bt_dpm_status_e dpm_status = BT_DPM_ALLOWED;
 177
 178         dpm_status = _bt_check_dpm_blocklist_uuid(BT_A2DP_UUID);
 179
 180         if (dpm_status == BT_DPM_NO_SERVICE || dpm_status == BT_DPM_RESTRICTED)
 181                 return dpm_status;
 182
 183         return dpm_status;
 184 }
 185
 186 static bt_dpm_status_e _bt_check_dpm_avrcp_restriction(void)
 187 {
 188         bt_dpm_status_e dpm_status = BT_DPM_ALLOWED;
 189
 190         dpm_status = _bt_check_dpm_blocklist_uuid(BT_AVRCP_TARGET_UUID);
 191
 192         if (dpm_status == BT_DPM_NO_SERVICE || dpm_status == BT_DPM_RESTRICTED)
 193                 return dpm_status;
 194
 195         return dpm_status;
 196 }
 197
 198 static bt_dpm_status_e _bt_check_dpm_spp_restriction(void)
 199 {
 200         bt_dpm_status_e dpm_status = BT_DPM_ALLOWED;
 201
 202         dpm_status = _bt_check_dpm_blocklist_uuid(BT_SPP_UUID);
 203
 204         if (dpm_status == BT_DPM_NO_SERVICE || dpm_status == BT_DPM_RESTRICTED)
 205                 return dpm_status;
 206
 207         return dpm_status;
 208 }
 209
 210 int _bt_check_dpm(int service, void *param)
 211 {
 212         bt_dpm_status_e status = BT_DPM_ALLOWED;
 213
 214         switch (service) {
 215         case BT_DPM_HF_ONLY:
 216                 status = _bt_check_dpm_handsfree_only();
 217                 break;
 218         case BT_DPM_PAIRING:
 219                 status = _bt_check_dpm_pairing_restriction();
 220                 break;
 221         case BT_DPM_DESKTOP:
 222                 status = _bt_check_dpm_desktop_connectivity_restriction();
 223                 break;
 224         case BT_DPM_ADDRESS: {
 225                 status = _bt_check_dpm_blocklist_device((bluetooth_device_address_t *)param);
 226                 }
 227                 break;
 228         case BT_DPM_UUID: {
 229                 char *uuid;
 230                 uuid = (char *)param;
 231                 status = _bt_check_dpm_blocklist_uuid(uuid);
 232                 }
 233                 break;
 234         case BT_DPM_OPP:
 235                 status = _bt_check_dpm_transfer_restriction();
 236                 break;
 237         /* TODO: MAP? see above */
 238         case BT_DPM_HSP:
 239                 status = _bt_check_dpm_hsp_restriction();
 240                 break;
 241         case BT_DPM_A2DP:
 242                 status = _bt_check_dpm_a2dp_restriction();
 243                 break;
 244         case BT_DPM_AVRCP:
 245                 status = _bt_check_dpm_avrcp_restriction();
 246                 break;
 247         case BT_DPM_SPP:
 248                 status = _bt_check_dpm_spp_restriction();
 249                 break;
 250         default:
 251                 BT_ERR("Unknown service");
 252                 return status;
 253         }
 254
 255         return status;
 256 }
 257
 258 BT_EXPORT_API int bluetooth_dpm_set_allow_mode(bt_dpm_allow_t value)
 259 {
 260         int result =  BLUETOOTH_ERROR_NONE;
 261         int bt_status;
 262
 263         if (value >= BLUETOOTH_DPM_BT_ALLOWED &&
 264                 value <= BLUETOOTH_DPM_BT_RESTRICTED) {
 265                 if (vconf_set_int(VCONFKEY_BT_DPM_STATUS, value) != 0) {
 266                         BT_ERR("Set VCONFKEY_BT_DPM_STATUS failed\n");
 267                         result = BLUETOOTH_ERROR_INTERNAL;
 268                 } else
 269                         result = BLUETOOTH_ERROR_NONE;
 270         } else
 271                 result = BLUETOOTH_ERROR_INVALID_PARAM;
 272
 273         if (vconf_get_int(VCONFKEY_BT_STATUS, &bt_status) < 0)
 274                 BT_ERR("Error in reading VCONFKEY_BT_STATUS");
 275
 276         if (bt_status == VCONFKEY_BT_STATUS_ON) {
 277                 BT_INIT_PARAMS();
 278                 BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 279
 280                 g_array_append_vals(in_param1, &value, sizeof(int));
 281
 282                 result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_SET_ALLOW_BT_MODE,
 283                         in_param1, in_param2, in_param3, in_param4, &out_param);
 284
 285                 BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 286
 287                 if (result == BLUETOOTH_ERROR_NONE &&
 288                         value == BLUETOOTH_DPM_BT_RESTRICTED) {
 289                         result = bluetooth_disable_adapter();
 290                 }
 291         }
 292
 293         return result;
 294
 295 }
 296
 297 BT_EXPORT_API int bluetooth_dpm_get_allow_mode(bt_dpm_allow_t *value)
 298 {
 299         int result;
 300
 301         if (vconf_get_int(VCONFKEY_BT_DPM_STATUS, value) != 0) {
 302                 BT_ERR("fail to get vconf key!");
 303                 return BLUETOOTH_ERROR_INTERNAL;
 304         }
 305         result = BLUETOOTH_ERROR_NONE;
 306
 307         return result;
 308 }
 309
 310
 311 BT_EXPORT_API int bluetooth_dpm_activate_device_restriction(bt_dpm_status_t value)
 312 {
 313         int result;
 314
 315         BT_CHECK_ENABLED_ANY(return);
 316
 317         BT_INIT_PARAMS();
 318         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 319
 320         g_array_append_vals(in_param1, &value, sizeof(int));
 321
 322         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_SET_DEVICE_RESTRITION,
 323                 in_param1, in_param2, in_param3, in_param4, &out_param);
 324
 325         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 326
 327         return result;
 328 }
 329
 330
 331 BT_EXPORT_API int bluetooth_dpm_is_device_restriction_active(bt_dpm_status_t *value)
 332 {
 333         int result;
 334
 335         BT_CHECK_ENABLED_ANY(return);
 336
 337         BT_INIT_PARAMS();
 338         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 339
 340         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_GET_DEVICE_RESTRITION,
 341                 in_param1, in_param2, in_param3, in_param4, &out_param);
 342
 343         if (result == BLUETOOTH_ERROR_NONE) {
 344                 if (out_param->len > 0) {
 345                         *value = g_array_index(out_param,
 346                                         int, 0);
 347                 } else {
 348                         BT_ERR("out_param length is 0!!");
 349                 }
 350         }
 351
 352         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 353
 354         return result;
 355 }
 356
 357
 358 BT_EXPORT_API int bluetooth_dpm_activate_uuid_restriction(bt_dpm_status_t value)
 359 {
 360         int result;
 361
 362         BT_CHECK_ENABLED_ANY(return);
 363
 364         BT_INIT_PARAMS();
 365         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 366
 367         g_array_append_vals(in_param1, &value, sizeof(int));
 368
 369         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_SET_UUID_RESTRITION,
 370                 in_param1, in_param2, in_param3, in_param4, &out_param);
 371
 372         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 373
 374         return result;
 375 }
 376
 377
 378 BT_EXPORT_API int bluetooth_dpm_is_uuid_restriction_active(bt_dpm_status_t *value)
 379 {
 380         int result;
 381
 382         BT_CHECK_ENABLED_ANY(return);
 383
 384         BT_INIT_PARAMS();
 385         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 386
 387         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_GET_UUID_RESTRITION,
 388                 in_param1, in_param2, in_param3, in_param4, &out_param);
 389
 390         if (result == BLUETOOTH_ERROR_NONE) {
 391                 if (out_param->len > 0) {
 392                         *value = g_array_index(out_param,
 393                                         int, 0);
 394                 } else {
 395                         BT_ERR("out_param length is 0!!");
 396                 }
 397         }
 398
 399         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 400
 401         return result;
 402
 403 }
 404
 405
 406 BT_EXPORT_API int bluetooth_dpm_add_devices_to_blocklist(const bluetooth_device_address_t *device_address)
 407 {
 408         int result;
 409
 410         BT_CHECK_PARAMETER(device_address, return);
 411         BT_CHECK_ENABLED_ANY(return);
 412
 413         BT_INIT_PARAMS();
 414         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 415
 416         g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
 417
 418
 419         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_ADD_DEVICES_BLOCKLIST,
 420                 in_param1, in_param2, in_param3, in_param4, &out_param);
 421
 422         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 423
 424         return result;
 425 }
 426
 427
 428 BT_EXPORT_API int bluetooth_dpm_add_devices_to_allowlist(const bluetooth_device_address_t *device_address)
 429 {
 430         int result;
 431
 432         BT_CHECK_PARAMETER(device_address, return);
 433         BT_CHECK_ENABLED_ANY(return);
 434
 435         BT_INIT_PARAMS();
 436         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 437
 438         g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
 439
 440         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_ADD_DEVICES_ALLOWLIST,
 441                 in_param1, in_param2, in_param3, in_param4, &out_param);
 442
 443         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 444
 445         return result;
 446
 447 }
 448
 449
 450 BT_EXPORT_API int bluetooth_dpm_add_uuids_to_blocklist(const char *service_uuid)
 451 {
 452         int result;
 453         char uuid[BLUETOOTH_UUID_STRING_MAX];
 454
 455         BT_CHECK_PARAMETER(service_uuid, return);
 456         BT_CHECK_ENABLED_ANY(return);
 457
 458
 459         BT_INIT_PARAMS();
 460         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 461
 462         g_strlcpy(uuid, service_uuid, sizeof(uuid));
 463         g_array_append_vals(in_param1, uuid, BLUETOOTH_UUID_STRING_MAX);
 464
 465         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_ADD_UUIDS_BLOCKLIST,
 466                 in_param1, in_param2, in_param3, in_param4, &out_param);
 467
 468         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 469
 470         return result;
 471
 472 }
 473
 474
 475 BT_EXPORT_API int bluetooth_dpm_add_uuids_to_allowlist(const char *service_uuid)
 476 {
 477         int result;
 478         char uuid[BLUETOOTH_UUID_STRING_MAX];
 479
 480         BT_CHECK_PARAMETER(service_uuid, return);
 481         BT_CHECK_ENABLED_ANY(return);
 482
 483         BT_INIT_PARAMS();
 484         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 485
 486         g_strlcpy(uuid, service_uuid, sizeof(uuid));
 487         g_array_append_vals(in_param1, uuid, BLUETOOTH_UUID_STRING_MAX);
 488
 489         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_ADD_UUIDS_ALLOWLIST,
 490                 in_param1, in_param2, in_param3, in_param4, &out_param);
 491
 492         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 493
 494         return result;
 495 }
 496
 497
 498 BT_EXPORT_API int bluetooth_dpm_clear_devices_from_blocklist(void)
 499 {
 500         int result;
 501
 502         BT_CHECK_ENABLED_ANY(return);
 503
 504         BT_INIT_PARAMS();
 505         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 506
 507         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_CLEAR_DEVICES_BLOCKLIST,
 508                 in_param1, in_param2, in_param3, in_param4, &out_param);
 509
 510         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 511
 512         return result;
 513 }
 514
 515
 516 BT_EXPORT_API int bluetooth_dpm_clear_devices_from_allowlist(void)
 517 {
 518         int result;
 519
 520         BT_CHECK_ENABLED_ANY(return);
 521
 522         BT_INIT_PARAMS();
 523         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 524
 525         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_CLEAR_DEVICES_ALLOWLIST,
 526                 in_param1, in_param2, in_param3, in_param4, &out_param);
 527
 528         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 529
 530         return result;
 531 }
 532
 533
 534 BT_EXPORT_API int bluetooth_dpm_clear_uuids_from_blocklist(void)
 535 {
 536         int result;
 537
 538         BT_CHECK_ENABLED_ANY(return);
 539
 540         BT_INIT_PARAMS();
 541         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 542
 543         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_CLEAR_UUIDS_BLOCKLIST,
 544                 in_param1, in_param2, in_param3, in_param4, &out_param);
 545
 546         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 547
 548         return result;
 549 }
 550
 551
 552 BT_EXPORT_API int bluetooth_dpm_clear_uuids_from_allowlist(void)
 553 {
 554         int result;
 555
 556         BT_CHECK_ENABLED_ANY(return);
 557
 558         BT_INIT_PARAMS();
 559         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 560
 561         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_CLEAR_UUIDS_ALLOWLIST,
 562                 in_param1, in_param2, in_param3, in_param4, &out_param);
 563
 564         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 565
 566         return result;
 567 }
 568
 569
 570 static void _bluetooth_extract_dpm_device_info(int count,
 571                                                         bt_dpm_device_list_t *dst_info,
 572                                                         bt_dpm_device_list_t *src_info)
 573 {
 574         int i;
 575
 576         for (i = 0; i < count; i++) {
 577                 memset(dst_info->addresses[i].addr, 0,
 578                         BLUETOOTH_ADDRESS_LENGTH);
 579
 580                 g_strlcpy((gchar *)dst_info->addresses[i].addr, (gchar *)src_info->addresses[i].addr,
 581                         BLUETOOTH_ADDRESS_LENGTH);
 582
 583 //              BT_DBG("address[%d] : %s", i, dst_info->addresses[i].addr);
 584         }
 585 }
 586
 587 static void _bluetooth_extract_dpm_uuid_info(int count,
 588                                                         bt_dpm_uuids_list_t *dst_info,
 589                                                         bt_dpm_uuids_list_t *src_info)
 590 {
 591         int i;
 592
 593         for (i = 0; i < count; i++) {
 594                 memset(dst_info->uuids[i], 0,
 595                         BLUETOOTH_UUID_STRING_MAX);
 596
 597                 g_strlcpy(dst_info->uuids[i], src_info->uuids[i],
 598                         BLUETOOTH_UUID_STRING_MAX);
 599
 600                 BT_DBG("uuids[%d] : %s", i, dst_info->uuids[i]);
 601         }
 602 }
 603
 604 BT_EXPORT_API int bluetooth_dpm_get_devices_from_blocklist(bt_dpm_device_list_t *device_list)
 605 {
 606         int result;
 607         bt_dpm_device_list_t *devices = NULL;
 608
 609         BT_CHECK_ENABLED_ANY(return);
 610
 611         BT_INIT_PARAMS();
 612         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 613
 614         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_GET_DEVICES_BLOCKLIST,
 615                 in_param1, in_param2, in_param3, in_param4, &out_param);
 616
 617         if (result == BLUETOOTH_ERROR_NONE) {
 618                 devices = &g_array_index(out_param, bt_dpm_device_list_t, 0);
 619                 BT_DBG("device_list->count : %d", devices->count);
 620
 621                 if (devices->count == 0) {
 622                         BT_ERR("device_list->count is zero !");
 623                         result = BLUETOOTH_ERROR_NOT_FOUND;
 624                 }
 625
 626                 device_list->count = devices->count;
 627
 628                 _bluetooth_extract_dpm_device_info(devices->count,
 629                                 device_list, devices);
 630         } else {
 631                 BT_ERR("Get Devices list Failed");
 632         }
 633
 634         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 635
 636         return result;
 637 }
 638
 639 BT_EXPORT_API int bluetooth_dpm_get_devices_from_allowlist(bt_dpm_device_list_t *device_list)
 640 {
 641         int result;
 642         bt_dpm_device_list_t *devices = NULL;
 643
 644         BT_CHECK_ENABLED_ANY(return);
 645
 646         BT_INIT_PARAMS();
 647         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 648
 649         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_GET_DEVICES_ALLOWLIST,
 650                 in_param1, in_param2, in_param3, in_param4, &out_param);
 651
 652         if (result == BLUETOOTH_ERROR_NONE) {
 653                 devices = &g_array_index(out_param, bt_dpm_device_list_t, 0);
 654                 BT_DBG("device_list->count : %d", devices->count);
 655
 656                 if (devices->count == 0) {
 657                         BT_ERR("device_list->count is zero !");
 658                         result = BLUETOOTH_ERROR_NOT_FOUND;
 659                 }
 660
 661                 device_list->count = devices->count;
 662
 663                 _bluetooth_extract_dpm_device_info(devices->count,
 664                                 device_list, devices);
 665
 666         } else {
 667                 BT_ERR("Get Devices list Failed");
 668         }
 669         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 670
 671         return result;
 672 }
 673
 674 BT_EXPORT_API int bluetooth_dpm_get_uuids_from_blocklist(bt_dpm_uuids_list_t *uuid_list)
 675 {
 676         int result;
 677         bt_dpm_uuids_list_t *uuids;
 678
 679         BT_CHECK_ENABLED_ANY(return);
 680
 681         BT_INIT_PARAMS();
 682         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 683
 684         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_GET_UUIDS_BLOCKLIST,
 685                 in_param1, in_param2, in_param3, in_param4, &out_param);
 686
 687         if (result == BLUETOOTH_ERROR_NONE) {
 688                 uuids = &g_array_index(out_param, bt_dpm_uuids_list_t, 0);
 689                 BT_DBG("uuids->count : %d", uuids->count);
 690
 691                 if (uuids->count == 0) {
 692                         BT_ERR("uuids->count is zero !");
 693                         result = BLUETOOTH_ERROR_NOT_FOUND;
 694                 }
 695
 696                 uuid_list->count = uuids->count;
 697                 _bluetooth_extract_dpm_uuid_info(uuids->count,
 698                                 uuid_list, uuids);
 699         } else {
 700                 BT_ERR("Get UUIDS list Failed");
 701         }
 702
 703         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 704
 705         return result;
 706 }
 707
 708 BT_EXPORT_API int bluetooth_dpm_get_uuids_from_allowlist(bt_dpm_uuids_list_t *uuid_list)
 709 {
 710         int result;
 711         bt_dpm_uuids_list_t *uuids;
 712
 713         BT_CHECK_ENABLED_ANY(return);
 714
 715         BT_INIT_PARAMS();
 716         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 717
 718         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_GET_UUIDS_ALLOWLIST,
 719                 in_param1, in_param2, in_param3, in_param4, &out_param);
 720
 721         if (result == BLUETOOTH_ERROR_NONE) {
 722                 uuids = &g_array_index(out_param, bt_dpm_uuids_list_t, 0);
 723                 BT_DBG("uuids->count : %d", uuids->count);
 724
 725                 if (uuids->count == 0) {
 726                         BT_ERR("uuids->count is zero !");
 727                         result = BLUETOOTH_ERROR_NOT_FOUND;
 728                 }
 729
 730                 uuid_list->count = uuids->count;
 731
 732                 _bluetooth_extract_dpm_uuid_info(uuids->count,
 733                                 uuid_list, uuids);
 734         } else {
 735                 BT_ERR("Get UUIDS list Failed");
 736         }
 737
 738         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 739
 740         return result;
 741 }
 742
 743 BT_EXPORT_API int bluetooth_dpm_remove_device_from_allowlist(const bluetooth_device_address_t *device_address)
 744 {
 745         int result;
 746
 747         BT_CHECK_PARAMETER(device_address, return);
 748         BT_CHECK_ENABLED_ANY(return);
 749
 750         BT_INIT_PARAMS();
 751         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 752
 753         g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
 754
 755         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_REMOVE_DEVICE_ALLOWLIST,
 756                 in_param1, in_param2, in_param3, in_param4, &out_param);
 757
 758         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 759
 760         return result;
 761 }
 762
 763 BT_EXPORT_API int bluetooth_dpm_remove_device_from_blocklist(const bluetooth_device_address_t *device_address)
 764 {
 765         int result;
 766
 767         BT_CHECK_PARAMETER(device_address, return);
 768         BT_CHECK_ENABLED_ANY(return);
 769
 770         BT_INIT_PARAMS();
 771         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 772
 773         g_array_append_vals(in_param1, device_address, sizeof(bluetooth_device_address_t));
 774
 775         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_REMOVE_DEVICE_BLOCKLIST,
 776                 in_param1, in_param2, in_param3, in_param4, &out_param);
 777
 778         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 779
 780         return result;
 781 }
 782
 783 BT_EXPORT_API int bluetooth_dpm_remove_uuid_from_allowlist(const char *service_uuid)
 784 {
 785         int result;
 786         char uuid[BLUETOOTH_UUID_STRING_MAX];
 787
 788         BT_CHECK_PARAMETER(service_uuid, return);
 789         BT_CHECK_ENABLED_ANY(return);
 790
 791         BT_INIT_PARAMS();
 792         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 793
 794         g_strlcpy(uuid, service_uuid, sizeof(uuid));
 795         g_array_append_vals(in_param1, uuid, BLUETOOTH_UUID_STRING_MAX);
 796
 797         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_REMOVE_UUID_ALLOWLIST,
 798                 in_param1, in_param2, in_param3, in_param4, &out_param);
 799
 800         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 801
 802         return result;
 803 }
 804
 805 BT_EXPORT_API int bluetooth_dpm_remove_uuid_from_blocklist(const char *service_uuid)
 806
 807 {
 808         int result;
 809         char uuid[BLUETOOTH_UUID_STRING_MAX];
 810
 811         BT_CHECK_PARAMETER(service_uuid, return);
 812         BT_CHECK_ENABLED_ANY(return);
 813
 814         BT_INIT_PARAMS();
 815         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 816
 817         g_strlcpy(uuid, service_uuid, sizeof(uuid));
 818         g_array_append_vals(in_param1, uuid, BLUETOOTH_UUID_STRING_MAX);
 819
 820         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_REMOVE_UUID_BLOCKLIST,
 821                 in_param1, in_param2, in_param3, in_param4, &out_param);
 822
 823         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 824
 825         return result;
 826
 827 }
 828
 829 BT_EXPORT_API int bluetooth_dpm_set_allow_outgoing_call(bt_dpm_status_t value)
 830 {
 831         int result;
 832
 833         BT_CHECK_ENABLED_ANY(return);
 834
 835         BT_INIT_PARAMS();
 836         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 837
 838         g_array_append_vals(in_param1, &value, sizeof(int));
 839
 840         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_SET_ALLOW_OUTGOING_CALL,
 841                 in_param1, in_param2, in_param3, in_param4, &out_param);
 842
 843         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 844
 845         return result;
 846 }
 847
 848 BT_EXPORT_API int bluetooth_dpm_get_allow_outgoing_call(bt_dpm_status_t *value)
 849 {
 850         int result;
 851
 852         BT_CHECK_ENABLED_ANY(return);
 853
 854         BT_INIT_PARAMS();
 855         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 856
 857         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_GET_ALLOW_OUTGOING_CALL,
 858                 in_param1, in_param2, in_param3, in_param4, &out_param);
 859
 860         if (result == BLUETOOTH_ERROR_NONE) {
 861                 if (out_param->len > 0) {
 862                         *value = g_array_index(out_param,
 863                                         int, 0);
 864                 } else {
 865                         BT_ERR("out_param length is 0!!");
 866                 }
 867         }
 868
 869         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 870
 871         return result;
 872 }
 873
 874 BT_EXPORT_API int bluetooth_dpm_set_pairing_state(bt_dpm_status_t value)
 875 {
 876         int result;
 877
 878         BT_CHECK_ENABLED_ANY(return);
 879
 880         BT_INIT_PARAMS();
 881         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 882
 883         g_array_append_vals(in_param1, &value, sizeof(int));
 884
 885         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_SET_PAIRING_STATE,
 886                 in_param1, in_param2, in_param3, in_param4, &out_param);
 887
 888         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 889
 890         return result;
 891 }
 892
 893 BT_EXPORT_API int bluetooth_dpm_get_pairing_state(bt_dpm_status_t *value)
 894 {
 895         int result;
 896
 897         BT_CHECK_ENABLED_ANY(return);
 898
 899         BT_INIT_PARAMS();
 900         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 901
 902         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_GET_ALLOW_BT_MODE,
 903                 in_param1, in_param2, in_param3, in_param4, &out_param);
 904
 905         if (result == BLUETOOTH_ERROR_NONE) {
 906                 if (out_param->len > 0) {
 907                         *value = g_array_index(out_param,
 908                                         int, 0);
 909                 } else {
 910                         BT_ERR("out_param length is 0!!");
 911                 }
 912         }
 913
 914         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 915
 916         return result;
 917 }
 918
 919 BT_EXPORT_API int bluetooth_dpm_set_profile_state(bt_dpm_profile_t profile, bt_dpm_status_t value)
 920 {
 921         int result;
 922
 923         BT_CHECK_ENABLED_ANY(return);
 924
 925         BT_INIT_PARAMS();
 926         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 927
 928         g_array_append_vals(in_param1, &profile, sizeof(int));
 929         g_array_append_vals(in_param2, &value, sizeof(int));
 930
 931         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_SET_PROFILE_STATE,
 932                 in_param1, in_param2, in_param3, in_param4, &out_param);
 933
 934         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 935
 936         return result;
 937 }
 938
 939 BT_EXPORT_API int bluetooth_dpm_get_profile_state(bt_dpm_profile_t profile, bt_dpm_status_t *value)
 940 {
 941         int result;
 942
 943         BT_CHECK_ENABLED_ANY(return);
 944
 945         BT_INIT_PARAMS();
 946         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 947
 948         g_array_append_vals(in_param1, &profile, sizeof(int));
 949
 950         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_GET_PROFILE_STATE,
 951                 in_param1, in_param2, in_param3, in_param4, &out_param);
 952
 953         if (result == BLUETOOTH_ERROR_NONE) {
 954                 if (out_param->len > 0) {
 955                         *value = g_array_index(out_param,
 956                                         int, 0);
 957                 } else {
 958                         BT_ERR("out_param length is 0!!");
 959                 }
 960         }
 961
 962         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 963
 964         return result;
 965 }
 966
 967 BT_EXPORT_API int bluetooth_dpm_set_desktop_connectivity_state(bt_dpm_status_t value)
 968 {
 969         int result;
 970
 971         BT_CHECK_ENABLED_ANY(return);
 972
 973         BT_INIT_PARAMS();
 974         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 975
 976         g_array_append_vals(in_param1, &value, sizeof(int));
 977
 978         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_SET_DESKROP_CONNECTIVITY_STATE,
 979                 in_param1, in_param2, in_param3, in_param4, &out_param);
 980
 981         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 982
 983         return result;
 984 }
 985
 986 BT_EXPORT_API int bluetooth_dpm_get_desktop_connectivity_state(bt_dpm_status_t *value)
 987 {
 988         int result;
 989
 990         BT_CHECK_ENABLED_ANY(return);
 991
 992         BT_INIT_PARAMS();
 993         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 994
 995         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_GET_DESKROP_CONNECTIVITY_STATE,
 996                 in_param1, in_param2, in_param3, in_param4, &out_param);
 997
 998         if (result == BLUETOOTH_ERROR_NONE) {
 999                 if (out_param->len > 0) {
1000                         *value = g_array_index(out_param,
1001                                         int, 0);
1002                 } else {
1003                         BT_ERR("out_param length is 0!!");
1004                 }
1005         }
1006
1007         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1008
1009         return result;
1010 }
1011
1012 BT_EXPORT_API int bluetooth_dpm_set_discoverable_state(bt_dpm_status_t value)
1013 {
1014         int result;
1015
1016         BT_CHECK_ENABLED_ANY(return);
1017
1018         BT_INIT_PARAMS();
1019         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1020
1021         g_array_append_vals(in_param1, &value, sizeof(int));
1022
1023         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_SET_DISCOVERABLE_STATE,
1024                 in_param1, in_param2, in_param3, in_param4, &out_param);
1025
1026         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1027
1028         return result;
1029 }
1030
1031 BT_EXPORT_API int bluetooth_dpm_get_discoverable_state(bt_dpm_status_t *value)
1032 {
1033         int result;
1034
1035         BT_CHECK_ENABLED_ANY(return);
1036
1037         BT_INIT_PARAMS();
1038         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1039
1040         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_GET_DISCOVERABLE_STATE,
1041                 in_param1, in_param2, in_param3, in_param4, &out_param);
1042
1043         if (result == BLUETOOTH_ERROR_NONE) {
1044                 if (out_param->len > 0) {
1045                         *value = g_array_index(out_param,
1046                                         int, 0);
1047                 } else {
1048                         BT_ERR("out_param length is 0!!");
1049                 }
1050         }
1051
1052         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1053
1054         return result;
1055 }
1056
1057 BT_EXPORT_API int bluetooth_dpm_set_limited_discoverable_state(bt_dpm_status_t value)
1058 {
1059         int result;
1060
1061         BT_CHECK_ENABLED_ANY(return);
1062
1063         BT_INIT_PARAMS();
1064         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1065
1066         g_array_append_vals(in_param1, &value, sizeof(int));
1067
1068         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_SET_LIMITED_DISCOVERABLE_STATE,
1069                 in_param1, in_param2, in_param3, in_param4, &out_param);
1070
1071         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1072
1073         return result;
1074 }
1075
1076 BT_EXPORT_API int bluetooth_dpm_get_limited_discoverable_state(bt_dpm_status_t *value)
1077 {
1078         int result;
1079
1080         BT_CHECK_ENABLED_ANY(return);
1081
1082         BT_INIT_PARAMS();
1083         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1084
1085         g_array_append_vals(in_param1, &value, sizeof(int));
1086
1087         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_GET_LIMITED_DISCOVERABLE_STATE,
1088                 in_param1, in_param2, in_param3, in_param4, &out_param);
1089
1090         if (result == BLUETOOTH_ERROR_NONE) {
1091                 if (out_param->len > 0) {
1092                         *value = g_array_index(out_param,
1093                                         int, 0);
1094                 } else {
1095                         BT_ERR("out_param length is 0!!");
1096                 }
1097         }
1098
1099         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1100
1101         return result;
1102 }
1103
1104 BT_EXPORT_API int bluetooth_dpm_set_data_transfer_state(bt_dpm_status_t value)
1105 {
1106         int result;
1107
1108         BT_CHECK_ENABLED_ANY(return);
1109
1110         BT_INIT_PARAMS();
1111         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1112
1113         g_array_append_vals(in_param1, &value, sizeof(int));
1114
1115         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_SET_DATA_TRANSFER_STATE,
1116                 in_param1, in_param2, in_param3, in_param4, &out_param);
1117
1118         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1119
1120         return result;
1121 }
1122
1123 BT_EXPORT_API int bluetooth_dpm_get_data_transfer_state(bt_dpm_status_t *value)
1124 {
1125         int result;
1126
1127         BT_CHECK_ENABLED_ANY(return);
1128
1129         BT_INIT_PARAMS();
1130         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1131
1132         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_DPM_GET_DATA_TRANSFER_STATE,
1133                 in_param1, in_param2, in_param3, in_param4, &out_param);
1134
1135         if (result == BLUETOOTH_ERROR_NONE) {
1136                 if (out_param->len > 0) {
1137                         *value = g_array_index(out_param,
1138                                         int, 0);
1139                 } else {
1140                         BT_ERR("out_param length is 0!!");
1141                 }
1142         }
1143
1144         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1145
1146         return result;
1147 }