bus: implement full method call timeout logic

1 files changed, 167 insertions, 20 deletions

diff --git a/src/libsystemd-bus/test-bus-chat.c b/src/libsystemd-bus/test-bus-chat.c
index 4260ca3bc0..9e14824186 100644
--- a/src/libsystemd-bus/test-bus-chat.c
+++ b/src/libsystemd-bus/test-bus-chat.c
@@ -22,12 +22,14 @@
 #include <assert.h>
 #include <stdlib.h>
 #include <pthread.h>
+#include <unistd.h>
 
 #include "log.h"
 #include "util.h"
 
 #include "sd-bus.h"
 #include "bus-message.h"
+#include "bus-error.h"
 
 static int server_init(sd_bus **_bus) {
         sd_bus *bus = NULL;
@@ -57,11 +59,11 @@ fail:
         return r;
 }
 
-static void* server(void *p) {
-        sd_bus *bus = p;
+static int server(sd_bus *bus) {
         int r;
+        bool client1_gone = false, client2_gone = false;
 
-        for (;;) {
+        while (!client1_gone || !client2_gone) {
                 _cleanup_bus_message_unref_ sd_bus_message *m = NULL, *reply = NULL;
 
                 r = sd_bus_process(bus, &m);
@@ -69,6 +71,7 @@ static void* server(void *p) {
                         log_error("Failed to process requests: %s", strerror(-r));
                         goto fail;
                 }
+
                 if (r == 0) {
                         r = sd_bus_wait(bus, (uint64_t) -1);
                         if (r < 0) {
@@ -79,6 +82,9 @@ static void* server(void *p) {
                         continue;
                 }
 
+                if (!m)
+                        continue;
+
                 log_info("Got message! %s", strna(sd_bus_message_get_member(m)));
                 /* bus_message_dump(m); */
                 /* sd_bus_message_rewind(m, true); */
@@ -112,9 +118,34 @@ static void* server(void *p) {
                                 log_error("Failed to append message: %s", strerror(-r));
                                 goto fail;
                         }
-                } else if (sd_bus_message_is_method_call(m, "org.freedesktop.systemd.test", "Exit"))
-                        break;
-                else if (sd_bus_message_is_method_call(m, NULL, NULL)) {
+                } else if (sd_bus_message_is_method_call(m, "org.freedesktop.systemd.test", "ExitClient1")) {
+
+                        r = sd_bus_message_new_method_return(bus, m, &reply);
+                        if (r < 0) {
+                                log_error("Failed to allocate return: %s", strerror(-r));
+                                goto fail;
+                        }
+
+                        client1_gone = true;
+                } else if (sd_bus_message_is_method_call(m, "org.freedesktop.systemd.test", "ExitClient2")) {
+
+                        r = sd_bus_message_new_method_return(bus, m, &reply);
+                        if (r < 0) {
+                                log_error("Failed to allocate return: %s", strerror(-r));
+                                goto fail;
+                        }
+
+                        client2_gone = true;
+                } else if (sd_bus_message_is_method_call(m, "org.freedesktop.systemd.test", "Slow")) {
+
+                        r = sd_bus_message_new_method_return(bus, m, &reply);
+                        if (r < 0) {
+                                log_error("Failed to allocate return: %s", strerror(-r));
+                                goto fail;
+                        }
+
+                        sleep(1);
+                } else if (sd_bus_message_is_method_call(m, NULL, NULL)) {
                         const sd_bus_error e = SD_BUS_ERROR_INIT_CONST("org.freedesktop.DBus.Error.UnknownMethod", "Unknown method.");
 
                         r = sd_bus_message_new_method_error(bus, m, &e, &reply);
@@ -130,19 +161,25 @@ static void* server(void *p) {
                                 log_error("Failed to send reply: %s", strerror(-r));
                                 goto fail;
                         }
+
+                        /* log_info("Sent"); */
+                        /* bus_message_dump(reply); */
+                        /* sd_bus_message_rewind(reply, true); */
                 }
         }
 
         r = 0;
 
 fail:
-        if (bus)
+        if (bus) {
+                sd_bus_flush(bus);
                 sd_bus_unref(bus);
+        }
 
-        return INT_TO_PTR(r);
+        return r;
 }
 
-static int client(void) {
+static void* client1(void*p) {
         _cleanup_bus_message_unref_ sd_bus_message *m = NULL, *reply = NULL;
         sd_bus *bus = NULL;
         sd_bus_error error = SD_BUS_ERROR_INIT;
@@ -173,9 +210,9 @@ static int client(void) {
                 goto finish;
         }
 
-        r = sd_bus_send_with_reply_and_block(bus, m, (uint64_t) -1, &error, &reply);
+        r = sd_bus_send_with_reply_and_block(bus, m, 0, &error, &reply);
         if (r < 0) {
-                log_error("Failed to issue method call: %s", error.message);
+                log_error("Failed to issue method call: %s", bus_error_message(&error, -r));
                 goto finish;
         }
 
@@ -198,7 +235,7 @@ finish:
                                 "org.freedesktop.systemd.test",
                                 "/",
                                 "org.freedesktop.systemd.test",
-                                "Exit",
+                                "ExitClient1",
                                 &q);
                 if (r < 0) {
                         log_error("Failed to allocate method call: %s", strerror(-r));
@@ -211,11 +248,114 @@ finish:
         }
 
         sd_bus_error_free(&error);
-        return r;
+        return INT_TO_PTR(r);
+}
+
+static int quit_callback(sd_bus *b, int ret, sd_bus_message *m, void *userdata) {
+        bool *x = userdata;
+
+        log_error("Quit callback: %s", strerror(ret));
+
+        *x = 1;
+        return 1;
+}
+
+static void* client2(void*p) {
+        _cleanup_bus_message_unref_ sd_bus_message *m = NULL, *reply = NULL;
+        sd_bus *bus = NULL;
+        sd_bus_error error = SD_BUS_ERROR_INIT;
+        int r;
+        bool quit = false;
+
+        r = sd_bus_open_user(&bus);
+        if (r < 0) {
+                log_error("Failed to connect to user bus: %s", strerror(-r));
+                goto finish;
+        }
+
+        r = sd_bus_message_new_method_call(
+                        bus,
+                        "org.freedesktop.systemd.test",
+                        "/",
+                        "org.freedesktop.systemd.test",
+                        "Slow",
+                        &m);
+        if (r < 0) {
+                log_error("Failed to allocate method call: %s", strerror(-r));
+                goto finish;
+        }
+
+        r = sd_bus_send_with_reply_and_block(bus, m, 200 * USEC_PER_MSEC, &error, &reply);
+        if (r < 0)
+                log_info("Failed to issue method call: %s", bus_error_message(&error, -r));
+        else
+                log_info("Slow call succeed.");
+
+        sd_bus_message_unref(m);
+        m = NULL;
+
+        r = sd_bus_message_new_method_call(
+                        bus,
+                        "org.freedesktop.systemd.test",
+                        "/",
+                        "org.freedesktop.systemd.test",
+                        "Slow",
+                        &m);
+        if (r < 0) {
+                log_error("Failed to allocate method call: %s", strerror(-r));
+                goto finish;
+        }
+
+        r = sd_bus_send_with_reply(bus, m, quit_callback, &quit, 200 * USEC_PER_MSEC, NULL);
+        if (r < 0) {
+                log_info("Failed to issue method call: %s", bus_error_message(&error, -r));
+                goto finish;
+        }
+
+        while (!quit) {
+                r = sd_bus_process(bus, NULL);
+                if (r < 0) {
+                        log_error("Failed to process requests: %s", strerror(-r));
+                        goto finish;
+                }
+                if (r == 0) {
+                        r = sd_bus_wait(bus, (uint64_t) -1);
+                        if (r < 0) {
+                                log_error("Failed to wait: %s", strerror(-r));
+                                goto finish;
+                        }
+                }
+        }
+
+        r = 0;
+
+finish:
+        if (bus) {
+                _cleanup_bus_message_unref_ sd_bus_message *q;
+
+                r = sd_bus_message_new_method_call(
+                                bus,
+                                "org.freedesktop.systemd.test",
+                                "/",
+                                "org.freedesktop.systemd.test",
+                                "ExitClient2",
+                                &q);
+                if (r < 0) {
+                        log_error("Failed to allocate method call: %s", strerror(-r));
+                        goto finish;
+                }
+
+                sd_bus_send(bus, q, NULL);
+                sd_bus_flush(bus);
+                sd_bus_unref(bus);
+        }
+
+        sd_bus_error_free(&error);
+        return INT_TO_PTR(r);
 }
 
 int main(int argc, char *argv[]) {
-        pthread_t t;
+        pthread_t c1, c2;
         sd_bus *bus;
         void *p;
         int q, r;
@@ -224,15 +364,22 @@ int main(int argc, char *argv[]) {
         if (r < 0)
                 return EXIT_FAILURE;
 
-        r = pthread_create(&t, NULL, server, bus);
-        if (r != 0) {
-                sd_bus_unref(bus);
+        log_info("Initialized...");
+
+        r = pthread_create(&c1, NULL, client1, bus);
+        if (r != 0)
                 return EXIT_FAILURE;
-        }
 
-        r = client();
+        r = pthread_create(&c2, NULL, client2, bus);
+        if (r != 0)
+                return EXIT_FAILURE;
 
-        q = pthread_join(t, &p);
+        r = server(bus);
+
+        q = pthread_join(c1, &p);
+        if (q != 0)
+                return EXIT_FAILURE;
+        q = pthread_join(c2, &p);
         if (q != 0)
                 return EXIT_FAILURE;
         if (r < 0)