+
+int _bt_set_pin_code(bluetooth_device_address_t *device_address,
+ bluetooth_device_pin_code_t *pin_code)
+{
+ char address[BT_ADDRESS_STRING_SIZE] = { 0 };
+ GSList *l = NULL;
+ bt_pin_code_info_t *pin_info = NULL;
+
+ BT_CHECK_PARAMETER(device_address, return);
+ BT_CHECK_PARAMETER(pin_code, return);
+ retv_if(g_slist_length(pin_info_list) >= BT_DEVICE_PIN_CODE_SLOT_MAX,
+ BLUETOOTH_ERROR_NO_RESOURCES);
+
+ _bt_convert_addr_type_to_string(address, device_address->addr);
+
+ for (l = pin_info_list; l != NULL; l = l->next) {
+ pin_info = l->data;
+
+ if (g_strcmp0(pin_info->address, address) == 0) {
+ g_free(pin_info->pin_code);
+ pin_info->pin_code = g_strdup(pin_code->pin_code);
+ return BLUETOOTH_ERROR_NONE;
+ }
+ }
+
+ pin_info = g_malloc0(sizeof(bt_pin_code_info_t));
+ pin_info->address = g_strdup(address);
+ pin_info->pin_code = g_strdup(pin_code->pin_code);
+ pin_info_list = g_slist_append(pin_info_list, pin_info);
+
+ return BLUETOOTH_ERROR_NONE;
+}
+
+gint __bt_compare_address(gpointer *a, gpointer *b)
+{
+ bt_pin_code_info_t *pin_info = (bt_pin_code_info_t *)a;
+ char *address = (char *)b;
+ return g_strcmp0(pin_info->address, address);
+}
+
+int _bt_unset_pin_code(bluetooth_device_address_t *device_address)
+{
+ char address[BT_ADDRESS_STRING_SIZE] = { 0 };
+ GSList *l = NULL;
+ bt_pin_code_info_t *pin_info = NULL;
+
+ BT_CHECK_PARAMETER(device_address, return);
+
+ _bt_convert_addr_type_to_string(address, device_address->addr);
+
+ l = g_slist_find_custom(pin_info_list, address,
+ (GCompareFunc)__bt_compare_address);
+ if (l)
+ pin_info = l->data;
+ if (pin_info) {
+ pin_info_list = g_slist_remove(pin_info_list, pin_info);
+ g_free(pin_info->address);
+ g_free(pin_info->pin_code);
+ g_free(pin_info);
+ }
+
+ return BLUETOOTH_ERROR_NONE;
+}
+
+int _bt_get_device_pin_code(const char *address, char *pin_code)
+{
+ GSList *l = NULL;
+
+ BT_CHECK_PARAMETER(address, return);
+ BT_CHECK_PARAMETER(pin_code, return);
+
+ for (l = pin_info_list; l != NULL; l = l->next) {
+ bt_pin_code_info_t *pin_info = l->data;
+
+ if (g_strcmp0(pin_info->address, address) == 0) {
+ g_strlcpy(pin_code, pin_info->pin_code,
+ BLUETOOTH_PIN_CODE_MAX_LENGTH + 1);
+
+ return BLUETOOTH_ERROR_NONE;
+ }
+ }
+
+ return BLUETOOTH_ERROR_NOT_FOUND;
+}
+
+int _bt_get_le_connection_parameter(bluetooth_le_connection_mode_t mode,
+ bluetooth_le_connection_param_t *param)
+{
+ if (param == NULL)
+ return BLUETOOTH_ERROR_INVALID_PARAM;
+
+ if (mode < BLUETOOTH_LE_CONNECTION_MODE_BALANCED ||
+ mode > BLUETOOTH_LE_CONNECTION_MODE_LOW_POWER)
+ return BLUETOOTH_ERROR_INVALID_PARAM;
+
+ memset(param, 0x00, sizeof(bluetooth_le_connection_param_t));
+
+ switch (mode) {
+ case BLUETOOTH_LE_CONNECTION_MODE_BALANCED:
+ param->interval_min = BT_LE_CONN_PARAM_BALANCED_MIN_INTERVAL;
+ param->interval_max = BT_LE_CONN_PARAM_BALANCED_MAX_INTERVAL;
+ param->latency = BT_LE_CONN_PARAM_BALANCED_SLAVE_LATENCY;
+ param->timeout = BT_LE_CONN_PARAM_DEFAULT_SUPERVISION_TIMEOUT;
+ break;
+
+ case BLUETOOTH_LE_CONNECTION_MODE_LOW_LATENCY:
+ param->interval_min = BT_LE_CONN_PARAM_LOW_LATENCY_MIN_INTERVAL;
+ param->interval_max = BT_LE_CONN_PARAM_LOW_LATENCY_MAX_INTERVAL;
+ param->latency = BT_LE_CONN_PARAM_LOW_LATENCY_SLAVE_LATENCY;
+ param->timeout = BT_LE_CONN_PARAM_DEFAULT_SUPERVISION_TIMEOUT;
+ break;
+
+ case BLUETOOTH_LE_CONNECTION_MODE_LOW_POWER:
+ param->interval_min = BT_LE_CONN_PARAM_LOW_POWER_MIN_INTERVAL;
+ param->interval_max = BT_LE_CONN_PARAM_LOW_POWER_MAX_INTERVAL;
+ param->latency = BT_LE_CONN_PARAM_LOW_POWER_SLAVE_LATENCY;
+ param->timeout = BT_LE_CONN_PARAM_DEFAULT_SUPERVISION_TIMEOUT;
+ break;
+
+ default:
+ BT_ERR("Unhandled mode : %d", mode);
+ break;
+ }
+
+ return BLUETOOTH_ERROR_NONE;
+}
+
+int _bt_get_trusted_profile_from_flag(bluetooth_trusted_profile_t profile,
+ guint trusted_profile_flag, guint *trusted)
+{
+ int trust_profile;
+ *trusted = FALSE;
+
+ switch (profile) {
+ case TRUSTED_PROFILE_PBAP:
+ if (trusted_profile_flag & (PROFILE_SUPPORTED << 0))
+ trust_profile = trusted_profile_flag & (1 << 1);
+ else
+ return BLUETOOTH_ERROR_NOT_SUPPORT;
+ break;
+ case TRUSTED_PROFILE_MAP:
+ if (trusted_profile_flag & (PROFILE_SUPPORTED << 2))
+ trust_profile = trusted_profile_flag & (1 << 3);
+ else
+ return BLUETOOTH_ERROR_NOT_SUPPORT;
+ break;
+ case TRUSTED_PROFILE_SAP:
+ if (trusted_profile_flag & (PROFILE_SUPPORTED << 4))
+ trust_profile = trusted_profile_flag & (1 << 5);
+ else
+ return BLUETOOTH_ERROR_NOT_SUPPORT;
+ break;
+ case TRUSTED_PROFILE_ALL: /* Return Flag for All profiles*/
+ *trusted = trusted_profile_flag;
+ return BLUETOOTH_ERROR_NONE;
+ default:
+ return BLUETOOTH_ERROR_NOT_SUPPORT;
+ }
+
+ if (trust_profile)
+ *trusted = TRUE;
+
+ return BLUETOOTH_ERROR_NONE;
+}
+
+int _bt_get_restricted_profile_from_flag(bluetooth_restricted_profile_t profile,
+ guint restricted_profile_flag, guint *restricted)
+{
+ int restrict_profile;
+ *restricted = FALSE;
+
+ switch (profile) {
+ case RESTRICTED_PROFILE_HFP_HS:
+ restrict_profile = restricted_profile_flag & (1 << 0);
+ break;
+ case RESTRICTED_PROFILE_A2DP:
+ restrict_profile = restricted_profile_flag & (1 << 2);
+ break;
+ default:
+ return BLUETOOTH_ERROR_NOT_SUPPORT;
+ }
+
+ if (restrict_profile)
+ *restricted = TRUE;
+
+ return BLUETOOTH_ERROR_NONE;
+}
+
+char *_bt_get_trusted_profile_uuid(bluetooth_trusted_profile_t profile)
+{
+ switch (profile) {
+ case TRUSTED_PROFILE_PBAP:
+ return g_strdup("00001130-0000-1000-8000-00805f9b34fb");
+ case TRUSTED_PROFILE_MAP:
+ return g_strdup("00001134-0000-1000-8000-00805f9b34fb");
+ case TRUSTED_PROFILE_SAP:
+ return g_strdup("0000112D-0000-1000-8000-00805f9b34fb");
+ case TRUSTED_PROFILE_ALL:
+ return NULL;
+ }
+
+ return NULL;
+}
+
+char *_bt_get_restricted_profile_uuid(bluetooth_restricted_profile_t profile)
+{
+ switch (profile) {
+ case RESTRICTED_PROFILE_HFP_HS:
+ return g_strdup("0000111e-0000-1000-8000-00805f9b34fb");
+ case RESTRICTED_PROFILE_A2DP:
+ return g_strdup("0000110b-0000-1000-8000-00805f9b34fb");
+ }
+
+ return NULL;
+}
+
+bluetooth_trusted_profile_t _bt_get_trusted_profile_enum(const char *uuid)
+{
+ if (g_strcmp0("0000112f-0000-1000-8000-00805f9b34fb", uuid) == 0)
+ return TRUSTED_PROFILE_PBAP;
+ else if (g_strcmp0("00001132-0000-1000-8000-00805f9b34fb", uuid) == 0)
+ return TRUSTED_PROFILE_MAP;
+ else if (g_strcmp0("0000112D-0000-1000-8000-00805f9b34fb", uuid) == 0)
+ return TRUSTED_PROFILE_SAP;
+
+ return 0; /* 0 - Unknown Profile */
+}
+
+int _bt_set_trust_profile(bluetooth_device_address_t *bd_addr,
+ bluetooth_trusted_profile_t profile, gboolean trust)
+{
+ int ret = BLUETOOTH_ERROR_NONE;
+ GDBusConnection *conn;
+ GDBusProxy *proxy;
+ GError *error = NULL;
+ char *device_path = NULL;
+ char *uuid = NULL;
+ char address[BT_ADDRESS_STRING_SIZE] = { 0 };
+ GVariant *reply;
+
+ BT_CHECK_PARAMETER(bd_addr, return);
+ BT_DBG("BD Address [%2.2X %2.2X %2.2X %2.2X %2.2X %2.2X] profile[%d] trust[%d]",
+ bd_addr->addr[0], bd_addr->addr[1],
+ bd_addr->addr[2], bd_addr->addr[3],
+ bd_addr->addr[4], bd_addr->addr[5],
+ profile, trust);
+
+ conn = _bt_gdbus_get_system_gconn();
+ retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
+
+ _bt_convert_addr_type_to_string(address, bd_addr->addr);
+
+ device_path = _bt_get_device_object_path(address);
+ retv_if(device_path == NULL, BLUETOOTH_ERROR_INTERNAL);
+
+ proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
+ NULL, BT_BLUEZ_NAME, device_path,
+ BT_DEVICE_INTERFACE, NULL, NULL);
+
+ g_free(device_path);
+ retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
+
+ uuid = _bt_get_trusted_profile_uuid(profile);
+ if (uuid == NULL) {
+ g_object_unref(proxy);
+ return BLUETOOTH_ERROR_NOT_SUPPORT;
+ }
+
+ reply = g_dbus_proxy_call_sync(proxy, "SetTrustedProfile",
+ g_variant_new("(sb)", uuid, trust),
+ G_DBUS_CALL_FLAGS_NONE, -1,
+ NULL, &error);
+ g_object_unref(proxy);
+
+ if (reply == NULL) {
+ BT_ERR("Failed to Set Profile Trusted");
+ ret = BLUETOOTH_ERROR_INTERNAL;
+ if (error) {
+ BT_ERR("Error %s[%s]", error->message, address);
+ g_error_free(error);
+ }
+ goto finish;
+ }
+ g_variant_unref(reply);
+
+finish:
+ g_free(uuid);
+ return ret;
+}
+
+int _bt_get_trust_profile(bluetooth_device_address_t *bd_addr,
+ bluetooth_trusted_profile_t profile, guint *trust)
+{
+ int ret = BLUETOOTH_ERROR_NONE;
+ GDBusConnection *conn;
+ GDBusProxy *proxy;
+ GError *error = NULL;
+ char *device_path = NULL;
+ guint trusted_profile_flag;
+ char address[BT_ADDRESS_STRING_SIZE] = { 0 };
+ GVariant *reply;
+
+ BT_CHECK_PARAMETER(bd_addr, return);
+ BT_DBG("BD Address [%2.2X %2.2X %2.2X %2.2X %2.2X %2.2X] profile[%d] trust[%d]",
+ bd_addr->addr[0], bd_addr->addr[1],
+ bd_addr->addr[2], bd_addr->addr[3],
+ bd_addr->addr[4], bd_addr->addr[5],
+ profile, *trust);
+
+ conn = _bt_gdbus_get_system_gconn();
+ retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
+
+ _bt_convert_addr_type_to_string(address, bd_addr->addr);
+
+ device_path = _bt_get_device_object_path(address);
+ retv_if(device_path == NULL, BLUETOOTH_ERROR_INTERNAL);
+
+ proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
+ NULL, BT_BLUEZ_NAME, device_path,
+ BT_PROPERTIES_INTERFACE, NULL, NULL);
+
+ g_free(device_path);
+ retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
+
+ reply = g_dbus_proxy_call_sync(proxy, "Get",
+ g_variant_new("(ss)", BT_DEVICE_INTERFACE, "TrustedProfiles"),
+ G_DBUS_CALL_FLAGS_NONE, -1,
+ NULL, &error);
+ g_object_unref(proxy);
+
+ if (reply == NULL) {
+ BT_ERR("Failed to Get Profile Trusted");
+ ret = BLUETOOTH_ERROR_INTERNAL;
+ if (error) {
+ BT_ERR("Error %s[%s]", error->message, address);
+ g_error_free(error);
+ }
+ *trust = 0;
+ } else {
+ GVariant *temp;
+ g_variant_get(reply, "(v)", &temp);
+ trusted_profile_flag = g_variant_get_uint32(temp);
+ BT_DBG("TRUST_FLAG %d", trusted_profile_flag);
+
+ ret = _bt_get_trusted_profile_from_flag(profile,
+ trusted_profile_flag, trust);
+ g_variant_unref(temp);
+ g_variant_unref(reply);
+ }
+
+ BT_DBG("TRUST %d", *trust);
+ return ret;
+}
+
+int _bt_set_restrict_profile(bluetooth_device_address_t *bd_addr,
+ bluetooth_restricted_profile_t profile, gboolean restricted)
+{
+ int ret = BLUETOOTH_ERROR_NONE;
+ GDBusConnection *conn;
+ GDBusProxy *proxy;
+ GError *error = NULL;
+ char *device_path = NULL;
+ char *uuid = NULL;
+ char address[BT_ADDRESS_STRING_SIZE] = { 0 };
+ GVariant *reply;
+
+ BT_CHECK_PARAMETER(bd_addr, return);
+ BT_DBG("BD Address [%2.2X %2.2X %2.2X %2.2X %2.2X %2.2X] profile[%d] restricted[%d]",
+ bd_addr->addr[0], bd_addr->addr[1],
+ bd_addr->addr[2], bd_addr->addr[3],
+ bd_addr->addr[4], bd_addr->addr[5],
+ profile, restricted);
+
+ conn = _bt_gdbus_get_system_gconn();
+ retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
+
+ _bt_convert_addr_type_to_string(address, bd_addr->addr);
+
+ device_path = _bt_get_device_object_path(address);
+ retv_if(device_path == NULL, BLUETOOTH_ERROR_INTERNAL);
+
+ proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
+ NULL, BT_BLUEZ_NAME, device_path,
+ BT_DEVICE_INTERFACE, NULL, NULL);
+
+ g_free(device_path);
+ retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
+
+ uuid = _bt_get_restricted_profile_uuid(profile);
+ if (uuid == NULL) {
+ g_object_unref(proxy);
+ return BLUETOOTH_ERROR_NOT_SUPPORT;
+ }
+
+ reply = g_dbus_proxy_call_sync(proxy, "SetRestrictedProfile",
+ g_variant_new("(sb)", uuid, restricted),
+ G_DBUS_CALL_FLAGS_NONE, -1,
+ NULL, &error);
+ g_object_unref(proxy);
+
+ if (reply == NULL) {
+ BT_ERR("Failed to Set Profile Restricted");
+ ret = BLUETOOTH_ERROR_INTERNAL;
+ if (error) {
+ BT_ERR("Error %s[%s]", error->message, address);
+ g_error_free(error);
+ }
+ goto finish;
+ }
+ g_variant_unref(reply);
+
+finish:
+ g_free(uuid);
+ return ret;
+}
+
+int _bt_get_restrict_profile(bluetooth_device_address_t *bd_addr,
+ bluetooth_restricted_profile_t profile, guint *restricted)
+{
+ int ret = BLUETOOTH_ERROR_NONE;
+ GDBusConnection *conn;
+ GDBusProxy *proxy;
+ GError *error = NULL;
+ char *device_path = NULL;
+ guint restricted_profile_flag;
+ char address[BT_ADDRESS_STRING_SIZE] = { 0 };
+ GVariant *reply;
+
+ BT_CHECK_PARAMETER(bd_addr, return);
+ BT_DBG("BD Address [%2.2X %2.2X %2.2X %2.2X %2.2X %2.2X] profile[%d] restricted[%d]",
+ bd_addr->addr[0], bd_addr->addr[1],
+ bd_addr->addr[2], bd_addr->addr[3],
+ bd_addr->addr[4], bd_addr->addr[5],
+ profile, *restricted);
+
+ conn = _bt_gdbus_get_system_gconn();
+ retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
+
+ _bt_convert_addr_type_to_string(address, bd_addr->addr);
+
+ device_path = _bt_get_device_object_path(address);
+ retv_if(device_path == NULL, BLUETOOTH_ERROR_INTERNAL);
+
+ proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
+ NULL, BT_BLUEZ_NAME, device_path,
+ BT_PROPERTIES_INTERFACE, NULL, NULL);
+
+ g_free(device_path);
+ retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
+
+ reply = g_dbus_proxy_call_sync(proxy, "Get",
+ g_variant_new("(ss)", BT_DEVICE_INTERFACE, "RestrictedProfiles"),
+ G_DBUS_CALL_FLAGS_NONE, -1,
+ NULL, &error);
+ g_object_unref(proxy);
+
+ if (reply == NULL) {
+ BT_ERR("Failed to Get Profile Restricted");
+ ret = BLUETOOTH_ERROR_INTERNAL;
+ if (error) {
+ BT_ERR("Error %s[%s]", error->message, address);
+ g_error_free(error);
+ }
+ *restricted = 0;
+ } else {
+ GVariant *temp;
+ g_variant_get(reply, "(v)", &temp);
+ restricted_profile_flag = g_variant_get_uint32(temp);
+ BT_DBG("Restricted_FLAG %d", restricted_profile_flag);
+
+ ret = _bt_get_restricted_profile_from_flag(profile,
+ restricted_profile_flag, restricted);
+ g_variant_unref(temp);
+ g_variant_unref(reply);
+ }
+
+ BT_DBG("TRUST %d", *restricted);
+ return ret;
+}
+
+static void __bt_request_att_mtu_device_cb(GDBusProxy *proxy, GAsyncResult *res,
+ gpointer user_data)
+{
+ GError *err = NULL;
+ GVariant *out_param1;
+ request_info_t *req_info;
+ GVariant *val = NULL;
+ GVariant *param = NULL;
+ guint8 status = 0;
+ guint16 mtu = 0;
+ bluetooth_device_address_t device_addr = { {0} };
+ int result = BLUETOOTH_ERROR_NONE;
+
+ BT_DBG("+");
+ val = g_dbus_proxy_call_finish(proxy, res, &err);
+
+ req_info = _bt_get_request_info(att_mtu_req_info->req_id);
+ if (req_info == NULL) {
+ BT_ERR("req_info == NULL");
+ g_object_unref(proxy);
+ att_mtu_req_info->device_proxy = NULL;
+ goto done;
+ }
+
+ if (err != NULL) {
+ BT_ERR("Error occured in RequestAttMtu [%s]", err->message);
+
+ if (g_strrstr(err->message, "NotSupported")) {
+ BT_INFO("Connection Not Supported");
+ result = BLUETOOTH_ERROR_NOT_SUPPORT;
+ } else if (g_strrstr(err->message, "NotConnected")) {
+ BT_INFO("Not connected");
+ result = BLUETOOTH_ERROR_NOT_CONNECTED;
+ } else if (g_strrstr(err->message, "InvalidArguments")) {
+ BT_INFO("Not connected");
+ result = BLUETOOTH_ERROR_INVALID_PARAM;
+ } else {
+ BT_DBG("Default case");
+ result = BLUETOOTH_ERROR_INTERNAL;
+ }
+ }
+
+ g_object_unref(proxy);
+ att_mtu_req_info->device_proxy = NULL;
+
+ if (result != BLUETOOTH_ERROR_NONE)
+ goto dbus_return;
+
+ if (val) {
+ g_variant_get(val, "(qy)", &mtu, &status);
+ g_variant_unref(val);
+ }
+
+ BT_DBG("MTU %d, Status %d, %s", mtu, status, att_mtu_req_info->addr);
+
+ param = g_variant_new("(isqy)",
+ result,
+ att_mtu_req_info->addr,
+ mtu,
+ status);
+
+ /* Send the event to application */
+ _bt_send_event(BT_DEVICE_EVENT,
+ BLUETOOTH_EVENT_GATT_ATT_MTU_CHANGED,
+ param);
+
+dbus_return:
+ if (req_info->context == NULL)
+ goto done;
+
+ _bt_convert_addr_string_to_type(device_addr.addr,
+ (const char *)att_mtu_req_info->addr);
+
+ out_param1 = g_variant_new_from_data((const GVariantType *)"ay",
+ &device_addr, sizeof(bluetooth_device_address_t), TRUE, NULL, NULL);
+ g_dbus_method_invocation_return_value(req_info->context,
+ g_variant_new("(iv)", result, out_param1));
+
+ _bt_delete_request_list(req_info->req_id);
+done:
+ if (err)
+ g_error_free(err);
+
+ g_free(att_mtu_req_info->addr);
+ g_free(att_mtu_req_info);
+ att_mtu_req_info = NULL;
+
+ BT_DBG("-");
+}
+
+int _bt_request_att_mtu(int request_id, bluetooth_device_address_t *device_address,
+ unsigned int mtu)
+{
+ char address[BT_ADDRESS_STRING_SIZE] = { 0 };
+ gchar *device_path = NULL;
+ GDBusProxy *adapter_proxy;
+ GDBusProxy *device_proxy;
+ GDBusConnection *conn;
+ int ret = BLUETOOTH_ERROR_NONE;
+
+ BT_CHECK_PARAMETER(device_address, return);
+
+ if (att_mtu_req_info) {
+ BT_ERR("ATT MTU request in progress");
+ return BLUETOOTH_ERROR_DEVICE_BUSY;
+ }
+
+ conn = _bt_gdbus_get_system_gconn();
+ retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
+
+ adapter_proxy = _bt_get_adapter_proxy();
+ retv_if(adapter_proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
+
+ _bt_convert_addr_type_to_string(address, device_address->addr);
+
+ BT_DBG("Remote device address: %s", address);
+
+ device_path = _bt_get_device_object_path(address);
+
+ retv_if(device_path == NULL, BLUETOOTH_ERROR_INTERNAL);
+
+ device_proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
+ NULL, BT_BLUEZ_NAME,
+ device_path, BT_DEVICE_INTERFACE, NULL, NULL);
+ g_free(device_path);
+ retv_if(device_proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
+
+ att_mtu_req_info = g_malloc0(sizeof(bt_funcion_data_t));
+ att_mtu_req_info->addr = (char *)g_strdup(address);
+ att_mtu_req_info->req_id = request_id;
+ att_mtu_req_info->device_proxy = device_proxy;
+
+ g_dbus_proxy_call(device_proxy, "RequestAttMtu",
+ g_variant_new("(q)", mtu),
+ G_DBUS_CALL_FLAGS_NONE,
+ BT_MAX_DBUS_TIMEOUT,
+ NULL,
+ (GAsyncReadyCallback)__bt_request_att_mtu_device_cb,
+ NULL);
+
+ return ret;
+}
+
+int _bt_get_att_mtu(bluetooth_device_address_t *device_address,
+ unsigned int *mtu)
+{
+ char address[BT_ADDRESS_STRING_SIZE] = { 0 };
+ char *object_path = NULL;
+
+ GDBusProxy *device_proxy;
+ GError *error = NULL;
+ GVariant *value;
+ GDBusConnection *conn;
+ GVariant *result = NULL;
+
+ BT_CHECK_PARAMETER(device_address, return);
+
+ conn = _bt_gdbus_get_system_gconn();
+ retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
+
+ _bt_convert_addr_type_to_string(address, device_address->addr);
+
+ object_path = _bt_get_device_object_path(address);
+ retv_if(object_path == NULL, BLUETOOTH_ERROR_NOT_PAIRED);
+
+ device_proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
+ NULL, BT_BLUEZ_NAME, object_path,
+ BT_PROPERTIES_INTERFACE, NULL, NULL);
+ g_free(object_path);
+ retv_if(device_proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
+
+ result = g_dbus_proxy_call_sync(device_proxy, "Get",
+ g_variant_new("(ss)", BT_DEVICE_INTERFACE, "AttMtu"),
+ G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
+ if (error) {
+ ERR("DBus Error : %s", error->message);
+ g_clear_error(&error);
+ g_object_unref(device_proxy);
+ return BLUETOOTH_ERROR_INTERNAL;
+ } else {
+ g_variant_get(result, "(v)", &value);
+ *mtu = g_variant_get_uint16(value);
+ BT_DBG("ATT MTU : %d", *mtu);
+ g_variant_unref(value);
+ g_variant_unref(result);
+
+ if (*mtu == 0) {
+ g_object_unref(device_proxy);
+ return BLUETOOTH_ERROR_NOT_CONNECTED;
+ }
+ }
+
+ g_object_unref(device_proxy);
+ return BLUETOOTH_ERROR_NONE;
+}
+
+int _bt_get_device_ida(bluetooth_device_address_t *device_address,
+ bluetooth_device_address_t *id_address)
+{
+ char address[BT_ADDRESS_STRING_SIZE] = { 0 };
+ gchar *device_path = NULL;
+ const gchar *idaddress = NULL;
+ GDBusProxy *device_proxy;
+ GError *error = NULL;
+ GVariant *result = NULL;
+ GDBusConnection *conn;
+ int ret = BLUETOOTH_ERROR_NONE;
+
+ BT_CHECK_PARAMETER(device_address, return);
+
+ conn = _bt_gdbus_get_system_gconn();
+ retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
+
+ _bt_convert_addr_type_to_string(address, device_address->addr);
+
+ device_path = _bt_get_device_object_path(address);
+ retv_if(device_path == NULL, BLUETOOTH_ERROR_NOT_PAIRED);
+
+ device_proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
+ NULL, BT_BLUEZ_NAME,
+ device_path, BT_DEVICE_INTERFACE, NULL, NULL);
+ g_free(device_path);
+ if (!device_proxy) {
+ BT_ERR("Unable to get proxy");
+ return BLUETOOTH_ERROR_INTERNAL;
+ }
+
+ result = g_dbus_proxy_call_sync(device_proxy, "GetIDAddress", NULL,
+ G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
+ if (result == NULL) {
+ BT_ERR("Failed to get device ID address");
+
+ ret = BLUETOOTH_ERROR_INTERNAL;
+ if (error != NULL) {
+ g_dbus_error_strip_remote_error(error);
+ BT_ERR("Error occured in Proxy call [%s]", error->message);
+ if (g_strcmp0(error->message, "Does Not Exist") == 0)
+ ret = BLUETOOTH_ERROR_NOT_PAIRED;
+ g_error_free(error);
+ }
+ g_object_unref(device_proxy);
+ return ret;
+ }
+
+ g_variant_get(result , "(&s)", &idaddress);
+
+ DBG_SECURE("ID Address : %s", idaddress);
+ _bt_convert_addr_string_to_type(id_address->addr, idaddress);
+
+ g_variant_unref(result);
+ g_object_unref(device_proxy);
+
+ return ret;
+}
+
+int _bt_passkey_reply(const char *passkey, gboolean authentication_reply)
+{
+ GapAgentPrivate *agent = _bt_get_adapter_agent();
+ retv_if(!agent, BLUETOOTH_ERROR_INTERNAL);
+
+ if (authentication_reply)
+ gap_agent_reply_pin_code(agent, GAP_AGENT_ACCEPT, passkey, NULL);
+ else
+ gap_agent_reply_pin_code(agent, GAP_AGENT_REJECT, passkey, NULL);
+
+ BT_DBG("BT_PASSKEY_REPLY");
+ return BLUETOOTH_ERROR_NONE;
+}
+
+int _bt_passkey_confirmation_reply(gboolean confirmation_reply)
+{
+ GapAgentPrivate *agent = _bt_get_adapter_agent();
+ retv_if(!agent, BLUETOOTH_ERROR_INTERNAL);
+
+ if (confirmation_reply)
+ gap_agent_reply_confirmation(agent, GAP_AGENT_ACCEPT, NULL);
+ else
+ gap_agent_reply_confirmation(agent, GAP_AGENT_REJECT, NULL);
+
+ BT_DBG("BT_PASSKEY_CONFIRMATION_REPLY");
+ return BLUETOOTH_ERROR_NONE;
+}