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=6f5ba5bd5b959e55f6bf92367f28c64c3d616291;hp=2c458f311c0912aaef1e85e15d89256376cf8624;hb=09365592341b4ba4ceca677bb551dcde811e0333;hpb=069f5e61eb128aa08b6fdff12fc6ac71c3897b48 diff --git a/src/libsystemd/sd-bus/sd-bus.c b/src/libsystemd/sd-bus/sd-bus.c index 2c458f311..6f5ba5bd5 100644 --- a/src/libsystemd/sd-bus/sd-bus.c +++ b/src/libsystemd/sd-bus/sd-bus.c @@ -35,6 +35,8 @@ #include "set.h" #include "missing.h" #include "def.h" +#include "cgroup-util.h" +#include "bus-label.h" #include "sd-bus.h" #include "bus-internal.h" @@ -49,6 +51,7 @@ #include "bus-util.h" #include "bus-container.h" #include "bus-protocol.h" +#include "bus-track.h" static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec); static int attach_io_events(sd_bus *b); @@ -60,10 +63,10 @@ static void bus_close_fds(sd_bus *b) { detach_io_events(b); if (b->input_fd >= 0) - close_nointr_nofail(b->input_fd); + safe_close(b->input_fd); if (b->output_fd >= 0 && b->output_fd != b->input_fd) - close_nointr_nofail(b->output_fd); + safe_close(b->output_fd); b->input_fd = b->output_fd = -1; } @@ -106,21 +109,21 @@ static void bus_node_destroy(sd_bus *b, struct node *n) { } static void bus_reset_queues(sd_bus *b) { - unsigned i; - assert(b); - for (i = 0; i < b->rqueue_size; i++) - sd_bus_message_unref(b->rqueue[i]); + while (b->rqueue_size > 0) + sd_bus_message_unref(b->rqueue[--b->rqueue_size]); + free(b->rqueue); + b->rqueue = NULL; + b->rqueue_allocated = 0; - for (i = 0; i < b->wqueue_size; i++) - sd_bus_message_unref(b->wqueue[i]); - free(b->wqueue); + while (b->wqueue_size > 0) + sd_bus_message_unref(b->wqueue[--b->wqueue_size]); - b->rqueue = b->wqueue = NULL; - b->rqueue_allocated = b->wqueue_allocated = 0; - b->rqueue_size = b->wqueue_size = 0; + free(b->wqueue); + b->wqueue = NULL; + b->wqueue_allocated = 0; } static void bus_free(sd_bus *b) { @@ -129,8 +132,13 @@ static void bus_free(sd_bus *b) { assert(b); + assert(!b->track_queue); + sd_bus_detach_event(b); + if (b->default_bus_ptr) + *b->default_bus_ptr = NULL; + bus_close_fds(b); if (b->kdbus_buffer) @@ -144,6 +152,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->exec_path); strv_free(b->exec_argv); @@ -275,6 +284,15 @@ _public_ int sd_bus_set_bus_client(sd_bus *bus, int b) { return 0; } +_public_ int sd_bus_set_monitor(sd_bus *bus, int b) { + assert_return(bus, -EINVAL); + assert_return(bus->state == BUS_UNSET, -EPERM); + assert_return(!bus_pid_changed(bus), -ECHILD); + + SET_FLAG(bus->hello_flags, KDBUS_HELLO_MONITOR, b); + return 0; +} + _public_ int sd_bus_negotiate_fds(sd_bus *bus, int b) { assert_return(bus, -EINVAL); assert_return(bus->state == BUS_UNSET, -EPERM); @@ -284,7 +302,7 @@ _public_ int sd_bus_negotiate_fds(sd_bus *bus, int b) { return 0; } -_public_ int sd_bus_negotiate_attach_timestamp(sd_bus *bus, int b) { +_public_ int sd_bus_negotiate_timestamp(sd_bus *bus, int b) { assert_return(bus, -EINVAL); assert_return(bus->state == BUS_UNSET, -EPERM); assert_return(!bus_pid_changed(bus), -ECHILD); @@ -293,7 +311,7 @@ _public_ int sd_bus_negotiate_attach_timestamp(sd_bus *bus, int b) { return 0; } -_public_ int sd_bus_negotiate_attach_creds(sd_bus *bus, uint64_t mask) { +_public_ int sd_bus_negotiate_creds(sd_bus *bus, uint64_t mask) { assert_return(bus, -EINVAL); assert_return(mask <= _SD_BUS_CREDS_ALL, -EINVAL); assert_return(bus->state == BUS_UNSET, -EPERM); @@ -334,6 +352,24 @@ _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; + + 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; +} + static int hello_callback(sd_bus *bus, sd_bus_message *reply, void *userdata, sd_bus_error *error) { const char *s; int r; @@ -376,11 +412,11 @@ static int bus_send_hello(sd_bus *bus) { r = sd_bus_message_new_method_call( bus, + &m, "org.freedesktop.DBus", "/org/freedesktop/DBus", "org.freedesktop.DBus", - "Hello", - &m); + "Hello"); if (r < 0) return r; @@ -771,7 +807,7 @@ static int parse_container_unix_address(sd_bus *b, const char **p, char **guid) 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; + b->sockaddr_size = offsetof(struct sockaddr_un, sun_path) + strlen("/var/run/dbus/system_bus_socket"); return 0; } @@ -1033,29 +1069,45 @@ _public_ int sd_bus_start(sd_bus *bus) { return bus_send_hello(bus); } -_public_ int sd_bus_open_system(sd_bus **ret) { +_public_ int sd_bus_open(sd_bus **ret) { const char *e; sd_bus *b; int r; assert_return(ret, -EINVAL); + /* Let's connect to the starter bus if it is set, and + * otherwise to the bus that is appropropriate for the scope + * we are running in */ + + e = secure_getenv("DBUS_STARTER_BUS_TYPE"); + if (e) { + if (streq(e, "system")) + return sd_bus_open_system(ret); + else if (STR_IN_SET(e, "session", "user")) + return sd_bus_open_user(ret); + } + + e = secure_getenv("DBUS_STARTER_ADDRESS"); + if (!e) { + if (cg_pid_get_owner_uid(0, NULL) >= 0) + return sd_bus_open_user(ret); + else + return sd_bus_open_system(ret); + } + r = sd_bus_new(&b); if (r < 0) return r; - e = secure_getenv("DBUS_SYSTEM_BUS_ADDRESS"); - if (e) - r = sd_bus_set_address(b, e); - else - r = sd_bus_set_address(b, DEFAULT_SYSTEM_BUS_PATH); + r = sd_bus_set_address(b, e); if (r < 0) goto fail; b->bus_client = true; - /* Let's do per-method access control on the system bus. We - * need the caller's UID and capability set for that. */ + /* We don't know whether the bus is trusted or not, so better + * be safe, and authenticate everything */ b->trusted = false; b->attach_flags |= KDBUS_ATTACH_CAPS | KDBUS_ATTACH_CREDS; @@ -1071,8 +1123,18 @@ fail: return r; } -_public_ int sd_bus_open_user(sd_bus **ret) { +int bus_set_address_system(sd_bus *b) { const char *e; + assert(b); + + e = secure_getenv("DBUS_SYSTEM_BUS_ADDRESS"); + if (e) + return sd_bus_set_address(b, e); + + return sd_bus_set_address(b, DEFAULT_SYSTEM_BUS_PATH); +} + +_public_ int sd_bus_open_system(sd_bus **ret) { sd_bus *b; int r; @@ -1082,42 +1144,82 @@ _public_ int sd_bus_open_user(sd_bus **ret) { if (r < 0) return r; + r = bus_set_address_system(b); + if (r < 0) + goto fail; + + b->bus_client = true; + b->is_system = true; + + /* Let's do per-method access control on the system bus. We + * need the caller's UID and capability set for that. */ + b->trusted = false; + b->attach_flags |= KDBUS_ATTACH_CAPS | KDBUS_ATTACH_CREDS; + + r = sd_bus_start(b); + if (r < 0) + goto fail; + + *ret = b; + return 0; + +fail: + bus_free(b); + return r; +} + +int bus_set_address_user(sd_bus *b) { + const char *e; + + assert(b); + e = secure_getenv("DBUS_SESSION_BUS_ADDRESS"); + if (e) + return sd_bus_set_address(b, e); + + e = secure_getenv("XDG_RUNTIME_DIR"); if (e) { - r = sd_bus_set_address(b, e); - if (r < 0) - goto fail; - } else { - e = secure_getenv("XDG_RUNTIME_DIR"); - if (e) { - _cleanup_free_ char *ee = NULL; + _cleanup_free_ char *ee = NULL; - ee = bus_address_escape(e); - if (!ee) { - r = -ENOMEM; - goto fail; - } + ee = bus_address_escape(e); + if (!ee) + return -ENOMEM; #ifdef ENABLE_KDBUS - asprintf(&b->address, KERNEL_USER_BUS_FMT ";" UNIX_USER_BUS_FMT, (unsigned long) getuid(), ee); + asprintf(&b->address, KERNEL_USER_BUS_FMT ";" UNIX_USER_BUS_FMT, (unsigned long) getuid(), ee); #else - asprintf(&b->address, UNIX_USER_BUS_FMT, ee); + asprintf(&b->address, UNIX_USER_BUS_FMT, ee); #endif - } else { + } else { #ifdef ENABLE_KDBUS - asprintf(&b->address, KERNEL_USER_BUS_FMT, (unsigned long) getuid()); + asprintf(&b->address, KERNEL_USER_BUS_FMT, (unsigned long) getuid()); #else - return -ECONNREFUSED; + return -ECONNREFUSED; #endif - } - - if (!b->address) { - r = -ENOMEM; - goto fail; - } } + if (!b->address) + return -ENOMEM; + + return 0; +} + +_public_ int sd_bus_open_user(sd_bus **ret) { + sd_bus *b; + int r; + + assert_return(ret, -EINVAL); + + r = sd_bus_new(&b); + if (r < 0) + return r; + + r = bus_set_address_user(b); + if (r < 0) + return r; + b->bus_client = true; + b->is_user = true; /* We don't do any per-method access control on the user * bus. */ @@ -1135,81 +1237,103 @@ fail: return r; } -_public_ int sd_bus_open_system_remote(const char *host, sd_bus **ret) { +int bus_set_address_system_remote(sd_bus *b, const char *host) { _cleanup_free_ char *e = NULL; - char *p = NULL; - sd_bus *bus; - int r; - assert_return(host, -EINVAL); - assert_return(ret, -EINVAL); + assert(b); + assert(host); 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) + b->address = strjoin("unixexec:path=ssh,argv1=-xT,argv2=", e, ",argv3=systemd-stdio-bridge", NULL); + if (!b->address) return -ENOMEM; + return 0; + } + +_public_ int sd_bus_open_system_remote(sd_bus **ret, const char *host) { + sd_bus *bus; + int r; + + assert_return(host, -EINVAL); + assert_return(ret, -EINVAL); + r = sd_bus_new(&bus); - if (r < 0) { - free(p); + if (r < 0) return r; - } - bus->address = p; + r = bus_set_address_system_remote(bus, host); + if (r < 0) + goto fail; + bus->bus_client = true; + bus->trusted = false; r = sd_bus_start(bus); - if (r < 0) { - bus_free(bus); - return r; - } + if (r < 0) + goto fail; *ret = bus; return 0; + +fail: + bus_free(bus); + return r; } -_public_ int sd_bus_open_system_container(const char *machine, sd_bus **ret) { +int bus_set_address_system_container(sd_bus *b, const char *machine) { _cleanup_free_ char *e = NULL; - sd_bus *bus; - char *p; - int r; - assert_return(machine, -EINVAL); - assert_return(ret, -EINVAL); - assert_return(filename_is_safe(machine), -EINVAL); + assert(b); + assert(machine); e = bus_address_escape(machine); if (!e) return -ENOMEM; #ifdef ENABLE_KDBUS - p = strjoin("x-container-kernel:machine=", e, ";x-container-unix:machine=", e, NULL); + b->address = strjoin("x-container-kernel:machine=", e, ";x-container-unix:machine=", e, NULL); #else - p = strjoin("x-container-unix:machine=", e, NULL); + b->address = strjoin("x-container-unix:machine=", e, NULL); #endif - if (!p) + if (!b->address) return -ENOMEM; + return 0; +} + +_public_ int sd_bus_open_system_container(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); + r = sd_bus_new(&bus); - if (r < 0) { - free(p); + if (r < 0) return r; - } - bus->address = p; + r = bus_set_address_system_container(bus, machine); + if (r < 0) + goto fail; + bus->bus_client = true; + bus->trusted = false; r = sd_bus_start(bus); - if (r < 0) { - bus_free(bus); - return r; - } + if (r < 0) + goto fail; *ret = bus; return 0; + +fail: + bus_free(bus); + return r; } _public_ void sd_bus_close(sd_bus *bus) { @@ -1264,21 +1388,37 @@ _public_ sd_bus *sd_bus_unref(sd_bus *bus) { if (!bus) return NULL; - i = REFCNT_DEC(bus->n_ref); - if (i != bus->rqueue_size + bus->wqueue_size) - 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; + } - for (i = 0; i < bus->rqueue_size; i++) - if (bus->rqueue[i]->n_ref > 1) - return NULL; + if (q) { + for (i = 0; i < bus->wqueue_size; i++) + if (bus->wqueue[i]->n_ref > 1) { + q = false; + break; + } + } - for (i = 0; i < bus->wqueue_size; i++) - if (bus->wqueue[i]->n_ref > 1) - return NULL; + /* 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 */ - /* we are the only holders on the messages */ - bus_free(bus); + if (q) + bus_reset_queues(bus); + } + i = REFCNT_DEC(bus->n_ref); + if (i > 0) + return NULL; + + bus_free(bus); return NULL; } @@ -1297,6 +1437,9 @@ _public_ int sd_bus_can_send(sd_bus *bus, char type) { assert_return(bus->state != BUS_UNSET, -ENOTCONN); assert_return(!bus_pid_changed(bus), -ECHILD); + if (bus->hello_flags & KDBUS_HELLO_MONITOR) + return 0; + if (type == SD_BUS_TYPE_UNIX_FD) { if (!(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)) return 0; @@ -1347,7 +1490,7 @@ static int bus_seal_message(sd_bus *b, sd_bus_message *m, usec_t timeout) { static int bus_remarshal_message(sd_bus *b, sd_bus_message **m) { assert(b); - /* Do packet version and endianess already match? */ + /* Do packet version and endianness already match? */ if ((b->message_version == 0 || b->message_version == (*m)->header->version) && (b->message_endian == 0 || b->message_endian == (*m)->header->endian)) return 0; @@ -1364,7 +1507,7 @@ int bus_seal_synthetic_message(sd_bus *b, sd_bus_message *m) { * hence let's fill something in for synthetic messages. Since * synthetic messages might have a fake sender and we don't * want to interfere with the real sender's serial numbers we - * pick a fixed, artifical one. We use (uint32_t) -1 rather + * 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. */ @@ -1386,15 +1529,15 @@ static int bus_write_message(sd_bus *bus, sd_bus_message *m, bool hint_sync_call return r; if (bus->is_kernel || *idx >= BUS_MESSAGE_SIZE(m)) - log_debug("Sent message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%lu reply_cookie=%lu error=%s", + log_debug("Sent message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%" PRIu64 " reply_cookie=%" PRIu64 " error=%s", bus_message_type_to_string(m->header->type), strna(sd_bus_message_get_sender(m)), strna(sd_bus_message_get_destination(m)), strna(sd_bus_message_get_path(m)), strna(sd_bus_message_get_interface(m)), strna(sd_bus_message_get_member(m)), - (unsigned long) BUS_MESSAGE_COOKIE(m), - (unsigned long) m->reply_cookie, + BUS_MESSAGE_COOKIE(m), + m->reply_cookie, strna(m->error.message)); return r; @@ -1437,11 +1580,11 @@ static int dispatch_wqueue(sd_bus *bus) { return ret; } -static int bus_read_message(sd_bus *bus) { +static int bus_read_message(sd_bus *bus, bool hint_priority, int64_t priority) { assert(bus); if (bus->is_kernel) - return bus_kernel_read_message(bus); + return bus_kernel_read_message(bus, hint_priority, priority); else return bus_socket_read_message(bus); } @@ -1458,13 +1601,17 @@ int bus_rqueue_make_room(sd_bus *bus) { return 0; } -static int dispatch_rqueue(sd_bus *bus, sd_bus_message **m) { +static int dispatch_rqueue(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **m) { int r, ret = 0; assert(bus); assert(m); assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO); + /* Note that the priority logic is only available on kdbus, + * where the rqueue is unused. We check the rqueue here + * anyway, because it's simple... */ + for (;;) { if (bus->rqueue_size > 0) { /* Dispatch a queued message */ @@ -1476,7 +1623,7 @@ static int dispatch_rqueue(sd_bus *bus, sd_bus_message **m) { } /* Try to read a new message */ - r = bus_read_message(bus); + r = bus_read_message(bus, hint_priority, priority); if (r < 0) return r; if (r == 0) @@ -1494,6 +1641,7 @@ static int bus_send_internal(sd_bus *bus, sd_bus_message *_m, uint64_t *cookie, assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN); assert_return(m, -EINVAL); assert_return(!bus_pid_changed(bus), -ECHILD); + assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS); if (m->n_fds > 0) { r = sd_bus_can_send(bus, SD_BUS_TYPE_UNIX_FD); @@ -1631,6 +1779,7 @@ _public_ int sd_bus_call_async( assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL); assert_return(callback, -EINVAL); assert_return(!bus_pid_changed(bus), -ECHILD); + assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS); r = hashmap_ensure_allocated(&bus->reply_callbacks, uint64_hash_func, uint64_compare_func); if (r < 0) @@ -1744,6 +1893,7 @@ _public_ int sd_bus_call( assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL); assert_return(!bus_error_is_dirty(error), -EINVAL); assert_return(!bus_pid_changed(bus), -ECHILD); + assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS); r = bus_ensure_running(bus); if (r < 0) @@ -1781,12 +1931,17 @@ _public_ int sd_bus_call( if (incoming->header->type == SD_BUS_MESSAGE_METHOD_RETURN) { - if (reply) - *reply = incoming; - else - sd_bus_message_unref(incoming); + if (incoming->n_fds <= 0 || (bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)) { + if (reply) + *reply = incoming; + else + sd_bus_message_unref(incoming); + + return 1; + } + + r = sd_bus_error_setf(error, SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Reply message contained file descriptors which I couldn't accept. Sorry."); - return 1; } else if (incoming->header->type == SD_BUS_MESSAGE_METHOD_ERROR) r = sd_bus_error_copy(error, &incoming->error); else @@ -1816,7 +1971,7 @@ _public_ int sd_bus_call( i++; } - r = bus_read_message(bus); + r = bus_read_message(bus, false, 0); if (r < 0) { if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) { bus_enter_closing(bus); @@ -1900,6 +2055,11 @@ _public_ int sd_bus_get_timeout(sd_bus *bus, uint64_t *timeout_usec) { assert_return(BUS_IS_OPEN(bus->state) || bus->state == BUS_CLOSING, -ENOTCONN); assert_return(!bus_pid_changed(bus), -ECHILD); + if (bus->track_queue) { + *timeout_usec = 0; + return 1; + } + if (bus->state == BUS_CLOSING) { *timeout_usec = 0; return 1; @@ -1999,8 +2159,9 @@ 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; - struct reply_callback *c; + _cleanup_free_ struct reply_callback *c = NULL; int r; assert(bus); @@ -2010,6 +2171,12 @@ static int process_reply(sd_bus *bus, sd_bus_message *m) { m->header->type != SD_BUS_MESSAGE_METHOD_ERROR) return 0; + if (bus->is_kernel && (bus->hello_flags & KDBUS_HELLO_MONITOR)) + return 0; + + if (m->destination && bus->unique_name && !streq_ptr(m->destination, bus->unique_name)) + return 0; + c = hashmap_remove(bus->reply_callbacks, &m->reply_cookie); if (!c) return 0; @@ -2017,13 +2184,32 @@ static int process_reply(sd_bus *bus, sd_bus_message *m) { if (c->timeout != 0) prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx); - r = sd_bus_message_rewind(m, true); - if (r < 0) - return r; + if (m->n_fds > 0 && !(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD)) { + + /* If the reply contained a file descriptor which we + * didn't want we pass an error instead. */ + + r = bus_message_new_synthetic_error( + bus, + m->reply_cookie, + &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Reply message contained file descriptor"), + &synthetic_reply); + if (r < 0) + return r; + + r = bus_seal_synthetic_message(bus, synthetic_reply); + if (r < 0) + return r; + + m = synthetic_reply; + } else { + r = sd_bus_message_rewind(m, true); + if (r < 0) + return r; + } r = c->callback(bus, m, c->userdata, &error_buffer); r = bus_maybe_reply_error(m, r, &error_buffer); - free(c); return r; } @@ -2091,6 +2277,9 @@ static int process_builtin(sd_bus *bus, sd_bus_message *m) { assert(bus); assert(m); + if (bus->hello_flags & KDBUS_HELLO_MONITOR) + return 0; + if (bus->manual_peer_interface) return 0; @@ -2135,6 +2324,32 @@ static int process_builtin(sd_bus *bus, sd_bus_message *m) { return 1; } +static int process_fd_check(sd_bus *bus, sd_bus_message *m) { + assert(bus); + assert(m); + + /* If we got a message with a file descriptor which we didn't + * want to accept, then let's drop it. How can this even + * happen? For example, when the kernel queues a message into + * an activatable names's queue which allows fds, and then is + * delivered to us later even though we ourselves did not + * negotiate it. */ + + if (bus->hello_flags & KDBUS_HELLO_MONITOR) + return 0; + + if (m->n_fds <= 0) + return 0; + + if (bus->hello_flags & KDBUS_HELLO_ACCEPT_FD) + return 0; + + if (m->header->type != SD_BUS_MESSAGE_METHOD_CALL) + return 1; /* just eat it up */ + + return sd_bus_reply_method_errorf(m, SD_BUS_ERROR_INCONSISTENT_MESSAGE, "Message contains file descriptors, which I cannot accept. Sorry."); +} + static int process_message(sd_bus *bus, sd_bus_message *m) { int r; @@ -2144,15 +2359,15 @@ static int process_message(sd_bus *bus, sd_bus_message *m) { bus->current = m; bus->iteration_counter++; - log_debug("Got message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%lu reply_cookie=%lu error=%s", + log_debug("Got message type=%s sender=%s destination=%s object=%s interface=%s member=%s cookie=%" PRIu64 " reply_cookie=%" PRIu64 " error=%s", bus_message_type_to_string(m->header->type), strna(sd_bus_message_get_sender(m)), strna(sd_bus_message_get_destination(m)), strna(sd_bus_message_get_path(m)), strna(sd_bus_message_get_interface(m)), strna(sd_bus_message_get_member(m)), - (unsigned long) BUS_MESSAGE_COOKIE(m), - (unsigned long) m->reply_cookie, + BUS_MESSAGE_COOKIE(m), + m->reply_cookie, strna(m->error.message)); r = process_hello(bus, m); @@ -2163,6 +2378,10 @@ static int process_message(sd_bus *bus, sd_bus_message *m) { if (r != 0) goto finish; + r = process_fd_check(bus, m); + if (r != 0) + goto finish; + r = process_filter(bus, m); if (r != 0) goto finish; @@ -2182,7 +2401,17 @@ finish: return r; } -static int process_running(sd_bus *bus, sd_bus_message **ret) { +static int dispatch_track(sd_bus *bus) { + assert(bus); + + if (!bus->track_queue) + return 0; + + bus_track_dispatch(bus->track_queue); + return 1; +} + +static int process_running(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) { _cleanup_bus_message_unref_ sd_bus_message *m = NULL; int r; @@ -2197,7 +2426,11 @@ static int process_running(sd_bus *bus, sd_bus_message **ret) { if (r != 0) goto null_message; - r = dispatch_rqueue(bus, &m); + r = dispatch_track(bus); + if (r != 0) + goto null_message; + + r = dispatch_rqueue(bus, hint_priority, priority, &m); if (r < 0) return r; if (!m) @@ -2285,10 +2518,10 @@ static int process_closing(sd_bus *bus, sd_bus_message **ret) { /* Then, synthesize a Disconnected message */ r = sd_bus_message_new_signal( bus, + &m, "/org/freedesktop/DBus/Local", "org.freedesktop.DBus.Local", - "Disconnected", - &m); + "Disconnected"); if (r < 0) return r; @@ -2323,7 +2556,7 @@ finish: return r; } -_public_ int sd_bus_process(sd_bus *bus, sd_bus_message **ret) { +static int bus_process_internal(sd_bus *bus, bool hint_priority, int64_t priority, sd_bus_message **ret) { BUS_DONT_DESTROY(bus); int r; @@ -2372,7 +2605,7 @@ _public_ int sd_bus_process(sd_bus *bus, sd_bus_message **ret) { case BUS_RUNNING: case BUS_HELLO: - r = process_running(bus, ret); + r = process_running(bus, hint_priority, priority, ret); if (r == -ENOTCONN || r == -ECONNRESET || r == -EPIPE || r == -ESHUTDOWN) { bus_enter_closing(bus); r = 1; @@ -2390,6 +2623,14 @@ _public_ int sd_bus_process(sd_bus *bus, sd_bus_message **ret) { assert_not_reached("Unknown state"); } +_public_ int sd_bus_process(sd_bus *bus, sd_bus_message **ret) { + return bus_process_internal(bus, false, 0, ret); +} + +_public_ int sd_bus_process_priority(sd_bus *bus, int64_t priority, sd_bus_message **ret) { + return bus_process_internal(bus, true, priority, ret); +} + static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec) { struct pollfd p[2] = {}; int r, e, n; @@ -2714,7 +2955,7 @@ static int attach_io_events(sd_bus *bus) { return 0; if (!bus->input_io_event_source) { - r = sd_event_add_io(bus->event, bus->input_fd, 0, io_callback, bus, &bus->input_io_event_source); + r = sd_event_add_io(bus->event, &bus->input_io_event_source, bus->input_fd, 0, io_callback, bus); if (r < 0) return r; @@ -2733,7 +2974,7 @@ static int attach_io_events(sd_bus *bus) { assert(bus->output_fd >= 0); if (!bus->output_io_event_source) { - r = sd_event_add_io(bus->event, bus->output_fd, 0, io_callback, bus, &bus->output_io_event_source); + r = sd_event_add_io(bus->event, &bus->output_io_event_source, bus->output_fd, 0, io_callback, bus); if (r < 0) return r; @@ -2782,7 +3023,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, 0, 0, time_callback, bus, &bus->time_event_source); + r = sd_event_add_monotonic(bus->event, &bus->time_event_source, 0, 0, time_callback, bus); if (r < 0) goto fail; @@ -2790,7 +3031,7 @@ _public_ int sd_bus_attach_event(sd_bus *bus, sd_event *event, int priority) { if (r < 0) goto fail; - r = sd_event_add_exit(bus->event, quit_callback, bus, &bus->quit_event_source); + r = sd_event_add_exit(bus->event, &bus->quit_event_source, quit_callback, bus); if (r < 0) goto fail; @@ -2880,6 +3121,43 @@ _public_ int sd_bus_default_user(sd_bus **ret) { return bus_default(sd_bus_open_user, &default_user_bus, ret); } +_public_ int sd_bus_default(sd_bus **ret) { + + const char *e; + + /* Let's try our best to reuse another cached connection. If + * the starter bus type is set, connect via our normal + * connection logic, ignoring $DBUS_STARTER_ADDRESS, so that + * we can share the connection with the user/system default + * bus. */ + + e = secure_getenv("DBUS_STARTER_BUS_TYPE"); + if (e) { + if (streq(e, "system")) + return sd_bus_default_system(ret); + else if (STR_IN_SET(e, "user", "session")) + return sd_bus_default_user(ret); + } + + /* No type is specified, so we have not other option than to + * use the starter address if it is set. */ + + e = secure_getenv("DBUS_STARTER_ADDRESS"); + if (e) { + static thread_local sd_bus *default_starter_bus = NULL; + + return bus_default(sd_bus_open, &default_starter_bus, ret); + } + + /* Finally, if nothing is set use the cached connection for + * the right scope */ + + if (cg_pid_get_owner_uid(0, NULL) >= 0) + return sd_bus_default_user(ret); + else + return sd_bus_default_system(ret); +} + _public_ int sd_bus_get_tid(sd_bus *b, pid_t *tid) { assert_return(b, -EINVAL); assert_return(tid, -EINVAL); @@ -2896,76 +3174,46 @@ _public_ int sd_bus_get_tid(sd_bus *b, pid_t *tid) { return -ENXIO; } -_public_ char *sd_bus_label_escape(const char *s) { - char *r, *t; - const char *f; - - assert_return(s, NULL); - - /* Escapes all chars that D-Bus' object path cannot deal - * with. Can be reversed with bus_path_unescape(). We special - * case the empty string. */ - - if (*s == 0) - return strdup("_"); - - r = new(char, strlen(s)*3 + 1); - if (!r) - return NULL; - - for (f = s, t = r; *f; f++) { +_public_ int sd_bus_path_encode(const char *prefix, const char *external_id, char **ret_path) { + _cleanup_free_ char *e = NULL; + char *ret; - /* Escape everything that is not a-zA-Z0-9. We also - * escape 0-9 if it's the first character */ + assert_return(object_path_is_valid(prefix), -EINVAL); + assert_return(external_id, -EINVAL); + assert_return(ret_path, -EINVAL); - if (!(*f >= 'A' && *f <= 'Z') && - !(*f >= 'a' && *f <= 'z') && - !(f > s && *f >= '0' && *f <= '9')) { - *(t++) = '_'; - *(t++) = hexchar(*f >> 4); - *(t++) = hexchar(*f); - } else - *(t++) = *f; - } + e = bus_label_escape(external_id); + if (!e) + return -ENOMEM; - *t = 0; + ret = strjoin(prefix, "/", e, NULL); + if (!ret) + return -ENOMEM; - return r; + *ret_path = ret; + return 0; } -_public_ char *sd_bus_label_unescape(const char *f) { - char *r, *t; - - assert_return(f, NULL); - - /* Special case for the empty string */ - if (streq(f, "_")) - return strdup(""); - - r = new(char, strlen(f) + 1); - if (!r) - return NULL; - - for (t = r; *f; f++) { +_public_ int sd_bus_path_decode(const char *path, const char *prefix, char **external_id) { + const char *e; + char *ret; - if (*f == '_') { - int a, b; + assert_return(object_path_is_valid(path), -EINVAL); + assert_return(object_path_is_valid(prefix), -EINVAL); + assert_return(external_id, -EINVAL); - if ((a = unhexchar(f[1])) < 0 || - (b = unhexchar(f[2])) < 0) { - /* Invalid escape code, let's take it literal then */ - *(t++) = '_'; - } else { - *(t++) = (char) ((a << 4) | b); - f += 2; - } - } else - *(t++) = *f; + e = object_path_startswith(path, prefix); + if (!e) { + *external_id = NULL; + return 0; } - *t = 0; + ret = bus_label_unescape(e); + if (!ret) + return -ENOMEM; - return r; + *external_id = ret; + return 1; } _public_ int sd_bus_get_peer_creds(sd_bus *bus, uint64_t mask, sd_bus_creds **ret) { @@ -3034,3 +3282,12 @@ _public_ int sd_bus_try_close(sd_bus *bus) { sd_bus_close(bus); return 0; } + +_public_ int sd_bus_get_name(sd_bus *bus, const char **name) { + assert_return(bus, -EINVAL); + assert_return(name, -EINVAL); + assert_return(!bus_pid_changed(bus), -ECHILD); + + *name = bus->connection_name; + return 0; +}