Change license, change style, clean up, flat file hier, clean valgrind output in test

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

3 files changed, 596 insertions, 3534 deletions

diff --git a/src/libcoopgamma.h b/libcoopgamma.h
index 723d5a3..5f5e800 100644
--- a/src/libcoopgamma.h
+++ b/libcoopgamma.h
@@ -1,40 +1,21 @@
-/**
- * libcoopgamma -- Library for interfacing with cooperative gamma servers
- * Copyright (C) 2016  Mattias Andrée (maandree@kth.se)
- * 
- * This library is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- * 
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- * 
- * You should have received a copy of the GNU General Public License
- * along with this library.  If not, see <http://www.gnu.org/licenses/>.
- */
+/* See LICENSE file for copyright and license details. */
 #ifndef LIBCOOPGAMMA_H
 #define LIBCOOPGAMMA_H
 
-
-
 #include <limits.h>
 #include <stddef.h>
 #include <stdint.h>
 
 
-
 #if defined(__clang__)
 # pragma GCC diagnostic push
 # pragma GCC diagnostic ignored "-Wdocumentation"
 #endif
 
 #if defined(__GNUC__) && !defined(__clang__)
-# define LIBCOOPGAMMA_GCC_ONLY(...)  __VA_ARGS__
+# define LIBCOOPGAMMA_GCC_ONLY(...) __VA_ARGS__
 #else
-# define LIBCOOPGAMMA_GCC_ONLY(...)  /* ignore */
+# define LIBCOOPGAMMA_GCC_ONLY(...) /* ignore */
 #endif
 
 
@@ -171,30 +152,29 @@
  * Values used to indicate the support
  * for gamma adjustments
  */
-typedef enum libcoopgamma_support
-{
-  /**
-   * Gamma adjustments are not supported
-   * 
-   * This value will always be 0
-   */
-  LIBCOOPGAMMA_NO = 0,
-  
-  /**
-   * Don't know whether gamma
-   * adjustments are supported
-   * 
-   * This value will always be 1
-   */
-  LIBCOOPGAMMA_MAYBE = 1,
-  
-  /**
-   * Gamma adjustments are supported
-   * 
-   * This value will always be 2
-   */
-  LIBCOOPGAMMA_YES = 2
-  
+typedef enum libcoopgamma_support {
+	/**
+	 * Gamma adjustments are not supported
+	 * 
+	 * This value will always be 0
+	 */
+	LIBCOOPGAMMA_NO = 0,
+
+	/**
+	 * Don't know whether gamma
+	 * adjustments are supported
+	 * 
+	 * This value will always be 1
+	 */
+	LIBCOOPGAMMA_MAYBE = 1,
+
+	/**
+	 * Gamma adjustments are supported
+	 * 
+	 * This value will always be 2
+	 */
+	LIBCOOPGAMMA_YES = 2
+
 } libcoopgamma_support_t;
 
 
@@ -206,38 +186,37 @@ typedef enum libcoopgamma_support
  * of bits for integral types, and
  * negative for floating-point types
  */
-typedef enum libcoopgamma_depth
-{
-  /**
-   * `uint8_t`
-   */
-  LIBCOOPGAMMA_UINT8 = 8,
-  
-  /**
-   * `uint16_t`
-   */
-  LIBCOOPGAMMA_UINT16 = 16,
-  
-  /**
-   * `uint32_t`
-   */
-  LIBCOOPGAMMA_UINT32 = 32,
-  
-  /**
-   * `uint64_t`
-   */
-  LIBCOOPGAMMA_UINT64 = 64,
-  
-  /**
-   * `float`
-   */
-  LIBCOOPGAMMA_FLOAT = -1,
-  
-  /**
-   * `double`
-   */
-  LIBCOOPGAMMA_DOUBLE = -2
-  
+typedef enum libcoopgamma_depth {
+	/**
+	 * `uint8_t`
+	 */
+	LIBCOOPGAMMA_UINT8 = 8,
+
+	/**
+	 * `uint16_t`
+	 */
+	LIBCOOPGAMMA_UINT16 = 16,
+
+	/**
+	 * `uint32_t`
+	 */
+	LIBCOOPGAMMA_UINT32 = 32,
+
+	/**
+	 * `uint64_t`
+	 */
+	LIBCOOPGAMMA_UINT64 = 64,
+
+	/**
+	 * `float`
+	 */
+	LIBCOOPGAMMA_FLOAT = -1,
+
+	/**
+	 * `double`
+	 */
+	LIBCOOPGAMMA_DOUBLE = -2
+
 } libcoopgamma_depth_t;
 
 
@@ -245,63 +224,61 @@ typedef enum libcoopgamma_depth
  * Values used to tell when a filter
  * should be removed
  */
-typedef enum libcoopgamma_lifespan
-{
-  /**
-   * Remove the filter now
-   * 
-   * This value will always be 0
-   */
-  LIBCOOPGAMMA_REMOVE = 0,
-  
-  /**
-   * Remove the filter when disconnecting
-   * from the coopgamma server
-   */
-  LIBCOOPGAMMA_UNTIL_DEATH = 1,
-  
-  /**
-   * Only remove the filter when it
-   * is explicitly requested
-   */
-  LIBCOOPGAMMA_UNTIL_REMOVAL = 2
-  
+typedef enum libcoopgamma_lifespan {
+	/**
+	 * Remove the filter now
+	 * 
+	 * This value will always be 0
+	 */
+	LIBCOOPGAMMA_REMOVE = 0,
+
+	/**
+	 * Remove the filter when disconnecting
+	 * from the coopgamma server
+	 */
+	LIBCOOPGAMMA_UNTIL_DEATH = 1,
+
+	/**
+	 * Only remove the filter when it
+	 * is explicitly requested
+	 */
+	LIBCOOPGAMMA_UNTIL_REMOVAL = 2
+
 } libcoopgamma_lifespan_t;
 
 
 /**
  * Colourspaces
  */
-typedef enum libcoopgamma_colourspace
-{
-  /**
-   * The colourspace is unknown
-   * 
-   * This value will always be 0
-   */
-  LIBCOOPGAMMA_UNKNOWN = 0,
-  
-  /**
-   * sRGB (Standard RGB)
-   */
-  LIBCOOPGAMMA_SRGB = 1,
-  
-  /**
-   * RGB other than sRGB
-   */
-  LIBCOOPGAMMA_RGB = 2,
-  
-  /**
-   * Non-RGB multicolour
-   */
-  LIBCOOPGAMMA_NON_RGB = 3,
-  
-  /**
-   * Monochrome, greyscale, or some
-   * other singlecolour scale
-   */
-  LIBCOOPGAMMA_GREY = 4
-  
+typedef enum libcoopgamma_colourspace {
+	/**
+	 * The colourspace is unknown
+	 * 
+	 * This value will always be 0
+	 */
+	LIBCOOPGAMMA_UNKNOWN = 0,
+
+	/**
+	 * sRGB (Standard RGB)
+	 */
+	LIBCOOPGAMMA_SRGB = 1,
+
+	/**
+	 * RGB other than sRGB
+	 */
+	LIBCOOPGAMMA_RGB = 2,
+
+	/**
+	 * Non-RGB multicolour
+	 */
+	LIBCOOPGAMMA_NON_RGB = 3,
+
+	/**
+	 * Monochrome, greyscale, or some
+	 * other singlecolour scale
+	 */
+	LIBCOOPGAMMA_GREY = 4
+
 } libcoopgamma_colourspace_t;
 
 
@@ -311,39 +288,38 @@ typedef enum libcoopgamma_colourspace
  * @param  suffix:identifier  The end of the name of the `struct`
  * @param  type:scalar-type   The datatype of the stops
  */
-#define LIBCOOPGAMMA_RAMPS__(suffix, type)	\
-typedef struct libcoopgamma_ramps##suffix	\
-{						\
-  /**
-   * The number of stops in the red ramp
-   */						\
-  size_t red_size;				\
-						\
-  /**
-   * The number of stops in the green ramp
-   */						\
-  size_t green_size;				\
-						\
-  /**
-   * The number of stops in the blue ramp
-   */						\
-  size_t blue_size;				\
-						\
-  /**
-   * The red ramp
-   */						\
-  type* red;					\
-						\
-  /**
-   * The green ramp
-   */						\
-  type* green;					\
-						\
-  /**
-   * The blue ramp
-   */						\
-  type* blue;					\
-						\
+#define LIBCOOPGAMMA_RAMPS__(suffix, type)\
+typedef struct libcoopgamma_ramps##suffix {\
+	/**
+	 * The number of stops in the red ramp
+	 */\
+	size_t red_size;\
+	\
+	/**
+	 * The number of stops in the green ramp
+	 */\
+	size_t green_size;\
+	\
+	/**
+	 * The number of stops in the blue ramp
+	 */\
+	size_t blue_size;\
+	\
+	/**
+	 * The red ramp
+	 */\
+	type *red;\
+	\
+	/**
+	 * The green ramp
+	 */\
+	type *green;\
+	\
+	/**
+	 * The blue ramp
+	 */\
+	type *blue;\
+	\
 } libcoopgamma_ramps##suffix##_t
 
 /**
@@ -392,38 +368,37 @@ LIBCOOPGAMMA_RAMPS__(d, double);
 /**
  * Union with all ramp types.
  */
-typedef union libcoopgamma_ramps
-{
-    /**
-     * 8-bit version
-     */
-    libcoopgamma_ramps8_t u8;
-    
-    /**
-     * 16-bit version
-     */
-    libcoopgamma_ramps16_t u16;
-    
-    /**
-     * 32-bit version
-     */
-    libcoopgamma_ramps32_t u32;
-    
-    /**
-     * 64-bit version
-     */
-    libcoopgamma_ramps64_t u64;
-    
-    /**
-     * Single precision floating-point version
-     */
-    libcoopgamma_rampsf_t f;
-    
-    /**
-     * Double precision floating-point version
-     */
-    libcoopgamma_rampsd_t d;
-    
+typedef union libcoopgamma_ramps {
+	/**
+	 * 8-bit version
+	 */
+	libcoopgamma_ramps8_t u8;
+
+	/**
+	 * 16-bit version
+	 */
+	libcoopgamma_ramps16_t u16;
+
+	/**
+	 * 32-bit version
+	 */
+	libcoopgamma_ramps32_t u32;
+
+	/**
+	 * 64-bit version
+	 */
+	libcoopgamma_ramps64_t u64;
+
+	/**
+	 * Single precision floating-point version
+	 */
+	libcoopgamma_rampsf_t f;
+
+	/**
+	 * Double precision floating-point version
+	 */
+	libcoopgamma_rampsd_t d;
+
 } libcoopgamma_ramps_t;
 
 
@@ -431,153 +406,151 @@ typedef union libcoopgamma_ramps
  * Data set to the coopgamma server to apply,
  * update, or remove a filter.
  */
-typedef struct libcoopgamma_filter
-{
-  /**
-   * The priority of the filter, higher priority
-   * is applied first. The gamma correction should
-   * have priority 0.
-   */
-  int64_t priority;
-  
-  /**
-   * The CRTC for which this filter shall be applied
-   */
-  char* crtc;
-  
-  /**
-   * Identifier for the filter
-   * 
-   * The syntax must be "${PACKAGE_NAME}::${COMMAND_NAME}::${RULE}"
-   */
-  char* class;
-  
-  /**
-   * When shall the filter be removed?
-   * 
-   * If this member's value is `LIBCOOPGAMMA_REMOVE`,
-   * only `.crtc` and `.class` need also be defined
-   */
-  libcoopgamma_lifespan_t lifespan;
-  
-  /**
-   * The data type and bit-depth of the ramp stops
-   */
-  libcoopgamma_depth_t depth;
-  
-  /**
-   * The gamma ramp adjustments of the filter
-   */
-  libcoopgamma_ramps_t ramps;
-  
+typedef struct libcoopgamma_filter {
+	/**
+	 * The priority of the filter, higher priority
+	 * is applied first. The gamma correction should
+	 * have priority 0.
+	 */
+	int64_t priority;
+
+	/**
+	 * The CRTC for which this filter shall be applied
+	 */
+	char *crtc;
+
+	/**
+	 * Identifier for the filter
+	 * 
+	 * The syntax must be "${PACKAGE_NAME}::${COMMAND_NAME}::${RULE}"
+	 */
+	char *class;
+
+	/**
+	 * When shall the filter be removed?
+	 * 
+	 * If this member's value is `LIBCOOPGAMMA_REMOVE`,
+	 * only `.crtc` and `.class` need also be defined
+	 */
+	libcoopgamma_lifespan_t lifespan;
+
+	/**
+	 * The data type and bit-depth of the ramp stops
+	 */
+	libcoopgamma_depth_t depth;
+
+	/**
+	 * The gamma ramp adjustments of the filter
+	 */
+	libcoopgamma_ramps_t ramps;
+
 } libcoopgamma_filter_t;
 
 
 /**
  * Gamma ramp meta information for a CRTC
  */
-typedef struct libcoopgamma_crtc_info
-{
-  /**
-   * Is cooperative gamma server running?
-   */
-  int cooperative;
-  
-  /**
-   * The data type and bit-depth of the ramp stops
-   */
-  libcoopgamma_depth_t depth;
-  
-  /**
-   * Is gamma adjustments supported on the CRTC?
-   * If not, `.depth`, `.red_size`, `.green_size`,
-   * and `.blue_size` are undefined
-   */
-  libcoopgamma_support_t supported;
-  
+typedef struct libcoopgamma_crtc_info {
+	/**
+	 * Is cooperative gamma server running?
+	 */
+	int cooperative;
+
+	/**
+	 * The data type and bit-depth of the ramp stops
+	 */
+	libcoopgamma_depth_t depth;
+
+	/**
+	 * Is gamma adjustments supported on the CRTC?
+	 * If not, `.depth`, `.red_size`, `.green_size`,
+	 * and `.blue_size` are undefined
+	 */
+	libcoopgamma_support_t supported;
+
 #if INT_MAX != LONG_MAX
-  int padding__;
+	int padding__;
 #endif
-  
-  /**
-   * The number of stops in the red ramp
-   */
-  size_t red_size;
-  
-  /**
-   * The number of stops in the green ramp
-   */
-  size_t green_size;
-  
-  /**
-   * The number of stops in the blue ramp
-   */
-  size_t blue_size;
-  
-  /**
-   * The monitor's colourspace
-   */
-  libcoopgamma_colourspace_t colourspace;
-  
-  /**
-   * Whether `.red_x`, `.red_y`, `.green_x`,
-   * `.green_y`, `.blue_x`, `.blue_y`,
-   * `.white_x`, and `.white_y` are set.
-   * 
-   * If this is true, but the colourspace
-   * is not RGB (or sRGB), there is something
-   * wrong. Please also check the colourspace.
-   */
-  int have_gamut;
-  
-  /**
-   * The x-value (CIE xyY) of the monitor's
-   * red colour, multiplied by 1024
-   */
-  unsigned red_x;
-  
-  /**
-   * The y-value (CIE xyY) of the monitor's
-   * red colour, multiplied by 1024
-   */
-  unsigned red_y;
-  
-  /**
-   * The x-value (CIE xyY) of the monitor's
-   * green colour, multiplied by 1024
-   */
-  unsigned green_x;
-  
-  /**
-   * The y-value (CIE xyY) of the monitor's
-   * green colour, multiplied by 1024
-   */
-  unsigned green_y;
-  
-  /**
-   * The x-value (CIE xyY) of the monitor's
-   * blue colour, multiplied by 1024
-   */
-  unsigned blue_x;
-  
-  /**
-   * The y-value (CIE xyY) of the monitor's
-   * blue colour, multiplied by 1024
-   */
-  unsigned blue_y;
-  
-  /**
-   * The x-value (CIE xyY) of the monitor's
-   * default white point, multiplied by 1024
-   */
-  unsigned white_x;
-  
-  /**
-   * The y-value (CIE xyY) of the monitor's
-   * default white point, multiplied by 1024
-   */
-  unsigned white_y;
-  
+
+	/**
+	 * The number of stops in the red ramp
+	 */
+	size_t red_size;
+
+	/**
+	 * The number of stops in the green ramp
+	 */
+	size_t green_size;
+
+	/**
+	 * The number of stops in the blue ramp
+	 */
+	size_t blue_size;
+
+	/**
+	 * The monitor's colourspace
+	 */
+	libcoopgamma_colourspace_t colourspace;
+
+	/**
+	 * Whether `.red_x`, `.red_y`, `.green_x`,
+	 * `.green_y`, `.blue_x`, `.blue_y`,
+	 * `.white_x`, and `.white_y` are set.
+	 * 
+	 * If this is true, but the colourspace
+	 * is not RGB (or sRGB), there is something
+	 * wrong. Please also check the colourspace.
+	 */
+	int have_gamut;
+
+	/**
+	 * The x-value (CIE xyY) of the monitor's
+	 * red colour, multiplied by 1024
+	 */
+	unsigned red_x;
+
+	/**
+	 * The y-value (CIE xyY) of the monitor's
+	 * red colour, multiplied by 1024
+	 */
+	unsigned red_y;
+
+	/**
+	 * The x-value (CIE xyY) of the monitor's
+	 * green colour, multiplied by 1024
+	 */
+	unsigned green_x;
+
+	/**
+	 * The y-value (CIE xyY) of the monitor's
+	 * green colour, multiplied by 1024
+	 */
+	unsigned green_y;
+
+	/**
+	 * The x-value (CIE xyY) of the monitor's
+	 * blue colour, multiplied by 1024
+	 */
+	unsigned blue_x;
+
+	/**
+	 * The y-value (CIE xyY) of the monitor's
+	 * blue colour, multiplied by 1024
+	 */
+	unsigned blue_y;
+
+	/**
+	 * The x-value (CIE xyY) of the monitor's
+	 * default white point, multiplied by 1024
+	 */
+	unsigned white_x;
+
+	/**
+	 * The y-value (CIE xyY) of the monitor's
+	 * default white point, multiplied by 1024
+	 */
+	unsigned white_y;
+
 } libcoopgamma_crtc_info_t;
 
 
@@ -586,36 +559,35 @@ typedef struct libcoopgamma_crtc_info
  * when requestng the current filter
  * table
  */
-typedef struct libcoopgamma_filter_query
-{
-  /**
-   * Do no return filters with higher
-   * priority than this value
-   */
-  int64_t high_priority;
-  
-  /**
-   * Do no return filters with lower
-   * priority than this value
-   */
-  int64_t low_priority;
-  
-  /**
-   * The CRTC for which the the current
-   * filters shall returned
-   */
-  char* crtc;
-  
-  /**
-   * Whether to coalesce all filters
-   * into one gamma ramp triplet
-   */
-  int coalesce;
-  
+typedef struct libcoopgamma_filter_query {
+	/**
+	 * Do no return filters with higher
+	 * priority than this value
+	 */
+	int64_t high_priority;
+
+	/**
+	 * Do no return filters with lower
+	 * priority than this value
+	 */
+	int64_t low_priority;
+
+	/**
+	 * The CRTC for which the the current
+	 * filters shall returned
+	 */
+	char *crtc;
+
+	/**
+	 * Whether to coalesce all filters
+	 * into one gamma ramp triplet
+	 */
+	int coalesce;
+
 #if INT_MAX != LONG_MAX
-  int padding__;
+	int padding__;
 #endif
-  
+
 } libcoopgamma_filter_query_t;
 
 
@@ -624,23 +596,22 @@ typedef struct libcoopgamma_filter_query
  * which only contains the information returned
  * in response to "Command: get-gamma"
  */
-typedef struct libcoopgamma_queried_filter
-{
-  /**
-   * The filter's priority
-   */
-  int64_t priority;
-  
-  /**
-   * The filter's class
-   */
-  char* class;
-  
-  /**
-   * The gamma ramp adjustments of the filter
-   */
-  libcoopgamma_ramps_t ramps;
-  
+typedef struct libcoopgamma_queried_filter {
+	/**
+	 * The filter's priority
+	 */
+	int64_t priority;
+
+	/**
+	 * The filter's class
+	 */
+	char *class;
+
+	/**
+	 * The gamma ramp adjustments of the filter
+	 */
+	libcoopgamma_ramps_t ramps;
+
 } libcoopgamma_queried_filter_t;
 
 
@@ -649,82 +620,80 @@ typedef struct libcoopgamma_queried_filter
  * list of applied filters and meta-information
  * that was necessary for decoding the response
  */
-typedef struct libcoopgamma_filter_table
-{
-  /**
-   * The number of stops in the red ramp
-   */
-  size_t red_size;
-  
-  /**
-   * The number of stops in the green ramp
-   */
-  size_t green_size;
-  
-  /**
-   * The number of stops in the blue ramp
-   */
-  size_t blue_size;
-  
-  /**
-   * The number of filters
-   */
-  size_t filter_count;
-  
-  /**
-   * The filters, should be ordered by priority
-   * in descending order, lest there is something
-   * wrong with the coopgamma server
-   * 
-   * If filter coalition was requested, there will
-   * be exactly one filter (`.filter_count == 1`)
-   * and `.filters->class == NULL` and
-   * `.filters->priority` is undefined.
-   */
-  libcoopgamma_queried_filter_t* filters;
-  
-  /**
-   * The data type and bit-depth of the ramp stops
-   */
-  libcoopgamma_depth_t depth;
-  
+typedef struct libcoopgamma_filter_table {
+	/**
+	 * The number of stops in the red ramp
+	 */
+	size_t red_size;
+
+	/**
+	 * The number of stops in the green ramp
+	 */
+	size_t green_size;
+
+	/**
+	 * The number of stops in the blue ramp
+	 */
+	size_t blue_size;
+
+	/**
+	 * The number of filters
+	 */
+	size_t filter_count;
+
+	/**
+	 * The filters, should be ordered by priority
+	 * in descending order, lest there is something
+	 * wrong with the coopgamma server
+	 * 
+	 * If filter coalition was requested, there will
+	 * be exactly one filter (`.filter_count == 1`)
+	 * and `.filters->class == NULL` and
+	 * `.filters->priority` is undefined.
+	 */
+	libcoopgamma_queried_filter_t *filters;
+
+	/**
+	 * The data type and bit-depth of the ramp stops
+	 */
+	libcoopgamma_depth_t depth;
+
 #if INT_MAX != LONG_MAX
-  int padding__;
+	int padding__;
 #endif
-  
+
 } libcoopgamma_filter_table_t;
 
 
 /**
  * Error message from coopgamma server
  */
-typedef struct libcoopgamma_error
-{
-  /**
-   * Error code
-   * 
-   * If `.custom` is false, 0 indicates
-   * success, otherwise, 0 indicates that
-   * no error code has been assigned
-   */
-  uint64_t number;
-  
-  /**
-   * Is this a custom error?
-   */
-  int custom;
-  
-  /**
-   * Did the error occur on the server-side?
-   */
-  int server_side;
-  
-  /**
-   * Error message, can be `NULL` if
-   * `.custom` is false
-   */
-  char* description;
-  
+typedef struct libcoopgamma_error {
+	/**
+	 * Error code
+	 * 
+	 * If `.custom` is false, 0 indicates
+	 * success, otherwise, 0 indicates that
+	 * no error code has been assigned
+	 */
+	uint64_t number;
+
+	/**
+	 * Is this a custom error?
+	 */
+	int custom;
+
+	/**
+	 * Did the error occur on the server-side?
+	 */
+	int server_side;
+
+	/**
+	 * Error message, can be `NULL` if
+	 * `.custom` is false
+	 */
+	char *description;
+
 } libcoopgamma_error_t;
 
 
@@ -735,103 +704,102 @@ typedef struct libcoopgamma_error
  * create one instance per thread that uses
  * this structure
  */
-typedef struct libcoopgamma_context
-{
-  /**
-   * The error of the last failed function call
-   * 
-   * This member is undefined after successful function call
-   */
-  libcoopgamma_error_t error;
-  
-  /**
-   * File descriptor for the socket
-   */
-  int fd;
-  
-  /* The members below are internal. */
-  
-  /**
-   * Whether `libcoopgamma_synchronise` have
-   * read the empty end-of-headers line
-   */
-  int have_all_headers;
-  
-  /**
-   * Whether `libcoopgamma_synchronise` is reading
-   * a corrupt but recoverable message
-   */
-  int bad_message;
-  
-  /**
-   * Is communication blocking?
-   */
-  int blocking;
-  
-  /**
-   * Message ID of the next message
-   */
-  uint32_t message_id;
-  
-  /**
-   * The ID of outbound message to which the inbound
-   * message being read by `libcoopgamma_synchronise`
-   * is a response
-   */
-  uint32_t in_response_to;
-  
-  /**
-   * Buffer with the outbound message
-   */
-  char* outbound;
-  
-  /**
-   * The write head for `outbound`
-   */
-  size_t outbound_head;
-  
-  /**
-   * The read head for `outbound`
-   */
-  size_t outbound_tail;
-  
-  /**
-   * The allocation size of `outbound`
-   */
-  size_t outbound_size;
-  
-  /**
-   * Buffer with the inbound message
-   */
-  char* inbound;
-  
-  /**
-   * The write head for `inbound`
-   */
-  size_t inbound_head;
-  
-  /**
-   * The read head for `inbound`
-   */
-  size_t inbound_tail;
-  
-  /**
-   * The allocation size of `inbound`
-   */
-  size_t inbound_size;
-  
-  /**
-   * The value of 'Length' header in
-   * the inbound message
-   */
-  size_t length;
-  
-  /**
-   * The beginning of the current line that
-   * is being read by `libcoopgamma_synchronise`
-   */
-  size_t curline;
-  
+typedef struct libcoopgamma_context {
+	/**
+	 * The error of the last failed function call
+	 * 
+	 * This member is undefined after successful function call
+	 */
+	libcoopgamma_error_t error;
+
+	/**
+	 * File descriptor for the socket
+	 */
+	int fd;
+
+	/* The members below are internal. */
+
+	/**
+	 * Whether `libcoopgamma_synchronise` have
+	 * read the empty end-of-headers line
+	 */
+	int have_all_headers;
+
+	/**
+	 * Whether `libcoopgamma_synchronise` is reading
+	 * a corrupt but recoverable message
+	 */
+	int bad_message;
+
+	/**
+	 * Is communication blocking?
+	 */
+	int blocking;
+
+	/**
+	 * Message ID of the next message
+	 */
+	uint32_t message_id;
+
+	/**
+	 * The ID of outbound message to which the inbound
+	 * message being read by `libcoopgamma_synchronise`
+	 * is a response
+	 */
+	uint32_t in_response_to;
+
+	/**
+	 * Buffer with the outbound message
+	 */
+	char *outbound;
+
+	/**
+	 * The write head for `outbound`
+	 */
+	size_t outbound_head;
+
+	/**
+	 * The read head for `outbound`
+	 */
+	size_t outbound_tail;
+
+	/**
+	 * The allocation size of `outbound`
+	 */
+	size_t outbound_size;
+
+	/**
+	 * Buffer with the inbound message
+	 */
+	char *inbound;
+
+	/**
+	 * The write head for `inbound`
+	 */
+	size_t inbound_head;
+
+	/**
+	 * The read head for `inbound`
+	 */
+	size_t inbound_tail;
+
+	/**
+	 * The allocation size of `inbound`
+	 */
+	size_t inbound_size;
+
+	/**
+	 * The value of 'Length' header in
+	 * the inbound message
+	 */
+	size_t length;
+
+	/**
+	 * The beginning of the current line that
+	 * is being read by `libcoopgamma_synchronise`
+	 */
+	size_t curline;
+
 } libcoopgamma_context_t;
 
 
@@ -839,22 +807,21 @@ typedef struct libcoopgamma_context
  * Information necessary to identify and
  * parse a response from the server
  */
-typedef struct libcoopgamma_async_context
-{
-  /* All members are internal. */
-  
-  /**
-   * The value of the 'In response to' header
-   * in the waited message
-   */
-  uint32_t message_id;
-  
-  /**
-   * Whether to coalesce all filters
-   * into one gamma ramp triplet
-   */
-  int coalesce;
-  
+typedef struct libcoopgamma_async_context {
+	/* All members are internal. */
+
+	/**
+	 * The value of the 'In response to' header
+	 * in the waited message
+	 */
+	uint32_t message_id;
+
+	/**
+	 * Whether to coalesce all filters
+	 * into one gamma ramp triplet
+	 */
+	int coalesce;
+
 } libcoopgamma_async_context_t;
 
 
@@ -868,8 +835,8 @@ typedef struct libcoopgamma_async_context
  * @param   this  The record to initialise
  * @return        Zero on success, -1 on error
  */
-#define libcoopgamma_ramps_initialise(this)  \
-  (libcoopgamma_ramps_initialise_((this), sizeof(*((this)->red))))
+#define libcoopgamma_ramps_initialise(this)\
+	(libcoopgamma_ramps_initialise_((this), sizeof(*((this)->red))))
 
 /**
  * Marshal a `libcoopgamma_ramps8_t`, `libcoopgamma_ramps16_t`, `libcoopgamma_ramps32_t`,
@@ -881,8 +848,8 @@ typedef struct libcoopgamma_async_context
  * @return        The number of marshalled bytes, or if `buf == NULL`,
  *                how many bytes would be marshalled if `buf != NULL`
  */
-#define libcoopgamma_ramps_marshal(this, buf)  \
-  (libcoopgamma_ramps_marshal_((this), (buf), sizeof(*((this)->red))))
+#define libcoopgamma_ramps_marshal(this, buf)\
+	(libcoopgamma_ramps_marshal_((this), (buf), sizeof(*((this)->red))))
 
 /**
  * Unmarshal a `libcoopgamma_ramps8_t`, `libcoopgamma_ramps16_t`, `libcoopgamma_ramps32_t`,
@@ -894,8 +861,8 @@ typedef struct libcoopgamma_async_context
  * @return        `LIBCOOPGAMMA_SUCCESS` (0), `LIBCOOPGAMMA_INCOMPATIBLE_DOWNGRADE`,
  *                `LIBCOOPGAMMA_INCOMPATIBLE_UPGRADE`, or `LIBCOOPGAMMA_ERRNO_SET`
  */
-#define libcoopgamma_ramps_unmarshal(this, buf, n)  \
-  (libcoopgamma_ramps_unmarshal_((this), (buf), (n), sizeof(*((this)->red))))
+#define libcoopgamma_ramps_unmarshal(this, buf, n)\
+	(libcoopgamma_ramps_unmarshal_((this), (buf), (n), sizeof(*((this)->red))))
 
 
 /**
@@ -909,7 +876,7 @@ typedef struct libcoopgamma_async_context
  * @return         Zero on success, -1 on error
  */
 LIBCOOPGAMMA_GCC_ONLY(__attribute__((__nonnull__, __leaf__)))
-int libcoopgamma_ramps_initialise_(void* restrict, size_t);
+int libcoopgamma_ramps_initialise_(void *restrict, size_t);
 
 /**
  * Release all resources allocated to  a `libcoopgamma_ramps8_t`, `libcoopgamma_ramps16_t`,
@@ -923,7 +890,7 @@ int libcoopgamma_ramps_initialise_(void* restrict, size_t);
  * @param  this  The record to destroy
  */
 LIBCOOPGAMMA_GCC_ONLY(__attribute__((__nonnull__, __leaf__)))
-void libcoopgamma_ramps_destroy(void* restrict);
+void libcoopgamma_ramps_destroy(void *restrict);
 
 /**
  * Marshal a `libcoopgamma_ramps8_t`, `libcoopgamma_ramps16_t`, `libcoopgamma_ramps32_t`,
@@ -937,7 +904,7 @@ void libcoopgamma_ramps_destroy(void* restrict);
  *                 how many bytes would be marshalled if `buf != NULL`
  */
 LIBCOOPGAMMA_GCC_ONLY(__attribute__((__nonnull__(1), __leaf__)))
-size_t libcoopgamma_ramps_marshal_(const void* restrict, void* restrict, size_t);
+size_t libcoopgamma_ramps_marshal_(const void *restrict, void *restrict, size_t);
 
 /**
  * Unmarshal a `libcoopgamma_ramps8_t`, `libcoopgamma_ramps16_t`, `libcoopgamma_ramps32_t`,
@@ -951,7 +918,7 @@ size_t libcoopgamma_ramps_marshal_(const void* restrict, void* restrict, size_t)
  *                 `LIBCOOPGAMMA_INCOMPATIBLE_UPGRADE`, or `LIBCOOPGAMMA_ERRNO_SET`
  */
 LIBCOOPGAMMA_GCC_ONLY(__attribute__((__nonnull__, __leaf__)))
-int libcoopgamma_ramps_unmarshal_(void* restrict, const void* restrict, size_t* restrict, size_t);
+int libcoopgamma_ramps_unmarshal_(void *restrict, const void *restrict, size_t *restrict, size_t);
 
 
 /**
@@ -961,7 +928,7 @@ int libcoopgamma_ramps_unmarshal_(void* restrict, const void* restrict, size_t*
  * @return        Zero on success, -1 on error
  */
 LIBCOOPGAMMA_GCC_ONLY(__attribute__((__nonnull__, __leaf__)))
-int libcoopgamma_filter_initialise(libcoopgamma_filter_t* restrict);
+int libcoopgamma_filter_initialise(libcoopgamma_filter_t *restrict);
 
 /**
  * Release all resources allocated to  a `libcoopgamma_filter_t`,
@@ -973,7 +940,7 @@ int libcoopgamma_filter_initialise(libcoopgamma_filter_t* restrict);
  * @param  this  The record to destroy
  */
 LIBCOOPGAMMA_GCC_ONLY(__attribute__((__nonnull__, __leaf__)))
-void libcoopgamma_filter_destroy(libcoopgamma_filter_t* restrict);
+void libcoopgamma_filter_destroy(libcoopgamma_filter_t *restrict);
 
 /**
  * Marshal a `libcoopgamma_filter_t` into a buffer
@@ -985,7 +952,7 @@ void libcoopgamma_filter_destroy(libcoopgamma_filter_t* restrict);
  *                how many bytes would be marshalled if `buf != NULL`
  */
 LIBCOOPGAMMA_GCC_ONLY(__attribute__((__nonnull__(1))))
-size_t libcoopgamma_filter_marshal(const libcoopgamma_filter_t* restrict, void* restrict);
+size_t libcoopgamma_filter_marshal(const libcoopgamma_filter_t *restrict, void *restrict);
 
 /**
  * Unmarshal a `libcoopgamma_filter_t` from a buffer
@@ -997,7 +964,7 @@ size_t libcoopgamma_filter_marshal(const libcoopgamma_filter_t* restrict, void*
  *                `LIBCOOPGAMMA_INCOMPATIBLE_UPGRADE`, or `LIBCOOPGAMMA_ERRNO_SET`
  */
 LIBCOOPGAMMA_GCC_ONLY(__attribute__((__nonnull__)))
-int libcoopgamma_filter_unmarshal(libcoopgamma_filter_t* restrict, const void* restrict, size_t* restrict);
+int libcoopgamma_filter_unmarshal(libcoopgamma_filter_t *restrict, const void *restrict, size_t *restrict);
 
 
 /**
@@ -1007,7 +974,7 @@ int libcoopgamma_filter_unmarshal(libcoopgamma_filter_t* restrict, const void* r
  * @return        Zero on success, -1 on error
  */
 LIBCOOPGAMMA_GCC_ONLY(__attribute__((__nonnull__, __leaf__)))
-int libcoopgamma_crtc_info_initialise(libcoopgamma_crtc_info_t* restrict);
+int libcoopgamma_crtc_info_initialise(libcoopgamma_crtc_info_t *restrict);
 
 /**
  * Release all resources allocated to  a `libcoopgamma_crtc_info_t`,
@@ -1019,7 +986,7 @@ int libcoopgamma_crtc_info_initialise(libcoopgamma_crtc_info_t* restrict);
  * @param  this  The record to destroy
  */
 LIBCOOPGAMMA_GCC_ONLY(__attribute__((__nonnull__, __leaf__)))
-void libcoopgamma_crtc_info_destroy(libcoopgamma_crtc_info_t* restrict);
+void libcoopgamma_crtc_info_destroy(libcoopgamma_crtc_info_t *restrict);
 
 /**
  * Marshal a `libcoopgamma_crtc_info_t` into a buffer
@@ -1031,7 +998,7 @@ void libcoopgamma_crtc_info_destroy(libcoopgamma_crtc_info_t* restrict);
  *                how many bytes would be marshalled if `buf != NULL`
  */
 LIBCOOPGAMMA_GCC_ONLY(__attribute__((__nonnull__(1), __leaf__)))
-size_t libcoopgamma_crtc_info_marshal(const libcoopgamma_crtc_info_t* restrict, void* restrict);
+size_t libcoopgamma_crtc_info_marshal(const libcoopgamma_crtc_info_t *restrict, void *restrict);
 
 /**
  * Unmarshal a `libcoopgamma_crtc_info_t` from a buffer
@@ -1043,8 +1010,7 @@ size_t libcoopgamma_crtc_info_marshal(const libcoopgamma_crtc_info_t* restrict,
  *                `LIBCOOPGAMMA_INCOMPATIBLE_UPGRADE`, or `LIBCOOPGAMMA_ERRNO_SET`
  */
 LIBCOOPGAMMA_GCC_ONLY(__attribute__((__nonnull__, __leaf__)))
-int libcoopgamma_crtc_info_unmarshal(libcoopgamma_crtc_info_t* restrict,
-				     const void* restrict, size_t* restrict);
+int libcoopgamma_crtc_info_unmarshal(libcoopgamma_crtc_info_t *restrict, const void *restrict, size_t *restrict);
 
 
 /**
@@ -1054,7 +1020,7 @@ int libcoopgamma_crtc_info_unmarshal(libcoopgamma_crtc_info_t* restrict,
  * @return        Zero on success, -1 on error
  */
 LIBCOOPGAMMA_GCC_ONLY(__attribute__((__nonnull__, __leaf__)))
-int libcoopgamma_filter_query_initialise(libcoopgamma_filter_query_t* restrict);
+int libcoopgamma_filter_query_initialise(libcoopgamma_filter_query_t *restrict);
 
 /**
  * Release all resources allocated to  a `libcoopgamma_filter_query_t`,
@@ -1066,7 +1032,7 @@ int libcoopgamma_filter_query_initialise(libcoopgamma_filter_query_t* restrict);
  * @param  this  The record to destroy
  */
 LIBCOOPGAMMA_GCC_ONLY(__attribute__((__nonnull__, __leaf__)))
-void libcoopgamma_filter_query_destroy(libcoopgamma_filter_query_t* restrict);
+void libcoopgamma_filter_query_destroy(libcoopgamma_filter_query_t *restrict);
 
 /**
  * Marshal a `libcoopgamma_filter_query_t` into a buffer
@@ -1078,7 +1044,7 @@ void libcoopgamma_filter_query_destroy(libcoopgamma_filter_query_t* restrict);
  *                how many bytes would be marshalled if `buf != NULL`
  */
 LIBCOOPGAMMA_GCC_ONLY(__attribute__((__nonnull__(1), __leaf__)))
-size_t libcoopgamma_filter_query_marshal(const libcoopgamma_filter_query_t* restrict, void* restrict);
+size_t libcoopgamma_filter_query_marshal(const libcoopgamma_filter_query_t *restrict, void *restrict);
 
 /**
  * Unmarshal a `libcoopgamma_filter_query_t` from a buffer
@@ -1090,8 +1056,7 @@ size_t libcoopgamma_filter_query_marshal(const libcoopgamma_filter_query_t* rest
  *                `LIBCOOPGAMMA_INCOMPATIBLE_UPGRADE`, or `LIBCOOPGAMMA_ERRNO_SET`
  */
 LIBCOOPGAMMA_GCC_ONLY(__attribute__((__nonnull__, __leaf__)))
-int libcoopgamma_filter_query_unmarshal(libcoopgamma_filter_query_t* restrict,
-					const void* restrict, size_t* restrict);
+int libcoopgamma_filter_query_unmarshal(libcoopgamma_filter_query_t *restrict, const void *restrict, size_t *restrict);
 
 
 /**
@@ -1101,7 +1066,7 @@ int libcoopgamma_filter_query_unmarshal(libcoopgamma_filter_query_t* restrict,
  * @return        Zero on success, -1 on error
  */
 LIBCOOPGAMMA_GCC_ONLY(__attribute__((__nonnull__, __leaf__)))
-int libcoopgamma_queried_filter_initialise(libcoopgamma_queried_filter_t* restrict);
+int libcoopgamma_queried_filter_initialise(libcoopgamma_queried_filter_t *restrict);
 
 /**
  * Release all resources allocated to  a `libcoopgamma_queried_filter_t`,
@@ -1113,7 +1078,7 @@ int libcoopgamma_queried_filter_initialise(libcoopgamma_queried_filter_t* restri
  * @param  this  The record to destroy
  */
 LIBCOOPGAMMA_GCC_ONLY(__attribute__((__nonnull__)))
-void libcoopgamma_queried_filter_destroy(libcoopgamma_queried_filter_t* restrict);
+void libcoopgamma_queried_filter_destroy(libcoopgamma_queried_filter_t *restrict);
 
 /**
  * Marshal a `libcoopgamma_queried_filter_t` into a buffer
@@ -1126,8 +1091,7 @@ void libcoopgamma_queried_filter_destroy(libcoopgamma_queried_filter_t* restrict
  *                 how many bytes would be marshalled if `buf != NULL`
  */
 LIBCOOPGAMMA_GCC_ONLY(__attribute__((__nonnull__(1))))
-size_t libcoopgamma_queried_filter_marshal(const libcoopgamma_queried_filter_t* restrict, void* restrict,
-					   libcoopgamma_depth_t);
+size_t libcoopgamma_queried_filter_marshal(const libcoopgamma_queried_filter_t *restrict, void *restrict, libcoopgamma_depth_t);
 
 /**
  * Unmarshal a `libcoopgamma_queried_filter_t` from a buffer
@@ -1140,8 +1104,8 @@ size_t libcoopgamma_queried_filter_marshal(const libcoopgamma_queried_filter_t*
  *                 `LIBCOOPGAMMA_INCOMPATIBLE_UPGRADE`, or `LIBCOOPGAMMA_ERRNO_SET`
  */
 LIBCOOPGAMMA_GCC_ONLY(__attribute__((__nonnull__)))
-int libcoopgamma_queried_filter_unmarshal(libcoopgamma_queried_filter_t* restrict,
-					  const void* restrict, size_t* restrict, libcoopgamma_depth_t);
+int libcoopgamma_queried_filter_unmarshal(libcoopgamma_queried_filter_t *restrict, const void *restrict,
+                                          size_t *restrict, libcoopgamma_depth_t);
 
 
 /**
@@ -1151,7 +1115,7 @@ int libcoopgamma_queried_filter_unmarshal(libcoopgamma_queried_filter_t* restric
  * @return        Zero on success, -1 on error
  */
 LIBCOOPGAMMA_GCC_ONLY(__attribute__((__nonnull__, __leaf__)))
-int libcoopgamma_filter_table_initialise(libcoopgamma_filter_table_t* restrict);
+int libcoopgamma_filter_table_initialise(libcoopgamma_filter_table_t *restrict);
 
 /**
  * Release all resources allocated to  a `libcoopgamma_filter_table_t`,
@@ -1163,7 +1127,7 @@ int libcoopgamma_filter_table_initialise(libcoopgamma_filter_table_t* restrict);
  * @param  this  The record to destroy
  */
 LIBCOOPGAMMA_GCC_ONLY(__attribute__((__nonnull__)))
-void libcoopgamma_filter_table_destroy(libcoopgamma_filter_table_t* restrict);
+void libcoopgamma_filter_table_destroy(libcoopgamma_filter_table_t *restrict);
 
 /**
  * Marshal a `libcoopgamma_filter_table_t` into a buffer
@@ -1175,7 +1139,7 @@ void libcoopgamma_filter_table_destroy(libcoopgamma_filter_table_t* restrict);
  *                how many bytes would be marshalled if `buf != NULL`
  */
 LIBCOOPGAMMA_GCC_ONLY(__attribute__((__nonnull__(1))))
-size_t libcoopgamma_filter_table_marshal(const libcoopgamma_filter_table_t* restrict, void* restrict);
+size_t libcoopgamma_filter_table_marshal(const libcoopgamma_filter_table_t *restrict, void *restrict);
 
 /**
  * Unmarshal a `libcoopgamma_filter_table_t` from a buffer
@@ -1187,8 +1151,7 @@ size_t libcoopgamma_filter_table_marshal(const libcoopgamma_filter_table_t* rest
  *                `LIBCOOPGAMMA_INCOMPATIBLE_UPGRADE`, or `LIBCOOPGAMMA_ERRNO_SET`
  */
 LIBCOOPGAMMA_GCC_ONLY(__attribute__((__nonnull__)))
-int libcoopgamma_filter_table_unmarshal(libcoopgamma_filter_table_t* restrict,
-					const void* restrict, size_t* restrict);
+int libcoopgamma_filter_table_unmarshal(libcoopgamma_filter_table_t *restrict, const void *restrict, size_t *restrict);
 
 
 /**
@@ -1198,7 +1161,7 @@ int libcoopgamma_filter_table_unmarshal(libcoopgamma_filter_table_t* restrict,
  * @return        Zero on success, -1 on error
  */
 LIBCOOPGAMMA_GCC_ONLY(__attribute__((__nonnull__, __leaf__)))
-int libcoopgamma_error_initialise(libcoopgamma_error_t* restrict);
+int libcoopgamma_error_initialise(libcoopgamma_error_t *restrict);
 
 /**
  * Release all resources allocated to  a `libcoopgamma_error_t`,
@@ -1210,7 +1173,7 @@ int libcoopgamma_error_initialise(libcoopgamma_error_t* restrict);
  * @param  this  The record to destroy
  */
 LIBCOOPGAMMA_GCC_ONLY(__attribute__((__nonnull__, __leaf__)))
-void libcoopgamma_error_destroy(libcoopgamma_error_t* restrict);
+void libcoopgamma_error_destroy(libcoopgamma_error_t *restrict);
 
 /**
  * Marshal a `libcoopgamma_error_t` into a buffer
@@ -1222,7 +1185,7 @@ void libcoopgamma_error_destroy(libcoopgamma_error_t* restrict);
  *                how many bytes would be marshalled if `buf != NULL`
  */
 LIBCOOPGAMMA_GCC_ONLY(__attribute__((__nonnull__(1), __leaf__)))
-size_t libcoopgamma_error_marshal(const libcoopgamma_error_t* restrict, void* restrict);
+size_t libcoopgamma_error_marshal(const libcoopgamma_error_t *restrict, void *restrict);
 
 /**
  * Unmarshal a `libcoopgamma_error_t` from a buffer
@@ -1234,7 +1197,7 @@ size_t libcoopgamma_error_marshal(const libcoopgamma_error_t* restrict, void* re
  *                `LIBCOOPGAMMA_INCOMPATIBLE_UPGRADE`, or `LIBCOOPGAMMA_ERRNO_SET`
  */
 LIBCOOPGAMMA_GCC_ONLY(__attribute__((__nonnull__, __leaf__)))
-int libcoopgamma_error_unmarshal(libcoopgamma_error_t* restrict, const void* restrict, size_t* restrict);
+int libcoopgamma_error_unmarshal(libcoopgamma_error_t *restrict, const void *restrict, size_t *restrict);
 
 
 /**
@@ -1244,7 +1207,7 @@ int libcoopgamma_error_unmarshal(libcoopgamma_error_t* restrict, const void* res
  * @return        Zero on success, -1 on error
  */
 LIBCOOPGAMMA_GCC_ONLY(__attribute__((__nonnull__, __leaf__)))
-int libcoopgamma_context_initialise(libcoopgamma_context_t* restrict);
+int libcoopgamma_context_initialise(libcoopgamma_context_t *restrict);
 
 /**
  * Release all resources allocated to  a `libcoopgamma_context_t`,
@@ -1257,7 +1220,7 @@ int libcoopgamma_context_initialise(libcoopgamma_context_t* restrict);
  * @param  disconnect  Disconnect from the server?
  */
 LIBCOOPGAMMA_GCC_ONLY(__attribute__((__nonnull__)))
-void libcoopgamma_context_destroy(libcoopgamma_context_t* restrict, int);
+void libcoopgamma_context_destroy(libcoopgamma_context_t *restrict, int);
 
 /**
  * Marshal a `libcoopgamma_context_t` into a buffer
@@ -1269,7 +1232,7 @@ void libcoopgamma_context_destroy(libcoopgamma_context_t* restrict, int);
  *                how many bytes would be marshalled if `buf != NULL`
  */
 LIBCOOPGAMMA_GCC_ONLY(__attribute__((__nonnull__(1))))
-size_t libcoopgamma_context_marshal(const libcoopgamma_context_t* restrict, void* restrict);
+size_t libcoopgamma_context_marshal(const libcoopgamma_context_t *restrict, void *restrict);
 
 /**
  * Unmarshal a `libcoopgamma_context_t` from a buffer
@@ -1281,7 +1244,7 @@ size_t libcoopgamma_context_marshal(const libcoopgamma_context_t* restrict, void
  *                `LIBCOOPGAMMA_INCOMPATIBLE_UPGRADE`, or `LIBCOOPGAMMA_ERRNO_SET`
  */
 LIBCOOPGAMMA_GCC_ONLY(__attribute__((__nonnull__)))
-int libcoopgamma_context_unmarshal(libcoopgamma_context_t* restrict, const void* restrict, size_t* restrict);
+int libcoopgamma_context_unmarshal(libcoopgamma_context_t *restrict, const void *restrict, size_t *restrict);
 
 
 /**
@@ -1291,7 +1254,7 @@ int libcoopgamma_context_unmarshal(libcoopgamma_context_t* restrict, const void*
  * @return        Zero on success, -1 on error
  */
 LIBCOOPGAMMA_GCC_ONLY(__attribute__((__nonnull__, __leaf__)))
-int libcoopgamma_async_context_initialise(libcoopgamma_async_context_t* restrict);
+int libcoopgamma_async_context_initialise(libcoopgamma_async_context_t *restrict);
 
 /**
  * Release all resources allocated to  a `libcoopgamma_async_context_t`,
@@ -1303,7 +1266,7 @@ int libcoopgamma_async_context_initialise(libcoopgamma_async_context_t* restrict
  * @param  this  The record to destroy
  */
 LIBCOOPGAMMA_GCC_ONLY(__attribute__((__nonnull__, __leaf__)))
-void libcoopgamma_async_context_destroy(libcoopgamma_async_context_t* restrict);
+void libcoopgamma_async_context_destroy(libcoopgamma_async_context_t *restrict);
 
 /**
  * Marshal a `libcoopgamma_async_context_t` into a buffer
@@ -1315,7 +1278,7 @@ void libcoopgamma_async_context_destroy(libcoopgamma_async_context_t* restrict);
  *                how many bytes would be marshalled if `buf != NULL`
  */
 LIBCOOPGAMMA_GCC_ONLY(__attribute__((__nonnull__(1), __leaf__)))
-size_t libcoopgamma_async_context_marshal(const libcoopgamma_async_context_t* restrict, void* restrict);
+size_t libcoopgamma_async_context_marshal(const libcoopgamma_async_context_t *restrict, void *restrict);
 
 /**
  * Unmarshal a `libcoopgamma_async_context_t` from a buffer
@@ -1327,8 +1290,7 @@ size_t libcoopgamma_async_context_marshal(const libcoopgamma_async_context_t* re
  *                `LIBCOOPGAMMA_INCOMPATIBLE_UPGRADE`, or `LIBCOOPGAMMA_ERRNO_SET`
  */
 LIBCOOPGAMMA_GCC_ONLY(__attribute__((__nonnull__, __leaf__)))
-int libcoopgamma_async_context_unmarshal(libcoopgamma_async_context_t* restrict, const void* restrict,
-					 size_t* restrict);
+int libcoopgamma_async_context_unmarshal(libcoopgamma_async_context_t *restrict, const void *restrict, size_t *restrict);
 
 
 /**
@@ -1341,7 +1303,7 @@ int libcoopgamma_async_context_unmarshal(libcoopgamma_async_context_t* restrict,
  *          outer pointer and cannot be freed. `NULL` on error.
  */
 LIBCOOPGAMMA_GCC_ONLY(__attribute__((__malloc__)))
-char** libcoopgamma_get_methods(void);
+char **libcoopgamma_get_methods(void);
 
 /**
  * Get the adjustment method and site
@@ -1360,8 +1322,7 @@ char** libcoopgamma_get_methods(void);
  *                   with this parameter set to `NULL`.
  * @return           Zero on success, -1 on error
  */
-int libcoopgamma_get_method_and_site(const char* restrict, const char* restrict,
-				     char** restrict, char** restrict);
+int libcoopgamma_get_method_and_site(const char *restrict, const char *restrict, char **restrict, char **restrict);
 
 /**
  * Get the PID file of the coopgamma server
@@ -1375,7 +1336,7 @@ int libcoopgamma_get_method_and_site(const char* restrict, const char* restrict,
  *                   case is detected by checking that `errno` is set to 0.
  */
 LIBCOOPGAMMA_GCC_ONLY(__attribute__((__malloc__)))
-char* libcoopgamma_get_pid_file(const char* restrict, const char* restrict);
+char *libcoopgamma_get_pid_file(const char *restrict, const char *restrict);
 
 /**
  * Get the socket file of the coopgamma server
@@ -1391,7 +1352,7 @@ char* libcoopgamma_get_pid_file(const char* restrict, const char* restrict);
  *                   multi-server display server like mds.
  */
 LIBCOOPGAMMA_GCC_ONLY(__attribute__((__malloc__)))
-char* libcoopgamma_get_socket_file(const char* restrict, const char* restrict);
+char *libcoopgamma_get_socket_file(const char *restrict, const char *restrict);
 
 
 /**
@@ -1408,7 +1369,7 @@ char* libcoopgamma_get_socket_file(const char* restrict, const char* restrict);
  *                  to 0 if the server could not be initialised.
  */
 LIBCOOPGAMMA_GCC_ONLY(__attribute__((__nonnull__(3))))
-int libcoopgamma_connect(const char* restrict, const char* restrict, libcoopgamma_context_t* restrict);
+int libcoopgamma_connect(const char *restrict, const char *restrict, libcoopgamma_context_t *restrict);
 
 /**
  * By default communication is blocking, this function
@@ -1426,7 +1387,7 @@ int libcoopgamma_connect(const char* restrict, const char* restrict, libcoopgamm
  * @return               Zero on success, -1 on error
  */
 LIBCOOPGAMMA_GCC_ONLY(__attribute__((__nonnull__, __leaf__)))
-int libcoopgamma_set_nonblocking(libcoopgamma_context_t* restrict, int);
+int libcoopgamma_set_nonblocking(libcoopgamma_context_t *restrict, int);
 
 /**
  * Send all pending outbound data
@@ -1441,7 +1402,7 @@ int libcoopgamma_set_nonblocking(libcoopgamma_context_t* restrict, int);
  * @return       Zero on success, -1 on error
  */
 LIBCOOPGAMMA_GCC_ONLY(__attribute__((__nonnull__, __leaf__)))
-int libcoopgamma_flush(libcoopgamma_context_t* restrict);
+int libcoopgamma_flush(libcoopgamma_context_t *restrict);
 
 /**
  * Wait for the next message to be received
@@ -1463,8 +1424,7 @@ int libcoopgamma_flush(libcoopgamma_context_t* restrict);
  *                    beyond recover.
  */
 LIBCOOPGAMMA_GCC_ONLY(__attribute__((__nonnull__(1, 4), __leaf__)))
-int libcoopgamma_synchronise(libcoopgamma_context_t* restrict, libcoopgamma_async_context_t* restrict,
-			     size_t, size_t* restrict);
+int libcoopgamma_synchronise(libcoopgamma_context_t *restrict, libcoopgamma_async_context_t *restrict, size_t, size_t *restrict);
 
 /**
  * Tell the library that you will not be parsing a receive message
@@ -1472,7 +1432,7 @@ int libcoopgamma_synchronise(libcoopgamma_context_t* restrict, libcoopgamma_asyn
  * @param  ctx  The state of the library, must be connected
  */
 LIBCOOPGAMMA_GCC_ONLY(__attribute__((__nonnull__)))
-void libcoopgamma_skip_message(libcoopgamma_context_t* restrict);
+void libcoopgamma_skip_message(libcoopgamma_context_t *restrict);
 
 
 /**
@@ -1486,7 +1446,7 @@ void libcoopgamma_skip_message(libcoopgamma_context_t* restrict);
  * @return         Zero on success, -1 on error
  */
 LIBCOOPGAMMA_GCC_ONLY(__attribute__((__nonnull__)))
-int libcoopgamma_get_crtcs_send(libcoopgamma_context_t* restrict, libcoopgamma_async_context_t* restrict);
+int libcoopgamma_get_crtcs_send(libcoopgamma_context_t *restrict, libcoopgamma_async_context_t *restrict);
 
 /**
  * List all available CRTC:s, receive response part
@@ -1500,7 +1460,7 @@ int libcoopgamma_get_crtcs_send(libcoopgamma_context_t* restrict, libcoopgamma_a
  *                 for information about the error.
  */
 LIBCOOPGAMMA_GCC_ONLY(__attribute__((__malloc__, __nonnull__)))
-char** libcoopgamma_get_crtcs_recv(libcoopgamma_context_t* restrict, libcoopgamma_async_context_t* restrict);
+char **libcoopgamma_get_crtcs_recv(libcoopgamma_context_t *restrict, libcoopgamma_async_context_t *restrict);
 
 /**
  * List all available CRTC:s, synchronous version
@@ -1520,7 +1480,7 @@ char** libcoopgamma_get_crtcs_recv(libcoopgamma_context_t* restrict, libcoopgamm
  *               for information about the error.
  */
 LIBCOOPGAMMA_GCC_ONLY(__attribute__((__malloc__, __nonnull__)))
-char** libcoopgamma_get_crtcs_sync(libcoopgamma_context_t* restrict);
+char **libcoopgamma_get_crtcs_sync(libcoopgamma_context_t *restrict);
 
 
 /**
@@ -1535,8 +1495,7 @@ char** libcoopgamma_get_crtcs_sync(libcoopgamma_context_t* restrict);
  * @return         Zero on success, -1 on error
  */
 LIBCOOPGAMMA_GCC_ONLY(__attribute__((__nonnull__)))
-int libcoopgamma_get_gamma_info_send(const char* restrict, libcoopgamma_context_t* restrict,
-				     libcoopgamma_async_context_t* restrict);
+int libcoopgamma_get_gamma_info_send(const char *restrict, libcoopgamma_context_t *restrict, libcoopgamma_async_context_t *restrict);
 
 /**
  * Retrieve information about a CRTC:s gamma ramps, receive response part
@@ -1548,8 +1507,8 @@ int libcoopgamma_get_gamma_info_send(const char* restrict, libcoopgamma_context_
  *                 (rather than `errno`) is read for information about the error
  */
 LIBCOOPGAMMA_GCC_ONLY(__attribute__((__nonnull__)))
-int libcoopgamma_get_gamma_info_recv(libcoopgamma_crtc_info_t* restrict, libcoopgamma_context_t* restrict,
-				     libcoopgamma_async_context_t* restrict);
+int libcoopgamma_get_gamma_info_recv(libcoopgamma_crtc_info_t *restrict, libcoopgamma_context_t *restrict,
+                                     libcoopgamma_async_context_t *restrict);
 
 /**
  * Retrieve information about a CRTC:s gamma ramps, synchronous version
@@ -1568,8 +1527,7 @@ int libcoopgamma_get_gamma_info_recv(libcoopgamma_crtc_info_t* restrict, libcoop
  *                 (rather than `errno`) is read for information about the error
  */
 LIBCOOPGAMMA_GCC_ONLY(__attribute__((__nonnull__)))
-int libcoopgamma_get_gamma_info_sync(const char* restrict, libcoopgamma_crtc_info_t* restrict,
-				     libcoopgamma_context_t* restrict);
+int libcoopgamma_get_gamma_info_sync(const char *restrict, libcoopgamma_crtc_info_t *restrict, libcoopgamma_context_t *restrict);
 
 
 /**
@@ -1584,8 +1542,8 @@ int libcoopgamma_get_gamma_info_sync(const char* restrict, libcoopgamma_crtc_inf
  * @return         Zero on success, -1 on error
  */
 LIBCOOPGAMMA_GCC_ONLY(__attribute__((__nonnull__)))
-int libcoopgamma_get_gamma_send(const libcoopgamma_filter_query_t* restrict, libcoopgamma_context_t* restrict,
-				libcoopgamma_async_context_t* restrict);
+int libcoopgamma_get_gamma_send(const libcoopgamma_filter_query_t *restrict, libcoopgamma_context_t *restrict,
+                                libcoopgamma_async_context_t *restrict);
 
 /**
  * Retrieve the current gamma ramp adjustments, receive response part
@@ -1597,8 +1555,8 @@ int libcoopgamma_get_gamma_send(const libcoopgamma_filter_query_t* restrict, lib
  *                 (rather than `errno`) is read for information about the error
  */
 LIBCOOPGAMMA_GCC_ONLY(__attribute__((__nonnull__)))
-int libcoopgamma_get_gamma_recv(libcoopgamma_filter_table_t* restrict, libcoopgamma_context_t* restrict,
-				libcoopgamma_async_context_t* restrict);
+int libcoopgamma_get_gamma_recv(libcoopgamma_filter_table_t *restrict, libcoopgamma_context_t *restrict,
+                                libcoopgamma_async_context_t *restrict);
 
 /**
  * Retrieve the current gamma ramp adjustments, synchronous version
@@ -1617,9 +1575,9 @@ int libcoopgamma_get_gamma_recv(libcoopgamma_filter_table_t* restrict, libcoopga
  *                 (rather than `errno`) is read for information about the error
  */
 LIBCOOPGAMMA_GCC_ONLY(__attribute__((__nonnull__)))
-int libcoopgamma_get_gamma_sync(const libcoopgamma_filter_query_t* restrict,
-				libcoopgamma_filter_table_t* restrict,
-				libcoopgamma_context_t* restrict);
+int libcoopgamma_get_gamma_sync(const libcoopgamma_filter_query_t *restrict,
+                                libcoopgamma_filter_table_t *restrict,
+                                libcoopgamma_context_t *restrict);
 
 
 /**
@@ -1634,8 +1592,8 @@ int libcoopgamma_get_gamma_sync(const libcoopgamma_filter_query_t* restrict,
  * @return          Zero on success, -1 on error
  */
 LIBCOOPGAMMA_GCC_ONLY(__attribute__((__nonnull__)))
-int libcoopgamma_set_gamma_send(const libcoopgamma_filter_t* restrict,
-				libcoopgamma_context_t* restrict, libcoopgamma_async_context_t* restrict);
+int libcoopgamma_set_gamma_send(const libcoopgamma_filter_t *restrict, libcoopgamma_context_t *restrict,
+                                libcoopgamma_async_context_t *restrict);
 
 /**
  * Apply, update, or remove a gamma ramp adjustment, receive response part
@@ -1646,7 +1604,7 @@ int libcoopgamma_set_gamma_send(const libcoopgamma_filter_t* restrict,
  *                 (rather than `errno`) is read for information about the error
  */
 LIBCOOPGAMMA_GCC_ONLY(__attribute__((__nonnull__)))
-int libcoopgamma_set_gamma_recv(libcoopgamma_context_t* restrict, libcoopgamma_async_context_t* restrict);
+int libcoopgamma_set_gamma_recv(libcoopgamma_context_t *restrict, libcoopgamma_async_context_t *restrict);
 
 /**
  * Apply, update, or remove a gamma ramp adjustment, synchronous version
@@ -1664,7 +1622,7 @@ int libcoopgamma_set_gamma_recv(libcoopgamma_context_t* restrict, libcoopgamma_a
  *                  (rather than `errno`) is read for information about the error
  */
 LIBCOOPGAMMA_GCC_ONLY(__attribute__((__nonnull__)))
-int libcoopgamma_set_gamma_sync(const libcoopgamma_filter_t* restrict, libcoopgamma_context_t* restrict);
+int libcoopgamma_set_gamma_sync(const libcoopgamma_filter_t *restrict, libcoopgamma_context_t *restrict);
 
 
 
@@ -1674,7 +1632,4 @@ int libcoopgamma_set_gamma_sync(const libcoopgamma_filter_t* restrict, libcoopga
 
 #undef LIBCOOPGAMMA_GCC_ONLY
 
-
-
 #endif
-
diff --git a/src/libcoopgamma.c b/src/libcoopgamma.c
deleted file mode 100644
index 40baf77..0000000
--- a/src/libcoopgamma.c
+++ /dev/null
@@ -1,2620 +0,0 @@
-/**
- * libcoopgamma -- Library for interfacing with cooperative gamma servers
- * Copyright (C) 2016  Mattias Andrée (maandree@kth.se)
- * 
- * This library is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- * 
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- * 
- * You should have received a copy of the GNU General Public License
- * along with this library.  If not, see <http://www.gnu.org/licenses/>.
- */
-#define _DEFAULT_SOURCE
-#define _BSD_SOURCE
-
-#include "libcoopgamma.h"
-
-#include <sys/socket.h>
-#include <sys/un.h>
-#include <sys/wait.h>
-#include <errno.h>
-#include <fcntl.h>
-#include <inttypes.h>
-#include <poll.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
-
-
-
-#if !defined(COOPGAMMAD)
-# define COOPGAMMAD "coopgammad"
-#endif
-
-
-
-#if defined(__clang__)
-# pragma GCC diagnostic ignored "-Wdocumentation"
-# pragma GCC diagnostic ignored "-Wcovered-switch-default"
-# pragma GCC diagnostic ignored "-Wcast-align"
-#endif
-
-
-
-#if defined(__GNUC__)
-# define NAME_OF_THE_PROCESS  (argv0)
-extern const char* argv0;
-const char* argv0 __attribute__((weak)) = "libcoopgamma";
-#else
-# define NAME_OF_THE_PROCESS  ("libcoopgamma")
-#endif
-
-
-
-#define SUBBUF  \
-  (buf ? buf + off : NULL)
-
-#define NNSUBBUF  \
-  (buf + off)
-
-#define MARSHAL_PROLOGUE	\
-  char* restrict buf = vbuf;	\
-  size_t off = 0;
-
-#define UNMARSHAL_PROLOGUE		\
-  const char* restrict buf = vbuf;	\
-  size_t off = 0;
-
-#define MARSHAL_EPILOGUE  \
-  return off
-
-#define UNMARSHAL_EPILOGUE  \
-  return *np = off, LIBCOOPGAMMA_SUCCESS
-
-#define marshal_prim(datum, type)  \
-  ((buf != NULL ? *(type*)(buf + off) = (datum) : 0), off += sizeof(type))
-
-#define unmarshal_prim(datum, type)  \
-  ((datum) = *(const type*)(buf + off), off += sizeof(type))
-
-#define marshal_version(version)  \
-  marshal_prim(version, int)
-
-#define unmarshal_version(version)			\
-  do							\
-    {							\
-      int version__;					\
-      unmarshal_prim(version__, int);			\
-      if (version__ < (version))			\
-	return LIBCOOPGAMMA_INCOMPATIBLE_DOWNGRADE;	\
-      if (version__ > (version))			\
-	return LIBCOOPGAMMA_INCOMPATIBLE_UPGRADE;	\
-    }							\
-  while (0)
-
-#define marshal_buffer(data, n)  \
-  ((buf != NULL ? (memcpy(buf + off, (data), (n)), 0) : 0), off += (n))
-
-#define unmarshal_buffer(data, n)	\
-  do					\
-    {					\
-      (data) = malloc(n);		\
-      if ((data) == NULL)		\
-	return LIBCOOPGAMMA_ERRNO_SET;	\
-      memcpy((data), buf + off, (n));	\
-      off += (n);			\
-    }					\
-  while (0)
-
-#define marshal_string(datum)						\
-  ((datum) == NULL ? marshal_prim(0, char) :				\
-   (marshal_prim(1, char), marshal_buffer((datum), strlen(datum) + 1)))
-
-#define unmarshal_string(datum)					\
-  do								\
-    {								\
-      char nonnull__;						\
-      unmarshal_prim(nonnull__, char);				\
-      if (nonnull__)						\
-	unmarshal_buffer((datum), strlen(buf + off) + 1);	\
-      else							\
-	(datum) = NULL;						\
-    }								\
-  while (0)
-
-
-
-#define copy_errno(ctx)				\
-  ((errno == 0) ? NULL :			\
-   ((ctx)->error.number = (uint64_t)errno,	\
-    (ctx)->error.custom = 0,			\
-    (ctx)->error.server_side = 0,		\
-    free((ctx)->error.description),		\
-    (ctx)->error.description = NULL))
-
-
-#define SYNC_CALL(send_call, recv_call, fail_return)			\
-  libcoopgamma_async_context_t async;					\
-  size_t _selected;							\
-  if (send_call < 0)							\
-    {									\
-    reflush:								\
-      if (errno != EINTR)						\
-	return fail_return;						\
-      if (libcoopgamma_flush(ctx) < 0)					\
-	goto reflush;							\
-    }									\
-resync:									\
-  if (libcoopgamma_synchronise(ctx, &async, (size_t)1, &_selected) < 0)	\
-    {									\
-      if ((errno != EINTR) && (errno != 0))				\
-	return fail_return;						\
-      goto resync;							\
-    }									\
-  return recv_call
-
-
-#define INTEGRAL_DEPTHS		\
-  case LIBCOOPGAMMA_UINT8:	\
-  case LIBCOOPGAMMA_UINT16:	\
-  case LIBCOOPGAMMA_UINT32:	\
-  case LIBCOOPGAMMA_UINT64:
-
-
-
-/**
- * Initialise a `libcoopgamma_ramps8_t`, `libcoopgamma_ramps16_t`, `libcoopgamma_ramps32_t`,
- * `libcoopgamma_ramps64_t`, `libcoopgamma_rampsf_t`, or `libcoopgamma_rampsd_t`
- * 
- * `this->red_size`, `this->green_size`, and `this->blue_size` must already be set
- * 
- * @param   this   The record to initialise
- * @param   width  The `sizeof(*(this->red))`
- * @return         Zero on success, -1 on error
- */
-int libcoopgamma_ramps_initialise_(void* restrict this, size_t width)
-{
-  libcoopgamma_ramps8_t* restrict this8 = (libcoopgamma_ramps8_t* restrict)this;
-  this8->red = this8->green = this8->blue = NULL;
-  this8->red = malloc((this8->red_size + this8->green_size + this8->blue_size) * width);
-  if (this8->red == NULL)
-    return -1;
-  this8->green = this8->red   + this8->red_size   * width;
-  this8->blue  = this8->green + this8->green_size * width;
-  return 0;
-}
-
-
-/**
- * Release all resources allocated to  a `libcoopgamma_ramps8_t`, `libcoopgamma_ramps16_t`,
- * `libcoopgamma_ramps32_t`, `libcoopgamma_ramps64_t`, `libcoopgamma_rampsf_t`,
- * `libcoopgamma_rampsd_t`, or `libcoopgamma_ramps_t`, the allocation of the record
- * itself is not freed
- * 
- * Always call this function after failed call to `libcoopgamma_ramps_initialise`
- * or failed call to `libcoopgamma_ramps_unmarshal`
- * 
- * @param  this  The record to destroy
- */
-void libcoopgamma_ramps_destroy(void* restrict this)
-{
-  libcoopgamma_ramps8_t* restrict this8 = (libcoopgamma_ramps8_t* restrict)this;
-  free(this8->red);
-  this8->red = this8->green = this8->blue = NULL;
-}
-
-
-/**
- * Marshal a `libcoopgamma_ramps8_t`, `libcoopgamma_ramps16_t`, `libcoopgamma_ramps32_t`,
- * `libcoopgamma_ramps64_t`, `libcoopgamma_rampsf_t`, or `libcoopgamma_rampsd_t` into a buffer
- * 
- * @param   this   The record to marshal
- * @param   vbuf    The output buffer, `NULL` to only measure
- *                 how large this buffer has to be
- * @param   width  The `sizeof(*(this->red))`
- * @return         The number of marshalled bytes, or if `buf == NULL`,
- *                 how many bytes would be marshalled if `buf != NULL`
- */
-size_t libcoopgamma_ramps_marshal_(const void* restrict this, void* restrict vbuf, size_t width)
-{
-  const libcoopgamma_ramps8_t* restrict this8 = (const libcoopgamma_ramps8_t* restrict)this;
-  MARSHAL_PROLOGUE;
-  marshal_version(LIBCOOPGAMMA_RAMPS_VERSION);
-  marshal_prim(this8->red_size, size_t);
-  marshal_prim(this8->green_size, size_t);
-  marshal_prim(this8->blue_size, size_t);
-  marshal_buffer(this8->red, (this8->red_size + this8->green_size + this8->blue_size) * width);
-  MARSHAL_EPILOGUE;
-}
-
-
-/**
- * Unmarshal a `libcoopgamma_ramps8_t`, `libcoopgamma_ramps16_t`, `libcoopgamma_ramps32_t`,
- * `libcoopgamma_ramps64_t`, `libcoopgamma_rampsf_t`, or `libcoopgamma_rampsd_t` from a buffer
- * 
- * @param   this   The output parameter for unmarshalled record
- * @param   vbuf   The buffer with the marshalled record
- * @param   np     Output parameter for the number of unmarshalled bytes, undefined on failure
- * @param   width  The `sizeof(*(this->red))`
- * @return         `LIBCOOPGAMMA_SUCCESS` (0), `LIBCOOPGAMMA_INCOMPATIBLE_DOWNGRADE`,
- *                 `LIBCOOPGAMMA_INCOMPATIBLE_UPGRADE`, or `LIBCOOPGAMMA_ERRNO_SET`
- */
-int libcoopgamma_ramps_unmarshal_(void* restrict this, const void* restrict vbuf,
-				  size_t* restrict np, size_t width)
-{
-  libcoopgamma_ramps8_t* restrict this8 = (libcoopgamma_ramps8_t* restrict)this;
-  UNMARSHAL_PROLOGUE;
-  unmarshal_version(LIBCOOPGAMMA_RAMPS_VERSION);
-  unmarshal_prim(this8->red_size, size_t);
-  unmarshal_prim(this8->green_size, size_t);
-  unmarshal_prim(this8->blue_size, size_t);
-  unmarshal_buffer(this8->red, (this8->red_size + this8->green_size + this8->blue_size) * width);
-  this8->green = this8->red + this8->red_size * width;
-  this8->blue = this8->green + this8->green_size * width;
-  UNMARSHAL_EPILOGUE;
-}
-
-
-
-/**
- * Initialise a `libcoopgamma_filter_t`
- * 
- * @param   this  The record to initialise
- * @return        Zero on success, -1 on error
- */
-int libcoopgamma_filter_initialise(libcoopgamma_filter_t* restrict this)
-{
-  memset(this, 0, sizeof(*this));
-  return 0;
-}
-
-
-/**
- * Release all resources allocated to  a `libcoopgamma_filter_t`,
- * the allocation of the record itself is not freed
- * 
- * Always call this function after failed call to `libcoopgamma_filter_initialise`
- * or failed call to `libcoopgamma_filter_unmarshal`
- * 
- * @param  this  The record to destroy
- */
-void libcoopgamma_filter_destroy(libcoopgamma_filter_t* restrict this)
-{
-  free(this->crtc);
-  free(this->class);
-  free(this->ramps.u8.red);
-  memset(this, 0, sizeof(*this));
-}
-
-
-/**
- * Marshal a `libcoopgamma_filter_t` into a buffer
- * 
- * @param   this  The record to marshal
- * @param   vbuf  The output buffer, `NULL` to only measure
- *                how large this buffer has to be
- * @return        The number of marshalled bytes, or if `buf == NULL`,
- *                how many bytes would be marshalled if `buf != NULL`
- */
-size_t libcoopgamma_filter_marshal(const libcoopgamma_filter_t* restrict this, void* restrict vbuf)
-{
-  MARSHAL_PROLOGUE;
-  marshal_version(LIBCOOPGAMMA_FILTER_VERSION);
-  marshal_version(LIBCOOPGAMMA_DEPTH_VERSION);
-  marshal_version(LIBCOOPGAMMA_LIFESPAN_VERSION);
-  marshal_prim(this->depth, libcoopgamma_depth_t);
-  marshal_prim(this->priority, int64_t);
-  marshal_string(this->crtc);
-  marshal_string(this->class);
-  marshal_prim(this->lifespan, libcoopgamma_lifespan_t);
-  switch (this->depth)
-    {
-    case LIBCOOPGAMMA_UINT8:   off += libcoopgamma_ramps_marshal(&(this->ramps.u8),  SUBBUF);  break;
-    case LIBCOOPGAMMA_UINT16:  off += libcoopgamma_ramps_marshal(&(this->ramps.u16), SUBBUF);  break;
-    case LIBCOOPGAMMA_UINT32:  off += libcoopgamma_ramps_marshal(&(this->ramps.u32), SUBBUF);  break;
-    case LIBCOOPGAMMA_UINT64:  off += libcoopgamma_ramps_marshal(&(this->ramps.u64), SUBBUF);  break;
-    case LIBCOOPGAMMA_FLOAT:   off += libcoopgamma_ramps_marshal(&(this->ramps.f),   SUBBUF);  break;
-    case LIBCOOPGAMMA_DOUBLE:  off += libcoopgamma_ramps_marshal(&(this->ramps.d),   SUBBUF);  break;
-    default:
-      break;
-    }
-  MARSHAL_EPILOGUE;
-}
-
-
-/**
- * Unmarshal a `libcoopgamma_filter_t` from a buffer
- * 
- * @param   this  The output parameter for unmarshalled record
- * @param   vbuf  The buffer with the marshalled record
- * @param   np    Output parameter for the number of unmarshalled bytes, undefined on failure
- * @return        `LIBCOOPGAMMA_SUCCESS` (0), `LIBCOOPGAMMA_INCOMPATIBLE_DOWNGRADE`,
- *                `LIBCOOPGAMMA_INCOMPATIBLE_UPGRADE`, or `LIBCOOPGAMMA_ERRNO_SET`
- */
-int libcoopgamma_filter_unmarshal(libcoopgamma_filter_t* restrict this,
-				  const void* restrict vbuf, size_t* restrict np)
-{
-  int r = LIBCOOPGAMMA_SUCCESS;
-  size_t n = 0;
-  UNMARSHAL_PROLOGUE;
-  memset(this, 0, sizeof(*this));
-  unmarshal_version(LIBCOOPGAMMA_FILTER_VERSION);
-  unmarshal_version(LIBCOOPGAMMA_DEPTH_VERSION);
-  unmarshal_version(LIBCOOPGAMMA_LIFESPAN_VERSION);
-  unmarshal_prim(this->depth, libcoopgamma_depth_t);
-  unmarshal_prim(this->priority, int64_t);
-  unmarshal_string(this->crtc);
-  unmarshal_string(this->class);
-  unmarshal_prim(this->lifespan, libcoopgamma_lifespan_t);
-  switch (this->depth)
-    {
-    case LIBCOOPGAMMA_UINT8:   r = libcoopgamma_ramps_unmarshal(&(this->ramps.u8),  NNSUBBUF, &n);  break;
-    case LIBCOOPGAMMA_UINT16:  r = libcoopgamma_ramps_unmarshal(&(this->ramps.u16), NNSUBBUF, &n);  break;
-    case LIBCOOPGAMMA_UINT32:  r = libcoopgamma_ramps_unmarshal(&(this->ramps.u32), NNSUBBUF, &n);  break;
-    case LIBCOOPGAMMA_UINT64:  r = libcoopgamma_ramps_unmarshal(&(this->ramps.u64), NNSUBBUF, &n);  break;
-    case LIBCOOPGAMMA_FLOAT:   r = libcoopgamma_ramps_unmarshal(&(this->ramps.f),   NNSUBBUF, &n);  break;
-    case LIBCOOPGAMMA_DOUBLE:  r = libcoopgamma_ramps_unmarshal(&(this->ramps.d),   NNSUBBUF, &n);  break;
-    default:
-      break;
-    }
-  if (r != LIBCOOPGAMMA_SUCCESS)
-    return r;
-  off += n;
-  UNMARSHAL_EPILOGUE;
-}
-
-
-
-/**
- * Initialise a `libcoopgamma_crtc_info_t`
- * 
- * @param   this  The record to initialise
- * @return        Zero on success, -1 on error
- */
-int libcoopgamma_crtc_info_initialise(libcoopgamma_crtc_info_t* restrict this)
-{
-  memset(this, 0, sizeof(*this));
-  return 0;
-}
-
-
-/**
- * Release all resources allocated to  a `libcoopgamma_crtc_info_t`,
- * the allocation of the record itself is not freed
- * 
- * Always call this function after failed call to `libcoopgamma_crtc_info_initialise`
- * or failed call to `libcoopgamma_crtc_info_unmarshal`
- * 
- * @param  this  The record to destroy
- */
-#if defined(__GNUC__)
-__attribute__((__const__))
-#endif
-void libcoopgamma_crtc_info_destroy(libcoopgamma_crtc_info_t* restrict this)
-{
-  (void) this;
-}
-
-
-/**
- * Marshal a `libcoopgamma_crtc_info_t` into a buffer
- * 
- * @param   this  The record to marshal
- * @param   vbuf  The output buffer, `NULL` to only measure
- *                how large this buffer has to be
- * @return        The number of marshalled bytes, or if `buf == NULL`,
- *                how many bytes would be marshalled if `buf != NULL`
- */
-size_t libcoopgamma_crtc_info_marshal(const libcoopgamma_crtc_info_t* restrict this, void* restrict vbuf)
-{
-  MARSHAL_PROLOGUE;
-  marshal_version(LIBCOOPGAMMA_CRTC_INFO_VERSION);
-  marshal_version(LIBCOOPGAMMA_DEPTH_VERSION);
-  marshal_version(LIBCOOPGAMMA_SUPPORT_VERSION);
-  marshal_version(LIBCOOPGAMMA_COLOURSPACE_VERSION);
-  marshal_prim(this->cooperative, int);
-  marshal_prim(this->depth, libcoopgamma_depth_t);
-  marshal_prim(this->red_size, size_t);
-  marshal_prim(this->green_size, size_t);
-  marshal_prim(this->blue_size, size_t);
-  marshal_prim(this->supported, libcoopgamma_support_t);
-  marshal_prim(this->colourspace, libcoopgamma_colourspace_t);
-  marshal_prim(this->have_gamut, int);
-  marshal_prim(this->red_x, unsigned);
-  marshal_prim(this->red_y, unsigned);
-  marshal_prim(this->green_x, unsigned);
-  marshal_prim(this->green_y, unsigned);
-  marshal_prim(this->blue_x, unsigned);
-  marshal_prim(this->blue_y, unsigned);
-  marshal_prim(this->white_x, unsigned);
-  marshal_prim(this->white_y, unsigned);
-  MARSHAL_EPILOGUE;
-}
-
-
-/**
- * Unmarshal a `libcoopgamma_crtc_info_t` from a buffer
- * 
- * @param   this  The output parameter for unmarshalled record
- * @param   vbuf  The buffer with the marshalled record
- * @param   np    Output parameter for the number of unmarshalled bytes, undefined on failure
- * @return        `LIBCOOPGAMMA_SUCCESS` (0), `LIBCOOPGAMMA_INCOMPATIBLE_DOWNGRADE`,
- *                `LIBCOOPGAMMA_INCOMPATIBLE_UPGRADE`, or `LIBCOOPGAMMA_ERRNO_SET`
- */
-int libcoopgamma_crtc_info_unmarshal(libcoopgamma_crtc_info_t* restrict this,
-				     const void* restrict vbuf, size_t* restrict np)
-{
-  UNMARSHAL_PROLOGUE;
-  unmarshal_version(LIBCOOPGAMMA_CRTC_INFO_VERSION);
-  unmarshal_version(LIBCOOPGAMMA_DEPTH_VERSION);
-  unmarshal_version(LIBCOOPGAMMA_SUPPORT_VERSION);
-  unmarshal_version(LIBCOOPGAMMA_COLOURSPACE_VERSION);
-  unmarshal_prim(this->cooperative, int);
-  unmarshal_prim(this->depth, libcoopgamma_depth_t);
-  unmarshal_prim(this->red_size, size_t);
-  unmarshal_prim(this->green_size, size_t);
-  unmarshal_prim(this->blue_size, size_t);
-  unmarshal_prim(this->supported, libcoopgamma_support_t);
-  unmarshal_prim(this->colourspace, libcoopgamma_colourspace_t);
-  unmarshal_prim(this->have_gamut, int);
-  unmarshal_prim(this->red_x, unsigned);
-  unmarshal_prim(this->red_y, unsigned);
-  unmarshal_prim(this->green_x, unsigned);
-  unmarshal_prim(this->green_y, unsigned);
-  unmarshal_prim(this->blue_x, unsigned);
-  unmarshal_prim(this->blue_y, unsigned);
-  unmarshal_prim(this->white_x, unsigned);
-  unmarshal_prim(this->white_y, unsigned);
-  UNMARSHAL_EPILOGUE;
-}
-
-
-
-/**
- * Initialise a `libcoopgamma_filter_query_t`
- * 
- * @param   this  The record to initialise
- * @return        Zero on success, -1 on error
- */
-int libcoopgamma_filter_query_initialise(libcoopgamma_filter_query_t* restrict this)
-{
-  this->crtc = NULL;
-  this->coalesce = 0;
-  this->high_priority = INT64_MAX;
-  this->low_priority = INT64_MIN;
-  return 0;
-}
-
-
-/**
- * Release all resources allocated to  a `libcoopgamma_filter_query_t`,
- * the allocation of the record itself is not freed
- * 
- * Always call this function after failed call to `libcoopgamma_filter_query_initialise`
- * or failed call to `libcoopgamma_filter_query_unmarshal`
- * 
- * @param  this  The record to destroy
- */
-void libcoopgamma_filter_query_destroy(libcoopgamma_filter_query_t* restrict this)
-{
-  free(this->crtc), this->crtc = NULL;
-}
-
-
-/**
- * Marshal a `libcoopgamma_filter_query_t` into a buffer
- * 
- * @param   this  The record to marshal
- * @param   vbuf  The output buffer, `NULL` to only measure
- *                how large this buffer has to be
- * @return        The number of marshalled bytes, or if `buf == NULL`,
- *                how many bytes would be marshalled if `buf != NULL`
- */
-size_t libcoopgamma_filter_query_marshal(const libcoopgamma_filter_query_t* restrict this, void* restrict vbuf)
-{
-  MARSHAL_PROLOGUE;
-  marshal_version(LIBCOOPGAMMA_FILTER_QUERY_VERSION);
-  marshal_string(this->crtc);
-  marshal_prim(this->coalesce, int);
-  marshal_prim(this->high_priority, int64_t);
-  marshal_prim(this->low_priority, int64_t);
-  MARSHAL_EPILOGUE;
-}
-
-
-/**
- * Unmarshal a `libcoopgamma_filter_query_t` from a buffer
- * 
- * @param   this  The output parameter for unmarshalled record
- * @param   vbuf  The buffer with the marshalled record
- * @param   np    Output parameter for the number of unmarshalled bytes, undefined on failure
- * @return        `LIBCOOPGAMMA_SUCCESS` (0), `LIBCOOPGAMMA_INCOMPATIBLE_DOWNGRADE`,
- *                `LIBCOOPGAMMA_INCOMPATIBLE_UPGRADE`, or `LIBCOOPGAMMA_ERRNO_SET`
- */
-int libcoopgamma_filter_query_unmarshal(libcoopgamma_filter_query_t* restrict this,
-					const void* restrict vbuf, size_t* restrict np)
-{
-  UNMARSHAL_PROLOGUE;
-  this->crtc = NULL;
-  unmarshal_version(LIBCOOPGAMMA_FILTER_QUERY_VERSION);
-  unmarshal_string(this->crtc);
-  unmarshal_prim(this->coalesce, int);
-  unmarshal_prim(this->high_priority, int64_t);
-  unmarshal_prim(this->low_priority, int64_t);
-  UNMARSHAL_EPILOGUE;
-}
-
-
-
-/**
- * Initialise a `libcoopgamma_queried_filter_t`
- * 
- * @param   this  The record to initialise
- * @return        Zero on success, -1 on error
- */
-int libcoopgamma_queried_filter_initialise(libcoopgamma_queried_filter_t* restrict this)
-{
-  memset(this, 0, sizeof(*this));
-  return 0;
-}
-
-
-/**
- * Release all resources allocated to  a `libcoopgamma_queried_filter_t`,
- * the allocation of the record itself is not freed
- * 
- * Always call this function after failed call to `libcoopgamma_queried_filter_initialise`
- * or failed call to `libcoopgamma_queried_filter_unmarshal`
- * 
- * @param  this  The record to destroy
- */
-void libcoopgamma_queried_filter_destroy(libcoopgamma_queried_filter_t* restrict this)
-{
-  free(this->class), this->class = NULL;
-  libcoopgamma_ramps_destroy(&(this->ramps.u8));
-}
-
-
-/**
- * Marshal a `libcoopgamma_queried_filter_t` into a buffer
- * 
- * @param   this   The record to marshal
- * @param   vbuf   The output buffer, `NULL` to only measure
- *                 how large this buffer has to be
- * @param   depth  The type used of ramp stops
- * @return         The number of marshalled bytes, or if `buf == NULL`,
- *                 how many bytes would be marshalled if `buf != NULL`
- */
-size_t libcoopgamma_queried_filter_marshal(const libcoopgamma_queried_filter_t* restrict this,
-					   void* restrict vbuf, libcoopgamma_depth_t depth)
-{
-  MARSHAL_PROLOGUE;
-  marshal_version(LIBCOOPGAMMA_QUERIED_FILTER_VERSION);
-  marshal_prim(this->priority, int64_t);
-  marshal_string(this->class);
-  switch (depth)
-    {
-    case LIBCOOPGAMMA_UINT8:   off += libcoopgamma_ramps_marshal(&(this->ramps.u8),  SUBBUF);  break;
-    case LIBCOOPGAMMA_UINT16:  off += libcoopgamma_ramps_marshal(&(this->ramps.u16), SUBBUF);  break;
-    case LIBCOOPGAMMA_UINT32:  off += libcoopgamma_ramps_marshal(&(this->ramps.u32), SUBBUF);  break;
-    case LIBCOOPGAMMA_UINT64:  off += libcoopgamma_ramps_marshal(&(this->ramps.u64), SUBBUF);  break;
-    case LIBCOOPGAMMA_FLOAT:   off += libcoopgamma_ramps_marshal(&(this->ramps.f),   SUBBUF);  break;
-    case LIBCOOPGAMMA_DOUBLE:  off += libcoopgamma_ramps_marshal(&(this->ramps.d),   SUBBUF);  break;
-    default:
-      break;
-    }
-  MARSHAL_EPILOGUE;
-}
-
-
-/**
- * Unmarshal a `libcoopgamma_queried_filter_t` from a buffer
- * 
- * @param   this   The output parameter for unmarshalled record
- * @param   vbuf   The buffer with the marshalled record
- * @param   np     Output parameter for the number of unmarshalled bytes, undefined on failure
- * @param   depth  The type used of ramp stops
- * @return         `LIBCOOPGAMMA_SUCCESS` (0), `LIBCOOPGAMMA_INCOMPATIBLE_DOWNGRADE`,
- *                 `LIBCOOPGAMMA_INCOMPATIBLE_UPGRADE`, or `LIBCOOPGAMMA_ERRNO_SET`
- */
-int libcoopgamma_queried_filter_unmarshal(libcoopgamma_queried_filter_t* restrict this,
-					  const void* restrict vbuf, size_t* restrict np,
-					  libcoopgamma_depth_t depth)
-{
-  int r = LIBCOOPGAMMA_SUCCESS;
-  size_t n = 0;
-  UNMARSHAL_PROLOGUE;
-  memset(this, 0, sizeof(*this));
-  unmarshal_version(LIBCOOPGAMMA_QUERIED_FILTER_VERSION);
-  unmarshal_prim(this->priority, int64_t);
-  unmarshal_string(this->class);
-  switch (depth)
-    {
-    case LIBCOOPGAMMA_UINT8:   r = libcoopgamma_ramps_unmarshal(&(this->ramps.u8),  NNSUBBUF, &n);  break;
-    case LIBCOOPGAMMA_UINT16:  r = libcoopgamma_ramps_unmarshal(&(this->ramps.u16), NNSUBBUF, &n);  break;
-    case LIBCOOPGAMMA_UINT32:  r = libcoopgamma_ramps_unmarshal(&(this->ramps.u32), NNSUBBUF, &n);  break;
-    case LIBCOOPGAMMA_UINT64:  r = libcoopgamma_ramps_unmarshal(&(this->ramps.u64), NNSUBBUF, &n);  break;
-    case LIBCOOPGAMMA_FLOAT:   r = libcoopgamma_ramps_unmarshal(&(this->ramps.f),   NNSUBBUF, &n);  break;
-    case LIBCOOPGAMMA_DOUBLE:  r = libcoopgamma_ramps_unmarshal(&(this->ramps.d),   NNSUBBUF, &n);  break;
-    default:
-      break;
-    }
-  if (r != LIBCOOPGAMMA_SUCCESS)
-    return r;
-  off += n;
-  UNMARSHAL_EPILOGUE;
-}
-
-
-
-/**
- * Initialise a `libcoopgamma_filter_table_t`
- * 
- * @param   this  The record to initialise
- * @return        Zero on success, -1 on error
- */
-int libcoopgamma_filter_table_initialise(libcoopgamma_filter_table_t* restrict this)
-{
-  memset(this, 0, sizeof(*this));
-  return 0;
-}
-
-
-/**
- * Release all resources allocated to  a `libcoopgamma_filter_table_t`,
- * the allocation of the record itself is not freed
- * 
- * Always call this function after failed call to `libcoopgamma_filter_table_initialise`
- * or failed call to `libcoopgamma_filter_table_unmarshal`
- * 
- * @param  this  The record to destroy
- */
-void libcoopgamma_filter_table_destroy(libcoopgamma_filter_table_t* restrict this)
-{
-  while (this->filter_count)
-    libcoopgamma_queried_filter_destroy(this->filters + --(this->filter_count));
-  free(this->filters), this->filters = NULL;
-}
-
-
-/**
- * Marshal a `libcoopgamma_filter_table_t` into a buffer
- * 
- * @param   this  The record to marshal
- * @param   vbuf  The output buffer, `NULL` to only measure
- *                how large this buffer has to be
- * @return        The number of marshalled bytes, or if `buf == NULL`,
- *                how many bytes would be marshalled if `buf != NULL`
- */
-size_t libcoopgamma_filter_table_marshal(const libcoopgamma_filter_table_t* restrict this, void* restrict vbuf)
-{
-  size_t i;
-  MARSHAL_PROLOGUE;
-  marshal_version(LIBCOOPGAMMA_FILTER_TABLE_VERSION);
-  marshal_version(LIBCOOPGAMMA_DEPTH_VERSION);
-  marshal_prim(this->depth, libcoopgamma_depth_t);
-  marshal_prim(this->red_size, size_t);
-  marshal_prim(this->green_size, size_t);
-  marshal_prim(this->blue_size, size_t);
-  marshal_prim(this->filter_count, size_t);
-  for (i = 0; i < this->filter_count; i++)
-    off += libcoopgamma_queried_filter_marshal(this->filters + i, SUBBUF, this->depth);
-  MARSHAL_EPILOGUE;
-}
-
-
-/**
- * Unmarshal a `libcoopgamma_filter_table_t` from a buffer
- * 
- * @param   this  The output parameter for unmarshalled record
- * @param   vbuf  The buffer with the marshalled record
- * @param   np    Output parameter for the number of unmarshalled bytes, undefined on failure
- * @return        `LIBCOOPGAMMA_SUCCESS` (0), `LIBCOOPGAMMA_INCOMPATIBLE_DOWNGRADE`,
- *                `LIBCOOPGAMMA_INCOMPATIBLE_UPGRADE`, or `LIBCOOPGAMMA_ERRNO_SET`
- */
-int libcoopgamma_filter_table_unmarshal(libcoopgamma_filter_table_t* restrict this,
-					const void* restrict vbuf, size_t* restrict np)
-{
-  size_t i, n, fn;
-  int r;
-  UNMARSHAL_PROLOGUE;
-  this->filter_count = 0;
-  this->filters = NULL;
-  unmarshal_version(LIBCOOPGAMMA_FILTER_TABLE_VERSION);
-  unmarshal_version(LIBCOOPGAMMA_DEPTH_VERSION);
-  unmarshal_prim(this->depth, libcoopgamma_depth_t);
-  unmarshal_prim(this->red_size, size_t);
-  unmarshal_prim(this->green_size, size_t);
-  unmarshal_prim(this->blue_size, size_t);
-  unmarshal_prim(fn, size_t);
-  this->filters = malloc(fn * sizeof(*(this->filters)));
-  if (this->filters == NULL)
-    return LIBCOOPGAMMA_ERRNO_SET;
-  for (i = 0; i < fn; i++)
-    {
-      r = libcoopgamma_queried_filter_unmarshal(this->filters + i, NNSUBBUF, &n, this->depth);
-      if (r != LIBCOOPGAMMA_SUCCESS)
-	return r;
-      off += n;
-      this->filter_count += 1;
-    }
-  UNMARSHAL_EPILOGUE;
-}
-
-
-
-/**
- * Initialise a `libcoopgamma_error_t`
- * 
- * @param   this  The record to initialise
- * @return        Zero on success, -1 on error
- */
-int libcoopgamma_error_initialise(libcoopgamma_error_t* restrict this)
-{
-  this->number = 0;
-  this->custom = 0;
-  this->description = NULL;
-  return 0;
-}
-
-
-/**
- * Release all resources allocated to  a `libcoopgamma_error_t`,
- * the allocation of the record itself is not freed
- * 
- * Always call this function after failed call to `libcoopgamma_error_initialise`
- * or failed call to `libcoopgamma_error_unmarshal`
- * 
- * @param  this  The record to destroy
- */
-void libcoopgamma_error_destroy(libcoopgamma_error_t* restrict this)
-{
-  free(this->description), this->description = NULL;
-}
-
-
-/**
- * Marshal a `libcoopgamma_error_t` into a buffer
- * 
- * @param   this  The record to marshal
- * @param   vbuf  The output buffer, `NULL` to only measure
- *                how large this buffer has to be
- * @return        The number of marshalled bytes, or if `buf == NULL`,
- *                how many bytes would be marshalled if `buf != NULL`
- */
-size_t libcoopgamma_error_marshal(const libcoopgamma_error_t* restrict this, void* restrict vbuf)
-{
-  MARSHAL_PROLOGUE;
-  marshal_version(LIBCOOPGAMMA_ERROR_VERSION);
-  marshal_prim(this->number, uint64_t);
-  marshal_prim(this->custom, int);
-  marshal_prim(this->server_side, int);
-  marshal_string(this->description);
-  MARSHAL_EPILOGUE;
-}
-
-
-/**
- * Unmarshal a `libcoopgamma_error_t` from a buffer
- * 
- * @param   this  The output parameter for unmarshalled record
- * @param   vbuf  The buffer with the marshalled record
- * @param   np    Output parameter for the number of unmarshalled bytes, undefined on failure
- * @return        `LIBCOOPGAMMA_SUCCESS` (0), `LIBCOOPGAMMA_INCOMPATIBLE_DOWNGRADE`,
- *                `LIBCOOPGAMMA_INCOMPATIBLE_UPGRADE`, or `LIBCOOPGAMMA_ERRNO_SET`
- */
-int libcoopgamma_error_unmarshal(libcoopgamma_error_t* restrict this,
-				 const void* restrict vbuf, size_t* restrict np)
-{
-  UNMARSHAL_PROLOGUE;
-  this->description = NULL;
-  unmarshal_version(LIBCOOPGAMMA_ERROR_VERSION);
-  unmarshal_prim(this->number, uint64_t);
-  unmarshal_prim(this->custom, int);
-  unmarshal_prim(this->server_side, int);
-  unmarshal_string(this->description);
-  UNMARSHAL_EPILOGUE;
-}
-
-
-
-/**
- * Initialise a `libcoopgamma_context_t`
- * 
- * @param   this  The record to initialise
- * @return        Zero on success, -1 on error
- */
-int libcoopgamma_context_initialise(libcoopgamma_context_t* restrict this)
-{
-  memset(this, 0, sizeof(*this));
-  this->fd = -1;
-  this->blocking = 1;
-  return 0;
-}
-
-
-/**
- * Release all resources allocated to  a `libcoopgamma_context_t`,
- * the allocation of the record itself is not freed
- * 
- * Always call this function after failed call to `libcoopgamma_context_initialise`
- * or failed call to `libcoopgamma_context_unmarshal`
- * 
- * @param  this        The record to destroy
- * @param  disconnect  Disconnect from the server?
- */
-void libcoopgamma_context_destroy(libcoopgamma_context_t* restrict this, int disconnect)
-{
-  if (disconnect && (this->fd >= 0))
-    {
-      shutdown(this->fd, SHUT_RDWR);
-      close(this->fd);
-    }
-  this->fd = -1;
-  libcoopgamma_error_destroy(&(this->error));
-  free(this->outbound), this->outbound = NULL;
-  free(this->inbound), this->inbound = NULL;
-}
-
-
-/**
- * Marshal a `libcoopgamma_context_t` into a buffer
- * 
- * @param   this  The record to marshal
- * @param   vbuf  The output buffer, `NULL` to only measure
- *                how large this buffer has to be
- * @return        The number of marshalled bytes, or if `buf == NULL`,
- *                how many bytes would be marshalled if `buf != NULL`
- */
-size_t libcoopgamma_context_marshal(const libcoopgamma_context_t* restrict this, void* restrict vbuf)
-{
-  MARSHAL_PROLOGUE;
-  marshal_version(LIBCOOPGAMMA_CONTEXT_VERSION);
-  marshal_prim(this->fd, int);
-  off += libcoopgamma_error_marshal(&(this->error), SUBBUF);
-  marshal_prim(this->message_id, uint32_t);
-  marshal_prim(this->outbound_head - this->outbound_tail, size_t);
-  marshal_buffer(this->outbound + this->outbound_tail, this->outbound_head - this->outbound_tail);
-  marshal_prim(this->inbound_head - this->inbound_tail, size_t);
-  marshal_buffer(this->inbound + this->inbound_tail, this->inbound_head - this->inbound_tail);
-  marshal_prim(this->length, size_t);
-  marshal_prim(this->curline, size_t);
-  marshal_prim(this->in_response_to, uint32_t);
-  marshal_prim(this->have_all_headers, int);
-  marshal_prim(this->bad_message, int);
-  marshal_prim(this->blocking, int);
-  MARSHAL_EPILOGUE;
-}
-
-
-/**
- * Unmarshal a `libcoopgamma_context_t` from a buffer
- * 
- * @param   this  The output parameter for unmarshalled record
- * @param   vbuf  The buffer with the marshalled record
- * @param   np    Output parameter for the number of unmarshalled bytes, undefined on failure
- * @return        `LIBCOOPGAMMA_SUCCESS` (0), `LIBCOOPGAMMA_INCOMPATIBLE_DOWNGRADE`,
- *                `LIBCOOPGAMMA_INCOMPATIBLE_UPGRADE`, or `LIBCOOPGAMMA_ERRNO_SET`
- */
-int libcoopgamma_context_unmarshal(libcoopgamma_context_t* restrict this,
-				   const void* restrict vbuf, size_t* restrict np)
-{
-  size_t n;
-  int r;
-  UNMARSHAL_PROLOGUE;
-  memset(this, 0, sizeof(*this));
-  unmarshal_version(LIBCOOPGAMMA_CONTEXT_VERSION);
-  unmarshal_prim(this->fd, int);
-  r = libcoopgamma_error_unmarshal(&(this->error), NNSUBBUF, &n);
-  if (r != LIBCOOPGAMMA_SUCCESS)
-    return r;
-  off += n;
-  unmarshal_prim(this->message_id, uint32_t);
-  unmarshal_prim(this->outbound_head, size_t);
-  this->outbound_size = this->outbound_head;
-  unmarshal_buffer(this->outbound, this->outbound_head);
-  unmarshal_prim(this->inbound_head, size_t);
-  this->inbound_size = this->inbound_head;
-  unmarshal_buffer(this->inbound, this->inbound_head);
-  unmarshal_prim(this->length, size_t);
-  unmarshal_prim(this->curline, size_t);
-  unmarshal_prim(this->in_response_to, uint32_t);
-  unmarshal_prim(this->have_all_headers, int);
-  unmarshal_prim(this->bad_message, int);
-  unmarshal_prim(this->blocking, int);
-  UNMARSHAL_EPILOGUE;
-}
-
-
-
-/**
- * Initialise a `libcoopgamma_async_context_t`
- * 
- * @param   this  The record to initialise
- * @return        Zero on success, -1 on error
- */
-int libcoopgamma_async_context_initialise(libcoopgamma_async_context_t* restrict this)
-{
-  this->message_id = 0;
-  this->coalesce = 0;
-  return 0;
-}
-
-
-/**
- * Release all resources allocated to  a `libcoopgamma_async_context_t`,
- * the allocation of the record itself is not freed
- * 
- * Always call this function after failed call to `libcoopgamma_async_context_initialise`
- * or failed call to `libcoopgamma_async_context_unmarshal`
- * 
- * @param  this  The record to destroy
- */
-#if defined(__GNUC__)
-__attribute__((__const__))
-#endif
-void libcoopgamma_async_context_destroy(libcoopgamma_async_context_t* restrict this)
-{
-  (void) this;
-}
-
-
-/**
- * Marshal a `libcoopgamma_async_context_t` into a buffer
- * 
- * @param   this  The record to marshal
- * @param   vbuf  The output buffer, `NULL` to only measure
- *                how large this buffer has to be
- * @return        The number of marshalled bytes, or if `buf == NULL`,
- *                how many bytes would be marshalled if `buf != NULL`
- */
-size_t libcoopgamma_async_context_marshal(const libcoopgamma_async_context_t* restrict this,
-					  void* restrict vbuf)
-{
-  MARSHAL_PROLOGUE;
-  marshal_version(LIBCOOPGAMMA_ASYNC_CONTEXT_VERSION);
-  marshal_prim(this->message_id, uint32_t);
-  marshal_prim(this->coalesce, int);
-  MARSHAL_EPILOGUE;
-}
-
-
-/**
- * Unmarshal a `libcoopgamma_async_context_t` from a buffer
- * 
- * @param   this  The output parameter for unmarshalled record
- * @param   vbuf  The buffer with the marshalled record
- * @param   np    Output parameter for the number of unmarshalled bytes, undefined on failure
- * @return        `LIBCOOPGAMMA_SUCCESS` (0), `LIBCOOPGAMMA_INCOMPATIBLE_DOWNGRADE`,
- *                `LIBCOOPGAMMA_INCOMPATIBLE_UPGRADE`, or `LIBCOOPGAMMA_ERRNO_SET`
- */
-int libcoopgamma_async_context_unmarshal(libcoopgamma_async_context_t* restrict this,
-					 const void* restrict vbuf, size_t* restrict np)
-{
-  UNMARSHAL_PROLOGUE;
-  unmarshal_version(LIBCOOPGAMMA_ASYNC_CONTEXT_VERSION);
-  unmarshal_prim(this->message_id, uint32_t);
-  unmarshal_prim(this->coalesce, int);
-  UNMARSHAL_EPILOGUE;
-}
-
-
-
-/**
- * List all recognised adjustment method
- * 
- * SIGCHLD must not be ignored or blocked
- * 
- * @return  A `NULL`-terminated list of names. You should only free
- *          the outer pointer, inner pointers are subpointers of the
- *          outer pointer and cannot be freed. `NULL` on error.
- */
-char** libcoopgamma_get_methods(void)
-{
-  char num[5]; /* The size is base on the fact that we have limited `n` in the loop below */
-  char** methods = NULL;
-  char** rc;
-  char* buffer;
-  int n = 0, saved_errno;
-  size_t size = 0;
-  
-  methods = malloc(4 * sizeof(*methods));
-  if (methods == NULL)
-    goto fail;
-  
-  for (n = 0; n < 10000 /* just to be safe */; n++)
-    {
-      char* method;
-      if ((n >= 4) && ((n & -n) == n))
-	{
-	  void* new = realloc(methods, (size_t)(n << 1) * sizeof(*methods));
-	  if (new == NULL)
-	    goto fail;
-	  methods = new;
-	}
-      sprintf(num, "%i", n);
-      if (libcoopgamma_get_method_and_site(num, NULL, &method, NULL))
-	goto fail;
-      if (!strcmp(method, num))
-	{
-	  free(method);
-	  break;
-	}
-      methods[n] = method;
-      size += strlen(method) + 1;
-    }
-  
-  rc = malloc((size_t)(n + 1) * sizeof(char*) + size);
-  if (rc == NULL)
-    goto fail;
-  buffer = ((char*)rc) + (size_t)(n + 1) * sizeof(char*);
-  rc[n] = NULL;
-  while (n--)
-    {
-      rc[n] = buffer;
-      buffer = stpcpy(buffer, methods[n]) + 1;
-      free(methods[n]);
-    }
-  free(methods);
-  
-  return rc;
-  
- fail:
-  saved_errno = errno;
-  while (n--)
-    free(methods[n]);
-  free(methods);
-  errno = saved_errno;
-  return NULL;
-}
-
-
-/**
- * Run coopgammad with -q or -qq and return the response
- * 
- * SIGCHLD must not be ignored or blocked
- * 
- * @param   method   The adjustment method, `NULL` for automatic
- * @param   site     The site, `NULL` for automatic
- * @param   arg      "-q" or "-qq", which shall be passed to coopgammad?
- * @return           The output of coopgammad, `NULL` on error. This
- *                   will be NUL-terminated and will not contain any
- *                   other `NUL` bytes.
- */
-static char* libcoopgamma_query(const char* restrict method, const char* restrict site, const char* restrict arg)
-{
-  const char* (args[7]) = {COOPGAMMAD, arg};
-  size_t i = 2, n = 0, size = 0;
-  int pipe_rw[2] = { -1, -1 };
-  pid_t pid;
-  int saved_errno, status;
-  char* msg = NULL;
-  ssize_t got;
-  
-  if (method != NULL)  args[i++] = "-m", args[i++] = method;
-  if (site   != NULL)  args[i++] = "-s", args[i++] = site;
-  args[i] = NULL;
-  
-  if (pipe(pipe_rw) < 0)
-    goto fail;
-  
-  switch ((pid = fork()))
-    {
-    case -1:
-      goto fail;
-    case 0:
-      /* Child */
-      close(pipe_rw[0]);
-      if (pipe_rw[1] != STDOUT_FILENO)
-	{
-	  close(STDOUT_FILENO);
-	  if (dup2(pipe_rw[1], STDOUT_FILENO) < 0)
-	    goto fail_child;
-	  close(pipe_rw[1]);
-	}
-#if defined(__GNUC__)
-# pragma GCC diagnostic push
-# pragma GCC diagnostic ignored "-Wcast-qual"
-#endif
-      execvp(COOPGAMMAD, (char* const*)(args));
-#if defined(__GNUC__)
-# pragma GCC diagnostic pop
-#endif
-    fail_child:
-      saved_errno = errno;
-      perror(NAME_OF_THE_PROCESS);
-      if (write(STDOUT_FILENO, &saved_errno, sizeof(int)) != sizeof(int))
-	perror(NAME_OF_THE_PROCESS);
-      exit(1);
-    default:
-      /* Parent */
-      close(pipe_rw[1]), pipe_rw[1] = -1;
-      for (;;)
-	{
-	  if (n == size)
-	    {
-	      void* new = realloc(msg, size = (n ? (n << 1) : 256));
-	      if (new == NULL)
-		goto fail;
-	      msg = new;
-	    }
-	  got = read(pipe_rw[0], msg + n, size - n);
-	  if (got < 0)
-	    {
-	      if (errno == EINTR)
-		continue;
-	      goto fail;
-	    }
-	  else if (got == 0)
-	    break;
-	  n += (size_t)got;
-	}
-      close(pipe_rw[0]), pipe_rw[0] = -1;
-      if (waitpid(pid, &status, 0) < 0)
-	goto fail;
-      if (status)
-	{
-	  errno = EINVAL;
-	  if ((n == sizeof(int)) && (*(int*)msg != 0))
-	    errno = *(int*)msg;
-	}
-      break;
-    }
-  
-  if (n == size)
-    {
-      void* new = realloc(msg, n + 1);
-      if (new == NULL)
-	goto fail;
-      msg = new;
-    }
-  msg[n] = '\0';
-  
-  if (strchr(msg, '\0') != msg + n)
-    {
-      errno = EBADMSG;
-      goto fail;
-    }
-  
-  return msg;
- fail:
-  saved_errno = errno;
-  if (pipe_rw[0] >= 0)  close(pipe_rw[0]);
-  if (pipe_rw[1] >= 0)  close(pipe_rw[1]);
-  free(msg);
-  errno = saved_errno;
-  return NULL;
-}
-
-
-/**
- * Get the adjustment method and site
- * 
- * SIGCHLD must not be ignored or blocked
- * 
- * @param   method   The adjustment method, `NULL` for automatic
- * @param   site     The site, `NULL` for automatic
- * @param   methodp  Output pointer for the selected adjustment method,
- *                   which cannot be `NULL`. It is safe to call
- *                   this function with this parameter set to `NULL`.
- * @param   sitep    Output pointer for the selected site, which will
- *                   be `NULL` the method only supports one site or if
- *                   `site == NULL` and no site can be selected
- *                   automatically. It is safe to call this function
- *                   with this parameter set to `NULL`.
- * @return           Zero on success, -1 on error
- */
-int libcoopgamma_get_method_and_site(const char* restrict method, const char* restrict site,
-				     char** restrict methodp, char** restrict sitep)
-{
-  int saved_errno;
-  char* raw;
-  char* p;
-  char* q;
-  
-  raw = libcoopgamma_query(method, site, "-q");
-  if (raw == NULL)
-    return -1;
-  
-  if (methodp != NULL)  *methodp = NULL;
-  if (sitep   != NULL)  *sitep   = NULL;
-  
-  p = strchr(raw, '\n');
-  if (p == NULL)
-    {
-      errno = EBADMSG;
-      goto fail;
-    }
-  *p++ = '\0';
-  
-  if (methodp != NULL)
-    {
-      *methodp = malloc(strlen(raw) + 1);
-      if (*methodp == NULL)
-	goto fail;
-      strcpy(*methodp, raw);
-    }
-  
-  if ((site != NULL) && *(q = strchr(p, '\0') - 1))
-    {
-      if (*q != '\n')
-	{
-	   errno = EBADMSG;
-	   goto fail;
-	}
-      *q = '\0';
-      *sitep = malloc(strlen(p) + 1);
-      if (*sitep == NULL)
-	goto fail;
-      strcpy(*sitep, p);
-    }
-  
-  free(raw);
-  return 0;
- fail:
-  saved_errno = errno;
-  if (methodp != NULL)
-    free(*methodp), *methodp = NULL;
-  free(raw);
-  errno = saved_errno;
-  return -1;
-}
-
-
-/**
- * Get the PID file of the coopgamma server
- * 
- * SIGCHLD must not be ignored or blocked
- * 
- * @param   method   The adjustment method, `NULL` for automatic
- * @param   site     The site, `NULL` for automatic
- * @return           The pathname of the server's PID file, `NULL` on error
- *                   or if there server does not use PID files. The later
- *                   case is detected by checking that `errno` is set to 0.
- */
-char* libcoopgamma_get_pid_file(const char* restrict method, const char* restrict site)
-{
-  char* path;
-  size_t n;
-  
-  path = libcoopgamma_get_socket_file(method, site);
-  if (path == NULL)
-    return NULL;
-  
-  n = strlen(path);
-  if (n < 7 || strcmp(path + n - 7, ".socket"))
-    {
-      free(path);
-      errno = EBADMSG;
-      return NULL;
-    }
-  
-  strcpy(path + n - 7, ".pid");
-  return path;
-}
-
-
-/**
- * Get the socket file of the coopgamma server
- * 
- * SIGCHLD must not be ignored or blocked
- * 
- * @param   method   The adjustment method, `NULL` for automatic
- * @param   site     The site, `NULL` for automatic
- * @return           The pathname of the server's socket, `NULL` on error
- *                   or if there server does have its own socket. The later
- *                   case is detected by checking that `errno` is set to 0,
- *                   and is the case when communicating with a server in a
- *                   multi-server display server like mds.
- */
-char* libcoopgamma_get_socket_file(const char* restrict method, const char* restrict site)
-{
-  int saved_errno;
-  char* raw;
-  char* p;
-  
-  raw = libcoopgamma_query(method, site, "-qq");
-  if (raw == NULL)
-    return NULL;
-  
-  p = strchr(raw, '\0') - 1;
-  if ((p < raw) || (*p != '\n'))
-    {
-      errno = EBADMSG;
-      goto fail;
-    }
-  *p = '\0';
-  if (*raw == '\0')
-    {
-      errno = EBADMSG;
-      goto fail;
-    }
-  
-  return raw;
- fail:
-  saved_errno = errno;
-  free(raw);
-  errno = saved_errno;
-  return NULL;
-}
-
-
-
-/**
- * Connect to a coopgamma server, and start it if necessary
- * 
- * Use `libcoopgamma_context_destroy` to disconnect
- * 
- * SIGCHLD must not be ignored or blocked
- * 
- * @param   method  The adjustment method, `NULL` for automatic
- * @param   site    The site, `NULL` for automatic
- * @param   ctx     The state of the library, must be initialised
- * @return          Zero on success, -1 on error. On error, `errno` is set
- *                  to 0 if the server could not be initialised.
- */
-int libcoopgamma_connect(const char* restrict method, const char* restrict site,
-			 libcoopgamma_context_t* restrict ctx)
-{
-  const char* (args[6]) = {COOPGAMMAD};
-  struct sockaddr_un address;
-  char* path;
-  int saved_errno;
-  int tries = 0, status;
-  pid_t pid;
-  size_t i = 1;
-  
-  ctx->blocking = 1;
-  
-  if (method != NULL)  args[i++] = "-m", args[i++] = method;
-  if (site   != NULL)  args[i++] = "-s", args[i++] = site;
-  args[i] = NULL;
-  
-  path = libcoopgamma_get_socket_file(method, site);
-  if (path == NULL)
-    return -1;
-  if (strlen(path) >= sizeof(address.sun_path))
-    {
-      free(path);
-      errno = ENAMETOOLONG;
-      return -1;
-    }
-  
-  address.sun_family = AF_UNIX;
-  strcpy(address.sun_path, path);
-  free(path);
-  if ((ctx->fd = socket(PF_UNIX, SOCK_STREAM, 0)) < 0)
-    return -1;
-
- retry:
-  if (connect(ctx->fd, (struct sockaddr*)(&address), (socklen_t)sizeof(address)) < 0)
-    {
-      if (((errno == ECONNREFUSED) || (errno == ENOENT) || (errno == ENOTDIR)) && !tries++)
-	{
-	  switch ((pid = fork()))
-	    {
-	    case -1:
-	      goto fail;
-	    case 0:
-	      /* Child */
-	      close(ctx->fd);
-#if defined(__GNUC__)
-# pragma GCC diagnostic push
-# pragma GCC diagnostic ignored "-Wcast-qual"
-#endif
-	      execvp(COOPGAMMAD, (char* const*)(args));
-#if defined(__GNUC__)
-# pragma GCC diagnostic pop
-#endif
-	      perror(NAME_OF_THE_PROCESS);
-	      exit(1);
-	    default:
-	      /* Parent */
-	      if (waitpid(pid, &status, 0) < 0)
-		goto fail;
-	      if (status)
-		{
-		  errno = 0;
-		  goto fail;
-		}
-	      break;
-	    }
-	  goto retry;
-	}
-      goto fail;
-    }
-  
-  return 0;
- fail:
-  saved_errno = errno;
-  close(ctx->fd), ctx->fd = -1;
-  errno = saved_errno;
-  return -1;
-}
-
-
-/**
- * By default communication is blocking, this function
- * can be used to switch between blocking and nonblocking
- * 
- * After setting the communication to nonblocking,
- * `libcoopgamma_flush`, `libcoopgamma_synchronise` and
- * and request-sending functions can fail with EAGAIN and
- * EWOULDBLOCK. It is safe to continue with `libcoopgamma_flush`
- * (for `libcoopgamma_flush` it selfand equest-sending functions)
- * or `libcoopgamma_synchronise` just like EINTR failure.
- * 
- * @param   ctx          The state of the library, must be connected
- * @param   nonblocking  Nonblocking mode?
- * @return               Zero on success, -1 on error
- */
-int libcoopgamma_set_nonblocking(libcoopgamma_context_t* restrict ctx, int nonblocking)
-{
-  int flags = fcntl(ctx->fd, F_GETFL);
-  if (flags == -1)
-    return -1;
-  if (nonblocking)
-    flags |= O_NONBLOCK;
-  else
-    flags &= ~O_NONBLOCK;
-  if (fcntl(ctx->fd, F_SETFL, flags) == -1)
-    return -1;
-  ctx->blocking = !nonblocking;
-  return 0;
-}
-
-
-/**
- * Send all pending outbound data
- * 
- * If this function or another function that sends a request
- * to the server fails with EINTR, call this function to
- * complete the transfer. The `async` parameter will always
- * be in a properly configured state if a function fails
- * with EINTR.
- * 
- * @param   ctx  The state of the library, must be connected
- * @return       Zero on success, -1 on error
- */
-int libcoopgamma_flush(libcoopgamma_context_t* restrict ctx)
-{
-  ssize_t sent;
-  size_t chunksize = ctx->outbound_head - ctx->outbound_tail;
-  size_t sendsize;
-  
-  while (ctx->outbound_tail < ctx->outbound_head)
-    {
-      sendsize = ctx->outbound_head - ctx->outbound_tail;
-      sendsize = sendsize < chunksize ? sendsize : chunksize;
-      sent = send(ctx->fd, ctx->outbound + ctx->outbound_tail, sendsize, MSG_NOSIGNAL);
-      if (sent < 0)
-	{
-	  if (errno == EPIPE)
-	    errno = ECONNRESET;
-	  if (errno != EMSGSIZE)
-	    return -1;
-	  if ((chunksize >>= 1) == 0)
-	    return -1;
-	  continue;
-	}
-
-#ifdef DEBUG_MODE
-      fprintf(stderr, "\033[31m");
-      fwrite(ctx->outbound + ctx->outbound_tail, (size_t)sent, 1, stderr);
-      fprintf(stderr, "\033[m");
-      fflush(stderr);
-#endif
-
-      ctx->outbound_tail += (size_t)sent;
-    }
-  
-  return 0;
-}
-
-
-/**
- * Wait for the next message to be received
- * 
- * @param   ctx       The state of the library, must be connected
- * @param   pending   Information for each pending request
- * @param   n         The number of elements in `pending`
- * @param   selected  The index of the element in `pending` which corresponds
- *                    to the first inbound message, note that this only means
- *                    that the message is not for any of the other request,
- *                    if the message is corrupt any of the listed requests can
- *                    be selected even if it is not for any of the requests.
- *                    Functions that parse the message will detect such corruption.
- * @return            Zero on success, -1 on error. If the the message is ignored,
- *                    which happens if corresponding `libcoopgamma_async_context_t`
- *                    is not listed, -1 is returned and `errno` is set to 0. If -1
- *                    is returned, `errno` is set to `ENOTRECOVERABLE` you have
- *                    received a corrupt message and the context has been tainted
- *                    beyond recover.
- */
-int libcoopgamma_synchronise(libcoopgamma_context_t* restrict ctx,
-			     libcoopgamma_async_context_t* restrict pending,
-			     size_t n, size_t* restrict selected)
-{
-  char temp[3 * sizeof(size_t) + 1];
-  ssize_t got;
-  size_t i;
-  char* p;
-  char* line;
-  char* value;
-  struct pollfd pollfd;
-  
-  if (ctx->inbound_head == ctx->inbound_tail)
-    ctx->inbound_head = ctx->inbound_tail = ctx->curline = 0;
-  else if (ctx->inbound_tail > 0)
-    {
-      memmove(ctx->inbound, ctx->inbound + ctx->inbound_tail, ctx->inbound_head -= ctx->inbound_tail);
-      ctx->curline -= ctx->inbound_tail;
-      ctx->inbound_tail = 0;
-    }
-  
-  pollfd.fd = ctx->fd;
-  pollfd.events = POLLIN | POLLRDNORM | POLLRDBAND | POLLPRI;
-  
-  if (ctx->inbound_head)
-    goto skip_recv;
-  for (;;)
-    {
-      if (ctx->inbound_head == ctx->inbound_size)
-	{
-	  size_t new_size = ctx->inbound_size ? (ctx->inbound_size << 1) : 1024;
-	  void* new = realloc(ctx->inbound, new_size);
-	  if (new == NULL)
-	    return -1;
-	  ctx->inbound = new;
-	  ctx->inbound_size = new_size;
-	}
-      
-      if (ctx->blocking)
-	{
-	  pollfd.revents = 0;
-	  if (poll(&pollfd, (nfds_t)1, -1) < 0)
-	    return -1;
-	}
-      got = recv(ctx->fd, ctx->inbound + ctx->inbound_head, ctx->inbound_size - ctx->inbound_head, 0);
-      if (got <= 0)
-	{
-	  if (got == 0)
-	    errno = ECONNRESET;
-	  return -1;
-	}
-      
-#ifdef DEBUG_MODE
-      fprintf(stderr, "\033[32m");
-      fwrite(ctx->inbound + ctx->inbound_head, (size_t)got, 1, stderr);
-      fprintf(stderr, "\033[m");
-      fflush(stderr);
-#endif
-      
-      ctx->inbound_head += (size_t)got;
-      
-    skip_recv:
-      while (ctx->have_all_headers == 0)
-	{
-	  line = ctx->inbound + ctx->curline;
-	  p = memchr(line, '\n', ctx->inbound_head - ctx->curline);
-	  if (p == NULL)
-	    break;
-	  if (memchr(line, '\0', (size_t)(p - line)) != NULL)
-	    ctx->bad_message = 1;
-	  *p++ = '\0';
-	  ctx->curline = (size_t)(p - ctx->inbound);
-	  if (!*line)
-	    {
-	      ctx->have_all_headers = 1;
-	    }
-	  else if (strstr(line, "In response to: ") == line)
-	    {
-	      value = line + (sizeof("In response to: ") - 1);
-	      ctx->in_response_to = (uint32_t)atol(value);
-	    }
-	  else if (strstr(line, "Length: ") == line)
-	    {
-	      value = line + (sizeof("Length: ") - 1);
-	      ctx->length = (size_t)atol(value);
-	      sprintf(temp, "%zu", ctx->length);
-	      if (strcmp(value, temp))
-		goto fatal;
-	    }
-	}
-      
-      if (ctx->have_all_headers && (ctx->inbound_head >= ctx->curline + ctx->length))
-	{
-	  ctx->curline += ctx->length;
-	  if (ctx->bad_message)
-	    {
-	      ctx->bad_message = 0;
-	      ctx->have_all_headers = 0;
-	      ctx->length = 0;
-	      ctx->inbound_tail = ctx->curline;
-	      errno = EBADMSG;
-	      return -1;
-	    }
-	  for (i = 0; i < n; i++)
-	    if (pending[i].message_id == ctx->in_response_to)
-	      {
-		*selected = i;
-		return 0;
-	      }
-	  *selected = 0;
-	  ctx->bad_message = 0;
-	  ctx->have_all_headers = 0;
-	  ctx->length = 0;
-	  ctx->inbound_tail = ctx->curline;
-	  errno = 0;
-	  return -1;
-	}
-    }
-  
- fatal:
-  errno = ENOTRECOVERABLE;
-  return -1;
-}
-
-
-/**
- * Send a message to the server and wait for response
- * 
- * @param  resp:char**                  Output parameter for the response,
- *                                      will be NUL-terminated
- * @param  ctx:libcoopgamma_context_t*  The state of the library
- * @param  payload:void*                Data to append to the end of the message
- * @param  payload_size:size_t          Byte-size of `payload`
- * @param  format:string-literal        Message formatting string
- * @param  ...                          Message formatting arguments
- * 
- * On error, the macro goes to `fail`.
- */
-#define SEND_MESSAGE(ctx, payload, payload_size, format, ...)		\
-  do									\
-    {									\
-      ssize_t n__;							\
-      char* msg__;							\
-      snprintf(NULL, (size_t)0, format "%zn", __VA_ARGS__, &n__);	\
-      msg__ = malloc((size_t)n__ + (payload_size) + (size_t)1);		\
-      if (msg__ == NULL)						\
-	goto fail;							\
-      sprintf(msg__, format, __VA_ARGS__);				\
-      if ((payload) != NULL)						\
-	memcpy(msg__ + n__, (payload), (payload_size));			\
-      if (send_message((ctx), msg__, (size_t)n__ + (payload_size)) < 0)	\
-	goto fail;							\
-    }									\
-  while (0)
-
-
-/**
- * Send a message to the server and wait for response
- * 
- * @param   ctx  The state of the library
- * @param   msg  The message to send
- * @param   n    The length of `msg`
- * @return       Zero on success, -1 on error
- */
-static int send_message(libcoopgamma_context_t* restrict ctx, char* msg, size_t n)
-{
-  if (ctx->outbound_head == ctx->outbound_tail)
-    {
-      free(ctx->outbound);
-      ctx->outbound = msg;
-      ctx->outbound_tail = 0;
-      ctx->outbound_head = n;
-      ctx->outbound_size = n;
-    }
-  else
-    {
-      if (ctx->outbound_head + n > ctx->outbound_size)
-	{
-	  memmove(ctx->outbound, ctx->outbound + ctx->outbound_tail, ctx->outbound_head -= ctx->outbound_tail);
-	  ctx->outbound_tail = 0;
-	}
-      if (ctx->outbound_head + n > ctx->outbound_size)
-	{
-	  void* new = realloc(ctx->outbound, ctx->outbound_head + n);
-	  if (new == NULL)
-	    {
-	      int saved_errno = errno;
-	      free(msg);
-	      errno = saved_errno;
-	      return -1;
-	    }
-	  ctx->outbound = new;
-	  ctx->outbound_size = ctx->outbound_head + n;
-	}
-      memcpy(ctx->outbound + ctx->outbound_head, msg, n);
-      ctx->outbound_head += n;
-      free(msg);
-    }
-  ctx->message_id += 1;
-  return libcoopgamma_flush(ctx);
-}
-
-
-/**
- * Get the next header of the inbound message
- * 
- * All headers must be read before the payload is read
- * 
- * @param   ctx  The state of the library, must be connected
- * @return       The next header line, can never be `NULL`,
- *               the empty string marks the end of the headers.
- *               This memory segment must not be freed.
- */
-static char* next_header(libcoopgamma_context_t* restrict ctx)
-{
-  char* rc = ctx->inbound + ctx->inbound_tail;
-  ctx->inbound_tail += strlen(rc) + 1;
-  return rc;
-}
-
-
-/**
- * Get the payload of the inbound message
- * 
- * Calling this function marks that the inbound message
- * has been fully ready. You must call this function
- * even if you do not expect a payload
- * 
- * @param   ctx  The state of the library, must be connected
- * @param   n    Output parameter for the size of the payload
- * @return       The payload (not NUL-terminated), `NULL` if
- *               there is no payload. Failure is impossible.
- *               This memory segment must not be freed.
- */
-static char* next_payload(libcoopgamma_context_t* restrict ctx, size_t* n)
-{
-  ctx->have_all_headers = 0;
-  if ((*n = ctx->length))
-    {
-      char* rc = ctx->inbound + ctx->inbound_tail;
-      ctx->inbound_tail += *n;
-      ctx->length = 0;
-      return rc;
-    }
-  else
-    return NULL;
-}
-
-
-/**
- * Tell the library that you will not be parsing a receive message
- * 
- * @param  ctx  The state of the library, must be connected
- */
-void libcoopgamma_skip_message(libcoopgamma_context_t* restrict ctx)
-{
-  size_t _n;
-  while (*next_header(ctx));
-  (void) next_payload(ctx, &_n);
-}
-
-
-/**
- * Check whether the server sent an error, if so copy it to `ctx`
- * 
- * This function will also reports EBADMSG if the message ID
- * that the message is a response to does not match the request
- * information, or if it is missing
- * 
- * @param   ctx    The state of the library, must be connected
- * @param   async  Information about the request
- * @return         1 if the server sent an error (even indicating success),
- *                 0 on success, -1 on failure. Information about failure
- *                 is copied `ctx`.
- */
-static int check_error(libcoopgamma_context_t* restrict ctx, libcoopgamma_async_context_t* restrict async)
-{
-  char temp[3 * sizeof(uint64_t) + 1];
-  size_t old_tail = ctx->inbound_tail;
-  char* line;
-  char* value;
-  int command_ok = 0;
-  int have_in_response_to = 0;
-  int have_error = 0;
-  int bad = 0;
-  char* payload;
-  size_t n;
-  
-  for (;;)
-    {
-      line = next_header(ctx);
-      value = strchr(line, ':') + 2;
-      if (!*line)
-	break;
-      else if (!strcmp(line, "Command: error"))
-	command_ok = 1;
-      else if (strstr(line, "In response to: ") == line)
-	{
-	  uint32_t id = (uint32_t)atol(value);
-	  have_in_response_to = 1 + !!have_in_response_to;
-	  if (id != async->message_id)
-	    bad = 1;
-	  else
-	    {
-	      sprintf(temp, "%" PRIu32, id);
-	      if (strcmp(value, temp))
-		bad = 1;
-	    }
-	}
-      else if (strstr(line, "Error: ") == line)
-	{
-	  have_error = 1 + !!have_error;
-	  ctx->error.server_side = 1;
-	  ctx->error.custom = (strstr(value, "custom") == value);
-	  if (ctx->error.custom)
-	    {
-	      if (value[6] == '\0')
-		{
-		  ctx->error.number = 0;
-		  continue;
-		}
-	      else if (value[6] != ' ')
-		{
-		  bad = 1;
-		  continue;
-		}
-	      value += 7;
-	    }
-	  ctx->error.number = (uint64_t)atoll(value);
-	  sprintf(temp, "%" PRIu64, ctx->error.number);
-	  if (strcmp(value, temp))
-	    bad = 1;
-	}
-    }
-  
-  if (command_ok == 0)
-    {
-      ctx->inbound_tail = old_tail;
-      return 0;
-    }
-  
-  payload = next_payload(ctx, &n);
-  if (payload != NULL)
-    {
-      if (memchr(payload, '\0', n) || (payload[n - 1] != '\n'))
-	goto badmsg;
-      ctx->error.description = malloc(n);
-      if (ctx->error.description == NULL)
-	goto fail;
-      memcpy(ctx->error.description, payload, n - 1);
-      ctx->error.description[n - 1] = '\0';
-    }
-  
-  if (bad || (have_in_response_to != 1) || (have_error != 1))
-    goto badmsg;
-  
-  return 1;
-badmsg:
-  errno = EBADMSG;
-fail:
-  copy_errno(ctx);
-  return -1;
-}
-
-
-
-#if defined(__GNUC__)
-# pragma GCC diagnostic push
-# pragma GCC diagnostic ignored "-Wnonnull"
-#endif
-
-
-
-/**
- * List all available CRTC:s, send request part
- * 
- * Cannot be used before connecting to the server
- * 
- * @param   ctx    The state of the library, must be connected
- * @param   async  Information about the request, that is needed to
- *                 identify and parse the response, is stored here
- * @return         Zero on success, -1 on error
- */
-int libcoopgamma_get_crtcs_send(libcoopgamma_context_t* restrict ctx,
-				libcoopgamma_async_context_t* restrict async)
-{
-  async->message_id = ctx->message_id;
-  SEND_MESSAGE(ctx, NULL, (size_t)0,
-	       "Command: enumerate-crtcs\n"
-	       "Message ID: %" PRIu32 "\n"
-	       "\n",
-	       ctx->message_id);
-  
-  return 0;
- fail:
-  copy_errno(ctx);
-  return -1;
-}
-
-
-/**
- * List all available CRTC:s, receive response part
- * 
- * @param   ctx    The state of the library, must be connected
- * @param   async  Information about the request
- * @return         A `NULL`-terminated list of names. You should only free
- *                 the outer pointer, inner pointers are subpointers of the
- *                 outer pointer and cannot be freed. `NULL` on error, in
- *                 which case `ctx->error` (rather than `errno`) is read
- *                 for information about the error.
- */
-char** libcoopgamma_get_crtcs_recv(libcoopgamma_context_t* restrict ctx,
-				   libcoopgamma_async_context_t* restrict async)
-{
-  char* line;
-  char* payload;
-  char* end;
-  int command_ok = 0;
-  size_t i, n, lines, len, length;
-  char** rc;
-  
-  if (check_error(ctx, async))
-    return NULL;
-  
-  for (;;)
-    {
-      line = next_header(ctx);
-      if (!*line)
-	break;
-      else if (!strcmp(line, "Command: crtc-enumeration"))
-	command_ok = 1;
-    }
-  
-  payload = next_payload(ctx, &n);
-  
-  if (!command_ok || ((n > 0) && (payload[n - 1] != '\n')))
-    {
-      errno = EBADMSG;
-      copy_errno(ctx);
-      return NULL;
-    }
-  
-  line = payload;
-  end = payload + n;
-  lines = length = 0;
-  while (line != end)
-    {
-      lines += 1;
-      length += len = (size_t)(strchr(line, '\n') + 1 - line);
-      line += len;
-      line[-1] = '\0';
-    }
-  
-  rc = malloc((lines + 1) * sizeof(char*) + length);
-  if (rc == NULL)
-    {
-      copy_errno(ctx);
-      return NULL;
-    }
-  
-  line = ((char*)rc) + (lines + 1) * sizeof(char*);
-  memcpy(line, payload, length);
-  rc[lines] = NULL;
-  for (i = 0; i < lines; i++)
-    {
-      rc[i] = line;
-      line = strchr(line, '\0') + 1;
-    }
-  
-  return rc;
-}
-
-
-/**
- * List all available CRTC:s, synchronous version
- * 
- * This is a synchronous request function, as such,
- * you have to ensure that communication is blocking
- * (default), and that there are not asynchronous
- * requests waiting, it also means that EINTR:s are
- * silently ignored and there no wait to cancel the
- * operation without disconnection from the server
- * 
- * @param   ctx  The state of the library, must be connected
- * @return       A `NULL`-terminated list of names. You should only free
- *               the outer pointer, inner pointers are subpointers of the
- *               outer pointer and cannot be freed. `NULL` on error, in
- *               which case `ctx->error` (rather than `errno`) is read
- *               for information about the error.
- */
-char** libcoopgamma_get_crtcs_sync(libcoopgamma_context_t* restrict ctx)
-{
-  SYNC_CALL(libcoopgamma_get_crtcs_send(ctx, &async),
-	    libcoopgamma_get_crtcs_recv(ctx, &async), (copy_errno(ctx), NULL));
-}
-
-
-
-/**
- * Retrieve information about a CRTC:s gamma ramps, send request part
- * 
- * Cannot be used before connecting to the server
- * 
- * @param   crtc   The name of the CRTC
- * @param   ctx    The state of the library, must be connected
- * @param   async  Information about the request, that is needed to
- *                 identify and parse the response, is stored here
- * @return         Zero on success, -1 on error
- */
-int libcoopgamma_get_gamma_info_send(const char* restrict crtc, libcoopgamma_context_t* restrict ctx,
-				     libcoopgamma_async_context_t* restrict async)
-{
-#if defined(__GNUC__) && !defined(__clang__)
-# pragma GCC diagnostic push
-# pragma GCC diagnostic ignored "-Wnonnull-compare"
-#endif
-  if ((crtc == NULL) || strchr(crtc, '\n'))
-    {
-      errno = EINVAL;
-      goto fail;
-    }
-#if defined(__GNUC__) && !defined(__clang__)
-# pragma GCC diagnostic pop
-#endif
-  
-  async->message_id = ctx->message_id;
-  SEND_MESSAGE(ctx, NULL, (size_t)0,
-	       "Command: get-gamma-info\n"
-	       "Message ID: %" PRIu32 "\n"
-	       "CRTC: %s\n"
-	       "\n",
-	       ctx->message_id, crtc);
-  
-  return 0;
- fail:
-  copy_errno(ctx);
-  return 0;
-}
-
-
-/**
- * Retrieve information about a CRTC:s gamma ramps, receive response part
- * 
- * @param   info   Output parameter for the information, must be initialised
- * @param   ctx    The state of the library, must be connected
- * @param   async  Information about the request
- * @return         Zero on success, -1 on error, in which case `ctx->error`
- *                 (rather than `errno`) is read for information about the error
- */
-int libcoopgamma_get_gamma_info_recv(libcoopgamma_crtc_info_t* restrict info,
-				     libcoopgamma_context_t* restrict ctx,
-				     libcoopgamma_async_context_t* restrict async)
-{
-  char temp[3 * sizeof(size_t) + 1];
-  char* line;
-  char* value;
-  size_t _n;
-  int have_cooperative = 0, have_gamma_support = 0, have_colourspace = 0;
-  int have_depth       = 0, have_white_x = 0, have_white_y = 0;
-  int have_red_size    = 0, have_red_x   = 0, have_red_y   = 0;
-  int have_green_size  = 0, have_green_x = 0, have_green_y = 0;
-  int have_blue_size   = 0, have_blue_x  = 0, have_blue_y  = 0;
-  int bad = 0, r = 0, g = 0, b = 0, x = 0;
-  
-  if (check_error(ctx, async))
-    return -1;
-  
-  info->cooperative = 0; /* Should be in the response, but ... */
-  info->colourspace = LIBCOOPGAMMA_UNKNOWN;
-  
-  for (;;)
-    {
-      line = next_header(ctx);
-      value = strchr(line, ':') + 2;
-      if (!*line)
-	break;
-      else if (strstr(line, "Cooperative: ") == line)
-	{
-	  have_cooperative = 1 + !!have_cooperative;
-	  if      (!strcmp(value, "yes"))  info->cooperative = 1;
-	  else if (!strcmp(value, "no"))   info->cooperative = 0;
-	  else
-	    bad = 1;
-	}
-      else if (strstr(line, "Depth: ") == line)
-	{
-	  have_depth = 1 + !!have_depth;
-	  if      (!strcmp(value, "8"))   info->depth = LIBCOOPGAMMA_UINT8;
-	  else if (!strcmp(value, "16"))  info->depth = LIBCOOPGAMMA_UINT16;
-	  else if (!strcmp(value, "32"))  info->depth = LIBCOOPGAMMA_UINT32;
-	  else if (!strcmp(value, "64"))  info->depth = LIBCOOPGAMMA_UINT64;
-	  else if (!strcmp(value, "f"))   info->depth = LIBCOOPGAMMA_FLOAT;
-	  else if (!strcmp(value, "d"))   info->depth = LIBCOOPGAMMA_DOUBLE;
-	  else
-	    bad = 1;
-	}
-      else if (strstr(line, "Gamma support: ") == line)
-	{
-	  have_gamma_support = 1 + !!have_gamma_support;
-	  if      (!strcmp(value, "yes"))    info->supported = LIBCOOPGAMMA_YES;
-	  else if (!strcmp(value, "no"))     info->supported = LIBCOOPGAMMA_NO;
-	  else if (!strcmp(value, "maybe"))  info->supported = LIBCOOPGAMMA_MAYBE;
-	  else
-	    bad = 1;
-	}
-      else if (((r = (strstr(line, "Red size: ")   == line))) ||
-	       ((g = (strstr(line, "Green size: ") == line))) ||
-	             (strstr(line, "Blue size: ")  == line))
-	{
-	  size_t* out;
-	  if (r)       have_red_size   = 1 + !!have_red_size,   out = &(info->red_size);
-	  else if (g)  have_green_size = 1 + !!have_green_size, out = &(info->green_size);
-	  else         have_blue_size  = 1 + !!have_blue_size,  out = &(info->blue_size);
-	  *out = (size_t)atol(value);
-	  sprintf(temp, "%zu", *out);
-	  if (strcmp(value, temp))
-	    bad = 1;
-	}
-      else if ((x = r = (strstr(line, "Red x: ")   == line)) ||
-	           (r = (strstr(line, "Red y: ")   == line)) ||
-	       (x = g = (strstr(line, "Green x: ") == line)) ||
-	           (g = (strstr(line, "Green y: ") == line)) ||
-	       (x = b = (strstr(line, "Blue x: ")  == line)) ||
-	           (b = (strstr(line, "Blue y: ")  == line)) ||
-	           (x = (strstr(line, "White x: ") == line)) ||
-	                (strstr(line, "White y: ") == line))
-	{
-	  unsigned* out;
-	  int* have;
-	  if      (r && x)  have = &have_red_x,   out = &(info->red_x);
-	  else if (r)       have = &have_red_y,   out = &(info->red_y);
-	  else if (g && x)  have = &have_green_x, out = &(info->green_x);
-	  else if (g)       have = &have_green_y, out = &(info->green_y);
-	  else if (b && x)  have = &have_blue_x,  out = &(info->blue_x);
-	  else if (b)       have = &have_blue_y,  out = &(info->blue_y);
-	  else if (x)       have = &have_white_x, out = &(info->white_x);
-	  else              have = &have_white_y, out = &(info->white_y);
-	  *have = 1 + !!*have;
-	  *out = (unsigned)atoi(value);
-	  sprintf(temp, "%u", *out);
-	  if (strcmp(value, temp))
-	    bad = 1;
-	}
-      else if (strstr(line, "Colour space: ") == line)
-	{
-	  have_colourspace = 1 + !!have_colourspace;
-	  if      (!strcmp(value, "sRGB"))     info->colourspace = LIBCOOPGAMMA_SRGB;
-	  else if (!strcmp(value, "RGB"))      info->colourspace = LIBCOOPGAMMA_RGB;
-	  else if (!strcmp(value, "non-RGB"))  info->colourspace = LIBCOOPGAMMA_NON_RGB;
-	  else if (!strcmp(value, "grey"))     info->colourspace = LIBCOOPGAMMA_GREY;
-	  else
-	    info->colourspace = LIBCOOPGAMMA_UNKNOWN;
-	}
-    }
-  
-  (void) next_payload(ctx, &_n);
-  
-  info->have_gamut = (have_red_x && have_green_x && have_blue_x && have_white_x &&
-		      have_red_y && have_green_y && have_blue_y && have_white_y);
-  
-  if (bad || (have_gamma_support != 1) || (have_red_x > 1) || (have_red_y > 1) ||
-      (have_green_x > 1) || (have_green_y > 1) || (have_blue_x > 1) || (have_blue_y > 1) ||
-      (have_white_x > 1) || (have_white_y > 1) || (have_colourspace > 1))
-    {
-      errno = EBADMSG;
-      copy_errno(ctx);
-      return -1;
-    }
-  if (info->supported != LIBCOOPGAMMA_NO)
-    if ((have_cooperative > 1) || (have_depth != 1) || (have_gamma_support != 1) ||
-	(have_red_size != 1) || (have_green_size != 1) || (have_blue_size != 1))
-      {
-	errno = EBADMSG;
-	copy_errno(ctx);
-	return -1;
-      }
-  
-  return 0;
-}
-
-
-/**
- * Retrieve information about a CRTC:s gamma ramps, synchronous version
- * 
- * This is a synchronous request function, as such,
- * you have to ensure that communication is blocking
- * (default), and that there are not asynchronous
- * requests waiting, it also means that EINTR:s are
- * silently ignored and there no wait to cancel the
- * operation without disconnection from the server
- * 
- * @param   crtc   The name of the CRTC
- * @param   info   Output parameter for the information, must be initialised
- * @param   ctx    The state of the library, must be connected
- * @return         Zero on success, -1 on error, in which case `ctx->error`
- *                 (rather than `errno`) is read for information about the error
- */
-int libcoopgamma_get_gamma_info_sync(const char* restrict ctrc, libcoopgamma_crtc_info_t* restrict info,
-				     libcoopgamma_context_t* restrict ctx)
-{
-  SYNC_CALL(libcoopgamma_get_gamma_info_send(ctrc, ctx, &async),
-	    libcoopgamma_get_gamma_info_recv(info, ctx, &async), (copy_errno(ctx), -1));
-}
-
-
-
-/**
- * Retrieve the current gamma ramp adjustments, send request part
- * 
- * Cannot be used before connecting to the server
- * 
- * @param   query  The query to send
- * @param   ctx    The state of the library, must be connected
- * @param   async  Information about the request, that is needed to
- *                 identify and parse the response, is stored here
- * @return         Zero on success, -1 on error
- */
-int libcoopgamma_get_gamma_send(const libcoopgamma_filter_query_t* restrict query,
-				libcoopgamma_context_t* restrict ctx,
-				libcoopgamma_async_context_t* restrict async)
-{
-#if defined(__GNUC__) && !defined(__clang__)
-# pragma GCC diagnostic push
-# pragma GCC diagnostic ignored "-Wnonnull-compare"
-#endif
-  if ((query == NULL) || (query->crtc == NULL) || strchr(query->crtc, '\n'))
-    {
-      errno = EINVAL;
-      goto fail;
-    }
-#if defined(__GNUC__) && !defined(__clang__)
-# pragma GCC diagnostic pop
-#endif
-  
-  async->message_id = ctx->message_id;
-  async->coalesce = query->coalesce;
-  SEND_MESSAGE(ctx, NULL, (size_t)0,
-	       "Command: get-gamma\n"
-	       "Message ID: %" PRIu32 "\n"
-	       "CRTC: %s\n"
-	       "Coalesce: %s\n"
-	       "High priority: %" PRIi64 "\n"
-	       "Low priority: %" PRIi64 "\n"
-	       "\n",
-	       ctx->message_id, query->crtc, query->coalesce ? "yes" : "no",
-	       query->high_priority, query->low_priority);
-  
-  return 0;
- fail:
-  copy_errno(ctx);
-  return -1;
-}
-
-
-/**
- * Retrieve the current gamma ramp adjustments, receive response part
- * 
- * @param   table  Output for the response, must be initialised
- * @param   ctx    The state of the library, must be connected
- * @param   async  Information about the request
- * @return         Zero on success, -1 on error, in which case `ctx->error`
- *                 (rather than `errno`) is read for information about the error
- */
-int libcoopgamma_get_gamma_recv(libcoopgamma_filter_table_t* restrict table,
-				libcoopgamma_context_t* restrict ctx,
-				libcoopgamma_async_context_t* restrict async)
-{
-  char temp[3 * sizeof(size_t) + 1];
-  char* line;
-  char* value;
-  char* payload;
-  size_t i, n, width, clutsize;
-  int have_depth = 0;
-  int have_red_size = 0;
-  int have_green_size = 0;
-  int have_blue_size = 0;
-  int have_tables = 0;
-  int bad = 0, r = 0, g = 0;
-  
-  if (check_error(ctx, async))
-    return -1;
-  
-  libcoopgamma_filter_table_destroy(table);
-  
-  for (;;)
-    {
-      line = next_header(ctx);
-      value = strchr(line, ':') + 2;
-      if (!*line)
-	break;
-      else if (strstr(line, "Depth: ") == line)
-	{
-	  have_depth = 1 + !!have_depth;
-	  if      (!strcmp(value, "8"))   table->depth = LIBCOOPGAMMA_UINT8;
-	  else if (!strcmp(value, "16"))  table->depth = LIBCOOPGAMMA_UINT16;
-	  else if (!strcmp(value, "32"))  table->depth = LIBCOOPGAMMA_UINT32;
-	  else if (!strcmp(value, "64"))  table->depth = LIBCOOPGAMMA_UINT64;
-	  else if (!strcmp(value, "f"))   table->depth = LIBCOOPGAMMA_FLOAT;
-	  else if (!strcmp(value, "d"))   table->depth = LIBCOOPGAMMA_DOUBLE;
-	  else
-	    bad = 1;
-	}
-      else if (((r = (strstr(line, "Red size: ")   == line))) ||
-	       ((g = (strstr(line, "Green size: ") == line))) ||
-	             (strstr(line, "Blue size: ")  == line))
-	{
-	  size_t* out;
-	  if (r)       have_red_size   = 1 + !!have_red_size,   out = &(table->red_size);
-	  else if (g)  have_green_size = 1 + !!have_green_size, out = &(table->green_size);
-	  else         have_blue_size  = 1 + !!have_blue_size,  out = &(table->blue_size);
-	  *out = (size_t)atol(value);
-	  sprintf(temp, "%zu", *out);
-	  if (strcmp(value, temp))
-	    bad = 1;
-	}
-      else if (strstr(line, "Tables: ") == line)
-	{
-	  have_tables = 1 + have_tables;
-	  table->filter_count = (size_t)atol(value);
-	  sprintf(temp, "%zu", table->filter_count);
-	  if (strcmp(value, temp))
-	    bad = 1;
-	}
-    }
-  
-  payload = next_payload(ctx, &n);
-  
-  if (bad || (have_depth != 1) || (have_red_size != 1) || (have_green_size != 1) ||
-      (have_blue_size != 1) || (async->coalesce ? (have_tables > 1) : (have_tables == 0)) ||
-      (((payload == NULL) || (n == 0)) && (async->coalesce || (table->filter_count > 0))) ||
-      ((n > 0) && have_tables && (table->filter_count == 0)) ||
-      (async->coalesce && have_tables && (table->filter_count != 1)))
-    goto bad;
-  
-  switch (table->depth)
-    {
-    case LIBCOOPGAMMA_FLOAT:   width = sizeof(float);   break;
-    case LIBCOOPGAMMA_DOUBLE:  width = sizeof(double);  break;
-    default: INTEGRAL_DEPTHS
-      if ((table->depth <= 0) || ((table->depth & 7) != 0))
-	goto bad;
-      width = (size_t)(table->depth / 8);
-      break;
-    }
-  
-  clutsize = table->red_size + table->green_size + table->blue_size;
-  clutsize *= width;
-  
-  if (async->coalesce)
-    {
-      if (n != clutsize)
-	goto bad;
-      table->filters = malloc(sizeof(*(table->filters)));
-      if (table->filters == NULL)
-	goto fail;
-      table->filters->priority = 0;
-      table->filters->class = NULL;
-      table->filters->ramps.u8.red_size   = table->red_size;
-      table->filters->ramps.u8.green_size = table->green_size;
-      table->filters->ramps.u8.blue_size  = table->blue_size;
-      if (libcoopgamma_ramps_initialise_(&(table->filters->ramps), width) < 0)
-	goto fail;
-      memcpy(table->filters->ramps.u8.red, payload, clutsize);
-      table->filter_count = 1;
-    }
-  else if (table->filter_count == 0)
-    table->filters = NULL;
-  else
-    {
-      size_t off = 0, len;
-      table->filters = calloc(table->filter_count, sizeof(*(table->filters)));
-      if (table->filters == NULL)
-	goto fail;
-      for (i = 0; i < table->filter_count; i++)
-	{
-	  if (off + sizeof(int64_t) > n)
-	    goto bad;
-	  table->filters[i].priority = *(int64_t*)(payload + off);
-	  off += sizeof(int64_t);
-	  if (memchr(payload + off, '\0', n - off) == NULL)
-	    goto bad;
-	  len = strlen(payload + off) + 1;
-	  table->filters[i].class = malloc(len);
-	  if (table->filters[i].class == NULL)
-	    goto fail;
-	  memcpy(table->filters[i].class, payload + off, len);
-	  off += len;
-	  if (off + clutsize > n)
-	    goto bad;
-	  table->filters[i].ramps.u8.red_size   = table->red_size;
-	  table->filters[i].ramps.u8.green_size = table->green_size;
-	  table->filters[i].ramps.u8.blue_size  = table->blue_size;
-	  if (libcoopgamma_ramps_initialise_(&(table->filters[i].ramps), width) < 0)
-	    goto fail;
-	  memcpy(table->filters->ramps.u8.red, payload + off, clutsize);
-	  off += clutsize;
-	}
-      if (off != n)
-	goto bad;
-    }
-  
-  return 0;
- bad:
-  errno = EBADMSG;
- fail:
-  copy_errno(ctx);
-  return -1;
-}
-
-
-/**
- * Retrieve the current gamma ramp adjustments, synchronous version
- * 
- * This is a synchronous request function, as such,
- * you have to ensure that communication is blocking
- * (default), and that there are not asynchronous
- * requests waiting, it also means that EINTR:s are
- * silently ignored and there no wait to cancel the
- * operation without disconnection from the server
- * 
- * @param   query  The query to send
- * @param   table  Output for the response, must be initialised
- * @param   ctx    The state of the library, must be connected
- * @return         Zero on success, -1 on error, in which case `ctx->error`
- *                 (rather than `errno`) is read for information about the error
- */
-int libcoopgamma_get_gamma_sync(const libcoopgamma_filter_query_t* restrict query,
-				libcoopgamma_filter_table_t* restrict table,
-				libcoopgamma_context_t* restrict ctx)
-{
-  SYNC_CALL(libcoopgamma_get_gamma_send(query, ctx, &async),
-	    libcoopgamma_get_gamma_recv(table, ctx, &async), (copy_errno(ctx), -1));
-}
-
-
-
-/**
- * Apply, update, or remove a gamma ramp adjustment, send request part
- * 
- * Cannot be used before connecting to the server
- * 
- * @param   filter  The filter to apply, update, or remove, gamma ramp meta-data must match the CRTC's
- * @param   ctx     The state of the library, must be connected
- * @param   async   Information about the request, that is needed to
- *                  identify and parse the response, is stored here
- * @return          Zero on success, -1 on error
- */
-int libcoopgamma_set_gamma_send(const libcoopgamma_filter_t* restrict filter,
-				libcoopgamma_context_t* restrict ctx,
-				libcoopgamma_async_context_t* restrict async)
-{
-  const void* payload = NULL;
-  const char* lifespan;
-  char priority[sizeof("Priority: \n") + 3 * sizeof(int64_t)] = {'\0'};
-  char length  [sizeof("Length: \n")   + 3 * sizeof(size_t) ] = {'\0'};
-  size_t payload_size = 0, stopwidth = 0;
-  
-#if defined(__GNUC__) && !defined(__clang__)
-# pragma GCC diagnostic push
-# pragma GCC diagnostic ignored "-Wnonnull-compare"
-#endif
-  if ((filter == NULL) || (filter->crtc == NULL) || strchr(filter->crtc, '\n') ||
-      (filter->class == NULL) || strchr(filter->class, '\n'))
-    {
-      errno = EINVAL;
-      goto fail;
-    }
-#if defined(__GNUC__) && !defined(__clang__)
-# pragma GCC diagnostic pop
-#endif
-  
-  switch (filter->lifespan)
-    {
-    case LIBCOOPGAMMA_REMOVE:         lifespan = "remove";         break;
-    case LIBCOOPGAMMA_UNTIL_DEATH:    lifespan = "until-death";    break;
-    case LIBCOOPGAMMA_UNTIL_REMOVAL:  lifespan = "until-removal";  break;
-    default:
-      errno = EINVAL;
-      goto fail;
-    }
-  
-  if (filter->lifespan != LIBCOOPGAMMA_REMOVE)
-    {
-      switch (filter->depth)
-	{
-	case LIBCOOPGAMMA_FLOAT:   stopwidth = sizeof(float);   break;
-	case LIBCOOPGAMMA_DOUBLE:  stopwidth = sizeof(double);  break;
-	default: INTEGRAL_DEPTHS
-	    if ((filter->depth <= 0) || ((filter->depth & 7) != 0))
-	      {
-		errno = EINVAL;
-		goto fail;
-	      }
-	  stopwidth = (size_t)(filter->depth / 8);
-	  break;
-	}
-      
-      payload_size  = filter->ramps.u8.red_size;
-      payload_size += filter->ramps.u8.green_size;
-      payload_size += filter->ramps.u8.blue_size;
-      payload_size *= stopwidth;
-      payload = filter->ramps.u8.red;
-      sprintf(priority, "Priority: %" PRIi64 "\n", filter->priority);
-      sprintf(length, "Length: %zu\n", payload_size);
-    }
-  
-  async->message_id = ctx->message_id;
-  SEND_MESSAGE(ctx, payload, payload_size,
-	       "Command: set-gamma\n"
-	       "Message ID: %" PRIu32 "\n"
-	       "CRTC: %s\n"
-	       "Class: %s\n"
-	       "Lifespan: %s\n"
-	       "%s"
-	       "%s"
-	       "\n",
-	       ctx->message_id, filter->crtc, filter->class, lifespan,
-	       priority, length);
-  
-  return 0;
- fail:
-  copy_errno(ctx);
-  return -1;
-}
-
-
-/**
- * Apply, update, or remove a gamma ramp adjustment, receive response part
- * 
- * @param   ctx    The state of the library, must be connected
- * @param   async  Information about the request
- * @return         Zero on success, -1 on error, in which case `ctx->error`
- *                 (rather than `errno`) is read for information about the error
- */
-int libcoopgamma_set_gamma_recv(libcoopgamma_context_t* restrict ctx,
-				libcoopgamma_async_context_t* restrict async)
-{
-  size_t _n = 0;
-  
-  if (check_error(ctx, async))
-    return -(ctx->error.custom || ctx->error.number);
-  
-  while (*next_header(ctx));
-  (void) next_payload(ctx, &_n);
-  
-  errno = EBADMSG;
-  copy_errno(ctx);
-  return -1;
-}
-
-
-/**
- * Apply, update, or remove a gamma ramp adjustment, synchronous version
- * 
- * This is a synchronous request function, as such,
- * you have to ensure that communication is blocking
- * (default), and that there are not asynchronous
- * requests waiting, it also means that EINTR:s are
- * silently ignored and there no wait to cancel the
- * operation without disconnection from the server
- * 
- * @param   filter  The filter to apply, update, or remove, gamma ramp meta-data must match the CRTC's
- * @param   depth   The datatype for the stops in the gamma ramps, must match the CRTC's
- * @param   ctx     The state of the library, must be connected
- * @return          Zero on success, -1 on error, in which case `ctx->error`
- *                  (rather than `errno`) is read for information about the error
- */
-int libcoopgamma_set_gamma_sync(const libcoopgamma_filter_t* restrict filter,
-				libcoopgamma_context_t* restrict ctx)
-{
-  SYNC_CALL(libcoopgamma_set_gamma_send(filter, ctx, &async),
-	    libcoopgamma_set_gamma_recv(ctx, &async), (copy_errno(ctx), -1));
-}
-
-
-
-#if defined(__GNUC__)
-# pragma GCC diagnostic pop
-#endif
-
diff --git a/src/test.c b/src/test.c
deleted file mode 100644
index 4a94a42..0000000
--- a/src/test.c
+++ /dev/null
@@ -1,273 +0,0 @@
-/**
- * libcoopgamma -- Library for interfacing with cooperative gamma servers
- * Copyright (C) 2016  Mattias Andrée (maandree@kth.se)
- * 
- * This library is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- * 
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- * 
- * You should have received a copy of the GNU General Public License
- * along with this library.  If not, see <http://www.gnu.org/licenses/>.
- */
-#include "libcoopgamma.h"
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-
-static int streq(const char* a, const char* b)
-{
-  if ((a == NULL) != (b == NULL))
-    return 0;
-  return (a == NULL) || !strcmp(a, b);
-}
-
-
-static int rampseq(const libcoopgamma_ramps_t* a, const libcoopgamma_ramps_t* b, libcoopgamma_depth_t depth)
-{
-  size_t nr, ng, nb, width;
-  
-  if ((a->u8.red_size   != b->u8.red_size)   ||
-      (a->u8.green_size != b->u8.green_size) ||
-      (a->u8.blue_size  != b->u8.blue_size))
-    return 0;
-  
-  if (depth == -2)
-    width = sizeof(double);
-  else if (depth == -1)
-    width = sizeof(float);
-  else
-    width = ((size_t)depth) / 8;
-  
-  nr = a->u8.red_size   * width;
-  ng = a->u8.green_size * width;
-  nb = a->u8.blue_size  * width;
-  
-  if (memcmp(a->u8.red, b->u8.red, nr + ng + nb))
-    return 0;
-  if (memcmp(a->u8.green, b->u8.green, ng + nb))
-    return 0;
-  if (memcmp(a->u8.blue, b->u8.blue, nb))
-    return 0;
-  
-  return 1;
-}
-
-
-int main(void)
-{
-  libcoopgamma_filter_t filter1, filter2;
-  libcoopgamma_crtc_info_t crtc1, crtc2;
-  libcoopgamma_filter_query_t query1, query2;
-  libcoopgamma_filter_table_t table1, table2;
-  libcoopgamma_context_t ctx1, ctx2;
-  libcoopgamma_async_context_t async1, async2;
-  size_t n, m, i;
-  char* buf;
-  
-  filter1.priority = INT64_MIN;
-  filter1.crtc = "CRTC";
-  filter1.class = "A::B::C::D";
-  filter1.lifespan = LIBCOOPGAMMA_UNTIL_REMOVAL;
-  filter1.depth = LIBCOOPGAMMA_DOUBLE;
-  filter1.ramps.d.red_size = 4;
-  filter1.ramps.d.green_size = 5;
-  filter1.ramps.d.blue_size = 6;
-  filter1.ramps.d.red = (double[]){0.0, 0.1, 0.2, 0.5,
-				   0.3, 0.11, 0.22, 0.45, 0.9,
-				   -1, -0.5, 0, 0.5, 1, 1.5};
-  filter1.ramps.d.green = filter1.ramps.d.red + filter1.ramps.d.red_size;
-  filter1.ramps.d.blue = filter1.ramps.d.green + filter1.ramps.d.green_size;
-  
-  crtc1.cooperative = 0;
-  crtc1.depth = LIBCOOPGAMMA_DOUBLE;
-  crtc1.supported = LIBCOOPGAMMA_YES;
-  crtc1.red_size = 4;
-  crtc1.green_size = 5;
-  crtc1.blue_size = 6;
-  crtc1.colourspace = LIBCOOPGAMMA_SRGB;
-  crtc1.have_gamut = 1;
-  crtc1.red_x = 100;
-  crtc1.red_y = 50;
-  crtc1.green_x = 300;
-  crtc1.green_y = 350;
-  crtc1.blue_x = 200;
-  crtc1.blue_y = 260;
-  crtc1.white_x = 500;
-  crtc1.white_y = 999;
-  
-  query1.high_priority = INT64_MIN;
-  query1.low_priority = INT64_MIN;
-  query1.crtc = "crtc";
-  query1.coalesce = 1;
-  
-  table1.red_size = 4;
-  table1.green_size = 5;
-  table1.blue_size = 6;
-  table1.filter_count = 2;
-  table1.filters = (libcoopgamma_queried_filter_t[]){
-    {
-      .priority = UINT64_MAX,
-      .class = "a::b::c",
-      .ramps.d = {
-	.red_size = 4,
-	.green_size = 5,
-	.blue_size = 6,
-	.red = (double[]){0.0, 0.1, 0.2, 0.5,
-			  0.3, 0.11, 0.22, 0.45, 0.9,
-			  -1, -0.5, 0, 0.5, 1, 1.5}
-      }
-    }, {
-      .priority = UINT64_MAX - 1,
-      .class = NULL,
-      .ramps.d = {
-	.red_size = 4,
-	.green_size = 5,
-	.blue_size = 6,
-	.red = (double[]){0.02, 0.12, 0.22, 0.52,
-			  0.32, 0.112, 0.222, 0.452, 0.92,
-			  -12, -0.52, 0.2, 0.52, 12, 1.52}
-      }
-    }
-  };
-  table1.depth = LIBCOOPGAMMA_DOUBLE;
-  table1.filters[0].ramps.d.green = table1.filters[0].ramps.d.red + table1.filters[0].ramps.d.red_size;
-  table1.filters[1].ramps.d.green = table1.filters[1].ramps.d.red + table1.filters[1].ramps.d.red_size;
-  table1.filters[0].ramps.d.blue = table1.filters[0].ramps.d.green + table1.filters[0].ramps.d.green_size;
-  table1.filters[1].ramps.d.blue = table1.filters[1].ramps.d.green + table1.filters[1].ramps.d.green_size;
-  
-  ctx1.error.number = UINT64_MAX;
-  ctx1.error.custom = 1;
-  ctx1.error.server_side = 0;
-  ctx1.error.description = "description";
-  ctx1.fd = 3;
-  ctx1.have_all_headers = 1;
-  ctx1.bad_message = 0;
-  ctx1.blocking = 2;
-  ctx1.message_id = UINT32_MAX;
-  ctx1.in_response_to = UINT32_MAX - 1;
-  ctx1.outbound = "0123456789";
-  ctx1.outbound_head = 7;
-  ctx1.outbound_tail = 2;
-  ctx1.outbound_size = 10;
-  ctx1.inbound = "abcdefghi";
-  ctx1.inbound_head = 6;
-  ctx1.inbound_tail = 3;
-  ctx1.inbound_size = 9;
-  ctx1.length = 100;
-  ctx1.curline = 5;
-  
-  async1.message_id = UINT32_MAX;
-  async1.coalesce = 1;
-  
-  n  = libcoopgamma_filter_marshal(&filter1, NULL);
-  n += libcoopgamma_crtc_info_marshal(&crtc1, NULL);
-  n += libcoopgamma_filter_query_marshal(&query1, NULL);
-  n += libcoopgamma_filter_table_marshal(&table1, NULL);
-  n += libcoopgamma_context_marshal(&ctx1, NULL);
-  n += libcoopgamma_async_context_marshal(&async1, NULL);
-  
-  buf = malloc(n);
-  n  = libcoopgamma_filter_marshal(&filter1, buf);
-  n += libcoopgamma_crtc_info_marshal(&crtc1, buf + n);
-  n += libcoopgamma_filter_query_marshal(&query1, buf + n);
-  n += libcoopgamma_filter_table_marshal(&table1, buf + n);
-  n += libcoopgamma_context_marshal(&ctx1, buf + n);
-  n += libcoopgamma_async_context_marshal(&async1, buf + n);
-  
-  if (libcoopgamma_filter_unmarshal(&filter2, buf, &m))           return 1; else n = m;
-  if (libcoopgamma_crtc_info_unmarshal(&crtc2, buf + n, &m))      return 2; else n += m;
-  if (libcoopgamma_filter_query_unmarshal(&query2, buf + n, &m))  return 3; else n += m;
-  if (libcoopgamma_filter_table_unmarshal(&table2, buf + n, &m))  return 4; else n += m;
-  if (libcoopgamma_context_unmarshal(&ctx2, buf + n, &m))         return 5; else n += m;
-  if (libcoopgamma_async_context_unmarshal(&async2, buf + n, &m)) return 6;
-  free(buf);
-  
-  if ((filter1.priority != filter2.priority) ||
-      (!streq(filter1.crtc, filter2.crtc)) ||
-      (!streq(filter1.class, filter2.class)) ||
-      (filter1.lifespan != filter2.lifespan) ||
-      (filter1.depth != filter2.depth) ||
-      (!rampseq(&(filter1.ramps), &(filter2.ramps), filter1.depth)))
-    return 7;
-  
-  if ((crtc1.cooperative != crtc2.cooperative) ||
-      (crtc1.depth != crtc2.depth) ||
-      (crtc1.supported != crtc2.supported) ||
-      (crtc1.red_size != crtc2.red_size) ||
-      (crtc1.green_size != crtc2.green_size) ||
-      (crtc1.blue_size != crtc2.blue_size) ||
-      (crtc1.colourspace != crtc2.colourspace) ||
-      (crtc1.have_gamut != crtc2.have_gamut) ||
-      (crtc1.red_x != crtc2.red_x) ||
-      (crtc1.red_y != crtc2.red_y) ||
-      (crtc1.green_x != crtc2.green_x) ||
-      (crtc1.green_y != crtc2.green_y) ||
-      (crtc1.blue_x != crtc2.blue_x) ||
-      (crtc1.blue_y != crtc2.blue_y) ||
-      (crtc1.white_x != crtc2.white_x) ||
-      (crtc1.white_y != crtc2.white_y))
-    return 8;
-  
-  if ((query1.high_priority != query2.high_priority) ||
-      (query1.low_priority != query2.low_priority) ||
-      !streq(query1.crtc, query2.crtc) ||
-      (query1.coalesce != query2.coalesce))
-    return 9;
-  
-  if ((table1.red_size != table2.red_size) ||
-      (table1.green_size != table2.green_size) ||
-      (table1.blue_size != table2.blue_size) ||
-      (table1.filter_count != table2.filter_count) ||
-      (table1.depth != table2.depth))
-    return 10;
-  for (i = 0; i < table1.filter_count; i++)
-    if ((table1.filters[i].priority != table2.filters[i].priority) ||
-	!streq(table1.filters[i].class, table2.filters[i].class) ||
-	!rampseq(&(table1.filters[i].ramps), &(table2.filters[i].ramps), table1.depth))
-      return 11;
-  
-  if ((ctx1.error.number != ctx2.error.number) ||
-      (ctx1.error.custom != ctx2.error.custom) ||
-      (ctx1.error.server_side != ctx2.error.server_side) ||
-      !streq(ctx1.error.description, ctx2.error.description))
-    return 12;
-  
-  if ((ctx1.fd != ctx2.fd) ||
-      (ctx1.have_all_headers != ctx2.have_all_headers) ||
-      (ctx1.bad_message != ctx2.bad_message) ||
-      (ctx1.blocking != ctx2.blocking) ||
-      (ctx1.message_id != ctx2.message_id) ||
-      (ctx1.in_response_to != ctx2.in_response_to) ||
-      (ctx1.length != ctx2.length) ||
-      (ctx1.curline != ctx2.curline))
-    return 13;
-  
-  if ((ctx2.outbound_head > ctx2.outbound_size) ||
-      (ctx2.outbound_tail > ctx2.outbound_size) ||
-      (ctx2.inbound_head > ctx2.inbound_size) ||
-      (ctx2.inbound_tail > ctx2.inbound_size))
-    return 14;
-  
-  if (((n = ctx1.outbound_head - ctx1.outbound_tail) != ctx2.outbound_head - ctx2.outbound_tail) ||
-      ((m = ctx1.inbound_head - ctx1.inbound_tail) != ctx2.inbound_head - ctx2.inbound_tail))
-    return 15;
-  
-  if (memcmp(ctx1.outbound + ctx1.outbound_tail, ctx2.outbound + ctx2.outbound_tail, n) ||
-      memcmp(ctx1.inbound + ctx1.inbound_tail, ctx2.inbound + ctx2.inbound_tail, m))
-    return 16;
-  
-  if ((async1.message_id != async2.message_id) ||
-      (async1.coalesce != async2.coalesce))
-    return 17;
-  
-  return 0;
-}
-