/* 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; }