/*      $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);
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.