/* 

   keyrand implementation using /dev/random

   Copyright (C) 2006 Red Hat, Inc.

   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 2 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, write to the Free Software

   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

*/

#include <sys/types.h>

#include <unistd.h>

#include <string.h>

#include <stdio.h>

#include <fcntl.h>

#include <errno.h>

#include <stdlib.h>

#include <slang/slang.h>

#include <newt.h>

static void collect_bytes(int fd, char *buffer, int total)

{

    int count;

    newtComponent title, form, scale;

    char message[1024];

    newtGrid box;

    box = newtCreateGrid(1, 3);

    snprintf(message, sizeof message,

             "To generate %u random bits from the "

             "kernel random number generator, some "

             "keyboard or mouse input may be necessary at the "

             "console for this host.  Please try entering "

             "some random text or moving the mouse, if "

             "running this program locally.", total * 8);

    title = newtTextboxReflowed(1, 1, message, 60, 10, 0, 0);

    newtGridSetField(box, 0, 0, NEWT_GRID_COMPONENT, title,

		     0, 0, 0, 0, 0, 0);

    /* The progress bar */

    scale = newtScale(0, 0, 30, total);

    newtScaleSet(scale, 0);

    newtGridSetField(box, 0, 1, NEWT_GRID_COMPONENT, scale,

		     0, 1, 0, 0, 0, 0);

    form = newtForm(NULL, NULL, 0);

    newtGridAddComponentsToForm(box, form, 1);

    newtGridWrappedWindow(box, "Collecting random data");

    newtDrawForm(form);

    count = 0;

    do {

        ssize_t rv;

        newtScaleSet(scale, count);

        newtRefresh();

        rv = read(fd, buffer + count, total - count);

        if (rv == -1 && errno == EINTR) continue;

        else if (rv < 0) {

            newtWinMessage("Error", "Exit", 

                           "Error reading from /dev/random");

            newtFinished();

            exit(1);

        }

	SLang_flush_input();

        count += rv;

    } while (count < total);

    newtFormDestroy(form);

}

int main(int argc, char **argv)

{

    const char *output;

    int bits, bytes, fd, rfd;

    char *buffer;

    if (argc < 3) {

        fprintf(stderr, "Usage: keyrand <number-of-bits> <output-file>\n");

        exit(1);

    }

    bits = atoi(argv[1]);

    output = argv[2];

    fd = open(output, O_APPEND|O_WRONLY);

    rfd = open("/dev/random", O_RDONLY);

    newtInit();

    newtCls();

    newtDrawRootText(0, 0, 

                     "Red Hat Keypair Generation (c) 2006 Red Hat, Inc.");

    if (fd < 0) {

        newtWinMessage("Error", "Exit", "Could not open output file");

        newtFinished();

        exit(1);

    }

    else if (rfd < 0) {

        newtWinMessage("Error", "Exit", "Could not open /dev/random");

        newtFinished();

        exit(1);

    }

    else if (bits < 8 || bits > 800 * 1024) {

        newtWinMessage("Error", "Exit", "More than 8 bits must be requested");

        newtFinished();

        exit(1);

    }

    bytes = bits / 8;

    buffer = malloc(bytes);

    sleep(1);

    collect_bytes(rfd, buffer, bytes);

    if (write(fd, buffer, bytes) != bytes || close(fd)) {

        newtWinMessage("Error", "Exit", "Error writing to random file");

        newtFinished();

        exit(1);

    }

    newtFinished();

    newtRefresh();

    sleep(1);

    newtPopWindow();

    SLang_flush_input();

    newtClearKeyBuffer();

    return 0;

}