## EggDBusBus EggDBusBus — Message bus daemon interface |

## Synopsis

                        EggDBusBus;
                        EggDBusBusIface;
    #define             EGG_DBUS_QUERY_INTERFACE_BUS        (object_proxy)
    enum                EggDBusRequestNameFlags;
    enum                EggDBusRequestNameReply;
    enum                EggDBusReleaseNameReply;
    enum                EggDBusStartServiceByNameReply;
    gboolean            egg_dbus_bus_hello_sync             (EggDBusBus *instance,
                                                             EggDBusCallFlags call_flags,
                                                             gchar **out_assigned_name,
                                                             GCancellable *cancellable,
                                                             GError **error);
    gboolean            egg_dbus_bus_request_name_sync      (EggDBusBus *instance,
                                                             EggDBusCallFlags call_flags,
                                                             const gchar *name,
                                                             EggDBusRequestNameFlags flags,
                                                             EggDBusRequestNameReply *out_value,
                                                             GCancellable *cancellable,
                                                             GError **error);
    gboolean            egg_dbus_bus_release_name_sync      (EggDBusBus *instance,
                                                             EggDBusCallFlags call_flags,
                                                             const gchar *name,
                                                             EggDBusReleaseNameReply *out_value,
                                                             GCancellable *cancellable,
                                                             GError **error);
    gboolean            egg_dbus_bus_start_service_by_name_sync
                                                            (EggDBusBus *instance,
                                                             EggDBusCallFlags call_flags,
                                                             const gchar *name,
                                                             guint flags,
                                                             EggDBusStartServiceByNameReply *out_value,
                                                             GCancellable *cancellable,
                                                             GError **error);
    gboolean            egg_dbus_bus_update_activation_environment_sync
                                                            (EggDBusBus *instance,
                                                             EggDBusCallFlags call_flags,
                                                             EggDBusHashMap *env_hash,
                                                             GCancellable *cancellable,
                                                             GError **error);
    gboolean            egg_dbus_bus_name_has_owner_sync    (EggDBusBus *instance,
                                                             EggDBusCallFlags call_flags,
                                                             const gchar *name,
                                                             gboolean *out_has_owner,
                                                             GCancellable *cancellable,
                                                             GError **error);
    gboolean            egg_dbus_bus_list_names_sync        (EggDBusBus *instance,
                                                             EggDBusCallFlags call_flags,
                                                             gchar ***out_names,
                                                             GCancellable *cancellable,
                                                             GError **error);
    gboolean            egg_dbus_bus_list_activatable_names_sync
                                                            (EggDBusBus *instance,
                                                             EggDBusCallFlags call_flags,
                                                             gchar ***out_activatable_names,
                                                             GCancellable *cancellable,
                                                             GError **error);
    gboolean            egg_dbus_bus_add_match_sync         (EggDBusBus *instance,
                                                             EggDBusCallFlags call_flags,
                                                             const gchar *rule,
                                                             GCancellable *cancellable,
                                                             GError **error);
    gboolean            egg_dbus_bus_remove_match_sync      (EggDBusBus *instance,
                                                             EggDBusCallFlags call_flags,
                                                             const gchar *rule,
                                                             GCancellable *cancellable,
                                                             GError **error);
    gboolean            egg_dbus_bus_get_name_owner_sync    (EggDBusBus *instance,
                                                             EggDBusCallFlags call_flags,
                                                             const gchar *name,
                                                             gchar **out_unique_name,
                                                             GCancellable *cancellable,
                                                             GError **error);
    gboolean            egg_dbus_bus_list_queued_owners_sync
                                                            (EggDBusBus *instance,
                                                             EggDBusCallFlags call_flags,
                                                             const gchar *name,
                                                             gchar ***out_queued_owners,
                                                             GCancellable *cancellable,
                                                             GError **error);
    gboolean            egg_dbus_bus_get_connection_unix_user_sync
                                                            (EggDBusBus *instance,
                                                             EggDBusCallFlags call_flags,
                                                             const gchar *name,
                                                             uid_t *out_uid,
                                                             GCancellable *cancellable,
                                                             GError **error);
    gboolean            egg_dbus_bus_get_connection_unix_process_id_sync
                                                            (EggDBusBus *instance,
                                                             EggDBusCallFlags call_flags,
                                                             const gchar *name,
                                                             pid_t *out_pid,
                                                             GCancellable *cancellable,
                                                             GError **error);
    gboolean            egg_dbus_bus_get_adt_audit_session_data_sync
                                                            (EggDBusBus *instance,
                                                             EggDBusCallFlags call_flags,
                                                             const gchar *name,
                                                             EggDBusArraySeq **out_data,
                                                             GCancellable *cancellable,
                                                             GError **error);
    gboolean            egg_dbus_bus_get_connection_se_linux_security_context_sync
                                                            (EggDBusBus *instance,
                                                             EggDBusCallFlags call_flags,
                                                             const gchar *name,
                                                             EggDBusArraySeq **out_security_context,
                                                             GCancellable *cancellable,
                                                             GError **error);
    gboolean            egg_dbus_bus_reload_config_sync     (EggDBusBus *instance,
                                                             EggDBusCallFlags call_flags,
                                                             GCancellable *cancellable,
                                                             GError **error);
    gboolean            egg_dbus_bus_get_id_sync            (EggDBusBus *instance,
                                                             EggDBusCallFlags call_flags,
                                                             gchar **out_unique_id,
                                                             GCancellable *cancellable,
                                                             GError **error);
    guint               egg_dbus_bus_hello                  (EggDBusBus *instance,
                                                             EggDBusCallFlags call_flags,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);
    gboolean            egg_dbus_bus_hello_finish           (EggDBusBus *instance,
                                                             gchar **out_assigned_name,
                                                             GAsyncResult *res,
                                                             GError **error);
    guint               egg_dbus_bus_request_name           (EggDBusBus *instance,
                                                             EggDBusCallFlags call_flags,
                                                             const gchar *name,
                                                             EggDBusRequestNameFlags flags,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);
    gboolean            egg_dbus_bus_request_name_finish    (EggDBusBus *instance,
                                                             EggDBusRequestNameReply *out_value,
                                                             GAsyncResult *res,
                                                             GError **error);
    guint               egg_dbus_bus_release_name           (EggDBusBus *instance,
                                                             EggDBusCallFlags call_flags,
                                                             const gchar *name,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);
    gboolean            egg_dbus_bus_release_name_finish    (EggDBusBus *instance,
                                                             EggDBusReleaseNameReply *out_value,
                                                             GAsyncResult *res,
                                                             GError **error);
    guint               egg_dbus_bus_start_service_by_name  (EggDBusBus *instance,
                                                             EggDBusCallFlags call_flags,
                                                             const gchar *name,
                                                             guint flags,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);
    gboolean            egg_dbus_bus_start_service_by_name_finish
                                                            (EggDBusBus *instance,
                                                             EggDBusStartServiceByNameReply *out_value,
                                                             GAsyncResult *res,
                                                             GError **error);
    guint               egg_dbus_bus_update_activation_environment
                                                            (EggDBusBus *instance,
                                                             EggDBusCallFlags call_flags,
                                                             EggDBusHashMap *env_hash,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);
    gboolean            egg_dbus_bus_update_activation_environment_finish
                                                            (EggDBusBus *instance,
                                                             GAsyncResult *res,
                                                             GError **error);
    guint               egg_dbus_bus_name_has_owner         (EggDBusBus *instance,
                                                             EggDBusCallFlags call_flags,
                                                             const gchar *name,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);
    gboolean            egg_dbus_bus_name_has_owner_finish  (EggDBusBus *instance,
                                                             gboolean *out_has_owner,
                                                             GAsyncResult *res,
                                                             GError **error);
    guint               egg_dbus_bus_list_names             (EggDBusBus *instance,
                                                             EggDBusCallFlags call_flags,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);
    gboolean            egg_dbus_bus_list_names_finish      (EggDBusBus *instance,
                                                             gchar ***out_names,
                                                             GAsyncResult *res,
                                                             GError **error);
    guint               egg_dbus_bus_list_activatable_names (EggDBusBus *instance,
                                                             EggDBusCallFlags call_flags,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);
    gboolean            egg_dbus_bus_list_activatable_names_finish
                                                            (EggDBusBus *instance,
                                                             gchar ***out_activatable_names,
                                                             GAsyncResult *res,
                                                             GError **error);
    guint               egg_dbus_bus_add_match              (EggDBusBus *instance,
                                                             EggDBusCallFlags call_flags,
                                                             const gchar *rule,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);
    gboolean            egg_dbus_bus_add_match_finish       (EggDBusBus *instance,
                                                             GAsyncResult *res,
                                                             GError **error);
    guint               egg_dbus_bus_remove_match           (EggDBusBus *instance,
                                                             EggDBusCallFlags call_flags,
                                                             const gchar *rule,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);
    gboolean            egg_dbus_bus_remove_match_finish    (EggDBusBus *instance,
                                                             GAsyncResult *res,
                                                             GError **error);
    guint               egg_dbus_bus_get_name_owner         (EggDBusBus *instance,
                                                             EggDBusCallFlags call_flags,
                                                             const gchar *name,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);
    gboolean            egg_dbus_bus_get_name_owner_finish  (EggDBusBus *instance,
                                                             gchar **out_unique_name,
                                                             GAsyncResult *res,
                                                             GError **error);
    guint               egg_dbus_bus_list_queued_owners     (EggDBusBus *instance,
                                                             EggDBusCallFlags call_flags,
                                                             const gchar *name,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);
    gboolean            egg_dbus_bus_list_queued_owners_finish
                                                            (EggDBusBus *instance,
                                                             gchar ***out_queued_owners,
                                                             GAsyncResult *res,
                                                             GError **error);
    guint               egg_dbus_bus_get_connection_unix_user
                                                            (EggDBusBus *instance,
                                                             EggDBusCallFlags call_flags,
                                                             const gchar *name,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);
    gboolean            egg_dbus_bus_get_connection_unix_user_finish
                                                            (EggDBusBus *instance,
                                                             uid_t *out_uid,
                                                             GAsyncResult *res,
                                                             GError **error);
    guint               egg_dbus_bus_get_connection_unix_process_id
                                                            (EggDBusBus *instance,
                                                             EggDBusCallFlags call_flags,
                                                             const gchar *name,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);
    gboolean            egg_dbus_bus_get_connection_unix_process_id_finish
                                                            (EggDBusBus *instance,
                                                             pid_t *out_pid,
                                                             GAsyncResult *res,
                                                             GError **error);
    guint               egg_dbus_bus_get_adt_audit_session_data
                                                            (EggDBusBus *instance,
                                                             EggDBusCallFlags call_flags,
                                                             const gchar *name,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);
    gboolean            egg_dbus_bus_get_adt_audit_session_data_finish
                                                            (EggDBusBus *instance,
                                                             EggDBusArraySeq **out_data,
                                                             GAsyncResult *res,
                                                             GError **error);
    guint               egg_dbus_bus_get_connection_se_linux_security_context
                                                            (EggDBusBus *instance,
                                                             EggDBusCallFlags call_flags,
                                                             const gchar *name,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);
    gboolean            egg_dbus_bus_get_connection_se_linux_security_context_finish
                                                            (EggDBusBus *instance,
                                                             EggDBusArraySeq **out_security_context,
                                                             GAsyncResult *res,
                                                             GError **error);
    guint               egg_dbus_bus_reload_config          (EggDBusBus *instance,
                                                             EggDBusCallFlags call_flags,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);
    gboolean            egg_dbus_bus_reload_config_finish   (EggDBusBus *instance,
                                                             GAsyncResult *res,
                                                             GError **error);
    guint               egg_dbus_bus_get_id                 (EggDBusBus *instance,
                                                             EggDBusCallFlags call_flags,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);
    gboolean            egg_dbus_bus_get_id_finish          (EggDBusBus *instance,
                                                             gchar **out_unique_id,
                                                             GAsyncResult *res,
                                                             GError **error);
    void                egg_dbus_bus_handle_hello_finish    (EggDBusMethodInvocation *method_invocation,
                                                             const gchar *out_assigned_name);
    void                egg_dbus_bus_handle_request_name_finish
                                                            (EggDBusMethodInvocation *method_invocation,
                                                             EggDBusRequestNameReply out_value);
    void                egg_dbus_bus_handle_release_name_finish
                                                            (EggDBusMethodInvocation *method_invocation,
                                                             EggDBusReleaseNameReply out_value);
    void                egg_dbus_bus_handle_start_service_by_name_finish
                                                            (EggDBusMethodInvocation *method_invocation,
                                                             EggDBusStartServiceByNameReply out_value);
    void                egg_dbus_bus_handle_update_activation_environment_finish
                                                            (EggDBusMethodInvocation *method_invocation);
    void                egg_dbus_bus_handle_name_has_owner_finish
                                                            (EggDBusMethodInvocation *method_invocation,
                                                             gboolean out_has_owner);
    void                egg_dbus_bus_handle_list_names_finish
                                                            (EggDBusMethodInvocation *method_invocation,
                                                             gchar **out_names);
    void                egg_dbus_bus_handle_list_activatable_names_finish
                                                            (EggDBusMethodInvocation *method_invocation,
                                                             gchar **out_activatable_names);
    void                egg_dbus_bus_handle_add_match_finish
                                                            (EggDBusMethodInvocation *method_invocation);
    void                egg_dbus_bus_handle_remove_match_finish
                                                            (EggDBusMethodInvocation *method_invocation);
    void                egg_dbus_bus_handle_get_name_owner_finish
                                                            (EggDBusMethodInvocation *method_invocation,
                                                             const gchar *out_unique_name);
    void                egg_dbus_bus_handle_list_queued_owners_finish
                                                            (EggDBusMethodInvocation *method_invocation,
                                                             gchar **out_queued_owners);
    void                egg_dbus_bus_handle_get_connection_unix_user_finish
                                                            (EggDBusMethodInvocation *method_invocation,
                                                             uid_t out_uid);
    void                egg_dbus_bus_handle_get_connection_unix_process_id_finish
                                                            (EggDBusMethodInvocation *method_invocation,
                                                             pid_t out_pid);
    void                egg_dbus_bus_handle_get_adt_audit_session_data_finish
                                                            (EggDBusMethodInvocation *method_invocation,
                                                             EggDBusArraySeq *out_data);
    void                egg_dbus_bus_handle_get_connection_se_linux_security_context_finish
                                                            (EggDBusMethodInvocation *method_invocation,
                                                             EggDBusArraySeq *out_security_context);
    void                egg_dbus_bus_handle_reload_config_finish
                                                            (EggDBusMethodInvocation *method_invocation);
    void                egg_dbus_bus_handle_get_id_finish   (EggDBusMethodInvocation *method_invocation,
                                                             const gchar *out_unique_id);
    void                egg_dbus_bus_emit_signal_name_owner_changed
                                                            (EggDBusBus *instance,
                                                             const gchar *destination,
                                                             const gchar *name,
                                                             const gchar *old_owner,
                                                             const gchar *new_owner);
    void                egg_dbus_bus_emit_signal_name_lost  (EggDBusBus *instance,
                                                             const gchar *destination,
                                                             const gchar *name);
    void                egg_dbus_bus_emit_signal_name_acquired
                                                            (EggDBusBus *instance,
                                                             const gchar *destination,
                                                             const gchar *name);

## Object Hierarchy

      GInterface
       +----EggDBusBus

## Prerequisites

EggDBusBus requires GObject.

## Signals

      "name-acquired"                                  : Run Last
      "name-lost"                                      : Run Last
      "name-owner-changed"                             : Run Last

## Description

The EggDBusBus D-Bus interface is implemented by message bus daemons. Normally applications only use the `egg_dbus_bus_request_name()` method to claim a well-known name on the message bus.

## Details

### EggDBusBus

    typedef struct _EggDBusBus EggDBusBus;

### EggDBusBusIface

    typedef struct {
      EggDBusInterfaceIface g_iface;

      void (* handle_hello) (
          EggDBusBus *instance,
          EggDBusMethodInvocation *method_invocation);

      void (* handle_request_name) (
          EggDBusBus *instance,
          const gchar *name,
          EggDBusRequestNameFlags flags,
          EggDBusMethodInvocation *method_invocation);

      void (* handle_release_name) (
          EggDBusBus *instance,
          const gchar *name,
          EggDBusMethodInvocation *method_invocation);

      void (* handle_start_service_by_name) (
          EggDBusBus *instance,
          const gchar *name,
          guint flags,
          EggDBusMethodInvocation *method_invocation);

      void (* handle_update_activation_environment) (
          EggDBusBus *instance,
          EggDBusHashMap *env_hash,
          EggDBusMethodInvocation *method_invocation);

      void (* handle_name_has_owner) (
          EggDBusBus *instance,
          const gchar *name,
          EggDBusMethodInvocation *method_invocation);

      void (* handle_list_names) (
          EggDBusBus *instance,
          EggDBusMethodInvocation *method_invocation);

      void (* handle_list_activatable_names) (
          EggDBusBus *instance,
          EggDBusMethodInvocation *method_invocation);

      void (* handle_add_match) (
          EggDBusBus *instance,
          const gchar *rule,
          EggDBusMethodInvocation *method_invocation);

      void (* handle_remove_match) (
          EggDBusBus *instance,
          const gchar *rule,
          EggDBusMethodInvocation *method_invocation);

      void (* handle_get_name_owner) (
          EggDBusBus *instance,
          const gchar *name,
          EggDBusMethodInvocation *method_invocation);

      void (* handle_list_queued_owners) (
          EggDBusBus *instance,
          const gchar *name,
          EggDBusMethodInvocation *method_invocation);

      void (* handle_get_connection_unix_user) (
          EggDBusBus *instance,
          const gchar *name,
          EggDBusMethodInvocation *method_invocation);

      void (* handle_get_connection_unix_process_id) (
          EggDBusBus *instance,
          const gchar *name,
          EggDBusMethodInvocation *method_invocation);

      void (* handle_get_adt_audit_session_data) (
          EggDBusBus *instance,
          const gchar *name,
          EggDBusMethodInvocation *method_invocation);

      void (* handle_get_connection_se_linux_security_context) (
          EggDBusBus *instance,
          const gchar *name,
          EggDBusMethodInvocation *method_invocation);

      void (* handle_reload_config) (
          EggDBusBus *instance,
          EggDBusMethodInvocation *method_invocation);

      void (* handle_get_id) (
          EggDBusBus *instance,
          EggDBusMethodInvocation *method_invocation);
    } EggDBusBusIface;

Interface VTable for implementing the org.freedesktop.DBus D-Bus interface.

EggDBusInterfaceIface `g_iface`; | The parent interface.
`handle_hello` () | Before an application is able to send messages to other applications it must invoke this method on the message bus to obtain a unique name. If an application without a unique name tries to send a message to another application, or a message to the message bus itself that isn't the `egg_dbus_bus_hello()` method, it will be disconnected from the bus. There is no corresponding disconnect request; if a client wishes to disconnect from the bus, it simply closes the socket (or other communication channel).
`handle_request_name` () | This method call should be invoked on the `org.freedesktop.DBus` name to request the message bus to assign the given name to the method caller. Each name maintains a queue of possible owners, where the head of the queue is the primary or current owner of the name. Each potential owner in the queue maintains the `EGG_DBUS_REQUEST_NAME_FLAGS_ALLOW_REPLACEMENT` and `EGG_DBUS_REQUEST_NAME_FLAGS_DO_NOT_QUEUE` settings from its latest `egg_dbus_bus_request_name()` call. See the D-Bus specification for more details.
`handle_release_name` () | This method call should be invoked on the `org.freedesktop.DBus` name to request the message bus to release the method caller's claim to the given name. If the caller is the primary owner, a new primary owner will be selected from the queue if any other owners are waiting. If the caller is waiting in the queue for the name, the caller will removed from the queue and will not be made an owner of the name if it later becomes available. If there are no other owners in the queue for the name, it will be removed from the bus entirely.
`handle_start_service_by_name` () | Tries to launch the executable associated with `name`. See the D-Bus specification for more details on service activation.
`handle_update_activation_environment` () | Normally, session bus activated services inherit the environment of the bus daemon. This method adds to or modifies that environment when activating services. Some bus instances, such as the standard system bus, may disable access to this method for some or all callers.
`handle_name_has_owner` () | Checks if the specified name exists (currently has an owner).
`handle_list_names` () | Returns a list of all currently-owned names on the bus.
`handle_list_activatable_names` () | Returns a list of all names that can be activated on the bus.
`handle_add_match` () | Adds a match rule to match messages going through the message bus. If the bus does not have enough resources the `org`.freedesktop.DBus.Error.OOM error is returned. See the D-Bus specification for more information about match rules.
`handle_remove_match` () | Removes the first rule that matches. If the rule is not found the `org`.freedesktop.DBus.Error.MatchRuleNotFound error is returned. See the D-Bus specification for more information about match rules.
`handle_get_name_owner` () | Returns the unique connection name of the primary owner of the name given. If the requested name doesn't have an owner, returns a `org`.freedesktop.DBus.Error.NameHasNoOwner error.
`handle_list_queued_owners` () | Lists the names waiting in queue to own `name`.
`handle_get_connection_unix_user` () | Returns the UNIX user id of the process connected to the server. If unable to determine it, a `org`.freedesktop.DBus.Error.Failed error is returned.
`handle_get_connection_unix_process_id` () | Returns the UNIX process id of the process connected to the server. If unable to determine it, a `org`.freedesktop.DBus.Error.Failed error is returned.
`handle_get_adt_audit_session_data` () | Returns the Solaris/ADT auditing data of the process connected to the server. If unable to determine it, a `org`.freedesktop.DBus.Error.AdtAuditDataUnknown error is returned.
`handle_get_connection_se_linux_security_context` () | Returns the SELinux security context of the process connected to the server. If unable to determine it, a `org`.freedesktop.DBus.Error.SELinuxSecurityContextUnknown error is returned.
`handle_reload_config` () | Asks the message bus to reload configuration files.
`handle_get_id` () | Gets the unique ID of the bus. The unique ID here is shared among all addresses the bus daemon is listening on (TCP, UNIX domain socket, etc.). Each address the bus is listening on also has its own unique ID. The per-bus and per-address IDs are not related. For a desktop session bus, the bus ID can be used as a way to uniquely identify a user's session. See the D-Bus specification for more information about unique IDs.

### EGG_DBUS_QUERY_INTERFACE_BUS()

    #define EGG_DBUS_QUERY_INTERFACE_BUS(object_proxy) (EGG_DBUS_BUS (egg_dbus_object_proxy_query_interface (object_proxy, EGG_DBUS_TYPE_BUS)))

Convenience macro to get an interface proxy for the remote object represented by `object_proxy`. See `egg_dbus_object_proxy_query_interface()` for details.

`object_proxy` : | A EggDBusObjectProxy.
Returns : | An instance derived from EggDBusInterfaceProxy that implements the EggDBusBus interface. This instance can be used to access the org.freedesktop.DBus D-Bus interface on the remote object represented by `object_proxy`. Do not ref or unref the returned instance, it is owned by `object_proxy`.

### enum EggDBusRequestNameFlags

    typedef enum
    {
      EGG_DBUS_REQUEST_NAME_FLAGS_NONE = 0x0000, /*< nick=none >*/
      EGG_DBUS_REQUEST_NAME_FLAGS_ALLOW_REPLACEMENT = 0x0001,
      EGG_DBUS_REQUEST_NAME_FLAGS_REPLACE_EXISTING = 0x0002,
      EGG_DBUS_REQUEST_NAME_FLAGS_DO_NOT_QUEUE = 0x0004,
    } EggDBusRequestNameFlags;

Flags used in the `egg_dbus_bus_request_name()` method.

`EGG_DBUS_REQUEST_NAME_FLAGS_NONE` | No flags set.
`EGG_DBUS_REQUEST_NAME_FLAGS_ALLOW_REPLACEMENT` | If an application A specifies this flag and succeeds in becoming the owner of the name, and another application B later calls `egg_dbus_bus_request_name()` with the `EGG_DBUS_REQUEST_NAME_FLAGS_REPLACE_EXISTING` flag, then application A will lose ownership and receive a "name-lost" signal, and application B will become the new owner. If `EGG_DBUS_REQUEST_NAME_FLAGS_ALLOW_REPLACEMENT` is not specified by application A, or `EGG_DBUS_REQUEST_NAME_FLAGS_REPLACE_EXISTING` is not specified by application B, then application B will not replace application A as the owner.
`EGG_DBUS_REQUEST_NAME_FLAGS_REPLACE_EXISTING` | Try to replace the current owner if there is one. If this flag is not set the application will only become the owner of the name if there is no current owner. If this flag is set, the application will replace the current owner if the current owner specified `EGG_DBUS_REQUEST_NAME_FLAGS_ALLOW_REPLACEMENT`.
`EGG_DBUS_REQUEST_NAME_FLAGS_DO_NOT_QUEUE` | Without this flag, if an application requests a name that is already owned, the application will be placed in a queue to own the name when the current owner gives it up. If this flag is given, the application will not be placed in the queue, the request for the name will simply fail. This flag also affects behavior when an application is replaced as name owner; by default the application moves back into the waiting queue, unless this flag was provided when the application became the name owner.

### enum EggDBusRequestNameReply

    typedef enum
    {
      EGG_DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER = 1,
      EGG_DBUS_REQUEST_NAME_REPLY_IN_QUEUE = 2,
      EGG_DBUS_REQUEST_NAME_REPLY_EXISTS = 3,
      EGG_DBUS_REQUEST_NAME_REPLY_ALREADY_OWNED = 4,
    } EggDBusRequestNameReply;

Return values for the `egg_dbus_bus_request_name()` method

`EGG_DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER` | The caller is now the primary owner of the name, replacing any previous owner. Either the name had no owner before, or the caller specified `EGG_DBUS_REQUEST_NAME_FLAGS_REPLACE_EXISTING` and the current owner specified `EGG_DBUS_REQUEST_NAME_FLAGS_ALLOW_REPLACEMENT`.
`EGG_DBUS_REQUEST_NAME_REPLY_IN_QUEUE` | The name already had an owner, `EGG_DBUS_REQUEST_NAME_FLAGS_DO_NOT_QUEUE` was not specified, and either the current owner did not specify `EGG_DBUS_REQUEST_NAME_FLAGS_ALLOW_REPLACEMENT` or the requesting application did not specify `EGG_DBUS_REQUEST_NAME_FLAGS_REPLACE_EXISTING`.
`EGG_DBUS_REQUEST_NAME_REPLY_EXISTS` | The name already has an owner, `EGG_DBUS_REQUEST_NAME_FLAGS_DO_NOT_QUEUE` was specified, and either `EGG_DBUS_REQUEST_NAME_FLAGS_ALLOW_REPLACEMENT` was not specified by the current owner, or `EGG_DBUS_REQUEST_NAME_FLAGS_REPLACE_EXISTING` was not specified by the requesting application.
`EGG_DBUS_REQUEST_NAME_REPLY_ALREADY_OWNED` | The application trying to request ownership of a name is already the owner of it

### enum EggDBusReleaseNameReply

    typedef enum
    {
      EGG_DBUS_RELEASE_NAME_REPLY_RELEASED = 1,
      EGG_DBUS_RELEASE_NAME_REPLY_NON_EXISTANT = 2,
      EGG_DBUS_RELEASE_NAME_REPLY_NOT_OWNER = 3,
    } EggDBusReleaseNameReply;

Return values for the `egg_dbus_bus_release_name()` method.

`EGG_DBUS_RELEASE_NAME_REPLY_RELEASED` | The caller has released his claim on the given name. Either the caller was the primary owner of the name, and the name is now unused or taken by somebody waiting in the queue for the name, or the caller was waiting in the queue for the name and has now been removed from the queue.
`EGG_DBUS_RELEASE_NAME_REPLY_NON_EXISTANT` | The given name does not exist on this bus.
`EGG_DBUS_RELEASE_NAME_REPLY_NOT_OWNER` | The caller was not the primary owner of this name, and was also not waiting in the queue to own this name.

### enum EggDBusStartServiceByNameReply

    typedef enum
    {
      EGG_DBUS_START_SERVICE_BY_NAME_REPLY_SUCCESS = 1,
      EGG_DBUS_START_SERVICE_BY_NAME_REPLY_ALREADY_RUNNING = 2,
    } EggDBusStartServiceByNameReply;

Return values for the `egg_dbus_bus_start_service_by_name()` method.

`EGG_DBUS_START_SERVICE_BY_NAME_REPLY_SUCCESS` | The service was successfully started.
`EGG_DBUS_START_SERVICE_BY_NAME_REPLY_ALREADY_RUNNING` | A connection already owns the given name.

### egg_dbus_bus_hello_sync ()

    gboolean            egg_dbus_bus_hello_sync             (EggDBusBus *instance,
                                                             EggDBusCallFlags call_flags,
                                                             gchar **out_assigned_name,
                                                             GCancellable *cancellable,
                                                             GError **error);

Before an application is able to send messages to other applications it must invoke this method on the message bus to obtain a unique name. If an application without a unique name tries to send a message to another application, or a message to the message bus itself that isn't the `egg_dbus_bus_hello()` method, it will be disconnected from the bus. There is no corresponding disconnect request; if a client wishes to disconnect from the bus, it simply closes the socket (or other communication channel).

This function synchronously invokes the Hello() method on the org.freedesktop.DBus interface on the object represented by `instance`. See `egg_dbus_bus_hello()` for the asynchronous version of this function.

`instance` : | A EggDBusBus.
`call_flags` : | Flags from EggDBusCallFlags detailing how the method should be invoked.
`out_assigned_name` : | Unique name assigned to the connection. Free with `g_free()`.
`cancellable` : | A GCancellable or `NULL`.
`error` : | Return location for error.
Returns : | `TRUE` if the method call succeeded, `FALSE` if `error` is set.

### egg_dbus_bus_request_name_sync ()

    gboolean            egg_dbus_bus_request_name_sync      (EggDBusBus *instance,
                                                             EggDBusCallFlags call_flags,
                                                             const gchar *name,
                                                             EggDBusRequestNameFlags flags,
                                                             EggDBusRequestNameReply *out_value,
                                                             GCancellable *cancellable,
                                                             GError **error);

This method call should be invoked on the `org.freedesktop.DBus` name to request the message bus to assign the given name to the method caller. Each name maintains a queue of possible owners, where the head of the queue is the primary or current owner of the name. Each potential owner in the queue maintains the `EGG_DBUS_REQUEST_NAME_FLAGS_ALLOW_REPLACEMENT` and `EGG_DBUS_REQUEST_NAME_FLAGS_DO_NOT_QUEUE` settings from its latest `egg_dbus_bus_request_name()` call. See the D-Bus specification for more details.

This function synchronously invokes the RequestName() method on the org.freedesktop.DBus interface on the object represented by `instance`. See `egg_dbus_bus_request_name()` for the asynchronous version of this function.

`instance` : | A EggDBusBus.
`call_flags` : | Flags from EggDBusCallFlags detailing how the method should be invoked.
`name` : | Name to request.
`flags` : | Flags.
`out_value` : | Return value.
`cancellable` : | A GCancellable or `NULL`.
`error` : | Return location for error.
Returns : | `TRUE` if the method call succeeded, `FALSE` if `error` is set.

### egg_dbus_bus_release_name_sync ()

    gboolean            egg_dbus_bus_release_name_sync      (EggDBusBus *instance,
                                                             EggDBusCallFlags call_flags,
                                                             const gchar *name,
                                                             EggDBusReleaseNameReply *out_value,
                                                             GCancellable *cancellable,
                                                             GError **error);

This method call should be invoked on the `org.freedesktop.DBus` name to request the message bus to release the method caller's claim to the given name. If the caller is the primary owner, a new primary owner will be selected from the queue if any other owners are waiting. If the caller is waiting in the queue for the name, the caller will removed from the queue and will not be made an owner of the name if it later becomes available. If there are no other owners in the queue for the name, it will be removed from the bus entirely.

This function synchronously invokes the ReleaseName() method on the org.freedesktop.DBus interface on the object represented by `instance`. See `egg_dbus_bus_release_name()` for the asynchronous version of this function.

`instance` : | A EggDBusBus.
`call_flags` : | Flags from EggDBusCallFlags detailing how the method should be invoked.
`name` : | Name to release.
`out_value` : | Return value.
`cancellable` : | A GCancellable or `NULL`.
`error` : | Return location for error.
Returns : | `TRUE` if the method call succeeded, `FALSE` if `error` is set.

### egg_dbus_bus_start_service_by_name_sync ()

    gboolean            egg_dbus_bus_start_service_by_name_sync
                                                            (EggDBusBus *instance,
                                                             EggDBusCallFlags call_flags,
                                                             const gchar *name,
                                                             guint flags,
                                                             EggDBusStartServiceByNameReply *out_value,
                                                             GCancellable *cancellable,
                                                             GError **error);

Tries to launch the executable associated with `name`. See the D-Bus specification for more details on service activation.

This function synchronously invokes the StartServiceByName() method on the org.freedesktop.DBus interface on the object represented by `instance`. See `egg_dbus_bus_start_service_by_name()` for the asynchronous version of this function.

`instance` : | A EggDBusBus.
`call_flags` : | Flags from EggDBusCallFlags detailing how the method should be invoked.
`name` : | Name of the service to start.
`flags` : | Flags (currently not used).
`out_value` : | Reply
`cancellable` : | A GCancellable or `NULL`.
`error` : | Return location for error.
Returns : | `TRUE` if the method call succeeded, `FALSE` if `error` is set.

### egg_dbus_bus_update_activation_environment_sync ()

    gboolean            egg_dbus_bus_update_activation_environment_sync
                                                            (EggDBusBus *instance,
                                                             EggDBusCallFlags call_flags,
                                                             EggDBusHashMap *env_hash,
                                                             GCancellable *cancellable,
                                                             GError **error);

Normally, session bus activated services inherit the environment of the bus daemon. This method adds to or modifies that environment when activating services. Some bus instances, such as the standard system bus, may disable access to this method for some or all callers.

This function synchronously invokes the UpdateActivationEnvironment() method on the org.freedesktop.DBus interface on the object represented by `instance`. See `egg_dbus_bus_update_activation_environment()` for the asynchronous version of this function.

`instance` : | A EggDBusBus.
`call_flags` : | Flags from EggDBusCallFlags detailing how the method should be invoked.
`env_hash` : | Environment to add or update.
`cancellable` : | A GCancellable or `NULL`.
`error` : | Return location for error.
Returns : | `TRUE` if the method call succeeded, `FALSE` if `error` is set.

### egg_dbus_bus_name_has_owner_sync ()

    gboolean            egg_dbus_bus_name_has_owner_sync    (EggDBusBus *instance,
                                                             EggDBusCallFlags call_flags,
                                                             const gchar *name,
                                                             gboolean *out_has_owner,
                                                             GCancellable *cancellable,
                                                             GError **error);

Checks if the specified name exists (currently has an owner).

This function synchronously invokes the NameHasOwner() method on the org.freedesktop.DBus interface on the object represented by `instance`. See `egg_dbus_bus_name_has_owner()` for the asynchronous version of this function.

`instance` : | A EggDBusBus.
`call_flags` : | Flags from EggDBusCallFlags detailing how the method should be invoked.
`name` : | Name to check.
`out_has_owner` : | `TRUE` only if `name` exists.
`cancellable` : | A GCancellable or `NULL`.
`error` : | Return location for error.
Returns : | `TRUE` if the method call succeeded, `FALSE` if `error` is set.

### egg_dbus_bus_list_names_sync ()

    gboolean            egg_dbus_bus_list_names_sync        (EggDBusBus *instance,
                                                             EggDBusCallFlags call_flags,
                                                             gchar ***out_names,
                                                             GCancellable *cancellable,
                                                             GError **error);

Returns a list of all currently-owned names on the bus.

This function synchronously invokes the ListNames() method on the org.freedesktop.DBus interface on the object represented by `instance`. See `egg_dbus_bus_list_names()` for the asynchronous version of this function.

`instance` : | A EggDBusBus.
`call_flags` : | Flags from EggDBusCallFlags detailing how the method should be invoked.
`out_names` : | Array of strings where each string is a bus name. Free with `g_strfreev()`.
`cancellable` : | A GCancellable or `NULL`.
`error` : | Return location for error.
Returns : | `TRUE` if the method call succeeded, `FALSE` if `error` is set.

### egg_dbus_bus_list_activatable_names_sync ()

    gboolean            egg_dbus_bus_list_activatable_names_sync
                                                            (EggDBusBus *instance,
                                                             EggDBusCallFlags call_flags,
                                                             gchar ***out_activatable_names,
                                                             GCancellable *cancellable,
                                                             GError **error);

Returns a list of all names that can be activated on the bus.

This function synchronously invokes the ListActivatableNames() method on the org.freedesktop.DBus interface on the object represented by `instance`. See `egg_dbus_bus_list_activatable_names()` for the asynchronous version of this function.

`instance` : | A EggDBusBus.
`call_flags` : | Flags from EggDBusCallFlags detailing how the method should be invoked.
`out_activatable_names` : | Array of strings where each string is a bus name. Free with `g_strfreev()`.
`cancellable` : | A GCancellable or `NULL`.
`error` : | Return location for error.
Returns : | `TRUE` if the method call succeeded, `FALSE` if `error` is set.

### egg_dbus_bus_add_match_sync ()

    gboolean            egg_dbus_bus_add_match_sync         (EggDBusBus *instance,
                                                             EggDBusCallFlags call_flags,
                                                             const gchar *rule,
                                                             GCancellable *cancellable,
                                                             GError **error);

Adds a match rule to match messages going through the message bus. If the bus does not have enough resources the `org`.freedesktop.DBus.Error.OOM error is returned. See the D-Bus specification for more information about match rules.

This function synchronously invokes the AddMatch() method on the org.freedesktop.DBus interface on the object represented by `instance`. See `egg_dbus_bus_add_match()` for the asynchronous version of this function.

`instance` : | A EggDBusBus.
`call_flags` : | Flags from EggDBusCallFlags detailing how the method should be invoked.
`rule` : | Match rule to add to the connection.
`cancellable` : | A GCancellable or `NULL`.
`error` : | Return location for error.
Returns : | `TRUE` if the method call succeeded, `FALSE` if `error` is set.

### egg_dbus_bus_remove_match_sync ()

    gboolean            egg_dbus_bus_remove_match_sync      (EggDBusBus *instance,
                                                             EggDBusCallFlags call_flags,
                                                             const gchar *rule,
                                                             GCancellable *cancellable,
                                                             GError **error);

Removes the first rule that matches. If the rule is not found the `org`.freedesktop.DBus.Error.MatchRuleNotFound error is returned. See the D-Bus specification for more information about match rules.

This function synchronously invokes the RemoveMatch() method on the org.freedesktop.DBus interface on the object represented by `instance`. See `egg_dbus_bus_remove_match()` for the asynchronous version of this function.

`instance` : | A EggDBusBus.
`call_flags` : | Flags from EggDBusCallFlags detailing how the method should be invoked.
`rule` : | Match rule to remove from the connection.
`cancellable` : | A GCancellable or `NULL`.
`error` : | Return location for error.
Returns : | `TRUE` if the method call succeeded, `FALSE` if `error` is set.

### egg_dbus_bus_get_name_owner_sync ()

    gboolean            egg_dbus_bus_get_name_owner_sync    (EggDBusBus *instance,
                                                             EggDBusCallFlags call_flags,
                                                             const gchar *name,
                                                             gchar **out_unique_name,
                                                             GCancellable *cancellable,
                                                             GError **error);

Returns the unique connection name of the primary owner of the name given. If the requested name doesn't have an owner, returns a `org`.freedesktop.DBus.Error.NameHasNoOwner error.

This function synchronously invokes the GetNameOwner() method on the org.freedesktop.DBus interface on the object represented by `instance`. See `egg_dbus_bus_get_name_owner()` for the asynchronous version of this function.

`instance` : | A EggDBusBus.
`call_flags` : | Flags from EggDBusCallFlags detailing how the method should be invoked.
`name` : | Name to get owner of.
`out_unique_name` : | The unique name that owns `name`. Free with `g_free()`.
`cancellable` : | A GCancellable or `NULL`.
`error` : | Return location for error.
Returns : | `TRUE` if the method call succeeded, `FALSE` if `error` is set.

### egg_dbus_bus_list_queued_owners_sync ()

    gboolean            egg_dbus_bus_list_queued_owners_sync
                                                            (EggDBusBus *instance,
                                                             EggDBusCallFlags call_flags,
                                                             const gchar *name,
                                                             gchar ***out_queued_owners,
                                                             GCancellable *cancellable,
                                                             GError **error);

Lists the names waiting in queue to own `name`.

This function synchronously invokes the ListQueuedOwners() method on the org.freedesktop.DBus interface on the object represented by `instance`. See `egg_dbus_bus_list_queued_owners()` for the asynchronous version of this function.

`instance` : | A EggDBusBus.
`call_flags` : | Flags from EggDBusCallFlags detailing how the method should be invoked.
`name` : | A well-known name.
`out_queued_owners` : | Array of unique names in queue to own `name`. Free with `g_strfreev()`.
`cancellable` : | A GCancellable or `NULL`.
`error` : | Return location for error.
Returns : | `TRUE` if the method call succeeded, `FALSE` if `error` is set.

### egg_dbus_bus_get_connection_unix_user_sync ()

    gboolean            egg_dbus_bus_get_connection_unix_user_sync
                                                            (EggDBusBus *instance,
                                                             EggDBusCallFlags call_flags,
                                                             const gchar *name,
                                                             uid_t *out_uid,
                                                             GCancellable *cancellable,
                                                             GError **error);

Returns the UNIX user id of the process connected to the server. If unable to determine it, a `org`.freedesktop.DBus.Error.Failed error is returned.

This function synchronously invokes the GetConnectionUnixUser() method on the org.freedesktop.DBus interface on the object represented by `instance`. See `egg_dbus_bus_get_connection_unix_user()` for the asynchronous version of this function.

`instance` : | A EggDBusBus.
`call_flags` : | Flags from EggDBusCallFlags detailing how the method should be invoked.
`name` : | Name of the connection to query.
`out_uid` : | UNIX user id.
`cancellable` : | A GCancellable or `NULL`.
`error` : | Return location for error.
Returns : | `TRUE` if the method call succeeded, `FALSE` if `error` is set.

### egg_dbus_bus_get_connection_unix_process_id_sync ()

    gboolean            egg_dbus_bus_get_connection_unix_process_id_sync
                                                            (EggDBusBus *instance,
                                                             EggDBusCallFlags call_flags,
                                                             const gchar *name,
                                                             pid_t *out_pid,
                                                             GCancellable *cancellable,
                                                             GError **error);

Returns the UNIX process id of the process connected to the server. If unable to determine it, a `org`.freedesktop.DBus.Error.Failed error is returned.

This function synchronously invokes the GetConnectionUnixProcessID() method on the org.freedesktop.DBus interface on the object represented by `instance`. See `egg_dbus_bus_get_connection_unix_process_id()` for the asynchronous version of this function.

`instance` : | A EggDBusBus.
`call_flags` : | Flags from EggDBusCallFlags detailing how the method should be invoked.
`name` : | Name of the connection to query.
`out_pid` : | UNIX process id.
`cancellable` : | A GCancellable or `NULL`.
`error` : | Return location for error.
Returns : | `TRUE` if the method call succeeded, `FALSE` if `error` is set.

### egg_dbus_bus_get_adt_audit_session_data_sync ()

    gboolean            egg_dbus_bus_get_adt_audit_session_data_sync
                                                            (EggDBusBus *instance,
                                                             EggDBusCallFlags call_flags,
                                                             const gchar *name,
                                                             EggDBusArraySeq **out_data,
                                                             GCancellable *cancellable,
                                                             GError **error);

Returns the Solaris/ADT auditing data of the process connected to the server. If unable to determine it, a `org`.freedesktop.DBus.Error.AdtAuditDataUnknown error is returned.

This function synchronously invokes the GetAdtAuditSessionData() method on the org.freedesktop.DBus interface on the object represented by `instance`. See `egg_dbus_bus_get_adt_audit_session_data()` for the asynchronous version of this function.

`instance` : | A EggDBusBus.
`call_flags` : | Flags from EggDBusCallFlags detailing how the method should be invoked.
`name` : | Name of the connection to query.
`out_data` : | An array of bytes (typically a string of undefined encoding). Free with `g_object_unref()`.
`cancellable` : | A GCancellable or `NULL`.
`error` : | Return location for error.
Returns : | `TRUE` if the method call succeeded, `FALSE` if `error` is set.

### egg_dbus_bus_get_connection_se_linux_security_context_sync ()

    gboolean            egg_dbus_bus_get_connection_se_linux_security_context_sync
                                                            (EggDBusBus *instance,
                                                             EggDBusCallFlags call_flags,
                                                             const gchar *name,
                                                             EggDBusArraySeq **out_security_context,
                                                             GCancellable *cancellable,
                                                             GError **error);

Returns the SELinux security context of the process connected to the server. If unable to determine it, a `org`.freedesktop.DBus.Error.SELinuxSecurityContextUnknown error is returned.

This function synchronously invokes the GetConnectionSELinuxSecurityContext() method on the org.freedesktop.DBus interface on the object represented by `instance`. See `egg_dbus_bus_get_connection_se_linux_security_context()` for the asynchronous version of this function.

`instance` : | A EggDBusBus.
`call_flags` : | Flags from EggDBusCallFlags detailing how the method should be invoked.
`name` : | Name of the connection to query.
`out_security_context` : | An array of bytes (typically a string of undefined encoding). Free with `g_object_unref()`.
`cancellable` : | A GCancellable or `NULL`.
`error` : | Return location for error.
Returns : | `TRUE` if the method call succeeded, `FALSE` if `error` is set.

### egg_dbus_bus_reload_config_sync ()

    gboolean            egg_dbus_bus_reload_config_sync     (EggDBusBus *instance,
                                                             EggDBusCallFlags call_flags,
                                                             GCancellable *cancellable,
                                                             GError **error);

Asks the message bus to reload configuration files.

This function synchronously invokes the ReloadConfig() method on the org.freedesktop.DBus interface on the object represented by `instance`. See `egg_dbus_bus_reload_config()` for the asynchronous version of this function.

`instance` : | A EggDBusBus.
`call_flags` : | Flags from EggDBusCallFlags detailing how the method should be invoked.
`cancellable` : | A GCancellable or `NULL`.
`error` : | Return location for error.
Returns : | `TRUE` if the method call succeeded, `FALSE` if `error` is set.

### egg_dbus_bus_get_id_sync ()

    gboolean            egg_dbus_bus_get_id_sync            (EggDBusBus *instance,
                                                             EggDBusCallFlags call_flags,
                                                             gchar **out_unique_id,
                                                             GCancellable *cancellable,
                                                             GError **error);

Gets the unique ID of the bus. The unique ID here is shared among all addresses the bus daemon is listening on (TCP, UNIX domain socket, etc.). Each address the bus is listening on also has its own unique ID. The per-bus and per-address IDs are not related. For a desktop session bus, the bus ID can be used as a way to uniquely identify a user's session. See the D-Bus specification for more information about unique IDs.

This function synchronously invokes the GetId() method on the org.freedesktop.DBus interface on the object represented by `instance`. See `egg_dbus_bus_get_id()` for the asynchronous version of this function.

`instance` : | A EggDBusBus.
`call_flags` : | Flags from EggDBusCallFlags detailing how the method should be invoked.
`out_unique_id` : | Unique ID identifying the bus daemon. Free with `g_free()`.
`cancellable` : | A GCancellable or `NULL`.
`error` : | Return location for error.
Returns : | `TRUE` if the method call succeeded, `FALSE` if `error` is set.

### egg_dbus_bus_hello ()

    guint               egg_dbus_bus_hello                  (EggDBusBus *instance,
                                                             EggDBusCallFlags call_flags,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);

Before an application is able to send messages to other applications it must invoke this method on the message bus to obtain a unique name. If an application without a unique name tries to send a message to another application, or a message to the message bus itself that isn't the `egg_dbus_bus_hello()` method, it will be disconnected from the bus. There is no corresponding disconnect request; if a client wishes to disconnect from the bus, it simply closes the socket (or other communication channel).

This function asynchronously invokes the Hello() method on the org.freedesktop.DBus interface on the object represented by `instance`. When the reply is ready, `callback` will be called (on the main thread). You can then call `egg_dbus_bus_hello_finish()` to get the result. See `egg_dbus_bus_hello_sync()` for the synchronous version of this function.

`instance` : | A EggDBusBus.
`call_flags` : | Flags from EggDBusCallFlags detailing how the method should be invoked.
`cancellable` : | A GCancellable or `NULL`.
`callback` : | Callback to invoke when the reply is ready.
`user_data` : | User data to pass to `callback`.
Returns : | A pending call id (never zero) that can be used with `egg_dbus_connection_pending_call_cancel()` or `egg_dbus_connection_pending_call_block()`.

### egg_dbus_bus_hello_finish ()

    gboolean            egg_dbus_bus_hello_finish           (EggDBusBus *instance,
                                                             gchar **out_assigned_name,
                                                             GAsyncResult *res,
                                                             GError **error);

Finishes an asynchronous method invocation started with `egg_dbus_bus_hello()`.

`instance` : | A EggDBusBus.
`out_assigned_name` : | Unique name assigned to the connection. Free with `g_free()`.
`res` : | A GAsyncResult obtained from the GAsyncReadyCallback function passed to `egg_dbus_bus_hello()`.
`error` : | Return location for error.
Returns : | `TRUE` if the method call succeeded, `FALSE` if `error` is set.

### egg_dbus_bus_request_name ()

    guint               egg_dbus_bus_request_name           (EggDBusBus *instance,
                                                             EggDBusCallFlags call_flags,
                                                             const gchar *name,
                                                             EggDBusRequestNameFlags flags,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);

This method call should be invoked on the `org.freedesktop.DBus` name to request the message bus to assign the given name to the method caller. Each name maintains a queue of possible owners, where the head of the queue is the primary or current owner of the name. Each potential owner in the queue maintains the `EGG_DBUS_REQUEST_NAME_FLAGS_ALLOW_REPLACEMENT` and `EGG_DBUS_REQUEST_NAME_FLAGS_DO_NOT_QUEUE` settings from its latest `egg_dbus_bus_request_name()` call. See the D-Bus specification for more details.

This function asynchronously invokes the RequestName() method on the org.freedesktop.DBus interface on the object represented by `instance`. When the reply is ready, `callback` will be called (on the main thread). You can then call `egg_dbus_bus_request_name_finish()` to get the result. See `egg_dbus_bus_request_name_sync()` for the synchronous version of this function.

`instance` : | A EggDBusBus.
`call_flags` : | Flags from EggDBusCallFlags detailing how the method should be invoked.
`name` : | Name to request.
`flags` : | Flags.
`cancellable` : | A GCancellable or `NULL`.
`callback` : | Callback to invoke when the reply is ready.
`user_data` : | User data to pass to `callback`.
Returns : | A pending call id (never zero) that can be used with `egg_dbus_connection_pending_call_cancel()` or `egg_dbus_connection_pending_call_block()`.

### egg_dbus_bus_request_name_finish ()

    gboolean            egg_dbus_bus_request_name_finish    (EggDBusBus *instance,
                                                             EggDBusRequestNameReply *out_value,
                                                             GAsyncResult *res,
                                                             GError **error);

Finishes an asynchronous method invocation started with `egg_dbus_bus_request_name()`.

`instance` : | A EggDBusBus.
`out_value` : | Return value.
`res` : | A GAsyncResult obtained from the GAsyncReadyCallback function passed to `egg_dbus_bus_request_name()`.
`error` : | Return location for error.
Returns : | `TRUE` if the method call succeeded, `FALSE` if `error` is set.

### egg_dbus_bus_release_name ()

    guint               egg_dbus_bus_release_name           (EggDBusBus *instance,
                                                             EggDBusCallFlags call_flags,
                                                             const gchar *name,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);

This method call should be invoked on the `org.freedesktop.DBus` name to request the message bus to release the method caller's claim to the given name. If the caller is the primary owner, a new primary owner will be selected from the queue if any other owners are waiting. If the caller is waiting in the queue for the name, the caller will removed from the queue and will not be made an owner of the name if it later becomes available. If there are no other owners in the queue for the name, it will be removed from the bus entirely.

This function asynchronously invokes the ReleaseName() method on the org.freedesktop.DBus interface on the object represented by `instance`. When the reply is ready, `callback` will be called (on the main thread). You can then call `egg_dbus_bus_release_name_finish()` to get the result. See `egg_dbus_bus_release_name_sync()` for the synchronous version of this function.

`instance` : | A EggDBusBus.
`call_flags` : | Flags from EggDBusCallFlags detailing how the method should be invoked.
`name` : | Name to release.
`cancellable` : | A GCancellable or `NULL`.
`callback` : | Callback to invoke when the reply is ready.
`user_data` : | User data to pass to `callback`.
Returns : | A pending call id (never zero) that can be used with `egg_dbus_connection_pending_call_cancel()` or `egg_dbus_connection_pending_call_block()`.

### egg_dbus_bus_release_name_finish ()

    gboolean            egg_dbus_bus_release_name_finish    (EggDBusBus *instance,
                                                             EggDBusReleaseNameReply *out_value,
                                                             GAsyncResult *res,
                                                             GError **error);

Finishes an asynchronous method invocation started with `egg_dbus_bus_release_name()`.

`instance` : | A EggDBusBus.
`out_value` : | Return value.
`res` : | A GAsyncResult obtained from the GAsyncReadyCallback function passed to `egg_dbus_bus_release_name()`.
`error` : | Return location for error.
Returns : | `TRUE` if the method call succeeded, `FALSE` if `error` is set.

### egg_dbus_bus_start_service_by_name ()

    guint               egg_dbus_bus_start_service_by_name  (EggDBusBus *instance,
                                                             EggDBusCallFlags call_flags,
                                                             const gchar *name,
                                                             guint flags,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);

Tries to launch the executable associated with `name`. See the D-Bus specification for more details on service activation.

This function asynchronously invokes the StartServiceByName() method on the org.freedesktop.DBus interface on the object represented by `instance`. When the reply is ready, `callback` will be called (on the main thread). You can then call `egg_dbus_bus_start_service_by_name_finish()` to get the result. See `egg_dbus_bus_start_service_by_name_sync()` for the synchronous version of this function.

`instance` : | A EggDBusBus.
`call_flags` : | Flags from EggDBusCallFlags detailing how the method should be invoked.
`name` : | Name of the service to start.
`flags` : | Flags (currently not used).
`cancellable` : | A GCancellable or `NULL`.
`callback` : | Callback to invoke when the reply is ready.
`user_data` : | User data to pass to `callback`.
Returns : | A pending call id (never zero) that can be used with `egg_dbus_connection_pending_call_cancel()` or `egg_dbus_connection_pending_call_block()`.

### egg_dbus_bus_start_service_by_name_finish ()

    gboolean            egg_dbus_bus_start_service_by_name_finish
                                                            (EggDBusBus *instance,
                                                             EggDBusStartServiceByNameReply *out_value,
                                                             GAsyncResult *res,
                                                             GError **error);

Finishes an asynchronous method invocation started with `egg_dbus_bus_start_service_by_name()`.

`instance` : | A EggDBusBus.
`out_value` : | Reply
`res` : | A GAsyncResult obtained from the GAsyncReadyCallback function passed to `egg_dbus_bus_start_service_by_name()`.
`error` : | Return location for error.
Returns : | `TRUE` if the method call succeeded, `FALSE` if `error` is set.

### egg_dbus_bus_update_activation_environment ()

    guint               egg_dbus_bus_update_activation_environment
                                                            (EggDBusBus *instance,
                                                             EggDBusCallFlags call_flags,
                                                             EggDBusHashMap *env_hash,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);

Normally, session bus activated services inherit the environment of the bus daemon. This method adds to or modifies that environment when activating services. Some bus instances, such as the standard system bus, may disable access to this method for some or all callers.

This function asynchronously invokes the UpdateActivationEnvironment() method on the org.freedesktop.DBus interface on the object represented by `instance`. When the reply is ready, `callback` will be called (on the main thread). You can then call `egg_dbus_bus_update_activation_environment_finish()` to get the result. See `egg_dbus_bus_update_activation_environment_sync()` for the synchronous version of this function.

`instance` : | A EggDBusBus.
`call_flags` : | Flags from EggDBusCallFlags detailing how the method should be invoked.
`env_hash` : | Environment to add or update.
`cancellable` : | A GCancellable or `NULL`.
`callback` : | Callback to invoke when the reply is ready.
`user_data` : | User data to pass to `callback`.
Returns : | A pending call id (never zero) that can be used with `egg_dbus_connection_pending_call_cancel()` or `egg_dbus_connection_pending_call_block()`.

### egg_dbus_bus_update_activation_environment_finish ()

    gboolean            egg_dbus_bus_update_activation_environment_finish
                                                            (EggDBusBus *instance,
                                                             GAsyncResult *res,
                                                             GError **error);

Finishes an asynchronous method invocation started with `egg_dbus_bus_update_activation_environment()`.

`instance` : | A EggDBusBus.
`res` : | A GAsyncResult obtained from the GAsyncReadyCallback function passed to `egg_dbus_bus_update_activation_environment()`.
`error` : | Return location for error.
Returns : | `TRUE` if the method call succeeded, `FALSE` if `error` is set.

### egg_dbus_bus_name_has_owner ()

    guint               egg_dbus_bus_name_has_owner         (EggDBusBus *instance,
                                                             EggDBusCallFlags call_flags,
                                                             const gchar *name,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);

Checks if the specified name exists (currently has an owner).

This function asynchronously invokes the NameHasOwner() method on the org.freedesktop.DBus interface on the object represented by `instance`. When the reply is ready, `callback` will be called (on the main thread). You can then call `egg_dbus_bus_name_has_owner_finish()` to get the result. See `egg_dbus_bus_name_has_owner_sync()` for the synchronous version of this function.

`instance` : | A EggDBusBus.
`call_flags` : | Flags from EggDBusCallFlags detailing how the method should be invoked.
`name` : | Name to check.
`cancellable` : | A GCancellable or `NULL`.
`callback` : | Callback to invoke when the reply is ready.
`user_data` : | User data to pass to `callback`.
Returns : | A pending call id (never zero) that can be used with `egg_dbus_connection_pending_call_cancel()` or `egg_dbus_connection_pending_call_block()`.

### egg_dbus_bus_name_has_owner_finish ()

    gboolean            egg_dbus_bus_name_has_owner_finish  (EggDBusBus *instance,
                                                             gboolean *out_has_owner,
                                                             GAsyncResult *res,
                                                             GError **error);

Finishes an asynchronous method invocation started with `egg_dbus_bus_name_has_owner()`.

`instance` : | A EggDBusBus.
`out_has_owner` : | `TRUE` only if `name` exists.
`res` : | A GAsyncResult obtained from the GAsyncReadyCallback function passed to `egg_dbus_bus_name_has_owner()`.
`error` : | Return location for error.
Returns : | `TRUE` if the method call succeeded, `FALSE` if `error` is set.

### egg_dbus_bus_list_names ()

    guint               egg_dbus_bus_list_names             (EggDBusBus *instance,
                                                             EggDBusCallFlags call_flags,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);

Returns a list of all currently-owned names on the bus.

This function asynchronously invokes the ListNames() method on the org.freedesktop.DBus interface on the object represented by `instance`. When the reply is ready, `callback` will be called (on the main thread). You can then call `egg_dbus_bus_list_names_finish()` to get the result. See `egg_dbus_bus_list_names_sync()` for the synchronous version of this function.

`instance` : | A EggDBusBus.
`call_flags` : | Flags from EggDBusCallFlags detailing how the method should be invoked.
`cancellable` : | A GCancellable or `NULL`.
`callback` : | Callback to invoke when the reply is ready.
`user_data` : | User data to pass to `callback`.
Returns : | A pending call id (never zero) that can be used with `egg_dbus_connection_pending_call_cancel()` or `egg_dbus_connection_pending_call_block()`.

### egg_dbus_bus_list_names_finish ()

    gboolean            egg_dbus_bus_list_names_finish      (EggDBusBus *instance,
                                                             gchar ***out_names,
                                                             GAsyncResult *res,
                                                             GError **error);

Finishes an asynchronous method invocation started with `egg_dbus_bus_list_names()`.

`instance` : | A EggDBusBus.
`out_names` : | Array of strings where each string is a bus name. Free with `g_strfreev()`.
`res` : | A GAsyncResult obtained from the GAsyncReadyCallback function passed to `egg_dbus_bus_list_names()`.
`error` : | Return location for error.
Returns : | `TRUE` if the method call succeeded, `FALSE` if `error` is set.

### egg_dbus_bus_list_activatable_names ()

    guint               egg_dbus_bus_list_activatable_names (EggDBusBus *instance,
                                                             EggDBusCallFlags call_flags,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);

Returns a list of all names that can be activated on the bus.

This function asynchronously invokes the ListActivatableNames() method on the org.freedesktop.DBus interface on the object represented by `instance`. When the reply is ready, `callback` will be called (on the main thread). You can then call `egg_dbus_bus_list_activatable_names_finish()` to get the result. See `egg_dbus_bus_list_activatable_names_sync()` for the synchronous version of this function.

`instance` : | A EggDBusBus.
`call_flags` : | Flags from EggDBusCallFlags detailing how the method should be invoked.
`cancellable` : | A GCancellable or `NULL`.
`callback` : | Callback to invoke when the reply is ready.
`user_data` : | User data to pass to `callback`.
Returns : | A pending call id (never zero) that can be used with `egg_dbus_connection_pending_call_cancel()` or `egg_dbus_connection_pending_call_block()`.

### egg_dbus_bus_list_activatable_names_finish ()

    gboolean            egg_dbus_bus_list_activatable_names_finish
                                                            (EggDBusBus *instance,
                                                             gchar ***out_activatable_names,
                                                             GAsyncResult *res,
                                                             GError **error);

Finishes an asynchronous method invocation started with `egg_dbus_bus_list_activatable_names()`.

`instance` : | A EggDBusBus.
`out_activatable_names` : | Array of strings where each string is a bus name. Free with `g_strfreev()`.
`res` : | A GAsyncResult obtained from the GAsyncReadyCallback function passed to `egg_dbus_bus_list_activatable_names()`.
`error` : | Return location for error.
Returns : | `TRUE` if the method call succeeded, `FALSE` if `error` is set.

### egg_dbus_bus_add_match ()

    guint               egg_dbus_bus_add_match              (EggDBusBus *instance,
                                                             EggDBusCallFlags call_flags,
                                                             const gchar *rule,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);

Adds a match rule to match messages going through the message bus. If the bus does not have enough resources the `org`.freedesktop.DBus.Error.OOM error is returned. See the D-Bus specification for more information about match rules.

This function asynchronously invokes the AddMatch() method on the org.freedesktop.DBus interface on the object represented by `instance`. When the reply is ready, `callback` will be called (on the main thread). You can then call `egg_dbus_bus_add_match_finish()` to get the result. See `egg_dbus_bus_add_match_sync()` for the synchronous version of this function.

`instance` : | A EggDBusBus.
`call_flags` : | Flags from EggDBusCallFlags detailing how the method should be invoked.
`rule` : | Match rule to add to the connection.
`cancellable` : | A GCancellable or `NULL`.
`callback` : | Callback to invoke when the reply is ready.
`user_data` : | User data to pass to `callback`.
Returns : | A pending call id (never zero) that can be used with `egg_dbus_connection_pending_call_cancel()` or `egg_dbus_connection_pending_call_block()`.

### egg_dbus_bus_add_match_finish ()

    gboolean            egg_dbus_bus_add_match_finish       (EggDBusBus *instance,
                                                             GAsyncResult *res,
                                                             GError **error);

Finishes an asynchronous method invocation started with `egg_dbus_bus_add_match()`.

`instance` : | A EggDBusBus.
`res` : | A GAsyncResult obtained from the GAsyncReadyCallback function passed to `egg_dbus_bus_add_match()`.
`error` : | Return location for error.
Returns : | `TRUE` if the method call succeeded, `FALSE` if `error` is set.

### egg_dbus_bus_remove_match ()

    guint               egg_dbus_bus_remove_match           (EggDBusBus *instance,
                                                             EggDBusCallFlags call_flags,
                                                             const gchar *rule,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);

Removes the first rule that matches. If the rule is not found the `org`.freedesktop.DBus.Error.MatchRuleNotFound error is returned. See the D-Bus specification for more information about match rules.

This function asynchronously invokes the RemoveMatch() method on the org.freedesktop.DBus interface on the object represented by `instance`. When the reply is ready, `callback` will be called (on the main thread). You can then call `egg_dbus_bus_remove_match_finish()` to get the result. See `egg_dbus_bus_remove_match_sync()` for the synchronous version of this function.

`instance` : | A EggDBusBus.
`call_flags` : | Flags from EggDBusCallFlags detailing how the method should be invoked.
`rule` : | Match rule to remove from the connection.
`cancellable` : | A GCancellable or `NULL`.
`callback` : | Callback to invoke when the reply is ready.
`user_data` : | User data to pass to `callback`.
Returns : | A pending call id (never zero) that can be used with `egg_dbus_connection_pending_call_cancel()` or `egg_dbus_connection_pending_call_block()`.

### egg_dbus_bus_remove_match_finish ()

    gboolean            egg_dbus_bus_remove_match_finish    (EggDBusBus *instance,
                                                             GAsyncResult *res,
                                                             GError **error);

Finishes an asynchronous method invocation started with `egg_dbus_bus_remove_match()`.

`instance` : | A EggDBusBus.
`res` : | A GAsyncResult obtained from the GAsyncReadyCallback function passed to `egg_dbus_bus_remove_match()`.
`error` : | Return location for error.
Returns : | `TRUE` if the method call succeeded, `FALSE` if `error` is set.

### egg_dbus_bus_get_name_owner ()

    guint               egg_dbus_bus_get_name_owner         (EggDBusBus *instance,
                                                             EggDBusCallFlags call_flags,
                                                             const gchar *name,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);

Returns the unique connection name of the primary owner of the name given. If the requested name doesn't have an owner, returns a `org`.freedesktop.DBus.Error.NameHasNoOwner error.

This function asynchronously invokes the GetNameOwner() method on the org.freedesktop.DBus interface on the object represented by `instance`. When the reply is ready, `callback` will be called (on the main thread). You can then call `egg_dbus_bus_get_name_owner_finish()` to get the result. See `egg_dbus_bus_get_name_owner_sync()` for the synchronous version of this function.

`instance` : | A EggDBusBus.
`call_flags` : | Flags from EggDBusCallFlags detailing how the method should be invoked.
`name` : | Name to get owner of.
`cancellable` : | A GCancellable or `NULL`.
`callback` : | Callback to invoke when the reply is ready.
`user_data` : | User data to pass to `callback`.
Returns : | A pending call id (never zero) that can be used with `egg_dbus_connection_pending_call_cancel()` or `egg_dbus_connection_pending_call_block()`.

### egg_dbus_bus_get_name_owner_finish ()

    gboolean            egg_dbus_bus_get_name_owner_finish  (EggDBusBus *instance,
                                                             gchar **out_unique_name,
                                                             GAsyncResult *res,
                                                             GError **error);

Finishes an asynchronous method invocation started with `egg_dbus_bus_get_name_owner()`.

`instance` : | A EggDBusBus.
`out_unique_name` : | The unique name that owns `name`. Free with `g_free()`.
`res` : | A GAsyncResult obtained from the GAsyncReadyCallback function passed to `egg_dbus_bus_get_name_owner()`.
`error` : | Return location for error.
Returns : | `TRUE` if the method call succeeded, `FALSE` if `error` is set.

### egg_dbus_bus_list_queued_owners ()

    guint               egg_dbus_bus_list_queued_owners     (EggDBusBus *instance,
                                                             EggDBusCallFlags call_flags,
                                                             const gchar *name,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);

Lists the names waiting in queue to own `name`.

This function asynchronously invokes the ListQueuedOwners() method on the org.freedesktop.DBus interface on the object represented by `instance`. When the reply is ready, `callback` will be called (on the main thread). You can then call `egg_dbus_bus_list_queued_owners_finish()` to get the result. See `egg_dbus_bus_list_queued_owners_sync()` for the synchronous version of this function.

`instance` : | A EggDBusBus.
`call_flags` : | Flags from EggDBusCallFlags detailing how the method should be invoked.
`name` : | A well-known name.
`cancellable` : | A GCancellable or `NULL`.
`callback` : | Callback to invoke when the reply is ready.
`user_data` : | User data to pass to `callback`.
Returns : | A pending call id (never zero) that can be used with `egg_dbus_connection_pending_call_cancel()` or `egg_dbus_connection_pending_call_block()`.

### egg_dbus_bus_list_queued_owners_finish ()

    gboolean            egg_dbus_bus_list_queued_owners_finish
                                                            (EggDBusBus *instance,
                                                             gchar ***out_queued_owners,
                                                             GAsyncResult *res,
                                                             GError **error);

Finishes an asynchronous method invocation started with `egg_dbus_bus_list_queued_owners()`.

`instance` : | A EggDBusBus.
`out_queued_owners` : | Array of unique names in queue to own `name`. Free with `g_strfreev()`.
`res` : | A GAsyncResult obtained from the GAsyncReadyCallback function passed to `egg_dbus_bus_list_queued_owners()`.
`error` : | Return location for error.
Returns : | `TRUE` if the method call succeeded, `FALSE` if `error` is set.

### egg_dbus_bus_get_connection_unix_user ()

    guint               egg_dbus_bus_get_connection_unix_user
                                                            (EggDBusBus *instance,
                                                             EggDBusCallFlags call_flags,
                                                             const gchar *name,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);

Returns the UNIX user id of the process connected to the server. If unable to determine it, a `org`.freedesktop.DBus.Error.Failed error is returned.

This function asynchronously invokes the GetConnectionUnixUser() method on the org.freedesktop.DBus interface on the object represented by `instance`. When the reply is ready, `callback` will be called (on the main thread). You can then call `egg_dbus_bus_get_connection_unix_user_finish()` to get the result. See `egg_dbus_bus_get_connection_unix_user_sync()` for the synchronous version of this function.

`instance` : | A EggDBusBus.
`call_flags` : | Flags from EggDBusCallFlags detailing how the method should be invoked.
`name` : | Name of the connection to query.
`cancellable` : | A GCancellable or `NULL`.
`callback` : | Callback to invoke when the reply is ready.
`user_data` : | User data to pass to `callback`.
Returns : | A pending call id (never zero) that can be used with `egg_dbus_connection_pending_call_cancel()` or `egg_dbus_connection_pending_call_block()`.

### egg_dbus_bus_get_connection_unix_user_finish ()

    gboolean            egg_dbus_bus_get_connection_unix_user_finish
                                                            (EggDBusBus *instance,
                                                             uid_t *out_uid,
                                                             GAsyncResult *res,
                                                             GError **error);

Finishes an asynchronous method invocation started with `egg_dbus_bus_get_connection_unix_user()`.

`instance` : | A EggDBusBus.
`out_uid` : | UNIX user id.
`res` : | A GAsyncResult obtained from the GAsyncReadyCallback function passed to `egg_dbus_bus_get_connection_unix_user()`.
`error` : | Return location for error.
Returns : | `TRUE` if the method call succeeded, `FALSE` if `error` is set.

### egg_dbus_bus_get_connection_unix_process_id ()

    guint               egg_dbus_bus_get_connection_unix_process_id
                                                            (EggDBusBus *instance,
                                                             EggDBusCallFlags call_flags,
                                                             const gchar *name,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);

Returns the UNIX process id of the process connected to the server. If unable to determine it, a `org`.freedesktop.DBus.Error.Failed error is returned.

This function asynchronously invokes the GetConnectionUnixProcessID() method on the org.freedesktop.DBus interface on the object represented by `instance`. When the reply is ready, `callback` will be called (on the main thread). You can then call `egg_dbus_bus_get_connection_unix_process_id_finish()` to get the result. See `egg_dbus_bus_get_connection_unix_process_id_sync()` for the synchronous version of this function.

`instance` : | A EggDBusBus.
`call_flags` : | Flags from EggDBusCallFlags detailing how the method should be invoked.
`name` : | Name of the connection to query.
`cancellable` : | A GCancellable or `NULL`.
`callback` : | Callback to invoke when the reply is ready.
`user_data` : | User data to pass to `callback`.
Returns : | A pending call id (never zero) that can be used with `egg_dbus_connection_pending_call_cancel()` or `egg_dbus_connection_pending_call_block()`.

### egg_dbus_bus_get_connection_unix_process_id_finish ()

    gboolean            egg_dbus_bus_get_connection_unix_process_id_finish
                                                            (EggDBusBus *instance,
                                                             pid_t *out_pid,
                                                             GAsyncResult *res,
                                                             GError **error);

Finishes an asynchronous method invocation started with `egg_dbus_bus_get_connection_unix_process_id()`.

`instance` : | A EggDBusBus.
`out_pid` : | UNIX process id.
`res` : | A GAsyncResult obtained from the GAsyncReadyCallback function passed to `egg_dbus_bus_get_connection_unix_process_id()`.
`error` : | Return location for error.
Returns : | `TRUE` if the method call succeeded, `FALSE` if `error` is set.

### egg_dbus_bus_get_adt_audit_session_data ()

    guint               egg_dbus_bus_get_adt_audit_session_data
                                                            (EggDBusBus *instance,
                                                             EggDBusCallFlags call_flags,
                                                             const gchar *name,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);

Returns the Solaris/ADT auditing data of the process connected to the server. If unable to determine it, a `org`.freedesktop.DBus.Error.AdtAuditDataUnknown error is returned.

This function asynchronously invokes the GetAdtAuditSessionData() method on the org.freedesktop.DBus interface on the object represented by `instance`. When the reply is ready, `callback` will be called (on the main thread). You can then call `egg_dbus_bus_get_adt_audit_session_data_finish()` to get the result. See `egg_dbus_bus_get_adt_audit_session_data_sync()` for the synchronous version of this function.

`instance` : | A EggDBusBus.
`call_flags` : | Flags from EggDBusCallFlags detailing how the method should be invoked.
`name` : | Name of the connection to query.
`cancellable` : | A GCancellable or `NULL`.
`callback` : | Callback to invoke when the reply is ready.
`user_data` : | User data to pass to `callback`.
Returns : | A pending call id (never zero) that can be used with `egg_dbus_connection_pending_call_cancel()` or `egg_dbus_connection_pending_call_block()`.

### egg_dbus_bus_get_adt_audit_session_data_finish ()

    gboolean            egg_dbus_bus_get_adt_audit_session_data_finish
                                                            (EggDBusBus *instance,
                                                             EggDBusArraySeq **out_data,
                                                             GAsyncResult *res,
                                                             GError **error);

Finishes an asynchronous method invocation started with `egg_dbus_bus_get_adt_audit_session_data()`.

`instance` : | A EggDBusBus.
`out_data` : | An array of bytes (typically a string of undefined encoding). Free with `g_object_unref()`.
`res` : | A GAsyncResult obtained from the GAsyncReadyCallback function passed to `egg_dbus_bus_get_adt_audit_session_data()`.
`error` : | Return location for error.
Returns : | `TRUE` if the method call succeeded, `FALSE` if `error` is set.

### egg_dbus_bus_get_connection_se_linux_security_context ()

    guint               egg_dbus_bus_get_connection_se_linux_security_context
                                                            (EggDBusBus *instance,
                                                             EggDBusCallFlags call_flags,
                                                             const gchar *name,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);

Returns the SELinux security context of the process connected to the server. If unable to determine it, a `org`.freedesktop.DBus.Error.SELinuxSecurityContextUnknown error is returned.

This function asynchronously invokes the GetConnectionSELinuxSecurityContext() method on the org.freedesktop.DBus interface on the object represented by `instance`. When the reply is ready, `callback` will be called (on the main thread). You can then call `egg_dbus_bus_get_connection_se_linux_security_context_finish()` to get the result. See `egg_dbus_bus_get_connection_se_linux_security_context_sync()` for the synchronous version of this function.

`instance` : | A EggDBusBus.
`call_flags` : | Flags from EggDBusCallFlags detailing how the method should be invoked.
`name` : | Name of the connection to query.
`cancellable` : | A GCancellable or `NULL`.
`callback` : | Callback to invoke when the reply is ready.
`user_data` : | User data to pass to `callback`.
Returns : | A pending call id (never zero) that can be used with `egg_dbus_connection_pending_call_cancel()` or `egg_dbus_connection_pending_call_block()`.

### egg_dbus_bus_get_connection_se_linux_security_context_finish ()

    gboolean            egg_dbus_bus_get_connection_se_linux_security_context_finish
                                                            (EggDBusBus *instance,
                                                             EggDBusArraySeq **out_security_context,
                                                             GAsyncResult *res,
                                                             GError **error);

Finishes an asynchronous method invocation started with `egg_dbus_bus_get_connection_se_linux_security_context()`.

`instance` : | A EggDBusBus.
`out_security_context` : | An array of bytes (typically a string of undefined encoding). Free with `g_object_unref()`.
`res` : | A GAsyncResult obtained from the GAsyncReadyCallback function passed to `egg_dbus_bus_get_connection_se_linux_security_context()`.
`error` : | Return location for error.
Returns : | `TRUE` if the method call succeeded, `FALSE` if `error` is set.

### egg_dbus_bus_reload_config ()

    guint               egg_dbus_bus_reload_config          (EggDBusBus *instance,
                                                             EggDBusCallFlags call_flags,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);

Asks the message bus to reload configuration files.

This function asynchronously invokes the ReloadConfig() method on the org.freedesktop.DBus interface on the object represented by `instance`. When the reply is ready, `callback` will be called (on the main thread). You can then call `egg_dbus_bus_reload_config_finish()` to get the result. See `egg_dbus_bus_reload_config_sync()` for the synchronous version of this function.

`instance` : | A EggDBusBus.
`call_flags` : | Flags from EggDBusCallFlags detailing how the method should be invoked.
`cancellable` : | A GCancellable or `NULL`.
`callback` : | Callback to invoke when the reply is ready.
`user_data` : | User data to pass to `callback`.
Returns : | A pending call id (never zero) that can be used with `egg_dbus_connection_pending_call_cancel()` or `egg_dbus_connection_pending_call_block()`.

### egg_dbus_bus_reload_config_finish ()

    gboolean            egg_dbus_bus_reload_config_finish   (EggDBusBus *instance,
                                                             GAsyncResult *res,
                                                             GError **error);

Finishes an asynchronous method invocation started with `egg_dbus_bus_reload_config()`.

`instance` : | A EggDBusBus.
`res` : | A GAsyncResult obtained from the GAsyncReadyCallback function passed to `egg_dbus_bus_reload_config()`.
`error` : | Return location for error.
Returns : | `TRUE` if the method call succeeded, `FALSE` if `error` is set.

### egg_dbus_bus_get_id ()

    guint               egg_dbus_bus_get_id                 (EggDBusBus *instance,
                                                             EggDBusCallFlags call_flags,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);

Gets the unique ID of the bus. The unique ID here is shared among all addresses the bus daemon is listening on (TCP, UNIX domain socket, etc.). Each address the bus is listening on also has its own unique ID. The per-bus and per-address IDs are not related. For a desktop session bus, the bus ID can be used as a way to uniquely identify a user's session. See the D-Bus specification for more information about unique IDs.

This function asynchronously invokes the GetId() method on the org.freedesktop.DBus interface on the object represented by `instance`. When the reply is ready, `callback` will be called (on the main thread). You can then call `egg_dbus_bus_get_id_finish()` to get the result. See `egg_dbus_bus_get_id_sync()` for the synchronous version of this function.

`instance` : | A EggDBusBus.
`call_flags` : | Flags from EggDBusCallFlags detailing how the method should be invoked.
`cancellable` : | A GCancellable or `NULL`.
`callback` : | Callback to invoke when the reply is ready.
`user_data` : | User data to pass to `callback`.
Returns : | A pending call id (never zero) that can be used with `egg_dbus_connection_pending_call_cancel()` or `egg_dbus_connection_pending_call_block()`.

### egg_dbus_bus_get_id_finish ()

    gboolean            egg_dbus_bus_get_id_finish          (EggDBusBus *instance,
                                                             gchar **out_unique_id,
                                                             GAsyncResult *res,
                                                             GError **error);

Finishes an asynchronous method invocation started with `egg_dbus_bus_get_id()`.

`instance` : | A EggDBusBus.
`out_unique_id` : | Unique ID identifying the bus daemon. Free with `g_free()`.
`res` : | A GAsyncResult obtained from the GAsyncReadyCallback function passed to `egg_dbus_bus_get_id()`.
`error` : | Return location for error.
Returns : | `TRUE` if the method call succeeded, `FALSE` if `error` is set.

### egg_dbus_bus_handle_hello_finish ()

    void                egg_dbus_bus_handle_hello_finish    (EggDBusMethodInvocation *method_invocation,
                                                             const gchar *out_assigned_name);

Function to be called by implementers of the org.freedesktop.DBus D-Bus interface to finish handling the Hello() method.

`assigned_name` : | Unique name assigned to the connection.
`method_invocation` : | A EggDBusMethodInvocation.

### egg_dbus_bus_handle_request_name_finish ()

    void                egg_dbus_bus_handle_request_name_finish
                                                            (EggDBusMethodInvocation *method_invocation,
                                                             EggDBusRequestNameReply out_value);

Function to be called by implementers of the org.freedesktop.DBus D-Bus interface to finish handling the RequestName() method.

`value` : | Return value.
`method_invocation` : | A EggDBusMethodInvocation.

### egg_dbus_bus_handle_release_name_finish ()

    void                egg_dbus_bus_handle_release_name_finish
                                                            (EggDBusMethodInvocation *method_invocation,
                                                             EggDBusReleaseNameReply out_value);

Function to be called by implementers of the org.freedesktop.DBus D-Bus interface to finish handling the ReleaseName() method.

`value` : | Return value.
`method_invocation` : | A EggDBusMethodInvocation.

### egg_dbus_bus_handle_start_service_by_name_finish ()

    void                egg_dbus_bus_handle_start_service_by_name_finish
                                                            (EggDBusMethodInvocation *method_invocation,
                                                             EggDBusStartServiceByNameReply out_value);

Function to be called by implementers of the org.freedesktop.DBus D-Bus interface to finish handling the StartServiceByName() method.

`value` : | Reply
`method_invocation` : | A EggDBusMethodInvocation.

### egg_dbus_bus_handle_update_activation_environment_finish ()

    void                egg_dbus_bus_handle_update_activation_environment_finish
                                                            (EggDBusMethodInvocation *method_invocation);

Function to be called by implementers of the org.freedesktop.DBus D-Bus interface to finish handling the UpdateActivationEnvironment() method.

`method_invocation` : | A EggDBusMethodInvocation.

### egg_dbus_bus_handle_name_has_owner_finish ()

    void                egg_dbus_bus_handle_name_has_owner_finish
                                                            (EggDBusMethodInvocation *method_invocation,
                                                             gboolean out_has_owner);

Function to be called by implementers of the org.freedesktop.DBus D-Bus interface to finish handling the NameHasOwner() method.

`has_owner` : | `TRUE` only if `name` exists.
`method_invocation` : | A EggDBusMethodInvocation.

### egg_dbus_bus_handle_list_names_finish ()

    void                egg_dbus_bus_handle_list_names_finish
                                                            (EggDBusMethodInvocation *method_invocation,
                                                             gchar **out_names);

Function to be called by implementers of the org.freedesktop.DBus D-Bus interface to finish handling the ListNames() method.

`names` : | Array of strings where each string is a bus name.
`method_invocation` : | A EggDBusMethodInvocation.

### egg_dbus_bus_handle_list_activatable_names_finish ()

    void                egg_dbus_bus_handle_list_activatable_names_finish
                                                            (EggDBusMethodInvocation *method_invocation,
                                                             gchar **out_activatable_names);

Function to be called by implementers of the org.freedesktop.DBus D-Bus interface to finish handling the ListActivatableNames() method.

`activatable_names` : | Array of strings where each string is a bus name.
`method_invocation` : | A EggDBusMethodInvocation.

### egg_dbus_bus_handle_add_match_finish ()

    void                egg_dbus_bus_handle_add_match_finish
                                                            (EggDBusMethodInvocation *method_invocation);

Function to be called by implementers of the org.freedesktop.DBus D-Bus interface to finish handling the AddMatch() method.

`method_invocation` : | A EggDBusMethodInvocation.

### egg_dbus_bus_handle_remove_match_finish ()

    void                egg_dbus_bus_handle_remove_match_finish
                                                            (EggDBusMethodInvocation *method_invocation);

Function to be called by implementers of the org.freedesktop.DBus D-Bus interface to finish handling the RemoveMatch() method.

`method_invocation` : | A EggDBusMethodInvocation.

### egg_dbus_bus_handle_get_name_owner_finish ()

    void                egg_dbus_bus_handle_get_name_owner_finish
                                                            (EggDBusMethodInvocation *method_invocation,
                                                             const gchar *out_unique_name);

Function to be called by implementers of the org.freedesktop.DBus D-Bus interface to finish handling the GetNameOwner() method.

`unique_name` : | The unique name that owns `name`.
`method_invocation` : | A EggDBusMethodInvocation.

### egg_dbus_bus_handle_list_queued_owners_finish ()

    void                egg_dbus_bus_handle_list_queued_owners_finish
                                                            (EggDBusMethodInvocation *method_invocation,
                                                             gchar **out_queued_owners);

Function to be called by implementers of the org.freedesktop.DBus D-Bus interface to finish handling the ListQueuedOwners() method.

`queued_owners` : | Array of unique names in queue to own `name`.
`method_invocation` : | A EggDBusMethodInvocation.

### egg_dbus_bus_handle_get_connection_unix_user_finish ()

    void                egg_dbus_bus_handle_get_connection_unix_user_finish
                                                            (EggDBusMethodInvocation *method_invocation,
                                                             uid_t out_uid);

Function to be called by implementers of the org.freedesktop.DBus D-Bus interface to finish handling the GetConnectionUnixUser() method.

`uid` : | UNIX user id.
`method_invocation` : | A EggDBusMethodInvocation.

### egg_dbus_bus_handle_get_connection_unix_process_id_finish ()

    void                egg_dbus_bus_handle_get_connection_unix_process_id_finish
                                                            (EggDBusMethodInvocation *method_invocation,
                                                             pid_t out_pid);

Function to be called by implementers of the org.freedesktop.DBus D-Bus interface to finish handling the GetConnectionUnixProcessID() method.

`pid` : | UNIX process id.
`method_invocation` : | A EggDBusMethodInvocation.

### egg_dbus_bus_handle_get_adt_audit_session_data_finish ()

    void                egg_dbus_bus_handle_get_adt_audit_session_data_finish
                                                            (EggDBusMethodInvocation *method_invocation,
                                                             EggDBusArraySeq *out_data);

Function to be called by implementers of the org.freedesktop.DBus D-Bus interface to finish handling the GetAdtAuditSessionData() method.

`data` : | An array of bytes (typically a string of undefined encoding).
`method_invocation` : | A EggDBusMethodInvocation.

### egg_dbus_bus_handle_get_connection_se_linux_security_context_finish ()

    void                egg_dbus_bus_handle_get_connection_se_linux_security_context_finish
                                                            (EggDBusMethodInvocation *method_invocation,
                                                             EggDBusArraySeq *out_security_context);

Function to be called by implementers of the org.freedesktop.DBus D-Bus interface to finish handling the GetConnectionSELinuxSecurityContext() method.

`security_context` : | An array of bytes (typically a string of undefined encoding).
`method_invocation` : | A EggDBusMethodInvocation.

### egg_dbus_bus_handle_reload_config_finish ()

    void                egg_dbus_bus_handle_reload_config_finish
                                                            (EggDBusMethodInvocation *method_invocation);

Function to be called by implementers of the org.freedesktop.DBus D-Bus interface to finish handling the ReloadConfig() method.

`method_invocation` : | A EggDBusMethodInvocation.

### egg_dbus_bus_handle_get_id_finish ()

    void                egg_dbus_bus_handle_get_id_finish   (EggDBusMethodInvocation *method_invocation,
                                                             const gchar *out_unique_id);

Function to be called by implementers of the org.freedesktop.DBus D-Bus interface to finish handling the GetId() method.

`unique_id` : | Unique ID identifying the bus daemon
`method_invocation` : | A EggDBusMethodInvocation.

### egg_dbus_bus_emit_signal_name_owner_changed ()

    void                egg_dbus_bus_emit_signal_name_owner_changed
                                                            (EggDBusBus *instance,
                                                             const gchar *destination,
                                                             const gchar *name,
                                                             const gchar *old_owner,
                                                             const gchar *new_owner);

Type safe wrapper for emitting the "name-owner-changed" signal.

`instance` : | A GObject derived type implementing the EggDBusBus interface.
`destination` : | The destination of the signal or `NULL` to emit signals to all listeners.
`name` : | Name with new owner.
`old_owner` : | Old owner or empty string if none.
`new_owner` : | New owner or empty string if none.

### egg_dbus_bus_emit_signal_name_lost ()

    void                egg_dbus_bus_emit_signal_name_lost  (EggDBusBus *instance,
                                                             const gchar *destination,
                                                             const gchar *name);

Type safe wrapper for emitting the "name-lost" signal.

`instance` : | A GObject derived type implementing the EggDBusBus interface.
`destination` : | The destination of the signal or `NULL` to emit signals to all listeners.
`name` : | Name which was lost.

### egg_dbus_bus_emit_signal_name_acquired ()

    void                egg_dbus_bus_emit_signal_name_acquired
                                                            (EggDBusBus *instance,
                                                             const gchar *destination,
                                                             const gchar *name);

Type safe wrapper for emitting the "name-acquired" signal.

`instance` : | A GObject derived type implementing the EggDBusBus interface.
`destination` : | The destination of the signal or `NULL` to emit signals to all listeners.
`name` : | Name which was acquired.

## Signal Details

### The `"name-acquired"` signal

    void                user_function                      (EggDBusBus *instance,
                                                            gchar      *name,
                                                            gpointer    user_data)      : Run Last

This signal is sent to a specific application when it gains ownership of a name.

`instance` : | A EggDBusBus.
`name` : | Name which was acquired.
`user_data` : | user data set when the signal handler was connected.

### The `"name-lost"` signal

    void                user_function                      (EggDBusBus *instance,
                                                            gchar      *name,
                                                            gpointer    user_data)      : Run Last

This signal is sent to a specific application when it loses ownership of a name.

`instance` : | A EggDBusBus.
`name` : | Name which was lost.
`user_data` : | user data set when the signal handler was connected.

### The `"name-owner-changed"` signal

    void                user_function                      (EggDBusBus *instance,
                                                            gchar      *name,
                                                            gchar      *old_owner,
                                                            gchar      *new_owner,
                                                            gpointer    user_data)      : Run Last

This signal indicates that the owner of a name has changed. It's also the signal to use to detect the appearance of new names on the bus.

`instance` : | A EggDBusBus.
`name` : | Name with new owner.
`old_owner` : | Old owner or empty string if none.
`new_owner` : | New owner or empty string if none.
`user_data` : | user data set when the signal handler was connected.