/**
 * featherweight – Keccak-based userspace pseudorandom number generator
 * Copyright © 2014  Mattias Andrée (maandree@member.fsf.org)
 * 
 * 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 <stdio.h>
#include <errno.h>
#include <fcntl.h>
#include <unistd.h>
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <alloca.h>

#include <libkeccak.h>
#include <argparser.h>



#ifndef URANDOM
# ifndef DEVDIR
#  define DEVDIR  "/dev"
# endif
# define URANDOM  DEVDIR "/urandom"
#endif



#define USER_ERROR(string) 				\
  (fprintf(stderr, "%s: %s.\n", execname, string), 1)

#define ADD(arg, desc, ...)								\
  (arg ? args_add_option(args_new_argumented(NULL, arg, 0, __VA_ARGS__, NULL), desc)	\
       : args_add_option(args_new_argumentless(NULL, 0, __VA_ARGS__, NULL), desc))

#define LAST(arg)					\
  (args_opts_get(arg)[args_opts_get_count(arg) - 1])



/**
 * `argv[0]` from `main`
 */
static char* execname;


/**
 * Convert `libkeccak_generalised_spec_t` to `libkeccak_spec_t` and check for errors
 * 
 * @param   gspec  See `libkeccak_degeneralise_spec` 
 * @param   spec   See `libkeccak_degeneralise_spec` 
 * @return         Zero on success, an appropriate exit value on error
 */
static int make_spec(libkeccak_generalised_spec_t* restrict gspec, libkeccak_spec_t* restrict spec)
{
  int r;
  
#define TEST(CASE, STR)  case LIBKECCAK_GENERALISED_SPEC_ERROR_##CASE:  return USER_ERROR(STR)
  if (r = libkeccak_degeneralise_spec(gspec, spec), r)
    switch (r)
      {
	TEST (STATE_NONPOSITIVE,      "the state size must be positive");
	TEST (STATE_TOO_LARGE,        "the state size is too large, may not exceed 1600");
	TEST (STATE_MOD_25,           "the state size must be a multiple of 25");
	TEST (WORD_NONPOSITIVE,       "the word size must be positive");
	TEST (WORD_TOO_LARGE,         "the word size is too large, may not exceed 64");
	TEST (STATE_WORD_INCOHERENCY, "the state size must be exactly 25 times the word size");
	TEST (CAPACITY_NONPOSITIVE,   "the capacity must be positive");
	TEST (CAPACITY_MOD_8,         "the capacity must be a multiple of 8");
	TEST (BITRATE_NONPOSITIVE,    "the rate must be positive");
	TEST (BITRATE_MOD_8,          "the rate must be a multiple of 8");
	TEST (OUTPUT_NONPOSITIVE,     "the output size must be positive");
      default:
	return USER_ERROR("unknown error in algorithm parameters");
    }
#undef TEST
  
#define TEST(CASE, STR)  case LIBKECCAK_SPEC_ERROR_##CASE:  return USER_ERROR(STR)
  if (r = libkeccak_spec_check(spec), r)
    switch (r)
      {
      TEST (BITRATE_NONPOSITIVE,  "the rate size must be positive");
      TEST (BITRATE_MOD_8,        "the rate must be a multiple of 8");
      TEST (CAPACITY_NONPOSITIVE, "the capacity must be positive");
      TEST (CAPACITY_MOD_8,       "the capacity must be a multiple of 8");
      TEST (OUTPUT_NONPOSITIVE,   "the output size must be positive");
      TEST (STATE_TOO_LARGE,      "the state size is too large, may not exceed 1600");
      TEST (STATE_MOD_25,         "the state size must be a multiple of 25");
      TEST (WORD_NON_2_POTENT,    "the word size must be a power of 2");
      TEST (WORD_MOD_8,           "the word size must be a multiple of 8");
      default:
	return USER_ERROR("unknown error in algorithm parameters");
      }
#undef TEST
  
  return 0;
}



/**
 * Mane!
 * 
 * @param   argc  The number of elements in `argv`
 * @param   argv  Command line arguments
 * @return        Zero on and only on success
 */
int main(int argc, char** argv)
{
  char* restrict generated_random = NULL;
  libkeccak_generalised_spec_t gspec;
  libkeccak_spec_t spec;
  libkeccak_state_t state;
  size_t length, ptr;
  ssize_t got;
  int r, fd = -1, verbose = 0;
  
  execname = *argv;
  
  
  memset(&state, 0, sizeof(libkeccak_state_t));
  libkeccak_generalised_spec_initialise(&gspec);
  
  args_init("Keccak-based userspace pseudorandom number generator",
	    "krandom [options...]", NULL,
	    NULL, 1, 0, args_standard_abbreviations);
   
  ADD(NULL,       "Display option summary", "-h", "--help");
  ADD("RATE",     "Select rate",            "-R", "--bitrate", "--rate");
  ADD("CAPACITY", "Select capacity",        "-C", "--capacity");
  ADD("SIZE",     "Select output size",     "-N", "-O", "--output-size", "--output");
  ADD("SIZE",     "Select state size",      "-S", "-B", "--state-size", "--state");
  ADD("SIZE",     "Select word size",       "-W", "--word-size", "--word");
  ADD(NULL,       "Be verbose",             "-v", "--verbose");
  
  args_parse(argc, argv);
  
  if (args_opts_used("-h"))  return args_help(0), args_dispose(), 0;
  if (args_opts_used("-R"))  gspec.bitrate    = atol(LAST("-R"));
  if (args_opts_used("-C"))  gspec.capacity   = atol(LAST("-C"));
  if (args_opts_used("-N"))  gspec.output     = atol(LAST("-N"));
  if (args_opts_used("-S"))  gspec.state_size = atol(LAST("-S"));
  if (args_opts_used("-W"))  gspec.word_size  = atol(LAST("-W"));
  if (args_opts_used("-v"))  verbose          = 1;
  
  if ((r = make_spec(&gspec, &spec)))
      goto done;
  
  if (verbose)
    {
      fprintf(stderr, "%s: "        "rate: %li\n", execname, gspec.bitrate);
      fprintf(stderr, "%s: "    "capacity: %li\n", execname, gspec.capacity);
      fprintf(stderr, "%s: " "output size: %li\n", execname, gspec.output);
      fprintf(stderr, "%s: "  "state size: %li\n", execname, gspec.state_size);
      fprintf(stderr, "%s: "   "word size: %li\n", execname, gspec.word_size);
    }
  
  libkeccak_state_initialise(&state, &spec);
  
  fd = open(URANDOM, O_RDONLY);
  if (fd < 0)
    goto fail;
  for (ptr = 0, length = sizeof(state.S); ptr < length;)
    {
      got = read(fd, (char*)(state.S) + ptr, length - ptr);
      if (got <= 0)
	goto fail;
      ptr += (size_t)got;
    }
  close(fd), fd = -1;
  
  length = (size_t)((spec.output + 7) / 8);
  generated_random = malloc(length);
  if (generated_random == NULL)
    goto fail;
  
  for (;;)
    {
      libkeccak_squeeze(&state, generated_random);
      got = write(STDOUT_FILENO, generated_random, length);
      if (got >= 0)
	continue;
      if (errno == EPIPE)
	break;
      goto fail;
    }
  
  
 done:
  if (fd >= 0)
    close(fd);
  args_dispose();
  free(generated_random);
  libkeccak_state_fast_destroy(&state);
  return r;
 fail:
  perror(execname);
  r = 2;
  goto done;
}