Now the record list is managed on a per adapter basis

1 files changed, 84 insertions, 64 deletions

diff --git a/plugins/service.c b/plugins/service.c
index 565a17a7..5c9347b2 100644
--- a/plugins/service.c
+++ b/plugins/service.c
@@ -48,12 +48,12 @@
 #define SERVICE_INTERFACE "org.bluez.Service"
 
 static DBusConnection *connection = NULL;
-static GSList *records = NULL;
 
 struct record_data {
 	uint32_t handle;
 	char *sender;
 	guint listener_id;
+	struct service_adapter *serv_adapter;
 };
 
 struct context_data {
@@ -74,6 +74,7 @@ struct pending_auth {
 struct service_adapter {
 	struct btd_adapter *adapter;
 	GSList *pending_list;
+	GSList *records;
 };
 
 static int compute_seq_size(sdp_data_t *data)
@@ -271,11 +272,12 @@ static sdp_record_t *sdp_xml_parse_record(const char *data, int size)
 	return record;
 }
 
-static struct record_data *find_record(uint32_t handle, const char *sender)
+static struct record_data *find_record(struct service_adapter *serv_adapter,
+					uint32_t handle, const char *sender)
 {
 	GSList *list;
 
-	for (list = records; list; list = list->next) {
+	for (list = serv_adapter->records; list; list = list->next) {
 		struct record_data *data = list->data;
 		if (handle == data->handle && !strcmp(sender, data->sender))
 			return data;
@@ -284,13 +286,50 @@ static struct record_data *find_record(uint32_t handle, const char *sender)
 	return NULL;
 }
 
+static struct pending_auth *next_pending(struct service_adapter *serv_adapter)
+{
+	GSList *l = serv_adapter->pending_list;
+
+	if (l) {
+		struct pending_auth *auth = l->data;
+		return auth;
+	}
+
+	return NULL;
+}
+
+static struct pending_auth *find_pending_by_sender(
+			struct service_adapter *serv_adapter,
+			const char *sender)
+{
+	GSList *l = serv_adapter->pending_list;
+
+	for (; l; l = l->next) {
+		struct pending_auth *auth = l->data;
+		if (g_str_equal(auth->sender, sender))
+			return auth;
+	}
+
+	return NULL;
+}
+
 static void exit_callback(void *user_data)
 {
 	struct record_data *user_record = user_data;
+	struct service_adapter *serv_adapter = user_record->serv_adapter;
+	struct pending_auth *auth;
 
 	debug("remove record");
 
-	records = g_slist_remove(records, user_record);
+	serv_adapter->records = g_slist_remove(serv_adapter->records,
+						user_record);
+
+	auth = find_pending_by_sender(serv_adapter, user_record->sender);
+	if (auth) {
+		serv_adapter->pending_list = g_slist_remove(serv_adapter->pending_list,
+							auth);
+		g_free(auth);
+	}
 
 	remove_record_from_server(user_record->handle);
 
@@ -334,11 +373,12 @@ static inline DBusMessage *does_not_exist(DBusMessage *msg)
 }
 
 static int add_xml_record(DBusConnection *conn, const char *sender,
-			bdaddr_t *src, const char *record,
-			dbus_uint32_t *handle)
+			struct service_adapter *serv_adapter,
+			const char *record, dbus_uint32_t *handle)
 {
 	struct record_data *user_record;
 	sdp_record_t *sdp_record;
+	bdaddr_t src;
 
 	sdp_record = sdp_xml_parse_record(record, strlen(record));
 	if (!sdp_record) {
@@ -346,23 +386,23 @@ static int add_xml_record(DBusConnection *conn, const char *sender,
 		return -EIO;
 	}
 
-	if (add_record_to_server(src, sdp_record) < 0) {
+	adapter_get_address(serv_adapter->adapter, &src);
+	if (add_record_to_server(&src, sdp_record) < 0) {
 		error("Failed to register service record");
 		sdp_record_free(sdp_record);
 		return -EIO;
 	}
 
 	user_record = g_new0(struct record_data, 1);
-
 	user_record->handle = sdp_record->handle;
-
 	user_record->sender = g_strdup(sender);
-
-	records = g_slist_append(records, user_record);
-
+	user_record->serv_adapter = serv_adapter;
 	user_record->listener_id = g_dbus_add_disconnect_watch(conn, sender,
 					exit_callback, user_record, NULL);
 
+	serv_adapter->records = g_slist_append(serv_adapter->records,
+					user_record);
+
 	debug("listener_id %d", user_record->listener_id);
 
 	*handle = user_record->handle;
@@ -371,8 +411,10 @@ static int add_xml_record(DBusConnection *conn, const char *sender,
 }
 
 static DBusMessage *update_record(DBusConnection *conn, DBusMessage *msg,
-		bdaddr_t *src, dbus_uint32_t handle, sdp_record_t *sdp_record)
+		struct service_adapter *serv_adapter,
+		dbus_uint32_t handle, sdp_record_t *sdp_record)
 {
+	bdaddr_t src;
 	int err;
 
 	if (remove_record_from_server(handle) < 0) {
@@ -382,8 +424,10 @@ static DBusMessage *update_record(DBusConnection *conn, DBusMessage *msg,
 				"Not Available");
 	}
 
+	adapter_get_address(serv_adapter->adapter, &src);
+
 	sdp_record->handle = handle;
-	err = add_record_to_server(src, sdp_record);
+	err = add_record_to_server(&src, sdp_record);
 	if (err < 0) {
 		sdp_record_free(sdp_record);
 		error("Failed to update the service record");
@@ -396,7 +440,8 @@ static DBusMessage *update_record(DBusConnection *conn, DBusMessage *msg,
 }
 
 static DBusMessage *update_xml_record(DBusConnection *conn,
-				DBusMessage *msg, bdaddr_t *src)
+				DBusMessage *msg,
+				struct service_adapter *serv_adapter)
 {
 	struct record_data *user_record;
 	sdp_record_t *sdp_record;
@@ -414,7 +459,8 @@ static DBusMessage *update_xml_record(DBusConnection *conn,
 	if (len == 0)
 		return invalid_arguments(msg);
 
-	user_record = find_record(handle, dbus_message_get_sender(msg));
+	user_record = find_record(serv_adapter, handle,
+				dbus_message_get_sender(msg));
 	if (!user_record)
 		return g_dbus_create_error(msg,
 				ERROR_INTERFACE ".NotAvailable",
@@ -429,17 +475,18 @@ static DBusMessage *update_xml_record(DBusConnection *conn,
 				strerror(EIO));
 	}
 
-	return update_record(conn, msg, src, handle, sdp_record);
+	return update_record(conn, msg, serv_adapter, handle, sdp_record);
 }
 
 static int remove_record(DBusConnection *conn, const char *sender,
+			struct service_adapter *serv_adapter,
 			dbus_uint32_t handle)
 {
 	struct record_data *user_record;
 
 	debug("remove record 0x%x", handle);
 
-	user_record = find_record(handle, sender);
+	user_record = find_record(serv_adapter, handle, sender);
 	if (!user_record)
 		return -1;
 
@@ -456,11 +503,9 @@ static DBusMessage *add_service_record(DBusConnection *conn,
 					DBusMessage *msg, void *data)
 {
 	struct service_adapter *serv_adapter = data;
-	struct btd_adapter *adapter = serv_adapter->adapter;
 	DBusMessage *reply;
 	const char *sender, *record;
 	dbus_uint32_t handle;
-	bdaddr_t src;
 	int err;
 
 	if (dbus_message_get_args(msg, NULL,
@@ -468,8 +513,7 @@ static DBusMessage *add_service_record(DBusConnection *conn,
 		return NULL;
 
 	sender = dbus_message_get_sender(msg);
-	adapter_get_address(adapter, &src);
-	err = add_xml_record(conn, sender, &src, record, &handle);
+	err = add_xml_record(conn, sender, serv_adapter, record, &handle);
 	if (err < 0)
 		return failed_strerror(msg, err);
 
@@ -487,17 +531,14 @@ static DBusMessage *update_service_record(DBusConnection *conn,
 					DBusMessage *msg, void *data)
 {
 	struct service_adapter *serv_adapter = data;
-	struct btd_adapter *adapter = serv_adapter->adapter;
-	bdaddr_t src;
 
-	adapter_get_address(adapter, &src);
-
-	return update_xml_record(conn, msg, &src);
+	return update_xml_record(conn, msg, serv_adapter);
 }
 
 static DBusMessage *remove_service_record(DBusConnection *conn,
 					DBusMessage *msg, void *data)
 {
+	struct service_adapter *serv_adapter = data;
 	dbus_uint32_t handle;
 	const char *sender;
 
@@ -507,39 +548,12 @@ static DBusMessage *remove_service_record(DBusConnection *conn,
 
 	sender = dbus_message_get_sender(msg);
 
-	if (remove_record(conn, sender, handle) < 0)
+	if (remove_record(conn, sender, serv_adapter, handle) < 0)
 		return not_available(msg);
 
 	return dbus_message_new_method_return(msg);
 }
 
-static struct pending_auth *next_pending(struct service_adapter *serv_adapter)
-{
-	GSList *l = serv_adapter->pending_list;
-
-	if (l) {
-		struct pending_auth *auth = l->data;
-		return auth;
-	}
-
-	return NULL;
-}
-
-static struct pending_auth *find_pending_by_sender(
-			struct service_adapter *serv_adapter,
-			const char *sender)
-{
-	GSList *l = serv_adapter->pending_list;
-
-	for (; l; l = l->next) {
-		struct pending_auth *auth = l->data;
-		if (g_str_equal(auth->sender, sender))
-			return auth;
-	}
-
-	return NULL;
-}
-
 static void auth_cb(DBusError *derr, void *user_data)
 {
 	struct service_adapter *serv_adapter = user_data;
@@ -607,7 +621,7 @@ static DBusMessage *request_authorization(DBusConnection *conn,
 	if (find_pending_by_sender(serv_adapter, sender))
 		return failed(msg);
 
-	user_record = find_record(handle, sender);
+	user_record = find_record(serv_adapter, handle, sender);
 	if (!user_record)
 		return not_authorized(msg);
 
@@ -647,8 +661,12 @@ static DBusMessage *request_authorization(DBusConnection *conn,
 		return does_not_exist(msg);
 
 	adapter_get_address(adapter, &src);
-	btd_request_authorization(&src, &auth->dst,
-				auth->uuid, auth_cb, serv_adapter);
+	if (btd_request_authorization(&src, &auth->dst, auth->uuid, auth_cb,
+					serv_adapter) < 0) {
+		serv_adapter->pending_list = g_slist_remove(serv_adapter->pending_list, auth);
+		g_free(auth);
+		return not_authorized(msg);
+	}
 
 	return NULL;
 }
@@ -706,24 +724,26 @@ static GDBusMethodTable service_methods[] = {
 
 static void path_unregister(void *data)
 {
-	g_slist_foreach(records, (GFunc) exit_callback, NULL);
+	struct service_adapter *serv_adapter = data;
+
+	g_slist_foreach(serv_adapter->records, (GFunc) exit_callback, NULL);
 }
 
 static int service_probe(struct btd_adapter *adapter)
 {
 	const char *path = adapter_get_path(adapter);
-	struct service_adapter *service_adapter;
+	struct service_adapter *serv_adapter;
 
 	DBG("path %s", path);
 
-	service_adapter = g_new0(struct service_adapter, 1);
-	service_adapter->adapter = adapter;
-	service_adapter->pending_list = NULL;
+	serv_adapter = g_new0(struct service_adapter, 1);
+	serv_adapter->adapter = adapter;
+	serv_adapter->pending_list = NULL;
 
 	if (!g_dbus_register_interface(connection, path,
 					SERVICE_INTERFACE,
 					service_methods, NULL, NULL,
-					service_adapter, path_unregister)) {
+					serv_adapter, path_unregister)) {
 		error("D-Bus failed to register %s interface",
 				SERVICE_INTERFACE);
 		return -1;