path: root/forg-import.c

#include <err.h>
#include <errno.h>
#include <limits.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <sysexits.h>
#include <unistd.h>

#define optstr "0h:L:r:"

typedef struct
{
  const char *hash;
  const char *repository;
  unsigned hash_max_lines;
  char **files;
  unsigned n_files;
  char input_sep;
} options_t;

static void
usage(const char *prgname)
{
  errx(EX_USAGE, "usage %s ...", prgname);
}

static int
str_to_uint(const char *str, unsigned *out)
{
  unsigned long result;
  char *end;

  errno = 0;
  result = strtoul(str, &end, 10);

  if (errno)
    goto fail;

  if (*end != '\0') {
    errno = EINVAL;
    goto fail;
  }

  if (result > UINT_MAX) {
    errno = ERANGE;
    goto fail;
  }

  *out = result;
  return 0;

fail:
  warn("str_to_uint \"%s\"", str);
  return -1;
}

static options_t
read_opts(int argc, char **argv)
{
  int o;
  const char *prgname;
  options_t options = {
    .hash = "md5sum",
    .repository = ".",
    .hash_max_lines = 4096,
    .input_sep = '\n',
  };

  prgname = argc < 1 ? "keep" : argv[0];

  while (o = getopt(argc, argv, optstr), o != -1) {
    switch (o) {
      case '0':
        options.input_sep = '\0';
        break;
      case 'h':
        options.hash = optarg;
        break;
      case 'L':
        if (str_to_uint(optarg, &options.hash_max_lines))
          goto fail;
        break;
      case 'r':
        options.repository = optarg;
        break;
      case '?':
      default:
        usage(prgname);
    }
  }

  options.files = argv + optind;
  options.n_files = argc - optind;

  return options;

fail:
  err(EX_CONFIG, "bad options");
}

static const char *
iter_files(const options_t *opts, void **aux)
{
  struct ctx
  {
    enum
    {
      from_files_list,
      from_stdin,
    } from;

    union
    {
      struct
      {
        int next;
      } files_list;
      struct
      {
        char *line;
        size_t len;
      } stdin;
    };
  };

  struct ctx *ctx = *aux;
  ssize_t nread;

  if (!ctx) { /* initialization */

    *aux = ctx = malloc(sizeof(struct ctx));
    if (!ctx)
      err(EX_OSERR, "malloc");

    *ctx = (struct ctx){ opts->n_files ? from_files_list : from_stdin };
  }

  switch (ctx->from) {
    case from_stdin:
      errno = 0;
      nread =
        getdelim(&ctx->stdin.line, &ctx->stdin.len, opts->input_sep, stdin);
      if (nread == -1) {
        if (!errno) {
          free(ctx->stdin.line);
          goto done;
        }
        err(EX_OSERR, "getdelim(..., stdin)");
      }
      if (opts->input_sep && ctx->stdin.line[nread - 1] == opts->input_sep)
        ctx->stdin.line[nread - 1] = '\0';
      return ctx->stdin.line;

    case from_files_list:
      if (ctx->files_list.next >= opts->n_files)
        goto done;
      return opts->files[ctx->files_list.next++];
  }
  err(EX_SOFTWARE, __FILE__ ":%d - buggy", __LINE__);

done:
  free(*aux);
  *aux = NULL;
  return NULL;
}

static int
run(const options_t *opts)
{
  void *aux = NULL;
  const char *file;

  while (file = iter_files(opts, &aux), file)
    warnx("[%s]", file);

  return 0;
}

int
main(int argc, char **argv)
{
  options_t opts;

  opts = read_opts(argc, argv);
  return run(&opts);
}