X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=elogind.git;a=blobdiff_plain;f=src%2Flibsystemd%2Fsd-bus%2Fsd-bus.c;h=15180d042354621bff69831dcd8c41879d301e2b;hp=984611fd4d9c92a959ca59015eb4a443806d5b4d;hb=52cd587789b9452e6e7d5f2f9b2ea652f9ad036e;hpb=eb33a6f858c2cd39dcf9c2f39514c9f83ed040fe diff --git a/src/libsystemd/sd-bus/sd-bus.c b/src/libsystemd/sd-bus/sd-bus.c index 984611fd4..15180d042 100644 --- a/src/libsystemd/sd-bus/sd-bus.c +++ b/src/libsystemd/sd-bus/sd-bus.c @@ -52,6 +52,7 @@ #include "bus-container.h" #include "bus-protocol.h" #include "bus-track.h" +#include "bus-slot.h" static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec); static int attach_io_events(sd_bus *b); @@ -71,52 +72,9 @@ static void bus_close_fds(sd_bus *b) { b->input_fd = b->output_fd = -1; } -static void bus_node_destroy(sd_bus *b, struct node *n) { - struct node_callback *c; - struct node_vtable *v; - struct node_enumerator *e; - - assert(b); - - if (!n) - return; - - while (n->child) - bus_node_destroy(b, n->child); - - while ((c = n->callbacks)) { - LIST_REMOVE(callbacks, n->callbacks, c); - free(c); - } - - while ((v = n->vtables)) { - LIST_REMOVE(vtables, n->vtables, v); - free(v->interface); - free(v); - } - - while ((e = n->enumerators)) { - LIST_REMOVE(enumerators, n->enumerators, e); - free(e); - } - - if (n->parent) - LIST_REMOVE(siblings, n->parent->child, n); - - assert_se(hashmap_remove(b->nodes, n->path) == n); - free(n->path); - free(n); -} - static void bus_reset_queues(sd_bus *b) { assert(b); - /* NOTE: We _must_ decrement b->Xqueue_size before calling - * sd_bus_message_unref() for _each_ message. Otherwise the - * self-reference checks in sd_bus_unref() will fire for each message. - * We would thus recurse into sd_bus_message_unref() and trigger the - * assert(m->n_ref > 0) */ - while (b->rqueue_size > 0) sd_bus_message_unref(b->rqueue[--b->rqueue_size]); @@ -133,15 +91,28 @@ static void bus_reset_queues(sd_bus *b) { } static void bus_free(sd_bus *b) { - struct filter_callback *f; - struct node *n; + sd_bus_slot *s; assert(b); - assert(!b->track_queue); + b->state = BUS_CLOSED; + sd_bus_detach_event(b); + while ((s = b->slots)) { + /* At this point only floating slots can still be + * around, because the non-floating ones keep a + * reference to the bus, and we thus couldn't be + * destructing right now... We forcibly disconnect the + * slots here, so that they still can be referenced by + * apps, but are dead. */ + + assert(s->floating); + bus_slot_disconnect(s); + sd_bus_slot_unref(s); + } + if (b->default_bus_ptr) *b->default_bus_ptr = NULL; @@ -158,7 +129,7 @@ static void bus_free(sd_bus *b) { free(b->machine); free(b->fake_label); free(b->cgroup_root); - free(b->connection_name); + free(b->description); free(b->exec_path); strv_free(b->exec_argv); @@ -168,22 +139,16 @@ static void bus_free(sd_bus *b) { bus_reset_queues(b); - hashmap_free_free(b->reply_callbacks); + ordered_hashmap_free_free(b->reply_callbacks); prioq_free(b->reply_callbacks_prioq); - while ((f = b->filter_callbacks)) { - LIST_REMOVE(callbacks, b->filter_callbacks, f); - free(f); - } - + assert(b->match_callbacks.type == BUS_MATCH_ROOT); bus_match_free(&b->match_callbacks); hashmap_free_free(b->vtable_methods); hashmap_free_free(b->vtable_properties); - while ((n = hashmap_first(b->nodes))) - bus_node_destroy(b, n); - + assert(hashmap_isempty(b->nodes)); hashmap_free(b->nodes); bus_kernel_flush_memfd(b); @@ -309,24 +274,50 @@ _public_ int sd_bus_negotiate_fds(sd_bus *bus, int b) { } _public_ int sd_bus_negotiate_timestamp(sd_bus *bus, int b) { + uint64_t new_flags; assert_return(bus, -EINVAL); - assert_return(bus->state == BUS_UNSET, -EPERM); + assert_return(!IN_SET(bus->state, BUS_CLOSING, BUS_CLOSED), -EPERM); assert_return(!bus_pid_changed(bus), -ECHILD); - SET_FLAG(bus->attach_flags, KDBUS_ATTACH_TIMESTAMP, b); + new_flags = bus->attach_flags; + SET_FLAG(new_flags, KDBUS_ATTACH_TIMESTAMP, b); + + if (bus->attach_flags == new_flags) + return 0; + + bus->attach_flags = new_flags; + if (bus->state != BUS_UNSET && bus->is_kernel) + bus_kernel_realize_attach_flags(bus); + return 0; } -_public_ int sd_bus_negotiate_creds(sd_bus *bus, uint64_t mask) { +_public_ int sd_bus_negotiate_creds(sd_bus *bus, int b, uint64_t mask) { + uint64_t new_flags; + assert_return(bus, -EINVAL); assert_return(mask <= _SD_BUS_CREDS_ALL, -EINVAL); - assert_return(bus->state == BUS_UNSET, -EPERM); + assert_return(!IN_SET(bus->state, BUS_CLOSING, BUS_CLOSED), -EPERM); assert_return(!bus_pid_changed(bus), -ECHILD); + if (b) + bus->creds_mask |= mask; + else + bus->creds_mask &= ~mask; + /* The well knowns we need unconditionally, so that matches can work */ - bus->creds_mask = mask | SD_BUS_CREDS_WELL_KNOWN_NAMES|SD_BUS_CREDS_UNIQUE_NAME; + bus->creds_mask |= SD_BUS_CREDS_WELL_KNOWN_NAMES|SD_BUS_CREDS_UNIQUE_NAME; + + /* Make sure we don't lose the timestamp flag */ + new_flags = (bus->attach_flags & KDBUS_ATTACH_TIMESTAMP) | attach_flags_to_kdbus(bus->creds_mask); + if (bus->attach_flags == new_flags) + return 0; - return kdbus_translate_attach_flags(bus->creds_mask, &bus->attach_flags); + bus->attach_flags = new_flags; + if (bus->state != BUS_UNSET && bus->is_kernel) + bus_kernel_realize_attach_flags(bus); + + return 0; } _public_ int sd_bus_set_server(sd_bus *bus, int b, sd_id128_t server_id) { @@ -358,22 +349,12 @@ _public_ int sd_bus_set_trusted(sd_bus *bus, int b) { return 0; } -_public_ int sd_bus_set_name(sd_bus *bus, const char *name) { - char *n; - +_public_ int sd_bus_set_description(sd_bus *bus, const char *description) { assert_return(bus, -EINVAL); - assert_return(name, -EINVAL); assert_return(bus->state == BUS_UNSET, -EPERM); assert_return(!bus_pid_changed(bus), -ECHILD); - n = strdup(name); - if (!n) - return -ENOMEM; - - free(bus->connection_name); - bus->connection_name = n; - - return 0; + return free_and_strdup(&bus->description, description); } static int hello_callback(sd_bus *bus, sd_bus_message *reply, void *userdata, sd_bus_error *error) { @@ -385,8 +366,6 @@ static int hello_callback(sd_bus *bus, sd_bus_message *reply, void *userdata, sd assert(reply); r = sd_bus_message_get_errno(reply); - if (r < 0) - return r; if (r > 0) return -r; @@ -426,7 +405,7 @@ static int bus_send_hello(sd_bus *bus) { if (r < 0) return r; - return sd_bus_call_async(bus, m, hello_callback, NULL, 0, &bus->hello_cookie); + return sd_bus_call_async(bus, NULL, m, hello_callback, NULL, 0); } int bus_start_running(sd_bus *bus) { @@ -777,7 +756,7 @@ static int parse_kernel_address(sd_bus *b, const char **p, char **guid) { } static int parse_container_unix_address(sd_bus *b, const char **p, char **guid) { - _cleanup_free_ char *machine = NULL; + _cleanup_free_ char *machine = NULL, *pid = NULL; int r; assert(b); @@ -798,18 +777,36 @@ static int parse_container_unix_address(sd_bus *b, const char **p, char **guid) else if (r > 0) continue; + r = parse_address_key(p, "pid", &pid); + if (r < 0) + return r; + else if (r > 0) + continue; + skip_address_key(p); } - if (!machine) + if (!machine == !pid) return -EINVAL; - if (!filename_is_safe(machine)) - return -EINVAL; + if (machine) { + if (!machine_name_is_valid(machine)) + return -EINVAL; - free(b->machine); - b->machine = machine; - machine = NULL; + free(b->machine); + b->machine = machine; + machine = NULL; + } else { + free(b->machine); + b->machine = NULL; + } + + if (pid) { + r = parse_pid(pid, &b->nspid); + if (r < 0) + return r; + } else + b->nspid = 0; 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)); @@ -819,7 +816,7 @@ static int parse_container_unix_address(sd_bus *b, const char **p, char **guid) } static int parse_container_kernel_address(sd_bus *b, const char **p, char **guid) { - _cleanup_free_ char *machine = NULL; + _cleanup_free_ char *machine = NULL, *pid = NULL; int r; assert(b); @@ -840,21 +837,39 @@ static int parse_container_kernel_address(sd_bus *b, const char **p, char **guid else if (r > 0) continue; + r = parse_address_key(p, "pid", &pid); + if (r < 0) + return r; + else if (r > 0) + continue; + skip_address_key(p); } - if (!machine) + if (!machine == !pid) return -EINVAL; - if (!filename_is_safe(machine)) - return -EINVAL; + if (machine) { + if (!machine_name_is_valid(machine)) + return -EINVAL; - free(b->machine); - b->machine = machine; - machine = NULL; + free(b->machine); + b->machine = machine; + machine = NULL; + } else { + free(b->machine); + b->machine = NULL; + } + + if (pid) { + r = parse_pid(pid, &b->nspid); + if (r < 0) + return r; + } else + b->nspid = 0; free(b->kernel); - b->kernel = strdup("/dev/kdbus/0-system/bus"); + b->kernel = strdup("/sys/fs/kdbus/0-system/bus"); if (!b->kernel) return -ENOMEM; @@ -875,6 +890,7 @@ static void bus_reset_parsed_address(sd_bus *b) { b->kernel = NULL; free(b->machine); b->machine = NULL; + b->nspid = 0; } static int bus_parse_next_address(sd_bus *b) { @@ -934,17 +950,17 @@ static int bus_parse_next_address(sd_bus *b) { return r; break; - } else if (startswith(a, "x-container-unix:")) { + } else if (startswith(a, "x-machine-unix:")) { - a += 17; + a += 15; r = parse_container_unix_address(b, &a, &guid); if (r < 0) return r; break; - } else if (startswith(a, "x-container-kernel:")) { + } else if (startswith(a, "x-machine-kernel:")) { - a += 19; + a += 17; r = parse_container_kernel_address(b, &a, &guid); if (r < 0) return r; @@ -979,9 +995,9 @@ static int bus_start_address(sd_bus *b) { if (b->exec_path) r = bus_socket_exec(b); - else if (b->machine && b->kernel) + else if ((b->nspid > 0 || b->machine) && b->kernel) r = bus_container_connect_kernel(b); - else if (b->machine && b->sockaddr.sa.sa_family != AF_UNSPEC) + else if ((b->nspid > 0 || b->machine) && b->sockaddr.sa.sa_family != AF_UNSPEC) r = bus_container_connect_socket(b); else if (b->kernel) r = bus_kernel_connect(b); @@ -1069,8 +1085,10 @@ _public_ int sd_bus_start(sd_bus *bus) { else return -EINVAL; - if (r < 0) + if (r < 0) { + sd_bus_close(bus); return r; + } return bus_send_hello(bus); } @@ -1116,6 +1134,7 @@ _public_ int sd_bus_open(sd_bus **ret) { * be safe, and authenticate everything */ b->trusted = false; b->attach_flags |= KDBUS_ATTACH_CAPS | KDBUS_ATTACH_CREDS; + b->creds_mask |= SD_BUS_CREDS_UID | SD_BUS_CREDS_EUID | SD_BUS_CREDS_EFFECTIVE_CAPS; r = sd_bus_start(b); if (r < 0) @@ -1137,7 +1156,7 @@ int bus_set_address_system(sd_bus *b) { if (e) return sd_bus_set_address(b, e); - return sd_bus_set_address(b, DEFAULT_SYSTEM_BUS_PATH); + return sd_bus_set_address(b, DEFAULT_SYSTEM_BUS_ADDRESS); } _public_ int sd_bus_open_system(sd_bus **ret) { @@ -1161,6 +1180,7 @@ _public_ int sd_bus_open_system(sd_bus **ret) { * need the caller's UID and capability set for that. */ b->trusted = false; b->attach_flags |= KDBUS_ATTACH_CAPS | KDBUS_ATTACH_CREDS; + b->creds_mask |= SD_BUS_CREDS_UID | SD_BUS_CREDS_EUID | SD_BUS_CREDS_EFFECTIVE_CAPS; r = sd_bus_start(b); if (r < 0) @@ -1192,13 +1212,13 @@ int bus_set_address_user(sd_bus *b) { return -ENOMEM; #ifdef ENABLE_KDBUS - asprintf(&b->address, KERNEL_USER_BUS_FMT ";" UNIX_USER_BUS_FMT, (unsigned long) getuid(), ee); + (void) asprintf(&b->address, KERNEL_USER_BUS_ADDRESS_FMT ";" UNIX_USER_BUS_ADDRESS_FMT, getuid(), ee); #else - asprintf(&b->address, UNIX_USER_BUS_FMT, ee); + (void) asprintf(&b->address, UNIX_USER_BUS_ADDRESS_FMT, ee); #endif } else { #ifdef ENABLE_KDBUS - asprintf(&b->address, KERNEL_USER_BUS_FMT, (unsigned long) getuid()); + (void) asprintf(&b->address, KERNEL_USER_BUS_ADDRESS_FMT, getuid()); #else return -ECONNREFUSED; #endif @@ -1245,15 +1265,38 @@ fail: int bus_set_address_system_remote(sd_bus *b, const char *host) { _cleanup_free_ char *e = NULL; + char *m = NULL, *c = NULL; assert(b); assert(host); - e = bus_address_escape(host); - if (!e) - return -ENOMEM; + /* Let's see if we shall enter some container */ + m = strchr(host, ':'); + if (m) { + m++; - b->address = strjoin("unixexec:path=ssh,argv1=-xT,argv2=", e, ",argv3=systemd-stdio-bridge", NULL); + /* Let's make sure this is not a port of some kind, + * and is a valid machine name. */ + if (!in_charset(m, "0123456789") && machine_name_is_valid(m)) { + char *t; + + /* Cut out the host part */ + t = strndupa(host, m - host - 1); + e = bus_address_escape(t); + if (!e) + return -ENOMEM; + + c = strappenda(",argv4=--machine=", m); + } + } + + if (!e) { + e = bus_address_escape(host); + if (!e) + return -ENOMEM; + } + + b->address = strjoin("unixexec:path=ssh,argv1=-xT,argv2=", e, ",argv3=systemd-stdio-bridge", c, NULL); if (!b->address) return -ENOMEM; @@ -1277,6 +1320,7 @@ _public_ int sd_bus_open_system_remote(sd_bus **ret, const char *host) { bus->bus_client = true; bus->trusted = false; + bus->is_system = true; r = sd_bus_start(bus); if (r < 0) @@ -1290,7 +1334,7 @@ fail: return r; } -int bus_set_address_system_container(sd_bus *b, const char *machine) { +int bus_set_address_system_machine(sd_bus *b, const char *machine) { _cleanup_free_ char *e = NULL; assert(b); @@ -1301,9 +1345,9 @@ int bus_set_address_system_container(sd_bus *b, const char *machine) { return -ENOMEM; #ifdef ENABLE_KDBUS - b->address = strjoin("x-container-kernel:machine=", e, ";x-container-unix:machine=", e, NULL); + b->address = strjoin("x-machine-kernel:machine=", e, ";x-machine-unix:machine=", e, NULL); #else - b->address = strjoin("x-container-unix:machine=", e, NULL); + b->address = strjoin("x-machine-unix:machine=", e, NULL); #endif if (!b->address) return -ENOMEM; @@ -1311,24 +1355,25 @@ int bus_set_address_system_container(sd_bus *b, const char *machine) { return 0; } -_public_ int sd_bus_open_system_container(sd_bus **ret, const char *machine) { +_public_ int sd_bus_open_system_machine(sd_bus **ret, const char *machine) { sd_bus *bus; int r; assert_return(machine, -EINVAL); assert_return(ret, -EINVAL); - assert_return(filename_is_safe(machine), -EINVAL); + assert_return(machine_name_is_valid(machine), -EINVAL); r = sd_bus_new(&bus); if (r < 0) return r; - r = bus_set_address_system_container(bus, machine); + r = bus_set_address_system_machine(bus, machine); if (r < 0) goto fail; bus->bus_client = true; bus->trusted = false; + bus->is_system = true; r = sd_bus_start(bus); if (r < 0) @@ -1394,35 +1439,6 @@ _public_ sd_bus *sd_bus_unref(sd_bus *bus) { if (!bus) return NULL; - if (REFCNT_GET(bus->n_ref) == bus->rqueue_size + bus->wqueue_size + 1) { - bool q = true; - - for (i = 0; i < bus->rqueue_size; i++) - if (bus->rqueue[i]->n_ref > 1) { - q = false; - break; - } - - if (q) { - for (i = 0; i < bus->wqueue_size; i++) - if (bus->wqueue[i]->n_ref > 1) { - q = false; - break; - } - } - - /* We are the only holders on the messages, and the - * messages are the only holders on us, so let's drop - * the messages and thus implicitly also kill our own - * last references. - * bus_reset_queues() decrements the queue-size before - * calling into sd_bus_message_unref(). Thus, it - * protects us from recursion. */ - - if (q) - bus_reset_queues(bus); - } - i = REFCNT_DEC(bus->n_ref); if (i > 0) return NULL; @@ -1463,18 +1479,18 @@ _public_ int sd_bus_can_send(sd_bus *bus, char type) { return bus_type_is_valid(type); } -_public_ int sd_bus_get_server_id(sd_bus *bus, sd_id128_t *server_id) { +_public_ int sd_bus_get_bus_id(sd_bus *bus, sd_id128_t *id) { int r; assert_return(bus, -EINVAL); - assert_return(server_id, -EINVAL); + assert_return(id, -EINVAL); assert_return(!bus_pid_changed(bus), -ECHILD); r = bus_ensure_running(bus); if (r < 0) return r; - *server_id = bus->server_id; + *id = bus->server_id; return 0; } @@ -1512,6 +1528,16 @@ int bus_seal_synthetic_message(sd_bus *b, sd_bus_message *m) { assert(b); assert(m); + /* Fake some timestamps, if they were requested, and not + * already initialized */ + if (b->attach_flags & KDBUS_ATTACH_TIMESTAMP) { + if (m->realtime <= 0) + m->realtime = now(CLOCK_REALTIME); + + if (m->monotonic <= 0) + m->monotonic = now(CLOCK_MONOTONIC); + } + /* The bus specification says the serial number cannot be 0, * hence let's fill something in for synthetic messages. Since * synthetic messages might have a fake sender and we don't @@ -1519,7 +1545,6 @@ int bus_seal_synthetic_message(sd_bus *b, sd_bus_message *m) { * pick a fixed, artificial one. We use (uint32_t) -1 rather * than (uint64_t) -1 since dbus1 only had 32bit identifiers, * even though kdbus can do 64bit. */ - return bus_message_seal(m, 0xFFFFFFFFULL, 0); } @@ -1775,14 +1800,14 @@ static int timeout_compare(const void *a, const void *b) { _public_ int sd_bus_call_async( sd_bus *bus, + sd_bus_slot **slot, sd_bus_message *_m, sd_bus_message_handler_t callback, void *userdata, - uint64_t usec, - uint64_t *cookie) { + uint64_t usec) { _cleanup_bus_message_unref_ sd_bus_message *m = sd_bus_message_ref(_m); - struct reply_callback *c; + _cleanup_bus_slot_unref_ sd_bus_slot *s = NULL; int r; assert_return(bus, -EINVAL); @@ -1796,7 +1821,7 @@ _public_ int sd_bus_call_async( if (!BUS_IS_OPEN(bus->state)) return -ENOTCONN; - r = hashmap_ensure_allocated(&bus->reply_callbacks, uint64_hash_func, uint64_compare_func); + r = ordered_hashmap_ensure_allocated(&bus->reply_callbacks, &uint64_hash_ops); if (r < 0) return r; @@ -1812,55 +1837,37 @@ _public_ int sd_bus_call_async( if (r < 0) return r; - c = new0(struct reply_callback, 1); - if (!c) + s = bus_slot_allocate(bus, !slot, BUS_REPLY_CALLBACK, sizeof(struct reply_callback), userdata); + if (!s) return -ENOMEM; - c->callback = callback; - c->userdata = userdata; - c->cookie = BUS_MESSAGE_COOKIE(m); - c->timeout = calc_elapse(m->timeout); + s->reply_callback.callback = callback; - r = hashmap_put(bus->reply_callbacks, &c->cookie, c); + s->reply_callback.cookie = BUS_MESSAGE_COOKIE(m); + r = ordered_hashmap_put(bus->reply_callbacks, &s->reply_callback.cookie, &s->reply_callback); if (r < 0) { - free(c); + s->reply_callback.cookie = 0; return r; } - if (c->timeout != 0) { - r = prioq_put(bus->reply_callbacks_prioq, c, &c->prioq_idx); + s->reply_callback.timeout = calc_elapse(m->timeout); + if (s->reply_callback.timeout != 0) { + r = prioq_put(bus->reply_callbacks_prioq, &s->reply_callback, &s->reply_callback.prioq_idx); if (r < 0) { - c->timeout = 0; - sd_bus_call_async_cancel(bus, c->cookie); + s->reply_callback.timeout = 0; return r; } } - r = sd_bus_send(bus, m, cookie); - if (r < 0) { - sd_bus_call_async_cancel(bus, c->cookie); + r = sd_bus_send(bus, m, &s->reply_callback.cookie); + if (r < 0) return r; - } - - return r; -} - -_public_ int sd_bus_call_async_cancel(sd_bus *bus, uint64_t cookie) { - struct reply_callback *c; - - assert_return(bus, -EINVAL); - assert_return(cookie != 0, -EINVAL); - assert_return(!bus_pid_changed(bus), -ECHILD); - c = hashmap_remove(bus->reply_callbacks, &cookie); - if (!c) - return 0; + if (slot) + *slot = s; + s = NULL; - if (c->timeout != 0) - prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx); - - free(c); - return 1; + return r; } int bus_ensure_running(sd_bus *bus) { @@ -2107,6 +2114,11 @@ _public_ int sd_bus_get_timeout(sd_bus *bus, uint64_t *timeout_usec) { return 0; } + if (c->timeout == 0) { + *timeout_usec = (uint64_t) -1; + return 0; + } + *timeout_usec = c->timeout; return 1; } @@ -2115,6 +2127,7 @@ static int process_timeout(sd_bus *bus) { _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL; _cleanup_bus_message_unref_ sd_bus_message* m = NULL; struct reply_callback *c; + sd_bus_slot *slot; usec_t n; int r; @@ -2136,25 +2149,38 @@ static int process_timeout(sd_bus *bus) { if (r < 0) return r; - m->sender = "org.freedesktop.DBus"; - r = bus_seal_synthetic_message(bus, m); if (r < 0) return r; assert_se(prioq_pop(bus->reply_callbacks_prioq) == c); - hashmap_remove(bus->reply_callbacks, &c->cookie); + c->timeout = 0; + + ordered_hashmap_remove(bus->reply_callbacks, &c->cookie); + c->cookie = 0; + + slot = container_of(c, sd_bus_slot, reply_callback); - bus->current = m; bus->iteration_counter ++; - r = c->callback(bus, m, c->userdata, &error_buffer); - r = bus_maybe_reply_error(m, r, &error_buffer); - free(c); + bus->current_message = m; + bus->current_slot = sd_bus_slot_ref(slot); + bus->current_handler = c->callback; + bus->current_userdata = slot->userdata; + r = c->callback(bus, m, slot->userdata, &error_buffer); + bus->current_userdata = NULL; + bus->current_handler = NULL; + bus->current_slot = NULL; + bus->current_message = NULL; - bus->current = NULL; + if (slot->floating) { + bus_slot_disconnect(slot); + sd_bus_slot_unref(slot); + } - return r; + sd_bus_slot_unref(slot); + + return bus_maybe_reply_error(m, r, &error_buffer); } static int process_hello(sd_bus *bus, sd_bus_message *m) { @@ -2173,7 +2199,7 @@ static int process_hello(sd_bus *bus, sd_bus_message *m) { m->header->type != SD_BUS_MESSAGE_METHOD_ERROR) return -EIO; - if (m->reply_cookie != bus->hello_cookie) + if (m->reply_cookie != 1) return -EIO; return 0; @@ -2182,7 +2208,8 @@ static int process_hello(sd_bus *bus, sd_bus_message *m) { static int process_reply(sd_bus *bus, sd_bus_message *m) { _cleanup_bus_message_unref_ sd_bus_message *synthetic_reply = NULL; _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL; - _cleanup_free_ struct reply_callback *c = NULL; + struct reply_callback *c; + sd_bus_slot *slot; int r; assert(bus); @@ -2198,12 +2225,13 @@ static int process_reply(sd_bus *bus, sd_bus_message *m) { if (m->destination && bus->unique_name && !streq_ptr(m->destination, bus->unique_name)) return 0; - c = hashmap_remove(bus->reply_callbacks, &m->reply_cookie); + c = ordered_hashmap_remove(bus->reply_callbacks, &m->reply_cookie); if (!c) return 0; - if (c->timeout != 0) - prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx); + c->cookie = 0; + + slot = container_of(c, sd_bus_slot, reply_callback); if (m->n_fds > 0 && !(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)) { @@ -2218,6 +2246,11 @@ static int process_reply(sd_bus *bus, sd_bus_message *m) { if (r < 0) return r; + /* Copy over original timestamp */ + synthetic_reply->realtime = m->realtime; + synthetic_reply->monotonic = m->monotonic; + synthetic_reply->seqnum = m->seqnum; + r = bus_seal_synthetic_message(bus, synthetic_reply); if (r < 0) return r; @@ -2229,10 +2262,27 @@ static int process_reply(sd_bus *bus, sd_bus_message *m) { return r; } - r = c->callback(bus, m, c->userdata, &error_buffer); - r = bus_maybe_reply_error(m, r, &error_buffer); + if (c->timeout != 0) { + prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx); + c->timeout = 0; + } - return r; + bus->current_slot = sd_bus_slot_ref(slot); + bus->current_handler = c->callback; + bus->current_userdata = slot->userdata; + r = c->callback(bus, m, slot->userdata, &error_buffer); + bus->current_userdata = NULL; + bus->current_handler = NULL; + bus->current_slot = NULL; + + if (slot->floating) { + bus_slot_disconnect(slot); + sd_bus_slot_unref(slot); + } + + sd_bus_slot_unref(slot); + + return bus_maybe_reply_error(m, r, &error_buffer); } static int process_filter(sd_bus *bus, sd_bus_message *m) { @@ -2247,6 +2297,7 @@ static int process_filter(sd_bus *bus, sd_bus_message *m) { bus->filter_callbacks_modified = false; LIST_FOREACH(callbacks, l, bus->filter_callbacks) { + sd_bus_slot *slot; if (bus->filter_callbacks_modified) break; @@ -2261,7 +2312,16 @@ static int process_filter(sd_bus *bus, sd_bus_message *m) { if (r < 0) return r; - r = l->callback(bus, m, l->userdata, &error_buffer); + slot = container_of(l, sd_bus_slot, filter_callback); + + bus->current_slot = sd_bus_slot_ref(slot); + bus->current_handler = l->callback; + bus->current_userdata = slot->userdata; + r = l->callback(bus, m, slot->userdata, &error_buffer); + bus->current_userdata = NULL; + bus->current_handler = NULL; + bus->current_slot = sd_bus_slot_unref(slot); + r = bus_maybe_reply_error(m, r, &error_buffer); if (r != 0) return r; @@ -2377,7 +2437,7 @@ static int process_message(sd_bus *bus, sd_bus_message *m) { assert(bus); assert(m); - bus->current = m; + bus->current_message = m; bus->iteration_counter++; log_debug("Got message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%" PRIu64 " reply_cookie=%" PRIu64 " error=%s", @@ -2418,7 +2478,7 @@ static int process_message(sd_bus *bus, sd_bus_message *m) { r = bus_process_object(bus, m); finish: - bus->current = NULL; + bus->current_message = NULL; return r; } @@ -2504,9 +2564,10 @@ static int process_closing(sd_bus *bus, sd_bus_message **ret) { assert(bus); assert(bus->state == BUS_CLOSING); - c = hashmap_first(bus->reply_callbacks); + c = ordered_hashmap_first(bus->reply_callbacks); if (c) { _cleanup_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL; + sd_bus_slot *slot; /* First, fail all outstanding method calls */ r = bus_message_new_synthetic_error( @@ -2521,19 +2582,36 @@ static int process_closing(sd_bus *bus, sd_bus_message **ret) { if (r < 0) return r; - if (c->timeout != 0) + if (c->timeout != 0) { prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx); + c->timeout = 0; + } + + ordered_hashmap_remove(bus->reply_callbacks, &c->cookie); + c->cookie = 0; - hashmap_remove(bus->reply_callbacks, &c->cookie); + slot = container_of(c, sd_bus_slot, reply_callback); - bus->current = m; bus->iteration_counter++; - r = c->callback(bus, m, c->userdata, &error_buffer); - r = bus_maybe_reply_error(m, r, &error_buffer); - free(c); + bus->current_message = m; + bus->current_slot = sd_bus_slot_ref(slot); + bus->current_handler = c->callback; + bus->current_userdata = slot->userdata; + r = c->callback(bus, m, slot->userdata, &error_buffer); + bus->current_userdata = NULL; + bus->current_handler = NULL; + bus->current_slot = NULL; + bus->current_message = NULL; + + if (slot->floating) { + bus_slot_disconnect(slot); + sd_bus_slot_unref(slot); + } - goto finish; + sd_bus_slot_unref(slot); + + return bus_maybe_reply_error(m, r, &error_buffer); } /* Then, synthesize a Disconnected message */ @@ -2546,7 +2624,7 @@ static int process_closing(sd_bus *bus, sd_bus_message **ret) { if (r < 0) return r; - m->sender = "org.freedesktop.DBus.Local"; + bus_message_set_sender_local(bus, m); r = bus_seal_synthetic_message(bus, m); if (r < 0) @@ -2554,7 +2632,7 @@ static int process_closing(sd_bus *bus, sd_bus_message **ret) { sd_bus_close(bus); - bus->current = m; + bus->current_message = m; bus->iteration_counter++; r = process_filter(bus, m); @@ -2573,7 +2651,8 @@ static int process_closing(sd_bus *bus, sd_bus_message **ret) { r = 1; finish: - bus->current = NULL; + bus->current_message = NULL; + return r; } @@ -2590,7 +2669,8 @@ static int bus_process_internal(sd_bus *bus, bool hint_priority, int64_t priorit assert_return(!bus_pid_changed(bus), -ECHILD); /* We don't allow recursively invoking sd_bus_process(). */ - assert_return(!bus->current, -EBUSY); + assert_return(!bus->current_message, -EBUSY); + assert(!bus->current_slot); switch (bus->state) { @@ -2656,7 +2736,7 @@ static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec) { struct pollfd p[2] = {}; int r, e, n; struct timespec ts; - usec_t m = (usec_t) -1; + usec_t m = USEC_INFINITY; assert(bus); @@ -2673,7 +2753,7 @@ static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec) { if (need_more) /* The caller really needs some more data, he doesn't * care about what's already read, or any timeouts - * except its own.*/ + * except its own. */ e |= POLLIN; else { usec_t until; @@ -2767,57 +2847,43 @@ _public_ int sd_bus_flush(sd_bus *bus) { } } -_public_ 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_slot **slot, + sd_bus_message_handler_t callback, + void *userdata) { - struct filter_callback *f; + sd_bus_slot *s; assert_return(bus, -EINVAL); assert_return(callback, -EINVAL); assert_return(!bus_pid_changed(bus), -ECHILD); - f = new0(struct filter_callback, 1); - if (!f) + s = bus_slot_allocate(bus, !slot, BUS_FILTER_CALLBACK, sizeof(struct filter_callback), userdata); + if (!s) return -ENOMEM; - f->callback = callback; - f->userdata = userdata; - bus->filter_callbacks_modified = true; - LIST_PREPEND(callbacks, bus->filter_callbacks, f); - return 0; -} - -_public_ int sd_bus_remove_filter(sd_bus *bus, - sd_bus_message_handler_t callback, - void *userdata) { - - struct filter_callback *f; + s->filter_callback.callback = callback; - assert_return(bus, -EINVAL); - assert_return(callback, -EINVAL); - assert_return(!bus_pid_changed(bus), -ECHILD); + bus->filter_callbacks_modified = true; + LIST_PREPEND(callbacks, bus->filter_callbacks, &s->filter_callback); - LIST_FOREACH(callbacks, f, bus->filter_callbacks) { - if (f->callback == callback && f->userdata == userdata) { - bus->filter_callbacks_modified = true; - LIST_REMOVE(callbacks, bus->filter_callbacks, f); - free(f); - return 1; - } - } + if (slot) + *slot = s; return 0; } -_public_ 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, + sd_bus_slot **slot, + 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; + sd_bus_slot *s = NULL; int r = 0; assert_return(bus, -EINVAL); @@ -2828,35 +2894,60 @@ _public_ int sd_bus_add_match(sd_bus *bus, if (r < 0) goto finish; + s = bus_slot_allocate(bus, !slot, BUS_MATCH_CALLBACK, sizeof(struct match_callback), userdata); + if (!s) { + r = -ENOMEM; + goto finish; + } + + s->match_callback.callback = callback; + s->match_callback.cookie = ++bus->match_cookie; + if (bus->bus_client) { - cookie = ++bus->match_cookie; - r = bus_add_match_internal(bus, match, components, n_components, cookie); + if (!bus->is_kernel) { + /* When this is not a kernel transport, we + * store the original match string, so that we + * can use it to remove the match again */ + + s->match_callback.match_string = strdup(match); + if (!s->match_callback.match_string) { + r = -ENOMEM; + goto finish; + } + } + + r = bus_add_match_internal(bus, s->match_callback.match_string, components, n_components, s->match_callback.cookie); if (r < 0) goto finish; } bus->match_callbacks_modified = true; - r = bus_match_add(&bus->match_callbacks, components, n_components, callback, userdata, cookie, NULL); - if (r < 0) { - if (bus->bus_client) - bus_remove_match_internal(bus, match, cookie); - } + r = bus_match_add(&bus->match_callbacks, components, n_components, &s->match_callback); + if (r < 0) + goto finish; + + if (slot) + *slot = s; + s = NULL; finish: bus_match_parse_free(components, n_components); + sd_bus_slot_unref(s); + return r; } -_public_ int sd_bus_remove_match(sd_bus *bus, - const char *match, - sd_bus_message_handler_t callback, - void *userdata) { +int bus_remove_match_by_string( + 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; - uint64_t cookie = 0; + struct match_callback *c; + int r = 0; assert_return(bus, -EINVAL); assert_return(match, -EINVAL); @@ -2864,17 +2955,18 @@ _public_ int sd_bus_remove_match(sd_bus *bus, r = bus_match_parse(match, &components, &n_components); if (r < 0) - return r; + goto finish; - bus->match_callbacks_modified = true; - r = bus_match_remove(&bus->match_callbacks, components, n_components, callback, userdata, &cookie); + r = bus_match_find(&bus->match_callbacks, components, n_components, NULL, NULL, &c); + if (r <= 0) + goto finish; - if (bus->bus_client) - q = bus_remove_match_internal(bus, match, cookie); + sd_bus_slot_unref(container_of(c, sd_bus_slot, match_callback)); +finish: bus_match_parse_free(components, n_components); - return r < 0 ? r : q; + return r; } bool bus_pid_changed(sd_bus *bus) { @@ -2963,6 +3055,7 @@ static int quit_callback(sd_event_source *event, void *userdata) { assert(event); sd_bus_flush(bus); + sd_bus_close(bus); return 1; } @@ -2988,6 +3081,10 @@ static int attach_io_events(sd_bus *bus) { return r; r = sd_event_source_set_priority(bus->input_io_event_source, bus->event_priority); + if (r < 0) + return r; + + r = sd_event_source_set_description(bus->input_io_event_source, "bus-input"); } else r = sd_event_source_set_io_fd(bus->input_io_event_source, bus->input_fd); @@ -3003,6 +3100,10 @@ static int attach_io_events(sd_bus *bus) { return r; r = sd_event_source_set_priority(bus->output_io_event_source, bus->event_priority); + if (r < 0) + return r; + + r = sd_event_source_set_description(bus->input_io_event_source, "bus-output"); } else r = sd_event_source_set_io_fd(bus->output_io_event_source, bus->output_fd); @@ -3047,7 +3148,7 @@ _public_ int sd_bus_attach_event(sd_bus *bus, sd_event *event, int priority) { bus->event_priority = priority; - r = sd_event_add_monotonic(bus->event, &bus->time_event_source, 0, 0, time_callback, bus); + r = sd_event_add_time(bus->event, &bus->time_event_source, CLOCK_MONOTONIC, 0, 0, time_callback, bus); if (r < 0) goto fail; @@ -3055,10 +3156,18 @@ _public_ int sd_bus_attach_event(sd_bus *bus, sd_event *event, int priority) { if (r < 0) goto fail; + r = sd_event_source_set_description(bus->time_event_source, "bus-time"); + if (r < 0) + goto fail; + r = sd_event_add_exit(bus->event, &bus->quit_event_source, quit_callback, bus); if (r < 0) goto fail; + r = sd_event_source_set_description(bus->quit_event_source, "bus-exit"); + if (r < 0) + goto fail; + r = attach_io_events(bus); if (r < 0) goto fail; @@ -3088,9 +3197,7 @@ _public_ int sd_bus_detach_event(sd_bus *bus) { bus->quit_event_source = sd_event_source_unref(bus->quit_event_source); } - if (bus->event) - bus->event = sd_event_unref(bus->event); - + bus->event = sd_event_unref(bus->event); return 1; } @@ -3100,10 +3207,28 @@ _public_ sd_event* sd_bus_get_event(sd_bus *bus) { return bus->event; } -_public_ sd_bus_message* sd_bus_get_current(sd_bus *bus) { +_public_ sd_bus_message* sd_bus_get_current_message(sd_bus *bus) { + assert_return(bus, NULL); + + return bus->current_message; +} + +_public_ sd_bus_slot* sd_bus_get_current_slot(sd_bus *bus) { assert_return(bus, NULL); - return bus->current; + return bus->current_slot; +} + +_public_ sd_bus_message_handler_t sd_bus_get_current_handler(sd_bus *bus) { + assert_return(bus, NULL); + + return bus->current_handler; +} + +_public_ void* sd_bus_get_current_userdata(sd_bus *bus) { + assert_return(bus, NULL); + + return bus->current_userdata; } static int bus_default(int (*bus_open)(sd_bus **), sd_bus **default_bus, sd_bus **ret) { @@ -3240,14 +3365,10 @@ _public_ int sd_bus_path_decode(const char *path, const char *prefix, char **ext return 1; } -_public_ int sd_bus_get_peer_creds(sd_bus *bus, uint64_t mask, sd_bus_creds **ret) { - sd_bus_creds *c; - pid_t pid = 0; +_public_ int sd_bus_try_close(sd_bus *bus) { int r; assert_return(bus, -EINVAL); - assert_return(mask <= _SD_BUS_CREDS_ALL, -ENOTSUP); - assert_return(ret, -EINVAL); assert_return(!bus_pid_changed(bus), -ECHILD); if (!bus->is_kernel) @@ -3256,70 +3377,142 @@ _public_ int sd_bus_get_peer_creds(sd_bus *bus, uint64_t mask, sd_bus_creds **re if (!BUS_IS_OPEN(bus->state)) return -ENOTCONN; - if (!bus->ucred_valid && !isempty(bus->label)) - return -ENODATA; + if (bus->rqueue_size > 0) + return -EBUSY; - c = bus_creds_new(); - if (!c) - return -ENOMEM; + if (bus->wqueue_size > 0) + return -EBUSY; - if (bus->ucred_valid) { - pid = c->pid = bus->ucred.pid; - c->uid = bus->ucred.uid; - c->gid = bus->ucred.gid; + r = bus_kernel_try_close(bus); + if (r < 0) + return r; - c->mask |= (SD_BUS_CREDS_UID | SD_BUS_CREDS_PID | SD_BUS_CREDS_GID) & mask; - } + sd_bus_close(bus); + return 0; +} + +_public_ int sd_bus_get_description(sd_bus *bus, const char **description) { + assert_return(bus, -EINVAL); + assert_return(description, -EINVAL); + assert_return(bus->description, -ENXIO); + assert_return(!bus_pid_changed(bus), -ECHILD); + + *description = bus->description; + return 0; +} + +int bus_get_root_path(sd_bus *bus) { + int r; + + if (bus->cgroup_root) + return 0; - if (!isempty(bus->label) && (mask & SD_BUS_CREDS_SELINUX_CONTEXT)) { - c->label = strdup(bus->label); - if (!c->label) { - sd_bus_creds_unref(c); + r = cg_get_root_path(&bus->cgroup_root); + if (r == -ENOENT) { + bus->cgroup_root = strdup("/"); + if (!bus->cgroup_root) return -ENOMEM; - } - c->mask |= SD_BUS_CREDS_SELINUX_CONTEXT; + r = 0; } - r = bus_creds_add_more(c, mask, pid, 0); - if (r < 0) - return r; - - *ret = c; - return 0; + return r; } -_public_ int sd_bus_try_close(sd_bus *bus) { +_public_ int sd_bus_get_scope(sd_bus *bus, const char **scope) { int r; assert_return(bus, -EINVAL); + assert_return(scope, -EINVAL); assert_return(!bus_pid_changed(bus), -ECHILD); - if (!bus->is_kernel) - return -ENOTSUP; + if (bus->is_kernel) { + _cleanup_free_ char *n = NULL; + const char *dash; - if (!BUS_IS_OPEN(bus->state)) - return -ENOTCONN; + r = bus_kernel_get_bus_name(bus, &n); + if (r < 0) + return r; - if (bus->rqueue_size > 0) - return -EBUSY; + if (streq(n, "0-system")) { + *scope = "system"; + return 0; + } - if (bus->wqueue_size > 0) - return -EBUSY; + dash = strchr(n, '-'); + if (streq_ptr(dash, "-user")) { + *scope = "user"; + return 0; + } + } - r = bus_kernel_try_close(bus); - if (r < 0) - return r; + if (bus->is_user) { + *scope = "user"; + return 0; + } - sd_bus_close(bus); - return 0; + if (bus->is_system) { + *scope = "system"; + return 0; + } + + return -ENODATA; +} + +_public_ int sd_bus_get_address(sd_bus *bus, const char **address) { + + assert_return(bus, -EINVAL); + assert_return(address, -EINVAL); + assert_return(!bus_pid_changed(bus), -ECHILD); + + if (bus->address) { + *address = bus->address; + return 0; + } + + return -ENODATA; } -_public_ int sd_bus_get_name(sd_bus *bus, const char **name) { +int sd_bus_get_creds_mask(sd_bus *bus, uint64_t *mask) { assert_return(bus, -EINVAL); - assert_return(name, -EINVAL); + assert_return(mask, -EINVAL); assert_return(!bus_pid_changed(bus), -ECHILD); - *name = bus->connection_name; + *mask = bus->creds_mask; return 0; } + +int sd_bus_is_bus_client(sd_bus *bus) { + assert_return(bus, -EINVAL); + assert_return(!bus_pid_changed(bus), -ECHILD); + + return bus->bus_client; +} + +int sd_bus_is_server(sd_bus *bus) { + assert_return(bus, -EINVAL); + assert_return(!bus_pid_changed(bus), -ECHILD); + + return bus->is_server; +} + +int sd_bus_is_anonymous(sd_bus *bus) { + assert_return(bus, -EINVAL); + assert_return(!bus_pid_changed(bus), -ECHILD); + + return bus->anonymous_auth; +} + +int sd_bus_is_trusted(sd_bus *bus) { + assert_return(bus, -EINVAL); + assert_return(!bus_pid_changed(bus), -ECHILD); + + return bus->trusted; +} + +int sd_bus_is_monitor(sd_bus *bus) { + assert_return(bus, -EINVAL); + assert_return(!bus_pid_changed(bus), -ECHILD); + + return !!(bus->hello_flags & KDBUS_HELLO_MONITOR); +}