sd-bus: when we synthesize messages, initialize timestamps ourselves

[elogind.git] / src / libsystemd / sd-bus / sd-bus.c

diff --git a/src/libsystemd/sd-bus/sd-bus.c b/src/libsystemd/sd-bus/sd-bus.c
index e494cd2ba907636b6b267696b91dced494145e9c..15180d042354621bff69831dcd8c41879d301e2b 100644 (file)
--- a/src/libsystemd/sd-bus/sd-bus.c
+++ b/src/libsystemd/sd-bus/sd-bus.c
@@ -36,6 +36,7 @@
 #include "missing.h"
 #include "def.h"
 #include "cgroup-util.h"
 #include "missing.h"
 #include "def.h"
 #include "cgroup-util.h"

+#include "bus-label.h"

 
 #include "sd-bus.h"
 #include "bus-internal.h"
 
 #include "sd-bus.h"
 #include "bus-internal.h"


@@ -50,6 +51,8 @@
 #include "bus-util.h"
 #include "bus-container.h"
 #include "bus-protocol.h"
 #include "bus-util.h"
 #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);
 
 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec);
 static int attach_io_events(sd_bus *b);


@@ -61,51 +64,14 @@ static void bus_close_fds(sd_bus *b) {
         detach_io_events(b);
 
         if (b->input_fd >= 0)
         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)
 
         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;
 }
 
 
         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);
 
 static void bus_reset_queues(sd_bus *b) {
         assert(b);
 


@@ -125,13 +91,28 @@ static void bus_reset_queues(sd_bus *b) {
 }
 
 static void bus_free(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);

+        assert(!b->track_queue);
+
+        b->state = BUS_CLOSED;

 
         sd_bus_detach_event(b);
 
 
         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;
 
         if (b->default_bus_ptr)
                 *b->default_bus_ptr = NULL;
 


@@ -148,7 +129,7 @@ static void bus_free(sd_bus *b) {
         free(b->machine);
         free(b->fake_label);
         free(b->cgroup_root);
         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);
 
         free(b->exec_path);
         strv_free(b->exec_argv);


@@ -158,22 +139,16 @@ static void bus_free(sd_bus *b) {
 
         bus_reset_queues(b);
 
 
         bus_reset_queues(b);
 

-        hashmap_free_free(b->reply_callbacks);
+        ordered_hashmap_free_free(b->reply_callbacks);

         prioq_free(b->reply_callbacks_prioq);
 
         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);
 
         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);
         hashmap_free(b->nodes);
 
         bus_kernel_flush_memfd(b);


@@ -280,6 +255,15 @@ _public_ int sd_bus_set_bus_client(sd_bus *bus, int b) {
         return 0;
 }
 
         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);
 _public_ int sd_bus_negotiate_fds(sd_bus *bus, int b) {
         assert_return(bus, -EINVAL);
         assert_return(bus->state == BUS_UNSET, -EPERM);


@@ -290,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) {
 }
 
 _public_ int sd_bus_negotiate_timestamp(sd_bus *bus, int b) {

+        uint64_t new_flags;

         assert_return(bus, -EINVAL);
         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);
 
         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;
 }
 
         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, -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);
 
         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 */
         /* 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->creds_mask);
+        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) {
 }
 
 _public_ int sd_bus_set_server(sd_bus *bus, int b, sd_id128_t server_id) {


@@ -339,22 +349,12 @@ _public_ int sd_bus_set_trusted(sd_bus *bus, int b) {
         return 0;
 }
 
         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(bus, -EINVAL);

-        assert_return(name, -EINVAL);

         assert_return(bus->state == BUS_UNSET, -EPERM);
         assert_return(!bus_pid_changed(bus), -ECHILD);
 
         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) {
 }
 
 static int hello_callback(sd_bus *bus, sd_bus_message *reply, void *userdata, sd_bus_error *error) {


@@ -366,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);
         assert(reply);
 
         r = sd_bus_message_get_errno(reply);

-        if (r < 0)
-                return r;

         if (r > 0)
                 return -r;
 
         if (r > 0)
                 return -r;
 


@@ -399,15 +397,15 @@ static int bus_send_hello(sd_bus *bus) {
 
         r = sd_bus_message_new_method_call(
                         bus,
 
         r = sd_bus_message_new_method_call(
                         bus,

+                        &m,

                         "org.freedesktop.DBus",
                         "/org/freedesktop/DBus",
                         "org.freedesktop.DBus",
                         "org.freedesktop.DBus",
                         "/org/freedesktop/DBus",
                         "org.freedesktop.DBus",

-                        "Hello",
-                        &m);
+                        "Hello");

         if (r < 0)
                 return r;
 
         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) {
 }
 
 int bus_start_running(sd_bus *bus) {


@@ -758,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) {
 }
 
 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);
         int r;
 
         assert(b);


@@ -779,28 +777,46 @@ static int parse_container_unix_address(sd_bus *b, const char **p, char **guid)
                 else if (r > 0)
                         continue;
 
                 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);
         }
 
                 skip_address_key(p);
         }
 

-        if (!machine)
+        if (!machine == !pid)

                 return -EINVAL;
 
                 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));
 
         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;
 }
 
 static int parse_container_kernel_address(sd_bus *b, const char **p, char **guid) {
 
         return 0;
 }
 
 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);
         int r;
 
         assert(b);


@@ -821,21 +837,39 @@ static int parse_container_kernel_address(sd_bus *b, const char **p, char **guid
                 else if (r > 0)
                         continue;
 
                 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);
         }
 
                 skip_address_key(p);
         }
 

-        if (!machine)
+        if (!machine == !pid)

                 return -EINVAL;
 
                 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);
 
         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;
 
         if (!b->kernel)
                 return -ENOMEM;
 


@@ -856,6 +890,7 @@ static void bus_reset_parsed_address(sd_bus *b) {
         b->kernel = NULL;
         free(b->machine);
         b->machine = NULL;
         b->kernel = NULL;
         free(b->machine);
         b->machine = NULL;

+        b->nspid = 0;

 }
 
 static int bus_parse_next_address(sd_bus *b) {
 }
 
 static int bus_parse_next_address(sd_bus *b) {


@@ -915,17 +950,17 @@ static int bus_parse_next_address(sd_bus *b) {
                                 return r;
 
                         break;
                                 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;
                         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;
                         r = parse_container_kernel_address(b, &a, &guid);
                         if (r < 0)
                                 return r;


@@ -960,9 +995,9 @@ static int bus_start_address(sd_bus *b) {
 
                 if (b->exec_path)
                         r = bus_socket_exec(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);
                         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);
                         r = bus_container_connect_socket(b);
                 else if (b->kernel)
                         r = bus_kernel_connect(b);


@@ -1050,8 +1085,10 @@ _public_ int sd_bus_start(sd_bus *bus) {
         else
                 return -EINVAL;
 
         else
                 return -EINVAL;
 

-        if (r < 0)
+        if (r < 0) {
+                sd_bus_close(bus);

                 return r;
                 return r;

+        }

 
         return bus_send_hello(bus);
 }
 
         return bus_send_hello(bus);
 }


@@ -1071,7 +1108,7 @@ _public_ int sd_bus_open(sd_bus **ret) {
         if (e) {
                 if (streq(e, "system"))
                         return sd_bus_open_system(ret);
         if (e) {
                 if (streq(e, "system"))
                         return sd_bus_open_system(ret);

-                else if (streq(e, "session") || streq(e, "user"))
+                else if (STR_IN_SET(e, "session", "user"))

                         return sd_bus_open_user(ret);
         }
 
                         return sd_bus_open_user(ret);
         }
 


@@ -1097,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;
          * 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)
 
         r = sd_bus_start(b);
         if (r < 0)


@@ -1110,8 +1148,18 @@ fail:
         return r;
 }
 
         return r;
 }
 

-_public_ int sd_bus_open_system(sd_bus **ret) {
+int bus_set_address_system(sd_bus *b) {

         const char *e;
         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_ADDRESS);
+}
+
+_public_ int sd_bus_open_system(sd_bus **ret) {

         sd_bus *b;
         int r;
 
         sd_bus *b;
         int r;
 


@@ -1121,11 +1169,7 @@ _public_ int sd_bus_open_system(sd_bus **ret) {
         if (r < 0)
                 return r;
 
         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 = bus_set_address_system(b);

         if (r < 0)
                 goto fail;
 
         if (r < 0)
                 goto fail;
 


@@ -1136,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;
          * 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)
 
         r = sd_bus_start(b);
         if (r < 0)


@@ -1149,52 +1194,56 @@ fail:
         return r;
 }
 
         return r;
 }
 

-_public_ int sd_bus_open_user(sd_bus **ret) {
+int bus_set_address_user(sd_bus *b) {

         const char *e;
         const char *e;

-        sd_bus *b;
-        int r;
-
-        assert_return(ret, -EINVAL);

 
 

-        r = sd_bus_new(&b);
-        if (r < 0)
-                return r;
+        assert(b);

 
         e = secure_getenv("DBUS_SESSION_BUS_ADDRESS");
 
         e = secure_getenv("DBUS_SESSION_BUS_ADDRESS");

+        if (e)
+                return sd_bus_set_address(b, e);
+
+        e = secure_getenv("XDG_RUNTIME_DIR");

         if (e) {
         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
 
 #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
 #else

-                        asprintf(&b->address, UNIX_USER_BUS_FMT, ee);
+                (void) asprintf(&b->address, UNIX_USER_BUS_ADDRESS_FMT, ee);

 #endif
 #endif

-                } else {
+        } else {

 #ifdef ENABLE_KDBUS
 #ifdef ENABLE_KDBUS

-                        asprintf(&b->address, KERNEL_USER_BUS_FMT, (unsigned long) getuid());
+                (void) asprintf(&b->address, KERNEL_USER_BUS_ADDRESS_FMT, getuid());

 #else
 #else

-                        return -ECONNREFUSED;
+                return -ECONNREFUSED;

 #endif
 #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;
 
         b->bus_client = true;
         b->is_user = true;
 


@@ -1214,81 +1263,128 @@ fail:
         return r;
 }
 
         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;
         _cleanup_free_ char *e = NULL;

-        char *p = NULL;
+        char *m = NULL, *c = NULL;
+
+        assert(b);
+        assert(host);
+
+        /* Let's see if we shall enter some container */
+        m = strchr(host, ':');
+        if (m) {
+                m++;
+
+                /* 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;
+
+        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);
 
         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);
         r = sd_bus_new(&bus);

-        if (r < 0) {
-                free(p);
+        if (r < 0)

                 return r;
                 return r;

-        }

 
 

-        bus->address = p;
+        r = bus_set_address_system_remote(bus, host);
+        if (r < 0)
+                goto fail;
+

         bus->bus_client = true;
         bus->bus_client = true;

+        bus->trusted = false;
+        bus->is_system = true;

 
         r = sd_bus_start(bus);
 
         r = sd_bus_start(bus);

-        if (r < 0) {
-                bus_free(bus);
-                return r;
-        }
+        if (r < 0)
+                goto fail;

 
         *ret = bus;
         return 0;
 
         *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_machine(sd_bus *b, const char *machine) {

         _cleanup_free_ char *e = NULL;
         _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
 
         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-machine-kernel:machine=", e, ";x-machine-unix:machine=", e, NULL);

 #else
 #else

-        p = strjoin("x-container-unix:machine=", e, NULL);
+        b->address = strjoin("x-machine-unix:machine=", e, NULL);

 #endif
 #endif

-        if (!p)
+        if (!b->address)

                 return -ENOMEM;
 
                 return -ENOMEM;
 

+        return 0;
+}
+
+_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(machine_name_is_valid(machine), -EINVAL);
+

         r = sd_bus_new(&bus);
         r = sd_bus_new(&bus);

-        if (r < 0) {
-                free(p);
+        if (r < 0)

                 return r;
                 return r;

-        }

 
 

-        bus->address = p;
+        r = bus_set_address_system_machine(bus, machine);
+        if (r < 0)
+                goto fail;
+

         bus->bus_client = true;
         bus->bus_client = true;

+        bus->trusted = false;
+        bus->is_system = true;

 
         r = sd_bus_start(bus);
 
         r = sd_bus_start(bus);

-        if (r < 0) {
-                bus_free(bus);
-                return r;
-        }
+        if (r < 0)
+                goto fail;

 
         *ret = bus;
         return 0;
 
         *ret = bus;
         return 0;

+
+fail:
+        bus_free(bus);
+        return r;

 }
 
 _public_ void sd_bus_close(sd_bus *bus) {
 }
 
 _public_ void sd_bus_close(sd_bus *bus) {


@@ -1343,32 +1439,6 @@ _public_ sd_bus *sd_bus_unref(sd_bus *bus) {
         if (!bus)
                 return NULL;
 
         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 */
-
-                if (q)
-                        bus_reset_queues(bus);
-        }
-

         i = REFCNT_DEC(bus->n_ref);
         if (i > 0)
                 return NULL;
         i = REFCNT_DEC(bus->n_ref);
         if (i > 0)
                 return NULL;


@@ -1392,6 +1462,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);
 
         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;
         if (type == SD_BUS_TYPE_UNIX_FD) {
                 if (!(bus->hello_flags & KDBUS_HELLO_ACCEPT_FD))
                         return 0;


@@ -1406,18 +1479,18 @@ _public_ int sd_bus_can_send(sd_bus *bus, char type) {
         return bus_type_is_valid(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);
         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;
 
         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;
 }
 
         return 0;
 }
 


@@ -1442,7 +1515,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);
 
 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;
         if ((b->message_version == 0 || b->message_version == (*m)->header->version) &&
             (b->message_endian == 0 || b->message_endian == (*m)->header->endian))
                 return 0;


@@ -1455,14 +1528,23 @@ int bus_seal_synthetic_message(sd_bus *b, sd_bus_message *m) {
         assert(b);
         assert(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
          * want to interfere with the real sender's serial numbers we
         /* 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
          * 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. */
          * than (uint64_t) -1 since dbus1 only had 32bit identifiers,
          * even though kdbus can do 64bit. */

-

         return bus_message_seal(m, 0xFFFFFFFFULL, 0);
 }
 
         return bus_message_seal(m, 0xFFFFFFFFULL, 0);
 }
 


@@ -1481,15 +1563,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))
                 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)),
                           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;
                           strna(m->error.message));
 
         return r;


@@ -1590,9 +1672,12 @@ static int bus_send_internal(sd_bus *bus, sd_bus_message *_m, uint64_t *cookie,
         int r;
 
         assert_return(bus, -EINVAL);
         int r;
 
         assert_return(bus, -EINVAL);

-        assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);

         assert_return(m, -EINVAL);
         assert_return(!bus_pid_changed(bus), -ECHILD);
         assert_return(m, -EINVAL);
         assert_return(!bus_pid_changed(bus), -ECHILD);

+        assert_return(!bus->is_kernel || !(bus->hello_flags & KDBUS_HELLO_MONITOR), -EROFS);
+
+        if (!BUS_IS_OPEN(bus->state))
+                return -ENOTCONN;

 
         if (m->n_fds > 0) {
                 r = sd_bus_can_send(bus, SD_BUS_TYPE_UNIX_FD);
 
         if (m->n_fds > 0) {
                 r = sd_bus_can_send(bus, SD_BUS_TYPE_UNIX_FD);


@@ -1669,10 +1754,12 @@ _public_ int sd_bus_send_to(sd_bus *bus, sd_bus_message *m, const char *destinat
         int r;
 
         assert_return(bus, -EINVAL);
         int r;
 
         assert_return(bus, -EINVAL);

-        assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);

         assert_return(m, -EINVAL);
         assert_return(!bus_pid_changed(bus), -ECHILD);
 
         assert_return(m, -EINVAL);
         assert_return(!bus_pid_changed(bus), -ECHILD);
 

+        if (!BUS_IS_OPEN(bus->state))
+                return -ENOTCONN;
+

         if (!streq_ptr(m->destination, destination)) {
 
                 if (!destination)
         if (!streq_ptr(m->destination, destination)) {
 
                 if (!destination)


@@ -1713,25 +1800,28 @@ static int timeout_compare(const void *a, const void *b) {
 
 _public_ int sd_bus_call_async(
                 sd_bus *bus,
 
 _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,
                 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);
 
         _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);
         int r;
 
         assert_return(bus, -EINVAL);

-        assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);

         assert_return(m, -EINVAL);
         assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
         assert_return(!(m->header->flags & BUS_MESSAGE_NO_REPLY_EXPECTED), -EINVAL);
         assert_return(callback, -EINVAL);
         assert_return(!bus_pid_changed(bus), -ECHILD);
         assert_return(m, -EINVAL);
         assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
         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);
+
+        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;
 
         if (r < 0)
                 return r;
 


@@ -1747,55 +1837,37 @@ _public_ int sd_bus_call_async(
         if (r < 0)
                 return r;
 
         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;
 
                 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) {
         if (r < 0) {

-                free(c);
+                s->reply_callback.cookie = 0;

                 return r;
         }
 
                 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) {
                 if (r < 0) {

-                        c->timeout = 0;
-                        sd_bus_call_async_cancel(bus, c->cookie);
+                        s->reply_callback.timeout = 0;

                         return r;
                 }
         }
 
                         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;

-        }
-
-        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 (c->timeout != 0)
-                prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
+        if (slot)
+                *slot = s;
+        s = NULL;

 
 

-        free(c);
-        return 1;
+        return r;

 }
 
 int bus_ensure_running(sd_bus *bus) {
 }
 
 int bus_ensure_running(sd_bus *bus) {


@@ -1837,14 +1909,17 @@ _public_ int sd_bus_call(
         int r;
 
         assert_return(bus, -EINVAL);
         int r;
 
         assert_return(bus, -EINVAL);

-        assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);

         assert_return(m, -EINVAL);
         assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
         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(m, -EINVAL);
         assert_return(m->header->type == SD_BUS_MESSAGE_METHOD_CALL, -EINVAL);
         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 (!BUS_IS_OPEN(bus->state))
+                return -ENOTCONN;
+
+        r = bus_ensure_running(bus);

         if (r < 0)
                 return r;
 
         if (r < 0)
                 return r;
 


@@ -1880,12 +1955,17 @@ _public_ int sd_bus_call(
 
                                 if (incoming->header->type == SD_BUS_MESSAGE_METHOD_RETURN) {
 
 
                                 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
                                 } else if (incoming->header->type == SD_BUS_MESSAGE_METHOD_ERROR)
                                         r = sd_bus_error_copy(error, &incoming->error);
                                 else


@@ -1969,9 +2049,11 @@ _public_ int sd_bus_get_events(sd_bus *bus) {
         int flags = 0;
 
         assert_return(bus, -EINVAL);
         int flags = 0;
 
         assert_return(bus, -EINVAL);

-        assert_return(BUS_IS_OPEN(bus->state) || bus->state == BUS_CLOSING, -ENOTCONN);

         assert_return(!bus_pid_changed(bus), -ECHILD);
 
         assert_return(!bus_pid_changed(bus), -ECHILD);
 

+        if (!BUS_IS_OPEN(bus->state) && bus->state != BUS_CLOSING)
+                return -ENOTCONN;
+

         if (bus->state == BUS_OPENING)
                 flags |= POLLOUT;
         else if (bus->state == BUS_AUTHENTICATING) {
         if (bus->state == BUS_OPENING)
                 flags |= POLLOUT;
         else if (bus->state == BUS_AUTHENTICATING) {


@@ -1996,9 +2078,16 @@ _public_ int sd_bus_get_timeout(sd_bus *bus, uint64_t *timeout_usec) {
 
         assert_return(bus, -EINVAL);
         assert_return(timeout_usec, -EINVAL);
 
         assert_return(bus, -EINVAL);
         assert_return(timeout_usec, -EINVAL);

-        assert_return(BUS_IS_OPEN(bus->state) || bus->state == BUS_CLOSING, -ENOTCONN);

         assert_return(!bus_pid_changed(bus), -ECHILD);
 
         assert_return(!bus_pid_changed(bus), -ECHILD);
 

+        if (!BUS_IS_OPEN(bus->state) && bus->state != BUS_CLOSING)
+                return -ENOTCONN;
+
+        if (bus->track_queue) {
+                *timeout_usec = 0;
+                return 1;
+        }
+

         if (bus->state == BUS_CLOSING) {
                 *timeout_usec = 0;
                 return 1;
         if (bus->state == BUS_CLOSING) {
                 *timeout_usec = 0;
                 return 1;


@@ -2025,6 +2114,11 @@ _public_ int sd_bus_get_timeout(sd_bus *bus, uint64_t *timeout_usec) {
                 return 0;
         }
 
                 return 0;
         }
 

+        if (c->timeout == 0) {
+                *timeout_usec = (uint64_t) -1;
+                return 0;
+        }
+

         *timeout_usec = c->timeout;
         return 1;
 }
         *timeout_usec = c->timeout;
         return 1;
 }


@@ -2033,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;
         _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;
 
         usec_t n;
         int r;
 


@@ -2054,25 +2149,38 @@ static int process_timeout(sd_bus *bus) {
         if (r < 0)
                 return r;
 
         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);
         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 ++;
 
         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) {
 }
 
 static int process_hello(sd_bus *bus, sd_bus_message *m) {


@@ -2091,15 +2199,17 @@ static int process_hello(sd_bus *bus, sd_bus_message *m) {
             m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
                 return -EIO;
 
             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;
 }
 
 static int process_reply(sd_bus *bus, sd_bus_message *m) {
                 return -EIO;
 
         return 0;
 }
 
 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_bus_error_free_ sd_bus_error error_buffer = SD_BUS_ERROR_NULL;
         struct reply_callback *c;

+        sd_bus_slot *slot;

         int r;
 
         assert(bus);
         int r;
 
         assert(bus);


@@ -2109,22 +2219,70 @@ static int process_reply(sd_bus *bus, sd_bus_message *m) {
             m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
                 return 0;
 
             m->header->type != SD_BUS_MESSAGE_METHOD_ERROR)
                 return 0;
 

-        c = hashmap_remove(bus->reply_callbacks, &m->reply_cookie);
+        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 = ordered_hashmap_remove(bus->reply_callbacks, &m->reply_cookie);

         if (!c)
                 return 0;
 
         if (!c)
                 return 0;
 

-        if (c->timeout != 0)
+        c->cookie = 0;
+
+        slot = container_of(c, sd_bus_slot, reply_callback);
+
+        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;
+
+                /* 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;
+
+                m = synthetic_reply;
+        } else {
+                r = sd_bus_message_rewind(m, true);
+                if (r < 0)
+                        return r;
+        }
+
+        if (c->timeout != 0) {

                 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
                 prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);

+                c->timeout = 0;
+        }

 
 

-        r = sd_bus_message_rewind(m, true);
-        if (r < 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;

 
 

-        r = c->callback(bus, m, c->userdata, &error_buffer);
-        r = bus_maybe_reply_error(m, r, &error_buffer);
-        free(c);
+        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_filter(sd_bus *bus, sd_bus_message *m) {
 }
 
 static int process_filter(sd_bus *bus, sd_bus_message *m) {


@@ -2139,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) {
                 bus->filter_callbacks_modified = false;
 
                 LIST_FOREACH(callbacks, l, bus->filter_callbacks) {

+                        sd_bus_slot *slot;

 
                         if (bus->filter_callbacks_modified)
                                 break;
 
                         if (bus->filter_callbacks_modified)
                                 break;


@@ -2153,7 +2312,16 @@ static int process_filter(sd_bus *bus, sd_bus_message *m) {
                         if (r < 0)
                                 return r;
 
                         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;
                         r = bus_maybe_reply_error(m, r, &error_buffer);
                         if (r != 0)
                                 return r;


@@ -2190,6 +2358,9 @@ static int process_builtin(sd_bus *bus, sd_bus_message *m) {
         assert(bus);
         assert(m);
 
         assert(bus);
         assert(m);
 

+        if (bus->hello_flags & KDBUS_HELLO_MONITOR)
+                return 0;
+

         if (bus->manual_peer_interface)
                 return 0;
 
         if (bus->manual_peer_interface)
                 return 0;
 


@@ -2234,24 +2405,50 @@ static int process_builtin(sd_bus *bus, sd_bus_message *m) {
         return 1;
 }
 
         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;
 
         assert(bus);
         assert(m);
 
 static int process_message(sd_bus *bus, sd_bus_message *m) {
         int r;
 
         assert(bus);
         assert(m);
 

-        bus->current = m;
+        bus->current_message = m;

         bus->iteration_counter++;
 
         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)),
                   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);
                   strna(m->error.message));
 
         r = process_hello(bus, m);


@@ -2262,6 +2459,10 @@ static int process_message(sd_bus *bus, sd_bus_message *m) {
         if (r != 0)
                 goto finish;
 
         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;
         r = process_filter(bus, m);
         if (r != 0)
                 goto finish;


@@ -2277,10 +2478,20 @@ static int process_message(sd_bus *bus, sd_bus_message *m) {
         r = bus_process_object(bus, m);
 
 finish:
         r = bus_process_object(bus, m);
 
 finish:

-        bus->current = NULL;
+        bus->current_message = NULL;

         return r;
 }
 
         return r;
 }
 

+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;
 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;


@@ -2296,6 +2507,10 @@ static int process_running(sd_bus *bus, bool hint_priority, int64_t priority, sd
         if (r != 0)
                 goto null_message;
 
         if (r != 0)
                 goto null_message;
 

+        r = dispatch_track(bus);
+        if (r != 0)
+                goto null_message;
+

         r = dispatch_rqueue(bus, hint_priority, priority, &m);
         if (r < 0)
                 return r;
         r = dispatch_rqueue(bus, hint_priority, priority, &m);
         if (r < 0)
                 return r;


@@ -2349,9 +2564,10 @@ static int process_closing(sd_bus *bus, sd_bus_message **ret) {
         assert(bus);
         assert(bus->state == BUS_CLOSING);
 
         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;
         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(
 
                 /* First, fail all outstanding method calls */
                 r = bus_message_new_synthetic_error(


@@ -2366,32 +2582,49 @@ static int process_closing(sd_bus *bus, sd_bus_message **ret) {
                 if (r < 0)
                         return r;
 
                 if (r < 0)
                         return r;
 

-                if (c->timeout != 0)
+                if (c->timeout != 0) {

                         prioq_remove(bus->reply_callbacks_prioq, c, &c->prioq_idx);
                         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++;
 
                 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 */
         r = sd_bus_message_new_signal(
                         bus,
         }
 
         /* Then, synthesize a Disconnected message */
         r = sd_bus_message_new_signal(
                         bus,

+                        &m,

                         "/org/freedesktop/DBus/Local",
                         "org.freedesktop.DBus.Local",
                         "/org/freedesktop/DBus/Local",
                         "org.freedesktop.DBus.Local",

-                        "Disconnected",
-                        &m);
+                        "Disconnected");

         if (r < 0)
                 return r;
 
         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)
 
         r = bus_seal_synthetic_message(bus, m);
         if (r < 0)


@@ -2399,7 +2632,7 @@ static int process_closing(sd_bus *bus, sd_bus_message **ret) {
 
         sd_bus_close(bus);
 
 
         sd_bus_close(bus);
 

-        bus->current = m;
+        bus->current_message = m;

         bus->iteration_counter++;
 
         r = process_filter(bus, m);
         bus->iteration_counter++;
 
         r = process_filter(bus, m);


@@ -2418,7 +2651,8 @@ static int process_closing(sd_bus *bus, sd_bus_message **ret) {
         r = 1;
 
 finish:
         r = 1;
 
 finish:

-        bus->current = NULL;
+        bus->current_message = NULL;
+

         return r;
 }
 
         return r;
 }
 


@@ -2435,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_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) {
 
 
         switch (bus->state) {
 


@@ -2501,14 +2736,15 @@ 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;
         struct pollfd p[2] = {};
         int r, e, n;
         struct timespec ts;

-        usec_t m = (usec_t) -1;
+        usec_t m = USEC_INFINITY;

 
         assert(bus);
 
         if (bus->state == BUS_CLOSING)
                 return 1;
 
 
         assert(bus);
 
         if (bus->state == BUS_CLOSING)
                 return 1;
 

-        assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
+        if (!BUS_IS_OPEN(bus->state))
+                return -ENOTCONN;

 
         e = sd_bus_get_events(bus);
         if (e < 0)
 
         e = sd_bus_get_events(bus);
         if (e < 0)


@@ -2517,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
         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;
                 e |= POLLIN;
         else {
                 usec_t until;


@@ -2563,7 +2799,8 @@ _public_ int sd_bus_wait(sd_bus *bus, uint64_t timeout_usec) {
         if (bus->state == BUS_CLOSING)
                 return 0;
 
         if (bus->state == BUS_CLOSING)
                 return 0;
 

-        assert_return(BUS_IS_OPEN(bus->state) , -ENOTCONN);
+        if (!BUS_IS_OPEN(bus->state))
+                return -ENOTCONN;

 
         if (bus->rqueue_size > 0)
                 return 0;
 
         if (bus->rqueue_size > 0)
                 return 0;


@@ -2580,7 +2817,8 @@ _public_ int sd_bus_flush(sd_bus *bus) {
         if (bus->state == BUS_CLOSING)
                 return 0;
 
         if (bus->state == BUS_CLOSING)
                 return 0;
 

-        assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
+        if (!BUS_IS_OPEN(bus->state))
+                return -ENOTCONN;

 
         r = bus_ensure_running(bus);
         if (r < 0)
 
         r = bus_ensure_running(bus);
         if (r < 0)


@@ -2609,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);
 
 
         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;
                 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) {
+        s->filter_callback.callback = callback;

 
 

-        struct filter_callback *f;
+        bus->filter_callbacks_modified = true;
+        LIST_PREPEND(callbacks, bus->filter_callbacks, &s->filter_callback);

 
 

-        assert_return(bus, -EINVAL);
-        assert_return(callback, -EINVAL);
-        assert_return(!bus_pid_changed(bus), -ECHILD);
-
-        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;
 }
 
 
         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;
 
         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);
         int r = 0;
 
         assert_return(bus, -EINVAL);


@@ -2670,35 +2894,60 @@ _public_ int sd_bus_add_match(sd_bus *bus,
         if (r < 0)
                 goto finish;
 
         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) {
         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;
                 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);
 
 finish:
         bus_match_parse_free(components, n_components);

+        sd_bus_slot_unref(s);
+

         return r;
 }
 
         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;
 
         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);
 
         assert_return(bus, -EINVAL);
         assert_return(match, -EINVAL);


@@ -2706,17 +2955,18 @@ _public_ int sd_bus_remove_match(sd_bus *bus,
 
         r = bus_match_parse(match, &components, &n_components);
         if (r < 0)
 
         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);
 
         bus_match_parse_free(components, n_components);
 

-        return r < 0 ? r : q;
+        return r;

 }
 
 bool bus_pid_changed(sd_bus *bus) {
 }
 
 bool bus_pid_changed(sd_bus *bus) {


@@ -2805,6 +3055,7 @@ static int quit_callback(sd_event_source *event, void *userdata) {
         assert(event);
 
         sd_bus_flush(bus);
         assert(event);
 
         sd_bus_flush(bus);

+        sd_bus_close(bus);

 
         return 1;
 }
 
         return 1;
 }


@@ -2821,7 +3072,7 @@ static int attach_io_events(sd_bus *bus) {
                 return 0;
 
         if (!bus->input_io_event_source) {
                 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;
 
                 if (r < 0)
                         return r;
 


@@ -2830,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);
                         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);
 
         } else
                 r = sd_event_source_set_io_fd(bus->input_io_event_source, bus->input_fd);
 


@@ -2840,11 +3095,15 @@ static int attach_io_events(sd_bus *bus) {
                 assert(bus->output_fd >= 0);
 
                 if (!bus->output_io_event_source) {
                 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;
 
                         r = sd_event_source_set_priority(bus->output_io_event_source, bus->event_priority);
                         if (r < 0)
                                 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);
 
                 } else
                         r = sd_event_source_set_io_fd(bus->output_io_event_source, bus->output_fd);
 


@@ -2889,7 +3148,7 @@ _public_ int sd_bus_attach_event(sd_bus *bus, sd_event *event, int priority) {
 
         bus->event_priority = 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_time(bus->event, &bus->time_event_source, CLOCK_MONOTONIC, 0, 0, time_callback, bus);

         if (r < 0)
                 goto fail;
 
         if (r < 0)
                 goto fail;
 


@@ -2897,7 +3156,15 @@ _public_ int sd_bus_attach_event(sd_bus *bus, sd_event *event, int priority) {
         if (r < 0)
                 goto fail;
 
         if (r < 0)
                 goto fail;
 

-        r = sd_event_add_exit(bus->event, quit_callback, bus, &bus->quit_event_source);
+        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;
 
         if (r < 0)
                 goto fail;
 


@@ -2930,9 +3197,7 @@ _public_ int sd_bus_detach_event(sd_bus *bus) {
                 bus->quit_event_source = sd_event_source_unref(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);
-
+        bus->event = sd_event_unref(bus->event);

         return 1;
 }
 
         return 1;
 }
 


@@ -2942,10 +3207,28 @@ _public_ sd_event* sd_bus_get_event(sd_bus *bus) {
         return bus->event;
 }
 
         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);
 
         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) {
 }
 
 static int bus_default(int (*bus_open)(sd_bus **), sd_bus **default_bus, sd_bus **ret) {


@@ -3001,7 +3284,7 @@ _public_ int sd_bus_default(sd_bus **ret) {
         if (e) {
                 if (streq(e, "system"))
                         return sd_bus_default_system(ret);
         if (e) {
                 if (streq(e, "system"))
                         return sd_bus_default_system(ret);

-                else if (streq(e, "user") || streq(e, "session"))
+                else if (STR_IN_SET(e, "user", "session"))

                         return sd_bus_default_user(ret);
         }
 
                         return sd_bus_default_user(ret);
         }
 


@@ -3040,150 +3323,196 @@ _public_ int sd_bus_get_tid(sd_bus *b, pid_t *tid) {
         return -ENXIO;
 }
 
         return -ENXIO;
 }
 

-_public_ char *sd_bus_label_escape(const char *s) {
-        char *r, *t;
-        const char *f;
+_public_ int sd_bus_path_encode(const char *prefix, const char *external_id, char **ret_path) {
+        _cleanup_free_ char *e = NULL;
+        char *ret;

 
 

-        assert_return(s, NULL);
+        assert_return(object_path_is_valid(prefix), -EINVAL);
+        assert_return(external_id, -EINVAL);
+        assert_return(ret_path, -EINVAL);

 
 

-        /* Escapes all chars that D-Bus' object path cannot deal
-         * with. Can be reversed with bus_path_unescape(). We special
-         * case the empty string. */
+        e = bus_label_escape(external_id);
+        if (!e)
+                return -ENOMEM;

 
 

-        if (*s == 0)
-                return strdup("_");
+        ret = strjoin(prefix, "/", e, NULL);
+        if (!ret)
+                return -ENOMEM;

 
 

-        r = new(char, strlen(s)*3 + 1);
-        if (!r)
-                return NULL;
+        *ret_path = ret;
+        return 0;
+}

 
 

-        for (f = s, t = r; *f; f++) {
+_public_ int sd_bus_path_decode(const char *path, const char *prefix, char **external_id) {
+        const char *e;
+        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(path), -EINVAL);
+        assert_return(object_path_is_valid(prefix), -EINVAL);
+        assert_return(external_id, -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 = 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_ char *sd_bus_label_unescape(const char *f) {
-        char *r, *t;
+_public_ int sd_bus_try_close(sd_bus *bus) {
+        int r;

 
 

-        assert_return(f, NULL);
+        assert_return(bus, -EINVAL);
+        assert_return(!bus_pid_changed(bus), -ECHILD);

 
 

-        /* Special case for the empty string */
-        if (streq(f, "_"))
-                return strdup("");
+        if (!bus->is_kernel)
+                return -ENOTSUP;

 
 

-        r = new(char, strlen(f) + 1);
-        if (!r)
-                return NULL;
+        if (!BUS_IS_OPEN(bus->state))
+                return -ENOTCONN;

 
 

-        for (t = r; *f; f++) {
+        if (bus->rqueue_size > 0)
+                return -EBUSY;

 
 

-                if (*f == '_') {
-                        int a, b;
+        if (bus->wqueue_size > 0)
+                return -EBUSY;

 
 

-                        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;
-        }
+        r = bus_kernel_try_close(bus);
+        if (r < 0)
+                return r;

 
 

-        *t = 0;
+        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;
+
+        r = cg_get_root_path(&bus->cgroup_root);
+        if (r == -ENOENT) {
+                bus->cgroup_root = strdup("/");
+                if (!bus->cgroup_root)
+                        return -ENOMEM;
+
+                r = 0;
+        }

 
         return r;
 }
 
 
         return r;
 }
 

-_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_get_scope(sd_bus *bus, const char **scope) {

         int r;
 
         assert_return(bus, -EINVAL);
         int r;
 
         assert_return(bus, -EINVAL);

-        assert_return(mask <= _SD_BUS_CREDS_ALL, -ENOTSUP);
-        assert_return(ret, -EINVAL);
-        assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);
+        assert_return(scope, -EINVAL);

         assert_return(!bus_pid_changed(bus), -ECHILD);
         assert_return(!bus_pid_changed(bus), -ECHILD);

-        assert_return(!bus->is_kernel, -ENOTSUP);

 
 

-        if (!bus->ucred_valid && !isempty(bus->label))
-                return -ENODATA;
+        if (bus->is_kernel) {
+                _cleanup_free_ char *n = NULL;
+                const char *dash;

 
 

-        c = bus_creds_new();
-        if (!c)
-                return -ENOMEM;
+                r = bus_kernel_get_bus_name(bus, &n);
+                if (r < 0)
+                        return r;

 
 

-        if (bus->ucred_valid) {
-                pid = c->pid = bus->ucred.pid;
-                c->uid = bus->ucred.uid;
-                c->gid = bus->ucred.gid;
+                if (streq(n, "0-system")) {
+                        *scope = "system";
+                        return 0;
+                }

 
 

-                c->mask |= (SD_BUS_CREDS_UID | SD_BUS_CREDS_PID | SD_BUS_CREDS_GID) & mask;
+                dash = strchr(n, '-');
+                if (streq_ptr(dash, "-user")) {
+                        *scope = "user";
+                        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);
-                        return -ENOMEM;
-                }
+        if (bus->is_user) {
+                *scope = "user";
+                return 0;
+        }

 
 

-                c->mask |= SD_BUS_CREDS_SELINUX_CONTEXT;
+        if (bus->is_system) {
+                *scope = "system";
+                return 0;

         }
 
         }
 

-        r = bus_creds_add_more(c, mask, pid, 0);
-        if (r < 0)
-                return r;
+        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;
+        }

 
 

-        *ret = c;
+        return -ENODATA;
+}
+
+int sd_bus_get_creds_mask(sd_bus *bus, uint64_t *mask) {
+        assert_return(bus, -EINVAL);
+        assert_return(mask, -EINVAL);
+        assert_return(!bus_pid_changed(bus), -ECHILD);
+
+        *mask = bus->creds_mask;

         return 0;
 }
 
         return 0;
 }
 

-_public_ int sd_bus_try_close(sd_bus *bus) {
-        int r;
+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, -EINVAL);

-        assert_return(BUS_IS_OPEN(bus->state), -ENOTCONN);

         assert_return(!bus_pid_changed(bus), -ECHILD);
         assert_return(!bus_pid_changed(bus), -ECHILD);

-        assert_return(bus->is_kernel, -ENOTSUP);

 
 

-        if (bus->rqueue_size > 0)
-                return -EBUSY;
+        return bus->is_server;
+}

 
 

-        if (bus->wqueue_size > 0)
-                return -EBUSY;
+int sd_bus_is_anonymous(sd_bus *bus) {
+        assert_return(bus, -EINVAL);
+        assert_return(!bus_pid_changed(bus), -ECHILD);

 
 

-        r = bus_kernel_try_close(bus);
-        if (r < 0)
-                return r;
+        return bus->anonymous_auth;
+}

 
 

-        sd_bus_close(bus);
-        return 0;
+int sd_bus_is_trusted(sd_bus *bus) {
+        assert_return(bus, -EINVAL);
+        assert_return(!bus_pid_changed(bus), -ECHILD);
+
+        return bus->trusted;

 }
 
 }
 

-_public_ int sd_bus_get_name(sd_bus *bus, const char **name) {
+int sd_bus_is_monitor(sd_bus *bus) {

         assert_return(bus, -EINVAL);
         assert_return(bus, -EINVAL);

-        assert_return(name, -EINVAL);

         assert_return(!bus_pid_changed(bus), -ECHILD);
 
         assert_return(!bus_pid_changed(bus), -ECHILD);
 

-        *name = bus->connection_name;
-        return 0;
+        return !!(bus->hello_flags & KDBUS_HELLO_MONITOR);

 }
 }