Fix data type sent in reply to BT-API from bt-service

This patch fixes the mismatched output parameter data type sent
to bt-api over dbus in reply to various requests.

Change-Id: Iae3ceb83014f28f8c4fd7d51aaebe958a3fc630a
Signed-off-by: Atul Rai <a.rai@samsung.com>

diff --git a/bt-api/bt-request-sender.c b/bt-api/bt-request-sender.c
index da58dd5..f5f6dfd 100644 (file)
--- a/bt-api/bt-request-sender.c
+++ b/bt-api/bt-request-sender.c
@@ -101,14 +101,14 @@ void _bt_get_event_info(int service_function, GArray *output,
                *event = BLUETOOTH_EVENT_BONDED_DEVICE_REMOVED;
                ret_if(output == NULL);
                *param_data = &g_array_index(output,
-                               bluetooth_device_info_t, 0);
+                               bluetooth_device_address_t, 0);
                break;
        case BT_SEARCH_SERVICE:
                *event_type = BT_ADAPTER_EVENT;
                *event = BLUETOOTH_EVENT_SERVICE_SEARCHED;
                ret_if(output == NULL);
                *param_data = &g_array_index(output,
-                               bluetooth_device_info_t, 0);
+                               bt_sdp_info_t, 0);
                break;
        case BT_HID_CONNECT:
                *event_type = BT_HID_EVENT;

diff --git a/bt-service-adaptation/services/bt-request-handler.c b/bt-service-adaptation/services/bt-request-handler.c
index 9a0ff5c..86d12cb 100644 (file)
--- a/bt-service-adaptation/services/bt-request-handler.c
+++ b/bt-service-adaptation/services/bt-request-handler.c
@@ -597,6 +597,14 @@ int __bt_bluez_request(int function_name,
                        sender = (char*)g_dbus_method_invocation_get_sender(context);
                        _bt_save_invocation_context(context, result, sender,
                                        function_name, (gpointer)addr);
+               } else {
+                       bluetooth_device_info_t dev_info;
+
+                       memset(&dev_info, 0x00, sizeof(bluetooth_device_info_t));
+                       memcpy(&dev_info.device_address, &address,
+                                       sizeof(bluetooth_device_address_t));
+                       g_array_append_vals(*out_param1, &dev_info,
+                                       sizeof(bluetooth_device_info_t));
                }
                break;
        }
@@ -615,12 +623,15 @@ int __bt_bluez_request(int function_name,
                        sender = (char*)g_dbus_method_invocation_get_sender(context);
                        _bt_save_invocation_context(context, result, sender,
                                        function_name, (gpointer)addr);
+               } else {
+                       g_array_append_vals(*out_param1, &address,
+                                       sizeof(bluetooth_device_address_t));
                }
                break;
        }
        case BT_CANCEL_BONDING:{
-                      result = _bt_cancel_bonding();
-                      break;
+               result = _bt_cancel_bonding();
+               break;
        }
        case BT_SEARCH_SERVICE: {
                bluetooth_device_address_t address = { {0} };
@@ -635,15 +646,20 @@ int __bt_bluez_request(int function_name,
                        sender = (char*)g_dbus_method_invocation_get_sender(context);
                        _bt_save_invocation_context(context, result, sender,
                                        function_name, (gpointer)addr);
-               } else
-                       g_array_append_vals(*out_param1, &address,
+               } else {
+                       bt_sdp_info_t sdp_info;
+
+                       memset(&sdp_info, 0x00, sizeof(bt_sdp_info_t));
+                       memcpy(&sdp_info.device_addr, &address,
                                        sizeof(bluetooth_device_address_t));
+                       g_array_append_vals(*out_param1, &sdp_info, sizeof(bt_sdp_info_t));
+               }
                break;
        }
        case BT_CANCEL_SEARCH_SERVICE: {
-              result = _bt_cancel_search_device();
-                      break;
-       }
+               result = _bt_cancel_search_device();
+               break;
+       }
        case BT_PASSKEY_REPLY: {
                const char *passkey = NULL;
                gboolean authentication_reply = FALSE;
@@ -663,9 +679,9 @@ int __bt_bluez_request(int function_name,
        case BT_SET_AUTHORIZATION: {
                bluetooth_device_address_t address = { {0} };
                gboolean authorize;
-                __bt_service_get_parameters(in_param1,
+               __bt_service_get_parameters(in_param1,
                                &address, sizeof(bluetooth_device_address_t));
-                __bt_service_get_parameters(in_param2,
+               __bt_service_get_parameters(in_param2,
                                &authorize, sizeof(gboolean));
                result = _bt_set_authorization(&address, authorize);
                break;
@@ -1050,9 +1066,11 @@ int __bt_bluez_request(int function_name,
                        g_array_append_vals(*out_param1, &conn_info,
                                        sizeof(bluetooth_rfcomm_connection_t));
                } else {
+                       char *addr = g_malloc0(BT_ADDRESS_STRING_SIZE);
                        BT_ERR("BT_RFCOMM_CLIENT_CONNECT success, save context");
+                       _bt_convert_addr_type_to_string(addr, address.addr);
                        sender = (char*)g_dbus_method_invocation_get_sender(context);
-                       _bt_save_invocation_context(context, result, sender, function_name, NULL);
+                       _bt_save_invocation_context(context, result, sender, function_name, addr);
                }
                break;
        }
@@ -1123,13 +1141,13 @@ int __bt_bluez_request(int function_name,
        }
        case BT_AV_CONNECT: {
                bluetooth_device_address_t address = { {0} };
-                       __bt_service_get_parameters(in_param1,
+               __bt_service_get_parameters(in_param1,
                                &address, sizeof(bluetooth_device_address_t));
 
                result = _bt_audio_connect(BT_AUDIO_A2DP, &address);
 
                if (result != BLUETOOTH_ERROR_NONE) {
-                       char *addr = g_malloc0(BT_ADDRESS_STRING_SIZE);
+                       char addr[BT_ADDRESS_STRING_SIZE];
                        _bt_convert_addr_type_to_string(addr, address.addr);
                        g_array_append_vals(*out_param1, addr, BT_ADDRESS_STRING_SIZE);
                } else {
@@ -1144,12 +1162,12 @@ int __bt_bluez_request(int function_name,
        case BT_AUDIO_CONNECT: {
                bluetooth_device_address_t address = { {0} };
                __bt_service_get_parameters(in_param1,
-                       &address, sizeof(bluetooth_device_address_t));
+                               &address, sizeof(bluetooth_device_address_t));
 
                result = _bt_audio_connect(BT_AUDIO_ALL, &address);
 
                if (result != BLUETOOTH_ERROR_NONE) {
-                       char *addr = g_malloc0(BT_ADDRESS_STRING_SIZE);
+                       char addr[BT_ADDRESS_STRING_SIZE];
                        _bt_convert_addr_type_to_string(addr, address.addr);
                        g_array_append_vals(*out_param1, addr, BT_ADDRESS_STRING_SIZE);
                } else {
@@ -1163,13 +1181,13 @@ int __bt_bluez_request(int function_name,
        }
        case BT_AUDIO_DISCONNECT: {
                bluetooth_device_address_t address = { {0} };
-                       __bt_service_get_parameters(in_param1,
+               __bt_service_get_parameters(in_param1,
                                &address, sizeof(bluetooth_device_address_t));
 
                result = _bt_audio_disconnect(BT_AUDIO_ALL, &address);
 
                if (result != BLUETOOTH_ERROR_NONE) {
-                       char *addr = g_malloc0(BT_ADDRESS_STRING_SIZE);
+                       char addr[BT_ADDRESS_STRING_SIZE];
                        _bt_convert_addr_type_to_string(addr, address.addr);
                        g_array_append_vals(*out_param1, addr, BT_ADDRESS_STRING_SIZE);
                } else {
@@ -1177,19 +1195,19 @@ int __bt_bluez_request(int function_name,
                        _bt_convert_addr_type_to_string(addr, address.addr);
                        sender = (char*)g_dbus_method_invocation_get_sender(context);
                        _bt_save_invocation_context(context, result, sender,
-                               function_name, (gpointer)addr);
+                                       function_name, (gpointer)addr);
                }
                break;
        }
        case BT_AV_DISCONNECT: {
                bluetooth_device_address_t address = { {0} };
                __bt_service_get_parameters(in_param1,
-                       &address, sizeof(bluetooth_device_address_t));
+                               &address, sizeof(bluetooth_device_address_t));
 
                result = _bt_audio_disconnect(BT_AUDIO_A2DP, &address);
 
                if (result != BLUETOOTH_ERROR_NONE) {
-                       char *addr = g_malloc0(BT_ADDRESS_STRING_SIZE);
+                       char addr[BT_ADDRESS_STRING_SIZE];
                        _bt_convert_addr_type_to_string(addr, address.addr);
                        g_array_append_vals(*out_param1, addr, BT_ADDRESS_STRING_SIZE);
                } else {
@@ -1197,61 +1215,62 @@ int __bt_bluez_request(int function_name,
                        _bt_convert_addr_type_to_string(addr, address.addr);
                        sender = (char*)g_dbus_method_invocation_get_sender(context);
                        _bt_save_invocation_context(context, result, sender,
-                       function_name, (gpointer)addr);
+                                       function_name, (gpointer)addr);
                }
                break;
        }
        case BT_AG_CONNECT: {
-                   bluetooth_device_address_t address = { {0} };
-                           __bt_service_get_parameters(in_param1,
-                                   &address, sizeof(bluetooth_device_address_t));
-
-                   result = _bt_audio_connect(BT_AUDIO_HSP, &address);
-
-                   if (result != BLUETOOTH_ERROR_NONE) {
-                           char *addr = g_malloc0(BT_ADDRESS_STRING_SIZE);
-                           _bt_convert_addr_type_to_string(addr, address.addr);
-                           g_array_append_vals(*out_param1, addr, BT_ADDRESS_STRING_SIZE);
-                   } else {
-                           char *addr = g_malloc0(BT_ADDRESS_STRING_SIZE);
-                           _bt_convert_addr_type_to_string(addr, address.addr);
-                           sender = (char*)g_dbus_method_invocation_get_sender(context);
-                           _bt_save_invocation_context(context, result, sender,
-                                           function_name, (gpointer)addr);
-                   }
-                   break;
+               bluetooth_device_address_t address = { {0} };
+               __bt_service_get_parameters(in_param1,
+                               &address, sizeof(bluetooth_device_address_t));
+
+               result = _bt_audio_connect(BT_AUDIO_HSP, &address);
+
+               if (result != BLUETOOTH_ERROR_NONE) {
+                       char addr[BT_ADDRESS_STRING_SIZE];
+                       _bt_convert_addr_type_to_string(addr, address.addr);
+                       g_array_append_vals(*out_param1, addr, BT_ADDRESS_STRING_SIZE);
+               } else {
+                       char *addr = g_malloc0(BT_ADDRESS_STRING_SIZE);
+                       _bt_convert_addr_type_to_string(addr, address.addr);
+                       sender = (char*)g_dbus_method_invocation_get_sender(context);
+                       _bt_save_invocation_context(context, result, sender,
+                                       function_name, (gpointer)addr);
+               }
+               break;
        }
        case BT_AG_DISCONNECT: {
-              bluetooth_device_address_t address = { {0} };
-
-              __bt_service_get_parameters(in_param1,
-                              &address, sizeof(bluetooth_device_address_t));
-
-              result = _bt_audio_disconnect(BT_AUDIO_HSP, &address);
-
-              if (result != BLUETOOTH_ERROR_NONE) {
-                      char *addr = g_malloc0(BT_ADDRESS_STRING_SIZE);
-                      _bt_convert_addr_type_to_string(addr, address.addr);
-                      g_array_append_vals(*out_param1, addr, BT_ADDRESS_STRING_SIZE);
-              } else {
-                      char *addr = g_malloc0(BT_ADDRESS_STRING_SIZE);
-                      _bt_convert_addr_type_to_string(addr, address.addr);
-                      sender = (char*)g_dbus_method_invocation_get_sender(context);
-                      _bt_save_invocation_context(context, result, sender,
-                                      function_name, (gpointer)addr);
-              }
-              break;
+               bluetooth_device_address_t address = { {0} };
+
+               __bt_service_get_parameters(in_param1,
+                               &address, sizeof(bluetooth_device_address_t));
+
+               result = _bt_audio_disconnect(BT_AUDIO_HSP, &address);
+
+               if (result != BLUETOOTH_ERROR_NONE) {
+                       char addr[BT_ADDRESS_STRING_SIZE];
+                       _bt_convert_addr_type_to_string(addr, address.addr);
+                       g_array_append_vals(*out_param1, addr, BT_ADDRESS_STRING_SIZE);
+               } else {
+                       char *addr = g_malloc0(BT_ADDRESS_STRING_SIZE);
+                       _bt_convert_addr_type_to_string(addr, address.addr);
+                       sender = (char*)g_dbus_method_invocation_get_sender(context);
+                       _bt_save_invocation_context(context, result, sender,
+                                       function_name, (gpointer)addr);
+               }
+               break;
        }
        case BT_AV_SOURCE_CONNECT: {
                bluetooth_device_address_t address = { {0} };
 
                __bt_service_get_parameters(in_param1,
-                       &address, sizeof(bluetooth_device_address_t));
+                               &address, sizeof(bluetooth_device_address_t));
 
                result = _bt_audio_connect(BT_AUDIO_A2DP_SOURCE, &address);
                if (result != BLUETOOTH_ERROR_NONE) {
-                       g_array_append_vals(*out_param1, &address,
-                       sizeof(bluetooth_device_address_t));
+                       char addr[BT_ADDRESS_STRING_SIZE];
+                       _bt_convert_addr_type_to_string(addr, address.addr);
+                       g_array_append_vals(*out_param1, addr, BT_ADDRESS_STRING_SIZE);
                } else {
                        char *addr = g_malloc0(BT_ADDRESS_STRING_SIZE);
                        _bt_convert_addr_type_to_string(addr, address.addr);
@@ -1269,8 +1288,9 @@ int __bt_bluez_request(int function_name,
 
                result = _bt_audio_disconnect(BT_AUDIO_A2DP_SOURCE, &address);
                if (result != BLUETOOTH_ERROR_NONE) {
-                       g_array_append_vals(*out_param1, &address,
-                                       sizeof(bluetooth_device_address_t));
+                       char addr[BT_ADDRESS_STRING_SIZE];
+                       _bt_convert_addr_type_to_string(addr, address.addr);
+                       g_array_append_vals(*out_param1, addr, BT_ADDRESS_STRING_SIZE);
                } else {
                        char *addr = g_malloc0(BT_ADDRESS_STRING_SIZE);
                        _bt_convert_addr_type_to_string(addr, address.addr);
@@ -1284,12 +1304,13 @@ int __bt_bluez_request(int function_name,
                bluetooth_device_address_t address = { {0} };
 
                __bt_service_get_parameters(in_param1,
-                       &address, sizeof(bluetooth_device_address_t));
+                               &address, sizeof(bluetooth_device_address_t));
 
                result = _bt_audio_connect(BT_AVRCP_TARGET, &address);
                if (result != BLUETOOTH_ERROR_NONE) {
-                       g_array_append_vals(*out_param1, &address,
-                       sizeof(bluetooth_device_address_t));
+                       char addr[BT_ADDRESS_STRING_SIZE];
+                       _bt_convert_addr_type_to_string(addr, address.addr);
+                       g_array_append_vals(*out_param1, addr, BT_ADDRESS_STRING_SIZE);
                } else {
                        char *addr = g_malloc0(BT_ADDRESS_STRING_SIZE);
                        _bt_convert_addr_type_to_string(addr, address.addr);
@@ -1307,8 +1328,49 @@ int __bt_bluez_request(int function_name,
 
                result = _bt_audio_disconnect(BT_AVRCP_TARGET, &address);
                if (result != BLUETOOTH_ERROR_NONE) {
-                       g_array_append_vals(*out_param1, &address,
-                                       sizeof(bluetooth_device_address_t));
+                       char addr[BT_ADDRESS_STRING_SIZE];
+                       _bt_convert_addr_type_to_string(addr, address.addr);
+                       g_array_append_vals(*out_param1, addr, BT_ADDRESS_STRING_SIZE);
+               } else {
+                       char *addr = g_malloc0(BT_ADDRESS_STRING_SIZE);
+                       _bt_convert_addr_type_to_string(addr, address.addr);
+                       sender = (char*)g_dbus_method_invocation_get_sender(context);
+                       _bt_save_invocation_context(context, result, sender,
+                                       function_name, (gpointer)addr);
+               }
+               break;
+       }
+       case BT_AVRCP_CONTROL_CONNECT: {
+               bluetooth_device_address_t address = { {0} };
+
+               __bt_service_get_parameters(in_param1,
+                               &address, sizeof(bluetooth_device_address_t));
+
+               result = _bt_audio_connect(BT_AVRCP, &address);
+               if (result != BLUETOOTH_ERROR_NONE) {
+                       char addr[BT_ADDRESS_STRING_SIZE];
+                       _bt_convert_addr_type_to_string(addr, address.addr);
+                       g_array_append_vals(*out_param1, addr, BT_ADDRESS_STRING_SIZE);
+               } else {
+                       char *addr = g_malloc0(BT_ADDRESS_STRING_SIZE);
+                       _bt_convert_addr_type_to_string(addr, address.addr);
+                       sender = (char*)g_dbus_method_invocation_get_sender(context);
+                       _bt_save_invocation_context(context, result, sender,
+                                       function_name, (gpointer)addr);
+               }
+               break;
+       }
+       case BT_AVRCP_CONTROL_DISCONNECT: {
+               bluetooth_device_address_t address = { {0} };
+
+               __bt_service_get_parameters(in_param1,
+                               &address, sizeof(bluetooth_device_address_t));
+
+               result = _bt_audio_disconnect(BT_AVRCP, &address);
+               if (result != BLUETOOTH_ERROR_NONE) {
+                       char addr[BT_ADDRESS_STRING_SIZE];
+                       _bt_convert_addr_type_to_string(addr, address.addr);
+                       g_array_append_vals(*out_param1, addr, BT_ADDRESS_STRING_SIZE);
                } else {
                        char *addr = g_malloc0(BT_ADDRESS_STRING_SIZE);
                        _bt_convert_addr_type_to_string(addr, address.addr);
@@ -1318,76 +1380,38 @@ int __bt_bluez_request(int function_name,
                }
                break;
        }
-        case BT_AVRCP_CONTROL_CONNECT: {
-                bluetooth_device_address_t address = { {0} };
-
-                __bt_service_get_parameters(in_param1,
-                        &address, sizeof(bluetooth_device_address_t));
-
-                result = _bt_audio_connect(BT_AVRCP, &address);
-                if (result != BLUETOOTH_ERROR_NONE) {
-                        g_array_append_vals(*out_param1, &address,
-                        sizeof(bluetooth_device_address_t));
-                } else {
-                        char *addr = g_malloc0(BT_ADDRESS_STRING_SIZE);
-                        _bt_convert_addr_type_to_string(addr, address.addr);
-                        sender = (char*)g_dbus_method_invocation_get_sender(context);
-                        _bt_save_invocation_context(context, result, sender,
-                                        function_name, (gpointer)addr);
-                }
-                break;
-        }
-        case BT_AVRCP_CONTROL_DISCONNECT: {
-                bluetooth_device_address_t address = { {0} };
-
-                __bt_service_get_parameters(in_param1,
-                                &address, sizeof(bluetooth_device_address_t));
-
-                result = _bt_audio_disconnect(BT_AVRCP, &address);
-                if (result != BLUETOOTH_ERROR_NONE) {
-                        g_array_append_vals(*out_param1, &address,
-                                        sizeof(bluetooth_device_address_t));
-                } else {
-                        char *addr = g_malloc0(BT_ADDRESS_STRING_SIZE);
-                        _bt_convert_addr_type_to_string(addr, address.addr);
-                        sender = (char*)g_dbus_method_invocation_get_sender(context);
-                        _bt_save_invocation_context(context, result, sender,
-                                        function_name, (gpointer)addr);
-                }
-                break;
-        }
        case BT_AVRCP_HANDLE_CONTROL: {
                int key_code;
                __bt_service_get_parameters(in_param1, &key_code, sizeof(int));
                result = _bt_avrcp_control_cmd(key_code);
                break;
        }
-        case BT_AVRCP_CONTROL_SET_PROPERTY: {
-                int type;
-                unsigned int value;
+       case BT_AVRCP_CONTROL_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));
+               __bt_service_get_parameters(in_param1,
+                               &type, sizeof(int));
+               __bt_service_get_parameters(in_param2,
+                               &value, sizeof(unsigned int));
 
-                result = _bt_avrcp_control_set_property(type, value);
-                break;
-        }
-        case BT_AVRCP_CONTROL_GET_PROPERTY: {
-                int type;
-                unsigned int value;
+               result = _bt_avrcp_control_set_property(type, value);
+               break;
+       }
+       case BT_AVRCP_CONTROL_GET_PROPERTY: {
+               int type;
+               unsigned int value;
 
-                __bt_service_get_parameters(in_param1, &type, sizeof(int));
+               __bt_service_get_parameters(in_param1, &type, sizeof(int));
 
-                result = _bt_avrcp_control_get_property(type, &value);
-                g_array_append_vals(*out_param1, &value, sizeof(int));
+               result = _bt_avrcp_control_get_property(type, &value);
+               g_array_append_vals(*out_param1, &value, sizeof(int));
 
-                break;
-        }
+               break;
+       }
        case BT_AVRCP_GET_TRACK_INFO: {
                result = _bt_avrcp_control_get_track_info();
-                /* Save invocation */
+               /* Save invocation */
                if (result == BLUETOOTH_ERROR_NONE) {
                        sender = (char*)g_dbus_method_invocation_get_sender(context);
                        _bt_save_invocation_context(context, result, sender,
@@ -1439,52 +1463,59 @@ int __bt_bluez_request(int function_name,
        case BT_HDP_CONNECT: {
                int app_id = -1;
                char *app_handle;
-               bt_hdp_qos_type_t channel_type;
-               bluetooth_device_address_t address = { {0} };
-               int *channel_id = g_new0(int, 1);
+
+               bt_hdp_connected_t *conn_info = NULL;
+
+               conn_info = g_malloc0(sizeof(bt_hdp_connected_t));
 
                app_handle = (char *)g_variant_get_data(in_param1);
+               g_strlcpy(conn_info->app_handle, app_handle, BT_MAX_HANDLE_LENGTH);
                sscanf(app_handle, "health_app_%d", &app_id);
 
                __bt_service_get_parameters(in_param2,
-                               &channel_type, sizeof(bt_hdp_qos_type_t));
+                               &(conn_info->type), sizeof(bt_hdp_qos_type_t));
                __bt_service_get_parameters(in_param3,
-                               &address, sizeof(bluetooth_device_address_t));
+                               &(conn_info->device_address),
+                               sizeof(bluetooth_device_address_t));
 
-               result = _bt_hdp_connect(app_id, &address, channel_type, channel_id);
+               result = _bt_hdp_connect(app_id, &(conn_info->device_address),
+                               conn_info->type, (int *)(&(conn_info->channel_id)));
                if (result != BLUETOOTH_ERROR_NONE) {
-                       g_array_append_vals(*out_param1, &address,
-                                       sizeof(bluetooth_device_address_t));
-                       g_free(channel_id);
+                       g_array_append_vals(*out_param1, conn_info,
+                                       sizeof(bt_hdp_connected_t));
+                       g_free(conn_info);
                } else {
                        sender = (char*)g_dbus_method_invocation_get_sender(context);
                        _bt_save_invocation_context(context, result, sender,
-                                       function_name, (gpointer)channel_id);
+                                       function_name, (gpointer)conn_info);
                }
                break;
        }
        case BT_HDP_DISCONNECT: {
-               int *channel_id = g_new0(int, 1);
-               bluetooth_device_address_t address = { {0} };
+               bt_hdp_disconnected_t *hdp_disconn_info = NULL;
 
-               __bt_service_get_parameters(in_param1, channel_id, sizeof(int));
+               hdp_disconn_info = g_malloc0(sizeof(bt_hdp_disconnected_t));
+
+               __bt_service_get_parameters(in_param1,
+                               &(hdp_disconn_info->channel_id), sizeof(int));
                __bt_service_get_parameters(in_param2,
-                               &address, sizeof(bluetooth_device_address_t));
+                               &(hdp_disconn_info->device_address),
+                               sizeof(bluetooth_device_address_t));
 
-               result = _bt_hdp_disconnect(*channel_id);
+               result = _bt_hdp_disconnect(hdp_disconn_info->channel_id);
                if (result != BLUETOOTH_ERROR_NONE) {
-                       g_array_append_vals(*out_param1, &address,
-                                       sizeof(bluetooth_device_address_t));
-                       g_free(channel_id);
+                       g_array_append_vals(*out_param1, hdp_disconn_info,
+                                       sizeof(bt_hdp_disconnected_t));
+                       g_free(hdp_disconn_info);
                } else {
                        sender = (char*)g_dbus_method_invocation_get_sender(context);
                        _bt_save_invocation_context(context, result, sender,
-                                       function_name, (gpointer)channel_id);
+                                       function_name, (gpointer)hdp_disconn_info);
                }
                break;
        }
        case BT_HDP_GET_FD: {
-               int  *channel_id = g_new0(int, 1);
+               int *channel_id = g_new0(int, 1);
 
                __bt_service_get_parameters(in_param1, channel_id, sizeof(int));
 
@@ -1530,7 +1561,6 @@ int __bt_bluez_request(int function_name,
                g_free((gpointer)meta_data.artist);
                g_free((gpointer)meta_data.album);
                g_free((gpointer)meta_data.genre);
-
                break;
        }
        case BT_AVRCP_SET_PROPERTY: {
@@ -1561,7 +1591,6 @@ int __bt_bluez_request(int function_name,
                }
 
                result = _bt_avrcp_set_property(type, value);
-
                break;
        }
        case BT_AVRCP_SET_PROPERTIES: {
@@ -1585,16 +1614,16 @@ int __bt_bluez_request(int function_name,
                app = (char *)g_dbus_method_invocation_get_sender(context);
                adv_handle = g_malloc0(sizeof(int));
 
-                __bt_service_get_parameters(in_param1,
-                       adv_handle, sizeof(int));
+               __bt_service_get_parameters(in_param1,
+                               adv_handle, sizeof(int));
                __bt_service_get_parameters(in_param2,
-                       &adv, sizeof(bluetooth_advertising_data_t));
+                               &adv, sizeof(bluetooth_advertising_data_t));
                __bt_service_get_parameters(in_param3,
-                       &length, sizeof(int));
-                __bt_service_get_parameters(in_param4,
-                       &use_reserved_slot, sizeof(gboolean));
+                               &length, sizeof(int));
+               __bt_service_get_parameters(in_param4,
+                               &use_reserved_slot, sizeof(gboolean));
                result = _bt_set_advertising_data(app, *adv_handle,
-                       &adv, length, use_reserved_slot);
+                               &adv, length, use_reserved_slot);
                if (result != BLUETOOTH_ERROR_NONE) {
                        BT_ERR("Set Advertising data failed!!");
                        g_free(adv_handle);
@@ -1605,26 +1634,26 @@ int __bt_bluez_request(int function_name,
                break;
        }
        case BT_SET_SCAN_RESPONSE_DATA: {
-                char *app = NULL;
-                int *adv_handle;
-                bluetooth_scan_resp_data_t rsp = { {0} };
-                int length;
-                gboolean use_reserved_slot = FALSE;
+               char *app = NULL;
+               int *adv_handle;
+               bluetooth_scan_resp_data_t rsp = { {0} };
+               int length;
+               gboolean use_reserved_slot = FALSE;
 
-                app = (char *)g_dbus_method_invocation_get_sender(context);
+               app = (char *)g_dbus_method_invocation_get_sender(context);
                adv_handle = g_malloc0(sizeof(int));
 
-                __bt_service_get_parameters(in_param1,
-                                adv_handle, sizeof(int));
-                __bt_service_get_parameters(in_param2,
-                                &rsp, sizeof(bluetooth_scan_resp_data_t));
-                __bt_service_get_parameters(in_param3,
-                                &length, sizeof(int));
-                __bt_service_get_parameters(in_param4,
-                                &use_reserved_slot, sizeof(gboolean));
+               __bt_service_get_parameters(in_param1,
+                               adv_handle, sizeof(int));
+               __bt_service_get_parameters(in_param2,
+                               &rsp, sizeof(bluetooth_scan_resp_data_t));
+               __bt_service_get_parameters(in_param3,
+                               &length, sizeof(int));
+               __bt_service_get_parameters(in_param4,
+                               &use_reserved_slot, sizeof(gboolean));
 
-                result = _bt_set_scan_response_data(app, *adv_handle,
-                                &rsp, length, use_reserved_slot);
+               result = _bt_set_scan_response_data(app, *adv_handle,
+                               &rsp, length, use_reserved_slot);
 
                if (result != BLUETOOTH_ERROR_NONE) {
                        BT_ERR("Set Scan Response Data failed!!");
@@ -1633,26 +1662,26 @@ int __bt_bluez_request(int function_name,
                        _bt_save_invocation_context(context, result, app,
                                        function_name, (gpointer)adv_handle);
                }
-                break;
-        }
+               break;
+       }
        case BT_SET_ADVERTISING: {
-                char *app = NULL;
-                int *adv_handle;
-                gboolean enable = FALSE;
-                gboolean use_reserved_slot = FALSE;
+               char *app = NULL;
+               int *adv_handle;
+               gboolean enable = FALSE;
+               gboolean use_reserved_slot = FALSE;
 
                adv_handle = g_malloc0(sizeof(int));
-                __bt_service_get_parameters(in_param1,
-                                adv_handle, sizeof(int));
-                __bt_service_get_parameters(in_param2,
-                                &enable, sizeof(gboolean));
-                __bt_service_get_parameters(in_param3,
-                                &use_reserved_slot, sizeof(gboolean));
+               __bt_service_get_parameters(in_param1,
+                               adv_handle, sizeof(int));
+               __bt_service_get_parameters(in_param2,
+                               &enable, sizeof(gboolean));
+               __bt_service_get_parameters(in_param3,
+                               &use_reserved_slot, sizeof(gboolean));
 
-                app = (char *)g_dbus_method_invocation_get_sender(context);
+               app = (char *)g_dbus_method_invocation_get_sender(context);
 
-                result = _bt_set_advertising(app, *adv_handle,
-                                enable, use_reserved_slot);
+               result = _bt_set_advertising(app, *adv_handle,
+                               enable, use_reserved_slot);
                if (result != BLUETOOTH_ERROR_NONE) {
                        BT_ERR("Start Advertising failed!!");
                        g_free(adv_handle);
@@ -1660,32 +1689,32 @@ int __bt_bluez_request(int function_name,
                        _bt_save_invocation_context(context, result, app,
                                        function_name, (gpointer)adv_handle);
                }
-                break;
-        }
-        case BT_SET_CUSTOM_ADVERTISING: {
-                char *app = NULL;
-                int *adv_handle;
-                gboolean enable = FALSE;
-                bluetooth_advertising_params_t adv_params;
-                gboolean use_reserved_slot = FALSE;
-
-                app = (char *)g_dbus_method_invocation_get_sender(context);
+               break;
+       }
+       case BT_SET_CUSTOM_ADVERTISING: {
+               char *app = NULL;
+               int *adv_handle;
+               gboolean enable = FALSE;
+               bluetooth_advertising_params_t adv_params;
+               gboolean use_reserved_slot = FALSE;
+
+               app = (char *)g_dbus_method_invocation_get_sender(context);
                adv_handle = g_malloc0(sizeof(int));
 
-                __bt_service_get_parameters(in_param1, adv_handle,
-                                sizeof(int));
-                __bt_service_get_parameters(in_param2, &enable,
-                                sizeof(gboolean));
-                __bt_service_get_parameters(in_param3, &adv_params,
-                                sizeof(bluetooth_advertising_params_t));
-                __bt_service_get_parameters(in_param4, &use_reserved_slot,
-                                sizeof(gboolean));
-
-                BT_DBG("bluetooth_advertising_params_t [%f %f %d %d]",
-                                adv_params.interval_min, adv_params.interval_max,
-                                adv_params.filter_policy, adv_params.type);
-                result = _bt_set_custom_advertising(app, *adv_handle,
-                                enable, &adv_params, use_reserved_slot);
+               __bt_service_get_parameters(in_param1, adv_handle,
+                               sizeof(int));
+               __bt_service_get_parameters(in_param2, &enable,
+                               sizeof(gboolean));
+               __bt_service_get_parameters(in_param3, &adv_params,
+                               sizeof(bluetooth_advertising_params_t));
+               __bt_service_get_parameters(in_param4, &use_reserved_slot,
+                               sizeof(gboolean));
+
+               BT_DBG("bluetooth_advertising_params_t [%f %f %d %d]",
+                               adv_params.interval_min, adv_params.interval_max,
+                               adv_params.filter_policy, adv_params.type);
+               result = _bt_set_custom_advertising(app, *adv_handle,
+                               enable, &adv_params, use_reserved_slot);
                if (result != BLUETOOTH_ERROR_NONE) {
                        BT_ERR("Start Custom Advertising failed!!");
                        g_free(adv_handle);
@@ -1693,66 +1722,66 @@ int __bt_bluez_request(int function_name,
                        _bt_save_invocation_context(context, result, app,
                                        function_name, (gpointer)adv_handle);
                }
-                break;
-        }
+               break;
+       }
        case BT_GET_SCAN_RESPONSE_DATA: {
-                bluetooth_scan_resp_data_t rsp = { {0} };
-                char *app = NULL;
-                int length = 0;
+               bluetooth_scan_resp_data_t rsp = { {0} };
+               char *app = NULL;
+               int length = 0;
                int adv_handle;
-                app = (char *)g_dbus_method_invocation_get_sender(context);
+               app = (char *)g_dbus_method_invocation_get_sender(context);
 
-                __bt_service_get_parameters(in_param1, &adv_handle,
-                                sizeof(int));
+               __bt_service_get_parameters(in_param1, &adv_handle,
+                               sizeof(int));
 
-                result = _bt_get_scan_response_data(app, adv_handle, &rsp, &length);
-                if (result == BLUETOOTH_ERROR_NONE)
-                        g_array_append_vals(*out_param1, rsp.data, length);
+               result = _bt_get_scan_response_data(app, adv_handle, &rsp, &length);
+               if (result == BLUETOOTH_ERROR_NONE)
+                       g_array_append_vals(*out_param1, rsp.data, length);
 
-                break;
-        }
+               break;
+       }
        case BT_GET_ADVERTISING_DATA: {
-                bluetooth_advertising_data_t adv = { {0} };
-                char *app = NULL;
-                int length = 0;
+               bluetooth_advertising_data_t adv = { {0} };
+               char *app = NULL;
+               int length = 0;
                int adv_handle;
-                app = (char *)g_dbus_method_invocation_get_sender(context);
+               app = (char *)g_dbus_method_invocation_get_sender(context);
 
-                __bt_service_get_parameters(in_param1, &adv_handle,
-                                sizeof(int));
+               __bt_service_get_parameters(in_param1, &adv_handle,
+                               sizeof(int));
 
-                result = _bt_get_advertising_data(app, adv_handle, &adv, &length);
-                if (result == BLUETOOTH_ERROR_NONE)
-                        g_array_append_vals(*out_param1, adv.data, length);
+               result = _bt_get_advertising_data(app, adv_handle, &adv, &length);
+               if (result == BLUETOOTH_ERROR_NONE)
+                       g_array_append_vals(*out_param1, adv.data, length);
 
-                break;
-        }
+               break;
+       }
        case BT_GATT_REGISTER_APPLICATION: {
                BT_DBG("Register GATT application:Unhandled!!");
                break;
        }
        case BT_GATT_SERVER_REGISTER: {
                BT_DBG("GATT Server instance initialization");
-                char *app;
+               char *app;
 
-                app = (char *)g_dbus_method_invocation_get_sender(context);
-                BT_INFO("GATT Server Unique Name [%s]", app);
+               app = (char *)g_dbus_method_invocation_get_sender(context);
+               BT_INFO("GATT Server Unique Name [%s]", app);
 
                /* No ADV handle: Set 0 */
-                result = _bt_register_server_instance(app, 0);
-                BT_INFO("GATT Server: Register Server result [%d]", result);
+               result = _bt_register_server_instance(app, 0);
+               BT_INFO("GATT Server: Register Server result [%d]", result);
 
                if (result != BLUETOOTH_ERROR_NONE) {
-                        BT_ERR("GATT Server registration failed!!");
-                } else {
-                        _bt_save_invocation_context(context, result, app,
-                                        function_name, NULL);
-                }
-                break;
+                       BT_ERR("GATT Server registration failed!!");
+               } else {
+                       _bt_save_invocation_context(context, result, app,
+                                       function_name, NULL);
+               }
+               break;
        }
        case BT_GATT_SERVER_DEREGISTER: {
-                char *app;
-                app = (char*)g_dbus_method_invocation_get_sender(context);
+               char *app;
+               app = (char*)g_dbus_method_invocation_get_sender(context);
 
                result = _bt_unregister_server_instance(app, 0/* Adv Handle*/);
                break;
@@ -1760,245 +1789,246 @@ int __bt_bluez_request(int function_name,
        case BT_GATT_SERVER_ADD_SERVICE: {
                BT_DBG("GATT Server Add Service");
                int service_type;
-                int num_handles;
-                char *svc_uuid;
-                int instance_id;
-                char *app;
-                int *tmp_inst_id = NULL;
+               int num_handles;
+               char *svc_uuid;
+               int instance_id;
+               char *app;
+               int *tmp_inst_id = NULL;
 
-                app = (char *)g_dbus_method_invocation_get_sender(context);
+               app = (char *)g_dbus_method_invocation_get_sender(context);
 
-                __bt_service_get_parameters(in_param1, &service_type,
-                                sizeof(int));
+               __bt_service_get_parameters(in_param1, &service_type,
+                               sizeof(int));
                __bt_service_get_parameters(in_param2, &num_handles,
-                                sizeof(int));
+                               sizeof(int));
                svc_uuid = (char *)g_variant_get_data(in_param3);
                __bt_service_get_parameters(in_param4, &instance_id,
-                                sizeof(int));
+                               sizeof(int));
 
-                BT_INFO("GATT Server Service UUID [%s]", svc_uuid);
+               BT_INFO("GATT Server Service UUID [%s]", svc_uuid);
                result = _bt_gatt_server_add_service(app, service_type, num_handles, svc_uuid, instance_id);
                if (result != BLUETOOTH_ERROR_NONE) {
-                        BT_ERR("GATT Server Add Service failed!!");
-                } else {
+                       BT_ERR("GATT Server Add Service failed!!");
+               } else {
                        tmp_inst_id = g_malloc0(sizeof(int));
-                        *tmp_inst_id = instance_id;
-                        BT_INFO("GATT Server: Save Instance ID in request Inst id [%d] request_id [%d]",
+                       *tmp_inst_id = instance_id;
+                       BT_INFO("GATT Server: Save Instance ID in request Inst id [%d] request_id [%d]",
                                        *tmp_inst_id, instance_id);
-                        _bt_save_invocation_context(context, result, app,
-                                        function_name, (gpointer)tmp_inst_id);
-                }
-                break;
+                       _bt_save_invocation_context(context, result, app,
+                                       function_name, (gpointer)tmp_inst_id);
+               }
+               break;
        }
        case BT_GATT_SERVER_ADD_CHARACTERISTIC: {
                BT_DBG("GATT Server Add Characteristic");
                char *char_uuid;
-                char *app;
-                int *tmp_inst_id = NULL;
-                bluetooth_gatt_server_attribute_params_t param;
+               char *app;
+               int *tmp_inst_id = NULL;
+               bluetooth_gatt_server_attribute_params_t param;
                memset(&param, 0, sizeof(bluetooth_gatt_server_attribute_params_t));
 
-                app = (char*)g_dbus_method_invocation_get_sender(context);
+               app = (char*)g_dbus_method_invocation_get_sender(context);
 
-                __bt_service_get_parameters(in_param1, &param,
-                                sizeof(bluetooth_gatt_server_attribute_params_t));
+               __bt_service_get_parameters(in_param1, &param,
+                               sizeof(bluetooth_gatt_server_attribute_params_t));
                char_uuid = (char *)g_variant_get_data(in_param2);
 
-                BT_INFO("GATT Server Characteristic UUID [%s]", char_uuid);
+               BT_INFO("GATT Server Characteristic UUID [%s]", char_uuid);
 
-                result = _bt_gatt_server_add_characteristic(app, char_uuid, &param);
+               result = _bt_gatt_server_add_characteristic(app, char_uuid, &param);
                if (result != BLUETOOTH_ERROR_NONE) {
-                        BT_ERR("GATT Server Add Service failed!!");
-                } else {
+                       BT_ERR("GATT Server Add Service failed!!");
+               } else {
                        tmp_inst_id = g_malloc0(sizeof(int));
-                        *tmp_inst_id = param.instance_id;
-                        BT_INFO("GATT Server: Save Instance ID in request Inst id [%d] request_id [%d]",
-                               *tmp_inst_id, param.instance_id);
-                        _bt_save_invocation_context(context, result, app,
-                                        function_name, (gpointer)tmp_inst_id);
-                }
-                break;
+                       *tmp_inst_id = param.instance_id;
+                       BT_INFO("GATT Server: Save Instance ID in request Inst id [%d] request_id [%d]",
+                                       *tmp_inst_id, param.instance_id);
+                       _bt_save_invocation_context(context, result, app,
+                                       function_name, (gpointer)tmp_inst_id);
+               }
+               break;
        }
        case BT_GATT_SERVER_ADD_DESCRIPTOR: {
                BT_DBG("GATT Server Add Descriptor");
-                char *desc_uuid;
-                int instance_id;
-                int service_handle;
-                bt_gatt_permission_t perm;
-                char *app;
-                int *tmp_inst_id = NULL;
+               char *desc_uuid;
+               int instance_id;
+               int service_handle;
+               bt_gatt_permission_t perm;
+               char *app;
+               int *tmp_inst_id = NULL;
                memset(&perm, 0, sizeof(bt_gatt_permission_t));
 
-                app = (char *)g_dbus_method_invocation_get_sender(context);
+               app = (char *)g_dbus_method_invocation_get_sender(context);
 
-                __bt_service_get_parameters(in_param1, &service_handle,
-                                sizeof(int));
-                __bt_service_get_parameters(in_param2, &instance_id,
-                                sizeof(int));
+               __bt_service_get_parameters(in_param1, &service_handle,
+                               sizeof(int));
+               __bt_service_get_parameters(in_param2, &instance_id,
+                               sizeof(int));
                desc_uuid = (char *)g_variant_get_data(in_param4);
-                __bt_service_get_parameters(in_param3, &perm,
-                                sizeof(bt_gatt_permission_t));
+               __bt_service_get_parameters(in_param3, &perm,
+                               sizeof(bt_gatt_permission_t));
 
-                BT_INFO("GATT Server Descriptor UUID [%s]", desc_uuid);
+               BT_INFO("GATT Server Descriptor UUID [%s]", desc_uuid);
 
-                result = _bt_gatt_server_add_descriptor(app, desc_uuid, &perm, service_handle, instance_id);
+               result = _bt_gatt_server_add_descriptor(app, desc_uuid, &perm, service_handle, instance_id);
                if (result != BLUETOOTH_ERROR_NONE) {
-                        BT_ERR("GATT Server Add Service failed!!");
-                } else {
+                       BT_ERR("GATT Server Add Service failed!!");
+               } else {
                        tmp_inst_id = g_malloc0(sizeof(int));
-                        *tmp_inst_id = instance_id;
-                        BT_INFO("GATT Server: Save Instance ID in request Inst id [%d] request_id [%d]",
-                               *tmp_inst_id, instance_id);
-                        _bt_save_invocation_context(context, result, app,
-                                        function_name, (gpointer)tmp_inst_id);
-                }
+                       *tmp_inst_id = instance_id;
+                       BT_INFO("GATT Server: Save Instance ID in request Inst id [%d] request_id [%d]",
+                                       *tmp_inst_id, instance_id);
+                       _bt_save_invocation_context(context, result, app,
+                                       function_name, (gpointer)tmp_inst_id);
+               }
                break;
        }
        case BT_GATT_SERVER_START_SERVICE: {
-                int service_handle;
-                int instance_id;
+               int service_handle;
+               int instance_id;
 
-                char *app;
-                int *tmp_inst_id = NULL;
-                app = (char*)g_dbus_method_invocation_get_sender(context);
+               char *app;
+               int *tmp_inst_id = NULL;
+               app = (char*)g_dbus_method_invocation_get_sender(context);
 
-                __bt_service_get_parameters(in_param1, &service_handle,
-                                sizeof(int));
-                __bt_service_get_parameters(in_param2, &instance_id,
-                                sizeof(int));
+               __bt_service_get_parameters(in_param1, &service_handle,
+                               sizeof(int));
+               __bt_service_get_parameters(in_param2, &instance_id,
+                               sizeof(int));
 
-                result = _bt_gatt_server_start_service(app, service_handle, instance_id);
+               result = _bt_gatt_server_start_service(app, service_handle, instance_id);
 
-                if (BLUETOOTH_ERROR_NONE == result) {
+               if (BLUETOOTH_ERROR_NONE == result) {
                        tmp_inst_id = g_malloc0(sizeof(int));
-                        *tmp_inst_id = instance_id;
-                        BT_INFO("GATT Server: Save Instance ID in request Inst id [%d] request_id [%d]",
-                               *tmp_inst_id, instance_id);
-                        _bt_save_invocation_context(context, result, app,
-                                        function_name, (gpointer)tmp_inst_id);
-                }
-                break;
-        }
+                       *tmp_inst_id = instance_id;
+                       BT_INFO("GATT Server: Save Instance ID in request Inst id [%d] request_id [%d]",
+                                       *tmp_inst_id, instance_id);
+                       _bt_save_invocation_context(context, result, app,
+                                       function_name, (gpointer)tmp_inst_id);
+               }
+               break;
+       }
        case BT_GATT_SERVER_STOP_SERVICE: {
-                int service_handle;
-                int instance_id;
-                char *app;
-                int *tmp_inst_id = NULL;
-                app = (char*)g_dbus_method_invocation_get_sender(context);
+               int service_handle;
+               int instance_id;
+               char *app;
+               int *tmp_inst_id = NULL;
+               app = (char*)g_dbus_method_invocation_get_sender(context);
 
-                __bt_service_get_parameters(in_param1, &service_handle,
-                                sizeof(int));
-                __bt_service_get_parameters(in_param2, &instance_id,
-                                sizeof(int));
+               __bt_service_get_parameters(in_param1, &service_handle,
+                               sizeof(int));
+               __bt_service_get_parameters(in_param2, &instance_id,
+                               sizeof(int));
 
-                result = _bt_gatt_server_stop_service(app, service_handle, instance_id);
+               result = _bt_gatt_server_stop_service(app, service_handle, instance_id);
 
-                if (BLUETOOTH_ERROR_NONE == result) {
+               if (BLUETOOTH_ERROR_NONE == result) {
                        tmp_inst_id = g_malloc0(sizeof(int));
-                        *tmp_inst_id = instance_id;
-                        BT_INFO("GATT Server: Save Instance ID in request Inst id [%d] request_id [%d]",
-                               *tmp_inst_id, instance_id);
-                        _bt_save_invocation_context(context, result, app,
-                                        function_name, (gpointer)tmp_inst_id);
-                }
-                break;
-        }
+                       *tmp_inst_id = instance_id;
+                       BT_INFO("GATT Server: Save Instance ID in request Inst id [%d] request_id [%d]",
+                                       *tmp_inst_id, instance_id);
+                       _bt_save_invocation_context(context, result, app,
+                                       function_name, (gpointer)tmp_inst_id);
+               }
+               break;
+       }
        case BT_GATT_SERVER_DELETE_SERVICE: {
-                int service_handle;
-                int instance_id;
-                int *tmp_inst_id = NULL;
-                char *app;
-                app = (char*)g_dbus_method_invocation_get_sender(context);
+               int service_handle;
+               int instance_id;
+               int *tmp_inst_id = NULL;
+               char *app;
+               app = (char*)g_dbus_method_invocation_get_sender(context);
 
-                __bt_service_get_parameters(in_param1, &service_handle,
-                                sizeof(int));
-                __bt_service_get_parameters(in_param2, &instance_id,
-                                sizeof(int));
+               __bt_service_get_parameters(in_param1, &service_handle,
+                               sizeof(int));
+               __bt_service_get_parameters(in_param2, &instance_id,
+                               sizeof(int));
 
-                result = _bt_gatt_server_delete_service(app, service_handle, instance_id);
+               result = _bt_gatt_server_delete_service(app, service_handle, instance_id);
 
-                if (BLUETOOTH_ERROR_NONE == result) {
+               if (BLUETOOTH_ERROR_NONE == result) {
                        tmp_inst_id = g_malloc0(sizeof(int));
-                        *tmp_inst_id = instance_id;
-                        BT_INFO("GATT Server: Save Instance ID in request Inst id [%d] request_id [%d]",
-                               *tmp_inst_id, instance_id);
-                        _bt_save_invocation_context(context, result, app,
-                                        function_name, (gpointer)tmp_inst_id);
-                }
-                break;
-        }
+                       *tmp_inst_id = instance_id;
+                       BT_INFO("GATT Server: Save Instance ID in request Inst id [%d] request_id [%d]",
+                                       *tmp_inst_id, instance_id);
+                       _bt_save_invocation_context(context, result, app,
+                                       function_name, (gpointer)tmp_inst_id);
+               }
+               break;
+       }
        case BT_GATT_SERVER_SEND_RESPONSE: {
-                bluetooth_gatt_server_response_params_t param;
-                bluetooth_gatt_att_data_t data;
-                char *app;
+               bluetooth_gatt_server_response_params_t param;
+               bluetooth_gatt_att_data_t data;
+               char *app;
 
                memset(&param, 0x00, sizeof(bluetooth_gatt_server_response_params_t));
                memset(&data, 0x00, sizeof(bluetooth_gatt_att_data_t));
 
-                app = (char*)g_dbus_method_invocation_get_sender(context);
+               app = (char*)g_dbus_method_invocation_get_sender(context);
 
                __bt_service_get_parameters(in_param1, &data,
-                                sizeof(bluetooth_gatt_att_data_t));
+                               sizeof(bluetooth_gatt_att_data_t));
                __bt_service_get_parameters(in_param2, &param,
-                                sizeof(bluetooth_gatt_server_response_params_t));
+                               sizeof(bluetooth_gatt_server_response_params_t));
 
-                result = _bt_gatt_server_send_response(app, &data, &param);
+               result = _bt_gatt_server_send_response(app, &data, &param);
 
-                break;
-        }
+               break;
+       }
        case BT_GATT_SERVER_SEND_INDICATION: {
-                bluetooth_gatt_server_indication_params_t param;
-                bluetooth_gatt_att_data_t data;
-                bluetooth_device_address_t address;
+               bluetooth_gatt_server_indication_params_t param;
+               bluetooth_gatt_att_data_t data;
+               bluetooth_device_address_t address;
 
-                char *app;
-                app = (char*)g_dbus_method_invocation_get_sender(context);
+               char *app;
+               app = (char*)g_dbus_method_invocation_get_sender(context);
 
                memset(&param, 0x00, sizeof(bluetooth_gatt_server_indication_params_t));
                memset(&data, 0x00, sizeof(bluetooth_gatt_att_data_t));
                memset(&address, 0x00, sizeof(bluetooth_device_address_t));
 
                __bt_service_get_parameters(in_param1, &data,
-                                sizeof(bluetooth_gatt_att_data_t));
+                               sizeof(bluetooth_gatt_att_data_t));
                __bt_service_get_parameters(in_param2, &param,
-                                sizeof(bluetooth_gatt_server_indication_params_t));
-               __bt_service_get_parameters(in_param3, &param,
-                                sizeof(bluetooth_device_address_t));
+                               sizeof(bluetooth_gatt_server_indication_params_t));
+               __bt_service_get_parameters(in_param3, &address,
+                               sizeof(bluetooth_device_address_t));
 
-                result = _bt_gatt_server_send_indication(app, &address, &data, &param);
+               result = _bt_gatt_server_send_indication(app, &address, &data, &param);
 
-                break;
-        }
+               break;
+       }
        case BT_GATT_SERVER_UPDATE_VALUE: {
-                bluetooth_gatt_server_update_value_t param;
+               bluetooth_gatt_server_update_value_t param;
                int instance_id;
-                char *app;
+               char *app;
 
                memset(&param, 0x00, sizeof(bluetooth_gatt_server_response_params_t));
 
-                app = (char*)g_dbus_method_invocation_get_sender(context);
+               app = (char*)g_dbus_method_invocation_get_sender(context);
 
                __bt_service_get_parameters(in_param1, &instance_id,
-                                sizeof(int));
+                               sizeof(int));
                __bt_service_get_parameters(in_param2, &param,
-                                sizeof(bluetooth_gatt_server_update_value_t));
+                               sizeof(bluetooth_gatt_server_update_value_t));
 
-                result = _bt_gatt_server_update_attribute_value(app, instance_id, &param);
+               result = _bt_gatt_server_update_attribute_value(app, instance_id, &param);
+               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));
+               __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));
+               if (result == BLUETOOTH_ERROR_NONE) {
+                       g_array_append_vals(*out_param1, &mtu,
+                                       sizeof(unsigned int));
                }
-                break;
+               break;
        }
        case BT_START_LE_DISCOVERY: {
                sender = (char *)g_dbus_method_invocation_get_sender(context);
@@ -2186,7 +2216,7 @@ gboolean __bt_service_check_privilege(int function_name,
        case BT_CANCEL_BONDING:
        case BT_UNBOND_DEVICE:
        case BT_PASSKEY_CONFIRMATION_REPLY:
-        case BT_PASSKEY_REPLY:
+       case BT_PASSKEY_REPLY:
        case BT_SET_ALIAS:
        case BT_SET_AUTHORIZATION:
        case BT_UNSET_AUTHORIZATION:

diff --git a/bt-service-adaptation/services/device/bt-service-core-device.c b/bt-service-adaptation/services/device/bt-service-core-device.c
index 1af341b..8fdd919 100644 (file)
--- a/bt-service-adaptation/services/device/bt-service-core-device.c
+++ b/bt-service-adaptation/services/device/bt-service-core-device.c
@@ -156,9 +156,29 @@ void __bt_device_handle_pending_requests(int result, int service_function,
                        continue;
 
                switch (service_function) {
-               case BT_BOND_DEVICE:
-               case BT_SEARCH_SERVICE:
-               case BT_UNBOND_DEVICE: {
+               case BT_SEARCH_SERVICE: {
+                       char *address = (char *)user_data;
+                       if (strncmp((char*)req_info->user_data, address, BT_ADDRESS_STRING_SIZE)) {
+                               BT_ERR("Unexpected: Info request pending for a different address!!");
+                               return;
+                       } else {
+                               BT_INFO("Found info request addr [%s]", (char*)req_info->user_data);
+                               bt_sdp_info_t sdp_info;
+
+                               memset(&sdp_info, 0x00, sizeof(bt_sdp_info_t));
+                               _bt_convert_addr_string_to_type(sdp_info.device_addr.addr, address);
+
+                               out_param = g_array_new(FALSE, FALSE, sizeof(gchar));
+                               g_array_append_vals(out_param, &sdp_info, sizeof(bt_sdp_info_t));
+                               _bt_service_method_return(req_info->context, out_param, result);
+
+                               g_free(req_info->user_data);
+                               _bt_free_info_from_invocation_list(req_info);
+                               g_array_free(out_param, TRUE);
+                       }
+                       break;
+               }
+               case BT_BOND_DEVICE: {
                        char *address = (char *)user_data;
                        if (strncmp((char*)req_info->user_data, address, BT_ADDRESS_STRING_SIZE)) {
                                BT_ERR("Unexpected: Info request pending for a different address!!");
@@ -169,10 +189,32 @@ void __bt_device_handle_pending_requests(int result, int service_function,
                                memset(&dev_info, 0x00, sizeof(bluetooth_device_info_t));
                                _bt_convert_addr_string_to_type(dev_info.device_address.addr,
                                                address);
-                                       out_param = g_array_new(FALSE, FALSE, sizeof(gchar));
+                               out_param = g_array_new(FALSE, FALSE, sizeof(gchar));
                                g_array_append_vals(out_param, &dev_info,
                                                sizeof(bluetooth_device_info_t));
-                                       _bt_service_method_return(req_info->context, out_param, result);
+                               _bt_service_method_return(req_info->context, out_param, result);
+
+                               g_free(req_info->user_data);
+                               _bt_free_info_from_invocation_list(req_info);
+                               g_array_free(out_param, TRUE);
+                       }
+                       break;
+               }
+               case BT_UNBOND_DEVICE: {
+                       char *address = (char *)user_data;
+                       if (strncmp((char*)req_info->user_data, address, BT_ADDRESS_STRING_SIZE)) {
+                               BT_ERR("Unexpected: Info request pending for a different address!!");
+                               return;
+                       } else {
+                               BT_INFO("Found info request addr [%s]", (char*)req_info->user_data);
+                               bluetooth_device_address_t dev_addr;
+                               _bt_convert_addr_string_to_type(dev_addr.addr, address);
+                               out_param = g_array_new(FALSE, FALSE, sizeof(gchar));
+                               g_array_append_vals(out_param, &dev_addr,
+                                               sizeof(bluetooth_device_address_t));
+                               _bt_service_method_return(req_info->context, out_param, result);
+
+                               g_free(req_info->user_data);
                                _bt_free_info_from_invocation_list(req_info);
                                g_array_free(out_param, TRUE);
                        }

diff --git a/bt-service-adaptation/services/health/bt-service-hdp.c b/bt-service-adaptation/services/health/bt-service-hdp.c
index 625c9a2..6ed2671 100644 (file)
--- a/bt-service-adaptation/services/health/bt-service-hdp.c
+++ b/bt-service-adaptation/services/health/bt-service-hdp.c
@@ -103,11 +103,12 @@ static void __bt_hdp_handle_pending_request_info(int result,
                case BT_HDP_CONNECT: {
                        bt_hdp_conn_info_t *info = data;
                        bt_hdp_connected_t *conn_data = info->data;
+                       bt_hdp_connected_t *req_conn_data = req_info->user_data;
 
                        if (!conn_data)
                                break;
 
-                       if (*((int *)req_info->user_data) != (int)conn_data->channel_id)
+                       if (req_conn_data->channel_id != conn_data->channel_id)
                                break;
 
                        out_param = g_array_new(FALSE, FALSE, sizeof(gchar));
@@ -121,8 +122,9 @@ static void __bt_hdp_handle_pending_request_info(int result,
                }
                case BT_HDP_DISCONNECT: {
                        bt_hdp_disconnected_t *disconn_data = data;
+                       bt_hdp_disconnected_t *req_disconn_data = req_info->user_data;
 
-                       if (*((int *)req_info->user_data) != (int)disconn_data->channel_id)
+                       if (req_disconn_data->channel_id != disconn_data->channel_id)
                                break;
 
                        out_param = g_array_new(FALSE, FALSE, sizeof(gchar));
@@ -538,8 +540,6 @@ void _bt_check_hdp_app_termination(const char *name)
        GSList *l;
        bt_hdp_app_info_t *app = NULL;
 
-       BT_DBG("+");
-
        ret_if(NULL == name);
 
        for (l = app_list; NULL != l; l = g_slist_next(l)) {
@@ -553,6 +553,4 @@ void _bt_check_hdp_app_termination(const char *name)
                        _bt_hdp_app_unregister(app->app_id);
                }
        }
-
-       BT_DBG("-");
 }

diff --git a/bt-service-adaptation/services/rfcomm/bt-service-rfcomm.c b/bt-service-adaptation/services/rfcomm/bt-service-rfcomm.c
index 0b4b199..75ab325 100644 (file)
--- a/bt-service-adaptation/services/rfcomm/bt-service-rfcomm.c
+++ b/bt-service-adaptation/services/rfcomm/bt-service-rfcomm.c
@@ -55,12 +55,21 @@ static void __bt_rfcomm_reply_pending_request(int result,
                case BT_RFCOMM_CLIENT_CONNECT: {
                        GUnixFDList *fd_list = NULL;
                        GError *error = NULL;
+                       char address[BT_ADDRESS_STRING_SIZE];
+                       bluetooth_rfcomm_connection_t *ptr = user_data;
+
+                       /* Check if connect address matched with requested address */
+                       _bt_convert_addr_type_to_string(address, ptr->device_addr.addr);
+                       if (strncasecmp(address, (char *)req_info->user_data,
+                                               BT_ADDRESS_STRING_SIZE)) {
+                               BT_INFO("RFCOMM connected addr: [%s], requested addr: [%s]",
+                                               address, (char *)req_info->user_data);
+                               break;
+                       }
 
                        g_array_append_vals(out_param, user_data, size);
 
                        if (BLUETOOTH_ERROR_NONE == result) {
-                               bluetooth_rfcomm_connection_t *ptr = user_data;
-
                                fd_list = g_unix_fd_list_new();
                                g_unix_fd_list_append(fd_list, ptr->socket_fd, &error);
                                g_assert_no_error(error);
@@ -69,7 +78,12 @@ static void __bt_rfcomm_reply_pending_request(int result,
 
                        _bt_service_method_return_with_unix_fd_list(
                                        req_info->context, out_param, result, fd_list);
-                       g_object_unref(fd_list);
+                       if (fd_list)
+                               g_object_unref(fd_list);
+
+                       g_free(req_info->user_data);
+                       _bt_free_info_from_invocation_list(req_info);
+                       g_array_free(out_param, TRUE);
                        break;
                }
                case BT_RFCOMM_LISTEN: {
@@ -91,14 +105,14 @@ static void __bt_rfcomm_reply_pending_request(int result,
 
                        close(*socket_fd);
                        g_object_unref(fd_list);
+
+                       _bt_free_info_from_invocation_list(req_info);
+                       g_array_free(out_param, TRUE);
                        break;
                }
                default:
                        BT_ERR("Unknown Service function");
                }
-
-               g_array_free(out_param, TRUE);
-               _bt_free_info_from_invocation_list(req_info);
        }
 
        return;