bt-service/bt-request-handler.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 <string.h>
  19 #include <glib.h>
  20 #include <dlog.h>
  21 #include <gio/gio.h>
  22 #include <cynara-client.h>
  23 #include <cynara-creds-gdbus.h>
  24
  25 #include "bluetooth-api.h"
  26 #include "bt-service-common.h"
  27 #include "bt-service-util.h"
  28 #include "bt-service-event.h"
  29 #include "bt-service-adapter.h"
  30 #include "bt-service-adapter-le.h"
  31 #include "bt-service-device.h"
  32 #include "bt-service-hid.h"
  33 #include "bt-service-network.h"
  34 #include "bt-service-audio.h"
  35 #include "bt-service-oob.h"
  36 #include "bt-service-avrcp.h"
  37 #include "bt-service-avrcp-controller.h"
  38 #include "bt-service-opp-client.h"
  39 #include "bt-service-map-client.h"
  40 #include "bt-service-obex-server.h"
  41 #include "bt-service-rfcomm-client.h"
  42 #include "bt-service-rfcomm-server.h"
  43 #include "bt-request-handler.h"
  44 #include "bt-service-pbap.h"
  45 #include "bt-service-dpm.h"
  46 #include "bt-service-agent.h"
  47 #include "bt-service-proximity.h"
  48 #include "bt-service-tds.h"
  49
  50 static GDBusConnection *bt_service_conn;
  51 static guint owner_id = 0;
  52 cynara *p_cynara;
  53 cynara_configuration *conf;
  54
  55 static const gchar bt_service_introspection_xml[] =
  56 "<node name='/org/projectx/bt_service'>"
  57 "       <interface name='org.projectx.bt'>"
  58 "               <method name='service_request'>"
  59                         /* Input Parameters */
  60 "                       <arg type='i' name='service_type' direction='in' />"
  61 "                       <arg type='i' name='service_function' direction='in' />"
  62 "                       <arg type='i' name='request_type' direction='in' />"
  63 "                       <arg type='ay' name='input_param1' direction='in' />"
  64 "                       <arg type='ay' name='input_param2' direction='in' />"
  65 "                       <arg type='ay' name='input_param3' direction='in' />"
  66 "                       <arg type='ay' name='input_param4' direction='in' />"
  67 "                       <arg type='ay' name='input_param5' direction='in' />"
  68                         /* Return Parameters */
  69 "                       <arg type='i' name='output_param1' direction='out' />"
  70 "                       <arg type='v' name='output_param2' direction='out' />"
  71 "               </method>"
  72 "       </interface>"
  73 "</node>";
  74
  75 GDBusNodeInfo *node_info = NULL;
  76
  77 static char *current_sender_playing = NULL;
  78
  79 static void __bt_service_method(GDBusConnection *connection,
  80                 const gchar *sender,
  81                 const gchar *object_path,
  82                 const gchar *interface_name,
  83                 const gchar *method_name,
  84                 GVariant *parameters,
  85                 GDBusMethodInvocation *invocation,
  86                 gpointer user_data);
  87
  88 int __bt_bluez_request(int function_name,
  89                 int request_type,
  90                 int request_id,
  91                 GDBusMethodInvocation *context,
  92                 GVariant *in_param1,
  93                 GVariant *in_param2,
  94                 GVariant *in_param3,
  95                 GVariant *in_param4,
  96                 GArray **out_param1);
  97 int __bt_obexd_request(int function_name,
  98                 int request_type,
  99                 int request_id,
 100                 GDBusMethodInvocation *context,
 101                 GVariant *in_param1,
 102                 GVariant *in_param2,
 103                 GVariant *in_param3,
 104                 GVariant *in_param4,
 105                 GArray **out_param1);
 106 int __bt_agent_request(int function_name,
 107                 int request_type,
 108                 int request_id,
 109                 GDBusMethodInvocation *context,
 110                 GVariant *in_param1,
 111                 GVariant *in_param2,
 112                 GVariant *in_param3,
 113                 GVariant *in_param4,
 114                 GArray **out_param1);
 115 int __bt_core_request(int function_name,
 116                 int request_type,
 117                 int request_id,
 118                 GDBusMethodInvocation *context,
 119                 GVariant *in_param1);
 120
 121 gboolean __bt_service_check_privilege(int function_name,
 122                                         int service_type,
 123                                         const char *unique_name);
 124
 125 /* Function definitions*/
 126 static void __bt_fill_garray_from_variant(GVariant *var, GArray *param)
 127 {
 128         char *data;
 129         int size;
 130
 131         size = g_variant_get_size(var);
 132         if (size > 0) {
 133                 data = (char *)g_variant_get_data(var);
 134                 if (data)
 135                         param = g_array_append_vals(param, data, size);
 136
 137         }
 138 }
 139
 140 static void __bt_service_get_parameters(GVariant *in_param,
 141                 void *value, int size)
 142 {
 143         void *buf = NULL;
 144         buf = (void *)g_variant_get_data(in_param);
 145         memcpy(value, buf, size);
 146 }
 147
 148 static void __bt_service_method(GDBusConnection *connection,
 149                 const gchar *sender,
 150                 const gchar *object_path,
 151                 const gchar *interface_name,
 152                 const gchar *method_name,
 153                 GVariant *parameters,
 154                 GDBusMethodInvocation *invocation,
 155                 gpointer user_data)
 156 {
 157         FN_START;
 158
 159         BT_DBG("Method[%s] Object Path[%s] Interface Name[%s]",
 160                         method_name, object_path, interface_name);
 161
 162         if (g_strcmp0(method_name, "service_request") == 0) {
 163                 int service_type;
 164                 int service_function;
 165                 int request_type;
 166                 GVariant *param1 = NULL;
 167                 GVariant *param2 = NULL;
 168                 GVariant *param3 = NULL;
 169                 GVariant *param4 = NULL;
 170                 GVariant *param5 = NULL;
 171                 GArray *out_param1 = NULL;
 172                 GVariant *out_var = NULL;
 173                 int result = 0;
 174                 int request_id = -1;
 175                 const char *sender = NULL;
 176
 177                 g_variant_get(parameters, "(iii@ay@ay@ay@ay@ay)", &service_type,
 178                                 &service_function, &request_type,
 179                                 &param1, &param2, &param3, &param4, &param5);
 180
 181                 out_param1 = g_array_new(FALSE, FALSE, sizeof(gchar));
 182
 183                 sender = g_dbus_method_invocation_get_sender(invocation);
 184
 185                 if (service_type == BT_CORE_SERVICE) {
 186                         BT_DBG("No need to check privilege from bt-core");
 187                 } else if (__bt_service_check_privilege(service_function,
 188                                         service_type, (const char *)sender) == FALSE) {
 189                         BT_ERR("Client don't have the privilege to excute this function");
 190                         result = BLUETOOTH_ERROR_PERMISSION_DEINED;
 191                         goto fail;
 192                 }
 193
 194                 if (request_type == BT_ASYNC_REQ
 195                                 || service_function == BT_OBEX_SERVER_ACCEPT_CONNECTION) {
 196                         /* Set the timer */
 197                         request_id = _bt_assign_request_id();
 198                         BT_DBG("Request ID: %d", request_id);
 199
 200                         if (request_id < 0) {
 201                                 BT_ERR("Fail to assign the request id");
 202                                 result = BLUETOOTH_ERROR_INTERNAL;
 203
 204                                 goto fail;
 205                         }
 206                 }
 207
 208                 BT_DBG("Service type = %d, fn = %s (0x%x)",
 209                                 service_type, _bt_convert_service_function_to_string(service_function),
 210                                 service_function);
 211                 switch (service_type) {
 212                 case BT_BLUEZ_SERVICE:
 213                         result = __bt_bluez_request(service_function,
 214                                         request_type, request_id,
 215                                         invocation, param1, param2,
 216                                         param3, param4, &out_param1);
 217                         break;
 218                 case BT_OBEX_SERVICE:
 219                         result = __bt_obexd_request(service_function,
 220                                         request_type, request_id,
 221                                         invocation, param1,
 222                                         param2, param3,
 223                                         param4, &out_param1);
 224                         break;
 225                 case BT_AGENT_SERVICE:
 226                         result = __bt_agent_request(service_function,
 227                                         request_type, request_id,
 228                                         invocation, param1,
 229                                         param2, param3,
 230                                         param4, &out_param1);
 231                         break;
 232                 case BT_CORE_SERVICE:
 233                         result = __bt_core_request(service_function,
 234                                         request_type, request_id,
 235                                         invocation, param1);
 236                         break;
 237                 case BT_CHECK_PRIVILEGE:
 238                         result = BLUETOOTH_ERROR_NONE;
 239                         break;
 240                 default:
 241                         BT_ERR("Unknown service type");
 242                         result = BLUETOOTH_ERROR_INTERNAL;
 243                         goto fail;
 244                 }
 245
 246                 if (result != BLUETOOTH_ERROR_NONE)
 247                         goto fail;
 248
 249                 if ((request_type == BT_ASYNC_REQ ||
 250                         service_function == BT_OBEX_SERVER_ACCEPT_CONNECTION) &&
 251                         service_function != BT_OPP_PUSH_FILES) {
 252                         BT_DBG("INSERT INTO REQ LIST");
 253                         _bt_insert_request_list(request_id, service_function,
 254                                                 NULL, invocation);
 255                 } else {
 256                         /* Return result */
 257                         if (service_type == BT_CHECK_PRIVILEGE ||
 258                                         service_function != BT_OPP_PUSH_FILES) {
 259                                 out_var = g_variant_new_from_data((const GVariantType *)"ay",
 260                                                 out_param1->data, out_param1->len,
 261                                                 TRUE, NULL, NULL);
 262
 263                                 GVariant *temp = g_variant_new("(iv)", result, out_var);
 264                                 g_dbus_method_invocation_return_value(invocation, temp);
 265
 266                                 g_array_free(out_param1, TRUE);
 267                                 out_param1 = NULL;
 268                         }
 269                 }
 270                 /* TODO: MAP? see the if{}else{} above */
 271
 272                 g_variant_unref(param1);
 273                 g_variant_unref(param2);
 274                 g_variant_unref(param3);
 275                 g_variant_unref(param4);
 276                 g_variant_unref(param5);
 277 //              g_free(sender);
 278                 FN_END;
 279                 return;
 280 fail:
 281                 BT_ERR_C("Request is failed [%s] [0x%x]",
 282                                 _bt_convert_error_to_string(result), result);
 283
 284                 out_var = g_variant_new_from_data((const GVariantType *)"ay",
 285                                 out_param1->data, out_param1->len,
 286                                 TRUE, NULL, NULL);
 287
 288                 GVariant *temp = g_variant_new("(iv)", result, out_var);
 289                 g_dbus_method_invocation_return_value(invocation, temp);
 290
 291                 g_array_free(out_param1, TRUE);
 292                 out_param1 = NULL;
 293
 294                 if (request_type == BT_ASYNC_REQ)
 295                         _bt_delete_request_id(request_id);
 296
 297                 g_variant_unref(param1);
 298                 g_variant_unref(param2);
 299                 g_variant_unref(param3);
 300                 g_variant_unref(param4);
 301                 g_variant_unref(param5);
 302 //              g_free(sender);
 303         }
 304
 305         FN_END;
 306         return;
 307 }
 308
 309
 310 static const GDBusInterfaceVTable method_table = {
 311         __bt_service_method,
 312         NULL,
 313         NULL,
 314 };
 315
 316 int __bt_bluez_request(int function_name,
 317                 int request_type,
 318                 int request_id,
 319                 GDBusMethodInvocation *context,
 320                 GVariant *in_param1,
 321                 GVariant *in_param2,
 322                 GVariant *in_param3,
 323                 GVariant *in_param4,
 324                 GArray **out_param1)
 325 {
 326         int result = BLUETOOTH_ERROR_NONE;
 327
 328         switch (function_name) {
 329         case BT_ENABLE_ADAPTER:
 330                 result = _bt_enable_adapter();
 331                 break;
 332         case BT_DISABLE_ADAPTER:
 333                 result = _bt_disable_adapter();
 334                 break;
 335         case BT_RECOVER_ADAPTER:
 336                 result = _bt_recover_adapter();
 337                 break;
 338         case BT_ENABLE_ADAPTER_LE:
 339                 _bt_set_le_intended_status(TRUE);
 340                 result = _bt_enable_adapter_le();
 341                 break;
 342         case BT_DISABLE_ADAPTER_LE:
 343                 _bt_set_le_intended_status(FALSE);
 344                 result = _bt_disable_adapter_le();
 345                 break;
 346         case BT_RESET_ADAPTER:
 347                 result = _bt_reset_adapter();
 348                 break;
 349         case BT_CHECK_ADAPTER: {
 350                 int enabled = BT_ADAPTER_DISABLED;
 351
 352                 result = _bt_check_adapter(&enabled);
 353
 354                 g_array_append_vals(*out_param1, &enabled,
 355                                 sizeof(int));
 356                 break;
 357         }
 358         case BT_GET_LOCAL_ADDRESS: {
 359                 bluetooth_device_address_t local_address = { {0} };
 360                 result = _bt_get_local_address(&local_address);
 361
 362                 g_array_append_vals(*out_param1, &local_address,
 363                                 sizeof(bluetooth_device_address_t));
 364                 break;
 365         }
 366         case BT_GET_LOCAL_VERSION: {
 367                 bluetooth_version_t ver = { {0} };
 368                 result = _bt_get_local_version(&ver);
 369
 370                 g_array_append_vals(*out_param1, &ver,
 371                                 sizeof(bluetooth_version_t));
 372                 break;
 373         }
 374         case BT_GET_LOCAL_NAME: {
 375                 bluetooth_device_name_t local_name = { {0} };
 376                 result = _bt_get_local_name(&local_name);
 377
 378                 g_array_append_vals(*out_param1, &local_name,
 379                                 sizeof(bluetooth_device_name_t));
 380
 381                 break;
 382         }
 383         case BT_SET_LOCAL_NAME: {
 384                 bluetooth_device_name_t local_name = { {0} };
 385                 __bt_service_get_parameters(in_param1,
 386                                 &local_name, sizeof(bluetooth_device_name_t));
 387
 388                 result = _bt_set_local_name(local_name.name);
 389
 390                 break;
 391         }
 392         case BT_IS_SERVICE_USED: {
 393                 char *uuid;
 394                 gboolean used = FALSE;
 395
 396                 uuid = (char *)g_variant_get_data(in_param1);
 397
 398                 result = _bt_is_service_used(uuid, &used);
 399
 400                 if (result == BLUETOOTH_ERROR_NONE) {
 401                         g_array_append_vals(*out_param1, &used,
 402                                                 sizeof(gboolean));
 403                 }
 404                 break;
 405         }
 406         case BT_GET_DISCOVERABLE_MODE: {
 407                 int mode = BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE;
 408
 409                 result = _bt_get_discoverable_mode(&mode);
 410
 411                 g_array_append_vals(*out_param1, &mode, sizeof(int));
 412                 break;
 413         }
 414         case BT_SET_DISCOVERABLE_MODE: {
 415                 int mode = BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE;
 416                 int time = 0;
 417
 418                 __bt_service_get_parameters(in_param1, &mode, sizeof(int));
 419                 __bt_service_get_parameters(in_param2, &time, sizeof(int));
 420
 421                 result = _bt_set_discoverable_mode(mode, time);
 422                 break;
 423         }
 424         case BT_GET_DISCOVERABLE_TIME: {
 425                 int timeout = 0;
 426
 427                 result = _bt_get_timeout_value(&timeout);
 428
 429                 g_array_append_vals(*out_param1, &timeout, sizeof(int));
 430                 break;
 431         }
 432         case BT_START_DISCOVERY:
 433                 result = _bt_start_discovery();
 434
 435                 break;
 436         case BT_START_CUSTOM_DISCOVERY: {
 437                 bt_discovery_role_type_t role;
 438
 439                 __bt_service_get_parameters(in_param1,
 440                                 &role, sizeof(bt_discovery_role_type_t));
 441                 result = _bt_start_custom_discovery(role);
 442
 443                 break;
 444         }
 445         case BT_CANCEL_DISCOVERY:
 446                 result = _bt_cancel_discovery();
 447                 break;
 448         case BT_IS_DISCOVERYING: {
 449                 gboolean discovering = FALSE;
 450                 discovering = _bt_is_discovering();
 451                 g_array_append_vals(*out_param1,
 452                                 &discovering, sizeof(gboolean));
 453                 break;
 454         }
 455         case BT_START_LE_DISCOVERY: {
 456                 char *sender = NULL;
 457
 458                 sender = (char *)g_dbus_method_invocation_get_sender(context);
 459                 result = _bt_start_le_scan(sender);
 460
 461                 break;
 462         }
 463         case BT_STOP_LE_DISCOVERY: {
 464                 char *sender = NULL;
 465
 466                 sender = (char *)g_dbus_method_invocation_get_sender(context);
 467                 result = _bt_stop_le_scan(sender);
 468
 469                 break;
 470         }
 471         case BT_IS_LE_DISCOVERYING: {
 472                 gboolean le_discovering = FALSE;
 473
 474                 le_discovering = _bt_is_le_scanning();
 475                 g_array_append_vals(*out_param1,
 476                                 &le_discovering, sizeof(gboolean));
 477
 478                 break;
 479         }
 480         case BT_REGISTER_SCAN_FILTER: {
 481                 char *sender = NULL;
 482                 bluetooth_le_scan_filter_t scan_filter;
 483                 int slot_id;
 484
 485                 sender = (char *)g_dbus_method_invocation_get_sender(context);
 486                 __bt_service_get_parameters(in_param1, &scan_filter,
 487                                 sizeof(bluetooth_le_scan_filter_t));
 488                 BT_DBG("bluetooth_le_scan_filter_t [features : %.2x]",
 489                                 scan_filter.added_features);
 490
 491                 result = _bt_register_scan_filter(sender,
 492                                 &scan_filter, &slot_id);
 493
 494                 g_array_append_vals(*out_param1, &slot_id, sizeof(int));
 495                 break;
 496         }
 497         case BT_UNREGISTER_SCAN_FILTER:{
 498                 char *sender = NULL;
 499                 int slot_id;
 500
 501                 sender = (char *)g_dbus_method_invocation_get_sender(context);
 502                 __bt_service_get_parameters(in_param1, &slot_id, sizeof(int));
 503                 BT_DBG("Remove scan filter [Slot ID : %d]", slot_id);
 504
 505                 result = _bt_unregister_scan_filter(sender, slot_id);
 506
 507                 break;
 508         }
 509         case BT_UNREGISTER_ALL_SCAN_FILTERS:{
 510                 char *sender = NULL;
 511
 512                 sender = (char *)g_dbus_method_invocation_get_sender(context);
 513
 514                 BT_DBG("Remove all scan filters [Sender : %s]", sender);
 515
 516                 result = _bt_unregister_all_scan_filters(sender);
 517
 518                 break;
 519         }
 520         case BT_IS_SCAN_FILTER_SUPPORTED:{
 521                 int is_supported = 0;
 522
 523                 if (_bt_is_scan_filter_supported() == TRUE)
 524                         is_supported = 1;
 525
 526                 g_array_append_vals(*out_param1,
 527                                 &is_supported, sizeof(int));
 528
 529                 break;
 530         }
 531         case BT_ENABLE_RSSI: {
 532                 bluetooth_device_address_t bd_addr;
 533                 int link_type;
 534                 bt_rssi_threshold_t rssi_threshold;
 535                 int low_threshold;
 536                 int in_range_threshold;
 537                 int high_threshold;
 538
 539                 BT_DBG("Enable RSSI");
 540
 541                 __bt_service_get_parameters(in_param1,
 542                                 &bd_addr, sizeof(bluetooth_device_address_t));
 543                 __bt_service_get_parameters(in_param2,
 544                                 &link_type, sizeof(int));
 545                 __bt_service_get_parameters(in_param3,
 546                                 &rssi_threshold, sizeof(bt_rssi_threshold_t));
 547
 548                 low_threshold = rssi_threshold.low_threshold;
 549                 in_range_threshold = rssi_threshold.in_range_threshold;
 550                 high_threshold = rssi_threshold.high_threshold;
 551
 552                 result = _bt_enable_rssi(&bd_addr,
 553                                 link_type, low_threshold,
 554                                 in_range_threshold, high_threshold);
 555                 break;
 556         }
 557         case BT_GET_RSSI: {
 558                 int link_type;
 559                 bluetooth_device_address_t bd_addr;
 560
 561                 BT_DBG("Get RSSI Strength");
 562
 563                 __bt_service_get_parameters(in_param1,
 564                                 &bd_addr, sizeof(bluetooth_device_address_t));
 565                 __bt_service_get_parameters(in_param2,
 566                                 &link_type, sizeof(int));
 567
 568                 result = _bt_get_rssi_strength(&bd_addr, link_type);
 569                 break;
 570         }
 571         case BT_IS_CONNECTABLE: {
 572                 gboolean is_connectable;
 573
 574                 is_connectable = _bt_is_connectable();
 575                 g_array_append_vals(*out_param1,
 576                                 &is_connectable, sizeof(gboolean));
 577                 break;
 578         }
 579         case BT_SET_CONNECTABLE: {
 580                 gboolean is_connectable;
 581
 582                 __bt_service_get_parameters(in_param1,
 583                                 &is_connectable, sizeof(gboolean));
 584                 result = _bt_set_connectable(is_connectable);
 585                 break;
 586         }
 587         case BT_SET_ADVERTISING: {
 588                 char *sender = NULL;
 589                 int adv_handle;
 590                 gboolean enable = FALSE;
 591                 gboolean use_reserved_slot = FALSE;
 592
 593                 __bt_service_get_parameters(in_param1,
 594                                 &adv_handle, sizeof(int));
 595                 __bt_service_get_parameters(in_param2,
 596                                 &enable, sizeof(gboolean));
 597                 __bt_service_get_parameters(in_param3,
 598                                 &use_reserved_slot, sizeof(gboolean));
 599
 600                 sender = (char *)g_dbus_method_invocation_get_sender(context);
 601
 602                 result = _bt_set_advertising(sender, adv_handle,
 603                                 enable, use_reserved_slot);
 604                 break;
 605         }
 606         case BT_SET_CUSTOM_ADVERTISING: {
 607                 char *sender = NULL;
 608                 int adv_handle;
 609                 gboolean enable = FALSE;
 610                 bluetooth_advertising_params_t adv_params;
 611                 gboolean use_reserved_slot = FALSE;
 612
 613                 sender = (char *)g_dbus_method_invocation_get_sender(context);
 614
 615                 __bt_service_get_parameters(in_param1, &adv_handle,
 616                                 sizeof(int));
 617                 __bt_service_get_parameters(in_param2, &enable,
 618                                 sizeof(gboolean));
 619                 __bt_service_get_parameters(in_param3, &adv_params,
 620                                 sizeof(bluetooth_advertising_params_t));
 621                 __bt_service_get_parameters(in_param4, &use_reserved_slot,
 622                                 sizeof(gboolean));
 623
 624                 BT_DBG("bluetooth_advertising_params_t [%f %f %d %d]",
 625                                 adv_params.interval_min, adv_params.interval_max,
 626                                 adv_params.filter_policy, adv_params.type);
 627                 result = _bt_set_custom_advertising(sender, adv_handle,
 628                                 enable, &adv_params, use_reserved_slot);
 629                 break;
 630         }
 631         case BT_GET_ADVERTISING_DATA: {
 632                 bluetooth_advertising_data_t adv = { {0} };
 633                 int length = 0;
 634
 635                 result = _bt_get_advertising_data(&adv, &length);
 636                 if (result == BLUETOOTH_ERROR_NONE)
 637                         g_array_append_vals(*out_param1, adv.data, length);
 638
 639                 break;
 640         }
 641         case BT_SET_ADVERTISING_DATA: {
 642                 char *sender = NULL;
 643                 int adv_handle;
 644                 bluetooth_advertising_data_t adv = { {0} };
 645                 int length;
 646                 gboolean use_reserved_slot = FALSE;
 647
 648                 sender = (char *)g_dbus_method_invocation_get_sender(context);
 649
 650                 __bt_service_get_parameters(in_param1,
 651                                 &adv_handle, sizeof(int));
 652                 __bt_service_get_parameters(in_param2,
 653                                 &adv, sizeof(bluetooth_advertising_data_t));
 654                 __bt_service_get_parameters(in_param3,
 655                                 &length, sizeof(int));
 656                 __bt_service_get_parameters(in_param4,
 657                                 &use_reserved_slot, sizeof(gboolean));
 658
 659                 result = _bt_set_advertising_data(sender, adv_handle,
 660                                 &adv, length, use_reserved_slot);
 661                 break;
 662         }
 663         case BT_GET_SCAN_RESPONSE_DATA: {
 664                 bluetooth_scan_resp_data_t rsp = { {0} };
 665                 int length = 0;
 666
 667                 result = _bt_get_scan_response_data(&rsp, &length);
 668                 if (result == BLUETOOTH_ERROR_NONE)
 669                         g_array_append_vals(*out_param1, rsp.data, length);
 670
 671                 break;
 672         }
 673         case BT_SET_SCAN_RESPONSE_DATA: {
 674                 char *sender = NULL;
 675                 int adv_handle;
 676                 bluetooth_scan_resp_data_t rsp = { {0} };
 677                 int length;
 678                 gboolean use_reserved_slot = FALSE;
 679
 680                 sender = (char *)g_dbus_method_invocation_get_sender(context);
 681
 682                 __bt_service_get_parameters(in_param1,
 683                                 &adv_handle, sizeof(int));
 684                 __bt_service_get_parameters(in_param2,
 685                                 &rsp, sizeof(bluetooth_scan_resp_data_t));
 686                 __bt_service_get_parameters(in_param3,
 687                                 &length, sizeof(int));
 688                 __bt_service_get_parameters(in_param4,
 689                                 &use_reserved_slot, sizeof(gboolean));
 690
 691                 result = _bt_set_scan_response_data(sender, adv_handle,
 692                                 &rsp, length, use_reserved_slot);
 693
 694                 break;
 695         }
 696         case BT_SET_MANUFACTURER_DATA: {
 697                 bluetooth_manufacturer_data_t m_data = { 0 };
 698                 __bt_service_get_parameters(in_param1,
 699                                 &m_data, sizeof(bluetooth_manufacturer_data_t));
 700
 701                 result = _bt_set_manufacturer_data(&m_data);
 702                 break;
 703         }
 704         case BT_SET_SCAN_PARAMETERS: {
 705                 bluetooth_le_scan_params_t scan_params;
 706                 __bt_service_get_parameters(in_param1, &scan_params,
 707                                 sizeof(bluetooth_le_scan_params_t));
 708
 709                 BT_DBG("bluetooth_le_scan_params_t [%f %f %d]",
 710                                 scan_params.interval, scan_params.window,
 711                                 scan_params.type);
 712
 713                 result = _bt_set_scan_parameters(&scan_params);
 714                 break;
 715         }
 716         case BT_LE_CONN_UPDATE: {
 717                 bluetooth_device_address_t local_address = { {0} };
 718                 bluetooth_le_connection_param_t parameters = {0};
 719
 720                 __bt_service_get_parameters(in_param1, &local_address,
 721                                 sizeof(bluetooth_device_address_t));
 722                 __bt_service_get_parameters(in_param2, &parameters,
 723                                 sizeof(bluetooth_le_connection_param_t));
 724
 725                 result =  _bt_le_conn_update(local_address.addr,
 726                                         parameters.interval_min,
 727                                         parameters.interval_max,
 728                                         parameters.latency,
 729                                         parameters.timeout);
 730                 break;
 731         }
 732         case BT_IS_ADVERTISING: {
 733                 gboolean advertising = FALSE;
 734                 advertising = _bt_is_advertising();
 735
 736                 g_array_append_vals(*out_param1, &advertising,
 737                                 sizeof(gboolean));
 738                 break;
 739         }
 740         case BT_ADD_WHITE_LIST: {
 741                 bluetooth_device_address_t address = { {0} };
 742                 int addr_type = 0;
 743
 744                 __bt_service_get_parameters(in_param1, &address,
 745                                 sizeof(bluetooth_device_address_t));
 746                 __bt_service_get_parameters(in_param2, &addr_type,
 747                                 sizeof(int));
 748
 749                 result = _bt_add_white_list(&address, addr_type);
 750                 break;
 751         }
 752         case BT_REMOVE_WHITE_LIST: {
 753                 bluetooth_device_address_t address = { {0} };
 754                 int addr_type = 0;
 755
 756                 __bt_service_get_parameters(in_param1,
 757                                 &address, sizeof(bluetooth_device_address_t));
 758                 __bt_service_get_parameters(in_param2,
 759                                 &addr_type, sizeof(int));
 760
 761                 result = _bt_remove_white_list(&address, addr_type);
 762                 break;
 763         }
 764         case BT_CLEAR_WHITE_LIST: {
 765                 result = _bt_clear_white_list();
 766                 break;
 767         }
 768         case BT_GET_BONDED_DEVICES: {
 769                 result = _bt_get_bonded_devices(out_param1);
 770                 break;
 771         }
 772         case BT_GET_PROFILE_CONNECTED_DEVICES: {
 773                 char *uuid;
 774                 uuid = (char *)g_variant_get_data(in_param1);
 775                 result = _bt_get_profile_connected_devices(uuid, out_param1);
 776                 break;
 777         }
 778         case BT_SET_PASSKEY_NOTIFICATION: {
 779                 char *sender = NULL;
 780                 gboolean enable;
 781
 782                 sender = (char *)g_dbus_method_invocation_get_sender(context);
 783                 __bt_service_get_parameters(in_param1,
 784                                 &enable, sizeof(gboolean));
 785
 786                 result = _bt_set_passkey_notification(sender, enable);
 787                 break;
 788         }
 789         case BT_GET_BONDED_DEVICE: {
 790                 bluetooth_device_address_t address = { {0} };
 791                 bluetooth_device_info_t dev_info;
 792
 793                 __bt_service_get_parameters(in_param1,
 794                                 &address, sizeof(bluetooth_device_address_t));
 795
 796                 memset(&dev_info, 0x00, sizeof(bluetooth_device_info_t));
 797                 result = _bt_get_bonded_device_info(&address, &dev_info);
 798
 799                 if (result == BLUETOOTH_ERROR_NONE) {
 800                         g_array_append_vals(*out_param1, &dev_info,
 801                                         sizeof(bluetooth_device_info_t));
 802                 }
 803                 break;
 804         }
 805         case BT_GET_IS_ALIAS_SET: {
 806                 bluetooth_device_address_t address = { {0} };
 807                 gboolean is_alias_set = FALSE;
 808
 809                 __bt_service_get_parameters(in_param1,
 810                                 &address, sizeof(bluetooth_device_address_t));
 811
 812                 result = _bt_is_alias_set(&address, &is_alias_set);
 813                 if (result == BLUETOOTH_ERROR_NONE)
 814                         g_array_append_vals(*out_param1, &is_alias_set, sizeof(gboolean));
 815
 816                 break;
 817         }
 818         case BT_BOND_DEVICE: {
 819                 bluetooth_device_address_t address = { {0} };
 820
 821                 __bt_service_get_parameters(in_param1,
 822                                 &address, sizeof(bluetooth_device_address_t));
 823
 824                 result = _bt_bond_device(request_id, &address,
 825                                 BLUETOOTH_DEV_CONN_DEFAULT, out_param1);
 826                 break;
 827         }
 828         case BT_BOND_DEVICE_BY_TYPE: {
 829                 bluetooth_device_address_t address = { {0} };
 830                 unsigned short conn_type = 0;
 831
 832                 __bt_service_get_parameters(in_param1,
 833                                 &address, sizeof(bluetooth_device_address_t));
 834                 __bt_service_get_parameters(in_param2,
 835                                 &conn_type, sizeof(unsigned short));
 836
 837                 result = _bt_bond_device(request_id, &address,
 838                                 conn_type, out_param1);
 839                 break;
 840         }
 841         case BT_CANCEL_BONDING: {
 842                 result = _bt_cancel_bonding();
 843                 break;
 844         }
 845         case BT_PASSKEY_REPLY: {
 846                 const char *passkey = NULL;
 847                 gboolean authentication_reply = FALSE;
 848
 849                 passkey = g_variant_get_data(in_param1);
 850                 __bt_service_get_parameters(in_param2,
 851                         &authentication_reply, sizeof(gboolean));
 852                 result = _bt_passkey_reply(passkey, authentication_reply);
 853                 break;
 854         }
 855         case BT_PASSKEY_CONFIRMATION_REPLY: {
 856                 gboolean confirmation_reply = FALSE;
 857
 858                 __bt_service_get_parameters(in_param1,
 859                         &confirmation_reply, sizeof(gboolean));
 860                 result = _bt_passkey_confirmation_reply(confirmation_reply);
 861                 break;
 862         }
 863         case BT_UNBOND_DEVICE: {
 864                 bluetooth_device_address_t address = { {0} };
 865
 866                 __bt_service_get_parameters(in_param1,
 867                                 &address, sizeof(bluetooth_device_address_t));
 868
 869                 result = _bt_unbond_device(request_id, &address, out_param1);
 870
 871                 break;
 872         }
 873         case BT_SET_ALIAS: {
 874                 bluetooth_device_address_t address = { {0} };
 875                 const char *local_name;
 876
 877                 __bt_service_get_parameters(in_param1,
 878                                 &address, sizeof(bluetooth_device_address_t));
 879                 local_name = (const char *)g_variant_get_data(in_param2);
 880
 881                 result = _bt_set_alias(&address, local_name);
 882                 break;
 883         }
 884         case BT_SEARCH_SERVICE: {
 885                 bluetooth_device_address_t address = { {0} };
 886
 887                 __bt_service_get_parameters(in_param1,
 888                                 &address, sizeof(bluetooth_device_address_t));
 889
 890                 result = _bt_search_device(request_id, &address);
 891                 if (result != BLUETOOTH_ERROR_NONE) {
 892                         g_array_append_vals(*out_param1, &address,
 893                                         sizeof(bluetooth_device_address_t));
 894                 }
 895                 break;
 896         }
 897         case BT_CANCEL_SEARCH_SERVICE: {
 898                 result = _bt_cancel_search_device();
 899                 break;
 900         }
 901         case BT_SET_AUTHORIZATION: {
 902                 bluetooth_device_address_t address = { {0} };
 903                 gboolean authorize;
 904
 905                 __bt_service_get_parameters(in_param1,
 906                                 &address, sizeof(bluetooth_device_address_t));
 907                 __bt_service_get_parameters(in_param2,
 908                                 &authorize, sizeof(gboolean));
 909
 910                 result = _bt_set_authorization(&address, authorize);
 911                 break;
 912         }
 913         case BT_IS_DEVICE_CONNECTED: {
 914                 bluetooth_device_address_t address = { {0} };
 915                 int type;
 916                 gboolean connected = FALSE;
 917
 918                 __bt_service_get_parameters(in_param1,
 919                                 &address, sizeof(bluetooth_device_address_t));
 920                 __bt_service_get_parameters(in_param2,
 921                                 &type, sizeof(int));
 922
 923                 result = _bt_is_device_connected(&address, type, &connected);
 924                 BT_DBG("is_connected: %d", connected);
 925                 if (result == BLUETOOTH_ERROR_NONE) {
 926                         g_array_append_vals(*out_param1, &connected,
 927                                                 sizeof(gboolean));
 928                 }
 929
 930                 break;
 931         }
 932         case BT_GET_CONNECTED_LINK_TYPE: {
 933                 bluetooth_device_address_t address = { {0} };
 934                 bluetooth_connected_link_t connected = BLUETOOTH_CONNECTED_LINK_NONE;
 935
 936                 __bt_service_get_parameters(in_param1,
 937                                 &address, sizeof(bluetooth_device_address_t));
 938
 939                 result = _bt_get_connected_link(&address, &connected);
 940
 941                 if (result == BLUETOOTH_ERROR_NONE) {
 942                         g_array_append_vals(*out_param1, &connected,
 943                                         sizeof(guint));
 944                 }
 945
 946                 break;
 947         }
 948         case BT_SET_PIN_CODE: {
 949                 bluetooth_device_address_t address = { {0} };
 950                 bluetooth_device_pin_code_t pin_code = { {0} };
 951
 952                 __bt_service_get_parameters(in_param1,
 953                                 &address, sizeof(bluetooth_device_address_t));
 954                 __bt_service_get_parameters(in_param2,
 955                                 &pin_code, sizeof(bluetooth_device_pin_code_t));
 956
 957                 result = _bt_set_pin_code(&address, &pin_code);
 958                 break;
 959         }
 960         case BT_UNSET_PIN_CODE: {
 961                 bluetooth_device_address_t address = { {0} };
 962
 963                 __bt_service_get_parameters(in_param1,
 964                                 &address, sizeof(bluetooth_device_address_t));
 965
 966                 result = _bt_unset_pin_code(&address);
 967                 break;
 968         }
 969         case BT_UPDATE_LE_CONNECTION_MODE: {
 970                 bluetooth_device_address_t remote_address = { { 0 } };
 971                 bluetooth_le_connection_param_t param = { 0 };
 972                 bluetooth_le_connection_mode_t mode = BLUETOOTH_LE_CONNECTION_MODE_BALANCED;
 973
 974                 __bt_service_get_parameters(in_param1, &remote_address,
 975                                 sizeof(bluetooth_device_address_t));
 976                 __bt_service_get_parameters(in_param2, &mode,
 977                                 sizeof(bluetooth_le_connection_mode_t));
 978
 979                 result = _bt_get_le_connection_parameter(mode, &param);
 980                 if (result != BLUETOOTH_ERROR_NONE)
 981                         break;
 982
 983                 result = _bt_le_conn_update(remote_address.addr,
 984                                 param.interval_min,
 985                                 param.interval_max,
 986                                 param.latency,
 987                                 param.timeout);
 988                 break;
 989         }
 990
 991         case BT_SET_PROFILE_TRUSTED: {
 992                 bluetooth_device_address_t bd_addr = { {0} };
 993                 int profile;
 994                 int trust;
 995
 996                 __bt_service_get_parameters(in_param1, &bd_addr,
 997                                 sizeof(bluetooth_device_address_t));
 998                 __bt_service_get_parameters(in_param2, &profile, sizeof(int));
 999                 __bt_service_get_parameters(in_param3, &trust, sizeof(int));
1000
1001                 result = _bt_set_trust_profile(&bd_addr, profile, trust);
1002                 break;
1003         }
1004         case BT_GET_PROFILE_TRUSTED: {
1005                 bluetooth_device_address_t bd_addr = { {0} };
1006                 int profile;
1007                 guint trusted_profile = 0;
1008
1009                 __bt_service_get_parameters(in_param1, &bd_addr,
1010                                 sizeof(bluetooth_device_address_t));
1011                 __bt_service_get_parameters(in_param2, &profile, sizeof(int));
1012
1013                 result = _bt_get_trust_profile(&bd_addr, profile, &trusted_profile);
1014                 BT_DBG("TRUST %d", trusted_profile);
1015                 if (result == BLUETOOTH_ERROR_NONE) {
1016                         g_array_append_vals(*out_param1, &trusted_profile,
1017                                         sizeof(guint));
1018                 }
1019
1020                 break;
1021         }
1022         case BT_SET_PROFILE_RESTRICTED: {
1023                 bluetooth_device_address_t bd_addr = { {0} };
1024                 int profile;
1025                 int restricted;
1026
1027                 __bt_service_get_parameters(in_param1, &bd_addr,
1028                                 sizeof(bluetooth_device_address_t));
1029                 __bt_service_get_parameters(in_param2, &profile, sizeof(int));
1030                 __bt_service_get_parameters(in_param3, &restricted, sizeof(int));
1031
1032                 result = _bt_set_restrict_profile(&bd_addr, profile, restricted);
1033                 break;
1034         }
1035         case BT_GET_PROFILE_RESTRICTED: {
1036                 bluetooth_device_address_t bd_addr = { {0} };
1037                 int profile;
1038                 guint restricted_profile = 0;
1039
1040                 __bt_service_get_parameters(in_param1, &bd_addr,
1041                                 sizeof(bluetooth_device_address_t));
1042                 __bt_service_get_parameters(in_param2, &profile, sizeof(int));
1043
1044                 result = _bt_get_restrict_profile(&bd_addr, profile, &restricted_profile);
1045                 BT_DBG("Restricted %d", restricted_profile);
1046                 if (result == BLUETOOTH_ERROR_NONE) {
1047                         g_array_append_vals(*out_param1, &restricted_profile,
1048                                         sizeof(guint));
1049                 }
1050
1051                 break;
1052         }
1053         case BT_HID_CONNECT: {
1054                 bluetooth_device_address_t address = { {0} };
1055
1056                 __bt_service_get_parameters(in_param1,
1057                                 &address, sizeof(bluetooth_device_address_t));
1058
1059                 result = _bt_hid_connect(request_id, &address);
1060                 if (result != BLUETOOTH_ERROR_NONE) {
1061                         g_array_append_vals(*out_param1, &address,
1062                                         sizeof(bluetooth_device_address_t));
1063                 }
1064                 break;
1065         }
1066         case BT_HID_DISCONNECT: {
1067                 bluetooth_device_address_t address = { {0} };
1068
1069                 __bt_service_get_parameters(in_param1,
1070                                 &address, sizeof(bluetooth_device_address_t));
1071
1072                 result = _bt_hid_disconnect(request_id, &address);
1073                 if (result != BLUETOOTH_ERROR_NONE) {
1074                         g_array_append_vals(*out_param1, &address,
1075                                         sizeof(bluetooth_device_address_t));
1076                 }
1077                 break;
1078         }
1079         case BT_HID_ENABLE_BARCODE_FEATURE: {
1080                 result = _bt_hid_enable_barcode_feature();
1081                 break;
1082         }
1083         case BT_NETWORK_ACTIVATE:
1084                 result = _bt_network_activate();
1085                 break;
1086         case BT_NETWORK_DEACTIVATE:
1087                 result = _bt_network_deactivate();
1088                 break;
1089         case BT_NETWORK_CONNECT: {
1090                 bluetooth_device_address_t address = { {0} };
1091                 int role;
1092
1093                 __bt_service_get_parameters(in_param1,
1094                                 &address, sizeof(bluetooth_device_address_t));
1095                 __bt_service_get_parameters(in_param2,
1096                                 &role, sizeof(int));
1097
1098                 result = _bt_network_connect(request_id, role, &address);
1099                 if (result != BLUETOOTH_ERROR_NONE) {
1100                         g_array_append_vals(*out_param1, &address,
1101                                         sizeof(bluetooth_device_address_t));
1102                 }
1103                 break;
1104         }
1105         case BT_NETWORK_DISCONNECT: {
1106                 bluetooth_device_address_t address = { {0} };
1107
1108                 __bt_service_get_parameters(in_param1,
1109                                 &address, sizeof(bluetooth_device_address_t));
1110
1111                 result = _bt_network_disconnect(request_id, &address);
1112                 if (result != BLUETOOTH_ERROR_NONE) {
1113                         g_array_append_vals(*out_param1, &address,
1114                                         sizeof(bluetooth_device_address_t));
1115                 }
1116                 break;
1117         }
1118         case BT_NETWORK_SERVER_DISCONNECT: {
1119                 bluetooth_device_address_t address = { {0} };
1120
1121                 __bt_service_get_parameters(in_param1,
1122                                 &address, sizeof(bluetooth_device_address_t));
1123
1124                 result = _bt_network_server_disconnect(request_id, &address);
1125                 if (result != BLUETOOTH_ERROR_NONE) {
1126                         g_array_append_vals(*out_param1, &address,
1127                                         sizeof(bluetooth_device_address_t));
1128                 }
1129                 break;
1130         }
1131
1132         case BT_AUDIO_CONNECT: {
1133                 bluetooth_device_address_t address = { {0} };
1134
1135                 __bt_service_get_parameters(in_param1,
1136                                 &address, sizeof(bluetooth_device_address_t));
1137
1138                 result = _bt_audio_connect(request_id, BT_AUDIO_ALL,
1139                                         &address, *out_param1);
1140                 break;
1141         }
1142         case BT_AUDIO_DISCONNECT: {
1143                 bluetooth_device_address_t address = { {0} };
1144
1145                 __bt_service_get_parameters(in_param1,
1146                                 &address, sizeof(bluetooth_device_address_t));
1147
1148                 result = _bt_audio_disconnect(request_id, BT_AUDIO_ALL,
1149                                         &address, *out_param1);
1150                 break;
1151         }
1152         case BT_AG_CONNECT: {
1153                 bluetooth_device_address_t address = { {0} };
1154
1155                 __bt_service_get_parameters(in_param1,
1156                                 &address, sizeof(bluetooth_device_address_t));
1157
1158                 result = _bt_audio_connect(request_id, BT_AUDIO_HSP,
1159                                         &address, *out_param1);
1160                 break;
1161         }
1162         case BT_AG_DISCONNECT: {
1163                 bluetooth_device_address_t address = { {0} };
1164
1165                 __bt_service_get_parameters(in_param1,
1166                                 &address, sizeof(bluetooth_device_address_t));
1167
1168                 result = _bt_audio_disconnect(request_id, BT_AUDIO_HSP,
1169                                         &address, *out_param1);
1170                 break;
1171         }
1172         case BT_AV_CONNECT: {
1173                 bluetooth_device_address_t address = { {0} };
1174
1175                 __bt_service_get_parameters(in_param1,
1176                                 &address, sizeof(bluetooth_device_address_t));
1177
1178                 result = _bt_audio_connect(request_id, BT_AUDIO_A2DP,
1179                                         &address, *out_param1);
1180                 break;
1181         }
1182         case BT_AV_DISCONNECT: {
1183                 bluetooth_device_address_t address = { {0} };
1184
1185                 __bt_service_get_parameters(in_param1,
1186                                 &address, sizeof(bluetooth_device_address_t));
1187
1188                 result = _bt_audio_disconnect(request_id, BT_AUDIO_A2DP,
1189                                         &address, *out_param1);
1190                 break;
1191         }
1192         case BT_AVRCP_CONTROL_CONNECT: {
1193                 bluetooth_device_address_t address = { {0} };
1194
1195                 __bt_service_get_parameters(in_param1,
1196                                 &address, sizeof(bluetooth_device_address_t));
1197
1198                 result = _bt_audio_connect(request_id, BT_AVRCP,
1199                                         &address, *out_param1);
1200                 break;
1201         }
1202         case BT_AVRCP_CONTROL_DISCONNECT: {
1203                 bluetooth_device_address_t address = { {0} };
1204
1205                 __bt_service_get_parameters(in_param1,
1206                                 &address, sizeof(bluetooth_device_address_t));
1207
1208                 result = _bt_audio_disconnect(request_id, BT_AVRCP,
1209                                         &address, *out_param1);
1210                 break;
1211         }
1212         case BT_AVRCP_TARGET_CONNECT: {
1213                 bluetooth_device_address_t address = { {0} };
1214                 __bt_service_get_parameters(in_param1,
1215                                 &address, sizeof(bluetooth_device_address_t));
1216                 result = _bt_audio_connect(request_id, BT_AVRCP_TARGET,
1217                                         &address, *out_param1);
1218                 break;
1219                 }
1220         case BT_AVRCP_TARGET_DISCONNECT: {
1221                 bluetooth_device_address_t address = { {0} };
1222                 __bt_service_get_parameters(in_param1,
1223                                 &address, sizeof(bluetooth_device_address_t));
1224                 result = _bt_audio_disconnect(request_id, BT_AVRCP_TARGET,
1225                                         &address, *out_param1);
1226                 break;
1227                 }
1228         case BT_AV_SOURCE_CONNECT: {
1229                 bluetooth_device_address_t address = { {0} };
1230
1231                 __bt_service_get_parameters(in_param1, &address,
1232                                 sizeof(bluetooth_device_address_t));
1233
1234                 result = _bt_audio_connect(request_id, BT_AUDIO_A2DP_SOURCE,
1235                                         &address, *out_param1);
1236                 break;
1237         }
1238         case BT_AV_SOURCE_DISCONNECT: {
1239                 bluetooth_device_address_t address = { {0} };
1240
1241                 __bt_service_get_parameters(in_param1, &address,
1242                                 sizeof(bluetooth_device_address_t));
1243
1244                 result = _bt_audio_disconnect(request_id, BT_AUDIO_A2DP_SOURCE,
1245                                         &address, *out_param1);
1246                 break;
1247         }
1248         case BT_HF_CONNECT: {
1249                 bluetooth_device_address_t address = { {0} };
1250
1251                 __bt_service_get_parameters(in_param1,
1252                                 &address, sizeof(bluetooth_device_address_t));
1253
1254                 result = _bt_hf_connect(request_id, &address, *out_param1);
1255                 break;
1256         }
1257         case BT_HF_DISCONNECT: {
1258                 bluetooth_device_address_t address = { {0} };
1259
1260                 __bt_service_get_parameters(in_param1,
1261                                 &address, sizeof(bluetooth_device_address_t));
1262
1263                 result = _bt_hf_disconnect(request_id, &address, *out_param1);
1264                 break;
1265         }
1266         case BT_SET_CONTENT_PROTECT: {
1267                 gboolean status;
1268
1269                 __bt_service_get_parameters(in_param1,
1270                                 &status, sizeof(gboolean));
1271
1272                 result = _bt_audio_set_content_protect(status);
1273
1274                 break;
1275         }
1276         case BT_AUDIO_SELECT_ROLE: {
1277
1278                 bluetooth_audio_role_t role;
1279
1280                 __bt_service_get_parameters(in_param1,
1281                                 &role, sizeof(bluetooth_audio_role_t));
1282
1283                 result = _bt_audio_select_role(role);
1284
1285                 break;
1286         }
1287         case BT_OOB_READ_LOCAL_DATA: {
1288                 bt_oob_data_t local_oob_data;
1289
1290                 memset(&local_oob_data, 0x00, sizeof(bt_oob_data_t));
1291                 result = _bt_oob_read_local_data(&local_oob_data);
1292
1293                 g_array_append_vals(*out_param1, &local_oob_data,
1294                                 sizeof(bt_oob_data_t));
1295
1296                 break;
1297         }
1298         case BT_OOB_ADD_REMOTE_DATA: {
1299                 bluetooth_device_address_t address = { {0} };
1300                 bt_oob_data_t remote_oob_data;
1301
1302                 __bt_service_get_parameters(in_param1,
1303                                 &address, sizeof(bluetooth_device_address_t));
1304                 __bt_service_get_parameters(in_param2,
1305                                 &remote_oob_data, sizeof(bt_oob_data_t));
1306
1307                 result = _bt_oob_add_remote_data(&address, &remote_oob_data);
1308
1309                 break;
1310         }
1311         case BT_OOB_REMOVE_REMOTE_DATA: {
1312                 bluetooth_device_address_t address = { {0} };
1313
1314                 __bt_service_get_parameters(in_param1,
1315                                 &address, sizeof(bluetooth_device_address_t));
1316
1317                 result = _bt_oob_remove_remote_data(&address);
1318
1319                 break;
1320         }
1321         case BT_AVRCP_SET_TRACK_INFO: {
1322                 media_metadata_t data;
1323                 media_metadata_attributes_t meta_data;
1324
1325                 memset(&data, 0x00, sizeof(media_metadata_t));
1326                 memset(&meta_data, 0x00, sizeof(media_metadata_attributes_t));
1327
1328                 __bt_service_get_parameters(in_param1,
1329                                 &data, sizeof(media_metadata_t));
1330
1331                 meta_data.title = g_strdup(data.title);
1332                 meta_data.artist = g_strdup(data.artist);
1333                 meta_data.album = g_strdup(data.album);
1334                 meta_data.genre = g_strdup(data.genre);
1335                 meta_data.total_tracks = data.total_tracks;
1336                 meta_data.number = data.number;
1337                 meta_data.duration = (int64_t) data.duration;
1338
1339                 result = _bt_avrcp_set_track_info(&meta_data);
1340
1341                 g_free((gpointer)meta_data.title);
1342                 g_free((gpointer)meta_data.artist);
1343                 g_free((gpointer)meta_data.album);
1344                 g_free((gpointer)meta_data.genre);
1345
1346                 break;
1347         }
1348         case BT_AVRCP_SET_PROPERTY: {
1349                 int type;
1350                 unsigned int value;
1351                 char *sender = NULL;
1352                 sender = (char *)g_dbus_method_invocation_get_sender(context);
1353                 BT_INFO("Sender %s", sender);
1354
1355                 __bt_service_get_parameters(in_param1,
1356                                 &type, sizeof(int));
1357                 __bt_service_get_parameters(in_param2,
1358                                 &value, sizeof(unsigned int));
1359
1360                 if (value == STATUS_PLAYING) {
1361                         if (current_sender_playing)
1362                                 g_free(current_sender_playing);
1363                         current_sender_playing = g_strdup(sender);
1364                 }
1365                 if (g_strcmp0(sender, current_sender_playing) == 0 ||
1366                         current_sender_playing == NULL) {
1367                         BT_INFO("Current Player Status %d type %d", value, type);
1368                 } else {
1369                         BT_INFO("Current Player and this sender are different");
1370                         result = BLUETOOTH_ERROR_NONE;
1371                         break;
1372                 }
1373                 result = _bt_avrcp_set_property(type, value);
1374
1375                 break;
1376         }
1377         case BT_AVRCP_SET_PROPERTIES: {
1378                 media_player_settings_t properties;
1379
1380                 memset(&properties, 0x00, sizeof(media_player_settings_t));
1381                 __bt_service_get_parameters(in_param1,
1382                                 &properties, sizeof(media_player_settings_t));
1383
1384                 result = _bt_avrcp_set_properties(&properties);
1385
1386                 break;
1387         }
1388         case BT_AVRCP_HANDLE_CONTROL: {
1389                 int type;
1390
1391                 __bt_service_get_parameters(in_param1, &type, sizeof(int));
1392
1393                 result = _bt_avrcp_control_cmd(type);
1394
1395                 break;
1396         }
1397         case BT_AVRCP_CONTROL_SET_PROPERTY: {
1398                 int type;
1399                 unsigned int value;
1400
1401                 __bt_service_get_parameters(in_param1,
1402                                 &type, sizeof(int));
1403                 __bt_service_get_parameters(in_param2,
1404                                 &value, sizeof(unsigned int));
1405
1406                 result = _bt_avrcp_control_set_property(type, value);
1407
1408                 break;
1409         }
1410         case BT_AVRCP_CONTROL_GET_PROPERTY: {
1411                 int type;
1412                 unsigned int value;
1413
1414                 __bt_service_get_parameters(in_param1, &type, sizeof(int));
1415
1416                 result = _bt_avrcp_control_get_property(type, &value);
1417                 g_array_append_vals(*out_param1, &value, sizeof(int));
1418
1419                 break;
1420         }
1421         case BT_AVRCP_GET_TRACK_INFO: {
1422                 media_metadata_t meta_data;
1423                 media_metadata_attributes_t metadata;
1424
1425                 memset(&meta_data, 0x00, sizeof(media_metadata_t));
1426                 memset(&metadata, 0x00, sizeof(media_metadata_attributes_t));
1427
1428                 result = _bt_avrcp_control_get_track_info(&metadata);
1429
1430                 if (BLUETOOTH_ERROR_NONE != result)
1431                         break;
1432
1433                 if (_bt_copy_utf8_string(meta_data.title, metadata.title,
1434                                                         BT_META_DATA_MAX_LEN))
1435                         BT_ERR("Error in copying Title\n");
1436                 if (_bt_copy_utf8_string(meta_data.artist, metadata.artist,
1437                                                         BT_META_DATA_MAX_LEN))
1438                         BT_ERR("Error in copying Artist\n");
1439                 if (_bt_copy_utf8_string(meta_data.album, metadata.album,
1440                                                         BT_META_DATA_MAX_LEN))
1441                         BT_ERR("Error in copying Album\n");
1442                 if (_bt_copy_utf8_string(meta_data.genre, metadata.genre,
1443                                                         BT_META_DATA_MAX_LEN))
1444                         BT_ERR("Error in copying Genre\n");
1445
1446                 if (_bt_utf8_validate(meta_data.title) == FALSE)
1447                         meta_data.title[0] = '\0';
1448
1449                 if (_bt_utf8_validate(meta_data.artist) == FALSE)
1450                         meta_data.artist[0] = '\0';
1451
1452                 if (_bt_utf8_validate(meta_data.album) == FALSE)
1453                         meta_data.album[0] = '\0';
1454
1455                 if (_bt_utf8_validate(meta_data.genre) == FALSE)
1456                         meta_data.genre[0] = '\0';
1457
1458                 meta_data.total_tracks = metadata.total_tracks;
1459                 meta_data.number = metadata.number;
1460                 meta_data.duration = metadata.duration;
1461
1462                 g_free((gpointer)metadata.title);
1463                 g_free((gpointer)metadata.artist);
1464                 g_free((gpointer)metadata.album);
1465                 g_free((gpointer)metadata.genre);
1466
1467                 g_array_append_vals(*out_param1, &meta_data,
1468                                         sizeof(media_metadata_t));
1469                 break;
1470         }
1471         case BT_RFCOMM_CLIENT_CONNECT: {
1472 #ifdef TIZEN_FEATURE_BT_RFCOMM_DIRECT
1473                 result = BLUETOOTH_ERROR_NONE;
1474 #else
1475                 bluetooth_device_address_t address = { {0} };
1476                 char *input_string;
1477                 int connect_type;
1478
1479                 __bt_service_get_parameters(in_param1,
1480                                 &address, sizeof(bluetooth_device_address_t));
1481
1482                 input_string = &g_array_index(in_param2, char, 0);
1483
1484                 connect_type = g_array_index(in_param3, int, 0);
1485
1486                 if (connect_type == BT_RFCOMM_UUID) {
1487                         result = _bt_rfcomm_connect_using_uuid(request_id,
1488                                                         &address, input_string);
1489                 } else {
1490                         result = _bt_rfcomm_connect_using_channel(request_id,
1491                                                         &address, input_string);
1492                 }
1493
1494                 if (result != BLUETOOTH_ERROR_NONE) {
1495                         g_array_append_vals(*out_param1, &address,
1496                                         sizeof(bluetooth_device_address_t));
1497                 }
1498 #endif
1499                 break;
1500         }
1501         case BT_RFCOMM_CLIENT_CANCEL_CONNECT:
1502                 result = _bt_rfcomm_cancel_connect();
1503                 break;
1504         case BT_RFCOMM_CLIENT_IS_CONNECTED: {
1505                 gboolean connected = FALSE;
1506                 result = _bt_rfcomm_is_connected(&connected);
1507
1508                 g_array_append_vals(*out_param1, &connected, sizeof(gboolean));
1509                 break;
1510         }
1511         case BT_RFCOMM_SOCKET_DISCONNECT: {
1512 #ifdef TIZEN_FEATURE_BT_RFCOMM_DIRECT
1513                 result = BLUETOOTH_ERROR_NONE;
1514 #else
1515                 int socket_fd;
1516
1517                 socket_fd = g_array_index(in_param1, int, 0);
1518
1519                 result = _bt_rfcomm_disconnect(socket_fd);
1520 #endif
1521                 break;
1522         }
1523         case BT_RFCOMM_SOCKET_WRITE: {
1524 #ifdef TIZEN_FEATURE_BT_RFCOMM_DIRECT
1525                 result = BLUETOOTH_ERROR_NONE;
1526 #else
1527                 int socket_fd;
1528                 int length;
1529                 char *buffer;
1530
1531                 socket_fd = g_array_index(in_param1, int, 0);
1532                 length = g_array_index(in_param2, int, 0);
1533                 buffer = &g_array_index(in_param3, char, 0);
1534
1535                 result = _bt_rfcomm_write(socket_fd, buffer, length);
1536 #endif
1537                 break;
1538         }
1539         case BT_RFCOMM_CREATE_SOCKET: {
1540 #ifdef TIZEN_FEATURE_BT_RFCOMM_DIRECT
1541                 result = BLUETOOTH_ERROR_NONE;
1542 #else
1543                 char *sender;
1544                 char *uuid;
1545                 int socket_fd = -1;
1546
1547                 sender = (char *)g_dbus_method_invocation_get_sender(context);
1548                 uuid = &g_array_index(in_param1, char, 0);
1549
1550                 result = _bt_rfcomm_create_socket(sender, uuid);
1551
1552                 if (result > 0) {
1553                         socket_fd = result;
1554                         result = BLUETOOTH_ERROR_NONE;
1555                 }
1556
1557                 g_array_append_vals(*out_param1, &socket_fd, sizeof(int));
1558
1559                 g_free(sender);
1560 #endif
1561                 break;
1562         }
1563         case BT_RFCOMM_REMOVE_SOCKET: {
1564 #ifdef TIZEN_FEATURE_BT_RFCOMM_DIRECT
1565                 result = BLUETOOTH_ERROR_NONE;
1566 #else
1567                 int socket_fd;
1568
1569                 socket_fd = g_array_index(in_param1, int, 0);
1570
1571                 result = _bt_rfcomm_remove_socket(socket_fd);
1572 #endif
1573                 break;
1574         }
1575         case BT_RFCOMM_LISTEN: {
1576                 int socket_fd;
1577                 int pending;
1578                 gboolean is_native;
1579
1580                 __bt_service_get_parameters(in_param1, &socket_fd,
1581                                 sizeof(int));
1582                 __bt_service_get_parameters(in_param2, &pending,
1583                                 sizeof(int));
1584                 __bt_service_get_parameters(in_param3, &is_native,
1585                                 sizeof(gboolean));
1586
1587                 result = _bt_rfcomm_listen(socket_fd, pending, is_native);
1588                 break;
1589         }
1590         case BT_RFCOMM_IS_UUID_AVAILABLE: {
1591                 gboolean available = TRUE;
1592                 char *uuid;
1593
1594                 uuid = (char *)g_variant_get_data(in_param1);
1595
1596                 result = _bt_rfcomm_is_uuid_available(uuid, &available);
1597
1598                 g_array_append_vals(*out_param1, &available, sizeof(gboolean));
1599                 break;
1600         }
1601         case BT_RFCOMM_ACCEPT_CONNECTION: {
1602                 int socket_fd;
1603
1604                 __bt_service_get_parameters(in_param1, &socket_fd, sizeof(int));
1605                 BT_DBG(" socket fd %d", socket_fd);
1606                 result = _bt_rfcomm_accept_connection();
1607                 break;
1608         }
1609         case BT_RFCOMM_REJECT_CONNECTION: {
1610                 int socket_fd;
1611
1612                 __bt_service_get_parameters(in_param1, &socket_fd, sizeof(int));
1613                 BT_DBG(" socket fd %d", socket_fd);
1614                 result = _bt_rfcomm_reject_connection();
1615                 break;
1616         }
1617         case BT_RFCOMM_CREATE_SOCKET_EX: {
1618                 result = BLUETOOTH_ERROR_NONE;
1619                 break;
1620         }
1621         case BT_RFCOMM_REMOVE_SOCKET_EX: {
1622                 result = BLUETOOTH_ERROR_NONE;
1623                 break;
1624         }
1625         case BT_CONNECT_LE: {
1626                 bluetooth_device_address_t address = { {0} };
1627                 gboolean auto_connect;
1628
1629                 __bt_service_get_parameters(in_param1,
1630                                 &address, sizeof(bluetooth_device_address_t));
1631                 __bt_service_get_parameters(in_param2,
1632                                 &auto_connect, sizeof(gboolean));
1633
1634                 result = _bt_connect_le_device(request_id, &address,
1635                                 auto_connect);
1636                 if (result != BLUETOOTH_ERROR_NONE) {
1637                         g_array_append_vals(*out_param1, &address,
1638                                         sizeof(bluetooth_device_address_t));
1639                 }
1640
1641                 break;
1642         }
1643         case BT_DISCONNECT_LE: {
1644                 bluetooth_device_address_t address = { {0} };
1645
1646                 __bt_service_get_parameters(in_param1, &address,
1647                                 sizeof(bluetooth_device_address_t));
1648
1649                 result = _bt_disconnect_le_device(request_id, &address);
1650                 if (result != BLUETOOTH_ERROR_NONE) {
1651                         g_array_append_vals(*out_param1, &address,
1652                                         sizeof(bluetooth_device_address_t));
1653                 }
1654
1655                 break;
1656         }
1657         case BT_SET_LE_PRIVACY: {
1658                 gboolean set_privacy;
1659
1660                 __bt_service_get_parameters(in_param1, &set_privacy,
1661                                 sizeof(gboolean));
1662
1663                 result = _bt_set_le_privacy(set_privacy);
1664
1665                 break;
1666         }
1667         case BT_REQ_ATT_MTU: {
1668                 bluetooth_device_address_t address = { {0} };
1669                 unsigned int mtu;
1670
1671                 __bt_service_get_parameters(in_param1,
1672                                 &address, sizeof(bluetooth_device_address_t));
1673                 __bt_service_get_parameters(in_param2,
1674                                 &mtu, sizeof(unsigned int));
1675
1676                 result = _bt_request_att_mtu(request_id, &address, mtu);
1677                 if (result != BLUETOOTH_ERROR_NONE) {
1678                         g_array_append_vals(*out_param1, &address,
1679                                         sizeof(bluetooth_device_info_t));
1680                 }
1681                 break;
1682         }
1683         case BT_GET_ATT_MTU: {
1684                 bluetooth_device_address_t address = { {0} };
1685                 unsigned int mtu = 0;
1686
1687                 __bt_service_get_parameters(in_param1,
1688                                 &address, sizeof(bluetooth_device_address_t));
1689
1690                 result = _bt_get_att_mtu(&address, &mtu);
1691                 BT_DBG("MTU: %d", mtu);
1692                 if (result == BLUETOOTH_ERROR_NONE) {
1693                         g_array_append_vals(*out_param1, &mtu,
1694                                                 sizeof(unsigned int));
1695                 }
1696                 break;
1697         }
1698         case BT_GET_DEVICE_IDA: {
1699                 bluetooth_device_address_t address = { {0} };
1700                 bluetooth_device_address_t id_addr = { {0} };
1701
1702                 __bt_service_get_parameters(in_param1,
1703                                 &address, sizeof(bluetooth_device_address_t));
1704
1705                 result = _bt_get_device_ida(&address, &id_addr);
1706
1707                 if (result == BLUETOOTH_ERROR_NONE) {
1708                         g_array_append_vals(*out_param1, &id_addr,
1709                                         sizeof(bluetooth_device_address_t));
1710                 }
1711                 break;
1712         }
1713         case BT_SET_LE_STATIC_RANDOM_ADDRESS: {
1714                 gboolean is_enable;
1715
1716                 __bt_service_get_parameters(in_param1, &is_enable,
1717                                 sizeof(gboolean));
1718
1719                 result = _bt_set_le_static_random_address(is_enable);
1720
1721                 break;
1722         }
1723         case BT_HDP_CONNECT:
1724         case BT_HDP_DISCONNECT:
1725         case BT_HDP_SEND_DATA:
1726
1727         case BT_GATT_GET_PRIMARY_SERVICES:
1728         case BT_GATT_DISCOVER_CHARACTERISTICS:
1729         case BT_GATT_SET_PROPERTY_REQUEST:
1730         case BT_GATT_READ_CHARACTERISTIC:
1731         case BT_GATT_DISCOVER_CHARACTERISTICS_DESCRIPTOR:
1732
1733         case BT_HID_DEVICE_ACTIVATE:
1734         case BT_HID_DEVICE_DEACTIVATE:
1735         case BT_HID_DEVICE_CONNECT:
1736         case BT_HID_DEVICE_DISCONNECT:
1737         case BT_HID_DEVICE_SEND_MOUSE_EVENT:
1738         case BT_HID_DEVICE_SEND_KEY_EVENT:
1739         case BT_HID_DEVICE_SEND_REPLY_TO_REPORT:
1740                 /* Just call to check the privilege */
1741                 break;
1742         case BT_LE_IPSP_INIT:
1743                 result = _bt_initialize_ipsp();
1744                 break;
1745         case BT_LE_IPSP_DEINIT:
1746                 result = _bt_deinitialize_ipsp();
1747                 break;
1748         case BT_LE_IPSP_CONNECT: {
1749                 bluetooth_device_address_t address = { {0} };
1750                 __bt_service_get_parameters(in_param1, &address,
1751                                 sizeof(bluetooth_device_address_t));
1752
1753                 result = _bt_connect_le_ipsp_device(&address);
1754                 break;
1755         }
1756         case BT_LE_IPSP_DISCONNECT: {
1757                 bluetooth_device_address_t address = { {0} };
1758
1759                 __bt_service_get_parameters(in_param1, &address,
1760                                 sizeof(bluetooth_device_address_t));
1761
1762                 result = _bt_disconnect_le_ipsp_device(&address);
1763                 break;
1764         }
1765         case BT_LE_READ_MAXIMUM_DATA_LENGTH: {
1766                 bluetooth_le_read_maximum_data_length_t max_le_datalength = {0};
1767
1768                 result = _bt_le_read_maximum_data_length(&max_le_datalength);
1769
1770                 g_array_append_vals(*out_param1, &max_le_datalength,
1771                         sizeof(bluetooth_le_read_maximum_data_length_t));
1772                 break;
1773         }
1774         case BT_LE_WRITE_HOST_SUGGESTED_DATA_LENGTH: {
1775                 unsigned int def_tx_Octects = 0;
1776                 unsigned int def_tx_Time = 0;
1777
1778                 __bt_service_get_parameters(in_param1,
1779                                 &def_tx_Octects, sizeof(int));
1780                 __bt_service_get_parameters(in_param2,
1781                                 &def_tx_Time, sizeof(int));
1782
1783                 result = _bt_le_write_host_suggested_default_data_length(
1784                                                 def_tx_Octects, def_tx_Time);
1785                 break;
1786         }
1787         case BT_LE_READ_HOST_SUGGESTED_DATA_LENGTH: {
1788                 bluetooth_le_read_host_suggested_data_length_t def_data_length = {0};
1789
1790                 result = _bt_le_read_host_suggested_default_data_length(&def_data_length);
1791
1792                 g_array_append_vals(*out_param1, &def_data_length,
1793                                 sizeof(bluetooth_le_read_host_suggested_data_length_t));
1794
1795                 break;
1796         }
1797         case BT_LE_SET_DATA_LENGTH: {
1798                 int max_tx_Octets = 0;
1799                 int max_tx_Time = 0;
1800                 bluetooth_device_address_t address = { {0} };
1801
1802                 __bt_service_get_parameters(in_param1, &address,
1803                                 sizeof(bluetooth_device_address_t));
1804                 __bt_service_get_parameters(in_param2,
1805                                 &max_tx_Octets, sizeof(int));
1806                 __bt_service_get_parameters(in_param3,
1807                                 &max_tx_Time, sizeof(int));
1808
1809                 result = _bt_le_set_data_length(&address, max_tx_Octets, max_tx_Time);
1810                 break;
1811         }
1812         case BT_DPM_SET_ALLOW_BT_MODE: {
1813                 dpm_bt_allow_t value = DPM_BT_ERROR;
1814
1815                 __bt_service_get_parameters(in_param1, &value,
1816                                 sizeof(int));
1817
1818                 result = _bt_dpm_set_allow_bluetooth_mode(value);
1819                 break;
1820         }
1821         case BT_DPM_GET_ALLOW_BT_MODE: {
1822                 int value = DPM_BT_ERROR;
1823
1824                 result = _bt_dpm_get_allow_bluetooth_mode(&value);
1825                 g_array_append_vals(*out_param1, &value, sizeof(int));
1826                 break;
1827         }
1828         case BT_DPM_SET_DEVICE_RESTRITION: {
1829                 dpm_status_t value = DPM_STATUS_ERROR;
1830
1831                 __bt_service_get_parameters(in_param1, &value,
1832                                 sizeof(int));
1833
1834                 result = _bt_dpm_activate_bluetooth_device_restriction(value);
1835                 break;
1836         }
1837         case BT_DPM_GET_DEVICE_RESTRITION: {
1838                 int value = DPM_STATUS_ERROR;
1839
1840                 result = _bt_dpm_is_bluetooth_device_restriction_active(&value);
1841                 g_array_append_vals(*out_param1, &value, sizeof(int));
1842                 break;
1843         }
1844         case BT_DPM_SET_UUID_RESTRITION: {
1845                 dpm_status_t value = DPM_STATUS_ERROR;
1846
1847                 __bt_service_get_parameters(in_param1, &value,
1848                                 sizeof(int));
1849
1850                 result = _bt_dpm_activate_bluetoooth_uuid_restriction(value);
1851                 break;
1852         }
1853         case BT_DPM_GET_UUID_RESTRITION: {
1854                 int value = DPM_STATUS_ERROR;
1855
1856                 result = _bt_dpm_is_bluetooth_uuid_restriction_active(&value);
1857                 g_array_append_vals(*out_param1, &value, sizeof(int));
1858                 break;
1859         }
1860         case BT_DPM_ADD_DEVICES_BLACKLIST: {
1861                 bluetooth_device_address_t address = { {0} };
1862
1863                 __bt_service_get_parameters(in_param1, &address,
1864                         sizeof(bluetooth_device_address_t));
1865
1866                 result = _bt_dpm_add_bluetooth_devices_to_blacklist(&address);
1867                 break;
1868         }
1869         case BT_DPM_ADD_DEVICES_WHITELIST: {
1870                 bluetooth_device_address_t address = { {0} };
1871
1872                 __bt_service_get_parameters(in_param1, &address,
1873                         sizeof(bluetooth_device_address_t));
1874
1875                 result = _bt_dpm_add_bluetooth_devices_to_whitelist(&address);
1876                 break;
1877         }
1878         case BT_DPM_ADD_UUIDS_BLACKLIST: {
1879                 const char *uuid = NULL;
1880
1881                 uuid = g_variant_get_data(in_param1);
1882
1883                 result = _bt_dpm_add_bluetooth_uuids_to_blacklist(uuid);
1884                 break;
1885         }
1886         case BT_DPM_ADD_UUIDS_WHITELIST: {
1887                 const char *uuid = NULL;
1888
1889                 uuid = g_variant_get_data(in_param1);
1890
1891                 result = _bt_dpm_add_bluetooth_uuids_to_whitelist(uuid);
1892                 break;
1893         }
1894         case BT_DPM_CLEAR_DEVICES_BLACKLIST: {
1895                 result = _bt_dpm_clear_bluetooth_devices_from_blacklist();
1896                 break;
1897         }
1898         case BT_DPM_CLEAR_DEVICES_WHITELIST: {
1899                 result = _bt_dpm_clear_bluetooth_devices_from_whitelist();
1900                 break;
1901         }
1902         case BT_DPM_CLEAR_UUIDS_BLACKLIST: {
1903                 result = _bt_dpm_clear_bluetooth_uuids_from_blacklist();
1904                 break;
1905         }
1906         case BT_DPM_CLEAR_UUIDS_WHITELIST: {
1907                 result = _bt_dpm_clear_bluetooth_uuids_from_whitelist();
1908                 break;
1909         }
1910         case BT_DPM_REMOVE_DEVICE_BLACKLIST: {
1911                 bluetooth_device_address_t address = { {0} };
1912
1913                 __bt_service_get_parameters(in_param1, &address,
1914                         sizeof(bluetooth_device_address_t));
1915
1916                 result = _bt_dpm_remove_bluetooth_devices_from_blacklist(&address);
1917                 break;
1918         }
1919         case BT_DPM_REMOVE_DEVICE_WHITELIST: {
1920                 bluetooth_device_address_t address = { {0} };
1921
1922                 __bt_service_get_parameters(in_param1, &address,
1923                         sizeof(bluetooth_device_address_t));
1924
1925                 result = _bt_dpm_remove_bluetooth_devices_from_whitelist(&address);
1926                 break;
1927         }
1928         case BT_DPM_REMOVE_UUID_BLACKLIST: {
1929                 const char *uuid = NULL;
1930
1931                 uuid = g_variant_get_data(in_param1);
1932
1933                 result = _bt_dpm_remove_bluetooth_uuids_from_blacklist(uuid);
1934                 break;
1935         }
1936         case BT_DPM_REMOVE_UUID_WHITELIST: {
1937                 const char *uuid = NULL;
1938
1939                 uuid = g_variant_get_data(in_param1);
1940
1941                 result = _bt_dpm_remove_bluetooth_uuids_from_whitelist(uuid);
1942
1943                 break;
1944         }
1945         case BT_DPM_GET_DEVICES_BLACKLIST: {
1946                 result = _bt_dpm_get_bluetooth_devices_from_blacklist(out_param1);
1947                 break;
1948         }
1949         case BT_DPM_GET_DEVICES_WHITELIST: {
1950                 result = _bt_dpm_get_bluetooth_devices_from_whitelist(out_param1);
1951                 break;
1952         }
1953         case BT_DPM_GET_UUIDS_BLACKLIST: {
1954                 result = _bt_dpm_get_bluetooth_uuids_from_blacklist(out_param1);
1955                 break;
1956         }
1957         case BT_DPM_GET_UUIDS_WHITELIST: {
1958                 result = _bt_dpm_get_bluetooth_uuids_from_whitelist(out_param1);
1959                 break;
1960         }
1961         case BT_DPM_SET_ALLOW_OUTGOING_CALL: {
1962                 dpm_status_t value = DPM_STATUS_ERROR;
1963
1964                 __bt_service_get_parameters(in_param1, &value,
1965                                 sizeof(int));
1966
1967                 result = _bt_dpm_set_allow_bluetooth_outgoing_call(value);
1968
1969                 break;
1970         }
1971         case BT_DPM_GET_ALLOW_OUTGOING_CALL: {
1972                 int value = DPM_STATUS_ERROR;
1973
1974                 result = _bt_dpm_get_allow_bluetooth_outgoing_call(&value);
1975                 g_array_append_vals(*out_param1, &value, sizeof(int));
1976                 break;
1977         }
1978         case BT_DPM_SET_PAIRING_STATE: {
1979                 dpm_status_t value = DPM_STATUS_ERROR;
1980
1981                 __bt_service_get_parameters(in_param1, &value,
1982                                 sizeof(int));
1983
1984                 result = _bt_dpm_set_bluetooth_pairing_state(value);
1985
1986                 break;
1987         }
1988         case BT_DPM_GET_PAIRING_STATE: {
1989                 int value = DPM_STATUS_ERROR;
1990
1991                 result = _bt_dpm_get_bluetooth_pairing_state(&value);
1992                 g_array_append_vals(*out_param1, &value, sizeof(int));
1993                 break;
1994         }
1995         case BT_DPM_SET_PROFILE_STATE: {
1996                 int value = DPM_STATUS_ERROR;
1997                 int profile = DPM_PROFILE_NONE;
1998
1999                 __bt_service_get_parameters(in_param1, &profile,
2000                                 sizeof(int));
2001                 __bt_service_get_parameters(in_param2, &value,
2002                                 sizeof(int));
2003
2004                 result = _bt_dpm_set_bluetooth_profile_state(profile, value);
2005
2006                 break;
2007         }
2008         case BT_DPM_GET_PROFILE_STATE: {
2009                 int value = DPM_STATUS_ERROR;
2010                 int profile = DPM_PROFILE_NONE;
2011
2012                 __bt_service_get_parameters(in_param1, &profile,
2013                                 sizeof(int));
2014
2015                 result = _bt_dpm_get_bluetooth_profile_state(profile, &value);
2016                 g_array_append_vals(*out_param1, &value, sizeof(int));
2017                 break;
2018         }
2019         case BT_DPM_SET_DESKROP_CONNECTIVITY_STATE: {
2020                 int value = DPM_BT_ERROR;
2021
2022                 __bt_service_get_parameters(in_param1, &value,
2023                                 sizeof(int));
2024
2025                 result = _bt_dpm_set_bluetooth_desktop_connectivity_state(value);
2026
2027                 break;
2028         }
2029         case BT_DPM_GET_DESKROP_CONNECTIVITY_STATE: {
2030                 int value = DPM_STATUS_ERROR;
2031
2032                 result = _bt_dpm_get_bluetooth_desktop_connectivity_state(&value);
2033                 g_array_append_vals(*out_param1, &value, sizeof(int));
2034                 break;
2035         }
2036         case BT_DPM_SET_DISCOVERABLE_STATE: {
2037                 int value = DPM_STATUS_ERROR;
2038
2039                 __bt_service_get_parameters(in_param1, &value,
2040                                 sizeof(int));
2041
2042                 result = _bt_dpm_set_bluetooth_discoverable_state(value);
2043
2044                 break;
2045         }
2046         case BT_DPM_GET_DISCOVERABLE_STATE: {
2047                 int value = DPM_STATUS_ERROR;
2048
2049                 result = _bt_dpm_get_bluetooth_discoverable_state(&value);
2050                 g_array_append_vals(*out_param1, &value, sizeof(int));
2051                 break;
2052         }
2053         case BT_DPM_SET_LIMITED_DISCOVERABLE_STATE: {
2054                 int value = DPM_STATUS_ERROR;
2055
2056                 __bt_service_get_parameters(in_param1, &value,
2057                                 sizeof(int));
2058
2059                 result = _bt_dpm_set_bluetooth_limited_discoverable_state(value);
2060
2061                 break;
2062         }
2063         case BT_DPM_GET_LIMITED_DISCOVERABLE_STATE: {
2064                 int value = DPM_STATUS_ERROR;
2065
2066                 result = _bt_dpm_get_bluetooth_limited_discoverable_state(&value);
2067                 g_array_append_vals(*out_param1, &value, sizeof(int));
2068                 break;
2069         }
2070         case BT_DPM_SET_DATA_TRANSFER_STATE: {
2071                 int value = DPM_STATUS_ERROR;
2072
2073                 __bt_service_get_parameters(in_param1, &value,
2074                                 sizeof(int));
2075
2076                 result = _bt_dpm_set_bluetooth_data_transfer_state(value);
2077
2078                 break;
2079         }
2080         case BT_DPM_GET_DATA_TRANSFER_STATE: {
2081                 int value = DPM_STATUS_ERROR;
2082
2083                 result = _bt_dpm_get_allow_bluetooth_data_transfer_state(&value);
2084                 g_array_append_vals(*out_param1, &value, sizeof(int));
2085                 break;
2086         }
2087         case BT_PXP_MONITOR_SET_PROPERTY: {
2088                 bluetooth_device_address_t address = { {0} };
2089                 unsigned int property = 0;
2090                 unsigned int value = 0;
2091
2092                 __bt_service_get_parameters(in_param1,
2093                                 &address, sizeof(bluetooth_device_address_t));
2094                 __bt_service_get_parameters(in_param2,
2095                                 &property, sizeof(int));
2096                 __bt_service_get_parameters(in_param3,
2097                                 &value, sizeof(int));
2098
2099                 result = _bt_proximity_monitor_set_property(&address, property, value);
2100                 break;
2101         }
2102         case BT_PXP_MONITOR_GET_PROPERTY: {
2103                 bluetooth_device_address_t address = { {0} };
2104                 unsigned int property = 0;
2105                 int value = 0;
2106
2107                 __bt_service_get_parameters(in_param1,
2108                                 &address, sizeof(bluetooth_device_address_t));
2109                 __bt_service_get_parameters(in_param2,
2110                                 &property, sizeof(unsigned int));
2111
2112                 result = _bt_proximity_monitor_get_property(&address, property, &value);
2113                 if (result == BLUETOOTH_ERROR_NONE) {
2114                         g_array_append_vals(*out_param1, &value,
2115                                                 sizeof(int));
2116                 }
2117                 break;
2118         }
2119         case BT_PXP_MONITOR_GET_SUPPORTED_SERIVCES: {
2120                 bluetooth_device_address_t address = { {0} };
2121                 unsigned int property = 0;
2122
2123                 __bt_service_get_parameters(in_param1,
2124                                 &address, sizeof(bluetooth_device_address_t));
2125
2126                 result = _bt_proximity_monitor_get_supported_services(&address, &property);
2127                 if (result == BLUETOOTH_ERROR_NONE) {
2128                         g_array_append_vals(*out_param1, &property,
2129                                                 sizeof(int));
2130                 }
2131                 break;
2132         }
2133         case BT_PXP_REPORTER_REGISTER: {
2134                 char *sender = NULL;
2135                 sender = (char *)g_dbus_method_invocation_get_sender(context);
2136                 result = _bt_proximity_reporter_register(sender);
2137                 break;
2138         }
2139         case BT_PXP_REPORTER_UNREGISTER: {
2140                 char *sender = NULL;
2141                 sender = (char *)g_dbus_method_invocation_get_sender(context);
2142                 result = _bt_proximity_reporter_unregister(sender);
2143                 break;
2144         }
2145         case BT_PXP_REPORTER_GET_PROPERTY: {
2146                 bluetooth_device_address_t address = { {0} };
2147                 unsigned int property = 0;
2148                 int value = 0;
2149
2150                 __bt_service_get_parameters(in_param1,
2151                                 &address, sizeof(bluetooth_device_address_t));
2152                 __bt_service_get_parameters(in_param2,
2153                                 &property, sizeof(unsigned int));
2154
2155                 result = _bt_proximity_reporter_get_property(&address, property, &value);
2156                 if (result == BLUETOOTH_ERROR_NONE) {
2157                         g_array_append_vals(*out_param1, &value,
2158                                                 sizeof(int));
2159                 }
2160                 break;
2161         }
2162         case BT_TDS_PROVIDER_REGISTER: {
2163                 char *sender = NULL;
2164
2165                 sender = (char *)g_dbus_method_invocation_get_sender(context);
2166                 result = _bt_tds_provider_register(sender);
2167
2168                 break;
2169         }
2170         case BT_TDS_PROVIDER_UNREGISTER: {
2171                 char *sender = NULL;
2172
2173                 sender = (char *)g_dbus_method_invocation_get_sender(context);
2174                 result = _bt_tds_provider_unregister(sender);
2175
2176                 break;
2177         }
2178         case BT_TDS_PROVIDER_SET_MANUF_DATA: {
2179                 char *sender = NULL;
2180                 unsigned int length = 0;
2181                 bluetooth_advertising_data_t manuf_data;
2182
2183                 __bt_service_get_parameters(in_param1,
2184                                 &length, sizeof(unsigned int));
2185                 __bt_service_get_parameters(in_param2,
2186                                 &manuf_data, sizeof(bluetooth_advertising_data_t));
2187                 sender = (char *)g_dbus_method_invocation_get_sender(context);
2188
2189                 result = _bt_tds_provider_set_manuf_data(sender, manuf_data.data, length);
2190                 break;
2191         }
2192         case BT_TDS_PROVIDER_CREATE: {
2193                 char *sender = NULL;
2194                 unsigned int tds_handle = 0;
2195                 int transport;
2196
2197                 __bt_service_get_parameters(in_param1,
2198                                 &tds_handle, sizeof(unsigned int));
2199                 __bt_service_get_parameters(in_param2,
2200                                 &transport, sizeof(int));
2201                 sender = (char *)g_dbus_method_invocation_get_sender(context);
2202                 result = _bt_tds_provider_transport_create(sender, transport, tds_handle);
2203
2204                 break;
2205         }
2206         case BT_TDS_PROVIDER_DESTROY: {
2207                 char *sender = NULL;
2208                 unsigned int tds_handle = 0;
2209
2210                 __bt_service_get_parameters(in_param1,
2211                                 &tds_handle, sizeof(unsigned int));
2212                 sender = (char *)g_dbus_method_invocation_get_sender(context);
2213                 result = _bt_tds_provider_transport_remove(sender, tds_handle);
2214
2215                 break;
2216         }
2217         case BT_TDS_PROVIDER_SET_TRANSPORT_DATA: {
2218                 char *sender = NULL;
2219                 unsigned int tds_handle = 0;
2220                 int transport_state = 0;
2221                 bluetooth_tds_data_t tds_data;
2222
2223                 __bt_service_get_parameters(in_param1,
2224                                 &tds_handle, sizeof(unsigned int));
2225                 __bt_service_get_parameters(in_param2,
2226                                 &transport_state, sizeof(int));
2227                 __bt_service_get_parameters(in_param3,
2228                                 &tds_data, sizeof(bluetooth_tds_data_t));
2229                 sender = (char *)g_dbus_method_invocation_get_sender(context);
2230
2231                 result = _bt_tds_provider_set_transport_data(sender, tds_handle,
2232                                 transport_state, tds_data.data, tds_data.length);
2233                 break;
2234         }
2235         case BT_TDS_SEND_ACTIVATION_RESPONSE: {
2236                 bluetooth_device_address_t address = { {0} };
2237                 bluetooth_tds_data_t tds_data;
2238                 char *sender = NULL;
2239                 unsigned int tds_handle = 0;
2240                 int response;
2241
2242                 __bt_service_get_parameters(in_param1,
2243                                 &tds_handle, sizeof(unsigned int));
2244                 __bt_service_get_parameters(in_param2,
2245                                 &response, sizeof(int));
2246                 __bt_service_get_parameters(in_param3, &address,
2247                         sizeof(bluetooth_device_address_t));
2248                 __bt_service_get_parameters(in_param4,
2249                                 &tds_data, sizeof(bluetooth_tds_data_t));
2250                 sender = (char *)g_dbus_method_invocation_get_sender(context);
2251
2252                 result = _bt_tds_provider_send_activation_response(sender, tds_handle,
2253                                 &address, response, tds_data.data, tds_data.length);
2254                 break;
2255         }
2256         case BT_TDS_READ_TRANSPORT_DATA: {
2257                 char *handle;
2258                 char *data = NULL;
2259                 guint data_len = 0;
2260
2261                 char *sender = NULL;
2262                 sender = (char *)g_dbus_method_invocation_get_sender(context);
2263
2264                 bluetooth_device_address_t address = { {0} };
2265                 __bt_service_get_parameters(in_param2,
2266                         &address, sizeof(bluetooth_device_address_t));
2267
2268                 data_len = g_variant_get_size(in_param1);
2269                 data = (char *)g_variant_get_data(in_param1);
2270
2271                 handle = g_strndup(data, data_len);
2272                 BT_DBG("Read TDS Transport Block [%s]", handle);
2273
2274                 result = _bt_tds_read_transport_data(request_id, sender, &address, handle);
2275
2276                 if (result != BLUETOOTH_ERROR_NONE) {
2277                         BT_ERR("Reading TDS Transport data failed result [%d]", result);
2278                         g_array_append_vals(*out_param1, &address,
2279                                         sizeof(bluetooth_device_address_t));
2280                 }
2281                 if (handle)
2282                         g_free(handle);
2283                 break;
2284         }
2285         case BT_TDS_ENABLE_CONTROL_POINT: {
2286                 char *handle;
2287                 char *data = NULL;
2288                 guint data_len = 0;
2289                 bluetooth_device_address_t address = { {0} };
2290
2291                 char *sender = NULL;
2292                 sender = (char *)g_dbus_method_invocation_get_sender(context);
2293
2294                 data_len = g_variant_get_size(in_param1);
2295                 data = (char *)g_variant_get_data(in_param1);
2296                 __bt_service_get_parameters(in_param2,
2297                         &address, sizeof(bluetooth_device_address_t));
2298
2299                 handle = g_strndup(data, data_len);
2300                 BT_DBG("TDS Control point CCCD handle [%s]", handle);
2301
2302                 result = _bt_tds_enable_control_point(request_id, sender, &address, handle);
2303
2304                 if (result != BLUETOOTH_ERROR_NONE) {
2305                         BT_ERR("Enabling TDS CCCD failed result [%d]", result);
2306                         g_array_append_vals(*out_param1, &address,
2307                                         sizeof(bluetooth_device_address_t));
2308                 }
2309                 if (handle)
2310                         g_free(handle);
2311                 break;
2312         }
2313         case BT_TDS_ACTIVATE_CONTROL_POINT: {
2314                 char *handle;
2315                 char *data = NULL;
2316                 guint data_len = 0;
2317                 bluetooth_control_point_data_t tds_data;
2318                 char *sender = NULL;
2319
2320                 sender = (char *)g_dbus_method_invocation_get_sender(context);
2321
2322                 bluetooth_device_address_t address = { {0} };
2323
2324                 data_len = g_variant_get_size(in_param1);
2325                 data = (char *)g_variant_get_data(in_param1);
2326
2327                  __bt_service_get_parameters(in_param2,
2328                         &address, sizeof(bluetooth_device_address_t));
2329
2330                 __bt_service_get_parameters(in_param3,
2331                         &tds_data, sizeof(bluetooth_control_point_data_t));
2332
2333                 handle = g_strndup(data, data_len);
2334                 BT_DBG("TDS Activate Control point handle [%s]", handle);
2335
2336                 result = _bt_tds_activate_control_point(request_id, sender, &address, handle,
2337                                                                 tds_data.data, tds_data.length);
2338
2339                 if (result != BLUETOOTH_ERROR_NONE) {
2340                         BT_ERR("Activating TDS Control Point request failed result [%d]", result);
2341                         g_array_append_vals(*out_param1, &address,
2342                                         sizeof(bluetooth_device_address_t));
2343                 }
2344                 if (handle)
2345                         g_free(handle);
2346                 break;
2347         }
2348         default:
2349                 result = BLUETOOTH_ERROR_INTERNAL;
2350                 break;
2351         }
2352
2353         return result;
2354 }
2355
2356 int __bt_obexd_request(int function_name,
2357                 int request_type,
2358                 int request_id,
2359                 GDBusMethodInvocation *context,
2360                 GVariant *in_param1,
2361                 GVariant *in_param2,
2362                 GVariant *in_param3,
2363                 GVariant *in_param4,
2364                 GArray **out_param1)
2365 {
2366         BT_DBG("+");
2367
2368         int result;
2369
2370         BT_DBG("function_name : %x", function_name);
2371
2372         switch (function_name) {
2373         case BT_OPP_PUSH_FILES: {
2374                 BT_DBG("BT_OPP_PUSH_FILES");
2375                 int i;
2376                 bluetooth_device_address_t address = { {0} };
2377                 bt_file_path_t path;
2378                 char **file_path;
2379                 int file_count;
2380                 GArray *param2;
2381
2382                 __bt_service_get_parameters(in_param1, &address,
2383                                 sizeof(bluetooth_device_address_t));
2384                 __bt_service_get_parameters(in_param3, &file_count,
2385                                 sizeof(int));
2386
2387                 file_path = g_new0(char *, file_count + 1);
2388
2389                 param2 = g_array_new(TRUE, TRUE, sizeof(gchar));
2390                 __bt_fill_garray_from_variant(in_param2, param2);
2391
2392                 for (i = 0; i < file_count; i++) {
2393                         path = g_array_index(param2, bt_file_path_t, i);
2394                         file_path[i] = g_strdup(path.path);
2395                 }
2396                 BT_DBG("_bt_opp_client_push_files");
2397                 result = _bt_opp_client_push_files(request_id, context,
2398                                                 &address, file_path,
2399                                                 file_count);
2400
2401                 for (i = 0; i < file_count; i++)
2402                         g_free(file_path[i]);
2403
2404                 g_free(file_path);
2405                 g_array_free(param2, TRUE);
2406
2407                 break;
2408         }
2409         case BT_OPP_CANCEL_PUSH: {
2410                 result = _bt_opp_client_cancel_push();
2411
2412                 break;
2413         }
2414         case BT_OPP_IS_PUSHING_FILES: {
2415                 gboolean is_sending = FALSE;
2416
2417                 result = _bt_opp_client_is_sending(&is_sending);
2418
2419                 g_array_append_vals(*out_param1, &is_sending,
2420                                 sizeof(gboolean));
2421                 break;
2422         }
2423         case BT_OPP_GET_TRANSFER_PROGRESS: {
2424                 int direction;
2425                 int transfer_id;
2426                 guint8 progress = 0;
2427
2428                 __bt_service_get_parameters(in_param1, &direction,
2429                                 sizeof(int));
2430                 __bt_service_get_parameters(in_param2, &transfer_id,
2431                                 sizeof(int));
2432                 if (direction)
2433                         result = _bt_opp_get_client_progress(&progress);
2434                 else
2435                         result = _bt_opp_get_server_progress(transfer_id, &progress);
2436
2437                 g_array_append_vals(*out_param1, &progress,
2438                                 sizeof(guint8));
2439
2440                 break;
2441         }
2442
2443         case BT_MAP_CREATE_SESSION: {
2444                 BT_DBG("BT_MAP_CREATE_SESSION");
2445                 char *address = (char *)g_variant_get_data(in_param1);
2446                 char *session_id = NULL;
2447                 result = _bt_create_session_sync(address, &session_id);
2448                 if (result == BLUETOOTH_ERROR_NONE)
2449                         g_array_append_vals(*out_param1, session_id, strlen(session_id)+1);
2450                 break;
2451         }
2452
2453         case BT_MAP_DESTROY_SESSION: {
2454                 BT_DBG("BT_MAP_DESTROY_SESSION");
2455                 char* session_id = (char *)g_variant_get_data(in_param1);
2456                 result = _bt_destroy_session_sync(session_id);
2457                 if (result == BLUETOOTH_ERROR_NONE)
2458                         BT_DBG("successfully destroyed session");
2459                 break;
2460         }
2461
2462         case BT_MAP_SET_FOLDER: {
2463                 BT_DBG("BT_MAP_SET_FOLDER");
2464                 char *session_id = (char *)g_variant_get_data(in_param1);
2465                 char *name = (char *)g_variant_get_data(in_param2);
2466                 result = _bt_map_client_set_folder(session_id, name);
2467                 break;
2468         }
2469
2470         case BT_MAP_LIST_FOLDERS: {
2471                 BT_DBG("BT_MAP_LIST_FOLDERS");
2472
2473                 char* session_id = (char *)g_variant_get_data(in_param1);
2474                 char* filter_serialized = (char*)g_variant_get_data(in_param2);
2475
2476                 result = _bt_map_client_list_folders(request_id, context, session_id, filter_serialized);
2477                 if (result == BLUETOOTH_ERROR_NONE)
2478                         BT_DBG("_bt_map_client_list_folders succeed");
2479
2480                 break;
2481         }
2482
2483         case BT_MAP_LIST_FILTER_FIELDS: {
2484                 BT_DBG("BT_MAP_LIST_FILTER_FIELDS");
2485
2486                 char* session_id = (char *)g_variant_get_data(in_param1);
2487
2488                 result = _bt_map_client_list_filter_fields(request_id, context, session_id);
2489                 if (result == BLUETOOTH_ERROR_NONE)
2490                         BT_DBG("_bt_map_client_list_filter_fields succeed");
2491
2492                 break;
2493         }
2494
2495         case BT_MAP_LIST_MESSAGES: {
2496                 BT_DBG("BT_MAP_LIST_MESSAGES");
2497
2498                 char* session_id = (char*)g_variant_get_data(in_param1);
2499                 char* folder = (char*)g_variant_get_data(in_param2);
2500                 char* filter_serialized = (char*)g_variant_get_data(in_param3);
2501
2502                 result = _bt_map_client_list_messages(request_id, context, session_id, folder, filter_serialized);
2503                 if (result == BLUETOOTH_ERROR_NONE)
2504                         BT_DBG("_bt_map_client_list_messages succeed");
2505                 else
2506                         BT_DBG("_bt_map_client_list_messages failed");
2507
2508                 break;
2509         }
2510
2511         case BT_MAP_UPDATE_INBOX: {
2512                 BT_DBG("BT_MAP_UPDATE_INBOX");
2513                 char* session_id = (char *)g_variant_get_data(in_param1);
2514                 result = _bt_map_client_update_inbox(session_id);
2515                 break;
2516         }
2517
2518         case BT_MAP_PUSH_MESSAGE: {
2519                 BT_DBG("BT_MAP_PUSH_MESSAGE");
2520
2521                 char* session_id = (char *)g_variant_get_data(in_param1);
2522                 char* source_file = (char *)g_variant_get_data(in_param2);
2523                 char* folder = (char *)g_variant_get_data(in_param3);
2524                 char* args_serialized = (char *)g_variant_get_data(in_param4);
2525
2526                 result = _bt_map_client_push_message(
2527                                 request_id, context, session_id, source_file, folder, args_serialized);
2528                 if (result == BLUETOOTH_ERROR_NONE)
2529                         BT_DBG("_bt_map_client_push_message succeed");
2530                 else
2531                         BT_ERR("_bt_map_client_push_message failed");
2532
2533                 break;
2534         }
2535
2536         case BT_MAP_GET_MESSAGE: {
2537                 BT_DBG("BT_MAP_GET_MESSAGE");
2538                 // TODO session currently is not used, but should be valid
2539                 //char* session_id = (char *)g_variant_get_data(in_param1);
2540                 char* message_object = (char *)g_variant_get_data(in_param2);
2541                 char* target_file = (char *)g_variant_get_data(in_param3);
2542                 bool attachment = false;
2543                 __bt_service_get_parameters(in_param4, &attachment, sizeof(bool));
2544
2545                 result = _bt_map_client_get_message(request_id, context, message_object,
2546                                 target_file, attachment);
2547                 if (result == BLUETOOTH_ERROR_NONE)
2548                         BT_DBG("_bt_map_client_get_message succeed");
2549
2550                 break;
2551         }
2552
2553         case BT_OBEX_SERVER_ALLOCATE: {
2554                 int app_pid;
2555                 gboolean is_native;
2556                 char *path;
2557                 char *sender;
2558
2559                 sender = (char *)g_dbus_method_invocation_get_sender(context);
2560
2561                 path = (char *)g_variant_get_data(in_param1);
2562                 __bt_service_get_parameters(in_param2, &is_native,
2563                                 sizeof(gboolean));
2564                 __bt_service_get_parameters(in_param3, &app_pid,
2565                                 sizeof(int));
2566
2567                 result = _bt_obex_server_allocate(sender,
2568                                 path, app_pid, is_native);
2569
2570                 break;
2571         }
2572         case BT_OBEX_SERVER_DEALLOCATE: {
2573                 int app_pid;
2574                 gboolean is_native;
2575
2576                 __bt_service_get_parameters(in_param1, &is_native,
2577                                 sizeof(gboolean));
2578                 __bt_service_get_parameters(in_param2, &app_pid,
2579                                 sizeof(int));
2580
2581                 result = _bt_obex_server_deallocate(app_pid, is_native);
2582                 break;
2583         }
2584         case BT_OBEX_SERVER_IS_ACTIVATED: {
2585                 gboolean is_activated = FALSE;
2586
2587                 result = _bt_obex_server_is_activated(&is_activated);
2588
2589                 g_array_append_vals(*out_param1, &is_activated,
2590                                 sizeof(gboolean));
2591
2592                 break;
2593         }
2594         case BT_OBEX_SERVER_ACCEPT_CONNECTION: {
2595                 result = _bt_obex_server_accept_connection(request_id);
2596
2597                 break;
2598         }
2599         case BT_OBEX_SERVER_REJECT_CONNECTION: {
2600                 result = _bt_obex_server_reject_connection();
2601
2602                 break;
2603         }
2604         case BT_OBEX_SERVER_ACCEPT_FILE: {
2605                 char *file_name;
2606
2607                 file_name = (char *)g_variant_get_data(in_param1);
2608
2609                 result = _bt_obex_server_accept_authorize(file_name, TRUE);
2610
2611                 break;
2612         }
2613         case BT_OBEX_SERVER_REJECT_FILE: {
2614                 result = _bt_obex_server_reject_authorize();
2615
2616                 break;
2617         }
2618         case BT_OBEX_SERVER_SET_PATH: {
2619                 gboolean is_native;
2620                 char *destination_path;
2621
2622                 destination_path = (char *)g_variant_get_data(in_param1);
2623                 __bt_service_get_parameters(in_param2, &is_native,
2624                                 sizeof(gboolean));
2625
2626                 result = _bt_obex_server_set_destination_path(destination_path,
2627                                                         is_native);
2628
2629                 break;
2630         }
2631         case BT_OBEX_SERVER_SET_ROOT: {
2632                 char *root;
2633
2634                 root = (char *)g_variant_get_data(in_param1);
2635
2636                 result = _bt_obex_server_set_root(root);
2637
2638                 break;
2639         }
2640         case BT_OBEX_SERVER_CANCEL_TRANSFER: {
2641                 int transfer_id;
2642
2643                 __bt_service_get_parameters(in_param1, &transfer_id,
2644                                 sizeof(int));
2645
2646                 result = _bt_obex_server_cancel_transfer(transfer_id);
2647
2648                 break;
2649         }
2650         case BT_OBEX_SERVER_CANCEL_ALL_TRANSFERS: {
2651                 result = _bt_obex_server_cancel_all_transfers();
2652
2653                 break;
2654         }
2655         case BT_OBEX_SERVER_IS_RECEIVING: {
2656                 gboolean is_receiving = FALSE;
2657
2658                 result = _bt_obex_server_is_receiving(&is_receiving);
2659
2660                 g_array_append_vals(*out_param1, &is_receiving,
2661                                 sizeof(gboolean));
2662                 break;
2663         }
2664         case BT_PBAP_CONNECT: {
2665                 bluetooth_device_address_t address = { {0} };
2666
2667                 __bt_service_get_parameters(in_param1, &address,
2668                                 sizeof(bluetooth_device_address_t));
2669
2670                 result = _bt_pbap_connect(&address);
2671                 break;
2672         }
2673         case BT_PBAP_DISCONNECT: {
2674                 bluetooth_device_address_t address = { {0} };
2675
2676                 __bt_service_get_parameters(in_param1, &address,
2677                                 sizeof(bluetooth_device_address_t));
2678
2679                 result = _bt_pbap_disconnect(&address);
2680                 break;
2681         }
2682         case BT_PBAP_GET_PHONEBOOK_SIZE: {
2683                 bluetooth_device_address_t address = { {0} };
2684                 bt_pbap_folder_t folder = { 0, };
2685
2686                 __bt_service_get_parameters(in_param1, &address,
2687                                 sizeof(bluetooth_device_address_t));
2688                 __bt_service_get_parameters(in_param2, &folder,
2689                                 sizeof(bt_pbap_folder_t));
2690
2691                 result = _bt_pbap_get_phonebook_size(&address,
2692                                 folder.addressbook, folder.folder_type);
2693                 break;
2694         }
2695         case BT_PBAP_GET_PHONEBOOK: {
2696                 bluetooth_device_address_t address = { {0} };
2697                 bt_pbap_folder_t folder = { 0, };
2698                 bt_pbap_pull_parameters_t app_param = { 0, };
2699
2700                 __bt_service_get_parameters(in_param1, &address,
2701                                 sizeof(bluetooth_device_address_t));
2702                 __bt_service_get_parameters(in_param2, &folder,
2703                                 sizeof(bt_pbap_folder_t));
2704                 __bt_service_get_parameters(in_param3, &app_param,
2705                                 sizeof(bt_pbap_pull_parameters_t));
2706
2707                 result = _bt_pbap_get_phonebook(&address, folder.addressbook,
2708                                 folder.folder_type, &app_param);
2709                 break;
2710         }
2711         case BT_PBAP_GET_LIST: {
2712                 bluetooth_device_address_t address = { {0} };
2713                 bt_pbap_folder_t folder = { 0, };
2714                 bt_pbap_list_parameters_t app_param = { 0, };
2715
2716                 __bt_service_get_parameters(in_param1, &address,
2717                                 sizeof(bluetooth_device_address_t));
2718                 __bt_service_get_parameters(in_param2, &folder,
2719                                 sizeof(bt_pbap_folder_t));
2720                 __bt_service_get_parameters(in_param3, &app_param,
2721                                 sizeof(bt_pbap_list_parameters_t));
2722
2723                 result = _bt_pbap_get_list(&address, folder.addressbook,
2724                                 folder.folder_type, &app_param);
2725                 break;
2726         }
2727         case BT_PBAP_PULL_VCARD: {
2728                 bluetooth_device_address_t address = { {0} };
2729                 bt_pbap_folder_t folder = { 0, };
2730                 bt_pbap_pull_vcard_parameters_t app_param = { 0, };
2731
2732                 __bt_service_get_parameters(in_param1, &address,
2733                                 sizeof(bluetooth_device_address_t));
2734                 __bt_service_get_parameters(in_param2, &folder,
2735                                 sizeof(bt_pbap_folder_t));
2736                 __bt_service_get_parameters(in_param3, &app_param,
2737                                 sizeof(bt_pbap_pull_vcard_parameters_t));
2738
2739                 result = _bt_pbap_pull_vcard(&address, folder.addressbook,
2740                                 folder.folder_type, &app_param);
2741                 break;
2742         }
2743         case BT_PBAP_PHONEBOOK_SEARCH: {
2744                 bluetooth_device_address_t address = { {0} };
2745                 bt_pbap_folder_t folder = { 0, };
2746                 bt_pbap_search_parameters_t app_param = { 0, };
2747
2748                 __bt_service_get_parameters(in_param1, &address,
2749                                 sizeof(bluetooth_device_address_t));
2750                 __bt_service_get_parameters(in_param2, &folder,
2751                                 sizeof(bt_pbap_folder_t));
2752                 __bt_service_get_parameters(in_param3, &app_param,
2753                                 sizeof(bt_pbap_search_parameters_t));
2754
2755                 result = _bt_pbap_phonebook_search(&address, folder.addressbook,
2756                                 folder.folder_type, &app_param);
2757                 break;
2758         }
2759
2760         default:
2761                 BT_ERR("Unknown function!");
2762                 result = BLUETOOTH_ERROR_INTERNAL;
2763                 break;
2764         }
2765
2766         FN_END;
2767
2768         return result;
2769 }
2770
2771 int __bt_agent_request(int function_name,
2772                 int request_type,
2773                 int request_id,
2774                 GDBusMethodInvocation *context,
2775                 GVariant *in_param1,
2776                 GVariant *in_param2,
2777                 GVariant *in_param3,
2778                 GVariant *in_param4,
2779                 GArray **out_param1)
2780 {
2781         int result;
2782         switch (function_name) {
2783         case BT_SET_AUTHORIZATION: {
2784                 int type;
2785                 char *uuid;
2786                 char *path;
2787                 int fd;
2788
2789                 __bt_service_get_parameters(in_param1, &type, sizeof(int));
2790                 uuid = (char *)g_variant_get_data(in_param2);
2791                 path = (char *)g_variant_get_data(in_param3);
2792                 __bt_service_get_parameters(in_param4, &fd, sizeof(int));
2793
2794                 result = _bt_register_osp_server_in_agent(type, uuid, path, fd);
2795                 break;
2796         }
2797         case BT_UNSET_AUTHORIZATION: {
2798                 int type;
2799                 char *uuid;
2800
2801                 __bt_service_get_parameters(in_param1, &type, sizeof(int));
2802                 uuid = (char *)g_variant_get_data(in_param2);
2803
2804                 result = _bt_unregister_osp_server_in_agent(type, uuid);
2805                 break;
2806         }
2807         default:
2808                 BT_ERR("Unknown function!");
2809                 result = BLUETOOTH_ERROR_INTERNAL;
2810                 break;
2811         }
2812
2813         return result;
2814 }
2815
2816 int __bt_core_request(int function_name,
2817                 int request_type,
2818                 int request_id,
2819                 GDBusMethodInvocation *context,
2820                 GVariant *in_param1)
2821 {
2822         int result;
2823
2824         switch (function_name) {
2825         case BT_ENABLE_ADAPTER:
2826         {
2827                 bt_status_t status;
2828
2829                 status = _bt_adapter_get_status();
2830
2831                 if (status == BT_ACTIVATING) {
2832                         BT_DBG("Enabling in progress");
2833                         result = BLUETOOTH_ERROR_IN_PROGRESS;
2834                 } else if (status == BT_ACTIVATED) {
2835                         BT_DBG("Already enabled");
2836                         result = BLUETOOTH_ERROR_DEVICE_ALREADY_ENABLED;
2837                 } else {
2838                         _bt_adapter_set_status(BT_ACTIVATING);
2839                         _bt_adapter_start_enable_timer();
2840                         result = BLUETOOTH_ERROR_NONE;
2841                 }
2842
2843                 break;
2844         }
2845         case BT_DISABLE_ADAPTER:
2846         {
2847                 bt_status_t status;
2848
2849                 status = _bt_adapter_get_status();
2850                 if (status == BT_DEACTIVATING) {
2851                                 BT_DBG("Disabling in progress");
2852                                 result = BLUETOOTH_ERROR_IN_PROGRESS;
2853                 } else if (status == BT_DEACTIVATED) {
2854                                 BT_DBG("Already disabled");
2855                                 result = BLUETOOTH_ERROR_DEVICE_NOT_ENABLED;
2856                 } else {
2857                         _bt_adapter_set_status(BT_DEACTIVATING);
2858                         result = BLUETOOTH_ERROR_NONE;
2859                 }
2860
2861                 break;
2862         }
2863         case BT_ENABLE_ADAPTER_LE:
2864         {
2865                 bt_le_status_t le_status;
2866
2867                 le_status = _bt_adapter_get_le_status();
2868                 if (le_status == BT_LE_ACTIVATING) {
2869                         BT_DBG("Enabling in progress");
2870                         result = BLUETOOTH_ERROR_IN_PROGRESS;
2871                 } else if (le_status == BT_LE_ACTIVATED) {
2872                         BT_DBG("Already enabled");
2873                         result = BLUETOOTH_ERROR_DEVICE_ALREADY_ENABLED;
2874                 } else {
2875                         _bt_adapter_set_le_status(BT_LE_ACTIVATING);
2876                         _bt_adapter_start_le_enable_timer();
2877                         result = BLUETOOTH_ERROR_NONE;
2878                 }
2879
2880                 break;
2881         }
2882         case BT_DISABLE_ADAPTER_LE:
2883         {
2884                 bt_le_status_t le_status;
2885
2886                 le_status = _bt_adapter_get_le_status();
2887                 if (le_status == BT_LE_DEACTIVATING) {
2888                                 BT_DBG("Disabling in progress");
2889                                 result = BLUETOOTH_ERROR_IN_PROGRESS;
2890                 } else if (le_status == BT_LE_DEACTIVATED) {
2891                                 BT_DBG("Already disabled");
2892                                 result = BLUETOOTH_ERROR_DEVICE_NOT_ENABLED;
2893                 } else {
2894                         _bt_adapter_set_le_status(BT_LE_DEACTIVATING);
2895                         result = BLUETOOTH_ERROR_NONE;
2896                 }
2897
2898                 break;
2899         }
2900         default:
2901                 BT_ERR("Unknown function!");
2902                 result = BLUETOOTH_ERROR_INTERNAL;
2903                 break;
2904         }
2905
2906         return result;
2907 }
2908
2909 gboolean __bt_service_check_privilege(int function_name,
2910                                         int service_type,
2911                                         const char *unique_name)
2912 {
2913         int ret_val;
2914         gboolean result = TRUE;
2915         char *client_creds = NULL;
2916         char *user_creds = NULL;
2917         char *client_session = "";
2918         enum cynara_client_creds client_creds_method = CLIENT_METHOD_SMACK;
2919         enum cynara_user_creds user_creds_method = USER_METHOD_UID;
2920         char err_msg[256] = {0, };
2921
2922         retv_if(unique_name == NULL, FALSE);
2923
2924         BT_DBG("unique_name: %s", unique_name);
2925
2926         retv_if(bt_service_conn == NULL, FALSE);
2927
2928         ret_val = cynara_creds_get_default_client_method(&client_creds_method);
2929         if (ret_val != CYNARA_API_SUCCESS) {
2930                 cynara_strerror(ret_val, err_msg, sizeof(err_msg));
2931                 BT_ERR("Fail to get default client method: %s", err_msg);
2932                 return FALSE;
2933         }
2934
2935         ret_val = cynara_creds_get_default_user_method(&user_creds_method);
2936         if (ret_val != CYNARA_API_SUCCESS) {
2937                 cynara_strerror(ret_val, err_msg, sizeof(err_msg));
2938                 BT_ERR("Fail to get default user method: %s", err_msg);
2939                 return FALSE;
2940         }
2941
2942         ret_val = cynara_creds_gdbus_get_client(bt_service_conn, unique_name, client_creds_method, &client_creds);
2943         if (ret_val != CYNARA_API_SUCCESS) {
2944                 cynara_strerror(ret_val, err_msg, sizeof(err_msg));
2945                 BT_ERR("Fail to get client credential: %s", err_msg);
2946                 return FALSE;
2947         }
2948
2949         BT_DBG("client_creds: %s", client_creds);
2950
2951         ret_val = cynara_creds_gdbus_get_user(bt_service_conn, unique_name, user_creds_method, &user_creds);
2952         if (ret_val != CYNARA_API_SUCCESS) {
2953                 cynara_strerror(ret_val, err_msg, sizeof(err_msg));
2954                 BT_ERR("Fail to get user credential: %s", err_msg);
2955                 if (client_creds)
2956                         free(client_creds);
2957                 return FALSE;
2958         }
2959
2960         BT_DBG("user_creds: %s", user_creds);
2961
2962         switch (function_name) {
2963         case BT_SET_LOCAL_NAME:
2964         case BT_START_DISCOVERY:
2965         case BT_START_CUSTOM_DISCOVERY:
2966         case BT_CANCEL_DISCOVERY:
2967         case BT_OOB_ADD_REMOTE_DATA:
2968         case BT_OOB_REMOVE_REMOTE_DATA:
2969         case BT_SET_ADVERTISING:
2970         case BT_SET_CUSTOM_ADVERTISING:
2971         case BT_SET_ADVERTISING_PARAMETERS:
2972         case BT_START_LE_DISCOVERY:
2973         case BT_STOP_LE_DISCOVERY:
2974         case BT_SET_SCAN_PARAMETERS:
2975
2976         case BT_BOND_DEVICE:
2977         case BT_CANCEL_BONDING:
2978         case BT_UNBOND_DEVICE:
2979         case BT_SET_ALIAS:
2980         case BT_SET_AUTHORIZATION:
2981         case BT_UNSET_AUTHORIZATION:
2982         case BT_SEARCH_SERVICE:
2983
2984         case BT_RFCOMM_CLIENT_CONNECT:
2985         case BT_RFCOMM_CLIENT_CANCEL_CONNECT:
2986         case BT_RFCOMM_SOCKET_DISCONNECT:
2987         case BT_RFCOMM_SOCKET_WRITE:
2988         case BT_RFCOMM_CREATE_SOCKET:
2989         case BT_RFCOMM_REMOVE_SOCKET:
2990
2991         case BT_OPP_PUSH_FILES:
2992         case BT_OPP_CANCEL_PUSH:
2993         /* TODO: MAP? MAP functions, see above */
2994
2995         case BT_OBEX_SERVER_ACCEPT_CONNECTION:
2996         case BT_OBEX_SERVER_REJECT_CONNECTION:
2997         case BT_OBEX_SERVER_ACCEPT_FILE:
2998         case BT_OBEX_SERVER_REJECT_FILE:
2999         case BT_OBEX_SERVER_SET_PATH:
3000         case BT_OBEX_SERVER_SET_ROOT:
3001         case BT_OBEX_SERVER_CANCEL_TRANSFER:
3002         case BT_OBEX_SERVER_CANCEL_ALL_TRANSFERS:
3003
3004         case BT_AUDIO_CONNECT:
3005         case BT_AUDIO_DISCONNECT:
3006         case BT_AG_CONNECT:
3007         case BT_AG_DISCONNECT:
3008         case BT_AV_CONNECT:
3009         case BT_AV_DISCONNECT:
3010         case BT_AV_SOURCE_CONNECT:
3011         case BT_AV_SOURCE_DISCONNECT:
3012         case BT_AVRCP_CONTROL_CONNECT:
3013         case BT_AVRCP_CONTROL_DISCONNECT:
3014         case BT_AVRCP_HANDLE_CONTROL:
3015         case BT_AVRCP_SET_TRACK_INFO:
3016         case BT_AVRCP_SET_PROPERTY:
3017         case BT_AVRCP_SET_PROPERTIES:
3018         case BT_AVRCP_CONTROL_SET_PROPERTY:
3019
3020         case BT_HF_CONNECT:
3021         case BT_HF_DISCONNECT:
3022
3023         case BT_HID_CONNECT:
3024         case BT_HID_DISCONNECT:
3025
3026         case BT_HID_DEVICE_ACTIVATE:
3027         case BT_HID_DEVICE_DEACTIVATE:
3028         case BT_HID_DEVICE_CONNECT:
3029         case BT_HID_DEVICE_DISCONNECT:
3030         case BT_HID_DEVICE_SEND_MOUSE_EVENT:
3031         case BT_HID_DEVICE_SEND_KEY_EVENT:
3032         case BT_HID_DEVICE_SEND_REPLY_TO_REPORT:
3033         case BT_HID_DEVICE_SEND_CUSTOM_EVENT:
3034
3035         case BT_CONNECT_LE:
3036         case BT_DISCONNECT_LE:
3037
3038         case BT_SET_ADVERTISING_DATA:
3039         case BT_SET_SCAN_RESPONSE_DATA:
3040
3041         case BT_HDP_CONNECT:
3042         case BT_HDP_DISCONNECT:
3043         case BT_HDP_SEND_DATA:
3044         case BT_HDP_REGISTER_SINK_APP:
3045         case BT_HDP_UNREGISTER_SINK_APP:
3046
3047         case BT_DPM_SET_ALLOW_BT_MODE:
3048         case BT_DPM_GET_ALLOW_BT_MODE:
3049         case BT_DPM_SET_DEVICE_RESTRITION:
3050         case BT_DPM_GET_DEVICE_RESTRITION:
3051         case BT_DPM_SET_UUID_RESTRITION:
3052         case BT_DPM_GET_UUID_RESTRITION:
3053         case BT_DPM_ADD_DEVICES_BLACKLIST:
3054         case BT_DPM_ADD_DEVICES_WHITELIST:
3055         case BT_DPM_ADD_UUIDS_BLACKLIST:
3056         case BT_DPM_ADD_UUIDS_WHITELIST:
3057         case BT_DPM_CLEAR_DEVICES_BLACKLIST:
3058         case BT_DPM_CLEAR_DEVICES_WHITELIST:
3059         case BT_DPM_CLEAR_UUIDS_BLACKLIST:
3060         case BT_DPM_CLEAR_UUIDS_WHITELIST:
3061         case BT_DPM_REMOVE_DEVICE_BLACKLIST:
3062         case BT_DPM_REMOVE_DEVICE_WHITELIST:
3063         case BT_DPM_REMOVE_UUID_BLACKLIST:
3064         case BT_DPM_REMOVE_UUID_WHITELIST:
3065         case BT_DPM_GET_DEVICES_BLACKLIST:
3066         case BT_DPM_GET_DEVICES_WHITELIST:
3067         case BT_DPM_GET_UUIDS_BLACKLIST:
3068         case BT_DPM_GET_UUIDS_WHITELIST:
3069         case BT_DPM_SET_ALLOW_OUTGOING_CALL:
3070         case BT_DPM_GET_ALLOW_OUTGOING_CALL:
3071         case BT_DPM_SET_PAIRING_STATE:
3072         case BT_DPM_GET_PAIRING_STATE:
3073         case BT_DPM_SET_PROFILE_STATE:
3074         case BT_DPM_GET_PROFILE_STATE:
3075         case BT_DPM_SET_DESKROP_CONNECTIVITY_STATE:
3076         case BT_DPM_GET_DESKROP_CONNECTIVITY_STATE:
3077         case BT_DPM_SET_DISCOVERABLE_STATE:
3078         case BT_DPM_GET_DISCOVERABLE_STATE:
3079         case BT_DPM_SET_LIMITED_DISCOVERABLE_STATE:
3080         case BT_DPM_GET_LIMITED_DISCOVERABLE_STATE:
3081         case BT_DPM_SET_DATA_TRANSFER_STATE:
3082         case BT_DPM_GET_DATA_TRANSFER_STATE:
3083
3084         case BT_NETWORK_ACTIVATE:
3085         case BT_NETWORK_DEACTIVATE:
3086         case BT_NETWORK_CONNECT:
3087         case BT_NETWORK_DISCONNECT:
3088         case BT_NETWORK_SERVER_DISCONNECT:
3089
3090         case BT_GATT_GET_PRIMARY_SERVICES:
3091         case BT_GATT_DISCOVER_CHARACTERISTICS:
3092         case BT_GATT_SET_PROPERTY_REQUEST:
3093         case BT_GATT_READ_CHARACTERISTIC:
3094         case BT_GATT_DISCOVER_CHARACTERISTICS_DESCRIPTOR:
3095         case BT_GATT_REGISTER_APPLICATION:
3096         case BT_GATT_REGISTER_SERVICE:
3097         case BT_GATT_SEND_RESPONSE:
3098
3099         case BT_PBAP_CONNECT:
3100         case BT_PBAP_DISCONNECT:
3101         case BT_PBAP_GET_PHONEBOOK_SIZE:
3102         case BT_PBAP_GET_PHONEBOOK:
3103         case BT_PBAP_GET_LIST:
3104         case BT_PBAP_PULL_VCARD:
3105         case BT_PBAP_PHONEBOOK_SEARCH:
3106         case BT_AUDIO_SELECT_ROLE:
3107
3108         ret_val = cynara_check(p_cynara, client_creds, client_session, user_creds,
3109                                                 BT_PRIVILEGE_PUBLIC);
3110
3111         if (ret_val != CYNARA_API_ACCESS_ALLOWED) {
3112                 BT_ERR("Fail to access: %s", BT_PRIVILEGE_PUBLIC);
3113                 result = FALSE;
3114         }
3115
3116         /* Need to check mediastorage privilege */
3117         if (function_name == BT_PBAP_GET_PHONEBOOK ||
3118                 function_name == BT_PBAP_PULL_VCARD) {
3119                 ret_val = cynara_check(p_cynara, client_creds, client_session, user_creds,
3120                                                         MEDIASTORAGE_PRIVILEGE);
3121
3122                 if (ret_val != CYNARA_API_ACCESS_ALLOWED) {
3123                 BT_ERR("Fail to access: %s", MEDIASTORAGE_PRIVILEGE);
3124                 result = FALSE;
3125                 }
3126         }
3127         break;
3128
3129         case BT_ENABLE_ADAPTER:
3130         case BT_DISABLE_ADAPTER:
3131         case BT_RESET_ADAPTER:
3132         case BT_RECOVER_ADAPTER:
3133         case BT_ENABLE_ADAPTER_LE:
3134         case BT_DISABLE_ADAPTER_LE:
3135         case BT_SET_CONNECTABLE:
3136         case BT_SET_DISCOVERABLE_MODE:
3137         case BT_ADD_WHITE_LIST:
3138         case BT_REMOVE_WHITE_LIST:
3139         case BT_CLEAR_WHITE_LIST:
3140         case BT_SET_MANUFACTURER_DATA:
3141         case BT_SET_PROFILE_RESTRICTED:
3142
3143         case BT_CANCEL_SEARCH_SERVICE:
3144         case BT_ENABLE_RSSI:
3145
3146         case BT_RFCOMM_ACCEPT_CONNECTION:
3147         case BT_RFCOMM_REJECT_CONNECTION:
3148         case BT_RFCOMM_LISTEN:
3149
3150         case BT_AVRCP_CONTROL_GET_PROPERTY:
3151         case BT_AVRCP_GET_TRACK_INFO:
3152
3153         case BT_SET_CONTENT_PROTECT:
3154         case BT_BOND_DEVICE_BY_TYPE:
3155         case BT_SET_LE_PRIVACY:
3156         case BT_SET_LE_STATIC_RANDOM_ADDRESS:
3157         case BT_LE_CONN_UPDATE:
3158         case BT_UPDATE_LE_CONNECTION_MODE:
3159         case BT_REQ_ATT_MTU:
3160         case BT_GET_DEVICE_IDA:
3161         case BT_LE_READ_MAXIMUM_DATA_LENGTH:
3162         case BT_LE_WRITE_HOST_SUGGESTED_DATA_LENGTH:
3163         case BT_LE_READ_HOST_SUGGESTED_DATA_LENGTH:
3164         case BT_LE_SET_DATA_LENGTH:
3165
3166         case BT_GET_ATT_MTU:
3167
3168         case BT_LE_IPSP_INIT:
3169         case BT_LE_IPSP_DEINIT:
3170         case BT_LE_IPSP_CONNECT:
3171         case BT_LE_IPSP_DISCONNECT:
3172         case BT_PXP_MONITOR_SET_PROPERTY:
3173         case BT_PXP_MONITOR_GET_PROPERTY:
3174         case BT_PXP_MONITOR_GET_SUPPORTED_SERIVCES:
3175         case BT_PXP_REPORTER_REGISTER:
3176         case BT_PXP_REPORTER_UNREGISTER:
3177         case BT_PXP_REPORTER_GET_PROPERTY:
3178
3179         /* TDS */
3180         case BT_TDS_PROVIDER_REGISTER:
3181         case BT_TDS_PROVIDER_UNREGISTER:
3182         case BT_TDS_PROVIDER_SET_MANUF_DATA:
3183         case BT_TDS_PROVIDER_CREATE:
3184         case BT_TDS_PROVIDER_DESTROY:
3185         case BT_TDS_PROVIDER_SET_TRANSPORT_DATA:
3186         case BT_TDS_SEND_ACTIVATION_RESPONSE:
3187         case BT_TDS_READ_TRANSPORT_DATA:
3188         case BT_TDS_ENABLE_CONTROL_POINT:
3189         case BT_TDS_ACTIVATE_CONTROL_POINT:
3190
3191         case BT_MAP_CREATE_SESSION:
3192         case BT_MAP_DESTROY_SESSION:
3193         case BT_MAP_SET_FOLDER:
3194         case BT_MAP_LIST_FOLDERS:
3195         case BT_MAP_LIST_FILTER_FIELDS:
3196         case BT_MAP_LIST_MESSAGES:
3197         case BT_MAP_UPDATE_INBOX:
3198         case BT_MAP_PUSH_MESSAGE:
3199         case BT_MAP_GET_MESSAGE:
3200
3201         ret_val = cynara_check(p_cynara, client_creds, client_session, user_creds,
3202                                 BT_PRIVILEGE_PLATFORM);
3203
3204         if (ret_val != CYNARA_API_ACCESS_ALLOWED) {
3205                 BT_ERR("Fail to access: %s", BT_PRIVILEGE_PLATFORM);
3206                 result = FALSE;
3207         }
3208         break;
3209
3210         case BT_CHECK_ADAPTER:
3211         case BT_GET_RSSI:
3212
3213         case BT_GET_LOCAL_NAME:
3214         case BT_GET_LOCAL_ADDRESS:
3215         case BT_GET_LOCAL_VERSION:
3216         case BT_IS_SERVICE_USED:
3217         case BT_GET_DISCOVERABLE_MODE:
3218         case BT_GET_DISCOVERABLE_TIME:
3219         case BT_IS_DISCOVERYING:
3220         case BT_IS_LE_DISCOVERYING:
3221         case BT_IS_CONNECTABLE:
3222         case BT_GET_BONDED_DEVICES:
3223         case BT_GET_PROFILE_CONNECTED_DEVICES:
3224         case BT_GET_BONDED_DEVICE:
3225         case BT_GET_IS_ALIAS_SET:
3226         case BT_IS_DEVICE_CONNECTED:
3227         case BT_GET_CONNECTED_LINK_TYPE:
3228         case BT_SET_PROFILE_TRUSTED:
3229         case BT_GET_PROFILE_TRUSTED:
3230         case BT_GET_SPEAKER_GAIN:
3231         case BT_SET_SPEAKER_GAIN:
3232         case BT_OOB_READ_LOCAL_DATA:
3233         case BT_RFCOMM_CLIENT_IS_CONNECTED:
3234         case BT_RFCOMM_IS_UUID_AVAILABLE:
3235         case BT_GET_ADVERTISING_DATA:
3236         case BT_GET_SCAN_RESPONSE_DATA:
3237         case BT_IS_ADVERTISING:
3238         case BT_GET_PROFILE_RESTRICTED:
3239         case BT_REGISTER_SCAN_FILTER:
3240         case BT_UNREGISTER_SCAN_FILTER:
3241         case BT_UNREGISTER_ALL_SCAN_FILTERS:
3242         case BT_IS_SCAN_FILTER_SUPPORTED:
3243
3244         case BT_OBEX_SERVER_ALLOCATE:
3245         case BT_OBEX_SERVER_DEALLOCATE:
3246         case BT_OBEX_SERVER_IS_ACTIVATED:
3247         case BT_OPP_GET_TRANSFER_PROGRESS:
3248                 /* Non-privilege control */
3249                 break;
3250         default:
3251                 BT_ERR("Unknown function!");
3252                 result = FALSE;
3253                 break;
3254         }
3255
3256         if (client_creds)
3257                 free(client_creds);
3258
3259         if (user_creds)
3260                 free(user_creds);
3261
3262         return result;
3263 }
3264
3265 GDBusNodeInfo *__bt_service_create_method_node_info
3266                                         (const gchar *introspection_data)
3267 {
3268         GError *err = NULL;
3269         GDBusNodeInfo *node_info = NULL;
3270
3271         if (introspection_data == NULL) {
3272                 ERR("Introspection XML not present");
3273                 return NULL;
3274         }
3275
3276         node_info = g_dbus_node_info_new_for_xml(introspection_data, &err);
3277
3278         if (err) {
3279                 ERR("Unable to create node: %s", err->message);
3280                 g_clear_error(&err);
3281         }
3282         return node_info;
3283 }
3284
3285 int __bt_service_register_object(GDBusConnection *conn,
3286                 GDBusNodeInfo *node_info, gboolean reg)
3287 {
3288         static guint service_id = 0;
3289         GError *error = NULL;
3290
3291         if (reg) {
3292                 if (node_info == NULL)
3293                         return -1;
3294
3295                 service_id = g_dbus_connection_register_object(conn,
3296                                 BT_SERVICE_PATH,
3297                                 node_info->interfaces[0],
3298                                 &method_table,
3299                                 NULL, NULL, &error);
3300                 if (service_id == 0)
3301                         return -1;
3302         } else {
3303                 if (service_id > 0) {
3304                         g_dbus_connection_unregister_object(conn,
3305                                         service_id);
3306                         service_id = 0;
3307                 }
3308         }
3309
3310         return 0;
3311 }
3312
3313 int _bt_service_register(void)
3314 {
3315         GDBusConnection *conn;
3316         GError *err = NULL;
3317         int result;
3318
3319         conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &err);
3320         retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
3321
3322         owner_id = g_bus_own_name(G_BUS_TYPE_SYSTEM,
3323                                 BT_SERVICE_NAME,
3324                                 G_BUS_NAME_OWNER_FLAGS_NONE,
3325                                 NULL, NULL, NULL,
3326                                 NULL, NULL);
3327         BT_DBG("owner_id is [%d]", owner_id);
3328         if (owner_id == 0)
3329                 goto fail;
3330
3331         node_info = __bt_service_create_method_node_info(
3332                         bt_service_introspection_xml);
3333
3334         if (node_info == NULL)
3335                 goto fail;
3336
3337         result = __bt_service_register_object(conn, node_info, TRUE);
3338         g_dbus_node_info_unref(node_info);
3339         node_info = NULL;
3340
3341         if (result != BLUETOOTH_ERROR_NONE)
3342                 goto fail;
3343
3344         bt_service_conn = conn;
3345
3346         return BLUETOOTH_ERROR_NONE;
3347
3348 fail:
3349         if (bt_service_conn) {
3350                 g_object_unref(bt_service_conn);
3351                 bt_service_conn = NULL;
3352         }
3353
3354         return BLUETOOTH_ERROR_INTERNAL;
3355 }
3356
3357 void _bt_service_unregister(void)
3358 {
3359         if (bt_service_conn) {
3360                 __bt_service_register_object(bt_service_conn, NULL, FALSE);
3361                 if (bt_service_conn) {
3362                         g_object_unref(bt_service_conn);
3363                         bt_service_conn = NULL;
3364                 }
3365                 if (node_info) {
3366                         g_dbus_node_info_unref(node_info);
3367                         node_info = NULL;
3368                 }
3369                 if (owner_id > 0) {
3370                         g_bus_unown_name(owner_id);
3371                         owner_id = 0;
3372                 }
3373         }
3374 }
3375
3376 int _bt_service_cynara_init(void)
3377 {
3378         int result;
3379         char err_msg[256] = {0, };
3380
3381         retv_if(p_cynara != NULL, BLUETOOTH_ERROR_ALREADY_INITIALIZED);
3382
3383         result = cynara_initialize(&p_cynara, conf);
3384
3385         if (result != CYNARA_API_SUCCESS) {
3386                 cynara_strerror(result, err_msg, sizeof(err_msg));
3387                 BT_ERR("Fail to initialize cynara: [%s]", err_msg);
3388                 return BLUETOOTH_ERROR_INTERNAL;
3389         }
3390
3391         return BLUETOOTH_ERROR_NONE;
3392 }
3393
3394 void _bt_service_cynara_deinit(void)
3395 {
3396         int result;
3397         char err_msg[256] = {0, };
3398
3399         ret_if(p_cynara == NULL);
3400
3401         result = cynara_finish(p_cynara);
3402
3403         if (result != CYNARA_API_SUCCESS) {
3404                 cynara_strerror(result, err_msg, sizeof(err_msg));
3405                 BT_ERR("Fail to finish cynara: [%s]", err_msg);
3406                 return;
3407         }
3408
3409         p_cynara = NULL;
3410         conf = NULL;
3411 }
3412