bool master_running(void) { NihError *err; /* is manager already running under cgmanager.lower */ server_conn = nih_dbus_connect(CGPROXY_DBUS_PATH, NULL); if (server_conn) { dbus_connection_unref (server_conn); return true; } err = nih_error_get(); nih_free(err); /* is manager running under cgmanager */ server_conn = nih_dbus_connect(CGMANAGER_DBUS_PATH, NULL); if (server_conn) { dbus_connection_unref (server_conn); return true; } err = nih_error_get(); nih_free(err); return false; }
static bool daemon_running(void) { DBusConnection *server_conn; NihError *err; server_conn = nih_dbus_connect(CGMANAGER_DBUS_PATH, NULL); if (server_conn) { dbus_connection_unref (server_conn); return true; } err = nih_error_get(); nih_free(err); return false; }
static void cgm_dbus_disconnected(DBusConnection *connection) { NihError *err; dbus_connection_unref(connection); while (1) { server_conn = nih_dbus_connect(CGPROXY_DBUS_PATH, cgm_dbus_disconnected); if (server_conn) return; err = nih_error_get(); nih_error("Failed to re-open connection to %s: %s", CGPROXY_DBUS_PATH, err->message); nih_free(err); nih_error("re-trying in 5 seconds\n"); sleep(5); } }
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 setup_proxy(void) { bool exists_upper = false, exists_lower = false; NihError *err; /* When running in container, /sys/fs/cgroup will have been already mounted. But it may be ro */ if (is_ro_mount(CGDIR)) turn_mount_rw(CGDIR); /* * If /sys/fs/cgroup/cgmanager.lower exists, * if /sys/fs/cgroup/cgmanager exists, then exit (proxy already running) * start up, connect to .lower * else * if /sys/fs/cgroup/cgmanager exists, move it to /sys/fs/cgroup/cgmanager.lower * start up and connect to .lower */ server_conn = nih_dbus_connect(CGMANAGER_DBUS_PATH, NULL); if (server_conn) { exists_upper = true; dbus_connection_unref (server_conn); } else { err = nih_error_get(); nih_free(err); } server_conn = nih_dbus_connect(CGPROXY_DBUS_PATH, cgm_dbus_disconnected); if (server_conn) { exists_lower = true; } else { err = nih_error_get(); nih_free(err); } if (exists_upper && exists_lower) { dbus_connection_unref (server_conn); nih_fatal("proxy already running"); return -1; // proxy already running } if (exists_lower) // we've got the sock we need, all set. return 0; if (exists_upper) { //move /sys/fs/cgroup/cgmanager to /sys/fs/cgroup/cgmanager.lower if (mkdir(CGPROXY_DIR, 0755) < 0 && errno != EEXIST) { nih_fatal("failed to create lower sock"); return -1; } if (mount(CGMANAGER_DIR, CGPROXY_DIR, "none", MS_MOVE, 0) < 0) { /* it wasn't a mount, meaning we are at the host * level on an old kernel. So rename it */ if (unlink(CGPROXY_SOCK) && errno != ENOENT) nih_warn("failed to remove %s: %s", CGPROXY_SOCK, strerror(errno)); if (rmdir(CGPROXY_DIR) && errno != ENOENT) nih_warn("failed to remove %s: %s", CGPROXY_DIR, strerror(errno)); if (rename(CGMANAGER_DIR, CGPROXY_DIR) < 0) { nih_fatal("unable to rename the socket"); return -1; } if (mkdir(CGMANAGER_DIR, 0755) < 0) { nih_fatal("unable to create socket dir"); return -1; } } } server_conn = nih_dbus_connect(CGPROXY_DBUS_PATH, cgm_dbus_disconnected); if (!server_conn) { err = nih_error_get(); nih_fatal("Failed to open connection to %s: %s", CGPROXY_DBUS_PATH, err->message); nih_free(err); return -1; } return 0; }
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; }
int main (int argc, char *argv[]) { char ** args; DBusConnection * conn; int fd, optval = 1, exitval = 1, ret; DBusMessage *message = NULL, *reply = NULL; DBusMessageIter iter; dbus_uint32_t serial;; nih_main_init (argv[0]); nih_option_set_synopsis (_("Control group client")); args = nih_option_parser (NULL, argc, argv, options, FALSE); if (! args) exit (1); if (!controller) usage(argv[0]); if (pid == -1) pid = getpid(); conn = nih_dbus_connect("unix:path=/tmp/cgmanager", NULL); nih_assert (conn != NULL); message = dbus_message_new_method_call(dbus_bus_get_unique_name(conn), "/org/linuxcontainers/cgmanager", "org.linuxcontainers.cgmanager0_0", "getPidCgroup"); if (!dbus_connection_get_socket(conn, &fd)) { nih_dbus_error_raise_printf (DBUS_ERROR_INVALID_ARGS, "Could not get socket"); return -1; } if (setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &optval, sizeof(optval)) == -1) { perror("setsockopt"); return -1; } dbus_message_iter_init_append(message, &iter); if (! dbus_message_iter_append_basic (&iter, DBUS_TYPE_STRING, &controller)) { nih_error_raise_no_memory (); return -1; } dbus_message_iter_init_append(message, &iter); if (! dbus_message_iter_append_basic (&iter, DBUS_TYPE_INT32, &pid)) { nih_error_raise_no_memory (); return -1; } if (!dbus_connection_send(conn, message, &serial)) { nih_error("failed to send dbus message"); return -1; } dbus_connection_flush(conn); /* If we're sending our own pid, or if we're root, then * we can send an SCM_CREDENTIAL */ if (pid == getpid() || geteuid() == 0) { if (send_pid(fd, pid)) { nih_error("Error sending pid over SCM_CREDENTIAL"); goto out; } } while (!(reply = dbus_connection_pop_message(conn))) dbus_connection_read_write(conn, -1); if (dbus_message_get_reply_serial(reply) != serial) { nih_error("wrong serial on reply"); goto out; } dbus_message_iter_init(reply, &iter); if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING) { nih_error("Got bad reply type: %d", dbus_message_iter_get_arg_type(&iter)); goto out; } char *str_value; dbus_message_iter_get_basic(&iter, &str_value); printf("%s\n", str_value); exitval = 0; out: if (message) dbus_message_unref(message); if (reply) dbus_message_unref(reply); dbus_connection_unref (conn); exit(exitval); }