ltk

ltkd.c (31307B)

---

 /* FIXME: Figure out how to properly print window id */
 /* FIXME: error checking in tokenizer (is this necessary?) */
 /* FIXME: strip whitespace at end of lines in socket format */
 /*
  * Copyright (c) 2016-2024 lumidify <nobody@lumidify.org>
  *
  * Permission to use, copy, modify, and/or distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above
  * copyright notice and this permission notice appear in all copies.
  *
  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  */
 
 #include <time.h>
 #include <stdio.h>
 #include <fcntl.h>
 #include <errno.h>
 #include <stdlib.h>
 #include <string.h>
 #include <stdarg.h>
 #include <unistd.h>
 #include <signal.h>
 #include <locale.h>
 #include <inttypes.h>
 
 #include <sys/un.h>
 #include <sys/select.h>
 #include <sys/socket.h>
 
 #include "err.h"
 #include "ltkd.h"
 #include "util.h"
 #include "widget.h"
 #include "cmd_helpers.h"
 #include "proto_types.h"
 
 #include <ltk/memory.h>
 #include <ltk/ltk.h>
 #include <ltk/util.h>
 #include <ltk/text.h>
 #include <ltk/macros.h>
 #include <ltk/graphics.h>
 
 #define MAX_SOCK_CONNS 20
 #define READ_BLK_SIZE 128
 #define WRITE_BLK_SIZE 128
 
 struct token_list {
 	ltkd_cmd_token *tokens;
 	/* FIXME: size_t everywhere */
 	int num_tokens;
 	int num_alloc;
 };
 
 /* FIXME: switch to size_t */
 static struct ltkd_sock_info {
 	int fd;                    /* file descriptor for socket connection */
 	int event_mask;            /* events to send to socket */
 	char *read;                /* text read from socket */
 	int read_len;              /* length of text in read buffer */
 	int read_alloc;            /* size of read buffer */
 	char *to_write;            /* text to be written to socket */
 	int write_len;             /* length of text in write buffer */
 	int write_cur;             /* length of text already written */
 	int write_alloc;           /* size of write buffer */
 	/* stuff for tokenizing */
 	int in_token;              /* last read char is inside token */
 	int offset;                /* offset from removing backslashes */
 	int in_str;                /* last read char is inside string */
 	int read_cur;              /* length of text already tokenized */
 	int bs;                    /* last char was non-escaped backslash */
 	struct token_list tokens;  /* current tokens */
 	uint32_t last_seq;         /* sequence number of last request processed */
 } sockets[MAX_SOCK_CONNS];
 
 static int daemonize_flag = 1;
 
 static void ltkd_mainloop(ltk_window *window);
 static char *get_sock_path(char *basedir, unsigned long id);
 static FILE *open_log(char *dir);
 static void daemonize(void);
 static int read_sock(struct ltkd_sock_info *sock);
 static int push_token(struct token_list *tl, char *token);
 static int read_sock(struct ltkd_sock_info *sock);
 static int write_sock(struct ltkd_sock_info *sock);
 static int tokenize_command(struct ltkd_sock_info *sock);
 static int ltkd_set_root_widget_cmd(ltk_window *window, ltkd_cmd_token *tokens, int num_tokens, ltkd_error *err);
 static int process_commands(ltk_window *window, int client);
 static int add_client(int fd);
 static int listen_sock(const char *sock_path);
 static int accept_sock(int listenfd);
 static void ltkd_quit(void);
 static void ltkd_cleanup(void);
 
 static short maxsocket = -1;
 static short running = 1;
 static short sock_write_available = 0;
 static int base_dir_fd = -1;
 static char *ltkd_dir = NULL;
 static FILE *ltkd_logfile = NULL;
 static char *sock_path = NULL;
 /* Note: Most functions still take this explicitly because it wasn't
    global originally, but that's just the way it is. */
 static ltk_window *main_window = NULL;
 
 typedef struct {
 	char *name;
 	int (*cmd)(ltk_window *, ltkd_cmd_token *, size_t, ltkd_error *);
 } ltkd_widget_funcs;
 
 /* FIXME: use binary search when searching for the widget */
 ltkd_widget_funcs widget_funcs[] = {
 	{
 		.name = "box",
 		.cmd = &ltkd_box_cmd
 	},
 	{
 		.name = "button",
 		.cmd = &ltkd_button_cmd
 	},
 	{
 		.name = "entry",
 		.cmd = &ltkd_entry_cmd
 	},
 	{
 		.name = "grid",
 		.cmd = &ltkd_grid_cmd
 	},
 	{
 		.name = "label",
 		.cmd = &ltkd_label_cmd
 	},
 	{
 		.name = "image",
 		.cmd = &ltkd_image_widget_cmd
 	},
 	{
 		.name = "menu",
 		.cmd = &ltkd_menu_cmd
 	},
 	{
 		.name = "menuentry",
 		.cmd = &ltkd_menuentry_cmd
 	},
 	{
 		.name = "submenu",
 		.cmd = &ltkd_menu_cmd
 	},
 };
 
 static int
 ltkd_window_close(ltk_widget *self, ltk_callback_arglist args, ltk_callback_arg data) {
 	(void)self;
 	(void)args;
 	(void)data;
 	ltkd_quit();
 	return 1;
 }
 
 int
 main(int argc, char *argv[]) {
 	setlocale(LC_CTYPE, "");
 	/* FIXME: decide where to add this (currently called in ltk, but kind of weird) */
 	/*XSetLocaleModifiers("");*/
 	int ch;
 	char *title = "LTK Window";
 	while ((ch = getopt(argc, argv, "dt:")) != -1) {
 		switch (ch) {
 			case 't':
 				title = optarg;
 				break;
 			case 'd':
 				daemonize_flag = 0;
 				break;
 			default:
 				ltkd_fatal("USAGE: ltkd [-t title]\n");
 		}
 	}
 
 	ltkd_dir = ltk_setup_directory("LTKDDIR", ".ltkd", 1);
 	if (!ltkd_dir) ltkd_fatal_errno("Unable to setup ltkd directory.\n");
 	/* FIXME: this is only used to use unlinkat for deleting the socket in
 	   the end in case ltkd_dir is relative. It would probably be better
 	   to just use getcwd to turn that into an absolute path instead.
 	   Or maybe ltkd should just stay in the current directory instead of
 	   moving to / in daemonize(). */
 	base_dir_fd = open(".", O_RDONLY);
 	if (base_dir_fd < 0)
 		ltkd_fatal_errno("Unable to open current directory.\n");
 	ltkd_logfile = open_log(ltkd_dir);
 	if (!ltkd_logfile) ltkd_fatal_errno("Unable to open log file.\n");
 
 	ltk_init();
 	ltkd_widgets_init();
 
 	/* FIXME: set window size properly - I only run it in a tiling WM
 	   anyways, so it doesn't matter, but still... */
 	main_window = ltk_window_create(title, 0, 0, 500, 500);
 	ltk_widget_register_signal_handler(LTK_CAST_WIDGET(main_window), LTK_WINDOW_SIGNAL_CLOSE, &ltkd_window_close, LTK_ARG_VOID);
 
 	sock_path = get_sock_path(ltkd_dir, ltk_renderer_get_window_id(main_window->renderwindow));
 	if (!sock_path) ltkd_fatal_errno("Unable to allocate memory for socket path.\n");
 
 	/* Note: sockets should be initialized to 0 because it is static */
 	for (int i = 0; i < MAX_SOCK_CONNS; i++) {
 		sockets[i].fd = -1; /* socket unused */
 		/* initialize these just because I'm paranoid */
 		sockets[i].read = NULL;
 		sockets[i].to_write = NULL;
 		sockets[i].tokens.tokens = NULL;
 	}
 
 	ltkd_mainloop(main_window);
 	return 0;
 }
 
 /* FIXME: need to recalculate maxfd when removing client */
 static struct {
 	fd_set rallfds, wallfds;
 	int maxfd;
 	int listenfd;
 } sock_state;
 
 /* FIXME: this is extremely dangerous right now because pretty much any command
    can be executed, so for instance the widget that caused the lock could also
    be destroyed, causing issues when this function returns */
 int
 ltkd_handle_lock_client(ltk_window *window, int client) {
 	if (client < 0 || client >= MAX_SOCK_CONNS || sockets[client].fd == -1)
 		return 0;
 	fd_set rfds, wfds, rallfds, wallfds;
 	int clifd = sockets[client].fd;
 	FD_ZERO(&rallfds);
 	FD_ZERO(&wallfds);
 	FD_SET(clifd, &rallfds);
 	FD_SET(clifd, &wallfds);
 	int retval;
 	struct timeval tv;
 	tv.tv_sec = 0;
 	tv.tv_usec = 0;
 	struct timespec now, elapsed, last, sleep_time;
 	clock_gettime(CLOCK_MONOTONIC, &last);
 	sleep_time.tv_sec = 0;
 	while (1) {
 		rfds = rallfds;
 		wfds = wallfds;
 		retval = select(clifd + 1, &rfds, &wfds, NULL, &tv);
 
 		if (retval > 0) {
 			if (FD_ISSET(clifd, &rfds)) {
 				int ret;
 				while ((ret = read_sock(&sockets[client])) == 1) {
 					int pret;
 					if ((pret = process_commands(window, client)) == 1)
 						return 1;
 					else if (pret == -1)
 						return 0;
 				}
 				/* FIXME: maybe also return on read error? or would that be dangerous? */
 				if (ret == 0) {
 					FD_CLR(clifd, &sock_state.rallfds);
 					FD_CLR(clifd, &sock_state.wallfds);
 					ltkd_widget_remove_client(client);
 					sockets[clifd].fd = -1;
 					close(clifd);
 					int newmaxsocket = -1;
 					for (int j = 0; j <= maxsocket; j++) {
 						if (sockets[j].fd >= 0)
 							newmaxsocket = j;
 					}
 					maxsocket = newmaxsocket;
 					if (maxsocket == -1) {
 						ltkd_quit();
 						break;
 					}
 					return 0;
 				}
 			}
 			if (FD_ISSET(clifd, &wfds)) {
 				/* FIXME: call in loop like above */
 				write_sock(&sockets[client]);
 			}
 		}
 		clock_gettime(CLOCK_MONOTONIC, &now);
 		ltk_timespecsub(&now, &last, &elapsed);
 		/* FIXME: configure framerate */
 		if (elapsed.tv_sec == 0 && elapsed.tv_nsec < 20000000LL) {
 			sleep_time.tv_nsec = 20000000LL - elapsed.tv_nsec;
 			nanosleep(&sleep_time, NULL);
 		}
 		last = now;
 	}
 	return 0;
 }
 
 /* FIXME: need to remove event masks from all widgets when removing client */
 static void
 ltkd_mainloop(ltk_window *window) {
 	fd_set rfds, wfds;
 	int retval;
 	int clifd;
 	struct timeval tv;
 	tv.tv_sec = 0;
 	tv.tv_usec = 0;
 
 	FD_ZERO(&sock_state.rallfds);
 	FD_ZERO(&sock_state.wallfds);
 
 	if ((sock_state.listenfd = listen_sock(sock_path)) < 0)
 		ltkd_fatal_errno("Error listening on socket.\n");
 
 	FD_SET(sock_state.listenfd, &sock_state.rallfds);
 	sock_state.maxfd = sock_state.listenfd;
 
 	printf("%lu", ltk_renderer_get_window_id(main_window->renderwindow));
 	fflush(stdout);
 	if (daemonize_flag)
 		daemonize();
 
 	ltk_mainloop_init();
 
 	while (running) {
 		rfds = sock_state.rallfds;
 		wfds = sock_state.wallfds;
 		retval = select(sock_state.maxfd + 1, &rfds, &wfds, NULL, &tv);
 		if (retval > 0) {
 			if (FD_ISSET(sock_state.listenfd, &rfds)) {
 				if ((clifd = accept_sock(sock_state.listenfd)) < 0) {
 					/* FIXME: Just log this! */
 					ltkd_fatal_errno("Error accepting socket connection.\n");
 				}
 				int i = add_client(clifd);
 				FD_SET(clifd, &sock_state.rallfds);
 				FD_SET(clifd, &sock_state.wallfds);
 				if (clifd > sock_state.maxfd)
 					sock_state.maxfd = clifd;
 				if (i > maxsocket)
 					maxsocket = i;
 				continue;
 			}
 			for (int i = 0; i <= maxsocket; i++) {
 				if ((clifd = sockets[i].fd) < 0)
 					continue;
 				if (FD_ISSET(clifd, &rfds)) {
 					/* FIXME: better error handling - this assumes error
 					   is always because read would block */
 					/* FIXME: maybe maximum number of iterations here to
 					   avoid choking on a lot of data? although such a
 					   large amount of data would probably cause other
 					   problems anyways */
 					/* or maybe measure time and break after max time? */
 					int ret;
 					while ((ret = read_sock(&sockets[i])) == 1) {
 						process_commands(window, i);
 					}
 					if (ret == 0) {
 						ltkd_widget_remove_client(i);
 						FD_CLR(clifd, &sock_state.rallfds);
 						FD_CLR(clifd, &sock_state.wallfds);
 						sockets[i].fd = -1;
 						/* FIXME: what to do on error? */
 						close(clifd);
 						int newmaxsocket = -1;
 						for (int j = 0; j <= maxsocket; j++) {
 							if (sockets[j].fd >= 0)
 								newmaxsocket = j;
 						}
 						maxsocket = newmaxsocket;
 						if (maxsocket == -1) {
 							ltkd_quit();
 							break;
 						}
 					}
 				}
 				/* FIXME: maybe ignore SIGPIPE signal - then don't call FD_CLR
 				   for wallfds above but rather when write fails with EPIPE */
 				/* -> this would possibly allow data to be written still in the
 				   hypothetical scenario that only the writing end of the socket
 				   is closed (and ltkd wouldn't crash if only the reading end is
 				   closed) */
 				if (FD_ISSET(clifd, &wfds)) {
 					/* FIXME: also call in loop like reading above */
 					write_sock(&sockets[i]);
 				}
 			}
 		}
 
 		ltk_mainloop_step(1);
 	}
 
 	ltkd_cleanup();
 }
 
 /* largely copied from APUE */
 static void
 daemonize(void) {
 	pid_t pid;
 	struct sigaction sa;
 
 	fflush(stdout);
 	fflush(stderr);
 	fflush(ltkd_logfile);
 
 	if ((pid = fork()) < 0)
 		ltkd_fatal_errno("Can't fork.\n");
 	else if (pid != 0)
 		exit(0);
 	setsid();
 
 	sa.sa_handler = SIG_IGN;
 	sigemptyset(&sa.sa_mask);
 	sa.sa_flags = 0;
 	if (sigaction(SIGHUP, &sa, NULL) < 0)
 		ltkd_fatal_errno("Unable to ignore SIGHUP.\n");
 	if ((pid  = fork()) < 0)
 		ltkd_fatal_errno("Can't fork.\n");
 	else if (pid != 0)
 		exit(0);
 
 	/* FIXME: does this cause any issues with the lazy initialization of pango/fontconfig? */
 	if (chdir("/") < 0)
 		ltkd_fatal_errno("Can't change directory to root.\n");
 
 	/* FIXME: error handling */
 	int devnull = open("/dev/null", O_RDONLY);
 	if (devnull >= 0)
 		dup2(devnull, fileno(stdin));
 	dup2(fileno(ltkd_logfile), fileno(stdout));
 	dup2(fileno(ltkd_logfile), fileno(stderr));
 }
 
 static char *
 get_sock_path(char *basedir, unsigned long id) {
 	int len;
 	char *path;
 
 	len = strlen(basedir);
 	/* FIXME: MAKE SURE THIS IS ACTUALLY BIG ENOUGH! */
 	path = ltk_malloc(len + 20);
 	/* FIXME: also check for less than 0 */
 	if (snprintf(path, len + 20, "%s/%lu.sock", basedir, id) >= len + 20)
 		ltkd_fatal("Tell lumidify to fix his code.\n");
 
 	return path;
 }
 
 static FILE *
 open_log(char *dir) {
 	FILE *f;
 	char *path;
 
 	path = ltk_strcat_useful(dir, "/ltkd.log");
 	if (!path)
 		return NULL;
 	f = fopen(path, "a");
 	if (!f) {
 		ltk_free(path);
 		return NULL;
 	}
 	ltk_free(path);
 
 	return f;
 }
 
 static void
 ltkd_cleanup(void) {
 	if (sock_path) {
 		/* FIXME: somewhat misleading warning message */
 		if (base_dir_fd >= 0)
 			unlinkat(base_dir_fd, sock_path, 0);
 		else
 			ltk_warn("Unable to remove socket file!\n");
 		ltk_free(sock_path);
 	}
 	if (base_dir_fd >= 0)
 		close(base_dir_fd);
 	if (sock_state.listenfd >= 0)
 		close(sock_state.listenfd);
 	if (ltkd_dir)
 		ltk_free(ltkd_dir);
 	if (ltkd_logfile)
 		fclose(ltkd_logfile);
 
 	for (int i = 0; i < MAX_SOCK_CONNS; i++) {
 		if (sockets[i].fd >= 0)
 			close(sockets[i].fd);
 		if (sockets[i].read)
 			ltk_free(sockets[i].read);
 		if (sockets[i].to_write)
 			ltk_free(sockets[i].to_write);
 		if (sockets[i].tokens.tokens)
 			ltk_free(sockets[i].tokens.tokens);
 	}
 
 	ltkd_widgets_cleanup();
 	main_window = NULL;
 	ltk_deinit();
 }
 
 static void
 ltkd_quit(void) {
 	running = 0;
 }
 
 static void
 ltkd_log_msg(const char *mode, const char *format, va_list args) {
 	char logtime[25]; /* FIXME: This should always be big enough, right? */
 	time_t clock;
 	struct tm *timeptr;
 
 	time(&clock);
 	timeptr = localtime(&clock);
 	strftime(logtime, 25, "%Y-%m-%d %H:%M:%S", timeptr);
 
 	if (main_window)
 		fprintf(stderr, "%s ltkd(%lu) %s: ", logtime, ltk_renderer_get_window_id(main_window->renderwindow), mode);
 	else
 		fprintf(stderr, "%s ltkd(?) %s: ", logtime, mode);
 	vfprintf(stderr, format, args);
 }
 
 static int
 ltkd_set_root_widget_cmd(
     ltk_window *window,
     ltkd_cmd_token *tokens,
     int num_tokens,
     ltkd_error *err) {
 	ltkd_widget *widget;
 	if (num_tokens != 2) {
 		err->type = ERR_INVALID_NUMBER_OF_ARGUMENTS;
 		err->arg = -1;
 		return 1;
 	} else if (tokens[1].contains_nul) {
 		err->type = ERR_INVALID_ARGUMENT;
 		err->arg = 1;
 		return 1;
 	}
 	widget = ltkd_get_widget(tokens[1].text, LTK_WIDGET_UNKNOWN, err);
 	if (!widget) {
 		err->arg = 1;
 		return 1;
 	}
 	ltk_window_set_root_widget(window, widget->widget);
 
 	return 0;
 }
 
 /* Push a token onto `token_list`, resizing the buffer if necessary.
    Returns -1 on error, 0 otherwise.
    Note: The token is not copied, it is only added directly. */
 static int
 push_token(struct token_list *tl, char *token) {
 	int new_size;
 	if (tl->num_tokens >= tl->num_alloc) {
 		new_size = (tl->num_alloc * 2) > (tl->num_tokens + 1) ?
 			   (tl->num_alloc * 2) : (tl->num_tokens + 1);
 		ltkd_cmd_token *new = ltk_reallocarray(tl->tokens, new_size, sizeof(ltkd_cmd_token));
 		if (!new) return -1;
 		tl->tokens = new;
 		tl->num_alloc = new_size;
 	}
 	tl->tokens[tl->num_tokens].text = token;
 	tl->tokens[tl->num_tokens].len = 0;
 	tl->tokens[tl->num_tokens++].contains_nul = 0;
 
 	return 0;
 }
 
 /* Add a new client to the socket list and return the index in `sockets`.
    Returns -1 if there is no space for a new client. */
 static int
 add_client(int fd) {
 	for (int i = 0; i < MAX_SOCK_CONNS; i++) {
 		if (sockets[i].fd == -1) {
 			sockets[i].fd = fd;
 			sockets[i].event_mask = ~0; /* FIXME */
 			sockets[i].read_len = 0;
 			sockets[i].write_len = 0;
 			sockets[i].write_cur = 0;
 			sockets[i].offset = 0;
 			sockets[i].in_str = 0;
 			sockets[i].read_cur = 0;
 			sockets[i].bs = 0;
 			sockets[i].tokens.num_tokens = 0;
 			sockets[i].last_seq = 0;
 			return i;
 		}
 	}
 
 	return -1;
 }
 
 /* largely copied from APUE */
 /* Listen on the socket at `sock_path`.
    Returns the file descriptor of the opened socket on success.
    Returns -1 if `sock_path` is too long
            -2 if the socket could not be created
            -3 if the socket could not be bound to the path
            -4 if the socket could not be listened on */
 static int
 listen_sock(const char *sock_path) {
 	int fd, len, err, rval;
 	struct sockaddr_un un;
 
 	if (strlen(sock_path) >= sizeof(un.sun_path)) {
 		errno = ENAMETOOLONG;
 		return -1;
 	}
 
 	if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0)
 		return -2;
 
 	unlink(sock_path);
 
 	memset(&un, 0, sizeof(un));
 	un.sun_family = AF_UNIX;
 	strcpy(un.sun_path, sock_path);
 	len = offsetof(struct sockaddr_un, sun_path) + strlen(sock_path);
 	if (bind(fd, (struct sockaddr *)&un, len) < 0) {
 		rval = -3;
 		goto errout;
 	}
 
 	if (listen(fd, 10) < 0) {
 		rval = -4;
 		goto errout;
 	}
 
 	return fd;
 
 errout:
 	err = errno;
 	close(fd);
 	errno = err;
 	return rval;
 }
 
 /* Accept a socket connection on the listening socket `listenfd`.
    Returns the file descriptor of the accepted client on success.
    Returns -1 if there was an error. */
 static int
 accept_sock(int listenfd) {
 	int clifd;
 	socklen_t len;
 	struct sockaddr_un un;
 
 	len = sizeof(un);
 	if ((clifd = accept(listenfd, (struct sockaddr *)&un, &len)) < 0) {
 		return -1;
 	}
 	if (ltkd_set_nonblock(clifd)) {
 		/* FIXME: what could even be done if close fails? */
 		close(clifd);
 		return -1;
 	}
 
 	return clifd;
 }
 
 /* Read up to READ_BLK_SIZE bytes from the socket `sock`.
    Returns -1 if an error occurred, 0 if the connection was closed, 1 otherwise.
    Note: Returning 1 on success is weird, but it could also be confusing to
    return 0 on success when `read` returns that to mean that the connection
    was closed. */
 static int
 read_sock(struct ltkd_sock_info *sock) {
 	int nread;
 	char *old = sock->read;
 	ltk_grow_string(&sock->read, &sock->read_alloc, sock->read_len + READ_BLK_SIZE);
 	/* move tokens to new addresses - this was added as an
 	   afterthought and really needs to be cleaned up */
 	if (sock->read != old) {
 		for (int i = 0; i < sock->tokens.num_tokens; i++) {
 			sock->tokens.tokens[i].text = sock->read + (sock->tokens.tokens[i].text - old);
 		}
 	}
 	nread = read(sock->fd, sock->read + sock->read_len, READ_BLK_SIZE);
 	if (nread == -1 || nread == 0)
 		return nread;
 	sock->read_len += nread;
 
 	return 1;
 }
 
 /* Write up to WRITE_BLK_SIZE bytes to the socket.
    Returns -1 on error, 0 otherwise. */
 static int
 write_sock(struct ltkd_sock_info *sock) {
 	if (sock->write_len == sock->write_cur)
 		return 0;
 	int write_len = WRITE_BLK_SIZE > sock->write_len - sock->write_cur ?
 			sock->write_len - sock->write_cur : WRITE_BLK_SIZE;
 	int nwritten = write(sock->fd, sock->to_write + sock->write_cur, write_len);
 	if (nwritten == -1)
 		return nwritten;
 	sock->write_cur += nwritten;
 
 	/* check if any sockets have text to write */
 	if (sock->write_cur == sock->write_len) {
 		int found = 0;
 		for (int i = 0; i < maxsocket; i++) {
 			if (sockets[i].fd != -1 &&
 			    sockets[i].write_cur != sockets[i].write_len) {
 				found = 1;
 				break;
 			}
 		}
 		if (!found)
 			sock_write_available = 0;
 	}
 
 	return 0;
 }
 
 static void
 move_write_pos(struct ltkd_sock_info *sock) {
 	/* FIXME: also resize if too large */
 	if (sock->write_cur > 0) {
 		memmove(sock->to_write, sock->to_write + sock->write_cur,
 		        sock->write_len - sock->write_cur);
 		sock->write_len -= sock->write_cur;
 		sock->write_cur = 0;
 	}
 }
 
 /* Queue `str` to be written to the socket. If len is < 0, it is set to `strlen(str)`.
    Returns -1 on error, 0 otherwise.
    Note: The string must include all '\n', etc. as defined in the protocol. This
    function just adds the given string verbatim. */
 int
 ltkd_queue_sock_write(int client, const char *str, int len) {
 	if (client < 0 || client >= MAX_SOCK_CONNS || sockets[client].fd == -1)
 		return 1;
 	/* this is always large enough to hold a uint32_t and " \0" */
 	char num[12];
 	struct ltkd_sock_info *sock = &sockets[client];
 	move_write_pos(sock);
 	if (len < 0)
 		len = strlen(str);
 
 	int numlen = snprintf(num, sizeof(num), "%"PRIu32" ", sock->last_seq);
 	if (numlen < 0 || (unsigned)numlen >= sizeof(num))
 		ltkd_fatal("There's a bug in the universe.\n");
 	if (sock->write_alloc - sock->write_len < len + numlen)
 		ltk_grow_string(&sock->to_write, &sock->write_alloc, sock->write_len + len + numlen);
 
 	(void)strncpy(sock->to_write + sock->write_len, num, numlen);
 	(void)strncpy(sock->to_write + sock->write_len + numlen, str, len);
 	sock->write_len += len + numlen;
 
 	sock_write_available = 1;
 
 	return 0;
 }
 
 int
 ltkd_queue_sock_write_fmt(int client, const char *fmt, ...) {
 	if (client < 0 || client >= MAX_SOCK_CONNS || sockets[client].fd == -1)
 		return 1;
 	struct ltkd_sock_info *sock = &sockets[client];
 	/* just to print the sequence number */
 	ltkd_queue_sock_write(client, "", 0);
 	va_list args;
 	va_start(args, fmt);
 	int len = vsnprintf(sock->to_write + sock->write_len, sock->write_alloc - sock->write_len, fmt, args);
 	if (len < 0) {
 		ltkd_fatal("Unable to print formatted text to socket.\n");
 	} else if (len >= sock->write_alloc - sock->write_len) {
 		va_end(args);
 		va_start(args, fmt);
 		/* snprintf always writes '\0', even though we don't actually need it here */
 		ltk_grow_string(&sock->to_write, &sock->write_alloc, sock->write_len + len + 1);
 		vsnprintf(sock->to_write + sock->write_len, sock->write_alloc - sock->write_len, fmt, args);
 	}
 	va_end(args);
 	sock->write_len += len;
 	sock_write_available = 1;
 
 	return 0;
 }
 
 /* Tokenize the current read buffer in `sock`.
    Returns 0 immediately if the end of a command was encountered, 1 otherwise. */
 static int
 tokenize_command(struct ltkd_sock_info *sock) {
 	for (; sock->read_cur < sock->read_len; sock->read_cur++) {
 		/* FIXME: strip extra whitespace? Or maybe just have a "hard" protocol where it always has to be one space. */
 		if (!sock->in_token) {
 			push_token(&sock->tokens, sock->read + sock->read_cur - sock->offset);
 			sock->in_token = 1;
 		}
 		if (sock->read[sock->read_cur] == '\\') {
 			sock->bs++;
 			if (sock->bs / 2)
 				sock->offset++;
 			else
 				sock->tokens.tokens[sock->tokens.num_tokens - 1].len++;
 			sock->bs %= 2;
 			sock->read[sock->read_cur-sock->offset] = '\\';
 		} else if (sock->read[sock->read_cur] == '\n' && !sock->in_str) {
 			sock->read[sock->read_cur-sock->offset] = '\0';
 			sock->read_cur++;
 			sock->offset = 0;
 			sock->in_token = 0;
 			sock->bs = 0;
 			return 0;
 		} else if (sock->read[sock->read_cur] == '"') {
 			sock->offset++;
 			if (sock->bs) {
 				sock->read[sock->read_cur-sock->offset] = '"';
 				sock->bs = 0;
 			} else {
 				sock->in_str = !sock->in_str;
 			}
 		} else if (sock->read[sock->read_cur] == ' ' && !sock->in_str) {
 			sock->read[sock->read_cur-sock->offset] = '\0';
 			sock->in_token = !sock->in_token;
 			sock->bs = 0;
 		} else {
 			sock->read[sock->read_cur-sock->offset] = sock->read[sock->read_cur];
 			/* FIXME: assert that num_tokens > 0 */
 			sock->tokens.tokens[sock->tokens.num_tokens - 1].len++;
 			if (sock->read[sock->read_cur] == '\0')
 				sock->tokens.tokens[sock->tokens.num_tokens - 1].contains_nul = 1;
 			sock->bs = 0;
 		}
 	}
 
 	return 1;
 }
 
 /* FIXME: currently no type-checking when setting specific widget mask */
 /* FIXME: this is really ugly and inefficient right now - it will be replaced with something
    more generic at some point (or maybe just with a binary protocol?) */
 static int
 handle_mask_command(int client, ltkd_cmd_token *tokens, size_t num_tokens, ltkd_error *err) {
 	if (num_tokens != 4 && num_tokens != 5) {
 		err->type = ERR_INVALID_NUMBER_OF_ARGUMENTS;
 		err->arg = -1;
 		return 1;
 	}
 	/* FIXME: make this nicer */
 	/* -> use generic cmd handling like the widgets */
 	if (tokens[1].contains_nul) {
 		err->type = ERR_INVALID_ARGUMENT;
 		err->arg = 1;
 		return 1;
 	} else if (tokens[2].contains_nul) {
 		err->type = ERR_INVALID_ARGUMENT;
 		err->arg = 2;
 		return 1;
 	} else if (tokens[3].contains_nul) {
 		err->type = ERR_INVALID_ARGUMENT;
 		err->arg = 3;
 		return 1;
 	} else if (num_tokens == 5 && tokens[4].contains_nul) {
 		err->type = ERR_INVALID_ARGUMENT;
 		err->arg = 4;
 		return 1;
 	}
 	uint32_t mask = 0;
 	int lock = 0;
 	int special = 0;
 	ltkd_widget *widget = ltkd_get_widget(tokens[1].text, LTK_WIDGET_UNKNOWN, err);
 	if (!widget) {
 		err->arg = 1;
 		return 1;
 	}
 	if (!strcmp(tokens[2].text, "widget")) {
 		if (!strcmp(tokens[3].text, "mousepress")) {
 			mask = LTKD_PEVENTMASK_MOUSEPRESS;
 		} else if (!strcmp(tokens[3].text, "mouserelease")) {
 			mask = LTKD_PEVENTMASK_MOUSERELEASE;
 		} else if (!strcmp(tokens[3].text, "mousemotion")) {
 			mask = LTKD_PEVENTMASK_MOUSEMOTION;
 		} else if (!strcmp(tokens[3].text, "resize")) {
 			mask = LTKD_PEVENTMASK_RESIZE;
 		} else if (!strcmp(tokens[3].text, "statechange")) {
 			mask = LTKD_PEVENTMASK_STATECHANGE;
 		} else if (!strcmp(tokens[3].text, "none")) {
 			mask = LTKD_PEVENTMASK_NONE;
 		} else {
 			err->type = ERR_INVALID_ARGUMENT;
 			err->arg = 3;
 			return 1;
 		}
 	} else if (!strcmp(tokens[2].text, "menuentry")) {
 		if (!strcmp(tokens[3].text, "press")) {
 			mask = LTKD_PWEVENTMASK_MENUENTRY_PRESS;
 		} else if (!strcmp(tokens[3].text, "none")) {
 			mask = LTKD_PWEVENTMASK_MENUENTRY_NONE;
 		} else {
 			err->type = ERR_INVALID_ARGUMENT;
 			err->arg = 3;
 			return 1;
 		}
 		special = 1;
 	} else if (!strcmp(tokens[2].text, "button")) {
 		if (!strcmp(tokens[3].text, "press")) {
 			mask = LTKD_PWEVENTMASK_BUTTON_PRESS;
 		} else if (!strcmp(tokens[3].text, "none")) {
 			mask = LTKD_PWEVENTMASK_BUTTON_NONE;
 		} else {
 			err->type = ERR_INVALID_ARGUMENT;
 			err->arg = 3;
 			return 1;
 		}
 		special = 1;
 	} else {
 		err->type = ERR_INVALID_ARGUMENT;
 		err->arg = 2;
 		return 1;
 	}
 	if (num_tokens == 5) {
 		if (!strcmp(tokens[4].text, "lock")) {
 			lock = 1;
 		} else {
 			err->type = ERR_INVALID_ARGUMENT;
 			err->arg = 4;
 			return 1;
 		}
 	}
 
 	if (!strcmp(tokens[0].text, "mask-add")) {
 		if (lock) {
 			if (special)
 				ltkd_widget_add_to_event_lwmask(widget, client, mask);
 			else
 				ltkd_widget_add_to_event_lmask(widget, client, mask);
 		} else {
 			if (special)
 				ltkd_widget_add_to_event_wmask(widget, client, mask);
 			else
 				ltkd_widget_add_to_event_mask(widget, client, mask);
 		}
 	} else if (!strcmp(tokens[0].text, "mask-set")) {
 		if (lock) {
 			if (special)
 				ltkd_widget_set_event_lwmask(widget, client, mask);
 			else
 				ltkd_widget_set_event_lmask(widget, client, mask);
 		} else {
 			if (special)
 				ltkd_widget_set_event_wmask(widget, client, mask);
 			else
 				ltkd_widget_set_event_mask(widget, client, mask);
 		}
 	} else if (!strcmp(tokens[0].text, "mask-remove")) {
 		if (lock) {
 			if (special)
 				ltkd_widget_remove_from_event_lwmask(widget, client, mask);
 			else
 				ltkd_widget_remove_from_event_lmask(widget, client, mask);
 		} else {
 			if (special)
 				ltkd_widget_remove_from_event_wmask(widget, client, mask);
 			else
 				ltkd_widget_remove_from_event_mask(widget, client, mask);
 		}
 	} else {
 		err->type = ERR_INVALID_COMMAND;
 		err->arg = 0;
 		return 1;
 	}
 	return 0;
 }
 
 /* Process the commands as they are read from the socket. */
 /* Returns 1 if command was 'event-unlock true',
    -1 if command was 'event-unlock false', 0 otherwise. */
 static int
 process_commands(ltk_window *window, int client) {
 	if (client < 0 || client >= MAX_SOCK_CONNS || sockets[client].fd == -1)
 		return 0;
 	struct ltkd_sock_info *sock = &sockets[client];
 	ltkd_cmd_token *tokens;
 	int num_tokens;
 	ltkd_error errdetail = {ERR_NONE, -1};
 	int err;
 	int retval = 0;
 	int last = 0;
 	uint32_t seq;
 	const char *errstr;
 	int contains_nul = 0;
 	while (!tokenize_command(sock)) {
 		contains_nul = 0;
 		err = 0;
 		tokens = sock->tokens.tokens;
 		num_tokens = sock->tokens.num_tokens;
 		if (num_tokens < 2) {
 			errdetail.type = ERR_INVALID_COMMAND;
 			errdetail.arg = -1;
 			err = 1;
 		} else {
 			contains_nul = tokens[0].contains_nul;
 			seq = (uint32_t)ltk_strtonum(tokens[0].text, 0, UINT32_MAX, &errstr);
 			tokens++;
 			num_tokens--;
 			if (errstr || contains_nul) {
 				errdetail.type = ERR_INVALID_SEQNUM;
 				errdetail.arg = -1;
 				err = 1;
 				seq = sock->last_seq;
 			} else if (tokens[0].contains_nul) {
 				errdetail.type = ERR_INVALID_ARGUMENT;
 				errdetail.arg = 0;
 				err = 1;
 				seq = sock->last_seq;
 			} else if (strcmp(tokens[0].text, "set-root-widget") == 0) {
 				err = ltkd_set_root_widget_cmd(window, tokens, num_tokens, &errdetail);
 			} else if (strcmp(tokens[0].text, "quit") == 0) {
 				ltkd_quit();
 				last = 1;
 			} else if (strcmp(tokens[0].text, "destroy") == 0) {
 				err = ltkd_widget_destroy_cmd(window, tokens, num_tokens, &errdetail);
 			} else if (strncmp(tokens[0].text, "mask", 4) == 0) {
 				err = handle_mask_command(client, tokens, num_tokens, &errdetail);
 			} else if (strcmp(tokens[0].text, "event-unlock") == 0) {
 				if (num_tokens != 2) {
 					errdetail.type = ERR_INVALID_NUMBER_OF_ARGUMENTS;
 					errdetail.arg = -1;
 					err = 1;
 				} else if (!tokens[1].contains_nul && strcmp(tokens[1].text, "true") == 0) {
 					retval = 1;
 				} else if (!tokens[1].contains_nul && strcmp(tokens[1].text, "false") == 0) {
 					retval = -1;
 				} else {
 					err = 1;
 					errdetail.type = ERR_INVALID_ARGUMENT;
 					errdetail.arg = 1;
 				}
 				last = 1;
 			} else {
 				int found = 0;
 				for (size_t i = 0; i < LENGTH(widget_funcs); i++) {
 					if (widget_funcs[i].cmd && !strcmp(tokens[0].text, widget_funcs[i].name)) {
 						err = widget_funcs[i].cmd(window, tokens, num_tokens, &errdetail);
 						found = 1;
 					}
 				}
 				if (!found) {
 					errdetail.type = ERR_INVALID_COMMAND;
 					errdetail.arg = -1;
 					err = 1;
 				}
 			}
 			sock->tokens.num_tokens = 0;
 			sock->last_seq = seq;
 		}
 		if (err) {
 			const char *errmsg = errtype_to_string(errdetail.type);
 			if (ltkd_queue_sock_write_fmt(client, "err %d %d \"%s\"\n", errdetail.type, errdetail.arg, errmsg))
 				ltkd_fatal("Unable to queue socket write.\n");
 		} else {
 			if (ltkd_queue_sock_write(client, "res ok\n", -1)) {
 				ltkd_fatal("Unable to queue socket write.\n");
 			}
 		}
 		if (last)
 			break;
 	}
 	if (sock->tokens.num_tokens > 0 && sock->tokens.tokens[0].text != sock->read) {
 		memmove(sock->read, sock->tokens.tokens[0].text, sock->read + sock->read_len - sock->tokens.tokens[0].text);
 		ptrdiff_t offset = sock->tokens.tokens[0].text - sock->read;
 		/* Hmm, seems a bit ugly... */
 		for (int i = 0; i < sock->tokens.num_tokens; i++) {
 			sock->tokens.tokens[i].text -= offset;
 		}
 		sock->read_len -= offset;
 		sock->read_cur -= offset;
 	} else if (sock->tokens.num_tokens == 0) {
 		sock->read_len = 0;
 		sock->read_cur = 0;
 	}
 	return retval;
 }
 
 LTK_GEN_LOG_FUNCS(ltkd, ltkd_log_msg, ltkd_cleanup)