Emit random numbers for statistical tests.

[u/mdw/catacomb] / rspit.c

/* -*-c-*-
 *
 * $Id: rspit.c,v 1.1 1999/12/10 23:29:13 mdw Exp $
 *
 * Spit out random numbers
 *
 * (c) 1999 Straylight/Edgeware
 */

/*----- Licensing notice --------------------------------------------------* 
 *
 * This file is part of Catacomb.
 *
 * Catacomb is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Library General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 * 
 * Catacomb 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 Library General Public License for more details.
 * 
 * You should have received a copy of the GNU Library General Public
 * License along with Catacomb; if not, write to the Free
 * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
 * MA 02111-1307, USA.
 */

/*----- Revision history --------------------------------------------------* 
 *
 * $Log: rspit.c,v $
 * Revision 1.1  1999/12/10 23:29:13  mdw
 * Emit random numbers for statistical tests.
 *
 */

/*----- Header files ------------------------------------------------------*/

#include "config.h"

#include <errno.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

#ifndef PORTABLE
#  include <unistd.h>
#endif

#include <mLib/darray.h>
#include <mLib/dstr.h>
#include <mLib/mdwopt.h>
#include <mLib/quis.h>
#include <mLib/report.h>
#include <mLib/sub.h>

#include "grand.h"

#include "lcrand.h"
#include "fibrand.h"
#include "rand.h"
#include "noise.h"

#include "bbs.h"
#include "mprand.h"

#include "rc4.h"

#include "des-ofb.h"
#include "des3-ofb.h"
#include "rc5-ofb.h"
#include "blowfish-ofb.h"
#include "idea-ofb.h"

#include "rmd160.h"

/*----- Data structures ---------------------------------------------------*/

typedef struct gen {
  const char *name;
  grand *(*seed)(unsigned /*i*/);
  unsigned i;
  const char *help;
} gen;

static gen generators[];

/*----- Miscellaneous static data -----------------------------------------*/

static FILE *outfp = stdout;
static size_t outsz = 0;

static int argc;
static char **argv;

static unsigned flags = 0;

enum {
  f_progress = 1,
  f_file = 2
};

/*----- Help options ------------------------------------------------------*/

static void usage(FILE *fp)
{
  pquis(fp, "Usage: $ generator [options]\n");
}

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

static void help(FILE *fp)
{
  version(fp);
  fputc('\n', fp);
  usage(fp);
  pquis(fp, "\n\
Emits a stream of random bytes suitable for, well, all sorts of things.\n\
The primary objective is to be able to generate streams of input for\n\
statistical tests, such as Diehard.\n\
\n\
Options are specific to the particular generator, although there's a\n\
common core set:\n\
\n\
-h, --help		Display this help message.\n\
-v, --version		Display the program's version number.\n\
-u, --usage		Display a useless usage message.\n\
\n\
-l, --list		Show a list of the supported generators, with\n\
			their options.\n\
-o, --output FILE	Write output to FILE, not stdout.\n\
-z, --size SIZE		Emit SIZE bytes, not an unlimited number.\n\
-p, --progress		Show a little progress meter (on stderr).\n\
\n\
(A SIZE may be followed by `g' for gigabytes, `m' for megabytes, or\n\
`k' for kilobytes.  If unqualified, an amount in bytes is assumed.)\n\
");
}

/*----- Main options parser -----------------------------------------------*/

static struct option opts[] = {

  /* --- Standard GNU help options --- */

  { "help",	0,		0,	'h' },
  { "version",	0,		0,	'v' },
  { "usage",	0,		0,	'u' },

  /* --- Other useful things --- */

  { "list",	0,		0,	'l' },
  { "output",	OPTF_ARGREQ,	0,	'o' },
  { "size",	OPTF_ARGREQ,	0,	'z' },
  { "progress",	0,		0,	'p' },

  /* --- End of main table --- */

  { 0,		0,		0,	0 }
};

static const char *sopts = "hvu lo:z:p";

#ifndef OPTION_V
   DA_DECL(option_v, struct option);
#  define OPTION_V
#endif

static option_v optv = DA_INIT;
static dstr optd = DSTR_INIT;

/* --- @addopts@ --- *
 *
 * Arguments:	@const char *s@ = pointer to short options
 *		@struct option *l@ = pointer to long options
 *
 * Returns:	---
 *
 * Use:		Adds a collection of options to the table.
 */

static void addopts(const char *s, struct option *l)
{
  dstr_puts(&optd, s);
  if (DA_LEN(&optv))
    DA_SHRINK(&optv, 1);
  while (l->name)
    DA_PUSH(&optv, *l++);
  DA_PUSH(&optv, *l);
}

/* --- @opt@ --- *
 *
 * Arguments:	---
 *
 * Returns:	Next option from argument array.
 *
 * Use:		Fetches options, handling the standard ones.
 */

static int opt(void)
{
  for (;;) {
    int i = mdwopt(argc, argv, optd.buf, DA(&optv), 0, 0, 0);
    switch (i) {
      case 'h':
	help(stdout);
	exit(0);
      case 'v':
	version(stdout);
	exit(0);
      case 'u':
	usage(stdout);
	exit(0);
      case 'l': {
	gen *g;
	puts("Generators supported:");
	for (g = generators; g->name; g++)
	  printf("  %s %s\n", g->name, g->help);
	exit(0);
      } break;
      case 'o':
	if (flags & f_file)
	  die(EXIT_FAILURE, "already set an output file");
	if (strcmp(optarg, "-") == 0)
	  outfp = stdout;
	else {
	  outfp = fopen(optarg, "w");
	  if (!outfp) {
	    die(EXIT_FAILURE, "couldn't open output file `%s': %s",
		strerror(errno));
	  }
	}
	flags |= f_file;
	break;
      case 'z': {
	char *p;
	outsz = strtoul(optarg, &p, 0);
	if (!outsz)
	  die(EXIT_FAILURE, "bad number `%s'", optarg);
	switch (*p) {
	  case 'G': case 'g': outsz *= 1024;
	  case 'M': case 'm': outsz *= 1024;
	  case 'K': case 'k': outsz *= 1024;
	  case 0:
	    break;
	  default:
	    die(EXIT_FAILURE, "bad suffix `%s'", p);
	    break;
	}
	if (*p && p[1] != 0)
	  die(EXIT_FAILURE, "bad suffix `%s'", p);
      } break;
      case 'p':
	flags |= f_progress;
	break;
      default:
	return (i);
    }
  }
}

/*----- Manglers for seed strings -----------------------------------------*/

/* --- @unhex@ --- *
 *
 * Arguments:	@const char *p@ = pointer to input string
 *		@char **end@ = where the end goes
 *		@dstr *d@ = output buffer
 *
 * Returns:	---
 *
 * Use:		Transforms a hex string into a chunk of binary data.
 */

static void unhex(const char *p, char **end, dstr *d)
{
  while (p[0] && p[1]) {
    int x = p[0], y = p[1];
    if ('0' <= x && x <= '9') x -= '0';
    else if ('A' <= x && x <= 'F') x -= 'A' - 10;
    else if ('a' <= x && x <= 'f') x -= 'a' - 10;
    else x = 0;
    if ('0' <= y && y <= '9') y -= '0';
    else if ('A' <= y && y <= 'F') y -= 'A' - 10;
    else if ('a' <= y && y <= 'f') y -= 'a' - 10;
    else y = 0;
    DPUTC(d, (x << 4) + y);
    p += 2;
  }
  *end = (char *)p;
}

/*----- Generators --------------------------------------------------------*/

/* --- Blum-Blum-Shub strong generator --- */

static int bbsev(int ev, mp *m, void *p)
{
  switch (ev) {
    case BBSEV_FINDP:
      fputs("Searching for p: ", stderr);
      fflush(stderr);
      break;
    case BBSEV_FINDQ:
      fputs("Searching for q: ", stderr);
      fflush(stderr);
      break;
    case BBSEV_FAILP:
    case BBSEV_FAILQ:
      fputc('.', stderr);
      fflush(stderr);
      break;
    case BBSEV_PASSP:
    case BBSEV_PASSQ:
      fputc('+', stderr);
      fflush(stderr);
      break;
    case BBSEV_GOODP:
    case BBSEV_GOODQ:
      fputc('\n', stderr);
      fflush(stderr);
      break;
  }
  return (0);
}

static grand *gen_bbs(unsigned i)
{
  /* --- Default modulus --- *
   *
   * The factors of this number are
   *
   *  @p = 1229936431484295969649886203367009966370895964206162032259292413@
   *      @7754313537966036459299022912838407755462506416274551744201653277@
   *	  @313130311731673973886822067@
   *
   *  @q = 9798171783943489959487301695884963889684294764514008432498259742@
   *	  @5374320073594018817245784145742769603334292182227671519041431067@
   *	  @61344781426317516045890159@
   *
   * Both %$p$% and %$q$% are prime; %$(p - 1)/2%$ and %$(q - 1)/2$% have no
   * common factors.  They were found using this program, with random
   * starting points.
   *
   * I hope that, by publishing these factors, I'll dissuade people from
   * actually using this modulus in attempt to actually attain real
   * security.  The program is quite quick at finding Blum numbers, so
   * there's no excuse for not generating your own.
   */

  const char *mt =
  "120511284390135742513572142094334711443073194119732569353820828435640527418092392240366088035509890969913081816369160298961490135716255689660470370755013177656905237112577648090277537209936078171554274553448103698084782669252936352843649980105109850503830397166360721262431179505917248447259735253684659338653";

  /* --- Other things --- */

  grand *r;
  const char *xt = 0;
  unsigned bits = 512;
  mp *m, *x;
  unsigned show = 0;

  /* --- Parse options --- */

  static struct option opts[] = {
    { "modulus",	OPTF_ARGREQ,	0,	'm' },
    { "generate",	0,		0,	'g' },
    { "seed",		OPTF_ARGREQ,	0,	's' },
    { "bits",		OPTF_ARGREQ,	0,	'b' },
    { "show",		0,		0,	'S' },
    { 0,		0,		0,	0 }
  };

  addopts("m:gs:b:S", opts);

  for (;;) {
    int o = opt();
    if (o < 0)
      break;
    switch (o) {
      case 'm':
	mt = optarg;
	break;
      case 'g':
	mt = 0;
	break;
      case 's':
	xt = optarg;
	break;
      case 'b':
	bits = strtoul(optarg, 0, 0);
	if (bits == 0)
	  die(EXIT_FAILURE, "bad number of bits `%s'", optarg);
	break;
      case 'S':
	show = 1;
	break;
      default:
	return (0);
    }
  }

  /* --- Generate a modulus if one is requested --- */

  if (mt) {
    char *p;
    m = mp_readstring(MP_NEW, mt, &p, 0);
    if (*p)
      die(EXIT_FAILURE, "bad modulus `%s'", mt);
    /* Unfortunately I don't know how to test for a Blum integer */
  } else {
    mp *p = mprand(MP_NEW, bits / 2, &rand_global, 3);
    mp *q = mprand(MP_NEW, bits - bits / 2, &rand_global, 3);
    bbs_params bp;
    int err;

    if ((err = bbs_gen(&bp, p, q, 0,
		       (flags & f_progress) ? bbsev : 0, 0)) !=	0)
      die(EXIT_FAILURE, "modulus generation failed (reason = %i)", err);
    m = bp.n;

    if (show) {
      fputs("p = ", stderr);
      mp_writefile(bp.p, stderr, 10);
      fputs("\nq = ", stderr);
      mp_writefile(bp.q, stderr, 10);
      fputs("\nn = ", stderr);
      mp_writefile(bp.n, stderr, 10);
      fputc('\n', stderr);
    }

    mp_drop(p);
    mp_drop(q);
    mp_drop(bp.p);
    mp_drop(bp.q);
  }

  /* --- Set up a seed --- */

  if (!xt)
    x = mprand(MP_NEW, mp_bits(m) - 1, &rand_global, 1);
  else {
    char *p;
    x = mp_readstring(MP_NEW, xt, &p, 0);
    if (*p)
      die(EXIT_FAILURE, "bad modulus `%s'", xt);
  }

  /* --- Right --- */

  r = bbs_rand(m, x);

  mp_drop(m);
  mp_drop(x);
  return (r);
}

/* --- Catacomb's random number generator --- */

static grand *gen_rand(unsigned i)
{
  grand *r = rand_create();
  dstr d = DSTR_INIT;

  static struct option opts[] = {
    { "key",		OPTF_ARGREQ,	0,	'k' },
    { "text",		OPTF_ARGREQ,	0,	't' },
    { "hex",		OPTF_ARGREQ,	0,	'H' },
    { "noise",		0,		0,	'n' },
    { 0,		0,		0,	0 }
  };

  addopts("k:t:H:n", opts);

  for (;;) {
    int o = opt();
    if (o < 0)
      break;
    switch (o) {
      case 'k': {
	rmd160_ctx c;
	octet hash[RMD160_HASHSZ];
	rmd160_init(&c);
	rmd160_hash(&c, optarg, strlen(optarg));
	rmd160_done(&c, hash);
	r->ops->misc(r, RAND_KEY, hash, sizeof(hash));
      } break;
      case 't':
	r->ops->misc(r, GRAND_SEEDBLOCK, optarg, strlen(optarg));
	break;
      case 'H': {
	char *p;
	DRESET(&d);
	unhex(optarg, &p, &d);
	if (*p)
	  die(EXIT_FAILURE, "bad hex key `%s'", optarg);
	r->ops->misc(r, GRAND_SEEDBLOCK, d.buf, d.len);
      } break;
      case 'n':
	r->ops->misc(r, RAND_NOISESRC, &noise_source);
	break;
    }
  }

  dstr_destroy(&d);
  return (r);
}

/* --- RC4 output --- */

static grand *gen_rc4(unsigned i)
{
  grand *r;
  dstr d = DSTR_INIT;

  static struct option opts[] = {
    { "key",		OPTF_ARGREQ,	0,	'k' },
    { "hex",		OPTF_ARGREQ,	0,	'H' },
    { 0,		0,		0,	0 }
  };

  addopts("k:H:", opts);

  for (;;) {
    int o = opt();
    if (o < 0)
      break;
    switch (o) {
      case 'k': {
	rmd160_ctx c;
	dstr_ensure(&d, RMD160_HASHSZ);
	rmd160_init(&c);
	rmd160_hash(&c, optarg, strlen(optarg));
	rmd160_done(&c, d.buf);
	d.len += RMD160_HASHSZ;
      } break;
      case 'H': {
	char *p;
	unhex(optarg, &p, &d);
	if (*p)
	  die(EXIT_FAILURE, "bad hex key `%s'", optarg);
      } break;
      default:
	return (0);
    }
  }

  if (!d.len) {
    dstr_ensure(&d, 16);
    d.len = 16;
    rand_getgood(RAND_GLOBAL, d.buf, d.len);
  }
  r = rc4_rand(d.buf, d.len);
  dstr_destroy(&d);
  return (r);
}

/* --- Output feedback generators --- */

#define OFBTAB								\
  E(OFB_DES,	  DES_KEYSZ, DES_BLKSZ, des_ofbrand),			\
  E(OFB_DES3,	  DES3_KEYSZ, DES3_BLKSZ, des3_ofbrand),		\
  E(OFB_RC5,	  RC5_KEYSZ, RC5_BLKSZ, rc5_ofbrand),			\
  E(OFB_BLOWFISH, BLOWFISH_KEYSZ, BLOWFISH_BLKSZ, blowfish_ofbrand),	\
  E(OFB_IDEA,	  IDEA_KEYSZ, IDEA_BLKSZ, idea_ofbrand)

static struct {
  size_t keysz;
  size_t blksz;
  grand *(*rand)(const void */*k*/, size_t /*sz*/);
} ofbtab[] = {
#define E(c, x, y, z) { x, y, z }
  OFBTAB
#undef E
};

enum {
#define E(c, x, y, z) c
  OFBTAB
#undef E
};

#undef OFBTAB

static grand *gen_ofb(unsigned i)
{
  grand *r;
  dstr d = DSTR_INIT;
  dstr iv = DSTR_INIT;

  static struct option opts[] = {
    { "key",		OPTF_ARGREQ,	0,	'k' },
    { "hex",		OPTF_ARGREQ,	0,	'H' },
    { "iv",		OPTF_ARGREQ,	0,	'i' },
    { 0,		0,		0,	0 }
  };

  addopts("k:H:i:", opts);

  for (;;) {
    int o = opt();
    if (o < 0)
      break;
    switch (o) {
      case 'k': {
	rmd160_ctx c;
	dstr_ensure(&d, RMD160_HASHSZ);
	rmd160_init(&c);
	rmd160_hash(&c, optarg, strlen(optarg));
	rmd160_done(&c, d.buf);
	d.len += RMD160_HASHSZ;
      } break;
      case 'H': {
	char *p;
	unhex(optarg, &p, &d);
	if (*p)
	  die(EXIT_FAILURE, "bad hex key `%s'", optarg);
      } break;
      case 'i': {
	char *p;
	unhex(optarg, &p, &iv);
	if (*p)
	  die(EXIT_FAILURE, "bad hex IV `%s'", optarg);
      } break;
      default:
	return (0);
    }
  }

  if (!d.len) {
    size_t n = ofbtab[i].keysz;
    if (!n)
      n = 16;
    dstr_ensure(&d, n);
    d.len = n;
    rand_getgood(RAND_GLOBAL, d.buf, d.len);
  }

  while (d.len < ofbtab[i].keysz)
    DPUTD(&d, &d);
  if (ofbtab[i].keysz && d.len > ofbtab[i].keysz)
    d.len = ofbtab[i].keysz;

  r = ofbtab[i].rand(d.buf, d.len);
  if (iv.len) {
    while (iv.len < ofbtab[i].blksz)
      DPUTD(&iv, &iv);
    r->ops->misc(r, GRAND_SEEDBLOCK, iv.buf);
  }

  dstr_destroy(&d);
  dstr_destroy(&iv);
  return (r);
}

/* --- Fibonacci generator --- */

static grand *gen_fib(unsigned i)
{
  grand *r;
  uint32 s = 0;
  char *p;
  unsigned set = 0;

  static struct option opts[] = {
    { "seed",		OPTF_ARGREQ,	0,	's' },
    { 0,		0,		0,	0 }
  };

  addopts("s:", opts);

  for (;;) {
    int o = opt();
    if (o < 0)
      break;
    switch (o) {
      case 's':
	s = strtoul(optarg, &p, 0);
	if (*p)
	  die(EXIT_FAILURE, "bad integer `%s'", optarg);
	set = 1;
	break;
      default:
	return (0);
    }
  }
  r = fibrand_create(s);
  if (!set)
    r->ops->misc(r, GRAND_SEEDRAND, &rand_global);
  return (r);
}

/* --- LC generator --- */

static grand *gen_lc(unsigned i)
{
  uint32 s = 0;
  char *p;
  unsigned set = 0;

  static struct option opts[] = {
    { "seed",		OPTF_ARGREQ,	0,	's' },
    { 0,		0,		0,	0 }
  };

  addopts("s:", opts);

  for (;;) {
    int o = opt();
    if (o < 0)
      break;
    switch (o) {
      case 's':
	s = strtoul(optarg, &p, 0);
	if (*p)
	  die(EXIT_FAILURE, "bad integer `%s'", optarg);
	set = 1;
	break;
      default:
	return (0);
    }
  }
  if (!set) {
    do
      s = rand_global.ops->range(&rand_global, LCRAND_P);
    while (s == LCRAND_FIXEDPT);
  }
  return (lcrand_create(s));
}

/* --- Basic options parser -- can't generate output --- */

static grand *gen_opts(unsigned i)
{
  while (opt() >= 0)
    ;
  return (0);
}

/*----- Generators table --------------------------------------------------*/

static gen generators[] = {
  { "fibonacci",	gen_fib,	0,
    "[-s SEED]" },
  { "lc",		gen_lc,		0,
    "[-s SEED]" },
  { "des-ofb",		gen_ofb,	OFB_DES,
    "[-k KEY-PHRASE] [-H HEX-KEY] [-i HEX-IV]" },
  { "3des-ofb",		gen_ofb,	OFB_DES3,
    "[-k KEY-PHRASE] [-H HEX-KEY] [-i HEX-IV]" },
  { "rc5-ofb",		gen_ofb,	OFB_RC5,
    "[-k KEY-PHRASE] [-H HEX-KEY] [-i HEX-IV]" },
  { "blowfish-ofb",		gen_ofb,	OFB_BLOWFISH,
    "[-k KEY-PHRASE] [-H HEX-KEY] [-i HEX-IV]" },
  { "idea-ofb",		gen_ofb,	OFB_IDEA,
    "[-k KEY-PHRASE] [-H HEX-KEY] [-i HEX-IV]" },
  { "rc4",		gen_rc4,	0,
    "[-k KEY-PHRASE] [-H HEX-KEY]" },
  { "rand",		gen_rand,	0,
    "[-n] [-k KEY-PHRASE] [-t TEXT-BLOCK] [-H HEX-BLOCK]" },
  { "bbs",		gen_bbs,	0,
    "[-gS] [-s SEED] [-m MODULUS] [-b BITS" },
  { 0,			0,		0, 0 },
};

static gen optsg = { "options", gen_opts, 0,
		     "This message shouldn't be printed." };

/*----- Main code ---------------------------------------------------------*/

int main(int ac, char *av[])
{
  gen *g = &optsg;
  grand *r;
  unsigned percent = -1;
  size_t kb = 0;
  time_t last;
  static char baton[] = "|/-\\";
  char *bp;

  /* --- Initialize mLib --- */

  ego(av[0]);
  sub_init();

  /* --- Set up the main Catacomb generator --- */

  rand_noisesrc(RAND_GLOBAL, &noise_source);

  /* --- Initialize the options table --- */

  addopts(sopts, opts);
  argc = ac;
  argv = av;

  /* --- Read the generator out of the first argument --- */

  if (argc > 1 && *argv[1] != '-') {
    const char *arg = av[1];
    size_t sz = strlen(arg);
    gen *gg;

    g = 0;
    for (gg = generators; gg->name; gg++) {
      if (strncmp(arg, gg->name, sz) == 0) {
	if (gg->name[sz] == 0) {
	  g = gg;
	  break;
	} else if (g)
	  die(EXIT_FAILURE, "ambiguous generator name `%s'", arg);
	else
	  g = gg;
      }
    }
    if (!g)
      die(EXIT_FAILURE, "unknown generator name `%s'", arg);
    argc--;
    argv++;
  }

  /* --- Get a generic random number generator --- */

  r = g->seed(g->i);
  if (!r || optind != ac - 1) {
    usage(stderr);
    exit(EXIT_FAILURE);
  }

#ifndef PORTABLE
  if (!(flags & f_file) && isatty(STDOUT_FILENO))
    die(EXIT_FAILURE, "writing output to a terminal is a bad idea");
#endif

  /* --- Spit out random data --- */

  last = time(0);
  bp = baton;
  if (flags & f_progress) {
    char *errbuf = xmalloc(BUFSIZ);
    setvbuf(stderr, errbuf, _IOLBF, BUFSIZ);
    fputc('[', stderr);
    fflush(stderr);
  }

#ifdef SIGPIPE
  signal(SIGPIPE, SIG_IGN);
#endif

  for (;;) {
    octet buf[BUFSIZ];
    size_t sz = sizeof(buf);

    /* --- Emit a bufferful (or less) of data --- */

    if (outsz) {
      if (sz > outsz - kb)
	sz = outsz - kb;
    }
    r->ops->fill(r, buf, sz);
    if (fwrite(buf, 1, sz, outfp) != sz) {
      if (flags & f_progress)
	fputc('\n', stderr);
      die(EXIT_FAILURE, "error writing data: %s", strerror(errno));
    }
    kb += sz;

    /* --- Update the display --- */

    if (flags & f_progress) {
      time_t t = time(0);
      unsigned up = 0;

      if (percent > 100)
	up = 1;

      if (!outsz) {
	if (difftime(t, last) > 1.0) {
	  up = 1;
	}
	if (up)
	  fputs(" ] ", stderr);
      } else {
	unsigned pc = kb * 100.0 / outsz;
	if (pc > percent || percent > 100 || difftime(t, last) > 1.0) {
	  if (percent > 100)
	    percent = 0;
	  percent &= ~1;
	  for (; percent < (pc & ~1); percent += 2)
	    putc('.', stderr);
	  percent = pc;
	  for (; pc < 100; pc += 2)
	    putc(' ', stderr);
	  fprintf(stderr, "] %3i%% ", percent);
	  up = 1;
	}
      }

      if (up) {
	size_t q = kb;
	char *suff = " KMG";
	while (q > 8192 && suff[1]) {
	  q >>= 10;
	  suff++;
	}
	fprintf(stderr, "%4i%c\r[", q, *suff);
	if (outsz) {
	  unsigned pc;
	  for (pc = 0; pc < (percent & ~1); pc += 2)
	    putc('.', stderr);
	}
	last = t;
      }

      if (percent > 100)
	percent = 0;

      if (percent < 100) {
	putc(*bp++, stderr);
	putc('\b', stderr);
	if (!*bp)
	  bp = baton;
      }
      fflush(stderr);
    }

    /* --- Terminate the loop --- */

    if (outsz && kb >= outsz)
      break;
  }

  /* --- Done --- */

  r->ops->destroy(r);
  if (flags & f_progress)
    fputc('\n', stderr);
  return (0);
}

/*----- That's all, folks -------------------------------------------------*/