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