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; }
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; }
/** * Description: * WSM Debus initialize function * * Parameter: * NULL * * Return: * 0: Successed; -1: failed * */ int wsm_dbus_init(void) { DBusError err; DBusObjectPathVTable wsm_vtbl = {NULL, &wsm_dbus_msg_handler, NULL, NULL, NULL, NULL}; unsigned char dbus_name[WSM_PATH_MAX] = {0}; unsigned char obj_path[WSM_PATH_MAX] = {0}; sprintf(dbus_name, "%s%d_%d", WSM_DBUS_BUSNAME,local, vrrid); sprintf(obj_path, "%s%d_%d", WSM_DBUS_OBJPATH,local, vrrid); WSMLog(L_INFO, "%s: dbus name : %s\n", __func__, dbus_name); WSMLog(L_INFO, "%s: obj name : %s\n", __func__, obj_path); dbus_threads_init_default(); dbus_connection_set_change_sigpipe (1); dbus_error_init (&err); wsm_dbus_conn = dbus_bus_get_private (DBUS_BUS_SYSTEM, &err); if (!wsm_dbus_conn) { WSMLog(L_CRIT, "%s: wsm_dbus_conn = NULL.\n", __func__); return -1; } if (!dbus_connection_register_fallback (wsm_dbus_conn, obj_path, &wsm_vtbl, NULL)) { WSMLog(L_CRIT, "%s: register fallback failed.\n", __func__); return -1; } dbus_bus_request_name (wsm_dbus_conn, dbus_name, 0, &err); if (dbus_error_is_set (&err)) { WSMLog(L_CRIT, "%s: dbus_bus_request_name() ERR:%s\n", __func__, err.message); return -1; } dbus_connection_add_filter (wsm_dbus_conn, wsm_dbus_filter_function, NULL, NULL); dbus_bus_add_match (wsm_dbus_conn, "type='signal'" ",interface='"DBUS_INTERFACE_DBUS"'" ",sender='"DBUS_SERVICE_DBUS"'" ",member='NameOwnerChanged'", NULL); return 0; }
int wbmd_dbus_reinit(void) { int i = 0; DBusError dbus_error; dbus_threads_init_default(); DBusObjectPathVTable wbmd_vtable = {NULL, &wbmd_dbus_message_handler, NULL, NULL, NULL, NULL}; dbus_connection_set_change_sigpipe (TRUE); dbus_error_init (&dbus_error); wbmd_dbus_connection = dbus_bus_get_private (DBUS_BUS_SYSTEM, &dbus_error); if (wbmd_dbus_connection == NULL) { wbmd_syslog_err("dbus_bus_get(): %s\n", dbus_error.message); return FALSE; } // Use npd to handle subsection of NPD_DBUS_OBJPATH including slots if (!dbus_connection_register_fallback (wbmd_dbus_connection, WBMD_DBUS_OBJPATH, &wbmd_vtable, NULL)) { wbmd_syslog_err("can't register D-BUS handlers (fallback NPD). cannot continue.\n"); return FALSE; } i = dbus_bus_request_name (wbmd_dbus_connection, WBMD_DBUS_BUSNAME, 0, &dbus_error); wbmd_syslog_debug_debug(WBMD_DBUS,"dbus_bus_request_name:%d",i); if (dbus_error_is_set (&dbus_error)) { wbmd_syslog_debug_debug(WBMD_DBUS,"dbus_bus_request_name(): %s", dbus_error.message); return FALSE; } dbus_connection_add_filter (wbmd_dbus_connection, wbmd_dbus_filter_function, NULL, NULL); dbus_bus_add_match (wbmd_dbus_connection, "type='signal'" ",interface='"DBUS_INTERFACE_DBUS"'" ",sender='"DBUS_SERVICE_DBUS"'" ",member='NameOwnerChanged'", NULL); return TRUE; }
int bsd_dbus_init(void) { int i = 0; DBusError dbus_error; dbus_threads_init_default(); DBusObjectPathVTable bsd_vtable = {NULL, &bsd_dbus_message_handler, NULL, NULL, NULL, NULL}; dbus_connection_set_change_sigpipe (TRUE); dbus_error_init (&dbus_error); bsd_dbus_connection = dbus_bus_get_private (DBUS_BUS_SYSTEM, &dbus_error); bsd_dbus_connection2 = dbus_bus_get_private (DBUS_BUS_SYSTEM, &dbus_error); if (bsd_dbus_connection == NULL) { bsd_syslog_err("dbus_bus_get(): %s\n", dbus_error.message); return FALSE; } if (!dbus_connection_register_fallback (bsd_dbus_connection, BSD_DBUS_OBJPATH, &bsd_vtable, NULL)) { bsd_syslog_err("can't register D-BUS handlers (fallback NPD). cannot continue.\n"); return FALSE; } i = dbus_bus_request_name (bsd_dbus_connection, BSD_DBUS_BUSNAME, 0, &dbus_error); dbus_bus_request_name (bsd_dbus_connection2, "aw.bsd2", 0, &dbus_error); if (dbus_error_is_set (&dbus_error)) { bsd_syslog_debug_debug(BSD_DBUS,"dbus_bus_request_name(): %s", dbus_error.message); return FALSE; } dbus_connection_add_filter (bsd_dbus_connection, bsd_dbus_filter_function, NULL, NULL); dbus_bus_add_match (bsd_dbus_connection, "type='signal'" ",interface='"DBUS_INTERFACE_DBUS"'" ",sender='"DBUS_SERVICE_DBUS"'" ",member='NameOwnerChanged'", NULL); // printf("init finished\n"); return TRUE; }
static gboolean nm_dbus_manager_init_bus (NMDBusManager *self) { NMDBusManagerPrivate *priv = NM_DBUS_MANAGER_GET_PRIVATE (self); GError *err = NULL; if (priv->connection) { nm_log_warn (LOGD_CORE, "DBus Manager already has a valid connection."); return FALSE; } dbus_connection_set_change_sigpipe (TRUE); priv->g_connection = dbus_g_bus_get (DBUS_BUS_SYSTEM, &err); if (!priv->g_connection) { nm_log_err (LOGD_CORE, "Could not get the system bus. Make sure " "the message bus daemon is running! Message: %s", err->message); g_error_free (err); return FALSE; } priv->connection = dbus_g_connection_get_connection (priv->g_connection); dbus_connection_set_exit_on_disconnect (priv->connection, FALSE); priv->proxy = dbus_g_proxy_new_for_name (priv->g_connection, "org.freedesktop.DBus", "/org/freedesktop/DBus", "org.freedesktop.DBus"); priv->proxy_destroy_id = g_signal_connect (priv->proxy, "destroy", G_CALLBACK (destroy_cb), self); dbus_g_proxy_add_signal (priv->proxy, "NameOwnerChanged", G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INVALID); dbus_g_proxy_connect_signal (priv->proxy, "NameOwnerChanged", G_CALLBACK (proxy_name_owner_changed), self, NULL); return TRUE; }
static NMCEService * bm_ce_service_new (DBusGConnection *bus, DBusGProxy *proxy, BMConnectionList *list) { GObject *object; DBusConnection *connection; GError *err = NULL; guint32 result; g_return_val_if_fail (bus != NULL, NULL); g_return_val_if_fail (proxy != NULL, NULL); object = g_object_new (BM_TYPE_CE_SERVICE, NULL); if (!object) return NULL; BM_CE_SERVICE (object)->list = list; dbus_connection_set_change_sigpipe (TRUE); connection = dbus_g_connection_get_connection (bus); dbus_connection_set_exit_on_disconnect (connection, FALSE); /* Register our single-instance service. Don't care if it fails. */ if (!dbus_g_proxy_call (proxy, "RequestName", &err, G_TYPE_STRING, BM_CE_DBUS_SERVICE_NAME, G_TYPE_UINT, DBUS_NAME_FLAG_DO_NOT_QUEUE, G_TYPE_INVALID, G_TYPE_UINT, &result, G_TYPE_INVALID)) { g_warning ("Could not acquire the connection editor service.\n" " Message: '%s'", err->message); g_error_free (err); } else { if (result != DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER) g_warning ("Could not acquire the connection editor service as it is already taken."); else { /* success */ dbus_g_connection_register_g_object (bus, "/", object); } } return (NMCEService *) object; }
/******************************************************************************* * igmp_snp_dbus_init * * DESCRIPTION: * init the dbus ,include bus get and connection etc. * * INPUTS: * null * * OUTPUTS: * null * * RETURNS: * IGMPSNP_RETURN_CODE_OK - init ok or can't register D-BUS handlers * IGMPSNP_RETURN_CODE_DBUS_CONNECTION_E - bus get or request name or error set fail * * COMMENTS: * ** ********************************************************************************/ int igmp_snp_dbus_init(void) { DBusError dbus_error; int ret = IGMPSNP_RETURN_CODE_OK; DBusObjectPathVTable igmp_snp_vtable = {NULL, &igmp_snp_dbus_message_handler, NULL, NULL, NULL, NULL}; igmp_snp_syslog_dbg ("IGMP>>DBUS init...\n"); dbus_connection_set_change_sigpipe (TRUE); dbus_error_init (&dbus_error); igmp_snp_dbus_connection = dbus_bus_get (DBUS_BUS_SYSTEM, &dbus_error); if (igmp_snp_dbus_connection == NULL) { igmp_snp_syslog_err ("IGMP>>dbus_bus_get(): %s", dbus_error.message); return IGMPSNP_RETURN_CODE_DBUS_CONNECTION_E; } igmp_snp_syslog_dbg("IGMP>>igmp_snp_dbus_connection %p\n",igmp_snp_dbus_connection); // Use npd to handle subsection of IGMP_DBUS_OBJPATH including slots if (!dbus_connection_register_fallback (igmp_snp_dbus_connection, IGMP_DBUS_OBJPATH, &igmp_snp_vtable, NULL)) { igmp_snp_syslog_err("IGMP>>can't register D-BUS handlers (fallback NPD). cannot continue."); return IGMPSNP_RETURN_CODE_OK; } ret = dbus_bus_request_name (igmp_snp_dbus_connection, IGMP_DBUS_BUSNAME,0, &dbus_error); if(-1 == ret) { igmp_snp_syslog_err("IGMP>>dbus request name err %d\n",ret); ret = IGMPSNP_RETURN_CODE_DBUS_CONNECTION_E; } else igmp_snp_syslog_dbg("IGMP>>dbus request name ok\n"); if (dbus_error_is_set (&dbus_error)) { igmp_snp_syslog_err ("IGMP>>dbus_bus_request_name(): %s", dbus_error.message); return IGMPSNP_RETURN_CODE_DBUS_CONNECTION_E; } return IGMPSNP_RETURN_CODE_OK; }
/** Establish connection to the D-BUS daemon. * * @returns TRUE if connection could be established or if connection is already, * established. FALSE if connection failed. */ gboolean ial_dbus_connect() { DBusError dbus_error; if (dbus_connection == NULL) { dbus_connection_set_change_sigpipe(TRUE); dbus_error_init(&dbus_error); dbus_connection = dbus_bus_get(DBUS_BUS_SYSTEM, &dbus_error); if (dbus_connection == NULL) { ERROR(("dbus_bus_get(): Error. (%s)", dbus_error.message)); return FALSE; } else { INFO(("dbus_bus_get(): Success.")); return TRUE; } } else { INFO(("Already connected to D-Bus.")); return TRUE; } }
static NML2tpPppService * nm_l2tp_ppp_service_new (NMConnection *connection, GError **error) { NML2tpPppService *self = NULL; DBusGConnection *bus; DBusGProxy *proxy; gboolean success = FALSE; guint result; bus = dbus_g_bus_get (DBUS_BUS_SYSTEM, error); if (!bus) return NULL; dbus_connection_set_change_sigpipe (TRUE); proxy = dbus_g_proxy_new_for_name (bus, "org.freedesktop.DBus", "/org/freedesktop/DBus", "org.freedesktop.DBus"); g_assert(proxy); if (dbus_g_proxy_call (proxy, "RequestName", error, G_TYPE_STRING, NM_DBUS_SERVICE_L2TP_PPP, G_TYPE_UINT, 0, G_TYPE_INVALID, G_TYPE_UINT, &result, G_TYPE_INVALID)) { self = (NML2tpPppService *) g_object_new (NM_TYPE_L2TP_PPP_SERVICE, NULL); g_assert(self); dbus_g_connection_register_g_object (bus, NM_DBUS_PATH_L2TP_PPP, G_OBJECT (self)); success = TRUE; } else { g_warning (_("Could not register D-Bus service name. Message: %s"), (*error)->message); } g_object_unref (proxy); dbus_g_connection_unref (bus); return self; }
static gboolean request_dbus_name (DBusGConnection *bus) { DBusGProxy *proxy; GError *error = NULL; int request_name_result; dbus_connection_set_change_sigpipe (TRUE); dbus_connection_set_exit_on_disconnect (dbus_g_connection_get_connection (bus), FALSE); proxy = dbus_g_proxy_new_for_name (bus, "org.freedesktop.DBus", "/org/freedesktop/DBus", "org.freedesktop.DBus"); if (!dbus_g_proxy_call (proxy, "RequestName", &error, G_TYPE_STRING, NM_DBUS_SERVICE_USER_SETTINGS, G_TYPE_UINT, DBUS_NAME_FLAG_DO_NOT_QUEUE, G_TYPE_INVALID, G_TYPE_UINT, &request_name_result, G_TYPE_INVALID)) { g_warning ("Could not acquire the NetworkManagerUserSettings service.\n" " Message: '%s'", error->message); g_error_free (error); return FALSE; } if (request_name_result != DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER) { g_warning ("Could not acquire the NetworkManagerUserSettings service " "as it is already taken. Return: %d", request_name_result); return FALSE; } return TRUE; }
//DbusHandler DBusHandler::DBusHandler(Compositor& comp) : compositor_(&comp) { DBusError err; dbus_error_init(&err); dbus_connection_set_change_sigpipe(false); //todo: error checking everywhere if(!(dbusConnection_ = dbus_bus_get_private(DBUS_BUS_SYSTEM, &err))) { std::string errStr; checkError(err, errStr); throw std::runtime_error("DBus::DBus: cant connect to dbus. " + errStr); return; } dbus_connection_set_exit_on_disconnect(dbusConnection_, false); //use dummy event fd int fd; if((fd = eventfd(0, EFD_CLOEXEC)) < 0) { throw std::runtime_error("DBus::DBus: cant create eventfd"); return; } //event source dbusEventSource_ = wl_event_loop_add_fd(&comp.wlEventLoop(), fd, 0, Callbacks::dispatchDBus, this); close(fd); wl_event_source_check(dbusEventSource_); //watch if(!dbus_connection_set_watch_functions(dbusConnection_, Callbacks::addWatch, Callbacks::removeWatch, Callbacks::toggleWatch, this, nullptr)) { throw std::runtime_error("dbus_connection_set_watch_functions failed"); return; } //timeout if(!dbus_connection_set_timeout_functions(dbusConnection_, Callbacks::addTimeout, Callbacks::removeTimeout, Callbacks::toggleTimeout, this, nullptr)) { throw std::runtime_error("dbus_connection_set_timeout_functions failed"); return; } //filter if(!dbus_connection_add_filter(dbusConnection_, Callbacks::dbusFilter, this, nullptr)) { throw std::runtime_error("dbus add filter failed"); return; } //disconnected callback signalCallbacks_.emplace_back(MsgCallback{DBUS_INTERFACE_LOCAL, "Diconnected", nytl::memberCallback(&DBusHandler::disconnected, this)}); ny::sendLog("dbus handler succesfully set up"); }