+bus_registry_acquire_service (BusRegistry *registry,
+ DBusConnection *connection,
+ const DBusString *service_name,
+ dbus_uint32_t flags,
+ dbus_uint32_t *result,
+ BusTransaction *transaction,
+ DBusError *error)
+{
+ dbus_bool_t retval;
+ DBusConnection *old_owner_conn;
+ BusClientPolicy *policy;
+ BusService *service;
+ BusActivation *activation;
+ BusSELinuxID *sid;
+ BusOwner *primary_owner;
+
+ retval = FALSE;
+
+ if (!_dbus_validate_bus_name (service_name, 0,
+ _dbus_string_get_length (service_name)))
+ {
+ dbus_set_error (error, DBUS_ERROR_INVALID_ARGS,
+ "Requested bus name \"%s\" is not valid",
+ _dbus_string_get_const_data (service_name));
+
+ _dbus_verbose ("Attempt to acquire invalid service name\n");
+
+ goto out;
+ }
+
+ if (_dbus_string_get_byte (service_name, 0) == ':')
+ {
+ /* Not allowed; only base services can start with ':' */
+ dbus_set_error (error, DBUS_ERROR_INVALID_ARGS,
+ "Cannot acquire a service starting with ':' such as \"%s\"",
+ _dbus_string_get_const_data (service_name));
+
+ _dbus_verbose ("Attempt to acquire invalid base service name \"%s\"",
+ _dbus_string_get_const_data (service_name));
+
+ goto out;
+ }
+
+ if (_dbus_string_equal_c_str (service_name, DBUS_SERVICE_DBUS))
+ {
+ dbus_set_error (error, DBUS_ERROR_INVALID_ARGS,
+ "Connection \"%s\" is not allowed to own the service \"%s\"because "
+ "it is reserved for D-Bus' use only",
+ bus_connection_is_active (connection) ?
+ bus_connection_get_name (connection) :
+ "(inactive)",
+ DBUS_SERVICE_DBUS);
+ goto out;
+ }
+
+ policy = bus_connection_get_policy (connection);
+ _dbus_assert (policy != NULL);
+
+ /* Note that if sid is #NULL then the bus's own context gets used
+ * in bus_connection_selinux_allows_acquire_service()
+ */
+ sid = bus_selinux_id_table_lookup (registry->service_sid_table,
+ service_name);
+
+ if (!bus_selinux_allows_acquire_service (connection, sid,
+ _dbus_string_get_const_data (service_name), error))
+ {
+
+ if (dbus_error_is_set (error) &&
+ dbus_error_has_name (error, DBUS_ERROR_NO_MEMORY))
+ {
+ goto out;
+ }
+
+ dbus_set_error (error, DBUS_ERROR_ACCESS_DENIED,
+ "Connection \"%s\" is not allowed to own the service \"%s\" due "
+ "to SELinux policy",
+ bus_connection_is_active (connection) ?
+ bus_connection_get_name (connection) :
+ "(inactive)",
+ _dbus_string_get_const_data (service_name));
+ goto out;
+ }
+
+ if (!bus_client_policy_check_can_own (policy, service_name))
+ {
+ dbus_set_error (error, DBUS_ERROR_ACCESS_DENIED,
+ "Connection \"%s\" is not allowed to own the service \"%s\" due "
+ "to security policies in the configuration file",
+ bus_connection_is_active (connection) ?
+ bus_connection_get_name (connection) :
+ "(inactive)",
+ _dbus_string_get_const_data (service_name));
+ goto out;
+ }
+
+ if (bus_connection_get_n_services_owned (connection) >=
+ bus_context_get_max_services_per_connection (registry->context))
+ {
+ dbus_set_error (error, DBUS_ERROR_LIMITS_EXCEEDED,
+ "Connection \"%s\" is not allowed to own more services "
+ "(increase limits in configuration file if required)",
+ bus_connection_is_active (connection) ?
+ bus_connection_get_name (connection) :
+ "(inactive)");
+ goto out;
+ }
+
+ service = bus_registry_lookup (registry, service_name);
+
+ if (service != NULL)
+ {
+ primary_owner = bus_service_get_primary_owner (service);
+ if (primary_owner != NULL)
+ old_owner_conn = primary_owner->conn;
+ else
+ old_owner_conn = NULL;
+ }
+ else
+ old_owner_conn = NULL;
+
+ if (service == NULL)
+ {
+ service = bus_registry_ensure (registry,
+ service_name, connection, flags,
+ transaction, error);
+ if (service == NULL)
+ goto out;
+ }
+
+ primary_owner = bus_service_get_primary_owner (service);
+ if (primary_owner == NULL)
+ goto out;
+
+ if (old_owner_conn == NULL)
+ {
+ _dbus_assert (primary_owner->conn == connection);
+
+ *result = DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER;
+ }
+ else if (old_owner_conn == connection)
+ {
+ bus_owner_set_flags (primary_owner, flags);
+ *result = DBUS_REQUEST_NAME_REPLY_ALREADY_OWNER;
+ }
+ else if (((flags & DBUS_NAME_FLAG_DO_NOT_QUEUE) &&
+ !(bus_service_get_allow_replacement (service))) ||
+ ((flags & DBUS_NAME_FLAG_DO_NOT_QUEUE) &&
+ !(flags & DBUS_NAME_FLAG_REPLACE_EXISTING)))
+ {
+ DBusList *link;
+ BusOwner *temp_owner;
+ /* Since we can't be queued if we are already in the queue
+ remove us */
+
+ link = _bus_service_find_owner_link (service, connection);
+ if (link != NULL)
+ {
+ _dbus_list_unlink (&service->owners, link);
+ temp_owner = (BusOwner *)link->data;
+ bus_owner_unref (temp_owner);
+ _dbus_list_free_link (link);
+ }
+
+ *result = DBUS_REQUEST_NAME_REPLY_EXISTS;
+ }
+ else if (!(flags & DBUS_NAME_FLAG_DO_NOT_QUEUE) &&
+ (!(flags & DBUS_NAME_FLAG_REPLACE_EXISTING) ||
+ !(bus_service_get_allow_replacement (service))))
+ {
+ /* Queue the connection */
+ if (!bus_service_add_owner (service, connection,
+ flags,
+ transaction, error))
+ goto out;
+
+ *result = DBUS_REQUEST_NAME_REPLY_IN_QUEUE;
+ }
+ else
+ {
+ /* Replace the current owner */
+
+ /* We enqueue the new owner and remove the first one because
+ * that will cause NameAcquired and NameLost messages to
+ * be sent.
+ */
+
+ if (!bus_service_add_owner (service, connection,
+ flags,
+ transaction, error))
+ goto out;
+
+ if (primary_owner->do_not_queue)
+ {
+ if (!bus_service_remove_owner (service, old_owner_conn,
+ transaction, error))
+ goto out;
+ }
+ else
+ {
+ if (!bus_service_swap_owner (service, old_owner_conn,
+ transaction, error))
+ goto out;
+ }
+
+
+ _dbus_assert (connection == bus_service_get_primary_owner (service)->conn);
+ *result = DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER;
+ }
+
+ activation = bus_context_get_activation (registry->context);
+ retval = bus_activation_send_pending_auto_activation_messages (activation,
+ service,
+ transaction,
+ error);
+
+ out:
+ return retval;
+}
+
+#ifdef ENABLE_KDBUS_TRANSPORT
+dbus_bool_t
+bus_registry_acquire_kdbus_service (BusRegistry *registry,
+ DBusConnection *connection,
+ DBusMessage *message,
+ dbus_uint32_t *result,
+ BusTransaction *transaction,
+ DBusError *error)
+{
+ dbus_bool_t retval;
+ BusService *service;
+ BusActivation *activation;
+ DBusString service_name_real;
+ const DBusString *service_name = &service_name_real;
+ char* name;
+ dbus_uint32_t flags;
+ __u64 sender_id;
+ const char* conn_unique_name;
+ DBusConnection* phantom;
+ unsigned long int uid;
+
+ if (!dbus_message_get_args (message, error,
+ DBUS_TYPE_STRING, &name,
+ DBUS_TYPE_UINT32, &flags,
+ DBUS_TYPE_INVALID))
+ return FALSE;
+
+ retval = FALSE;
+
+ _dbus_string_init_const (&service_name_real, name);
+
+ if (!_dbus_validate_bus_name (service_name, 0,
+ _dbus_string_get_length (service_name)))
+ {
+ dbus_set_error (error, DBUS_ERROR_INVALID_ARGS,
+ "Requested bus name \"%s\" is not valid", name);
+
+ _dbus_verbose ("Attempt to acquire invalid service name\n");
+
+ return FALSE;
+ }
+
+ if (_dbus_string_get_byte (service_name, 0) == ':')
+ {
+ /* Not allowed; only base services can start with ':' */
+ dbus_set_error (error, DBUS_ERROR_INVALID_ARGS,
+ "Cannot acquire a service starting with ':' such as \"%s\"", name);
+
+ _dbus_verbose ("Attempt to acquire invalid base service name \"%s\"", name);
+
+ return FALSE;
+ }
+
+ conn_unique_name = dbus_message_get_sender(message);
+
+ if (_dbus_string_equal_c_str (service_name, DBUS_SERVICE_DBUS))
+ {
+ dbus_set_error (error, DBUS_ERROR_INVALID_ARGS,
+ "Connection \"%s\" is not allowed to own the service \"%s\"because "
+ "it is reserved for D-Bus' use only",
+ conn_unique_name, DBUS_SERVICE_DBUS);
+ return FALSE;
+ }
+
+ sender_id = sender_name_to_id(conn_unique_name, error);
+ if(dbus_error_is_set(error))
+ return FALSE;
+
+ phantom = bus_connections_find_conn_by_name(bus_connection_get_connections(connection), conn_unique_name);
+ if(phantom == NULL)
+ {
+ phantom = create_phantom_connection(connection, conn_unique_name, error);
+ if(phantom == NULL)
+ return FALSE;
+ }
+
+ if (!bus_client_policy_check_can_own (bus_connection_get_policy (phantom), service_name))
+ {
+ dbus_set_error (error, DBUS_ERROR_ACCESS_DENIED,
+ "Connection \"%s\" is not allowed to own the service \"%s\" due "
+ "to security policies in the configuration file", conn_unique_name, name);
+ goto failed;
+ }
+
+ if (!kdbus_connection_get_unix_user(phantom, conn_unique_name, &uid, NULL))
+ goto failed;
+
+#ifdef POLICY_TO_KDBUS
+ if (!register_kdbus_policy(name, dbus_connection_get_transport(phantom), uid))
+ {
+ dbus_set_error (error, DBUS_ERROR_ACCESS_DENIED,
+ "Kdbus error when setting policy for connection \"%s\" and service name \"%s\"",
+ conn_unique_name, name);
+ goto failed;
+ }
+#endif
+
+ *result = kdbus_request_name(connection, service_name, flags, sender_id);
+ if(*result == -EPERM)
+ {
+ dbus_set_error (error, DBUS_ERROR_ACCESS_DENIED,
+ "Kdbus not allowed %s to own the service \"%s\"",
+ conn_unique_name, _dbus_string_get_const_data (service_name));
+ goto failed;
+ }
+ else if(*result < 0)
+ {
+ dbus_set_error (error, DBUS_ERROR_FAILED , "Name \"%s\" could not be acquired", name);
+ goto failed;
+ }
+
+ if((*result == DBUS_REQUEST_NAME_REPLY_IN_QUEUE) || (*result == DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER))
+ {
+ service = bus_registry_lookup (registry, service_name);
+ if (service == NULL)
+ {
+ service = bus_registry_ensure (registry, service_name, phantom, flags,
+ transaction, error);
+ if (service == NULL)
+ goto failed2;
+ }
+ else
+ {
+ if (!bus_service_add_owner (service, phantom, flags, transaction, error))
+ goto failed2;
+ }
+
+ activation = bus_context_get_activation (registry->context);
+ retval = bus_activation_send_pending_auto_activation_messages (activation,
+ service,
+ transaction,
+ error);
+ }
+ else
+ retval = TRUE;
+
+ return retval;
+
+failed2:
+ kdbus_release_name(phantom, service_name, sender_id);
+failed:
+ bus_connection_disconnected(phantom);
+
+ return FALSE;
+}
+#endif
+
+dbus_bool_t
+bus_registry_release_service (BusRegistry *registry,
+ DBusConnection *connection,
+ const DBusString *service_name,
+ dbus_uint32_t *result,
+ BusTransaction *transaction,
+ DBusError *error)
+{
+ dbus_bool_t retval;
+ BusService *service;
+
+ retval = FALSE;
+
+ if (!_dbus_validate_bus_name (service_name, 0,
+ _dbus_string_get_length (service_name)))
+ {
+ dbus_set_error (error, DBUS_ERROR_INVALID_ARGS,
+ "Given bus name \"%s\" is not valid",
+ _dbus_string_get_const_data (service_name));
+
+ _dbus_verbose ("Attempt to release invalid service name\n");
+
+ goto out;
+ }
+
+ if (_dbus_string_get_byte (service_name, 0) == ':')
+ {
+ /* Not allowed; the base service name cannot be created or released */
+ dbus_set_error (error, DBUS_ERROR_INVALID_ARGS,
+ "Cannot release a service starting with ':' such as \"%s\"",
+ _dbus_string_get_const_data (service_name));
+
+ _dbus_verbose ("Attempt to release invalid base service name \"%s\"",
+ _dbus_string_get_const_data (service_name));
+
+ goto out;
+ }
+
+ if (_dbus_string_equal_c_str (service_name, DBUS_SERVICE_DBUS))
+ {
+ /* Not allowed; the base service name cannot be created or released */
+ dbus_set_error (error, DBUS_ERROR_INVALID_ARGS,
+ "Cannot release the %s service because it is owned by the bus",
+ DBUS_SERVICE_DBUS);
+
+ _dbus_verbose ("Attempt to release service name \"%s\"",
+ DBUS_SERVICE_DBUS);
+
+ goto out;
+ }
+
+ service = bus_registry_lookup (registry, service_name);
+
+ if (service == NULL)
+ {
+ *result = DBUS_RELEASE_NAME_REPLY_NON_EXISTENT;
+ }
+ else if (!bus_service_has_owner (service, connection))
+ {
+ *result = DBUS_RELEASE_NAME_REPLY_NOT_OWNER;
+ }
+ else
+ {
+ if (!bus_service_remove_owner (service, connection,
+ transaction, error))
+ goto out;
+
+ _dbus_assert (!bus_service_has_owner (service, connection));
+ *result = DBUS_RELEASE_NAME_REPLY_RELEASED;
+ }
+
+ retval = TRUE;
+
+ out:
+ return retval;
+}
+
+#ifdef ENABLE_KDBUS_TRANSPORT
+dbus_bool_t
+bus_registry_release_service_kdbus (const char* sender_name,
+ DBusConnection *connection,
+ const DBusString *service_name,
+ dbus_uint32_t *result,
+ BusTransaction *transaction,
+ DBusError *error)
+{
+ dbus_bool_t retval = FALSE;
+ __u64 sender_id;
+
+ if (!_dbus_validate_bus_name (service_name, 0,
+ _dbus_string_get_length (service_name)))
+ {
+ dbus_set_error (error, DBUS_ERROR_INVALID_ARGS,
+ "Given bus name \"%s\" is not valid",
+ _dbus_string_get_const_data (service_name));
+
+ _dbus_verbose ("Attempt to release invalid service name\n");
+
+ goto out;
+ }
+
+ if (_dbus_string_get_byte (service_name, 0) == ':')
+ {
+ /* Not allowed; the base service name cannot be created or released */
+ dbus_set_error (error, DBUS_ERROR_INVALID_ARGS,
+ "Cannot release a service starting with ':' such as \"%s\"",
+ _dbus_string_get_const_data (service_name));
+
+ _dbus_verbose ("Attempt to release invalid base service name \"%s\"",
+ _dbus_string_get_const_data (service_name));
+
+ goto out;
+ }
+
+ if (_dbus_string_equal_c_str (service_name, DBUS_SERVICE_DBUS))
+ {
+ /* Not allowed; the base service name cannot be created or released */
+ dbus_set_error (error, DBUS_ERROR_INVALID_ARGS,
+ "Cannot release the %s service because it is owned by the bus",
+ DBUS_SERVICE_DBUS);
+
+ _dbus_verbose ("Attempt to release service name \"%s\"",
+ DBUS_SERVICE_DBUS);
+
+ goto out;
+ }
+
+ sender_id = sender_name_to_id(sender_name, error);
+ if(dbus_error_is_set(error))
+ return FALSE;
+
+ *result = kdbus_release_name(connection, service_name, sender_id);
+
+ if(*result == DBUS_RELEASE_NAME_REPLY_RELEASED)
+ {
+ BusRegistry* registry;
+ BusService *service;
+
+ registry = bus_connection_get_registry (connection);
+ service = bus_registry_lookup (registry, service_name);
+ if(service)
+ {
+ DBusConnection* phantom;
+
+ phantom = _bus_service_find_owner_connection(service, sender_name);
+ if(phantom)
+ {
+ bus_service_remove_owner (service, phantom, transaction, NULL);
+ /* todo we could remove phantom if he doesn't own any name
+ * to do this we should write function in connection.c to check if
+ * _dbus_list_get_last (&d->services_owned) returns not NULL
+ * or we can leave phantom - he will be removed when he disconnects from the bus
+ */
+ }
+ else
+ _dbus_verbose ("Didn't find phantom connection for released name!\n");
+ }
+ }
+
+ retval = TRUE;
+
+ out:
+ return retval;
+}
+#endif
+
+dbus_bool_t
+bus_registry_set_service_context_table (BusRegistry *registry,
+ DBusHashTable *table)
+{
+ DBusHashTable *new_table;
+ DBusHashIter iter;
+
+ new_table = bus_selinux_id_table_new ();
+ if (!new_table)
+ return FALSE;
+
+ _dbus_hash_iter_init (table, &iter);
+ while (_dbus_hash_iter_next (&iter))
+ {
+ const char *service = _dbus_hash_iter_get_string_key (&iter);
+ const char *context = _dbus_hash_iter_get_value (&iter);
+
+ if (!bus_selinux_id_table_insert (new_table,
+ service,
+ context))
+ return FALSE;
+ }
+
+ if (registry->service_sid_table)
+ _dbus_hash_table_unref (registry->service_sid_table);
+ registry->service_sid_table = new_table;
+ return TRUE;
+}
+
+static void
+bus_service_unlink_owner (BusService *service,
+ BusOwner *owner)
+{
+ _dbus_list_remove_last (&service->owners, owner);
+ bus_owner_unref (owner);
+}
+
+static void
+bus_service_unlink (BusService *service)
+{
+ _dbus_assert (service->owners == NULL);
+
+ /* the service may not be in the hash, if
+ * the failure causing transaction cancel
+ * was in the right place, but that's OK
+ */
+ _dbus_hash_table_remove_string (service->registry->service_hash,
+ service->name);
+
+ bus_service_unref (service);
+}
+
+static void
+bus_service_relink (BusService *service,
+ DBusPreallocatedHash *preallocated)
+{
+ _dbus_assert (service->owners == NULL);
+ _dbus_assert (preallocated != NULL);
+
+ _dbus_hash_table_insert_string_preallocated (service->registry->service_hash,
+ preallocated,
+ service->name,
+ service);
+
+ bus_service_ref (service);
+}
+
+/**
+ * Data used to represent an ownership cancellation in
+ * a bus transaction.
+ */
+typedef struct
+{
+ BusOwner *owner; /**< the owner */
+ BusService *service; /**< service to cancel ownership of */
+} OwnershipCancelData;
+
+static void
+cancel_ownership (void *data)
+{
+ OwnershipCancelData *d = data;
+
+ /* We don't need to send messages notifying of these
+ * changes, since we're reverting something that was
+ * cancelled (effectively never really happened)
+ */
+ bus_service_unlink_owner (d->service, d->owner);
+
+ if (d->service->owners == NULL)
+ bus_service_unlink (d->service);
+}
+
+static void
+free_ownership_cancel_data (void *data)
+{
+ OwnershipCancelData *d = data;
+
+ dbus_connection_unref (d->owner->conn);
+ bus_owner_unref (d->owner);
+ bus_service_unref (d->service);
+
+ dbus_free (d);
+}
+
+static dbus_bool_t
+add_cancel_ownership_to_transaction (BusTransaction *transaction,
+ BusService *service,
+ BusOwner *owner)
+{
+ OwnershipCancelData *d;
+
+ d = dbus_new (OwnershipCancelData, 1);
+ if (d == NULL)
+ return FALSE;
+
+ d->service = service;
+ d->owner = owner;
+
+ if (!bus_transaction_add_cancel_hook (transaction, cancel_ownership, d,
+ free_ownership_cancel_data))
+ {
+ dbus_free (d);
+ return FALSE;
+ }
+
+ bus_service_ref (d->service);
+ bus_owner_ref (owner);
+ dbus_connection_ref (d->owner->conn);
+
+ return TRUE;
+}
+
+/* this function is self-cancelling if you cancel the transaction */
+dbus_bool_t