Work on changing style

Signed-off-by: Mattias Andrée <maandree@kth.se>

10 files changed, 2124 insertions, 2153 deletions

diff --git a/src/libmdsserver/client-list.c b/src/libmdsserver/client-list.c
index 19eaf5a..02d555e 100644
--- a/src/libmdsserver/client-list.c
+++ b/src/libmdsserver/client-list.c
@@ -27,7 +27,7 @@
  * The default initial capacity
  */
 #ifndef CLIENT_LIST_DEFAULT_INITIAL_CAPACITY
-#define CLIENT_LIST_DEFAULT_INITIAL_CAPACITY  8
+# define CLIENT_LIST_DEFAULT_INITIAL_CAPACITY 8
 #endif
 
 
@@ -38,19 +38,19 @@
  * @param   value  The value to be rounded up to a power of two
  * @return         The nearest, but not smaller, power of two
  */
-__attribute__((const))
-static size_t to_power_of_two(size_t value)
+static size_t __attribute__((const))
+to_power_of_two(size_t value)
 {
-  value -= 1;
-  value |= value >> 1;
-  value |= value >> 2;
-  value |= value >> 4;
-  value |= value >> 8;
-  value |= value >> 16;
+	value -= 1;
+	value |= value >> 1;
+	value |= value >> 2;
+	value |= value >> 4;
+	value |= value >> 8;
+	value |= value >> 16;
 #if SIZE_MAX == UINT64_MAX
-  value |= value >> 32;
+	value |= value >> 32;
 #endif
-  return value + 1;
+	return value + 1;
 }
 
 
@@ -61,21 +61,22 @@ static size_t to_power_of_two(size_t value)
  * @param   capacity  The minimum initial capacity of the client list, 0 for default
  * @return            Non-zero on error, `errno` will have been set accordingly
  */
-int client_list_create(client_list_t* restrict this, size_t capacity)
+int
+client_list_create(client_list_t *restrict this, size_t capacity)
 {
-  /* Use default capacity of zero is specified. */
-  if (capacity == 0)
-    capacity = CLIENT_LIST_DEFAULT_INITIAL_CAPACITY;
-  
-  /* Initialise the client list. */
-  this->capacity = capacity = to_power_of_two(capacity);
-  this->size     = 0;
-  this->clients  = NULL;
-  fail_if (xmalloc(this->clients, capacity, uint64_t));
-  
-  return 0;
- fail:
-  return -1;
+	/* Use default capacity of zero is specified. */
+	if (!capacity)
+		capacity = CLIENT_LIST_DEFAULT_INITIAL_CAPACITY;
+
+	/* Initialise the client list. */
+	this->capacity = capacity = to_power_of_two(capacity);
+	this->size     = 0;
+	this->clients  = NULL;
+	fail_if (xmalloc(this->clients, capacity, uint64_t));
+
+	return 0;
+fail:
+	return -1;
 }
 
 
@@ -85,10 +86,11 @@ int client_list_create(client_list_t* restrict this, size_t capacity)
  * 
  * @param  this  The client list
  */
-void client_list_destroy(client_list_t* restrict this)
+void
+client_list_destroy(client_list_t *restrict this)
 {
-  free(this->clients);
-  this->clients = NULL;
+	free(this->clients);
+	this->clients = NULL;
 }
 
 
@@ -99,17 +101,18 @@ void client_list_destroy(client_list_t* restrict this)
  * @param   out   Memory slot in which to store the new client list
  * @return        Non-zero on error, `errno` will have been set accordingly
  */
-int client_list_clone(const client_list_t* restrict this, client_list_t* restrict out)
+int
+client_list_clone(const client_list_t *restrict this, client_list_t *restrict out)
 {
-  fail_if (xmemdup(out->clients, this->clients, this->capacity, uint64_t));
-  
-  out->capacity = this->capacity;
-  out->size     = this->size;
-  
-  return 0;
-  
- fail:
-  return -1;
+	fail_if (xmemdup(out->clients, this->clients, this->capacity, uint64_t));
+
+	out->capacity = this->capacity;
+	out->size     = this->size;
+
+	return 0;
+
+fail:
+	return -1;
 }
 
 
@@ -120,23 +123,23 @@ int client_list_clone(const client_list_t* restrict this, client_list_t* restric
  * @param   client  The client to add
  * @return          Non-zero on error, `errno` will be set accordingly
  */
-int client_list_add(client_list_t* restrict this, uint64_t client)
+int
+client_list_add(client_list_t *restrict this, uint64_t client)
 {
-  if (this->size == this->capacity)
-    {
-      uint64_t* old = this->clients;
-      if (xrealloc(old, this->capacity <<= 1, uint64_t))
-	{
-	  this->capacity >>= 1;
-	  this->clients = old;
-	  fail_if (1);
+	uint64_t* old;
+	if (this->size == this->capacity) {
+		old = this->clients;
+		if (xrealloc(old, this->capacity <<= 1, uint64_t)) {
+			this->capacity >>= 1;
+			this->clients = old;
+			fail_if (1);
+		}
 	}
-    }
-  
-  this->clients[this->size++] = client;
-  return 0;
- fail:
-  return -1;
+
+	this->clients[this->size++] = client;
+	return 0;
+fail:
+	return -1;
 }
 
 
@@ -146,29 +149,27 @@ int client_list_add(client_list_t* restrict this, uint64_t client)
  * @param  this    The list
  * @param  client  The client to remove
  */
-void client_list_remove(client_list_t* restrict this, uint64_t client)
+void
+client_list_remove(client_list_t *restrict this, uint64_t client)
 {
-  size_t i;
-  for (i = 0; i < this->size; i++)
-    {
-      if (this->clients[i] == client)
-	{
-	  size_t n = (--(this->size) - i) * sizeof(uint64_t);
-	  memmove(this->clients + i, this->clients + i + 1, n);
-	  
-	  if (this->size << 1 <= this->capacity)
-	    {
-	      uint64_t* old = this->clients;
-	      if (xrealloc(old, this->capacity >>= 1, uint64_t))
-		{
-		  this->capacity <<= 1;
-		  this->clients = old;
+	size_t i, n;
+	uint64_t *old;
+	for (i = 0; i < this->size; i++) {
+		if (this->clients[i] == client) {
+			n = (--(this->size) - i) * sizeof(uint64_t);
+			memmove(this->clients + i, this->clients + i + 1, n);
+
+			if (this->size << 1 <= this->capacity) {
+				old = this->clients;
+				if (xrealloc(old, this->capacity >>= 1, uint64_t)) {
+					this->capacity <<= 1;
+					this->clients = old;
+				}
+			}
+
+			return;
 		}
-	    }
-	  
-	  return;
 	}
-    }
 }
 
 
@@ -178,9 +179,10 @@ void client_list_remove(client_list_t* restrict this, uint64_t client)
  * @param   this  The list
  * @return        The number of bytes to allocate to the output buffer
  */
-size_t client_list_marshal_size(const client_list_t* restrict this)
+size_t
+client_list_marshal_size(const client_list_t *restrict this)
 {
-  return 2 * sizeof(size_t) + this->size * sizeof(uint64_t) + sizeof(int);
+	return 2 * sizeof(size_t) + this->size * sizeof(uint64_t) + sizeof(int);
 }
 
 
@@ -190,13 +192,14 @@ size_t client_list_marshal_size(const client_list_t* restrict this)
  * @param  this  The list
  * @param  data  Output buffer for the marshalled data
  */
-void client_list_marshal(const client_list_t* restrict this, char* restrict data)
+void
+client_list_marshal(const client_list_t *restrict this, char *restrict data)
 {
-  buf_set_next(data, int, CLIENT_LIST_T_VERSION);
-  buf_set_next(data, size_t, this->capacity);
-  buf_set_next(data, size_t, this->size);
-  
-  memcpy(data, this->clients, this->size * sizeof(uint64_t));
+	buf_set_next(data, int, CLIENT_LIST_T_VERSION);
+	buf_set_next(data, size_t, this->capacity);
+	buf_set_next(data, size_t, this->size);
+
+	memcpy(data, this->clients, this->size * sizeof(uint64_t));
 }
 
 
@@ -208,21 +211,21 @@ void client_list_marshal(const client_list_t* restrict this, char* restrict data
  * @return        Non-zero on error, `errno` will be set accordingly.
  *                Destroy the list on error.
  */
-int client_list_unmarshal(client_list_t* restrict this, char* restrict data)
+int
+client_list_unmarshal(client_list_t *restrict this, char *restrict data)
 {
-  /* buf_get(data, int, 0, CLIENT_LIST_T_VERSION); */
-  buf_next(data, int, 1);
-  
-  this->clients = NULL;
-  
-  buf_get_next(data, size_t, this->capacity);
-  buf_get_next(data, size_t, this->size);
-  
-  fail_if (xmalloc(this->clients, this->capacity, uint64_t));
-  memcpy(this->clients, data, this->size * sizeof(uint64_t));
-  
-  return 0;
- fail:
-  return -1;
-}
+	/* buf_get(data, int, 0, CLIENT_LIST_T_VERSION); */
+	buf_next(data, int, 1);
+
+	this->clients = NULL;
+
+	buf_get_next(data, size_t, this->capacity);
+	buf_get_next(data, size_t, this->size);
 
+	fail_if (xmalloc(this->clients, this->capacity, uint64_t));
+	memcpy(this->clients, data, this->size * sizeof(uint64_t));
+
+	return 0;
+fail:
+	return -1;
+}
diff --git a/src/libmdsserver/client-list.h b/src/libmdsserver/client-list.h
index 4d2bfa7..ffe828a 100644
--- a/src/libmdsserver/client-list.h
+++ b/src/libmdsserver/client-list.h
@@ -30,8 +30,7 @@
 /**
  * Dynamic array of client ID:s
  */
-typedef struct client_list
-{
+typedef struct client_list {
 	/**
 	 * The size of the array
 	 */
@@ -46,7 +45,6 @@ typedef struct client_list
 	 * Stored client ID:s
 	 */
 	uint64_t *clients;
-
 } client_list_t;
 
 
diff --git a/src/libmdsserver/fd-table.c b/src/libmdsserver/fd-table.c
index 1db2d87..fafaa65 100644
--- a/src/libmdsserver/fd-table.c
+++ b/src/libmdsserver/fd-table.c
@@ -31,29 +31,30 @@
  * @param   initial_capacity  The initial capacity of the table
  * @return                    Non-zero on error, `errno` will have been set accordingly
  */
-int fd_table_create_tuned(fd_table_t* restrict this, size_t initial_capacity)
+int
+fd_table_create_tuned(fd_table_t *restrict this, size_t initial_capacity)
 {
-  size_t bitcap;
-  
-  this->capacity = initial_capacity ? initial_capacity : 1;
-  this->size = 0;
-  
-  this->values = NULL;
-  this->used = NULL;
-  this->value_comparator = NULL;
-  
-  /* It is important that both allocations are done with calloc:
-     `this->used` must set all keys as unused at the initial state,
-     `this->values` must be initialised for marshaling and it helps
-     the time overhead of `fd_table_contains_value`. */
-  
-  bitcap = (this->capacity + 63) / 64;
-  fail_if (xcalloc(this->used,   bitcap,         size_t));
-  fail_if (xcalloc(this->values, this->capacity, size_t));
-  
-  return 0;
- fail:
-  return -1;
+	size_t bitcap;
+
+	this->capacity = initial_capacity ? initial_capacity : 1;
+	this->size = 0;
+
+	this->values = NULL;
+	this->used = NULL;
+	this->value_comparator = NULL;
+
+	/* It is important that both allocations are done with calloc:
+	   `this->used` must set all keys as unused at the initial state,
+	   `this->values` must be initialised for marshaling and it helps
+	   the time overhead of `fd_table_contains_value`. */
+
+	bitcap = (this->capacity + 63) / 64;
+	fail_if (xcalloc(this->used,   bitcap,         size_t));
+	fail_if (xcalloc(this->values, this->capacity, size_t));
+
+	return 0;
+fail:
+	return -1;
 }
 
 
@@ -65,20 +66,20 @@ int fd_table_create_tuned(fd_table_t* restrict this, size_t initial_capacity)
  * @param  keys_freer    Function that frees a key, `NULL` if keys should not be freed
  * @param  values_freer  Function that frees a value, `NULL` if value should not be freed
  */
-void fd_table_destroy(fd_table_t* restrict this, free_func* key_freer, free_func* value_freer)
+void
+fd_table_destroy(fd_table_t *restrict this, free_func *key_freer, free_func *value_freer)
 {
-  if (((key_freer != NULL) || (value_freer != NULL)) && (this->used != NULL) && (this->values != NULL))
-    {
-      size_t i;
-      for (i = 0; i < this->capacity; i++)
-	if (this->used[i / 64] & ((uint64_t)1 << (i % 64)))
-	  {
-	    if (key_freer   != NULL)  key_freer(i);
-	    if (value_freer != NULL)  value_freer(this->values[i]);
-	  }
-    }
-  free(this->values);
-  free(this->used);
+	size_t i;
+	if ((key_freer || value_freer) && this->used && this->values) {
+		for (i = 0; i < this->capacity; i++) {
+			if (this->used[i / 64] & ((uint64_t)1 << (i % 64))) {
+				if (key_freer)   key_freer(i);
+				if (value_freer) value_freer(this->values[i]);
+			}
+		}
+	}
+	free(this->values);
+	free(this->used);
 }
 
 
@@ -89,24 +90,22 @@ void fd_table_destroy(fd_table_t* restrict this, free_func* key_freer, free_func
  * @param   value  The value
  * @return         Whether the value is stored in the table
  */
-int fd_table_contains_value(const fd_table_t* restrict this, size_t value)
+int
+fd_table_contains_value(const fd_table_t *restrict this, size_t value)
 {
-  size_t i;
-  if (this->value_comparator == NULL)
-    {
-      for (i = 0; i < this->capacity; i++)
-	if (this->values[i] == value)
-	  if (this->used[i / 64] & ((uint64_t)1 << (i % 64)))
-	    return 1;
-    }
-  else
-    {
-      for (i = 0; i < this->capacity; i++)
-	if (this->used[i / 64] & ((uint64_t)1 << (i % 64)))
-	  if (this->value_comparator(this->values[i], value))
-	    return 1;
-    }
-  return 0;
+	size_t i;
+	if (!this->value_comparator) {
+		for (i = 0; i < this->capacity; i++)
+			if (this->values[i] == value)
+				if (this->used[i / 64] & ((uint64_t)1 << (i % 64)))
+					return 1;
+	} else {
+		for (i = 0; i < this->capacity; i++)
+			if (this->used[i / 64] & ((uint64_t)1 << (i % 64)))
+				if (this->value_comparator(this->values[i], value))
+					return 1;
+	}
+	return 0;
 }
 
 
@@ -117,9 +116,10 @@ int fd_table_contains_value(const fd_table_t* restrict this, size_t value)
  * @param   key   The key
  * @return        Whether the key is used
  */
-int fd_table_contains_key(const fd_table_t* restrict this, int key)
+int
+fd_table_contains_key(const fd_table_t *restrict this, int key)
 {
-  return ((size_t)key < this->capacity) && (this->used[key / 64] & ((uint64_t)1 << (key % 64)));
+	return (size_t)key < this->capacity && (this->used[key / 64] & ((uint64_t)1 << (key % 64)));
 }
 
 
@@ -130,11 +130,10 @@ int fd_table_contains_key(const fd_table_t* restrict this, int key)
  * @param   key   The key associated with the value
  * @return        The value associated with the key, 0 if the key was not used
  */
-size_t fd_table_get(const fd_table_t* restrict this, int key)
+size_t
+fd_table_get(const fd_table_t *restrict this, int key)
 {
-  if (fd_table_contains_key(this, key) == 0)
-    return 0;
-  return this->values[key];
+	return fd_table_contains_key(this, key) ? this->values[key] : 0;
 }
 
 
@@ -147,55 +146,53 @@ size_t fd_table_get(const fd_table_t* restrict this, int key)
  * @return         The previous value associated with the key, 0 if the key was not used.
  *                 0 will also be returned on error, check the `errno` variable.
  */
-size_t fd_table_put(fd_table_t* restrict this, int key, size_t value)
+size_t
+fd_table_put(fd_table_t *restrict this, int key, size_t value)
 {
-  /* Override current value if the key is already used. */
-  if (fd_table_contains_key(this, key))
-    {
-      size_t rc = fd_table_get(this, key);
-      this->values[key] = value;
-      return rc;
-    }
-  
-  /* Grow the table if it is too small. */
-  errno = 0;
-  if ((size_t)key >= this->capacity)
-    {
-      size_t* old_values = this->values;
-      size_t old_bitcap, new_bitcap;
-      if (xrealloc(this->values, this->capacity << 1, size_t))
-	{
-	  this->values = old_values;
-	  fail_if (1);
+	size_t rc, old_bitcap, new_bitcap, *old_values;
+	uint64_t *old_used;
+
+	/* Override current value if the key is already used. */
+	if (fd_table_contains_key(this, key)) {
+		rc = fd_table_get(this, key);
+		this->values[key] = value;
+		return rc;
 	}
+
+	/* Grow the table if it is too small. */
+	errno = 0;
+	if ((size_t)key >= this->capacity) {
+		old_values = this->values;
+		if (xrealloc(this->values, this->capacity << 1, size_t)) {
+			this->values = old_values;
+			fail_if (1);
+		}
+
+		memset(this->values + this->capacity, 0, this->capacity * sizeof(size_t));
       
-      memset(this->values + this->capacity, 0, this->capacity * sizeof(size_t));
-      
-      old_bitcap = (this->capacity + 63) / 64;
-      this->capacity <<= 1;
-      new_bitcap = (this->capacity + 63) / 64;
-      
-      if (new_bitcap > old_bitcap)
-	{
-	  uint64_t* old_used = this->used;
-	  if (xrealloc(this->used, new_bitcap, size_t))
-	    {
-	      this->used = old_used;
-	      this->capacity >>= 1;
-	      fail_if (1);
-	    }
-	  
-	  memset(this->used + old_bitcap, 0, (new_bitcap - old_bitcap) * sizeof(uint64_t));
+		old_bitcap = (this->capacity + 63) / 64;
+		this->capacity <<= 1;
+		new_bitcap = (this->capacity + 63) / 64;
+
+		if (new_bitcap > old_bitcap) {
+			old_used = this->used;
+			if (xrealloc(this->used, new_bitcap, size_t)) {
+				this->used = old_used;
+				this->capacity >>= 1;
+				fail_if (1);
+			}
+
+			memset(this->used + old_bitcap, 0, (new_bitcap - old_bitcap) * sizeof(uint64_t));
+		}
 	}
-    }
-  
-  /* Store the entry. */
-  this->used[key / 64] |= (uint64_t)1 << (key % 64);
-  this->values[key] = value;
-  this->size++;
-  return 0;
- fail:
-  return 0;
+
+	/* Store the entry. */
+	this->used[key / 64] |= (uint64_t)1 << (key % 64);
+	this->values[key] = value;
+	this->size++;
+	return 0;
+fail:
+	return 0;
 }
 
 
@@ -206,15 +203,15 @@ size_t fd_table_put(fd_table_t* restrict this, int key, size_t value)
  * @param   key   The key of the entry to remove
  * @return        The previous value associated with the key, 0 if the key was not used
  */
-size_t fd_table_remove(fd_table_t* restrict this, int key)
+size_t
+fd_table_remove(fd_table_t *restrict this, int key)
 {
-  size_t rc = fd_table_get(this, key);
-  if (rc && fd_table_contains_key(this, key))
-    {
-      this->used[key / 64] &= ~((uint64_t)1 << (key % 64));
-      this->size--;
-    }
-  return rc;
+	size_t rc = fd_table_get(this, key);
+	if (rc && fd_table_contains_key(this, key)) {
+		this->used[key / 64] &= ~((uint64_t)1 << (key % 64));
+		this->size--;
+	}
+	return rc;
 }
 
 
@@ -223,12 +220,13 @@ size_t fd_table_remove(fd_table_t* restrict this, int key)
  * 
  * @param  this  The fd table
  */
-void fd_table_clear(fd_table_t* restrict this)
+void
+fd_table_clear(fd_table_t *restrict this)
 {
-  size_t bitcap;
-  this->size = 0;
-  bitcap = (this->capacity + 63) / 64;
-  memset(this->used, 0, bitcap * sizeof(uint64_t));
+	size_t bitcap;
+	this->size = 0;
+	bitcap = (this->capacity + 63) / 64;
+	memset(this->used, 0, bitcap * sizeof(uint64_t));
 }
 
 
@@ -238,10 +236,11 @@ void fd_table_clear(fd_table_t* restrict this)
  * @param   this  The fd table
  * @return        The number of bytes to allocate to the output buffer
  */
-size_t fd_table_marshal_size(const fd_table_t* restrict this)
+size_t
+fd_table_marshal_size(const fd_table_t *restrict this)
 {
-  size_t bitcap = (this->capacity + 63) / 64;
-  return (this->capacity + 2) * sizeof(size_t) + bitcap * sizeof(uint64_t) + sizeof(int);
+	size_t bitcap = (this->capacity + 63) / 64;
+	return (this->capacity + 2) * sizeof(size_t) + bitcap * sizeof(uint64_t) + sizeof(int);
 }
 
 
@@ -251,18 +250,19 @@ size_t fd_table_marshal_size(const fd_table_t* restrict this)
  * @param  this  The fd table
  * @param  data  Output buffer for the marshalled data
  */
-void fd_table_marshal(const fd_table_t* restrict this, char* restrict data)
+void
+fd_table_marshal(const fd_table_t *restrict this, char *restrict data)
 {
-  size_t bitcap = (this->capacity + 63) / 64;
-  
-  buf_set_next(data, int, FD_TABLE_T_VERSION);
-  buf_set_next(data, size_t, this->capacity);
-  buf_set_next(data, size_t, this->size);
-  
-  memcpy(data, this->values, this->capacity * sizeof(size_t));
-  buf_next(data, size_t, this->capacity);
-  
-  memcpy(data, this->used, bitcap * sizeof(uint64_t));
+	size_t bitcap = (this->capacity + 63) / 64;
+
+	buf_set_next(data, int, FD_TABLE_T_VERSION);
+	buf_set_next(data, size_t, this->capacity);
+	buf_set_next(data, size_t, this->size);
+
+	memcpy(data, this->values, this->capacity * sizeof(size_t));
+	buf_next(data, size_t, this->capacity);
+
+	memcpy(data, this->used, bitcap * sizeof(uint64_t));
 }
 
 
@@ -275,38 +275,38 @@ void fd_table_marshal(const fd_table_t* restrict this, char* restrict data)
  * @return            Non-zero on error, `errno` will be set accordingly.
  *                    Destroy the table on error.
  */
-int fd_table_unmarshal(fd_table_t* restrict this, char* restrict data, remap_func* remapper)
+int
+fd_table_unmarshal(fd_table_t *restrict this, char *restrict data, remap_func *remapper)
 {
-  size_t bitcap;
-  size_t i;
-  
-  /* buf_get(data, int, 0, FD_TABLE_T_VERSION) */
-  buf_next(data, int, 1);
-  
-  buf_get_next(data, size_t, this->capacity);
-  buf_get_next(data, size_t, this->size);
-  
-  this->values           = NULL;
-  this->used             = NULL;
-  this->value_comparator = NULL;
-  
-  fail_if (xmalloc(this->values, this->capacity, size_t));
-  
-  bitcap = (this->capacity + 63) / 64;
-  fail_if (xmalloc(this->used, bitcap, size_t));
-  
-  memcpy(this->values, data, this->capacity * sizeof(size_t));
-  buf_next(data, size_t, this->capacity);
-  
-  memcpy(this->used, data, bitcap * sizeof(uint64_t));
-  
-  if (remapper != NULL)
-    for (i = 0; i < this->capacity; i++)
-      if (this->used[i / 64] & ((uint64_t)1 << (i % 64)))
-	this->values[i] = remapper(this->values[i]);
-  
-  return 0;
- fail:
-  return -1;
-}
+	size_t bitcap;
+	size_t i;
+
+	/* buf_get(data, int, 0, FD_TABLE_T_VERSION) */
+	buf_next(data, int, 1);
+
+	buf_get_next(data, size_t, this->capacity);
+	buf_get_next(data, size_t, this->size);
 
+	this->values           = NULL;
+	this->used             = NULL;
+	this->value_comparator = NULL;
+
+	fail_if (xmalloc(this->values, this->capacity, size_t));
+
+	bitcap = (this->capacity + 63) / 64;
+	fail_if (xmalloc(this->used, bitcap, size_t));
+
+	memcpy(this->values, data, this->capacity * sizeof(size_t));
+	buf_next(data, size_t, this->capacity);
+
+	memcpy(this->used, data, bitcap * sizeof(uint64_t));
+
+	if (remapper)
+		for (i = 0; i < this->capacity; i++)
+			if (this->used[i / 64] & ((uint64_t)1 << (i % 64)))
+				this->values[i] = remapper(this->values[i]);
+
+	return 0;
+fail:
+	return -1;
+}
diff --git a/src/libmdsserver/fd-table.h b/src/libmdsserver/fd-table.h
index e0b3a09..e484937 100644
--- a/src/libmdsserver/fd-table.h
+++ b/src/libmdsserver/fd-table.h
@@ -30,8 +30,7 @@
 /**
  * Value lookup table optimised for file descriptors as keys
  */
-typedef struct fd_table
-{
+typedef struct fd_table {
 	/**
 	 * The table's capacity, i.e. how many entries that can be stored,
 	 * in total, before its internal table needs to grow
@@ -61,7 +60,6 @@ typedef struct fd_table
 	 * Be aware, this variable cannot be marshalled
 	 */
 	compare_func *value_comparator;
-
 } fd_table_t;
 
 
diff --git a/src/libmdsserver/hash-list.h b/src/libmdsserver/hash-list.h
index abcbb74..2087bce 100644
--- a/src/libmdsserver/hash-list.h
+++ b/src/libmdsserver/hash-list.h
@@ -34,7 +34,7 @@
  * The default initial capacity
  */
 #ifndef HASH_LIST_DEFAULT_INITIAL_CAPACITY
-# define HASH_LIST_DEFAULT_INITIAL_CAPACITY  128
+# define HASH_LIST_DEFAULT_INITIAL_CAPACITY 128
 #endif
 
 /**
@@ -61,15 +61,15 @@
  * that is, have the value `__VA_ARGS__`.
  */
 #ifndef HASH_LIST_EXPECTED
-# define HASH_LIST_EXPECTED(...)  __builtin_expect((__VA_ARGS__), 1)
+# define HASH_LIST_EXPECTED(...) __builtin_expect((__VA_ARGS__), 1)
 #endif
 
 
-#define HASH_LIST_HASH(key)  (this->hasher != NULL ? this->hasher(key) : (size_t)key)
+#define HASH_LIST_HASH(key) (this->hasher ? this->hasher(key) : (size_t)key)
 
 
 
-#define HASH_LIST_T_VERSION  0
+#define HASH_LIST_T_VERSION 0
 
 
 /**
@@ -105,7 +105,7 @@ typedef VALUE_T T##_value_t;\
  * 
  * @param  entry  The entry, will never be `NULL`, any only used entries will be passed
  */\
-typedef void T##_entry_free_func(struct T##_entry* entry);\
+typedef void T##_entry_free_func(struct T##_entry *entry);\
 \
 /**
  * Function-type for the function responsible for hashing keys
@@ -134,7 +134,7 @@ static inline int T##_key_comparer(CKEY_T key_a, CKEY_T key_b);\
  * @return         The marshal-size of the entry's key and value
  */\
 __attribute__((pure, nonnull))\
-static inline size_t T##_submarshal_size(const struct T##_entry* entry);\
+static inline size_t T##_submarshal_size(const struct T##_entry *entry);\
 \
 /**
  * Marshal an entry's key and value
@@ -144,7 +144,7 @@ static inline size_t T##_submarshal_size(const struct T##_entry* entry);\
  * @return         The marshal-size of the entry's key and value
  */\
 __attribute__((pure, nonnull))\
-static inline size_t T##_submarshal(const struct T##_entry* entry, char* restrict data);\
+static inline size_t T##_submarshal(const struct T##_entry *entry, char *restrict data);\
 \
 /**
  * Unmarshal an entry's key and value
@@ -154,7 +154,7 @@ static inline size_t T##_submarshal(const struct T##_entry* entry, char* restric
  * @return         The number of read bytes, zero on error
  */\
 __attribute__((pure, nonnull))\
-static inline size_t T##_subunmarshal(struct T##_entry* entry, char* restrict data);\
+static inline size_t T##_subunmarshal(struct T##_entry *entry, char *restrict data);\
 \
 \
 \
@@ -163,21 +163,21 @@ static inline size_t T##_subunmarshal(struct T##_entry* entry, char* restrict da
  */\
 typedef struct T##_entry\
 {\
-  /**
-   * The key of the entry, `NULL` if the slot is unused
-   */\
-  KEY_T key;\
-  \
-  /**
-   * Hash of `key`, undefined but initialised if the slot is unused
-   */\
-  size_t key_hash;\
-  \
-  /**
-   * The value of the entry
-   */\
-  T##_value_t value;\
-  \
+	/**
+	 * The key of the entry, `NULL` if the slot is unused
+	 */\
+	KEY_T key;\
+	\
+	/**
+	 * Hash of `key`, undefined but initialised if the slot is unused
+	 */\
+	size_t key_hash;\
+	\
+	/**
+	 * The value of the entry
+	 */\
+	T##_value_t value;\
+	\
 } T##_entry_t;\
 \
 \
@@ -186,55 +186,55 @@ typedef struct T##_entry\
  */\
 typedef struct T\
 {\
-  /**
-   * The number of allocated slots
-   */\
-  size_t allocated;\
-  \
-  /**
-   * The number of unused slot that
-   * has previously be used
-   */\
-  size_t unused;\
-  \
-  /**
-   * The number of slots that have
-   * been used, even if no longer used
-   */\
-  size_t used;\
-  \
-  /**
-   * This variable is used for optimisation, any
-   * time `hash_list_get` finds an element, its
-   * will be stored, and it will be the first
-   * inspected element by `hash_list_put` and
-   * `hash_list_remove`
-   */\
-  size_t last;\
-  \
-  /**
-   * The slots
-   */\
-  T##_entry_t* slots;\
-  \
-  /**
-   * Function used to free keys and values of entries
-   * 
-   * The freeing is not used if this function pointer is `NULL`
-   * 
-   * Be aware, this variable cannot be marshalled
-   */\
-  T##_entry_free_func* freer;\
-  \
-  /**
-   * Function used to calculate the hash of a key
-   * 
-   * If this function pointer is `NULL`, the identity hash is used
-   * 
-   * Be aware, this variable cannot be marshalled
-   */\
-  T##_key_hash_func* hasher;\
-  \
+	/**
+	 * The number of allocated slots
+	 */\
+	size_t allocated;\
+	\
+	/**
+	 * The number of unused slot that
+	 * has previously be used
+	 */\
+	size_t unused;\
+	\
+	/**
+	 * The number of slots that have
+	 * been used, even if no longer used
+	 */\
+	size_t used;\
+	\
+	/**
+	 * This variable is used for optimisation, any
+	 * time `hash_list_get` finds an element, its
+	 * will be stored, and it will be the first
+	 * inspected element by `hash_list_put` and
+	 * `hash_list_remove`
+	 */\
+	size_t last;\
+	\
+	/**
+	 * The slots
+	 */\
+	T##_entry_t *slots;\
+	\
+	/**
+	 * Function used to free keys and values of entries
+	 * 
+	 * The freeing is not used if this function pointer is `NULL`
+	 * 
+	 * Be aware, this variable cannot be marshalled
+	 */\
+	T##_entry_free_func *freer;\
+	\
+	/**
+	 * Function used to calculate the hash of a key
+	 * 
+	 * If this function pointer is `NULL`, the identity hash is used
+	 * 
+	 * Be aware, this variable cannot be marshalled
+	 */\
+	T##_key_hash_func *hasher;\
+	\
 } T##_t;\
 \
 \
@@ -247,24 +247,24 @@ typedef struct T\
  * @return            Non-zero on error, `errno` will have been set accordingly
  */\
 static inline int __attribute__((unused, nonnull))\
-T##_create(T##_t* restrict this, size_t capacity)\
+T##_create(T##_t *restrict this, size_t capacity)\
 {\
-  if (capacity == 0)\
-    capacity = HASH_LIST_DEFAULT_INITIAL_CAPACITY;\
-  \
-  this->freer = NULL;\
-  this->hasher = NULL;\
-  this->allocated = 0;\
-  this->unused = 0;\
-  this->used = 0;\
-  this->last = 0;\
-  \
-  this->slots = malloc(capacity * sizeof(T##_t));\
-  if (this->slots == NULL)\
-    return -1;\
-  \
-  this->allocated = capacity;\
-  return 0;\
+	if (!capacity)\
+		capacity = HASH_LIST_DEFAULT_INITIAL_CAPACITY;\
+	\
+	this->freer = NULL;\
+	this->hasher = NULL;\
+	this->allocated = 0;\
+	this->unused = 0;\
+	this->used = 0;\
+	this->last = 0;\
+	\
+	this->slots = malloc(capacity * sizeof(T##_t));\
+	if (!this->slots)\
+		return -1;\
+	\
+	this->allocated = capacity;\
+	return 0;\
 }\
 \
 \
@@ -274,19 +274,19 @@ T##_create(T##_t* restrict this, size_t capacity)\
  * @param  this  The hash list
  */\
 static inline void __attribute__((unused, nonnull))\
-T##_destroy(T##_t* restrict this)\
+T##_destroy(T##_t *restrict this)\
 {\
-  size_t i, n;\
-  if (this->freer != NULL)\
-    for (i = 0, n = this->used; i < n; i++)\
-      if (this->slots[i].key)\
-	this->freer(this->slots + i);\
-  this->used = 0;\
-  this->unused = 0;\
-  this->allocated = 0;\
-  this->last = 0;\
-  free(this->slots);\
-  this->slots = NULL;\
+	size_t i, n;\
+	if (this->freer)\
+		for (i = 0, n = this->used; i < n; i++)\
+			if (this->slots[i].key)\
+				this->freer(this->slots + i);\
+	this->used = 0;\
+	this->unused = 0;\
+	this->allocated = 0;\
+	this->last = 0;\
+	free(this->slots);\
+	this->slots = NULL;\
 }\
 \
 \
@@ -298,14 +298,14 @@ T##_destroy(T##_t* restrict this)\
  * @return        Non-zero on error, `errno` will have been set accordingly
  */\
 static inline int __attribute__((unused, nonnull))\
-T##_clone(const T##_t* restrict this, T##_t* restrict out)\
+T##_clone(const T##_t *restrict this, T##_t *restrict out)\
 {\
-  if (T##_create(out, this->allocated) < 0)\
-    return -1;\
-  out->used = this->used;\
-  out->unused = this->unused;\
-  out->last = this->last;\
-  memcpy(out->slots, this->slots, this->used * sizeof(T##_entry_t));\
+	if (T##_create(out, this->allocated) < 0)\
+		return -1;\
+	out->used = this->used;\
+	out->unused = this->unused;\
+	out->last = this->last;\
+	memcpy(out->slots, this->slots, this->used * sizeof(T##_entry_t));\
 }\
 \
 \
@@ -321,32 +321,30 @@ T##_clone(const T##_t* restrict this, T##_t* restrict out)\
  *                been set accordingly. Errors are non-fatal.
  */\
 static inline int __attribute__((unused, nonnull))\
-T##_pack(T##_t* restrict this)\
+T##_pack(T##_t *restrict this)\
 {\
-  size_t i, j, n;\
-  T##_entry_t* slots = this->slots;\
-  \
-  if (this->unused > 0)\
-    {\
-      for (i = 0, j = 0, n = this->used; i < n; i++)\
-	if (slots[i].key != NULL)\
-	  slots[j++] = slots[i];\
-      \
-      this->used -= this->unused;\
-      this->unused = 0;\
-      this->last = 0;\
-    }\
-  \
-  if (this->used < this->allocated)\
-    {\
-      slots = realloc(slots, this->used * sizeof(T##_entry_t));\
-      if (slots == NULL)\
-	return -1;\
-      this->slots = slots;\
-      this->allocated = this->used;\
-    }\
-  \
-  return 0;\
+	size_t i, j, n;\
+	T##_entry_t *slots = this->slots;\
+	\
+	if (this->unused > 0) {\
+		for (i = 0, j = 0, n = this->used; i < n; i++)\
+			if (slots[i].key)\
+				slots[j++] = slots[i];\
+		\
+		this->used -= this->unused;\
+		this->unused = 0;\
+		this->last = 0;\
+	}\
+	\
+	if (this->used < this->allocated) {\
+		slots = realloc(slots, this->used * sizeof(T##_entry_t));\
+		if (!slots)\
+			return -1;\
+		this->slots = slots;\
+		this->allocated = this->used;\
+	}\
+	\
+	return 0;\
 }\
 \
 \
@@ -359,14 +357,14 @@ T##_pack(T##_t* restrict this)\
  * @return         Whether the key was found, error is impossible
  */\
 static inline int __attribute__((unused, nonnull))\
-T##_get(T##_t* restrict this, CKEY_T key, T##_value_t* restrict value)\
+T##_get(T##_t *restrict this, CKEY_T key, T##_value_t *restrict value)\
 {\
-  size_t i, n, hash = HASH_LIST_HASH(key);\
-  for (i = 0, n = this->used; i < n; i++)\
-    if ((this->slots[i].key_hash == hash) && this->slots[i].key)\
-      if (T##_key_comparer(this->slots[i].key, key))\
-	return *value = this->slots[this->last = i].value, 1;\
-  return this->last = 0, 0;\
+	size_t i, n, hash = HASH_LIST_HASH(key);\
+	for (i = 0, n = this->used; i < n; i++)\
+		if (this->slots[i].key_hash == hash && this->slots[i].key)\
+			if (T##_key_comparer(this->slots[i].key, key))\
+				return *value = this->slots[this->last = i].value, 1;\
+	return this->last = 0, 0;\
 }\
 \
 \
@@ -377,39 +375,39 @@ T##_get(T##_t* restrict this, CKEY_T key, T##_value_t* restrict value)\
  * @param  key   The key of the entry to remove, must not be `NULL`
  */\
 static inline void __attribute__((unused, nonnull))\
-T##_remove(T##_t* restrict this, CKEY_T key)\
+T##_remove(T##_t *restrict this, CKEY_T key)\
 {\
-  size_t i = this->last, n, hash = HASH_LIST_HASH(key);\
-  T##_entry_t* slots = this->slots;\
-  \
-  /* First, try cached index. */\
-  if (HASH_LIST_EXPECTED(i && (slots[i].key_hash == hash) && (slots[i].key != NULL)))\
-    if (HASH_LIST_EXPECTED(T##_key_comparer(slots[i].key, key)))\
-      goto do_remove;\
-  /* It is discouraged to use put or remove without
-   * doing a get before it, otherwise you do not know
-   * what is happening. So we do not expect to get
-   * get to the next line. However, if do not expect to
-   * run get before put or remove, you should modify the
-   * `HASH_LIST_EXPECTED` macro. However, this is single
-   * case where will will get to the next line, when the
-   * index of the item is zero. */\
-  \
-  /* Then, search. */\
-  for (i = 0, n = this->used; i < n; i++)\
-    if ((slots[i].key_hash == hash) && (slots[i].key != NULL))\
-      if (T##_key_comparer(slots[i].key, key))\
-	goto do_remove;\
-  \
-  return;\
- do_remove:\
-  if (this->freer != NULL)\
-    this->freer(slots + i);\
-  slots[i].key = NULL;\
-  this->unused++;\
-  if ((this->unused >> 1) >= this->used)\
-    T##_pack(this);\
-  this->last = 0;\
+	size_t i = this->last, n, hash = HASH_LIST_HASH(key);\
+	T##_entry_t *slots = this->slots;\
+	\
+	/* First, try cached index. */\
+	if (HASH_LIST_EXPECTED(i && slots[i].key_hash == hash && slots[i].key))\
+		if (HASH_LIST_EXPECTED(T##_key_comparer(slots[i].key, key)))\
+			goto do_remove;\
+	/* It is discouraged to use put or remove without
+	 * doing a get before it, otherwise you do not know
+	 * what is happening. So we do not expect to get
+	 * get to the next line. However, if do not expect to
+	 * run get before put or remove, you should modify the
+	 * `HASH_LIST_EXPECTED` macro. However, this is single
+	 * case where will will get to the next line, when the
+	 * index of the item is zero. */\
+	\
+	/* Then, search. */\
+	for (i = 0, n = this->used; i < n; i++)\
+		if (slots[i].key_hash == hash && slots[i].key)\
+			if (T##_key_comparer(slots[i].key, key))\
+				goto do_remove;\
+	\
+	return;\
+do_remove:\
+	if (this->freer)\
+		this->freer(slots + i);\
+	slots[i].key = NULL;\
+	this->unused++;\
+	if (this->unused >> 1 >= this->used)\
+		T##_pack(this);\
+	this->last = 0;\
 }\
 \
 \
@@ -423,66 +421,66 @@ T##_remove(T##_t* restrict this, CKEY_T key)\
  * @return         Non-zero on error, `errno` will have been set accordingly
  */\
 static inline int __attribute__((unused, nonnull(1, 2)))\
-T##_put(T##_t* restrict this, KEY_T key, const T##_value_t* restrict value)\
+T##_put(T##_t *restrict this, KEY_T key, const T##_value_t *restrict value)\
 {\
-  size_t i = this->last, n, empty = this->used, hash;\
-  T##_entry_t* slots = this->slots;\
-  \
-  /* Remove entry if no value is passed. */\
-  if (value == NULL)\
-    {\
-      T##_remove(this, key);\
-      return 0;\
-    }\
-  \
-  /* Hash the input key. */\
-  hash = HASH_LIST_HASH(key);\
-  \
-  /* Try cached index. */\
-  if (HASH_LIST_EXPECTED(i && (slots[i].key != NULL)))\
-    if (HASH_LIST_EXPECTED(slots[i].key_hash == hash))\
-      if (HASH_LIST_EXPECTED(T##_key_comparer(slots[i].key, key)))\
-	goto put;\
-  /* It is discouraged to use put or remove without
-   * doing a get before it, otherwise you do not know
-   * what is happening. So we do not expect to get
-   * get to the next line. However, if do not expect to
-   * run get before put or remove, you should modify the
-   * `HASH_LIST_EXPECTED` macro. However, this is single
-   * case where will will get to the next line, when the
-   * index of the item is zero. */\
-  \
-  /* Find an unused slot or the current slot. */\
-  for (i = 0, n = this->used; i < n; i++)\
-    if (slots[i].key == NULL)\
-      empty = i;\
-    else if (slots[i].key_hash == hash)\
-      if (T##_key_comparer(slots[i].key, key))\
-	goto put;\
-  \
-  /* Grow slot allocation is required. */\
-  if (empty == this->allocated)\
-    {\
-      if (empty >= SIZE_MAX >> 1)\
-	return errno = ENOMEM, -1;\
-      slots = realloc(slots, (empty << 1) * sizeof(T##_entry_t));\
-      if (slots == NULL)\
-	return -1;\
-      this->slots = slots;\
-      this->allocated <<= 1;\
-    }\
-  \
-  /* Store entry. */\
-  i = empty;\
-  goto put_no_free;\
- put:\
-  if (this->freer != NULL)\
-    this->freer(slots + i);\
- put_no_free:\
-  slots[i].key = key;\
-  slots[i].key_hash = hash;\
-  slots[i].value = *value;\
-  return 0;\
+	size_t i = this->last, n, empty = this->used, hash;\
+	T##_entry_t* slots = this->slots;\
+	\
+	/* Remove entry if no value is passed. */\
+	if (!value) {\
+		T##_remove(this, key);\
+		return 0;\
+	}\
+	\
+	/* Hash the input key. */\
+	hash = HASH_LIST_HASH(key);\
+	\
+	/* Try cached index. */\
+	if (HASH_LIST_EXPECTED(i && slots[i].key))\
+		if (HASH_LIST_EXPECTED(slots[i].key_hash == hash))\
+			if (HASH_LIST_EXPECTED(T##_key_comparer(slots[i].key, key)))\
+				goto put;\
+	/* It is discouraged to use put or remove without
+	 * doing a get before it, otherwise you do not know
+	 * what is happening. So we do not expect to get
+	 * get to the next line. However, if do not expect to
+	 * run get before put or remove, you should modify the
+	 * `HASH_LIST_EXPECTED` macro. However, this is single
+	 * case where will will get to the next line, when the
+	 * index of the item is zero. */\
+	\
+	/* Find an unused slot or the current slot. */\
+	for (i = 0, n = this->used; i < n; i++) {\
+		if (!slots[i].key) {\
+			empty = i;\
+		} else if (slots[i].key_hash == hash) {\
+			if (T##_key_comparer(slots[i].key, key))\
+				goto put;\
+		}\
+	}\
+	\
+	/* Grow slot allocation is required. */\
+	if (empty == this->allocated) {\
+		if (empty >= SIZE_MAX >> 1)\
+			return errno = ENOMEM, -1;\
+		slots = realloc(slots, (empty << 1) * sizeof(T##_entry_t));\
+		if (!slots)\
+			return -1;\
+		this->slots = slots;\
+		this->allocated <<= 1;\
+	}\
+	\
+	/* Store entry. */\
+	i = empty;\
+	goto put_no_free;\
+put:\
+	if (this->freer)\
+		this->freer(slots + i);\
+put_no_free:\
+	slots[i].key = key;\
+	slots[i].key_hash = hash;\
+	slots[i].value = *value;\
+	return 0;\
 }\
 \
 \
@@ -493,14 +491,14 @@ T##_put(T##_t* restrict this, KEY_T key, const T##_value_t* restrict value)\
  * @return        The number of bytes to allocate to the output buffer
  */\
 static inline size_t __attribute__((unused, pure, nonnull))\
-T##_marshal_size(const T##_t* restrict this)\
+T##_marshal_size(const T##_t *restrict this)\
 {\
-  size_t i, n = this->used;\
-  size_t rc = sizeof(int) + 4 * sizeof(size_t);\
-  for (i = 0; i < n; i++)\
-    if (this->slots[i].key != NULL)\
-      rc += T##_submarshal_size(this->slots + i);\
-  return rc + n * sizeof(char) + (n - this->unused) * sizeof(size_t);\
+	size_t i, n = this->used;\
+	size_t rc = sizeof(int) + 4 * sizeof(size_t);\
+	for (i = 0; i < n; i++)\
+		if (this->slots[i].key)\
+			rc += T##_submarshal_size(this->slots + i);\
+	return rc + n * sizeof(char) + (n - this->unused) * sizeof(size_t);\
 }\
 \
 \
@@ -511,26 +509,26 @@ T##_marshal_size(const T##_t* restrict this)\
  * @param  data  Output buffer for the marshalled data
  */\
 static inline void __attribute__((unused, nonnull))\
-T##_marshal(const T##_t* restrict this, char* restrict data)\
+T##_marshal(const T##_t *restrict this, char *restrict data)\
 {\
-  size_t wrote, i, n = this->used;\
-  \
-  buf_set_next(data, int, HASH_LIST_T_VERSION);\
-  buf_set_next(data, size_t, this->allocated);\
-  buf_set_next(data, size_t, this->unused);\
-  buf_set_next(data, size_t, this->used);\
-  buf_set_next(data, size_t, this->last);\
-  \
-  for (i = 0; i < n; i++)\
-    if (this->slots[i].key != NULL)\
-      {\
-	buf_set_next(data, char, 1);\
-	buf_set_next(data, size_t, this->slots[i].key_hash);\
-	wrote = T##_submarshal(this->slots + i, data);\
-	data += wrote / sizeof(char);\
-      }\
-    else\
-      buf_set_next(data, char, 0);\
+	size_t wrote, i, n = this->used;\
+	\
+	buf_set_next(data, int, HASH_LIST_T_VERSION);\
+	buf_set_next(data, size_t, this->allocated);\
+	buf_set_next(data, size_t, this->unused);\
+	buf_set_next(data, size_t, this->used);\
+	buf_set_next(data, size_t, this->last);\
+	\
+	for (i = 0; i < n; i++) {\
+		if (this->slots[i].key) {\
+			buf_set_next(data, char, 1);\
+			buf_set_next(data, size_t, this->slots[i].key_hash);\
+			wrote = T##_submarshal(this->slots + i, data);\
+			data += wrote / sizeof(char);\
+		} else {\
+			buf_set_next(data, char, 0);\
+		}\
+	}\
 }\
 \
 \
@@ -543,39 +541,38 @@ T##_marshal(const T##_t* restrict this, char* restrict data)\
  *                    Destroy the table on error.
  */\
 static inline int __attribute__((unused, nonnull))\
-T##_unmarshal(T##_t* restrict this, char* restrict data)\
+T##_unmarshal(T##_t *restrict this, char *restrict data)\
 {\
-  size_t i, n, got;\
-  char used;\
-  \
-  this->freer = NULL;\
-  this->hasher = NULL;\
-  \
-  /* buf_get(data, int, 0, HASH_LIST_T_VERSION); */\
-  buf_next(data, int, 1);\
-  \
-  buf_get_next(data, size_t, this->allocated);\
-  buf_get_next(data, size_t, this->unused);\
-  buf_get_next(data, size_t, this->used);\
-  buf_get_next(data, size_t, this->last);\
-  \
-  this->slots = calloc(this->allocated, sizeof(T##_entry_t));\
-  if (this->slots == NULL)\
-    return -1;\
-  \
-  for (i = 0, n = this->used; i < n; i++)\
-    {\
-      buf_get_next(data, char, used);\
-      if (used == 0)\
-	continue;\
-      buf_set_next(data, size_t, this->slots[i].key_hash);\
-      got = T##_subunmarshal(this->slots + i, data);\
-      if (got == 0)\
-	return -1;\
-      data += got / sizeof(char);\
-    }\
-  \
-  return 0;\
+	size_t i, n, got;\
+	char used;\
+	\
+	this->freer = NULL;\
+	this->hasher = NULL;\
+	\
+	/* buf_get(data, int, 0, HASH_LIST_T_VERSION); */\
+	buf_next(data, int, 1);\
+	\
+	buf_get_next(data, size_t, this->allocated);\
+	buf_get_next(data, size_t, this->unused);\
+	buf_get_next(data, size_t, this->used);\
+	buf_get_next(data, size_t, this->last);\
+	\
+	this->slots = calloc(this->allocated, sizeof(T##_entry_t));\
+	if (!this->slots)\
+		return -1;\
+	\
+	for (i = 0, n = this->used; i < n; i++) {\
+		buf_get_next(data, char, used);\
+		if (!used)\
+			continue;\
+		buf_set_next(data, size_t, this->slots[i].key_hash);\
+		got = T##_subunmarshal(this->slots + i, data);\
+		if (!got)\
+			return -1;\
+		data += got / sizeof(char);\
+	}\
+	\
+	return 0;\
 }
 
 
@@ -586,9 +583,9 @@ T##_unmarshal(T##_t* restrict this, char* restrict data)\
  * @param  i:size_t                 The variable to store the buckey index in at each iteration
  * @param  entry:hash_list_enty_t*  The variable to store the entry in at each iteration
  */
-#define foreach_hash_list_entry(this, i, entry)	\
-  for (i = 0; i < (this).used; i++)		\
-    if (entry = (this).slots, entry->key != NULL)
+#define foreach_hash_list_entry(this, i, entry)\
+	for (i = 0; i < (this).used; i++)\
+		if ((entry = (this).slots)->key)
 
 
 #endif
diff --git a/src/libmdsserver/hash-table.c b/src/libmdsserver/hash-table.c
index 000bd20..2a7bc3c 100644
--- a/src/libmdsserver/hash-table.c
+++ b/src/libmdsserver/hash-table.c
@@ -31,8 +31,8 @@
  * @param  K  The key
  * @param  H  The hash of the key
  */
-#define TEST_KEY(T, B, K, H) \
-  ((B->key == K) || (T->key_comparator && (B->hash == H) && T->key_comparator(B->key, K)))
+#define TEST_KEY(T, B, K, H)\
+	((B)->key == (K) || ((T)->key_comparator && (B)->hash == (H) && (T)->key_comparator((B)->key, (K))))
 
 
 /**
@@ -42,10 +42,10 @@
  * @param   key   The key to hash
  * @return        The hash of the key
  */
-__attribute__((pure, nonnull))
-static inline size_t hash(const hash_table_t* restrict this, size_t key)
+static inline size_t __attribute__((pure, nonnull))
+hash(const hash_table_t *restrict this, size_t key)
 {
-  return this->hasher ? this->hasher(key) : key;
+	return this->hasher ? this->hasher(key) : key;
 }
 
 
@@ -56,10 +56,10 @@ static inline size_t hash(const hash_table_t* restrict this, size_t key)
  * @param   key   The key to hash
  * @return        A non-negative value less the the table's capacity
  */
-__attribute__((pure, nonnull))
-static inline size_t truncate_hash(const hash_table_t* restrict this, size_t hash)
+static inline size_t __attribute__((pure, nonnull))
+truncate_hash(const hash_table_t *restrict this, size_t hash)
 {
-  return hash % this->capacity;
+	return hash % this->capacity;
 }
 
 
@@ -69,49 +69,42 @@ static inline size_t truncate_hash(const hash_table_t* restrict this, size_t has
  * @param   this  The hash table
  * @return        Non-zero on error, `errno` will be set accordingly
  */
-__attribute__((nonnull))
-static int rehash(hash_table_t* restrict this)
+static int __attribute__((nonnull))
+rehash(hash_table_t *restrict this)
 {
-  hash_entry_t** old_buckets = this->buckets;
-  size_t old_capacity = this->capacity;
-  size_t i = old_capacity, index;
-  hash_entry_t* bucket;
-  hash_entry_t* destination;
-  hash_entry_t* next;
-  
-  fail_if (xcalloc(this->buckets, old_capacity * 2 + 1, hash_entry_t*));
-  this->capacity = old_capacity * 2 + 1;
-  this->threshold = (size_t)((float)(this->capacity) * this->load_factor);
-  
-  while (i)
-    {
-      bucket = this->buckets[--i];
-      while (bucket)
-	{
-	  index = truncate_hash(this, bucket->hash);
-	  if ((destination = this->buckets[index]))
-	    {
-	      next = destination->next;
-	      while (next)
-		{
-		  destination = next;
-		  next = destination->next;
+	hash_entry_t **old_buckets = this->buckets;
+	size_t old_capacity = this->capacity;
+	size_t i = old_capacity, index;
+	hash_entry_t *bucket;
+	hash_entry_t *destination;
+	hash_entry_t *next;
+
+	fail_if (xcalloc(this->buckets, old_capacity * 2 + 1, hash_entry_t*));
+	this->capacity = old_capacity * 2 + 1;
+	this->threshold = (size_t)((float)(this->capacity) * this->load_factor);
+
+	while (i--) {
+		bucket = this->buckets[i];
+		while (bucket) {
+			index = truncate_hash(this, bucket->hash);
+			if ((destination = this->buckets[index])) {
+				while ((next = destination->next))
+					destination = next;
+				destination->next = bucket;
+			} else {
+				this->buckets[index] = bucket;
+			}
+
+			next = bucket->next;
+			bucket->next = NULL;
+			bucket = next;
 		}
-	      destination->next = bucket;
-	    }
-	  else
-	    this->buckets[index] = bucket;
-	  
-	  next = bucket->next;
-	  bucket->next = NULL;
-	  bucket = next;
 	}
-    }
-  
-  free(old_buckets);
-  return 0;
- fail:
-  return -1;
+
+	free(old_buckets);
+	return 0;
+fail:
+	return -1;
 }
 
 
@@ -123,22 +116,23 @@ static int rehash(hash_table_t* restrict this)
  * @param   load_factor       The load factor of the table, i.e. when to grow the table
  * @return                    Non-zero on error, `errno` will have been set accordingly
  */
-int hash_table_create_fine_tuned(hash_table_t* restrict this, size_t initial_capacity, float load_factor)
+int
+hash_table_create_fine_tuned(hash_table_t *restrict this, size_t initial_capacity, float load_factor)
 {
-  this->buckets = NULL;
-  
-  this->capacity = initial_capacity ? initial_capacity : 1;
-  fail_if (xcalloc(this->buckets, this->capacity, hash_entry_t*));
-  this->load_factor = load_factor;
-  this->threshold = (size_t)((float)(this->capacity) * load_factor);
-  this->size = 0;
-  this->value_comparator = NULL;
-  this->key_comparator = NULL;
-  this->hasher = NULL;
-  
-  return 0;
- fail:
-  return -1;
+	this->buckets = NULL;
+
+	this->capacity = initial_capacity ? initial_capacity : 1;
+	fail_if (xcalloc(this->buckets, this->capacity, hash_entry_t*));
+	this->load_factor = load_factor;
+	this->threshold = (size_t)((float)(this->capacity) * load_factor);
+	this->size = 0;
+	this->value_comparator = NULL;
+	this->key_comparator = NULL;
+	this->hasher = NULL;
+
+	return 0;
+fail:
+	return -1;
 }
 
 
@@ -150,27 +144,24 @@ int hash_table_create_fine_tuned(hash_table_t* restrict this, size_t initial_cap
  * @param  keys_freer    Function that frees a key, `NULL` if keys should not be freed
  * @param  values_freer  Function that frees a value, `NULL` if value should not be freed
  */
-void hash_table_destroy(hash_table_t* restrict this, free_func* key_freer, free_func* value_freer)
+void
+hash_table_destroy(hash_table_t *restrict this, free_func *key_freer, free_func *value_freer)
 {
-  size_t i = this->capacity;
-  hash_entry_t* bucket;
-  hash_entry_t* last;
-  
-  if (this->buckets != NULL)
-    {
-      while (i)
-	{
-	  bucket = this->buckets[--i];
-	  while (bucket)
-	    {
-	      if (key_freer   != NULL)  key_freer(bucket->key);
-	      if (value_freer != NULL)  value_freer(bucket->value);
-	      bucket = (last = bucket)->next;
-	      free(last);
-	    }
+	size_t i = this->capacity;
+	hash_entry_t *bucket, *last;
+
+	if (this->buckets) {
+		while (i) {
+			bucket = this->buckets[--i];
+			while (bucket) {
+				if (key_freer)   key_freer(bucket->key);
+				if (value_freer) value_freer(bucket->value);
+				bucket = (last = bucket)->next;
+				free(last);
+			}
+		}
+		free(this->buckets);
 	}
-      free(this->buckets);
-    }
 }
 
 
@@ -181,25 +172,24 @@ void hash_table_destroy(hash_table_t* restrict this, free_func* key_freer, free_
  * @param   value  The value
  * @return         Whether the value is stored in the table
  */
-int hash_table_contains_value(const hash_table_t* restrict this, size_t value)
+int
+hash_table_contains_value(const hash_table_t *restrict this, size_t value)
 {
-  size_t i = this->capacity;
-  hash_entry_t* restrict bucket;
-  
-  while (i)
-    {
-      bucket = this->buckets[--i];
-      while (bucket != NULL)
-	{
-	  if (bucket->value == value)
-	    return 1;
-	  if (this->value_comparator && this->value_comparator(bucket->value, value))
-	    return 1;
-	  bucket = bucket->next;
+	size_t i = this->capacity;
+	hash_entry_t *restrict bucket;
+
+	while (i--) {
+		bucket = this->buckets[i];
+		while (bucket) {
+			if (bucket->value == value)
+				return 1;
+			if (this->value_comparator && this->value_comparator(bucket->value, value))
+				return 1;
+			bucket = bucket->next;
+		}
 	}
-    }
-  
-  return 0;
+
+	return 0;
 }
 
 
@@ -210,20 +200,20 @@ int hash_table_contains_value(const hash_table_t* restrict this, size_t value)
  * @param   key   The key
  * @return        Whether the key is used
  */
-int hash_table_contains_key(const hash_table_t* restrict this, size_t key)
+int
+hash_table_contains_key(const hash_table_t *restrict this, size_t key)
 {
-  size_t key_hash = hash(this, key);
-  size_t index = truncate_hash(this, key_hash);
-  hash_entry_t* restrict bucket = this->buckets[index];
-  
-  while (bucket)
-    {
-      if (TEST_KEY(this, bucket, key, key_hash))
-	return 1;
-      bucket = bucket->next;
-    }
-  
-  return 0;
+	size_t key_hash = hash(this, key);
+	size_t index = truncate_hash(this, key_hash);
+	hash_entry_t *restrict bucket = this->buckets[index];
+
+	while (bucket) {
+		if (TEST_KEY(this, bucket, key, key_hash))
+			return 1;
+		bucket = bucket->next;
+	}
+
+	return 0;
 }
 
 
@@ -234,20 +224,20 @@ int hash_table_contains_key(const hash_table_t* restrict this, size_t key)
  * @param   key   The key associated with the value
  * @return        The value associated with the key, 0 if the key was not used
  */
-size_t hash_table_get(const hash_table_t* restrict this, size_t key)
+size_t
+hash_table_get(const hash_table_t *restrict this, size_t key)
 {
-  size_t key_hash = hash(this, key);
-  size_t index = truncate_hash(this, key_hash);
-  hash_entry_t* restrict bucket = this->buckets[index];
-  
-  while (bucket)
-    {
-      if (TEST_KEY(this, bucket, key, key_hash))
-	return bucket->value;
-      bucket = bucket->next;
-    }
-  
-  return 0;
+	size_t key_hash = hash(this, key);
+	size_t index = truncate_hash(this, key_hash);
+	hash_entry_t *restrict bucket = this->buckets[index];
+
+	while (bucket) {
+		if (TEST_KEY(this, bucket, key, key_hash))
+			return bucket->value;
+		bucket = bucket->next;
+	}
+
+	return 0;
 }
 
 
@@ -258,20 +248,20 @@ size_t hash_table_get(const hash_table_t* restrict this, size_t key)
  * @param   key   The key associated with the value
  * @return        The entry associated with the key, `NULL` if the key was not used
  */
-hash_entry_t* hash_table_get_entry(const hash_table_t* restrict this, size_t key)
+hash_entry_t *
+hash_table_get_entry(const hash_table_t *restrict this, size_t key)
 {
-  size_t key_hash = hash(this, key);
-  size_t index = truncate_hash(this, key_hash);
-  hash_entry_t* restrict bucket = this->buckets[index];
-  
-  while (bucket)
-    {
-      if (TEST_KEY(this, bucket, key, key_hash))
-	return bucket;
-      bucket = bucket->next;
-    }
-  
-  return NULL;
+	size_t key_hash = hash(this, key);
+	size_t index = truncate_hash(this, key_hash);
+	hash_entry_t *restrict bucket = this->buckets[index];
+
+	while (bucket) {
+		if (TEST_KEY(this, bucket, key, key_hash))
+			return bucket;
+		bucket = bucket->next;
+	}
+
+	return NULL;
 }
 
 
@@ -284,41 +274,41 @@ hash_entry_t* hash_table_get_entry(const hash_table_t* restrict this, size_t key
  * @return         The previous value associated with the key, 0 if the key was not used.
  *                 0 will also be returned on error, check the `errno` variable.
  */
-size_t hash_table_put(hash_table_t* restrict this, size_t key, size_t value)
+size_t
+hash_table_put(hash_table_t *restrict this, size_t key, size_t value)
 {
-  size_t key_hash = hash(this, key);
-  size_t index = truncate_hash(this, key_hash);
-  hash_entry_t* restrict bucket = this->buckets[index];
-  size_t rc;
-  
-  while (bucket)
-    if (TEST_KEY(this, bucket, key, key_hash))
-      {
-	rc = bucket->value;
+	size_t key_hash = hash(this, key);
+	size_t index = truncate_hash(this, key_hash);
+	hash_entry_t *restrict bucket = this->buckets[index];
+	size_t rc;
+
+	while (bucket) {
+		if (TEST_KEY(this, bucket, key, key_hash)) {
+				rc = bucket->value;
+				bucket->value = value;
+				return rc;
+		} else {
+			bucket = bucket->next;
+		}
+	}
+
+	if (++(this->size) > this->threshold) {
+		errno = 0;
+		fail_if (rehash(this));
+		index = truncate_hash(this, key_hash);
+	}
+
+	errno = 0;
+	fail_if (xmalloc(bucket, 1, hash_entry_t));
 	bucket->value = value;
-	return rc;
-      }
-    else
-      bucket = bucket->next;
-  
-  if (++(this->size) > this->threshold)
-    {
-      errno = 0;
-      fail_if (rehash(this));
-      index = truncate_hash(this, key_hash);
-    }
-  
-  errno = 0;
-  fail_if (xmalloc(bucket, 1, hash_entry_t));
-  bucket->value = value;
-  bucket->key = key;
-  bucket->hash = key_hash;
-  bucket->next = this->buckets[index];
-  this->buckets[index] = bucket;
-  
-  return 0;
- fail:
-  return 0;
+	bucket->key = key;
+	bucket->hash = key_hash;
+	bucket->next = this->buckets[index];
+	this->buckets[index] = bucket;
+
+	return 0;
+fail:
+	return 0;
 }
 
 
@@ -329,32 +319,31 @@ size_t hash_table_put(hash_table_t* restrict this, size_t key, size_t value)
  * @param   key   The key of the entry to remove
  * @return        The previous value associated with the key, 0 if the key was not used
  */
-size_t hash_table_remove(hash_table_t* restrict this, size_t key)
+size_t
+hash_table_remove(hash_table_t *restrict this, size_t key)
 {
-  size_t key_hash = hash(this, key);
-  size_t index = truncate_hash(this, key_hash);
-  hash_entry_t* bucket = this->buckets[index];
-  hash_entry_t* last = NULL;
-  size_t rc;
-  
-  while (bucket)
-    {
-      if (TEST_KEY(this, bucket, key, key_hash))
-	{
-	  if (last == NULL)
-	    this->buckets[index] = bucket->next;
-	  else
-	    last->next = bucket->next;
-	  this->size--;
-	  rc = bucket->value;
-	  free(bucket);
-	  return rc;
+	size_t key_hash = hash(this, key);
+	size_t index = truncate_hash(this, key_hash);
+	hash_entry_t *bucket = this->buckets[index];
+	hash_entry_t *last = NULL;
+	size_t rc;
+
+	while (bucket) {
+		if (TEST_KEY(this, bucket, key, key_hash)) {
+			if (!last)
+				this->buckets[index] = bucket->next;
+			else
+				last->next = bucket->next;
+			this->size--;
+			rc = bucket->value;
+			free(bucket);
+			return rc;
+		}
+		last = bucket;
+		bucket = bucket->next;
 	}
-      last = bucket;
-      bucket = bucket->next;
-    }
-  
-  return 0;
+
+	return 0;
 }
 
 
@@ -363,32 +352,29 @@ size_t hash_table_remove(hash_table_t* restrict this, size_t key)
  * 
  * @param  this  The hash table
  */
-void hash_table_clear(hash_table_t* restrict this)
+void
+hash_table_clear(hash_table_t *restrict this)
 {
-  hash_entry_t** buf;
-  hash_entry_t* bucket;
-  size_t i, ptr;
-  
-  if (this->size)
-    {
-      buf = alloca((this->size + 1) * sizeof(hash_entry_t*));
-      i = this->capacity;
-      while (i)
-	{
-	  bucket = this->buckets[--i];
-	  ptr = 0;
-	  buf[ptr++] = bucket;
-	  while (bucket)
-	    {
-	      bucket = bucket->next;
-	      buf[ptr++] = bucket;
-	    }
-	  while (ptr)
-	    free(buf[--ptr]);
-	  this->buckets[i] = NULL;
+	hash_entry_t **buf, *bucket;
+	size_t i, ptr;
+
+	if (this->size) {
+		buf = alloca((this->size + 1) * sizeof(hash_entry_t*));
+		i = this->capacity;
+		while (i--) {
+			bucket = this->buckets[i];
+			ptr = 0;
+			buf[ptr++] = bucket;
+			while (bucket) {
+				bucket = bucket->next;
+				buf[ptr++] = bucket;
+			}
+			while (ptr)
+				free(buf[--ptr]);
+			this->buckets[i] = NULL;
+		}
+		this->size = 0;
 	}
-      this->size = 0;
-    }
 }
 
 
@@ -398,23 +384,23 @@ void hash_table_clear(hash_table_t* restrict this)
  * @param   this  The hash table
  * @return        The number of bytes to allocate to the output buffer
  */
-size_t hash_table_marshal_size(const hash_table_t* restrict this)
+size_t
+hash_table_marshal_size(const hash_table_t *restrict this)
 {
-  size_t n = this->capacity;
-  size_t rc = 3 * sizeof(size_t) + sizeof(float) + n * sizeof(size_t);
-  size_t i, m = 0;
-  
-  for (i = 0; i < n; i++)
-    {
-      hash_entry_t* restrict bucket = this->buckets[i];
-      while (bucket != NULL)
-	{
-	  bucket = bucket->next;
-	  m++;
+	size_t n = this->capacity;
+	size_t rc = 3 * sizeof(size_t) + sizeof(float) + n * sizeof(size_t);
+	size_t i, m = 0;
+	hash_entry_t *restrict bucket;
+
+	for (i = 0; i < n; i++) {
+		bucket = this->buckets[i];
+		while (bucket) {
+			bucket = bucket->next;
+			m++;
+		}
 	}
-    }
-  
-  return rc + m * 3 * sizeof(size_t) + sizeof(int);
+
+	return rc + m * 3 * sizeof(size_t) + sizeof(int);
 }
 
 
@@ -424,31 +410,31 @@ size_t hash_table_marshal_size(const hash_table_t* restrict this)
  * @param  this  The hash table
  * @param  data  Output buffer for the marshalled data
  */
-void hash_table_marshal(const hash_table_t* restrict this, char* restrict data)
+void
+hash_table_marshal(const hash_table_t *restrict this, char *restrict data)
 {
-  size_t i, n = this->capacity;
-  
-  buf_set_next(data, int, HASH_TABLE_T_VERSION);
-  buf_set_next(data, size_t, this->capacity);
-  buf_set_next(data, float, this->load_factor);
-  buf_set_next(data, size_t, this->threshold);
-  buf_set_next(data, size_t, this->size);
-  
-  for (i = 0; i < n; i++)
-    {
-      hash_entry_t* restrict bucket = this->buckets[i];
-      size_t m = 0;
-      while (bucket != NULL)
-	{
-	  buf_set(data, size_t, 1 + m * 3 + 0, bucket->key);
-	  buf_set(data, size_t, 1 + m * 3 + 1, bucket->value);
-	  buf_set(data, size_t, 1 + m * 3 + 2, bucket->hash);
-	  bucket = bucket->next;
-	  m++;
+	size_t i, n = this->capacity, m;
+	hash_entry_t *restrict bucket;
+
+	buf_set_next(data, int, HASH_TABLE_T_VERSION);
+	buf_set_next(data, size_t, this->capacity);
+	buf_set_next(data, float, this->load_factor);
+	buf_set_next(data, size_t, this->threshold);
+	buf_set_next(data, size_t, this->size);
+
+	for (i = 0; i < n; i++) {
+		bucket = this->buckets[i];
+		m = 0;
+		while (bucket) {
+			buf_set(data, size_t, 1 + m * 3 + 0, bucket->key);
+			buf_set(data, size_t, 1 + m * 3 + 1, bucket->value);
+			buf_set(data, size_t, 1 + m * 3 + 2, bucket->hash);
+			bucket = bucket->next;
+			m++;
+		}
+		buf_set(data, size_t, 0, m);
+		buf_next(data, size_t, 1 + m * 3);
 	}
-      buf_set(data, size_t, 0, m);
-      buf_next(data, size_t, 1 + m * 3);
-    }
 }
 
 
@@ -461,48 +447,45 @@ void hash_table_marshal(const hash_table_t* restrict this, char* restrict data)
  * @return            Non-zero on error, `errno` will be set accordingly.
  *                    Destroy the table on error.
  */
-int hash_table_unmarshal(hash_table_t* restrict this, char* restrict data, remap_func* remapper)
+int
+hash_table_unmarshal(hash_table_t *restrict this, char *restrict data, remap_func *remapper)
 {
-  size_t i, n;
-  
-  /* buf_get(data, int, 0, HASH_TABLE_T_VERSION); */
-  buf_next(data, int, 1);
-  
-  this->value_comparator = NULL;
-  this->key_comparator   = NULL;
-  this->hasher           = NULL;
-  
-  buf_get_next(data, size_t, this->capacity = n);
-  buf_get_next(data, float, this->load_factor);
-  buf_get_next(data, size_t, this->threshold);
-  buf_get_next(data, size_t, this->size);
-  
-  fail_if (xcalloc(this->buckets, this->capacity, hash_entry_t*));
-  
-  for (i = 0; i < n; i++)
-    {
-      size_t m;
-      hash_entry_t* restrict bucket;
-      buf_get_next(data, size_t, m);
-      
-      fail_if (xmalloc(this->buckets[i] = bucket, 1, hash_entry_t));
-      
-      while (m--)
-	{
-	  if (m == 0)
-	    bucket->next = NULL;
-	  else
-	    fail_if (xmalloc(bucket->next, 1, hash_entry_t));
-	  buf_get_next(data, size_t, bucket->key);
-	  buf_get_next(data, size_t, bucket->value);
-	  if (remapper != NULL)
-	    bucket->value = remapper(bucket->value);
-	  buf_get_next(data, size_t, bucket->hash);
+	size_t i, n, m;
+	hash_entry_t *restrict bucket;
+
+	/* buf_get(data, int, 0, HASH_TABLE_T_VERSION); */
+	buf_next(data, int, 1);
+
+	this->value_comparator = NULL;
+	this->key_comparator   = NULL;
+	this->hasher           = NULL;
+
+	buf_get_next(data, size_t, this->capacity = n);
+	buf_get_next(data, float, this->load_factor);
+	buf_get_next(data, size_t, this->threshold);
+	buf_get_next(data, size_t, this->size);
+
+	fail_if (xcalloc(this->buckets, this->capacity, hash_entry_t*));
+
+	for (i = 0; i < n; i++) {
+		buf_get_next(data, size_t, m);
+
+		fail_if (xmalloc(this->buckets[i] = bucket, 1, hash_entry_t));
+
+		while (m--) {
+			if (!m)
+				bucket->next = NULL;
+			else
+				fail_if (xmalloc(bucket->next, 1, hash_entry_t));
+			buf_get_next(data, size_t, bucket->key);
+			buf_get_next(data, size_t, bucket->value);
+			if (remapper)
+				bucket->value = remapper(bucket->value);
+			buf_get_next(data, size_t, bucket->hash);
+		}
 	}
-    }
-  
-  return 0;
- fail:
-  return -1;
-}
 
+	return 0;
+fail:
+	return -1;
+}
diff --git a/src/libmdsserver/linked-list.c b/src/libmdsserver/linked-list.c
index 401a726..954c6fe 100644
--- a/src/libmdsserver/linked-list.c
+++ b/src/libmdsserver/linked-list.c
@@ -27,7 +27,7 @@
  * The default initial capacity
  */
 #ifndef LINKED_LIST_DEFAULT_INITIAL_CAPACITY
-# define LINKED_LIST_DEFAULT_INITIAL_CAPACITY  128
+# define LINKED_LIST_DEFAULT_INITIAL_CAPACITY 128
 #endif
 
 
@@ -38,19 +38,19 @@
  * @param   value  The value to be rounded up to a power of two
  * @return         The nearest, but not smaller, power of two
  */
-__attribute__((const))
-static size_t to_power_of_two(size_t value)
+static size_t __attribute__((const))
+to_power_of_two(size_t value)
 {
-  value -= 1;
-  value |= value >> 1;
-  value |= value >> 2;
-  value |= value >> 4;
-  value |= value >> 8;
-  value |= value >> 16;
+	value -= 1;
+	value |= value >> 1;
+	value |= value >> 2;
+	value |= value >> 4;
+	value |= value >> 8;
+	value |= value >> 16;
 #if SIZE_MAX == UINT64_MAX
-  value |= value >> 32;
+	value |= value >> 32;
 #endif
-  return value + 1;
+	return value + 1;
 }
 
 
@@ -61,32 +61,33 @@ static size_t to_power_of_two(size_t value)
  * @param   capacity  The minimum initial capacity of the linked list, 0 for default
  * @return            Non-zero on error, `errno` will have been set accordingly
  */
-int linked_list_create(linked_list_t* restrict this, size_t capacity)
+int
+linked_list_create(linked_list_t *restrict this, size_t capacity)
 {
-  /* Use default capacity of zero is specified. */
-  if (capacity == 0)
-    capacity = LINKED_LIST_DEFAULT_INITIAL_CAPACITY;
-  
-  /* Initialise the linked list. */
-  this->capacity   = capacity = to_power_of_two(capacity);
-  this->edge       = 0;
-  this->end        = 1;
-  this->reuse_head = 0;
-  this->reusable   = NULL;
-  this->values     = NULL;
-  this->next       = NULL;
-  this->previous   = NULL;
-  fail_if (xmalloc(this->reusable, capacity, ssize_t));
-  fail_if (xmalloc(this->values,   capacity,  size_t));
-  fail_if (xmalloc(this->next,     capacity, ssize_t));
-  fail_if (xmalloc(this->previous, capacity, ssize_t));
-  this->values[this->edge]   = 0;
-  this->next[this->edge]     = this->edge;
-  this->previous[this->edge] = this->edge;
-  
-  return 0;
- fail:
-  return -1;
+	/* Use default capacity of zero is specified. */
+	if (!capacity)
+		capacity = LINKED_LIST_DEFAULT_INITIAL_CAPACITY;
+
+	/* Initialise the linked list. */
+	this->capacity   = capacity = to_power_of_two(capacity);
+	this->edge       = 0;
+	this->end        = 1;
+	this->reuse_head = 0;
+	this->reusable   = NULL;
+	this->values     = NULL;
+	this->next       = NULL;
+	this->previous   = NULL;
+	fail_if (xmalloc(this->reusable, capacity, ssize_t));
+	fail_if (xmalloc(this->values,   capacity,  size_t));
+	fail_if (xmalloc(this->next,     capacity, ssize_t));
+	fail_if (xmalloc(this->previous, capacity, ssize_t));
+	this->values[this->edge]   = 0;
+	this->next[this->edge]     = this->edge;
+	this->previous[this->edge] = this->edge;
+
+	return 0;
+fail:
+	return -1;
 }
 
 
@@ -96,12 +97,13 @@ int linked_list_create(linked_list_t* restrict this, size_t capacity)
  * 
  * @param  this  The linked list
  */
-void linked_list_destroy(linked_list_t* restrict this)
+void
+linked_list_destroy(linked_list_t *restrict this)
 {
-  free(this->reusable),  this->reusable = NULL;
-  free(this->values),    this->values   = NULL;
-  free(this->next),      this->next     = NULL;
-  free(this->previous),  this->previous = NULL;
+	free(this->reusable), this->reusable = NULL;
+	free(this->values),   this->values   = NULL;
+	free(this->next),     this->next     = NULL;
+	free(this->previous), this->previous = NULL;
 }
 
 
@@ -112,22 +114,23 @@ void linked_list_destroy(linked_list_t* restrict this)
  * @param   out   Memory slot in which to store the new linked list
  * @return        Non-zero on error, `errno` will have been set accordingly
  */
-int linked_list_clone(const linked_list_t* restrict this, linked_list_t* restrict out)
+int
+linked_list_clone(const linked_list_t *restrict this, linked_list_t *restrict out)
 {
-  fail_if (xmemdup(out->values,   this->values,   this->capacity, size_t));
-  fail_if (xmemdup(out->next,     this->next,     this->capacity, ssize_t));
-  fail_if (xmemdup(out->previous, this->previous, this->capacity, ssize_t));
-  fail_if (xmemdup(out->reusable, this->reusable, this->capacity, ssize_t));
-  
-  out->capacity   = this->capacity;
-  out->end        = this->end;
-  out->reuse_head = this->reuse_head;
-  out->edge       = this->edge;
-  
-  return 0;
-
- fail:
-  return -1;
+	fail_if (xmemdup(out->values,   this->values,   this->capacity, size_t));
+	fail_if (xmemdup(out->next,     this->next,     this->capacity, ssize_t));
+	fail_if (xmemdup(out->previous, this->previous, this->capacity, ssize_t));
+	fail_if (xmemdup(out->reusable, this->reusable, this->capacity, ssize_t));
+
+	out->capacity   = this->capacity;
+	out->end        = this->end;
+	out->reuse_head = this->reuse_head;
+	out->edge       = this->edge;
+
+	return 0;
+
+fail:
+	return -1;
 }
 
 
@@ -145,64 +148,64 @@ int linked_list_clone(const linked_list_t* restrict this, linked_list_t* restric
  * @param   this  The list
  * @return        Non-zero on error, `errno` will have been set accordingly
  */
-int linked_list_pack(linked_list_t* restrict this)
+int
+linked_list_pack(linked_list_t *restrict this)
 {
-  ssize_t* restrict new_next = NULL;
-  ssize_t* restrict new_previous = NULL;
-  ssize_t* restrict new_reusable = NULL;
-  size_t size = this->end - this->reuse_head;
-  size_t cap = to_power_of_two(size);
-  ssize_t head = 0;
-  size_t i = 0;
-  ssize_t node;
-  size_t* restrict vals;
-  int saved_errno;
-  
-  fail_if (xmalloc(vals, cap, size_t));
-  while (((size_t)head != this->end) && (this->next[head] == LINKED_LIST_UNUSED))
-    head++;
-  if ((size_t)head != this->end)
-    for (node = head; (node != head) || (i == 0); i++)
-      {
-	vals[i] = this->values[node];
-	node = this->next[node];
-      }
-  
-  if (cap != this->capacity)
-    {
-      fail_if (xmalloc(new_next,     cap, ssize_t));
-      fail_if (xmalloc(new_previous, cap, ssize_t));
-      fail_if (xmalloc(new_reusable, cap, ssize_t));
-      
-      free(this->next);
-      free(this->previous);
-      free(this->reusable);
-      
-      this->next     = new_next;
-      this->previous = new_previous;
-      this->reusable = new_reusable;
-    }
-  
-  for (i = 0; i < size; i++)
-    this->next[i] = (ssize_t)(i + 1);
-  this->next[size - 1] = 0;
-  
-  for (i = 1; i < size; i++)
-    this->previous[i] = (ssize_t)(i - 1);
-  this->previous[0] = (ssize_t)(size - 1);
-  
-  this->values = vals;
-  this->end = size;
-  this->reuse_head = 0;
-  
-  return 0;
-
- fail:
-  saved_errno = errno;
-  free(vals);
-  free(new_next);
-  free(new_previous);
-  return errno = saved_errno, -1;
+	ssize_t *restrict new_next = NULL;
+	ssize_t *restrict new_previous = NULL;
+	ssize_t *restrict new_reusable = NULL;
+	size_t size = this->end - this->reuse_head;
+	size_t cap = to_power_of_two(size);
+	ssize_t head = 0;
+	size_t i = 0;
+	ssize_t node;
+	size_t *restrict vals;
+	int saved_errno;
+
+	fail_if (xmalloc(vals, cap, size_t));
+	while ((size_t)head != this->end && this->next[head] == LINKED_LIST_UNUSED)
+		head++;
+	if ((size_t)head != this->end) {
+		for (node = head; (node != head) || (i == 0); i++) {
+			vals[i] = this->values[node];
+			node = this->next[node];
+		}
+	}
+
+	if (cap != this->capacity) {
+		fail_if (xmalloc(new_next,     cap, ssize_t));
+		fail_if (xmalloc(new_previous, cap, ssize_t));
+		fail_if (xmalloc(new_reusable, cap, ssize_t));
+
+		free(this->next);
+		free(this->previous);
+		free(this->reusable);
+
+		this->next     = new_next;
+		this->previous = new_previous;
+		this->reusable = new_reusable;
+	}
+
+	for (i = 0; i < size; i++)
+		this->next[i] = (ssize_t)(i + 1);
+	this->next[size - 1] = 0;
+
+	for (i = 1; i < size; i++)
+		this->previous[i] = (ssize_t)(i - 1);
+	this->previous[0] = (ssize_t)(size - 1);
+
+	this->values = vals;
+	this->end = size;
+	this->reuse_head = 0;
+
+	return 0;
+
+fail:
+	saved_errno = errno;
+	free(vals);
+	free(new_next);
+	free(new_previous);
+	return errno = saved_errno, -1;
 }
 
 
@@ -215,29 +218,28 @@ int linked_list_pack(linked_list_t* restrict this)
  * @return        The next free position,
  *                `LINKED_LIST_UNUSED` on error, `errno` will be set accordingly
  */
-__attribute__((nonnull))
-static ssize_t linked_list_get_next(linked_list_t* restrict this)
+static ssize_t __attribute__((nonnull))
+linked_list_get_next(linked_list_t *restrict this)
 {
-  size_t* tmp_values;
-  ssize_t* tmp;
-  
-  if (this->reuse_head > 0)
-    return this->reusable[--(this->reuse_head)];
-  if (this->end == this->capacity)
-    {
-      if ((ssize_t)(this->end) < 0)
-	fail_if ((errno = ENOMEM));
-      
-      this->capacity <<= 1;
-      
-      fail_if (yrealloc(tmp_values, this->values,   this->capacity, size_t));
-      fail_if (yrealloc(tmp,        this->next,     this->capacity, ssize_t));
-      fail_if (yrealloc(tmp,        this->previous, this->capacity, ssize_t));
-      fail_if (yrealloc(tmp,        this->reusable, this->capacity, ssize_t));
-    }
-  return (ssize_t)(this->end++);
- fail:
-  return LINKED_LIST_UNUSED;
+	size_t *tmp_values;
+	ssize_t *tmp;
+
+	if (this->reuse_head > 0)
+		return this->reusable[--(this->reuse_head)];
+	if (this->end == this->capacity) {
+		if ((ssize_t)(this->end) < 0)
+			fail_if ((errno = ENOMEM));
+
+		this->capacity <<= 1;
+
+		fail_if (yrealloc(tmp_values, this->values,   this->capacity, size_t));
+		fail_if (yrealloc(tmp,        this->next,     this->capacity, ssize_t));
+		fail_if (yrealloc(tmp,        this->previous, this->capacity, ssize_t));
+		fail_if (yrealloc(tmp,        this->reusable, this->capacity, ssize_t));
+	}
+	return (ssize_t)(this->end++);
+fail:
+	return LINKED_LIST_UNUSED;
 }
 
 
@@ -248,15 +250,15 @@ static ssize_t linked_list_get_next(linked_list_t* restrict this)
  * @param   node  The position
  * @return        The position
  */
-__attribute__((nonnull))
-static ssize_t linked_list_unuse(linked_list_t* restrict this, ssize_t node)
+static ssize_t __attribute__((nonnull))
+linked_list_unuse(linked_list_t *restrict this, ssize_t node)
 {
-  if (node < 0)
-    return node;
-  this->reusable[this->reuse_head++] = node;
-  this->next[node] = LINKED_LIST_UNUSED;
-  this->previous[node] = LINKED_LIST_UNUSED;
-  return node;
+	if (node < 0)
+		return node;
+	this->reusable[this->reuse_head++] = node;
+	this->next[node] = LINKED_LIST_UNUSED;
+	this->previous[node] = LINKED_LIST_UNUSED;
+	return node;
 }
 
 
@@ -269,18 +271,19 @@ static ssize_t linked_list_unuse(linked_list_t* restrict this, ssize_t node)
  * @return               The node that has been created and inserted,
  *                       `LINKED_LIST_UNUSED` on error, `errno` will be set accordingly
  */
-ssize_t linked_list_insert_after(linked_list_t* this, size_t value, ssize_t predecessor)
+ssize_t
+linked_list_insert_after(linked_list_t *this, size_t value, ssize_t predecessor)
 {
-  ssize_t node = linked_list_get_next(this);
-  fail_if (node == LINKED_LIST_UNUSED);
-  this->values[node] = value;
-  this->next[node] = this->next[predecessor];
-  this->next[predecessor] = node;
-  this->previous[node] = predecessor;
-  this->previous[this->next[node]] = node;
-  return node;
- fail:
-  return LINKED_LIST_UNUSED;
+	ssize_t node = linked_list_get_next(this);
+	fail_if (node == LINKED_LIST_UNUSED);
+	this->values[node] = value;
+	this->next[node] = this->next[predecessor];
+	this->next[predecessor] = node;
+	this->previous[node] = predecessor;
+	this->previous[this->next[node]] = node;
+	return node;
+fail:
+	return LINKED_LIST_UNUSED;
 }
 
 
@@ -291,12 +294,13 @@ ssize_t linked_list_insert_after(linked_list_t* this, size_t value, ssize_t pred
  * @param   predecessor  The reference node
  * @return               The node that has been removed
  */
-ssize_t linked_list_remove_after(linked_list_t* restrict this, ssize_t predecessor)
+ssize_t
+linked_list_remove_after(linked_list_t *restrict this, ssize_t predecessor)
 {
-  ssize_t node = this->next[predecessor];
-  this->next[predecessor] = this->next[node];
-  this->previous[this->next[node]] = predecessor;
-  return linked_list_unuse(this, node);
+	ssize_t node = this->next[predecessor];
+	this->next[predecessor] = this->next[node];
+	this->previous[this->next[node]] = predecessor;
+	return linked_list_unuse(this, node);
 }
 
 
@@ -309,18 +313,19 @@ ssize_t linked_list_remove_after(linked_list_t* restrict this, ssize_t predecess
  * @return             The node that has been created and inserted,
  *                     `LINKED_LIST_UNUSED` on error, `errno` will be set accordingly
  */
-ssize_t linked_list_insert_before(linked_list_t* restrict this, size_t value, ssize_t successor)
+ssize_t
+linked_list_insert_before(linked_list_t *restrict this, size_t value, ssize_t successor)
 {
-  ssize_t node = linked_list_get_next(this);
-  fail_if (node == LINKED_LIST_UNUSED);
-  this->values[node] = value;
-  this->previous[node] = this->previous[successor];
-  this->previous[successor] = node;
-  this->next[node] = successor;
-  this->next[this->previous[node]] = node;
-  return node;
- fail:
-  return LINKED_LIST_UNUSED;
+	ssize_t node = linked_list_get_next(this);
+	fail_if (node == LINKED_LIST_UNUSED);
+	this->values[node] = value;
+	this->previous[node] = this->previous[successor];
+	this->previous[successor] = node;
+	this->next[node] = successor;
+	this->next[this->previous[node]] = node;
+	return node;
+fail:
+	return LINKED_LIST_UNUSED;
 }
 
 
@@ -331,12 +336,13 @@ ssize_t linked_list_insert_before(linked_list_t* restrict this, size_t value, ss
  * @param   successor  The reference node
  * @return             The node that has been removed
  */
-ssize_t linked_list_remove_before(linked_list_t* restrict this, ssize_t successor)
+ssize_t
+linked_list_remove_before(linked_list_t *restrict this, ssize_t successor)
 {
-  ssize_t node = this->previous[successor];
-  this->previous[successor] = this->previous[node];
-  this->next[this->previous[node]] = successor;
-  return linked_list_unuse(this, node);
+	ssize_t node = this->previous[successor];
+	this->previous[successor] = this->previous[node];
+	this->next[this->previous[node]] = successor;
+	return linked_list_unuse(this, node);
 }
 
 
@@ -346,11 +352,12 @@ ssize_t linked_list_remove_before(linked_list_t* restrict this, ssize_t successo
  * @param  this  The list
  * @param  node  The node to remove
  */
-void linked_list_remove(linked_list_t* restrict this, ssize_t node)
+void
+linked_list_remove(linked_list_t *restrict this, ssize_t node)
 {
-  this->next[this->previous[node]] = this->next[node];
-  this->previous[this->next[node]] = this->previous[node];
-  linked_list_unuse(this, node);
+	this->next[this->previous[node]] = this->next[node];
+	this->previous[this->next[node]] = this->previous[node];
+	linked_list_unuse(this, node);
 }
 
 
@@ -360,9 +367,10 @@ void linked_list_remove(linked_list_t* restrict this, ssize_t node)
  * @param   this  The list
  * @return        The number of bytes to allocate to the output buffer
  */
-size_t linked_list_marshal_size(const linked_list_t* restrict this)
+size_t
+linked_list_marshal_size(const linked_list_t *restrict this)
 {
-  return sizeof(size_t) * (4 + this->reuse_head + 3 * this->end) + sizeof(int);
+	return sizeof(size_t) * (4 + this->reuse_head + 3 * this->end) + sizeof(int);
 }
 
 
@@ -372,27 +380,28 @@ size_t linked_list_marshal_size(const linked_list_t* restrict this)
  * @param  this  The list
  * @param  data  Output buffer for the marshalled data
  */
-void linked_list_marshal(const linked_list_t* restrict this, char* restrict data)
+void
+linked_list_marshal(const linked_list_t *restrict this, char *restrict data)
 {
-  buf_set(data, int, 0, LINKED_LIST_T_VERSION);
-  buf_next(data, int, 1);
-  
-  buf_set(data, size_t, 0, this->capacity);
-  buf_set(data, size_t, 1, this->end);
-  buf_set(data, size_t, 2, this->reuse_head);
-  buf_set(data, ssize_t, 3, this->edge);
-  buf_next(data, size_t, 4);
-  
-  memcpy(data, this->reusable, this->reuse_head * sizeof(ssize_t));
-  buf_next(data, ssize_t, this->reuse_head);
-  
-  memcpy(data, this->values, this->end * sizeof(size_t));
-  buf_next(data, size_t, this->end);
-  
-  memcpy(data, this->next, this->end * sizeof(ssize_t));
-  buf_next(data, ssize_t, this->end);
-  
-  memcpy(data, this->previous, this->end * sizeof(ssize_t));
+	buf_set(data, int, 0, LINKED_LIST_T_VERSION);
+	buf_next(data, int, 1);
+
+	buf_set(data, size_t, 0, this->capacity);
+	buf_set(data, size_t, 1, this->end);
+	buf_set(data, size_t, 2, this->reuse_head);
+	buf_set(data, ssize_t, 3, this->edge);
+	buf_next(data, size_t, 4);
+
+	memcpy(data, this->reusable, this->reuse_head * sizeof(ssize_t));
+	buf_next(data, ssize_t, this->reuse_head);
+
+	memcpy(data, this->values, this->end * sizeof(size_t));
+	buf_next(data, size_t, this->end);
+
+	memcpy(data, this->next, this->end * sizeof(ssize_t));
+	buf_next(data, ssize_t, this->end);
+
+	memcpy(data, this->previous, this->end * sizeof(ssize_t));
 }
 
 
@@ -404,41 +413,42 @@ void linked_list_marshal(const linked_list_t* restrict this, char* restrict data
  * @return        Non-zero on error, `errno` will be set accordingly.
  *                Destroy the list on error.
  */
-int linked_list_unmarshal(linked_list_t* restrict this, char* restrict data)
+int
+linked_list_unmarshal(linked_list_t *restrict this, char *restrict data)
 {
-  /* buf_get(data, int, 0, LINKED_LIST_T_VERSION); */
-  buf_next(data, int, 1);
-  
-  this->reusable = NULL;
-  this->values   = NULL;
-  this->next     = NULL;
-  this->previous = NULL;
-  
-  buf_get(data, size_t, 0, this->capacity);
-  buf_get(data, size_t, 1, this->end);
-  buf_get(data, size_t, 2, this->reuse_head);
-  buf_get(data, ssize_t, 3, this->edge);
-  buf_next(data, size_t, 4);
-  
-  fail_if (xmalloc(this->reusable, this->capacity, size_t));
-  fail_if (xmalloc(this->values,   this->capacity, size_t));
-  fail_if (xmalloc(this->next,     this->capacity, size_t));
-  fail_if (xmalloc(this->previous, this->capacity, size_t));
-  
-  memcpy(this->reusable, data, this->reuse_head * sizeof(ssize_t));
-  buf_next(data, ssize_t, this->reuse_head);
-  
-  memcpy(this->values, data, this->end * sizeof(size_t));
-  buf_next(data, size_t, this->end);
-  
-  memcpy(this->next, data, this->end * sizeof(ssize_t));
-  buf_next(data, ssize_t, this->end);
-  
-  memcpy(this->previous, data, this->end * sizeof(ssize_t));
-  
-  return 0;
- fail:
-  return -1;
+	/* buf_get(data, int, 0, LINKED_LIST_T_VERSION); */
+	buf_next(data, int, 1);
+
+	this->reusable = NULL;
+	this->values   = NULL;
+	this->next     = NULL;
+	this->previous = NULL;
+
+	buf_get(data, size_t, 0, this->capacity);
+	buf_get(data, size_t, 1, this->end);
+	buf_get(data, size_t, 2, this->reuse_head);
+	buf_get(data, ssize_t, 3, this->edge);
+	buf_next(data, size_t, 4);
+
+	fail_if (xmalloc(this->reusable, this->capacity, size_t));
+	fail_if (xmalloc(this->values,   this->capacity, size_t));
+	fail_if (xmalloc(this->next,     this->capacity, size_t));
+	fail_if (xmalloc(this->previous, this->capacity, size_t));
+
+	memcpy(this->reusable, data, this->reuse_head * sizeof(ssize_t));
+	buf_next(data, ssize_t, this->reuse_head);
+
+	memcpy(this->values, data, this->end * sizeof(size_t));
+	buf_next(data, size_t, this->end);
+
+	memcpy(this->next, data, this->end * sizeof(ssize_t));
+	buf_next(data, ssize_t, this->end);
+
+	memcpy(this->previous, data, this->end * sizeof(ssize_t));
+
+	return 0;
+fail:
+	return -1;
 }
 
 
@@ -448,31 +458,31 @@ int linked_list_unmarshal(linked_list_t* restrict this, char* restrict data)
  * @param  this    The list
  * @param  output  Output file
  */
-void linked_list_dump(linked_list_t* restrict this, FILE* restrict output)
+void
+linked_list_dump(linked_list_t *restrict this, FILE *restrict output)
 {
-  ssize_t i;
-  size_t j;
-  fprintf(output, "======= LINKED LIST DUMP =======\n");
-  fprintf(output, "Capacity:    %zu\n", this->capacity);
-  fprintf(output, "End:         %zu\n", this->end);
-  fprintf(output, "Reuse head:  %zu\n", this->reuse_head);
-  fprintf(output, "Edge:        %zi\n", this->edge);
-  fprintf(output, "--------------------------------\n");
-  fprintf(output, "Node table (Next, Prev, Value):\n");
-  i = this->edge;
-  fprintf(output, "    %zi: %zi, %zi, %zu\n", i, this->next[i], this->previous[i], this->values[i]);
-  foreach_linked_list_node((*this), i)
-    fprintf(output, "    %zi: %zi, %zi, %zu\n", i, this->next[i], this->previous[i], this->values[i]);
-  i = this->edge;
-  fprintf(output, "    %zi: %zi, %zi, %zu\n", i, this->next[i], this->previous[i], this->values[i]);
-  fprintf(output, "--------------------------------\n");
-  fprintf(output, "Raw node table:\n");
-  for (j = 0; j < this->end; j++)
-    fprintf(output, "    %zu: %zi, %zi, %zu\n", i, this->next[i], this->previous[i], this->values[i]);
-  fprintf(output, "--------------------------------\n");
-  fprintf(output, "Reuse stack:\n");
-  for (j = 0; j < this->reuse_head; j++)
-    fprintf(output, "    %zu: %zi\n", j, this->reusable[j]);
-  fprintf(output, "================================\n");
+	ssize_t i;
+	size_t j;
+	fprintf(output, "======= LINKED LIST DUMP =======\n");
+	fprintf(output, "Capacity:    %zu\n", this->capacity);
+	fprintf(output, "End:         %zu\n", this->end);
+	fprintf(output, "Reuse head:  %zu\n", this->reuse_head);
+	fprintf(output, "Edge:        %zi\n", this->edge);
+	fprintf(output, "--------------------------------\n");
+	fprintf(output, "Node table (Next, Prev, Value):\n");
+	i = this->edge;
+	fprintf(output, "    %zi: %zi, %zi, %zu\n", i, this->next[i], this->previous[i], this->values[i]);
+	foreach_linked_list_node((*this), i)
+		fprintf(output, "    %zi: %zi, %zi, %zu\n", i, this->next[i], this->previous[i], this->values[i]);
+	i = this->edge;
+	fprintf(output, "    %zi: %zi, %zi, %zu\n", i, this->next[i], this->previous[i], this->values[i]);
+	fprintf(output, "--------------------------------\n");
+	fprintf(output, "Raw node table:\n");
+	for (j = 0; j < this->end; j++)
+		fprintf(output, "    %zu: %zi, %zi, %zu\n", i, this->next[i], this->previous[i], this->values[i]);
+	fprintf(output, "--------------------------------\n");
+	fprintf(output, "Reuse stack:\n");
+	for (j = 0; j < this->reuse_head; j++)
+		fprintf(output, "    %zu: %zi\n", j, this->reusable[j]);
+	fprintf(output, "================================\n");
 }
-
diff --git a/src/libmdsserver/macros.h b/src/libmdsserver/macros.h
index d4d588c..45412b9 100644
--- a/src/libmdsserver/macros.h
+++ b/src/libmdsserver/macros.h
@@ -44,24 +44,22 @@
 
 /* CLOCK_MONOTONIC_RAW is a Linux-specific bug-fix */
 #ifndef CLOCK_MONOTONIC_RAW
-# define CLOCK_MONOTONIC_RAW  CLOCK_MONOTONIC
+# define CLOCK_MONOTONIC_RAW CLOCK_MONOTONIC
 #endif
 
 /* Define TEMP_FAILURE_RETRY if not defined, however
  * this version does not return a value, it will hoever
  * clear `errno` if no error occurs. */
 #ifndef TEMP_FAILURE_RETRY
-# define TEMP_FAILURE_RETRY(expression)			\
-  do							\
-    {							\
-      ssize_t __result;					\
-      do						\
-	__result = (ssize_t)(expression);		\
-      while ((__result < 0) && (errno == EINTR));	\
-      if (__result >= 0)				\
-	errno = 0;					\
-    }							\
-  while (0)
+# define TEMP_FAILURE_RETRY(expression)\
+	do {\
+		ssize_t __result;\
+		do\
+			__result = (ssize_t)(expression);\
+		while (__result < 0 && errno == EINTR);\
+		if (__result >= 0)\
+			errno = 0;\
+	} while (0)
 # define MDS_LIBMDSSERVER_MACROS_DEFINED_TEMP_FAILURE_RETRY
 #endif
 
@@ -118,16 +116,16 @@
  * @param   ...:const char*, ...  The format string and arguments
  * @return  :int                  Zero on success, -1 on error
  */
-#define xasprintf(VAR, ...)					\
-  (asprintf(&(VAR), __VA_ARGS__) < 0 ? (VAR = NULL, -1) : 0)
+#define xasprintf(VAR, ...)\
+	(asprintf(&(VAR), __VA_ARGS__) < 0 ? (VAR = NULL, -1) : 0)
 /*
-#define xasprintf(VAR, ...)								\
-  ({											\
-    int _x_rc = (asprintf(&(VAR), __VA_ARGS__) < 0 ? (VAR = NULL, -1) : 0);		\
-    fprintf(stderr, "xasprintf(%s, %s)(=%zu) @ %s:%i\n",				\
-	    #VAR, #__VA_ARGS__, _x_rc ? 0 : (strlen(VAR) + 1), __FILE__, __LINE__);	\
-    _x_rc;										\
-  })
+#define xasprintf(VAR, ...)\
+	({\
+		int _x_rc = (asprintf(&(VAR), __VA_ARGS__) < 0 ? (VAR = NULL, -1) : 0);\
+		fprintf(stderr, "xasprintf(%s, %s)(=%zu) @ %s:%i\n",\
+		        #VAR, #__VA_ARGS__, _x_rc ? 0 : (strlen(VAR) + 1), __FILE__, __LINE__);\
+		_x_rc;\
+	})
 */
 
 
@@ -138,8 +136,8 @@
  * @param   ...:const char*, ...  The format string and arguments
  * @return  :int                  The number of bytes written, including the NUL-termination, negative on error
  */
-#define xsnprintf(buffer, ...)  \
-  snprintf(buffer, sizeof(buffer) / sizeof(char), __VA_ARGS__)
+#define xsnprintf(buffer, ...)\
+	snprintf(buffer, sizeof(buffer) / sizeof(char), __VA_ARGS__)
 
 
 /**
@@ -149,8 +147,8 @@
  * @param   format:const char*  The format
  * @return  :int                The number of bytes written, including the NUL-termination, negative on error
  */
-#define eprint(format)  \
-  fprintf(stderr, "%s: " format "\n", *argv)
+#define eprint(format)\
+	fprintf(stderr, "%s: " format "\n", *argv)
 
 
 /**
@@ -161,8 +159,8 @@
  * @param   ...                 The arguments
  * @return  :int                The number of bytes written, including the NUL-termination, negative on error
  */
-#define eprintf(format, ...)  \
-  fprintf(stderr, "%s: " format "\n", *argv, __VA_ARGS__)
+#define eprintf(format, ...)\
+	fprintf(stderr, "%s: " format "\n", *argv, __VA_ARGS__)
 
 
 /**
@@ -174,8 +172,8 @@
  * @param   format:const char*  The format
  * @return  :int                The number of bytes written, including the NUL-termination, negative on error
  */
-#define iprint(format)  \
-  fprintf(stderr, "%s: info: " format "\n", *argv)
+#define iprint(format)\
+	fprintf(stderr, "%s: info: " format "\n", *argv)
 
 
 /**
@@ -188,8 +186,8 @@
  * @param   ...                 The arguments
  * @return  :int                The number of bytes written, including the NUL-termination, negative on error
  */
-#define iprintf(format, ...)  \
-  fprintf(stderr, "%s: info: " format "\n", *argv, __VA_ARGS__)
+#define iprintf(format, ...)\
+	fprintf(stderr, "%s: info: " format "\n", *argv, __VA_ARGS__)
 
 
 /**
@@ -198,18 +196,14 @@
  * @param  mutex:pthread_mutex_t  The mutex
  * @param  instructions           The instructions to run while the mutex is locked
  */
-#define with_mutex(mutex, instructions)		\
-  do						\
-    {						\
-      errno = pthread_mutex_lock(&(mutex));	\
-      do					\
-	{					\
-	  instructions ;			\
-	}					\
-      while (0);				\
-      errno = pthread_mutex_unlock(&(mutex));	\
-    }						\
-  while (0)
+#define with_mutex(mutex, instructions)\
+	do {\
+		errno = pthread_mutex_lock(&mutex);\
+		do {\
+			instructions;\
+		} while (0);\
+		errno = pthread_mutex_unlock(&mutex);\
+	} while (0)
 
 /**
  * Wrapper for `pthread_mutex_lock` and `pthread_mutex_unlock` with an embedded if-statement
@@ -218,19 +212,14 @@
  * @parma  condition              The condition to test
  * @param  instructions           The instructions to run while the mutex is locked
  */
-#define with_mutex_if(mutex, condition, instructions)	\
-  do							\
-    {							\
-      errno = pthread_mutex_lock(&(mutex));		\
-      if (condition)					\
-        do						\
-	  {						\
-	    instructions ;				\
-	  }						\
-        while (0);					\
-      errno = pthread_mutex_unlock(&(mutex));		\
-    }							\
-  while (0)
+#define with_mutex_if(mutex, condition, instructions)\
+	do {\
+		errno = pthread_mutex_lock(&mutex);\
+		if (condition) {\
+			instructions;\
+		}\
+		errno = pthread_mutex_unlock(&mutex);\
+	} while (0)
 
 
 /**
@@ -240,8 +229,8 @@
  * @param   b  The other one of the values
  * @return     The maximum value
  */
-#define max(a, b)  \
-  (a < b ? b : a)
+#define max(a, b)\
+	((a) < (b) ? (b) : (a))
 
 
 /**
@@ -251,8 +240,8 @@
  * @param   b  The other one of the values
  * @return     The minimum value
  */
-#define min(a, b)  \
-  (a < b ? a : b)
+#define min(a, b)\
+	((a) < (b) ? (a) : (b))
 
 
 /**
@@ -263,8 +252,8 @@
  * @param   index:size_t  The index of the element to address
  * @return  [type]        A slot that can be set or get
  */
-#define buf_cast(buffer, type, index)  \
-  (((type*)(buffer))[index])
+#define buf_cast(buffer, type, index)\
+	(((type *)(buffer))[index])
 
 
 /**
@@ -276,8 +265,8 @@
  * @param   variable:type  The new value of the element
  * @return  variable:      The new value of the element
  */
-#define buf_set(buffer, type, index, variable)	\
-  (((type*)(buffer))[index] = (variable))
+#define buf_set(buffer, type, index, variable)\
+	(((type *)(buffer))[index] = (variable))
 
 
 /**
@@ -289,8 +278,8 @@
  * @param   variable:type       Slot to set with the value of the element
  * @return  variable:           The value of the element
  */
-#define buf_get(buffer, type, index, variable)	\
-  (variable = ((const type*)(buffer))[index])
+#define buf_get(buffer, type, index, variable)\
+	(variable = ((const type*)(buffer))[index])
 
 
 /**
@@ -301,8 +290,8 @@
  * @param   count:size_t  The number elements of the data type `type` to increase the pointer with
  * @return  buffer:       The buffer
  */
-#define buf_next(buffer, type, count)  \
-  (buffer += (count) * sizeof(type) / sizeof(char))
+#define buf_next(buffer, type, count)\
+	(buffer += (count) * sizeof(type) / sizeof(char))
 
 
 /**
@@ -313,8 +302,8 @@
  * @param   count:size_t  The number elements of the data type `type` to decrease the pointer with
  * @return  buffer:       The buffer
  */
-#define buf_prev(buffer, type, count)  \
-  (buffer -= (count) * sizeof(type) / sizeof(char))
+#define buf_prev(buffer, type, count)\
+	(buffer -= (count) * sizeof(type) / sizeof(char))
 
 
 /**
@@ -326,9 +315,9 @@
  * @param   variable:type  The new value of the element
  * @return  variable:      The new value of the element
  */
-#define buf_set_next(buffer, type, variable)  \
-  (buf_set(buffer, type, 0, variable),        \
-   buf_next(buffer, type, 1))
+#define buf_set_next(buffer, type, variable)\
+	(buf_set(buffer, type, 0, variable),\
+	 buf_next(buffer, type, 1))
 
 
 /**
@@ -340,9 +329,9 @@
  * @param   variable:type  Slot to set with the value of the element
  * @return  variable:      The value of the element
  */
-#define buf_get_next(buffer, type, variable)  \
-  (buf_get(buffer, type, 0, variable),        \
-   buf_next(buffer, type, 1))
+#define buf_get_next(buffer, type, variable)\
+	(buf_get(buffer, type, 0, variable),\
+	 buf_next(buffer, type, 1))
 
 
 /**
@@ -352,8 +341,8 @@
  * @param   b:const char*  The other of the strings
  * @return  :int           Whether the strings are equal
  */
-#define strequals(a, b)  \
-  (strcmp(a, b) == 0)
+#define strequals(a, b)\
+	(!strcmp(a, b))
 
 
 /**
@@ -363,8 +352,8 @@
  * @param   needle:const char*    The string `haystack` should start with
  * @return  :int                  Whether `haystack` starts with `needle`
  */
-#define startswith(haystack, needle)  \
-  (strstr(haystack, needle) == haystack)
+#define startswith(haystack, needle)\
+	(strstr(haystack, needle) == haystack)
 
 
 /**
@@ -374,9 +363,9 @@
  * 
  * @return  :int  Non-zero on error
  */
-#define drop_privileges()                              \
-  ((getegid() == getgid() ? 0 : setegid(getgid())) ||  \
-   (geteuid() == getuid() ? 0 : seteuid(getuid())))
+#define drop_privileges()\
+	((getegid() == getgid() ? 0 : setegid(getgid())) ||\
+	 (geteuid() == getuid() ? 0 : seteuid(getuid())))
 
 
 /**
@@ -386,8 +375,8 @@
  * @param   time_slot:struct timespec*  Pointer to the variable in which to store the time
  * @return  :int                        Zero on success, -1 on error
  */
-#define monotone(time_slot)  \
-  clock_gettime(CLOCK_MONOTONIC_RAW, time_slot)
+#define monotone(time_slot)\
+	clock_gettime(CLOCK_MONOTONIC_RAW, time_slot)
 
 
 /**
@@ -397,15 +386,15 @@
  * @param  fd:int  The file descriptor
  */
 #if 1 /* For kernels that ensure that close(2) always closes valid file descriptors. */
-# define xclose(fd)  \
-  close(fd)
+# define xclose(fd)\
+	close(fd)
 #else /* For kernels that ensure that close(2) never closes valid file descriptors on interruption. */
 # ifdef MDS_LIBMDSSERVER_MACROS_DEFINED_TEMP_FAILURE_RETRY
-#  define xclose(fd)  \
-  TEMP_FAILURE_RETRY(close(fd))
+#  define xclose(fd)\
+	TEMP_FAILURE_RETRY(close(fd))
 # else
-#  define xclose(fd)  \
-  (TEMP_FAILURE_RETRY(close(fd)) < 0 ? 0 : (errno = 0))
+#  define xclose(fd)\
+	(TEMP_FAILURE_RETRY(close(fd)) < 0 ? 0 : (errno = 0))
 # endif
 #endif
 
@@ -417,15 +406,15 @@
  * @param  f:FILE*  The stream
  */
 #if 1 /* For kernels that ensure that close(2) always closes valid file descriptors. */
-# define xfclose(f)  \
-  fclose(f)
+# define xfclose(f)\
+	fclose(f)
 #else /* For kernels that ensure that close(2) never closes valid file descriptors on interruption. */
 # ifdef MDS_LIBMDSSERVER_MACROS_DEFINED_TEMP_FAILURE_RETRY
-#  define xfclose(f)  \
-  TEMP_FAILURE_RETRY(fclose(f))
+#  define xfclose(f)\
+	TEMP_FAILURE_RETRY(fclose(f))
 # else
-#  define xfclose(f)  \
-  (TEMP_FAILURE_RETRY(fclose(f)) < 0 ? 0 : (errno = 0))
+#  define xfclose(f)\
+	(TEMP_FAILURE_RETRY(fclose(f)) < 0 ? 0 : (errno = 0))
 # endif
 #endif
 
@@ -435,29 +424,27 @@
  * 
  * @param  condition  The condition, it should evaluate the variable `fd`
  */
-#define close_files(condition)									\
-  do												\
-    {												\
-      DIR* dir = opendir(SELF_FD);								\
-      struct dirent* file;									\
-												\
-      if (dir == NULL)										\
-	perror(*argv); /* Well, that is just unfortunate, but we cannot really do anything. */	\
-      else											\
-	{											\
-          int dfd = dirfd(dir);									\
-	  while ((file = readdir(dir)) != NULL)							\
-	    if (strcmp(file->d_name, ".") && strcmp(file->d_name, ".."))			\
-	      {											\
-		int fd = atoi(file->d_name);							\
-		if (fd != dfd)									\
-		  if (condition)								\
-		    xclose(fd);									\
-	      }											\
-	  closedir(dir);									\
-	}											\
-    }												\
-  while (0)
+#define close_files(condition)\
+	do {\
+		DIR *dir = opendir(SELF_FD);\
+		struct dirent *file;\
+		int dfd, fd;\
+		\
+		if (!dir) {\
+			perror(*argv); /* Well, that is just unfortunate, but we cannot really do anything. */\
+		} else {\
+			dfd = dirfd(dir);\
+			while ((file = readdir(dir))) {\
+				if (strcmp(file->d_name, ".") && strcmp(file->d_name, "..")) {\
+					fd = atoi(file->d_name);\
+					if (fd != dfd)\
+						if (condition)\
+							xclose(fd);\
+				}\
+			}\
+			closedir(dir);\
+		}\
+	} while (0)
 
 
 /**
@@ -467,14 +454,13 @@
  * @param  elements:size_t  The number of elements, in the array, to free
  * @scope  i:size_t         The variable `i` must be declared as `size_t` and avaiable for use
  */
-#define xfree(array, elements)		\
-  do					\
-    {					\
-      for (i = 0; i < (elements); i++)	\
-	free((array)[i]);		\
-      free(array), (array) = NULL;	\
-    }					\
-  while (0)
+#define xfree(array, elements)\
+	do {\
+		for (i = 0; i < (elements); i++)\
+			free((array)[i]);\
+		free(array);\
+		(array) = NULL;\
+	} while (0)
 
 
 /**
@@ -485,17 +471,17 @@
  * @param   type             The data type of the elements for which to create an allocation
  * @return  :int             Evaluates to true if an only if the allocation failed
  */
-#define xmalloc(var, elements, type)  \
-  ((var = malloc((elements) * sizeof(type))) == NULL)
+#define xmalloc(var, elements, type)\
+	(!(var = malloc((elements) * sizeof(type))))
 /*
-#define xmalloc(var, elements, type)					\
-  ({									\
-    size_t _x_elements = (elements);					\
-    size_t _x_size = _x_elements * sizeof(type);			\
-    fprintf(stderr, "xmalloc(%s, %zu, %s)(=%zu) @ %s:%i\n",		\
-	    #var, _x_elements, #type, _x_size, __FILE__, __LINE__);	\
-    ((var = malloc(_x_size)) == NULL);					\
-  })
+#define xmalloc(var, elements, type)\
+	({\
+		size_t _x_elements = (elements);\
+		size_t _x_size = _x_elements * sizeof(type);\
+		fprintf(stderr, "xmalloc(%s, %zu, %s)(=%zu) @ %s:%i\n",\
+		        #var, _x_elements, #type, _x_size, __FILE__, __LINE__);\
+		(!(var = malloc(_x_size)));\
+	})
 */
 
 
@@ -506,16 +492,16 @@
  * @param   bytes:size_t  The number of bytes to allocate
  * @return  :int          Evaluates to true if an only if the allocation failed
  */
-#define xbmalloc(var, bytes)  \
-  ((var = malloc(bytes)) == NULL)
+#define xbmalloc(var, bytes) \
+  (!(var = malloc(bytes)))
 /*
-#define xbmalloc(var, bytes)					\
-  ({								\
-    size_t _x_bytes = (bytes);					\
-    fprintf(stderr, "xbmalloc(%s, %zu) @ %s:%i\n",		\
-	    #var, _x_bytes, __FILE__, __LINE__);		\
-    ((var = malloc(_x_bytes)) == NULL);				\
-  })
+#define xbmalloc(var, bytes)\
+	({\
+		size_t _x_bytes = (bytes);\
+		fprintf(stderr, "xbmalloc(%s, %zu) @ %s:%i\n",\
+		        #var, _x_bytes, __FILE__, __LINE__);\
+		(!(var = malloc(_x_bytes)));\
+	})
 */
 
 
@@ -527,17 +513,17 @@
  * @param   type             The data type of the elements for which to create an allocation
  * @return  :int             Evaluates to true if an only if the allocation failed
  */
-#define xcalloc(var, elements, type)  \
-  ((var = calloc(elements, sizeof(type))) == NULL)
+#define xcalloc(var, elements, type)\
+	(!(var = calloc(elements, sizeof(type))))
 /*
-#define xcalloc(var, elements, type)					\
-  ({									\
-    size_t _x_elements = (elements);					\
-    size_t _x_size = _x_elements * sizeof(type);			\
-    fprintf(stderr, "xcalloc(%s, %zu, %s)(=%zu) @ %s:%i\n",		\
-	    #var, _x_elements, #type, _x_size, __FILE__, __LINE__);	\
-    ((var = calloc(_x_elements, sizeof(type))) == NULL);		\
-  })
+#define xcalloc(var, elements, type)\
+	({\
+		size_t _x_elements = (elements);\
+		size_t _x_size = _x_elements * sizeof(type);\
+		fprintf(stderr, "xcalloc(%s, %zu, %s)(=%zu) @ %s:%i\n",\
+		        #var, _x_elements, #type, _x_size, __FILE__, __LINE__);\
+		(!(var = calloc(_x_elements, sizeof(type))));\
+	})
 */
 
 
@@ -548,16 +534,16 @@
  * @param   bytes:size_t  The number of bytes to allocate
  * @return  :int          Evaluates to true if an only if the allocation failed
  */
-#define xbcalloc(var, bytes)  \
-  ((var = calloc(bytes, sizeof(char))) == NULL)
+#define xbcalloc(var, bytes)\
+	(!(var = calloc(bytes, sizeof(char))))
 /*
-#define xbcalloc(var, bytes)					\
-  ({								\
-    size_t _x_bytes = (bytes);					\
-    fprintf(stderr, "xbcalloc(%s, %zu) @ %s:%i\n",		\
-	    #var, _x_bytes, __FILE__, __LINE__);		\
-    ((var = calloc(_x_bytes, sizeof(char))) == NULL);		\
-  })
+#define xbcalloc(var, bytes)\
+	({\
+		size_t _x_bytes = (bytes);\
+		fprintf(stderr, "xbcalloc(%s, %zu) @ %s:%i\n",\
+			#var, _x_bytes, __FILE__, __LINE__);\
+		(!(var = calloc(_x_bytes, sizeof(char))));\
+	})
 */
 
 
@@ -570,16 +556,16 @@
  * @return  :int             Evaluates to true if an only if the allocation failed
  */
 #define xrealloc(var, elements, type)  \
-  ((var = realloc(var, (elements) * sizeof(type))) == NULL)
+	(!(var = realloc(var, (elements) * sizeof(type))))
 /*
-#define xrealloc(var, elements, type)					\
-  ({									\
-    size_t _x_elements = (elements);					\
-    size_t _x_size = _x_elements * sizeof(type);			\
-    fprintf(stderr, "xrealloc(%s, %zu, %s)(=%zu) @ %s:%i\n",		\
-	    #var, _x_elements, #type, _x_size, __FILE__, __LINE__);	\
-    ((var = realloc(var, _x_size)) == NULL);				\
-  })
+#define xrealloc(var, elements, type)\
+	({\
+		size_t _x_elements = (elements);\
+		size_t _x_size = _x_elements * sizeof(type);\
+		fprintf(stderr, "xrealloc(%s, %zu, %s)(=%zu) @ %s:%i\n",\
+		        #var, _x_elements, #type, _x_size, __FILE__, __LINE__);\
+		(!(var = realloc(var, _x_size)));\
+	})
 */
 
 
@@ -593,17 +579,17 @@
  * @param   type             The data type of the elements for which to create an allocation
  * @return  :int             Evaluates to true if an only if the allocation failed
  */
-#define xxrealloc(old, var, elements, type)  \
-  (old = var, (((var = realloc(var, (elements) * sizeof(type))) == NULL) ? 1 : (old = NULL, 0)))
+#define xxrealloc(old, var, elements, type)\
+	(old = var, ((!(var = realloc(var, (elements) * sizeof(type)))) ? 1 : (old = NULL, 0)))
 /*
-#define xxrealloc(old, var, elements, type)						\
-  ({											\
-    size_t _x_elements = (elements);							\
-    size_t _x_size = _x_elements * sizeof(type);					\
-    fprintf(stderr, "xxrealloc(%s, %s, %zu, %s)(=%zu) @ %s:%i\n",			\
-	    #old, #var, _x_elements, #type, _x_size, __FILE__, __LINE__);		\
-    (old = var, (((var = realloc(var, _x_size)) == NULL) ? 1 : (old = NULL, 0)));	\
-  })
+#define xxrealloc(old, var, elements, type)\
+	({\
+		size_t _x_elements = (elements);\
+		size_t _x_size = _x_elements * sizeof(type);\
+		fprintf(stderr, "xxrealloc(%s, %s, %zu, %s)(=%zu) @ %s:%i\n",\
+			#old, #var, _x_elements, #type, _x_size, __FILE__, __LINE__);\
+		(old = var, ((!(var = realloc(var, _x_size))) ? 1 : (old = NULL, 0)));\
+	})
 */
 
 
@@ -616,19 +602,19 @@
  * @param   type             The data type of the elements for which to create an allocation
  * @return  :int             Evaluates to true if an only if the allocation failed
  */
-#define yrealloc(tmp, var, elements, type)                               \
-  ((tmp = var, (var = realloc(var, (elements) * sizeof(type))) == NULL)  \
-   ? (var = tmp, tmp = NULL, 1) : (tmp = NULL, 0))
+#define yrealloc(tmp, var, elements, type)\
+	((tmp = var, !(var = realloc(var, (elements) * sizeof(type))))\
+	 ? (var = tmp, tmp = NULL, 1) : (tmp = NULL, 0))
 /*
-#define yrealloc(tmp, var, elements, type)					\
-  ({										\
-    size_t _x_elements = (elements);						\
-    size_t _x_size = _x_elements * sizeof(type);				\
-    fprintf(stderr, "yrealloc(%s, %s, %zu, %s)(=%zu) @ %s:%i\n",		\
-	    #tmp, #var, _x_elements, #type, _x_size, __FILE__, __LINE__);	\
-    ((tmp = var, (var = realloc(var, _x_size)) == NULL)				\
-     ? (var = tmp, tmp = NULL, 1) : (tmp = NULL, 0));				\
-  })
+#define yrealloc(tmp, var, elements, type)\
+	({\
+		size_t _x_elements = (elements);\
+		size_t _x_size = _x_elements * sizeof(type);\
+		fprintf(stderr, "yrealloc(%s, %s, %zu, %s)(=%zu) @ %s:%i\n",\
+		        #tmp, #var, _x_elements, #type, _x_size, __FILE__, __LINE__);\
+		((tmp = var, !(var = realloc(var, _x_size)))\
+		? (var = tmp, tmp = NULL, 1) : (tmp = NULL, 0));\
+	})
 */
 
 
@@ -641,17 +627,17 @@
  * @param   type             The data type of the elements for which to create an allocation
  * @return  :int             Evaluates to true if an only if the allocation failed
  */
-#define growalloc(old, var, elements, type)  \
-  (old = var, xrealloc(var, (elements) <<= 1, type) ? (var = old, (elements) >>= 1, 1) : 0)
+#define growalloc(old, var, elements, type) \
+	(old = var, xrealloc(var, (elements) <<= 1, type) ? (var = old, (elements) >>= 1, 1) : 0)
 /*
-#define growalloc(old, var, elements, type)							\
-  ({												\
-    size_t _x_elements_ = (elements);								\
-    size_t _x_size_ = _x_elements_ * sizeof(type);						\
-    fprintf(stderr, "growalloc(%s, %s, %zu, %s)(=%zu)\n-->  ",					\
-	    #old, #var, _x_elements_, #type, _x_size_, __FILE__, __LINE__); 			\
-    (old = var, xrealloc(var, (elements) <<= 1, type) ? (var = old, (elements) >>= 1, 1) : 0);	\
-  })
+#define growalloc(old, var, elements, type)\
+	({\
+		size_t _x_elements_ = (elements);\
+		size_t _x_size_ = _x_elements_ * sizeof(type);\
+		fprintf(stderr, "growalloc(%s, %s, %zu, %s)(=%zu)\n-->  ",\
+		        #old, #var, _x_elements_, #type, _x_size_, __FILE__, __LINE__);\
+		(old = var, xrealloc(var, (elements) <<= 1, type) ? (var = old, (elements) >>= 1, 1) : 0);\
+	})
 */
 
 
@@ -662,16 +648,16 @@
  * @param   original:const char*  The string to duplicate, may be `NULL`
  * @return  :int                  Evaluates to true if an only if the allocation failed
  */
-#define xstrdup(var, original)  \
-  (original ? ((var = strdup(original)) == NULL) : (var = NULL, 0))
+#define xstrdup(var, original)\
+	(original ? !(var = strdup(original)) : (var = NULL, 0))
 /*
-#define xstrdup(var, original)									\
-  ({												\
-    size_t _x_size = original ? strlen(original) : 0;						\
-    fprintf(stderr, "xstrdup(%s, %s(“%s”=%zu))(=%zu) @ %s:%i\n",				\
-	    #var, #original, original, _x_size, _x_size + !!_x_size, __FILE__, __LINE__); 	\
-    (original ? ((var = strdup(original)) == NULL) : (var = NULL, 0));				\
-  })
+#define xstrdup(var, original)\
+	({\
+		size_t _x_size = original ? strlen(original) : 0;\
+		fprintf(stderr, "xstrdup(%s, %s(“%s”=%zu))(=%zu) @ %s:%i\n",\
+		        #var, #original, original, _x_size, _x_size + !!_x_size, __FILE__, __LINE__);\
+		(original ? ((var = strdup(original)) == NULL) : (var = NULL, 0));\
+	})
 */
 
 
@@ -685,16 +671,16 @@
  * @param   original:const char*  The string to duplicate, must not be `NULL`
  * @return  :int                  Evaluates to true if an only if the allocation failed
  */
-#define xstrdup_nn(var, original)  \
-  ((var = strdup(original)) == NULL)
+#define xstrdup_nn(var, original)\
+	(!(var = strdup(original)))
 /*
-#define xstrdup_nn(var, original)								\
-  ({												\
-    size_t _x_size = strlen(original);								\
-    fprintf(stderr, "xstrdup_nn(%s, %s(“%s”=%zu))(=%zu) @ %s:%i\n",				\
-	    #var, #original, original, _x_size, _x_size + !!_x_size, __FILE__, __LINE__); 	\
-    (var = strdup(original)) == NULL;								\
-  })
+#define xstrdup_nn(var, original)\
+	({\
+		size_t _x_size = strlen(original);\
+		fprintf(stderr, "xstrdup_nn(%s, %s(“%s”=%zu))(=%zu) @ %s:%i\n",\
+		        #var, #original, original, _x_size, _x_size + !!_x_size, __FILE__, __LINE__);\
+		!(var = strdup(original));\
+	})
 */
 
 
@@ -708,18 +694,18 @@
  * @param   type                  The data type of the elements to duplicate
  * @return  :int                  Evaluates to true if an only if the allocation failed
  */
-#define xmemdup(var, original, elements, type)	              \
-  (((var = malloc((elements) * sizeof(type))) == NULL) ? 1 :  \
-   (memcpy(var, original, (elements) * sizeof(type)), 0))
+#define xmemdup(var, original, elements, type)\
+	(!(var = malloc((elements) * sizeof(type))) ? 1 :\
+	 (memcpy(var, original, (elements) * sizeof(type)), 0))
 /*
-#define xmemdup(var, original, elements, type)						\
-  ({											\
-    size_t _x_elements = (elements);							\
-    size_t _x_size = _x_elements * sizeof(type);					\
-    fprintf(stderr, "xmemdup(%s, %s, %zu, %s)(=%zu) @ %s:%i\n",				\
-	    #var, #original, _x_elements, #type, _x_size, __FILE__, __LINE__);		\
-    (((var = malloc(_x_size)) == NULL) ? 1 : (memcpy(var, original, _x_size), 0));	\
-  })
+#define xmemdup(var, original, elements, type)\
+	({\
+		size_t _x_elements = (elements);\
+		size_t _x_size = _x_elements * sizeof(type);\
+		fprintf(stderr, "xmemdup(%s, %s, %zu, %s)(=%zu) @ %s:%i\n",\
+		        #var, #original, _x_elements, #type, _x_size, __FILE__, __LINE__);\
+		!(var = malloc(_x_size)) ? 1 : (memcpy(var, original, _x_size), 0);\
+	})
 */
 
 
diff --git a/src/libmdsserver/mds-message.c b/src/libmdsserver/mds-message.c
index 4ec8142..c3d968f 100644
--- a/src/libmdsserver/mds-message.c
+++ b/src/libmdsserver/mds-message.c
@@ -27,7 +27,7 @@
 #include <sys/socket.h>
 
 
-#define try(INSTRUCTION)   if ((r = INSTRUCTION) < 0)  return r
+#define try(INSTRUCTION) do { if ((r = INSTRUCTION) < 0) return r; } while (0)
 
 
 /**
@@ -38,20 +38,21 @@
  * @return        Non-zero on error, `errno` will be set accordingly.
  *                Destroy the message on error.
  */
-int mds_message_initialise(mds_message_t* restrict this)
+int
+mds_message_initialise(mds_message_t *restrict this)
 {
-  this->headers = NULL;
-  this->header_count = 0;
-  this->payload = NULL;
-  this->payload_size = 0;
-  this->payload_ptr = 0;
-  this->buffer_size = 128;
-  this->buffer_ptr = 0;
-  this->stage = 0;
-  fail_if (xmalloc(this->buffer, this->buffer_size, char));
-  return 0;
- fail:
-  return -1;
+	this->headers = NULL;
+	this->header_count = 0;
+	this->payload = NULL;
+	this->payload_size = 0;
+	this->payload_ptr = 0;
+	this->buffer_size = 128;
+	this->buffer_ptr = 0;
+	this->stage = 0;
+	fail_if (xmalloc(this->buffer, this->buffer_size, char));
+	return 0;
+fail:
+	return -1;
 }
 
 
@@ -60,17 +61,18 @@ int mds_message_initialise(mds_message_t* restrict this)
  * 
  * @param  this  Memory slot in which to store the new message
  */
-void mds_message_zero_initialise(mds_message_t* restrict this)
+void
+mds_message_zero_initialise(mds_message_t *restrict this)
 {
-  this->headers = NULL;
-  this->header_count = 0;
-  this->payload = NULL;
-  this->payload_size = 0;
-  this->payload_ptr = 0;
-  this->buffer = NULL;
-  this->buffer_size = 0;
-  this->buffer_ptr = 0;
-  this->stage = 0;
+	this->headers = NULL;
+	this->header_count = 0;
+	this->payload = NULL;
+	this->payload_size = 0;
+	this->payload_ptr = 0;
+	this->buffer = NULL;
+	this->buffer_size = 0;
+	this->buffer_ptr = 0;
+	this->stage = 0;
 }
 
 
@@ -80,14 +82,15 @@ void mds_message_zero_initialise(mds_message_t* restrict this)
  * 
  * @param  this  The message
  */
-void mds_message_destroy(mds_message_t* restrict this)
+void
+mds_message_destroy(mds_message_t *restrict this)
 {
-  size_t i;
-  if (this->headers != NULL)
-    xfree(this->headers, this->header_count);
-  
-  free(this->payload), this->payload = NULL;
-  free(this->buffer),  this->buffer  = NULL;
+	size_t i;
+	if (this->headers)
+		xfree(this->headers, this->header_count);
+
+	free(this->payload), this->payload = NULL;
+	free(this->buffer),  this->buffer  = NULL;
 }
 
 
@@ -98,14 +101,15 @@ void mds_message_destroy(mds_message_t* restrict this)
  * @param   extent  The number of additional entries
  * @return          Zero on success, -1 on error
  */
-int mds_message_extend_headers(mds_message_t* restrict this, size_t extent)
+int
+mds_message_extend_headers(mds_message_t *restrict this, size_t extent)
 {
-  char** new_headers = this->headers;
-  fail_if (xrealloc(new_headers, this->header_count + extent, char*));
-  this->headers = new_headers;
-  return 0;
- fail:
-  return -1;
+	char **new_headers = this->headers;
+	fail_if (xrealloc(new_headers, this->header_count + extent, char*));
+	this->headers = new_headers;
+	return 0;
+fail:
+	return -1;
 }
 
 
@@ -115,16 +119,16 @@ int mds_message_extend_headers(mds_message_t* restrict this, size_t extent)
  * @param   this  The message
  * @return        Zero on success, -1 on error
  */
-__attribute__((nonnull))
-static int mds_message_extend_buffer(mds_message_t* restrict this)
+static int __attribute__((nonnull))
+mds_message_extend_buffer(mds_message_t *restrict this)
 {
-  char* new_buf = this->buffer;
-  fail_if (xrealloc(new_buf, this->buffer_size << 1, char));
-  this->buffer = new_buf;
-  this->buffer_size <<= 1;
-  return 0;
- fail:
-  return -1;
+	char *new_buf = this->buffer;
+	fail_if (xrealloc(new_buf, this->buffer_size << 1, char));
+	this->buffer = new_buf;
+	this->buffer_size <<= 1;
+	return 0;
+fail:
+	return -1;
 }
 
 
@@ -133,18 +137,18 @@ static int mds_message_extend_buffer(mds_message_t* restrict this)
  * 
  * @param  this  The message
  */
-__attribute__((nonnull))
-static void reset_message(mds_message_t* restrict this)
+static void __attribute__((nonnull))
+reset_message(mds_message_t *restrict this)
 {
-  size_t i;
-  if (this->headers != NULL)
-    xfree(this->headers, this->header_count);
-  this->header_count = 0;
-  
-  free(this->payload);
-  this->payload = NULL;
-  this->payload_size = 0;
-  this->payload_ptr = 0;
+	size_t i;
+	if (this->headers)
+		xfree(this->headers, this->header_count);
+	this->header_count = 0;
+
+	free(this->payload);
+	this->payload = NULL;
+	this->payload_size = 0;
+	this->payload_ptr = 0;
 }
 
 
@@ -154,29 +158,29 @@ static void reset_message(mds_message_t* restrict this)
  * @param   this  The message
  * @return        Zero on success, negative on error (malformated message: unrecoverable state)
  */
-__attribute__((pure, nonnull))
-static int get_payload_length(mds_message_t* restrict this)
+static int __attribute__((pure, nonnull))
+get_payload_length(mds_message_t *restrict this)
 {
-  char* header;
-  size_t i;
-  
-  for (i = 0; i < this->header_count; i++)
-    if (strstr(this->headers[i], "Length: ") == this->headers[i])
-      {
-	/* Store the message length. */
-	header = this->headers[i] + strlen("Length: ");
-	this->payload_size = atoz(header);
-	
-	/* Do not except a length that is not correctly formated. */
-	for (; *header; header++)
-	  if ((*header < '0') || ('9' < *header))
-	    return -2; /* Malformated value, enters unrecoverable state. */
-	
-	/* Stop searching for the ‘Length’ header, we have found and parsed it. */
-	break;
-      }
-  
-  return 0;
+	char *header;
+	size_t i;
+  
+	for (i = 0; i < this->header_count; i++) {
+		if (strstr(this->headers[i], "Length: ") == this->headers[i]) {
+			/* Store the message length. */
+			header = this->headers[i] + strlen("Length: ");
+			this->payload_size = atoz(header);
+
+			/* Do not except a length that is not correctly formated. */
+			for (; *header; header++)
+				if (*header < '0' || '9' < *header)
+					return -2; /* Malformated value, enters unrecoverable state. */
+
+			/* Stop searching for the ‘Length’ header, we have found and parsed it. */
+			break;
+		}
+	}
+
+	return 0;
 }
 
 
@@ -187,21 +191,21 @@ static int get_payload_length(mds_message_t* restrict this)
  * @param   length  The length of the header
  * @return          Zero if valid, negative if invalid (malformated message: unrecoverable state)
  */
-__attribute__((pure, nonnull))
-static int validate_header(const char* header, size_t length)
+static int __attribute__((pure, nonnull))
+validate_header(const char *header, size_t length)
 {
-  char* p = memchr(header, ':', length * sizeof(char));
-  
-  if (verify_utf8(header, 0) < 0)
-    /* Either the string is not UTF-8, or your are under an UTF-8 attack,
-       let's just call this unrecoverable because the client will not correct. */
-    return -2;
-  
-  if ((p == NULL) || /* Buck you, rawmemchr should not segfault the program. */
-      (p[1] != ' ')) /* Also an invalid format. ' ' is mandated after the ':'. */
-    return -2;
-  
-  return 0;
+	char *p = memchr(header, ':', length * sizeof(char));
+
+	if (verify_utf8(header, 0) < 0)
+		/* Either the string is not UTF-8, or your are under an UTF-8 attack,
+		   let's just call this unrecoverable because the client will not correct. */
+		return -2;
+
+	if (!p ||         /* Buck you, rawmemchr should not segfault the program. */
+	    p[1] != ' ')  /* Also an invalid format. ' ' is mandated after the ':'. */
+		return -2;
+
+	return 0;
 }
 
 
@@ -212,12 +216,12 @@ static int validate_header(const char* header, size_t length)
  * @param  length      The number of characters to remove  
  * @param  update_ptr  Whether to update the buffer pointer
  */
-__attribute__((nonnull))
-static void unbuffer_beginning(mds_message_t* restrict this, size_t length, int update_ptr)
+static void __attribute__((nonnull))
+unbuffer_beginning(mds_message_t *restrict this, size_t length, int update_ptr)
 {
-  memmove(this->buffer, this->buffer + length, (this->buffer_ptr - length) * sizeof(char));
-  if (update_ptr)
-    this->buffer_ptr -= length;
+	memmove(this->buffer, this->buffer + length, (this->buffer_ptr - length) * sizeof(char));
+	if (update_ptr)
+		this->buffer_ptr -= length;
 }
 
 
@@ -228,23 +232,23 @@ static void unbuffer_beginning(mds_message_t* restrict this, size_t length, int
  * @param   this  The message
  * @return        The return value follows the rules of `mds_message_read`
  */
-__attribute__((nonnull))
-static int initialise_payload(mds_message_t* restrict this)
+static int __attribute__((nonnull))
+initialise_payload(mds_message_t *restrict this)
 {
-  /* Remove the \n (end of empty line) we found from the buffer. */
-  unbuffer_beginning(this, 1, 1);
-  
-  /* Get the length of the payload. */
-  if (get_payload_length(this) < 0)
-    return -2; /* Malformated value, enters unrecoverable state. */
-  
-  /* Allocate the payload buffer. */
-  if (this->payload_size > 0)
-    fail_if (xmalloc(this->payload, this->payload_size, char));
-  
-  return 0;
- fail:
-  return -1;
+	/* Remove the \n (end of empty line) we found from the buffer. */
+	unbuffer_beginning(this, 1, 1);
+
+	/* Get the length of the payload. */
+	if (get_payload_length(this) < 0)
+		return -2; /* Malformated value, enters unrecoverable state. */
+
+	/* Allocate the payload buffer. */
+	if (this->payload_size > 0)
+		fail_if (xmalloc(this->payload, this->payload_size, char));
+
+	return 0;
+fail:
+	return -1;
 }
 
 
@@ -255,35 +259,34 @@ static int initialise_payload(mds_message_t* restrict this)
  * @param   length  The length of the header, including LF-termination
  * @return          The return value follows the rules of `mds_message_read`
  */
-__attribute__((nonnull))
-static int store_header(mds_message_t* restrict this, size_t length)
+static int __attribute__((nonnull))
+store_header(mds_message_t *restrict this, size_t length)
 {
-  char* header;
-  
-  /* Allocate the header. */
-  fail_if (xmalloc(header, length, char)); /* Last char is a LF, which is substituted with NUL. */
-  /* Copy the header data into the allocated header, */
-  memcpy(header, this->buffer, length * sizeof(char));
-  /* and NUL-terminate it. */
-  header[length - 1] = '\0';
-  
-  /* Remove the header data from the read buffer. */
-  unbuffer_beginning(this, length, 1);
-  
-  /* Make sure the the header syntax is correct so that
-     the program does not need to care about it. */
-  if (validate_header(header, length))
-    {
-      free(header);
-      return -2;
-    }
-  
-  /* Store the header in the header list. */
-  this->headers[this->header_count++] = header;
-  
-  return 0;
- fail:
-  return -1;
+	char *header;
+
+	/* Allocate the header. */
+	fail_if (xmalloc(header, length, char)); /* Last char is a LF, which is substituted with NUL. */
+	/* Copy the header data into the allocated header, */
+	memcpy(header, this->buffer, length * sizeof(char));
+	/* and NUL-terminate it. */
+	header[length - 1] = '\0';
+
+	/* Remove the header data from the read buffer. */
+	unbuffer_beginning(this, length, 1);
+
+	/* Make sure the the header syntax is correct so that
+	   the program does not need to care about it. */
+	if (validate_header(header, length)) {
+		free(header);
+		return -2;
+	}
+
+	/* Store the header in the header list. */
+	this->headers[this->header_count++] = header;
+
+	return 0;
+fail:
+	return -1;
 }
 
 
@@ -294,37 +297,36 @@ static int store_header(mds_message_t* restrict this, size_t length)
  * @param   fd    The file descriptor of the socket
  * @return        The return value follows the rules of `mds_message_read`
  */
-__attribute__((nonnull))
-static int continue_read(mds_message_t* restrict this, int fd)
+static int __attribute__((nonnull))
+continue_read(mds_message_t *restrict this, int fd)
 {
-  size_t n;
-  ssize_t got;
-  int r;
-  
-  /* Figure out how much space we have left in the read buffer. */
-  n = this->buffer_size - this->buffer_ptr;
-  
-  /* If we do not have too much left, */
-  if (n < 128)
-    {
-      /* grow the buffer, */
-      try (mds_message_extend_buffer(this));
-      
-      /* and recalculate how much space we have left. */
-      n = this->buffer_size - this->buffer_ptr;
-    }
-  
-  /* Then read from the socket. */
-  errno = 0;
-  got = recv(fd, this->buffer + this->buffer_ptr, n, 0);
-  this->buffer_ptr += (size_t)(got < 0 ? 0 : got);
-  fail_if (errno);
-  if (got == 0)
-    fail_if ((errno = ECONNRESET));
-  
-  return 0;
- fail:
-  return -1;
+	size_t n;
+	ssize_t got;
+	int r;
+
+	/* Figure out how much space we have left in the read buffer. */
+	n = this->buffer_size - this->buffer_ptr;
+
+	/* If we do not have too much left, */
+	if (n < 128) {
+		/* grow the buffer, */
+		try (mds_message_extend_buffer(this));
+
+		/* and recalculate how much space we have left. */
+		n = this->buffer_size - this->buffer_ptr;
+	}
+
+	/* Then read from the socket. */
+	errno = 0;
+	got = recv(fd, this->buffer + this->buffer_ptr, n, 0);
+	this->buffer_ptr += (size_t)(got < 0 ? 0 : got);
+	fail_if (errno);
+	if (!got)
+		fail_if ((errno = ECONNRESET));
+
+	return 0;
+fail:
+	return -1;
 }
 
 
@@ -341,86 +343,78 @@ static int continue_read(mds_message_t* restrict this, int fd)
  *                -2 indicates that the message is malformated,
  *                which is a state that cannot be recovered from.
  */
-int mds_message_read(mds_message_t* restrict this, int fd)
+int
+mds_message_read(mds_message_t *restrict this, int fd)
 {
-  size_t header_commit_buffer = 0;
-  int r;
-  
-  /* If we are at stage 2, we are done and it is time to start over.
-     This is important because the function could have been interrupted. */
-  if (this->stage == 2)
-    {
-      reset_message(this);
-      this->stage = 0;
-    }
-  
-  /* Read from file descriptor until we have a full message. */
-  for (;;)
-    {
-      char* p;
-      size_t length;
-      
-      /* Stage 0: headers. */
-      /* Read all headers that we have stored into the read buffer. */
-      while ((this->stage == 0) &&
-	     ((p = memchr(this->buffer, '\n', this->buffer_ptr * sizeof(char))) != NULL))
-	if ((length = (size_t)(p - this->buffer)))
-	  {
-	    /* We have found a header. */
-	    
-	    /* On every eighth header found with this function call,
-	       we prepare the header list for eight more headers so
-	       that it does not need to be reallocated again and again. */
-	    if (header_commit_buffer == 0)
-	      try (mds_message_extend_headers(this, header_commit_buffer = 8));
-	    
-	    /* Create and store header. */
-	    try (store_header(this, length + 1));
-	    header_commit_buffer -= 1;
-	  }
-	else
-	  {
-	    /* We have found an empty line, i.e. the end of the headers. */
-	    
-	    /* Remove the header–payload delimiter from the buffer,
-	       get the payload's size and allocate the payload. */
-	    try (initialise_payload(this));
-	    
-	    /* Mark end of stage, next stage is getting the payload. */
-	    this->stage = 1;
-	  }
-      
-      
-      /* Stage 1: payload. */
-      if ((this->stage == 1) && (this->payload_size > 0))
-	{
-	  /* How much of the payload that has not yet been filled. */
-	  size_t need = this->payload_size - this->payload_ptr;
-	  /* How much we have of that what is needed. */
-	  size_t move = min(this->buffer_ptr, need);
-	  
-	  /* Copy what we have, and remove it from the the read buffer. */
-	  memcpy(this->payload + this->payload_ptr, this->buffer, move * sizeof(char));
-	  unbuffer_beginning(this, move, 1);
-	  
-	  /* Keep track of how much we have read. */
-	  this->payload_ptr += move;
+	size_t header_commit_buffer = 0, length, need, move;
+	int r;
+	char *p;
+
+	/* If we are at stage 2, we are done and it is time to start over.
+	   This is important because the function could have been interrupted. */
+	if (this->stage == 2) {
+		reset_message(this);
+		this->stage = 0;
 	}
-      if ((this->stage == 1) && (this->payload_ptr == this->payload_size))
-	{
-	  /* If we have filled the payload (or there was no payload),
-	     mark the end of this stage, i.e. that the message is
-	     complete, and return with success. */
-	  this->stage = 2;
-	  return 0;
+
+	/* Read from file descriptor until we have a full message. */
+	for (;;) {
+		/* Stage 0: headers. */
+		/* Read all headers that we have stored into the read buffer. */
+		while (!this->stage && ((p = memchr(this->buffer, '\n', this->buffer_ptr * sizeof(char))))) {
+			if ((length = (size_t)(p - this->buffer))) {
+				/* We have found a header. */
+
+				/* On every eighth header found with this function call,
+				   we prepare the header list for eight more headers so
+				   that it does not need to be reallocated again and again. */
+				if (!header_commit_buffer)
+					try (mds_message_extend_headers(this, header_commit_buffer = 8));
+
+				/* Create and store header. */
+				try (store_header(this, length + 1));
+				header_commit_buffer -= 1;
+			} else {
+				/* We have found an empty line, i.e. the end of the headers. */
+
+				/* Remove the header–payload delimiter from the buffer,
+				   get the payload's size and allocate the payload. */
+				try (initialise_payload(this));
+
+				/* Mark end of stage, next stage is getting the payload. */
+				this->stage = 1;
+			}
+		}
+
+
+		/* Stage 1: payload. */
+		if (this->stage == 1 && this->payload_size > 0) {
+			/* How much of the payload that has not yet been filled. */
+			need = this->payload_size - this->payload_ptr;
+			/* How much we have of that what is needed. */
+			move = min(this->buffer_ptr, need);
+
+			/* Copy what we have, and remove it from the the read buffer. */
+			memcpy(this->payload + this->payload_ptr, this->buffer, move * sizeof(char));
+			unbuffer_beginning(this, move, 1);
+
+			/* Keep track of how much we have read. */
+			this->payload_ptr += move;
+		}
+		if (this->stage == 1 && this->payload_ptr == this->payload_size) {
+			/* If we have filled the payload (or there was no payload),
+			   mark the end of this stage, i.e. that the message is
+			   complete, and return with success. */
+			this->stage = 2;
+			return 0;
+		}
+
+
+		/* If stage 1 was not completed. */
+
+		/* Continue reading from the socket into the buffer. */
+		try (continue_read(this, fd));
 	}
-      
-      
-      /* If stage 1 was not completed. */
-      
-      /* Continue reading from the socket into the buffer. */
-      try (continue_read(this, fd));
-    }
 }
 
 
@@ -431,15 +425,15 @@ int mds_message_read(mds_message_t* restrict this, int fd)
  * @param   this  The message
  * @return        The size of the message when marshalled
  */
-size_t mds_message_marshal_size(const mds_message_t* restrict this)
+size_t
+mds_message_marshal_size(const mds_message_t *restrict this)
 {
-  size_t rc = this->header_count + this->payload_size;
-  size_t i;
-  for (i = 0; i < this->header_count; i++)
-    rc += strlen(this->headers[i]);
-  rc *= sizeof(char);
-  rc += 4 * sizeof(size_t) + 2 * sizeof(int);
-  return rc;
+	size_t i, rc = this->header_count + this->payload_size;
+	for (i = 0; i < this->header_count; i++)
+		rc += strlen(this->headers[i]);
+	rc *= sizeof(char);
+	rc += 4 * sizeof(size_t) + 2 * sizeof(int);
+	return rc;
 }
 
 
@@ -449,29 +443,29 @@ size_t mds_message_marshal_size(const mds_message_t* restrict this)
  * @param  this  The message
  * @param  data  Output buffer for the marshalled data
  */
-void mds_message_marshal(const mds_message_t* restrict this, char* restrict data)
+void
+mds_message_marshal(const mds_message_t *restrict this, char *restrict data)
 {
-  size_t i, n;
-  
-  buf_set_next(data, int, MDS_MESSAGE_T_VERSION);
-  
-  buf_set_next(data, size_t, this->header_count);
-  buf_set_next(data, size_t, this->payload_size);
-  buf_set_next(data, size_t, this->payload_ptr);
-  buf_set_next(data, size_t, this->buffer_ptr);
-  buf_set_next(data, int, this->stage);
-  
-  for (i = 0; i < this->header_count; i++)
-    {
-      n = strlen(this->headers[i]) + 1;
-      memcpy(data, this->headers[i], n * sizeof(char));
-      buf_next(data, char, n);
-    }
-  
-  memcpy(data, this->payload, this->payload_ptr * sizeof(char));
-  buf_next(data, char, this->payload_ptr);
-  
-  memcpy(data, this->buffer, this->buffer_ptr * sizeof(char));
+	size_t i, n;
+
+	buf_set_next(data, int, MDS_MESSAGE_T_VERSION);
+
+	buf_set_next(data, size_t, this->header_count);
+	buf_set_next(data, size_t, this->payload_size);
+	buf_set_next(data, size_t, this->payload_ptr);
+	buf_set_next(data, size_t, this->buffer_ptr);
+	buf_set_next(data, int, this->stage);
+
+	for (i = 0; i < this->header_count; i++) {
+		n = strlen(this->headers[i]) + 1;
+		memcpy(data, this->headers[i], n * sizeof(char));
+		buf_next(data, char, n);
+	}
+
+	memcpy(data, this->payload, this->payload_ptr * sizeof(char));
+	buf_next(data, char, this->payload_ptr);
+
+	memcpy(data, this->buffer, this->buffer_ptr * sizeof(char));
 }
 
 
@@ -483,75 +477,74 @@ void mds_message_marshal(const mds_message_t* restrict this, char* restrict data
  * @return       Non-zero on error, `errno` will be set accordingly.
  *               Destroy the message on error.
  */
-int mds_message_unmarshal(mds_message_t* restrict this, char* restrict data)
+int
+mds_message_unmarshal(mds_message_t *restrict this, char *restrict data)
 {
-  size_t i, n, header_count;
-  
-  /* buf_get(data, int, 0, MDS_MESSAGE_T_VERSION); */
-  buf_next(data, int, 1);
-  
-  this->header_count = 0;
-  buf_get_next(data, size_t, header_count);
-  buf_get_next(data, size_t, this->payload_size);
-  buf_get_next(data, size_t, this->payload_ptr);
-  buf_get_next(data, size_t, this->buffer_size = this->buffer_ptr);
-  buf_get_next(data, int, this->stage);
-  
-  /* Make sure that the pointers are NULL so that they are
-     not freed without being allocated when the message is
-     destroyed if this function fails. */
-  this->headers = NULL;
-  this->payload = NULL;
-  this->buffer  = NULL;
-  
-  /* To 2-power-multiple of 128 bytes. */
-  this->buffer_size >>= 7;
-  if (this->buffer_size == 0)
-    this->buffer_size = 1;
-  else
-    {
-      this->buffer_size -= 1;
-      this->buffer_size |= this->buffer_size >> 1;
-      this->buffer_size |= this->buffer_size >> 2;
-      this->buffer_size |= this->buffer_size >> 4;
-      this->buffer_size |= this->buffer_size >> 8;
-      this->buffer_size |= this->buffer_size >> 16;
+	size_t i, n, header_count;
+
+	/* buf_get(data, int, 0, MDS_MESSAGE_T_VERSION); */
+	buf_next(data, int, 1);
+
+	this->header_count = 0;
+	buf_get_next(data, size_t, header_count);
+	buf_get_next(data, size_t, this->payload_size);
+	buf_get_next(data, size_t, this->payload_ptr);
+	buf_get_next(data, size_t, this->buffer_size = this->buffer_ptr);
+	buf_get_next(data, int, this->stage);
+
+	/* Make sure that the pointers are NULL so that they are
+	   not freed without being allocated when the message is
+	   destroyed if this function fails. */
+	this->headers = NULL;
+	this->payload = NULL;
+	this->buffer  = NULL;
+
+	/* To 2-power-multiple of 128 bytes. */
+	this->buffer_size >>= 7;
+	if (!this->buffer_size) {
+		this->buffer_size = 1;
+	} else {
+		this->buffer_size -= 1;
+		this->buffer_size |= this->buffer_size >> 1;
+		this->buffer_size |= this->buffer_size >> 2;
+		this->buffer_size |= this->buffer_size >> 4;
+		this->buffer_size |= this->buffer_size >> 8;
+		this->buffer_size |= this->buffer_size >> 16;
 #if SIZE_MAX == UINT64_MAX
-      this->buffer_size |= this->buffer_size >> 32;
+		this->buffer_size |= this->buffer_size >> 32;
 #endif
-      this->buffer_size += 1;
-    }
-  this->buffer_size <<= 7;
-  
-  /* Allocate header list, payload and read buffer. */
-  
-  if (header_count > 0)
-    fail_if (xmalloc(this->headers, header_count, char*));
-  
-  if (this->payload_size > 0)
-    fail_if (xmalloc(this->payload, this->payload_size, char));
-  
-  fail_if (xmalloc(this->buffer, this->buffer_size, char));
-  
-  /* Fill the header list, payload and read buffer. */
-  
-  for (i = 0; i < header_count; i++)
-    {
-      n = strlen(data) + 1;
-      fail_if (xmemdup(this->headers[i], data, n, char));
-      buf_next(data, char, n);
-      this->header_count++;
-    }
-  
-  memcpy(this->payload, data, this->payload_ptr * sizeof(char));
-  buf_next(data, char, this->payload_ptr);
-  
-  memcpy(this->buffer, data, this->buffer_ptr * sizeof(char));
-  
-  return 0;
-  
- fail:
-  return -1;
+		this->buffer_size += 1;
+	}
+	this->buffer_size <<= 7;
+
+	/* Allocate header list, payload and read buffer. */
+
+	if (header_count > 0)
+		fail_if (xmalloc(this->headers, header_count, char*));
+
+	if (this->payload_size > 0)
+		fail_if (xmalloc(this->payload, this->payload_size, char));
+
+	fail_if (xmalloc(this->buffer, this->buffer_size, char));
+
+	/* Fill the header list, payload and read buffer. */
+
+	for (i = 0; i < header_count; i++) {
+		n = strlen(data) + 1;
+		fail_if (xmemdup(this->headers[i], data, n, char));
+		buf_next(data, char, n);
+		this->header_count++;
+	}
+
+	memcpy(this->payload, data, this->payload_ptr * sizeof(char));
+	buf_next(data, char, this->payload_ptr);
+
+	memcpy(this->buffer, data, this->buffer_ptr * sizeof(char));
+
+	return 0;
+
+fail:
+	return -1;
 }
 
 
@@ -562,13 +555,14 @@ int mds_message_unmarshal(mds_message_t* restrict this, char* restrict data)
  * @param   this  The message
  * @return        The size of the message when marshalled
  */
-size_t mds_message_compose_size(const mds_message_t* restrict this)
+size_t
+mds_message_compose_size(const mds_message_t *restrict this)
 {
-  size_t rc = 1 + this->payload_size;
-  size_t i;
-  for (i = 0; i < this->header_count; i++)
-    rc += strlen(this->headers[i]) + 1;
-  return rc * sizeof(char);
+	size_t rc = 1 + this->payload_size;
+	size_t i;
+	for (i = 0; i < this->header_count; i++)
+		rc += strlen(this->headers[i]) + 1;
+	return rc * sizeof(char);
 }
 
 
@@ -578,23 +572,22 @@ size_t mds_message_compose_size(const mds_message_t* restrict this)
  * @param  this  The message
  * @param  data  Output buffer for the marshalled data
  */
-void mds_message_compose(const mds_message_t* restrict this, char* restrict data)
+void
+mds_message_compose(const mds_message_t *restrict this, char *restrict data)
 {
-  size_t i, n;
-  
-  for (i = 0; i < this->header_count; i++)
-    {
-      n = strlen(this->headers[i]);
-      memcpy(data, this->headers[i], n * sizeof(char));
-      data += n;
-      buf_set_next(data, char, '\n');
-    }
-  buf_set_next(data, char, '\n');
-  
-  if (this->payload_size > 0)
-    memcpy(data, this->payload, this->payload_size * sizeof(char));
+	size_t i, n;
+
+	for (i = 0; i < this->header_count; i++) {
+		n = strlen(this->headers[i]);
+		memcpy(data, this->headers[i], n * sizeof(char));
+		data += n;
+		buf_set_next(data, char, '\n');
+	}
+	buf_set_next(data, char, '\n');
+
+	if (this->payload_size > 0)
+		memcpy(data, this->payload, this->payload_size * sizeof(char));
 }
 
   
 #undef try
-
diff --git a/src/libmdsserver/util.c b/src/libmdsserver/util.c
index cac30ad..09d996a 100644
--- a/src/libmdsserver/util.c
+++ b/src/libmdsserver/util.c
@@ -49,20 +49,21 @@ static char self_exe[PATH_MAX] = {0};
  * @param   str  The client ID string
  * @return       The client ID integer
  */
-uint64_t parse_client_id(const char* str)
+uint64_t
+parse_client_id(const char *str)
 {
-  char client_words[22];
-  char* client_high;
-  char* client_low;
-  uint64_t client;
-  
-  strcpy(client_high = client_words, str);
-  client_low = rawmemchr(client_words, ':');
-  *client_low++ = '\0';
-  client = atou64(client_high) << 32;
-  client |= atou64(client_low);
-  
-  return client;
+	char client_words[22];
+	char *client_high;
+	char *client_low;
+	uint64_t client;
+
+	strcpy(client_high = client_words, str);
+	client_low = rawmemchr(client_words, ':');
+	*client_low++ = '\0';
+	client = atou64(client_high) << 32;
+	client |= atou64(client_low);
+
+	return client;
 }
 
 
@@ -72,12 +73,11 @@ uint64_t parse_client_id(const char* str)
  * @param   var  The environment variable's name
  * @return       The environment variable's value, `NULL` if empty or not defined
  */
-char* getenv_nonempty(const char* var)
+char *
+getenv_nonempty(const char *var)
 {
-  char* rc = getenv(var);
-  if ((rc == NULL) || (*rc == '\0'))
-    return NULL;
-  return rc;
+	char *rc = getenv(var);
+	return (rc && *rc) ? rc : NULL;
 }
 
 
@@ -97,20 +97,21 @@ char* getenv_nonempty(const char* var)
  * 
  * @return  Zero on success, -1 on error
  */
-int prepare_reexec(void)
+int
+prepare_reexec(void)
 {
-  ssize_t len;
-  len = readlink(SELF_EXE, self_exe, (sizeof(self_exe) / sizeof(char)) - 1);
-  fail_if (len < 0);
-  /* ‘readlink() does not append a null byte to buf.’ */
-  self_exe[len] = '\0';
-  /* Handle possible race condition: file was removed. */
-  if (access(self_exe, F_OK) < 0)
-    if (!strcmp(self_exe + (len - 10), " (deleted)"))
-      self_exe[len - 10] = '\0';
-  return 0;
- fail:
-  return -1;
+	ssize_t len;
+	len = readlink(SELF_EXE, self_exe, (sizeof(self_exe) / sizeof(char)) - 1);
+	fail_if (len < 0);
+	/* ‘readlink() does not append a null byte to buf.’ */
+	self_exe[len] = '\0';
+	/* Handle possible race condition: file was removed. */
+	if (access(self_exe, F_OK) < 0)
+		if (!strcmp(self_exe + (len - 10), " (deleted)"))
+			self_exe[len - 10] = '\0';
+	return 0;
+fail:
+	return -1;
 }
 
 
@@ -125,30 +126,30 @@ int prepare_reexec(void)
  * @param  argv      The command line arguments
  * @param  reexeced  Whether the server has previously been re-exec:ed
  */
-void reexec_server(int argc, char** argv, int reexeced)
+void
+reexec_server(int argc, char **argv, int reexeced)
 {
-  char** reexec_args;
-  char** reexec_args_;
-  int i;
-  
-  /* Re-exec the server. */
-  reexec_args = alloca(((size_t)argc + 2) * sizeof(char*));
-  reexec_args_ = reexec_args;
-  if (reexeced == 0)
-    {
-      *reexec_args_++ = *argv;
-      fail_if (xstrdup(*reexec_args_, "--re-exec"));
-      for (i = 1; i < argc; i++)
-	reexec_args_[i] = argv[i];
-    }
-  else /* Don't let the --re-exec:s accumulate. */
-    *reexec_args_ = *argv;
-  for (i = 1; i < argc; i++)
-    reexec_args_[i] = argv[i];
-  reexec_args_[argc] = NULL;
-  execv(self_exe[0] ? self_exe : argv[0], reexec_args);
- fail:
-  return;
+	char **reexec_args;
+	char **reexec_args_;
+	int i;
+
+	/* Re-exec the server. */
+	reexec_args = alloca(((size_t)argc + 2) * sizeof(char*));
+	reexec_args_ = reexec_args;
+	if (!reexeced) {
+		*reexec_args_++ = *argv;
+		fail_if (xstrdup(*reexec_args_, "--re-exec"));
+		for (i = 1; i < argc; i++)
+			reexec_args_[i] = argv[i];
+	} else { /* Don't let the --re-exec:s accumulate. */
+		*reexec_args_ = *argv;
+	}
+	for (i = 1; i < argc; i++)
+		reexec_args_[i] = argv[i];
+	reexec_args_[argc] = NULL;
+	execv(self_exe[0] ? self_exe : argv[0], reexec_args);
+fail:
+	return;
 }
 
 
@@ -164,17 +165,18 @@ void reexec_server(int argc, char** argv, int reexeced)
  * @param   function  The function to run when the signal is caught
  * @return            Zero on success, -1 on error
  */
-int xsigaction(int signo, void (*function)(int signo))
+int
+xsigaction(int signo, void (*function)(int signo))
 {
-  struct sigaction action;
-  sigset_t sigset;
-  
-  sigemptyset(&sigset);
-  action.sa_handler = function;
-  action.sa_mask = sigset;
-  action.sa_flags = 0;
-  
-  return sigaction(signo, &action, NULL);
+	struct sigaction action;
+	sigset_t sigset;
+
+	sigemptyset(&sigset);
+	action.sa_handler = function;
+	action.sa_mask = sigset;
+	action.sa_flags = 0;
+
+	return sigaction(signo, &action, NULL);
 }
 
 
@@ -186,34 +188,32 @@ int xsigaction(int signo, void (*function)(int signo))
  * @param   length   The length of the message
  * @return           The number of bytes that have been sent (even on error)
  */
-size_t send_message(int socket, const char* message, size_t length)
+size_t
+send_message(int socket, const char *message, size_t length)
 {
-  size_t block_size = length;
-  size_t sent = 0;
-  ssize_t just_sent;
-  
-  errno = 0;
-  while (length > 0)
-    if ((just_sent = send(socket, message + sent, min(block_size, length), MSG_NOSIGNAL)) < 0)
-      {
-	if (errno == EPIPE)
-	  errno = ECONNRESET;
-	if (errno == EMSGSIZE)
-	  {
-	    block_size >>= 1;
-	    if (block_size == 0)
-	      return sent;
-	  }
-	else
-	  return sent;
-      }
-    else
-      {
-	sent += (size_t)just_sent;
-	length -= (size_t)just_sent;
-      }
-  
-  return sent;
+	size_t block_size = length;
+	size_t sent = 0;
+	ssize_t just_sent;
+
+	errno = 0;
+	while (length > 0) {
+		if ((just_sent = send(socket, message + sent, min(block_size, length), MSG_NOSIGNAL)) < 0) {
+			if (errno == EPIPE)
+				errno = ECONNRESET;
+			if (errno == EMSGSIZE) {
+				block_size >>= 1;
+				if (!block_size)
+					return sent;
+			} else {
+				return sent;
+			}
+		} else {
+			sent += (size_t)just_sent;
+			length -= (size_t)just_sent;
+		}
+	}
+
+	return sent;
 }
 
 
@@ -226,20 +226,21 @@ size_t send_message(int socket, const char* message, size_t length)
  * @param   max    The maximum accepted value
  * @return         Zero on success, -1 on syntax error
  */
-int strict_atoi(const char* str, int* value, int min, int max)
+int
+strict_atoi(const char *str, int *value, int min, int max)
 {
-  long long int r;
-  char* endptr;
-  
-  r = strtoll(str, &endptr, 10);
-  if ((*str == '\0') || isspace(*str) ||
-      (endptr - str != (ssize_t)strlen(str)) ||
-      (r < (long long int)min) ||
-      (r > (long long int)max))
-    return -1;
-  
-  *value = (int)r;
-  return 0;
+	long long int r;
+	char *endptr;
+
+	r = strtoll(str, &endptr, 10);
+	if (!*str || isspace(*str) ||
+	    endptr - str != (ssize_t)strlen(str) ||
+	    r < (long long int)min ||
+	    r > (long long int)max)
+		return -1;
+
+	*value = (int)r;
+	return 0;
 }
 
 
@@ -252,51 +253,50 @@ int strict_atoi(const char* str, int* value, int min, int max)
  * @param   max    The maximum accepted value
  * @return         Zero on success, -1 on syntax error
  */
-int strict_atoj(const char* str, intmax_t* value, intmax_t min, intmax_t max)
+int
+strict_atoj(const char *str, intmax_t *value, intmax_t min, intmax_t max)
 {
-  static char minstr[3 * sizeof(intmax_t) + 2] = { '\0' };
-  intmax_t r = 0;
-  char c;
-  int neg = 0;
-  
-  if (*str == '-')
-    {
-      if (*minstr == '\0')
-	sprintf(minstr, "%j", INTMAX_MIN);
-      if (!strcmp(str, minstr))
-	{
-	  r = INTMAX_MIN;
-	  goto done;
+	static char minstr[3 * sizeof(intmax_t) + 2] = { '\0' };
+	intmax_t r = 0;
+	char c;
+	int neg = 0;
+
+	if (*str == '-') {
+		if (!*minstr)
+			sprintf(minstr, "%j", INTMAX_MIN);
+		if (!strcmp(str, minstr)) {
+			r = INTMAX_MIN;
+			goto done;
+		}
+		neg = 1, str++;
 	}
-      neg = 1, str++;
-    }
-  
-  if (*str == '\0')
-    return -1;
-  
-  while ((c = *str))
-    if (('0' <= c) && (c <= '9'))
-      {
-	if (r > INTMAX_MAX / 10)
-	  return -1;
-	else if (r == INTMAX_MAX / 10)
-	  if ((c & 15) > INTMAX_MAX % 10)
-	    return -1;
-	r = r * 10 + (c & 15);
-      }
-    else
-      return -1;
-  
-  if (neg)
-    r = -r;
-  
- done:
-  
-  if ((r < min) || (r > max))
-    return -1;
-  
-  *value = r;
-  return 0;
+
+	if (!*str)
+		return -1;
+
+	while ((c = *str)) {
+		if ('0' <= c && c <= '9') {
+			if (r > INTMAX_MAX / 10) {
+				return -1;
+			} else if (r == INTMAX_MAX / 10) {
+				if ((c & 15) > INTMAX_MAX % 10)
+					return -1;
+			}
+			r = r * 10 + (c & 15);
+		} else {
+			return -1;
+		}
+	}
+
+	if (neg)
+		r = -r;
+
+done:
+	if (r < min || r > max)
+		return -1;
+
+	*value = r;
+	return 0;
 }
 
 
@@ -316,50 +316,53 @@ int strict_atoj(const char* str, intmax_t* value, intmax_t min, intmax_t max)
  * @param   max    The maximum accepted value
  * @return         Zero on success, -1 on syntax error
  */
-int strict_atouj(const char* str, uintmax_t* value, uintmax_t min, uintmax_t max)
+int
+strict_atouj(const char *str, uintmax_t *value, uintmax_t min, uintmax_t max)
 {
-  uintmax_t r = 0;
-  char c;
-  
-  if (*str == '\0')
-    return -1;
-  
-  while ((c = *str))
-    if (('0' <= c) && (c <= '9'))
-      {
-	if (r > INTMAX_MAX / 10)
-	  return -1;
-	else if (r == INTMAX_MAX / 10)
-	  if ((c & 15) > INTMAX_MAX % 10)
-	    return -1;
-	r = r * 10 + (c & 15);
-      }
-    else
-      return -1;
-  
-  if ((r < min) || (r > max))
-    return -1;
-  
-  *value = r;
-  return 0;
+	uintmax_t r = 0;
+	char c;
+
+	if (!*str)
+		return -1;
+
+	while ((c = *str)) {
+		if ('0' <= c && c <= '9') {
+			if (r > INTMAX_MAX / 10) {
+				return -1;
+			} else if (r == INTMAX_MAX / 10) {
+				if ((c & 15) > INTMAX_MAX % 10)
+					return -1;
+			}
+			r = r * 10 + (c & 15);
+		} else {
+			return -1;
+		}
+	}
+
+	if (r < min || r > max)
+		return -1;
+
+	*value = r;
+	return 0;
 }
 #if defined(__GNUC__)
 # pragma GCC diagnostic pop
 #endif
 
 
-#define __strict_y(Y, TYPE, PARA_TYPE, HYPER_Y, HYPER_TYPE)					\
-  int strict_##Y(const char* str, TYPE* value, PARA_TYPE min, PARA_TYPE max)			\
-  {												\
-    HYPER_TYPE intermediate_value;								\
-    if (strict_##HYPER_Y(str, &intermediate_value, (HYPER_TYPE)min, (HYPER_TYPE)max) < 0)	\
-      return -1;										\
-    return *value = (TYPE)intermediate_value, 0;						\
-  }
+#define __strict_y(Y, TYPE, PARA_TYPE, HYPER_Y, HYPER_TYPE)\
+	int\
+	strict_##Y(const char *str, TYPE *value, PARA_TYPE min, PARA_TYPE max)\
+	{\
+		HYPER_TYPE intermediate_value;\
+		if (strict_##HYPER_Y(str, &intermediate_value, (HYPER_TYPE)min, (HYPER_TYPE)max) < 0)\
+			return -1;\
+		return *value = (TYPE)intermediate_value, 0;\
+	}
 
 
-#define __strict_x(X, TYPE, HYPER_X, HYPER_TYPE)  \
-  __strict_y(X, TYPE, TYPE, HYPER_X, HYPER_TYPE)
+#define __strict_x(X, TYPE, HYPER_X, HYPER_TYPE)\
+	__strict_y(X, TYPE, TYPE, HYPER_X, HYPER_TYPE)
 
 
 /**
@@ -577,20 +580,20 @@ __strict_x(atou64, uint64_t, atouj, uintmax_t)
  * @param   length  The length of the buffer
  * @return          Zero on success, -1 on error
  */
-int full_write(int fd, const char* buffer, size_t length)
+int
+full_write(int fd, const char *buffer, size_t length)
 {
-  ssize_t wrote;
-  while (length > 0)
-    {
-      errno = 0;
-      wrote = write(fd, buffer, length);
-      fail_if (errno && (errno != EINTR));
-      length -= (size_t)max(wrote, 0);
-      buffer += (size_t)max(wrote, 0);
-    }
-  return 0;
- fail:
-  return -1;
+	ssize_t wrote;
+	while (length > 0) {
+		errno = 0;
+		wrote = write(fd, buffer, length);
+		fail_if (errno && errno != EINTR);
+		length -= (size_t)max(wrote, 0);
+		buffer += (size_t)max(wrote, 0);
+	}
+	return 0;
+fail:
+	return -1;
 }
 
 
@@ -601,44 +604,44 @@ int full_write(int fd, const char* buffer, size_t length)
  * @param   length  Output parameter for the length of the file, may be `NULL`
  * @return          The content of the file, you will need to free it. `NULL` on error.
  */
-char* full_read(int fd, size_t* length)
+char *
+full_read(int fd, size_t *length)
 {
-  char* old_buf = NULL;
-  size_t buffer_size = 8 << 10;
-  size_t buffer_ptr = 0;
-  char* buffer;
-  ssize_t got;
-  int saved_errno;
-  
-  if (length != NULL)
-    *length = 0;
-  
-  /* Allocate buffer for data. */
-  fail_if (xmalloc(buffer, buffer_size, char));
-  
-  /* Read the file. */
-  for (;;)
-    {
-      /* Grow buffer if it is too small. */
-      if (buffer_size == buffer_ptr)
-	fail_if (xxrealloc(old_buf, buffer, buffer_size <<= 1, char));
-      
-      /* Read from the file into the buffer. */
-      got = read(fd, buffer + buffer_ptr, buffer_size - buffer_ptr);
-      fail_if ((got < 0) && (errno != EINTR));
-      if (got == 0)
-	break;
-      buffer_ptr += (size_t)got;
-    }
-  
-  if (length != NULL)
-    *length = buffer_ptr;
-  return buffer;
- fail:
-  saved_errno = errno;
-  free(old_buf);
-  free(buffer);
-  return errno = saved_errno, NULL;
+	char *old_buf = NULL;
+	size_t buffer_size = 8 << 10;
+	size_t buffer_ptr = 0;
+	char *buffer;
+	ssize_t got;
+	int saved_errno;
+
+	if (length)
+		*length = 0;
+
+	/* Allocate buffer for data. */
+	fail_if (xmalloc(buffer, buffer_size, char));
+
+	/* Read the file. */
+	for (;;) {
+		/* Grow buffer if it is too small. */
+		if (buffer_size == buffer_ptr)
+			fail_if (xxrealloc(old_buf, buffer, buffer_size <<= 1, char));
+
+		/* Read from the file into the buffer. */
+		got = read(fd, buffer + buffer_ptr, buffer_size - buffer_ptr);
+		fail_if (got < 0 && errno != EINTR);
+		if (!got)
+			break;
+		buffer_ptr += (size_t)got;
+	}
+
+	if (length)
+		*length = buffer_ptr;
+	return buffer;
+fail:
+	saved_errno = errno;
+	free(old_buf);
+	free(buffer);
+	return errno = saved_errno, NULL;
 }
 
 
@@ -650,20 +653,20 @@ char* full_read(int fd, size_t* length)
  * @param   length   The length of the message
  * @return           Zero on success, -1 on error
  */
-int full_send(int socket, const char* message, size_t length)
+int
+full_send(int socket, const char *message, size_t length)
 {
-  size_t sent;
+	size_t sent;
   
-  while (length > 0)
-    {
-      sent = send_message(socket, message, length);
-      fail_if ((sent < length) && (errno != EINTR));
-      message += sent;
-      length -= sent;
-    }
-  return 0;
- fail:
-  return -1;
+	while (length > 0) {
+		sent = send_message(socket, message, length);
+		fail_if (sent < length && errno != EINTR);
+		message += sent;
+		length -= sent;
+	}
+	return 0;
+fail:
+	return -1;
 }
 
 
@@ -677,17 +680,18 @@ int full_send(int socket, const char* message, size_t length)
  * @param   needle_n    The length of `needle`
  * @return              Whether the `haystack` begins with `needle`
  */
-int startswith_n(const char* haystack, const char* needle, size_t haystack_n, size_t needle_n)
+int
+startswith_n(const char *haystack, const char *needle, size_t haystack_n, size_t needle_n)
 {
-  size_t i;
-  if (haystack_n < needle_n)
-    return 0;
-  
-  for (i = 0; i < needle_n; i++)
-    if (haystack[i] != needle[i])
-      return 0;
-  
-  return 1;
+	size_t i;
+	if (haystack_n < needle_n)
+		return 0;
+
+	for (i = 0; i < needle_n; i++)
+		if (haystack[i] != needle[i])
+			return 0;
+
+	return 1;
 }
 
 
@@ -700,30 +704,30 @@ int startswith_n(const char* haystack, const char* needle, size_t haystack_n, si
  * @param   options  See description of `options` in the documentation for `waitpid`
  * @return           See the documentation for `waitpid`
  */
-pid_t uninterruptable_waitpid(pid_t pid, int* restrict status, int options)
+pid_t
+uninterruptable_waitpid(pid_t pid, int *restrict status, int options)
 {
-  struct timespec time_start;
-  struct timespec time_intr;
-  int intr_count = 0, have_time;
-  pid_t rc;
-  
-  have_time = (monotone(&time_start) >= 0);
-  
- rewait:
-  rc = waitpid(pid, status, options);
-  if (rc == (pid_t)-1)
-    {
-      fail_if (errno != EINTR);
-      if (have_time && (monotone(&time_intr) >= 0))
-	if (time_start.tv_sec != time_intr.tv_sec)
-	  intr_count = 0;
-      if (intr_count++ < 100)
-	goto rewait;
-      /* Don't let the CPU catch fire! */
-      errno = EINTR;
-    }
- fail:
-  return rc;
+	struct timespec time_start;
+	struct timespec time_intr;
+	int intr_count = 0, have_time;
+	pid_t rc;
+
+	have_time = (monotone(&time_start) >= 0);
+
+rewait:
+	rc = waitpid(pid, status, options);
+	if (rc == (pid_t)-1) {
+		fail_if (errno != EINTR);
+		if (have_time && monotone(&time_intr) >= 0)
+			if (time_start.tv_sec != time_intr.tv_sec)
+				intr_count = 0;
+		if (intr_count++ < 100)
+			goto rewait;
+		/* Don't let the CPU catch fire! */
+		errno = EINTR;
+	}
+fail:
+	return rc;
 }
 
 
@@ -734,72 +738,71 @@ pid_t uninterruptable_waitpid(pid_t pid, int* restrict status, int options)
  * @param   allow_modified_nul  Whether Modified UTF-8 is allowed, which allows a two-byte encoding for NUL
  * @return                      Zero if good, -1 on encoding error
  */
-int verify_utf8(const char* string, int allow_modified_nul)
+int
+verify_utf8(const char *string, int allow_modified_nul)
 {
-  static long BYTES_TO_MIN_BITS[] = {0, 0,  8, 12, 17, 22, 37};
-  static long BYTES_TO_MAX_BITS[] = {0, 7, 11, 16, 21, 26, 31};
-  long bytes = 0, read_bytes = 0, bits = 0, c, character;
-  
-  /*                                                      min bits  max bits
-    0.......                                                 0         7
-    110..... 10......                                        8        11
-    1110.... 10...... 10......                              12        16
-    11110... 10...... 10...... 10......                     17        21
-    111110.. 10...... 10...... 10...... 10......            22        26
-    1111110. 10...... 10...... 10...... 10...... 10......   27        31
-   */
-  
-  while ((c = (long)(*string++)))
-    if (read_bytes == 0)
-      {
-	/* First byte of the character. */
-	
-	if ((c & 0x80) == 0x00)
-	  /* Single-byte character. */
-	  continue;
-	
-	if ((c & 0xC0) == 0x80)
-	  /* Single-byte character marked as multibyte, or
-	     a non-first byte in a multibyte character. */
-	  return -1;
-	
-	/* Multibyte character. */
-	while ((c & 0x80))
-	  bytes++, c <<= 1;
-	read_bytes = 1;
-	character = c & 0x7F;
-	if (bytes > 6)
-	  /* 31-bit characters can be encoded with 6-bytes,
-	     and UTF-8 does not cover higher code points. */
-	  return -1;
-      }
-    else
-      {
-	/* Not first byte of the character. */
-	
-	if ((c & 0xC0) != 0x80)
-	  /* Beginning of new character before a
-	     multibyte character has ended. */
-	  return -1;
-	
-	character = (character << 6) | (c & 0x7F);
-	
-	if (++read_bytes < bytes)
-	  /* Not at last byte yet. */
-	  continue;
-	
-	/* Check that the character is not unnecessarily long. */
-	while (character)
-	  character >>= 1, bits++;
-	bits = ((bits == 0) && (bytes == 2) && allow_modified_nul) ? 8 : bits;
-	if ((bits < BYTES_TO_MIN_BITS[bytes]) || (BYTES_TO_MAX_BITS[bytes] < bits))
-	  return -1;
-	
-	read_bytes = bytes = bits = 0;
-      }
-  
-  /* Make sure we did not stop at the middle of a multibyte character. */
-  return read_bytes == 0 ? 0 : -1;
+	static long BYTES_TO_MIN_BITS[] = {0, 0,  8, 12, 17, 22, 37};
+	static long BYTES_TO_MAX_BITS[] = {0, 7, 11, 16, 21, 26, 31};
+	long bytes = 0, read_bytes = 0, bits = 0, c, character;
+
+	/*                                                      min bits  max bits
+	  0.......                                                 0         7
+	  110..... 10......                                        8        11
+	  1110.... 10...... 10......                              12        16
+	  11110... 10...... 10...... 10......                     17        21
+	  111110.. 10...... 10...... 10...... 10......            22        26
+	  1111110. 10...... 10...... 10...... 10...... 10......   27        31
+	*/
+
+	while ((c = (long)(*string++))) {
+		if (read_bytes == 0) {
+			/* First byte of the character. */
+
+			if (!(c & 0x80))
+				/* Single-byte character. */
+				continue;
+
+			if ((c & 0xC0) == 0x80)
+				/* Single-byte character marked as multibyte, or
+				   a non-first byte in a multibyte character. */
+				return -1;
+
+			/* Multibyte character. */
+			while ((c & 0x80))
+				bytes++, c <<= 1;
+			read_bytes = 1;
+			character = c & 0x7F;
+			if (bytes > 6)
+				/* 31-bit characters can be encoded with 6-bytes,
+				   and UTF-8 does not cover higher code points. */
+				return -1;
+		} else {
+			/* Not first byte of the character. */
+
+			if ((c & 0xC0) != 0x80)
+				/* Beginning of new character before a
+				   multibyte character has ended. */
+				return -1;
+
+			character = (character << 6) | (c & 0x7F);
+
+			if (++read_bytes < bytes)
+				/* Not at last byte yet. */
+				continue;
+
+			/* Check that the character is not unnecessarily long. */
+			while (character)
+				character >>= 1, bits++;
+			bits = ((bits == 0) && (bytes == 2) && allow_modified_nul) ? 8 : bits;
+			if ((bits < BYTES_TO_MIN_BITS[bytes]) || (BYTES_TO_MAX_BITS[bytes] < bits))
+				return -1;
+
+			read_bytes = bytes = bits = 0;
+		}
+	}
+
+	/* Make sure we did not stop at the middle of a multibyte character. */
+	return read_bytes == 0 ? 0 : -1;
 }
 
 
@@ -828,85 +831,85 @@ int verify_utf8(const char* string, int allow_modified_nul)
  * @param   message_id        The message ID of this message
  * @return                    The length of the message, zero on error
  */
-size_t construct_error_message(const char* restrict recv_client_id, const char* restrict recv_message_id,
-			       const char* restrict recv_command, int custom, int errnum,
-			       const char* restrict message, char** restrict send_buffer,
-			       size_t* restrict send_buffer_size, uint32_t message_id)
+size_t
+construct_error_message(const char *restrict recv_client_id, const char *restrict recv_message_id,
+                        const char *restrict recv_command, int custom, int errnum,
+                        const char *restrict message, char **restrict send_buffer,
+                        size_t *restrict send_buffer_size, uint32_t message_id)
 {
-  ssize_t part_length;
-  size_t length;
-  char* temp;
-  
-  /* Measure the maximum length of message, including NUL-termination.. */
-  length = sizeof("Command: error\n"
-		  "To: 4294967296:4294967296\n"
-		  "In response to: 4294967296\n"
-		  "Origin command: \n"
-		  "Message ID: 4294967296\n"
-		  "Error: custom \n"
-		  "Length: \n"
-		  "\n") / sizeof(char) + 3 * (sizeof(int)) + strlen(recv_command);
-  if (message != NULL)
-    length += (sizeof("Length: \n") / sizeof(char) - 1) + 3 * sizeof(char) + strlen(message) + 1;
-  
-  /* Ensure that the send buffer is large enough. */
-  if (length > *send_buffer_size)
-    {
-      fail_if (yrealloc(temp, *send_buffer, length, char));
-      *send_buffer_size = length;
-    }
-  
-  /* Reset `length` to indicate that the currently written
-     message has zero in length. */
-  length = 0;
-  
-  /* Start writting the error message, begin with required
-     headers, but exclude the error number. */
-  sprintf((*send_buffer) + length,
-	  "Command: error\n"
-	  "To: %s\n"
-	  "In response to: %s\n"
-	  "Origin command: %s\n"
-	  "Message ID: %"PRIu32"\n"
-	  "Error: %s%zn",
-	  recv_client_id, recv_message_id, recv_command,
-	  message_id, custom ? "custom" : "",
-	  &part_length),
-    length += (size_t)part_length;
-  
-  /* If the error is custom and has a number we need
-     blank space before we write the error number. */
-  if (custom && (errnum >= 0))
-    (*send_buffer)[length++] = ' ';
-  
-  /* Add the error number of there is one. */
-  if (errnum >= 0)
-    sprintf((*send_buffer) + length, "%i%zn", errnum, &part_length),
-      length += (size_t)part_length;
-  
-  /* End the `Error`-header line. */
-  (*send_buffer)[length++] = '\n';
-  
-  /* Add the `Length`-header if there is a description. */
-  if (message != NULL)
-    sprintf((*send_buffer) + length, "Length: %zu\n%zn",
-	    strlen(message) + 1, &part_length),
-      length += (size_t)part_length + strlen(message) + 1;
-  
-  /* Add an empty line to mark the end of headers. */
-  (*send_buffer)[length++] = '\n';
-  
-  /* Write the description if there is one. */
-  if (message)
-    {
-      memcpy((*send_buffer) + length, message, strlen(message) * sizeof(char));
-      length += strlen(message);
-      (*send_buffer)[length++] = '\n';
-    }
-  
-  return length;
- fail:
-  return 0;
+	ssize_t part_length;
+	size_t length;
+	char *temp;
+
+	/* Measure the maximum length of message, including NUL-termination.. */
+	length = sizeof("Command: error\n"
+	                "To: 4294967296:4294967296\n"
+	                "In response to: 4294967296\n"
+	                "Origin command: \n"
+	                "Message ID: 4294967296\n"
+	                "Error: custom \n"
+	                "Length: \n"
+	                "\n") / sizeof(char) + 3 * (sizeof(int)) + strlen(recv_command);
+	if (message)
+		length += (sizeof("Length: \n") / sizeof(char) - 1) + 3 * sizeof(char) + strlen(message) + 1;
+
+	/* Ensure that the send buffer is large enough. */
+	if (length > *send_buffer_size) {
+		fail_if (yrealloc(temp, *send_buffer, length, char));
+		*send_buffer_size = length;
+	}
+
+	/* Reset `length` to indicate that the currently written
+	   message has zero in length. */
+	length = 0;
+
+	/* Start writting the error message, begin with required
+	   headers, but exclude the error number. */
+	sprintf((*send_buffer) + length,
+	        "Command: error\n"
+	        "To: %s\n"
+	        "In response to: %s\n"
+	        "Origin command: %s\n"
+	        "Message ID: %"PRIu32"\n"
+	        "Error: %s%zn",
+	        recv_client_id, recv_message_id, recv_command,
+	        message_id, custom ? "custom" : "",
+	        &part_length);
+	length += (size_t)part_length;
+
+	/* If the error is custom and has a number we need
+	   blank space before we write the error number. */
+	if (custom && errnum >= 0)
+		(*send_buffer)[length++] = ' ';
+
+	/* Add the error number of there is one. */
+	if (errnum >= 0)
+		sprintf((*send_buffer) + length, "%i%zn", errnum, &part_length),
+			length += (size_t)part_length;
+
+	/* End the `Error`-header line. */
+	(*send_buffer)[length++] = '\n';
+
+	/* Add the `Length`-header if there is a description. */
+	if (message) {
+		sprintf((*send_buffer) + length, "Length: %zu\n%zn",
+		        strlen(message) + 1, &part_length);
+		length += (size_t)part_length + strlen(message) + 1;
+	}
+
+	/* Add an empty line to mark the end of headers. */
+	(*send_buffer)[length++] = '\n';
+
+	/* Write the description if there is one. */
+	if (message) {
+		memcpy((*send_buffer) + length, message, strlen(message) * sizeof(char));
+		length += strlen(message);
+		(*send_buffer)[length++] = '\n';
+	}
+
+	return length;
+fail:
+	return 0;
 }
 
 
@@ -936,17 +939,17 @@ size_t construct_error_message(const char* restrict recv_client_id, const char*
  * @param   message_id        The message ID of this message
  * @return                    Zero on success, -1 on error
  */
-int send_error(const char* restrict recv_client_id, const char* restrict recv_message_id,
-	       const char* restrict recv_command, int custom, int errnum, const char* restrict message,
-	       char** restrict send_buffer, size_t* restrict send_buffer_size, uint32_t message_id,
-	       int socket_fd)
+int
+send_error(const char *restrict recv_client_id, const char *restrict recv_message_id,
+           const char *restrict recv_command, int custom, int errnum, const char *restrict message,
+           char **restrict send_buffer, size_t *restrict send_buffer_size, uint32_t message_id,
+           int socket_fd)
 {
-  size_t length;
-  fail_if ((length = construct_error_message(recv_client_id, recv_message_id, recv_command, custom, errnum,
-					     message, send_buffer, send_buffer_size, message_id)) == 0);
-  fail_if (full_send(socket_fd, *send_buffer, length));
-  return 0;
- fail:
-  return -1;
+	size_t length;
+	fail_if (!(length = construct_error_message(recv_client_id, recv_message_id, recv_command, custom, errnum,
+	                                            message, send_buffer, send_buffer_size, message_id)));
+	fail_if (full_send(socket_fd, *send_buffer, length));
+	return 0;
+fail:
+	return -1;
 }
-