#include "dat.h"
#include "fn.h"

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/stat.h>
#include <poll.h>
#include <dbus/dbus.h>
#include <xkbcommon/xkbcommon.h>

enum
{
	Maxwatches	= 32,
	Maxconns	= 16,
	Maxcontexts	= 64,
	Relmask		= 1<<30,
	Ibussupermask	= 1<<26,
};

typedef struct Ictx Ictx;
struct Ictx
{
	DBusConnection	*conn;
	char	path[64];
	int	focused;
	Caret	caret;
};

static DBusWatch *watches[Maxwatches];
static int nwatches;
static DBusConnection *conns[Maxconns];
static int nconns;
static DBusServer *srv;
static Ictx contexts[Maxcontexts];
static char addrfile[512];
static dev_t addrdev;
static ino_t addrino;
static int addrowned;
static int icctr;
static int busctr;
static Channel *replyc;

static DBusHandlerResult onmsg(DBusConnection*, DBusMessage*, void*);

static void
unlinkaddr(void)
{
	struct stat st;

	if(addrowned && lstat(addrfile, &st) == 0 &&
	   st.st_dev == addrdev && st.st_ino == addrino)
		unlink(addrfile);
	addrowned = 0;
}

static void
machineid(char *buf, int sz)
{
	int fd, n;

	fd = open("/etc/machine-id", 0);
	if(fd < 0)
		fd = open("/var/lib/dbus/machine-id", 0);
	if(fd < 0){
		buf[0] = '\0';
		return;
	}
	n = read(fd, buf, sz - 1);
	close(fd);
	if(n < 0) n = 0;
	buf[n] = '\0';
	while(n > 0 && (buf[n-1] == '\n' || buf[n-1] == '\r'))
		buf[--n] = '\0';
}

static void
xdisplay(char *host, int hsz, char *num, int nsz)
{
	char *d, *colon, *dot, *p;
	int n;

	strncpy(host, "unix", hsz);
	host[hsz-1] = '\0';
	strncpy(num, "0", nsz);
	num[nsz-1] = '\0';
	d = getenv("DISPLAY");
	if(d == nil || d[0] == '\0')
		return;
	colon = strchr(d, ':');
	if(colon == nil)
		return;
	if(colon > d){
		n = colon - d;
		if(n >= hsz) n = hsz - 1;
		memcpy(host, d, n);
		host[n] = '\0';
	}
	p = colon + 1;
	dot = strchr(p, '.');
	n = dot ? dot - p : (int)strlen(p);
	if(n >= nsz) n = nsz - 1;
	memcpy(num, p, n);
	num[n] = '\0';
}

static int
buildaddrpath(char *buf, int sz)
{
	char mid[64], host[64], num[8], *cfg, *home;
	struct stat st;
	char dir[512];
	int n;

	machineid(mid, sizeof(mid));
	if(mid[0] == '\0')
		return -1;
	xdisplay(host, sizeof(host), num, sizeof(num));
	cfg = getenv("XDG_CONFIG_HOME");
	if(cfg != nil && cfg[0] != '\0')
		n = snprintf(dir, sizeof(dir), "%s/ibus/bus", cfg);
	else{
		home = getenv("HOME");
		if(home == nil)
			return -1;
		n = snprintf(dir, sizeof(dir), "%s/.config/ibus/bus", home);
	}
	if(n < 0 || n >= (int)sizeof dir)
		return -1;
	if(stat(dir, &st) < 0){
		char tmp[512];
		char *p;
		strncpy(tmp, dir, sizeof(tmp));
		tmp[sizeof(tmp)-1] = '\0';
		for(p = tmp+1; *p; p++)
			if(*p == '/'){
				*p = '\0';
				mkdir(tmp, 0700);
				*p = '/';
			}
		mkdir(tmp, 0700);
	}
	n = snprintf(buf, sz, "%s/%s-%s-%s", dir, mid, host, num);
	return n < 0 || n >= sz ? -1 : 0;
}

static int
writeaddr(char *path, char *addr)
{
	char tmp[576];
	FILE *fp;
	struct stat st;
	int fd, n, ok;

	n = snprintf(tmp, sizeof tmp, "%s.tmp.XXXXXX", path);
	if(n < 0 || n >= (int)sizeof tmp)
		return -1;
	fd = mkstemp(tmp);
	if(fd < 0)
		return -1;
	ok = 0;
	fp = nil;
	if(fchmod(fd, 0600) < 0)
		goto out;
	fp = fdopen(fd, "w");
	if(fp == nil)
		goto out;
	fd = -1;
	if(fprintf(fp, "IBUS_ADDRESS=%s\n", addr) < 0 ||
	   fprintf(fp, "IBUS_DAEMON_PID=%d\n", (int)getpid()) < 0 ||
	   fflush(fp) < 0 || fsync(fileno(fp)) < 0)
		goto out;
	if(fclose(fp) < 0){
		fp = nil;
		goto out;
	}
	fp = nil;
	if(rename(tmp, path) < 0 || lstat(path, &st) < 0)
		goto out;
	addrdev = st.st_dev;
	addrino = st.st_ino;
	addrowned = 1;
	ok = 1;
out:
	if(fp != nil)
		fclose(fp);
	if(fd >= 0)
		close(fd);
	if(!ok)
		unlink(tmp);
	return ok ? 0 : -1;
}

static dbus_bool_t
addwatch(DBusWatch *w, void *_)
{
	int i;

	USED(_);
	for(i = 0; i < nwatches; i++)
		if(watches[i] == nil){
			watches[i] = w;
			return TRUE;
		}
	if(nwatches >= Maxwatches)
		return FALSE;
	watches[nwatches++] = w;
	return TRUE;
}

static void
removewatch(DBusWatch *w, void *_)
{
	int i;

	USED(_);
	for(i = 0; i < nwatches; i++)
		if(watches[i] == w){
			watches[i] = nil;
			return;
		}
}

static void
togglewatch(DBusWatch *w, void *_)
{
	USED(w);
	USED(_);
}

static u32int
kget(u32int sym)
{
	u32int c;

	c = xkb_keysym_to_utf32(sym);
	if(c >= ' ' && c != 0x7f)
		return c;
	if(sym >= 0xff00 && sym <= 0xffff)
		return Kspec + (sym - 0xff00);
	return c;
}

static u32int
mget(u32int state)
{
	u32int m;

	m = 0;
	if(state & (1<<0)) m |= Mshift;
	if(state & (1<<2)) m |= Mctrl;
	if(state & (1<<3)) m |= Malt;
	if(state & ((1<<6)|Ibussupermask)) m |= Msuper;
	return m;
}

static Ictx*
findcontext(DBusConnection *conn, const char *path)
{
	int i;

	for(i = 0; i < nelem(contexts); i++)
		if(contexts[i].conn == conn && strcmp(contexts[i].path, path) == 0)
			return &contexts[i];
	return nil;
}

static Ictx*
newcontext(DBusConnection *conn, const char *path)
{
	int i;

	for(i = 0; i < nelem(contexts); i++)
		if(contexts[i].conn == nil){
			memset(&contexts[i], 0, sizeof contexts[i]);
			contexts[i].conn = conn;
			strncpy(contexts[i].path, path, sizeof contexts[i].path);
			contexts[i].path[sizeof contexts[i].path-1] = '\0';
			return &contexts[i];
		}
	return nil;
}

static void
sendrequest(Ictx *ctx, int op, u32int ks, u32int mod, Keyres *res)
{
	Keyreq kr;

	memset(&kr, 0, sizeof kr);
	kr.owner = ctx;
	kr.op = op;
	kr.ks = ks;
	kr.mod = mod;
	kr.caret = ctx->caret;
	kr.reply = replyc;
	chansend(keyc, &kr);
	chanrecv(replyc, res);
}

static void
releasecontext(Ictx *ctx)
{
	Keyres res;

	if(ctx->focused)
		sendrequest(ctx, Keyrelease, 0, 0, &res);
	ctx->focused = 0;
	memset(&ctx->caret, 0, sizeof ctx->caret);
}

static void
dropcontext(Ictx *ctx)
{
	releasecontext(ctx);
	memset(ctx, 0, sizeof *ctx);
}

static void
dropconncontexts(DBusConnection *conn)
{
	int i;

	for(i = 0; i < nelem(contexts); i++)
		if(contexts[i].conn == conn)
			dropcontext(&contexts[i]);
}

static int
processkey(Ictx *ctx, u32int sym, u32int state, Keyres *res)
{
	if(state & Relmask || !ctx->focused)
		return 0;
	sendrequest(ctx, Keypress, kget(sym), mget(state), res);
	return 1;
}

static void
setcursor(Ictx *ctx, int x, int y, int h)
{
	Keyres res;

	ctx->caret.valid = 1;
	ctx->caret.x = x;
	ctx->caret.y = y;
	ctx->caret.h = h;
	if(ctx->focused)
		sendrequest(ctx, Keycaret, 0, 0, &res);
}

static void
appendibustext(DBusMessageIter *it, const char *s)
{
	DBusMessageIter v, st, attach, alv, ali, attr, alist;
	const char *name = "IBusText";
	const char *aname = "IBusAttrList";

	dbus_message_iter_open_container(it, DBUS_TYPE_VARIANT, "(sa{sv}sv)", &v);
	dbus_message_iter_open_container(&v, DBUS_TYPE_STRUCT, nil, &st);
	dbus_message_iter_append_basic(&st, DBUS_TYPE_STRING, &name);
	dbus_message_iter_open_container(&st, DBUS_TYPE_ARRAY, "{sv}", &attach);
	dbus_message_iter_close_container(&st, &attach);
	dbus_message_iter_append_basic(&st, DBUS_TYPE_STRING, &s);
	dbus_message_iter_open_container(&st, DBUS_TYPE_VARIANT, "(sa{sv}av)", &alv);
	dbus_message_iter_open_container(&alv, DBUS_TYPE_STRUCT, nil, &ali);
	dbus_message_iter_append_basic(&ali, DBUS_TYPE_STRING, &aname);
	dbus_message_iter_open_container(&ali, DBUS_TYPE_ARRAY, "{sv}", &attr);
	dbus_message_iter_close_container(&ali, &attr);
	dbus_message_iter_open_container(&ali, DBUS_TYPE_ARRAY, "v", &alist);
	dbus_message_iter_close_container(&ali, &alist);
	dbus_message_iter_close_container(&alv, &ali);
	dbus_message_iter_close_container(&st, &alv);
	dbus_message_iter_close_container(&v, &st);
	dbus_message_iter_close_container(it, &v);
}

static void
emitcommit(DBusConnection *c, const char *path, const char *text)
{
	DBusMessage *sig;
	DBusMessageIter it;

	sig = dbus_message_new_signal(path, "org.freedesktop.IBus.InputContext", "CommitText");
	if(sig == nil)
		return;
	dbus_message_iter_init_append(sig, &it);
	appendibustext(&it, text);
	dbus_connection_send(c, sig, nil);
	dbus_message_unref(sig);
}

static void
emitpreedit(DBusConnection *c, const char *path, const char *text)
{
	DBusMessage *sig;
	DBusMessageIter it;
	dbus_uint32_t cursor;
	dbus_bool_t visible;

	sig = dbus_message_new_signal(path,
		"org.freedesktop.IBus.InputContext", "UpdatePreeditText");
	if(sig == nil)
		return;
	dbus_message_iter_init_append(sig, &it);
	appendibustext(&it, text);
	cursor = utflen((char*)text);
	visible = text[0] != '\0' ? TRUE : FALSE;
	dbus_message_iter_append_basic(&it, DBUS_TYPE_UINT32, &cursor);
	dbus_message_iter_append_basic(&it, DBUS_TYPE_BOOLEAN, &visible);
	dbus_connection_send(c, sig, nil);
	dbus_message_unref(sig);
}

static DBusHandlerResult
handlehello(DBusConnection *c, DBusMessage *m)
{
	DBusMessage *r;
	char name[32];
	const char *np;

	busctr++;
	snprintf(name, sizeof(name), ":1.%d", busctr);
	np = name;
	r = dbus_message_new_method_return(m);
	dbus_message_append_args(r, DBUS_TYPE_STRING, &np, DBUS_TYPE_INVALID);
	dbus_connection_send(c, r, nil);
	dbus_message_unref(r);
	return DBUS_HANDLER_RESULT_HANDLED;
}

static DBusHandlerResult
handleerror(DBusConnection *c, DBusMessage *m, const char *name,
	const char *text)
{
	DBusMessage *r;

	r = dbus_message_new_error(m, name, text);
	if(r != nil){
		dbus_connection_send(c, r, nil);
		dbus_message_unref(r);
	}
	return DBUS_HANDLER_RESULT_HANDLED;
}

static DBusHandlerResult
handlebool(DBusConnection *c, DBusMessage *m, int value)
{
	DBusMessage *r;
	dbus_bool_t b;

	r = dbus_message_new_method_return(m);
	b = value ? TRUE : FALSE;
	dbus_message_append_args(r, DBUS_TYPE_BOOLEAN, &b, DBUS_TYPE_INVALID);
	dbus_connection_send(c, r, nil);
	dbus_message_unref(r);
	return DBUS_HANDLER_RESULT_HANDLED;
}

static DBusHandlerResult
handlecreate(DBusConnection *c, DBusMessage *m)
{
	DBusMessage *r;
	char path[64];
	const char *pp;
	Ictx *ctx;
	int n;

	icctr++;
	n = snprintf(path, sizeof(path),
		"/org/freedesktop/IBus/InputContext_%d", icctr);
	if(n < 0 || n >= (int)sizeof path)
		return handleerror(c, m, DBUS_ERROR_LIMITS_EXCEEDED,
			"input context path exhausted");
	ctx = newcontext(c, path);
	if(ctx == nil)
		return handleerror(c, m, DBUS_ERROR_LIMITS_EXCEEDED,
			"too many input contexts");
	pp = path;
	r = dbus_message_new_method_return(m);
	dbus_message_append_args(r, DBUS_TYPE_OBJECT_PATH, &pp, DBUS_TYPE_INVALID);
	dbus_connection_send(c, r, nil);
	dbus_message_unref(r);
	return DBUS_HANDLER_RESULT_HANDLED;
}

static DBusHandlerResult
handlekey(DBusConnection *c, DBusMessage *m, Ictx *ctx)
{
	DBusError err;
	dbus_uint32_t sym, code, state;
	Keyres res;
	char commit[Maxutf], preedit[Maxutf];

	dbus_error_init(&err);
	if(!dbus_message_get_args(m, &err,
		DBUS_TYPE_UINT32, &sym,
		DBUS_TYPE_UINT32, &code,
		DBUS_TYPE_UINT32, &state,
		DBUS_TYPE_INVALID)){
		dbus_error_free(&err);
		return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
	}
	USED(code);
	if(!processkey(ctx, sym, state, &res))
		return handlebool(c, m, 0);
	stoutf(&res.commit, commit, sizeof commit);
	stoutf(&res.preedit, preedit, sizeof preedit);
	if(commit[0] != '\0')
		emitcommit(c, dbus_message_get_path(m), commit);
	emitpreedit(c, dbus_message_get_path(m), preedit);
	return handlebool(c, m, res.eaten);
}

static DBusHandlerResult
handlenoop(DBusConnection *c, DBusMessage *m)
{
	DBusMessage *r;

	r = dbus_message_new_method_return(m);
	dbus_connection_send(c, r, nil);
	dbus_message_unref(r);
	return DBUS_HANDLER_RESULT_HANDLED;
}

static DBusHandlerResult
handlereset(DBusConnection *c, DBusMessage *m, Ictx *ctx)
{
	Keyres res;

	sendrequest(ctx, Keyreset, 0, 0, &res);
	emitpreedit(c, dbus_message_get_path(m), "");
	return handlenoop(c, m);
}

static DBusHandlerResult
handlefocusin(DBusConnection *c, DBusMessage *m, Ictx *ctx)
{
	ctx->focused = 1;
	return handlenoop(c, m);
}

static DBusHandlerResult
handlefocusout(DBusConnection *c, DBusMessage *m, Ictx *ctx)
{
	releasecontext(ctx);
	emitpreedit(c, dbus_message_get_path(m), "");
	return handlenoop(c, m);
}

static DBusHandlerResult
handledestroy(DBusConnection *c, DBusMessage *m, Ictx *ctx)
{
	dropcontext(ctx);
	return handlenoop(c, m);
}

static DBusHandlerResult
handlecursor(DBusConnection *c, DBusMessage *m, Ictx *ctx)
{
	DBusError err;
	dbus_int32_t x, y, w, h;

	dbus_error_init(&err);
	if(!dbus_message_get_args(m, &err,
		DBUS_TYPE_INT32, &x, DBUS_TYPE_INT32, &y,
		DBUS_TYPE_INT32, &w, DBUS_TYPE_INT32, &h,
		DBUS_TYPE_INVALID)){
		dbus_error_free(&err);
		return handleerror(c, m, DBUS_ERROR_INVALID_ARGS,
			"SetCursorLocation expects four integers");
	}
	if(w < 0 || h < 0)
		return handleerror(c, m, DBUS_ERROR_INVALID_ARGS,
			"cursor dimensions must not be negative");
	setcursor(ctx, x, y, h);
	return handlenoop(c, m);
}

static const char introspectxml[] =
"<!DOCTYPE node PUBLIC \"-//freedesktop//DTD D-BUS Object Introspection 1.0//EN\"\n"
" \"http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd\">\n"
"<node>\n"
" <interface name=\"org.freedesktop.IBus\">\n"
"  <method name=\"CreateInputContext\">\n"
"   <arg direction=\"in\" type=\"s\"/>\n"
"   <arg direction=\"out\" type=\"o\"/>\n"
"  </method>\n"
" </interface>\n"
" <interface name=\"org.freedesktop.IBus.InputContext\">\n"
"  <method name=\"ProcessKeyEvent\">\n"
"   <arg direction=\"in\" type=\"u\"/>\n"
"   <arg direction=\"in\" type=\"u\"/>\n"
"   <arg direction=\"in\" type=\"u\"/>\n"
"   <arg direction=\"out\" type=\"b\"/>\n"
"  </method>\n"
"  <method name=\"FocusIn\"/>\n"
"  <method name=\"FocusOut\"/>\n"
"  <method name=\"Reset\"/>\n"
"  <method name=\"Destroy\"/>\n"
"  <method name=\"SetCapabilities\"><arg direction=\"in\" type=\"u\"/></method>\n"
"  <method name=\"SetCursorLocation\">"
"<arg direction=\"in\" type=\"i\"/><arg direction=\"in\" type=\"i\"/>"
"<arg direction=\"in\" type=\"i\"/><arg direction=\"in\" type=\"i\"/></method>\n"
"  <method name=\"SetEngine\"><arg direction=\"in\" type=\"s\"/></method>\n"
"  <signal name=\"CommitText\"><arg type=\"v\"/></signal>\n"
"  <signal name=\"UpdatePreeditText\">"
"<arg type=\"v\"/><arg type=\"u\"/><arg type=\"b\"/></signal>\n"
" </interface>\n"
"</node>\n";

static DBusHandlerResult
handleintrospect(DBusConnection *c, DBusMessage *m)
{
	DBusMessage *r;
	const char *xml = introspectxml;

	r = dbus_message_new_method_return(m);
	dbus_message_append_args(r, DBUS_TYPE_STRING, &xml, DBUS_TYPE_INVALID);
	dbus_connection_send(c, r, nil);
	dbus_message_unref(r);
	return DBUS_HANDLER_RESULT_HANDLED;
}

static DBusHandlerResult
onmsg(DBusConnection *c, DBusMessage *m, void *_)
{
	const char *iface, *member, *path;
	Ictx *ctx;

	USED(_);
	if(dbus_message_get_type(m) != DBUS_MESSAGE_TYPE_METHOD_CALL)
		return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
	iface = dbus_message_get_interface(m);
	member = dbus_message_get_member(m);
	path = dbus_message_get_path(m);
	if(iface == nil || member == nil || path == nil)
		return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
	if(strcmp(iface, "org.freedesktop.DBus.Introspectable") == 0
	&& strcmp(member, "Introspect") == 0)
		return handleintrospect(c, m);
	if(strcmp(iface, "org.freedesktop.DBus") == 0){
		if(strcmp(member, "Hello") == 0)
			return handlehello(c, m);
		if(strcmp(member, "AddMatch") == 0
		|| strcmp(member, "RemoveMatch") == 0)
			return handlenoop(c, m);
	}
	if(strcmp(iface, "org.freedesktop.IBus") == 0){
		if(strcmp(member, "CreateInputContext") == 0)
			return handlecreate(c, m);
	}
	if(strcmp(iface, "org.freedesktop.IBus.InputContext") == 0){
		ctx = findcontext(c, path);
		if(ctx == nil)
			return handleerror(c, m, DBUS_ERROR_UNKNOWN_OBJECT,
				"unknown input context");
		if(strcmp(member, "ProcessKeyEvent") == 0)
			return handlekey(c, m, ctx);
		if(strcmp(member, "FocusIn") == 0)
			return handlefocusin(c, m, ctx);
		if(strcmp(member, "FocusOut") == 0)
			return handlefocusout(c, m, ctx);
		if(strcmp(member, "Reset") == 0)
			return handlereset(c, m, ctx);
		if(strcmp(member, "Destroy") == 0)
			return handledestroy(c, m, ctx);
		if(strcmp(member, "SetCursorLocation") == 0)
			return handlecursor(c, m, ctx);
		if(strcmp(member, "SetCapabilities") == 0
		|| strcmp(member, "SetEngine") == 0)
			return handlenoop(c, m);
	}
	return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}

static void
newconn(DBusServer *s, DBusConnection *c, void *_)
{
	DBusObjectPathVTable vt;

	USED(s);
	USED(_);
	if(nconns >= Maxconns)
		return;
	dbus_connection_ref(c);
	dbus_connection_set_watch_functions(c, addwatch, removewatch, togglewatch, nil, nil);
	memset(&vt, 0, sizeof(vt));
	vt.message_function = onmsg;
	dbus_connection_register_fallback(c, "/", &vt, nil);
	conns[nconns++] = c;
}

static void
pruneconns(void)
{
	int i, j;

	j = 0;
	for(i = 0; i < nconns; i++){
		if(dbus_connection_get_is_connected(conns[i])){
			conns[j++] = conns[i];
			continue;
		}
		dropconncontexts(conns[i]);
		dbus_connection_unref(conns[i]);
	}
	nconns = j;
}

static int
ibusinit(void)
{
	DBusError err;
	char addr[128];
	char *full;

	if(buildaddrpath(addrfile, sizeof(addrfile)) < 0){
		fprintf(stderr, "strans: ibus: cannot build address path\n");
		return -1;
	}
	if(snprintf(addr, sizeof(addr), "unix:abstract=strans-%d",
	   (int)getpid()) >= (int)sizeof addr){
		fprintf(stderr, "strans: ibus: address is too long\n");
		return -1;
	}
	dbus_error_init(&err);
	srv = dbus_server_listen(addr, &err);
	if(srv == nil){
		fprintf(stderr, "strans: ibus: listen: %s\n", err.message);
		dbus_error_free(&err);
		addrfile[0] = '\0';
		return -1;
	}
	dbus_server_set_new_connection_function(srv, newconn, nil, nil);
	dbus_server_set_watch_functions(srv, addwatch, removewatch, togglewatch, nil, nil);
	full = dbus_server_get_address(srv);
	if(writeaddr(addrfile, full) < 0){
		fprintf(stderr, "strans: ibus: cannot write %s\n", addrfile);
		dbus_free(full);
		dbus_server_disconnect(srv);
		dbus_server_unref(srv);
		srv = nil;
		addrfile[0] = '\0';
		return -1;
	}
	dbus_free(full);
	atexit(unlinkaddr);
	return 0;
}

void
ibusthread(void *_)
{
	struct pollfd pfds[Maxwatches];
	DBusWatch *polled[Maxwatches];
	int wi[Maxwatches];
	int i, n, rv;
	unsigned int f;

	USED(_);
	threadsetname("ibus");
	if(ibusinit() < 0)
		return;
	replyc = chancreate(sizeof(Keyres), 0);
	for(;;){
		n = 0;
		for(i = 0; i < nwatches && n < Maxwatches; i++){
			if(watches[i] == nil)
				continue;
			if(!dbus_watch_get_enabled(watches[i]))
				continue;
			pfds[n].fd = dbus_watch_get_unix_fd(watches[i]);
			pfds[n].events = 0;
			f = dbus_watch_get_flags(watches[i]);
			if(f & DBUS_WATCH_READABLE) pfds[n].events |= POLLIN;
			if(f & DBUS_WATCH_WRITABLE) pfds[n].events |= POLLOUT;
			wi[n] = i;
			polled[n] = watches[i];
			n++;
		}
		rv = poll(pfds, n, 200);
		if(rv < 0)
			continue;
		for(i = 0; i < n; i++){
			if(pfds[i].revents == 0)
				continue;
			if(watches[wi[i]] != polled[i])
				continue;
			f = 0;
			if(pfds[i].revents & POLLIN) f |= DBUS_WATCH_READABLE;
			if(pfds[i].revents & POLLOUT) f |= DBUS_WATCH_WRITABLE;
			if(pfds[i].revents & POLLHUP) f |= DBUS_WATCH_HANGUP;
			if(pfds[i].revents & POLLERR) f |= DBUS_WATCH_ERROR;
			dbus_watch_handle(polled[i], f);
		}
		for(i = 0; i < nconns; i++)
			while(dbus_connection_dispatch(conns[i]) == DBUS_DISPATCH_DATA_REMAINS)
				;
		pruneconns();
	}
}