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

/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/

/***
  This file is part of systemd.

  Copyright 2013 Lennart Poettering

  systemd is free software; you can redistribute it and/or modify it
  under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation; either version 2.1 of the License, or
  (at your option) any later version.

  systemd is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License
  along with systemd; If not, see <http://www.gnu.org/licenses/>.
***/

#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;
        sd_id128_t id;
        int r;
        const char *unique;

        assert(_bus);

        r = sd_bus_open_user(&bus);
        if (r < 0) {
                log_error("Failed to connect to user bus: %s", strerror(-r));
                goto fail;
        }

        r = sd_bus_get_peer(bus, &id);
        if (r < 0) {
                log_error("Failed to get peer ID: %s", strerror(-r));
                goto fail;
        }

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

        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("Failed to acquire name: %s", strerror(-r));
                goto fail;
        }

        *_bus = bus;
        return 0;

fail:
        if (bus)
                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_bus_message_unref_ sd_bus_message *m = NULL, *reply = NULL;
                pid_t pid = 0;

                r = sd_bus_process(bus, &m);
                if (r < 0) {
                        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) {
                                log_error("Failed to wait: %s", strerror(-r));
                                goto fail;
                        }

                        continue;
                }

                if (!m)
                        continue;

                sd_bus_message_get_pid(m, &pid);
                log_info("Got message! member=%s pid=%lu label=%s", strna(sd_bus_message_get_member(m)), (unsigned long) pid, strna(sd_bus_message_get_label(m)));
                /* 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("Failed to get parameter: %s", strerror(-r));
                                goto fail;
                        }

                        r = sd_bus_message_new_method_return(bus, m, &reply);
                        if (r < 0) {
                                log_error("Failed to allocate return: %s", strerror(-r));
                                goto fail;
                        }

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

                        ascii_strlower(lowercase);

                        r = sd_bus_message_append(reply, "s", lowercase);
                        if (r < 0) {
                                log_error("Failed to append message: %s", strerror(-r));
                                goto fail;
                        }
                } 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);
                        if (r < 0) {
                                log_error("Failed to allocate return: %s", strerror(-r));
                                goto fail;
                        }
                }

                if (reply) {
                        r = sd_bus_send(bus, reply, NULL);
                        if (r < 0) {
                                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) {
                sd_bus_flush(bus);
                sd_bus_unref(bus);
        }

        return r;
}

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;
        const char *hello;
        int r;

        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",
                        "LowerCase",
                        &m);
        if (r < 0) {
                log_error("Failed to allocate method call: %s", strerror(-r));
                goto finish;
        }

        r = sd_bus_message_append(m, "s", "HELLO");
        if (r < 0) {
                log_error("Failed to append string: %s", strerror(-r));
                goto finish;
        }

        r = sd_bus_send_with_reply_and_block(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", &hello);
        if (r < 0) {
                log_error("Failed to get string: %s", strerror(-r));
                goto finish;
        }

        assert(streq(hello, "hello"));

        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",
                                "ExitClient1",
                                &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);
}

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;
        bool quit = false;
        const char *mid;
        int r;

        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.DBus.Peer",
                        "GetMachineId",
                        &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, 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("Failed to parse machine ID: %s", strerror(-r));
                goto finish;
        }

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

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

        sd_bus_message_unref(reply);
        reply = NULL;

        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 c1, c2;
        sd_bus *bus;
        void *p;
        int q, r;

        r = server_init(&bus);
        if (r < 0)
                return EXIT_FAILURE;

        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;
        q = pthread_join(c2, &p);
        if (q != 0)
                return EXIT_FAILURE;
        if (r < 0)
                return EXIT_FAILURE;

        return EXIT_SUCCESS;
}
Commit	Line	Data
	1	/-- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil --/
	2
	3	/***
	4	This file is part of systemd.
	5
	6	Copyright 2013 Lennart Poettering
	7
	8	systemd is free software; you can redistribute it and/or modify it
	9	under the terms of the GNU Lesser General Public License as published by
	10	the Free Software Foundation; either version 2.1 of the License, or
	11	(at your option) any later version.
	12
	13	systemd is distributed in the hope that it will be useful, but
	14	WITHOUT ANY WARRANTY; without even the implied warranty of
	15	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	16	Lesser General Public License for more details.
	17
	18	You should have received a copy of the GNU Lesser General Public License
	19	along with systemd; If not, see <http://www.gnu.org/licenses/>.
	20	***/
	21
	22	#include <assert.h>
	23	#include <stdlib.h>
	24	#include <pthread.h>
	25	#include <unistd.h>
	26
	27	#include "log.h"
	28	#include "util.h"
	29
	30	#include "sd-bus.h"
	31	#include "bus-message.h"
	32	#include "bus-error.h"
	33
	34	static int server_init(sd_bus **_bus) {
	35	sd_bus *bus = NULL;
	36	sd_id128_t id;
	37	int r;
	38	const char *unique;
	39
	40	assert(_bus);
	41
	42	r = sd_bus_open_user(&bus);
	43	if (r < 0) {
	44	log_error("Failed to connect to user bus: %s", strerror(-r));
	45	goto fail;
	46	}
	47
	48	r = sd_bus_get_peer(bus, &id);
	49	if (r < 0) {
	50	log_error("Failed to get peer ID: %s", strerror(-r));
	51	goto fail;
	52	}
	53
	54	r = sd_bus_get_unique_name(bus, &unique);
	55	if (r < 0) {
	56	log_error("Failed to get unique name: %s", strerror(-r));
	57	goto fail;
	58	}
	59
	60	log_info("Peer ID is " SD_ID128_FORMAT_STR ".", SD_ID128_FORMAT_VAL(id));
	61	log_info("Unique ID: %s", unique);
	62	log_info("Can send file handles: %i", sd_bus_can_send(bus, 'h'));
	63
	64	r = sd_bus_request_name(bus, "org.freedesktop.systemd.test", 0);
	65	if (r < 0) {
	66	log_error("Failed to acquire name: %s", strerror(-r));
	67	goto fail;
	68	}
	69
	70	*_bus = bus;
	71	return 0;
	72
	73	fail:
	74	if (bus)
	75	sd_bus_unref(bus);
	76
	77	return r;
	78	}
	79
	80	static int server(sd_bus *bus) {
	81	int r;
	82	bool client1_gone = false, client2_gone = false;
	83
	84	while (!client1_gone \|\| !client2_gone) {
	85	_cleanup_bus_message_unref_ sd_bus_message m = NULL, reply = NULL;
	86	pid_t pid = 0;
	87
	88	r = sd_bus_process(bus, &m);
	89	if (r < 0) {
	90	log_error("Failed to process requests: %s", strerror(-r));
	91	goto fail;
	92	}
	93
	94	if (r == 0) {
	95	r = sd_bus_wait(bus, (uint64_t) -1);
	96	if (r < 0) {
	97	log_error("Failed to wait: %s", strerror(-r));
	98	goto fail;
	99	}
	100
	101	continue;
	102	}
	103
	104	if (!m)
	105	continue;
	106
	107	sd_bus_message_get_pid(m, &pid);
	108	log_info("Got message! member=%s pid=%lu label=%s", strna(sd_bus_message_get_member(m)), (unsigned long) pid, strna(sd_bus_message_get_label(m)));
	109	/* bus_message_dump(m); */
	110	/* sd_bus_message_rewind(m, true); */
	111
	112	if (sd_bus_message_is_method_call(m, "org.freedesktop.systemd.test", "LowerCase")) {
	113	const char *hello;
	114	_cleanup_free_ char *lowercase = NULL;
	115
	116	r = sd_bus_message_read(m, "s", &hello);
	117	if (r < 0) {
	118	log_error("Failed to get parameter: %s", strerror(-r));
	119	goto fail;
	120	}
	121
	122	r = sd_bus_message_new_method_return(bus, m, &reply);
	123	if (r < 0) {
	124	log_error("Failed to allocate return: %s", strerror(-r));
	125	goto fail;
	126	}
	127
	128	lowercase = strdup(hello);
	129	if (!lowercase) {
	130	r = log_oom();
	131	goto fail;
	132	}
	133
	134	ascii_strlower(lowercase);
	135
	136	r = sd_bus_message_append(reply, "s", lowercase);
	137	if (r < 0) {
	138	log_error("Failed to append message: %s", strerror(-r));
	139	goto fail;
	140	}
	141	} else if (sd_bus_message_is_method_call(m, "org.freedesktop.systemd.test", "ExitClient1")) {
	142
	143	r = sd_bus_message_new_method_return(bus, m, &reply);
	144	if (r < 0) {
	145	log_error("Failed to allocate return: %s", strerror(-r));
	146	goto fail;
	147	}
	148
	149	client1_gone = true;
	150	} else if (sd_bus_message_is_method_call(m, "org.freedesktop.systemd.test", "ExitClient2")) {
	151
	152	r = sd_bus_message_new_method_return(bus, m, &reply);
	153	if (r < 0) {
	154	log_error("Failed to allocate return: %s", strerror(-r));
	155	goto fail;
	156	}
	157
	158	client2_gone = true;
	159	} else if (sd_bus_message_is_method_call(m, "org.freedesktop.systemd.test", "Slow")) {
	160
	161	r = sd_bus_message_new_method_return(bus, m, &reply);
	162	if (r < 0) {
	163	log_error("Failed to allocate return: %s", strerror(-r));
	164	goto fail;
	165	}
	166
	167	sleep(1);
	168	} else if (sd_bus_message_is_method_call(m, NULL, NULL)) {
	169	const sd_bus_error e = SD_BUS_ERROR_INIT_CONST("org.freedesktop.DBus.Error.UnknownMethod", "Unknown method.");
	170
	171	r = sd_bus_message_new_method_error(bus, m, &e, &reply);
	172	if (r < 0) {
	173	log_error("Failed to allocate return: %s", strerror(-r));
	174	goto fail;
	175	}
	176	}
	177
	178	if (reply) {
	179	r = sd_bus_send(bus, reply, NULL);
	180	if (r < 0) {
	181	log_error("Failed to send reply: %s", strerror(-r));
	182	goto fail;
	183	}
	184
	185	/* log_info("Sent"); */
	186	/* bus_message_dump(reply); */
	187	/* sd_bus_message_rewind(reply, true); */
	188	}
	189	}
	190
	191	r = 0;
	192
	193	fail:
	194	if (bus) {
	195	sd_bus_flush(bus);
	196	sd_bus_unref(bus);
	197	}
	198
	199	return r;
	200	}
	201
	202	static void* client1(void*p) {
	203	_cleanup_bus_message_unref_ sd_bus_message m = NULL, reply = NULL;
	204	sd_bus *bus = NULL;
	205	sd_bus_error error = SD_BUS_ERROR_INIT;
	206	const char *hello;
	207	int r;
	208
	209	r = sd_bus_open_user(&bus);
	210	if (r < 0) {
	211	log_error("Failed to connect to user bus: %s", strerror(-r));
	212	goto finish;
	213	}
	214
	215	r = sd_bus_message_new_method_call(
	216	bus,
	217	"org.freedesktop.systemd.test",
	218	"/",
	219	"org.freedesktop.systemd.test",
	220	"LowerCase",
	221	&m);
	222	if (r < 0) {
	223	log_error("Failed to allocate method call: %s", strerror(-r));
	224	goto finish;
	225	}
	226
	227	r = sd_bus_message_append(m, "s", "HELLO");
	228	if (r < 0) {
	229	log_error("Failed to append string: %s", strerror(-r));
	230	goto finish;
	231	}
	232
	233	r = sd_bus_send_with_reply_and_block(bus, m, 0, &error, &reply);
	234	if (r < 0) {
	235	log_error("Failed to issue method call: %s", bus_error_message(&error, -r));
	236	goto finish;
	237	}
	238
	239	r = sd_bus_message_read(reply, "s", &hello);
	240	if (r < 0) {
	241	log_error("Failed to get string: %s", strerror(-r));
	242	goto finish;
	243	}
	244
	245	assert(streq(hello, "hello"));
	246
	247	r = 0;
	248
	249	finish:
	250	if (bus) {
	251	_cleanup_bus_message_unref_ sd_bus_message *q;
	252
	253	r = sd_bus_message_new_method_call(
	254	bus,
	255	"org.freedesktop.systemd.test",
	256	"/",
	257	"org.freedesktop.systemd.test",
	258	"ExitClient1",
	259	&q);
	260	if (r < 0) {
	261	log_error("Failed to allocate method call: %s", strerror(-r));
	262	goto finish;
	263	}
	264
	265	sd_bus_send(bus, q, NULL);
	266	sd_bus_flush(bus);
	267	sd_bus_unref(bus);
	268	}
	269
	270	sd_bus_error_free(&error);
	271	return INT_TO_PTR(r);
	272	}
	273
	274	static int quit_callback(sd_bus b, int ret, sd_bus_message m, void *userdata) {
	275	bool *x = userdata;
	276
	277	log_error("Quit callback: %s", strerror(ret));
	278
	279	*x = 1;
	280	return 1;
	281	}
	282
	283	static void* client2(void*p) {
	284	_cleanup_bus_message_unref_ sd_bus_message m = NULL, reply = NULL;
	285	sd_bus *bus = NULL;
	286	sd_bus_error error = SD_BUS_ERROR_INIT;
	287	bool quit = false;
	288	const char *mid;
	289	int r;
	290
	291	r = sd_bus_open_user(&bus);
	292	if (r < 0) {
	293	log_error("Failed to connect to user bus: %s", strerror(-r));
	294	goto finish;
	295	}
	296
	297	r = sd_bus_message_new_method_call(
	298	bus,
	299	"org.freedesktop.systemd.test",
	300	"/",
	301	"org.freedesktop.DBus.Peer",
	302	"GetMachineId",
	303	&m);
	304	if (r < 0) {
	305	log_error("Failed to allocate method call: %s", strerror(-r));
	306	goto finish;
	307	}
	308
	309	r = sd_bus_send_with_reply_and_block(bus, m, 0, &error, &reply);
	310	if (r < 0) {
	311	log_error("Failed to issue method call: %s", bus_error_message(&error, -r));
	312	goto finish;
	313	}
	314
	315	r = sd_bus_message_read(reply, "s", &mid);
	316	if (r < 0) {
	317	log_error("Failed to parse machine ID: %s", strerror(-r));
	318	goto finish;
	319	}
	320
	321	log_info("Machine ID is %s.", mid);
	322
	323	sd_bus_message_unref(m);
	324	m = NULL;
	325
	326	r = sd_bus_message_new_method_call(
	327	bus,
	328	"org.freedesktop.systemd.test",
	329	"/",
	330	"org.freedesktop.systemd.test",
	331	"Slow",
	332	&m);
	333	if (r < 0) {
	334	log_error("Failed to allocate method call: %s", strerror(-r));
	335	goto finish;
	336	}
	337
	338	sd_bus_message_unref(reply);
	339	reply = NULL;
	340
	341	r = sd_bus_send_with_reply_and_block(bus, m, 200 * USEC_PER_MSEC, &error, &reply);
	342	if (r < 0)
	343	log_info("Failed to issue method call: %s", bus_error_message(&error, -r));
	344	else
	345	log_info("Slow call succeed.");
	346
	347	sd_bus_message_unref(m);
	348	m = NULL;
	349
	350	r = sd_bus_message_new_method_call(
	351	bus,
	352	"org.freedesktop.systemd.test",
	353	"/",
	354	"org.freedesktop.systemd.test",
	355	"Slow",
	356	&m);
	357	if (r < 0) {
	358	log_error("Failed to allocate method call: %s", strerror(-r));
	359	goto finish;
	360	}
	361
	362	r = sd_bus_send_with_reply(bus, m, quit_callback, &quit, 200 * USEC_PER_MSEC, NULL);
	363	if (r < 0) {
	364	log_info("Failed to issue method call: %s", bus_error_message(&error, -r));
	365	goto finish;
	366	}
	367
	368	while (!quit) {
	369	r = sd_bus_process(bus, NULL);
	370	if (r < 0) {
	371	log_error("Failed to process requests: %s", strerror(-r));
	372	goto finish;
	373	}
	374	if (r == 0) {
	375	r = sd_bus_wait(bus, (uint64_t) -1);
	376	if (r < 0) {
	377	log_error("Failed to wait: %s", strerror(-r));
	378	goto finish;
	379	}
	380	}
	381	}
	382
	383	r = 0;
	384
	385	finish:
	386	if (bus) {
	387	_cleanup_bus_message_unref_ sd_bus_message *q;
	388
	389	r = sd_bus_message_new_method_call(
	390	bus,
	391	"org.freedesktop.systemd.test",
	392	"/",
	393	"org.freedesktop.systemd.test",
	394	"ExitClient2",
	395	&q);
	396	if (r < 0) {
	397	log_error("Failed to allocate method call: %s", strerror(-r));
	398	goto finish;
	399	}
	400
	401	sd_bus_send(bus, q, NULL);
	402	sd_bus_flush(bus);
	403	sd_bus_unref(bus);
	404	}
	405
	406	sd_bus_error_free(&error);
	407	return INT_TO_PTR(r);
	408	}
	409
	410	int main(int argc, char *argv[]) {
	411	pthread_t c1, c2;
	412	sd_bus *bus;
	413	void *p;
	414	int q, r;
	415
	416	r = server_init(&bus);
	417	if (r < 0)
	418	return EXIT_FAILURE;
	419
	420	log_info("Initialized...");
	421
	422	r = pthread_create(&c1, NULL, client1, bus);
	423	if (r != 0)
	424	return EXIT_FAILURE;
	425
	426	r = pthread_create(&c2, NULL, client2, bus);
	427	if (r != 0)
	428	return EXIT_FAILURE;
	429
	430	r = server(bus);
	431
	432	q = pthread_join(c1, &p);
	433	if (q != 0)
	434	return EXIT_FAILURE;
	435	q = pthread_join(c2, &p);
	436	if (q != 0)
	437	return EXIT_FAILURE;
	438	if (r < 0)
	439	return EXIT_FAILURE;
	440
	441	return EXIT_SUCCESS;
	442	}