bus: parse uid/gid/pid/tid meta data from kdbus messages

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

diff --git a/src/libsystemd-bus/sd-bus.c b/src/libsystemd-bus/sd-bus.c
index 8b8ce3c03e6a1df096e31a8974e6ef08434a0d8b..2424ee14465bb69737f8b4281ec226c6839672fa 100644 (file)
--- a/src/libsystemd-bus/sd-bus.c
+++ b/src/libsystemd-bus/sd-bus.c
@@ -37,6 +37,7 @@
 #include "bus-message.h"
 #include "bus-type.h"
 #include "bus-socket.h"
+#include "bus-kernel.h"
 #include "bus-control.h"
 
 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec);
@@ -54,6 +55,7 @@ static void bus_free(sd_bus *b) {
         free(b->unique_name);
         free(b->auth_buffer);
         free(b->address);
+        free(b->kernel);
 
         free(b->exec_path);
         strv_free(b->exec_argv);
@@ -259,7 +261,7 @@ static int bus_send_hello(sd_bus *bus) {
 
         assert(bus);
 
-        if (!bus->bus_client)
+        if (!bus->bus_client || bus->is_kernel)
                 return 0;
 
         r = sd_bus_message_new_method_call(
@@ -436,8 +438,11 @@ static int parse_unix_address(sd_bus *b, const char **p, char **guid) {
 
 static int parse_tcp_address(sd_bus *b, const char **p, char **guid) {
         _cleanup_free_ char *host = NULL, *port = NULL, *family = NULL;
-        struct addrinfo hints, *result;
         int r;
+        struct addrinfo *result, hints = {
+                .ai_socktype = SOCK_STREAM,
+                .ai_flags = AI_ADDRCONFIG,
+        };
 
         assert(b);
         assert(p);
@@ -475,10 +480,6 @@ static int parse_tcp_address(sd_bus *b, const char **p, char **guid) {
         if (!host || !port)
                 return -EINVAL;
 
-        zero(hints);
-        hints.ai_socktype = SOCK_STREAM;
-        hints.ai_flags = AI_ADDRCONFIG;
-
         if (family) {
                 if (streq(family, "ipv4"))
                         hints.ai_family = AF_INET;
@@ -597,6 +598,41 @@ fail:
         return r;
 }
 
+static int parse_kernel_address(sd_bus *b, const char **p, char **guid) {
+        _cleanup_free_ char *path = NULL;
+        int r;
+
+        assert(b);
+        assert(p);
+        assert(*p);
+        assert(guid);
+
+        while (**p != 0 && **p != ';') {
+                r = parse_address_key(p, "guid", guid);
+                if (r < 0)
+                        return r;
+                else if (r > 0)
+                        continue;
+
+                r = parse_address_key(p, "path", &path);
+                if (r < 0)
+                        return r;
+                else if (r > 0)
+                        continue;
+
+                skip_address_key(p);
+        }
+
+        if (!path)
+                return -EINVAL;
+
+        free(b->kernel);
+        b->kernel = path;
+        path = NULL;
+
+        return 0;
+}
+
 static void bus_reset_parsed_address(sd_bus *b) {
         assert(b);
 
@@ -607,6 +643,8 @@ static void bus_reset_parsed_address(sd_bus *b) {
         b->exec_path = NULL;
         b->exec_argv = NULL;
         b->server_id = SD_ID128_NULL;
+        free(b->kernel);
+        b->kernel = NULL;
 }
 
 static int bus_parse_next_address(sd_bus *b) {
@@ -658,6 +696,14 @@ static int bus_parse_next_address(sd_bus *b) {
 
                         break;
 
+                } else if (startswith(a, "kernel:")) {
+
+                        a += 7;
+                        r = parse_kernel_address(b, &a, &guid);
+                        if (r < 0)
+                                return r;
+
+                        break;
                 }
 
                 a = strchr(a, ';');
@@ -697,6 +743,13 @@ static int bus_start_address(sd_bus *b) {
                         if (r >= 0)
                                 return r;
 
+                        b->last_connect_error = -r;
+                } else if (b->kernel) {
+
+                        r = bus_kernel_connect(b);
+                        if (r >= 0)
+                                return r;
+
                         b->last_connect_error = -r;
                 }
 
@@ -716,6 +769,7 @@ int bus_next_address(sd_bus *b) {
 }
 
 static int bus_start_fd(sd_bus *b) {
+        struct stat st;
         int r;
 
         assert(b);
@@ -740,7 +794,13 @@ static int bus_start_fd(sd_bus *b) {
                         return r;
         }
 
-        return bus_socket_take_fd(b);
+        if (fstat(b->input_fd, &st) < 0)
+                return -errno;
+
+        if (S_ISCHR(b->input_fd))
+                return bus_kernel_take_fd(b);
+        else
+                return bus_socket_take_fd(b);
 }
 
 int sd_bus_start(sd_bus *bus) {
@@ -758,7 +818,7 @@ int sd_bus_start(sd_bus *bus) {
 
         if (bus->input_fd >= 0)
                 r = bus_start_fd(bus);
-        else if (bus->address || bus->sockaddr.sa.sa_family != AF_UNSPEC || bus->exec_path)
+        else if (bus->address || bus->sockaddr.sa.sa_family != AF_UNSPEC || bus->exec_path || bus->kernel)
                 r = bus_start_address(bus);
         else
                 return -EINVAL;
@@ -959,14 +1019,18 @@ static int dispatch_wqueue(sd_bus *bus) {
 
         while (bus->wqueue_size > 0) {
 
-                r = bus_socket_write_message(bus, bus->wqueue[0], &bus->windex);
+                if (bus->is_kernel)
+                        r = bus_kernel_write_message(bus, bus->wqueue[0]);
+                else
+                        r = bus_socket_write_message(bus, bus->wqueue[0], &bus->windex);
+
                 if (r < 0) {
                         sd_bus_close(bus);
                         return r;
                 } else if (r == 0)
                         /* Didn't do anything this time */
                         return ret;
-                else if (bus->windex >= bus->wqueue[0]->size) {
+                else if (bus->is_kernel || bus->windex >= BUS_MESSAGE_SIZE(bus->wqueue[0])) {
                         /* Fully written. Let's drop the entry from
                          * the queue.
                          *
@@ -1011,7 +1075,11 @@ static int dispatch_rqueue(sd_bus *bus, sd_bus_message **m) {
 
         /* Try to read a new message */
         do {
-                r = bus_socket_read_message(bus, &z);
+                if (bus->is_kernel)
+                        r = bus_kernel_read_message(bus, &z);
+                else
+                        r = bus_socket_read_message(bus, &z);
+
                 if (r < 0) {
                         sd_bus_close(bus);
                         return r;
@@ -1063,11 +1131,15 @@ int sd_bus_send(sd_bus *bus, sd_bus_message *m, uint64_t *serial) {
         if ((bus->state == BUS_RUNNING || bus->state == BUS_HELLO) && bus->wqueue_size <= 0) {
                 size_t idx = 0;
 
-                r = bus_socket_write_message(bus, m, &idx);
+                if (bus->is_kernel)
+                        r = bus_kernel_write_message(bus, m);
+                else
+                        r = bus_socket_write_message(bus, m, &idx);
+
                 if (r < 0) {
                         sd_bus_close(bus);
                         return r;
-                } else if (idx < m->size)  {
+                } else if (!bus->is_kernel && idx < BUS_MESSAGE_SIZE(m))  {
                         /* Wasn't fully written. So let's remember how
                          * much was written. Note that the first entry
                          * of the wqueue array is always allocated so
@@ -1305,7 +1377,10 @@ int sd_bus_send_with_reply_and_block(
                         room = true;
                 }
 
-                r = bus_socket_read_message(bus, &incoming);
+                if (bus->is_kernel)
+                        r = bus_kernel_read_message(bus, &incoming);
+                else
+                        r = bus_socket_read_message(bus, &incoming);
                 if (r < 0)
                         return r;
                 if (incoming) {
@@ -1314,7 +1389,12 @@ int sd_bus_send_with_reply_and_block(
                                 /* Found a match! */
 
                                 if (incoming->header->type == SD_BUS_MESSAGE_TYPE_METHOD_RETURN) {
-                                        *reply = incoming;
+
+                                        if (reply)
+                                                *reply = incoming;
+                                        else
+                                                sd_bus_message_unref(incoming);
+
                                         return 0;
                                 }
 
@@ -1932,7 +2012,7 @@ int sd_bus_process(sd_bus *bus, sd_bus_message **ret) {
 }
 
 static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec) {
-        struct pollfd p[2];
+        struct pollfd p[2] = {};
         int r, e, n;
         struct timespec ts;
         usec_t until, m;
@@ -1963,9 +2043,7 @@ static int bus_poll(sd_bus *bus, bool need_more, uint64_t timeout_usec) {
         if (timeout_usec != (uint64_t) -1 && (m == (uint64_t) -1 || timeout_usec < m))
                 m = timeout_usec;
 
-        zero(p);
         p[0].fd = bus->input_fd;
-
         if (bus->output_fd == bus->input_fd) {
                 p[0].events = e;
                 n = 1;