buf.1: Fix stupid speling mitsake.

[misc] / gorp.c

#include <ctype.h>
#include <errno.h>
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <mLib/alloc.h>
#include <mLib/base64.h>
#include <mLib/base32.h>
#include <mLib/dstr.h>
#include <mLib/hex.h>
#include <mLib/mdwopt.h>
#include <mLib/quis.h>
#include <mLib/report.h>

#include <catacomb/rand.h>
#include <catacomb/noise.h>

struct format {
  const char *name;
  void (*out)(size_t, unsigned);
};

#define CHUNK 1024

static void do_format(size_t n, unsigned line, void *ctx,
		      void (*encode)(void *, char *, size_t, dstr *),
		      void (*fix)(char *, size_t))
{
  char buf[CHUNK];
  dstr d = DSTR_INIT;

  while (n) {
    size_t nn = CHUNK;
    if (nn > n) nn = n;
    rand_get(RAND_GLOBAL, buf, nn);
    encode(ctx, buf, nn, &d);
    if (fix) fix(d.buf, d.len);
    DWRITE(&d, stdout);
    DRESET(&d);
    n -= nn;
  }
  encode(ctx, 0, 0, &d);
  if (!line) {
    while (d.len && d.buf[d.len - 1] == '=')
      d.len--;
  }
  if (fix) fix(d.buf, d.len);
  DPUTC(&d, '\n');
  DWRITE(&d, stdout);
}

static void do_base64(void *ctx, char *p, size_t sz, dstr *d)
  { base64_encode(ctx, p, sz, d); }
static void do_format_base64(size_t n, unsigned line,
			     void (*fix)(char *, size_t))
{
  base64_ctx b;

  base64_init(&b);
  if (line) { b.indent = "\n"; b.maxline = line; }
  else { b.indent = ""; b.maxline = 0; }
  do_format(n, line, &b, do_base64, fix);
}
static void format_base64(size_t n, unsigned line)
  { do_format_base64(n, line, 0); }

static void do_base32(void *ctx, char *p, size_t sz, dstr *d)
  { base32_encode(ctx, p, sz, d); }
static void format_base32(size_t n, unsigned line)
{
  base32_ctx b;

  base32_init(&b);
  if (line) { b.indent = "\n"; b.maxline = line; }
  else { b.indent = ""; b.maxline = 0; }
  do_format(n, line, &b, do_base32, 0);
}

static void fix_file64(char *p, size_t n)
{
  while (n) {
    if (*p == '/') *p = '%';
    p++; n--;
  }
}
static void format_file64(size_t n, unsigned line)
  { do_format_base64(n, line, fix_file64); }

static void fix_safe64(char *p, size_t n)
{
  while (n) {
    if (*p == '+') *p = '-';
    else if (*p == '/') *p = '_';
    p++; n--;
  }
}
static void format_safe64(size_t n, unsigned line)
  { do_format_base64(n, line, fix_safe64); }

static void do_hex(void *ctx, char *p, size_t sz, dstr *d)
  { hex_encode(ctx, p, sz, d); }
static void format_hex(size_t n, unsigned line)
{
  hex_ctx b;

  hex_init(&b);
  if (line) { b.indent = "\n"; b.maxline = line; }
  else { b.indent = ""; b.maxline = 0; }
  do_format(n, line, &b, do_hex, 0);
}

static void format_raw(size_t n, unsigned line)
{
  unsigned char buf[CHUNK];

  while (n) {
    size_t nn = CHUNK;
    if (nn > n) nn = n;
    rand_get(RAND_GLOBAL, buf, nn);
    fwrite(buf, 1, nn, stdout);
    n -= nn;
  }
}

static const struct format fmt[] = {
  { "base64",	format_base64 },
  { "file64",	format_file64 },
  { "safe64",	format_safe64 },
  { "base32",	format_base32 },
  { "hex",	format_hex },
  { "raw",	format_raw },
  { 0,		0 }
};

static int uarg(const char *p, const char *what)
{
  unsigned long x;
  char *q;
  errno = 0;
  x = strtoul(p, &q, 0);
  if (*q || errno || x > INT_MAX) die(EXIT_FAILURE, "bad %s", what);
  return (x);
}

static void version(FILE *fp)
{
  pquis(stderr, "$, version " VERSION "\n");
}

static void usage(FILE *fp)
{
  pquis(stderr, "Usage: $ [-y] [-l LEN] [-f FORMAT] [BITS]\n");
}

static void help(FILE *fp)
{
  version(fp);
  putc('\n', fp);
  usage(fp);
  fputs("\n\
Generates a random string, and prints it to standard output.\n\
\n\
Options:\n\
\n\
-h, --help		Print this help message.\n\
-v, --version		Print program version number.\n\
-u, --usage		Print short usage summary.\n\
\n\
-y, --bytes		Output length is bytes, not bits.\n\
-l, --line=LENGTH	For textual output, limit line length to LENGTH.\n\
-f, --format=FORMAT	Select output format:\n\
			  base64, file64, safe64, base32, hex, raw.\n\
", stdout);
}

int main(int argc, char *argv[])
{
  size_t n;
  unsigned f = 0;
  unsigned len = 0;
  unsigned mul = 8;
  const struct format *ff = &fmt[0];

#define f_bogus 1u

  ego(argv[0]);
  for (;;) {
    static const struct option opt[] = {
      { "help",		0,		0,	'h' },
      { "version",	0,		0,	'v' },
      { "usage",	0,		0,	'u' },

      { "format",	OPTF_ARGREQ,	0,	'f' },
      { "line",		OPTF_ARGREQ,	0,	'l' },
      { "bytes",	0,		0,	'y' },
      { 0,		0,		0,	0 }
    };
    int i;

    i = mdwopt(argc, argv, "hvuf:l:y", opt, 0, 0, 0);
    if (i < 0)
      break;
    switch (i) {
      case 'h':
	help(stdout);
	exit(0);
      case 'v':
	version(stdout);
	exit(0);
      case 'u':
	usage(stdout);
	exit(0);
      case 'y':
	mul = 1;
	break;
      case 'l':
	len = uarg(optarg, "line length");
	break;
      case 'f':
	ff = 0;
	n = strlen(optarg);
	for (i = 0; fmt[i].name; i++) {
	  if (strncmp(fmt[i].name, optarg, n) != 0)
	    continue;
	  if (!fmt[i].name[n]) {
	    ff = &fmt[i];
	    break;
	  }
	  if (ff)
	    die(EXIT_FAILURE, "ambiguous format name `%s'", optarg);
	  ff = &fmt[i];
	}
	if (!ff)
	  die(EXIT_FAILURE, "unknown format name `%s'", optarg);
	break;
      default:
	f |= f_bogus;
	break;
    }
  }

  argc -= optind;
  argv += optind;
  if (f & f_bogus && argc > 1) {
    usage(stderr);
    exit(EXIT_FAILURE);
  }
  n = argc == 1 ? uarg(argv[0], "bit count") : 128;
  if (!n || n % mul) die(EXIT_FAILURE, "bad bit count");
  n /= mul;
  rand_noisesrc(RAND_GLOBAL, &noise_source);
  rand_seed(RAND_GLOBAL, 160);
  ff->out(n, len);
  if (ferror(stdout))
    die(EXIT_FAILURE, "output error: %s", strerror(errno));
  return (0);
}