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