moberg.c

#define _POSIX_C_SOURCE  200809L
#define _GNU_SOURCE               /* scandirat */

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>
#include <basedir.h>
#include <stdio.h>
#include <dirent.h>
#include <string.h>
#include <moberg.h>
#include <moberg_config.h>
#include <moberg_parser.h>
#include <moberg_module.h>

struct moberg {
  struct moberg_config *config;
  struct channel_list {
    int capacity;
    struct moberg_channel **value;
  } analog_in, analog_out, digital_in, digital_out, encoder_in;
  struct deferred_action {
    struct deferred_action *next;
    int (*action)(void *param);
    void *param;
  } *deferred_action;

};

static void run_deferred_actions(struct moberg *moberg)
{
  while (moberg->deferred_action) {
    struct deferred_action *deferred = moberg->deferred_action;
    moberg->deferred_action = deferred->next;
    deferred->action(deferred->param);
    free(deferred);
  }
}

static int channel_list_set(struct channel_list *list,
                            int index,
                            struct moberg_channel *value)
{
  if (list->capacity <= index) {
    int capacity;
    for (capacity = 2 ; capacity <= index ; capacity *= 2);
    void *new = realloc(list->value, capacity * sizeof(**list->value));
    if (!new) {
      goto err;
    }
    void *p = new + list->capacity * sizeof(*list->value);
    memset(p, 0, (capacity - list->capacity) * sizeof(**list->value));
    list->value = new;
    list->capacity = capacity;
  }

  if (0 <= index && index < list->capacity) {
    list->value[index] = value;
    return 1;
  }
err:
  return 0;
}
                                   
static int channel_list_get(struct channel_list *list,
                            int index,
                            struct moberg_channel **value)
{
  if (0 <= index && index < list->capacity) {
    *value = list->value[index];
    return 1;
  }
  return 0;
}

static void channel_list_free(struct channel_list *list)
{
  for (int i = 0 ; i < list->capacity ; i++) {
    if (list->value[i]) {
      list->value[i]->down(list->value[i]);
    }
  }
  free(list->value);
}

static void parse_config_at(
  struct moberg *moberg,
  int dirfd,
  const char *pathname)
{
  if (dirfd >= 0) {
    int fd = openat(dirfd, pathname, O_RDONLY);
    if (fd >= 0) {
      struct stat statbuf;
      if (fstat(fd, &statbuf) == 0) {
        char *buf = malloc(statbuf.st_size + 1);
        if (buf) {
          if (read(fd, buf, statbuf.st_size) == statbuf.st_size) {
            buf[statbuf.st_size] = 0;
          }
          struct moberg_config *config = moberg_parse(moberg, buf);
          if (config) {
            if (! moberg->config) {
              moberg->config = config;
            } else {
              moberg_config_join(moberg->config, config);
              moberg_config_free(config);
            }
          }
          free(buf);
        }
      }
      close(fd);
    }
  }
}

static int conf_filter(
  const struct dirent *entry)
{
  char *dot = strrchr(entry->d_name, '.');
  if (dot != NULL && strcmp(dot, ".conf") == 0) {
    return  1;
  } else {
    return 0;
  }
}

static void parse_config_dir_at(
  struct moberg *config,
  int dirfd)
{
  if (dirfd >= 0) {
    struct dirent **entry = NULL;
    int n = scandirat(dirfd, ".", &entry, conf_filter, alphasort);
    for (int i = 0 ; i < n ; i++) {
      parse_config_at(config, dirfd, entry[i]->d_name);
      free(entry[i]);
    }
    free(entry);
  }
  
}

static int install_channel(struct moberg *moberg,
                           int index,
                           struct moberg_device* device,
                           struct moberg_channel *channel)
{
  if (channel) {
    struct moberg_channel *old = NULL;
    switch (channel->kind) {
      case chan_ANALOGIN:
        channel_list_get(&moberg->analog_in, index, &old);
        break;
      case chan_ANALOGOUT:
        channel_list_get(&moberg->analog_out, index, &old);
        break;
      case chan_DIGITALIN:
        channel_list_get(&moberg->digital_in, index, &old);
        break;
      case chan_DIGITALOUT:
        channel_list_get(&moberg->digital_out, index, &old);
        break;
      case chan_ENCODERIN:
        channel_list_get(&moberg->encoder_in, index, &old);
        break;
    }
    if (old) {
      old->down(old);
    }
    channel->up(channel);
    /* TODO: Clean up old channel */
    switch (channel->kind) {
      case chan_ANALOGIN:
        if (! channel_list_set(&moberg->analog_in, index, channel)) {
          goto err;
        }
        break;
      case chan_ANALOGOUT:
        if (! channel_list_set(&moberg->analog_out, index, channel)) {
          goto err;
        }
        break;
      case chan_DIGITALIN:
        if (! channel_list_set(&moberg->digital_in, index, channel)) {
          goto err;
        }
        break;
      case chan_DIGITALOUT:
        if (! channel_list_set(&moberg->digital_out, index, channel)) {
          goto err;
        }
        break;
      case chan_ENCODERIN:
        if (! channel_list_set(&moberg->encoder_in, index, channel)) {
          goto err;
        }
        break;
    }
  }
  return 1;
err:
  return 0;
}

static int install_config(struct moberg *moberg)
{
  struct moberg_channel_install install = {
    .context=moberg,
    .channel=install_channel
  };
  if (! moberg->config) {
    fprintf(stderr, "No moberg configuration found\n");
    return 0;
  } else {
    return moberg_config_install_channels(moberg->config, &install);
  }
}

struct moberg *moberg_new()
{
  struct moberg *result = malloc(sizeof(*result));
  if (! result) {
    fprintf(stderr, "Failed to allocate moberg struct\n");
    goto err;
  }
  result->analog_in.capacity = 0;
  result->analog_in.value = NULL;
  result->analog_out.capacity = 0;
  result->analog_out.value = NULL;
  result->digital_in.capacity = 0;
  result->digital_in.value = NULL;
  result->digital_out.capacity = 0;
  result->digital_out.value = NULL;
  result->encoder_in.capacity = 0;
  result->encoder_in.value = NULL;
  result->deferred_action = NULL;
  result->config = NULL;
    
  /* Parse default configuration(s) */
  const char * const *config_paths = xdgSearchableConfigDirectories(NULL);
  const char * const *path;
  for (path = config_paths ; *path ; path++) {
    int dirfd1 = open(*path, O_DIRECTORY);
    if (dirfd >= 0) {
      parse_config_at(result, dirfd1, "moberg.conf");
      int dirfd2 = openat(dirfd1, "moberg.d", O_DIRECTORY);
      if (dirfd2 >= 0) { 
        parse_config_dir_at(result, dirfd2);
        close(dirfd2);
      }
      close(dirfd1);
    }
    free((char*)*path);
  }
  free((const char **)config_paths);
  
  /* TODO: Read & parse environment overrides */

  install_config(result);
  run_deferred_actions(result);
  
err:
  return result;
}

void moberg_free(struct moberg *moberg)
{
  if (moberg) {
    moberg_config_free(moberg->config);
    channel_list_free(&moberg->analog_in);
    channel_list_free(&moberg->analog_out);
    channel_list_free(&moberg->digital_in);
    channel_list_free(&moberg->digital_out);
    channel_list_free(&moberg->encoder_in);
    run_deferred_actions(moberg);
    free(moberg);
  }
}

/* Input/output */

int moberg_analog_in_open(struct moberg *moberg,
                          int index,
                          struct moberg_analog_in *analog_in)
{
  struct moberg_channel *channel = NULL;
  channel_list_get(&moberg->analog_in, index, &channel);
  if (channel) {
    channel->open(channel);
    *analog_in = channel->action.analog_in;
    return 1;
  }
  return 0;
}

int moberg_analog_in_close(struct moberg *moberg,
                           int index,
                           struct moberg_analog_in analog_in)
{
  struct moberg_channel *channel = NULL;
  channel_list_get(&moberg->analog_in, index, &channel);
  if (channel && channel->action.analog_in.context == analog_in.context) {
    channel->close(channel);
  }
  return 1;
}

int moberg_analog_out_open(struct moberg *moberg,
                           int index,
                           struct moberg_analog_out *analog_out)
{
  struct moberg_channel *channel = NULL;
  channel_list_get(&moberg->analog_out, index, &channel);
  if (channel) {
    channel->open(channel);
    *analog_out = channel->action.analog_out;
    return 1;
  }
  return 0;
}

int moberg_analog_out_close(struct moberg *moberg,
                            int index,
                            struct moberg_analog_out analog_out)
{
  struct moberg_channel *channel = NULL;
  channel_list_get(&moberg->analog_out, index, &channel);
  if (channel && channel->action.analog_out.context == analog_out.context) {
    channel->close(channel);
  }
  return 1;
}

int moberg_digital_in_open(struct moberg *moberg,
                           int index,
                           struct moberg_digital_in *digital_in)
{
  struct moberg_channel *channel = NULL;
  channel_list_get(&moberg->digital_in, index, &channel);
  if (channel) {
    channel->open(channel);
    *digital_in = channel->action.digital_in;
    return 1;
  }
  return 0;
}

int moberg_digital_in_close(struct moberg *moberg,
                            int index,
                            struct moberg_digital_in digital_in)
{
  struct moberg_channel *channel = NULL;
  channel_list_get(&moberg->digital_in, index, &channel);
  if (channel && channel->action.digital_in.context == digital_in.context) {
    channel->close(channel);
  }
  return 1;
}

int moberg_digital_out_open(struct moberg *moberg,
                            int index,
                            struct moberg_digital_out *digital_out)
{
  struct moberg_channel *channel = NULL;
  channel_list_get(&moberg->digital_out, index, &channel);
  if (channel) {
    channel->open(channel);
    *digital_out = channel->action.digital_out;
    return 1;
  }
  return 0;
}

int moberg_digital_out_close(struct moberg *moberg,
                             int index,
                             struct moberg_digital_out digital_out)
{
  struct moberg_channel *channel = NULL;
  channel_list_get(&moberg->digital_out, index, &channel);
  if (channel && channel->action.digital_out.context == digital_out.context) {
    channel->close(channel);
  }
  return 1;
}

int moberg_encoder_in_open(struct moberg *moberg,
                           int index,
                           struct moberg_encoder_in *encoder_in)
{
  struct moberg_channel *channel = NULL;
  channel_list_get(&moberg->encoder_in, index, &channel);
  if (channel) {
    channel->open(channel);
    *encoder_in = channel->action.encoder_in;
    return 1;
  }
  return 0;
}

int moberg_encoder_in_close(struct moberg *moberg,
                            int index,
                            struct moberg_encoder_in encoder_in)
{
  struct moberg_channel *channel = NULL;
  channel_list_get(&moberg->encoder_in, index, &channel);
  if (channel && channel->action.encoder_in.context == encoder_in.context) {
    channel->close(channel);
  }
  return 1;
}

/* System init functionality (systemd/init/...) */

int moberg_start(
  struct moberg *moberg,
  FILE *f)
{
  return moberg_config_start(moberg->config, f);
}

int moberg_stop(
  struct moberg *moberg,
  FILE *f)
{
  return moberg_config_stop(moberg->config, f);
}

/* Intended for final cleanup actions (dlclose so far...) */

void moberg_deferred_action(struct moberg *moberg,
                            int (*action)(void *param),
                            void *param)
{
  struct deferred_action *deferred = malloc(sizeof(*deferred));
  if (deferred) {
    deferred->next = moberg->deferred_action;
    deferred->action = action;
    deferred->param = param;
    moberg->deferred_action = deferred;
  }
}