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

/* SPDX-License-Identifier: LGPL-2.1+ */

#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 "bus-util.h"
#include "fd-util.h"
#include "format-util.h"
#include "log.h"
#include "macro.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;
        }

        r = sd_bus_get_description(bus, &desc);
        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_t) -1);
                        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));
                /* 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) {
                log_error_errno(errno, "Failed to allocate pipe: %m");
                r = -errno;
                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 ? strerror(errno) : "early read");
                goto finish;
        }

        r = 0;

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

                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_t) -1);
                        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;

                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
53e1b683	1	/* SPDX-License-Identifier: LGPL-2.1+ */
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"
057171ef	14	#include "bus-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"
317bb217	19	#include "tests.h"
07630cea	20	#include "util.h"
392d5b37	21
19070062	22	static int match_callback(sd_bus_message m, void userdata, sd_bus_error *ret_error) {
392d5b37 LP	23	log_info("Match triggered! interface=%s member=%s", strna(sd_bus_message_get_interface(m)), strna(sd_bus_message_get_member(m)));
	24	return 0;
	25	}
89ffcd2a	26
19070062	27	static int object_callback(sd_bus_message m, void userdata, sd_bus_error *ret_error) {
a652755d LP	28	int r;
a652755d LP	29
eb01ba5d	30	if (sd_bus_message_is_method_error(m, NULL))
a652755d LP	31	return 0;
	32
	33	if (sd_bus_message_is_method_call(m, "org.object.test", "Foobar")) {
a652755d LP	34	log_info("Invoked Foobar() on %s", sd_bus_message_get_path(m));
a652755d LP	35
df2d202e	36	r = sd_bus_reply_method_return(m, NULL);
f647962d MS	37	if (r < 0)
f647962d MS	38	return log_error_errno(r, "Failed to send reply: %m");
a652755d LP	39
	40	return 1;
	41	}
	42
	43	return 0;
	44	}
	45
89ffcd2a LP	46	static int server_init(sd_bus **_bus) {
89ffcd2a LP	47	sd_bus *bus = NULL;
d728d708	48	sd_id128_t id;
89ffcd2a	49	int r;
56fbd718	50	const char unique, desc;
89ffcd2a	51
0c0cdb06	52	assert_se(_bus);
89ffcd2a	53
56fbd718	54	r = sd_bus_open_user_with_description(&bus, "my bus!");
89ffcd2a	55	if (r < 0) {
da927ba9	56	log_error_errno(r, "Failed to connect to user bus: %m");
89ffcd2a LP	57	goto fail;
	58	}
	59
5c302692	60	r = sd_bus_get_bus_id(bus, &id);
d728d708	61	if (r < 0) {
da927ba9	62	log_error_errno(r, "Failed to get server ID: %m");
d728d708 LP	63	goto fail;
	64	}
	65
20902f3e LP	66	r = sd_bus_get_unique_name(bus, &unique);
20902f3e LP	67	if (r < 0) {
da927ba9	68	log_error_errno(r, "Failed to get unique name: %m");
20902f3e LP	69	goto fail;
	70	}
	71
56fbd718 ZJS	72	r = sd_bus_get_description(bus, &desc);
	73	assert_se(streq(desc, "my bus!"));
	74
d728d708	75	log_info("Peer ID is " SD_ID128_FORMAT_STR ".", SD_ID128_FORMAT_VAL(id));
20902f3e	76	log_info("Unique ID: %s", unique);
d728d708	77	log_info("Can send file handles: %i", sd_bus_can_send(bus, 'h'));
d728d708	78
89ffcd2a LP	79	r = sd_bus_request_name(bus, "org.freedesktop.systemd.test", 0);
89ffcd2a LP	80	if (r < 0) {
da927ba9	81	log_error_errno(r, "Failed to acquire name: %m");
89ffcd2a LP	82	goto fail;
	83	}
	84
19befb2d	85	r = sd_bus_add_fallback(bus, NULL, "/foo/bar", object_callback, NULL);
a652755d	86	if (r < 0) {
da927ba9	87	log_error_errno(r, "Failed to add object: %m");
a652755d LP	88	goto fail;
	89	}
	90
75152a4d	91	r = sd_bus_match_signal(bus, NULL, NULL, NULL, "foo.bar", "Notify", match_callback, NULL);
392d5b37	92	if (r < 0) {
75152a4d	93	log_error_errno(r, "Failed to request match: %m");
392d5b37 LP	94	goto fail;
	95	}
	96
19befb2d	97	r = sd_bus_add_match(bus, NULL, "type='signal',interface='org.freedesktop.DBus',member='NameOwnerChanged'", match_callback, NULL);
392d5b37	98	if (r < 0) {
da927ba9	99	log_error_errno(r, "Failed to add match: %m");
392d5b37 LP	100	goto fail;
	101	}
	102
	103	bus_match_dump(&bus->match_callbacks, 0);
	104
89ffcd2a LP	105	*_bus = bus;
	106	return 0;
	107
	108	fail:
3e044c49	109	sd_bus_unref(bus);
89ffcd2a LP	110	return r;
	111	}
	112
e3017af9	113	static int server(sd_bus *bus) {
89ffcd2a	114	int r;
e3017af9	115	bool client1_gone = false, client2_gone = false;
89ffcd2a	116
e3017af9	117	while (!client1_gone \|\| !client2_gone) {
4afd3348	118	_cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
2571ead1	119	pid_t pid = 0;
4a875b61	120	const char *label = NULL;
89ffcd2a LP	121
	122	r = sd_bus_process(bus, &m);
	123	if (r < 0) {
da927ba9	124	log_error_errno(r, "Failed to process requests: %m");
89ffcd2a LP	125	goto fail;
89ffcd2a LP	126	}
e3017af9	127
89ffcd2a LP	128	if (r == 0) {
	129	r = sd_bus_wait(bus, (uint64_t) -1);
	130	if (r < 0) {
da927ba9	131	log_error_errno(r, "Failed to wait: %m");
89ffcd2a LP	132	goto fail;
	133	}
	134
	135	continue;
	136	}
	137
e3017af9 LP	138	if (!m)
	139	continue;
	140
5b12334d LP	141	sd_bus_creds_get_pid(sd_bus_message_get_creds(m), &pid);
5b12334d LP	142	sd_bus_creds_get_selinux_context(sd_bus_message_get_creds(m), &label);
de0671ee	143	log_info("Got message! member=%s pid="PID_FMT" label=%s",
4a875b61	144	strna(sd_bus_message_get_member(m)),
de0671ee	145	pid,
4a875b61	146	strna(label));
89ffcd2a LP	147	/* bus_message_dump(m); */
	148	/* sd_bus_message_rewind(m, true); */
	149
	150	if (sd_bus_message_is_method_call(m, "org.freedesktop.systemd.test", "LowerCase")) {
	151	const char *hello;
	152	_cleanup_free_ char *lowercase = NULL;
	153
	154	r = sd_bus_message_read(m, "s", &hello);
	155	if (r < 0) {
da927ba9	156	log_error_errno(r, "Failed to get parameter: %m");
89ffcd2a LP	157	goto fail;
	158	}
	159
89ffcd2a LP	160	lowercase = strdup(hello);
	161	if (!lowercase) {
	162	r = log_oom();
	163	goto fail;
	164	}
	165
	166	ascii_strlower(lowercase);
	167
df2d202e	168	r = sd_bus_reply_method_return(m, "s", lowercase);
89ffcd2a	169	if (r < 0) {
da927ba9	170	log_error_errno(r, "Failed to send reply: %m");
89ffcd2a LP	171	goto fail;
89ffcd2a LP	172	}
e3017af9 LP	173	} else if (sd_bus_message_is_method_call(m, "org.freedesktop.systemd.test", "ExitClient1")) {
e3017af9 LP	174
df2d202e	175	r = sd_bus_reply_method_return(m, NULL);
e3017af9	176	if (r < 0) {
da927ba9	177	log_error_errno(r, "Failed to send reply: %m");
e3017af9 LP	178	goto fail;
	179	}
	180
	181	client1_gone = true;
	182	} else if (sd_bus_message_is_method_call(m, "org.freedesktop.systemd.test", "ExitClient2")) {
	183
df2d202e	184	r = sd_bus_reply_method_return(m, NULL);
e3017af9	185	if (r < 0) {
da927ba9	186	log_error_errno(r, "Failed to send reply: %m");
e3017af9 LP	187	goto fail;
	188	}
	189
	190	client2_gone = true;
	191	} else if (sd_bus_message_is_method_call(m, "org.freedesktop.systemd.test", "Slow")) {
	192
b7f247e0 LP	193	sleep(1);
b7f247e0 LP	194
df2d202e	195	r = sd_bus_reply_method_return(m, NULL);
e3017af9	196	if (r < 0) {
da927ba9	197	log_error_errno(r, "Failed to send reply: %m");
e3017af9 LP	198	goto fail;
	199	}
	200
2c93b4ef LP	201	} else if (sd_bus_message_is_method_call(m, "org.freedesktop.systemd.test", "FileDescriptor")) {
	202	int fd;
	203	static const char x = 'X';
	204
	205	r = sd_bus_message_read(m, "h", &fd);
	206	if (r < 0) {
da927ba9	207	log_error_errno(r, "Failed to get parameter: %m");
2c93b4ef LP	208	goto fail;
	209	}
	210
5a330cda ZJS	211	log_info("Received fd=%d", fd);
5a330cda ZJS	212
2c93b4ef	213	if (write(fd, &x, 1) < 0) {
56f64d95	214	log_error_errno(errno, "Failed to write to fd: %m");
03e334a1	215	safe_close(fd);
2c93b4ef LP	216	goto fail;
	217	}
	218
df2d202e	219	r = sd_bus_reply_method_return(m, NULL);
2c93b4ef	220	if (r < 0) {
da927ba9	221	log_error_errno(r, "Failed to send reply: %m");
2c93b4ef LP	222	goto fail;
	223	}
	224
e3017af9	225	} else if (sd_bus_message_is_method_call(m, NULL, NULL)) {
89ffcd2a	226
d4100e24	227	r = sd_bus_reply_method_error(
df2d202e	228	m,
14c24659	229	&SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_UNKNOWN_METHOD, "Unknown method."));
89ffcd2a	230	if (r < 0) {
da927ba9	231	log_error_errno(r, "Failed to send reply: %m");
89ffcd2a LP	232	goto fail;
	233	}
	234	}
	235	}
	236
	237	r = 0;
	238
	239	fail:
e3017af9 LP	240	if (bus) {
e3017af9 LP	241	sd_bus_flush(bus);
89ffcd2a	242	sd_bus_unref(bus);
e3017af9	243	}
89ffcd2a	244
e3017af9	245	return r;
89ffcd2a LP	246	}
89ffcd2a LP	247
f2a3de01	248	static void* client1(void *p) {
4afd3348 LP	249	_cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
	250	_cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
	251	_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
89ffcd2a LP	252	const char *hello;
89ffcd2a LP	253	int r;
0e851143	254	_cleanup_close_pair_ int pp[2] = { -1, -1 };
2c93b4ef	255	char x;
89ffcd2a LP	256
	257	r = sd_bus_open_user(&bus);
	258	if (r < 0) {
da927ba9	259	log_error_errno(r, "Failed to connect to user bus: %m");
89ffcd2a LP	260	goto finish;
	261	}
	262
d4100e24	263	r = sd_bus_call_method(
89ffcd2a LP	264	bus,
	265	"org.freedesktop.systemd.test",
	266	"/",
	267	"org.freedesktop.systemd.test",
	268	"LowerCase",
d4100e24 LP	269	&error,
	270	&reply,
	271	"s",
	272	"HELLO");
89ffcd2a	273	if (r < 0) {
da927ba9	274	log_error_errno(r, "Failed to issue method call: %m");
89ffcd2a LP	275	goto finish;
	276	}
	277
	278	r = sd_bus_message_read(reply, "s", &hello);
	279	if (r < 0) {
da927ba9	280	log_error_errno(r, "Failed to get string: %m");
89ffcd2a LP	281	goto finish;
	282	}
	283
0c0cdb06	284	assert_se(streq(hello, "hello"));
89ffcd2a	285
2c93b4ef	286	if (pipe2(pp, O_CLOEXEC\|O_NONBLOCK) < 0) {
56f64d95	287	log_error_errno(errno, "Failed to allocate pipe: %m");
2c93b4ef LP	288	r = -errno;
	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) {
	311	log_error("Failed to read from pipe: %s", errno ? strerror(errno) : "early read");
	312	goto finish;
	313	}
	314
89ffcd2a LP	315	r = 0;
	316
	317	finish:
	318	if (bus) {
4afd3348	319	_cleanup_(sd_bus_message_unrefp) sd_bus_message *q;
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) {
	375	log_error("Failed to issue method call: %s", bus_error_message(&error, -r));
	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) {
	394	log_error("Failed to issue signal: %s", bus_error_message(&error, -r));
	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 LP	413	if (r < 0) {
	414	log_error("Failed to issue method call: %s", bus_error_message(&error, -r));
	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 LP	443	if (r < 0)
	444	log_info("Failed to issue method call: %s", bus_error_message(&error, -r));
	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 LP	463	if (r < 0) {
	464	log_info("Failed to issue method call: %s", bus_error_message(&error, -r));
	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) {
	475	r = sd_bus_wait(bus, (uint64_t) -1);
	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) {
4afd3348	487	_cleanup_(sd_bus_message_unrefp) sd_bus_message *q;
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	}