desktop-tools/dwmstatus.c

/*
 * dwmstatus.c: simple PulseAudio-enabled dwmstatus
 *
 * Copyright (c) 2015 - 2016, Přemysl Janouch <p.janouch@gmail.com>
 *
 * 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.
 *
 */

#define LIBERTY_WANT_POLLER
#define LIBERTY_WANT_ASYNC
#define LIBERTY_WANT_PROTO_MPD

#define _GNU_SOURCE // openat

#include "config.h"
#undef PROGRAM_NAME
#define PROGRAM_NAME "dwmstatus"
#include "liberty/liberty.c"

#include <dirent.h>
#include <spawn.h>

#include <X11/Xlib.h>
#include <X11/keysym.h>
#include <X11/XF86keysym.h>
#include <X11/XKBlib.h>

#include <pulse/mainloop.h>
#include <pulse/context.h>
#include <pulse/error.h>
#include <pulse/introspect.h>
#include <pulse/subscribe.h>

// --- Utilities ---------------------------------------------------------------

static void
log_message_custom (void *user_data, const char *quote, const char *fmt,
	va_list ap)
{
	(void) user_data;
	FILE *stream = stdout;

	fprintf (stream, PROGRAM_NAME ": ");
	fputs (quote, stream);
	vfprintf (stream, fmt, ap);
	fputs ("\n", stream);
}

static void
set_dwm_status (Display *dpy, const char *str)
{
	print_debug ("setting status to: %s", str);
	XStoreName (dpy, DefaultRootWindow (dpy), str);
	XSync (dpy, False);
}

// --- PulseAudio mainloop abstraction -----------------------------------------

struct pa_io_event
{
	LIST_HEADER (pa_io_event)

	pa_mainloop_api *api;               ///< Parent structure
	struct poller_fd fd;                ///< Underlying FD event

	pa_io_event_cb_t dispatch;          ///< Dispatcher
	pa_io_event_destroy_cb_t free;      ///< Destroyer
	void *user_data;                    ///< User data
};

struct pa_time_event
{
	LIST_HEADER (pa_time_event)

	pa_mainloop_api *api;               ///< Parent structure
	struct poller_timer timer;          ///< Underlying timer event

	pa_time_event_cb_t dispatch;        ///< Dispatcher
	pa_time_event_destroy_cb_t free;    ///< Destroyer
	void *user_data;                    ///< User data
};

struct pa_defer_event
{
	LIST_HEADER (pa_defer_event)

	pa_mainloop_api *api;               ///< Parent structure
	struct poller_idle idle;            ///< Underlying idle event

	pa_defer_event_cb_t dispatch;       ///< Dispatcher
	pa_defer_event_destroy_cb_t free;   ///< Destroyer
	void *user_data;                    ///< User data
};

struct poller_pa
{
	struct poller *poller;              ///< The underlying event loop
	int result;                         ///< Result on quit
	bool running;                       ///< Not quitting

	pa_io_event *io_list;               ///< I/O events
	pa_time_event *time_list;           ///< Timer events
	pa_defer_event *defer_list;         ///< Deferred events
};

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

static short
poller_pa_flags_to_events (pa_io_event_flags_t flags)
{
	short result = 0;
	if (flags & PA_IO_EVENT_ERROR)   result |= POLLERR;
	if (flags & PA_IO_EVENT_HANGUP)  result |= POLLHUP;
	if (flags & PA_IO_EVENT_INPUT)   result |= POLLIN;
	if (flags & PA_IO_EVENT_OUTPUT)  result |= POLLOUT;
	return result;
}

static pa_io_event_flags_t
poller_pa_events_to_flags (short events)
{
	pa_io_event_flags_t result = 0;
	if (events & POLLERR)  result |= PA_IO_EVENT_ERROR;
	if (events & POLLHUP)  result |= PA_IO_EVENT_HANGUP;
	if (events & POLLIN)   result |= PA_IO_EVENT_INPUT;
	if (events & POLLOUT)  result |= PA_IO_EVENT_OUTPUT;
	return result;
}

static struct timeval
poller_pa_get_current_time (void)
{
	struct timeval tv;
#ifdef _POSIX_TIMERS
	struct timespec tp;
	hard_assert (clock_gettime (CLOCK_REALTIME, &tp) != -1);
	tv.tv_sec = tp.tv_sec;
	tv.tv_usec = tp.tv_nsec / 1000;
#else
	gettimeofday (&tv, NULL);
#endif
	return tv;
}

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

static void
poller_pa_io_dispatcher (const struct pollfd *pfd, void *user_data)
{
	pa_io_event *self = user_data;
	self->dispatch (self->api, self,
		pfd->fd, poller_pa_events_to_flags (pfd->revents), self->user_data);
}

static void
poller_pa_io_enable (pa_io_event *self, pa_io_event_flags_t events)
{
	struct poller_fd *fd = &self->fd;
	if (events)
		poller_fd_set (fd, poller_pa_flags_to_events (events));
	else
		poller_fd_reset (fd);
}

static pa_io_event *
poller_pa_io_new (pa_mainloop_api *api, int fd_, pa_io_event_flags_t events,
	pa_io_event_cb_t cb, void *userdata)
{
	pa_io_event *self = xcalloc (1, sizeof *self);
	self->api = api;
	self->dispatch = cb;
	self->user_data = userdata;

	struct poller_pa *data = api->userdata;
	struct poller_fd *fd = &self->fd;
	poller_fd_init (fd, data->poller, fd_);
	fd->user_data = self;
	fd->dispatcher = poller_pa_io_dispatcher;

	// FIXME: under x2go PA tries to register twice for the same FD,
	//   which fails with our curent poller implementation;
	//   we could maintain a list of { poller_fd, listeners } structures;
	//   or maybe we're doing something wrong, which is yet to be determined
	poller_pa_io_enable (self, events);
	LIST_PREPEND (data->io_list, self);
	return self;
}

static void
poller_pa_io_free (pa_io_event *self)
{
	if (self->free)
		self->free (self->api, self, self->user_data);

	struct poller_pa *data = self->api->userdata;
	poller_fd_reset (&self->fd);
	LIST_UNLINK (data->io_list, self);
	free (self);
}

static void
poller_pa_io_set_destroy (pa_io_event *self, pa_io_event_destroy_cb_t cb)
{
	self->free = cb;
}

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

static void
poller_pa_time_dispatcher (void *user_data)
{
	pa_time_event *self = user_data;
	// XXX: the meaning of the time argument is undocumented,
	//   so let's just put current Unix time in there
	struct timeval now = poller_pa_get_current_time ();
	self->dispatch (self->api, self, &now, self->user_data);
}

static void
poller_pa_time_restart (pa_time_event *self, const struct timeval *tv)
{
	struct poller_timer *timer = &self->timer;
	if (tv)
	{
		struct timeval now = poller_pa_get_current_time ();
		poller_timer_set (timer,
			(tv->tv_sec  - now.tv_sec)  * 1000 +
			(tv->tv_usec - now.tv_usec) / 1000);
	}
	else
		poller_timer_reset (timer);
}

static pa_time_event *
poller_pa_time_new (pa_mainloop_api *api, const struct timeval *tv,
	pa_time_event_cb_t cb, void *userdata)
{
	pa_time_event *self = xcalloc (1, sizeof *self);
	self->api = api;
	self->dispatch = cb;
	self->user_data = userdata;

	struct poller_pa *data = api->userdata;
	struct poller_timer *timer = &self->timer;
	poller_timer_init (timer, data->poller);
	timer->user_data = self;
	timer->dispatcher = poller_pa_time_dispatcher;

	poller_pa_time_restart (self, tv);
	LIST_PREPEND (data->time_list, self);
	return self;
}

static void
poller_pa_time_free (pa_time_event *self)
{
	if (self->free)
		self->free (self->api, self, self->user_data);

	struct poller_pa *data = self->api->userdata;
	poller_timer_reset (&self->timer);
	LIST_UNLINK (data->time_list, self);
	free (self);
}

static void
poller_pa_time_set_destroy (pa_time_event *self, pa_time_event_destroy_cb_t cb)
{
	self->free = cb;
}

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

static void
poller_pa_defer_dispatcher (void *user_data)
{
	pa_defer_event *self = user_data;
	self->dispatch (self->api, self, self->user_data);
}

static pa_defer_event *
poller_pa_defer_new (pa_mainloop_api *api,
	pa_defer_event_cb_t cb, void *userdata)
{
	pa_defer_event *self = xcalloc (1, sizeof *self);
	self->api = api;
	self->dispatch = cb;
	self->user_data = userdata;

	struct poller_pa *data = api->userdata;
	struct poller_idle *idle = &self->idle;
	poller_idle_init (idle, data->poller);
	idle->user_data = self;
	idle->dispatcher = poller_pa_defer_dispatcher;

	poller_idle_set (idle);
	LIST_PREPEND (data->defer_list, self);
	return self;
}

static void
poller_pa_defer_enable (pa_defer_event *self, int enable)
{
	struct poller_idle *idle = &self->idle;
	if (enable)
		poller_idle_set (idle);
	else
		poller_idle_reset (idle);
}

static void
poller_pa_defer_free (pa_defer_event *self)
{
	if (self->free)
		self->free (self->api, self, self->user_data);

	struct poller_pa *data = self->api->userdata;
	poller_idle_reset (&self->idle);
	LIST_UNLINK (data->defer_list, self);
	free (self);
}

static void
poller_pa_defer_set_destroy (pa_defer_event *self,
	pa_defer_event_destroy_cb_t cb)
{
	self->free = cb;
}

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

static void
poller_pa_quit (pa_mainloop_api *api, int retval)
{
	struct poller_pa *data = api->userdata;
	data->result = retval;
	data->running = false;
}

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

static struct pa_mainloop_api g_poller_pa_template =
{
	.io_new            = poller_pa_io_new,
	.io_enable         = poller_pa_io_enable,
	.io_free           = poller_pa_io_free,
	.io_set_destroy    = poller_pa_io_set_destroy,

	.time_new          = poller_pa_time_new,
	.time_restart      = poller_pa_time_restart,
	.time_free         = poller_pa_time_free,
	.time_set_destroy  = poller_pa_time_set_destroy,

	.defer_new         = poller_pa_defer_new,
	.defer_enable      = poller_pa_defer_enable,
	.defer_free        = poller_pa_defer_free,
	.defer_set_destroy = poller_pa_defer_set_destroy,

	.quit              = poller_pa_quit,
};

static struct pa_mainloop_api *
poller_pa_new (struct poller *self)
{
	struct poller_pa *data = xcalloc (1, sizeof *data);
	data->poller = self;

	struct pa_mainloop_api *api = xmalloc (sizeof *api);
	*api = g_poller_pa_template;
	api->userdata = data;
	return api;
}

static void
poller_pa_destroy (struct pa_mainloop_api *api)
{
	struct poller_pa *data = api->userdata;

	LIST_FOR_EACH (pa_io_event, iter, data->io_list)
		poller_pa_io_free (iter);
	LIST_FOR_EACH (pa_time_event, iter, data->time_list)
		poller_pa_time_free (iter);
	LIST_FOR_EACH (pa_defer_event, iter, data->defer_list)
		poller_pa_defer_free (iter);

	free (data);
	free (api);
}

/// Since our poller API doesn't care much about continuous operation,
/// we need to provide that in the PulseAudio abstraction itself
static int
poller_pa_run (struct pa_mainloop_api *api)
{
	struct poller_pa *data = api->userdata;
	data->running = true;
	while (data->running)
		poller_run (data->poller);
	return data->result;
}

// --- NUT ---------------------------------------------------------------------

// More or less copied and pasted from the MPD client.  This code doesn't even
// deserve much love, the protocol is somehow even worse than MPD's.
//
// http://www.networkupstools.org/docs/developer-guide.chunked/ar01s09.html

// This was written by loosely following the top comment in NUT's parseconf.c.

enum nut_parser_state
{
	NUT_STATE_START_LINE,               ///< Start of a line
	NUT_STATE_BETWEEN,                  ///< Between words, expecting non-WS
	NUT_STATE_UNQUOTED,                 ///< Within unquoted word
	NUT_STATE_UNQUOTED_ESCAPE,          ///< Dtto after a backslash
	NUT_STATE_QUOTED,                   ///< Within a quoted word
	NUT_STATE_QUOTED_ESCAPE,            ///< Dtto after a backslash
	NUT_STATE_QUOTED_END                ///< End of word, expecting WS
};

struct nut_parser
{
	enum nut_parser_state state;        ///< Parser state
	struct str current_field;           ///< Current field

	// Public:

	struct str_vector fields;           ///< Line fields
};

static void
nut_parser_init (struct nut_parser *self)
{
	self->state = NUT_STATE_START_LINE;
	str_init (&self->current_field);
	str_vector_init (&self->fields);
}

static void
nut_parser_free (struct nut_parser *self)
{
	str_free (&self->current_field);
	str_vector_free (&self->fields);
}

static int
nut_parser_end_field (struct nut_parser *self, char c)
{
	str_vector_add (&self->fields, self->current_field.str);
	str_reset (&self->current_field);

	if (c == '\n')
	{
		self->state = NUT_STATE_START_LINE;
		return 1;
	}

	self->state = NUT_STATE_BETWEEN;
	return 0;
}

/// Returns 1 if a complete line has been read, -1 on error, 0 otherwise
static int
nut_parser_push (struct nut_parser *self, char c)
{
	switch (self->state)
	{
	case NUT_STATE_START_LINE:
		str_vector_reset (&self->fields);
		str_reset (&self->current_field);
		self->state = NUT_STATE_BETWEEN;
		// Fall-through

	case NUT_STATE_BETWEEN:
		if (c == '\\')
			self->state = NUT_STATE_UNQUOTED_ESCAPE;
		else if (c == '"')
			self->state = NUT_STATE_QUOTED;
		else if (c == '\n' && self->fields.len)
		{
			self->state = NUT_STATE_START_LINE;
			return 1;
		}
		else if (!isspace_ascii (c))
		{
			str_append_c (&self->current_field, c);
			self->state = NUT_STATE_UNQUOTED;
		}
		return 0;

	case NUT_STATE_UNQUOTED:
		if (c == '\\')
			self->state = NUT_STATE_UNQUOTED_ESCAPE;
		else if (c == '"')
			return -1;
		else if (!isspace_ascii (c))
			str_append_c (&self->current_field, c);
		else
			return nut_parser_end_field (self, c);
		return 0;

	case NUT_STATE_UNQUOTED_ESCAPE:
		str_append_c (&self->current_field, c);
		self->state = NUT_STATE_UNQUOTED;
		return 0;

	case NUT_STATE_QUOTED:
		if (c == '\\')
			self->state = NUT_STATE_QUOTED_ESCAPE;
		else if (c == '"')
			self->state = NUT_STATE_QUOTED_END;
		else
			str_append_c (&self->current_field, c);
		return 0;

	case NUT_STATE_QUOTED_ESCAPE:
		str_append_c (&self->current_field, c);
		self->state = NUT_STATE_QUOTED;
		return 0;

	case NUT_STATE_QUOTED_END:
		if (!isspace_ascii (c))
			return -1;
		return nut_parser_end_field (self, c);
	}

	// Silence the compiler
	hard_assert (!"unhandled NUT parser state");
	return -1;
}

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

struct nut_line
{
	LIST_HEADER (struct nut_line)

	struct str_vector fields;           ///< Parsed fields from the line
};

struct nut_response
{
	struct nut_line *data;              ///< Raw result data

	bool success;                       ///< Whether a general failure occured
	char *message;                      ///< Eventually an error ID string
};

/// Task completion callback
typedef void (*nut_client_task_cb)
	(const struct nut_response *response, void *user_data);

struct nut_client_task
{
	LIST_HEADER (struct nut_client_task)

	nut_client_task_cb callback;        ///< Callback on completion
	void *user_data;                    ///< User data
};

enum nut_client_state
{
	NUT_DISCONNECTED,                   ///< Not connected
	NUT_CONNECTING,                     ///< Currently connecting
	NUT_CONNECTED                       ///< Connected
};

struct nut_client
{
	struct poller *poller;              ///< Poller

	// Connection:

	enum nut_client_state state;        ///< Connection state
	struct connector *connector;        ///< Connection establisher

	int socket;                         ///< MPD socket
	struct str read_buffer;             ///< Input yet to be processed
	struct str write_buffer;            ///< Outut yet to be be sent out
	struct poller_fd socket_event;      ///< We can read from the socket

	// Protocol:

	struct nut_parser parser;           ///< Protocol parser
	struct nut_line *data;              ///< Data from last command
	struct nut_line *data_tail;         ///< Tail of data list
	bool in_list;                       ///< Currently within a list

	struct nut_client_task *tasks;      ///< Task queue
	struct nut_client_task *tasks_tail; ///< Tail of task queue

	// User configuration:

	void *user_data;                    ///< User data for callbacks

	/// Callback after connection has been successfully established
	void (*on_connected) (void *user_data);

	/// Callback for general failures or even normal disconnection;
	/// the interface is reinitialized
	void (*on_failure) (void *user_data);
};

static void nut_client_reset (struct nut_client *self);
static void nut_client_destroy_connector (struct nut_client *self);

static void
nut_client_init (struct nut_client *self, struct poller *poller)
{
	memset (self, 0, sizeof *self);

	self->poller = poller;
	self->socket = -1;

	str_init (&self->read_buffer);
	str_init (&self->write_buffer);

	nut_parser_init (&self->parser);

	poller_fd_init (&self->socket_event, poller, -1);
}

static void
nut_client_free (struct nut_client *self)
{
	// So that we don't have to repeat most of the stuff
	nut_client_reset (self);

	str_free (&self->read_buffer);
	str_free (&self->write_buffer);

	nut_parser_free (&self->parser);
}

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

static void
nut_client_flush_data (struct nut_client *self)
{
	LIST_FOR_EACH (struct nut_line, iter, self->data)
	{
		str_vector_free (&iter->fields);
		free (iter);
	}
	self->data = self->data_tail = NULL;
}

/// Reinitialize the interface so that you can reconnect anew
static void
nut_client_reset (struct nut_client *self)
{
	if (self->state == NUT_CONNECTING)
		nut_client_destroy_connector (self);

	if (self->socket != -1)
		xclose (self->socket);
	self->socket = -1;

	self->socket_event.closed = true;
	poller_fd_reset (&self->socket_event);

	str_reset (&self->read_buffer);
	str_reset (&self->write_buffer);

	self->parser.state = NUT_STATE_START_LINE;
	nut_client_flush_data (self);
	self->in_list = false;

	LIST_FOR_EACH (struct nut_client_task, iter, self->tasks)
		free (iter);
	self->tasks = self->tasks_tail = NULL;

	self->state = NUT_DISCONNECTED;
}

static void
nut_client_fail (struct nut_client *self)
{
	nut_client_reset (self);
	if (self->on_failure)
		self->on_failure (self->user_data);
}

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

static void
nut_client_quote (const char *s, struct str *output)
{
	str_append_c (output, '"');
	for (; *s; s++)
	{
		if (*s == '"' || *s == '\\')
			str_append_c (output, '\\');
		str_append_c (output, *s);
	}
	str_append_c (output, '"');
}

static bool
nut_client_must_quote (const char *s)
{
	if (!*s)
		return true;
	for (; *s; s++)
		if ((unsigned char) *s <= ' ' || *s == '"' || *s == '\\')
			return true;
	return false;
}

static void
nut_client_serialize (char **commands, struct str *line)
{
	for (; *commands; commands++)
	{
		if (line->len)
			str_append_c (line, ' ');

		if (nut_client_must_quote (*commands))
			nut_client_quote (*commands, line);
		else
			str_append (line, *commands);
	}
}

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

static void
nut_client_dispatch (struct nut_client *self, struct nut_response *response)
{
	struct nut_client_task *task;
	if (!(task = self->tasks))
		return;

	if (task->callback)
		task->callback (response, task->user_data);
	nut_client_flush_data (self);

	LIST_UNLINK_WITH_TAIL (self->tasks, self->tasks_tail, task);
	free (task);
}

static bool
nut_client_parse_line (struct nut_client *self)
{
	struct str reconstructed;
	str_init (&reconstructed);
	nut_client_serialize (self->parser.fields.vector, &reconstructed);
	print_debug ("NUT >> %s", reconstructed.str);
	str_free (&reconstructed);

	struct str_vector *fields = &self->parser.fields;
	hard_assert (fields->len != 0);

	// Lists are always dispatched as their innards (and they can be empty)
	if (fields->len >= 2
	 && !strcmp (fields->vector[0], "BEGIN")
	 && !strcmp (fields->vector[1], "LIST"))
		self->in_list = true;
	else if (fields->len >= 2
	 && !strcmp (fields->vector[0], "END")
	 && !strcmp (fields->vector[1], "LIST"))
		self->in_list = false;
	else
	{
		struct nut_line *line = xcalloc (1, sizeof *line);
		str_vector_init (&line->fields);
		str_vector_add_vector (&line->fields, fields->vector);
		LIST_APPEND_WITH_TAIL (self->data, self->data_tail, line);
	}

	if (!self->in_list)
	{
		struct nut_response response;
		memset (&response, 0, sizeof response);
		response.success = true;
		response.data = self->data;

		if (!strcmp (fields->vector[0], "ERR"))
		{
			response.success = false;
			if (fields->len < 2)
				return false;
			response.message = xstrdup (fields->vector[1]);
		}

		nut_client_dispatch (self, &response);
		free (response.message);
	}
	return true;
}

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

static void
nut_client_update_poller (struct nut_client *self)
{
	poller_fd_set (&self->socket_event,
		self->write_buffer.len ? (POLLIN | POLLOUT) : POLLIN);
}

static bool
nut_client_process_input (struct nut_client *self)
{
	struct str *rb = &self->read_buffer;
	for (size_t i = 0; i < rb->len; i++)
	{
		int res = nut_parser_push (&self->parser, rb->str[i]);
		if (res == -1 || (res == 1 && !nut_client_parse_line (self)))
			return false;
	}

	str_reset (rb);
	return true;
}

static void
nut_client_on_ready (const struct pollfd *pfd, void *user_data)
{
	(void) pfd;

	struct nut_client *self = user_data;
	bool read_succeeded = socket_io_try_read
		(self->socket, &self->read_buffer) == SOCKET_IO_OK;

	// Whether or not the read was successful, we need to process all data
	if (!nut_client_process_input (self) || !read_succeeded
	 || socket_io_try_write (self->socket, &self->write_buffer) != SOCKET_IO_OK)
		nut_client_fail (self);
	else
		nut_client_update_poller (self);
}

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

/// Beware that delivery of the event isn't deferred and you musn't make
/// changes to the interface while processing the event!
static void
nut_client_add_task
	(struct nut_client *self, nut_client_task_cb cb, void *user_data)
{
	struct nut_client_task *task = xcalloc (1, sizeof *self);
	task->callback = cb;
	task->user_data = user_data;
	LIST_APPEND_WITH_TAIL (self->tasks, self->tasks_tail, task);
}

/// Send a command.  Remember to call nut_client_add_task() to handle responses,
/// unless the command generates none.
static void nut_client_send_command
	(struct nut_client *self, const char *command, ...) ATTRIBUTE_SENTINEL;

static void
nut_client_send_commandv (struct nut_client *self, char **commands)
{
	struct str line;
	str_init (&line);
	nut_client_serialize (commands, &line);

	print_debug ("NUT << %s", line.str);
	str_append_c (&line, '\n');
	str_append_str (&self->write_buffer, &line);
	str_free (&line);

	nut_client_update_poller (self);
}

static void
nut_client_send_command (struct nut_client *self, const char *command, ...)
{
	struct str_vector v;
	str_vector_init (&v);

	va_list ap;
	va_start (ap, command);
	for (; command; command = va_arg (ap, const char *))
		str_vector_add (&v, command);
	va_end (ap);

	nut_client_send_commandv (self, v.vector);
	str_vector_free (&v);
}

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

static void
nut_client_finish_connection (struct nut_client *self, int socket)
{
	set_blocking (socket, false);
	self->socket = socket;
	self->state = NUT_CONNECTED;

	poller_fd_init (&self->socket_event, self->poller, self->socket);
	self->socket_event.dispatcher = nut_client_on_ready;
	self->socket_event.user_data = self;

	nut_client_update_poller (self);

	if (self->on_connected)
		self->on_connected (self->user_data);
}

static void
nut_client_destroy_connector (struct nut_client *self)
{
	if (self->connector)
		connector_free (self->connector);
	free (self->connector);
	self->connector = NULL;

	// Not connecting anymore
	self->state = NUT_DISCONNECTED;
}

static void
nut_client_on_connector_failure (void *user_data)
{
	struct nut_client *self = user_data;
	nut_client_destroy_connector (self);
	nut_client_fail (self);
}

static void
nut_client_on_connector_connected
	(void *user_data, int socket, const char *host)
{
	(void) host;

	struct nut_client *self = user_data;
	nut_client_destroy_connector (self);
	nut_client_finish_connection (self, socket);
}

static void
nut_client_connect
	(struct nut_client *self, const char *address, const char *service)
{
	hard_assert (self->state == NUT_DISCONNECTED);

	struct connector *connector = xmalloc (sizeof *connector);
	connector_init (connector, self->poller);
	self->connector = connector;

	connector->user_data    = self;
	connector->on_connected = nut_client_on_connector_connected;
	connector->on_failure   = nut_client_on_connector_failure;

	connector_add_target (connector, address, service);
	self->state = NUT_CONNECTING;
}

// --- Configuration -----------------------------------------------------------

static struct simple_config_item g_config_table[] =
{
	{ "mpd_address",     "localhost",       "MPD host or socket"             },
	{ "mpd_service",     "6600",            "MPD service name or port"       },
	{ "mpd_password",    NULL,              "MPD password"                   },

	{ "nut_enabled",     "off",             "NUT UPS status reading enabled" },
	{ "nut_load_thld",   "50",              "NUT threshold for load display" },

	// This is just a hack because my UPS doesn't report that value; a more
	// proper way of providing this information would be by making use of the
	// enhanced configuration format and allowing arbitrary per-UPS overrides
	{ "nut_load_power",  NULL,              "ups.realpower.nominal override" },

	{ NULL,              NULL,              NULL                             }
};

// --- Application -------------------------------------------------------------

struct app_context
{
	struct str_map config;              ///< Program configuration

	Display *dpy;                       ///< X display handle
	int xkb_base_event_code;            ///< Xkb base event code
	const char *prefix;                 ///< User-defined prefix

	struct poller poller;               ///< Poller
	struct poller_timer time_changed;   ///< Time change timer
	struct poller_timer make_context;   ///< Start PulseAudio communication
	struct poller_timer refresh_rest;   ///< Refresh unpollable information

	// Hotkeys:

	struct poller_fd x_event;           ///< X11 event
	char *layout;                       ///< Keyboard layout

	// MPD:

	struct poller_timer mpd_reconnect;  ///< Start MPD communication
	struct mpd_client mpd_client;       ///< MPD client

	char *mpd_song;                     ///< MPD current song
	char *mpd_status;                   ///< MPD status (overrides song)

	// NUT:

	struct poller_timer nut_reconnect;  ///< Start NUT communication
	struct nut_client nut_client;       ///< NUT client
	struct str_map nut_ups_info;        ///< Per-UPS information
	bool nut_success;                   ///< Information retrieved successfully

	char *nut_status;                   ///< NUT status

	// PulseAudio:

	pa_mainloop_api *api;               ///< PulseAudio event loop proxy
	pa_context *context;                ///< PulseAudio connection context

	bool failed;                        ///< General PulseAudio failure

	pa_cvolume sink_volume;             ///< Current volume
	bool sink_muted;                    ///< Currently muted?
	struct str_vector sink_ports;       ///< All sink port names
	char *sink_port_active;             ///< Active sink port

	bool source_muted;                  ///< Currently muted?
};

static void
str_map_destroy (void *self)
{
	str_map_free (self);
	free (self);
}

static void
app_context_init (struct app_context *self)
{
	memset (self, 0, sizeof *self);

	str_map_init (&self->config);
	self->config.free = free;
	simple_config_load_defaults (&self->config, g_config_table);

	if (!(self->dpy = XkbOpenDisplay
		(NULL, &self->xkb_base_event_code, NULL, NULL, NULL, NULL)))
		exit_fatal ("cannot open display");

	poller_init (&self->poller);
	self->api = poller_pa_new (&self->poller);

	poller_fd_init (&self->x_event, &self->poller,
		ConnectionNumber (self->dpy));

	mpd_client_init (&self->mpd_client, &self->poller);

	nut_client_init (&self->nut_client, &self->poller);
	str_map_init (&self->nut_ups_info);
	self->nut_ups_info.free = str_map_destroy;

	str_vector_init (&self->sink_ports);
}

static void
app_context_free (struct app_context *self)
{
	str_map_free (&self->config);

	poller_fd_reset (&self->x_event);
	free (self->layout);

	if (self->context)  pa_context_unref (self->context);
	if (self->dpy)      XCloseDisplay (self->dpy);

	poller_pa_destroy (self->api);
	poller_free (&self->poller);

	mpd_client_free (&self->mpd_client);
	free (self->mpd_song);
	free (self->mpd_status);

	nut_client_free (&self->nut_client);
	str_map_free (&self->nut_ups_info);

	str_vector_free (&self->sink_ports);
	free (self->sink_port_active);
}

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

static char *
read_value (int dir, const char *filename, struct error **e)
{
	int fd = openat (dir, filename, O_RDONLY);
	if (fd < 0)
	{
		error_set (e, "%s: %s: %s", filename, "openat", strerror (errno));
		return NULL;
	}

	FILE *fp = fdopen (fd, "r");
	if (!fp)
	{
		error_set (e, "%s: %s: %s", filename, "fdopen", strerror (errno));
		close (fd);
		return NULL;
	}

	struct str s;
	str_init (&s);
	bool success = read_line (fp, &s);
	fclose (fp);

	if (!success)
	{
		error_set (e, "%s: %s", filename, "read failed");
		return NULL;
	}
	return str_steal (&s);
}

static unsigned long
read_number (int dir, const char *filename, struct error **e)
{
	char *value;
	if (!(value = read_value (dir, filename, e)))
		return false;

	unsigned long number = 0;
	if (!xstrtoul (&number, value, 10))
		error_set (e, "%s: %s", filename, "doesn't contain an unsigned number");
	free (value);
	return number;
}

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

static char *
read_battery_status (int dir, struct error **e)
{
	char *result = NULL;
	struct error *error = NULL;

	char *status;
	double charge_now;
	double charge_full;

	if ((status      = read_value  (dir, "status",      &error), error)
	 || (charge_now  = read_number (dir, "charge_now",  &error), error)
	 || (charge_full = read_number (dir, "charge_full", &error), error))
		error_propagate (e, error);
	else
		result = xstrdup_printf ("%s (%u%%)",
			status, (unsigned) (charge_now / charge_full * 100 + 0.5));

	free (status);
	return result;
}

static char *
try_power_supply (int dir, struct error **e)
{
	char *type;
	struct error *error = NULL;
	if (!(type = read_value (dir, "type", &error)))
	{
		error_propagate (e, error);
		return NULL;
	}

	bool is_relevant =
		!strcmp (type, "Battery") ||
		!strcmp (type, "UPS");

	char *result = NULL;
	if (is_relevant)
	{
		char *status = read_battery_status (dir, &error);
		if (error)
			error_propagate (e, error);
		if (status)
			result = xstrdup_printf ("%s %s", type, status);
		free (status);
	}
	free (type);
	return result;
}

static char *
make_battery_status (void)
{
	DIR *power_supply = opendir ("/sys/class/power_supply");
	if (!power_supply)
	{
		print_debug ("cannot access %s: %s: %s",
			"/sys/class/power_supply", "opendir", strerror (errno));
		return NULL;
	}

	struct dirent *entry;
	char *status = NULL;
	while (!status && (entry = readdir (power_supply)))
	{
		const char *device_name = entry->d_name;
		if (device_name[0] == '.')
			continue;

		int dir = openat (dirfd (power_supply), device_name, O_RDONLY);
		if (dir < 0)
		{
			print_error ("%s: %s: %s", device_name, "openat", strerror (errno));
			continue;
		}

		struct error *error = NULL;
		status = try_power_supply (dir, &error);
		close (dir);
		if (error)
		{
			print_error ("%s: %s", device_name, error->message);
			error_free (error);
		}
	}
	closedir (power_supply);
	return status;
}

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

static char *
make_time_status (char *fmt)
{
	char buf[129] = "";
	time_t now = time (NULL);
	struct tm *local = localtime (&now);

	if (local == NULL)
		exit_fatal ("%s: %s", "localtime", strerror (errno));
	if (!strftime (buf, sizeof buf, fmt, local))
		exit_fatal ("strftime == 0");

	return xstrdup (buf);
}

#define VOLUME_PERCENT(x) (((x) * 100 + PA_VOLUME_NORM / 2) / PA_VOLUME_NORM)

static char *
make_volume_status (struct app_context *ctx)
{
	if (!ctx->sink_volume.channels)
		return xstrdup ("");

	struct str s;
	str_init (&s);
	str_append_printf (&s, "%u%%", VOLUME_PERCENT (ctx->sink_volume.values[0]));
	if (!pa_cvolume_channels_equal_to (&ctx->sink_volume, ctx->sink_volume.values[0]))
		for (size_t i = 1; i < ctx->sink_volume.channels; i++)
			str_append_printf (&s, " / %u%%",
				VOLUME_PERCENT (ctx->sink_volume.values[i]));
	return str_steal (&s);
}

static void
refresh_status (struct app_context *ctx)
{
	struct str status;
	str_init (&status);

	if (ctx->prefix)
		str_append_printf (&status, "%s   ", ctx->prefix);

	if (ctx->mpd_status)
		str_append_printf (&status, "%s   ", ctx->mpd_status);
	else if (ctx->mpd_song)
		str_append_printf (&status, "%s   ", ctx->mpd_song);

	if (ctx->failed)
		str_append_printf (&status, "%s   ", "PA failure");
	else
	{
		char *volumes = make_volume_status (ctx);
		str_append_printf (&status, "%s%s   ",
			ctx->sink_muted ? "Muted " : "", volumes);
		free (volumes);
	}

	char *battery = make_battery_status ();
	if (battery)
		str_append_printf (&status, "%s   ", battery);
	free (battery);

	if (ctx->nut_status)
		str_append_printf (&status, "%s   ", ctx->nut_status);

	if (ctx->layout)
		str_append_printf (&status, "%s   ", ctx->layout);

	char *times = make_time_status ("Week %V, %a %d %b %Y %H:%M %Z");
	str_append (&status, times);
	free (times);

	set_dwm_status (ctx->dpy, status.str);
	str_free (&status);
}

static void
on_time_changed (void *user_data)
{
	struct app_context *ctx = user_data;
	refresh_status (ctx);

	const time_t now = time (NULL);
	const time_t next = (now / 60 + 1) * 60;
	poller_timer_set (&ctx->time_changed, (next - now) * 1000);
}

static void
on_refresh_rest (void *user_data)
{
	struct app_context *ctx = user_data;

	// We cannot use poll() on most sysfs entries, including battery charge

	refresh_status (ctx);
	poller_timer_set (&ctx->refresh_rest, 5000);
}

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

// Sometimes it's not that easy and there can be repeating entries
static void
mpd_vector_to_map (const struct str_vector *data, struct str_map *map)
{
	str_map_init (map);
	map->key_xfrm = tolower_ascii_strxfrm;
	map->free = free;

	char *key, *value;
	for (size_t i = 0; i < data->len; i++)
	{
		if ((key = mpd_client_parse_kv (data->vector[i], &value)))
			str_map_set (map, key, xstrdup (value));
		else
			print_debug ("%s: %s", "erroneous MPD output", data->vector[i]);
	}
}

static void
mpd_on_info_response (const struct mpd_response *response,
	const struct str_vector *data, void *user_data)
{
	if (!response->success)
	{
		print_debug ("%s: %s",
			"retrieving MPD info failed", response->message_text);
		return;
	}

	struct app_context *ctx = user_data;
	struct str_map map;
	mpd_vector_to_map (data, &map);

	free (ctx->mpd_status);
	ctx->mpd_status = NULL;

	struct str s;
	str_init (&s);

	const char *value;
	if ((value = str_map_find (&map, "state")))
	{
		if (!strcmp (value, "stop"))
			ctx->mpd_status = xstrdup ("MPD stopped");
		else if (!strcmp (value, "pause"))
			str_append (&s, "|| ");
		else
			str_append (&s, "|> ");
	}

	if ((value = str_map_find (&map, "title"))
	 || (value = str_map_find (&map, "name"))
	 || (value = str_map_find (&map, "file")))
		str_append_printf (&s, "\"%s\"", value);
	if ((value = str_map_find (&map, "artist")))
		str_append_printf (&s, " by \"%s\"", value);
	if ((value = str_map_find (&map, "album")))
		str_append_printf (&s, " from \"%s\"", value);

	free (ctx->mpd_song);
	ctx->mpd_song = str_steal (&s);

	refresh_status (ctx);
	str_map_free (&map);
}

static void
mpd_request_info (struct app_context *ctx)
{
	struct mpd_client *c = &ctx->mpd_client;

	mpd_client_list_begin (c);
	mpd_client_send_command (c, "currentsong", NULL);
	mpd_client_send_command (c, "status", NULL);
	mpd_client_list_end (c);
	mpd_client_add_task (c, mpd_on_info_response, ctx);

	mpd_client_idle (c, 0);
}

static void
mpd_on_events (unsigned subsystems, void *user_data)
{
	struct app_context *ctx = user_data;
	struct mpd_client *c = &ctx->mpd_client;

	if (subsystems & (MPD_SUBSYSTEM_PLAYER | MPD_SUBSYSTEM_PLAYLIST))
		mpd_request_info (ctx);
	else
		mpd_client_idle (c, 0);
}

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

static void
mpd_queue_reconnect (struct app_context *ctx)
{
	poller_timer_set (&ctx->mpd_reconnect, 30 * 1000);
}

static void
mpd_on_password_response (const struct mpd_response *response,
	const struct str_vector *data, void *user_data)
{
	(void) data;
	struct app_context *ctx = user_data;
	struct mpd_client *c = &ctx->mpd_client;

	if (response->success)
		mpd_request_info (ctx);
	else
	{
		print_error ("%s: %s",
			"couldn't authenticate to MPD", response->message_text);
		mpd_client_send_command (c, "close", NULL);
	}
}

static void
mpd_on_connected (void *user_data)
{
	struct app_context *ctx = user_data;
	struct mpd_client *c = &ctx->mpd_client;

	const char *password = str_map_find (&ctx->config, "mpd_password");
	if (password)
	{
		mpd_client_send_command (c, "password", password, NULL);
		mpd_client_add_task (c, mpd_on_password_response, ctx);
	}
	else
		mpd_request_info (ctx);
}

static void
mpd_on_failure (void *user_data)
{
	// This is also triggered both by a failed connect and a clean disconnect
	struct app_context *ctx = user_data;
	print_error ("connection to MPD failed");
	mpd_queue_reconnect (ctx);
}

static void
mpd_on_io_hook (void *user_data, bool outgoing, const char *line)
{
	(void) user_data;
	if (outgoing)
		print_debug ("MPD << %s", line);
	else
		print_debug ("MPD >> %s", line);
}

static void
on_mpd_reconnect (void *user_data)
{
	struct app_context *ctx = user_data;

	struct mpd_client *c = &ctx->mpd_client;
	c->user_data    = ctx;
	c->on_failure   = mpd_on_failure;
	c->on_connected = mpd_on_connected;
	c->on_event     = mpd_on_events;
	c->on_io_hook   = mpd_on_io_hook;

	struct error *e = NULL;
	if (!mpd_client_connect (&ctx->mpd_client,
		str_map_find (&ctx->config, "mpd_address"),
		str_map_find (&ctx->config, "mpd_service"), &e))
	{
		print_error ("%s: %s", "cannot connect to MPD", e->message);
		error_free (e);
		mpd_queue_reconnect (ctx);
	}
}

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

static bool
nut_common_handler (const struct nut_response *response)
{
	if (response->success)
		return true;

	print_error ("%s: %s", "retrieving NUT info failed", response->message);
	return false;
}

static void
nut_translate_status (const char *status, struct str_vector *out)
{
	// https://github.com/networkupstools/nut/blob/master/clients/status.h
	if (!strcmp (status, "OL"))      str_vector_add (out, "on-line");
	if (!strcmp (status, "OB"))      str_vector_add (out, "on battery");
	if (!strcmp (status, "LB"))      str_vector_add (out, "low battery");
	if (!strcmp (status, "RB"))      str_vector_add (out, "replace battery");
	if (!strcmp (status, "CHRG"))    str_vector_add (out, "charging");
	if (!strcmp (status, "DISCHRG")) str_vector_add (out, "discharging");
	if (!strcmp (status, "OVER"))    str_vector_add (out, "overload");
	if (!strcmp (status, "OFF"))     str_vector_add (out, "off");
	if (!strcmp (status, "TRIM"))    str_vector_add (out, "voltage trim");
	if (!strcmp (status, "BOOST"))   str_vector_add (out, "voltage boost");
	if (!strcmp (status, "BYPASS"))  str_vector_add (out, "bypass");
}

static char *
interval_string (unsigned long seconds)
{
	unsigned long hours = seconds / 3600; seconds %= 3600;
	unsigned long mins  = seconds /   60; seconds %=   60;
	return xstrdup_printf ("%lu:%02lu:%02lu", hours, mins, seconds);
}

static void
nut_process_ups (struct app_context *ctx, struct str_vector *ups_list,
	const char *ups_name, struct str_map *dict)
{
	// Not currently interested in this kind of information;
	// maybe if someone had more than one UPS installed
	(void) ups_name;

	// http://www.networkupstools.org/docs/developer-guide.chunked/apas01.html
	const char *status  = str_map_find (dict, "ups.status");
	const char *charge  = str_map_find (dict, "battery.charge");
	const char *runtime = str_map_find (dict, "battery.runtime");
	const char *load    = str_map_find (dict, "ups.load");

	if (!soft_assert (status && charge && runtime))
		return;

	unsigned long runtime_sec;
	if (!soft_assert (xstrtoul (&runtime_sec, runtime, 10)))
		return;

	struct str_vector items;
	str_vector_init (&items);

	bool running_on_batteries = false;

	struct str_vector v;
	str_vector_init (&v);
	cstr_split (status, " ", true, &v);
	for (size_t i = 0; i < v.len; i++)
	{
		const char *status = v.vector[i];
		nut_translate_status (status, &items);

		if (!strcmp (status, "OB"))
			running_on_batteries = true;
	}
	str_vector_free (&v);

	if (running_on_batteries || strcmp (charge, "100"))
		str_vector_add_owned (&items, xstrdup_printf ("%s%%", charge));
	if (running_on_batteries)
		str_vector_add_owned (&items, interval_string (runtime_sec));

	// Only show load if it's higher than the threshold so as to not distract
	const char *threshold = str_map_find (&ctx->config, "nut_load_thld");
	unsigned long load_n, threshold_n;
	if (load
	 && xstrtoul (&load_n,      load,      10)
	 && xstrtoul (&threshold_n, threshold, 10)
	 && load_n >= threshold_n)
	{
		struct str item;
		str_init (&item);
		str_append_printf (&item, "load %s%%", load);

		const char *power = str_map_find (dict, "ups.realpower.nominal");
		// Override if NUT cannot tell it correctly for whatever reason
		if (!power) power = str_map_find (&ctx->config, "nut_load_power");

		// Approximation of how much electricity the perpihery actually uses
		unsigned long power_n;
		if (power && xstrtoul (&power_n, power, 10))
			str_append_printf (&item, " (~%luW)", power_n * load_n / 100);

		str_vector_add_owned (&items, str_steal (&item));
	}

	struct str result;
	str_init (&result);
	str_append (&result, "UPS: ");

	for (size_t i = 0; i < items.len; i++)
	{
		if (i) str_append (&result, "; ");
		str_append (&result, items.vector[i]);
	}
	str_vector_free (&items);
	str_vector_add_owned (ups_list, str_steal (&result));
}

static void
nut_on_logout_response (const struct nut_response *response, void *user_data)
{
	if (!nut_common_handler (response))
		return;

	struct app_context *ctx = user_data;
	struct str_vector ups_list;
	str_vector_init (&ups_list);

	struct str_map_iter iter;
	str_map_iter_init (&iter, &ctx->nut_ups_info);
	struct str_map *dict;
	while ((dict = str_map_iter_next (&iter)))
		nut_process_ups (ctx, &ups_list, iter.link->key, dict);

	free (ctx->nut_status);
	ctx->nut_status = NULL;

	if (ups_list.len)
	{
		struct str status;
		str_init (&status);
		str_append (&status, ups_list.vector[0]);
		for (size_t i = 1; i < ups_list.len; i++)
			str_append_printf (&status, "   %s", ups_list.vector[0]);
		ctx->nut_status = str_steal (&status);
	}

	ctx->nut_success = true;
	str_vector_free (&ups_list);
	refresh_status (ctx);
}

static void
nut_store_var (struct app_context *ctx,
	const char *ups_name, const char *key, const char *value)
{
	struct str_map *map;
	if (!(map = str_map_find (&ctx->nut_ups_info, ups_name)))
	{
		str_map_init ((map = xcalloc (1, sizeof *map)));
		map->free = free;
		str_map_set (&ctx->nut_ups_info, ups_name, map);
	}

	str_map_set (map, key, xstrdup (value));
}

static void
nut_on_var_response (const struct nut_response *response, void *user_data)
{
	if (!nut_common_handler (response))
		return;

	struct app_context *ctx = user_data;
	LIST_FOR_EACH (struct nut_line, iter, response->data)
	{
		const struct str_vector *fields = &iter->fields;
		if (!soft_assert (fields->len >= 4
		 && !strcmp (fields->vector[0], "VAR")))
			continue;

		nut_store_var (ctx, fields->vector[1],
			fields->vector[2], fields->vector[3]);
	}
}

static void
nut_on_list_ups_response (const struct nut_response *response, void *user_data)
{
	if (!nut_common_handler (response))
		return;

	struct app_context *ctx = user_data;
	struct nut_client *c = &ctx->nut_client;

	// Then we list all their properties and terminate the connection
	LIST_FOR_EACH (struct nut_line, iter, response->data)
	{
		const struct str_vector *fields = &iter->fields;
		if (!soft_assert (fields->len >= 2
		 && !strcmp (fields->vector[0], "UPS")))
			continue;

		nut_client_send_command (c, "LIST", "VAR", fields->vector[1], NULL);
		nut_client_add_task (c, nut_on_var_response, ctx);
	}

	nut_client_send_command (c, "LOGOUT", NULL);
	nut_client_add_task (c, nut_on_logout_response, ctx);
}

static void
nut_on_connected (void *user_data)
{
	struct app_context *ctx = user_data;
	struct nut_client *c = &ctx->nut_client;

	// First we list all available UPS devices
	nut_client_send_command (c, "LIST", "UPS", NULL);
	nut_client_add_task (c, nut_on_list_ups_response, ctx);
}

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

static void
nut_indicate_failure (struct app_context *ctx)
{
	free (ctx->nut_status);
	ctx->nut_status = xstrdup ("NUT failure");

	refresh_status (ctx);
}

static void
nut_on_failure (void *user_data)
{
	struct app_context *ctx = user_data;

	// This is also triggered both by a failed connect and a clean disconnect
	if (!ctx->nut_success)
	{
		print_error ("connection to NUT failed");
		nut_indicate_failure (ctx);
	}
}

static void
on_nut_reconnect (void *user_data)
{
	struct app_context *ctx = user_data;

	bool want_nut = false;
	if (!set_boolean_if_valid (&want_nut,
		str_map_find (&ctx->config, "nut_enabled")))
		print_error ("invalid configuration value for `%s'", "nut_enabled");
	if (!want_nut)
		return;

	struct nut_client *c = &ctx->nut_client;
	c->user_data    = ctx;
	c->on_failure   = nut_on_failure;
	c->on_connected = nut_on_connected;

	// So that we don't have to maintain a separate timeout timer,
	// we keep a simple periodic reconnect timer
	if (c->state != NUT_DISCONNECTED)
	{
		print_error ("failed to retrieve NUT status within the interval");
		nut_indicate_failure (ctx);
		nut_client_reset (c);
	}

	str_map_clear (&ctx->nut_ups_info);

	nut_client_connect (&ctx->nut_client, "localhost", "3493");
	ctx->nut_success = false;
	poller_timer_set (&ctx->nut_reconnect, 10 * 1000);
}

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

#define DEFAULT_SOURCE "@DEFAULT_SOURCE@"
#define DEFAULT_SINK   "@DEFAULT_SINK@"

static void
on_sink_info (pa_context *context, const pa_sink_info *info, int eol,
	void *userdata)
{
	(void) context;

	if (info && !eol)
	{
		struct app_context *ctx = userdata;
		ctx->sink_volume = info->volume;
		ctx->sink_muted = !!info->mute;

		str_vector_reset (&ctx->sink_ports);
		free (ctx->sink_port_active);
		ctx->sink_port_active = NULL;

		if (info->ports)
			for (struct pa_sink_port_info **iter = info->ports; *iter; iter++)
				str_vector_add (&ctx->sink_ports, (*iter)->name);
		if (info->active_port)
			ctx->sink_port_active = xstrdup (info->active_port->name);

		refresh_status (ctx);
	}
}

static void
on_source_info (pa_context *context, const pa_source_info *info, int eol,
	void *userdata)
{
	(void) context;

	if (info && !eol)
	{
		struct app_context *ctx = userdata;
		ctx->source_muted = !!info->mute;
	}
}

static void
update_volume (struct app_context *ctx)
{
	pa_operation_unref (pa_context_get_sink_info_by_name
		(ctx->context, DEFAULT_SINK, on_sink_info, ctx));
	pa_operation_unref (pa_context_get_source_info_by_name
		(ctx->context, DEFAULT_SOURCE, on_source_info, ctx));
}

static void
on_event (pa_context *context, pa_subscription_event_type_t event,
	uint32_t index, void *userdata)
{
	(void) context;
	(void) index;

	struct app_context *ctx = userdata;
	if ((event & PA_SUBSCRIPTION_EVENT_TYPE_MASK)
		== PA_SUBSCRIPTION_EVENT_CHANGE)
		update_volume (ctx);
}

static void
on_subscribe_finish (pa_context *context, int success, void *userdata)
{
	(void) context;

	struct app_context *ctx = userdata;
	if (!success)
	{
		ctx->failed = true;
		refresh_status (ctx);
	}
}

static void
on_context_state_change (pa_context *context, void *userdata)
{
	struct app_context *ctx = userdata;
	switch (pa_context_get_state (context))
	{
	case PA_CONTEXT_FAILED:
	case PA_CONTEXT_TERMINATED:
		ctx->failed = true;
		refresh_status (ctx);

		pa_context_unref (context);
		ctx->context = NULL;

		// Retry after an arbitrary delay of 5 seconds
		poller_timer_set (&ctx->make_context, 5000);
		return;
	case PA_CONTEXT_READY:
		ctx->failed = false;
		refresh_status (ctx);

		pa_context_set_subscribe_callback (context, on_event, userdata);
		pa_operation_unref (pa_context_subscribe (context,
			PA_SUBSCRIPTION_MASK_SINK | PA_SUBSCRIPTION_MASK_SOURCE,
			on_subscribe_finish, userdata));
		update_volume (ctx);
	default:
		return;
	}
}

static void
on_make_context (void *user_data)
{
	struct app_context *ctx = user_data;
	ctx->context = pa_context_new (ctx->api, PROGRAM_NAME);
	pa_context_set_state_callback (ctx->context, on_context_state_change, ctx);
	pa_context_connect (ctx->context, NULL, PA_CONTEXT_NOFLAGS, NULL);
}

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

static void
spawn (struct app_context *ctx, char *argv[])
{
	posix_spawn_file_actions_t actions;
	posix_spawn_file_actions_init (&actions);

	posix_spawn_file_actions_addclose (&actions, ConnectionNumber (ctx->dpy));
	if (ctx->mpd_client.socket != -1)
		posix_spawn_file_actions_addclose (&actions, ctx->mpd_client.socket);
	if (ctx->nut_client.socket != -1)
		posix_spawn_file_actions_addclose (&actions, ctx->nut_client.socket);

	posix_spawnattr_t attr;
	posix_spawnattr_init (&attr);
	posix_spawnattr_setpgroup (&attr, 0);

	posix_spawnp (NULL, argv[0], &actions, &attr, argv, environ);

	posix_spawn_file_actions_destroy (&actions);
	posix_spawnattr_destroy (&attr);
}

#define MPD_SIMPLE(name, ...)                              \
	static void                                            \
	on_mpd_ ## name (struct app_context *ctx, int arg)     \
	{                                                      \
		(void) arg;                                        \
		struct mpd_client *c = &ctx->mpd_client;           \
		if (c->state != MPD_CONNECTED)                     \
			return;                                        \
		mpd_client_send_command (c, __VA_ARGS__);          \
		mpd_client_add_task (c, NULL, NULL);               \
		mpd_client_idle (c, 0);                            \
	}

// XXX: pause without argument is deprecated, we can watch play state
//   if we want to have the toggle pause/play functionality
MPD_SIMPLE (play,     "pause",    NULL)
MPD_SIMPLE (stop,     "stop",     NULL)
MPD_SIMPLE (prev,     "previous", NULL)
MPD_SIMPLE (next,     "next",     NULL)
MPD_SIMPLE (forward,  "seekcur", "+10", NULL)
MPD_SIMPLE (backward, "seekcur", "-10", NULL)

static void
on_volume_finish (pa_context *context, int success, void *userdata)
{
	(void) context;
	(void) success;
	(void) userdata;

	// Just like... whatever, man
}

static void
on_volume_mic_mute (struct app_context *ctx, int arg)
{
	(void) arg;

	if (!ctx->context)
		return;

	pa_operation_unref (pa_context_set_source_mute_by_name (ctx->context,
		DEFAULT_SOURCE, !ctx->source_muted, on_volume_finish, ctx));
}

static void
on_volume_switch (struct app_context *ctx, int arg)
{
	(void) arg;

	if (!ctx->context || !ctx->sink_port_active || !ctx->sink_ports.len)
		return;

	size_t current = 0;
	for (size_t i = 0; i < ctx->sink_ports.len; i++)
		if (!strcmp (ctx->sink_port_active, ctx->sink_ports.vector[i]))
			current = i;

	pa_operation_unref (pa_context_set_sink_port_by_name (ctx->context,
		DEFAULT_SINK,
		ctx->sink_ports.vector[(current + 1) % ctx->sink_ports.len],
		on_volume_finish, ctx));
}

static void
on_volume_mute (struct app_context *ctx, int arg)
{
	(void) arg;

	if (!ctx->context)
		return;

	pa_operation_unref (pa_context_set_sink_mute_by_name (ctx->context,
		DEFAULT_SINK, !ctx->sink_muted, on_volume_finish, ctx));
}

static void
on_volume_set (struct app_context *ctx, int arg)
{
	if (!ctx->context)
		return;

	pa_cvolume volume = ctx->sink_volume;
	if (arg > 0)
		pa_cvolume_inc (&volume, (pa_volume_t)  arg * PA_VOLUME_NORM / 100);
	else
		pa_cvolume_dec (&volume, (pa_volume_t) -arg * PA_VOLUME_NORM / 100);
	pa_operation_unref (pa_context_set_sink_volume_by_name (ctx->context,
		DEFAULT_SINK, &volume, on_volume_finish, ctx));
}

static void
on_lock (struct app_context *ctx, int arg)
{
	(void) arg;

	// One of these will work
	char *argv_gdm[] = { "gdm-switch-user", NULL };
	spawn (ctx, argv_gdm);
	char *argv_ldm[] = { "dm-tool", "lock", NULL };
	spawn (ctx, argv_ldm);
}

static void
on_brightness (struct app_context *ctx, int arg)
{
	char *value = xstrdup_printf ("%d", arg);
	char *argv[] = { "brightness", value, NULL };
	spawn (ctx, argv);
	free (value);
}

static void
on_lock_group (struct app_context *ctx, int arg)
{
	XkbLockGroup (ctx->dpy, XkbUseCoreKbd, arg);
}

struct
{
	unsigned mod;
	KeySym keysym;
	void (*handler) (struct app_context *ctx, int arg);
	int arg;
}
g_keys[] =
{
	// This key should be labeled L on normal Qwert[yz] layouts
	{ Mod4Mask,            XK_n,         on_lock,              0 },

	// MPD
	{ Mod4Mask,            XK_Up,        on_mpd_play,          0 },
	{ Mod4Mask,            XK_Down,      on_mpd_stop,          0 },
	{ Mod4Mask,            XK_Left,      on_mpd_prev,          0 },
	{ Mod4Mask,            XK_Right,     on_mpd_next,          0 },
	/* xmodmap | grep -e Alt_R -e Meta_R -e ISO_Level3_Shift -e Mode_switch */
	{ Mod4Mask | Mod5Mask, XK_Left,      on_mpd_backward,      0 },
	{ Mod4Mask | Mod5Mask, XK_Right,     on_mpd_forward,       0 },

	// Keyboard groups
	{ Mod4Mask,            XK_F9,        on_lock_group,        0 },
	{ Mod4Mask,            XK_F10,       on_lock_group,        1 },
	{ Mod4Mask,            XK_F11,       on_lock_group,        2 },
	{ Mod4Mask,            XK_F12,       on_lock_group,        3 },

	// Brightness
	{ Mod4Mask,            XK_Home,      on_brightness,       10 },
	{ Mod4Mask,            XK_End,       on_brightness,      -10 },
	{ 0, XF86XK_MonBrightnessUp,         on_brightness,       10 },
	{ 0, XF86XK_MonBrightnessDown,       on_brightness,      -10 },

	// Volume
	{ Mod4Mask,            XK_Insert,    on_volume_switch,     0 },
	{ Mod4Mask,            XK_Delete,    on_volume_mute,       0 },
	{ Mod4Mask,            XK_Page_Up,   on_volume_set,        5 },
	{ Mod4Mask | Mod5Mask, XK_Page_Up,   on_volume_set,        1 },
	{ Mod4Mask,            XK_Page_Down, on_volume_set,       -5 },
	{ Mod4Mask | Mod5Mask, XK_Page_Down, on_volume_set,       -1 },
	{ 0, XF86XK_AudioMicMute,            on_volume_mic_mute,   0 },
	{ 0, XF86XK_AudioMute,               on_volume_mute,       0 },
	{ 0, XF86XK_AudioRaiseVolume,        on_volume_set,        5 },
	{ 0, XF86XK_AudioLowerVolume,        on_volume_set,       -5 },
};

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

static void
on_x_keypress (struct app_context *ctx, XEvent *e)
{
	XKeyEvent *ev = &e->xkey;
	unsigned unconsumed_mods;
	KeySym keysym;
	if (!XkbLookupKeySym (ctx->dpy,
		(KeyCode) ev->keycode, ev->state, &unconsumed_mods, &keysym))
		return;
	for (size_t i = 0; i < N_ELEMENTS (g_keys); i++)
		if (g_keys[i].keysym == keysym
		 && g_keys[i].mod == ev->state
		 && g_keys[i].handler)
			g_keys[i].handler (ctx, g_keys[i].arg);
}

static void
on_xkb_event (struct app_context *ctx, XkbEvent *ev)
{
	int group;
	if (ev->any.xkb_type == XkbStateNotify)
		group = ev->state.group;
	else
	{
		XkbStateRec rec;
		XkbGetState (ctx->dpy, XkbUseCoreKbd, &rec);
		group = rec.group;
	}

	XkbDescPtr desc = XkbAllocKeyboard ();
	XkbGetNames (ctx->dpy, XkbGroupNamesMask, desc);

	free (ctx->layout);
	ctx->layout = NULL;

	if (group != 0)
	{
		char *layout = XGetAtomName (ctx->dpy, desc->names->groups[group]);
		ctx->layout = xstrdup (layout);
		XFree (layout);
	}

	XkbFreeKeyboard (desc, 0, True);
	refresh_status (ctx);
}

static void
on_x_ready (const struct pollfd *pfd, void *user_data)
{
	(void) pfd;
	struct app_context *ctx = user_data;

	XkbEvent ev;
	while (XPending (ctx->dpy))
	{
		if (XNextEvent (ctx->dpy, &ev.core))
			exit_fatal ("XNextEvent returned non-zero");
		if (ev.type == KeyPress)
			on_x_keypress (ctx, &ev.core);
		if (ev.type == ctx->xkb_base_event_code)
			on_xkb_event (ctx, &ev);
	}
}

static void
grab_keys (struct app_context *ctx)
{
	unsigned ignored_locks =
		LockMask | XkbKeysymToModifiers (ctx->dpy, XK_Num_Lock);
	hard_assert (XkbSetIgnoreLockMods
		(ctx->dpy, XkbUseCoreKbd, ignored_locks, ignored_locks, 0, 0));

	KeyCode code;
	Window root = DefaultRootWindow (ctx->dpy);
	for (size_t i = 0; i < N_ELEMENTS (g_keys); i++)
		if ((code = XKeysymToKeycode (ctx->dpy, g_keys[i].keysym)))
			XGrabKey (ctx->dpy, code, g_keys[i].mod, root,
				 False /* ? */, GrabModeAsync, GrabModeAsync);

	XSelectInput (ctx->dpy, root, KeyPressMask);
	XSync (ctx->dpy, False);

	ctx->x_event.dispatcher = on_x_ready;
	ctx->x_event.user_data = ctx;
	poller_fd_set (&ctx->x_event, POLLIN);

	// XXX: XkbMapNotify -> XkbRefreshKeyboardMapping(), ...?
	XkbSelectEventDetails (ctx->dpy, XkbUseCoreKbd, XkbNamesNotify,
		XkbAllNamesMask, XkbGroupNamesMask);
	XkbSelectEventDetails (ctx->dpy, XkbUseCoreKbd, XkbStateNotify,
		XkbAllStateComponentsMask, XkbGroupStateMask);
}

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

static void
poller_timer_init_and_set (struct poller_timer *self, struct poller *poller,
	poller_timer_fn cb, void *user_data)
{
	poller_timer_init (self, poller);
	self->dispatcher = cb;
	self->user_data = user_data;

	poller_timer_set (self, 0);
}

int
main (int argc, char *argv[])
{
	g_log_message_real = log_message_custom;

	static const struct opt opts[] =
	{
		{ 'd', "debug", NULL, 0, "run in debug mode" },
		{ 'h', "help", NULL, 0, "display this help and exit" },
		{ 'V', "version", NULL, 0, "output version information and exit" },
		{ 'w', "write-default-cfg", "FILENAME",
		  OPT_OPTIONAL_ARG | OPT_LONG_ONLY,
		  "write a default configuration file and exit" },
		{ 0, NULL, NULL, 0, NULL }
	};

	struct opt_handler oh;
	opt_handler_init (&oh, argc, argv, opts, NULL, "Set root window name.");

	int c;
	while ((c = opt_handler_get (&oh)) != -1)
	switch (c)
	{
	case 'd':
		g_debug_mode = true;
		break;
	case 'h':
		opt_handler_usage (&oh, stdout);
		exit (EXIT_SUCCESS);
	case 'V':
		printf (PROGRAM_NAME " " PROGRAM_VERSION "\n");
		exit (EXIT_SUCCESS);
	case 'w':
		call_simple_config_write_default (optarg, g_config_table);
		exit (EXIT_SUCCESS);
	default:
		print_error ("wrong options");
		opt_handler_usage (&oh, stderr);
		exit (EXIT_FAILURE);
	}

	argc -= optind;
	argv += optind;

	opt_handler_free (&oh);

	// We don't need to retrieve exit statuses of anything, avoid zombies
	struct sigaction sa;
	sa.sa_flags = SA_RESTART | SA_NOCLDWAIT;
	sigemptyset (&sa.sa_mask);
	sa.sa_handler = SIG_IGN;
	if (sigaction (SIGCHLD, &sa, NULL) == -1)
		print_error ("%s: %s", "sigaction", strerror (errno));

	struct app_context ctx;
	app_context_init (&ctx);
	ctx.prefix = argc > 1 ? argv[1] : NULL;

	struct error *e = NULL;
	if (!simple_config_update_from_file (&ctx.config, &e))
		exit_fatal ("%s", e->message);

	poller_timer_init_and_set (&ctx.time_changed, &ctx.poller,
		on_time_changed, &ctx);
	poller_timer_init_and_set (&ctx.make_context, &ctx.poller,
		on_make_context, &ctx);
	poller_timer_init_and_set (&ctx.refresh_rest, &ctx.poller,
		on_refresh_rest, &ctx);
	poller_timer_init_and_set (&ctx.mpd_reconnect, &ctx.poller,
		on_mpd_reconnect, &ctx);
	poller_timer_init_and_set (&ctx.nut_reconnect, &ctx.poller,
		on_nut_reconnect, &ctx);

	grab_keys (&ctx);

	poller_pa_run (ctx.api);
	app_context_free (&ctx);

	return 0;
}