X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=bt-service%2Fbt-request-handler.c;h=a9567ed6058bb866a5623aed65b57db9db25b243;hb=042b728c3fce4bc167f4b99557cafe11893a24f3;hp=f22b79407636c5d86eef214846951dd62c2e7c94;hpb=db2890652008b7e20b096ab46c54567dd258f7a9;p=platform%2Fcore%2Fconnectivity%2Fbluetooth-frwk.git diff --git a/bt-service/bt-request-handler.c b/bt-service/bt-request-handler.c old mode 100755 new mode 100644 index f22b794..a9567ed --- a/bt-service/bt-request-handler.c +++ b/bt-service/bt-request-handler.c @@ -36,11 +36,17 @@ #include "bt-service-avrcp.h" #include "bt-service-avrcp-controller.h" #include "bt-service-opp-client.h" +#include "bt-service-map-client.h" #include "bt-service-obex-server.h" #include "bt-service-rfcomm-client.h" #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" +#include "bt-service-tds.h" +#include "bt-service-otp.h" static GDBusConnection *bt_service_conn; static guint owner_id = 0; @@ -67,7 +73,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, @@ -95,7 +103,6 @@ int __bt_obexd_request(int function_name, GVariant *in_param2, GVariant *in_param3, GVariant *in_param4, - GVariant *in_param5, GArray **out_param1); int __bt_agent_request(int function_name, int request_type, @@ -149,6 +156,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); @@ -198,8 +206,9 @@ static void __bt_service_method(GDBusConnection *connection, } } - BT_DBG("SERVICE TYPE [%d] SERVICE FUNC [%d]", - service_type, service_function); + BT_DBG("Service type = %d, fn = %s (0x%x)", + 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, @@ -212,7 +221,7 @@ static void __bt_service_method(GDBusConnection *connection, request_type, request_id, invocation, param1, param2, param3, - param4, param5, &out_param1); + param4, &out_param1); break; case BT_AGENT_SERVICE: result = __bt_agent_request(service_function, @@ -235,9 +244,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,22 +263,20 @@ 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; } } + /* TODO: MAP? see the if{}else{} above */ + g_array_free(out_param1, TRUE); g_variant_unref(param1); g_variant_unref(param2); g_variant_unref(param3); g_variant_unref(param4); g_variant_unref(param5); -// g_free(sender); 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", @@ -291,7 +297,6 @@ fail: g_variant_unref(param3); g_variant_unref(param4); g_variant_unref(param5); -// g_free(sender); } FN_END; @@ -328,9 +333,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: @@ -507,6 +514,17 @@ int __bt_bluez_request(int function_name, break; } + case BT_IS_SCAN_FILTER_SUPPORTED:{ + int is_supported = 0; + + if (_bt_is_scan_filter_supported() == TRUE) + is_supported = 1; + + g_array_append_vals(*out_param1, + &is_supported, sizeof(int)); + + break; + } case BT_ENABLE_RSSI: { bluetooth_device_address_t bd_addr; int link_type; @@ -612,9 +630,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: { @@ -644,9 +662,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; } @@ -694,15 +711,19 @@ int __bt_bluez_request(int function_name, break; } case BT_LE_CONN_UPDATE: { + char *sender = NULL; bluetooth_device_address_t local_address = { {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_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, @@ -749,6 +770,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; @@ -765,6 +803,19 @@ 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_BOND_DEVICE: { bluetooth_device_address_t address = { {0} }; @@ -917,6 +968,7 @@ int __bt_bluez_request(int function_name, 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; @@ -930,7 +982,10 @@ int __bt_bluez_request(int function_name, if (result != BLUETOOTH_ERROR_NONE) break; - result = _bt_le_conn_update(remote_address.addr, + 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, @@ -938,6 +993,37 @@ int __bt_bluez_request(int function_name, 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_HID_CONNECT: { bluetooth_device_address_t address = { {0} }; @@ -964,6 +1050,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; @@ -1020,7 +1110,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: { @@ -1030,7 +1120,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: { @@ -1040,7 +1130,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: { @@ -1050,7 +1140,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: { @@ -1060,7 +1150,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: { @@ -1070,7 +1160,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: { @@ -1080,7 +1170,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: { @@ -1090,9 +1180,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} }; @@ -1100,7 +1206,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: { @@ -1110,7 +1216,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: { @@ -1119,7 +1225,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: { @@ -1128,7 +1234,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: { @@ -1141,6 +1247,17 @@ int __bt_bluez_request(int function_name, break; } + case BT_AUDIO_SELECT_ROLE: { + + bluetooth_audio_role_t role; + + __bt_service_get_parameters(in_param1, + &role, sizeof(bluetooth_audio_role_t)); + + result = _bt_audio_select_role(role); + + break; + } case BT_OOB_READ_LOCAL_DATA: { bt_oob_data_t local_oob_data; @@ -1154,14 +1271,17 @@ 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; + 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, - &local_oob_data, sizeof(bt_oob_data_t)); + &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, &local_oob_data); + result = _bt_oob_add_remote_data(&address, address_type, &remote_oob_data); break; } @@ -1205,12 +1325,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; @@ -1259,6 +1395,19 @@ int __bt_bluez_request(int function_name, break; } + case BT_AVRCP_TRANSPORT_SET_PROPERTY: { + int type; + unsigned int value; + + __bt_service_get_parameters(in_param1, + &type, sizeof(int)); + __bt_service_get_parameters(in_param2, + &value, sizeof(unsigned int)); + + result = _bt_avrcp_transport_set_property(type, value); + + break; + } case BT_AVRCP_GET_TRACK_INFO: { media_metadata_t meta_data; media_metadata_attributes_t metadata; @@ -1310,7 +1459,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} }; @@ -1350,7 +1499,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; @@ -1362,7 +1511,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; @@ -1378,7 +1527,7 @@ 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; @@ -1402,7 +1551,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; @@ -1472,11 +1621,13 @@ int __bt_bluez_request(int function_name, __bt_service_get_parameters(in_param2, &auto_connect, sizeof(gboolean)); - result = _bt_connect_le_device(request_id, &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; } case BT_DISCONNECT_LE: { @@ -1490,6 +1641,7 @@ int __bt_bluez_request(int function_name, g_array_append_vals(*out_param1, &address, sizeof(bluetooth_device_address_t)); } + break; } case BT_SET_LE_PRIVACY: { @@ -1502,37 +1654,81 @@ int __bt_bluez_request(int function_name, break; } - case BT_HDP_CONNECT: - case BT_HDP_DISCONNECT: - case BT_HDP_SEND_DATA: + case BT_REQ_ATT_MTU: { + bluetooth_device_address_t address = { {0} }; + unsigned int mtu; - case BT_GATT_GET_PRIMARY_SERVICES: - case BT_GATT_DISCOVER_CHARACTERISTICS: - case BT_GATT_SET_PROPERTY_REQUEST: - case BT_GATT_READ_CHARACTERISTIC: - case BT_GATT_DISCOVER_CHARACTERISTICS_DESCRIPTOR: - /* Just call to check the privilege */ + __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; -#ifndef GATT_NO_RELAY - case BT_GATT_WATCH_CHARACTERISTIC: { - char *sender = NULL; + } + case BT_GET_ATT_MTU: { + bluetooth_device_address_t address = { {0} }; + unsigned int mtu = 0; - sender = (char *)g_dbus_method_invocation_get_sender(context); + __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_insert_gatt_client_sender(sender); + 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_GATT_UNWATCH_CHARACTERISTIC: { - char *sender = NULL; + case BT_SET_LE_STATIC_RANDOM_ADDRESS: { + gboolean is_enable; - sender = (char *)g_dbus_method_invocation_get_sender(context); + __bt_service_get_parameters(in_param1, &is_enable, + sizeof(gboolean)); - result = _bt_delete_gatt_client_sender(sender); + result = _bt_set_le_static_random_address(is_enable); break; } -#endif + case BT_HDP_CONNECT: + case BT_HDP_DISCONNECT: + case BT_HDP_SEND_DATA: + + case BT_GATT_GET_PRIMARY_SERVICES: + case BT_GATT_DISCOVER_CHARACTERISTICS: + 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; case BT_LE_IPSP_INIT: result = _bt_initialize_ipsp(); break; @@ -1603,155 +1799,860 @@ int __bt_bluez_request(int function_name, result = _bt_le_set_data_length(&address, max_tx_Octets, max_tx_Time); break; } - default: - result = BLUETOOTH_ERROR_INTERNAL; + 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: { + int value = DPM_BT_ERROR; - 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, - GVariant *in_param5, - GArray **out_param1) -{ - BT_DBG("+"); + result = _bt_dpm_get_allow_bluetooth_mode(&value); + g_array_append_vals(*out_param1, &value, sizeof(int)); + break; + } + case BT_DPM_SET_DEVICE_RESTRITION: { + dpm_status_t value = DPM_STATUS_ERROR; - int result; + __bt_service_get_parameters(in_param1, &value, + sizeof(int)); - BT_DBG("function_name : %x", function_name); + result = _bt_dpm_activate_bluetooth_device_restriction(value); + break; + } + case BT_DPM_GET_DEVICE_RESTRITION: { + int value = DPM_STATUS_ERROR; - 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; - GDBusProxy *process_proxy; - guint owner_pid = 0; - int opp_server_pid = 0; - const gchar *owner_sender_name = NULL; - GDBusConnection *owner_connection = NULL; - GVariant *val_get = NULL; - GError *error_connection = NULL; - GError *errro_proxy = NULL; - GArray *param2; + result = _bt_dpm_is_bluetooth_device_restriction_active(&value); + g_array_append_vals(*out_param1, &value, sizeof(int)); + break; + } + case BT_DPM_SET_UUID_RESTRITION: { + dpm_status_t value = DPM_STATUS_ERROR; - __bt_service_get_parameters(in_param1, &address, - sizeof(bluetooth_device_address_t)); - __bt_service_get_parameters(in_param3, &file_count, + __bt_service_get_parameters(in_param1, &value, sizeof(int)); - file_path = g_new0(char *, file_count + 1); - - param2 = g_array_new(TRUE, TRUE, sizeof(gchar)); - __bt_fill_garray_from_variant(in_param2, param2); + result = _bt_dpm_activate_bluetoooth_uuid_restriction(value); + break; + } + case BT_DPM_GET_UUID_RESTRITION: { + int value = DPM_STATUS_ERROR; - for (i = 0; i < file_count; i++) { - path = g_array_index(param2, bt_file_path_t, i); - file_path[i] = g_strdup(path.path); - } + result = _bt_dpm_is_bluetooth_uuid_restriction_active(&value); + g_array_append_vals(*out_param1, &value, sizeof(int)); + break; + } + case BT_DPM_ADD_DEVICES_BLACKLIST: { + bluetooth_device_address_t address = { {0} }; - owner_connection = g_dbus_method_invocation_get_connection(context); - owner_sender_name = g_dbus_method_invocation_get_sender(context); + __bt_service_get_parameters(in_param1, &address, + sizeof(bluetooth_device_address_t)); - BT_DBG("sender = %s", owner_sender_name); + result = _bt_dpm_add_bluetooth_devices_to_blacklist(&address); + break; + } + case BT_DPM_ADD_DEVICES_WHITELIST: { + bluetooth_device_address_t address = { {0} }; - process_proxy = g_dbus_proxy_new_sync(owner_connection, - G_DBUS_PROXY_FLAGS_NONE, - NULL, - "org.freedesktop.DBus", - "/org/freedesktop/DBus", - "org.freedesktop.DBus", - NULL, &error_connection); + __bt_service_get_parameters(in_param1, &address, + sizeof(bluetooth_device_address_t)); - if(process_proxy == NULL) - BT_DBG("Fail to get process_proxy"); + result = _bt_dpm_add_bluetooth_devices_to_whitelist(&address); + break; + } + case BT_DPM_ADD_UUIDS_BLACKLIST: { + const char *uuid = NULL; - if (error_connection) { - BT_DBG("Fail to get proxy : %s", error_connection->message); - g_error_free(error_connection); - error_connection = NULL; - } + uuid = g_variant_get_data(in_param1); - if (process_proxy) { - val_get = g_dbus_proxy_call_sync(process_proxy, - "GetConnectionUnixProcessID", - g_variant_new("(s)", owner_sender_name), - G_DBUS_CALL_FLAGS_NONE, - -1, NULL, - &errro_proxy); - - if (val_get == NULL) { - BT_DBG("Fail to get pid"); - } else { - g_variant_get(val_get, "(u)", &owner_pid); - BT_DBG("request is from pid %d\n", owner_pid); - } + result = _bt_dpm_add_bluetooth_uuids_to_blacklist(uuid); + break; + } + case BT_DPM_ADD_UUIDS_WHITELIST: { + const char *uuid = NULL; - if (errro_proxy) { - g_error("Unable to get PID for %s: %s", - owner_sender_name, errro_proxy->message); - g_error_free(errro_proxy); - errro_proxy = NULL; - } - } else { - BT_DBG("fail to get proxy"); - } + uuid = g_variant_get_data(in_param1); - opp_server_pid = _bt_obex_get_native_pid(); + 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_DBG("owner_pid, agent_info.native_server->app_pid = %d, %d", - owner_pid, opp_server_pid); - if (opp_server_pid == owner_pid) { - BT_DBG("The exception case : _bt_opp_client_push_files"); - result = _bt_opp_client_push_files(request_id, context, - &address, file_path, - file_count); - } else { - BT_DBG("normal case"); - result = _bt_opp_client_push_files(request_id, context, - &address, file_path, - file_count); - } + __bt_service_get_parameters(in_param1, &address, + sizeof(bluetooth_device_address_t)); - for (i = 0; i < file_count; i++) { - g_free(file_path[i]); - } - g_free(file_path); - g_array_free(param2, TRUE); - if (process_proxy) - g_object_unref(process_proxy); + result = _bt_dpm_remove_bluetooth_devices_from_blacklist(&address); break; } - case BT_OPP_CANCEL_PUSH: { - result = _bt_opp_client_cancel_push(); + 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_OPP_IS_PUSHING_FILES: { - gboolean is_sending = FALSE; + case BT_DPM_REMOVE_UUID_BLACKLIST: { + const char *uuid = NULL; - result = _bt_opp_client_is_sending(&is_sending); + uuid = g_variant_get_data(in_param1); - g_array_append_vals(*out_param1, &is_sending, - sizeof(gboolean)); + result = _bt_dpm_remove_bluetooth_uuids_from_blacklist(uuid); break; } - case BT_OBEX_SERVER_ALLOCATE: { - int app_pid; - gboolean is_native; - char *path; - char *sender; + 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_STATUS_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: { + int value = DPM_STATUS_ERROR; + + result = _bt_dpm_get_allow_bluetooth_outgoing_call(&value); + g_array_append_vals(*out_param1, &value, sizeof(int)); + break; + } + case BT_DPM_SET_PAIRING_STATE: { + dpm_status_t value = DPM_STATUS_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: { + int value = DPM_STATUS_ERROR; + + result = _bt_dpm_get_bluetooth_pairing_state(&value); + g_array_append_vals(*out_param1, &value, sizeof(int)); + break; + } + case BT_DPM_SET_PROFILE_STATE: { + int value = DPM_STATUS_ERROR; + int 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: { + int value = DPM_STATUS_ERROR; + int profile = DPM_PROFILE_NONE; + + __bt_service_get_parameters(in_param1, &profile, + sizeof(int)); + + result = _bt_dpm_get_bluetooth_profile_state(profile, &value); + g_array_append_vals(*out_param1, &value, sizeof(int)); + break; + } + case BT_DPM_SET_DESKROP_CONNECTIVITY_STATE: { + int 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: { + int value = DPM_STATUS_ERROR; + + result = _bt_dpm_get_bluetooth_desktop_connectivity_state(&value); + g_array_append_vals(*out_param1, &value, sizeof(int)); + break; + } + case BT_DPM_SET_DISCOVERABLE_STATE: { + int value = DPM_STATUS_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: { + int value = DPM_STATUS_ERROR; + + result = _bt_dpm_get_bluetooth_discoverable_state(&value); + g_array_append_vals(*out_param1, &value, sizeof(int)); + break; + } + case BT_DPM_SET_LIMITED_DISCOVERABLE_STATE: { + int value = DPM_STATUS_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: { + int value = DPM_STATUS_ERROR; + + result = _bt_dpm_get_bluetooth_limited_discoverable_state(&value); + g_array_append_vals(*out_param1, &value, sizeof(int)); + break; + } + case BT_DPM_SET_DATA_TRANSFER_STATE: { + int value = DPM_STATUS_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: { + int value = DPM_STATUS_ERROR; + + result = _bt_dpm_get_allow_bluetooth_data_transfer_state(&value); + g_array_append_vals(*out_param1, &value, sizeof(int)); + break; + } + case BT_PXP_MONITOR_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_proximity_monitor_set_property(&address, property, value); + break; + } + case BT_PXP_MONITOR_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_proximity_monitor_get_property(&address, property, &value); + if (result == BLUETOOTH_ERROR_NONE) { + g_array_append_vals(*out_param1, &value, + sizeof(int)); + } + break; + } + case BT_PXP_MONITOR_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_proximity_monitor_get_supported_services(&address, &property); + if (result == BLUETOOTH_ERROR_NONE) { + g_array_append_vals(*out_param1, &property, + sizeof(int)); + } + break; + } + case BT_PXP_REPORTER_REGISTER: { + char *sender = NULL; + sender = (char *)g_dbus_method_invocation_get_sender(context); + result = _bt_proximity_reporter_register(sender); + break; + } + case BT_PXP_REPORTER_UNREGISTER: { + char *sender = NULL; + sender = (char *)g_dbus_method_invocation_get_sender(context); + result = _bt_proximity_reporter_unregister(sender); + break; + } + case BT_PXP_REPORTER_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_proximity_reporter_get_property(&address, property, &value); + if (result == BLUETOOTH_ERROR_NONE) { + g_array_append_vals(*out_param1, &value, + sizeof(int)); + } + break; + } + case BT_TDS_PROVIDER_REGISTER: { + char *sender = NULL; + + sender = (char *)g_dbus_method_invocation_get_sender(context); + result = _bt_tds_provider_register(sender); + + break; + } + case BT_TDS_PROVIDER_UNREGISTER: { + char *sender = NULL; + + sender = (char *)g_dbus_method_invocation_get_sender(context); + result = _bt_tds_provider_unregister(sender); + + break; + } + case BT_TDS_PROVIDER_SET_MANUF_DATA: { + char *sender = NULL; + unsigned int length = 0; + bluetooth_advertising_data_t manuf_data; + + __bt_service_get_parameters(in_param1, + &length, sizeof(unsigned int)); + __bt_service_get_parameters(in_param2, + &manuf_data, sizeof(bluetooth_advertising_data_t)); + sender = (char *)g_dbus_method_invocation_get_sender(context); + + result = _bt_tds_provider_set_manuf_data(sender, manuf_data.data, length); + break; + } + case BT_TDS_PROVIDER_CREATE: { + char *sender = NULL; + unsigned int tds_handle = 0; + int transport; + + __bt_service_get_parameters(in_param1, + &tds_handle, sizeof(unsigned int)); + __bt_service_get_parameters(in_param2, + &transport, sizeof(int)); + sender = (char *)g_dbus_method_invocation_get_sender(context); + result = _bt_tds_provider_transport_create(sender, transport, tds_handle); + + break; + } + case BT_TDS_PROVIDER_DESTROY: { + char *sender = NULL; + unsigned int tds_handle = 0; + + __bt_service_get_parameters(in_param1, + &tds_handle, sizeof(unsigned int)); + sender = (char *)g_dbus_method_invocation_get_sender(context); + result = _bt_tds_provider_transport_remove(sender, tds_handle); + + break; + } + case BT_TDS_PROVIDER_SET_TRANSPORT_DATA: { + char *sender = NULL; + unsigned int tds_handle = 0; + int transport_state = 0; + bluetooth_tds_data_t tds_data; + + __bt_service_get_parameters(in_param1, + &tds_handle, sizeof(unsigned int)); + __bt_service_get_parameters(in_param2, + &transport_state, sizeof(int)); + __bt_service_get_parameters(in_param3, + &tds_data, sizeof(bluetooth_tds_data_t)); + sender = (char *)g_dbus_method_invocation_get_sender(context); + + result = _bt_tds_provider_set_transport_data(sender, tds_handle, + transport_state, tds_data.data, tds_data.length); + break; + } + case BT_TDS_SEND_ACTIVATION_RESPONSE: { + bluetooth_device_address_t address = { {0} }; + bluetooth_tds_data_t tds_data; + char *sender = NULL; + unsigned int tds_handle = 0; + int response; + + __bt_service_get_parameters(in_param1, + &tds_handle, sizeof(unsigned int)); + __bt_service_get_parameters(in_param2, + &response, sizeof(int)); + __bt_service_get_parameters(in_param3, &address, + sizeof(bluetooth_device_address_t)); + __bt_service_get_parameters(in_param4, + &tds_data, sizeof(bluetooth_tds_data_t)); + sender = (char *)g_dbus_method_invocation_get_sender(context); + + result = _bt_tds_provider_send_activation_response(sender, tds_handle, + &address, response, tds_data.data, tds_data.length); + break; + } + case BT_TDS_READ_TRANSPORT_DATA: { + char *handle; + char *data = NULL; + guint data_len = 0; + + char *sender = NULL; + sender = (char *)g_dbus_method_invocation_get_sender(context); + + bluetooth_device_address_t address = { {0} }; + __bt_service_get_parameters(in_param2, + &address, sizeof(bluetooth_device_address_t)); + + data_len = g_variant_get_size(in_param1); + data = (char *)g_variant_get_data(in_param1); + + handle = g_strndup(data, data_len); + BT_DBG("Read TDS Transport Block [%s]", handle); + + result = _bt_tds_read_transport_data(request_id, sender, &address, handle); + + if (result != BLUETOOTH_ERROR_NONE) { + BT_ERR("Reading TDS Transport data failed result [%d]", result); + g_array_append_vals(*out_param1, &address, + sizeof(bluetooth_device_address_t)); + } + if (handle) + g_free(handle); + break; + } + case BT_TDS_ENABLE_CONTROL_POINT: { + char *handle; + char *data = NULL; + guint data_len = 0; + bluetooth_device_address_t address = { {0} }; + + char *sender = NULL; + sender = (char *)g_dbus_method_invocation_get_sender(context); + + data_len = g_variant_get_size(in_param1); + data = (char *)g_variant_get_data(in_param1); + __bt_service_get_parameters(in_param2, + &address, sizeof(bluetooth_device_address_t)); + + handle = g_strndup(data, data_len); + BT_DBG("TDS Control point CCCD handle [%s]", handle); + + result = _bt_tds_enable_control_point(request_id, sender, &address, handle); + + if (result != BLUETOOTH_ERROR_NONE) { + BT_ERR("Enabling TDS CCCD failed result [%d]", result); + g_array_append_vals(*out_param1, &address, + sizeof(bluetooth_device_address_t)); + } + if (handle) + g_free(handle); + break; + } + case BT_TDS_ACTIVATE_CONTROL_POINT: { + char *handle; + char *data = NULL; + guint data_len = 0; + bluetooth_control_point_data_t tds_data; + char *sender = NULL; + + sender = (char *)g_dbus_method_invocation_get_sender(context); + + bluetooth_device_address_t address = { {0} }; + + data_len = g_variant_get_size(in_param1); + data = (char *)g_variant_get_data(in_param1); + + __bt_service_get_parameters(in_param2, + &address, sizeof(bluetooth_device_address_t)); + + __bt_service_get_parameters(in_param3, + &tds_data, sizeof(bluetooth_control_point_data_t)); + + handle = g_strndup(data, data_len); + BT_DBG("TDS Activate Control point handle [%s]", handle); + + result = _bt_tds_activate_control_point(request_id, sender, &address, handle, + tds_data.data, tds_data.length); + + if (result != BLUETOOTH_ERROR_NONE) { + BT_ERR("Activating TDS Control Point request failed result [%d]", result); + g_array_append_vals(*out_param1, &address, + sizeof(bluetooth_device_address_t)); + } + if (handle) + g_free(handle); + break; + } + case BT_OTP_SERVER_INIT: { + const char *directory; + directory = (const char *)g_variant_get_data(in_param1); + result = bt_otp_server_init(request_id, directory); + break; + } + case BT_OTP_SERVER_DEINIT: { + result = bt_otp_server_deinit(request_id); + break; + } + case BT_OTP_READ_VALUE: { + char *handle; + char *data = NULL; + guint data_len = 0; + + char *sender = NULL; + sender = (char *)g_dbus_method_invocation_get_sender(context); + + data_len = g_variant_get_size(in_param1); + data = (char *)g_variant_get_data(in_param1); + + handle = g_strndup(data, data_len); + BT_DBG("Read OTP Characteristic Value [%s]", handle); + + result = _bt_otp_read_characteristic_value(request_id, sender, handle); + + if (result != BLUETOOTH_ERROR_NONE) { + BT_ERR("Reading OTP Characteristic Value failed result [%d]", result); + g_array_append_vals(*out_param1, handle, data_len); + } + if (handle) + g_free(handle); + break; + } + case BT_OTP_ENABLE_NOTIFICATION: { + char *handle; + char *data = NULL; + guint data_len = 0; + + char *sender = NULL; + sender = (char *)g_dbus_method_invocation_get_sender(context); + + data_len = g_variant_get_size(in_param1); + data = (char *)g_variant_get_data(in_param1); + + handle = g_strndup(data, data_len); + BT_DBG("OTP Control point CCCD handle [%s]", handle); + + result = _bt_otp_enable_notification(request_id, sender, handle); + + if (result != BLUETOOTH_ERROR_NONE) { + BT_ERR("Enabling OTP CCCD failed result [%d]", result); + g_array_append_vals(*out_param1, handle, data_len); + } + if (handle) + g_free(handle); + break; + } + case BT_OTP_WRITE_VALUE: { + char *handle; + char *data = NULL; + guint data_len = 0; + char *sender = NULL; + bluetooth_otp_charc_data_t otp_charc_data; + sender = (char *)g_dbus_method_invocation_get_sender(context); + + data_len = g_variant_get_size(in_param1); + data = (char *)g_variant_get_data(in_param1); + + handle = g_strndup(data, data_len); + BT_DBG("OTP Write Characteristic value [%s]", handle); + + __bt_service_get_parameters(in_param2, + &otp_charc_data, sizeof(bluetooth_otp_charc_data_t)); + + int i; + for (i = 0; i < otp_charc_data.length; i++) + BT_DBG("Value[%d] = %u", i, otp_charc_data.data[i]); + + result = _bt_otp_write_characteristic_value(request_id, sender, handle, + otp_charc_data.data, otp_charc_data.length); + + if (result != BLUETOOTH_ERROR_NONE) { + BT_ERR("OTP Write Characteristic failed result [%d]", result); + g_array_append_vals(*out_param1, handle, data_len); + } + if (handle) + g_free(handle); + break; + } + case BT_LE_OTC_CONNECT: { + BT_DBG("OTC Connect"); + bluetooth_device_address_t address = { {0} }; + __bt_service_get_parameters(in_param1, &address, + sizeof(bluetooth_device_address_t)); + + result = _bt_otp_connect_otc(request_id, &address); + break; + } + case BT_LE_OTC_DISCONNECT: { + BT_DBG("OTC Disconnect"); + bluetooth_device_address_t address = { {0} }; + + __bt_service_get_parameters(in_param1, &address, + sizeof(bluetooth_device_address_t)); + result = _bt_otp_disconnect_otc(&address); + 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); + + param2 = g_array_new(TRUE, TRUE, sizeof(gchar)); + __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); + } + 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++) + g_free(file_path[i]); + + g_free(file_path); + g_array_free(param2, TRUE); + + break; + } + case BT_OPP_CANCEL_PUSH: { + result = _bt_opp_client_cancel_push(); + + break; + } + case BT_OPP_IS_PUSHING_FILES: { + gboolean is_sending = FALSE; + + result = _bt_opp_client_is_sending(&is_sending); + + g_array_append_vals(*out_param1, &is_sending, + 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_MAP_CREATE_SESSION: { + BT_DBG("BT_MAP_CREATE_SESSION"); + char *address = (char *)g_variant_get_data(in_param1); + char *session_id = NULL; + result = _bt_create_session_sync(address, &session_id); + if (result == BLUETOOTH_ERROR_NONE) + g_array_append_vals(*out_param1, session_id, strlen(session_id)+1); + break; + } + + case BT_MAP_DESTROY_SESSION: { + BT_DBG("BT_MAP_DESTROY_SESSION"); + char* session_id = (char *)g_variant_get_data(in_param1); + result = _bt_destroy_session_sync(session_id); + if (result == BLUETOOTH_ERROR_NONE) + BT_DBG("successfully destroyed session"); + break; + } + + case BT_MAP_SET_FOLDER: { + BT_DBG("BT_MAP_SET_FOLDER"); + char *session_id = (char *)g_variant_get_data(in_param1); + char *name = (char *)g_variant_get_data(in_param2); + result = _bt_map_client_set_folder(session_id, name); + break; + } + + case BT_MAP_LIST_FOLDERS: { + BT_DBG("BT_MAP_LIST_FOLDERS"); + + char* session_id = (char *)g_variant_get_data(in_param1); + char* filter_serialized = (char*)g_variant_get_data(in_param2); + + result = _bt_map_client_list_folders(request_id, context, session_id, filter_serialized); + if (result == BLUETOOTH_ERROR_NONE) + BT_DBG("_bt_map_client_list_folders succeed"); + + break; + } + + case BT_MAP_LIST_FILTER_FIELDS: { + BT_DBG("BT_MAP_LIST_FILTER_FIELDS"); + + char* session_id = (char *)g_variant_get_data(in_param1); + + result = _bt_map_client_list_filter_fields(request_id, context, session_id); + if (result == BLUETOOTH_ERROR_NONE) + BT_DBG("_bt_map_client_list_filter_fields succeed"); + + break; + } + + case BT_MAP_LIST_MESSAGES: { + BT_DBG("BT_MAP_LIST_MESSAGES"); + + char* session_id = (char*)g_variant_get_data(in_param1); + char* folder = (char*)g_variant_get_data(in_param2); + char* filter_serialized = (char*)g_variant_get_data(in_param3); + + result = _bt_map_client_list_messages(request_id, context, session_id, folder, filter_serialized); + if (result == BLUETOOTH_ERROR_NONE) + BT_DBG("_bt_map_client_list_messages succeed"); + else + BT_DBG("_bt_map_client_list_messages failed"); + + break; + } + + case BT_MAP_UPDATE_INBOX: { + BT_DBG("BT_MAP_UPDATE_INBOX"); + char* session_id = (char *)g_variant_get_data(in_param1); + result = _bt_map_client_update_inbox(session_id); + break; + } + + case BT_MAP_PUSH_MESSAGE: { + BT_DBG("BT_MAP_PUSH_MESSAGE"); + + char* session_id = (char *)g_variant_get_data(in_param1); + char* source_file = (char *)g_variant_get_data(in_param2); + char* folder = (char *)g_variant_get_data(in_param3); + char* args_serialized = (char *)g_variant_get_data(in_param4); + + result = _bt_map_client_push_message( + request_id, context, session_id, source_file, folder, args_serialized); + if (result == BLUETOOTH_ERROR_NONE) + BT_DBG("_bt_map_client_push_message succeed"); + else + BT_ERR("_bt_map_client_push_message failed"); + + break; + } + + case BT_MAP_GET_MESSAGE: { + BT_DBG("BT_MAP_GET_MESSAGE"); + // TODO session currently is not used, but should be valid + //char* session_id = (char *)g_variant_get_data(in_param1); + char* message_object = (char *)g_variant_get_data(in_param2); + char* target_file = (char *)g_variant_get_data(in_param3); + bool attachment = false; + __bt_service_get_parameters(in_param4, &attachment, sizeof(bool)); + + result = _bt_map_client_get_message(request_id, context, message_object, + target_file, attachment); + if (result == BLUETOOTH_ERROR_NONE) + BT_DBG("_bt_map_client_get_message succeed"); + + break; + } + + case BT_OBEX_SERVER_ALLOCATE: { + int app_pid; + gboolean is_native; + char *path; + char *sender; sender = (char *)g_dbus_method_invocation_get_sender(context); @@ -1760,6 +2661,7 @@ int __bt_obexd_request(int function_name, sizeof(gboolean)); __bt_service_get_parameters(in_param3, &app_pid, sizeof(int)); + result = _bt_obex_server_allocate(sender, path, app_pid, is_native); @@ -1801,6 +2703,7 @@ int __bt_obexd_request(int function_name, char *file_name; file_name = (char *)g_variant_get_data(in_param1); + result = _bt_obex_server_accept_authorize(file_name, TRUE); break; @@ -1818,8 +2721,8 @@ int __bt_obexd_request(int function_name, __bt_service_get_parameters(in_param2, &is_native, sizeof(gboolean)); - result = _bt_obex_server_set_destination_path( - destination_path, is_native); + result = _bt_obex_server_set_destination_path(destination_path, + is_native); break; } @@ -2105,178 +3008,187 @@ gboolean __bt_service_check_privilege(int function_name, int service_type, const char *unique_name) { - int ret_val; - 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); - - BT_DBG("unique_name: %s", unique_name); - - 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; - } - - 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; - } - - 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; - } - - BT_DBG("client_creds: %s", client_creds); - - 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("user_creds: %s", user_creds); - - switch (function_name) { - case BT_SET_LOCAL_NAME: - case BT_START_DISCOVERY: - case BT_START_CUSTOM_DISCOVERY: - case BT_CANCEL_DISCOVERY: - case BT_OOB_ADD_REMOTE_DATA: - case BT_OOB_REMOVE_REMOTE_DATA: - case BT_SET_ADVERTISING: - case BT_SET_CUSTOM_ADVERTISING: - case BT_SET_ADVERTISING_PARAMETERS: - case BT_START_LE_DISCOVERY: - case BT_STOP_LE_DISCOVERY: - - case BT_BOND_DEVICE: - case BT_CANCEL_BONDING: - case BT_UNBOND_DEVICE: - case BT_SET_ALIAS: - case BT_SET_AUTHORIZATION: - case BT_UNSET_AUTHORIZATION: - case BT_SEARCH_SERVICE: - - case BT_RFCOMM_CLIENT_CONNECT: - case BT_RFCOMM_CLIENT_CANCEL_CONNECT: - case BT_RFCOMM_SOCKET_DISCONNECT: - case BT_RFCOMM_SOCKET_WRITE: - case BT_RFCOMM_CREATE_SOCKET: - case BT_RFCOMM_REMOVE_SOCKET: - - case BT_OPP_PUSH_FILES: - case BT_OPP_CANCEL_PUSH: - - case BT_OBEX_SERVER_ACCEPT_CONNECTION: - case BT_OBEX_SERVER_REJECT_CONNECTION: - case BT_OBEX_SERVER_ACCEPT_FILE: - case BT_OBEX_SERVER_REJECT_FILE: - case BT_OBEX_SERVER_SET_PATH: - case BT_OBEX_SERVER_SET_ROOT: - case BT_OBEX_SERVER_CANCEL_TRANSFER: - case BT_OBEX_SERVER_CANCEL_ALL_TRANSFERS: - - case BT_AUDIO_CONNECT: - case BT_AUDIO_DISCONNECT: - case BT_AG_CONNECT: - case BT_AG_DISCONNECT: - case BT_AV_CONNECT: - case BT_AV_DISCONNECT: - case BT_AV_SOURCE_CONNECT: - case BT_AV_SOURCE_DISCONNECT: - case BT_AVRCP_CONTROL_CONNECT: - case BT_AVRCP_CONTROL_DISCONNECT: - case BT_HF_CONNECT: - case BT_HF_DISCONNECT: - - case BT_HID_CONNECT: - case BT_HID_DISCONNECT: - - case BT_CONNECT_LE: - case BT_DISCONNECT_LE: - - case BT_SET_ADVERTISING_DATA: - case BT_SET_SCAN_RESPONSE_DATA: - - case BT_HDP_CONNECT: - case BT_HDP_DISCONNECT: - case BT_HDP_SEND_DATA: - - case BT_NETWORK_ACTIVATE: - case BT_NETWORK_DEACTIVATE: - case BT_NETWORK_CONNECT: - case BT_NETWORK_DISCONNECT: - case BT_NETWORK_SERVER_DISCONNECT: - - case BT_GATT_GET_PRIMARY_SERVICES: - case BT_GATT_DISCOVER_CHARACTERISTICS: - case BT_GATT_SET_PROPERTY_REQUEST: - case BT_GATT_READ_CHARACTERISTIC: - case BT_GATT_DISCOVER_CHARACTERISTICS_DESCRIPTOR: - 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; - } - break; - - case BT_ENABLE_ADAPTER: - case BT_DISABLE_ADAPTER: - case BT_RESET_ADAPTER: - case BT_RECOVER_ADAPTER: - case BT_ENABLE_ADAPTER_LE: - case BT_DISABLE_ADAPTER_LE: - case BT_SET_CONNECTABLE: - case BT_SET_DISCOVERABLE_MODE: - case BT_ADD_WHITE_LIST: - case BT_REMOVE_WHITE_LIST: - case BT_CLEAR_WHITE_LIST: - case BT_SET_MANUFACTURER_DATA: - case BT_SET_SCAN_PARAMETERS: - - case BT_CANCEL_SEARCH_SERVICE: - case BT_ENABLE_RSSI: - - case BT_RFCOMM_ACCEPT_CONNECTION: - case BT_RFCOMM_REJECT_CONNECTION: - case BT_RFCOMM_LISTEN: - - 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_SET_CONTENT_PROTECT: - case BT_BOND_DEVICE_BY_TYPE: - case BT_SET_LE_PRIVACY: - case BT_LE_CONN_UPDATE: - 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: + int ret_val; + 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; + } + + 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; + } + + 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: + case BT_START_DISCOVERY: + case BT_START_CUSTOM_DISCOVERY: + case BT_CANCEL_DISCOVERY: + case BT_OOB_ADD_REMOTE_DATA: + case BT_OOB_REMOVE_REMOTE_DATA: + case BT_SET_ADVERTISING: + case BT_SET_CUSTOM_ADVERTISING: + case BT_SET_ADVERTISING_PARAMETERS: + case BT_START_LE_DISCOVERY: + case BT_STOP_LE_DISCOVERY: + case BT_SET_SCAN_PARAMETERS: + + case BT_BOND_DEVICE: + case BT_CANCEL_BONDING: + case BT_UNBOND_DEVICE: + case BT_SET_ALIAS: + case BT_SET_AUTHORIZATION: + case BT_UNSET_AUTHORIZATION: + case BT_SEARCH_SERVICE: + + case BT_RFCOMM_CLIENT_CONNECT: + case BT_RFCOMM_CLIENT_CANCEL_CONNECT: + case BT_RFCOMM_SOCKET_DISCONNECT: + case BT_RFCOMM_SOCKET_WRITE: + case BT_RFCOMM_CREATE_SOCKET: + case BT_RFCOMM_REMOVE_SOCKET: + + case BT_OPP_PUSH_FILES: + case BT_OPP_CANCEL_PUSH: + /* TODO: MAP? MAP functions, see above */ + + case BT_OBEX_SERVER_ACCEPT_CONNECTION: + case BT_OBEX_SERVER_REJECT_CONNECTION: + case BT_OBEX_SERVER_ACCEPT_FILE: + case BT_OBEX_SERVER_REJECT_FILE: + case BT_OBEX_SERVER_SET_PATH: + case BT_OBEX_SERVER_SET_ROOT: + case BT_OBEX_SERVER_CANCEL_TRANSFER: + case BT_OBEX_SERVER_CANCEL_ALL_TRANSFERS: + + case BT_AUDIO_CONNECT: + case BT_AUDIO_DISCONNECT: + case BT_AG_CONNECT: + case BT_AG_DISCONNECT: + case BT_AV_CONNECT: + case BT_AV_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: + + case BT_SET_ADVERTISING_DATA: + case BT_SET_SCAN_RESPONSE_DATA: + + 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: + case BT_NETWORK_CONNECT: + case BT_NETWORK_DISCONNECT: + case BT_NETWORK_SERVER_DISCONNECT: + + case BT_GATT_GET_PRIMARY_SERVICES: + case BT_GATT_DISCOVER_CHARACTERISTICS: + 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: + case BT_PBAP_CONNECT: case BT_PBAP_DISCONNECT: case BT_PBAP_GET_PHONEBOOK_SIZE: @@ -2284,57 +3196,176 @@ gboolean __bt_service_check_privilege(int function_name, case BT_PBAP_GET_LIST: case BT_PBAP_PULL_VCARD: case BT_PBAP_PHONEBOOK_SEARCH: - 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: - case BT_GET_RSSI: - - case BT_GET_LOCAL_NAME: - case BT_GET_LOCAL_ADDRESS: - case BT_GET_LOCAL_VERSION: - case BT_IS_SERVICE_USED: - case BT_GET_DISCOVERABLE_MODE: - case BT_GET_DISCOVERABLE_TIME: - case BT_IS_DISCOVERYING: - case BT_IS_LE_DISCOVERYING: - case BT_IS_CONNECTABLE: - case BT_GET_BONDED_DEVICES: - case BT_GET_BONDED_DEVICE: - case BT_IS_DEVICE_CONNECTED: - case BT_GET_SPEAKER_GAIN: - case BT_SET_SPEAKER_GAIN: - case BT_OOB_READ_LOCAL_DATA: - case BT_RFCOMM_CLIENT_IS_CONNECTED: - case BT_RFCOMM_IS_UUID_AVAILABLE: - case BT_GET_ADVERTISING_DATA: - case BT_GET_SCAN_RESPONSE_DATA: - case BT_IS_ADVERTISING: - - case BT_OBEX_SERVER_ALLOCATE: - case BT_OBEX_SERVER_DEALLOCATE: - - /* Non-privilege control */ - break; - default: - BT_ERR("Unknown function!"); - result = FALSE; - break; - } - - if (client_creds) - free(client_creds); - - if (user_creds) - free(user_creds); - - return result; + 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: + case BT_DISABLE_ADAPTER: + case BT_RESET_ADAPTER: + case BT_RECOVER_ADAPTER: + case BT_ENABLE_ADAPTER_LE: + case BT_DISABLE_ADAPTER_LE: + case BT_SET_CONNECTABLE: + case BT_SET_DISCOVERABLE_MODE: + case BT_ADD_WHITE_LIST: + case BT_REMOVE_WHITE_LIST: + case BT_CLEAR_WHITE_LIST: + case BT_SET_MANUFACTURER_DATA: + + case BT_CANCEL_SEARCH_SERVICE: + case BT_ENABLE_RSSI: + + case BT_RFCOMM_ACCEPT_CONNECTION: + case BT_RFCOMM_REJECT_CONNECTION: + case BT_RFCOMM_LISTEN: + + case BT_HID_ENABLE_BARCODE_FEATURE: + + 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: + case BT_UPDATE_LE_CONNECTION_MODE: + case BT_REQ_ATT_MTU: + case BT_GET_DEVICE_IDA: + 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_GET_ATT_MTU: + + case BT_LE_IPSP_INIT: + case BT_LE_IPSP_DEINIT: + case BT_LE_IPSP_CONNECT: + case BT_LE_IPSP_DISCONNECT: + case BT_PXP_MONITOR_SET_PROPERTY: + case BT_PXP_MONITOR_GET_PROPERTY: + case BT_PXP_MONITOR_GET_SUPPORTED_SERIVCES: + case BT_PXP_REPORTER_REGISTER: + case BT_PXP_REPORTER_UNREGISTER: + case BT_PXP_REPORTER_GET_PROPERTY: + + /* TDS */ + case BT_TDS_PROVIDER_REGISTER: + case BT_TDS_PROVIDER_UNREGISTER: + case BT_TDS_PROVIDER_SET_MANUF_DATA: + case BT_TDS_PROVIDER_CREATE: + case BT_TDS_PROVIDER_DESTROY: + case BT_TDS_PROVIDER_SET_TRANSPORT_DATA: + case BT_TDS_SEND_ACTIVATION_RESPONSE: + case BT_TDS_READ_TRANSPORT_DATA: + case BT_TDS_ENABLE_CONTROL_POINT: + case BT_TDS_ACTIVATE_CONTROL_POINT: + + /* OTP Server */ + case BT_OTP_SERVER_INIT: + case BT_OTP_SERVER_DEINIT: + case BT_OTP_READ_VALUE: + case BT_OTP_ENABLE_NOTIFICATION: + case BT_OTP_WRITE_VALUE: + case BT_LE_OTC_CONNECT: + case BT_LE_OTC_DISCONNECT: + + case BT_MAP_CREATE_SESSION: + case BT_MAP_DESTROY_SESSION: + case BT_MAP_SET_FOLDER: + case BT_MAP_LIST_FOLDERS: + case BT_MAP_LIST_FILTER_FIELDS: + case BT_MAP_LIST_MESSAGES: + case BT_MAP_UPDATE_INBOX: + case BT_MAP_PUSH_MESSAGE: + case BT_MAP_GET_MESSAGE: + + 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: + case BT_GET_RSSI: + + case BT_GET_LOCAL_NAME: + case BT_GET_LOCAL_ADDRESS: + case BT_GET_LOCAL_VERSION: + case BT_IS_SERVICE_USED: + case BT_GET_DISCOVERABLE_MODE: + case BT_GET_DISCOVERABLE_TIME: + case BT_IS_DISCOVERYING: + 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: + case BT_RFCOMM_CLIENT_IS_CONNECTED: + case BT_RFCOMM_IS_UUID_AVAILABLE: + case BT_GET_ADVERTISING_DATA: + 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_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: + BT_ERR("Unknown function!"); + result = FALSE; + break; + } + + if (client_creds) + free(client_creds); + + if (user_creds) + free(user_creds); + + return result; } GDBusNodeInfo *__bt_service_create_method_node_info @@ -2385,39 +3416,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: @@ -2437,10 +3493,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; @@ -2450,38 +3502,38 @@ void _bt_service_unregister(void) int _bt_service_cynara_init(void) { - int result; - char err_msg[256] = {0, }; + int result; + char err_msg[256] = {0, }; - retv_if(p_cynara != NULL, BLUETOOTH_ERROR_ALREADY_INITIALIZED); + retv_if(p_cynara != NULL, BLUETOOTH_ERROR_ALREADY_INITIALIZED); - result = cynara_initialize(&p_cynara, conf); + 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; - } + 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; + return BLUETOOTH_ERROR_NONE; } void _bt_service_cynara_deinit(void) { - int result; - char err_msg[256] = {0, }; + int result; + char err_msg[256] = {0, }; - ret_if(p_cynara == NULL); + ret_if(p_cynara == NULL); - result = cynara_finish(p_cynara); + 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; - } + 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; + p_cynara = NULL; + conf = NULL; }