[thirdparty/systemd.git] / src / libsystemd / sd-bus / test-bus-chat.c

/* SPDX-License-Identifier: LGPL-2.1-or-later */

#include <fcntl.h>
#include <pthread.h>
#include <stdlib.h>
#include <unistd.h>

#include "sd-bus.h"

#include "alloc-util.h"
#include "bus-error.h"
#include "bus-internal.h"
#include "bus-match.h"
#include "errno-util.h"
#include "fd-util.h"
#include "format-util.h"
#include "log.h"
#include "macro.h"
#include "string-util.h"
#include "tests.h"
#include "util.h"

static int match_callback(sd_bus_message *m, void *userdata, sd_bus_error *ret_error) {
        log_info("Match triggered! interface=%s member=%s", strna(sd_bus_message_get_interface(m)), strna(sd_bus_message_get_member(m)));
        return 0;
}

static int object_callback(sd_bus_message *m, void *userdata, sd_bus_error *ret_error) {
        int r;

        if (sd_bus_message_is_method_error(m, NULL))
                return 0;

        if (sd_bus_message_is_method_call(m, "org.object.test", "Foobar")) {
                log_info("Invoked Foobar() on %s", sd_bus_message_get_path(m));

                r = sd_bus_reply_method_return(m, NULL);
                if (r < 0)
                        return log_error_errno(r, "Failed to send reply: %m");

                return 1;
        }

        return 0;
}

static int server_init(sd_bus **_bus) {
        sd_bus *bus = NULL;
        sd_id128_t id;
        int r;
        const char *unique, *desc;

        assert_se(_bus);

        r = sd_bus_open_user_with_description(&bus, "my bus!");
        if (r < 0) {
                log_error_errno(r, "Failed to connect to user bus: %m");
                goto fail;
        }

        r = sd_bus_get_bus_id(bus, &id);
        if (r < 0) {
                log_error_errno(r, "Failed to get server ID: %m");
                goto fail;
        }

        r = sd_bus_get_unique_name(bus, &unique);
        if (r < 0) {
                log_error_errno(r, "Failed to get unique name: %m");
                goto fail;
        }

        assert_se(sd_bus_get_description(bus, &desc) >= 0);
        assert_se(streq(desc, "my bus!"));

        log_info("Peer ID is " SD_ID128_FORMAT_STR ".", SD_ID128_FORMAT_VAL(id));
        log_info("Unique ID: %s", unique);
        log_info("Can send file handles: %i", sd_bus_can_send(bus, 'h'));

        r = sd_bus_request_name(bus, "org.freedesktop.systemd.test", 0);
        if (r < 0) {
                log_error_errno(r, "Failed to acquire name: %m");
                goto fail;
        }

        r = sd_bus_add_fallback(bus, NULL, "/foo/bar", object_callback, NULL);
        if (r < 0) {
                log_error_errno(r, "Failed to add object: %m");
                goto fail;
        }

        r = sd_bus_match_signal(bus, NULL, NULL, NULL, "foo.bar", "Notify", match_callback, NULL);
        if (r < 0) {
                log_error_errno(r, "Failed to request match: %m");
                goto fail;
        }

        r = sd_bus_add_match(bus, NULL, "type='signal',interface='org.freedesktop.DBus',member='NameOwnerChanged'", match_callback, NULL);
        if (r < 0) {
                log_error_errno(r, "Failed to add match: %m");
                goto fail;
        }

        bus_match_dump(&bus->match_callbacks, 0);

        *_bus = bus;
        return 0;

fail:
        sd_bus_unref(bus);
        return r;
}

static int server(sd_bus *bus) {
        int r;
        bool client1_gone = false, client2_gone = false;

        while (!client1_gone || !client2_gone) {
                _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
                pid_t pid = 0;
                const char *label = NULL;

                r = sd_bus_process(bus, &m);
                if (r < 0) {
                        log_error_errno(r, "Failed to process requests: %m");
                        goto fail;
                }

                if (r == 0) {
                        r = sd_bus_wait(bus, UINT64_MAX);
                        if (r < 0) {
                                log_error_errno(r, "Failed to wait: %m");
                                goto fail;
                        }

                        continue;
                }

                if (!m)
                        continue;

                sd_bus_creds_get_pid(sd_bus_message_get_creds(m), &pid);
                sd_bus_creds_get_selinux_context(sd_bus_message_get_creds(m), &label);
                log_info("Got message! member=%s pid="PID_FMT" label=%s",
                         strna(sd_bus_message_get_member(m)),
                         pid,
                         strna(label));
                /* sd_bus_message_dump(m); */
                /* sd_bus_message_rewind(m, true); */

                if (sd_bus_message_is_method_call(m, "org.freedesktop.systemd.test", "LowerCase")) {
                        const char *hello;
                        _cleanup_free_ char *lowercase = NULL;

                        r = sd_bus_message_read(m, "s", &hello);
                        if (r < 0) {
                                log_error_errno(r, "Failed to get parameter: %m");
                                goto fail;
                        }

                        lowercase = strdup(hello);
                        if (!lowercase) {
                                r = log_oom();
                                goto fail;
                        }

                        ascii_strlower(lowercase);

                        r = sd_bus_reply_method_return(m, "s", lowercase);
                        if (r < 0) {
                                log_error_errno(r, "Failed to send reply: %m");
                                goto fail;
                        }
                } else if (sd_bus_message_is_method_call(m, "org.freedesktop.systemd.test", "ExitClient1")) {

                        r = sd_bus_reply_method_return(m, NULL);
                        if (r < 0) {
                                log_error_errno(r, "Failed to send reply: %m");
                                goto fail;
                        }

                        client1_gone = true;
                } else if (sd_bus_message_is_method_call(m, "org.freedesktop.systemd.test", "ExitClient2")) {

                        r = sd_bus_reply_method_return(m, NULL);
                        if (r < 0) {
                                log_error_errno(r, "Failed to send reply: %m");
                                goto fail;
                        }

                        client2_gone = true;
                } else if (sd_bus_message_is_method_call(m, "org.freedesktop.systemd.test", "Slow")) {

                        sleep(1);

                        r = sd_bus_reply_method_return(m, NULL);
                        if (r < 0) {
                                log_error_errno(r, "Failed to send reply: %m");
                                goto fail;
                        }

                } else if (sd_bus_message_is_method_call(m, "org.freedesktop.systemd.test", "FileDescriptor")) {
                        int fd;
                        static const char x = 'X';

                        r = sd_bus_message_read(m, "h", &fd);
                        if (r < 0) {
                                log_error_errno(r, "Failed to get parameter: %m");
                                goto fail;
                        }

                        log_info("Received fd=%d", fd);

                        if (write(fd, &x, 1) < 0) {
                                log_error_errno(errno, "Failed to write to fd: %m");
                                safe_close(fd);
                                goto fail;
                        }

                        r = sd_bus_reply_method_return(m, NULL);
                        if (r < 0) {
                                log_error_errno(r, "Failed to send reply: %m");
                                goto fail;
                        }

                } else if (sd_bus_message_is_method_call(m, NULL, NULL)) {

                        r = sd_bus_reply_method_error(
                                        m,
                                        &SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_UNKNOWN_METHOD, "Unknown method."));
                        if (r < 0) {
                                log_error_errno(r, "Failed to send reply: %m");
                                goto fail;
                        }
                }
        }

        r = 0;

fail:
        if (bus) {
                sd_bus_flush(bus);
                sd_bus_unref(bus);
        }

        return r;
}

static void* client1(void *p) {
        _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
        _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
        _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
        const char *hello;
        int r;
        _cleanup_close_pair_ int pp[2] = { -1, -1 };
        char x;

        r = sd_bus_open_user(&bus);
        if (r < 0) {
                log_error_errno(r, "Failed to connect to user bus: %m");
                goto finish;
        }

        r = sd_bus_call_method(
                        bus,
                        "org.freedesktop.systemd.test",
                        "/",
                        "org.freedesktop.systemd.test",
                        "LowerCase",
                        &error,
                        &reply,
                        "s",
                        "HELLO");
        if (r < 0) {
                log_error_errno(r, "Failed to issue method call: %m");
                goto finish;
        }

        r = sd_bus_message_read(reply, "s", &hello);
        if (r < 0) {
                log_error_errno(r, "Failed to get string: %m");
                goto finish;
        }

        assert_se(streq(hello, "hello"));

        if (pipe2(pp, O_CLOEXEC|O_NONBLOCK) < 0) {
                r = log_error_errno(errno, "Failed to allocate pipe: %m");
                goto finish;
        }

        log_info("Sending fd=%d", pp[1]);

        r = sd_bus_call_method(
                        bus,
                        "org.freedesktop.systemd.test",
                        "/",
                        "org.freedesktop.systemd.test",
                        "FileDescriptor",
                        &error,
                        NULL,
                        "h",
                        pp[1]);
        if (r < 0) {
                log_error_errno(r, "Failed to issue method call: %m");
                goto finish;
        }

        errno = 0;
        if (read(pp[0], &x, 1) <= 0) {
                log_error("Failed to read from pipe: %s", errno != 0 ? strerror_safe(errno) : "early read");
                goto finish;
        }

        r = 0;

finish:
        if (bus) {
                _cleanup_(sd_bus_message_unrefp) sd_bus_message *q = NULL;

                r = sd_bus_message_new_method_call(
                                bus,
                                &q,
                                "org.freedesktop.systemd.test",
                                "/",
                                "org.freedesktop.systemd.test",
                                "ExitClient1");
                if (r < 0)
                        log_error_errno(r, "Failed to allocate method call: %m");
                else
                        sd_bus_send(bus, q, NULL);

        }

        return INT_TO_PTR(r);
}

static int quit_callback(sd_bus_message *m, void *userdata, sd_bus_error *ret_error) {
        bool *x = userdata;

        log_error_errno(sd_bus_message_get_errno(m), "Quit callback: %m");

        *x = 1;
        return 1;
}

static void* client2(void *p) {
        _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL, *reply = NULL;
        _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
        _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
        bool quit = false;
        const char *mid;
        int r;

        r = sd_bus_open_user(&bus);
        if (r < 0) {
                log_error_errno(r, "Failed to connect to user bus: %m");
                goto finish;
        }

        r = sd_bus_message_new_method_call(
                        bus,
                        &m,
                        "org.freedesktop.systemd.test",
                        "/foo/bar/waldo/piep",
                        "org.object.test",
                        "Foobar");
        if (r < 0) {
                log_error_errno(r, "Failed to allocate method call: %m");
                goto finish;
        }

        r = sd_bus_send(bus, m, NULL);
        if (r < 0) {
                log_error("Failed to issue method call: %s", bus_error_message(&error, r));
                goto finish;
        }

        m = sd_bus_message_unref(m);

        r = sd_bus_message_new_signal(
                        bus,
                        &m,
                        "/foobar",
                        "foo.bar",
                        "Notify");
        if (r < 0) {
                log_error_errno(r, "Failed to allocate signal: %m");
                goto finish;
        }

        r = sd_bus_send(bus, m, NULL);
        if (r < 0) {
                log_error("Failed to issue signal: %s", bus_error_message(&error, r));
                goto finish;
        }

        m = sd_bus_message_unref(m);

        r = sd_bus_message_new_method_call(
                        bus,
                        &m,
                        "org.freedesktop.systemd.test",
                        "/",
                        "org.freedesktop.DBus.Peer",
                        "GetMachineId");
        if (r < 0) {
                log_error_errno(r, "Failed to allocate method call: %m");
                goto finish;
        }

        r = sd_bus_call(bus, m, 0, &error, &reply);
        if (r < 0) {
                log_error("Failed to issue method call: %s", bus_error_message(&error, r));
                goto finish;
        }

        r = sd_bus_message_read(reply, "s", &mid);
        if (r < 0) {
                log_error_errno(r, "Failed to parse machine ID: %m");
                goto finish;
        }

        log_info("Machine ID is %s.", mid);

        m = sd_bus_message_unref(m);

        r = sd_bus_message_new_method_call(
                        bus,
                        &m,
                        "org.freedesktop.systemd.test",
                        "/",
                        "org.freedesktop.systemd.test",
                        "Slow");
        if (r < 0) {
                log_error_errno(r, "Failed to allocate method call: %m");
                goto finish;
        }

        reply = sd_bus_message_unref(reply);

        r = sd_bus_call(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.");

        m = sd_bus_message_unref(m);

        r = sd_bus_message_new_method_call(
                        bus,
                        &m,
                        "org.freedesktop.systemd.test",
                        "/",
                        "org.freedesktop.systemd.test",
                        "Slow");
        if (r < 0) {
                log_error_errno(r, "Failed to allocate method call: %m");
                goto finish;
        }

        r = sd_bus_call_async(bus, NULL, m, quit_callback, &quit, 200 * USEC_PER_MSEC);
        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_errno(r, "Failed to process requests: %m");
                        goto finish;
                }
                if (r == 0) {
                        r = sd_bus_wait(bus, UINT64_MAX);
                        if (r < 0) {
                                log_error_errno(r, "Failed to wait: %m");
                                goto finish;
                        }
                }
        }

        r = 0;

finish:
        if (bus) {
                _cleanup_(sd_bus_message_unrefp) sd_bus_message *q = NULL;

                r = sd_bus_message_new_method_call(
                                bus,
                                &q,
                                "org.freedesktop.systemd.test",
                                "/",
                                "org.freedesktop.systemd.test",
                                "ExitClient2");
                if (r < 0) {
                        log_error_errno(r, "Failed to allocate method call: %m");
                        goto finish;
                }

                (void) sd_bus_send(bus, q, NULL);
        }

        return INT_TO_PTR(r);
}

int main(int argc, char *argv[]) {
        pthread_t c1, c2;
        sd_bus *bus;
        void *p;
        int q, r;

        test_setup_logging(LOG_INFO);

        r = server_init(&bus);
        if (r < 0)
                return log_tests_skipped("Failed to connect to bus");

        log_info("Initialized...");

        r = pthread_create(&c1, NULL, client1, bus);
        if (r != 0)
                return EXIT_FAILURE;

        r = pthread_create(&c2, NULL, client2, bus);
        if (r != 0)
                return EXIT_FAILURE;

        r = server(bus);

        q = pthread_join(c1, &p);
        if (q != 0)
                return EXIT_FAILURE;
        if (PTR_TO_INT(p) < 0)
                return EXIT_FAILURE;

        q = pthread_join(c2, &p);
        if (q != 0)
                return EXIT_FAILURE;
        if (PTR_TO_INT(p) < 0)
                return EXIT_FAILURE;

        if (r < 0)
                return EXIT_FAILURE;

        return EXIT_SUCCESS;
}
Commit	Line	Data
db9ecf05	1	/* SPDX-License-Identifier: LGPL-2.1-or-later */
89ffcd2a	2
cf0fbc49	3	#include <fcntl.h>
89ffcd2a	4	#include <pthread.h>
cf0fbc49	5	#include <stdlib.h>
e3017af9	6	#include <unistd.h>
89ffcd2a	7
89ffcd2a	8	#include "sd-bus.h"
07630cea	9
b5efdb8a	10	#include "alloc-util.h"
e3017af9	11	#include "bus-error.h"
392d5b37	12	#include "bus-internal.h"
07630cea	13	#include "bus-match.h"
4bbccb02	14	#include "errno-util.h"
cf0fbc49	15	#include "fd-util.h"
f97b34a6	16	#include "format-util.h"
07630cea LP	17	#include "log.h"
07630cea LP	18	#include "macro.h"
6969a671	19	#include "string-util.h"
317bb217	20	#include "tests.h"
07630cea	21	#include "util.h"
392d5b37	22
19070062	23	static int match_callback(sd_bus_message m, void userdata, sd_bus_error *ret_error) {
392d5b37 LP	24	log_info("Match triggered! interface=%s member=%s", strna(sd_bus_message_get_interface(m)), strna(sd_bus_message_get_member(m)));
	25	return 0;
	26	}
89ffcd2a	27
19070062	28	static int object_callback(sd_bus_message m, void userdata, sd_bus_error *ret_error) {
a652755d LP	29	int r;
a652755d LP	30
eb01ba5d	31	if (sd_bus_message_is_method_error(m, NULL))
a652755d LP	32	return 0;
	33
	34	if (sd_bus_message_is_method_call(m, "org.object.test", "Foobar")) {
a652755d LP	35	log_info("Invoked Foobar() on %s", sd_bus_message_get_path(m));
a652755d LP	36
df2d202e	37	r = sd_bus_reply_method_return(m, NULL);
f647962d MS	38	if (r < 0)
f647962d MS	39	return log_error_errno(r, "Failed to send reply: %m");
a652755d LP	40
	41	return 1;
	42	}
	43
	44	return 0;
	45	}
	46
89ffcd2a LP	47	static int server_init(sd_bus **_bus) {
89ffcd2a LP	48	sd_bus *bus = NULL;
d728d708	49	sd_id128_t id;
89ffcd2a	50	int r;
56fbd718	51	const char unique, desc;
89ffcd2a	52
0c0cdb06	53	assert_se(_bus);
89ffcd2a	54
56fbd718	55	r = sd_bus_open_user_with_description(&bus, "my bus!");
89ffcd2a	56	if (r < 0) {
da927ba9	57	log_error_errno(r, "Failed to connect to user bus: %m");
89ffcd2a LP	58	goto fail;
	59	}
	60
5c302692	61	r = sd_bus_get_bus_id(bus, &id);
d728d708	62	if (r < 0) {
da927ba9	63	log_error_errno(r, "Failed to get server ID: %m");
d728d708 LP	64	goto fail;
	65	}
	66
20902f3e LP	67	r = sd_bus_get_unique_name(bus, &unique);
20902f3e LP	68	if (r < 0) {
da927ba9	69	log_error_errno(r, "Failed to get unique name: %m");
20902f3e LP	70	goto fail;
	71	}
	72
90e207e4	73	assert_se(sd_bus_get_description(bus, &desc) >= 0);
56fbd718 ZJS	74	assert_se(streq(desc, "my bus!"));
56fbd718 ZJS	75
d728d708	76	log_info("Peer ID is " SD_ID128_FORMAT_STR ".", SD_ID128_FORMAT_VAL(id));
20902f3e	77	log_info("Unique ID: %s", unique);
d728d708	78	log_info("Can send file handles: %i", sd_bus_can_send(bus, 'h'));
d728d708	79
89ffcd2a LP	80	r = sd_bus_request_name(bus, "org.freedesktop.systemd.test", 0);
89ffcd2a LP	81	if (r < 0) {
da927ba9	82	log_error_errno(r, "Failed to acquire name: %m");
89ffcd2a LP	83	goto fail;
	84	}
	85
19befb2d	86	r = sd_bus_add_fallback(bus, NULL, "/foo/bar", object_callback, NULL);
a652755d	87	if (r < 0) {
da927ba9	88	log_error_errno(r, "Failed to add object: %m");
a652755d LP	89	goto fail;
	90	}
	91
75152a4d	92	r = sd_bus_match_signal(bus, NULL, NULL, NULL, "foo.bar", "Notify", match_callback, NULL);
392d5b37	93	if (r < 0) {
75152a4d	94	log_error_errno(r, "Failed to request match: %m");
392d5b37 LP	95	goto fail;
	96	}
	97
19befb2d	98	r = sd_bus_add_match(bus, NULL, "type='signal',interface='org.freedesktop.DBus',member='NameOwnerChanged'", match_callback, NULL);
392d5b37	99	if (r < 0) {
da927ba9	100	log_error_errno(r, "Failed to add match: %m");
392d5b37 LP	101	goto fail;
	102	}
	103
	104	bus_match_dump(&bus->match_callbacks, 0);
	105
89ffcd2a LP	106	*_bus = bus;
	107	return 0;
	108
	109	fail:
3e044c49	110	sd_bus_unref(bus);
89ffcd2a LP	111	return r;
	112	}
	113
e3017af9	114	static int server(sd_bus *bus) {
89ffcd2a	115	int r;
e3017af9	116	bool client1_gone = false, client2_gone = false;
89ffcd2a	117
e3017af9	118	while (!client1_gone \|\| !client2_gone) {
4afd3348	119	_cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
2571ead1	120	pid_t pid = 0;
4a875b61	121	const char *label = NULL;
89ffcd2a LP	122
	123	r = sd_bus_process(bus, &m);
	124	if (r < 0) {
da927ba9	125	log_error_errno(r, "Failed to process requests: %m");
89ffcd2a LP	126	goto fail;
89ffcd2a LP	127	}
e3017af9	128
89ffcd2a	129	if (r == 0) {
f5fbe71d	130	r = sd_bus_wait(bus, UINT64_MAX);
89ffcd2a	131	if (r < 0) {
da927ba9	132	log_error_errno(r, "Failed to wait: %m");
89ffcd2a LP	133	goto fail;
	134	}
	135
	136	continue;
	137	}
	138
e3017af9 LP	139	if (!m)
	140	continue;
	141
5b12334d LP	142	sd_bus_creds_get_pid(sd_bus_message_get_creds(m), &pid);
5b12334d LP	143	sd_bus_creds_get_selinux_context(sd_bus_message_get_creds(m), &label);
de0671ee	144	log_info("Got message! member=%s pid="PID_FMT" label=%s",
4a875b61	145	strna(sd_bus_message_get_member(m)),
de0671ee	146	pid,
4a875b61	147	strna(label));
2b4a65b6	148	/* sd_bus_message_dump(m); */
89ffcd2a LP	149	/* sd_bus_message_rewind(m, true); */
	150
	151	if (sd_bus_message_is_method_call(m, "org.freedesktop.systemd.test", "LowerCase")) {
	152	const char *hello;
	153	_cleanup_free_ char *lowercase = NULL;
	154
	155	r = sd_bus_message_read(m, "s", &hello);
	156	if (r < 0) {
da927ba9	157	log_error_errno(r, "Failed to get parameter: %m");
89ffcd2a LP	158	goto fail;
	159	}
	160
89ffcd2a LP	161	lowercase = strdup(hello);
	162	if (!lowercase) {
	163	r = log_oom();
	164	goto fail;
	165	}
	166
	167	ascii_strlower(lowercase);
	168
df2d202e	169	r = sd_bus_reply_method_return(m, "s", lowercase);
89ffcd2a	170	if (r < 0) {
da927ba9	171	log_error_errno(r, "Failed to send reply: %m");
89ffcd2a LP	172	goto fail;
89ffcd2a LP	173	}
e3017af9 LP	174	} else if (sd_bus_message_is_method_call(m, "org.freedesktop.systemd.test", "ExitClient1")) {
e3017af9 LP	175
df2d202e	176	r = sd_bus_reply_method_return(m, NULL);
e3017af9	177	if (r < 0) {
da927ba9	178	log_error_errno(r, "Failed to send reply: %m");
e3017af9 LP	179	goto fail;
	180	}
	181
	182	client1_gone = true;
	183	} else if (sd_bus_message_is_method_call(m, "org.freedesktop.systemd.test", "ExitClient2")) {
	184
df2d202e	185	r = sd_bus_reply_method_return(m, NULL);
e3017af9	186	if (r < 0) {
da927ba9	187	log_error_errno(r, "Failed to send reply: %m");
e3017af9 LP	188	goto fail;
	189	}
	190
	191	client2_gone = true;
	192	} else if (sd_bus_message_is_method_call(m, "org.freedesktop.systemd.test", "Slow")) {
	193
b7f247e0 LP	194	sleep(1);
b7f247e0 LP	195
df2d202e	196	r = sd_bus_reply_method_return(m, NULL);
e3017af9	197	if (r < 0) {
da927ba9	198	log_error_errno(r, "Failed to send reply: %m");
e3017af9 LP	199	goto fail;
	200	}
	201
2c93b4ef LP	202	} else if (sd_bus_message_is_method_call(m, "org.freedesktop.systemd.test", "FileDescriptor")) {
	203	int fd;
	204	static const char x = 'X';
	205
	206	r = sd_bus_message_read(m, "h", &fd);
	207	if (r < 0) {
da927ba9	208	log_error_errno(r, "Failed to get parameter: %m");
2c93b4ef LP	209	goto fail;
	210	}
	211
5a330cda ZJS	212	log_info("Received fd=%d", fd);
5a330cda ZJS	213
2c93b4ef	214	if (write(fd, &x, 1) < 0) {
56f64d95	215	log_error_errno(errno, "Failed to write to fd: %m");
03e334a1	216	safe_close(fd);
2c93b4ef LP	217	goto fail;
	218	}
	219
df2d202e	220	r = sd_bus_reply_method_return(m, NULL);
2c93b4ef	221	if (r < 0) {
da927ba9	222	log_error_errno(r, "Failed to send reply: %m");
2c93b4ef LP	223	goto fail;
	224	}
	225
e3017af9	226	} else if (sd_bus_message_is_method_call(m, NULL, NULL)) {
89ffcd2a	227
d4100e24	228	r = sd_bus_reply_method_error(
df2d202e	229	m,
14c24659	230	&SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_UNKNOWN_METHOD, "Unknown method."));
89ffcd2a	231	if (r < 0) {
da927ba9	232	log_error_errno(r, "Failed to send reply: %m");
89ffcd2a LP	233	goto fail;
	234	}
	235	}
	236	}
	237
	238	r = 0;
	239
	240	fail:
e3017af9 LP	241	if (bus) {
e3017af9 LP	242	sd_bus_flush(bus);
89ffcd2a	243	sd_bus_unref(bus);
e3017af9	244	}
89ffcd2a	245
e3017af9	246	return r;
89ffcd2a LP	247	}
89ffcd2a LP	248
f2a3de01	249	static void* client1(void *p) {
4afd3348 LP	250	_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
	251	_cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
	252	_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
89ffcd2a LP	253	const char *hello;
89ffcd2a LP	254	int r;
0e851143	255	_cleanup_close_pair_ int pp[2] = { -1, -1 };
2c93b4ef	256	char x;
89ffcd2a LP	257
	258	r = sd_bus_open_user(&bus);
	259	if (r < 0) {
da927ba9	260	log_error_errno(r, "Failed to connect to user bus: %m");
89ffcd2a LP	261	goto finish;
	262	}
	263
d4100e24	264	r = sd_bus_call_method(
89ffcd2a LP	265	bus,
	266	"org.freedesktop.systemd.test",
	267	"/",
	268	"org.freedesktop.systemd.test",
	269	"LowerCase",
d4100e24 LP	270	&error,
	271	&reply,
	272	"s",
	273	"HELLO");
89ffcd2a	274	if (r < 0) {
da927ba9	275	log_error_errno(r, "Failed to issue method call: %m");
89ffcd2a LP	276	goto finish;
	277	}
	278
	279	r = sd_bus_message_read(reply, "s", &hello);
	280	if (r < 0) {
da927ba9	281	log_error_errno(r, "Failed to get string: %m");
89ffcd2a LP	282	goto finish;
	283	}
	284
0c0cdb06	285	assert_se(streq(hello, "hello"));
89ffcd2a	286
2c93b4ef	287	if (pipe2(pp, O_CLOEXEC\|O_NONBLOCK) < 0) {
d7a0f1f4	288	r = log_error_errno(errno, "Failed to allocate pipe: %m");
2c93b4ef LP	289	goto finish;
	290	}
	291
5a330cda ZJS	292	log_info("Sending fd=%d", pp[1]);
5a330cda ZJS	293
b7f247e0	294	r = sd_bus_call_method(
2c93b4ef LP	295	bus,
	296	"org.freedesktop.systemd.test",
	297	"/",
	298	"org.freedesktop.systemd.test",
	299	"FileDescriptor",
b7f247e0 LP	300	&error,
	301	NULL,
	302	"h",
	303	pp[1]);
2c93b4ef	304	if (r < 0) {
da927ba9	305	log_error_errno(r, "Failed to issue method call: %m");
2c93b4ef LP	306	goto finish;
	307	}
	308
	309	errno = 0;
	310	if (read(pp[0], &x, 1) <= 0) {
4bbccb02	311	log_error("Failed to read from pipe: %s", errno != 0 ? strerror_safe(errno) : "early read");
2c93b4ef LP	312	goto finish;
	313	}
	314
89ffcd2a LP	315	r = 0;
	316
	317	finish:
	318	if (bus) {
b9c54c46	319	_cleanup_(sd_bus_message_unrefp) sd_bus_message *q = NULL;
89ffcd2a LP	320
	321	r = sd_bus_message_new_method_call(
	322	bus,
151b9b96	323	&q,
89ffcd2a LP	324	"org.freedesktop.systemd.test",
	325	"/",
	326	"org.freedesktop.systemd.test",
151b9b96	327	"ExitClient1");
b7f247e0	328	if (r < 0)
da927ba9	329	log_error_errno(r, "Failed to allocate method call: %m");
b7f247e0 LP	330	else
b7f247e0 LP	331	sd_bus_send(bus, q, NULL);
89ffcd2a	332
89ffcd2a LP	333	}
89ffcd2a LP	334
e3017af9 LP	335	return INT_TO_PTR(r);
	336	}
	337
19070062	338	static int quit_callback(sd_bus_message m, void userdata, sd_bus_error *ret_error) {
e3017af9 LP	339	bool *x = userdata;
e3017af9 LP	340
9eec7d12	341	log_error_errno(sd_bus_message_get_errno(m), "Quit callback: %m");
e3017af9 LP	342
	343	*x = 1;
	344	return 1;
	345	}
	346
f2a3de01	347	static void* client2(void *p) {
4afd3348 LP	348	_cleanup_(sd_bus_message_unrefp) sd_bus_message m = NULL, reply = NULL;
	349	_cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
	350	_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
e3017af9	351	bool quit = false;
b9bf7e2b LP	352	const char *mid;
b9bf7e2b LP	353	int r;
e3017af9 LP	354
	355	r = sd_bus_open_user(&bus);
	356	if (r < 0) {
da927ba9	357	log_error_errno(r, "Failed to connect to user bus: %m");
e3017af9 LP	358	goto finish;
	359	}
	360
a652755d LP	361	r = sd_bus_message_new_method_call(
a652755d LP	362	bus,
151b9b96	363	&m,
a652755d LP	364	"org.freedesktop.systemd.test",
	365	"/foo/bar/waldo/piep",
	366	"org.object.test",
151b9b96	367	"Foobar");
a652755d	368	if (r < 0) {
da927ba9	369	log_error_errno(r, "Failed to allocate method call: %m");
a652755d LP	370	goto finish;
	371	}
	372
	373	r = sd_bus_send(bus, m, NULL);
	374	if (r < 0) {
2a03b9ed	375	log_error("Failed to issue method call: %s", bus_error_message(&error, r));
a652755d LP	376	goto finish;
	377	}
	378
0e851143	379	m = sd_bus_message_unref(m);
a652755d	380
392d5b37 LP	381	r = sd_bus_message_new_signal(
392d5b37 LP	382	bus,
151b9b96	383	&m,
392d5b37 LP	384	"/foobar",
392d5b37 LP	385	"foo.bar",
151b9b96	386	"Notify");
392d5b37	387	if (r < 0) {
da927ba9	388	log_error_errno(r, "Failed to allocate signal: %m");
392d5b37 LP	389	goto finish;
	390	}
	391
	392	r = sd_bus_send(bus, m, NULL);
	393	if (r < 0) {
2a03b9ed	394	log_error("Failed to issue signal: %s", bus_error_message(&error, r));
392d5b37 LP	395	goto finish;
	396	}
	397
0e851143	398	m = sd_bus_message_unref(m);
392d5b37	399
b9bf7e2b LP	400	r = sd_bus_message_new_method_call(
b9bf7e2b LP	401	bus,
151b9b96	402	&m,
b9bf7e2b LP	403	"org.freedesktop.systemd.test",
	404	"/",
	405	"org.freedesktop.DBus.Peer",
151b9b96	406	"GetMachineId");
b9bf7e2b	407	if (r < 0) {
da927ba9	408	log_error_errno(r, "Failed to allocate method call: %m");
b9bf7e2b LP	409	goto finish;
	410	}
	411
c49b30a2	412	r = sd_bus_call(bus, m, 0, &error, &reply);
b9bf7e2b	413	if (r < 0) {
2a03b9ed	414	log_error("Failed to issue method call: %s", bus_error_message(&error, r));
b9bf7e2b LP	415	goto finish;
	416	}
	417
	418	r = sd_bus_message_read(reply, "s", &mid);
	419	if (r < 0) {
da927ba9	420	log_error_errno(r, "Failed to parse machine ID: %m");
b9bf7e2b LP	421	goto finish;
	422	}
	423
	424	log_info("Machine ID is %s.", mid);
	425
0e851143	426	m = sd_bus_message_unref(m);
b9bf7e2b	427
e3017af9 LP	428	r = sd_bus_message_new_method_call(
e3017af9 LP	429	bus,
151b9b96	430	&m,
e3017af9 LP	431	"org.freedesktop.systemd.test",
	432	"/",
	433	"org.freedesktop.systemd.test",
151b9b96	434	"Slow");
e3017af9	435	if (r < 0) {
da927ba9	436	log_error_errno(r, "Failed to allocate method call: %m");
e3017af9 LP	437	goto finish;
	438	}
	439
0e851143	440	reply = sd_bus_message_unref(reply);
b9bf7e2b	441
c49b30a2	442	r = sd_bus_call(bus, m, 200 * USEC_PER_MSEC, &error, &reply);
e3017af9	443	if (r < 0)
2a03b9ed	444	log_info("Failed to issue method call: %s", bus_error_message(&error, r));
e3017af9 LP	445	else
	446	log_info("Slow call succeed.");
	447
0e851143	448	m = sd_bus_message_unref(m);
e3017af9 LP	449
	450	r = sd_bus_message_new_method_call(
	451	bus,
151b9b96	452	&m,
e3017af9 LP	453	"org.freedesktop.systemd.test",
	454	"/",
	455	"org.freedesktop.systemd.test",
151b9b96	456	"Slow");
e3017af9	457	if (r < 0) {
da927ba9	458	log_error_errno(r, "Failed to allocate method call: %m");
e3017af9 LP	459	goto finish;
	460	}
	461
19befb2d	462	r = sd_bus_call_async(bus, NULL, m, quit_callback, &quit, 200 * USEC_PER_MSEC);
e3017af9	463	if (r < 0) {
2a03b9ed	464	log_info("Failed to issue method call: %s", bus_error_message(&error, r));
e3017af9 LP	465	goto finish;
	466	}
	467
	468	while (!quit) {
	469	r = sd_bus_process(bus, NULL);
	470	if (r < 0) {
da927ba9	471	log_error_errno(r, "Failed to process requests: %m");
e3017af9 LP	472	goto finish;
	473	}
	474	if (r == 0) {
f5fbe71d	475	r = sd_bus_wait(bus, UINT64_MAX);
e3017af9	476	if (r < 0) {
da927ba9	477	log_error_errno(r, "Failed to wait: %m");
e3017af9 LP	478	goto finish;
	479	}
	480	}
	481	}
	482
	483	r = 0;
	484
	485	finish:
	486	if (bus) {
b9c54c46	487	_cleanup_(sd_bus_message_unrefp) sd_bus_message *q = NULL;
e3017af9 LP	488
	489	r = sd_bus_message_new_method_call(
	490	bus,
151b9b96	491	&q,
e3017af9 LP	492	"org.freedesktop.systemd.test",
	493	"/",
	494	"org.freedesktop.systemd.test",
151b9b96	495	"ExitClient2");
e3017af9	496	if (r < 0) {
da927ba9	497	log_error_errno(r, "Failed to allocate method call: %m");
e3017af9 LP	498	goto finish;
	499	}
	500
0e851143	501	(void) sd_bus_send(bus, q, NULL);
e3017af9 LP	502	}
e3017af9 LP	503
e3017af9	504	return INT_TO_PTR(r);
89ffcd2a LP	505	}
	506
	507	int main(int argc, char *argv[]) {
e3017af9	508	pthread_t c1, c2;
89ffcd2a LP	509	sd_bus *bus;
	510	void *p;
	511	int q, r;
	512
6d7c4033 ZJS	513	test_setup_logging(LOG_INFO);
6d7c4033 ZJS	514
89ffcd2a	515	r = server_init(&bus);
317bb217 ZJS	516	if (r < 0)
317bb217 ZJS	517	return log_tests_skipped("Failed to connect to bus");
89ffcd2a	518
e3017af9 LP	519	log_info("Initialized...");
	520
	521	r = pthread_create(&c1, NULL, client1, bus);
	522	if (r != 0)
89ffcd2a	523	return EXIT_FAILURE;
89ffcd2a	524
e3017af9 LP	525	r = pthread_create(&c2, NULL, client2, bus);
	526	if (r != 0)
	527	return EXIT_FAILURE;
89ffcd2a	528
e3017af9 LP	529	r = server(bus);
	530
	531	q = pthread_join(c1, &p);
	532	if (q != 0)
	533	return EXIT_FAILURE;
2181a7f5 LP	534	if (PTR_TO_INT(p) < 0)
	535	return EXIT_FAILURE;
	536
e3017af9	537	q = pthread_join(c2, &p);
89ffcd2a LP	538	if (q != 0)
89ffcd2a LP	539	return EXIT_FAILURE;
2181a7f5 LP	540	if (PTR_TO_INT(p) < 0)
	541	return EXIT_FAILURE;
	542
89ffcd2a LP	543	if (r < 0)
	544	return EXIT_FAILURE;
	545
	546	return EXIT_SUCCESS;
	547	}