test: share one daemon and D-Bus harness across live tests

Six live tests carried private copies of the same daemon harness: the
private XDG_RUNTIME_DIR, the fork/exec with captured stderr, the
readiness waits, the SIGTERM and SIGKILL paths, the IBus address file
reader, the socket connect, and the IPC probe. Three of them also
carried the same libdbus helpers.

Extract one implementation into tests/live.c and, so that the binaries
that do not link dbus-1 keep not linking it, the D-Bus half into
tests/livebus.c. Both are compiled into each binary the way ../ipc.c
already is. gtk_live_test keeps its own fake-server harness and only
takes fail, nowms and leftms; xim_live_test keeps its own Xvfb and
process-group daemon spawn, which must inherit DISPLAY, and takes the
temporary directory, timing and cleanup halves.

The copies had drifted; the harness keeps the stricter behaviour.

  - nowms reports a broken clock (-1) instead of pretending it read
    zero, and leftms turns that into an expired deadline, so a loop
    ends in a timeout failure rather than spinning. livesetup checks
    the clock once up front, as daemon_restart_test did.
  - Timeouts compare with <= 0, not == 0.
  - readuntil keeps the three-way result (complete, peer closed, error)
    from ipc_live_test and daemon_restart_test rather than folding
    peer closure into ECONNRESET.
  - The daemon's stdout and stderr are both captured, and a failing
    setenv is reported, for every daemon; daemon_failure_test captured
    stderr only and said nothing about setenv.
  - The child keeps daemon_restart_test's careful redirect that also
    works when the pipe lands on fd 1 or 2.
  - parseaddress requires a positive declared PID.
  - killdaemon reports ECHILD after SIGKILL as a failure; one copy
    accepted it. It now reaps with a blocking waitpid, which SIGKILL
    guarantees will return, instead of daemon_restart_test's polled
    wait with its own timeout diagnostic.
  - stopdaemon tolerates ESRCH on SIGTERM, a benign race two copies
    reported as an error.
  - liveclean removes the socket and address files and then rmdirs
    each directory, reporting leftovers, rather than deleting the
    temporary root recursively.
  - ibus_live_test now waits for the IPC socket and the address file
    by polling, dropping its inotify variant; it asserted only the
    address file before.

tests/livebus.c

@@ -0,0 +1,168 @@
+#define _GNU_SOURCE
+#include <dbus/dbus.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "live.h"
+#include "livebus.h"
+
+DBusConnection*
+openbus(char *address, char *where)
+{
+	DBusConnection *conn;
+	DBusError err;
+
+	dbus_error_init(&err);
+	conn = dbus_connection_open_private(address, &err);
+	if(conn == NULL){
+		fail("open %s private IBus connection: %s", where,
+			err.message != NULL ? err.message : "D-Bus error");
+		dbus_error_free(&err);
+		return NULL;
+	}
+	dbus_error_free(&err);
+	dbus_connection_set_exit_on_disconnect(conn, FALSE);
+	return conn;
+}
+
+void
+closebus(DBusConnection **conn)
+{
+	if(*conn == NULL)
+		return;
+	dbus_connection_close(*conn);
+	dbus_connection_unref(*conn);
+	*conn = NULL;
+}
+
+DBusMessage*
+contextcall(char *path, char *member)
+{
+	return dbus_message_new_method_call("org.freedesktop.IBus", path,
+		"org.freedesktop.IBus.InputContext", member);
+}
+
+DBusMessage*
+sendcall(DBusConnection *conn, DBusMessage *m, char *where)
+{
+	DBusMessage *reply;
+	DBusPendingCall *pending;
+	int timeout;
+	int64_t deadline;
+
+	if(m == NULL){
+		fail("allocate %s call", where);
+		return NULL;
+	}
+	pending = NULL;
+	if(!dbus_connection_send_with_reply(conn, m, &pending, Calltimeout) ||
+	   pending == NULL){
+		dbus_message_unref(m);
+		fail("queue %s call", where);
+		return NULL;
+	}
+	dbus_message_unref(m);
+	deadline = nowms() + Calltimeout;
+	while(!dbus_pending_call_get_completed(pending)){
+		timeout = leftms(deadline);
+		if(timeout == 0){
+			fail("timed out waiting for %s", where);
+			goto out;
+		}
+		if(!dbus_connection_read_write_dispatch(conn, timeout)){
+			fail("connection closed waiting for %s", where);
+			goto out;
+		}
+	}
+	reply = dbus_pending_call_steal_reply(pending);
+	dbus_pending_call_unref(pending);
+	if(reply == NULL)
+		fail("%s completed without a reply", where);
+	return reply;
+out:
+	dbus_pending_call_cancel(pending);
+	dbus_pending_call_unref(pending);
+	return NULL;
+}
+
+DBusMessage*
+callret(DBusConnection *conn, DBusMessage *m, char *where)
+{
+	DBusMessage *reply;
+
+	reply = sendcall(conn, m, where);
+	if(reply == NULL)
+		return NULL;
+	if(dbus_message_get_type(reply) != DBUS_MESSAGE_TYPE_METHOD_RETURN){
+		fail("%s returned D-Bus message type %d", where,
+			dbus_message_get_type(reply));
+		dbus_message_unref(reply);
+		return NULL;
+	}
+	return reply;
+}
+
+int
+hello(DBusConnection *conn, char *name, size_t nname, char *where)
+{
+	DBusMessage *m, *reply;
+	DBusError err;
+	const char *s;
+	int ok;
+
+	m = dbus_message_new_method_call("org.freedesktop.DBus",
+		"/org/freedesktop/DBus", "org.freedesktop.DBus", "Hello");
+	reply = callret(conn, m, where);
+	if(reply == NULL)
+		return 0;
+	dbus_error_init(&err);
+	ok = dbus_message_has_signature(reply, "s") &&
+		dbus_message_get_args(reply, &err, DBUS_TYPE_STRING, &s,
+		DBUS_TYPE_INVALID);
+	if(!ok)
+		fail("%s returned an invalid Hello reply", where);
+	else if(s[0] != ':')
+		ok = fail("%s returned invalid Hello name %s", where, s);
+	else if(name != NULL && snprintf(name, nname, "%s", s) >= (int)nname)
+		ok = fail("%s Hello name is too long", where);
+	dbus_error_free(&err);
+	dbus_message_unref(reply);
+	return ok;
+}
+
+int
+createcontext(DBusConnection *conn, char *path, size_t npath, char *where)
+{
+	DBusMessage *m, *reply;
+	DBusError err;
+	const char *client, *p;
+	int ok;
+
+	client = testname;
+	m = dbus_message_new_method_call("org.freedesktop.IBus",
+		"/org/freedesktop/IBus", "org.freedesktop.IBus",
+		"CreateInputContext");
+	if(m == NULL || !dbus_message_append_args(m, DBUS_TYPE_STRING, &client,
+	   DBUS_TYPE_INVALID)){
+		if(m != NULL)
+			dbus_message_unref(m);
+		return fail("build %s CreateInputContext call", where);
+	}
+	reply = callret(conn, m, where);
+	if(reply == NULL)
+		return 0;
+	dbus_error_init(&err);
+	ok = dbus_message_has_signature(reply, "o") &&
+		dbus_message_get_args(reply, &err, DBUS_TYPE_OBJECT_PATH, &p,
+		DBUS_TYPE_INVALID);
+	if(!ok)
+		fail("%s returned an invalid context reply", where);
+	else if(p[0] != '/')
+		ok = fail("%s returned invalid context path %s", where, p);
+	else if(path != NULL && snprintf(path, npath, "%s", p) >= (int)npath)
+		ok = fail("%s context path is too long", where);
+	dbus_error_free(&err);
+	dbus_message_unref(reply);
+	return ok;
+}