Allow for overriding feature test macros

This is not a regular expression.

.clang-format

@@ -0,0 +1,32 @@
+# clang-format is fairly limited, and these rules are approximate:
+#  - array initializers can get terribly mangled with clang-format 12.0,
+#  - sometimes it still aligns with space characters,
+#  - struct name NL { NL ... NL } NL name; is unachievable.
+BasedOnStyle: GNU
+ColumnLimit: 80
+IndentWidth: 4
+TabWidth: 4
+UseTab: ForContinuationAndIndentation
+BreakBeforeBraces: Allman
+SpaceAfterCStyleCast: true
+AlignAfterOpenBracket: DontAlign
+AlignOperands: DontAlign
+AlignConsecutiveMacros: Consecutive
+AllowAllArgumentsOnNextLine: false
+AllowAllParametersOfDeclarationOnNextLine: false
+IndentGotoLabels: false
+
+# IncludeCategories has some potential, but it may also break the build.
+# Note that the documentation says the value should be "Never".
+SortIncludes: false
+
+# This is a compromise, it generally works out aesthetically better.
+BinPackArguments: false
+
+# Unfortunately, this can't be told to align to column 40 or so.
+SpacesBeforeTrailingComments: 2
+
+# liberty-specific macro body wrappers.
+MacroBlockBegin: "BLOCK_START"
+MacroBlockEnd: "BLOCK_END"
+ForEachMacros: ["LIST_FOR_EACH"]

.gitignore

@@ -7,3 +7,5 @@
 /liberty.files
 /liberty.creator*
 /liberty.includes
+/liberty.cflags
+/liberty.cxxflags

CMakeLists.txt

@@ -1,12 +1,12 @@
 project (liberty C)
-cmake_minimum_required (VERSION 2.8.5)
+cmake_minimum_required (VERSION 2.8.12)
 
 # Moar warnings
 if ("${CMAKE_C_COMPILER_ID}" MATCHES "GNU" OR CMAKE_COMPILER_IS_GNUCC)
 	# -Wunused-function is pretty annoying here, as everything is static
-	set (wdisabled "-Wno-unused-function -Wno-implicit-fallthrough")
+	set (wdisabled "-Wno-unused-function")
 	set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=c99 -Wall -Wextra ${wdisabled}")
-endif ("${CMAKE_C_COMPILER_ID}" MATCHES "GNU" OR CMAKE_COMPILER_IS_GNUCC)
+endif ()
 
 # Dependencies
 set (CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake)
@@ -16,11 +16,9 @@ find_package (PkgConfig REQUIRED)
 pkg_check_modules (libssl REQUIRED libssl libcrypto)
 
 if ("${CMAKE_SYSTEM_NAME}" MATCHES "BSD")
-	include_directories (/usr/local/include)
-	link_directories (/usr/local/lib)
 	# Our POSIX version macros make these undefined
 	add_definitions (-D__BSD_VISIBLE=1 -D_BSD_SOURCE=1)
-endif ("${CMAKE_SYSTEM_NAME}" MATCHES "BSD")
+endif ()
 
 set (common_libraries ${libssl_LIBRARIES})
 include_directories (${libssl_INCLUDE_DIRS})
@@ -32,15 +30,25 @@ foreach (extra iconv rt)
 	find_library (extra_lib_${extra} ${extra})
 	if (extra_lib_${extra})
 		list (APPEND common_libraries ${extra})
-	endif (extra_lib_${extra})
-endforeach (extra)
+	endif ()
+endforeach ()
 
 # Build some unit tests
 include_directories (${PROJECT_SOURCE_DIR})
 enable_testing ()
-foreach (name liberty proto)
+set (tests liberty proto)
+
+pkg_check_modules (libpulse libpulse)
+if (libpulse_FOUND)
+	list (APPEND tests pulse)
+	list (APPEND common_libraries ${libpulse_LIBRARIES})
+	include_directories (${libpulse_INCLUDE_DIRS})
+	link_directories (${libpulse_LIBRARY_DIRS})
+endif ()
+
+foreach (name ${tests})
 	add_executable (test-${name} tests/${name}.c ${common_sources})
 	add_threads (test-${name})
 	target_link_libraries (test-${name} ${common_libraries})
 	add_test (NAME test-${name} COMMAND test-${name})
-endforeach (name)
+endforeach ()

LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2014 - 2020, Přemysl Eric Janouch <p@janouch.name>
+Copyright (c) 2014 - 2022, Přemysl Eric Janouch <p@janouch.name>
 
 Permission to use, copy, modify, and/or distribute this software for any
 purpose with or without fee is hereby granted.

liberty-proto.c

@@ -148,7 +148,7 @@ irc_free_message (struct irc_message *msg)
 
 static void
 irc_process_buffer (struct str *buf,
-	void (*callback)(const struct irc_message *, const char *, void *),
+	void (*callback) (const struct irc_message *, const char *, void *),
 	void *user_data)
 {
 	char *start = buf->str, *end = start + buf->len;
@@ -507,7 +507,7 @@ http_parse_upgrade (const char *upgrade, struct http_protocol **out)
 		case HTTP_T_WHITESPACE:
 			break;
 		case HTTP_T_TOKEN:
-			proto = (struct http_protocol *) xcalloc (1, sizeof *proto);
+			proto = xcalloc (1, sizeof *proto);
 			proto->name = xstrdup (t.string.str);
 			LIST_APPEND_WITH_TAIL (list, tail, proto);
 			state = STATE_SLASH;
@@ -1002,7 +1002,7 @@ fcgi_nv_parser_push (struct fcgi_nv_parser *self, const void *data, size_t len)
 		if (self->input.len < self->name_len)
 			return;
 
-		self->name = (char *) xmalloc (self->name_len + 1);
+		self->name = xmalloc (self->name_len + 1);
 		self->name[self->name_len] = '\0';
 		memcpy (self->name, self->input.str, self->name_len);
 		str_remove_slice (&self->input, 0, self->name_len);
@@ -1012,7 +1012,7 @@ fcgi_nv_parser_push (struct fcgi_nv_parser *self, const void *data, size_t len)
 		if (self->input.len < self->value_len)
 			return;
 
-		self->value = (char *) xmalloc (self->value_len + 1);
+		self->value = xmalloc (self->value_len + 1);
 		self->value[self->value_len] = '\0';
 		memcpy (self->value, self->input.str, self->value_len);
 		str_remove_slice (&self->input, 0, self->value_len);
@@ -1050,7 +1050,7 @@ fcgi_nv_convert (struct str_map *map, struct str *output)
 	while (str_map_iter_next (&iter))
 	{
 		const char *name  = iter.link->key;
-		const char *value = (const char *) iter.link->data;
+		const char *value = iter.link->data;
 		size_t name_len   = iter.link->key_length;
 		size_t value_len  = strlen (value);
 
@@ -1227,7 +1227,7 @@ ws_parser_push (struct ws_parser *self, const void *data, size_t len)
 		self->reserved_1  = (u8 >> 6) &   1;
 		self->reserved_2  = (u8 >> 5) &   1;
 		self->reserved_3  = (u8 >> 4) &   1;
-		self->opcode      = (enum ws_opcode) (u8 & 15);
+		self->opcode      =  u8       &  15;
 
 		(void) msg_unpacker_u8 (&unpacker, &u8);
 		self->is_masked   = (u8 >> 7) &   1;
@@ -1321,7 +1321,6 @@ enum mpd_subsystem
 #define XX(a, b, c) MPD_SUBSYSTEM_ ## a = (1 << b),
 	MPD_SUBSYSTEM_TABLE (XX)
 #undef XX
-	MPD_SUBSYSTEM_MAX
 };
 
 static const char *mpd_subsystem_names[] =
@@ -1423,9 +1422,9 @@ mpd_client_make (struct poller *poller)
 		.socket = -1,
 		.read_buffer = str_make (),
 		.write_buffer = str_make (),
+		.data = strv_make (),
 		.socket_event = poller_fd_make (poller, -1),
 		.timeout_timer = poller_timer_make (poller),
-		.data = strv_make (),
 	};
 }
 
@@ -1464,7 +1463,7 @@ mpd_client_reset (struct mpd_client *self)
 {
 	// Get rid of all pending tasks to release resources etc.
 	strv_reset (&self->data);
-	struct mpd_response aborted = { .message_text = (char *) "Disconnected" };
+	struct mpd_response aborted = { .message_text = "Disconnected" };
 	while (self->tasks)
 		mpd_client_dispatch (self, &aborted);
 
@@ -1524,8 +1523,7 @@ mpd_client_parse_response (const char *p, struct mpd_response *response)
 	if (errno != 0 || end == p)
 		return false;
 	p = end;
-	if (*p++ != ']' || *p++ != ' ' || *p++ != '{'
-	 || !(end = (char *) strchr (p, '}')))
+	if (*p++ != ']' || *p++ != ' ' || *p++ != '{' || !(end = strchr (p, '}')))
 		return false;
 
 	response->current_command = xstrndup (p, end - p);
@@ -1625,7 +1623,7 @@ mpd_client_on_ready (const struct pollfd *pfd, void *user_data)
 {
 	(void) pfd;
 
-	struct mpd_client *self = (struct mpd_client *) user_data;
+	struct mpd_client *self = user_data;
 	if (socket_io_try_read  (self->socket, &self->read_buffer)  != SOCKET_IO_OK
 	 || !mpd_client_process_input (self)
 	 || socket_io_try_write (self->socket, &self->write_buffer) != SOCKET_IO_OK)
@@ -1677,8 +1675,7 @@ mpd_client_add_task
 	// later flushed if an early ACK or OK arrives).
 	hard_assert (!self->in_list);
 
-	struct mpd_client_task *task =
-		(struct mpd_client_task *) xcalloc (1, sizeof *self);
+	struct mpd_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);
@@ -1796,7 +1793,7 @@ mpd_client_on_idle_return (const struct mpd_response *response,
 {
 	(void) response;
 
-	struct mpd_client *self = (struct mpd_client *) user_data;
+	struct mpd_client *self = user_data;
 	unsigned subsystems = 0;
 	for (size_t i = 0; i < data->len; i++)
 	{
@@ -1819,7 +1816,7 @@ static void mpd_client_idle (struct mpd_client *self, unsigned subsystems);
 static void
 mpd_client_on_timeout (void *user_data)
 {
-	struct mpd_client *self = (struct mpd_client *) user_data;
+	struct mpd_client *self = user_data;
 
 	// Abort and immediately restore the current idle so that MPD doesn't
 	// disconnect us, even though the documentation says this won't happen.
@@ -1887,7 +1884,7 @@ mpd_client_destroy_connector (struct mpd_client *self)
 static void
 mpd_client_on_connector_failure (void *user_data)
 {
-	struct mpd_client *self = (struct mpd_client *) user_data;
+	struct mpd_client *self = user_data;
 	mpd_client_destroy_connector (self);
 	mpd_client_fail (self);
 }
@@ -1898,7 +1895,7 @@ mpd_client_on_connector_connected
 {
 	(void) host;
 
-	struct mpd_client *self = (struct mpd_client *) user_data;
+	struct mpd_client *self = user_data;
 	mpd_client_destroy_connector (self);
 	mpd_client_finish_connection (self, socket);
 }
@@ -1942,8 +1939,7 @@ mpd_client_connect (struct mpd_client *self, const char *address,
 	if (strchr (address, '/'))
 		return mpd_client_connect_unix (self, address, e);
 
-	struct connector *connector =
-		(struct connector *) xmalloc (sizeof *connector);
+	struct connector *connector = xmalloc (sizeof *connector);
 	connector_init (connector, self->poller);
 	self->connector = connector;
 

liberty-pulse.c

@@ -0,0 +1,348 @@
+/*
+ * liberty-pulse.c: PulseAudio mainloop abstraction
+ *
+ * Copyright (c) 2016 - 2021, Přemysl Eric Janouch <p@janouch.name>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted.
+ *
+ * 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 <pulse/mainloop.h>
+
+// --- 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
+	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;
+	self->fd = poller_fd_make (data->poller, fd_);
+	self->fd.user_data = self;
+	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;
+	self->timer = poller_timer_make (data->poller);
+	self->timer.user_data = self;
+	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;
+	self->idle = poller_idle_make (data->poller);
+	self->idle.user_data = self;
+	self->idle.dispatcher = poller_pa_defer_dispatcher;
+
+	poller_idle_set (&self->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)
+{
+	(void) api;
+	(void) retval;
+
+	// This is not called from within libpulse
+	hard_assert (!"quitting the libpulse event loop is unimplemented");
+}
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+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);
+}

liberty.c

@@ -1,7 +1,7 @@
 /*
  * liberty.c: the ultimate C unlibrary
  *
- * Copyright (c) 2014 - 2020, Přemysl Eric Janouch <p@janouch.name>
+ * Copyright (c) 2014 - 2022, Přemysl Eric Janouch <p@janouch.name>
  *
  * Permission to use, copy, modify, and/or distribute this software for any
  * purpose with or without fee is hereby granted.
@@ -16,8 +16,13 @@
  *
  */
 
-#define _POSIX_C_SOURCE 199309L
+#ifndef _POSIX_C_SOURCE
+#define _POSIX_C_SOURCE 200112L
+#endif
+
+#ifndef _XOPEN_SOURCE
 #define _XOPEN_SOURCE 600
+#endif
 
 #include <stdio.h>
 #include <stddef.h>
@@ -117,8 +122,7 @@ extern char **environ;
 #define CONTAINER_OF(pointer, type, member) \
 	((type *) ((char *) pointer - offsetof (type, member)))
 
-const char *liberty =
-	"They who can give up essential liberty to obtain a little "
+char *liberty = "They who can give up essential liberty to obtain a little "
 	"temporary safety deserve neither liberty nor safety.";
 
 // --- Logging -----------------------------------------------------------------
@@ -288,7 +292,7 @@ xreallocarray (void *o, size_t n, size_t m)
 static char *
 xstrdup (const char *s)
 {
-	return strcpy ((char *) xmalloc (strlen (s) + 1), s);
+	return strcpy (xmalloc (strlen (s) + 1), s);
 }
 
 static char *
@@ -298,7 +302,7 @@ xstrndup (const char *s, size_t n)
 	if (n > size)
 		n = size;
 
-	char *copy = (char *) xmalloc (n + 1);
+	char *copy = xmalloc (n + 1);
 	memcpy (copy, s, n);
 	copy[n] = '\0';
 	return copy;
@@ -311,15 +315,14 @@ xstrndup (const char *s, size_t n)
 #define ARRAY(type, name) type *name; size_t name ## _len, name ## _alloc;
 #define ARRAY_INIT_SIZED(a, n)                                                 \
 	BLOCK_START                                                                \
-		(a) = (type *) xcalloc (sizeof *(a), (a ## _alloc) = (n));             \
+		(a) = xcalloc (sizeof *(a), (a ## _alloc) = (n));                      \
 		(a ## _len) = 0;                                                       \
 	BLOCK_END
 #define ARRAY_INIT(a) ARRAY_INIT_SIZED (a, 16)
 #define ARRAY_RESERVE(a, n)                                                    \
 	BLOCK_START                                                                \
 		while ((a ## _alloc) - (a ## _len) < n)                                \
-			(a) = (type *) xreallocarray ((a),                                 \
-				sizeof *(a), (a ## _alloc) <<= 1);                             \
+			(a) = xreallocarray ((a), sizeof *(a), (a ## _alloc) <<= 1);       \
 	BLOCK_END
 
 // --- Double-linked list helpers ----------------------------------------------
@@ -394,7 +397,7 @@ strv_make (void)
 	struct strv self;
 	self.alloc = 4;
 	self.len = 0;
-	self.vector = (char **) xcalloc (sizeof *self.vector, self.alloc);
+	self.vector = xcalloc (sizeof *self.vector, self.alloc);
 	return self;
 }
 
@@ -421,7 +424,7 @@ strv_append_owned (struct strv *self, char *s)
 {
 	self->vector[self->len] = s;
 	if (++self->len >= self->alloc)
-		self->vector = (char **) xreallocarray (self->vector,
+		self->vector = xreallocarray (self->vector,
 			sizeof *self->vector, (self->alloc <<= 1));
 	self->vector[self->len] = NULL;
 }
@@ -494,7 +497,7 @@ str_make (void)
 	struct str self;
 	self.alloc = 16;
 	self.len = 0;
-	self.str = strcpy ((char *) xmalloc (self.alloc), "");
+	self.str = strcpy (xmalloc (self.alloc), "");
 	return self;
 }
 
@@ -531,7 +534,7 @@ str_reserve (struct str *self, size_t n)
 	while (new_alloc <= self->len + n)
 		new_alloc <<= 1;
 	if (new_alloc != self->alloc)
-		self->str = (char *) xrealloc (self->str, (self->alloc = new_alloc));
+		self->str = xrealloc (self->str, (self->alloc = new_alloc));
 }
 
 static void
@@ -610,7 +613,7 @@ str_remove_slice (struct str *self, size_t start, size_t length)
 
 	// Shrink the string if the allocation becomes way too large
 	if (self->alloc >= STR_SHRINK_THRESHOLD && self->len < (self->alloc >> 2))
-		self->str = (char *) xrealloc (self->str, self->alloc >>= 2);
+		self->str = xrealloc (self->str, self->alloc >>= 2);
 }
 
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
@@ -624,11 +627,7 @@ str_pack_u8 (struct str *self, uint8_t x)
 static void
 str_pack_u16 (struct str *self, uint16_t x)
 {
-	uint8_t tmp[2] =
-	{
-		(uint8_t) (x >> 8),
-		(uint8_t)  x
-	};
+	uint8_t tmp[2] = { x >> 8, x };
 	str_append_data (self, tmp, sizeof tmp);
 }
 
@@ -636,13 +635,7 @@ static void
 str_pack_u32 (struct str *self, uint32_t x)
 {
 	uint32_t u = x;
-	uint8_t tmp[4] =
-	{
-		(uint8_t) (u >> 24),
-		(uint8_t) (u >> 16),
-		(uint8_t) (u >>  8),
-		(uint8_t)  u
-	};
+	uint8_t tmp[4] = { u >> 24, u >> 16, u >> 8, u };
 	str_append_data (self, tmp, sizeof tmp);
 }
 
@@ -650,16 +643,7 @@ static void
 str_pack_u64 (struct str *self, uint64_t x)
 {
 	uint8_t tmp[8] =
-	{
-		(uint8_t) (x >> 56),
-		(uint8_t) (x >> 48),
-		(uint8_t) (x >> 40),
-		(uint8_t) (x >> 32),
-		(uint8_t) (x >> 24),
-		(uint8_t) (x >> 16),
-		(uint8_t) (x >>  8),
-		(uint8_t)  x
-	};
+		{ x >> 56, x >> 48, x >> 40, x >> 32, x >> 24, x >> 16, x >> 8, x };
 	str_append_data (self, tmp, sizeof tmp);
 }
 
@@ -693,8 +677,8 @@ error_set (struct error **e, const char *message, ...)
 
 	hard_assert (size >= 0);
 
-	struct error *tmp = (struct error *) xmalloc (sizeof *tmp);
-	tmp->message = (char *) xmalloc (size + 1);
+	struct error *tmp = xmalloc (sizeof *tmp);
+	tmp->message = xmalloc (size + 1);
 
 	va_start (ap, message);
 	size = vsnprintf (tmp->message, size + 1, message, ap);
@@ -799,7 +783,7 @@ random_bytes (void *output, size_t len, struct error **e)
 
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
-static unsigned char g_siphash_key[16] = "SipHash 2-4 key" /* \0 */;
+static unsigned char g_siphash_key[16] = "SipHash 2-4 key!";
 
 static inline void
 siphash_wrapper_randomize (void)
@@ -811,7 +795,7 @@ siphash_wrapper_randomize (void)
 static inline uint64_t
 siphash_wrapper (const void *m, size_t len)
 {
-	return siphash (g_siphash_key, (const unsigned char *) m, len);
+	return siphash (g_siphash_key, m, len);
 }
 
 // --- String hash map ---------------------------------------------------------
@@ -853,7 +837,7 @@ str_map_make (str_map_free_fn free)
 	self.len = 0;
 	self.free = free;
 	self.key_xfrm = NULL;
-	self.map = (struct str_map_link **) xcalloc (self.alloc, sizeof *self.map);
+	self.map = xcalloc (self.alloc, sizeof *self.map);
 	self.shrink_lock = false;
 	return self;
 }
@@ -909,8 +893,7 @@ str_map_resize (struct str_map *self, size_t new_size)
 	size_t mask = new_size - 1;
 
 	self->alloc = new_size;
-	self->map =
-		(struct str_map_link **) xcalloc (self->alloc, sizeof *self->map);
+	self->map = xcalloc (self->alloc, sizeof *self->map);
 	for (i = 0; i < old_size; i++)
 	{
 		struct str_map_link *iter = old_map[i], *next_iter;
@@ -980,8 +963,7 @@ str_map_set_real (struct str_map *self, const char *key, void *value)
 
 	// Link in a new element for the given <key, value> pair
 	size_t key_length = strlen (key);
-	struct str_map_link *link =
-		(struct str_map_link *) xmalloc (sizeof *link + key_length + 1);
+	struct str_map_link *link = xmalloc (sizeof *link + key_length + 1);
 	link->data = value;
 	link->key_length = key_length;
 	memcpy (link->key, key, key_length + 1);
@@ -1184,7 +1166,7 @@ async_cancel (struct async *self)
 static void
 async_cleanup (void *user_data)
 {
-	struct async *self = (struct async *) user_data;
+	struct async *self = user_data;
 
 	hard_assert (!pthread_mutex_lock (&self->manager->lock));
 	LIST_UNLINK (self->manager->running, self);
@@ -1200,7 +1182,7 @@ async_routine (void *user_data)
 {
 	// Beware that we mustn't trigger any cancellation point before we set up
 	// the cleanup handler, otherwise we'd need to disable it first
-	struct async *self = (struct async *) user_data;
+	struct async *self = user_data;
 	pthread_cleanup_push (async_cleanup, self);
 
 	self->execute (self);
@@ -1409,8 +1391,7 @@ poller_timers_make (void)
 	struct poller_timers self;
 	self.alloc = POLLER_MIN_ALLOC;
 	self.len = 0;
-	self.heap =
-		(struct poller_timer **) xmalloc (self.alloc * sizeof *self.heap);
+	self.heap = xmalloc (self.alloc * sizeof *self.heap);
 	return self;
 }
 
@@ -1520,7 +1501,7 @@ poller_timers_set (struct poller_timers *self, struct poller_timer *timer)
 	}
 
 	if (self->len == self->alloc)
-		self->heap = (struct poller_timer **) xreallocarray (self->heap,
+		self->heap = xreallocarray (self->heap,
 			self->alloc <<= 1, sizeof *self->heap);
 	self->heap[self->len] = timer;
 	timer->index = self->len;
@@ -1597,10 +1578,9 @@ poller_init (struct poller *self)
 
 	self->len = 0;
 	self->alloc = POLLER_MIN_ALLOC;
-	self->fds = (struct poller_fd **) xcalloc (self->alloc, sizeof *self->fds);
-	self->dummy = (int *) xcalloc (self->alloc, sizeof *self->dummy);
-	self->revents = (struct epoll_event *)
-		xcalloc (self->alloc, sizeof *self->revents);
+	self->fds = xcalloc (self->alloc, sizeof *self->fds);
+	self->dummy = xcalloc (self->alloc, sizeof *self->dummy);
+	self->revents = xcalloc (self->alloc, sizeof *self->revents);
 	self->revents_len = 0;
 
 	poller_common_init (&self->common, self);
@@ -1613,7 +1593,7 @@ poller_free (struct poller *self)
 	{
 		struct poller_fd *fd = self->fds[i];
 		hard_assert (epoll_ctl (self->epoll_fd,
-			EPOLL_CTL_DEL, fd->fd, (struct epoll_event *) "") != -1);
+			EPOLL_CTL_DEL, fd->fd, (void *) "") != -1);
 	}
 
 	poller_common_free (&self->common);
@@ -1633,11 +1613,11 @@ poller_ensure_space (struct poller *self)
 	self->alloc <<= 1;
 	hard_assert (self->alloc != 0);
 
-	self->revents = (struct epoll_event *) xreallocarray
+	self->revents = xreallocarray
 		(self->revents, sizeof *self->revents, self->alloc);
-	self->fds = (struct poller_fd **) xreallocarray
+	self->fds = xreallocarray
 		(self->fds, sizeof *self->fds, self->alloc);
-	self->dummy = (int *) xreallocarray
+	self->dummy = xreallocarray
 		(self->dummy, sizeof *self->dummy, self->alloc);
 }
 
@@ -1689,12 +1669,8 @@ poller_set (struct poller *self, struct poller_fd *fd)
 static int
 poller_compare_fds (const void *ax, const void *bx)
 {
-	const struct epoll_event
-		*ay = (const struct epoll_event *) ax,
-		*by = (const struct epoll_event *) bx;
-	struct poller_fd
-		*a = (struct poller_fd *) ay->data.ptr,
-		*b = (struct poller_fd *) by->data.ptr;
+	const struct epoll_event *ay = ax, *by = bx;
+	struct poller_fd *a = ay->data.ptr, *b = by->data.ptr;
 	return a->fd - b->fd;
 }
 
@@ -1705,7 +1681,7 @@ poller_remove_from_dispatch (struct poller *self, const struct poller_fd *fd)
 		return;
 
 	struct epoll_event key = { .data.ptr = (void *) fd }, *fd_event;
-	if ((fd_event = (struct epoll_event *) bsearch (&key, self->revents,
+	if ((fd_event = bsearch (&key, self->revents,
 		self->revents_len, sizeof *self->revents, poller_compare_fds)))
 	{
 		fd_event->events = -1;
@@ -1728,7 +1704,7 @@ poller_remove_at_index (struct poller *self, size_t index)
 	poller_remove_from_dispatch (self, fd);
 	if (!fd->closed)
 		hard_assert (epoll_ctl (self->epoll_fd,
-			EPOLL_CTL_DEL, fd->fd, (struct epoll_event *) "") != -1);
+			EPOLL_CTL_DEL, fd->fd, (void *) "") != -1);
 
 	if (index != --self->len)
 	{
@@ -1764,7 +1740,7 @@ poller_run (struct poller *self)
 		if (revents->events == (uint32_t) -1)
 			continue;
 
-		struct poller_fd *fd = (struct poller_fd *) revents->data.ptr;
+		struct poller_fd *fd = revents->data.ptr;
 		hard_assert (fd->index != -1);
 
 		struct pollfd pfd;
@@ -1778,10 +1754,9 @@ poller_run (struct poller *self)
 	self->revents_len = 0;
 }
 
-#elif defined (BSD)
-
-// Mac OS X's kqueue is fatally broken, or so I've been told; leaving it out.
-// Otherwise this is sort of similar to the epoll version.
+// Sort of similar to the epoll version.  Let's hope Darwin isn't broken,
+// that'd mean reimplementing this in terms of select() just because of Crapple.
+#elif defined (BSD) || defined (__APPLE__)
 
 #include <sys/types.h>
 #include <sys/event.h>
@@ -1807,9 +1782,8 @@ poller_init (struct poller *self)
 
 	self->len = 0;
 	self->alloc = POLLER_MIN_ALLOC;
-	self->fds = (struct poller_fd **) xcalloc (self->alloc, sizeof *self->fds);
-	self->revents = (struct kevent *)
-		xcalloc (self->alloc, sizeof *self->revents);
+	self->fds = xcalloc (self->alloc, sizeof *self->fds);
+	self->revents = xcalloc (self->alloc, sizeof *self->revents);
 	self->revents_len = 0;
 	poller_common_init (&self->common, self);
 }
@@ -1832,9 +1806,9 @@ poller_ensure_space (struct poller *self)
 	self->alloc <<= 1;
 	hard_assert (self->alloc != 0);
 
-	self->revents = (struct kevent *) xreallocarray
+	self->revents = xreallocarray
 		(self->revents, sizeof *self->revents, self->alloc);
-	self->fds = (struct poller_fd **) xreallocarray
+	self->fds = xreallocarray
 		(self->fds, sizeof *self->fds, self->alloc);
 }
 
@@ -2034,9 +2008,8 @@ poller_init (struct poller *self)
 {
 	self->alloc = POLLER_MIN_ALLOC;
 	self->len = 0;
-	self->fds = (struct pollfd **) xcalloc (self->alloc, sizeof *self->fds);
-	self->fds_data = (struct poller_fd **)
-		xcalloc (self->alloc, sizeof *self->fds_data);
+	self->fds = xcalloc (self->alloc, sizeof *self->fds);
+	self->fds_data = xcalloc (self->alloc, sizeof *self->fds_data);
 	poller_common_init (&self->common, self);
 	self->dispatch_next = -1;
 }
@@ -2056,9 +2029,8 @@ poller_ensure_space (struct poller *self)
 		return;
 
 	self->alloc <<= 1;
-	self->fds = (struct pollfd *)
-		xreallocarray (self->fds, sizeof *self->fds, self->alloc);
-	self->fds_data = (struct poller_fd **) xreallocarray
+	self->fds = xreallocarray (self->fds, sizeof *self->fds, self->alloc);
+	self->fds_data = xreallocarray
 		(self->fds_data, sizeof *self->fds_data, self->alloc);
 }
 
@@ -2342,8 +2314,7 @@ static struct async_getaddrinfo *
 async_getaddrinfo (struct async_manager *manager,
 	const char *host, const char *service, const struct addrinfo *hints)
 {
-	struct async_getaddrinfo *self =
-		(struct async_getaddrinfo *) xcalloc (1, sizeof *self);
+	struct async_getaddrinfo *self = xcalloc (1, sizeof *self);
 	self->async = async_make (manager);
 
 	if (host)     self->host = xstrdup (host);
@@ -2407,11 +2378,10 @@ static struct async_getnameinfo *
 async_getnameinfo (struct async_manager *manager,
 	const struct sockaddr *sa, socklen_t sa_len, int flags)
 {
-	struct async_getnameinfo *self =
-		(struct async_getnameinfo *) xcalloc (1, sizeof *self);
+	struct async_getnameinfo *self = xcalloc (1, sizeof *self);
 	self->async = async_make (manager);
 
-	self->address = (struct sockaddr *) memcpy (xmalloc (sa_len), sa, sa_len);
+	self->address = memcpy (xmalloc (sa_len), sa, sa_len);
 	self->address_len = sa_len;
 	self->flags = flags;
 
@@ -2485,7 +2455,7 @@ write_queue_processed (struct write_queue *self, size_t len)
 }
 
 static bool
-write_queue_is_empty (struct write_queue *self)
+write_queue_is_empty (const struct write_queue *self)
 {
 	return self->head == NULL;
 }
@@ -2576,16 +2546,11 @@ struct msg_unpacker
 static struct msg_unpacker
 msg_unpacker_make (const void *data, size_t len)
 {
-	return (struct msg_unpacker)
-	{
-		.data = (const char *) data,
-		.offset = 0,
-		.len = len
-	};
+	return (struct msg_unpacker) { .data = data, .len = len, .offset = 0 };
 }
 
 static size_t
-msg_unpacker_get_available (struct msg_unpacker *self)
+msg_unpacker_get_available (const struct msg_unpacker *self)
 {
 	return self->len - self->offset;
 }
@@ -2670,16 +2635,8 @@ msg_writer_flush (struct msg_writer *self, size_t *len)
 {
 	// Update the message length
 	uint64_t x = self->buf.len;
-	uint8_t tmp[8] = {
-		(uint8_t) (x >> 56),
-		(uint8_t) (x >> 48),
-		(uint8_t) (x >> 40),
-		(uint8_t) (x >> 32),
-		(uint8_t) (x >> 24),
-		(uint8_t) (x >> 16),
-		(uint8_t) (x >>  8),
-		(uint8_t)  x
-	};
+	uint8_t tmp[8] =
+		{ x >> 56, x >> 48, x >> 40, x >> 32, x >> 24, x >> 16, x >> 8, x };
 	memcpy (self->buf.str, tmp, sizeof tmp);
 
 	*len = x;
@@ -2795,16 +2752,12 @@ utf8_decode (const char **s, size_t len)
 	}
 
 	// In the middle of a character
-	if (sequence_len == 1)
+	// or an overlong sequence (subset, possibly MUTF-8, not supported)
+	if (sequence_len == 1 || *p == 0xC0 || *p == 0xC1)
 		return -1;
 
 	// Check the rest of the sequence
 	uint32_t cp = *p++ & ~mask;
-
-	// Overlong sequence (possibly MUTF-8, not supported)
-	if (!cp && sequence_len)
-		return -1;
-
 	while (sequence_len && --sequence_len)
 	{
 		if (p == end)
@@ -2958,7 +2911,7 @@ base64_encode (const void *data, size_t len, struct str *output)
 	const char *alphabet =
 		"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 
-	const uint8_t *p = (const uint8_t *) data;
+	const uint8_t *p = data;
 	size_t n_groups = len / 3;
 	size_t tail = len - n_groups * 3;
 	uint32_t group;
@@ -2995,10 +2948,10 @@ base64_encode (const void *data, size_t len, struct str *output)
 // --- Utilities ---------------------------------------------------------------
 
 static void
-cstr_set (char **s, char *new_)
+cstr_set (char **s, char *new)
 {
 	free (*s);
-	*s = new_;
+	*s = new;
 }
 
 static void
@@ -3076,7 +3029,7 @@ iconv_xstrdup (iconv_t conv, char *in, size_t in_len, size_t *out_len)
 	char *buf, *buf_ptr;
 	size_t out_left, buf_alloc;
 
-	buf = buf_ptr = (char *) xmalloc (out_left = buf_alloc = 64);
+	buf = buf_ptr = xmalloc (out_left = buf_alloc = 64);
 
 	char *in_ptr = in;
 	if (in_len == (size_t) -1)
@@ -3092,7 +3045,7 @@ iconv_xstrdup (iconv_t conv, char *in, size_t in_len, size_t *out_len)
 			return NULL;
 		}
 		out_left += buf_alloc;
-		char *new_buf = (char *) xrealloc (buf, buf_alloc <<= 1);
+		char *new_buf = xrealloc (buf, buf_alloc <<= 1);
 		buf_ptr += new_buf - buf;
 		buf = new_buf;
 	}
@@ -3173,8 +3126,8 @@ lock_pid_file (const char *path, struct error **e)
 	struct flock lock =
 	{
 		.l_type = F_WRLCK,
-		.l_whence = SEEK_SET,
 		.l_start = 0,
+		.l_whence = SEEK_SET,
 		.l_len = 0,
 	};
 	if (fcntl (fd, F_SETLK, &lock))
@@ -3298,7 +3251,7 @@ get_xdg_config_dirs (struct strv *out)
 	str_free (&config_home);
 
 	const char *xdg_config_dirs;
-	if (!(xdg_config_dirs = getenv ("XDG_CONFIG_DIRS")))
+	if (!(xdg_config_dirs = getenv ("XDG_CONFIG_DIRS")) || !*xdg_config_dirs)
 		xdg_config_dirs = "/etc/xdg";
 	cstr_split (xdg_config_dirs, ":", true, out);
 }
@@ -3323,7 +3276,7 @@ get_xdg_data_dirs (struct strv *out)
 	str_free (&data_home);
 
 	const char *xdg_data_dirs;
-	if (!(xdg_data_dirs = getenv ("XDG_DATA_DIRS")))
+	if (!(xdg_data_dirs = getenv ("XDG_DATA_DIRS")) || !*xdg_data_dirs)
 		xdg_data_dirs = "/usr/local/share/:/usr/share/";
 	cstr_split (xdg_data_dirs, ":", true, out);
 }
@@ -3373,7 +3326,7 @@ resolve_relative_runtime_filename (const char *filename)
 /// path can reside in a system-wide directory with no risk of a conflict.
 /// However, we have to take care about permissions.  Do we even need this?
 static char *
-resolve_relative_runtime_template (const char *template_)
+resolve_relative_runtime_template (const char *template)
 {
 	struct str path = str_make ();
 	const char *runtime_dir = getenv ("XDG_RUNTIME_DIR");
@@ -3385,7 +3338,7 @@ resolve_relative_runtime_template (const char *template_)
 	else
 		str_append_printf (&path, "/tmp/%s.%d", PROGRAM_NAME, geteuid ());
 
-	str_append_printf (&path, "/%s", template_);
+	str_append_printf (&path, "/%s", template);
 	return resolve_relative_runtime_filename_finish (path);
 }
 
@@ -3407,9 +3360,9 @@ try_expand_tilde (const char *filename)
 	struct passwd pwd, *success = NULL;
 
 	char *user = xstrndup (filename, until_slash);
-	char *buf = (char *) xmalloc (buf_len);
+	char *buf = xmalloc (buf_len);
 	while (getpwnam_r (user, &pwd, buf, buf_len, &success) == ERANGE)
-		buf = (char *) xrealloc (buf, buf_len <<= 1);
+		buf = xrealloc (buf, buf_len <<= 1);
 	free (user);
 
 	char *result = NULL;
@@ -3485,7 +3438,7 @@ xssl_get_error (SSL *ssl, int result, const char **error_info)
 static regex_t *
 regex_compile (const char *regex, int flags, struct error **e)
 {
-	regex_t *re = (regex_t *) xmalloc (sizeof *re);
+	regex_t *re = xmalloc (sizeof *re);
 	int err = regcomp (re, regex, flags);
 	if (!err)
 		return re;
@@ -3501,7 +3454,7 @@ regex_compile (const char *regex, int flags, struct error **e)
 static void
 regex_free (void *regex)
 {
-	regfree ((regex_t *) regex);
+	regfree (regex);
 	free (regex);
 }
 
@@ -3520,7 +3473,7 @@ static bool
 regex_cache_match (struct str_map *cache, const char *regex, int flags,
 	const char *s, struct error **e)
 {
-	regex_t *re = (regex_t *) str_map_find (cache, regex);
+	regex_t *re = str_map_find (cache, regex);
 	if (!re)
 	{
 		re = regex_compile (regex, flags, e);
@@ -3790,7 +3743,7 @@ opt_handler_make (int argc, char **argv,
 
 	self.opts = opts;
 	self.opts_len = len;
-	self.options = (struct option *) xcalloc (len + 1, sizeof *self.options);
+	self.options = xcalloc (len + 1, sizeof *self.options);
 
 	struct str opt_string = str_make ();
 	for (size_t i = 0; i < len; i++)
@@ -3968,7 +3921,7 @@ test_add_internal (struct test *self, const char *name, size_t fixture_size,
 	hard_assert (test != NULL);
 	hard_assert (name != NULL);
 
-	struct test_unit *unit = (struct test_unit *) xcalloc (1, sizeof *unit);
+	struct test_unit *unit = xcalloc (1, sizeof *unit);
 	unit->name = xstrdup (name);
 	unit->fixture_size = fixture_size;
 	unit->user_data = user_data;
@@ -4121,8 +4074,7 @@ struct connector_target
 static struct connector_target *
 connector_target_new (void)
 {
-	struct connector_target *self =
-		(struct connector_target *) xcalloc (1, sizeof *self);
+	struct connector_target *self = xcalloc (1, sizeof *self);
 	return self;
 }
 
@@ -4335,7 +4287,7 @@ connector_free (struct connector *self)
 static void
 connector_on_getaddrinfo (int err, struct addrinfo *results, void *user_data)
 {
-	struct connector_target *self = (struct connector_target *) user_data;
+	struct connector_target *self = user_data;
 
 	if (err)
 	{
@@ -4465,11 +4417,13 @@ socket_io_try_write (int socket_fd, struct str *wb)
 //   object  = lws '{' entries endobj
 //   endobj  = lws '}'
 //
-//   string  = lws '"' ('\\' escape / ![\\"] char)* '"'
+//   quoted  = lws '"' (!["\\] char / '\\' escape)* '"'
+//           / lws '`' (![`] char)* '`'
+//   string  = (quoted)+
 //   char    = [\0-\177]  # or any Unicode codepoint in the UTF-8 encoding
 //   escape  = [\\"abfnrtv] / [xX][0-9A-Fa-f][0-9A-Fa-f]? / [0-7][0-7]?[0-7]?
 //
-//   integer = lws '-'? [0-9]+  # whatever strtoll() accepts on your system
+//   integer = lws [-+]? [0-9]+  # whatever strtoll() accepts on your system
 //   null    = lws 'null'
 //   boolean = lws 'yes'  / lws 'YES'  / lws 'no'    / lws 'NO'
 //           / lws 'on'   / lws 'ON'   / lws 'off'   / lws 'OFF'
@@ -4588,8 +4542,7 @@ config_item_move (struct config_item *self, struct config_item *source)
 static struct config_item *
 config_item_new (enum config_item_type type)
 {
-	struct config_item *self =
-		(struct config_item *) xcalloc (1, sizeof *self);
+	struct config_item *self = xcalloc (1, sizeof *self);
 	self->type = type;
 	return self;
 }
@@ -4729,8 +4682,7 @@ config_item_get (struct config_item *self, const char *path, struct error **e)
 		const char *key = v.vector[i];
 		if (!*key)
 			error_set (e, "empty path element");
-		else if (!(self = (struct config_item *)
-			str_map_find (&self->value.object, key)))
+		else if (!(self = str_map_find (&self->value.object, key)))
 			error_set (e, "`%s' not found in object", key);
 		else if (++i == v.len)
 			result = self;
@@ -4762,13 +4714,15 @@ config_item_write_string (struct str *output, const struct str *s)
 	for (size_t i = 0; i < s->len; i++)
 	{
 		unsigned char c = s->str[i];
-		if      (c == '\n')  str_append        (output, "\\n");
-		else if (c == '\r')  str_append        (output, "\\r");
-		else if (c == '\t')  str_append        (output, "\\t");
-		else if (c == '\\')  str_append        (output, "\\\\");
-		else if (c == '"')   str_append        (output, "\\\"");
-		else if (c < 32)     str_append_printf (output, "\\x%02x", c);
-		else                 str_append_c      (output, c);
+		if      (c == '\n')  str_append (output, "\\n");
+		else if (c == '\r')  str_append (output, "\\r");
+		else if (c == '\t')  str_append (output, "\\t");
+		else if (c == '\\')  str_append (output, "\\\\");
+		else if (c == '"')   str_append (output, "\\\"");
+		else if (iscntrl_ascii (c))
+			str_append_printf (output, "\\x%02x", c);
+		else
+			str_append_c (output, c);
 	}
 	str_append_c (output, '"');
 }
@@ -4861,7 +4815,7 @@ config_item_write_object_innards
 
 	struct str_map_iter iter = str_map_iter_make (&object->value.object);
 	struct config_item *value;
-	while ((value = (struct config_item *) str_map_iter_next (&iter)))
+	while ((value = str_map_iter_next (&iter)))
 		config_item_write_kv_pair (self, iter.link->key, value);
 }
 
@@ -5092,10 +5046,10 @@ config_tokenizer_escape_sequence
 }
 
 static bool
-config_tokenizer_string
-	(struct config_tokenizer *self, struct str *output, struct error **e)
+config_tokenizer_dq_string (struct config_tokenizer *self, struct str *output,
+	struct error **e)
 {
-	unsigned char c;
+	unsigned char c = config_tokenizer_advance (self);
 	while (self->len)
 	{
 		if ((c = config_tokenizer_advance (self)) == '"')
@@ -5109,6 +5063,44 @@ config_tokenizer_string
 	return false;
 }
 
+static bool
+config_tokenizer_bt_string (struct config_tokenizer *self, struct str *output,
+	struct error **e)
+{
+	unsigned char c = config_tokenizer_advance (self);
+	while (self->len)
+	{
+		if ((c = config_tokenizer_advance (self)) == '`')
+			return true;
+		str_append_c (output, c);
+	}
+	config_tokenizer_error (self, e, "premature end of string");
+	return false;
+}
+
+static bool
+config_tokenizer_string (struct config_tokenizer *self, struct str *output,
+	struct error **e)
+{
+	// Go-like strings, with C/AWK-like automatic concatenation
+	while (self->len)
+	{
+		bool ok = true;
+		if (isspace_ascii (*self->p) && *self->p != '\n')
+			config_tokenizer_advance (self);
+		else if (*self->p == '"')
+			ok = config_tokenizer_dq_string (self, output, e);
+		else if (*self->p == '`')
+			ok = config_tokenizer_bt_string (self, output, e);
+		else
+			break;
+
+		if (!ok)
+			return false;
+	}
+	return true;
+}
+
 static enum config_token
 config_tokenizer_next (struct config_tokenizer *self, struct error **e)
 {
@@ -5133,7 +5125,7 @@ config_tokenizer_next (struct config_tokenizer *self, struct error **e)
 		return CONFIG_T_ABORT;
 
 	case '"':
-		config_tokenizer_advance (self);
+	case '`':
 		str_reset (&self->string);
 		if (!config_tokenizer_string (self, &self->string, e))
 			return CONFIG_T_ABORT;
@@ -5427,11 +5419,11 @@ config_read_from_file (const char *filename, struct error **e)
 {
 	struct config_item *root = NULL;
 
-	struct error *error = NULL;
 	struct str data = str_make ();
 	if (!read_file (filename, &data, e))
 		goto end;
 
+	struct error *error = NULL;
 	if (!(root = config_item_parse (data.str, data.len, false, &error)))
 	{
 		error_set (e, "parse error in `%s': %s", filename, error->message);
@@ -5451,12 +5443,12 @@ config_schema_initialize_item (struct config_schema *schema,
 	struct error **e)
 {
 	hard_assert (parent->type == CONFIG_ITEM_OBJECT);
-	struct config_item *item = (struct config_item *)
+	struct config_item *item =
 		str_map_find (&parent->value.object, schema->name);
 
-	struct error *error = NULL;
 	if (item)
 	{
+		struct error *error = NULL;
 		item->user_data = user_data;
 		if (config_item_validate_by_schema (item, schema, &error))
 			goto keep_current;
@@ -5464,9 +5456,9 @@ config_schema_initialize_item (struct config_schema *schema,
 		error_set (warning, "resetting configuration item "
 			"`%s' to default: %s", schema->name, error->message);
 		error_free (error);
-		error = NULL;
 	}
 
+	struct error *error = NULL;
 	if (schema->default_)
 		item = config_item_parse
 			(schema->default_, strlen (schema->default_), true, &error);
@@ -5529,7 +5521,7 @@ config_schema_call_changed (struct config_item *item)
 	{
 		struct str_map_iter iter = str_map_iter_make (&item->value.object);
 		struct config_item *child;
-		while ((child = (struct config_item *) str_map_iter_next (&iter)))
+		while ((child = str_map_iter_next (&iter)))
 			config_schema_call_changed (child);
 	}
 	else if (item->schema && item->schema->on_change)
@@ -5582,8 +5574,7 @@ static void
 config_register_module (struct config *self,
 	const char *name, config_module_load_fn loader, void *user_data)
 {
-	struct config_module *module =
-		(struct config_module *) xcalloc (1, sizeof *module);
+	struct config_module *module = xcalloc (1, sizeof *module);
 	module->name = xstrdup (name);
 	module->loader = loader;
 	module->user_data = user_data;
@@ -5601,9 +5592,9 @@ config_load (struct config *self, struct config_item *root)
 
 	struct str_map_iter iter = str_map_iter_make (&self->modules);
 	struct config_module *module;
-	while ((module = (struct config_module *) str_map_iter_next (&iter)))
+	while ((module = str_map_iter_next (&iter)))
 	{
-		struct config_item *subtree = (struct config_item *) str_map_find
+		struct config_item *subtree = str_map_find
 			(&root->value.object, module->name);
 		// Silently fix inputs that only a lunatic user could create
 		if (!subtree || subtree->type != CONFIG_ITEM_OBJECT)

siphash.c

@@ -82,4 +82,3 @@ siphash (const unsigned char key[16], const unsigned char *m, size_t len)
 
 	return v0 ^ v1 ^ v2 ^ v3;
 }
-

tests/liberty.c

@@ -1,7 +1,7 @@
 /*
  * tests/liberty.c
  *
- * Copyright (c) 2015 - 2016, Přemysl Eric Janouch <p@janouch.name>
+ * Copyright (c) 2015 - 2022, Přemysl Eric Janouch <p@janouch.name>
  *
  * Permission to use, copy, modify, and/or distribute this software for any
  * purpose with or without fee is hereby granted.
@@ -331,10 +331,12 @@ test_utf8 (void)
 	soft_assert (utf8_decode (&partial, 1) == -2);
 	soft_assert (utf8_decode (&empty,   0) == -1);
 
-	const char valid[] = "2H₂ + O₂ ⇌ 2H₂O, R = 4.7 kΩ, ⌀ 200 mm";
+	const char valid_1[] = "2H₂ + O₂ ⇌ 2H₂O, R = 4.7 kΩ, ⌀ 200 mm";
+	const char valid_2[] = "\xf0\x93\x82\xb9";
 	const char invalid_1[] = "\xf0\x90\x28\xbc";
 	const char invalid_2[] = "\xc0\x80";
-	soft_assert ( utf8_validate (valid,     sizeof valid));
+	soft_assert ( utf8_validate (valid_1,   sizeof valid_1));
+	soft_assert ( utf8_validate (valid_2,   sizeof valid_2));
 	soft_assert (!utf8_validate (invalid_1, sizeof invalid_1));
 	soft_assert (!utf8_validate (invalid_2, sizeof invalid_2));
 
@@ -647,7 +649,7 @@ static struct config_schema g_config_test[] =
 	  .default_  = "1" },
 	{ .name      = "foobar",
 	  .type      = CONFIG_ITEM_STRING,
-	  .default_  = "\"qux\\x01\"" },
+	  .default_  = "\"qux\\x01`\" \"\"`a`" },
 	{}
 };
 
@@ -673,6 +675,9 @@ test_config (void)
 		"top.bar", NULL), invalid, NULL));
 	config_item_destroy (invalid);
 
+	hard_assert (!strcmp ("qux\001`a",
+		config_item_get (config.root, "top.foobar", NULL)->value.string.str));
+
 	struct str s = str_make ();
 	config_item_write (config.root, true, &s);
 	struct config_item *parsed = config_item_parse (s.str, s.len, false, NULL);

tests/pulse.c

@@ -0,0 +1,127 @@
+/*
+ * tests/pulse.c
+ *
+ * Copyright (c) 2021, Přemysl Eric Janouch <p@janouch.name>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted.
+ *
+ * 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 PROGRAM_NAME "test"
+#define PROGRAM_VERSION "0"
+
+#define LIBERTY_WANT_POLLER
+
+#include "../liberty.c"
+#include "../liberty-pulse.c"
+
+// --- Tests -------------------------------------------------------------------
+
+enum
+{
+	EVENT_IO    =  1 << 0,
+	EVENT_TIME  =  1 << 1,
+	EVENT_DEFER =  1 << 2,
+	EVENT_ALL   = (1 << 3) - 1
+};
+
+static intptr_t g_events = 0;
+static intptr_t g_destroys = 0;
+
+static void
+io_event_cb (pa_mainloop_api *a,
+	pa_io_event *e, int fd, pa_io_event_flags_t events, void *userdata)
+{
+	(void) a; (void) e; (void) fd; (void) events;
+	g_events |= (intptr_t) userdata;
+}
+
+static void
+io_event_destroy_cb (pa_mainloop_api *a, pa_io_event *e, void *userdata)
+{
+	(void) a; (void) e;
+	g_destroys += (intptr_t) userdata;
+}
+
+static void
+time_event_cb (pa_mainloop_api *a,
+	pa_time_event *e, const struct timeval *tv, void *userdata)
+{
+	(void) a; (void) e; (void) tv;
+	g_events |= (intptr_t) userdata;
+}
+
+static void
+time_event_destroy_cb (pa_mainloop_api *a, pa_time_event *e, void *userdata)
+{
+	(void) a; (void) e;
+	g_destroys += (intptr_t) userdata;
+}
+
+static void
+defer_event_cb (pa_mainloop_api *a, pa_defer_event *e, void *userdata)
+{
+	(void) a; (void) e;
+	g_events |= (intptr_t) userdata;
+}
+
+static void
+defer_event_destroy_cb (pa_mainloop_api *a, pa_defer_event *e, void *userdata)
+{
+	(void) a; (void) e;
+	g_destroys += (intptr_t) userdata;
+}
+
+static void
+test_pulse (void)
+{
+	struct poller poller;
+	poller_init (&poller);
+
+	// Let's just get this over with, not aiming for high test coverage here
+	pa_mainloop_api *api = poller_pa_new (&poller);
+
+	pa_io_event *ie = api->io_new (api, STDOUT_FILENO, PA_IO_EVENT_OUTPUT,
+		io_event_cb, (void *) EVENT_IO);
+	api->io_set_destroy (ie, io_event_destroy_cb);
+
+	const struct timeval tv = poller_pa_get_current_time ();
+	pa_time_event *te = api->time_new (api, &tv,
+		time_event_cb, (void *) EVENT_TIME);
+	api->time_set_destroy (te, time_event_destroy_cb);
+	api->time_restart (te, &tv);
+
+	pa_defer_event *de = api->defer_new (api,
+		defer_event_cb, (void *) EVENT_DEFER);
+	api->defer_set_destroy (de, defer_event_destroy_cb);
+	api->defer_enable (api->defer_new (api,
+		defer_event_cb, (void *) EVENT_DEFER), false);
+
+	alarm (1);
+	while (g_events != EVENT_ALL)
+		poller_run (&poller);
+
+	poller_pa_destroy (api);
+	soft_assert (g_destroys == EVENT_ALL);
+	poller_free (&poller);
+}
+
+// --- Main --------------------------------------------------------------------
+
+int
+main (int argc, char *argv[])
+{
+	struct test test;
+	test_init (&test, argc, argv);
+	test_add_simple (&test, "/pulse", NULL, test_pulse);
+	return test_run (&test);
+}