#include "bus-signature.h"
#include "bus-objects.h"
#include "bus-util.h"
+#include "bus-container.h"
static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec);
free(b->auth_buffer);
free(b->address);
free(b->kernel);
+ free(b->machine);
free(b->exec_path);
strv_free(b->exec_argv);
free(b);
}
-int sd_bus_new(sd_bus **ret) {
+_public_ int sd_bus_new(sd_bus **ret) {
sd_bus *r;
assert_return(ret, -EINVAL);
return 0;
}
-int sd_bus_set_address(sd_bus *bus, const char *address) {
+_public_ int sd_bus_set_address(sd_bus *bus, const char *address) {
char *a;
assert_return(bus, -EINVAL);
return 0;
}
-int sd_bus_set_fd(sd_bus *bus, int input_fd, int output_fd) {
+_public_ int sd_bus_set_fd(sd_bus *bus, int input_fd, int output_fd) {
assert_return(bus, -EINVAL);
assert_return(bus->state == BUS_UNSET, -EPERM);
assert_return(input_fd >= 0, -EINVAL);
return 0;
}
-int sd_bus_set_exec(sd_bus *bus, const char *path, char *const argv[]) {
+_public_ int sd_bus_set_exec(sd_bus *bus, const char *path, char *const argv[]) {
char *p, **a;
assert_return(bus, -EINVAL);
return 0;
}
-int sd_bus_set_bus_client(sd_bus *bus, int b) {
+_public_ int sd_bus_set_bus_client(sd_bus *bus, int b) {
assert_return(bus, -EINVAL);
assert_return(bus->state == BUS_UNSET, -EPERM);
assert_return(!bus_pid_changed(bus), -ECHILD);
return 0;
}
-int sd_bus_negotiate_fds(sd_bus *bus, int b) {
+_public_ int sd_bus_negotiate_fds(sd_bus *bus, int b) {
assert_return(bus, -EINVAL);
assert_return(bus->state == BUS_UNSET, -EPERM);
assert_return(!bus_pid_changed(bus), -ECHILD);
return 0;
}
-int sd_bus_negotiate_attach_comm(sd_bus *bus, int b) {
+_public_ int sd_bus_negotiate_attach_comm(sd_bus *bus, int b) {
assert_return(bus, -EINVAL);
assert_return(bus->state == BUS_UNSET, -EPERM);
assert_return(!bus_pid_changed(bus), -ECHILD);
return 0;
}
-int sd_bus_negotiate_attach_exe(sd_bus *bus, int b) {
+_public_ int sd_bus_negotiate_attach_exe(sd_bus *bus, int b) {
assert_return(bus, -EINVAL);
assert_return(bus->state == BUS_UNSET, -EPERM);
assert_return(!bus_pid_changed(bus), -ECHILD);
return 0;
}
-int sd_bus_negotiate_attach_cmdline(sd_bus *bus, int b) {
+_public_ int sd_bus_negotiate_attach_cmdline(sd_bus *bus, int b) {
assert_return(bus, -EINVAL);
assert_return(bus->state == BUS_UNSET, -EPERM);
assert_return(!bus_pid_changed(bus), -ECHILD);
return 0;
}
-int sd_bus_negotiate_attach_cgroup(sd_bus *bus, int b) {
+_public_ int sd_bus_negotiate_attach_cgroup(sd_bus *bus, int b) {
assert_return(bus, -EINVAL);
assert_return(bus->state == BUS_UNSET, -EPERM);
assert_return(!bus_pid_changed(bus), -ECHILD);
return 0;
}
-int sd_bus_negotiate_attach_caps(sd_bus *bus, int b) {
+_public_ int sd_bus_negotiate_attach_caps(sd_bus *bus, int b) {
assert_return(bus, -EINVAL);
assert_return(bus->state == BUS_UNSET, -EPERM);
assert_return(!bus_pid_changed(bus), -ECHILD);
return 0;
}
-int sd_bus_negotiate_attach_selinux_context(sd_bus *bus, int b) {
+_public_ int sd_bus_negotiate_attach_selinux_context(sd_bus *bus, int b) {
assert_return(bus, -EINVAL);
assert_return(bus->state == BUS_UNSET, -EPERM);
assert_return(!bus_pid_changed(bus), -ECHILD);
return 0;
}
-int sd_bus_negotiate_attach_audit(sd_bus *bus, int b) {
+_public_ int sd_bus_negotiate_attach_audit(sd_bus *bus, int b) {
assert_return(bus, -EINVAL);
assert_return(bus->state == BUS_UNSET, -EPERM);
assert_return(!bus_pid_changed(bus), -ECHILD);
return 0;
}
-int sd_bus_set_server(sd_bus *bus, int b, sd_id128_t server_id) {
+_public_ int sd_bus_set_server(sd_bus *bus, int b, sd_id128_t server_id) {
assert_return(bus, -EINVAL);
assert_return(b || sd_id128_equal(server_id, SD_ID128_NULL), -EINVAL);
assert_return(bus->state == BUS_UNSET, -EPERM);
return 0;
}
-int sd_bus_set_anonymous(sd_bus *bus, int b) {
+_public_ int sd_bus_set_anonymous(sd_bus *bus, int b) {
assert_return(bus, -EINVAL);
assert_return(bus->state == BUS_UNSET, -EPERM);
assert_return(!bus_pid_changed(bus), -ECHILD);
return 0;
}
+static int parse_container_address(sd_bus *b, const char **p, char **guid) {
+ _cleanup_free_ char *machine = NULL;
+ int r;
+
+ assert(b);
+ assert(p);
+ assert(*p);
+ assert(guid);
+
+ while (**p != 0 && **p != ';') {
+ r = parse_address_key(p, "guid", guid);
+ if (r < 0)
+ return r;
+ else if (r > 0)
+ continue;
+
+ r = parse_address_key(p, "machine", &machine);
+ if (r < 0)
+ return r;
+ else if (r > 0)
+ continue;
+
+ skip_address_key(p);
+ }
+
+ if (!machine)
+ return -EINVAL;
+
+ free(b->machine);
+ b->machine = machine;
+ machine = NULL;
+
+ b->sockaddr.un.sun_family = AF_UNIX;
+ strncpy(b->sockaddr.un.sun_path, "/var/run/dbus/system_bus_socket", sizeof(b->sockaddr.un.sun_path));
+ b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + sizeof("/var/run/dbus/system_bus_socket") - 1;
+
+ return 0;
+}
+
static void bus_reset_parsed_address(sd_bus *b) {
assert(b);
b->server_id = SD_ID128_NULL;
free(b->kernel);
b->kernel = NULL;
+ free(b->machine);
+ b->machine = NULL;
}
static int bus_parse_next_address(sd_bus *b) {
if (r < 0)
return r;
+ break;
+ } else if (startswith(a, "x-container:")) {
+
+ a += 12;
+ r = parse_container_address(b, &a, &guid);
+ if (r < 0)
+ return r;
+
break;
}
for (;;) {
sd_bus_close(b);
- if (b->sockaddr.sa.sa_family != AF_UNSPEC) {
+ if (b->exec_path) {
- r = bus_socket_connect(b);
+ r = bus_socket_exec(b);
+ if (r >= 0)
+ return r;
+
+ b->last_connect_error = -r;
+ } else if (b->kernel) {
+
+ r = bus_kernel_connect(b);
if (r >= 0)
return r;
b->last_connect_error = -r;
- } else if (b->exec_path) {
+ } else if (b->machine) {
- r = bus_socket_exec(b);
+ r = bus_container_connect(b);
if (r >= 0)
return r;
b->last_connect_error = -r;
- } else if (b->kernel) {
- r = bus_kernel_connect(b);
+ } else if (b->sockaddr.sa.sa_family != AF_UNSPEC) {
+
+ r = bus_socket_connect(b);
if (r >= 0)
return r;
return bus_socket_take_fd(b);
}
-int sd_bus_start(sd_bus *bus) {
+_public_ int sd_bus_start(sd_bus *bus) {
int r;
assert_return(bus, -EINVAL);
if (bus->input_fd >= 0)
r = bus_start_fd(bus);
- else if (bus->address || bus->sockaddr.sa.sa_family != AF_UNSPEC || bus->exec_path || bus->kernel)
+ else if (bus->address || bus->sockaddr.sa.sa_family != AF_UNSPEC || bus->exec_path || bus->kernel || bus->machine)
r = bus_start_address(bus);
else
return -EINVAL;
return bus_send_hello(bus);
}
-int sd_bus_open_system(sd_bus **ret) {
+_public_ int sd_bus_open_system(sd_bus **ret) {
const char *e;
sd_bus *b;
int r;
return r;
}
-int sd_bus_open_user(sd_bus **ret) {
+_public_ int sd_bus_open_user(sd_bus **ret) {
const char *e;
sd_bus *b;
size_t l;
return r;
}
-void sd_bus_close(sd_bus *bus) {
+_public_ int sd_bus_open_system_remote(const char *host, sd_bus **ret) {
+ _cleanup_free_ char *e = NULL;
+ char *p = NULL;
+ sd_bus *bus;
+ int r;
+
+ assert_return(host, -EINVAL);
+ assert_return(ret, -EINVAL);
+
+ e = bus_address_escape(host);
+ if (!e)
+ return -ENOMEM;
+
+ p = strjoin("unixexec:path=ssh,argv1=-xT,argv2=", e, ",argv3=systemd-stdio-bridge", NULL);
+ if (!p)
+ return -ENOMEM;
+
+ r = sd_bus_new(&bus);
+ if (r < 0) {
+ free(p);
+ return r;
+ }
+
+ bus->address = p;
+ bus->bus_client = true;
+
+ r = sd_bus_start(bus);
+ if (r < 0) {
+ bus_free(bus);
+ return r;
+ }
+
+ *ret = bus;
+ return 0;
+}
+
+_public_ int sd_bus_open_system_container(const char *machine, sd_bus **ret) {
+ _cleanup_free_ char *e = NULL;
+ sd_bus *bus;
+ char *p;
+ int r;
+
+ assert_return(machine, -EINVAL);
+ assert_return(ret, -EINVAL);
+
+ e = bus_address_escape(machine);
+ if (!e)
+ return -ENOMEM;
+
+ p = strjoin("x-container:machine=", e, NULL);
+ if (!p)
+ return -ENOMEM;
+
+ r = sd_bus_new(&bus);
+ if (r < 0) {
+ free(p);
+ return r;
+ }
+
+ bus->address = p;
+ bus->bus_client = true;
+
+ r = sd_bus_start(bus);
+ if (r < 0) {
+ bus_free(bus);
+ return r;
+ }
+
+ *ret = bus;
+ return 0;
+}
+
+_public_ void sd_bus_close(sd_bus *bus) {
if (!bus)
return;
if (bus->state == BUS_CLOSED)
* freed. */
}
-sd_bus *sd_bus_ref(sd_bus *bus) {
- if (!bus)
- return NULL;
+_public_ sd_bus *sd_bus_ref(sd_bus *bus) {
+ assert_return(bus, NULL);
assert_se(REFCNT_INC(bus->n_ref) >= 2);
return bus;
}
-sd_bus *sd_bus_unref(sd_bus *bus) {
- if (!bus)
- return NULL;
+_public_ sd_bus *sd_bus_unref(sd_bus *bus) {
+ assert_return(bus, NULL);
if (REFCNT_DEC(bus->n_ref) <= 0)
bus_free(bus);
return NULL;
}
-int sd_bus_is_open(sd_bus *bus) {
+_public_ int sd_bus_is_open(sd_bus *bus) {
assert_return(bus, -EINVAL);
assert_return(!bus_pid_changed(bus), -ECHILD);
return BUS_IS_OPEN(bus->state);
}
-int sd_bus_can_send(sd_bus *bus, char type) {
+_public_ int sd_bus_can_send(sd_bus *bus, char type) {
int r;
assert_return(bus, -EINVAL);
return bus_type_is_valid(type);
}
-int sd_bus_get_server_id(sd_bus *bus, sd_id128_t *server_id) {
+_public_ int sd_bus_get_server_id(sd_bus *bus, sd_id128_t *server_id) {
int r;
assert_return(bus, -EINVAL);
return ret;
}
-int sd_bus_send(sd_bus *bus, sd_bus_message *m, uint64_t *serial) {
+_public_ int sd_bus_send(sd_bus *bus, sd_bus_message *m, uint64_t *serial) {
int r;
assert_return(bus, -EINVAL);
return 0;
}
-int sd_bus_send_with_reply(
+_public_ int sd_bus_send_with_reply(
sd_bus *bus,
sd_bus_message *m,
sd_bus_message_handler_t callback,
return r;
}
-int sd_bus_send_with_reply_cancel(sd_bus *bus, uint64_t serial) {
+_public_ int sd_bus_send_with_reply_cancel(sd_bus *bus, uint64_t serial) {
struct reply_callback *c;
assert_return(bus, -EINVAL);
}
}
-int sd_bus_send_with_reply_and_block(
+_public_ int sd_bus_send_with_reply_and_block(
sd_bus *bus,
sd_bus_message *m,
uint64_t usec,
}
}
-int sd_bus_get_fd(sd_bus *bus) {
+_public_ int sd_bus_get_fd(sd_bus *bus) {
assert_return(bus, -EINVAL);
assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
return bus->input_fd;
}
-int sd_bus_get_events(sd_bus *bus) {
+_public_ int sd_bus_get_events(sd_bus *bus) {
int flags = 0;
assert_return(bus, -EINVAL);
return flags;
}
-int sd_bus_get_timeout(sd_bus *bus, uint64_t *timeout_usec) {
+_public_ int sd_bus_get_timeout(sd_bus *bus, uint64_t *timeout_usec) {
struct reply_callback *c;
assert_return(bus, -EINVAL);
assert(bus);
assert(m);
+ bus->current = m;
bus->iteration_counter++;
log_debug("Got message sender=%s object=%s interface=%s member=%s",
r = process_hello(bus, m);
if (r != 0)
- return r;
+ goto finish;
r = process_reply(bus, m);
if (r != 0)
- return r;
+ goto finish;
r = process_filter(bus, m);
if (r != 0)
- return r;
+ goto finish;
r = process_match(bus, m);
if (r != 0)
- return r;
+ goto finish;
r = process_builtin(bus, m);
if (r != 0)
- return r;
+ goto finish;
- return bus_process_object(bus, m);
+ r = bus_process_object(bus, m);
+
+finish:
+ bus->current = NULL;
+ return r;
}
static int process_running(sd_bus *bus, sd_bus_message **ret) {
return r;
}
-int sd_bus_process(sd_bus *bus, sd_bus_message **ret) {
+_public_ int sd_bus_process(sd_bus *bus, sd_bus_message **ret) {
BUS_DONT_DESTROY(bus);
int r;
return r > 0 ? 1 : 0;
}
-int sd_bus_wait(sd_bus *bus, uint64_t timeout_usec) {
+_public_ int sd_bus_wait(sd_bus *bus, uint64_t timeout_usec) {
assert_return(bus, -EINVAL);
assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
return bus_poll(bus, false, timeout_usec);
}
-int sd_bus_flush(sd_bus *bus) {
+_public_ int sd_bus_flush(sd_bus *bus) {
int r;
assert_return(bus, -EINVAL);
}
}
-int sd_bus_add_filter(sd_bus *bus, sd_bus_message_handler_t callback, void *userdata) {
+_public_ int sd_bus_add_filter(sd_bus *bus,
+ sd_bus_message_handler_t callback,
+ void *userdata) {
+
struct filter_callback *f;
assert_return(bus, -EINVAL);
return 0;
}
-int sd_bus_remove_filter(sd_bus *bus, sd_bus_message_handler_t callback, void *userdata) {
+_public_ int sd_bus_remove_filter(sd_bus *bus,
+ sd_bus_message_handler_t callback,
+ void *userdata) {
+
struct filter_callback *f;
assert_return(bus, -EINVAL);
return 0;
}
-int sd_bus_add_match(sd_bus *bus, const char *match, sd_bus_message_handler_t callback, void *userdata) {
+_public_ int sd_bus_add_match(sd_bus *bus,
+ const char *match,
+ sd_bus_message_handler_t callback,
+ void *userdata) {
+
struct bus_match_component *components = NULL;
unsigned n_components = 0;
uint64_t cookie = 0;
return r;
}
-int sd_bus_remove_match(sd_bus *bus, const char *match, sd_bus_message_handler_t callback, void *userdata) {
+_public_ int sd_bus_remove_match(sd_bus *bus,
+ const char *match,
+ sd_bus_message_handler_t callback,
+ void *userdata) {
+
struct bus_match_component *components = NULL;
unsigned n_components = 0;
int r = 0, q = 0;
return 1;
}
-int sd_bus_attach_event(sd_bus *bus, sd_event *event, int priority) {
+static int quit_callback(sd_event_source *event, void *userdata) {
+ sd_bus *bus = userdata;
+
+ assert(event);
+
+ sd_bus_flush(bus);
+
+ return 1;
+}
+
+_public_ int sd_bus_attach_event(sd_bus *bus, sd_event *event, int priority) {
int r;
assert_return(bus, -EINVAL);
if (r < 0)
goto fail;
+ r = sd_event_add_quit(event, quit_callback, bus, &bus->quit_event_source);
+ if (r < 0)
+ goto fail;
+
return 0;
fail:
return r;
}
-int sd_bus_detach_event(sd_bus *bus) {
+_public_ int sd_bus_detach_event(sd_bus *bus) {
assert_return(bus, -EINVAL);
assert_return(bus->event, -ENXIO);
if (bus->time_event_source)
bus->time_event_source = sd_event_source_unref(bus->time_event_source);
+ if (bus->quit_event_source)
+ bus->quit_event_source = sd_event_source_unref(bus->quit_event_source);
+
if (bus->event)
bus->event = sd_event_unref(bus->event);
return 0;
}
+
+sd_bus_message* sd_bus_get_current(sd_bus *bus) {
+ assert_return(bus, NULL);
+
+ return bus->current;
+}
~ianmdlvl / elogind.git / blobdiff