bt-service/bt-service-mdm.c

   1 /*
   2  * Bluetooth-frwk
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact:  Hocheol Seo <hocheol.seo@samsung.com>
   7  *               Girishashok Joshi <girish.joshi@samsung.com>
   8  *               Chanyeol Park <chanyeol.park@samsung.com>
   9  *
  10  * Licensed under the Apache License, Version 2.0 (the "License");
  11  * you may not use this file except in compliance with the License.
  12  * You may obtain a copy of the License at
  13  *
  14  *              http://www.apache.org/licenses/LICENSE-2.0
  15  *
  16  * Unless required by applicable law or agreed to in writing, software
  17  * distributed under the License is distributed on an "AS IS" BASIS,
  18  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  19  * See the License for the specific language governing permissions and
  20  * limitations under the License.
  21  *
  22  */
  23
  24 #ifdef TIZEN_MDM_ENABLE
  25 #include <syspopup_caller.h>
  26
  27 #include "bt-internal-types.h"
  28 #include "bt-service-common.h"
  29 #include "bt-service-main.h"
  30 #include "bt-service-mdm.h"
  31 #include "bt-service-opp-client.h"
  32 #include "bt-service-obex-server.h"
  33 #include "bt-service-rfcomm-client.h"
  34 #include "bt-service-rfcomm-server.h"
  35 #include "bt-service-adapter.h"
  36 #include "bt-service-device.h"
  37 #include "bt-service-network.h"
  38 #include "bt-service-pbap.h"
  39
  40 policy_receiver_handle mdm_handle;
  41
  42 static int __bt_mdm_is_profile_connected(bluetooth_device_address_t *device_address,
  43                 char *profile_uuid, gboolean *is_connected)
  44 {
  45         char *object_path = NULL;
  46         char address[BT_ADDRESS_STRING_SIZE] = { 0 };
  47         DBusGProxy *device_proxy = NULL;
  48         DBusGProxy *adapter_proxy = NULL;
  49         DBusGConnection *conn;
  50         GError *error = NULL;
  51         GHashTable *hash = NULL;
  52         GValue *value = NULL;
  53         dbus_bool_t val = FALSE;
  54
  55         retv_if(device_address == NULL, BLUETOOTH_ERROR_INVALID_PARAM);
  56         retv_if(profile_uuid == NULL, BLUETOOTH_ERROR_INVALID_PARAM);
  57         retv_if(is_connected == NULL, BLUETOOTH_ERROR_INVALID_PARAM);
  58
  59         *is_connected = FALSE;
  60
  61         if (g_strcmp0(profile_uuid, RFCOMM_UUID_STR) == 0)
  62                 return _bt_rfcomm_is_device_connected(device_address,
  63                                                       is_connected);
  64         else if (g_strcmp0(profile_uuid, GATT_UUID) == 0)
  65                 return _bt_is_gatt_connected(device_address, is_connected);
  66
  67         adapter_proxy = _bt_get_adapter_proxy();
  68         retv_if(adapter_proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
  69
  70         conn = _bt_get_system_gconn();
  71         retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
  72
  73         _bt_convert_addr_type_to_string(address, device_address->addr);
  74
  75         if (g_strcmp0(profile_uuid, NAP_UUID) == 0) {
  76                 object_path = _bt_get_adapter_path();
  77                 device_proxy = dbus_g_proxy_new_for_name(conn, BT_BLUEZ_NAME,
  78                                 object_path, BT_NETWORK_SERVER_INTERFACE);
  79                 g_free(object_path);
  80                 if (device_proxy == NULL) {
  81                         BT_DBG("Device don't have this service");
  82                         return BLUETOOTH_ERROR_INTERNAL;
  83                 }
  84                 dbus_g_proxy_call(device_proxy, "GetProperties", NULL,
  85                                 G_TYPE_STRING, address,
  86                                 G_TYPE_INVALID,
  87                                 dbus_g_type_get_map("GHashTable",
  88                                         G_TYPE_STRING, G_TYPE_VALUE),
  89                                 &hash, G_TYPE_INVALID);
  90                 if (hash != NULL) {
  91                         value = g_hash_table_lookup(hash, "Connected");
  92                         *is_connected = value ? g_value_get_boolean(value) : FALSE;
  93                         g_hash_table_destroy(hash);
  94                 }
  95         } else if (g_strcmp0(profile_uuid, PANU_UUID) == 0)
  96                 return _bt_is_network_connected(_bt_get_net_conn(),
  97                                 device_address->addr, is_connected);
  98         else {
  99                 object_path = _bt_get_device_object_path(address);
 100                 retv_if(object_path == NULL, BLUETOOTH_ERROR_NOT_PAIRED);
 101
 102                 device_proxy = dbus_g_proxy_new_for_name(conn, BT_BLUEZ_NAME,
 103                                 object_path, BT_DEVICE_INTERFACE);
 104                 g_free(object_path);
 105                 if (device_proxy == NULL) {
 106                         BT_DBG("Device don't have this service");
 107                         return BLUETOOTH_ERROR_INTERNAL;
 108                 }
 109                 dbus_g_proxy_call(device_proxy, "IsConnectedProfile", &error,
 110                                 G_TYPE_STRING, profile_uuid,
 111                                 G_TYPE_INVALID,
 112                                 G_TYPE_BOOLEAN, &val,
 113                                 G_TYPE_INVALID);
 114                 if (error != NULL) {
 115                         BT_ERR("Failed to get properties: %s\n", error->message);
 116                         g_error_free(error);
 117                 }
 118
 119                 *is_connected = val;
 120         }
 121
 122         if (device_proxy)
 123                 g_object_unref(device_proxy);
 124
 125         return BLUETOOTH_ERROR_NONE;
 126 }
 127
 128 static int __bt_mdm_get_connected_profile_address(char *address, char *UUID)
 129 {
 130         int err;
 131         int ret = FALSE;
 132         int i;
 133         gboolean is_connected = FALSE;
 134         GArray *device_list = NULL;
 135         bluetooth_device_info_t info;
 136         guint size;
 137
 138         device_list = g_array_new(FALSE, FALSE, sizeof(gchar));
 139
 140         if (_bt_get_bonded_devices(&device_list)
 141                                         != BLUETOOTH_ERROR_NONE) {
 142                 g_array_free(device_list, TRUE);
 143                 return ret;
 144         }
 145
 146         size = (device_list->len) / sizeof(bluetooth_device_info_t);
 147         BT_DBG("g arrary size : [%d]", size);
 148
 149         for (i = 0; i < size; i++) {
 150
 151                 info = g_array_index(device_list,
 152                                 bluetooth_device_info_t, i);
 153
 154                 if (info.connected == TRUE) {
 155                         BT_DBG("Found Connected device[%s]", info.device_name.name);
 156                         err = __bt_mdm_is_profile_connected(&info.device_address,
 157                                 UUID, &is_connected);
 158
 159                         if (err == BLUETOOTH_ERROR_NONE) {
 160                                 if (is_connected) {
 161                                         BT_DBG("connected device name : %s", info.device_name.name);
 162                                         _bt_convert_addr_type_to_string(address, (unsigned char *)info.device_address.addr);
 163                                         ret = TRUE;
 164                                         break;
 165                                 }
 166                         }
 167
 168                 }
 169         }
 170         g_array_free(device_list, TRUE);
 171
 172         return ret;
 173 }
 174
 175 static void __bt_mdm_mode_changed(int mode)
 176 {
 177         int visible = BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE;
 178
 179         BT_DBG("allow mode: %d", mode);
 180
 181         switch (mode) {
 182         case MDM_BT_ALLOWED:
 183                 BT_DBG("MDM_BT_ALLOWED");
 184                 /* Nothing to do */
 185                 break;
 186         case MDM_BT_HANDSFREE_ONLY:
 187                 BT_DBG("MDM_BT_HANDSFREE_ONLY");
 188
 189                 _bt_get_discoverable_mode(&visible);
 190                 ret_if(visible == BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE);
 191
 192                 _bt_set_discoverable_mode(BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE, 0);
 193
 194                 _bt_opp_client_cancel_all_transfers();
 195
 196                 _bt_obex_server_cancel_all_transfers();
 197
 198                 _bt_rfcomm_client_disconnect_all();
 199
 200                 _bt_rfcomm_server_disconnect_all_connection();
 201
 202                 _bt_launch_mdm_popup("MDM_POLICY_DISABLE_BT_HANDSFREE");
 203
 204                 break;
 205         case MDM_BT_RESTRICTED:
 206                 BT_DBG("MDM_BT_RESTRICTED");
 207
 208                 _bt_launch_mdm_popup("MDM_POLICY_DISABLE_BT");
 209
 210                 /* deactivate BT */
 211                 _bt_disable_adapter();
 212                 break;
 213         default:
 214                 BT_DBG("Unknown mode");
 215                 break;
 216         }
 217
 218         BT_DBG("-");
 219 }
 220
 221 static void __bt_mdm_discoverable_state_changed(int state)
 222 {
 223         int visible = BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE;
 224
 225         BT_DBG("state: %d", state);
 226
 227         switch (state) {
 228         case MDM_ALLOWED:
 229                 BT_DBG("MDM_ALLOWED");
 230                 /* Nothing to do */
 231                 break;
 232         case MDM_RESTRICTED:
 233                 BT_DBG("MDM_RESTRICTED");
 234
 235                 _bt_get_discoverable_mode(&visible);
 236                 ret_if(visible == BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE);
 237
 238                 _bt_set_discoverable_mode(BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE, 0);
 239                 break;
 240         default:
 241                 BT_DBG("Unknown mode");
 242                 break;
 243         }
 244 }
 245
 246 static void __bt_mdm_limited_discoverable_state_changed(int state)
 247 {
 248         int visible = BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE;
 249         int timeout = 0;
 250
 251         BT_DBG("state: %d", state);
 252
 253         switch (state) {
 254         case MDM_ALLOWED:
 255                 BT_DBG("MDM_ALLOWED");
 256                 if (vconf_get_int(BT_FILE_VISIBLE_TIME, &timeout) != 0)
 257                         BT_ERR("Fail to get the timeout value");
 258                 else {
 259                         if (timeout != -1) {
 260                                 BT_DBG("_bt_set_discoverable_mode");
 261                                 if (_bt_set_discoverable_mode(
 262                                         BLUETOOTH_DISCOVERABLE_MODE_TIME_LIMITED_DISCOVERABLE,
 263                                         timeout) != BLUETOOTH_ERROR_NONE) {
 264                                         if (vconf_set_int(BT_FILE_VISIBLE_TIME, 0) != 0)
 265                                                 BT_ERR("Set vconf failed");
 266                                 }
 267                         }
 268                 }
 269
 270                 break;
 271         case MDM_RESTRICTED:
 272                 BT_DBG("MDM_RESTRICTED");
 273
 274                 _bt_get_discoverable_mode(&visible);
 275                 ret_if(visible == BLUETOOTH_DISCOVERABLE_MODE_GENERAL_DISCOVERABLE);
 276
 277                 _bt_set_discoverable_mode(BLUETOOTH_DISCOVERABLE_MODE_GENERAL_DISCOVERABLE,
 278                                 0);
 279                 break;
 280         default:
 281                 BT_DBG("Unknown mode");
 282                 break;
 283         }
 284 }
 285
 286 static int __bt_mdm_idle_cb(void *data)
 287 {
 288         int *status = data;
 289         int mode;
 290         char address[BT_ADDRESS_STRING_SIZE] = { 0 };
 291
 292         retv_if(status == NULL, FALSE);
 293
 294         BT_DBG("policy: %d", *status);
 295
 296         if (mdm_get_service() != MDM_RESULT_SUCCESS) return BT_MDM_NO_SERVICE;
 297
 298         switch (*status) {
 299         case MDM_BT_MODE_CHANGED:
 300                 mode = mdm_get_allow_bluetooth_mode();
 301                 __bt_mdm_mode_changed(mode);
 302                 break;
 303         case MDM_BT_OUTGOING_CALL_CHANGED:
 304                 BT_DBG("MDM_BT_OUTGOING_CALL_CHANGED");
 305                 break;
 306         case MDM_BT_A2DP_PROFILE_CHANGED:
 307                 BT_DBG("MDM_BT_A2DP_PROFILE_CHANGED");
 308 #ifdef MDM_PHASE_2
 309                 if (mdm_get_bluetooth_profile_state(BLUETOOTH_A2DP_PROFILE)
 310                         == MDM_RESTRICTED) {
 311                         if (__bt_mdm_get_connected_profile_address(address,
 312                                                         A2DP_SINK_UUID))
 313                                 _bt_disconnect_profile(address, A2DP_SINK_UUID,
 314                                                                 NULL, NULL);
 315                 }
 316 #endif
 317                 break;
 318         case MDM_BT_AVRCP_PROFILE_CHANGED:
 319                 BT_DBG("MDM_BT_AVRCP_PROFILE_CHANGED");
 320 #ifdef MDM_PHASE_2
 321                 if (mdm_get_bluetooth_profile_state(BLUETOOTH_AVRCP_PROFILE)
 322                         == MDM_RESTRICTED) {
 323                         if (__bt_mdm_get_connected_profile_address(address,
 324                                                         AVRCP_REMOTE_UUID))
 325                                 _bt_disconnect_profile(address, AVRCP_REMOTE_UUID,
 326                                                                 NULL, NULL);
 327                 }
 328 #endif
 329                 break;
 330         case MDM_BT_BPP_PROFILE_CHANGED:
 331                 BT_DBG("MDM_BT_BPP_PROFILE_CHANGED");
 332                 break;
 333         case MDM_BT_DUN_PROFILE_CHANGED:
 334                 BT_DBG("MDM_BT_DUN_PROFILE_CHANGED");
 335                 break;
 336         case MDM_BT_FTP_PROFILE_CHANGED:
 337                 BT_DBG("MDM_BT_FTP_PROFILE_CHANGED");
 338                 break;
 339         case MDM_BT_HFP_PROFILE_CHANGED:
 340                 BT_DBG("MDM_BT_HFP_PROFILE_CHANGED");
 341 #ifdef MDM_PHASE_2
 342                 if (mdm_get_bluetooth_profile_state(BLUETOOTH_HFP_PROFILE)
 343                         == MDM_RESTRICTED) {
 344                         if (__bt_mdm_get_connected_profile_address(address,
 345                                                         HFP_HS_UUID))
 346                                 _bt_disconnect_profile(address, HFP_HS_UUID,
 347                                                                 NULL, NULL);
 348                 }
 349 #endif
 350                 break;
 351         case MDM_BT_HSP_PROFILE_CHANGED:
 352                 BT_DBG("MDM_BT_HSP_PROFILE_CHANGED");
 353 #ifdef MDM_PHASE_2
 354                 if (mdm_get_bluetooth_profile_state(BLUETOOTH_HSP_PROFILE)
 355                         == MDM_RESTRICTED) {
 356                         if (__bt_mdm_get_connected_profile_address(address,
 357                                                         HSP_HS_UUID))
 358                                 _bt_disconnect_profile(address, HSP_HS_UUID,
 359                                                                 NULL, NULL);
 360                 }
 361 #endif
 362                 break;
 363         case MDM_BT_PBAP_PROFILE_CHANGED:
 364                 BT_DBG("MDM_BT_PBAP_PROFILE_CHANGED");
 365 #ifdef MDM_PHASE_2
 366                 if (mdm_get_bluetooth_profile_state(BLUETOOTH_PBAP_PROFILE)
 367                         == MDM_RESTRICTED) {
 368                         if (__bt_mdm_get_connected_profile_address(address,
 369                                                 OBEX_PSE_UUID)) {
 370                                 bluetooth_device_address_t addr;
 371                                 _bt_convert_addr_string_to_type(addr.addr,
 372                                                 address);
 373                                 _bt_pbap_disconnect(&addr);
 374                         }
 375                 }
 376 #endif
 377                 break;
 378         case MDM_BT_SAP_PROFILE_CHANGED:
 379                 BT_DBG("MDM_BT_SAP_PROFILE_CHANGED");
 380                 break;
 381         case MDM_BT_SPP_PROFILE_CHANGED:
 382                 BT_DBG("MDM_BT_SPP_PROFILE_CHANGED");
 383                 break;
 384         case MDM_BT_DESKTOP_CONNECTIVITY_STATE_CHANGED:
 385                 BT_DBG("MDM_BT_DESKTOP_CONNECTIVITY_STATE_CHANGED");
 386                 break;
 387         case MDM_BT_DISCOVERABLE_STATE_CHANGED:
 388                 BT_DBG("MDM_BT_DISCOVERABLE_STATE_CHANGED");
 389 #ifdef MDM_PHASE_2
 390                 mode = mdm_get_bluetooth_discoverable_state();
 391                 __bt_mdm_discoverable_state_changed(mode);
 392 #endif
 393                 break;
 394         case MDM_BT_PARINIG_STATE_CHANGED:
 395                 BT_DBG("MDM_BT_PARINIG_STATE_CHANGED");
 396                 break;
 397         case MDM_BT_LIMITED_DISCOVERABLE_STATE_CHANGED:
 398                 BT_DBG("MDM_BT_LIMITED_DISCOVERABLE_STATE_CHANGED");
 399 #ifdef MDM_PHASE_2
 400                 mode = mdm_get_bluetooth_limited_discoverable_state();
 401                 __bt_mdm_limited_discoverable_state_changed(mode);
 402 #endif
 403                 break;
 404         case MDM_BT_DATA_TRANSFER_CHANGED:
 405                 BT_DBG("MDM_BT_DATA_TRANSFER_CHANGED");
 406 #ifdef MDM_PHASE_2
 407                 mode = mdm_get_bluetooth_data_transfer_state();
 408                 if (mode == MDM_RESTRICTED) {
 409                         _bt_opp_client_cancel_all_transfers();
 410                         _bt_obex_server_cancel_all_transfers();
 411                 }
 412 #endif
 413                 break;
 414         default:
 415                 BT_DBG("Unknown mode");
 416                 break;
 417         }
 418
 419         g_free(status);
 420
 421         mdm_release_service();
 422
 423         BT_DBG("-");
 424         return FALSE;
 425 }
 426
 427 static void __bt_mdm_policy_changed_cb(int status, void *data)
 428 {
 429         int *mdm_status;
 430
 431         BT_DBG("policy: %d", status);
 432
 433         mdm_status = g_malloc0(sizeof(int));
 434
 435         *mdm_status = status;
 436
 437         g_idle_add((GSourceFunc)__bt_mdm_idle_cb, mdm_status);
 438 }
 439
 440 void _bt_init_mdm_handle(void)
 441 {
 442         mdm_handle = mdm_register_policy_receiver(MDM_POLICY_ON_BT,
 443                                                 NULL,
 444                                                 __bt_mdm_policy_changed_cb);
 445         if (mdm_handle == (policy_receiver_handle)NULL)
 446                 BT_ERR("MDM register failed\n");
 447 }
 448
 449 void _bt_deinit_mdm_handle(void)
 450 {
 451         if(mdm_handle != (policy_receiver_handle)NULL) {
 452                 mdm_deregister_policy_receiver(mdm_handle);
 453                 mdm_handle = (policy_receiver_handle)NULL;
 454         }
 455
 456         mdm_release_service();
 457 }
 458
 459 int _bt_launch_mdm_popup(char *mode)
 460 {
 461         int ret = 0;
 462         bundle *b;
 463
 464         b = bundle_create();
 465         retv_if(b == NULL, BLUETOOTH_ERROR_INTERNAL);
 466
 467         bundle_add(b, "mode", mode);
 468
 469         ret = syspopup_launch(BT_MDM_SYSPOPUP, b);
 470
 471         if (ret < 0)
 472                 BT_DBG("Popup launch failed: %d\n", ret);
 473
 474         bundle_free(b);
 475
 476         return ret;
 477 }
 478
 479 bt_mdm_status_e _bt_check_mdm_allow_restriction(void)
 480 {
 481         mdm_bt_allow_t mode;
 482
 483         if (mdm_get_service() != MDM_RESULT_SUCCESS) return BT_MDM_NO_SERVICE;
 484
 485         mode = mdm_get_allow_bluetooth_mode();
 486         mdm_release_service();
 487
 488         return (mode == MDM_BT_RESTRICTED) ? BT_MDM_RESTRICTED : BT_MDM_ALLOWED;
 489 }
 490
 491 #ifdef MDM_PHASE_2
 492 bt_mdm_status_e _bt_check_mdm_desktop_connectivity_restriction(void)
 493 {
 494        bt_mdm_status_e mdm_status = BT_MDM_ALLOWED;
 495
 496        if (mdm_get_service() != MDM_RESULT_SUCCESS)
 497                return BT_MDM_NO_SERVICE;
 498
 499        if (mdm_get_bluetooth_desktop_connectivity_state() == MDM_RESTRICTED) {
 500                /* Not allow to visible on */
 501                BT_ERR("Desktop connection is restricted");
 502                mdm_status = BT_MDM_RESTRICTED;
 503        }
 504        mdm_release_service();
 505
 506        return mdm_status;
 507 }
 508
 509 bt_mdm_status_e _bt_check_mdm_visible_restriction(void)
 510 {
 511         bt_mdm_status_e mdm_status = BT_MDM_ALLOWED;
 512
 513         if (mdm_get_service() != MDM_RESULT_SUCCESS) return BT_MDM_NO_SERVICE;
 514
 515         if (mdm_get_bluetooth_discoverable_state() == MDM_RESTRICTED ||
 516              mdm_get_allow_bluetooth_mode() == MDM_BT_HANDSFREE_ONLY) {
 517                 /* Not allow to visible on */
 518                 BT_ERR("Restricted to set visible mode");
 519                 mdm_status = BT_MDM_RESTRICTED;
 520         }
 521         mdm_release_service();
 522
 523         return mdm_status;
 524 }
 525
 526 bt_mdm_status_e _bt_check_mdm_limited_discoverable_mode(void)
 527 {
 528         bt_mdm_status_e mdm_status = BT_MDM_ALLOWED;
 529
 530         if (mdm_get_service() != MDM_RESULT_SUCCESS) return BT_MDM_NO_SERVICE;
 531
 532         if (mdm_get_bluetooth_limited_discoverable_state() == MDM_RESTRICTED) {
 533                 BT_ERR("limited discoverable mode");
 534                 mdm_status = BT_MDM_RESTRICTED;
 535         }
 536         mdm_release_service();
 537
 538         return mdm_status;
 539 }
 540
 541 bt_mdm_status_e _bt_check_mdm_blacklist_devices(bluetooth_device_address_t *address)
 542 {
 543         mdm_data_t *lp_data;
 544         GList *blacklist;
 545         char *device_name;
 546         bluetooth_device_info_t dev_info;
 547         bt_mdm_status_e mdm_status = BT_MDM_ALLOWED;
 548
 549         if (mdm_get_service() != MDM_RESULT_SUCCESS) return BT_MDM_NO_SERVICE;
 550
 551         memset(&dev_info, 0x00, sizeof(bluetooth_device_info_t));
 552
 553         if (_bt_get_bonded_device_info(address,
 554                                 &dev_info) != BLUETOOTH_ERROR_NONE) {
 555                 BT_ERR("Not paired device");
 556                 goto release;
 557         }
 558
 559         lp_data = mdm_get_bluetooth_devices_from_blacklist();
 560         if (lp_data == NULL) {
 561                 BT_ERR("No blacklist");
 562                 goto release;
 563         }
 564
 565         for (blacklist = (GList *)lp_data->data; blacklist; blacklist = blacklist->next) {
 566                 device_name = blacklist->data;
 567
 568                 DBG_SECURE("blacklist name: %s", device_name);
 569
 570                 if (g_strcmp0(dev_info.device_name.name,
 571                                         device_name) == 0) {
 572                         mdm_status = BT_MDM_RESTRICTED;
 573                         break;
 574                 }
 575         }
 576
 577         mdm_free_data(lp_data);
 578 release :
 579         mdm_release_service();
 580         return mdm_status;
 581 }
 582
 583 mdm_bt_profile_t convert_uuid_string_to_type(const char* uuid)
 584 {
 585         retv_if (uuid == NULL, MDM_BT_PROFILE_NONE);
 586
 587         if (!strcasecmp(uuid, BT_A2DP_UUID))
 588                 return BLUETOOTH_A2DP_PROFILE;
 589         else if (!strcasecmp(uuid, BT_AVRCP_TARGET_UUID))
 590                 return BLUETOOTH_AVRCP_PROFILE;
 591         else if (!strcasecmp(uuid, BT_FTP_UUID))
 592                 return BLUETOOTH_FTP_PROFILE;
 593         else if (!strcasecmp(uuid, BT_HFP_AUDIO_GATEWAY_UUID))
 594                 return BLUETOOTH_HFP_PROFILE;
 595         else if (!strcasecmp(uuid, HSP_AG_UUID))
 596                 return BLUETOOTH_HSP_PROFILE;
 597         else if (!strcasecmp(uuid, OBEX_PSE_UUID))
 598                 return BLUETOOTH_PBAP_PROFILE;
 599         else if (!strcasecmp(uuid, BT_SPP_UUID))
 600                 return BLUETOOTH_SPP_PROFILE;
 601
 602         return MDM_BT_PROFILE_NONE;
 603 }
 604
 605 bt_mdm_status_e _bt_check_mdm_blacklist_uuid(char *uuid)
 606 {
 607         mdm_data_t *lp_data;
 608         GList *blacklist;
 609         char *blacklist_uuid;
 610         bt_mdm_status_e mdm_status = BT_MDM_ALLOWED;
 611
 612         retv_if (uuid == NULL, mdm_status);
 613
 614         if (mdm_get_service() != MDM_RESULT_SUCCESS) return BT_MDM_NO_SERVICE;
 615
 616         lp_data = mdm_get_bluetooth_uuids_from_blacklist();
 617         if (lp_data == NULL) {
 618                 BT_ERR("No blacklist");
 619                 goto release;
 620         }
 621
 622         for (blacklist = (GList *)lp_data->data; blacklist; blacklist = blacklist->next) {
 623                 blacklist_uuid = blacklist->data;
 624
 625                 BT_DBG("blacklist_uuid: %s", blacklist_uuid);
 626
 627                 if (g_strcmp0(blacklist_uuid, uuid) == 0) {
 628                         mdm_status = BT_MDM_RESTRICTED;
 629                         break;
 630                 }
 631         }
 632
 633         if (mdm_status == BT_MDM_ALLOWED) {
 634                 mdm_bt_profile_t profile;
 635                 profile = convert_uuid_string_to_type(uuid);
 636                 if (mdm_get_bluetooth_profile_state(profile) == MDM_RESTRICTED) {
 637                         BT_ERR("Restricted UUID");
 638                         mdm_status = BT_MDM_RESTRICTED;
 639                 }
 640         }
 641
 642         mdm_free_data(lp_data);
 643
 644 release :
 645         mdm_release_service();
 646         return mdm_status;
 647 }
 648 #endif
 649 #endif
 650