/**
 * cg-tools -- Cooperative gamma-enabled tools
 * Copyright (C) 2016  Mattias Andrée (maandree@kth.se)
 * 
 * This program 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 program 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 program.  If not, see <http://www.gnu.org/licenses/>.
 */
#include "cg-base.h"

#include <libclut.h>

#include <alloca.h>
#include <errno.h>
#include <inttypes.h>
#include <poll.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>



/**
 * The process's name
 */
const char* argv0 = NULL;

/**
 * The libcoopgamma context
 */
libcoopgamma_context_t cg;

/**
 * The names of the selected CRTC:s
 */
char** crtcs = NULL;

/**
 * Gamma ramp updates for each CRTC
 */
filter_update_t* crtc_updates = NULL;

/**
 * CRTC and monitor information about
 * each selected CRTC and connect monitor
 */
libcoopgamma_crtc_info_t* crtc_info = NULL;

/**
 * The number of selected CRTC:s
 */
size_t crtcs_n = 0;


/**
 * Contexts for asynchronous ramp updates
 */
static libcoopgamma_async_context_t* asyncs = NULL;

/**
 * The number of pending receives
 */
static size_t pending_recvs = 0;

/**
 * Whether message must be flushed
 */
static int flush_pending = 0;



/**
 * Data used to sort CRTC:s
 */
struct crtc_sort_data
{
  /**
   * The gamma ramp type
   */
  libcoopgamma_depth_t depth;
  
  /**
   * Should be 0
   */
  int __padding;
  
  /**
   * The size of the red gamma ramp
   */
  size_t red_size;
  
  /**
   * The size of the green gamma ramp
   */
  size_t green_size;
  
  /**
   * The size of the blue gamma ramp
   */
  size_t blue_size;
  
  /**
   * The index of the CRTC
   */
  size_t index;
};



/**
 * Compare two strings
 * 
 * @param   a  Return -1 if this string is `NULL` or less than `b`
 * @param   b  Return +1 if this string is less than `a`
 * @return     See `a` and `b`, 0 is returned if `a` and `b` are equal
 */
static int nulstrcmp(const char *a, const char *b)
{
  return (a == NULL) ? -1 : strcmp(a, b);
}


/**
 * Compare two instances of `crtc_sort_data`
 * 
 * @param   a_  Return -1 if this one is lower
 * @param   b_  Return +1 if this one is higher
 * @return      See `a_` and `b_`, only -1 or +1 can be returned
 */
static int crtc_sort_data_cmp(const void* a_, const void* b_)
{
  const struct crtc_sort_data* a = a_;
  const struct crtc_sort_data* b = b_;
  int cmp = memcmp(a, b, sizeof(*a) - sizeof(a->index));
  return cmp ? cmp : a->index < b->index ? -1 : +1;
}


/**
 * Make elements in `crtc_updates` slaves where appropriate
 * 
 * @return  Zero on success, -1 on error
 */
int make_slaves(void)
{
  struct crtc_sort_data* data;
  size_t i, j, n = 0, master = 0, master_i;
  
  data = alloca(crtcs_n * sizeof(*data));
  memset(data, 0, crtcs_n * sizeof(*data));
  for (i = 0; i < crtcs_n; i++)
    {
      if (!(crtc_info[i].supported))
	continue;
      
      data[n].depth      = crtc_updates[i].filter.depth;
      data[n].red_size   = crtc_updates[i].filter.ramps.u8.red_size;
      data[n].green_size = crtc_updates[i].filter.ramps.u8.green_size;
      data[n].blue_size  = crtc_updates[i].filter.ramps.u8.blue_size;
      data[n].index      = i;
      n++;
    }
  
  qsort(data, n, sizeof(*data), crtc_sort_data_cmp);
  if (n == 0)
    return 0;
  
  master_i = data[0].index;
  for (i = 1; i < n; i++)
    if (memcmp(data + i, data + master, sizeof(*data) - sizeof(data->index)))
      {
	if (master + 1 < i)
	  {
	    crtc_updates[master_i].slaves = calloc(i - master, sizeof(size_t));
	    if (crtc_updates[master_i].slaves == NULL)
	      return -1;
	    for (j = 1; master + j < i; j++)
	      crtc_updates[master_i].slaves[j - 1] = data[master + j].index;
	  }
	master = i;
	master_i = data[master].index;
      }
    else
      {
	libcoopgamma_ramps_destroy(&(crtc_updates[data[i].index].filter.ramps.u8));
	crtc_updates[data[i].index].master = 0;
	crtc_updates[data[i].index].filter.ramps.u8 = crtc_updates[master_i].filter.ramps.u8;
      }
  
  if (master + 1 < i)
    {
      crtc_updates[master_i].slaves = calloc(i - master, sizeof(size_t));
      if (crtc_updates[master_i].slaves == NULL)
	return -1;
      for (j = 1; master + j < i; j++)
	crtc_updates[master_i].slaves[j - 1] = data[master + j].index;
    }
  
  return 0;
}


/**
 * Update a filter and synchronise calls
 * 
 * @param   index    The index of the CRTC
 * @param   timeout  The number of milliseconds a call to `poll` may block,
 *                   -1 if it may block forever
 * @return           1: Success, no pending synchronisations
 *                   0: Success, with still pending synchronisations
 *                   -1: Error, `errno` set
 *                   -2: Error, `cg.error` set
 * 
 * @throws  EINTR   Call to `poll` was interrupted by a signal
 * @throws  EAGAIN  Call to `poll` timed out
 */
int update_filter(size_t index, int timeout)
{
  filter_update_t* filter = crtc_updates + index;
  
  if (!(filter->synced) || filter->failed)
    abort();
  
  pending_recvs += 1;
  
  if (libcoopgamma_set_gamma_send(&(filter->filter), &cg, asyncs + index) < 0)
    switch (errno)
      {
      case EINTR:
      case EAGAIN:
#if EAGAIN != EWOULDBLOCK
      case EWOULDBLOCK:
#endif
	flush_pending = 1;
	break;
      default:
	return -1;
      }
  
  filter->synced = 0;
  return synchronise(timeout);
}


/**
 * Synchronised calls
 * 
 * @param   timeout  The number of milliseconds a call to `poll` may block,
 *                   -1 if it may block forever
 * @return           1: Success, no pending synchronisations
 *                   0: Success, with still pending synchronisations
 *                   -1: Error, `errno` set
 *                   -2: Error, `cg.error` set
 * 
 * @throws  EINTR   Call to `poll` was interrupted by a signal
 * @throws  EAGAIN  Call to `poll` timed out
 */
int synchronise(int timeout)
{
  struct pollfd pollfd;
  size_t selected;
  
  pollfd.fd = cg.fd;
  pollfd.events = POLLIN | POLLRDNORM | POLLRDBAND | POLLPRI;
  if (flush_pending > 0)
    pollfd.events |= POLLOUT;
  
  pollfd.revents = 0;
  if (poll(&pollfd, (nfds_t)1, timeout) < 0)
    return -1;
  
  if (pollfd.revents & (POLLOUT | POLLERR | POLLHUP | POLLNVAL))
    {
      if (libcoopgamma_flush(&cg) < 0)
	goto sync;
      flush_pending = 0;
    }
  
  if ((timeout < 0) && (pending_recvs > 0))
    if (!(pollfd.revents & (POLLIN | POLLRDNORM | POLLRDBAND | POLLPRI)))
      {
	pollfd.revents = 0;
	if (poll(&pollfd, (nfds_t)1, -1) < 0)
	  return -1;
      }
  
 sync:
  if (pollfd.revents & (POLLIN | POLLRDNORM | POLLRDBAND | POLLPRI | POLLERR | POLLHUP | POLLNVAL))
    for (;;)
      {
	if (libcoopgamma_synchronise(&cg, asyncs, crtcs_n, &selected) < 0)
	  {
	    if (errno == 0)
	      continue;
	    else
	      goto fail;
	  }
	if (crtc_updates[selected].synced)
	  continue;
	crtc_updates[selected].synced = 1;
	pending_recvs -= 1;
	if (libcoopgamma_set_gamma_recv(&cg, asyncs + selected) < 0)
	  {
	    if (cg.error.server_side)
	      {
		crtc_updates[selected].error = cg.error;
		crtc_updates[selected].failed = 1;
		memset(&(cg.error), 0, sizeof(cg.error));
	      }
	    else
	      goto cg_fail;
	  }
      }
  
  return pending_recvs == 0;
 cg_fail:
  return -2;
 fail:
  switch (errno)
    {
    case EINTR:
    case EAGAIN:
#if EAGAIN != EWOULDBLOCK
    case EWOULDBLOCK:
#endif
      return pending_recvs == 0;
    default:
      return -1;
    }
}


/**
 * Initialise the process, specifically
 * reset the signal mask and signal handlers
 * 
 * @return  Zero on success, -1 on error
 */
static int initialise_proc(void)
{
  sigset_t sigmask;
  int sig;
  
  for (sig = 1; sig < _NSIG; sig++)
    if (signal(sig, SIG_DFL) == SIG_ERR)
      if (sig == SIGCHLD)
	return -1;
  
  if (sigemptyset(&sigmask) < 0)
    return -1;
  if (sigprocmask(SIG_SETMASK, &sigmask, NULL) < 0)
    return -1;
  
  return 0;
}


/**
 * Print, to stdout, a list of all
 * recognised adjustment methods
 * 
 * @return  Zero on success, -1 on error
 */
static int list_methods(void)
{
  char** list;
  size_t i;
  
  list = libcoopgamma_get_methods();
  if (list == NULL)
    return -1;
  for (i = 0; list[i]; i++)
    printf("%s\n", list[i]);
  free(list);
  if (fflush(stdout) < 0)
    return -1;
  
  return 0;
}


/**
 * Print, to stdout, a list of all CRTC:s
 * 
 * A connection to the coopgamma server
 * must have been made
 * 
 * @return  Zero on success, -1 on error, -2
 *          on libcoopgamma error
 */
static int list_crtcs(void)
{
  char** list;
  size_t i;
  
  list = libcoopgamma_get_crtcs_sync(&cg);
  if (list == NULL)
    return -2;
  for (i = 0; list[i]; i++)
    printf("%s\n", list[i]);
  free(list);
  if (fflush(stdout) < 0)
    return -1;
  
  return 0;
}


/**
 * Fill the list of CRTC information
 * 
 * @return  Zero on success, -1 on error, -2
 *          on libcoopgamma error
 */
static int get_crtc_info(void)
{
  size_t i, unsynced = 0, selected;
  char* synced;
  int need_flush = 0;
  struct pollfd pollfd;
  
  synced = alloca(crtcs_n * sizeof(*synced));
  memset(synced, 0, crtcs_n * sizeof(*synced));
  
  i = 0;
  pollfd.fd = cg.fd;
  pollfd.events = POLLIN | POLLRDNORM | POLLRDBAND | POLLPRI;
  
  while ((unsynced > 0) || (i < crtcs_n))
    {
    wait:
      if (i < crtcs_n)
	pollfd.events |= POLLOUT;
      else
	pollfd.events &= ~POLLOUT;
      
      pollfd.revents = 0;
      if (poll(&pollfd, (nfds_t)1, -1) < 0)
	goto fail;
      
      if (pollfd.revents & (POLLOUT | POLLERR | POLLHUP | POLLNVAL))
	{
	  if (need_flush && (libcoopgamma_flush(&cg) < 0))
	    goto send_fail;
	  need_flush = 0;
	  for (; i < crtcs_n; i++)
	    if (unsynced++, libcoopgamma_get_gamma_info_send(crtcs[i], &cg, asyncs + i) < 0)
	      goto send_fail;
	  goto send_done;
	send_fail:
	  switch (errno)
	    {
	    case EINTR:
	    case EAGAIN:
#if EAGAIN != EWOULDBLOCK
	    case EWOULDBLOCK:
#endif
	      i++;
	      need_flush = 1;
	      break;
	    default:
	      goto fail;
	    }
	}
    send_done:
      
      if ((unsynced == 0) && (i == crtcs_n))
	break;
      
      if (pollfd.revents & (POLLIN | POLLRDNORM | POLLRDBAND | POLLPRI))
	while (unsynced > 0)
	  switch (libcoopgamma_synchronise(&cg, asyncs, i, &selected))
	    {
	    case 0:
	      if (synced[selected])
		{
		  libcoopgamma_skip_message(&cg);
		  break;
		}
	      synced[selected] = 1;
	      unsynced -= 1;
	      if (libcoopgamma_get_gamma_info_recv(crtc_info + selected, &cg, asyncs + selected) < 0)
		goto cg_fail;
	      break;
	    case -1:
	      switch (errno)
		{
		case 0:
		  break;
		case EINTR:
		case EAGAIN:
#if EAGAIN != EWOULDBLOCK
		case EWOULDBLOCK:
#endif
		  goto wait;
		default:
		  goto fail;
		}
	      break;
	    }
    }
  
  return 0;
 fail:
  return -1;
 cg_fail:
  return -2;
}


/**
 * -M METHOD
 *     Select adjustment method. If METHOD is "?",
 *     available methods will be printed to stdout.
 * 
 * -S SITE
 *     Select site (display server instance).
 * 
 * -c CRTC
 *     Select CRT controller. If CRTC is "?", CRTC:s
 *     will be printed to stdout.
 *     
 *     This option can be used multiple times. If it
 *     is not used at all, all CRTC:s will be selected.
 * 
 * -p PRIORITY
 *     Select the priority for the filter, this should
 *     be a signed two's-complement integer. If
 *     PRIORITY is "?", the default priority for the
 *     program is printed to stdout.
 * 
 * -R RULE
 *     The rule of the filter, that is, the last part
 *     of the class which is its identifier. If RULE
 *     is "?" the default rule is printed to stdout,
 *     if RULE is "??" the default class is printed
 *     to stdout.
 * 
 * @param   argc  The number of command line arguments
 * @param   argv  The command line arguments
 * @return        0 on success, 1 on error
 */
int main(int argc, char* argv[])
{
  int stage = 0;
  int dealloc_crtcs = 0;
  int rc = 0;
  char* method = NULL;
  char* site = NULL;
  size_t crtcs_i = 0;
  int64_t priority = default_priority;
  char* prio = NULL;
  char* rule = NULL;
  char* class = default_class;
  int explicit_crtcs = 0;
  int have_crtc_q = 0;
  
  argv0 = *argv++, argc--;
  
  if (initialise_proc() < 0)
    goto fail;
  
  crtcs = alloca(argc * sizeof(*crtcs));
  
  for (; *argv; argv++, argc--)
    {
      char* args = *argv;
      char opt[3];
      if (!strcmp(args, "--"))
	{
	  argv++, argc--;
	  break;
	}
      opt[0] = *args++;
      opt[2] = '\0';
      if ((*opt != '-') && (*opt != '+'))
	break;
      while (*args)
	{
	  char* arg;
	  int at_end;
	  opt[1] = *args++;
	  arg = args;
	  if ((at_end = !*arg))
	    arg = argv[1];
	  if (!strcmp(opt, "-M"))
	    {
	      if ((method != NULL) || ((method = arg) == NULL))
		usage();
	    }
	  else if (!strcmp(opt, "-S"))
	    {
	      if ((site != NULL) || ((site = arg) == NULL))
		usage();
	    }
	  else if (!strcmp(opt, "-c"))
	    {
	      if (arg == NULL)
		usage();
	      crtcs[crtcs_i++] = arg;
	      explicit_crtcs = 1;
	      if (!have_crtc_q && !strcmp(arg, "?"))
		have_crtc_q = 1;
	    }
	  else if (!strcmp(opt, "-p"))
	    {
	      if ((prio != NULL) || ((prio = arg) == NULL))
		usage();
	    }
	  else if (!strcmp(opt, "-R"))
	    {
	      if ((rule != NULL) || ((rule = arg) == NULL))
		usage();
	    }
	  else
	    switch (handle_opt(opt, arg))
	      {
	      case 0:
		goto next_opt;
	      case 1:
		break;
	      default:
		goto fail;
	      }
	  argv += at_end;
	  argc -= at_end;
	  break;
	next_opt:;
	}
    }
  
  crtcs_n = crtcs_i;
  crtcs[crtcs_i] = NULL;
  if (!have_crtc_q &&
      nulstrcmp(prio, "?") && nulstrcmp(rule, "??") &&
      nulstrcmp(rule, "?") && nulstrcmp(method, "?"))
    if (handle_args(argc, argv, prio) < 0)
      goto fail;
  
  if (!nulstrcmp(prio, "?"))
    {
      printf("%" PRIi64 "\n", priority);
      return 0;
    }
  else if (prio != NULL)
    priority = (int64_t)atoll(prio);
  
  if (!nulstrcmp(rule, "??"))
    {
      printf("%s\n", class);
      return 0;
    }
  else if (!nulstrcmp(rule, "?"))
    {
      printf("%s\n", strstr(strstr(class, "::") + 2, "::") + 2);
      return 0;
    }
  else if (rule != NULL)
    {
      char* p = strstr(strstr(class, "::") + 2, "::") + 2;
      size_t n = (size_t)(p - class);
      class = alloca(strlen(rule) + n + (size_t)1);
      memcpy(class, default_class, n);
      strcpy(class + n, rule);
      if (strchr(class, '\n'))
	{
	  fprintf(stderr, "%s: LF character is not allowed in the filter's class\n", argv0);
	  goto custom_fail;
	}
    }
  
  if (!nulstrcmp(method, "?"))
    {
      if (list_methods() < 0)
	goto fail;
      return 0;
    }
  
  if (libcoopgamma_context_initialise(&cg) < 0)
    goto fail;
  stage++;
  if (libcoopgamma_connect(method, site, &cg) < 0)
    {
      fprintf(stderr, "%s: server failed to initialise\n", argv0);
      goto custom_fail;
    }
  stage++;

  if (have_crtc_q)
    switch (list_crtcs())
      {
      case 0:
	goto done;
      case -1:
	goto fail;
      default:
	goto cg_fail;
      }
  
  if (crtcs_n == 0)
    {
      crtcs = libcoopgamma_get_crtcs_sync(&cg);
      if (crtcs == NULL)
	goto cg_fail;
      dealloc_crtcs = 1;
      for (; crtcs[crtcs_n] != NULL; crtcs_n++);
    }
  
  if (crtcs_n == 0)
    {
      fprintf(stderr, "%s: no CRTC:s are available\n", argv0);
      goto custom_fail;
    }
  
  crtc_info = alloca(crtcs_n * sizeof(*crtc_info));
  memset(crtc_info, 0, crtcs_n * sizeof(*crtc_info));
  for (crtcs_i = 0; crtcs_i < crtcs_n; crtcs_i++)
    if (libcoopgamma_crtc_info_initialise(crtc_info + crtcs_i) < 0)
      goto cg_fail;
  
  if (libcoopgamma_set_nonblocking(&cg, 1) < 0)
    goto fail;
  
  asyncs = alloca(crtcs_n * sizeof(*asyncs));
  memset(asyncs, 0, crtcs_n * sizeof(*asyncs));
  for (crtcs_i = 0; crtcs_i < crtcs_n; crtcs_i++)
    if (libcoopgamma_async_context_initialise(asyncs + crtcs_i) < 0)
      goto fail;
  
  switch (get_crtc_info())
    {
    case 0:
      break;
    case -1:
      goto fail;
    case -2:
      goto cg_fail;
    }
  
  for (crtcs_i = 0; crtcs_i < crtcs_n; crtcs_i++)
    {
      if (explicit_crtcs && !(crtc_info[crtcs_i].supported))
	fprintf(stderr, "%s: warning: gamma adjustments not supported on CRTC: %s\n",
		argv0, crtcs[crtcs_i]);
      if (crtc_info[crtcs_i].cooperative == 0)
	fprintf(stderr, "%s: warning: cooperative gamma server not running for CRTC: %s\n",
		argv0, crtcs[crtcs_i]);
    }
  
  crtc_updates = alloca(crtcs_n * sizeof(*crtc_updates));
  memset(crtc_updates, 0, crtcs_n * sizeof(*crtc_updates));
  for (crtcs_i = 0; crtcs_i < crtcs_n; crtcs_i++)
    {
      if (libcoopgamma_filter_initialise(&(crtc_updates[crtcs_i].filter)) < 0)
	goto fail;
      if (libcoopgamma_error_initialise(&(crtc_updates[crtcs_i].error)) < 0)
	goto fail;
      crtc_updates[crtcs_i].synced = 1;
      crtc_updates[crtcs_i].failed = 0;
      crtc_updates[crtcs_i].master = 1;
      crtc_updates[crtcs_i].slaves = NULL;
      crtc_updates[crtcs_i].filter.crtc                = crtcs[crtcs_i];
      crtc_updates[crtcs_i].filter.class               = class;
      crtc_updates[crtcs_i].filter.priority            = priority;
      crtc_updates[crtcs_i].filter.depth               = crtc_info[crtcs_i].depth;
      crtc_updates[crtcs_i].filter.ramps.u8.red_size   = crtc_info[crtcs_i].red_size;
      crtc_updates[crtcs_i].filter.ramps.u8.green_size = crtc_info[crtcs_i].green_size;
      crtc_updates[crtcs_i].filter.ramps.u8.blue_size  = crtc_info[crtcs_i].blue_size;
      switch (crtc_updates[crtcs_i].filter.depth)
	{
#define X(CONST, MEMBER, MAX, TYPE)\
	case CONST:\
	  libcoopgamma_ramps_initialise(&(crtc_updates[crtcs_i].filter.ramps.MEMBER));\
	  libclut_start_over(&(crtc_updates[crtcs_i].filter.ramps.MEMBER), MAX, TYPE, 1, 1, 1);\
	  break;
LIST_DEPTHS
#undef X
	default:
	  fprintf(stderr, "%s: internal error: gamma ramp type is unrecognised: %i\n",
		  argv0, crtc_updates[crtcs_i].filter.depth);
	  goto custom_fail;
	}
    }
  
  switch (start())
    {
    case 0:
      break;
    case -1:
      goto fail;
    case -2:
      goto cg_fail;
    case -3:
      goto custom_fail;
    }
  
  for (crtcs_i = 0; crtcs_i < crtcs_n; crtcs_i++)
    if (crtc_updates[crtcs_i].failed)
      {
	const char* side = cg.error.server_side ? "server" : "client";
	const char* crtc = crtc_updates[crtcs_i].filter.crtc;
	if (cg.error.custom)
	  {
	    if ((cg.error.number != 0) || (cg.error.description != NULL))
	      fprintf(stderr, "%s: %s-side error number %" PRIu64 " for CRTC %s: %s\n",
		      argv0, side, cg.error.number, crtc, cg.error.description);
	    else if (cg.error.number != 0)
	      fprintf(stderr, "%s: %s-side error number %" PRIu64 " for CRTC %s\n",
		      argv0, side, cg.error.number, crtc);
	    else if (cg.error.description != NULL)
	      fprintf(stderr, "%s: %s-side error for CRTC %s: %s\n", argv0, side, crtc, cg.error.description);
	  }
	else if (cg.error.description != NULL)
	  fprintf(stderr, "%s: %s-side error for CRTC %s: %s\n", argv0, side, crtc, cg.error.description);
	else
	  fprintf(stderr, "%s: %s-side error for CRTC %s: %s\n", argv0, side, crtc, strerror(cg.error.number));
      }
  
 done:
  if (dealloc_crtcs)
    free(crtcs);
  if (crtc_info != NULL)
    for (crtcs_i = 0; crtcs_i < crtcs_n; crtcs_i++)
      libcoopgamma_crtc_info_destroy(crtc_info + crtcs_i);
  if (asyncs != NULL)
    for (crtcs_i = 0; crtcs_i < crtcs_n; crtcs_i++)
      libcoopgamma_async_context_destroy(asyncs + crtcs_i);
  if (stage >= 1)
    libcoopgamma_context_destroy(&cg, stage >= 2);
  if (crtc_updates != NULL)
    for (crtcs_i = 0; crtcs_i < crtcs_n; crtcs_i++)
      {
	if (crtc_updates[crtcs_i].master == 0)
	  memset(&(crtc_updates[crtcs_i].filter.ramps.u8), 0, sizeof(crtc_updates[crtcs_i].filter.ramps.u8));
	crtc_updates[crtcs_i].filter.crtc = NULL;
	crtc_updates[crtcs_i].filter.class = NULL;
	libcoopgamma_filter_destroy(&(crtc_updates[crtcs_i].filter));
	libcoopgamma_error_destroy(&(crtc_updates[crtcs_i].error));
	free(crtc_updates[crtcs_i].slaves);
      }
  return rc;
  
 custom_fail:
  rc = 1;
  goto done;
  
 fail:
  rc = 1;
  if (errno)
    perror(argv0);
  goto done;
  
 cg_fail:
  rc = 1;
  {
    const char* side = cg.error.server_side ? "server" : "client";
    if (cg.error.custom)
      {
	if ((cg.error.number != 0) || (cg.error.description != NULL))
	  fprintf(stderr, "%s: %s-side error number %" PRIu64 ": %s\n",
		  argv0, side, cg.error.number, cg.error.description);
	else if (cg.error.number != 0)
	  fprintf(stderr, "%s: %s-side error number %" PRIu64 "\n", argv0, side, cg.error.number);
	else if (cg.error.description != NULL)
	  fprintf(stderr, "%s: %s-side error: %s\n", argv0, side, cg.error.description);
      }
    else if (cg.error.description != NULL)
      fprintf(stderr, "%s: %s-side error: %s\n", argv0, side, cg.error.description);
    else
      fprintf(stderr, "%s: %s-side error: %s\n", argv0, side, strerror(cg.error.number));
  }
  goto done;
}