/**
* storaged_object_get_block_lvm2:
* @object: A #StoragedObject.
*
* Gets the #StoragedBlockLVM2 instance for the D-Bus interface <link linkend="gdbus-interface-org-storaged-Storaged-Block-LVM2.top_of_page">org.storaged.Storaged.Block.LVM2</link> on @object, if any.
*
* Returns: (transfer full): A #StoragedBlockLVM2 that must be freed with g_object_unref() or %NULL if @object does not implement the interface.
*/
StoragedBlockLVM2 *
storaged_object_get_block_lvm2 (StoragedObject *object)
{
GDBusInterface *ret;
ret = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.storaged.Storaged.Block.LVM2");
if (ret == NULL)
return NULL;
return STORAGED_BLOCK_LVM2 (ret);
}
/**
* storaged_object_get_physical_volume:
* @object: A #StoragedObject.
*
* Gets the #StoragedPhysicalVolume instance for the D-Bus interface <link linkend="gdbus-interface-org-storaged-Storaged-PhysicalVolume.top_of_page">org.storaged.Storaged.PhysicalVolume</link> on @object, if any.
*
* Returns: (transfer full): A #StoragedPhysicalVolume that must be freed with g_object_unref() or %NULL if @object does not implement the interface.
*/
StoragedPhysicalVolume *
storaged_object_get_physical_volume (StoragedObject *object)
{
GDBusInterface *ret;
ret = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.storaged.Storaged.PhysicalVolume");
if (ret == NULL)
return NULL;
return STORAGED_PHYSICAL_VOLUME (ret);
}
/**
* storaged_object_get_volume_group:
* @object: A #StoragedObject.
*
* Gets the #StoragedVolumeGroup instance for the D-Bus interface <link linkend="gdbus-interface-org-storaged-Storaged-VolumeGroup.top_of_page">org.storaged.Storaged.VolumeGroup</link> on @object, if any.
*
* Returns: (transfer full): A #StoragedVolumeGroup that must be freed with g_object_unref() or %NULL if @object does not implement the interface.
*/
StoragedVolumeGroup *
storaged_object_get_volume_group (StoragedObject *object)
{
GDBusInterface *ret;
ret = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.storaged.Storaged.VolumeGroup");
if (ret == NULL)
return NULL;
return STORAGED_VOLUME_GROUP (ret);
}
void
storage_daemon_publish (StorageDaemon *self,
const gchar *path,
gboolean uniquely,
gpointer thing)
{
GDBusInterface *prev;
GDBusInterfaceInfo *info;
GDBusObjectSkeleton *object;
GQuark detail;
g_return_if_fail (STORAGE_IS_DAEMON (self));
g_return_if_fail (path != NULL);
if (G_IS_DBUS_INTERFACE (thing))
{
g_debug ("%spublishing iface: %s %s", uniquely ? "uniquely " : "", path,
g_dbus_interface_get_info(thing)->name);
object = G_DBUS_OBJECT_SKELETON (g_dbus_object_manager_get_object (G_DBUS_OBJECT_MANAGER (self->object_manager), path));
if (object != NULL)
{
if (uniquely)
{
info = g_dbus_interface_get_info (thing);
prev = g_dbus_object_get_interface (G_DBUS_OBJECT (object), info->name);
if (prev)
{
g_object_unref (prev);
g_object_unref (object);
object = NULL;
}
}
}
if (object == NULL)
object = g_dbus_object_skeleton_new (path);
g_dbus_object_skeleton_add_interface (object, thing);
}
else
{
g_critical ("Unsupported type to publish: %s", G_OBJECT_TYPE_NAME (thing));
return;
}
if (uniquely)
g_dbus_object_manager_server_export_uniquely (self->object_manager, object);
else
g_dbus_object_manager_server_export (self->object_manager, object);
detail = g_quark_from_static_string (G_OBJECT_TYPE_NAME (thing));
g_signal_emit (self, signals[PUBLISHED], detail, thing);
g_object_unref (object);
}
/**
* storaged_object_peek_logical_volume: (skip)
* @object: A #StoragedObject.
*
* Like storaged_object_get_logical_volume() but doesn't increase the reference count on the returned object.
*
* <warning>It is not safe to use the returned object if you are on another thread than the one where the #GDBusObjectManagerClient or #GDBusObjectManagerServer for @object is running.</warning>
*
* Returns: (transfer none): A #StoragedLogicalVolume or %NULL if @object does not implement the interface. Do not free the returned object, it is owned by @object.
*/
StoragedLogicalVolume *
storaged_object_peek_logical_volume (StoragedObject *object)
{
GDBusInterface *ret;
ret = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.storaged.Storaged.LogicalVolume");
if (ret == NULL)
return NULL;
g_object_unref (ret);
return STORAGED_LOGICAL_VOLUME (ret);
}
static bool uninstall_application(GDBusObjectManager* installed,
const char* appid)
{
GList* objects = g_dbus_object_manager_get_objects(installed);
GList* l;
bool ret = false;
for (l = objects; l; l = l->next) {
GDBusObject* object = l->data;
GDBusInterface* iface = g_dbus_object_get_interface(
object,
xwalk_installed_app_iface);
if (!iface)
continue;
GDBusProxy* proxy = G_DBUS_PROXY(iface);
GVariant* value = g_dbus_proxy_get_cached_property(proxy, "AppID");
if (!value) {
g_object_unref(iface);
continue;
}
const char* id;
g_variant_get(value, "s", &id);
if (g_strcmp0(appid, id)) {
g_object_unref(iface);
continue;
}
GError* error = NULL;
GVariant* result = g_dbus_proxy_call_sync(proxy, "Uninstall", NULL,
G_DBUS_CALL_FLAGS_NONE,
-1, NULL, &error);
if (!result) {
g_print("Uninstalling application failed: %s\n", error->message);
g_error_free(error);
g_object_unref(iface);
ret = false;
goto done;
}
g_object_unref(iface);
ret = true;
goto done;
}
g_print("Application ID '%s' could not be found\n", appid);
done:
g_list_free_full(objects, g_object_unref);
return ret;
}
static gboolean
is_realm_with_kerberos_and_membership (gpointer object)
{
GDBusInterface *interface;
if (!G_IS_DBUS_OBJECT (object))
return FALSE;
interface = g_dbus_object_get_interface (object, "org.freedesktop.realmd.Kerberos");
if (interface == NULL)
return FALSE;
g_object_unref (interface);
interface = g_dbus_object_get_interface (object, "org.freedesktop.realmd.KerberosMembership");
if (interface == NULL)
return FALSE;
g_object_unref (interface);
return TRUE;
}
GList *
storage_daemon_get_jobs (StorageDaemon *self)
{
GList *objects, *l;
GList *jobs = NULL;
objects = g_dbus_object_manager_get_objects (G_DBUS_OBJECT_MANAGER (self->object_manager));
for (l = objects; l != NULL; l = g_list_next (l))
{
StorageJob *job = STORAGE_JOB (g_dbus_object_get_interface (l->data, "org.freedesktop.UDisks2.Job"));
if (job)
jobs = g_list_prepend (jobs, job);
}
g_list_free_full (objects, g_object_unref);
return jobs;
}
static GDBusInterface *
cockpit_fake_manager_get_interface (GDBusObjectManager *manager,
const gchar *object_path,
const gchar *interface_name)
{
GDBusInterface *interface;
GDBusObject *object;
object = cockpit_fake_manager_get_object (manager, object_path);
if (object == NULL)
return NULL;
interface = g_dbus_object_get_interface (object, interface_name);
g_object_unref (object);
return interface;
}
static void
do_list_remote ()
{
GDBusObjectManager *object_manager;
UsbemuDBusManager *manager;
GError *error = NULL;
const gchar * const *list;
const gchar * const *path;
usbip_dbus_init (opt_list_remote_path, &object_manager, &manager);
list = usbemu_dbus_manager_get_devices (manager);
if (list == NULL || *list == NULL) {
g_print ("no exportable devices found on %s\n",
opt_list_remote_path ? opt_list_remote_path : "(local)");
return;
}
g_print ("Exportable USB devices\n");
g_print ("======================\n");
g_print (" - %s\n\n", opt_list_remote_path ? opt_list_remote_path : "(local)");
path = list;
while (*path) {
GDBusObject *device_object;
UsbemuDBusDevice *device;
device_object = g_dbus_object_manager_get_object (object_manager, *path);
device =
USBEMU_DBUS_DEVICE (g_dbus_object_get_interface (device_object,
USBEMU_DBUS_DEVICE_PREFIX));
g_object_unref (device_object);
g_print ("%s\n", *path);
g_print ("\n");
g_object_unref (device);
++path;
}
g_object_unref (manager);
g_object_unref (object_manager);
}
static GDBusInterface *
g_dbus_object_manager_server_get_interface (GDBusObjectManager *_manager,
const gchar *object_path,
const gchar *interface_name)
{
GDBusInterface *ret;
GDBusObject *object;
ret = NULL;
object = g_dbus_object_manager_get_object (_manager, object_path);
if (object == NULL)
goto out;
ret = g_dbus_object_get_interface (object, interface_name);
g_object_unref (object);
out:
return ret;
}
static void list_applications(GDBusObjectManager* installed) {
GList* objects = g_dbus_object_manager_get_objects(installed);
GList* l;
for (l = objects; l; l = l->next) {
GDBusObject* object = l->data;
GDBusInterface* iface = g_dbus_object_get_interface(
object,
xwalk_installed_app_iface);
if (!iface)
continue;
GDBusProxy* proxy = G_DBUS_PROXY(iface);
GVariant* id_variant;
id_variant = g_dbus_proxy_get_cached_property(proxy, "AppID");
if (!id_variant) {
g_object_unref(iface);
continue;
}
const char* id;
g_variant_get(id_variant, "s", &id);
GVariant* name_variant;
name_variant = g_dbus_proxy_get_cached_property(proxy, "Name");
if (!name_variant) {
g_object_unref(iface);
continue;
}
const char* name;
g_variant_get(name_variant, "s", &name);
g_print("%s\t%s\n", id, name);
g_object_unref(iface);
}
g_list_free_full(objects, g_object_unref);
}
static gboolean
update_iface (StoragedObject *object,
const gchar *uevent_action,
StoragedObjectHasInterfaceFunc has_func,
StoragedObjectConnectInterfaceFunc connect_func,
StoragedObjectUpdateInterfaceFunc update_func,
GType skeleton_type,
gpointer _interface_pointer)
{
gboolean ret = FALSE;
gboolean has;
gboolean add;
GDBusInterface **interface_pointer = _interface_pointer;
GDBusInterfaceInfo *interface_info = NULL;
g_return_val_if_fail (object != NULL, FALSE);
g_return_val_if_fail (has_func != NULL, FALSE);
g_return_val_if_fail (update_func != NULL, FALSE);
g_return_val_if_fail (g_type_is_a (skeleton_type, G_TYPE_OBJECT), FALSE);
g_return_val_if_fail (g_type_is_a (skeleton_type, G_TYPE_DBUS_INTERFACE), FALSE);
g_return_val_if_fail (interface_pointer != NULL, FALSE);
g_return_val_if_fail (*interface_pointer == NULL || G_IS_DBUS_INTERFACE (*interface_pointer), FALSE);
add = FALSE;
has = has_func (object);
if (*interface_pointer == NULL)
{
if (has)
{
*interface_pointer = g_object_new (skeleton_type, NULL);
if (connect_func != NULL)
connect_func (object);
add = TRUE;
}
}
else
{
if (!has)
{
/* Check before we remove interface from object */
interface_info = g_dbus_interface_get_info (*interface_pointer);
if (g_dbus_object_get_interface ((GDBusObject *) object,
interface_info->name))
g_dbus_object_skeleton_remove_interface
(G_DBUS_OBJECT_SKELETON (object),
G_DBUS_INTERFACE_SKELETON (*interface_pointer));
g_object_unref (*interface_pointer);
*interface_pointer = NULL;
}
}
if (*interface_pointer != NULL)
{
if (update_func (object, uevent_action, G_DBUS_INTERFACE (*interface_pointer)))
ret = TRUE;
if (add)
g_dbus_object_skeleton_add_interface (G_DBUS_OBJECT_SKELETON (object),
G_DBUS_INTERFACE_SKELETON (*interface_pointer));
}
return ret;
}
/*
* the DBus.Tracker.Properties1 interface returns a list of strings
* where each selected item brings up both its URI and its Caja
* mime type.
*
* We return to the caller a GList of NASelectedInfo objects
*/
static GList *
targets_from_selection( void )
{
static const gchar *thisfn = "caja_actions_run_targets_from_selection";
GList *selection;
GError *error;
gchar **paths;
g_debug( "%s", thisfn );
selection = NULL;
error = NULL;
paths = NULL;
#ifdef HAVE_GDBUS
GDBusObjectManager *manager;
gchar *name_owner;
GDBusObject *object;
GDBusInterface *iface;
manager = na_tracker_object_manager_client_new_for_bus_sync(
G_BUS_TYPE_SESSION,
G_DBUS_OBJECT_MANAGER_CLIENT_FLAGS_NONE,
CAJA_ACTIONS_DBUS_SERVICE,
CAJA_ACTIONS_DBUS_TRACKER_PATH,
NULL,
&error );
if( !manager ){
g_printerr( "%s: unable to allocate an ObjectManagerClient: %s\n", thisfn, error->message );
g_error_free( error );
return( NULL );
}
name_owner = g_dbus_object_manager_client_get_name_owner( G_DBUS_OBJECT_MANAGER_CLIENT( manager ));
g_debug( "%s: name_owner=%s", thisfn, name_owner );
g_free( name_owner );
object = g_dbus_object_manager_get_object( manager, CAJA_ACTIONS_DBUS_TRACKER_PATH "/0" );
if( !object ){
g_printerr( "%s: unable to get object at %s path\n", thisfn, CAJA_ACTIONS_DBUS_TRACKER_PATH "/0" );
g_object_unref( manager );
return( NULL );
}
iface = g_dbus_object_get_interface( object, CAJA_ACTIONS_DBUS_TRACKER_IFACE );
if( !iface ){
g_printerr( "%s: unable to get %s interface\n", thisfn, CAJA_ACTIONS_DBUS_TRACKER_IFACE );
g_object_unref( object );
g_object_unref( manager );
return( NULL );
}
/* note that @iface is really a GDBusProxy instance
* and additionally also a NATrackerProperties1 instance
*/
na_tracker_properties1_call_get_selected_paths_sync(
NA_TRACKER_PROPERTIES1( iface ),
&paths,
NULL,
&error );
#else
# ifdef HAVE_DBUS_GLIB
DBusGConnection *connection;
DBusGProxy *proxy = NULL;
connection = dbus_g_bus_get( DBUS_BUS_SESSION, &error );
if( !connection ){
if( error ){
g_printerr( _( "Error: unable to get a connection to session DBus: %s" ), error->message );
g_error_free( error );
}
return( NULL );
}
g_debug( "%s: connection is ok", thisfn );
proxy = dbus_g_proxy_new_for_name( connection,
CAJA_ACTIONS_DBUS_SERVICE,
CAJA_ACTIONS_DBUS_TRACKER_PATH "/0",
CAJA_ACTIONS_DBUS_TRACKER_IFACE );
if( !proxy ){
g_printerr( _( "Error: unable to get a proxy on %s service" ), CAJA_ACTIONS_DBUS_SERVICE );
dbus_g_connection_unref( connection );
return( NULL );
}
g_debug( "%s: proxy is ok", thisfn );
if( !dbus_g_proxy_call( proxy, "GetSelectedPaths", &error,
G_TYPE_INVALID,
G_TYPE_STRV, &paths, G_TYPE_INVALID )){
g_printerr( _( "Error on GetSelectedPaths call: %s" ), error->message );
g_error_free( error );
/* TODO: unref proxy */
dbus_g_connection_unref( connection );
return( NULL );
}
g_debug( "%s: function call is ok", thisfn );
/* TODO: unref proxy */
dbus_g_connection_unref( connection );
# endif
#endif
selection = get_selection_from_strv(( const gchar ** ) paths, TRUE );
g_strfreev( paths );
return( selection );
}
