Handle the obex agent using tizen OPP feature

[platform/core/connectivity/bluetooth-frwk.git] / bt-api / bt-hid-device.c

diff --git a/bt-api/bt-hid-device.c b/bt-api/bt-hid-device.c
index b287ca7..c9b851a 100644 (file)
--- a/bt-api/bt-hid-device.c
+++ b/bt-api/bt-hid-device.c
@@ -97,10 +97,10 @@ static GVariant* __bt_hid_agent_dbus_send(const char *path,
        GDBusProxy *proxy = NULL;
        GDBusConnection *conn = NULL;
 
-       conn = _bt_gdbus_get_system_gconn();
+       conn = _bt_get_system_private_conn();
        retv_if(conn == NULL, NULL);
 
-       proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
+       proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES,
                NULL, BT_HID_SERVICE_NAME, path, interface, NULL, err);
        if (proxy == NULL) {
                BT_ERR("Unable to allocate new proxy");
@@ -120,7 +120,7 @@ static hid_connected_device_info_t *__find_hid_info_with_address(const char *rem
 
        for (l = device_list; l != NULL; l = l->next) {
                hid_connected_device_info_t *info = l->data;
-               if (g_strcmp0((const char *)info->address, (const char *)remote_addr) == 0)
+               if (strcasecmp((const char *)info->address, (const char *)remote_addr) == 0)
                        return info;
        }
        return NULL;
@@ -286,7 +286,7 @@ static gboolean __received_cb(GIOChannel *chan, GIOCondition cond,
                        &len, &err);
        if (status == G_IO_STATUS_NORMAL) {
                BT_INFO("Parsing Data");
-               bluetooth_hid_received_data_t data = {0};
+               bluetooth_hid_received_data_t recv_data = {0};
                header = buffer[0];
                type = header & BT_HID_HEADER_TRANS_MASK;
                param = header & BT_HID_HEADER_PARAM_MASK;
@@ -297,121 +297,111 @@ static gboolean __received_cb(GIOChannel *chan, GIOCondition cond,
                if (event_info == NULL)
                        return FALSE;
 
-               data.address = g_strdup(info->address);
+               recv_data.address = g_strdup(info->address);
                switch (type) {
                case BT_HID_TRANS_HANDSHAKE:
                        BT_INFO("TRANS HANDSHAKE");
-                       data.type = HTYPE_TRANS_HANDSHAKE;
-                       data.buffer_size = len;
-                       data.buffer = (char *) malloc(sizeof(char) * len);
-                       if (data.buffer)
-                               memcpy(data.buffer, buffer, len);
+                       recv_data.type = HTYPE_TRANS_HANDSHAKE;
+                       recv_data.buffer_size = len;
+                       recv_data.buffer = (char *)g_malloc0(sizeof(char) * len);
+                       memcpy(recv_data.buffer, buffer, len);
                break;
 
                case BT_HID_TRANS_HID_CONTROL:
                        BT_INFO("HID CONTROL");
-                       data.type = HTYPE_TRANS_HID_CONTROL;
-                       data.buffer_size = len;
-                       data.buffer = (char *) malloc(sizeof(char) * len);
-                       if (data.buffer)
-                               memcpy(data.buffer, buffer, len);
+                       recv_data.type = HTYPE_TRANS_HID_CONTROL;
+                       recv_data.buffer_size = len;
+                       recv_data.buffer = (char *)g_malloc0(sizeof(char) * len);
+                       memcpy(recv_data.buffer, buffer, len);
                break;
 
                case BT_HID_TRANS_DATA:
                        BT_INFO("TRANS DATA");
-                       data.type = HTYPE_TRANS_DATA;
+                       recv_data.type = HTYPE_TRANS_DATA;
                        if (param & BT_HID_DATA_RTYPE_INPUT) {
                                BT_INFO("Input Report");
-                               data.param = PTYPE_DATA_RTYPE_INPUT;
-                               data.buffer_size = len;
-                               data.buffer = (char *) malloc(sizeof(char) * len);
-                               if (data.buffer)
-                                       memcpy(data.buffer, buffer, len);
+                               recv_data.param = PTYPE_DATA_RTYPE_INPUT;
+                               recv_data.buffer_size = len;
+                               recv_data.buffer = (char *)g_malloc0(sizeof(char) * len);
+                               memcpy(recv_data.buffer, buffer, len);
                        } else {
                                BT_INFO("Out Report");
-                               data.param = PTYPE_DATA_RTYPE_OUTPUT;
-                               data.buffer_size = len;
-                               data.buffer = (char *) malloc(sizeof(char) * len);
-                               if (data.buffer)
-                                       memcpy(data.buffer, buffer, len);
+                               recv_data.param = PTYPE_DATA_RTYPE_OUTPUT;
+                               recv_data.buffer_size = len;
+                               recv_data.buffer = (char *)g_malloc0(sizeof(char) * len);
+                               memcpy(recv_data.buffer, buffer, len);
                        }
                break;
 
                case BT_HID_TRANS_GET_REPORT: {
                        BT_INFO("Get Report");
-                       data.type = HTYPE_TRANS_GET_REPORT;
+                       recv_data.type = HTYPE_TRANS_GET_REPORT;
                        if (param & BT_HID_DATA_RTYPE_INPUT) {
                                BT_INFO("Input Report");
-                               data.param = PTYPE_DATA_RTYPE_INPUT;
+                               recv_data.param = PTYPE_DATA_RTYPE_INPUT;
                        } else {
                                BT_INFO("Output Report");
-                               data.param = PTYPE_DATA_RTYPE_OUTPUT;
+                               recv_data.param = PTYPE_DATA_RTYPE_OUTPUT;
                        }
-                       data.buffer_size = len;
-                       data.buffer = (char *) malloc(sizeof(char) * len);
-                       if (data.buffer)
-                               memcpy(data.buffer, buffer, len);
+                       recv_data.buffer_size = len;
+                       recv_data.buffer = (char *)g_malloc0(sizeof(char) * len);
+                       memcpy(recv_data.buffer, buffer, len);
                        break;
                }
 
                case BT_HID_TRANS_SET_REPORT: {
                        BT_INFO("Set Report");
-                       data.type = HTYPE_TRANS_SET_REPORT;
+                       recv_data.type = HTYPE_TRANS_SET_REPORT;
                        if (param & BT_HID_DATA_RTYPE_INPUT) {
                                BT_INFO("Input Report");
-                               data.param = PTYPE_DATA_RTYPE_INPUT;
+                               recv_data.param = PTYPE_DATA_RTYPE_INPUT;
                        } else {
                                BT_INFO("Output Report");
-                               data.param = PTYPE_DATA_RTYPE_OUTPUT;
+                               recv_data.param = PTYPE_DATA_RTYPE_OUTPUT;
                        }
-                       data.buffer_size = len;
-                       data.buffer = (char *) malloc(sizeof(char) * len);
-                       if (data.buffer)
-                               memcpy(data.buffer, buffer, len);
+                       recv_data.buffer_size = len;
+                       recv_data.buffer = (char *)g_malloc0(sizeof(char) * len);
+                       memcpy(recv_data.buffer, buffer, len);
                        break;
                }
 
                case BT_HID_TRANS_GET_PROTOCOL:{
                        BT_INFO("Get_PROTOCOL");
-                       data.type = HTYPE_TRANS_GET_PROTOCOL;
-                       data.param = PTYPE_DATA_RTYPE_INPUT;
-                       data.buffer_size = len;
-                       data.buffer = (char *) malloc(sizeof(char) * len);
-                       if (data.buffer)
-                               memcpy(data.buffer, buffer, len);
+                       recv_data.type = HTYPE_TRANS_GET_PROTOCOL;
+                       recv_data.param = PTYPE_DATA_RTYPE_INPUT;
+                       recv_data.buffer_size = len;
+                       recv_data.buffer = (char *)g_malloc0(sizeof(char) * len);
+                       memcpy(recv_data.buffer, buffer, len);
                        break;
                }
 
                case BT_HID_TRANS_SET_PROTOCOL:{
                        BT_INFO("Set_PROTOCOL");
-                       data.type = HTYPE_TRANS_SET_PROTOCOL;
-                       data.param = PTYPE_DATA_RTYPE_INPUT;
-                       data.buffer_size = len;
-                       data.buffer = (char *) malloc(sizeof(char) * len);
-                       if (data.buffer)
-                               memcpy(data.buffer, buffer, len);
+                       recv_data.type = HTYPE_TRANS_SET_PROTOCOL;
+                       recv_data.param = PTYPE_DATA_RTYPE_INPUT;
+                       recv_data.buffer_size = len;
+                       recv_data.buffer = (char *)g_malloc0(sizeof(char) * len);
+                       memcpy(recv_data.buffer, buffer, len);
                        break;
                }
 
                case BT_HID_TRANS_GET_IDLE:{
                        BT_INFO("Get_IDLE");
-                       data.type = HTYPE_TRANS_GET_IDLE;
-                       data.param = PTYPE_DATA_RTYPE_INPUT;
-                       data.buffer_size = len;
-                       data.buffer = (char *) malloc(sizeof(char) * len);
-                       if (data.buffer)
-                               memcpy(data.buffer, buffer, len);
+                       recv_data.type = HTYPE_TRANS_GET_IDLE;
+                       recv_data.param = PTYPE_DATA_RTYPE_INPUT;
+                       recv_data.buffer_size = len;
+                       recv_data.buffer = (char *)g_malloc0(sizeof(char) * len);
+                       memcpy(recv_data.buffer, buffer, len);
                        break;
                }
 
                case BT_HID_TRANS_SET_IDLE:{
                        BT_INFO("Set_IDLE");
-                       data.type = HTYPE_TRANS_SET_IDLE;
-                       data.param = PTYPE_DATA_RTYPE_INPUT;
-                       data.buffer_size = len;
-                       data.buffer = (char *) malloc(sizeof(char) * len);
-                       if (data.buffer)
-                               memcpy(data.buffer, buffer, len);
+                       recv_data.type = HTYPE_TRANS_SET_IDLE;
+                       recv_data.param = PTYPE_DATA_RTYPE_INPUT;
+                       recv_data.buffer_size = len;
+                       recv_data.buffer = (char *)g_malloc0(sizeof(char) * len);
+                       memcpy(recv_data.buffer, buffer, len);
                        break;
                }
 
@@ -420,7 +410,7 @@ static gboolean __received_cb(GIOChannel *chan, GIOCondition cond,
                        BT_ERR("Send Handshake Message");
                        guint8 type = BT_HID_TRANS_HANDSHAKE |
                                BT_HID_HSHK_ERR_UNSUPPORTED_REQUEST;
-                       data.type = HTYPE_TRANS_UNKNOWN;
+                       recv_data.type = HTYPE_TRANS_UNKNOWN;
                        int fd = g_io_channel_unix_get_fd(chan);
                        int bytes = write(fd,  &type, sizeof(type));
                        BT_INFO("Bytes Written %d", bytes);
@@ -429,13 +419,13 @@ static gboolean __received_cb(GIOChannel *chan, GIOCondition cond,
        }
 
        _bt_common_event_cb(BLUETOOTH_HID_DEVICE_DATA_RECEIVED,
-                               BLUETOOTH_ERROR_NONE, &data,
+                               BLUETOOTH_ERROR_NONE, &recv_data,
                                event_info->cb, event_info->user_data);
-       if (data.buffer)
-               g_free(data.buffer);
+       if (recv_data.buffer)
+               g_free(recv_data.buffer);
 
-       if (data.address)
-               g_free((char *)data.address);
+       if (recv_data.address)
+               g_free((char *)recv_data.address);
        } else {
                BT_ERR("Error while reading data %d [%s]", status, info->address);
                if (err) {
@@ -482,13 +472,13 @@ int _bt_hid_device_get_fd(const char *address, int *ctrl, int *intr)
        int index1 = 0;
        int index2 = 0;
        GUnixFDList *out_fd_list = NULL;
-       conn = _bt_gdbus_get_system_gconn();
+       conn = _bt_get_system_private_conn();
        retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
 
        adapter_path = _bt_get_device_object_path((char *)address);
        retv_if(adapter_path == NULL, BLUETOOTH_ERROR_INTERNAL);
        BT_INFO_C("Device : %s", adapter_path);
-       server_proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
+       server_proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES,
                        NULL, BT_BLUEZ_NAME,
                        adapter_path, "org.bluez.Input1",  NULL, NULL);
        g_free(adapter_path);
@@ -911,6 +901,10 @@ BT_EXPORT_API int bluetooth_hid_device_reply_to_report(const char *remote_addr,
        hid_connected_device_info_t *info = NULL;
 
        BT_CHECK_PARAMETER(remote_addr, return);
+       if (data_len > 20) {
+               BT_ERR("data(len:%d) overflow", data_len);
+               return BLUETOOTH_ERROR_INVALID_PARAM;
+       }
 
        info = __find_hid_info_with_address(remote_addr);
        if (info == NULL) {
@@ -990,6 +984,14 @@ BT_EXPORT_API int bluetooth_hid_device_reply_to_report(const char *remote_addr,
                break;
        }
 
+       case HTYPE_TRANS_DATA: {
+               output_report.type = BT_HID_TRANS_DATA;
+               memcpy(output_report.rep_data, data, data_len);
+               bytes = write(info->ctrl_fd,  &output_report.type,
+                               data_len + 1);
+               break;
+       }
+
        case HTYPE_TRANS_GET_IDLE: {
                output_report.type = BT_HID_TRANS_DATA | BT_HID_DATA_RTYPE_OUTPUT;
                output_report.rep_data[0] = data[0];