X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=bt-service%2Fbt-request-handler.c;h=18c99e00e91f4611623f084f941344164cc0471f;hb=e808cd1dcf0cc5e04b27b4900305fd77e19e5a3f;hp=a9b1460a80b8a4f6ec0ca2176c227d3da13e7316;hpb=7640de5c091be29285bd031bcbd591aa14cf0d3e;p=platform%2Fcore%2Fconnectivity%2Fbluetooth-frwk.git diff --git a/bt-service/bt-request-handler.c b/bt-service/bt-request-handler.c index a9b1460..18c99e0 100644 --- a/bt-service/bt-request-handler.c +++ b/bt-service/bt-request-handler.c @@ -1,11 +1,5 @@ /* - * Bluetooth-frwk - * - * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. - * - * Contact: Hocheol Seo - * Girishashok Joshi - * Chanyeol Park + * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -24,8 +18,9 @@ #include #include #include -#include #include +#include +#include #include "bluetooth-api.h" #include "bt-service-common.h" @@ -46,9 +41,14 @@ #include "bt-service-rfcomm-server.h" #include "bt-request-handler.h" #include "bt-service-pbap.h" +#include "bt-service-dpm.h" +#include "bt-service-agent.h" +#include "bt-service-proximity.h" static GDBusConnection *bt_service_conn; static guint owner_id = 0; +cynara *p_cynara; +cynara_configuration *conf; static const gchar bt_service_introspection_xml[] = "" @@ -70,7 +70,9 @@ static const gchar bt_service_introspection_xml[] = " " ""; -GDBusNodeInfo *node_info = NULL; +static gboolean name_acquired = FALSE; + +static char *current_sender_playing = NULL; static void __bt_service_method(GDBusConnection *connection, const gchar *sender, @@ -116,7 +118,7 @@ int __bt_core_request(int function_name, gboolean __bt_service_check_privilege(int function_name, int service_type, - GVariant *param); + const char *unique_name); /* Function definitions*/ static void __bt_fill_garray_from_variant(GVariant *var, GArray *param) @@ -151,6 +153,7 @@ static void __bt_service_method(GDBusConnection *connection, gpointer user_data) { FN_START; + BT_DBG("Method[%s] Object Path[%s] Interface Name[%s]", method_name, object_path, interface_name); @@ -167,6 +170,7 @@ static void __bt_service_method(GDBusConnection *connection, GVariant *out_var = NULL; int result = 0; int request_id = -1; + const char *sender = NULL; g_variant_get(parameters, "(iii@ay@ay@ay@ay@ay)", &service_type, &service_function, &request_type, @@ -174,13 +178,14 @@ static void __bt_service_method(GDBusConnection *connection, out_param1 = g_array_new(FALSE, FALSE, sizeof(gchar)); + sender = g_dbus_method_invocation_get_sender(invocation); + if (service_type == BT_CORE_SERVICE) { BT_DBG("No need to check privilege from bt-core"); } else if (__bt_service_check_privilege(service_function, - service_type, param5) == FALSE) { + service_type, (const char *)sender) == FALSE) { + BT_ERR("Client don't have the privilege to excute this function"); result = BLUETOOTH_ERROR_PERMISSION_DEINED; - BT_ERR("Priviledge Check Failed"); - goto fail; } @@ -198,8 +203,8 @@ static void __bt_service_method(GDBusConnection *connection, } } - BT_DBG("SERVICE TYPE [%d] SERVICE FUNC [%d]", - service_type, service_function); + BT_DBG("Service type = %s, fn = %s (0x%x)", __bt_convert_service_type_to_string(service_type), + _bt_convert_service_function_to_string(service_function), service_function); switch (service_type) { case BT_BLUEZ_SERVICE: result = __bt_bluez_request(service_function, @@ -235,9 +240,8 @@ static void __bt_service_method(GDBusConnection *connection, goto fail; } - if (result != BLUETOOTH_ERROR_NONE) { + if (result != BLUETOOTH_ERROR_NONE) goto fail; - } if ((request_type == BT_ASYNC_REQ || service_function == BT_OBEX_SERVER_ACCEPT_CONNECTION) && @@ -255,12 +259,10 @@ static void __bt_service_method(GDBusConnection *connection, GVariant *temp = g_variant_new("(iv)", result, out_var); g_dbus_method_invocation_return_value(invocation, temp); - - g_array_free(out_param1, TRUE); - out_param1 = NULL; } } + g_array_free(out_param1, TRUE); g_variant_unref(param1); g_variant_unref(param2); g_variant_unref(param3); @@ -269,7 +271,7 @@ static void __bt_service_method(GDBusConnection *connection, FN_END; return; fail: - BT_ERR_C("Request is failed [%s] [%x]", + BT_ERR_C("Request is failed [%s] [0x%x]", _bt_convert_error_to_string(result), result); out_var = g_variant_new_from_data((const GVariantType *)"ay", @@ -326,9 +328,11 @@ int __bt_bluez_request(int function_name, result = _bt_recover_adapter(); break; case BT_ENABLE_ADAPTER_LE: + _bt_set_le_intended_status(TRUE); result = _bt_enable_adapter_le(); break; case BT_DISABLE_ADAPTER_LE: + _bt_set_le_intended_status(FALSE); result = _bt_disable_adapter_le(); break; case BT_RESET_ADAPTER: @@ -468,7 +472,6 @@ int __bt_bluez_request(int function_name, case BT_REGISTER_SCAN_FILTER: { char *sender = NULL; bluetooth_le_scan_filter_t scan_filter; - int slot_id; sender = (char *)g_dbus_method_invocation_get_sender(context); __bt_service_get_parameters(in_param1, &scan_filter, @@ -477,31 +480,18 @@ int __bt_bluez_request(int function_name, scan_filter.added_features); result = _bt_register_scan_filter(sender, - &scan_filter, &slot_id); - - g_array_append_vals(*out_param1, &slot_id, sizeof(int)); - break; - } - case BT_UNREGISTER_SCAN_FILTER:{ - char *sender = NULL; - int slot_id; - - sender = (char *)g_dbus_method_invocation_get_sender(context); - __bt_service_get_parameters(in_param1, &slot_id, sizeof(int)); - BT_DBG("Remove scan filter [Slot ID : %d]", slot_id); - - result = _bt_unregister_scan_filter(sender, slot_id); + &scan_filter); break; } - case BT_UNREGISTER_ALL_SCAN_FILTERS:{ - char *sender = NULL; - - sender = (char *)g_dbus_method_invocation_get_sender(context); + case BT_IS_SCAN_FILTER_SUPPORTED:{ + int is_supported = 0; - BT_DBG("Remove all scan filters [Sender : %s]", sender); + if (_bt_is_scan_filter_supported() == TRUE) + is_supported = 1; - result = _bt_unregister_all_scan_filters(sender); + g_array_append_vals(*out_param1, + &is_supported, sizeof(int)); break; } @@ -598,9 +588,9 @@ int __bt_bluez_request(int function_name, __bt_service_get_parameters(in_param4, &use_reserved_slot, sizeof(gboolean)); - BT_DBG("bluetooth_advertising_params_t [%f %f %d %d]", + BT_DBG("bluetooth_advertising_params_t [%f %f %d %d %d]", adv_params.interval_min, adv_params.interval_max, - adv_params.filter_policy, adv_params.type); + adv_params.filter_policy, adv_params.type, adv_params.tx_power_level); result = _bt_set_custom_advertising(sender, adv_handle, enable, &adv_params, use_reserved_slot); break; @@ -610,9 +600,9 @@ int __bt_bluez_request(int function_name, int length = 0; result = _bt_get_advertising_data(&adv, &length); - if (result == BLUETOOTH_ERROR_NONE) { + if (result == BLUETOOTH_ERROR_NONE) g_array_append_vals(*out_param1, adv.data, length); - } + break; } case BT_SET_ADVERTISING_DATA: { @@ -642,9 +632,8 @@ int __bt_bluez_request(int function_name, int length = 0; result = _bt_get_scan_response_data(&rsp, &length); - if (result == BLUETOOTH_ERROR_NONE) { + if (result == BLUETOOTH_ERROR_NONE) g_array_append_vals(*out_param1, rsp.data, length); - } break; } @@ -688,23 +677,35 @@ int __bt_bluez_request(int function_name, scan_params.interval, scan_params.window, scan_params.type); - result = _bt_set_scan_parameters(&scan_params); + result = _bt_prepare_scan_parameters(&scan_params, 0); + break; + } + case BT_SET_SCAN_TYPE: { + int scan_type = 0; + __bt_service_get_parameters(in_param1, &scan_type, sizeof(int)); + + BT_DBG("bluetooth_le_scan_type [%d]", scan_type); + result = _bt_prepare_scan_parameters(NULL, scan_type); break; } case BT_LE_CONN_UPDATE: { + char *sender = NULL; bluetooth_device_address_t local_address = { {0} }; - bluetooth_le_conn_update_t parameters = {0}; + bluetooth_le_connection_param_t parameters = {0}; + + sender = (char *)g_dbus_method_invocation_get_sender(context); __bt_service_get_parameters(in_param1, &local_address, sizeof(bluetooth_device_address_t)); __bt_service_get_parameters(in_param2, ¶meters, - sizeof(bluetooth_le_conn_update_t)); + sizeof(bluetooth_le_connection_param_t)); - result = _bt_le_conn_update(local_address.addr, + result = _bt_le_conn_update(sender, + local_address.addr, parameters.interval_min, parameters.interval_max, parameters.latency, - parameters.time_out); + parameters.timeout); break; } case BT_IS_ADVERTISING: { @@ -747,6 +748,23 @@ int __bt_bluez_request(int function_name, result = _bt_get_bonded_devices(out_param1); break; } + case BT_GET_PROFILE_CONNECTED_DEVICES: { + char *uuid; + uuid = (char *)g_variant_get_data(in_param1); + result = _bt_get_profile_connected_devices(uuid, out_param1); + break; + } + case BT_SET_PASSKEY_NOTIFICATION: { + char *sender = NULL; + gboolean enable; + + sender = (char *)g_dbus_method_invocation_get_sender(context); + __bt_service_get_parameters(in_param1, + &enable, sizeof(gboolean)); + + result = _bt_set_passkey_notification(sender, enable); + break; + } case BT_GET_BONDED_DEVICE: { bluetooth_device_address_t address = { {0} }; bluetooth_device_info_t dev_info; @@ -763,6 +781,30 @@ int __bt_bluez_request(int function_name, } break; } + case BT_GET_IS_ALIAS_SET: { + bluetooth_device_address_t address = { {0} }; + gboolean is_alias_set = FALSE; + + __bt_service_get_parameters(in_param1, + &address, sizeof(bluetooth_device_address_t)); + + result = _bt_is_alias_set(&address, &is_alias_set); + if (result == BLUETOOTH_ERROR_NONE) + g_array_append_vals(*out_param1, &is_alias_set, sizeof(gboolean)); + + break; + } + case BT_DISCONNECT_DEVICE: { + bluetooth_device_address_t addr = { {0} }; + char address[BLUETOOTH_ADDRESS_STRING_LENGTH + 1]; + + __bt_service_get_parameters(in_param1, + &addr, sizeof(bluetooth_device_address_t)); + _bt_convert_addr_type_to_string(address, addr.addr); + + result = _bt_disconnect_all(address); + break; + } case BT_BOND_DEVICE: { bluetooth_device_address_t address = { {0} }; @@ -790,6 +832,24 @@ int __bt_bluez_request(int function_name, result = _bt_cancel_bonding(); break; } + case BT_PASSKEY_REPLY: { + const char *passkey = NULL; + gboolean authentication_reply = FALSE; + + passkey = g_variant_get_data(in_param1); + __bt_service_get_parameters(in_param2, + &authentication_reply, sizeof(gboolean)); + result = _bt_passkey_reply(passkey, authentication_reply); + break; + } + case BT_PASSKEY_CONFIRMATION_REPLY: { + gboolean confirmation_reply = FALSE; + + __bt_service_get_parameters(in_param1, + &confirmation_reply, sizeof(gboolean)); + result = _bt_passkey_confirmation_reply(confirmation_reply); + break; + } case BT_UNBOND_DEVICE: { bluetooth_device_address_t address = { {0} }; @@ -875,7 +935,115 @@ int __bt_bluez_request(int function_name, break; } + case BT_SET_PIN_CODE: { + bluetooth_device_address_t address = { {0} }; + bluetooth_device_pin_code_t pin_code = { {0} }; + + __bt_service_get_parameters(in_param1, + &address, sizeof(bluetooth_device_address_t)); + __bt_service_get_parameters(in_param2, + &pin_code, sizeof(bluetooth_device_pin_code_t)); + + result = _bt_set_pin_code(&address, &pin_code); + break; + } + case BT_UNSET_PIN_CODE: { + bluetooth_device_address_t address = { {0} }; + + __bt_service_get_parameters(in_param1, + &address, sizeof(bluetooth_device_address_t)); + + result = _bt_unset_pin_code(&address); + break; + } + case BT_UPDATE_LE_CONNECTION_MODE: { + char *sender = NULL; + bluetooth_device_address_t remote_address = { { 0 } }; + bluetooth_le_connection_param_t param = { 0 }; + bluetooth_le_connection_mode_t mode = BLUETOOTH_LE_CONNECTION_MODE_BALANCED; + + __bt_service_get_parameters(in_param1, &remote_address, + sizeof(bluetooth_device_address_t)); + __bt_service_get_parameters(in_param2, &mode, + sizeof(bluetooth_le_connection_mode_t)); + + result = _bt_get_le_connection_parameter(mode, ¶m); + if (result != BLUETOOTH_ERROR_NONE) + break; + + sender = (char *)g_dbus_method_invocation_get_sender(context); + + result = _bt_le_conn_update(sender, + remote_address.addr, + param.interval_min, + param.interval_max, + param.latency, + param.timeout); + break; + } + + case BT_SET_PROFILE_TRUSTED: { + bluetooth_device_address_t bd_addr = { {0} }; + int profile; + int trust; + + __bt_service_get_parameters(in_param1, &bd_addr, + sizeof(bluetooth_device_address_t)); + __bt_service_get_parameters(in_param2, &profile, sizeof(int)); + __bt_service_get_parameters(in_param3, &trust, sizeof(int)); + + result = _bt_set_trust_profile(&bd_addr, profile, trust); + break; + } + case BT_GET_PROFILE_TRUSTED: { + bluetooth_device_address_t bd_addr = { {0} }; + int profile; + guint trusted_profile = 0; + + __bt_service_get_parameters(in_param1, &bd_addr, + sizeof(bluetooth_device_address_t)); + __bt_service_get_parameters(in_param2, &profile, sizeof(int)); + + result = _bt_get_trust_profile(&bd_addr, profile, &trusted_profile); + BT_DBG("TRUST %d", trusted_profile); + if (result == BLUETOOTH_ERROR_NONE) { + g_array_append_vals(*out_param1, &trusted_profile, + sizeof(guint)); + } + + break; + } + case BT_SET_PROFILE_RESTRICTED: { + bluetooth_device_address_t bd_addr = { {0} }; + int profile; + int restricted; + + __bt_service_get_parameters(in_param1, &bd_addr, + sizeof(bluetooth_device_address_t)); + __bt_service_get_parameters(in_param2, &profile, sizeof(int)); + __bt_service_get_parameters(in_param3, &restricted, sizeof(int)); + + result = _bt_set_restrict_profile(&bd_addr, profile, restricted); + break; + } + case BT_GET_PROFILE_RESTRICTED: { + bluetooth_device_address_t bd_addr = { {0} }; + int profile; + guint restricted_profile = 0; + + __bt_service_get_parameters(in_param1, &bd_addr, + sizeof(bluetooth_device_address_t)); + __bt_service_get_parameters(in_param2, &profile, sizeof(int)); + result = _bt_get_restrict_profile(&bd_addr, profile, &restricted_profile); + BT_DBG("Restricted %d", restricted_profile); + if (result == BLUETOOTH_ERROR_NONE) { + g_array_append_vals(*out_param1, &restricted_profile, + sizeof(guint)); + } + + break; + } case BT_HID_CONNECT: { bluetooth_device_address_t address = { {0} }; @@ -902,6 +1070,10 @@ int __bt_bluez_request(int function_name, } break; } + case BT_HID_ENABLE_BARCODE_FEATURE: { + result = _bt_hid_enable_barcode_feature(); + break; + } case BT_NETWORK_ACTIVATE: result = _bt_network_activate(); break; @@ -958,7 +1130,7 @@ int __bt_bluez_request(int function_name, &address, sizeof(bluetooth_device_address_t)); result = _bt_audio_connect(request_id, BT_AUDIO_ALL, - &address, out_param1); + &address, *out_param1); break; } case BT_AUDIO_DISCONNECT: { @@ -968,7 +1140,7 @@ int __bt_bluez_request(int function_name, &address, sizeof(bluetooth_device_address_t)); result = _bt_audio_disconnect(request_id, BT_AUDIO_ALL, - &address, out_param1); + &address, *out_param1); break; } case BT_AG_CONNECT: { @@ -978,7 +1150,7 @@ int __bt_bluez_request(int function_name, &address, sizeof(bluetooth_device_address_t)); result = _bt_audio_connect(request_id, BT_AUDIO_HSP, - &address, out_param1); + &address, *out_param1); break; } case BT_AG_DISCONNECT: { @@ -988,7 +1160,7 @@ int __bt_bluez_request(int function_name, &address, sizeof(bluetooth_device_address_t)); result = _bt_audio_disconnect(request_id, BT_AUDIO_HSP, - &address, out_param1); + &address, *out_param1); break; } case BT_AV_CONNECT: { @@ -998,7 +1170,7 @@ int __bt_bluez_request(int function_name, &address, sizeof(bluetooth_device_address_t)); result = _bt_audio_connect(request_id, BT_AUDIO_A2DP, - &address, out_param1); + &address, *out_param1); break; } case BT_AV_DISCONNECT: { @@ -1008,7 +1180,7 @@ int __bt_bluez_request(int function_name, &address, sizeof(bluetooth_device_address_t)); result = _bt_audio_disconnect(request_id, BT_AUDIO_A2DP, - &address, out_param1); + &address, *out_param1); break; } case BT_AVRCP_CONTROL_CONNECT: { @@ -1018,7 +1190,7 @@ int __bt_bluez_request(int function_name, &address, sizeof(bluetooth_device_address_t)); result = _bt_audio_connect(request_id, BT_AVRCP, - &address, out_param1); + &address, *out_param1); break; } case BT_AVRCP_CONTROL_DISCONNECT: { @@ -1028,9 +1200,25 @@ int __bt_bluez_request(int function_name, &address, sizeof(bluetooth_device_address_t)); result = _bt_audio_disconnect(request_id, BT_AVRCP, - &address, out_param1); + &address, *out_param1); break; } + case BT_AVRCP_TARGET_CONNECT: { + bluetooth_device_address_t address = { {0} }; + __bt_service_get_parameters(in_param1, + &address, sizeof(bluetooth_device_address_t)); + result = _bt_audio_connect(request_id, BT_AVRCP_TARGET, + &address, *out_param1); + break; + } + case BT_AVRCP_TARGET_DISCONNECT: { + bluetooth_device_address_t address = { {0} }; + __bt_service_get_parameters(in_param1, + &address, sizeof(bluetooth_device_address_t)); + result = _bt_audio_disconnect(request_id, BT_AVRCP_TARGET, + &address, *out_param1); + break; + } case BT_AV_SOURCE_CONNECT: { bluetooth_device_address_t address = { {0} }; @@ -1038,7 +1226,7 @@ int __bt_bluez_request(int function_name, sizeof(bluetooth_device_address_t)); result = _bt_audio_connect(request_id, BT_AUDIO_A2DP_SOURCE, - &address, out_param1); + &address, *out_param1); break; } case BT_AV_SOURCE_DISCONNECT: { @@ -1048,7 +1236,7 @@ int __bt_bluez_request(int function_name, sizeof(bluetooth_device_address_t)); result = _bt_audio_disconnect(request_id, BT_AUDIO_A2DP_SOURCE, - &address, out_param1); + &address, *out_param1); break; } case BT_HF_CONNECT: { @@ -1057,7 +1245,7 @@ int __bt_bluez_request(int function_name, __bt_service_get_parameters(in_param1, &address, sizeof(bluetooth_device_address_t)); - result = _bt_hf_connect(request_id, &address, out_param1); + result = _bt_hf_connect(request_id, &address, *out_param1); break; } case BT_HF_DISCONNECT: { @@ -1066,7 +1254,7 @@ int __bt_bluez_request(int function_name, __bt_service_get_parameters(in_param1, &address, sizeof(bluetooth_device_address_t)); - result = _bt_hf_disconnect(request_id, &address, out_param1); + result = _bt_hf_disconnect(request_id, &address, *out_param1); break; } case BT_SET_CONTENT_PROTECT: { @@ -1092,14 +1280,14 @@ int __bt_bluez_request(int function_name, } case BT_OOB_ADD_REMOTE_DATA: { bluetooth_device_address_t address = { {0} }; - bt_oob_data_t local_oob_data; + bt_oob_data_t remote_oob_data; __bt_service_get_parameters(in_param1, &address, sizeof(bluetooth_device_address_t)); __bt_service_get_parameters(in_param2, - &local_oob_data, sizeof(bt_oob_data_t)); + &remote_oob_data, sizeof(bt_oob_data_t)); - result = _bt_oob_add_remote_data(&address, &local_oob_data); + result = _bt_oob_add_remote_data(&address, &remote_oob_data); break; } @@ -1113,6 +1301,33 @@ int __bt_bluez_request(int function_name, break; } + case BT_LE_OOB_READ_LOCAL_DATA: { + bt_oob_data_t local_oob_data; + + memset(&local_oob_data, 0x00, sizeof(bt_oob_data_t)); + result = _bt_le_oob_read_local_data(&local_oob_data); + + g_array_append_vals(*out_param1, &local_oob_data, + sizeof(bt_oob_data_t)); + + break; + } + case BT_LE_OOB_ADD_REMOTE_DATA: { + bluetooth_device_address_t address = { {0} }; + unsigned short address_type; + bt_oob_data_t remote_oob_data; + + __bt_service_get_parameters(in_param1, + &address, sizeof(bluetooth_device_address_t)); + __bt_service_get_parameters(in_param2, + &address_type, sizeof(unsigned short)); + __bt_service_get_parameters(in_param3, + &remote_oob_data, sizeof(bt_oob_data_t)); + + result = _bt_oob_add_remote_data(&address, address_type, &remote_oob_data); + + break; + } case BT_AVRCP_SET_TRACK_INFO: { media_metadata_t data; media_metadata_attributes_t meta_data; @@ -1131,6 +1346,17 @@ int __bt_bluez_request(int function_name, meta_data.number = data.number; meta_data.duration = (int64_t) data.duration; + if (meta_data.title) + BT_INFO("title [%s]", meta_data.title); + if (meta_data.artist) + BT_INFO("artist [%s]", meta_data.artist); + if (meta_data.album) + BT_INFO("album [%s]", meta_data.album); + if (meta_data.genre) + BT_INFO("genre [%s]", meta_data.genre); + BT_INFO("total_tracks[%d], number[%d], duration[%d]", + meta_data.total_tracks, meta_data.number, meta_data.duration); + result = _bt_avrcp_set_track_info(&meta_data); g_free((gpointer)meta_data.title); @@ -1143,12 +1369,28 @@ int __bt_bluez_request(int function_name, case BT_AVRCP_SET_PROPERTY: { int type; unsigned int value; + char *sender = NULL; + sender = (char *)g_dbus_method_invocation_get_sender(context); + BT_INFO("Sender %s", sender); __bt_service_get_parameters(in_param1, &type, sizeof(int)); __bt_service_get_parameters(in_param2, &value, sizeof(unsigned int)); + if (value == STATUS_PLAYING) { + if (current_sender_playing) + g_free(current_sender_playing); + current_sender_playing = g_strdup(sender); + } + if (g_strcmp0(sender, current_sender_playing) == 0 || + current_sender_playing == NULL) { + BT_INFO("Current Player Status %d type %d", value, type); + } else { + BT_INFO("Current Player and this sender are different"); + result = BLUETOOTH_ERROR_NONE; + break; + } result = _bt_avrcp_set_property(type, value); break; @@ -1248,7 +1490,7 @@ int __bt_bluez_request(int function_name, break; } case BT_RFCOMM_CLIENT_CONNECT: { -#ifdef RFCOMM_DIRECT +#ifdef TIZEN_FEATURE_BT_RFCOMM_DIRECT result = BLUETOOTH_ERROR_NONE; #else bluetooth_device_address_t address = { {0} }; @@ -1288,7 +1530,7 @@ int __bt_bluez_request(int function_name, break; } case BT_RFCOMM_SOCKET_DISCONNECT: { -#ifdef RFCOMM_DIRECT +#ifdef TIZEN_FEATURE_BT_RFCOMM_DIRECT result = BLUETOOTH_ERROR_NONE; #else int socket_fd; @@ -1300,7 +1542,7 @@ int __bt_bluez_request(int function_name, break; } case BT_RFCOMM_SOCKET_WRITE: { -#ifdef RFCOMM_DIRECT +#ifdef TIZEN_FEATURE_BT_RFCOMM_DIRECT result = BLUETOOTH_ERROR_NONE; #else int socket_fd; @@ -1316,14 +1558,14 @@ int __bt_bluez_request(int function_name, break; } case BT_RFCOMM_CREATE_SOCKET: { -#ifdef RFCOMM_DIRECT +#ifdef TIZEN_FEATURE_BT_RFCOMM_DIRECT result = BLUETOOTH_ERROR_NONE; #else char *sender; char *uuid; int socket_fd = -1; - sender = dbus_g_method_get_sender(context); + sender = (char *)g_dbus_method_invocation_get_sender(context); uuid = &g_array_index(in_param1, char, 0); result = _bt_rfcomm_create_socket(sender, uuid); @@ -1340,7 +1582,7 @@ int __bt_bluez_request(int function_name, break; } case BT_RFCOMM_REMOVE_SOCKET: { -#ifdef RFCOMM_DIRECT +#ifdef TIZEN_FEATURE_BT_RFCOMM_DIRECT result = BLUETOOTH_ERROR_NONE; #else int socket_fd; @@ -1410,7 +1652,12 @@ int __bt_bluez_request(int function_name, __bt_service_get_parameters(in_param2, &auto_connect, sizeof(gboolean)); - result = _bt_connect_le_device(&address, auto_connect); + result = _bt_connect_le_device(request_id, &address, + auto_connect); + if (result != BLUETOOTH_ERROR_NONE) { + g_array_append_vals(*out_param1, &address, + sizeof(bluetooth_device_address_t)); + } break; } @@ -1420,7 +1667,11 @@ int __bt_bluez_request(int function_name, __bt_service_get_parameters(in_param1, &address, sizeof(bluetooth_device_address_t)); - result = _bt_disconnect_le_device(&address); + result = _bt_disconnect_le_device(request_id, &address); + if (result != BLUETOOTH_ERROR_NONE) { + g_array_append_vals(*out_param1, &address, + sizeof(bluetooth_device_address_t)); + } break; } @@ -1434,6 +1685,62 @@ int __bt_bluez_request(int function_name, break; } + case BT_REQ_ATT_MTU: { + bluetooth_device_address_t address = { {0} }; + unsigned int mtu; + + __bt_service_get_parameters(in_param1, + &address, sizeof(bluetooth_device_address_t)); + __bt_service_get_parameters(in_param2, + &mtu, sizeof(unsigned int)); + + result = _bt_request_att_mtu(request_id, &address, mtu); + if (result != BLUETOOTH_ERROR_NONE) { + g_array_append_vals(*out_param1, &address, + sizeof(bluetooth_device_info_t)); + } + break; + } + case BT_GET_ATT_MTU: { + bluetooth_device_address_t address = { {0} }; + unsigned int mtu = 0; + + __bt_service_get_parameters(in_param1, + &address, sizeof(bluetooth_device_address_t)); + + result = _bt_get_att_mtu(&address, &mtu); + BT_DBG("MTU: %d", mtu); + if (result == BLUETOOTH_ERROR_NONE) { + g_array_append_vals(*out_param1, &mtu, + sizeof(unsigned int)); + } + break; + } + case BT_GET_DEVICE_IDA: { + bluetooth_device_address_t address = { {0} }; + bluetooth_device_address_t id_addr = { {0} }; + + __bt_service_get_parameters(in_param1, + &address, sizeof(bluetooth_device_address_t)); + + result = _bt_get_device_ida(&address, &id_addr); + + if (result == BLUETOOTH_ERROR_NONE) { + g_array_append_vals(*out_param1, &id_addr, + sizeof(bluetooth_device_address_t)); + } + break; + } + case BT_SET_LE_STATIC_RANDOM_ADDRESS: { + gboolean is_enable; + + __bt_service_get_parameters(in_param1, &is_enable, + sizeof(gboolean)); + + result = _bt_set_le_static_random_address(is_enable); + + break; + } case BT_HDP_CONNECT: case BT_HDP_DISCONNECT: case BT_HDP_SEND_DATA: @@ -1443,45 +1750,492 @@ int __bt_bluez_request(int function_name, case BT_GATT_SET_PROPERTY_REQUEST: case BT_GATT_READ_CHARACTERISTIC: case BT_GATT_DISCOVER_CHARACTERISTICS_DESCRIPTOR: + + case BT_HID_DEVICE_ACTIVATE: + case BT_HID_DEVICE_DEACTIVATE: + case BT_HID_DEVICE_CONNECT: + case BT_HID_DEVICE_DISCONNECT: + case BT_HID_DEVICE_SEND_MOUSE_EVENT: + case BT_HID_DEVICE_SEND_KEY_EVENT: + case BT_HID_DEVICE_SEND_REPLY_TO_REPORT: /* Just call to check the privilege */ break; - default: - result = BLUETOOTH_ERROR_INTERNAL; +#ifndef GATT_NO_RELAY + case BT_GATT_WATCH_CHARACTERISTIC: { + char *sender = NULL; + + sender = (char *)g_dbus_method_invocation_get_sender(context); + + result = _bt_insert_gatt_client_sender(sender); + break; } + case BT_GATT_UNWATCH_CHARACTERISTIC: { + char *sender = NULL; - return result; -} - -int __bt_obexd_request(int function_name, - int request_type, - int request_id, - GDBusMethodInvocation *context, - GVariant *in_param1, - GVariant *in_param2, - GVariant *in_param3, - GVariant *in_param4, - GArray **out_param1) -{ - BT_DBG("+"); + sender = (char *)g_dbus_method_invocation_get_sender(context); - int result; + result = _bt_delete_gatt_client_sender(sender); - BT_DBG("function_name : %x", function_name); + break; + } +#endif + case BT_LE_IPSP_INIT: + result = _bt_initialize_ipsp(); + break; + case BT_LE_IPSP_DEINIT: + result = _bt_deinitialize_ipsp(); + break; + case BT_LE_IPSP_CONNECT: { + bluetooth_device_address_t address = { {0} }; + __bt_service_get_parameters(in_param1, &address, + sizeof(bluetooth_device_address_t)); - switch (function_name) { - case BT_OPP_PUSH_FILES: { - BT_DBG("BT_OPP_PUSH_FILES"); - int i; + result = _bt_connect_le_ipsp_device(&address); + break; + } + case BT_LE_IPSP_DISCONNECT: { bluetooth_device_address_t address = { {0} }; - bt_file_path_t path; - char **file_path; - int file_count; - GArray *param2; __bt_service_get_parameters(in_param1, &address, sizeof(bluetooth_device_address_t)); - __bt_service_get_parameters(in_param3, &file_count, + + result = _bt_disconnect_le_ipsp_device(&address); + break; + } + case BT_LE_READ_MAXIMUM_DATA_LENGTH: { + bluetooth_le_read_maximum_data_length_t max_le_datalength = {0}; + + result = _bt_le_read_maximum_data_length(&max_le_datalength); + + g_array_append_vals(*out_param1, &max_le_datalength, + sizeof(bluetooth_le_read_maximum_data_length_t)); + break; + } + case BT_LE_WRITE_HOST_SUGGESTED_DATA_LENGTH: { + unsigned int def_tx_Octects = 0; + unsigned int def_tx_Time = 0; + + __bt_service_get_parameters(in_param1, + &def_tx_Octects, sizeof(int)); + __bt_service_get_parameters(in_param2, + &def_tx_Time, sizeof(int)); + + result = _bt_le_write_host_suggested_default_data_length( + def_tx_Octects, def_tx_Time); + break; + } + case BT_LE_READ_HOST_SUGGESTED_DATA_LENGTH: { + bluetooth_le_read_host_suggested_data_length_t def_data_length = {0}; + + result = _bt_le_read_host_suggested_default_data_length(&def_data_length); + + g_array_append_vals(*out_param1, &def_data_length, + sizeof(bluetooth_le_read_host_suggested_data_length_t)); + + break; + } + case BT_LE_SET_DATA_LENGTH: { + int max_tx_Octets = 0; + int max_tx_Time = 0; + bluetooth_device_address_t address = { {0} }; + + __bt_service_get_parameters(in_param1, &address, + sizeof(bluetooth_device_address_t)); + __bt_service_get_parameters(in_param2, + &max_tx_Octets, sizeof(int)); + __bt_service_get_parameters(in_param3, + &max_tx_Time, sizeof(int)); + + result = _bt_le_set_data_length(&address, max_tx_Octets, max_tx_Time); + break; + } + case BT_DPM_SET_ALLOW_BT_MODE: { + dpm_bt_allow_t value = DPM_BT_ERROR; + + __bt_service_get_parameters(in_param1, &value, + sizeof(int)); + + result = _bt_dpm_set_allow_bluetooth_mode(value); + break; + } + case BT_DPM_GET_ALLOW_BT_MODE: { + dpm_bt_allow_t value = DPM_BT_ERROR; + + value = _bt_dpm_get_allow_bluetooth_mode(); + result = DPM_RESULT_SUCCESS; + g_array_append_vals(*out_param1, &value, sizeof(int)); + + break; + } + case BT_DPM_SET_DEVICE_RESTRITION: { + dpm_status_t value = DPM_BT_ERROR; + + __bt_service_get_parameters(in_param1, &value, + sizeof(int)); + + result = _bt_dpm_activate_bluetooth_device_restriction(value); + break; + } + case BT_DPM_GET_DEVICE_RESTRITION: { + dpm_status_t value = DPM_BT_ERROR; + + value = _bt_dpm_is_bluetooth_device_restriction_active(); + result = DPM_RESULT_SUCCESS; + g_array_append_vals(*out_param1, &value, sizeof(int)); + + break; + } + case BT_DPM_SET_UUID_RESTRITION: { + dpm_status_t value = DPM_BT_ERROR; + + __bt_service_get_parameters(in_param1, &value, + sizeof(int)); + + result = _bt_dpm_activate_bluetoooth_uuid_restriction(value); + break; + } + case BT_DPM_GET_UUID_RESTRITION: { + dpm_status_t value = DPM_BT_ERROR; + + value = _bt_dpm_is_bluetooth_uuid_restriction_active(); + result = DPM_RESULT_SUCCESS; + g_array_append_vals(*out_param1, &value, sizeof(int)); + + break; + } + case BT_DPM_ADD_DEVICES_BLACKLIST: { + bluetooth_device_address_t address = { {0} }; + + __bt_service_get_parameters(in_param1, &address, + sizeof(bluetooth_device_address_t)); + + result = _bt_dpm_add_bluetooth_devices_to_blacklist(&address); + break; + } + case BT_DPM_ADD_DEVICES_WHITELIST: { + bluetooth_device_address_t address = { {0} }; + + __bt_service_get_parameters(in_param1, &address, + sizeof(bluetooth_device_address_t)); + + result = _bt_dpm_add_bluetooth_devices_to_whitelist(&address); + break; + } + case BT_DPM_ADD_UUIDS_BLACKLIST: { + const char *uuid = NULL; + + uuid = g_variant_get_data(in_param1); + + result = _bt_dpm_add_bluetooth_uuids_to_blacklist(uuid); + break; + } + case BT_DPM_ADD_UUIDS_WHITELIST: { + const char *uuid = NULL; + + uuid = g_variant_get_data(in_param1); + + result = _bt_dpm_add_bluetooth_uuids_to_whitelist(uuid); + break; + } + case BT_DPM_CLEAR_DEVICES_BLACKLIST: { + result = _bt_dpm_clear_bluetooth_devices_from_blacklist(); + break; + } + case BT_DPM_CLEAR_DEVICES_WHITELIST: { + result = _bt_dpm_clear_bluetooth_devices_from_whitelist(); + break; + } + case BT_DPM_CLEAR_UUIDS_BLACKLIST: { + result = _bt_dpm_clear_bluetooth_uuids_from_blacklist(); + break; + } + case BT_DPM_CLEAR_UUIDS_WHITELIST: { + result = _bt_dpm_clear_bluetooth_uuids_from_whitelist(); + break; + } + case BT_DPM_REMOVE_DEVICE_BLACKLIST: { + bluetooth_device_address_t address = { {0} }; + + __bt_service_get_parameters(in_param1, &address, + sizeof(bluetooth_device_address_t)); + + result = _bt_dpm_remove_bluetooth_devices_from_blacklist(&address); + break; + } + case BT_DPM_REMOVE_DEVICE_WHITELIST: { + bluetooth_device_address_t address = { {0} }; + + __bt_service_get_parameters(in_param1, &address, + sizeof(bluetooth_device_address_t)); + + result = _bt_dpm_remove_bluetooth_devices_from_whitelist(&address); + break; + } + case BT_DPM_REMOVE_UUID_BLACKLIST: { + const char *uuid = NULL; + + uuid = g_variant_get_data(in_param1); + + result = _bt_dpm_remove_bluetooth_uuids_from_blacklist(uuid); + break; + } + case BT_DPM_REMOVE_UUID_WHITELIST: { + const char *uuid = NULL; + + uuid = g_variant_get_data(in_param1); + + result = _bt_dpm_remove_bluetooth_uuids_from_whitelist(uuid); + + break; + } + case BT_DPM_GET_DEVICES_BLACKLIST: { + result = _bt_dpm_get_bluetooth_devices_from_blacklist(out_param1); + break; + } + case BT_DPM_GET_DEVICES_WHITELIST: { + result = _bt_dpm_get_bluetooth_devices_from_whitelist(out_param1); + break; + } + case BT_DPM_GET_UUIDS_BLACKLIST: { + result = _bt_dpm_get_bluetooth_uuids_from_blacklist(out_param1); + break; + } + case BT_DPM_GET_UUIDS_WHITELIST: { + result = _bt_dpm_get_bluetooth_uuids_from_whitelist(out_param1); + break; + } + case BT_DPM_SET_ALLOW_OUTGOING_CALL: { + dpm_status_t value = DPM_BT_ERROR; + + __bt_service_get_parameters(in_param1, &value, + sizeof(int)); + + result = _bt_dpm_set_allow_bluetooth_outgoing_call(value); + + break; + } + case BT_DPM_GET_ALLOW_OUTGOING_CALL: { + dpm_status_t value = DPM_BT_ERROR; + + value = _bt_dpm_get_allow_bluetooth_outgoing_call(); + result = DPM_RESULT_SUCCESS; + g_array_append_vals(*out_param1, &value, sizeof(int)); + + break; + } + case BT_DPM_SET_PAIRING_STATE: { + dpm_status_t value = DPM_BT_ERROR; + + __bt_service_get_parameters(in_param1, &value, + sizeof(int)); + + result = _bt_dpm_set_bluetooth_pairing_state(value); + + break; + } + case BT_DPM_GET_PAIRING_STATE: { + dpm_status_t value = DPM_BT_ERROR; + + value = _bt_dpm_get_bluetooth_pairing_state(); + result = DPM_RESULT_SUCCESS; + g_array_append_vals(*out_param1, &value, sizeof(int)); + + break; + } + case BT_DPM_SET_PROFILE_STATE: { + dpm_status_t value = DPM_BT_ERROR; + dpm_profile_t profile = DPM_PROFILE_NONE; + + __bt_service_get_parameters(in_param1, &profile, + sizeof(int)); + __bt_service_get_parameters(in_param2, &value, + sizeof(int)); + + result = _bt_dpm_set_bluetooth_profile_state(profile, value); + + break; + } + case BT_DPM_GET_PROFILE_STATE: { + dpm_status_t value = DPM_BT_ERROR; + dpm_profile_t profile = DPM_PROFILE_NONE; + + __bt_service_get_parameters(in_param2, &profile, + sizeof(int)); + + value = _bt_dpm_get_bluetooth_profile_state(profile); + result = DPM_RESULT_SUCCESS; + g_array_append_vals(*out_param1, &value, sizeof(int)); + + break; + } + case BT_DPM_SET_DESKROP_CONNECTIVITY_STATE: { + dpm_status_t value = DPM_BT_ERROR; + + __bt_service_get_parameters(in_param1, &value, + sizeof(int)); + + result = _bt_dpm_set_bluetooth_desktop_connectivity_state(value); + + break; + } + case BT_DPM_GET_DESKROP_CONNECTIVITY_STATE: { + dpm_status_t value = DPM_BT_ERROR; + + value = _bt_dpm_get_bluetooth_desktop_connectivity_state(); + result = DPM_RESULT_SUCCESS; + g_array_append_vals(*out_param1, &value, sizeof(int)); + + break; + } + case BT_DPM_SET_DISCOVERABLE_STATE: { + dpm_status_t value = DPM_BT_ERROR; + + __bt_service_get_parameters(in_param1, &value, + sizeof(int)); + + result = _bt_dpm_set_bluetooth_discoverable_state(value); + + break; + } + case BT_DPM_GET_DISCOVERABLE_STATE: { + dpm_status_t value = DPM_BT_ERROR; + + value = _bt_dpm_get_bluetooth_discoverable_state(); + result = DPM_RESULT_SUCCESS; + g_array_append_vals(*out_param1, &value, sizeof(int)); + + break; + } + case BT_DPM_SET_LIMITED_DISCOVERABLE_STATE: { + dpm_status_t value = DPM_BT_ERROR; + + __bt_service_get_parameters(in_param1, &value, + sizeof(int)); + + result = _bt_dpm_set_bluetooth_limited_discoverable_state(value); + + break; + } + case BT_DPM_GET_LIMITED_DISCOVERABLE_STATE: { + dpm_status_t value = DPM_BT_ERROR; + + value = _bt_dpm_get_bluetooth_limited_discoverable_state(); + result = DPM_RESULT_SUCCESS; + g_array_append_vals(*out_param1, &value, sizeof(int)); + + break; + } + case BT_DPM_SET_DATA_TRANSFER_STATE: { + dpm_status_t value = DPM_BT_ERROR; + + __bt_service_get_parameters(in_param1, &value, + sizeof(int)); + + result = _bt_dpm_set_bluetooth_data_transfer_state(value); + + break; + } + case BT_DPM_GET_DATA_TRANSFER_STATE: { + dpm_status_t value = DPM_BT_ERROR; + + value = _bt_dpm_get_allow_bluetooth_data_transfer_state(); + result = DPM_RESULT_SUCCESS; + g_array_append_vals(*out_param1, &value, sizeof(int)); + + break; + } + case BT_PXP_SET_PROPERTY: { + bluetooth_device_address_t address = { {0} }; + unsigned int property = 0; + unsigned int value = 0; + + __bt_service_get_parameters(in_param1, + &address, sizeof(bluetooth_device_address_t)); + __bt_service_get_parameters(in_param2, + &property, sizeof(int)); + __bt_service_get_parameters(in_param3, + &value, sizeof(int)); + + result = bt_set_proximity_property(&address, property, value); + break; + } + case BT_PXP_GET_PROPERTY: { + bluetooth_device_address_t address = { {0} }; + unsigned int property = 0; + int value = 0; + + __bt_service_get_parameters(in_param1, + &address, sizeof(bluetooth_device_address_t)); + __bt_service_get_parameters(in_param2, + &property, sizeof(unsigned int)); + + result = bt_get_proximity_property(&address, property, &value); + if (result == BLUETOOTH_ERROR_NONE) { + g_array_append_vals(*out_param1, &value, + sizeof(int)); + } + break; + } + case BT_PXP_GET_SUPPORTED_SERIVCES: { + bluetooth_device_address_t address = { {0} }; + unsigned int property = 0; + + __bt_service_get_parameters(in_param1, + &address, sizeof(bluetooth_device_address_t)); + + result = bt_get_proximity_supported_services(&address, &property); + if (result == BLUETOOTH_ERROR_NONE) { + g_array_append_vals(*out_param1, &property, + sizeof(int)); + } + break; + } + case BT_PXP_REGISTER_REPORTER: { + result = bt_register_proximity_reporter(); + break; + } + case BT_PXP_UNREGISTER_REPORTER: { + result = bt_unregister_proximity_reporter(); + break; + } + default: + result = BLUETOOTH_ERROR_INTERNAL; + break; + } + + return result; +} + +int __bt_obexd_request(int function_name, + int request_type, + int request_id, + GDBusMethodInvocation *context, + GVariant *in_param1, + GVariant *in_param2, + GVariant *in_param3, + GVariant *in_param4, + GArray **out_param1) +{ + BT_DBG("+"); + + int result; + + BT_DBG("function_name : %x", function_name); + + switch (function_name) { + case BT_OPP_PUSH_FILES: { + BT_DBG("BT_OPP_PUSH_FILES"); + int i; + bluetooth_device_address_t address = { {0} }; + bt_file_path_t *path; + char **file_path; + int file_count; + GArray *param2; + + __bt_service_get_parameters(in_param1, &address, + sizeof(bluetooth_device_address_t)); + __bt_service_get_parameters(in_param3, &file_count, sizeof(int)); file_path = g_new0(char *, file_count + 1); @@ -1490,17 +2244,17 @@ int __bt_obexd_request(int function_name, __bt_fill_garray_from_variant(in_param2, param2); for (i = 0; i < file_count; i++) { - path = g_array_index(param2, bt_file_path_t, i); - file_path[i] = g_strdup(path.path); + path = &g_array_index(param2, bt_file_path_t, i); + file_path[i] = g_strdup(path->path); } BT_DBG("_bt_opp_client_push_files"); result = _bt_opp_client_push_files(request_id, context, &address, file_path, file_count); - for (i = 0; i < file_count; i++) { + for (i = 0; i < file_count; i++) g_free(file_path[i]); - } + g_free(file_path); g_array_free(param2, TRUE); @@ -1520,6 +2274,25 @@ int __bt_obexd_request(int function_name, sizeof(gboolean)); break; } + case BT_OPP_GET_TRANSFER_PROGRESS: { + int direction; + int transfer_id; + guint8 progress = 0; + + __bt_service_get_parameters(in_param1, &direction, + sizeof(int)); + __bt_service_get_parameters(in_param2, &transfer_id, + sizeof(int)); + if (direction) + result = _bt_opp_get_client_progress(&progress); + else + result = _bt_opp_get_server_progress(transfer_id, &progress); + + g_array_append_vals(*out_param1, &progress, + sizeof(guint8)); + + break; + } case BT_OBEX_SERVER_ALLOCATE: { int app_pid; gboolean is_native; @@ -1878,18 +2651,51 @@ int __bt_core_request(int function_name, gboolean __bt_service_check_privilege(int function_name, int service_type, - GVariant *param) + const char *unique_name) { - char *cookie = NULL; int ret_val; - int len; gboolean result = TRUE; + char *client_creds = NULL; + char *user_creds = NULL; + char *client_session = ""; + enum cynara_client_creds client_creds_method = CLIENT_METHOD_SMACK; + enum cynara_user_creds user_creds_method = USER_METHOD_UID; + char err_msg[256] = {0, }; + + retv_if(unique_name == NULL, FALSE); + retv_if(bt_service_conn == NULL, FALSE); + + ret_val = cynara_creds_get_default_client_method(&client_creds_method); + if (ret_val != CYNARA_API_SUCCESS) { + cynara_strerror(ret_val, err_msg, sizeof(err_msg)); + BT_ERR("Fail to get default client method: %s", err_msg); + return FALSE; + } - len = g_variant_get_size(param); - if (len > 0) - cookie = (char *)g_variant_get_data(param); + ret_val = cynara_creds_get_default_user_method(&user_creds_method); + if (ret_val != CYNARA_API_SUCCESS) { + cynara_strerror(ret_val, err_msg, sizeof(err_msg)); + BT_ERR("Fail to get default user method: %s", err_msg); + return FALSE; + } - retv_if(cookie == NULL, FALSE); + ret_val = cynara_creds_gdbus_get_client(bt_service_conn, unique_name, client_creds_method, &client_creds); + if (ret_val != CYNARA_API_SUCCESS) { + cynara_strerror(ret_val, err_msg, sizeof(err_msg)); + BT_ERR("Fail to get client credential: %s", err_msg); + return FALSE; + } + + ret_val = cynara_creds_gdbus_get_user(bt_service_conn, unique_name, user_creds_method, &user_creds); + if (ret_val != CYNARA_API_SUCCESS) { + cynara_strerror(ret_val, err_msg, sizeof(err_msg)); + BT_ERR("Fail to get user credential: %s", err_msg); + if (client_creds) + free(client_creds); + return FALSE; + } + + BT_DBG("%s, %s, %s", unique_name, client_creds, user_creds); switch (function_name) { case BT_SET_LOCAL_NAME: @@ -1903,6 +2709,8 @@ gboolean __bt_service_check_privilege(int function_name, case BT_SET_ADVERTISING_PARAMETERS: case BT_START_LE_DISCOVERY: case BT_STOP_LE_DISCOVERY: + case BT_SET_SCAN_PARAMETERS: + case BT_SET_SCAN_TYPE: case BT_BOND_DEVICE: case BT_CANCEL_BONDING: @@ -1937,16 +2745,31 @@ gboolean __bt_service_check_privilege(int function_name, case BT_AG_DISCONNECT: case BT_AV_CONNECT: case BT_AV_DISCONNECT: - case BT_AVRCP_CONTROL_CONNECT: - case BT_AVRCP_CONTROL_DISCONNECT: case BT_AV_SOURCE_CONNECT: case BT_AV_SOURCE_DISCONNECT: + case BT_AVRCP_CONTROL_CONNECT: + case BT_AVRCP_CONTROL_DISCONNECT: + case BT_AVRCP_HANDLE_CONTROL: + case BT_AVRCP_SET_TRACK_INFO: + case BT_AVRCP_SET_PROPERTY: + case BT_AVRCP_SET_PROPERTIES: + case BT_AVRCP_CONTROL_SET_PROPERTY: + case BT_HF_CONNECT: case BT_HF_DISCONNECT: case BT_HID_CONNECT: case BT_HID_DISCONNECT: + case BT_HID_DEVICE_ACTIVATE: + case BT_HID_DEVICE_DEACTIVATE: + case BT_HID_DEVICE_CONNECT: + case BT_HID_DEVICE_DISCONNECT: + case BT_HID_DEVICE_SEND_MOUSE_EVENT: + case BT_HID_DEVICE_SEND_KEY_EVENT: + case BT_HID_DEVICE_SEND_REPLY_TO_REPORT: + case BT_HID_DEVICE_SEND_CUSTOM_EVENT: + case BT_CONNECT_LE: case BT_DISCONNECT_LE: @@ -1956,6 +2779,45 @@ gboolean __bt_service_check_privilege(int function_name, case BT_HDP_CONNECT: case BT_HDP_DISCONNECT: case BT_HDP_SEND_DATA: + case BT_HDP_REGISTER_SINK_APP: + case BT_HDP_UNREGISTER_SINK_APP: + + case BT_DPM_SET_ALLOW_BT_MODE: + case BT_DPM_GET_ALLOW_BT_MODE: + case BT_DPM_SET_DEVICE_RESTRITION: + case BT_DPM_GET_DEVICE_RESTRITION: + case BT_DPM_SET_UUID_RESTRITION: + case BT_DPM_GET_UUID_RESTRITION: + case BT_DPM_ADD_DEVICES_BLACKLIST: + case BT_DPM_ADD_DEVICES_WHITELIST: + case BT_DPM_ADD_UUIDS_BLACKLIST: + case BT_DPM_ADD_UUIDS_WHITELIST: + case BT_DPM_CLEAR_DEVICES_BLACKLIST: + case BT_DPM_CLEAR_DEVICES_WHITELIST: + case BT_DPM_CLEAR_UUIDS_BLACKLIST: + case BT_DPM_CLEAR_UUIDS_WHITELIST: + case BT_DPM_REMOVE_DEVICE_BLACKLIST: + case BT_DPM_REMOVE_DEVICE_WHITELIST: + case BT_DPM_REMOVE_UUID_BLACKLIST: + case BT_DPM_REMOVE_UUID_WHITELIST: + case BT_DPM_GET_DEVICES_BLACKLIST: + case BT_DPM_GET_DEVICES_WHITELIST: + case BT_DPM_GET_UUIDS_BLACKLIST: + case BT_DPM_GET_UUIDS_WHITELIST: + case BT_DPM_SET_ALLOW_OUTGOING_CALL: + case BT_DPM_GET_ALLOW_OUTGOING_CALL: + case BT_DPM_SET_PAIRING_STATE: + case BT_DPM_GET_PAIRING_STATE: + case BT_DPM_SET_PROFILE_STATE: + case BT_DPM_GET_PROFILE_STATE: + case BT_DPM_SET_DESKROP_CONNECTIVITY_STATE: + case BT_DPM_GET_DESKROP_CONNECTIVITY_STATE: + case BT_DPM_SET_DISCOVERABLE_STATE: + case BT_DPM_GET_DISCOVERABLE_STATE: + case BT_DPM_SET_LIMITED_DISCOVERABLE_STATE: + case BT_DPM_GET_LIMITED_DISCOVERABLE_STATE: + case BT_DPM_SET_DATA_TRANSFER_STATE: + case BT_DPM_GET_DATA_TRANSFER_STATE: case BT_NETWORK_ACTIVATE: case BT_NETWORK_DEACTIVATE: @@ -1968,13 +2830,39 @@ gboolean __bt_service_check_privilege(int function_name, case BT_GATT_SET_PROPERTY_REQUEST: case BT_GATT_READ_CHARACTERISTIC: case BT_GATT_DISCOVER_CHARACTERISTICS_DESCRIPTOR: + case BT_GATT_REGISTER_APPLICATION: + case BT_GATT_REGISTER_SERVICE: + case BT_GATT_SEND_RESPONSE: - ret_val = security_server_check_privilege_by_cookie(cookie, - BT_PRIVILEGE_PUBLIC, "w"); - if (ret_val == SECURITY_SERVER_API_ERROR_ACCESS_DENIED) { - BT_ERR("[SMACK] Fail to access: %s", BT_PRIVILEGE_PUBLIC); - result = FALSE; + case BT_REQ_ATT_MTU: + case BT_PBAP_CONNECT: + case BT_PBAP_DISCONNECT: + case BT_PBAP_GET_PHONEBOOK_SIZE: + case BT_PBAP_GET_PHONEBOOK: + case BT_PBAP_GET_LIST: + case BT_PBAP_PULL_VCARD: + case BT_PBAP_PHONEBOOK_SEARCH: + case BT_AUDIO_SELECT_ROLE: + + ret_val = cynara_check(p_cynara, client_creds, client_session, user_creds, + BT_PRIVILEGE_PUBLIC); + + if (ret_val != CYNARA_API_ACCESS_ALLOWED) { + BT_ERR("Fail to access: %s", BT_PRIVILEGE_PUBLIC); + result = FALSE; + } + + /* Need to check mediastorage privilege */ + if (function_name == BT_PBAP_GET_PHONEBOOK || + function_name == BT_PBAP_PULL_VCARD) { + ret_val = cynara_check(p_cynara, client_creds, client_session, user_creds, + MEDIASTORAGE_PRIVILEGE); + + if (ret_val != CYNARA_API_ACCESS_ALLOWED) { + BT_ERR("Fail to access: %s", MEDIASTORAGE_PRIVILEGE); + result = FALSE; } + } break; case BT_ENABLE_ADAPTER: @@ -1989,53 +2877,57 @@ gboolean __bt_service_check_privilege(int function_name, case BT_REMOVE_WHITE_LIST: case BT_CLEAR_WHITE_LIST: case BT_SET_MANUFACTURER_DATA: - case BT_SET_SCAN_PARAMETERS: + case BT_SET_PASSKEY_NOTIFICATION: + case BT_SET_PROFILE_RESTRICTED: + case BT_DISCONNECT_DEVICE: case BT_CANCEL_SEARCH_SERVICE: case BT_ENABLE_RSSI: - case BT_HID_DEVICE_ACTIVATE: - case BT_HID_DEVICE_DEACTIVATE: - case BT_HID_DEVICE_CONNECT: - case BT_HID_DEVICE_DISCONNECT: - case BT_HID_DEVICE_SEND_MOUSE_EVENT: - case BT_HID_DEVICE_SEND_KEY_EVENT: - case BT_HID_DEVICE_SEND_REPLY_TO_REPORT: - case BT_RFCOMM_ACCEPT_CONNECTION: case BT_RFCOMM_REJECT_CONNECTION: case BT_RFCOMM_LISTEN: case BT_RFCOMM_CREATE_SOCKET_EX: case BT_RFCOMM_REMOVE_SOCKET_EX: - case BT_PBAP_CONNECT: - case BT_PBAP_DISCONNECT: - case BT_PBAP_GET_PHONEBOOK_SIZE: - case BT_PBAP_GET_PHONEBOOK: - case BT_PBAP_GET_LIST: - case BT_PBAP_PULL_VCARD: - case BT_PBAP_PHONEBOOK_SEARCH: + case BT_HID_ENABLE_BARCODE_FEATURE: - case BT_AVRCP_SET_TRACK_INFO: - case BT_AVRCP_SET_PROPERTY: - case BT_AVRCP_SET_PROPERTIES: - case BT_AVRCP_HANDLE_CONTROL: - case BT_AVRCP_CONTROL_SET_PROPERTY: case BT_AVRCP_CONTROL_GET_PROPERTY: case BT_AVRCP_GET_TRACK_INFO: + case BT_AVRCP_TRANSPORT_SET_PROPERTY: + case BT_SET_CONTENT_PROTECT: case BT_BOND_DEVICE_BY_TYPE: case BT_SET_LE_PRIVACY: + case BT_SET_LE_STATIC_RANDOM_ADDRESS: case BT_LE_CONN_UPDATE: - - ret_val = security_server_check_privilege_by_cookie(cookie, - BT_PRIVILEGE_PLATFORM, "w"); - - if (ret_val == SECURITY_SERVER_API_ERROR_ACCESS_DENIED) { - BT_ERR("[SMACK] Fail to access: %s", BT_PRIVILEGE_PLATFORM); - result = FALSE; - } + case BT_UPDATE_LE_CONNECTION_MODE: + case BT_GET_DEVICE_IDA: + case BT_ENABLE_FORCE_HCI_DUMP: + case BT_LE_READ_MAXIMUM_DATA_LENGTH: + case BT_LE_WRITE_HOST_SUGGESTED_DATA_LENGTH: + case BT_LE_READ_HOST_SUGGESTED_DATA_LENGTH: + case BT_LE_SET_DATA_LENGTH: + case BT_LE_OOB_READ_LOCAL_DATA: + case BT_LE_OOB_ADD_REMOTE_DATA: + + case BT_LE_IPSP_INIT: + case BT_LE_IPSP_DEINIT: + case BT_LE_IPSP_CONNECT: + case BT_LE_IPSP_DISCONNECT: + case BT_PXP_SET_PROPERTY: + case BT_PXP_GET_PROPERTY: + case BT_PXP_GET_SUPPORTED_SERIVCES: + case BT_PXP_REGISTER_REPORTER: + case BT_PXP_UNREGISTER_REPORTER: + ret_val = cynara_check(p_cynara, client_creds, client_session, user_creds, + BT_PRIVILEGE_PLATFORM); + + if (ret_val != CYNARA_API_ACCESS_ALLOWED) { + BT_ERR("Fail to access: %s", BT_PRIVILEGE_PLATFORM); + result = FALSE; + } break; case BT_CHECK_ADAPTER: @@ -2051,9 +2943,15 @@ gboolean __bt_service_check_privilege(int function_name, case BT_IS_LE_DISCOVERYING: case BT_IS_CONNECTABLE: case BT_GET_BONDED_DEVICES: + case BT_GET_PROFILE_CONNECTED_DEVICES: case BT_GET_BONDED_DEVICE: + case BT_PASSKEY_REPLY: + case BT_PASSKEY_CONFIRMATION_REPLY: + case BT_GET_IS_ALIAS_SET: case BT_IS_DEVICE_CONNECTED: case BT_GET_CONNECTED_LINK_TYPE: + case BT_SET_PROFILE_TRUSTED: + case BT_GET_PROFILE_TRUSTED: case BT_GET_SPEAKER_GAIN: case BT_SET_SPEAKER_GAIN: case BT_OOB_READ_LOCAL_DATA: @@ -2063,13 +2961,14 @@ gboolean __bt_service_check_privilege(int function_name, case BT_GET_SCAN_RESPONSE_DATA: case BT_IS_ADVERTISING: case BT_REGISTER_SCAN_FILTER: - case BT_UNREGISTER_SCAN_FILTER: - case BT_UNREGISTER_ALL_SCAN_FILTERS: + case BT_IS_SCAN_FILTER_SUPPORTED: + case BT_GET_PROFILE_RESTRICTED: + case BT_GET_ATT_MTU: case BT_OBEX_SERVER_ALLOCATE: case BT_OBEX_SERVER_DEALLOCATE: case BT_OBEX_SERVER_IS_ACTIVATED: - + case BT_OPP_GET_TRANSFER_PROGRESS: /* Non-privilege control */ break; default: @@ -2078,6 +2977,12 @@ gboolean __bt_service_check_privilege(int function_name, break; } + if (client_creds) + free(client_creds); + + if (user_creds) + free(user_creds); + return result; } @@ -2088,7 +2993,7 @@ GDBusNodeInfo *__bt_service_create_method_node_info GDBusNodeInfo *node_info = NULL; if (introspection_data == NULL) { - ERR("Introspection XML not present: %s", err->message); + ERR("Introspection XML not present"); return NULL; } @@ -2129,39 +3034,64 @@ int __bt_service_register_object(GDBusConnection *conn, return 0; } +static void __bt_service_bus_acquired_handler(GDBusConnection *connection, + const gchar *name, gpointer user_data) +{ + GDBusNodeInfo *node_info = NULL; + + BT_INFO("bus acquired"); + + ret_if(connection == NULL); + + node_info = __bt_service_create_method_node_info( + bt_service_introspection_xml); + ret_if(node_info == NULL); + + __bt_service_register_object(connection, node_info, TRUE); + g_dbus_node_info_unref(node_info); + + bt_service_conn = connection; +} + +static void __bt_service_name_acquired_handler(GDBusConnection *connection, + const gchar *name, gpointer user_data) +{ + BT_INFO("name acquired"); + name_acquired = TRUE; +} + +static void __bt_service_name_lost_handler(GDBusConnection *connection, + const gchar *name, gpointer user_data) +{ + BT_INFO("name lost"); + name_acquired = FALSE; +} + +gboolean _is_name_acquired(void) +{ + return name_acquired; +} + int _bt_service_register(void) { GDBusConnection *conn; GError *err = NULL; - int result; conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &err); retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL); + bt_service_conn = conn; owner_id = g_bus_own_name(G_BUS_TYPE_SYSTEM, BT_SERVICE_NAME, G_BUS_NAME_OWNER_FLAGS_NONE, - NULL, NULL, NULL, + __bt_service_bus_acquired_handler, + __bt_service_name_acquired_handler, + __bt_service_name_lost_handler, NULL, NULL); BT_DBG("owner_id is [%d]", owner_id); if (owner_id == 0) goto fail; - node_info = __bt_service_create_method_node_info( - bt_service_introspection_xml); - - if (node_info == NULL) - goto fail; - - result = __bt_service_register_object(conn, node_info, TRUE); - g_dbus_node_info_unref(node_info); - node_info = NULL; - - if (result != BLUETOOTH_ERROR_NONE) - goto fail; - - bt_service_conn = conn; - return BLUETOOTH_ERROR_NONE; fail: @@ -2181,10 +3111,6 @@ void _bt_service_unregister(void) g_object_unref(bt_service_conn); bt_service_conn = NULL; } - if (node_info) { - g_dbus_node_info_unref(node_info); - node_info = NULL; - } if (owner_id > 0) { g_bus_unown_name(owner_id); owner_id = 0; @@ -2192,3 +3118,40 @@ void _bt_service_unregister(void) } } +int _bt_service_cynara_init(void) +{ + int result; + char err_msg[256] = {0, }; + + retv_if(p_cynara != NULL, BLUETOOTH_ERROR_ALREADY_INITIALIZED); + + result = cynara_initialize(&p_cynara, conf); + + if (result != CYNARA_API_SUCCESS) { + cynara_strerror(result, err_msg, sizeof(err_msg)); + BT_ERR("Fail to initialize cynara: [%s]", err_msg); + return BLUETOOTH_ERROR_INTERNAL; + } + + return BLUETOOTH_ERROR_NONE; +} + +void _bt_service_cynara_deinit(void) +{ + int result; + char err_msg[256] = {0, }; + + ret_if(p_cynara == NULL); + + result = cynara_finish(p_cynara); + + if (result != CYNARA_API_SUCCESS) { + cynara_strerror(result, err_msg, sizeof(err_msg)); + BT_ERR("Fail to finish cynara: [%s]", err_msg); + return; + } + + p_cynara = NULL; + conf = NULL; +} +