/** * 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; }
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 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; }
bool cgm_dbus_connect(void) { DBusError dbus_error; static DBusConnection *connection; dbus_error_init(&dbus_error); connection = dbus_connection_open_private(CGMANAGER_DBUS_SOCK, &dbus_error); if (!connection) { fprintf(stderr, "Failed opening dbus connection: %s: %s\n", dbus_error.name, dbus_error.message); 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); dbus_connection_unref(connection); if (!cgroup_manager) { NihError *nerr; nerr = nih_error_get(); fprintf(stderr, "Error opening cgmanager proxy: %s\n", 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(); fprintf(stderr, "Error cgroup manager api version: %s\n", nerr->message); nih_free(nerr); cgm_dbus_disconnect(); return false; } return true; }
bool lxc_init_cgmanager(void) { DBusError dbus_error; DBusConnection *connection; dbus_error_init(&dbus_error); connection = nih_dbus_connect(CGMANAGER_DBUS_SOCK, cgmanager_disconnected); if (!connection) { NihError *nerr; nerr = nih_error_get(); ERROR("Error opening cgmanager connection at %s: %s", CGMANAGER_DBUS_SOCK, nerr->message); nih_free(nerr); 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); dbus_connection_unref(connection); if (!cgroup_manager) { NihError *nerr; nerr = nih_error_get(); ERROR("Error opening cgmanager proxy: %s", nerr->message); nih_free(nerr); return false; } active_cg_ops = &cgmanager_ops; // force fd passing negotiation if (cgmanager_ping_sync(NULL, cgroup_manager, 0) != 0) { NihError *nerr; nerr = nih_error_get(); ERROR("Error pinging cgroup manager: %s", nerr->message); nih_free(nerr); } return true; }
int main (int argc, char *argv[]) { char ** args; DBusConnection * connection; struct udev * udev; struct udev_monitor *udev_monitor; int ret; nih_main_init (argv[0]); nih_option_set_synopsis (_("Bridge udev events into upstart")); nih_option_set_help ( _("By default, upstart-udev-bridge does not detach from the " "console and remains in the foreground. Use the --daemon " "option to have it detach.")); args = nih_option_parser (NULL, argc, argv, options, FALSE); if (! args) exit (1); /* Initialise the connection to Upstart */ connection = NIH_SHOULD (nih_dbus_connect (DBUS_ADDRESS_UPSTART, upstart_disconnected)); if (! connection) { NihError *err; err = nih_error_get (); nih_fatal ("%s: %s", _("Could not connect to Upstart"), err->message); nih_free (err); exit (1); } upstart = NIH_SHOULD (nih_dbus_proxy_new (NULL, connection, NULL, DBUS_PATH_UPSTART, NULL, NULL)); if (! upstart) { NihError *err; err = nih_error_get (); nih_fatal ("%s: %s", _("Could not create Upstart proxy"), err->message); nih_free (err); exit (1); } /* Initialise the connection to udev */ nih_assert (udev = udev_new ()); nih_assert (udev_monitor = udev_monitor_new_from_netlink (udev, "udev")); nih_assert (udev_monitor_enable_receiving (udev_monitor) == 0); udev_monitor_set_receive_buffer_size(udev_monitor, 128*1024*1024); NIH_MUST (nih_io_add_watch (NULL, udev_monitor_get_fd (udev_monitor), NIH_IO_READ, (NihIoWatcher)udev_monitor_watcher, udev_monitor)); /* Become daemon */ if (daemonise) { if (nih_main_daemonise () < 0) { NihError *err; err = nih_error_get (); nih_fatal ("%s: %s", _("Unable to become daemon"), err->message); nih_free (err); exit (1); } /* Send all logging output to syslog */ openlog (program_name, LOG_PID, LOG_DAEMON); nih_log_set_logger (nih_logger_syslog); } /* Handle TERM and INT signals gracefully */ nih_signal_set_handler (SIGTERM, nih_signal_handler); NIH_MUST (nih_signal_add_handler (NULL, SIGTERM, nih_main_term_signal, NULL)); if (! daemonise) { nih_signal_set_handler (SIGINT, nih_signal_handler); NIH_MUST (nih_signal_add_handler (NULL, SIGINT, nih_main_term_signal, NULL)); } ret = nih_main_loop (); return ret; }