/* This function acts like dbus_bus_get but creates a private
* connection instead. */
static DBusConnection* avahi_dbus_bus_get(DBusError *error) {
DBusConnection *c;
#ifdef HAVE_DBUS_BUS_GET_PRIVATE
if (!(c = dbus_bus_get_private(DBUS_BUS_SYSTEM, error)))
return NULL;
dbus_connection_set_exit_on_disconnect(c, FALSE);
#else
const char *a;
if (!(a = getenv("DBUS_SYSTEM_BUS_ADDRESS")) || !*a)
a = DBUS_SYSTEM_BUS_DEFAULT_ADDRESS;
if (!(c = dbus_connection_open_private(a, error)))
return NULL;
dbus_connection_set_exit_on_disconnect(c, FALSE);
if (!dbus_bus_register(c, error)) {
#ifdef HAVE_DBUS_CONNECTION_CLOSE
dbus_connection_close(c);
#else
dbus_connection_disconnect(c);
#endif
dbus_connection_unref(c);
return NULL;
}
#endif
return c;
}
static DBusConnection *
_asdbus_get_session_connection()
{
DBusError error;
int res;
DBusConnection *session_conn;
dbus_error_init (&error);
session_conn = dbus_bus_get (DBUS_BUS_SESSION, &error);
if (dbus_error_is_set (&error)) {
show_error ("Failed to connect to Session DBus: %s", error.message);
} else {
dbus_connection_set_exit_on_disconnect (session_conn, FALSE);
res = dbus_bus_request_name (session_conn,
AFTERSTEP_DBUS_SERVICE_NAME,
DBUS_NAME_FLAG_REPLACE_EXISTING |
DBUS_NAME_FLAG_ALLOW_REPLACEMENT,
&error);
if (dbus_error_is_set (&error)) {
show_error ("Failed to request name from DBus: %s", error.message);
} else if (res != DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER) {
show_error ("Failed to request name from DBus - not a primary owner.");
} else {
dbus_connection_register_object_path (session_conn,
AFTERSTEP_DBUS_ROOT_PATH,
&ASDBusMessagesVTable, 0);
}
}
if (dbus_error_is_set (&error))
dbus_error_free (&error);
return session_conn;
}
int Keyboard::dbus_connect()
{
DBusError error;
dbus_error_init(&error);
if (!(conn = dbus_bus_get_private(DBUS_BUS_SESSION, &error)))
{
CLog::Log(LOGWARNING, "dbus_bus_get_private(): %s", error.message);
goto fail;
}
dbus_connection_set_exit_on_disconnect(conn, FALSE);
return 0;
fail:
if (dbus_error_is_set(&error))
dbus_error_free(&error);
if (conn)
{
dbus_connection_close(conn);
dbus_connection_unref(conn);
conn = NULL;
}
return -1;
}
/* Returns true on success (even if adapter is present but disabled).
* Return false if dbus is down, or another serious error (out of memory)
*/
static bool initNative(JNIEnv* env, jobject object) {
LOGV(__FUNCTION__);
#ifdef HAVE_BLUETOOTH
nat = (native_data_t *)calloc(1, sizeof(native_data_t));
if (NULL == nat) {
LOGE("%s: out of memory!", __FUNCTION__);
return false;
}
env->GetJavaVM( &(nat->vm) );
nat->envVer = env->GetVersion();
nat->me = env->NewGlobalRef(object);
DBusError err;
dbus_error_init(&err);
dbus_threads_init_default();
nat->conn = dbus_bus_get(DBUS_BUS_SYSTEM, &err);
if (dbus_error_is_set(&err)) {
LOGE("Could not get onto the system bus: %s", err.message);
dbus_error_free(&err);
return false;
}
dbus_connection_set_exit_on_disconnect(nat->conn, FALSE);
#endif /*HAVE_BLUETOOTH*/
return true;
}
static DBusGConnection *
get_session_bus (void)
{
GError *error;
DBusGConnection *bus;
DBusConnection *connection;
error = NULL;
bus = dbus_g_bus_get (DBUS_BUS_SESSION, &error);
if (bus == NULL) {
g_warning ("Couldn't connect to session bus: %s",
error->message);
g_error_free (error);
goto out;
}
connection = dbus_g_connection_get_connection (bus);
dbus_connection_add_filter (connection,
(DBusHandleMessageFunction)
bus_message_handler,
NULL, NULL);
dbus_connection_set_exit_on_disconnect (connection, FALSE);
out:
return bus;
}
static bool cgm_dbus_connect(void)
{
DBusError dbus_error;
dbus_error_init(&dbus_error);
connection = dbus_connection_open_private(CGMANAGER_DBUS_SOCK, &dbus_error);
if (!connection) {
dbus_error_free(&dbus_error);
return false;
}
dbus_connection_set_exit_on_disconnect(connection, FALSE);
dbus_error_free(&dbus_error);
cgroup_manager = nih_dbus_proxy_new(NULL, connection,
NULL /* p2p */,
"/org/linuxcontainers/cgmanager", NULL, NULL);
if (!cgroup_manager) {
NihError *nerr;
nerr = nih_error_get();
nih_free(nerr);
cgm_dbus_disconnect();
return false;
}
// force fd passing negotiation
if (cgmanager_ping_sync(NULL, cgroup_manager, 0) != 0) {
NihError *nerr;
nerr = nih_error_get();
nih_free(nerr);
cgm_dbus_disconnect();
return false;
}
return true;
}
static void
_new_connection (DBusServer *server,
DBusConnection *connection,
void *data)
{
ServiceData *svc = (ServiceData *)data;
DBusObjectPathVTable vt = {
_unregister_handler,
_handle_message,
NULL, NULL, NULL, NULL
};
rb_debug ("new connection to metadata service");
/* don't allow more than one connection at a time */
if (svc->connection) {
rb_debug ("metadata service already has a client. go away.");
return;
}
dbus_connection_register_object_path (connection,
RB_METADATA_DBUS_OBJECT_PATH,
&vt,
svc);
dbus_connection_ref (connection);
dbus_connection_setup_with_g_main (connection,
g_main_loop_get_context (svc->loop));
if (!svc->external)
dbus_connection_set_exit_on_disconnect (connection, TRUE);
}
void init_dbus()
{
GError *error = NULL;
DBusConnection *local_conn;
main_thread = g_thread_self();
info_mutex = g_mutex_new();
info_cond = g_cond_new();
AUDDBG ("Trying to initialize D-Bus.\n");
dbus_conn = dbus_g_bus_get(DBUS_BUS_SESSION, &error);
if (dbus_conn == NULL)
{
g_warning("Unable to connect to dbus: %s", error->message);
g_error_free(error);
return;
}
g_type_init();
g_object_new(audacious_rc_get_type(), NULL);
g_object_new(mpris_root_get_type(), NULL);
mpris = g_object_new(mpris_player_get_type(), NULL);
g_object_new(mpris_tracklist_get_type(), NULL);
local_conn = dbus_g_connection_get_connection(dbus_conn);
dbus_connection_set_exit_on_disconnect(local_conn, FALSE);
}
/**
* hd_status_plugin_item_get_dbus_connection:
* @item: A #HDStatusPluginItem
* @type: The #DBusBusType %DBUS_BUS_SESSION or %DBUS_BUS_SYSTEM
* @error: A #DBusError to return error messages
*
* Creates a new private #DBusConnection to the D-Bus session or system bus.
*
* It is similar to the dbus_bus_get_private() function but in contrast to the
* dbus_bus_get_private() function the application will not exit if the connection
* closes. Additionally this function is used to map the unique D-Bus name to the
* plugin.
*
* So this function should be used by plugins to create D-Bus connections.
*
* Returns: A new private connection to bus %type. The connection must be unrefed with dbus_connection_unref() when it is not longer needed.
**/
DBusConnection *
hd_status_plugin_item_get_dbus_connection (HDStatusPluginItem *item,
DBusBusType type,
DBusError *error)
{
DBusConnection *connection;
g_return_val_if_fail (HD_IS_STATUS_PLUGIN_ITEM (item), NULL);
/* Create a private connection */
connection = dbus_bus_get_private (type, error);
if (!connection || (error != NULL && dbus_error_is_set (error)))
return NULL;
/* Do not exit on disconnect */
dbus_connection_set_exit_on_disconnect (connection, FALSE);
/* Log the connection name for debug purposes */
g_debug ("Plugin '%s' opened D-Bus connection '%s'.",
hd_status_plugin_item_get_dl_filename (item),
dbus_bus_get_unique_name (connection));
return connection;
}
int weston_dbus_open(struct wl_event_loop *loop, DBusBusType bus,
DBusConnection **out, struct wl_event_source **ctx_out)
{
DBusConnection *c;
int r;
/* Ihhh, global state.. stupid dbus. */
dbus_connection_set_change_sigpipe(FALSE);
/* This is actually synchronous. It blocks for some authentication and
* setup. We just trust the dbus-server here and accept this blocking
* call. There is no real reason to complicate things further and make
* this asynchronous/non-blocking. A context should be created during
* thead/process/app setup, so blocking calls should be fine. */
c = dbus_bus_get_private(bus, NULL);
if (!c)
return -EIO;
dbus_connection_set_exit_on_disconnect(c, FALSE);
r = weston_dbus_bind(loop, c, ctx_out);
if (r < 0)
goto error;
*out = c;
return r;
error:
dbus_connection_close(c);
dbus_connection_unref(c);
return r;
}
CUPowerSyscall::CUPowerSyscall()
{
CLog::Log(LOGINFO, "Selected UPower as PowerSyscall");
m_lowBattery = false;
//! @todo do not use dbus_connection_pop_message() that requires the use of a
//! private connection
if (m_connection.Connect(DBUS_BUS_SYSTEM, true))
{
dbus_connection_set_exit_on_disconnect(m_connection, false);
CDBusError error;
dbus_bus_add_match(m_connection, "type='signal',interface='org.freedesktop.UPower'", error);
dbus_connection_flush(m_connection);
if (error)
{
error.Log("UPower: Failed to attach to signal");
m_connection.Destroy();
}
}
m_CanPowerdown = false;
m_CanReboot = false;
UpdateCapabilities();
EnumeratePowerSources();
}
CConsoleUPowerSyscall::CConsoleUPowerSyscall()
{
CLog::Log(LOGINFO, "Selected UPower and ConsoleKit as PowerSyscall");
m_lowBattery = false;
dbus_error_init (&m_error);
// TODO: do not use dbus_connection_pop_message() that requires the use of a
// private connection
m_connection = dbus_bus_get_private(DBUS_BUS_SYSTEM, &m_error);
if (m_connection)
{
dbus_connection_set_exit_on_disconnect(m_connection, false);
dbus_bus_add_match(m_connection, "type='signal',interface='org.freedesktop.UPower'", &m_error);
dbus_connection_flush(m_connection);
}
if (dbus_error_is_set(&m_error))
{
CLog::Log(LOGERROR, "UPower: Failed to attach to signal %s", m_error.message);
dbus_connection_close(m_connection);
dbus_connection_unref(m_connection);
m_connection = NULL;
}
m_CanPowerdown = ConsoleKitMethodCall("CanStop");
m_CanReboot = ConsoleKitMethodCall("CanRestart");
UpdateUPower();
EnumeratePowerSources();
}
/**
* upstart_open:
* @parent: parent object for new proxy.
*
* Opens a connection to the Upstart init daemon and returns a proxy
* to the manager object. If @dest_name is not NULL, a connection is
* instead opened to the system bus and the proxy linked to the
* well-known name given.
*
* If @parent is not NULL, it should be a pointer to another object
* which will be used as a parent for the returned proxy. When all
* parents of the returned proxy are freed, the returned proxy will
* also be freed.
*
* Returns: newly allocated D-Bus proxy or NULL on raised error.
**/
NihDBusProxy *
upstart_open (const void *parent)
{
DBusError dbus_error;
DBusConnection *connection;
NihDBusProxy * upstart;
dbus_error_init (&dbus_error);
connection = dbus_bus_get (DBUS_BUS_SYSTEM, &dbus_error);
if (! connection) {
nih_dbus_error_raise (dbus_error.name, dbus_error.message);
dbus_error_free (&dbus_error);
return NULL;
}
dbus_connection_set_exit_on_disconnect (connection, FALSE);
dbus_error_free (&dbus_error);
upstart = nih_dbus_proxy_new (parent, connection,
DBUS_SERVICE_UPSTART,
DBUS_PATH_UPSTART,
NULL, NULL);
if (! upstart) {
dbus_connection_unref (connection);
return NULL;
}
upstart->auto_start = FALSE;
/* Drop initial reference now the proxy holds one */
dbus_connection_unref (connection);
return upstart;
}
pa_dbus_wrap_connection* pa_dbus_wrap_connection_new(pa_mainloop_api *m, pa_bool_t use_rtclock, DBusBusType type, DBusError *error) {
DBusConnection *conn;
pa_dbus_wrap_connection *pconn;
char *id;
pa_assert(type == DBUS_BUS_SYSTEM || type == DBUS_BUS_SESSION || type == DBUS_BUS_STARTER);
if (!(conn = dbus_bus_get_private(type, error)))
return NULL;
pconn = pa_xnew(pa_dbus_wrap_connection, 1);
pconn->mainloop = m;
pconn->connection = conn;
pconn->use_rtclock = use_rtclock;
dbus_connection_set_exit_on_disconnect(conn, FALSE);
dbus_connection_set_dispatch_status_function(conn, dispatch_status, pconn, NULL);
dbus_connection_set_watch_functions(conn, add_watch, remove_watch, toggle_watch, pconn, NULL);
dbus_connection_set_timeout_functions(conn, add_timeout, remove_timeout, toggle_timeout, pconn, NULL);
dbus_connection_set_wakeup_main_function(conn, wakeup_main, pconn, NULL);
pconn->dispatch_event = pconn->mainloop->defer_new(pconn->mainloop, dispatch_cb, conn);
pa_log_debug("Successfully connected to D-Bus %s bus %s as %s",
type == DBUS_BUS_SYSTEM ? "system" : (type == DBUS_BUS_SESSION ? "session" : "starter"),
pa_strnull((id = dbus_connection_get_server_id(conn))),
pa_strnull(dbus_bus_get_unique_name(conn)));
dbus_free(id);
return pconn;
}
static DBusConnection *virDBusBusInit(DBusBusType type, DBusError *dbuserr)
{
DBusConnection *bus;
/* Allocate and initialize a new HAL context */
dbus_connection_set_change_sigpipe(FALSE);
dbus_threads_init_default();
dbus_error_init(dbuserr);
bus = sharedBus ?
dbus_bus_get(type, dbuserr) :
dbus_bus_get_private(type, dbuserr);
if (!bus)
return NULL;
dbus_connection_set_exit_on_disconnect(bus, FALSE);
/* Register dbus watch callbacks */
if (!dbus_connection_set_watch_functions(bus,
virDBusAddWatch,
virDBusRemoveWatch,
virDBusToggleWatch,
bus, NULL)) {
return NULL;
}
return bus;
}
gboolean
gconfd_dbus_init (void)
{
DBusError error;
gint ret;
dbus_error_init (&error);
bus_conn = dbus_bus_get (DBUS_BUS_SESSION, &error);
if (!bus_conn)
{
gconf_log (GCL_ERR, _("Daemon failed to connect to the D-BUS daemon:\n%s"),
error.message);
dbus_error_free (&error);
return FALSE;
}
/* We handle exiting ourselves on disconnect. */
dbus_connection_set_exit_on_disconnect (bus_conn, FALSE);
/* Add message filter to handle Disconnected. */
dbus_connection_add_filter (bus_conn,
(DBusHandleMessageFunction) server_filter_func,
NULL, NULL);
ret = dbus_bus_request_name (bus_conn,
GCONF_DBUS_SERVICE,
0,
&error);
if (ret != DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER)
{
gconf_log (GCL_ERR, "Daemon could not become primary owner");
return FALSE;
}
if (dbus_error_is_set (&error))
{
gconf_log (GCL_ERR, _("Daemon failed to acquire gconf service:\n%s"),
error.message);
dbus_error_free (&error);
return FALSE;
}
if (!dbus_connection_register_object_path (bus_conn,
server_path,
&server_vtable,
NULL))
{
gconf_log (GCL_ERR, _("Failed to register server object with the D-BUS bus daemon"));
return FALSE;
}
nr_of_connections = 1;
dbus_connection_setup_with_g_main (bus_conn, NULL);
return TRUE;
}
static void
_cs_dbus_init(void)
{
DBusConnection *dbc = NULL;
DBusError err;
dbus_error_init(&err);
dbc = dbus_bus_get(DBUS_BUS_SYSTEM, &err);
if (!dbc) {
snprintf(_err, sizeof(_err),
"dbus_bus_get: %s", err.message);
err_set = 1;
dbus_error_free(&err);
return;
}
dbus_connection_set_exit_on_disconnect(dbc, FALSE);
db = dbc;
notifiers[num_notifiers].node_membership_fn =
_cs_dbus_node_membership_event;
notifiers[num_notifiers].node_quorum_fn =
_cs_dbus_node_quorum_event;
notifiers[num_notifiers].application_connection_fn =
_cs_dbus_application_connection_event;
notifiers[num_notifiers].rrp_faulty_fn =
_cs_dbus_rrp_faulty_event;
num_notifiers++;
}
/* returns NULL or error message, may fail silently if dbus daemon not yet up. */
char *dbus_init(void)
{
DBusConnection *connection = NULL;
DBusObjectPathVTable dnsmasq_vtable = {NULL, &message_handler, NULL, NULL, NULL, NULL };
DBusError dbus_error;
DBusMessage *message;
dbus_error_init (&dbus_error);
if (!(connection = dbus_bus_get (DBUS_BUS_SYSTEM, &dbus_error)))
return NULL;
dbus_connection_set_exit_on_disconnect(connection, FALSE);
dbus_connection_set_watch_functions(connection, add_watch, remove_watch,
NULL, NULL, NULL);
dbus_error_init (&dbus_error);
dbus_bus_request_name (connection, daemon->dbus_name, 0, &dbus_error);
if (dbus_error_is_set (&dbus_error))
return (char *)dbus_error.message;
if (!dbus_connection_register_object_path(connection, DNSMASQ_PATH,
&dnsmasq_vtable, NULL))
return _("could not register a DBus message handler");
daemon->dbus = connection;
if ((message = dbus_message_new_signal(DNSMASQ_PATH, daemon->dbus_name, "Up")))
{
dbus_connection_send(connection, message, NULL);
dbus_message_unref(message);
}
return NULL;
}
int elektraDbusSendMessage (DBusBusType type, const char * keyName, const char * signalName)
{
DBusConnection * connection;
DBusError error;
DBusMessage * message;
const char * dest = NULL; // to all receivers
const char * interface = "org.libelektra";
const char * path = "/org/libelektra/configuration";
dbus_error_init (&error);
connection = dbus_bus_get (type, &error);
if (connection == NULL)
{
ELEKTRA_LOG_WARNING ("Failed to open connection to %s message bus: %s", (type == DBUS_BUS_SYSTEM) ? "system" : "session",
error.message);
dbus_connection_unref (connection);
dbus_error_free (&error);
return -1;
}
dbus_connection_set_exit_on_disconnect (connection, FALSE);
message = dbus_message_new_signal (path, interface, signalName);
if (message == NULL)
{
ELEKTRA_LOG_WARNING ("Couldn't allocate D-Bus message");
dbus_connection_unref (connection);
dbus_error_free (&error);
return -1;
}
if (dest && !dbus_message_set_destination (message, dest))
{
ELEKTRA_LOG_WARNING ("Not enough memory");
dbus_message_unref (message);
dbus_connection_unref (connection);
dbus_error_free (&error);
return -1;
}
if (!dbus_message_append_args (message, DBUS_TYPE_STRING, &keyName, DBUS_TYPE_INVALID))
{
ELEKTRA_LOG_WARNING ("Couldn't add message argument");
dbus_message_unref (message);
dbus_connection_unref (connection);
dbus_error_free (&error);
return -1;
}
dbus_connection_send (connection, message, NULL);
dbus_connection_flush (connection);
dbus_message_unref (message);
dbus_connection_unref (connection);
dbus_error_free (&error);
return 1;
}
::DBusConnection* createConnection() {
const ::DBusBusType libdbusType = ::DBusBusType::DBUS_BUS_SESSION;
::DBusConnection* libdbusConnection = dbus_bus_get_private(libdbusType, NULL);
dbus_connection_ref(libdbusConnection);
dbus_connection_set_exit_on_disconnect(libdbusConnection, false);
return libdbusConnection;
}
int
main (int argc, char *argv[])
{
DBusConnection *dbus_connection;
DBusError error;
const char *commandline;
hal_set_proc_title_init (argc, argv);
setup_logger ();
dbus_error_init (&error);
if ((ctx = libhal_ctx_init_direct (&error)) == NULL) {
HAL_WARNING (("Unable to init libhal context"));
goto out;
}
if ((dbus_connection = libhal_ctx_get_dbus_connection(ctx)) == NULL) {
HAL_WARNING (("Cannot get DBus connection"));
goto out;
}
if ((commandline = getenv ("SINGLETON_COMMAND_LINE")) == NULL) {
HAL_WARNING (("SINGLETON_COMMAND_LINE not set"));
goto out;
}
libhal_ctx_set_singleton_device_added (ctx, add_device);
libhal_ctx_set_singleton_device_removed (ctx, remove_device);
dbus_connection_setup_with_g_main (dbus_connection, NULL);
dbus_connection_set_exit_on_disconnect (dbus_connection, 0);
if (!libhal_device_singleton_addon_is_ready (ctx, commandline, &error)) {
goto out;
}
leds = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
gmain = g_main_loop_new (NULL, FALSE);
g_main_loop_run (gmain);
return 0;
out:
HAL_DEBUG (("An error occured, exiting cleanly"));
LIBHAL_FREE_DBUS_ERROR (&error);
if (ctx != NULL) {
libhal_ctx_shutdown (ctx, &error);
LIBHAL_FREE_DBUS_ERROR (&error);
libhal_ctx_free (ctx);
}
return 0;
}
void pcmk_dbus_connection_setup_with_select(DBusConnection *c){
dbus_connection_set_exit_on_disconnect (c, FALSE);
dbus_connection_set_timeout_functions(
c, pcmk_dbus_timeout_add, pcmk_dbus_timeout_remove, pcmk_dbus_timeout_toggle, NULL, NULL);
dbus_connection_set_watch_functions(c, pcmk_dbus_watch_add, pcmk_dbus_watch_remove, pcmk_dbus_watch_toggle, NULL, NULL);
dbus_connection_set_dispatch_status_function(c, pcmk_dbus_connection_dispatch, NULL, NULL);
pcmk_dbus_connection_dispatch(c, dbus_connection_get_dispatch_status(c), NULL);
}
void
_folks_test_case_dbus_1_set_no_exit_on_disconnect (void)
{
DBusConnection *conn = dbus_bus_get (DBUS_BUS_SESSION, NULL);
if (conn != NULL)
{
dbus_connection_set_exit_on_disconnect (conn, FALSE);
dbus_connection_unref (conn);
}
}
nsWifiScannerDBus::nsWifiScannerDBus(nsCOMArray<nsWifiAccessPoint> *aAccessPoints)
: mAccessPoints(aAccessPoints)
{
MOZ_ASSERT(mAccessPoints);
mConnection = dbus_bus_get(DBUS_BUS_SYSTEM, nullptr);
MOZ_ASSERT(mConnection);
dbus_connection_set_exit_on_disconnect(mConnection, false);
MOZ_COUNT_CTOR(nsWifiScannerDBus);
}
NS_IMETHODIMP
nsGIOService::OrgFreedesktopFileManager1ShowItems(const nsACString& aPath)
{
#ifndef MOZ_ENABLE_DBUS
return NS_ERROR_FAILURE;
#else
GError* error = nullptr;
static bool org_freedesktop_FileManager1_exists = true;
if (!org_freedesktop_FileManager1_exists) {
return NS_ERROR_NOT_AVAILABLE;
}
DBusGConnection* dbusGConnection = dbus_g_bus_get(DBUS_BUS_SESSION, &error);
if (!dbusGConnection) {
if (error) {
g_printerr("Failed to open connection to session bus: %s\n", error->message);
g_error_free(error);
}
return NS_ERROR_FAILURE;
}
char *uri = g_filename_to_uri(PromiseFlatCString(aPath).get(), nullptr, nullptr);
if (uri == nullptr) {
return NS_ERROR_FAILURE;
}
DBusConnection* dbusConnection = dbus_g_connection_get_connection(dbusGConnection);
// Make sure we do not exit the entire program if DBus connection get lost.
dbus_connection_set_exit_on_disconnect(dbusConnection, false);
DBusGProxy* dbusGProxy = dbus_g_proxy_new_for_name(dbusGConnection,
"org.freedesktop.FileManager1",
"/org/freedesktop/FileManager1",
"org.freedesktop.FileManager1");
const char *uris[2] = { uri, nullptr };
gboolean rv_dbus_call = dbus_g_proxy_call (dbusGProxy, "ShowItems", nullptr, G_TYPE_STRV, uris,
G_TYPE_STRING, "", G_TYPE_INVALID, G_TYPE_INVALID);
g_object_unref(dbusGProxy);
dbus_g_connection_unref(dbusGConnection);
g_free(uri);
if (!rv_dbus_call) {
org_freedesktop_FileManager1_exists = false;
return NS_ERROR_NOT_AVAILABLE;
}
return NS_OK;
#endif
}
static void
setup (Test *test,
gconstpointer data)
{
GError *error = NULL;
GQuark features[] = { TP_CONNECTION_FEATURE_CONNECTED, 0 };
tp_debug_set_flags ("all");
test->dbus = tp_tests_dbus_daemon_dup_or_die ();
test->mainloop = g_main_loop_new (NULL, FALSE);
test->error = NULL;
test->client_libdbus = dbus_bus_get_private (DBUS_BUS_STARTER, NULL);
g_assert (test->client_libdbus != NULL);
dbus_connection_setup_with_g_main (test->client_libdbus, NULL);
dbus_connection_set_exit_on_disconnect (test->client_libdbus, FALSE);
test->client_dbusglib = dbus_connection_get_g_connection (
test->client_libdbus);
dbus_g_connection_ref (test->client_dbusglib);
test->client_bus = tp_dbus_daemon_new (test->client_dbusglib);
g_assert (test->client_bus != NULL);
test->service_conn = tp_tests_object_new_static_class (
EXAMPLE_TYPE_CONTACT_LIST_CONNECTION,
"account", "*****@*****.**",
"protocol", "simple-protocol",
NULL);
test->service_conn_as_base = TP_BASE_CONNECTION (test->service_conn);
g_assert (test->service_conn != NULL);
g_assert (test->service_conn_as_base != NULL);
g_assert (tp_base_connection_register (test->service_conn_as_base, "simple",
&test->conn_name, &test->conn_path, &error));
g_assert_no_error (error);
test->cwr_ready = FALSE;
test->cwr_error = NULL;
test->conn = tp_connection_new (test->client_bus, test->conn_name,
test->conn_path, &error);
g_assert (test->conn != NULL);
g_assert_no_error (error);
tp_cli_connection_call_connect (test->conn, -1, NULL, NULL, NULL, NULL);
g_assert (!tp_proxy_is_prepared (test->conn, TP_CONNECTION_FEATURE_CORE));
g_assert (!tp_proxy_is_prepared (test->conn,
TP_CONNECTION_FEATURE_CONNECTED));
g_assert (!tp_proxy_is_prepared (test->conn, TP_CONNECTION_FEATURE_BALANCE));
tp_tests_proxy_run_until_prepared (test->conn, features);
}
static bool
_changed(pxNetworkModule *s)
{
pxNetworkManagerNetworkModule *self = (pxNetworkManagerNetworkModule *) s;
// Make sure we have a valid connection with a proper match
DBusConnection *conn = self->conn;
if (!conn || !dbus_connection_get_is_connected(conn))
{
// If the connection was disconnected,
// close it an clear the queue
if (conn)
{
dbus_connection_close(conn);
dbus_connection_read_write(conn, 0);
for (DBusMessage *msg=NULL ; (msg = dbus_connection_pop_message(conn)) ; dbus_message_unref(msg));
}
// Create a new connections
conn = dbus_bus_get_private(DBUS_BUS_SYSTEM, NULL);
self->conn = conn;
if (!conn) return false;
// If connection was successful, set it up
dbus_connection_set_exit_on_disconnect(conn, false);
dbus_bus_add_match(conn, "type='signal',interface='" NM_DBUS_INTERFACE "',member='StateChange'", NULL);
dbus_connection_flush(conn);
}
// We are guaranteed a connection,
// so check for incoming messages
bool changed = false;
while (true)
{
DBusMessage *msg = NULL;
uint32_t state;
// Pull messages off the queue
dbus_connection_read_write(conn, 0);
if (!(msg = dbus_connection_pop_message(conn)))
break;
// If a message is the right type and value,
// we'll reset the network
if (dbus_message_get_args(msg, NULL, DBUS_TYPE_UINT32, &state, DBUS_TYPE_INVALID))
if (state == NM_STATE_CONNECTED)
changed = true;
dbus_message_unref(msg);
}
return changed;
}
/**
* Attempt to connect to the system bus, and set a filter to deal with
* disconnection (see message_filter above).
*
* @return 1 on success, 0 on failure.
*/
static int
connect_to_bus(void)
{
DBusError error;
struct dbus_core_hook *hook;
dbus_error_init(&error);
bus_info.connection = dbus_bus_get(DBUS_BUS_SYSTEM, &error);
if (!bus_info.connection || dbus_error_is_set(&error)) {
LogMessage(X_ERROR, "dbus-core: error connecting to system bus: %s (%s)\n",
error.name, error.message);
goto err_begin;
}
/* Thankyou. Really, thankyou. */
dbus_connection_set_exit_on_disconnect(bus_info.connection, FALSE);
if (!dbus_connection_get_unix_fd(bus_info.connection, &bus_info.fd)) {
ErrorF("[dbus-core] couldn't get fd for system bus\n");
goto err_unref;
}
if (!dbus_connection_add_filter(bus_info.connection, message_filter,
&bus_info, NULL)) {
ErrorF("[dbus-core] couldn't add filter: %s (%s)\n", error.name,
error.message);
goto err_fd;
}
dbus_error_free(&error);
AddGeneralSocket(bus_info.fd);
RegisterBlockAndWakeupHandlers(block_handler, wakeup_handler, &bus_info);
for (hook = bus_info.hooks; hook; hook = hook->next) {
if (hook->connect)
hook->connect(bus_info.connection, hook->data);
}
return 1;
err_fd:
bus_info.fd = -1;
err_unref:
dbus_connection_unref(bus_info.connection);
bus_info.connection = NULL;
err_begin:
dbus_error_free(&error);
return 0;
}
static DBusHandlerResult disconnect_filter(DBusConnection *conn,
DBusMessage *message, void *data)
{
struct wpas_dbus_priv *priv = data;
if (dbus_message_is_signal(message, DBUS_INTERFACE_LOCAL,
"Disconnected")) {
wpa_printf(MSG_DEBUG, "dbus: bus disconnected, terminating");
dbus_connection_set_exit_on_disconnect(conn, FALSE);
wpa_supplicant_terminate_proc(priv->global);
return DBUS_HANDLER_RESULT_HANDLED;
} else
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
static bool cgm_dbus_connect(void)
{
DBusError dbus_error;
static DBusConnection *connection;
cgm_lock();
if (!dbus_threads_initialized) {
// tell dbus to do struct locking for thread safety
dbus_threads_init_default();
dbus_threads_initialized = true;
}
dbus_error_init(&dbus_error);
connection = dbus_connection_open_private(CGMANAGER_DBUS_SOCK, &dbus_error);
if (!connection) {
DEBUG("Failed opening dbus connection: %s: %s",
dbus_error.name, dbus_error.message);
dbus_error_free(&dbus_error);
cgm_unlock();
return false;
}
dbus_connection_set_exit_on_disconnect(connection, FALSE);
dbus_error_free(&dbus_error);
cgroup_manager = nih_dbus_proxy_new(NULL, connection,
NULL /* p2p */,
"/org/linuxcontainers/cgmanager", NULL, NULL);
dbus_connection_unref(connection);
if (!cgroup_manager) {
NihError *nerr;
nerr = nih_error_get();
ERROR("Error opening cgmanager proxy: %s", nerr->message);
nih_free(nerr);
cgm_dbus_disconnect();
return false;
}
// get the api version
if (cgmanager_get_api_version_sync(NULL, cgroup_manager, &api_version) != 0) {
NihError *nerr;
nerr = nih_error_get();
ERROR("Error cgroup manager api version: %s", nerr->message);
nih_free(nerr);
cgm_dbus_disconnect();
return false;
}
if (api_version < CGM_SUPPORTS_NAMED)
cull_user_controllers();
return true;
}
