static void setup_dbus_server(mrp_mainloop_t *ml)
{
static struct DBusObjectPathVTable vtable = {
.message_function = dispatch_method
};
char *addr = "org.murphy.test";
MRP_UNUSED(ml);
if ((dbus_test.conn = connect_to_dbus(addr)) == NULL)
fatal("failed to connect to DBUS");
if (!mrp_setup_dbus_connection(ml, dbus_test.conn))
fatal("failed to setup DBUS connection with mainloop");
if (!dbus_connection_register_fallback(dbus_test.conn, "/", &vtable, NULL))
fatal("failed to set up method dispatching");
if (write(dbus_test.pipe[1], addr, strlen(addr) + 1) < 0) {
/* just ignore it... */
}
cfg.nrunning++;
}
/**
* wpas_dbus_register_new_iface - Register a new interface with dbus
* @wpa_s: %wpa_supplicant interface description structure to register
* Returns: 0 on success, -1 on error
*
* Registers a new interface with dbus and assigns it a dbus object path.
*/
int wpas_dbus_register_iface(struct wpa_supplicant *wpa_s)
{
struct wpas_dbus_priv *ctrl_iface = wpa_s->global->dbus;
DBusConnection * con;
u32 next;
DBusObjectPathVTable vtable = {
NULL, &wpas_iface_message_handler, NULL, NULL, NULL, NULL
};
/* Do nothing if the control interface is not turned on */
if (ctrl_iface == NULL)
return 0;
con = ctrl_iface->con;
next = ctrl_iface->next_objid++;
/* Create and set the interface's object path */
wpa_s->dbus_path = os_zalloc(WPAS_DBUS_OBJECT_PATH_MAX);
if (wpa_s->dbus_path == NULL)
return -1;
os_snprintf(wpa_s->dbus_path, WPAS_DBUS_OBJECT_PATH_MAX,
WPAS_DBUS_PATH_INTERFACES "/%u",
next);
/* Register the message handler for the interface functions */
if (!dbus_connection_register_fallback(con, wpa_s->dbus_path, &vtable,
wpa_s)) {
wpa_printf(MSG_ERROR, "dbus: Could not set up message "
"handler for interface %s", wpa_s->ifname);
return -1;
}
return 0;
}
void plugin_init(void)
{
DBusError error;
object_hash=g_hash_table_new(g_str_hash, g_str_equal);
object_count=g_hash_table_new(g_str_hash, g_str_equal);
dbg(0,"enter 1\n");
dbus_error_init(&error);
connection = dbus_bus_get(DBUS_BUS_SESSION, &error);
if (!connection) {
dbg(0,"Failed to open connection to session message bus: %s\n", error.message);
dbus_error_free(&error);
return;
}
dbus_connection_setup_with_g_main(connection, NULL);
#if 0
dbus_connection_add_filter(connection, filter, NULL, NULL);
dbus_bus_add_match(connection, "type='signal',""interface='" DBUS_INTERFACE_DBUS "'", &error);
#endif
dbus_connection_register_fallback(connection, object_path, &dbus_navit_vtable, NULL);
dbus_bus_request_name(connection, service_name, 0, &error);
if (dbus_error_is_set(&error)) {
dbg(0,"Failed to request name: %s", error.message);
dbus_error_free (&error);
}
}
/**
* 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;
}
Tcl_DBusHandlerData *DBus_GetMessageHandler(Tcl_Interp *interp,
Tcl_DBusBus *dbus, char *path)
{
DBusObjectPathVTable vtable;
Tcl_DBusHandlerData *dataPtr;
/* Get the currently registered handler for the path */
if (*path == '\0') {
if (!dbus_connection_get_object_path_data(dbus->conn, "/",
(void **)&dataPtr)) return NULL;
}
else {
if (!dbus_connection_get_object_path_data(dbus->conn, path,
(void **)&dataPtr)) return NULL;
}
if (dataPtr == NULL) {
/* No handler currently exists - create a new one */
vtable.message_function = DBus_Message;
vtable.unregister_function = DBus_Unregister;
dataPtr = (Tcl_DBusHandlerData *)ckalloc(sizeof(Tcl_DBusHandlerData));
dataPtr->dbus = dbus;
dataPtr->signal = NULL;
dataPtr->method = NULL;
dataPtr->flags = 0;
if (path[0] == '\0' || (path[0] == '/' && path[1] == '\0')) {
/* Register as a fallback method handler */
if (!dbus_connection_register_fallback(dbus->conn, "/",
&vtable, dataPtr))
return NULL;
dataPtr->flags |= DBUSFLAG_FALLBACK;
}
else {
/* Register as a regular method handler */
if (!dbus_connection_register_object_path(dbus->conn, path,
&vtable, dataPtr))
return NULL;
}
}
if (*path == '\0') {
if (dbus->fallback != NULL)
return dbus->fallback;
dataPtr = (Tcl_DBusHandlerData *)ckalloc(sizeof(Tcl_DBusHandlerData));
dataPtr->dbus = dbus;
dataPtr->signal = NULL;
dataPtr->method = NULL;
dbus->fallback = dataPtr;
}
return dataPtr;
}
/**
* wpas_dbus_register_new_iface - Register a new interface with dbus
* @global: Global %wpa_supplicant data
* @wpa_s: %wpa_supplicant interface description structure to register
* Returns: 0 on success, -1 on error
*
* Registers a new interface with dbus and assigns it a dbus object path.
*/
int wpas_dbus_register_iface(struct wpa_supplicant *wpa_s)
{
struct ctrl_iface_dbus_priv *ctrl_iface =
wpa_s->global->dbus_ctrl_iface;
DBusConnection * con;
u32 next;
DBusObjectPathVTable vtable = {
NULL, &wpas_iface_message_handler, NULL, NULL, NULL, NULL
};
char *path;
int ret = -1;
/* Do nothing if the control interface is not turned on */
if (ctrl_iface == NULL)
return 0;
con = ctrl_iface->con;
next = wpa_supplicant_dbus_next_objid(ctrl_iface);
/* Create and set the interface's object path */
path = os_zalloc(WPAS_DBUS_OBJECT_PATH_MAX);
if (path == NULL)
return -1;
snprintf(path, WPAS_DBUS_OBJECT_PATH_MAX,
WPAS_DBUS_PATH_INTERFACES "/%u",
next);
if (wpa_supplicant_set_dbus_path(wpa_s, path)) {
wpa_printf(MSG_DEBUG,
"Failed to set dbus path for interface %s",
wpa_s->ifname);
goto out;
}
/* Register the message handler for the interface functions */
if (!dbus_connection_register_fallback(con, path, &vtable, wpa_s)) {
perror("wpas_dbus_register_iface [dbus]");
wpa_printf(MSG_ERROR, "Could not set up DBus message "
"handler for interface %s.", wpa_s->ifname);
goto out;
}
ret = 0;
out:
free(path);
return ret;
}
static int ldbus_connection_register_fallback(lua_State *L) {
DBusConnection *connection = check_DBusConnection(L, 1);
const char *path = luaL_checkstring(L, 2);
ldbus_callback_udata *data;
luaL_checktype(L, 3, LUA_TFUNCTION);
lua_settop(L, 3);
if ((data = malloc(sizeof(ldbus_callback_udata))) == NULL) {
return luaL_error(L, LDBUS_NO_MEMORY);
}
data->L = L;
data->ref = luaL_ref(L, LUA_REGISTRYINDEX);
if (!dbus_connection_register_fallback(connection, path, &VTable, data)) {
free(data);
return luaL_error(L, "unknown error");
}
lua_pushboolean(L, 1);
return 1;
}
/*******************************************************************************
* 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;
}
int
init_ac_manage_dbus(void) {
DBusError dbus_error;
DBusObjectPathVTable ac_manage_vtable = {NULL, &ac_manage_dbus_message_handler, NULL, NULL, NULL, NULL};
dbus_error_init (&dbus_error);
ac_manage_dbus_connection = dbus_bus_get_private(DBUS_BUS_SYSTEM, &dbus_error);
if(NULL == ac_manage_dbus_connection) {
syslog(LOG_WARNING, "dbus_bus_get(): %s\n", dbus_error.message);
dbus_error_free(&dbus_error);
return AC_MANAGE_DBUS_ERROR;
}
if(!dbus_connection_register_fallback(ac_manage_dbus_connection, AC_MANAGE_DBUS_OBJPATH, &ac_manage_vtable, NULL)) {
syslog(LOG_WARNING, "init_ac_manage_dbus: register fallback fail!\n");
return AC_MANAGE_DBUS_ERROR;
}
dbus_bus_request_name(ac_manage_dbus_connection, AC_MANAGE_DBUS_DBUSNAME, 0, &dbus_error);
if (dbus_error_is_set(&dbus_error)) {
syslog(LOG_WARNING, "dbus_bus_get(): %s\n", dbus_error.message);
dbus_error_free(&dbus_error);
return AC_MANAGE_DBUS_ERROR;
}
dbus_connection_add_filter (ac_manage_dbus_connection, ac_manage_dbus_filter_function, NULL, NULL);
dbus_bus_add_match (ac_manage_dbus_connection,
"type='signal'"
",interface='"AC_MANAGE_DBUS_INTERFACE"'",
NULL);
return AC_MANAGE_SUCCESS;
}
static void
handle_connection(DBusServer *server,
DBusConnection *new_connection,
void *data)
{
if (runner_connection == NULL) {
DBusObjectPathVTable vtable = { &runner_server_unregister_handler,
&runner_server_message_handler,
NULL, NULL, NULL, NULL};
runner_connection = new_connection;
dbus_connection_ref (new_connection);
dbus_connection_setup_with_g_main (new_connection, NULL);
dbus_connection_register_fallback (new_connection,
"/org/freedesktop",
&vtable,
NULL);
/* dbus_server_unref(server); */
}
}
static int manager_connect_bus(Manager *m) {
DBusError error;
int r;
struct epoll_event ev = {
.events = EPOLLIN,
.data.u32 = FD_BUS,
};
assert(m);
assert(!m->bus);
assert(m->bus_fd < 0);
dbus_error_init(&error);
m->bus = dbus_bus_get_private(DBUS_BUS_SYSTEM, &error);
if (!m->bus) {
log_error("Failed to get system D-Bus connection: %s", bus_error_message(&error));
r = -ECONNREFUSED;
goto fail;
}
if (!dbus_connection_register_object_path(m->bus, "/org/freedesktop/machine1", &bus_manager_vtable, m) ||
!dbus_connection_register_fallback(m->bus, "/org/freedesktop/machine1/machine", &bus_machine_vtable, m) ||
!dbus_connection_add_filter(m->bus, bus_message_filter, m, NULL)) {
r = log_oom();
goto fail;
}
dbus_bus_add_match(m->bus,
"type='signal',"
"sender='org.freedesktop.systemd1',"
"interface='org.freedesktop.systemd1.Manager',"
"member='JobRemoved',"
"path='/org/freedesktop/systemd1'",
&error);
if (dbus_error_is_set(&error)) {
log_error("Failed to add match for JobRemoved: %s", bus_error_message(&error));
dbus_error_free(&error);
}
dbus_bus_add_match(m->bus,
"type='signal',"
"sender='org.freedesktop.systemd1',"
"interface='org.freedesktop.systemd1.Manager',"
"member='UnitRemoved',"
"path='/org/freedesktop/systemd1'",
&error);
if (dbus_error_is_set(&error)) {
log_error("Failed to add match for UnitRemoved: %s", bus_error_message(&error));
dbus_error_free(&error);
}
dbus_bus_add_match(m->bus,
"type='signal',"
"sender='org.freedesktop.systemd1',"
"interface='org.freedesktop.DBus.Properties',"
"member='PropertiesChanged'",
&error);
if (dbus_error_is_set(&error)) {
log_error("Failed to add match for PropertiesChanged: %s", bus_error_message(&error));
dbus_error_free(&error);
}
dbus_bus_add_match(m->bus,
"type='signal',"
"sender='org.freedesktop.systemd1',"
"interface='org.freedesktop.systemd1.Manager',"
"member='Reloading',"
"path='/org/freedesktop/systemd1'",
&error);
if (dbus_error_is_set(&error)) {
log_error("Failed to add match for Reloading: %s", bus_error_message(&error));
dbus_error_free(&error);
}
r = bus_method_call_with_reply(
m->bus,
"org.freedesktop.systemd1",
"/org/freedesktop/systemd1",
"org.freedesktop.systemd1.Manager",
"Subscribe",
NULL,
&error,
DBUS_TYPE_INVALID);
if (r < 0) {
log_error("Failed to enable subscription: %s", bus_error(&error, r));
dbus_error_free(&error);
}
r = dbus_bus_request_name(m->bus, "org.freedesktop.machine1", DBUS_NAME_FLAG_DO_NOT_QUEUE, &error);
if (dbus_error_is_set(&error)) {
log_error("Failed to register name on bus: %s", bus_error_message(&error));
r = -EIO;
goto fail;
}
if (r != DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER) {
log_error("Failed to acquire name.");
r = -EEXIST;
goto fail;
}
m->bus_fd = bus_loop_open(m->bus);
if (m->bus_fd < 0) {
r = m->bus_fd;
goto fail;
}
if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->bus_fd, &ev) < 0)
goto fail;
return 0;
fail:
dbus_error_free(&error);
return r;
}
void manager_gc(Manager *m, bool drop_not_started) {
Machine *machine;
assert(m);
while ((machine = m->machine_gc_queue)) {
LIST_REMOVE(gc_queue, m->machine_gc_queue, machine);
machine->in_gc_queue = false;
if (machine_check_gc(machine, drop_not_started) == 0) {
machine_stop(machine);
machine_free(machine);
}
}
}
