Package ch.bailu.gtk.gio

Klasse DBusAuthObserver

java.lang.Object
ch.bailu.gtk.type.Type
ch.bailu.gtk.type.Pointer
ch.bailu.gtk.gobject.Object
ch.bailu.gtk.type.PropertyHolder
ch.bailu.gtk.gio.DBusAuthObserver
Alle implementierten Schnittstellen:
PointerInterface
public class DBusAuthObserver extends PropertyHolder
`GDBusAuthObserver` provides a mechanism for participating
in how a [class@Gio.DBusServer] (or a [class@Gio.DBusConnection])
authenticates remote peers.

Simply instantiate a `GDBusAuthObserver` and connect to the
signals you are interested in. Note that new signals may be added
in the future.

## Controlling Authentication Mechanisms

By default, a `GDBusServer` or server-side `GDBusConnection` will allow
any authentication mechanism to be used. If you only want to allow D-Bus
connections with the `EXTERNAL` mechanism, which makes use of credentials
passing and is the recommended mechanism for modern Unix platforms such
as Linux and the BSD family, you would use a signal handler like this:

```c
static gboolean
on_allow_mechanism (GDBusAuthObserver *observer,
const gchar *mechanism,
gpointer user_data)
{
if (g_strcmp0 (mechanism, "EXTERNAL") == 0)
{
return TRUE;
}

return FALSE;
}
```

## Controlling Authorization

By default, a `GDBusServer` or server-side `GDBusConnection` will accept
connections from any successfully authenticated user (but not from
anonymous connections using the `ANONYMOUS` mechanism). If you only
want to allow D-Bus connections from processes owned by the same uid
as the server, since GLib 2.68, you should use the
`G_DBUS_SERVER_FLAGS_AUTHENTICATION_REQUIRE_SAME_USER` flag. It’s equivalent
to the following signal handler:

```c
static gboolean
on_authorize_authenticated_peer (GDBusAuthObserver *observer,
GIOStream *stream,
GCredentials *credentials,
gpointer user_data)
{
gboolean authorized;

authorized = FALSE;
if (credentials != NULL)
{
GCredentials *own_credentials;
own_credentials = g_credentials_new ();
if (g_credentials_is_same_user (credentials, own_credentials, NULL))
authorized = TRUE;
g_object_unref (own_credentials);
}

return authorized;
}
```

https://docs.gtk.org/gio/class.DBusAuthObserver.html

  • Felddetails

    • SIGNAL_ON_ALLOW_MECHANISM

      public static final String SIGNAL_ON_ALLOW_MECHANISM
      Siehe auch:

    • SIGNAL_ON_AUTHORIZE_AUTHENTICATED_PEER

      public static final String SIGNAL_ON_AUTHORIZE_AUTHENTICATED_PEER
      Siehe auch:

  • Konstruktordetails

    • DBusAuthObserver

      public DBusAuthObserver(PointerContainer pointer)

    • DBusAuthObserver

      public DBusAuthObserver()
      Creates a new #GDBusAuthObserver object.

  • Methodendetails

    • getClassHandler

      public static ClassHandler getClassHandler()

    • allowMechanism

      public boolean allowMechanism(@Nonnull Str mechanism)
      Emits the #GDBusAuthObserver::allow-mechanism signal on @observer.
      Parameter:
      mechanism - The name of the mechanism, e.g. `DBUS_COOKIE_SHA1`.
      Gibt zurück:
      %TRUE if @mechanism can be used to authenticate the other peer, %FALSE if not.

    • allowMechanism

      public boolean allowMechanism(String mechanism)
      Emits the #GDBusAuthObserver::allow-mechanism signal on @observer.
      Parameter:
      mechanism - The name of the mechanism, e.g. `DBUS_COOKIE_SHA1`.
      Gibt zurück:
      %TRUE if @mechanism can be used to authenticate the other peer, %FALSE if not.

    • authorizeAuthenticatedPeer

      public boolean authorizeAuthenticatedPeer(@Nonnull IOStream stream, @Nullable Credentials credentials)
      Emits the #GDBusAuthObserver::authorize-authenticated-peer signal on @observer.
      Parameter:
      stream - A #GIOStream for the #GDBusConnection.
      credentials - Credentials received from the peer or %NULL.
      Gibt zurück:
      %TRUE if the peer is authorized, %FALSE if not.

    • onAllowMechanism

      public SignalHandler onAllowMechanism(DBusAuthObserver.OnAllowMechanism signal)
      Connect to signal "allow-mechanism".
      See DBusAuthObserver.OnAllowMechanism.onAllowMechanism(ch.bailu.gtk.type.Str) for signal description.
      Field SIGNAL_ON_ALLOW_MECHANISM contains original signal name and can be used as resource reference.
      Parameter:
      signal - callback function (lambda).
      Gibt zurück:
      SignalHandler. Can be used to disconnect signal and to release callback function.

    • onAuthorizeAuthenticatedPeer

      public SignalHandler onAuthorizeAuthenticatedPeer(DBusAuthObserver.OnAuthorizeAuthenticatedPeer signal)
      Connect to signal "authorize-authenticated-peer".
      See DBusAuthObserver.OnAuthorizeAuthenticatedPeer.onAuthorizeAuthenticatedPeer(ch.bailu.gtk.gio.IOStream, ch.bailu.gtk.gio.Credentials) for signal description.
      Field SIGNAL_ON_AUTHORIZE_AUTHENTICATED_PEER contains original signal name and can be used as resource reference.
      Parameter:
      signal - callback function (lambda).
      Gibt zurück:
      SignalHandler. Can be used to disconnect signal and to release callback function.

    • getTypeID

      public static long getTypeID()

    • getParentTypeID

      public static long getParentTypeID()

    • getTypeSize

      public static TypeSystem.TypeSize getTypeSize()

    • getParentTypeSize

      public static TypeSystem.TypeSize getParentTypeSize()

    • getInstanceSize

      public static int getInstanceSize()