bt-service/bt-request-handler.c

   1 /*
   2  * Bluetooth-frwk
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact:  Hocheol Seo <hocheol.seo@samsung.com>
   7  *               Girishashok Joshi <girish.joshi@samsung.com>
   8  *               Chanyeol Park <chanyeol.park@samsung.com>
   9  *
  10  * Licensed under the Apache License, Version 2.0 (the "License");
  11  * you may not use this file except in compliance with the License.
  12  * You may obtain a copy of the License at
  13  *
  14  *              http://www.apache.org/licenses/LICENSE-2.0
  15  *
  16  * Unless required by applicable law or agreed to in writing, software
  17  * distributed under the License is distributed on an "AS IS" BASIS,
  18  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  19  * See the License for the specific language governing permissions and
  20  * limitations under the License.
  21  *
  22  */
  23
  24 #include <string.h>
  25 #include <glib.h>
  26 #include <dlog.h>
  27 #include <gio/gio.h>
  28 #include <cynara-client.h>
  29 #include <cynara-creds-gdbus.h>
  30
  31 #include "bluetooth-api.h"
  32 #include "bt-service-common.h"
  33 #include "bt-service-util.h"
  34 #include "bt-service-event.h"
  35 #include "bt-service-adapter.h"
  36 #include "bt-service-adapter-le.h"
  37 #include "bt-service-device.h"
  38 #include "bt-service-hid.h"
  39 #include "bt-service-network.h"
  40 #include "bt-service-audio.h"
  41 #include "bt-service-oob.h"
  42 #include "bt-service-avrcp.h"
  43 #include "bt-service-avrcp-controller.h"
  44 #include "bt-service-opp-client.h"
  45 #include "bt-service-obex-server.h"
  46 #include "bt-service-rfcomm-client.h"
  47 #include "bt-service-rfcomm-server.h"
  48 #include "bt-request-handler.h"
  49 #include "bt-service-pbap.h"
  50
  51 static GDBusConnection *bt_service_conn;
  52 static guint owner_id = 0;
  53 cynara *p_cynara;
  54 cynara_configuration *conf;
  55
  56 static const gchar bt_service_introspection_xml[] =
  57 "<node name='/org/projectx/bt_service'>"
  58 "       <interface name='org.projectx.bt'>"
  59 "               <method name='service_request'>"
  60                         /* Input Parameters */
  61 "                       <arg type='i' name='service_type' direction='in' />"
  62 "                       <arg type='i' name='service_function' direction='in' />"
  63 "                       <arg type='i' name='request_type' direction='in' />"
  64 "                       <arg type='ay' name='input_param1' direction='in' />"
  65 "                       <arg type='ay' name='input_param2' direction='in' />"
  66 "                       <arg type='ay' name='input_param3' direction='in' />"
  67 "                       <arg type='ay' name='input_param4' direction='in' />"
  68 "                       <arg type='ay' name='input_param5' direction='in' />"
  69                         /* Return Parameters */
  70 "                       <arg type='i' name='output_param1' direction='out' />"
  71 "                       <arg type='v' name='output_param2' direction='out' />"
  72 "               </method>"
  73 "       </interface>"
  74 "</node>";
  75
  76 GDBusNodeInfo *node_info = NULL;
  77
  78 static void __bt_service_method(GDBusConnection *connection,
  79                 const gchar *sender,
  80                 const gchar *object_path,
  81                 const gchar *interface_name,
  82                 const gchar *method_name,
  83                 GVariant *parameters,
  84                 GDBusMethodInvocation *invocation,
  85                 gpointer user_data);
  86
  87 int __bt_bluez_request(int function_name,
  88                 int request_type,
  89                 int request_id,
  90                 GDBusMethodInvocation *context,
  91                 GVariant *in_param1,
  92                 GVariant *in_param2,
  93                 GVariant *in_param3,
  94                 GVariant *in_param4,
  95                 GArray **out_param1);
  96 int __bt_obexd_request(int function_name,
  97                 int request_type,
  98                 int request_id,
  99                 GDBusMethodInvocation *context,
 100                 GVariant *in_param1,
 101                 GVariant *in_param2,
 102                 GVariant *in_param3,
 103                 GVariant *in_param4,
 104                 GArray **out_param1);
 105 int __bt_agent_request(int function_name,
 106                 int request_type,
 107                 int request_id,
 108                 GDBusMethodInvocation *context,
 109                 GVariant *in_param1,
 110                 GVariant *in_param2,
 111                 GVariant *in_param3,
 112                 GVariant *in_param4,
 113                 GArray **out_param1);
 114 int __bt_core_request(int function_name,
 115                 int request_type,
 116                 int request_id,
 117                 GDBusMethodInvocation *context,
 118                 GVariant *in_param1);
 119
 120 gboolean __bt_service_check_privilege(int function_name,
 121                                         int service_type,
 122                                         const char *unique_name);
 123
 124 /* Function definitions*/
 125 static void __bt_fill_garray_from_variant(GVariant *var, GArray *param)
 126 {
 127         char *data;
 128         int size;
 129
 130         size = g_variant_get_size(var);
 131         if (size > 0) {
 132                 data = (char *)g_variant_get_data(var);
 133                 if (data)
 134                         param = g_array_append_vals(param, data, size);
 135
 136         }
 137 }
 138
 139 static void __bt_service_get_parameters(GVariant *in_param,
 140                 void *value, int size)
 141 {
 142         void *buf = NULL;
 143         buf = (void *)g_variant_get_data(in_param);
 144         memcpy(value, buf, size);
 145 }
 146
 147 static void __bt_service_method(GDBusConnection *connection,
 148                 const gchar *sender,
 149                 const gchar *object_path,
 150                 const gchar *interface_name,
 151                 const gchar *method_name,
 152                 GVariant *parameters,
 153                 GDBusMethodInvocation *invocation,
 154                 gpointer user_data)
 155 {
 156         FN_START;
 157         BT_DBG("Method[%s] Object Path[%s] Interface Name[%s]",
 158                         method_name, object_path, interface_name);
 159
 160         if (g_strcmp0(method_name, "service_request") == 0) {
 161                 int service_type;
 162                 int service_function;
 163                 int request_type;
 164                 GVariant *param1 = NULL;
 165                 GVariant *param2 = NULL;
 166                 GVariant *param3 = NULL;
 167                 GVariant *param4 = NULL;
 168                 GVariant *param5 = NULL;
 169                 GArray *out_param1 = NULL;
 170                 GVariant *out_var = NULL;
 171                 int result = 0;
 172                 int request_id = -1;
 173                 char *sender = NULL;
 174
 175                 g_variant_get(parameters, "(iii@ay@ay@ay@ay@ay)", &service_type,
 176                                 &service_function, &request_type,
 177                                 &param1, &param2, &param3, &param4, &param5);
 178
 179                 out_param1 = g_array_new(FALSE, FALSE, sizeof(gchar));
 180
 181                 sender = g_dbus_method_invocation_get_sender(invocation);
 182
 183                 if (service_type == BT_CORE_SERVICE) {
 184                         BT_DBG("No need to check privilege from bt-core");
 185                 } else if (__bt_service_check_privilege(service_function,
 186                                         service_type, (const char *)sender) == FALSE) {
 187                         BT_ERR("Client don't have the privilege to excute this function");
 188                         /* TODO: privilege check doesn't work properly. It sometimes reutrns fail. */
 189 #if 0
 190                         result = BLUETOOTH_ERROR_PERMISSION_DEINED;
 191                         goto fail;
 192 #endif
 193                 }
 194
 195                 if (request_type == BT_ASYNC_REQ
 196                                 || service_function == BT_OBEX_SERVER_ACCEPT_CONNECTION) {
 197                         /* Set the timer */
 198                         request_id = _bt_assign_request_id();
 199                         BT_DBG("Request ID: %d", request_id);
 200
 201                         if (request_id < 0) {
 202                                 BT_ERR("Fail to assign the request id");
 203                                 result = BLUETOOTH_ERROR_INTERNAL;
 204
 205                                 goto fail;
 206                         }
 207                 }
 208
 209                 BT_DBG("SERVICE TYPE [%d] SERVICE FUNC [%d]",
 210                                 service_type, 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
 250                 if ((request_type == BT_ASYNC_REQ ||
 251                         service_function == BT_OBEX_SERVER_ACCEPT_CONNECTION) &&
 252                         service_function != BT_OPP_PUSH_FILES) {
 253                         BT_DBG("INSERT INTO REQ LIST");
 254                         _bt_insert_request_list(request_id, service_function,
 255                                                 NULL, invocation);
 256                 } else {
 257                         /* Return result */
 258                         if (service_type == BT_CHECK_PRIVILEGE ||
 259                                         service_function != BT_OPP_PUSH_FILES) {
 260                                 out_var = g_variant_new_from_data((const GVariantType *)"ay",
 261                                                 out_param1->data, out_param1->len,
 262                                                 TRUE, NULL, NULL);
 263
 264                                 GVariant *temp = g_variant_new("(iv)", result, out_var);
 265                                 g_dbus_method_invocation_return_value(invocation, temp);
 266
 267                                 g_array_free(out_param1, TRUE);
 268                                 out_param1 = NULL;
 269                         }
 270                 }
 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] [%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                 result = _bt_enable_adapter_le();
 340                 break;
 341         case BT_DISABLE_ADAPTER_LE:
 342                 result = _bt_disable_adapter_le();
 343                 break;
 344         case BT_RESET_ADAPTER:
 345                 result = _bt_reset_adapter();
 346                 break;
 347         case BT_CHECK_ADAPTER: {
 348                 int enabled = BT_ADAPTER_DISABLED;
 349
 350                 result = _bt_check_adapter(&enabled);
 351
 352                 g_array_append_vals(*out_param1, &enabled,
 353                                 sizeof(int));
 354                 break;
 355         }
 356         case BT_GET_LOCAL_ADDRESS: {
 357                 bluetooth_device_address_t local_address = { {0} };
 358                 result = _bt_get_local_address(&local_address);
 359
 360                 g_array_append_vals(*out_param1, &local_address,
 361                                 sizeof(bluetooth_device_address_t));
 362                 break;
 363         }
 364         case BT_GET_LOCAL_VERSION: {
 365                 bluetooth_version_t ver = { {0} };
 366                 result = _bt_get_local_version(&ver);
 367
 368                 g_array_append_vals(*out_param1, &ver,
 369                                 sizeof(bluetooth_version_t));
 370                 break;
 371         }
 372         case BT_GET_LOCAL_NAME: {
 373                 bluetooth_device_name_t local_name = { {0} };
 374                 result = _bt_get_local_name(&local_name);
 375
 376                 g_array_append_vals(*out_param1, &local_name,
 377                                 sizeof(bluetooth_device_name_t));
 378
 379                 break;
 380         }
 381         case BT_SET_LOCAL_NAME: {
 382                 bluetooth_device_name_t local_name = { {0} };
 383                 __bt_service_get_parameters(in_param1,
 384                                 &local_name, sizeof(bluetooth_device_name_t));
 385
 386                 result = _bt_set_local_name(local_name.name);
 387
 388                 break;
 389         }
 390         case BT_IS_SERVICE_USED: {
 391                 char *uuid;
 392                 gboolean used = FALSE;
 393
 394                 uuid = (char *)g_variant_get_data(in_param1);
 395
 396                 result = _bt_is_service_used(uuid, &used);
 397
 398                 if (result == BLUETOOTH_ERROR_NONE) {
 399                         g_array_append_vals(*out_param1, &used,
 400                                                 sizeof(gboolean));
 401                 }
 402                 break;
 403         }
 404         case BT_GET_DISCOVERABLE_MODE: {
 405                 int mode = BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE;
 406
 407                 result = _bt_get_discoverable_mode(&mode);
 408
 409                 g_array_append_vals(*out_param1, &mode, sizeof(int));
 410                 break;
 411         }
 412         case BT_SET_DISCOVERABLE_MODE: {
 413                 int mode = BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE;
 414                 int time = 0;
 415
 416                 __bt_service_get_parameters(in_param1, &mode, sizeof(int));
 417                 __bt_service_get_parameters(in_param2, &time, sizeof(int));
 418
 419                 result = _bt_set_discoverable_mode(mode, time);
 420                 break;
 421         }
 422         case BT_GET_DISCOVERABLE_TIME: {
 423                 int timeout = 0;
 424
 425                 result = _bt_get_timeout_value(&timeout);
 426
 427                 g_array_append_vals(*out_param1, &timeout, sizeof(int));
 428                 break;
 429         }
 430         case BT_START_DISCOVERY:
 431                 result = _bt_start_discovery();
 432
 433                 break;
 434         case BT_START_CUSTOM_DISCOVERY: {
 435                 bt_discovery_role_type_t role;
 436
 437                 __bt_service_get_parameters(in_param1,
 438                                 &role, sizeof(bt_discovery_role_type_t));
 439                 result = _bt_start_custom_discovery(role);
 440
 441                 break;
 442         }
 443         case BT_CANCEL_DISCOVERY:
 444                 result = _bt_cancel_discovery();
 445                 break;
 446         case BT_IS_DISCOVERYING: {
 447                 gboolean discovering = FALSE;
 448                 discovering = _bt_is_discovering();
 449                 g_array_append_vals(*out_param1,
 450                                 &discovering, sizeof(gboolean));
 451                 break;
 452         }
 453         case BT_START_LE_DISCOVERY: {
 454                 char *sender = NULL;
 455
 456                 sender = (char *)g_dbus_method_invocation_get_sender(context);
 457                 result = _bt_start_le_scan(sender);
 458
 459                 break;
 460         }
 461         case BT_STOP_LE_DISCOVERY: {
 462                 char *sender = NULL;
 463
 464                 sender = (char *)g_dbus_method_invocation_get_sender(context);
 465                 result = _bt_stop_le_scan(sender);
 466
 467                 break;
 468         }
 469         case BT_IS_LE_DISCOVERYING: {
 470                 gboolean le_discovering = FALSE;
 471
 472                 le_discovering = _bt_is_le_scanning();
 473                 g_array_append_vals(*out_param1,
 474                                 &le_discovering, sizeof(gboolean));
 475
 476                 break;
 477         }
 478         case BT_REGISTER_SCAN_FILTER: {
 479                 char *sender = NULL;
 480                 bluetooth_le_scan_filter_t scan_filter;
 481                 int slot_id;
 482
 483                 sender = (char *)g_dbus_method_invocation_get_sender(context);
 484                 __bt_service_get_parameters(in_param1, &scan_filter,
 485                                 sizeof(bluetooth_le_scan_filter_t));
 486                 BT_DBG("bluetooth_le_scan_filter_t [features : %.2x]",
 487                                 scan_filter.added_features);
 488
 489                 result = _bt_register_scan_filter(sender,
 490                                 &scan_filter, &slot_id);
 491
 492                 g_array_append_vals(*out_param1, &slot_id, sizeof(int));
 493                 break;
 494         }
 495         case BT_UNREGISTER_SCAN_FILTER:{
 496                 char *sender = NULL;
 497                 int slot_id;
 498
 499                 sender = (char *)g_dbus_method_invocation_get_sender(context);
 500                 __bt_service_get_parameters(in_param1, &slot_id, sizeof(int));
 501                 BT_DBG("Remove scan filter [Slot ID : %d]", slot_id);
 502
 503                 result = _bt_unregister_scan_filter(sender, slot_id);
 504
 505                 break;
 506         }
 507         case BT_UNREGISTER_ALL_SCAN_FILTERS:{
 508                 char *sender = NULL;
 509
 510                 sender = (char *)g_dbus_method_invocation_get_sender(context);
 511
 512                 BT_DBG("Remove all scan filters [Sender : %s]", sender);
 513
 514                 result = _bt_unregister_all_scan_filters(sender);
 515
 516                 break;
 517         }
 518         case BT_ENABLE_RSSI: {
 519                 bluetooth_device_address_t bd_addr;
 520                 int link_type;
 521                 bt_rssi_threshold_t rssi_threshold;
 522                 int low_threshold;
 523                 int in_range_threshold;
 524                 int high_threshold;
 525
 526                 BT_DBG("Enable RSSI");
 527
 528                 __bt_service_get_parameters(in_param1,
 529                                 &bd_addr, sizeof(bluetooth_device_address_t));
 530                 __bt_service_get_parameters(in_param2,
 531                                 &link_type, sizeof(int));
 532                 __bt_service_get_parameters(in_param3,
 533                                 &rssi_threshold, sizeof(bt_rssi_threshold_t));
 534
 535                 low_threshold = rssi_threshold.low_threshold;
 536                 in_range_threshold = rssi_threshold.in_range_threshold;
 537                 high_threshold = rssi_threshold.high_threshold;
 538
 539                 result = _bt_enable_rssi(&bd_addr,
 540                                 link_type, low_threshold,
 541                                 in_range_threshold, high_threshold);
 542                 break;
 543         }
 544         case BT_GET_RSSI: {
 545                 int link_type;
 546                 bluetooth_device_address_t bd_addr;
 547
 548                 BT_DBG("Get RSSI Strength");
 549
 550                 __bt_service_get_parameters(in_param1,
 551                                 &bd_addr, sizeof(bluetooth_device_address_t));
 552                 __bt_service_get_parameters(in_param2,
 553                                 &link_type, sizeof(int));
 554
 555                 result = _bt_get_rssi_strength(&bd_addr, link_type);
 556                 break;
 557         }
 558         case BT_IS_CONNECTABLE: {
 559                 gboolean is_connectable;
 560
 561                 is_connectable = _bt_is_connectable();
 562                 g_array_append_vals(*out_param1,
 563                                 &is_connectable, sizeof(gboolean));
 564                 break;
 565         }
 566         case BT_SET_CONNECTABLE: {
 567                 gboolean is_connectable;
 568
 569                 __bt_service_get_parameters(in_param1,
 570                                 &is_connectable, sizeof(gboolean));
 571                 result = _bt_set_connectable(is_connectable);
 572                 break;
 573         }
 574         case BT_SET_ADVERTISING: {
 575                 char *sender = NULL;
 576                 int adv_handle;
 577                 gboolean enable = FALSE;
 578                 gboolean use_reserved_slot = FALSE;
 579
 580                 __bt_service_get_parameters(in_param1,
 581                                 &adv_handle, sizeof(int));
 582                 __bt_service_get_parameters(in_param2,
 583                                 &enable, sizeof(gboolean));
 584                 __bt_service_get_parameters(in_param3,
 585                                 &use_reserved_slot, sizeof(gboolean));
 586
 587                 sender = (char *)g_dbus_method_invocation_get_sender(context);
 588
 589                 result = _bt_set_advertising(sender, adv_handle,
 590                                 enable, use_reserved_slot);
 591                 break;
 592         }
 593         case BT_SET_CUSTOM_ADVERTISING: {
 594                 char *sender = NULL;
 595                 int adv_handle;
 596                 gboolean enable = FALSE;
 597                 bluetooth_advertising_params_t adv_params;
 598                 gboolean use_reserved_slot = FALSE;
 599
 600                 sender = (char *)g_dbus_method_invocation_get_sender(context);
 601
 602                 __bt_service_get_parameters(in_param1, &adv_handle,
 603                                 sizeof(int));
 604                 __bt_service_get_parameters(in_param2, &enable,
 605                                 sizeof(gboolean));
 606                 __bt_service_get_parameters(in_param3, &adv_params,
 607                                 sizeof(bluetooth_advertising_params_t));
 608                 __bt_service_get_parameters(in_param4, &use_reserved_slot,
 609                                 sizeof(gboolean));
 610
 611                 BT_DBG("bluetooth_advertising_params_t [%f %f %d %d]",
 612                                 adv_params.interval_min, adv_params.interval_max,
 613                                 adv_params.filter_policy, adv_params.type);
 614                 result = _bt_set_custom_advertising(sender, adv_handle,
 615                                 enable, &adv_params, use_reserved_slot);
 616                 break;
 617         }
 618         case BT_GET_ADVERTISING_DATA: {
 619                 bluetooth_advertising_data_t adv = { {0} };
 620                 int length = 0;
 621
 622                 result = _bt_get_advertising_data(&adv, &length);
 623                 if (result == BLUETOOTH_ERROR_NONE) {
 624                         g_array_append_vals(*out_param1, adv.data, length);
 625                 }
 626                 break;
 627         }
 628         case BT_SET_ADVERTISING_DATA: {
 629                 char *sender = NULL;
 630                 int adv_handle;
 631                 bluetooth_advertising_data_t adv = { {0} };
 632                 int length;
 633                 gboolean use_reserved_slot = FALSE;
 634
 635                 sender = (char *)g_dbus_method_invocation_get_sender(context);
 636
 637                 __bt_service_get_parameters(in_param1,
 638                                 &adv_handle, sizeof(int));
 639                 __bt_service_get_parameters(in_param2,
 640                                 &adv, sizeof(bluetooth_advertising_data_t));
 641                 __bt_service_get_parameters(in_param3,
 642                                 &length, sizeof(int));
 643                 __bt_service_get_parameters(in_param4,
 644                                 &use_reserved_slot, sizeof(gboolean));
 645
 646                 result = _bt_set_advertising_data(sender, adv_handle,
 647                                 &adv, length, use_reserved_slot);
 648                 break;
 649         }
 650         case BT_GET_SCAN_RESPONSE_DATA: {
 651                 bluetooth_scan_resp_data_t rsp = { {0} };
 652                 int length = 0;
 653
 654                 result = _bt_get_scan_response_data(&rsp, &length);
 655                 if (result == BLUETOOTH_ERROR_NONE) {
 656                         g_array_append_vals(*out_param1, rsp.data, length);
 657                 }
 658
 659                 break;
 660         }
 661         case BT_SET_SCAN_RESPONSE_DATA: {
 662                 char *sender = NULL;
 663                 int adv_handle;
 664                 bluetooth_scan_resp_data_t rsp = { {0} };
 665                 int length;
 666                 gboolean use_reserved_slot = FALSE;
 667
 668                 sender = (char *)g_dbus_method_invocation_get_sender(context);
 669
 670                 __bt_service_get_parameters(in_param1,
 671                                 &adv_handle, sizeof(int));
 672                 __bt_service_get_parameters(in_param2,
 673                                 &rsp, sizeof(bluetooth_scan_resp_data_t));
 674                 __bt_service_get_parameters(in_param3,
 675                                 &length, sizeof(int));
 676                 __bt_service_get_parameters(in_param4,
 677                                 &use_reserved_slot, sizeof(gboolean));
 678
 679                 result = _bt_set_scan_response_data(sender, adv_handle,
 680                                 &rsp, length, use_reserved_slot);
 681
 682                 break;
 683         }
 684         case BT_SET_MANUFACTURER_DATA: {
 685                 bluetooth_manufacturer_data_t m_data = { 0 };
 686                 __bt_service_get_parameters(in_param1,
 687                                 &m_data, sizeof(bluetooth_manufacturer_data_t));
 688
 689                 result = _bt_set_manufacturer_data(&m_data);
 690                 break;
 691         }
 692         case BT_SET_SCAN_PARAMETERS: {
 693                 bluetooth_le_scan_params_t scan_params;
 694                 __bt_service_get_parameters(in_param1, &scan_params,
 695                                 sizeof(bluetooth_le_scan_params_t));
 696
 697                 BT_DBG("bluetooth_le_scan_params_t [%f %f %d]",
 698                                 scan_params.interval, scan_params.window,
 699                                 scan_params.type);
 700
 701                 result = _bt_set_scan_parameters(&scan_params);
 702                 break;
 703         }
 704         case BT_LE_CONN_UPDATE: {
 705                 bluetooth_device_address_t local_address = { {0} };
 706                 bluetooth_le_conn_update_t parameters = {0};
 707
 708                 __bt_service_get_parameters(in_param1, &local_address,
 709                                 sizeof(bluetooth_device_address_t));
 710                 __bt_service_get_parameters(in_param2, &parameters,
 711                                 sizeof(bluetooth_le_conn_update_t));
 712
 713                 result =  _bt_le_conn_update(local_address.addr,
 714                                         parameters.interval_min,
 715                                         parameters.interval_max,
 716                                         parameters.latency,
 717                                         parameters.time_out);
 718                 break;
 719         }
 720         case BT_IS_ADVERTISING: {
 721                 gboolean advertising = FALSE;
 722                 advertising = _bt_is_advertising();
 723
 724                 g_array_append_vals(*out_param1, &advertising,
 725                                 sizeof(gboolean));
 726                 break;
 727         }
 728         case BT_ADD_WHITE_LIST: {
 729                 bluetooth_device_address_t address = { {0} };
 730                 int addr_type = 0;
 731
 732                 __bt_service_get_parameters(in_param1, &address,
 733                                 sizeof(bluetooth_device_address_t));
 734                 __bt_service_get_parameters(in_param2, &addr_type,
 735                                 sizeof(int));
 736
 737                 result = _bt_add_white_list(&address, addr_type);
 738                 break;
 739         }
 740         case BT_REMOVE_WHITE_LIST: {
 741                 bluetooth_device_address_t address = { {0} };
 742                 int addr_type = 0;
 743
 744                 __bt_service_get_parameters(in_param1,
 745                                 &address, sizeof(bluetooth_device_address_t));
 746                 __bt_service_get_parameters(in_param2,
 747                                 &addr_type, sizeof(int));
 748
 749                 result = _bt_remove_white_list(&address, addr_type);
 750                 break;
 751         }
 752         case BT_CLEAR_WHITE_LIST: {
 753                 result = _bt_clear_white_list();
 754                 break;
 755         }
 756         case BT_GET_BONDED_DEVICES: {
 757                 result = _bt_get_bonded_devices(out_param1);
 758                 break;
 759         }
 760         case BT_GET_BONDED_DEVICE: {
 761                 bluetooth_device_address_t address = { {0} };
 762                 bluetooth_device_info_t dev_info;
 763
 764                 __bt_service_get_parameters(in_param1,
 765                                 &address, sizeof(bluetooth_device_address_t));
 766
 767                 memset(&dev_info, 0x00, sizeof(bluetooth_device_info_t));
 768                 result = _bt_get_bonded_device_info(&address, &dev_info);
 769
 770                 if (result == BLUETOOTH_ERROR_NONE) {
 771                         g_array_append_vals(*out_param1, &dev_info,
 772                                         sizeof(bluetooth_device_info_t));
 773                 }
 774                 break;
 775         }
 776         case BT_BOND_DEVICE: {
 777                 bluetooth_device_address_t address = { {0} };
 778
 779                 __bt_service_get_parameters(in_param1,
 780                                 &address, sizeof(bluetooth_device_address_t));
 781
 782                 result = _bt_bond_device(request_id, &address,
 783                                 BLUETOOTH_DEV_CONN_DEFAULT, out_param1);
 784                 break;
 785         }
 786         case BT_BOND_DEVICE_BY_TYPE: {
 787                 bluetooth_device_address_t address = { {0} };
 788                 unsigned short conn_type = 0;
 789
 790                 __bt_service_get_parameters(in_param1,
 791                                 &address, sizeof(bluetooth_device_address_t));
 792                 __bt_service_get_parameters(in_param2,
 793                                 &conn_type, sizeof(unsigned short));
 794
 795                 result = _bt_bond_device(request_id, &address,
 796                                 conn_type, out_param1);
 797                 break;
 798         }
 799         case BT_CANCEL_BONDING: {
 800                 result = _bt_cancel_bonding();
 801                 break;
 802         }
 803         case BT_UNBOND_DEVICE: {
 804                 bluetooth_device_address_t address = { {0} };
 805
 806                 __bt_service_get_parameters(in_param1,
 807                                 &address, sizeof(bluetooth_device_address_t));
 808
 809                 result = _bt_unbond_device(request_id, &address, out_param1);
 810
 811                 break;
 812         }
 813         case BT_SET_ALIAS: {
 814                 bluetooth_device_address_t address = { {0} };
 815                 const char *local_name;
 816
 817                 __bt_service_get_parameters(in_param1,
 818                                 &address, sizeof(bluetooth_device_address_t));
 819                 local_name = (const char *)g_variant_get_data(in_param2);
 820
 821                 result = _bt_set_alias(&address, local_name);
 822                 break;
 823         }
 824         case BT_SEARCH_SERVICE: {
 825                 bluetooth_device_address_t address = { {0} };
 826
 827                 __bt_service_get_parameters(in_param1,
 828                                 &address, sizeof(bluetooth_device_address_t));
 829
 830                 result = _bt_search_device(request_id, &address);
 831                 if (result != BLUETOOTH_ERROR_NONE) {
 832                         g_array_append_vals(*out_param1, &address,
 833                                         sizeof(bluetooth_device_address_t));
 834                 }
 835                 break;
 836         }
 837         case BT_CANCEL_SEARCH_SERVICE: {
 838                 result = _bt_cancel_search_device();
 839                 break;
 840         }
 841         case BT_SET_AUTHORIZATION: {
 842                 bluetooth_device_address_t address = { {0} };
 843                 gboolean authorize;
 844
 845                 __bt_service_get_parameters(in_param1,
 846                                 &address, sizeof(bluetooth_device_address_t));
 847                 __bt_service_get_parameters(in_param2,
 848                                 &authorize, sizeof(gboolean));
 849
 850                 result = _bt_set_authorization(&address, authorize);
 851                 break;
 852         }
 853         case BT_IS_DEVICE_CONNECTED: {
 854                 bluetooth_device_address_t address = { {0} };
 855                 int type;
 856                 gboolean connected = FALSE;
 857
 858                 __bt_service_get_parameters(in_param1,
 859                                 &address, sizeof(bluetooth_device_address_t));
 860                 __bt_service_get_parameters(in_param2,
 861                                 &type, sizeof(int));
 862
 863                 result = _bt_is_device_connected(&address, type, &connected);
 864                 BT_DBG("is_connected: %d", connected);
 865                 if (result == BLUETOOTH_ERROR_NONE) {
 866                         g_array_append_vals(*out_param1, &connected,
 867                                                 sizeof(gboolean));
 868                 }
 869
 870                 break;
 871         }
 872         case BT_GET_CONNECTED_LINK_TYPE: {
 873                 bluetooth_device_address_t address = { {0} };
 874                 bluetooth_connected_link_t connected = BLUETOOTH_CONNECTED_LINK_NONE;
 875
 876                 __bt_service_get_parameters(in_param1,
 877                                 &address, sizeof(bluetooth_device_address_t));
 878
 879                 result = _bt_get_connected_link(&address, &connected);
 880
 881                 if (result == BLUETOOTH_ERROR_NONE) {
 882                         g_array_append_vals(*out_param1, &connected,
 883                                         sizeof(guint));
 884                 }
 885
 886                 break;
 887         }
 888
 889         case BT_HID_CONNECT: {
 890                 bluetooth_device_address_t address = { {0} };
 891
 892                 __bt_service_get_parameters(in_param1,
 893                                 &address, sizeof(bluetooth_device_address_t));
 894
 895                 result = _bt_hid_connect(request_id, &address);
 896                 if (result != BLUETOOTH_ERROR_NONE) {
 897                         g_array_append_vals(*out_param1, &address,
 898                                         sizeof(bluetooth_device_address_t));
 899                 }
 900                 break;
 901         }
 902         case BT_HID_DISCONNECT: {
 903                 bluetooth_device_address_t address = { {0} };
 904
 905                 __bt_service_get_parameters(in_param1,
 906                                 &address, sizeof(bluetooth_device_address_t));
 907
 908                 result = _bt_hid_disconnect(request_id, &address);
 909                 if (result != BLUETOOTH_ERROR_NONE) {
 910                         g_array_append_vals(*out_param1, &address,
 911                                         sizeof(bluetooth_device_address_t));
 912                 }
 913                 break;
 914         }
 915         case BT_NETWORK_ACTIVATE:
 916                 result = _bt_network_activate();
 917                 break;
 918         case BT_NETWORK_DEACTIVATE:
 919                 result = _bt_network_deactivate();
 920                 break;
 921         case BT_NETWORK_CONNECT: {
 922                 bluetooth_device_address_t address = { {0} };
 923                 int role;
 924
 925                 __bt_service_get_parameters(in_param1,
 926                                 &address, sizeof(bluetooth_device_address_t));
 927                 __bt_service_get_parameters(in_param2,
 928                                 &role, sizeof(int));
 929
 930                 result = _bt_network_connect(request_id, role, &address);
 931                 if (result != BLUETOOTH_ERROR_NONE) {
 932                         g_array_append_vals(*out_param1, &address,
 933                                         sizeof(bluetooth_device_address_t));
 934                 }
 935                 break;
 936         }
 937         case BT_NETWORK_DISCONNECT: {
 938                 bluetooth_device_address_t address = { {0} };
 939
 940                 __bt_service_get_parameters(in_param1,
 941                                 &address, sizeof(bluetooth_device_address_t));
 942
 943                 result = _bt_network_disconnect(request_id, &address);
 944                 if (result != BLUETOOTH_ERROR_NONE) {
 945                         g_array_append_vals(*out_param1, &address,
 946                                         sizeof(bluetooth_device_address_t));
 947                 }
 948                 break;
 949         }
 950         case BT_NETWORK_SERVER_DISCONNECT: {
 951                 bluetooth_device_address_t address = { {0} };
 952
 953                 __bt_service_get_parameters(in_param1,
 954                                 &address, sizeof(bluetooth_device_address_t));
 955
 956                 result = _bt_network_server_disconnect(request_id, &address);
 957                 if (result != BLUETOOTH_ERROR_NONE) {
 958                         g_array_append_vals(*out_param1, &address,
 959                                         sizeof(bluetooth_device_address_t));
 960                 }
 961                 break;
 962         }
 963
 964         case BT_AUDIO_CONNECT: {
 965                 bluetooth_device_address_t address = { {0} };
 966
 967                 __bt_service_get_parameters(in_param1,
 968                                 &address, sizeof(bluetooth_device_address_t));
 969
 970                 result = _bt_audio_connect(request_id, BT_AUDIO_ALL,
 971                                         &address, out_param1);
 972                 break;
 973         }
 974         case BT_AUDIO_DISCONNECT: {
 975                 bluetooth_device_address_t address = { {0} };
 976
 977                 __bt_service_get_parameters(in_param1,
 978                                 &address, sizeof(bluetooth_device_address_t));
 979
 980                 result = _bt_audio_disconnect(request_id, BT_AUDIO_ALL,
 981                                         &address, out_param1);
 982                 break;
 983         }
 984         case BT_AG_CONNECT: {
 985                 bluetooth_device_address_t address = { {0} };
 986
 987                 __bt_service_get_parameters(in_param1,
 988                                 &address, sizeof(bluetooth_device_address_t));
 989
 990                 result = _bt_audio_connect(request_id, BT_AUDIO_HSP,
 991                                         &address, out_param1);
 992                 break;
 993         }
 994         case BT_AG_DISCONNECT: {
 995                 bluetooth_device_address_t address = { {0} };
 996
 997                 __bt_service_get_parameters(in_param1,
 998                                 &address, sizeof(bluetooth_device_address_t));
 999
1000                 result = _bt_audio_disconnect(request_id, BT_AUDIO_HSP,
1001                                         &address, out_param1);
1002                 break;
1003         }
1004         case BT_AV_CONNECT: {
1005                 bluetooth_device_address_t address = { {0} };
1006
1007                 __bt_service_get_parameters(in_param1,
1008                                 &address, sizeof(bluetooth_device_address_t));
1009
1010                 result = _bt_audio_connect(request_id, BT_AUDIO_A2DP,
1011                                         &address, out_param1);
1012                 break;
1013         }
1014         case BT_AV_DISCONNECT: {
1015                 bluetooth_device_address_t address = { {0} };
1016
1017                 __bt_service_get_parameters(in_param1,
1018                                 &address, sizeof(bluetooth_device_address_t));
1019
1020                 result = _bt_audio_disconnect(request_id, BT_AUDIO_A2DP,
1021                                         &address, out_param1);
1022                 break;
1023         }
1024         case BT_AVRCP_CONTROL_CONNECT: {
1025                 bluetooth_device_address_t address = { {0} };
1026
1027                 __bt_service_get_parameters(in_param1,
1028                                 &address, sizeof(bluetooth_device_address_t));
1029
1030                 result = _bt_audio_connect(request_id, BT_AVRCP,
1031                                         &address, out_param1);
1032                 break;
1033         }
1034         case BT_AVRCP_CONTROL_DISCONNECT: {
1035                 bluetooth_device_address_t address = { {0} };
1036
1037                 __bt_service_get_parameters(in_param1,
1038                                 &address, sizeof(bluetooth_device_address_t));
1039
1040                 result = _bt_audio_disconnect(request_id, BT_AVRCP,
1041                                         &address, out_param1);
1042                 break;
1043         }
1044         case BT_AV_SOURCE_CONNECT: {
1045                 bluetooth_device_address_t address = { {0} };
1046
1047                 __bt_service_get_parameters(in_param1, &address,
1048                                 sizeof(bluetooth_device_address_t));
1049
1050                 result = _bt_audio_connect(request_id, BT_AUDIO_A2DP_SOURCE,
1051                                         &address, out_param1);
1052                 break;
1053         }
1054         case BT_AV_SOURCE_DISCONNECT: {
1055                 bluetooth_device_address_t address = { {0} };
1056
1057                 __bt_service_get_parameters(in_param1, &address,
1058                                 sizeof(bluetooth_device_address_t));
1059
1060                 result = _bt_audio_disconnect(request_id, BT_AUDIO_A2DP_SOURCE,
1061                                         &address, out_param1);
1062                 break;
1063         }
1064         case BT_HF_CONNECT: {
1065                 bluetooth_device_address_t address = { {0} };
1066
1067                 __bt_service_get_parameters(in_param1,
1068                                 &address, sizeof(bluetooth_device_address_t));
1069
1070                 result = _bt_hf_connect(request_id, &address, out_param1);
1071                 break;
1072         }
1073         case BT_HF_DISCONNECT: {
1074                 bluetooth_device_address_t address = { {0} };
1075
1076                 __bt_service_get_parameters(in_param1,
1077                                 &address, sizeof(bluetooth_device_address_t));
1078
1079                 result = _bt_hf_disconnect(request_id, &address, out_param1);
1080                 break;
1081         }
1082         case BT_SET_CONTENT_PROTECT: {
1083                 gboolean status;
1084
1085                 __bt_service_get_parameters(in_param1,
1086                                 &status, sizeof(gboolean));
1087
1088                 result = _bt_audio_set_content_protect(status);
1089
1090                 break;
1091         }
1092         case BT_OOB_READ_LOCAL_DATA: {
1093                 bt_oob_data_t local_oob_data;
1094
1095                 memset(&local_oob_data, 0x00, sizeof(bt_oob_data_t));
1096                 result = _bt_oob_read_local_data(&local_oob_data);
1097
1098                 g_array_append_vals(*out_param1, &local_oob_data,
1099                                 sizeof(bt_oob_data_t));
1100
1101                 break;
1102         }
1103         case BT_OOB_ADD_REMOTE_DATA: {
1104                 bluetooth_device_address_t address = { {0} };
1105                 bt_oob_data_t local_oob_data;
1106
1107                 __bt_service_get_parameters(in_param1,
1108                                 &address, sizeof(bluetooth_device_address_t));
1109                 __bt_service_get_parameters(in_param2,
1110                                 &local_oob_data, sizeof(bt_oob_data_t));
1111
1112                 result = _bt_oob_add_remote_data(&address, &local_oob_data);
1113
1114                 break;
1115         }
1116         case BT_OOB_REMOVE_REMOTE_DATA: {
1117                 bluetooth_device_address_t address = { {0} };
1118
1119                 __bt_service_get_parameters(in_param1,
1120                                 &address, sizeof(bluetooth_device_address_t));
1121
1122                 result = _bt_oob_remove_remote_data(&address);
1123
1124                 break;
1125         }
1126         case BT_AVRCP_SET_TRACK_INFO: {
1127                 media_metadata_t data;
1128                 media_metadata_attributes_t meta_data;
1129
1130                 memset(&data, 0x00, sizeof(media_metadata_t));
1131                 memset(&meta_data, 0x00, sizeof(media_metadata_attributes_t));
1132
1133                 __bt_service_get_parameters(in_param1,
1134                                 &data, sizeof(media_metadata_t));
1135
1136                 meta_data.title = g_strdup(data.title);
1137                 meta_data.artist = g_strdup(data.artist);
1138                 meta_data.album = g_strdup(data.album);
1139                 meta_data.genre = g_strdup(data.genre);
1140                 meta_data.total_tracks = data.total_tracks;
1141                 meta_data.number = data.number;
1142                 meta_data.duration = (int64_t) data.duration;
1143
1144                 result = _bt_avrcp_set_track_info(&meta_data);
1145
1146                 g_free((gpointer)meta_data.title);
1147                 g_free((gpointer)meta_data.artist);
1148                 g_free((gpointer)meta_data.album);
1149                 g_free((gpointer)meta_data.genre);
1150
1151                 break;
1152         }
1153         case BT_AVRCP_SET_PROPERTY: {
1154                 int type;
1155                 unsigned int value;
1156
1157                 __bt_service_get_parameters(in_param1,
1158                                 &type, sizeof(int));
1159                 __bt_service_get_parameters(in_param2,
1160                                 &value, sizeof(unsigned int));
1161
1162                 result = _bt_avrcp_set_property(type, value);
1163
1164                 break;
1165         }
1166         case BT_AVRCP_SET_PROPERTIES: {
1167                 media_player_settings_t properties;
1168
1169                 memset(&properties, 0x00, sizeof(media_player_settings_t));
1170                 __bt_service_get_parameters(in_param1,
1171                                 &properties, sizeof(media_player_settings_t));
1172
1173                 result = _bt_avrcp_set_properties(&properties);
1174
1175                 break;
1176         }
1177         case BT_AVRCP_HANDLE_CONTROL: {
1178                 int type;
1179
1180                 __bt_service_get_parameters(in_param1, &type, sizeof(int));
1181
1182                 result = _bt_avrcp_control_cmd(type);
1183
1184                 break;
1185         }
1186         case BT_AVRCP_CONTROL_SET_PROPERTY: {
1187                 int type;
1188                 unsigned int value;
1189
1190                 __bt_service_get_parameters(in_param1,
1191                                 &type, sizeof(int));
1192                 __bt_service_get_parameters(in_param2,
1193                                 &value, sizeof(unsigned int));
1194
1195                 result = _bt_avrcp_control_set_property(type, value);
1196
1197                 break;
1198         }
1199         case BT_AVRCP_CONTROL_GET_PROPERTY: {
1200                 int type;
1201                 unsigned int value;
1202
1203                 __bt_service_get_parameters(in_param1, &type, sizeof(int));
1204
1205                 result = _bt_avrcp_control_get_property(type, &value);
1206                 g_array_append_vals(*out_param1, &value, sizeof(int));
1207
1208                 break;
1209         }
1210         case BT_AVRCP_GET_TRACK_INFO: {
1211                 media_metadata_t meta_data;
1212                 media_metadata_attributes_t metadata;
1213
1214                 memset(&meta_data, 0x00, sizeof(media_metadata_t));
1215                 memset(&metadata, 0x00, sizeof(media_metadata_attributes_t));
1216
1217                 result = _bt_avrcp_control_get_track_info(&metadata);
1218
1219                 if (BLUETOOTH_ERROR_NONE != result)
1220                         break;
1221
1222                 if (_bt_copy_utf8_string(meta_data.title, metadata.title,
1223                                                         BT_META_DATA_MAX_LEN))
1224                         BT_ERR("Error in copying Title\n");
1225                 if (_bt_copy_utf8_string(meta_data.artist, metadata.artist,
1226                                                         BT_META_DATA_MAX_LEN))
1227                         BT_ERR("Error in copying Artist\n");
1228                 if (_bt_copy_utf8_string(meta_data.album, metadata.album,
1229                                                         BT_META_DATA_MAX_LEN))
1230                         BT_ERR("Error in copying Album\n");
1231                 if (_bt_copy_utf8_string(meta_data.genre, metadata.genre,
1232                                                         BT_META_DATA_MAX_LEN))
1233                         BT_ERR("Error in copying Genre\n");
1234
1235                 if (_bt_utf8_validate(meta_data.title) == FALSE)
1236                         meta_data.title[0] = '\0';
1237
1238                 if (_bt_utf8_validate(meta_data.artist) == FALSE)
1239                         meta_data.artist[0] = '\0';
1240
1241                 if (_bt_utf8_validate(meta_data.album) == FALSE)
1242                         meta_data.album[0] = '\0';
1243
1244                 if (_bt_utf8_validate(meta_data.genre) == FALSE)
1245                         meta_data.genre[0] = '\0';
1246
1247                 meta_data.total_tracks = metadata.total_tracks;
1248                 meta_data.number = metadata.number;
1249                 meta_data.duration = metadata.duration;
1250
1251                 g_free((gpointer)metadata.title);
1252                 g_free((gpointer)metadata.artist);
1253                 g_free((gpointer)metadata.album);
1254                 g_free((gpointer)metadata.genre);
1255
1256                 g_array_append_vals(*out_param1, &meta_data,
1257                                         sizeof(media_metadata_t));
1258                 break;
1259         }
1260         case BT_RFCOMM_CLIENT_CONNECT: {
1261 #ifdef RFCOMM_DIRECT
1262                 result = BLUETOOTH_ERROR_NONE;
1263 #else
1264                 bluetooth_device_address_t address = { {0} };
1265                 char *input_string;
1266                 int connect_type;
1267
1268                 __bt_service_get_parameters(in_param1,
1269                                 &address, sizeof(bluetooth_device_address_t));
1270
1271                 input_string = &g_array_index(in_param2, char, 0);
1272
1273                 connect_type = g_array_index(in_param3, int, 0);
1274
1275                 if (connect_type == BT_RFCOMM_UUID) {
1276                         result = _bt_rfcomm_connect_using_uuid(request_id,
1277                                                         &address, input_string);
1278                 } else {
1279                         result = _bt_rfcomm_connect_using_channel(request_id,
1280                                                         &address, input_string);
1281                 }
1282
1283                 if (result != BLUETOOTH_ERROR_NONE) {
1284                         g_array_append_vals(*out_param1, &address,
1285                                         sizeof(bluetooth_device_address_t));
1286                 }
1287 #endif
1288                 break;
1289         }
1290         case BT_RFCOMM_CLIENT_CANCEL_CONNECT:
1291                 result = _bt_rfcomm_cancel_connect();
1292                 break;
1293         case BT_RFCOMM_CLIENT_IS_CONNECTED: {
1294                 gboolean connected = FALSE;
1295                 result = _bt_rfcomm_is_connected(&connected);
1296
1297                 g_array_append_vals(*out_param1, &connected, sizeof(gboolean));
1298                 break;
1299         }
1300         case BT_RFCOMM_SOCKET_DISCONNECT: {
1301 #ifdef RFCOMM_DIRECT
1302                 result = BLUETOOTH_ERROR_NONE;
1303 #else
1304                 int socket_fd;
1305
1306                 socket_fd = g_array_index(in_param1, int, 0);
1307
1308                 result = _bt_rfcomm_disconnect(socket_fd);
1309 #endif
1310                 break;
1311         }
1312         case BT_RFCOMM_SOCKET_WRITE: {
1313 #ifdef RFCOMM_DIRECT
1314                 result = BLUETOOTH_ERROR_NONE;
1315 #else
1316                 int socket_fd;
1317                 int length;
1318                 char *buffer;
1319
1320                 socket_fd = g_array_index(in_param1, int, 0);
1321                 length = g_array_index(in_param2, int, 0);
1322                 buffer = &g_array_index(in_param3, char, 0);
1323
1324                 result = _bt_rfcomm_write(socket_fd, buffer, length);
1325 #endif
1326                 break;
1327         }
1328         case BT_RFCOMM_CREATE_SOCKET: {
1329 #ifdef RFCOMM_DIRECT
1330                 result = BLUETOOTH_ERROR_NONE;
1331 #else
1332                 char *sender;
1333                 char *uuid;
1334                 int socket_fd = -1;
1335
1336                 sender = dbus_g_method_get_sender(context);
1337                 uuid = &g_array_index(in_param1, char, 0);
1338
1339                 result = _bt_rfcomm_create_socket(sender, uuid);
1340
1341                 if (result > 0) {
1342                         socket_fd = result;
1343                         result = BLUETOOTH_ERROR_NONE;
1344                 }
1345
1346                 g_array_append_vals(*out_param1, &socket_fd, sizeof(int));
1347
1348                 g_free(sender);
1349 #endif
1350                 break;
1351         }
1352         case BT_RFCOMM_REMOVE_SOCKET: {
1353 #ifdef RFCOMM_DIRECT
1354                 result = BLUETOOTH_ERROR_NONE;
1355 #else
1356                 int socket_fd;
1357
1358                 socket_fd = g_array_index(in_param1, int, 0);
1359
1360                 result = _bt_rfcomm_remove_socket(socket_fd);
1361 #endif
1362                 break;
1363         }
1364         case BT_RFCOMM_LISTEN: {
1365                 int socket_fd;
1366                 int pending;
1367                 gboolean is_native;
1368
1369                 __bt_service_get_parameters(in_param1, &socket_fd,
1370                                 sizeof(int));
1371                 __bt_service_get_parameters(in_param2, &pending,
1372                                 sizeof(int));
1373                 __bt_service_get_parameters(in_param3, &is_native,
1374                                 sizeof(gboolean));
1375
1376                 result = _bt_rfcomm_listen(socket_fd, pending, is_native);
1377                 break;
1378         }
1379         case BT_RFCOMM_IS_UUID_AVAILABLE: {
1380                 gboolean available = TRUE;
1381                 char *uuid;
1382
1383                 uuid = (char *)g_variant_get_data(in_param1);
1384
1385                 result = _bt_rfcomm_is_uuid_available(uuid, &available);
1386
1387                 g_array_append_vals(*out_param1, &available, sizeof(gboolean));
1388                 break;
1389         }
1390         case BT_RFCOMM_ACCEPT_CONNECTION: {
1391                 int socket_fd;
1392
1393                 __bt_service_get_parameters(in_param1, &socket_fd, sizeof(int));
1394                 BT_DBG(" socket fd %d", socket_fd);
1395                 result = _bt_rfcomm_accept_connection();
1396                 break;
1397         }
1398         case BT_RFCOMM_REJECT_CONNECTION: {
1399                 int socket_fd;
1400
1401                 __bt_service_get_parameters(in_param1, &socket_fd, sizeof(int));
1402                 BT_DBG(" socket fd %d", socket_fd);
1403                 result = _bt_rfcomm_reject_connection();
1404                 break;
1405         }
1406         case BT_RFCOMM_CREATE_SOCKET_EX: {
1407                 result = BLUETOOTH_ERROR_NONE;
1408                 break;
1409         }
1410         case BT_RFCOMM_REMOVE_SOCKET_EX: {
1411                 result = BLUETOOTH_ERROR_NONE;
1412                 break;
1413         }
1414         case BT_CONNECT_LE: {
1415                 bluetooth_device_address_t address = { {0} };
1416                 gboolean auto_connect;
1417
1418                 __bt_service_get_parameters(in_param1,
1419                                 &address, sizeof(bluetooth_device_address_t));
1420                 __bt_service_get_parameters(in_param2,
1421                                 &auto_connect, sizeof(gboolean));
1422
1423                 result = _bt_connect_le_device(&address, auto_connect);
1424
1425                 break;
1426         }
1427         case BT_DISCONNECT_LE: {
1428                 bluetooth_device_address_t address = { {0} };
1429
1430                 __bt_service_get_parameters(in_param1, &address,
1431                                 sizeof(bluetooth_device_address_t));
1432
1433                 result = _bt_disconnect_le_device(&address);
1434
1435                 break;
1436         }
1437         case BT_SET_LE_PRIVACY: {
1438                 gboolean set_privacy;
1439
1440                 __bt_service_get_parameters(in_param1, &set_privacy,
1441                                 sizeof(gboolean));
1442
1443                 result = _bt_set_le_privacy(set_privacy);
1444
1445                 break;
1446         }
1447         case BT_HDP_CONNECT:
1448         case BT_HDP_DISCONNECT:
1449         case BT_HDP_SEND_DATA:
1450
1451         case BT_GATT_GET_PRIMARY_SERVICES:
1452         case BT_GATT_DISCOVER_CHARACTERISTICS:
1453         case BT_GATT_SET_PROPERTY_REQUEST:
1454         case BT_GATT_READ_CHARACTERISTIC:
1455         case BT_GATT_DISCOVER_CHARACTERISTICS_DESCRIPTOR:
1456                 /* Just call to check the privilege */
1457                 break;
1458         default:
1459                 result = BLUETOOTH_ERROR_INTERNAL;
1460                 break;
1461         }
1462
1463         return result;
1464 }
1465
1466 int __bt_obexd_request(int function_name,
1467                 int request_type,
1468                 int request_id,
1469                 GDBusMethodInvocation *context,
1470                 GVariant *in_param1,
1471                 GVariant *in_param2,
1472                 GVariant *in_param3,
1473                 GVariant *in_param4,
1474                 GArray **out_param1)
1475 {
1476         BT_DBG("+");
1477
1478         int result;
1479
1480         BT_DBG("function_name : %x", function_name);
1481
1482         switch (function_name) {
1483         case BT_OPP_PUSH_FILES: {
1484                 BT_DBG("BT_OPP_PUSH_FILES");
1485                 int i;
1486                 bluetooth_device_address_t address = { {0} };
1487                 bt_file_path_t path;
1488                 char **file_path;
1489                 int file_count;
1490                 GArray *param2;
1491
1492                 __bt_service_get_parameters(in_param1, &address,
1493                                 sizeof(bluetooth_device_address_t));
1494                 __bt_service_get_parameters(in_param3, &file_count,
1495                                 sizeof(int));
1496
1497                 file_path = g_new0(char *, file_count + 1);
1498
1499                 param2 = g_array_new(TRUE, TRUE, sizeof(gchar));
1500                 __bt_fill_garray_from_variant(in_param2, param2);
1501
1502                 for (i = 0; i < file_count; i++) {
1503                         path = g_array_index(param2, bt_file_path_t, i);
1504                         file_path[i] = g_strdup(path.path);
1505                 }
1506                 BT_DBG("_bt_opp_client_push_files");
1507                 result = _bt_opp_client_push_files(request_id, context,
1508                                                 &address, file_path,
1509                                                 file_count);
1510
1511                 for (i = 0; i < file_count; i++) {
1512                         g_free(file_path[i]);
1513                 }
1514                 g_free(file_path);
1515                 g_array_free(param2, TRUE);
1516
1517                 break;
1518         }
1519         case BT_OPP_CANCEL_PUSH: {
1520                 result = _bt_opp_client_cancel_push();
1521
1522                 break;
1523         }
1524         case BT_OPP_IS_PUSHING_FILES: {
1525                 gboolean is_sending = FALSE;
1526
1527                 result = _bt_opp_client_is_sending(&is_sending);
1528
1529                 g_array_append_vals(*out_param1, &is_sending,
1530                                 sizeof(gboolean));
1531                 break;
1532         }
1533         case BT_OBEX_SERVER_ALLOCATE: {
1534                 int app_pid;
1535                 gboolean is_native;
1536                 char *path;
1537                 char *sender;
1538
1539                 sender = (char *)g_dbus_method_invocation_get_sender(context);
1540
1541                 path = (char *)g_variant_get_data(in_param1);
1542                 __bt_service_get_parameters(in_param2, &is_native,
1543                                 sizeof(gboolean));
1544                 __bt_service_get_parameters(in_param3, &app_pid,
1545                                 sizeof(int));
1546
1547                 result = _bt_obex_server_allocate(sender,
1548                                 path, app_pid, is_native);
1549
1550                 break;
1551         }
1552         case BT_OBEX_SERVER_DEALLOCATE: {
1553                 int app_pid;
1554                 gboolean is_native;
1555
1556                 __bt_service_get_parameters(in_param1, &is_native,
1557                                 sizeof(gboolean));
1558                 __bt_service_get_parameters(in_param2, &app_pid,
1559                                 sizeof(int));
1560
1561                 result = _bt_obex_server_deallocate(app_pid, is_native);
1562                 break;
1563         }
1564         case BT_OBEX_SERVER_IS_ACTIVATED: {
1565                 gboolean is_activated = FALSE;
1566
1567                 result = _bt_obex_server_is_activated(&is_activated);
1568
1569                 g_array_append_vals(*out_param1, &is_activated,
1570                                 sizeof(gboolean));
1571
1572                 break;
1573         }
1574         case BT_OBEX_SERVER_ACCEPT_CONNECTION: {
1575                 result = _bt_obex_server_accept_connection(request_id);
1576
1577                 break;
1578         }
1579         case BT_OBEX_SERVER_REJECT_CONNECTION: {
1580                 result = _bt_obex_server_reject_connection();
1581
1582                 break;
1583         }
1584         case BT_OBEX_SERVER_ACCEPT_FILE: {
1585                 char *file_name;
1586
1587                 file_name = (char *)g_variant_get_data(in_param1);
1588
1589                 result = _bt_obex_server_accept_authorize(file_name, TRUE);
1590
1591                 break;
1592         }
1593         case BT_OBEX_SERVER_REJECT_FILE: {
1594                 result = _bt_obex_server_reject_authorize();
1595
1596                 break;
1597         }
1598         case BT_OBEX_SERVER_SET_PATH: {
1599                 gboolean is_native;
1600                 char *destination_path;
1601
1602                 destination_path = (char *)g_variant_get_data(in_param1);
1603                 __bt_service_get_parameters(in_param2, &is_native,
1604                                 sizeof(gboolean));
1605
1606                 result = _bt_obex_server_set_destination_path(destination_path,
1607                                                         is_native);
1608
1609                 break;
1610         }
1611         case BT_OBEX_SERVER_SET_ROOT: {
1612                 char *root;
1613
1614                 root = (char *)g_variant_get_data(in_param1);
1615
1616                 result = _bt_obex_server_set_root(root);
1617
1618                 break;
1619         }
1620         case BT_OBEX_SERVER_CANCEL_TRANSFER: {
1621                 int transfer_id;
1622
1623                 __bt_service_get_parameters(in_param1, &transfer_id,
1624                                 sizeof(int));
1625
1626                 result = _bt_obex_server_cancel_transfer(transfer_id);
1627
1628                 break;
1629         }
1630         case BT_OBEX_SERVER_CANCEL_ALL_TRANSFERS: {
1631                 result = _bt_obex_server_cancel_all_transfers();
1632
1633                 break;
1634         }
1635         case BT_OBEX_SERVER_IS_RECEIVING: {
1636                 gboolean is_receiving = FALSE;
1637
1638                 result = _bt_obex_server_is_receiving(&is_receiving);
1639
1640                 g_array_append_vals(*out_param1, &is_receiving,
1641                                 sizeof(gboolean));
1642                 break;
1643         }
1644         case BT_PBAP_CONNECT: {
1645                 bluetooth_device_address_t address = { {0} };
1646
1647                 __bt_service_get_parameters(in_param1, &address,
1648                                 sizeof(bluetooth_device_address_t));
1649
1650                 result = _bt_pbap_connect(&address);
1651                 break;
1652         }
1653         case BT_PBAP_DISCONNECT: {
1654                 bluetooth_device_address_t address = { {0} };
1655
1656                 __bt_service_get_parameters(in_param1, &address,
1657                                 sizeof(bluetooth_device_address_t));
1658
1659                 result = _bt_pbap_disconnect(&address);
1660                 break;
1661         }
1662         case BT_PBAP_GET_PHONEBOOK_SIZE: {
1663                 bluetooth_device_address_t address = { {0} };
1664                 bt_pbap_folder_t folder = { 0, };
1665
1666                 __bt_service_get_parameters(in_param1, &address,
1667                                 sizeof(bluetooth_device_address_t));
1668                 __bt_service_get_parameters(in_param2, &folder,
1669                                 sizeof(bt_pbap_folder_t));
1670
1671                 result = _bt_pbap_get_phonebook_size(&address,
1672                                 folder.addressbook, folder.folder_type);
1673                 break;
1674         }
1675         case BT_PBAP_GET_PHONEBOOK: {
1676                 bluetooth_device_address_t address = { {0} };
1677                 bt_pbap_folder_t folder = { 0, };
1678                 bt_pbap_pull_parameters_t app_param = { 0, };
1679
1680                 __bt_service_get_parameters(in_param1, &address,
1681                                 sizeof(bluetooth_device_address_t));
1682                 __bt_service_get_parameters(in_param2, &folder,
1683                                 sizeof(bt_pbap_folder_t));
1684                 __bt_service_get_parameters(in_param3, &app_param,
1685                                 sizeof(bt_pbap_pull_parameters_t));
1686
1687                 result = _bt_pbap_get_phonebook(&address, folder.addressbook,
1688                                 folder.folder_type, &app_param);
1689                 break;
1690         }
1691         case BT_PBAP_GET_LIST: {
1692                 bluetooth_device_address_t address = { {0} };
1693                 bt_pbap_folder_t folder = { 0, };
1694                 bt_pbap_list_parameters_t app_param = { 0, };
1695
1696                 __bt_service_get_parameters(in_param1, &address,
1697                                 sizeof(bluetooth_device_address_t));
1698                 __bt_service_get_parameters(in_param2, &folder,
1699                                 sizeof(bt_pbap_folder_t));
1700                 __bt_service_get_parameters(in_param3, &app_param,
1701                                 sizeof(bt_pbap_list_parameters_t));
1702
1703                 result = _bt_pbap_get_list(&address, folder.addressbook,
1704                                 folder.folder_type, &app_param);
1705                 break;
1706         }
1707         case BT_PBAP_PULL_VCARD: {
1708                 bluetooth_device_address_t address = { {0} };
1709                 bt_pbap_folder_t folder = { 0, };
1710                 bt_pbap_pull_vcard_parameters_t app_param = { 0, };
1711
1712                 __bt_service_get_parameters(in_param1, &address,
1713                                 sizeof(bluetooth_device_address_t));
1714                 __bt_service_get_parameters(in_param2, &folder,
1715                                 sizeof(bt_pbap_folder_t));
1716                 __bt_service_get_parameters(in_param3, &app_param,
1717                                 sizeof(bt_pbap_pull_vcard_parameters_t));
1718
1719                 result = _bt_pbap_pull_vcard(&address, folder.addressbook,
1720                                 folder.folder_type, &app_param);
1721                 break;
1722         }
1723         case BT_PBAP_PHONEBOOK_SEARCH: {
1724                 bluetooth_device_address_t address = { {0} };
1725                 bt_pbap_folder_t folder = { 0, };
1726                 bt_pbap_search_parameters_t app_param = { 0, };
1727
1728                 __bt_service_get_parameters(in_param1, &address,
1729                                 sizeof(bluetooth_device_address_t));
1730                 __bt_service_get_parameters(in_param2, &folder,
1731                                 sizeof(bt_pbap_folder_t));
1732                 __bt_service_get_parameters(in_param3, &app_param,
1733                                 sizeof(bt_pbap_search_parameters_t));
1734
1735                 result = _bt_pbap_phonebook_search(&address, folder.addressbook,
1736                                 folder.folder_type, &app_param);
1737                 break;
1738         }
1739
1740         default:
1741                 BT_ERR("Unknown function!");
1742                 result = BLUETOOTH_ERROR_INTERNAL;
1743                 break;
1744         }
1745
1746         FN_END;
1747
1748         return result;
1749 }
1750
1751 int __bt_agent_request(int function_name,
1752                 int request_type,
1753                 int request_id,
1754                 GDBusMethodInvocation *context,
1755                 GVariant *in_param1,
1756                 GVariant *in_param2,
1757                 GVariant *in_param3,
1758                 GVariant *in_param4,
1759                 GArray **out_param1)
1760 {
1761         int result;
1762         switch (function_name) {
1763         case BT_SET_AUTHORIZATION: {
1764                 int type;
1765                 char *uuid;
1766                 char *path;
1767                 int fd;
1768
1769                 __bt_service_get_parameters(in_param1, &type, sizeof(int));
1770                 uuid = (char *)g_variant_get_data(in_param2);
1771                 path = (char *)g_variant_get_data(in_param3);
1772                 __bt_service_get_parameters(in_param4, &fd, sizeof(int));
1773
1774                 result = _bt_register_osp_server_in_agent(type, uuid, path, fd);
1775                 break;
1776         }
1777         case BT_UNSET_AUTHORIZATION: {
1778                 int type;
1779                 char *uuid;
1780
1781                 __bt_service_get_parameters(in_param1, &type, sizeof(int));
1782                 uuid = (char *)g_variant_get_data(in_param2);
1783
1784                 result = _bt_unregister_osp_server_in_agent(type, uuid);
1785                 break;
1786         }
1787         default:
1788                 BT_ERR("Unknown function!");
1789                 result = BLUETOOTH_ERROR_INTERNAL;
1790                 break;
1791         }
1792
1793         return result;
1794 }
1795
1796 int __bt_core_request(int function_name,
1797                 int request_type,
1798                 int request_id,
1799                 GDBusMethodInvocation *context,
1800                 GVariant *in_param1)
1801 {
1802         int result;
1803
1804         switch (function_name) {
1805         case BT_ENABLE_ADAPTER:
1806         {
1807                 bt_status_t status;
1808
1809                 status = _bt_adapter_get_status();
1810
1811                 if (status == BT_ACTIVATING) {
1812                         BT_DBG("Enabling in progress");
1813                         result = BLUETOOTH_ERROR_IN_PROGRESS;
1814                 } else if (status == BT_ACTIVATED) {
1815                         BT_DBG("Already enabled");
1816                         result = BLUETOOTH_ERROR_DEVICE_ALREADY_ENABLED;
1817                 } else {
1818                         _bt_adapter_set_status(BT_ACTIVATING);
1819                         _bt_adapter_start_enable_timer();
1820                         result = BLUETOOTH_ERROR_NONE;
1821                 }
1822
1823                 break;
1824         }
1825         case BT_DISABLE_ADAPTER:
1826         {
1827                 bt_status_t status;
1828
1829                 status = _bt_adapter_get_status();
1830                 if (status == BT_DEACTIVATING) {
1831                                 BT_DBG("Disabling in progress");
1832                                 result = BLUETOOTH_ERROR_IN_PROGRESS;
1833                 } else if (status == BT_DEACTIVATED) {
1834                                 BT_DBG("Already disabled");
1835                                 result = BLUETOOTH_ERROR_DEVICE_NOT_ENABLED;
1836                 } else {
1837                         _bt_adapter_set_status(BT_DEACTIVATING);
1838                         result = BLUETOOTH_ERROR_NONE;
1839                 }
1840
1841                 break;
1842         }
1843         case BT_ENABLE_ADAPTER_LE:
1844         {
1845                 bt_le_status_t le_status;
1846
1847                 le_status = _bt_adapter_get_le_status();
1848                 if (le_status == BT_LE_ACTIVATING) {
1849                         BT_DBG("Enabling in progress");
1850                         result = BLUETOOTH_ERROR_IN_PROGRESS;
1851                 } else if (le_status == BT_LE_ACTIVATED) {
1852                         BT_DBG("Already enabled");
1853                         result = BLUETOOTH_ERROR_DEVICE_ALREADY_ENABLED;
1854                 } else {
1855                         _bt_adapter_set_le_status(BT_LE_ACTIVATING);
1856                         _bt_adapter_start_le_enable_timer();
1857                         result = BLUETOOTH_ERROR_NONE;
1858                 }
1859
1860                 break;
1861         }
1862         case BT_DISABLE_ADAPTER_LE:
1863         {
1864                 bt_le_status_t le_status;
1865
1866                 le_status = _bt_adapter_get_le_status();
1867                 if (le_status == BT_LE_DEACTIVATING) {
1868                                 BT_DBG("Disabling in progress");
1869                                 result = BLUETOOTH_ERROR_IN_PROGRESS;
1870                 } else if (le_status == BT_LE_DEACTIVATED) {
1871                                 BT_DBG("Already disabled");
1872                                 result = BLUETOOTH_ERROR_DEVICE_NOT_ENABLED;
1873                 } else {
1874                         _bt_adapter_set_le_status(BT_LE_DEACTIVATING);
1875                         result = BLUETOOTH_ERROR_NONE;
1876                 }
1877
1878                 break;
1879         }
1880         default:
1881                 BT_ERR("Unknown function!");
1882                 result = BLUETOOTH_ERROR_INTERNAL;
1883                 break;
1884         }
1885
1886         return result;
1887 }
1888
1889 gboolean __bt_service_check_privilege(int function_name,
1890                                         int service_type,
1891                                         const char *unique_name)
1892 {
1893         int ret_val;
1894         gboolean result = TRUE;
1895         char *client_creds = NULL;
1896         char *user_creds = NULL;
1897         char *client_session = "";
1898         int client_creds_method = CLIENT_METHOD_SMACK;
1899         int user_creds_method = USER_METHOD_UID;
1900         char err_msg[256] = {0, };
1901
1902         retv_if(unique_name == NULL, FALSE);
1903
1904         BT_DBG("unique_name: %s", unique_name);
1905
1906         retv_if(bt_service_conn == NULL, FALSE);
1907
1908         ret_val = cynara_creds_get_default_client_method(&client_creds_method);
1909         if (ret_val != CYNARA_API_SUCCESS) {
1910                 cynara_strerror(ret_val, err_msg, sizeof(err_msg));
1911                 BT_ERR("Fail to get default client method: %s", err_msg);
1912                 return FALSE;
1913         }
1914
1915         ret_val = cynara_creds_get_default_user_method(&user_creds_method);
1916         if (ret_val != CYNARA_API_SUCCESS) {
1917                 cynara_strerror(ret_val, err_msg, sizeof(err_msg));
1918                 BT_ERR("Fail to get default user method: %s", err_msg);
1919                 return FALSE;
1920         }
1921
1922         ret_val = cynara_creds_gdbus_get_client(bt_service_conn, unique_name, client_creds_method, &client_creds);
1923         if (ret_val != CYNARA_API_SUCCESS) {
1924                 cynara_strerror(ret_val, err_msg, sizeof(err_msg));
1925                 BT_ERR("Fail to get client credential: %s", err_msg);
1926                 return FALSE;
1927         }
1928
1929         BT_DBG("client_creds: %s", client_creds);
1930
1931         ret_val = cynara_creds_gdbus_get_user(bt_service_conn, unique_name, user_creds_method, &user_creds);
1932         if (ret_val != CYNARA_API_SUCCESS) {
1933                 cynara_strerror(ret_val, err_msg, sizeof(err_msg));
1934                 BT_ERR("Fail to get user credential: %s", err_msg);
1935                 if (client_creds)
1936                         free(client_creds);
1937                 return FALSE;
1938         }
1939
1940         BT_DBG("user_creds: %s", user_creds);
1941
1942         switch (function_name) {
1943         case BT_SET_LOCAL_NAME:
1944         case BT_START_DISCOVERY:
1945         case BT_START_CUSTOM_DISCOVERY:
1946         case BT_CANCEL_DISCOVERY:
1947         case BT_OOB_ADD_REMOTE_DATA:
1948         case BT_OOB_REMOVE_REMOTE_DATA:
1949         case BT_SET_ADVERTISING:
1950         case BT_SET_CUSTOM_ADVERTISING:
1951         case BT_START_LE_DISCOVERY:
1952         case BT_STOP_LE_DISCOVERY:
1953
1954         case BT_BOND_DEVICE:
1955         case BT_CANCEL_BONDING:
1956         case BT_UNBOND_DEVICE:
1957         case BT_SET_ALIAS:
1958         case BT_SET_AUTHORIZATION:
1959         case BT_UNSET_AUTHORIZATION:
1960         case BT_SEARCH_SERVICE:
1961
1962         case BT_RFCOMM_CLIENT_CONNECT:
1963         case BT_RFCOMM_CLIENT_CANCEL_CONNECT:
1964         case BT_RFCOMM_SOCKET_DISCONNECT:
1965         case BT_RFCOMM_SOCKET_WRITE:
1966         case BT_RFCOMM_CREATE_SOCKET:
1967         case BT_RFCOMM_REMOVE_SOCKET:
1968
1969         case BT_OPP_PUSH_FILES:
1970         case BT_OPP_CANCEL_PUSH:
1971
1972         case BT_OBEX_SERVER_ACCEPT_CONNECTION:
1973         case BT_OBEX_SERVER_REJECT_CONNECTION:
1974         case BT_OBEX_SERVER_ACCEPT_FILE:
1975         case BT_OBEX_SERVER_REJECT_FILE:
1976         case BT_OBEX_SERVER_SET_PATH:
1977         case BT_OBEX_SERVER_SET_ROOT:
1978         case BT_OBEX_SERVER_CANCEL_TRANSFER:
1979         case BT_OBEX_SERVER_CANCEL_ALL_TRANSFERS:
1980
1981         case BT_AUDIO_CONNECT:
1982         case BT_AUDIO_DISCONNECT:
1983         case BT_AG_CONNECT:
1984         case BT_AG_DISCONNECT:
1985         case BT_AV_CONNECT:
1986         case BT_AV_DISCONNECT:
1987         case BT_AVRCP_CONTROL_CONNECT:
1988         case BT_AVRCP_CONTROL_DISCONNECT:
1989         case BT_HF_CONNECT:
1990         case BT_HF_DISCONNECT:
1991
1992         case BT_HID_CONNECT:
1993         case BT_HID_DISCONNECT:
1994
1995         case BT_CONNECT_LE:
1996         case BT_DISCONNECT_LE:
1997
1998         case BT_SET_ADVERTISING_DATA:
1999         case BT_SET_SCAN_RESPONSE_DATA:
2000
2001         case BT_HDP_CONNECT:
2002         case BT_HDP_DISCONNECT:
2003         case BT_HDP_SEND_DATA:
2004
2005         case BT_NETWORK_ACTIVATE:
2006         case BT_NETWORK_DEACTIVATE:
2007         case BT_NETWORK_CONNECT:
2008         case BT_NETWORK_DISCONNECT:
2009         case BT_NETWORK_SERVER_DISCONNECT:
2010
2011         case BT_GATT_GET_PRIMARY_SERVICES:
2012         case BT_GATT_DISCOVER_CHARACTERISTICS:
2013         case BT_GATT_SET_PROPERTY_REQUEST:
2014         case BT_GATT_READ_CHARACTERISTIC:
2015         case BT_GATT_DISCOVER_CHARACTERISTICS_DESCRIPTOR:
2016                 ret_val = cynara_check(p_cynara, client_creds, client_session, user_creds,
2017                                                                                  BT_PRIVILEGE_PUBLIC);
2018
2019                 if (ret_val != CYNARA_API_ACCESS_ALLOWED) {
2020                         BT_ERR("Fail to access: %s", BT_PRIVILEGE_PUBLIC);
2021                         result = FALSE;
2022                 }
2023         break;
2024
2025         case BT_ENABLE_ADAPTER:
2026         case BT_DISABLE_ADAPTER:
2027         case BT_RESET_ADAPTER:
2028         case BT_RECOVER_ADAPTER:
2029         case BT_ENABLE_ADAPTER_LE:
2030         case BT_DISABLE_ADAPTER_LE:
2031         case BT_SET_CONNECTABLE:
2032         case BT_SET_DISCOVERABLE_MODE:
2033         case BT_ADD_WHITE_LIST:
2034         case BT_REMOVE_WHITE_LIST:
2035         case BT_CLEAR_WHITE_LIST:
2036         case BT_SET_MANUFACTURER_DATA:
2037         case BT_SET_SCAN_PARAMETERS:
2038
2039         case BT_CANCEL_SEARCH_SERVICE:
2040         case BT_ENABLE_RSSI:
2041
2042         case BT_RFCOMM_ACCEPT_CONNECTION:
2043         case BT_RFCOMM_REJECT_CONNECTION:
2044         case BT_RFCOMM_LISTEN:
2045
2046         case BT_AVRCP_SET_TRACK_INFO:
2047         case BT_AVRCP_SET_PROPERTY:
2048         case BT_AVRCP_SET_PROPERTIES:
2049         case BT_AVRCP_HANDLE_CONTROL:
2050         case BT_AVRCP_CONTROL_SET_PROPERTY:
2051         case BT_AVRCP_CONTROL_GET_PROPERTY:
2052         case BT_AVRCP_GET_TRACK_INFO:
2053
2054         case BT_SET_CONTENT_PROTECT:
2055         case BT_BOND_DEVICE_BY_TYPE:
2056         case BT_SET_LE_PRIVACY:
2057         case BT_LE_CONN_UPDATE:
2058                 ret_val = cynara_check(p_cynara, client_creds, client_session, user_creds,
2059                                                                                  BT_PRIVILEGE_PLATFORM);
2060
2061                 if (ret_val != CYNARA_API_ACCESS_ALLOWED) {
2062                         BT_ERR("Fail to access: %s", BT_PRIVILEGE_PLATFORM);
2063                         result = FALSE;
2064                 }
2065         break;
2066
2067         case BT_CHECK_ADAPTER:
2068         case BT_GET_RSSI:
2069
2070         case BT_GET_LOCAL_NAME:
2071         case BT_GET_LOCAL_ADDRESS:
2072         case BT_GET_LOCAL_VERSION:
2073         case BT_IS_SERVICE_USED:
2074         case BT_GET_DISCOVERABLE_MODE:
2075         case BT_GET_DISCOVERABLE_TIME:
2076         case BT_IS_DISCOVERYING:
2077         case BT_IS_LE_DISCOVERYING:
2078         case BT_IS_CONNECTABLE:
2079         case BT_GET_BONDED_DEVICES:
2080         case BT_GET_BONDED_DEVICE:
2081         case BT_IS_DEVICE_CONNECTED:
2082         case BT_GET_SPEAKER_GAIN:
2083         case BT_SET_SPEAKER_GAIN:
2084         case BT_OOB_READ_LOCAL_DATA:
2085         case BT_RFCOMM_CLIENT_IS_CONNECTED:
2086         case BT_RFCOMM_IS_UUID_AVAILABLE:
2087         case BT_GET_ADVERTISING_DATA:
2088         case BT_GET_SCAN_RESPONSE_DATA:
2089         case BT_IS_ADVERTISING:
2090
2091         case BT_OBEX_SERVER_ALLOCATE:
2092         case BT_OBEX_SERVER_DEALLOCATE:
2093
2094                 /* Non-privilege control */
2095                 break;
2096         default:
2097                 BT_ERR("Unknown function!");
2098                 result = FALSE;
2099                 break;
2100         }
2101
2102         if (client_creds)
2103                 free(client_creds);
2104
2105         if (user_creds)
2106                 free(user_creds);
2107
2108         return result;
2109 }
2110
2111 GDBusNodeInfo *__bt_service_create_method_node_info
2112                                         (const gchar *introspection_data)
2113 {
2114         GError *err = NULL;
2115         GDBusNodeInfo *node_info = NULL;
2116
2117         if (introspection_data == NULL) {
2118                 ERR("Introspection XML not present");
2119                 return NULL;
2120         }
2121
2122         node_info = g_dbus_node_info_new_for_xml(introspection_data, &err);
2123
2124         if (err) {
2125                 ERR("Unable to create node: %s", err->message);
2126                 g_clear_error(&err);
2127         }
2128         return node_info;
2129 }
2130
2131 int __bt_service_register_object(GDBusConnection *conn,
2132                 GDBusNodeInfo *node_info, gboolean reg)
2133 {
2134         static guint service_id = 0;
2135         GError *error = NULL;
2136
2137         if (reg) {
2138                 if (node_info == NULL)
2139                         return -1;
2140
2141                 service_id = g_dbus_connection_register_object(conn,
2142                                 BT_SERVICE_PATH,
2143                                 node_info->interfaces[0],
2144                                 &method_table,
2145                                 NULL, NULL, &error);
2146                 if (service_id == 0)
2147                         return -1;
2148         } else {
2149                 if (service_id > 0) {
2150                         g_dbus_connection_unregister_object(conn,
2151                                         service_id);
2152                         service_id = 0;
2153                 }
2154         }
2155
2156         return 0;
2157 }
2158
2159 int _bt_service_register(void)
2160 {
2161         GDBusConnection *conn;
2162         GError *err = NULL;
2163         int result;
2164
2165         conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &err);
2166         retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
2167
2168         owner_id = g_bus_own_name(G_BUS_TYPE_SYSTEM,
2169                                 BT_SERVICE_NAME,
2170                                 G_BUS_NAME_OWNER_FLAGS_NONE,
2171                                 NULL, NULL, NULL,
2172                                 NULL, NULL);
2173         BT_DBG("owner_id is [%d]", owner_id);
2174         if (owner_id == 0)
2175                 goto fail;
2176
2177         node_info = __bt_service_create_method_node_info(
2178                         bt_service_introspection_xml);
2179
2180         if (node_info == NULL)
2181                 goto fail;
2182
2183         result = __bt_service_register_object(conn, node_info, TRUE);
2184         g_dbus_node_info_unref(node_info);
2185         node_info = NULL;
2186
2187         if (result != BLUETOOTH_ERROR_NONE)
2188                 goto fail;
2189
2190         bt_service_conn = conn;
2191
2192         return BLUETOOTH_ERROR_NONE;
2193
2194 fail:
2195         if (bt_service_conn) {
2196                 g_object_unref(bt_service_conn);
2197                 bt_service_conn = NULL;
2198         }
2199
2200         return BLUETOOTH_ERROR_INTERNAL;
2201 }
2202
2203 void _bt_service_unregister(void)
2204 {
2205         if (bt_service_conn) {
2206                 __bt_service_register_object(bt_service_conn, NULL, FALSE);
2207                 if (bt_service_conn) {
2208                         g_object_unref(bt_service_conn);
2209                         bt_service_conn = NULL;
2210                 }
2211                 if (node_info) {
2212                         g_dbus_node_info_unref(node_info);
2213                         node_info = NULL;
2214                 }
2215                 if (owner_id > 0) {
2216                         g_bus_unown_name(owner_id);
2217                         owner_id = 0;
2218                 }
2219         }
2220 }
2221
2222 int _bt_service_cynara_init(void)
2223 {
2224         int result;
2225         char err_msg[256] = {0, };
2226
2227         retv_if(p_cynara != NULL, BLUETOOTH_ERROR_ALREADY_INITIALIZED);
2228
2229         result = cynara_initialize(&p_cynara, conf);
2230
2231         if (result != CYNARA_API_SUCCESS) {
2232                 cynara_strerror(result, err_msg, sizeof(err_msg));
2233                 BT_ERR("Fail to initialize cynara: [%s]", err_msg);
2234                 return BLUETOOTH_ERROR_INTERNAL;
2235         }
2236
2237         return BLUETOOTH_ERROR_NONE;
2238 }
2239
2240 void _bt_service_cynara_deinit(void)
2241 {
2242         int result;
2243         char err_msg[256] = {0, };
2244
2245         ret_if(p_cynara == NULL);
2246
2247         result = cynara_finish(p_cynara);
2248
2249         if (result != CYNARA_API_SUCCESS) {
2250                 cynara_strerror(result, err_msg, sizeof(err_msg));
2251                 BT_ERR("Fail to finish cynara: [%s]", err_msg);
2252                 return;
2253         }
2254
2255         p_cynara = NULL;
2256         conf = NULL;
2257 }
2258