static struct gatt_req_info *__bt_gatt_find_request_info(guint request_id);
+static void __bt_gatt_close_gdbus_connection(void)
+{
+ GError *err = NULL;
+
+ BT_DBG("+");
+
+ ret_if(g_conn == NULL);
+
+ if (!g_dbus_connection_flush_sync(g_conn, NULL, &err)) {
+ BT_ERR("Fail to flush the connection: %s", err->message);
+ g_error_free(err);
+ err = NULL;
+ }
+
+ if (!g_dbus_connection_close_sync(g_conn, NULL, &err)) {
+ if (err) {
+ BT_ERR("Fail to close the dbus connection: %s", err->message);
+ g_error_free(err);
+ }
+ }
+
+ g_object_unref(g_conn);
+
+ g_conn = NULL;
+
+ BT_DBG("-");
+}
+
#ifdef HPS_FEATURE
static int __bt_send_event_to_hps(int event, GVariant *var)
{
if (introspection_data == NULL)
return NULL;
+
+ BT_DBG("Create new node info");
node_info = g_dbus_node_info_new_for_xml(introspection_data, &err);
if (err) {
BT_ERR("Unable to create node: %s", err->message);
g_clear_error(&err);
+ return NULL;
}
+
return node_info;
}
static GDBusConnection *__bt_gatt_get_gdbus_connection(void)
{
GDBusConnection *local_system_gconn = NULL;
+ char *address;
GError *err = NULL;
if (g_conn == NULL) {
- g_conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &err);
+ address = g_dbus_address_get_for_bus_sync(G_BUS_TYPE_SYSTEM, NULL, &err);
+ if (address == NULL) {
+ if (err) {
+ BT_ERR("Failed to get bus address: %s", err->message);
+ g_clear_error(&err);
+ }
+ return NULL;
+ }
+
+ g_conn = g_dbus_connection_new_for_address_sync(address,
+ G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT |
+ G_DBUS_CONNECTION_FLAGS_MESSAGE_BUS_CONNECTION,
+ NULL, /* GDBusAuthObserver */
+ NULL,
+ &err);
if (!g_conn) {
if (err) {
BT_ERR("Unable to connect to dbus: %s", err->message);
g_clear_error(&err);
}
- g_conn = NULL;
+ return NULL;
}
} else if (g_dbus_connection_is_closed(g_conn)) {
- local_system_gconn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &err);
+ address = g_dbus_address_get_for_bus_sync(G_BUS_TYPE_SYSTEM, NULL, &err);
+ if (address == NULL) {
+ if (err) {
+ BT_ERR("Failed to get bus address: %s", err->message);
+ g_clear_error(&err);
+ }
+ return NULL;
+ }
+
+ local_system_gconn = g_dbus_connection_new_for_address_sync(address,
+ G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT |
+ G_DBUS_CONNECTION_FLAGS_MESSAGE_BUS_CONNECTION,
+ NULL, /* GDBusAuthObserver */
+ NULL,
+ &err);
if (!local_system_gconn) {
BT_ERR("Unable to connect to dbus: %s", err->message);
BT_EXPORT_API int bluetooth_gatt_init(void)
{
GDBusConnection *conn;
- GDBusNodeInfo *obj_info;
GError *error = NULL;
+ GDBusNodeInfo *node_info = NULL;
- owner_id = g_bus_own_name(G_BUS_TYPE_SYSTEM,
- BT_GATT_SERVICE_NAME,
- G_BUS_NAME_OWNER_FLAGS_NONE,
- NULL, NULL, NULL, NULL, NULL);
+ if (app_path != NULL) {
+ BT_ERR("app path already exists! initialized");
+ return BLUETOOTH_ERROR_ALREADY_INITIALIZED;
+ }
+
+ if (owner_id == 0) {
+ owner_id = g_bus_own_name(G_BUS_TYPE_SYSTEM,
+ BT_GATT_SERVICE_NAME,
+ G_BUS_NAME_OWNER_FLAGS_NONE,
+ NULL, NULL, NULL, NULL, NULL);
+ }
BT_DBG("owner_id is [%d]", owner_id);
app_path = g_strdup_printf("/com/%d", getpid());
conn = __bt_gatt_get_gdbus_connection();
if (!conn) {
BT_ERR("Unable to get connection");
- return BLUETOOTH_ERROR_INTERNAL;
+ goto failed;
}
/* Register ObjectManager interface */
- obj_info = __bt_gatt_create_method_node_info(
+ node_info = __bt_gatt_create_method_node_info(
manager_introspection_xml);
- if (obj_info == NULL) {
+ if (node_info == NULL) {
BT_ERR("failed to get node info");
- return BLUETOOTH_ERROR_INTERNAL;
+ goto failed;
}
- manager_id = g_dbus_connection_register_object(g_conn, app_path,
- obj_info->interfaces[0],
- &manager_interface_vtable,
- NULL, NULL, &error);
+ if (manager_id == 0) {
+ BT_INFO("manager_id does not exists");
+
+ manager_id = g_dbus_connection_register_object(g_conn, app_path,
+ node_info->interfaces[0],
+ &manager_interface_vtable,
+ NULL, NULL, &error);
+ }
if (manager_id == 0) {
BT_ERR("failed to register: %s", error->message);
g_error_free(error);
- return BLUETOOTH_ERROR_INTERNAL;
+ goto failed;
}
return BLUETOOTH_ERROR_NONE;
+
+failed:
+ if (owner_id)
+ g_bus_unown_name(owner_id);
+
+ g_free(app_path);
+
+ app_path = NULL;
+ owner_id = 0;
+
+ __bt_gatt_close_gdbus_connection();
+
+ return BLUETOOTH_ERROR_INTERNAL;
}
BT_EXPORT_API int bluetooth_gatt_deinit()
int ret = BLUETOOTH_ERROR_NONE;
/* Unown gdbus bus */
if (owner_id) {
-
/* remove/unregister all services */
BT_DBG("removing all registered gatt service\n");
bluetooth_gatt_delete_services();
- g_bus_unown_name(owner_id);
-
/* unregister the exported interface for object manager */
g_dbus_connection_unregister_object(g_conn,
manager_id);
+ manager_id = 0;
+
+ ret = bluetooth_gatt_unregister_application();
+ if (ret != BLUETOOTH_ERROR_NONE)
+ BT_ERR("Fail to unregister application\n");
+
+ g_bus_unown_name(owner_id);
+ owner_id = 0;
+
+ g_free(app_path);
+ app_path = NULL;
+
BT_DBG("Gatt service deinitialized \n");
g_slist_free(gatt_services);
gatt_services = NULL;
- ret = bluetooth_gatt_unregister_application();
+ g_object_unref(manager_gproxy);
+ manager_gproxy = NULL;
- if (ret == BLUETOOTH_ERROR_NONE) {
- g_free(app_path);
- app_path = NULL;
- }
+ __bt_gatt_close_gdbus_connection();
return ret;
}
+ __bt_gatt_close_gdbus_connection();
+
return BLUETOOTH_ERROR_NOT_FOUND;
}
char_info = __bt_gatt_find_gatt_char_info(serv_path, char_path);
if (char_info == NULL) {
g_strfreev(line_argv);
+ g_free(serv_path);
return BLUETOOTH_ERROR_INVALID_PARAM;
}
if (node_info == NULL) {
g_strfreev(line_argv);
+ g_free(serv_path);
return BLUETOOTH_ERROR_INTERNAL;
}
g_error_free(error);
g_free(path);
g_strfreev(line_argv);
+ g_free(serv_path);
return BLUETOOTH_ERROR_INTERNAL;
}
*desc_path = g_strdup(path);
g_free(path);
+ g_free(serv_path);
g_strfreev(line_argv);
g_variant_builder_unref(inner_builder);
g_variant_builder_unref(builder);
if (!__bt_gatt_get_service_state(serv_path)) {
BT_DBG("service not registered for this characteristic \n");
+ g_free(serv_path);
g_strfreev(line_argv);
return BLUETOOTH_ERROR_INTERNAL;
}
char_info = __bt_gatt_find_gatt_char_info(serv_path, char_path);
if (char_info == NULL) {
+ g_free(serv_path);
+ g_strfreev(line_argv);
+ g_variant_builder_unref(inner_builder);
+ g_variant_builder_unref(outer_builder);
+ g_variant_builder_unref(invalidated_builder);
+
return BLUETOOTH_ERROR_INVALID_DATA;
}
}
}
+ g_free(serv_path);
g_strfreev(line_argv);
g_variant_builder_unref(inner_builder);
g_variant_builder_unref(outer_builder);
return err;
}
+static void __bt_gatt_free_descriptor_info(struct gatt_desc_info *desc_info)
+{
+ int i;
+
+ if (!desc_info)
+ return;
+
+ g_free(desc_info->desc_path);
+ g_free(desc_info->desc_uuid);
+ g_free(desc_info->desc_value);
+
+ for (i = 0; i < desc_info->flags_length; i++)
+ g_free(desc_info->desc_flags[i]);
+
+ g_free(desc_info);
+}
+
+static void __bt_gatt_free_characteristic_info(struct gatt_char_info *char_info)
+{
+ int i;
+
+ if (!char_info)
+ return;
+
+ g_free(char_info->char_path);
+ g_free(char_info->char_uuid);
+ g_free(char_info->char_value);
+
+ for (i = 0; i < char_info->flags_length; i++)
+ g_free(char_info->char_flags[i]);
+
+ g_free(char_info);
+}
+
+static void __bt_gatt_free_service_info(struct gatt_service_info *svc_info)
+{
+ if (!svc_info)
+ return;
+
+ g_free(svc_info->serv_path);
+ g_free(svc_info->service_uuid);
+ g_free(svc_info);
+}
+
BT_EXPORT_API int bluetooth_gatt_unregister_service(const char *svc_path)
{
GSList *l, *l1;
struct gatt_service_info *svc_info;
gboolean ret;
int err = BLUETOOTH_ERROR_NONE;
- GSList *tmp;
BT_DBG("svc_path %s", svc_path);
svc_info = __bt_gatt_find_gatt_service_info(svc_path);
for (l = svc_info->char_data; l != NULL; l = l->next) {
struct gatt_char_info *char_info = l->data;
+ if (char_info == NULL)
+ break;
+
for (l1 = char_info->desc_data; l1 != NULL; l1 = l1->next) {
struct gatt_desc_info *desc_info = l1->data;
+ if (desc_info == NULL)
+ break;
+
ret = g_dbus_connection_unregister_object(g_conn,
desc_info->desc_id);
if (ret) {
} else {
err = BLUETOOTH_ERROR_INTERNAL;
}
+
+ /* list remove & free */
+ char_info->desc_data = g_slist_remove(char_info->desc_data, desc_info);
+ __bt_gatt_free_descriptor_info(desc_info);
}
+
+ g_slist_free(char_info->desc_data);
+ char_info->desc_data = NULL;
+
ret = g_dbus_connection_unregister_object(g_conn,
char_info->char_id);
if (ret) {
} else {
err = BLUETOOTH_ERROR_INTERNAL;
}
+
+ /* list remove & free */
+ svc_info->char_data = g_slist_remove(svc_info->char_data, char_info);
+ __bt_gatt_free_characteristic_info(char_info);
}
+
+ g_slist_free(svc_info->char_data);
+ svc_info->char_data = NULL;
+
ret = g_dbus_connection_unregister_object(g_conn, svc_info->serv_id);
if (ret) {
__bt_gatt_emit_interface_removed(svc_info->serv_path,
BT_DBG("Unregistered the service on properties interface");
}
- for (tmp = gatt_services; tmp != NULL; tmp = tmp->next) {
- struct gatt_service_info *info = tmp->data;
-
- if (g_strcmp0(info->serv_path, svc_path) == 0) {
- gatt_services = g_slist_delete_link(gatt_services, tmp->data);
- }
- }
+ /* list remove & free */
+ gatt_services = g_slist_remove(gatt_services, svc_info);
+ __bt_gatt_free_service_info(svc_info);
new_service = FALSE;
- if (gatt_services->next == NULL)
+ if (gatt_services == NULL) {
+ serv_id = 1;
+ } else if (gatt_services->next == NULL) {
serv_id--;
+ }
return err;
}
if (req_info) {
if (resp_state != BLUETOOTH_ERROR_NONE) {
-
- GQuark quark = g_quark_from_string("gatt-server");
- GError *err = g_error_new(quark, 0, "Application Error");
- g_dbus_method_invocation_return_gerror(req_info->context, err);
- g_error_free(err);
+ g_dbus_method_invocation_return_dbus_error(req_info->context,
+ "org.bluez.Error.Failed", "Application Error");
gatt_requests = g_slist_remove(gatt_requests, req_info);
if (!__bt_gatt_get_service_state(serv_path)) {
BT_DBG("service not registered for this characteristic \n");
+ g_free(serv_path);
g_strfreev(line_argv);
return BLUETOOTH_ERROR_INTERNAL;
}
+ g_free(serv_path);
+
outer_builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
invalidated_builder = g_variant_builder_new(G_VARIANT_TYPE("as"));