/*      $NetBSD: bootpref.c,v 1.6 2009/03/17 00:18:40 he Exp $  */
/*-
 * Copyright (c) 1998 The NetBSD Foundation, Inc.
 * All rights reserved.
 *
 * This code is derived from software contributed to The NetBSD Foundation
 * by Julian Coleman.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */
#include <sys/types.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <fcntl.h>
#include <errno.h>
#include <err.h>
#include <sys/mman.h>
#include "bootpref.h"

static void     usage(void);
static int      openNVRAM(void);
static void     closeNVRAM(int);
static u_char   readNVRAM(int, int);
static void     writeNVRAM(int, int, u_char);
static void     getNVpref(int, u_char[]);
static void     setNVpref(int, u_char[], int, int);
static void     showOS(u_char);
static void     showLang(u_char);
static void     showKbdLang(u_char);
static void     showDateFmt(u_char);
static void     showDateSep(u_char);
static void     showVideo2(u_char);
static void     showVideo1(u_char, u_char);
static int      checkOS(u_char *, char *);
static int      checkLang(u_char *, char *);
static int      checkKbdLang(u_char *, char *);
static int      checkInt(u_char *, char *, int, int);
static int      checkDateFmt(u_char *, char *);
static void     checkDateSep(u_char *, char *);
static int      checkColours(u_char *, char *);

#define SET_OS          0x001
#define SET_LANG        0x002
#define SET_KBDLANG     0x004
#define SET_HOSTID      0x008
#define SET_DATIME      0x010
#define SET_DATESEP     0x020
#define SET_BOOTDLY     0x040
#define SET_VID1        0x080
#define SET_VID2        0x100

#define ARRAY_OS        0
#define ARRAY_LANG      1
#define ARRAY_KBDLANG   2
#define ARRAY_HOSTID    3
#define ARRAY_DATIME    4
#define ARRAY_DATESEP   5
#define ARRAY_BOOTDLY   6
#define ARRAY_VID1      7
#define ARRAY_VID2      8

static const char       nvrdev[] = PATH_NVRAM;

int
main (int argc, char *argv[])
{
        int     c, set = 0, verbose = 0;
        int     fd;
        u_char  bootpref[] = {0, 0, 0, 0, 0, 0, 0, 0, 0};
        u_char  check_hour = 0, check_video1 = 0, check_video2 = 0;

        fd = openNVRAM ();
        bootpref[ARRAY_VID2] = readNVRAM (fd, NVRAM_VID2);
        bootpref[ARRAY_VID1] = readNVRAM (fd, NVRAM_VID1);
        /* parse options */
        while ((c = getopt (argc, argv, "Vb:d:k:l:s:f:12e:c:nptv48oOxXiI")) != -1) {
                switch (c) {
                case 'V':
                        verbose = 1;
                        break;
                case 'b':
                        if (checkOS (&bootpref[ARRAY_OS], optarg))
                                set |= SET_OS;
                        else
                                usage ();
                        break;
                case 'd':
                        if (checkInt (&bootpref[ARRAY_BOOTDLY], optarg,
                           0, 255))
                                set |= SET_BOOTDLY;
                        else
                                usage ();
                        break;
                case 'k':
                        if (checkKbdLang (&bootpref[ARRAY_KBDLANG], optarg))
                                set |= SET_KBDLANG;
                        else
                                usage ();
                        break;
                case 'l':
                        if (checkLang (&bootpref[ARRAY_LANG], optarg))
                                set |= SET_LANG;
                        else
                                usage ();
                        break;
                case 's':
                        if (checkInt (&bootpref[ARRAY_HOSTID], optarg,
                            0, 7))
                                set |= SET_HOSTID;
                        else
                                usage ();
                        break;
                case 'f':
                        if (checkDateFmt (&bootpref[ARRAY_DATIME], optarg))
                                set |= SET_DATIME;
                        else
                                usage ();
                        break;
                case '1':
                        if (check_hour & DATIME_24H) {
                                usage();
                        } else {
                                bootpref[ARRAY_DATIME] &= ~DATIME_24H;
                                set |= SET_DATIME;
                                check_hour |= DATIME_24H;
                        }
                        break;
                case '2':
                        if (check_hour & DATIME_24H) {
                                usage();
                        } else {
                                bootpref[ARRAY_DATIME] |= DATIME_24H;
                                set |= SET_DATIME;
                                check_hour |= DATIME_24H;
                        }
                        break;
                case 'e':
                        checkDateSep (&bootpref[ARRAY_DATESEP], optarg);
                        set |= SET_DATESEP;
                        break;
                case 'c':
                        if (checkColours (&bootpref[ARRAY_VID2], optarg))
                                set |= SET_VID2;
                        else
                                usage ();
                        break;
                case 'n':
                        if (check_video2 & VID2_PAL) {
                                usage();
                        } else {
                                bootpref[ARRAY_VID2] &= ~VID2_PAL;
                                set |= SET_VID2;
                                check_video2 |= VID2_PAL;
                        }
                        break;
                case 'p':
                        if (check_video2 & VID2_PAL) {
                                usage();
                        } else {
                                bootpref[ARRAY_VID2] |= VID2_PAL;
                                set |= SET_VID2;
                                check_video2 |= VID2_PAL;
                        }
                        break;
                case 't':
                        if (check_video2 & VID2_VGA) {
                                usage();
                        } else {
                                bootpref[ARRAY_VID2] &= ~VID2_VGA;
                                set |= SET_VID2;
                                check_video2 |= VID2_VGA;
                        }
                        break;
                case 'v':
                        if (check_video2 & VID2_VGA) {
                                usage();
                        } else {
                                bootpref[ARRAY_VID2] |= VID2_VGA;
                                set |= SET_VID2;
                                check_video2 |= VID2_VGA;
                        }
                        break;
                case '4':
                        if (check_video2 & VID2_80CLM) {
                                usage();
                        } else {
                                bootpref[ARRAY_VID2] &= ~VID2_80CLM;
                                set |= SET_VID2;
                                check_video2 |= VID2_80CLM;
                        }
                        break;
                case '8':
                        if (check_video2 & VID2_80CLM) {
                                usage();
                        } else {
                                bootpref[ARRAY_VID2] |= VID2_80CLM;
                                set |= SET_VID2;
                                check_video2 |= VID2_80CLM;
                        }
                        break;
                case 'o':
                        if (check_video2 & VID2_OVERSCAN) {
                                usage();
                        } else {
                                bootpref[ARRAY_VID2] |= VID2_OVERSCAN;
                                set |= SET_VID2;
                                check_video2 |= VID2_OVERSCAN;
                        }
                        break;
                case 'O':
                        if (check_video2 & VID2_OVERSCAN) {
                                usage();
                        } else {
                                bootpref[ARRAY_VID2] &= ~VID2_OVERSCAN;
                                set |= SET_VID2;
                                check_video2 |= VID2_OVERSCAN;
                        }
                        break;
                case 'x':
                        if (check_video2 & VID2_COMPAT) {
                                usage();
                        } else {
                                bootpref[ARRAY_VID2] |= VID2_COMPAT;
                                set |= SET_VID2;
                                check_video2 |= VID2_COMPAT;
                        }
                        break;
                case 'X':
                        if (check_video2 & VID2_COMPAT) {
                                usage();
                        } else {
                                bootpref[ARRAY_VID2] &= ~VID2_COMPAT;
                                set |= SET_VID2;
                                check_video2 |= VID2_COMPAT;
                        }
                        break;
                case 'i':
                        if (check_video1 & VID1_INTERLACE) {
                                usage();
                        } else {
                                bootpref[ARRAY_VID1] |= VID1_INTERLACE;
                                set |= SET_VID1;
                                check_video1 |= VID1_INTERLACE;
                        }
                        break;
                case 'I':
                        if (check_video1 & VID1_INTERLACE) {
                                usage();
                        } else {
                                bootpref[ARRAY_VID1] &= ~VID1_INTERLACE;
                                set |= SET_VID1;
                                check_video1 |= VID1_INTERLACE;
                        }
                        break;
                default:
                        usage ();
                }
        }
        if (optind != argc) {
                usage ();
        }
        if (set) {
                setNVpref (fd, bootpref, set, verbose);
        } else {
                getNVpref (fd, bootpref);
        }
        closeNVRAM (fd);
        return (EXIT_SUCCESS);
}

static void
usage (void)
{
        fprintf (stderr,
                "usage: bootpref [-V] [-b os] [-d delay] [-k kbd] [-l lang] "
                "[-s id]\n"
                "\t[-f fmt] [-1] [-2] [-e sep]\n"
                "\t[-c colours] [-n] [-p] [-t] [-v] [-4] [-8]\n"
                "\t[-o] [-O] [-x] [-X] [-i] [-I]\n");
        exit (EXIT_FAILURE);
}

static int
openNVRAM ()
{
        int fd;

        if ((fd = open (nvrdev, O_RDWR)) < 0) {
                err (EXIT_FAILURE, "%s", nvrdev);
        }
        return (fd);
}

static void
closeNVRAM (int fd)
{
        if (close (fd) < 0) {
                err (EXIT_FAILURE, "%s", nvrdev);
        }
}

static u_char
readNVRAM (int fd, int pos)
{
        u_char val;

        if (lseek(fd, (off_t)pos, SEEK_SET) != pos) {
                err(EXIT_FAILURE, "%s", nvrdev);
        }
        if (read (fd, &val, (size_t)1) != 1) {
                err(EXIT_FAILURE, "%s", nvrdev);
        }
        return (val);
}

static void
writeNVRAM (int fd, int pos, u_char val)
{
        if (lseek(fd, (off_t)pos, SEEK_SET) != pos) {
                err(EXIT_FAILURE, "%s", nvrdev);
        }
        if (write (fd, &val, (size_t)1) != 1) {
                err(EXIT_FAILURE, "%s", nvrdev);
        }
}

static void
getNVpref (int fd, u_char bootpref[])
{
        /* Boot OS */
        printf ("Boot OS is ");
        showOS (readNVRAM (fd, NVRAM_BOOTPREF));
        /* Boot Delay */
        printf ("Boot delay is %d seconds\n", readNVRAM (fd, NVRAM_BOOTDLY));
        /* TOS Language */
        printf ("Language is ");
        showLang (readNVRAM (fd, NVRAM_LANG));
        /* Keyboard Language */
        printf ("Keyboard is ");
        showKbdLang (readNVRAM (fd, NVRAM_KBDLANG));
        /* SCSI Host ID */
        printf ("SCSI host ID is ");
        if (readNVRAM (fd, NVRAM_HOSTID) & HOSTID_VALID) {
                printf ("%d\n", readNVRAM (fd, NVRAM_HOSTID) ^ HOSTID_VALID);
        } else {
                printf ("invalid");
        }
        /* Date format/separator */
        printf ("Date format is ");
        showDateFmt (readNVRAM (fd, NVRAM_DATIME));
        printf ("Date separator is ");
        showDateSep (readNVRAM (fd, NVRAM_DATESEP));
        /* Video */
        printf ("Video is (0x%02x, 0x%02x) :\n", readNVRAM (fd, NVRAM_VID2),
            readNVRAM (fd, NVRAM_VID1));
        showVideo2 (readNVRAM (fd, NVRAM_VID2));
        showVideo1 (readNVRAM (fd, NVRAM_VID1), readNVRAM (fd, NVRAM_VID2));
}

static void
setNVpref (int fd, u_char bootpref[], int set, int verbose)
{
        /* Boot OS */
        if (set & SET_OS) {
                writeNVRAM (fd, NVRAM_BOOTPREF, bootpref[ARRAY_OS]);
                if (verbose) {
                        printf ("Boot OS set to ");
                        showOS (readNVRAM (fd, NVRAM_BOOTPREF));
                }
        }
        /* Boot Delay */
        if (set & SET_BOOTDLY) {
                writeNVRAM (fd, NVRAM_BOOTDLY, bootpref[ARRAY_BOOTDLY]);
                if (verbose) {
                        printf ("Boot delay set to %d seconds\n", readNVRAM (fd,
                            NVRAM_BOOTDLY));
                }
        }
        /* TOS Language */
        if (set & SET_LANG) {
                writeNVRAM (fd, NVRAM_LANG, bootpref[ARRAY_LANG]);
                if (verbose) {
                        printf ("Language set to ");
                        showLang (readNVRAM (fd, NVRAM_LANG));
                }
        }
        /* Keyboard Language */
        if (set & SET_KBDLANG) {
                writeNVRAM (fd, NVRAM_KBDLANG, bootpref[ARRAY_KBDLANG]);
                if (verbose) {
                        printf ("Keyboard set to ");
                        showKbdLang (readNVRAM (fd, NVRAM_KBDLANG));
                }
        }
        /* SCSI Host ID */
        if (set & SET_HOSTID) {
                writeNVRAM (fd, NVRAM_HOSTID, bootpref[ARRAY_HOSTID] |
                    HOSTID_VALID);
                if (verbose) {
                        printf ("SCSI host ID set to ");
                        printf ("%d\n", readNVRAM (fd, NVRAM_HOSTID) ^
                                HOSTID_VALID);
                }
        }
        /* Date format/separator */
        if (set & SET_DATIME) {
                writeNVRAM (fd, NVRAM_DATIME, bootpref[ARRAY_DATIME]);
                if (verbose) {
                        printf ("Date format set to ");
                        showDateFmt (readNVRAM (fd, NVRAM_DATIME));
                        printf ("\n");
                }
        }
        if (set & SET_DATESEP) {
                writeNVRAM (fd, NVRAM_DATESEP, bootpref[ARRAY_DATESEP]);
                if (verbose) {
                        printf ("Date separator set to ");
                        showDateSep (readNVRAM (fd, NVRAM_DATESEP));
                }
        }
        /* Video */
        if ((set & SET_VID2) || (set & SET_VID1)) {
                if (set & SET_VID2) {
                        writeNVRAM (fd, NVRAM_VID2, bootpref[ARRAY_VID2]);
                }
                if (set & SET_VID1) {
                        writeNVRAM (fd, NVRAM_VID1, bootpref[ARRAY_VID1]);
                }
                if (verbose) {
                        printf ("Video set to (0x%02x, 0x%02x) :\n",
                            readNVRAM (fd, NVRAM_VID2),
                            readNVRAM (fd, NVRAM_VID1));
                        showVideo2 (readNVRAM (fd, NVRAM_VID2));
                        showVideo1 (readNVRAM (fd, NVRAM_VID1),
                            readNVRAM (fd, NVRAM_VID2));
                }
        }
}

static void
showOS (u_char bootos)
{
        switch (bootos) {
        case BOOTPREF_NETBSD:
                printf ("NetBSD");
                break;
        case BOOTPREF_TOS:
                printf ("TOS");
                break;
        case BOOTPREF_MAGIC:
                printf ("MAGIC");
                break;
        case BOOTPREF_LINUX:
                printf ("Linux");
                break;
        case BOOTPREF_SYSV:
                printf ("System V");
                break;
        case BOOTPREF_NONE:
                printf ("none");
                break;
        default:
                printf ("unknown");
                break;
        }
        printf (" (0x%x).\n", bootos);
}

static void
showLang (u_char lang)
{
        switch (lang) {
        case LANG_USA:
        case LANG_GB:
                printf ("English");
                break;
        case LANG_D:
                printf ("German");
                break;
        case LANG_FR:
                printf ("French");
                break;
        case LANG_ESP:
                printf ("Spanish");
                break;
        case LANG_I:
                printf ("Italian");
                break;
        default:
                printf ("unknown");
                break;
        }
        printf (" (0x%x).\n", lang);
}

static void
showKbdLang (u_char lang)
{
        switch (lang) {
        case KBDLANG_USA:
                printf ("American");
                break;
        case KBDLANG_D:
                printf ("German");
                break;
        case KBDLANG_FR:
                printf ("French");
                break;
        case KBDLANG_GB:
                printf ("British");
                break;
        case KBDLANG_ESP:
                printf ("Spanish");
                break;
        case KBDLANG_I:
                printf ("Italian");
                break;
        case KBDLANG_CHF:
                printf ("Swiss (French)");
                break;
        case KBDLANG_CHD:
                printf ("Swiss (German)");
                break;
        default:
                printf ("unknown");
                break;
        }
        printf (" (0x%x).\n", lang);
}

static void
showDateFmt (u_char fmt)
{
        if (fmt & DATIME_24H) {
                printf ("24 hour clock, ");
        } else {
                printf ("12 hour clock, ");
        }
        switch (fmt & ~DATIME_24H) {
        case DATIME_MMDDYY:
                printf ("MMDDYY");
                break;
        case DATIME_DDMMYY:
                printf ("DDMMYY");
                break;
        case DATIME_YYMMDD:
                printf ("YYMMDD");
                break;
        case DATIME_YYDDMM:
                printf ("YYDDMM");
                break;
        default:
                printf ("unknown");
                break;
        }
        printf (" (0x%02x)\n", fmt);
}

static void
showDateSep (u_char sep)
{
        if (sep) {
                if (sep >= 0x20) {
                        printf ("\"%c\" ", sep);
                }
        } else {
                printf ("\"/\" ");
        }
        printf ("(0x%02x)\n", sep);
}

static void
showVideo2 (u_char vid2)
{
        u_char colours;

        colours = vid2 & 0x07;
        printf ("\t");
        switch (colours) {
        case VID2_2COL:
                printf ("2");
                break;
        case VID2_4COL:
                printf ("4");
                break;
        case VID2_16COL:
                printf ("16");
                break;
        case VID2_256COL:
                printf ("256");
                break;
        case VID2_65535COL:
                printf ("65535");
                break;
        }
        printf (" colours, ");
        if (vid2 & VID2_80CLM) {
                printf ("80");
        } else {
                printf ("40");
        }
        printf (" column, ");
        if (vid2 & VID2_VGA) {
                printf ("VGA");
        } else {
                printf ("TV");
        }
        printf (", ");
        if (vid2 & VID2_PAL) {
                printf ("PAL\n");
        } else {
                printf ("NTSC\n");
        }
        printf ("\tOverscan ");
        if (vid2 & VID2_OVERSCAN) {
                printf ("on\n");
        } else {
                printf ("off\n");
        }
        printf ("\tST compatibility ");
        if (vid2 & VID2_COMPAT) {
                printf ("on\n");
        } else {
                printf ("off\n");
        }
}

static void
showVideo1 (u_char vid1, u_char vid2)
{
        if (vid2 & VID2_VGA) {
                printf ("\tDouble line ");
                if (vid1 & VID1_INTERLACE) {
                        printf ("on");
                } else {
                        printf ("off");
                }
        } else {
                printf ("\tInterlace ");
                if (vid1 & VID1_INTERLACE) {
                        printf ("on");
                } else {
                        printf ("off");
                }
        }
        printf ("\n");
}

static int
checkOS (u_char *val, char *str)
{
        if (!strncasecmp (str, "ne", 2)) {
                *val = BOOTPREF_NETBSD;
                return (1);
        }
        if (!strncasecmp (str, "t", 1)) {
                *val = BOOTPREF_TOS;
                return (1);
        }
        if (!strncasecmp (str, "m", 1)) {
                *val = BOOTPREF_MAGIC;
                return (1);
        }
        if (!strncasecmp (str, "l", 1)) {
                *val = BOOTPREF_LINUX;
                return (1);
        }
        if (!strncasecmp (str, "s", 1)) {
                *val = BOOTPREF_SYSV;
                return (1);
        }
        if (!strncasecmp (str, "no", 2)) {
                *val = BOOTPREF_NONE;
                return (1);
        }
        return (0);
}

static int
checkLang (u_char *val, char *str)
{
        if (!strncasecmp (str, "e", 1)) {
                *val = LANG_GB;
                return (1);
        }
        if (!strncasecmp (str, "g", 1)) {
                *val = LANG_D;
                return (1);
        }
        if (!strncasecmp (str, "f", 1)) {
                *val = LANG_FR;
                return (1);
        }
        if (!strncasecmp (str, "s", 1)) {
                *val = LANG_ESP;
                return (1);
        }
        if (!strncasecmp (str, "i", 1)) {
                *val = LANG_I;
                return (1);
        }
        return (0);
}

static int
checkKbdLang (u_char *val, char *str)
{
        if (!strncasecmp (str, "a", 1)) {
                *val = KBDLANG_USA;
                return (1);
        }
        if (!strncasecmp (str, "g", 1)) {
                *val = KBDLANG_D;
                return (1);
        }
        if (!strncasecmp (str, "f", 1)) {
                *val = KBDLANG_FR;
                return (1);
        }
        if (!strncasecmp (str, "b", 1)) {
                *val = KBDLANG_GB;
                return (1);
        }
        if (!strncasecmp (str, "sp", 2)) {
                *val = KBDLANG_ESP;
                return (1);
        }
        if (!strncasecmp (str, "i", 1)) {
                *val = KBDLANG_I;
                return (1);
        }
        if (!strncasecmp (str, "swiss f", 7) || !strncasecmp (str, "sw f", 4)) {
                *val = KBDLANG_CHF;
                return (1);
        }
        if (!strncasecmp (str, "swiss g", 7) || !strncasecmp (str, "sw g", 4)) {
                *val = KBDLANG_CHD;
                return (1);
        }
        return (0);
}

static int
checkInt (u_char *val, char *str, int min, int max)
{
        int num;
        if (1 == sscanf (str, "%d", &num) && num >= min && num <= max) {
                *val = num;
                return (1);
        }
        return (0);
}

static int
checkDateFmt (u_char *val, char *str)
{
        if (!strncasecmp (str, "m", 1)) {
                *val |= DATIME_MMDDYY;
                return (1);
        }
        if (!strncasecmp (str, "d", 1)) {
                *val |= DATIME_DDMMYY;
                return (1);
        }
        if (!strncasecmp (str, "yym", 3)) {
                *val |= DATIME_YYMMDD;
                return (1);
        }
        if (!strncasecmp (str, "yyd", 3)) {
                *val |= DATIME_YYDDMM;
                return (1);
        }
        return (0);
}

static void
checkDateSep (u_char *val, char *str)
{
        if (str[0] == '/') {
                *val = 0;
        } else {
                *val = str[0];
        }
}
        
static int
checkColours (u_char *val, char *str)
{
        *val &= ~0x07;
        if (!strncasecmp (str, "6", 1)) {
                *val |= VID2_65535COL;
                return (1);
        }
        if (!strncasecmp (str, "25", 2)) {
                *val |= VID2_256COL;
                return (1);
        }
        if (!strncasecmp (str, "1", 1)) {
                *val |= VID2_16COL;
                return (1);
        }
        if (!strncasecmp (str, "4", 1)) {
                *val |= VID2_4COL;
                return (1);
        }
        if (!strncasecmp (str, "2", 1)) {
                *val |= VID2_2COL;
                return (1);
        }
        return (0);
}