initial import of sc2010 scripts ..HEADmaster

16 files changed, 2852 insertions, 0 deletions

diff --git a/contrib/syslinux-4.02/utils/Makefile b/contrib/syslinux-4.02/utils/Makefile
new file mode 100644
index 0000000..455eb82
--- /dev/null
+++ b/contrib/syslinux-4.02/utils/Makefile
@@ -0,0 +1,72 @@
+## -----------------------------------------------------------------------
+##
+##   Copyright 1998-2008 H. Peter Anvin - All Rights Reserved
+##
+##   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, Inc., 53 Temple Place Ste 330,
+##   Boston MA 02111-1307, USA; either version 2 of the License, or
+##   (at your option) any later version; incorporated herein by reference.
+##
+## -----------------------------------------------------------------------
+
+#
+# SYSLINUX utilities
+#
+
+topdir = ..
+include $(topdir)/MCONFIG
+
+CFLAGS   = $(GCCWARN) -Os -fomit-frame-pointer -D_FILE_OFFSET_BITS=64
+LDFLAGS  = -O2 -s
+
+TARGETS	 = mkdiskimage isohybrid gethostip memdiskfind
+TARGETS += isohybrid.pl  # about to be obsoleted
+ASIS     = keytab-lilo lss16toppm md5pass ppmtolss16 sha1pass syslinux2ansi \
+	   pxelinux-options
+
+ISOHDPFX = ../mbr/isohdpfx.bin ../mbr/isohdpfx_f.bin ../mbr/isohdpfx_c.bin \
+	   ../mbr/isohdppx.bin ../mbr/isohdppx_f.bin ../mbr/isohdppx_c.bin
+
+all: $(TARGETS)
+
+%.o: %.c
+	$(CC) $(UMAKEDEPS) $(CFLAGS) -c -o $@ $<
+
+mkdiskimage: mkdiskimage.in ../mbr/mbr.bin bin2hex.pl
+	$(PERL) bin2hex.pl < ../mbr/mbr.bin | cat mkdiskimage.in - > $@
+	chmod a+x $@
+
+# Works on anything with a Perl interpreter...
+isohybrid.pl: isohybrid.in $(ISOHDPFX) bin2hex.pl
+	cp -f isohybrid.in $@
+	for f in $(ISOHDPFX) ; do $(PERL) bin2hex.pl < $$f >> $@ ; done
+	chmod a+x $@
+
+isohdpfx.c: $(ISOHDPFX) isohdpfxarray.pl
+	$(PERL) isohdpfxarray.pl $(ISOHDPFX) > $@
+
+isohybrid: isohybrid.o isohdpfx.o
+	$(CC) $(LDFLAGS) -o $@ $^
+
+gethostip: gethostip.o
+	$(CC) $(LDFLAGS) -o $@ $^
+
+memdiskfind: memdiskfind.o
+	$(CC) $(LDFLAGS) -o $@ $^
+
+tidy dist:
+	rm -f *.o .*.d isohdpfx.c
+
+clean: tidy
+	rm -f $(TARGETS)
+
+spotless: clean
+
+installer: all
+
+install: installer
+	mkdir -m 755 -p $(INSTALLROOT)$(BINDIR)
+	install -m 755 $(TARGETS) $(ASIS) $(INSTALLROOT)$(BINDIR)
+
+-include .*.d
diff --git a/contrib/syslinux-4.02/utils/bin2hex.pl b/contrib/syslinux-4.02/utils/bin2hex.pl
new file mode 100644
index 0000000..778b699
--- /dev/null
+++ b/contrib/syslinux-4.02/utils/bin2hex.pl
@@ -0,0 +1,48 @@
+#!/usr/bin/perl
+## -----------------------------------------------------------------------
+##
+##   Copyright 2003-2008 H. Peter Anvin - All Rights Reserved
+##
+##   Permission is hereby granted, free of charge, to any person
+##   obtaining a copy of this software and associated documentation
+##   files (the "Software"), to deal in the Software without
+##   restriction, including without limitation the rights to use,
+##   copy, modify, merge, publish, distribute, sublicense, and/or
+##   sell copies of the Software, and to permit persons to whom
+##   the Software is furnished to do so, subject to the following
+##   conditions:
+##
+##   The above copyright notice and this permission notice shall
+##   be included in all copies or substantial portions of the Software.
+##
+##   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+##   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+##   OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+##   NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+##   HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+##   WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+##   FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+##   OTHER DEALINGS IN THE SOFTWARE.
+##
+## -----------------------------------------------------------------------
+
+eval { use bytes; };
+eval { binmode STDIN; };
+
+$len = 0;
+while ( read(STDIN,$ch,1) ) {
+    $cc = ord($ch);
+    $s = sprintf("%x", $cc);
+    print $s;
+    $len += length($s);
+    if ( $len > 72 ) {
+	print "\n";
+	$len = 0;
+    } else {
+	print " ";
+	$len++;
+    }
+}
+print "\n" if ( $len );
+print "*\n";
+exit 0;
diff --git a/contrib/syslinux-4.02/utils/gethostip.c b/contrib/syslinux-4.02/utils/gethostip.c
new file mode 100644
index 0000000..f3f8757
--- /dev/null
+++ b/contrib/syslinux-4.02/utils/gethostip.c
@@ -0,0 +1,131 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 2001-2008 H. Peter Anvin - All Rights Reserved
+ *
+ *   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, Inc., 53 Temple Place Ste 330,
+ *   Boston MA 02111-1307, USA; either version 2 of the License, or
+ *   (at your option) any later version; incorporated herein by reference.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * gethostip.c
+ *
+ * Small program to use gethostbyname() to print out a hostname in
+ * hex and/or dotted-quad notation
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <netdb.h>
+#include <sys/socket.h>
+#include <unistd.h>
+#include <sysexits.h>
+#define _GNU_SOURCE		/* For getopt_long */
+#include <getopt.h>
+
+const struct option options[] = {
+    {"hexadecimal", 0, NULL, 'x'},
+    {"decimal", 0, NULL, 'd'},
+    {"dotted-quad", 0, NULL, 'd'},
+    {"full-output", 0, NULL, 'f'},
+    {"name", 0, NULL, 'n'},
+    {"help", 0, NULL, 'h'},
+    {NULL, 0, NULL, 0}
+};
+
+const char *program;
+
+void usage(int exit_code)
+{
+    fprintf(stderr, "Usage: %s [-dxnf] hostname/ip...\n", program);
+    exit(exit_code);
+}
+
+int main(int argc, char *argv[])
+{
+    int opt;
+    int output = 0;
+    int i;
+    char *sep;
+    int err = 0;
+
+    struct hostent *host;
+
+    program = argv[0];
+
+    while ((opt = getopt_long(argc, argv, "dxfnh", options, NULL)) != -1) {
+	switch (opt) {
+	case 'd':
+	    output |= 2;	/* Decimal output */
+	    break;
+	case 'x':
+	    output |= 4;	/* Hexadecimal output */
+	    break;
+	case 'n':
+	    output |= 1;	/* Canonical name output */
+	    break;
+	case 'f':
+	    output = 7;		/* Full output */
+	    break;
+	case 'h':
+	    usage(0);
+	    break;
+	default:
+	    usage(EX_USAGE);
+	    break;
+	}
+    }
+
+    if (optind == argc)
+	usage(EX_USAGE);
+
+    if (output == 0)
+	output = 7;		/* Default output */
+
+    for (i = optind; i < argc; i++) {
+	sep = "";
+	host = gethostbyname(argv[i]);
+	if (!host) {
+	    herror(argv[i]);
+	    err = 1;
+	    continue;
+	}
+
+	if (host->h_addrtype != AF_INET || host->h_length != 4) {
+	    fprintf(stderr, "%s: No IPv4 address associated with name\n",
+		    argv[i]);
+	    err = 1;
+	    continue;
+	}
+
+	if (output & 1) {
+	    printf("%s%s", sep, host->h_name);
+	    sep = " ";
+	}
+
+	if (output & 2) {
+	    printf("%s%u.%u.%u.%u", sep,
+		   ((unsigned char *)host->h_addr)[0],
+		   ((unsigned char *)host->h_addr)[1],
+		   ((unsigned char *)host->h_addr)[2],
+		   ((unsigned char *)host->h_addr)[3]);
+	    sep = " ";
+	}
+
+	if (output & 4) {
+	    printf("%s%02X%02X%02X%02X", sep,
+		   ((unsigned char *)host->h_addr)[0],
+		   ((unsigned char *)host->h_addr)[1],
+		   ((unsigned char *)host->h_addr)[2],
+		   ((unsigned char *)host->h_addr)[3]);
+	    sep = " ";
+	}
+
+	putchar('\n');
+    }
+
+    return err;
+}
diff --git a/contrib/syslinux-4.02/utils/isohdpfxarray.pl b/contrib/syslinux-4.02/utils/isohdpfxarray.pl
new file mode 100644
index 0000000..06c71bf
--- /dev/null
+++ b/contrib/syslinux-4.02/utils/isohdpfxarray.pl
@@ -0,0 +1,57 @@
+#!/usr/bin/perl
+## -----------------------------------------------------------------------
+##
+##   Copyright (C) 2010 P J P <pj.pandit@yahoo.co.in>
+##
+##   Permission is hereby granted, free of charge, to any person
+##   obtaining a copy of this software and associated documentation
+##   files (the "Software"), to deal in the Software without
+##   restriction, including without limitation the rights to use,
+##   copy, modify, merge, publish, distribute, sublicense, and/or
+##   sell copies of the Software, and to permit persons to whom
+##   the Software is furnished to do so, subject to the following
+##   conditions:
+##
+##   The above copyright notice and this permission notice shall
+##   be included in all copies or substantial portions of the Software.
+##
+##   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+##   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+##   OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+##   NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+##   HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+##   WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+##   FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+##   OTHER DEALINGS IN THE SOFTWARE.
+##
+## -----------------------------------------------------------------------
+
+use strict;
+use warnings;
+
+binmode STDIN;
+
+print "#include <inttypes.h>\n";
+print "#include \"isohybrid.h\"\n";
+print "\n";
+print "uint8_t isohdpfx[][MBRSIZE] =\n";
+print "{\n";
+
+foreach my $file (@ARGV) {
+    my $len = 0;
+    my $ch;
+
+    open(IN, '<', $file) or die "$0: $file: $!\n";
+    printf("    {\n");
+    while (read(IN, $ch, 1))
+    {
+	printf("\t/* 0x%03x */ ", $len) if (!($len % 8));
+	printf("0x%02x,", ord($ch));
+	$len++;
+    
+	print("\n") if (!($len % 8));
+    }
+    print "    },\n";
+    close(IN);
+}
+print "};\n";
diff --git a/contrib/syslinux-4.02/utils/isohybrid.c b/contrib/syslinux-4.02/utils/isohybrid.c
new file mode 100644
index 0000000..57c1015
--- /dev/null
+++ b/contrib/syslinux-4.02/utils/isohybrid.c
@@ -0,0 +1,561 @@
+/*
+ * isohybrid.c: Post process an ISO 9660 image generated with mkisofs or
+ * genisoimage to allow - hybrid booting - as a CD-ROM or as a hard
+ * disk.
+ *
+ * This is based on the original Perl script written by H. Peter Anvin. The
+ * rewrite in C is to avoid dependency on Perl on a system under installation.
+ *
+ * Copyright (C) 2010 P J P <pj.pandit@yahoo.co.in>
+ *
+ * isohybrid is a free software; you can redistribute it and/or modify it
+ * under the terms of GNU General Public License as published by Free Software
+ * Foundation; either version 2 of the license, or (at your option) any later
+ * version.
+ *
+ * isohybrid 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 isohybrid; if not, see: <http://www.gnu.org/licenses>.
+ *
+ */
+
+#include <err.h>
+#include <time.h>
+#include <ctype.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <alloca.h>
+#include <getopt.h>
+#include <signal.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/stat.h>
+#include <inttypes.h>
+
+#include "isohybrid.h"
+
+char *prog = NULL;
+extern int opterr, optind;
+
+uint8_t mode = 0;
+enum { VERBOSE = 1 };
+
+/* user options */
+uint16_t head = 64;             /* 1 <= head <= 256 */
+uint8_t sector = 32;            /* 1 <= sector <= 63  */
+
+uint8_t entry = 1;              /* partition number: 1 <= entry <= 4 */
+uint8_t offset = 0;             /* partition offset: 0 <= offset <= 64 */
+uint16_t type = 0x17;           /* partition type: 0 <= type <= 255 */
+uint32_t id = 0;                /* MBR: 0 <= id <= 0xFFFFFFFF(4294967296) */
+
+uint8_t hd0 = 0;                /* 0 <= hd0 <= 2 */
+uint8_t partok = 0;             /* 0 <= partok <= 1 */
+
+uint16_t ve[16];
+uint32_t catoffset = 0;
+uint32_t c = 0, cc = 0, cs = 0;
+
+/* boot catalogue parameters */
+uint32_t de_lba = 0;
+uint16_t de_seg = 0, de_count = 0, de_mbz2 = 0;
+uint8_t de_boot = 0, de_media = 0, de_sys = 0, de_mbz1 = 0;
+
+
+void
+usage(void)
+{
+    printf("Usage: %s [OPTIONS] <boot.iso>\n", prog);
+}
+
+
+void
+printh(void)
+{
+#define FMT "%-18s %s\n"
+
+    usage();
+
+    printf("\n");
+    printf("Options:\n");
+    printf(FMT, "   -h <X>", "Number of default geometry heads");
+    printf(FMT, "   -s <X>", "Number of default geometry sectors");
+    printf(FMT, "   -e --entry", "Specify partition entry number (1-4)");
+    printf(FMT, "   -o --offset", "Specify partition offset (default 0)");
+    printf(FMT, "   -t --type", "Specify partition type (default 0x17)");
+    printf(FMT, "   -i --id", "Specify MBR ID (default random)");
+
+    printf("\n");
+    printf(FMT, "   --forcehd0", "Assume we are loaded as disk ID 0");
+    printf(FMT, "   --ctrlhd0", "Assume disk ID 0 if the Ctrl key is pressed");
+    printf(FMT, "   --partok", "Allow booting from within a partition");
+
+    printf("\n");
+    printf(FMT, "   -? --help", "Display this help");
+    printf(FMT, "   -v --verbose", "Display verbose output");
+    printf(FMT, "   -V --version", "Display version information");
+
+    printf("\n");
+    printf("Report bugs to <pj.pandit@yahoo.co.in>\n");
+}
+
+
+int
+check_option(int argc, char *argv[])
+{
+    int n = 0, ind = 0;
+
+    const char optstr[] = ":h:s:e:o:t:i:fcp?vV";
+    struct option lopt[] = \
+    {
+        { "entry", required_argument, NULL, 'e' },
+        { "offset", required_argument, NULL, 'o' },
+        { "type", required_argument, NULL, 't' },
+        { "id", required_argument, NULL, 'i' },
+
+        { "forcehd0", no_argument, NULL, 'f' },
+        { "ctrlhd0", no_argument, NULL, 'c' },
+        { "partok", no_argument, NULL, 'p'},
+
+        { "help", no_argument, NULL, '?' },
+        { "verbose", no_argument, NULL, 'v' },
+        { "version", no_argument, NULL, 'V' },
+
+        { 0, 0, 0, 0 }
+    };
+
+    opterr = mode = 0;
+    while ((n = getopt_long_only(argc, argv, optstr, lopt, &ind)) != -1)
+    {
+        switch (n)
+        {
+        case 'h':
+            if (!sscanf(optarg, "%hu", &head) || head < 1 || head > 256)
+                errx(1, "invalid head: `%s', 1 <= head <= 256", optarg);
+            break;
+
+        case 's':
+            if (!sscanf(optarg, "%hhu", &sector) || sector < 1 || sector > 63)
+                errx(1, "invalid sector: `%s', 1 <= sector <= 63", optarg);
+            break;
+
+        case 'e':
+            if (!sscanf(optarg, "%hhu", &entry) || entry < 1 || entry > 4)
+                errx(1, "invalid entry: `%s', 1 <= entry <= 4", optarg);
+            break;
+
+        case 'o':
+            if (!sscanf(optarg, "%hhu", &offset) || offset > 64)
+                errx(1, "invalid offset: `%s', 0 <= offset <= 64", optarg);
+            break;
+
+        case 't':
+            if (!sscanf(optarg, "%hu", &type) || type > 255)
+                errx(1, "invalid type: `%s', 0 <= type <= 255", optarg);
+            break;
+
+        case 'i':
+            if (!sscanf(optarg, "%u", &id))
+                errx(1, "invalid id: `%s'", optarg);
+            break;
+
+        case 'f':
+            hd0 = 1;
+            break;
+
+        case 'c':
+            hd0 = 2;
+            break;
+
+        case 'p':
+            partok = 1;
+            break;
+
+        case 'v':
+            mode |= VERBOSE;
+            break;
+
+        case 'V':
+            printf("%s version %s\n", prog, VERSION);
+            exit(0);
+
+        case ':':
+            errx(1, "option `-%c' takes an argument", optopt);
+
+        default:
+        case '?':
+            if (optopt)
+                errx(1, "invalid option `-%c', see --help", optopt);
+
+            printh();
+            exit(0);
+        }
+    }
+
+    return optind;
+}
+
+
+uint16_t
+lendian_short(const uint16_t s)
+{
+    uint16_t r = 1;
+
+    if (*(uint8_t *)&r)
+        return s;
+
+    r = (s & 0x00FF) << 8 | (s & 0xFF00) >> 8;
+
+    return r;
+}
+
+
+uint32_t
+lendian_int(const uint32_t s)
+{
+    uint32_t r = 1;
+
+    if (*(uint8_t *)&r)
+        return s;
+
+    r = (s & 0x000000FF) << 24 | (s & 0xFF000000) >> 24
+        | (s & 0x0000FF00) << 8 | (s & 0x00FF0000) >> 8;
+
+    return r;
+}
+
+
+int
+check_banner(const uint8_t *buf)
+{
+    static const char banner[] = "\0CD001\1EL TORITO SPECIFICATION\0\0\0\0" \
+        "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0" \
+        "\0\0\0\0\0";
+
+    if (!buf || memcmp(buf, banner, sizeof(banner) - 1))
+        return 1;
+
+    buf += sizeof(banner) - 1;
+    memcpy(&catoffset, buf, sizeof(catoffset));
+
+    catoffset = lendian_int(catoffset);
+
+    return 0;
+}
+
+
+int
+check_catalogue(const uint8_t *buf)
+{
+    int i = 0;
+
+    for (i = 0, cs = 0; i < 16; i++)
+    {
+        ve[i] = 0;
+        memcpy(&ve[i], buf, sizeof(ve[i]));
+
+        ve[i] = lendian_short(ve[i]);
+
+        buf += 2;
+        cs += ve[i];
+
+        if (mode & VERBOSE)
+            printf("ve[%d]: %d, cs: %d\n", i, ve[i], cs);
+    }
+    if ((ve[0] != 0x0001) || (ve[15] != 0xAA55) || (cs & 0xFFFF))
+        return 1;
+
+    return 0;
+}
+
+
+int
+read_catalogue(const uint8_t *buf)
+{
+    memcpy(&de_boot, buf++, 1);
+    memcpy(&de_media, buf++, 1);
+
+    memcpy(&de_seg, buf, 2);
+    de_seg = lendian_short(de_seg);
+    buf += 2;
+
+    memcpy(&de_sys, buf++, 1);
+    memcpy(&de_mbz1, buf++, 1);
+
+    memcpy(&de_count, buf, 2);
+    de_count = lendian_short(de_count);
+    buf += 2;
+
+    memcpy(&de_lba, buf, 4);
+    de_lba = lendian_int(de_lba);
+    buf += 4;
+
+    memcpy(&de_mbz2, buf, 2);
+    de_mbz2 = lendian_short(de_mbz2);
+    buf += 2;
+
+    if (de_boot != 0x88 || de_media != 0
+        || (de_seg != 0 && de_seg != 0x7C0) || de_count != 4)
+        return 1;
+
+    return 0;
+}
+
+
+void
+display_catalogue(void)
+{
+    printf("de_boot: %hhu\n", de_boot);
+    printf("de_media: %hhu\n", de_media);
+    printf("de_seg: %hu\n", de_seg);
+    printf("de_sys: %hhu\n", de_sys);
+    printf("de_mbz1: %hhu\n", de_mbz1);
+    printf("de_count: %hu\n", de_count);
+    printf("de_lba: %u\n", de_lba);
+    printf("de_mbz2: %hu\n", de_mbz2);
+}
+
+
+int
+initialise_mbr(uint8_t *mbr)
+{
+    int i = 0;
+    uint32_t psize = 0, tmp = 0;
+    uint8_t ptype = 0, *rbm = mbr;
+    uint8_t bhead = 0, bsect = 0, bcyle = 0;
+    uint8_t ehead = 0, esect = 0, ecyle = 0;
+
+    extern unsigned char isohdpfx[][MBRSIZE];
+
+    memcpy(mbr, &isohdpfx[hd0 + 3 * partok], MBRSIZE);
+    mbr += MBRSIZE;                                 /* offset 432 */
+
+    tmp = lendian_int(de_lba * 4);
+    memcpy(mbr, &tmp, sizeof(tmp));
+    mbr += sizeof(tmp);                             /* offset 436 */
+
+    tmp = 0;
+    memcpy(mbr, &tmp, sizeof(tmp));
+    mbr += sizeof(tmp);                             /* offset 440 */
+
+    tmp = lendian_int(id);
+    memcpy(mbr, &tmp, sizeof(tmp));
+    mbr += sizeof(tmp);                             /* offset 444 */
+
+    mbr[0] = '\0';
+    mbr[1] = '\0';
+    mbr += 2;                                       /* offset 446 */
+
+    ptype = type;
+    psize = c * head * sector - offset;
+
+    bhead = (offset / sector) % head;
+    bsect = (offset % sector) + 1;
+    bcyle = offset / (head * sector);
+
+    bsect += (bcyle & 0x300) >> 2;
+    bcyle  &= 0xFF;
+
+    ehead = head - 1;
+    esect = sector + (((cc - 1) & 0x300) >> 2);
+    ecyle = (cc - 1) & 0xFF;
+
+    for (i = 1; i <= 4; i++)
+    {
+        memset(mbr, 0, 16);
+        if (i == entry)
+        {
+            mbr[0] = 0x80;
+            mbr[1] = bhead;
+            mbr[2] = bsect;
+            mbr[3] = bcyle;
+            mbr[4] = ptype;
+            mbr[5] = ehead;
+            mbr[6] = esect;
+            mbr[7] = ecyle;
+
+            tmp = lendian_int(offset);
+            memcpy(&mbr[8], &tmp, sizeof(tmp));
+
+            tmp = lendian_int(psize);
+            memcpy(&mbr[12], &tmp, sizeof(tmp));
+        }
+        mbr += 16;
+    }
+    mbr[0] = 0x55;
+    mbr[1] = 0xAA;
+    mbr += 2;
+
+    return mbr - rbm;
+}
+
+
+void
+display_mbr(const uint8_t *mbr, size_t len)
+{
+    unsigned char c = 0;
+    unsigned int i = 0, j = 0;
+
+    printf("sizeof(MBR): %zu bytes\n", len);
+    for (i = 0; i < len; i++)
+    {
+        if (!(i % 16))
+            printf("%04d ", i);
+
+        if (!(i % 8))
+            printf(" ");
+
+        c = mbr[i];
+        printf("%02x ", c);
+
+        if (!((i + 1) % 16))
+        {
+            printf(" |");
+            for (; j <= i; j++)
+                printf("%c", isprint(mbr[j]) ? mbr[j] : '.');
+            printf("|\n");
+        }
+    }
+}
+
+
+int
+main(int argc, char *argv[])
+{
+    int i = 0;
+    FILE *fp = NULL;
+    struct stat isostat;
+    uint8_t *buf = NULL, *bufz = NULL;
+    int cylsize = 0, frac = 0, padding = 0;
+
+    prog = strcpy(alloca(strlen(argv[0]) + 1), argv[0]);
+    i = check_option(argc, argv);
+    argc -= i;
+    argv += i;
+
+    if (!argc)
+    {
+        usage();
+        return 1;
+    }
+    srand(time(NULL) << (getppid() << getpid()));
+
+    if (!(fp = fopen(argv[0], "r+")))
+        err(1, "could not open file `%s'", argv[0]);
+    if (fseek(fp, 17 * 2048, SEEK_SET))
+        err(1, "%s: seek error - 1", argv[0]);
+
+    bufz = buf = calloc(BUFSIZE, sizeof(char));
+    if (fread(buf, sizeof(char), BUFSIZE, fp) != BUFSIZE)
+        err(1, "%s", argv[0]);
+
+    if (check_banner(buf))
+        errx(1, "%s: could not find boot record", argv[0]);
+
+    if (mode & VERBOSE)
+        printf("catalogue offset: %d\n", catoffset);
+
+    if (fseek(fp, catoffset * 2048, SEEK_SET))
+        err(1, "%s: seek error - 2", argv[0]);
+
+    buf = bufz;
+    memset(buf, 0, BUFSIZE);
+    if (fread(buf, sizeof(char), BUFSIZE, fp) != BUFSIZE)
+        err(1, "%s", argv[0]);
+
+    if (check_catalogue(buf))
+        errx(1, "%s: invalid boot catalogue", argv[0]);
+
+    buf += sizeof(ve);
+    if (read_catalogue(buf))
+        errx(1, "%s: unexpected boot catalogue parameters", argv[0]);
+
+    if (mode & VERBOSE)
+        display_catalogue();
+
+    if (fseek(fp, (de_lba * 2048 + 0x40), SEEK_SET))
+        err(1, "%s: seek error - 3", argv[0]);
+
+    buf = bufz;
+    memset(buf, 0, BUFSIZE);
+    if (fread(buf, sizeof(char), 4, fp) != 4)
+        err(1, "%s", argv[0]);
+
+    if (memcmp(buf, "\xFB\xC0\x78\x70", 4))
+        errx(1, "%s: boot loader does not have an isolinux.bin hybrid " \
+                 "signature. Note that isolinux-debug.bin does not support " \
+                 "hybrid booting", argv[0]);
+
+    if (stat(argv[0], &isostat))
+        err(1, "%s", argv[0]);
+
+    cylsize = head * sector * 512;
+    frac = isostat.st_size % cylsize;
+    padding = (frac > 0) ? cylsize - frac : 0;
+
+    if (mode & VERBOSE)
+        printf("imgsize: %zu, padding: %d\n", (size_t)isostat.st_size, padding);
+
+    cc = c = (isostat.st_size + padding) / cylsize;
+    if (c > 1024)
+    {
+        warnx("Warning: more than 1024 cylinders: %d", c);
+        warnx("Not all BIOSes will be able to boot this device");
+        cc = 1024;
+    }
+
+    if (!id)
+    {
+        if (fseek(fp, 440, SEEK_SET))
+            err(1, "%s: seek error - 4", argv[0]);
+
+	if (fread(&id, 1, 4, fp) != 4)
+	    err(1, "%s: read error", argv[0]);
+
+        id = lendian_int(id);
+        if (!id)
+        {
+            if (mode & VERBOSE)
+                printf("random ");
+            id = rand();
+        }
+    }
+    if (mode & VERBOSE)
+        printf("id: %u\n", id);
+
+    buf = bufz;
+    memset(buf, 0, BUFSIZE);
+    i = initialise_mbr(buf);
+
+    if (mode & VERBOSE)
+        display_mbr(buf, i);
+
+    if (fseek(fp, 0, SEEK_SET))
+        err(1, "%s: seek error - 5", argv[0]);
+
+    if (fwrite(buf, sizeof(char), i, fp) != (size_t)i)
+        err(1, "%s: write error - 1", argv[0]);
+
+    if (padding)
+    {
+        if (!(buf = realloc(buf, padding)))
+            err(1, "%s: could not re-size buffer", argv[0]);
+
+        if (fseek(fp, isostat.st_size, SEEK_SET))
+            err(1, "%s: seek error - 6", argv[0]);
+
+        memset(buf, 0, padding);
+        if (fwrite(buf, sizeof(char), padding, fp) != (size_t)padding)
+            err(1, "%s: write error - 2", argv[0]);
+    }
+
+    free(buf);
+    fclose(fp);
+
+    return 0;
+}
diff --git a/contrib/syslinux-4.02/utils/isohybrid.h b/contrib/syslinux-4.02/utils/isohybrid.h
new file mode 100644
index 0000000..826e90c
--- /dev/null
+++ b/contrib/syslinux-4.02/utils/isohybrid.h
@@ -0,0 +1,27 @@
+/*
+ * isohybrid.h: header file for isohybrid.c: Post process an ISO 9660 image
+ * generated with mkisofs or genisoimage to allow - hybrid booting - as a
+ * CD-ROM or as a hard disk.
+ *
+ * Copyright (C) 2010 Geert Stappers <stappers@stappers.nl>
+ *
+ * isohybrid is a free software; you can redistribute it and/or modify it
+ * under the terms of GNU General Public License as published by Free Software
+ * Foundation; either version 2 of the license, or (at your option) any later
+ * version.
+ *
+ * isohybrid 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 isohybrid; if not, see: <http://www.gnu.org/licenses>.
+ *
+ */
+
+#define VERSION     "0.11"
+#define BUFSIZE     2048
+#define MBRSIZE      432
+
+/* End of header file */
diff --git a/contrib/syslinux-4.02/utils/isohybrid.in b/contrib/syslinux-4.02/utils/isohybrid.in
new file mode 100644
index 0000000..a127784
--- /dev/null
+++ b/contrib/syslinux-4.02/utils/isohybrid.in
@@ -0,0 +1,258 @@
+#!/usr/bin/perl
+## -----------------------------------------------------------------------
+##
+##   Copyright 2002-2008 H. Peter Anvin - All Rights Reserved
+##   Copyright 2009 Intel Corporation; author: H. Peter Anvin
+##
+##   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, Inc., 53 Temple Place Ste 330,
+##   Boston MA 02111-1307, USA; either version 2 of the License, or
+##   (at your option) any later version; incorporated herein by reference.
+##
+## -----------------------------------------------------------------------
+
+#
+# Post-process an ISO 9660 image generated with mkisofs/genisoimage
+# to allow "hybrid booting" as a CD-ROM or as a hard disk.
+#
+
+use bytes;
+use Fcntl;
+
+# User-specifyable options
+%opt = (
+    # Fake geometry (zipdrive-style...)
+    'h'      => 64,
+    's'      => 32,
+    # Partition number
+    'entry'  => 1,
+    # Partition offset
+    'offset' => 0,
+    # Partition type
+    'type'   => 0x17,		# "Windows hidden IFS"
+    # MBR ID
+    'id'     => undef,
+);
+
+%valid_range = (
+    'h'      => [1, 256],
+    's'      => [1, 63],
+    'entry'  => [1, 4],
+    'offset' => [0, 64],
+    'type'   => [0, 255],
+    'id'     => [0, 0xffffffff],
+    'hd0'    => [0, 2],
+    'partok' => [0, 1],
+);
+
+# Boolean options just set other options
+%bool_opt = (
+    'nohd0'    => ['hd0', 0],
+    'forcehd0' => ['hd0', 1],
+    'ctrlhd0'  => ['hd0', 2],
+    'nopartok' => ['partok', 0],
+    'partok'   => ['partok', 1],
+);
+
+sub usage() {
+    print STDERR "Usage: $0 [options] filename.iso\n",
+    "Options:\n",
+    "  -h          Number of default geometry heads\n",
+    "  -s          Number of default geometry sectors\n",
+    "  -entry      Specify partition entry number (1-4)\n",
+    "  -offset     Specify partition offset (default 0)\n",
+    "  -type       Specify partition type (default 0x17)\n",
+    "  -id         Specify MBR ID (default random)\n",
+    "  -forcehd0   Always assume we are loaded as disk ID 0\n",
+    "  -ctrlhd0    Assume disk ID 0 if the Ctrl key is pressed\n",
+    "  -partok     Allow booting from within a partition\n";
+    exit 1;
+}
+
+# Parse a C-style integer (decimal/octal/hex)
+sub doh($) {
+    my($n) = @_;
+    return ($n =~ /^0/) ? oct $n : $n+0;
+}
+
+sub get_random() {
+    # Get a 32-bit random number
+    my $rfd, $rnd;
+    my $rid;
+
+    if (open($rfd, "< /dev/urandom\0") && read($rfd, $rnd, 4) == 4) {
+	$rid = unpack("V", $rnd);
+    }
+
+    close($rfd) if (defined($rfd));
+    return $rid if (defined($rid));
+
+    # This sucks but is better than nothing...
+    return ($$+time()) & 0xffffffff;
+}
+
+sub get_hex_data() {
+    my $mbr = '';
+    my $line, $byte;
+    while ( $line = <DATA> ) {
+	chomp $line;
+	last if ($line eq '*');
+	foreach $byte ( split(/\s+/, $line) ) {
+	    $mbr .= chr(hex($byte));
+	}
+    }
+    return $mbr;
+}
+
+while ($ARGV[0] =~ /^\-(.*)$/) {
+    $o = $1;
+    shift @ARGV;
+    if (defined($bool_opt{$o})) {
+	($o, $v) = @{$bool_opt{$o}};
+	$opt{$o} = $v;
+    } elsif (exists($opt{$o})) {
+	$opt{$o} = doh(shift @ARGV);
+	if (defined($valid_range{$o})) {
+	    ($l, $h) = @{$valid_range{$o}};
+	    if ($opt{$o} < $l || $opt{$o} > $h) {
+		die "$0: valid values for the -$o parameter are $l to $h\n";
+	    }
+	}
+    } else {
+	usage();
+    }
+}
+
+($file) = @ARGV;
+
+if (!defined($file)) {
+    usage();
+}
+
+open(FILE, "+< $file\0") or die "$0: cannot open $file: $!\n";
+binmode FILE;
+
+#
+# First, actually figure out where mkisofs hid isolinux.bin
+#
+seek(FILE, 17*2048, SEEK_SET) or die "$0: $file: $!\n";
+read(FILE, $boot_record, 2048) == 2048 or die "$0: $file: read error\n";
+($br_sign, $br_cat_offset) = unpack("a71V", $boot_record);
+if ($br_sign ne ("\0CD001\1EL TORITO SPECIFICATION" . ("\0" x 41))) {
+    die "$0: $file: no boot record found\n";
+}
+seek(FILE, $br_cat_offset*2048, SEEK_SET) or die "$0: $file: $!\n";
+read(FILE, $boot_cat, 2048) == 2048 or die "$0: $file: read error\n";
+
+# We must have a Validation Entry followed by a Default Entry...
+# no fanciness allowed for the Hybrid mode [XXX: might relax this later]
+@ve = unpack("v16", $boot_cat);
+$cs = 0;
+for ($i = 0; $i < 16; $i++) {
+    $cs += $ve[$i];
+}
+if ($ve[0] != 0x0001 || $ve[15] != 0xaa55 || $cs & 0xffff) {
+    die "$0: $file: invalid boot catalog\n";
+}
+($de_boot, $de_media, $de_seg, $de_sys, $de_mbz1, $de_count, 
+ $de_lba, $de_mbz2) = unpack("CCvCCvVv", substr($boot_cat, 32, 32));
+if ($de_boot != 0x88 || $de_media != 0 ||
+    ($de_segment != 0 && $de_segment != 0x7c0) || $de_count != 4) {
+    die "$0: $file: unexpected boot catalog parameters\n";
+}
+
+# Now $de_lba should contain the CD sector number for isolinux.bin
+seek(FILE, $de_lba*2048+0x40, SEEK_SET) or die "$0: $file: $!\n";
+read(FILE, $ibsig, 4);
+if ($ibsig ne "\xfb\xc0\x78\x70") {
+    die "$0: $file: bootloader does not have a isolinux.bin hybrid signature.".
+        "Note that isolinux-debug.bin does not support hybrid booting.\n";
+}
+
+# Get the total size of the image
+(@imgstat = stat(FILE)) or die "$0: $file: $!\n";
+$imgsize = $imgstat[7];
+if (!$imgsize) {
+    die "$0: $file: cannot determine length of file\n";
+}
+# Target image size: round up to a multiple of $h*$s*512
+$h = $opt{'h'};
+$s = $opt{'s'};
+$cylsize = $h*$s*512;
+$frac = $imgsize % $cylsize;
+$padding = ($frac > 0) ? $cylsize - $frac : 0;
+$imgsize += $padding;
+$c = int($imgsize/$cylsize);
+if ($c > 1024) {
+    print STDERR "Warning: more than 1024 cylinders ($c).\n";
+    print STDERR "Not all BIOSes will be able to boot this device.\n";
+    $cc = 1024;
+} else {
+    $cc = $c;
+}
+
+# Preserve id when run again
+if (defined($opt{'id'})) {
+    $id = pack("V", doh($opt{'id'}));
+} else {
+    seek(FILE, 440, SEEK_SET) or die "$0: $file: $!\n";
+    read(FILE, $id, 4);
+    if ($id eq "\x00\x00\x00\x00") {
+	$id = pack("V", get_random());
+    }
+}
+
+# Print the MBR and partition table
+seek(FILE, 0, SEEK_SET) or die "$0: $file: $!\n";
+
+for ($i = 0; $i <= $opt{'hd0'}+3*$opt{'partok'}; $i++) {
+    $mbr = get_hex_data();
+}
+if ( length($mbr) > 432 ) {
+    die "$0: Bad MBR code\n";
+}
+
+$mbr .= "\0" x (432 - length($mbr));
+
+$mbr .= pack("VV", $de_lba*4, 0); 	# Offset 432: LBA of isolinux.bin
+$mbr .= $id;				# Offset 440: MBR ID
+$mbr .= "\0\0";				# Offset 446: actual partition table
+
+# Print partition table
+$offset  = $opt{'offset'};
+$psize   = $c*$h*$s - $offset;
+$bhead   = int($offset/$s) % $h;
+$bsect   = ($offset % $s) + 1;
+$bcyl    = int($offset/($h*$s));
+$bsect  += ($bcyl & 0x300) >> 2;
+$bcyl   &= 0xff;
+$ehead   = $h-1;
+$esect   = $s + ((($cc-1) & 0x300) >> 2);
+$ecyl    = ($cc-1) & 0xff;
+$fstype  = $opt{'type'};	# Partition type
+$pentry  = $opt{'entry'};	# Partition slot
+
+for ( $i = 1 ; $i <= 4 ; $i++ ) {
+    if ( $i == $pentry ) {
+	$mbr .= pack("CCCCCCCCVV", 0x80, $bhead, $bsect, $bcyl, $fstype,
+		     $ehead, $esect, $ecyl, $offset, $psize);
+    } else {
+	$mbr .= "\0" x 16;
+    }
+}
+$mbr .= "\x55\xaa";
+
+print FILE $mbr;
+
+# Pad the image to a fake cylinder boundary
+seek(FILE, $imgstat[7], SEEK_SET) or die "$0: $file: $!\n";
+if ($padding) {
+    print FILE "\0" x $padding;
+}
+
+# Done...
+close(FILE);
+
+exit 0;
+__END__
diff --git a/contrib/syslinux-4.02/utils/keytab-lilo b/contrib/syslinux-4.02/utils/keytab-lilo
new file mode 100755
index 0000000..9e34160
--- /dev/null
+++ b/contrib/syslinux-4.02/utils/keytab-lilo
@@ -0,0 +1,95 @@
+#!/usr/bin/perl
+
+eval { use bytes; };
+eval { binmode STDOUT; };
+
+$DEFAULT_MAP = "us";
+$DEFAULT_EXT = ".kmap";
+
+sub usage
+{
+    print STDERR
+      "usage: $0 [ -p old_code=new_code ] ...\n".
+      (" "x(8+length $0))."[path]default_layout[.kmap] ] ".
+      "[path]kbd_layout[.kmap]\n";
+    exit 1;
+}
+
+
+while ($ARGV[0] eq "-p") {
+    shift(@ARGV);
+    &usage unless $ARGV[0] =~ /=/;
+    $table[eval($`)] = eval($');
+    shift(@ARGV);
+}
+&usage unless defined $ARGV[0];
+load_map("def",defined $ARGV[1] ? $ARGV[0] : undef);
+load_map("kbd",defined $ARGV[1] ? $ARGV[1] : $ARGV[0]);
+&build_table("plain","shift","ctrl","altgr","shift_ctrl",
+  "altgr_ctrl","alt","shift_alt","ctrl_alt");
+for ($i = 0; $i < 256; $i++) {
+    printf("%c",$table[$i] ? $table[$i] : $i) || die "print: $!";
+}
+close STDOUT || die "close: $!";
+
+
+sub load_map
+{
+    local ($pfx,$map) = @_;
+    local ($empty,$current);
+
+    $map = $DEFAULT_MAP unless defined $map;
+    $map .= $DEFAULT_EXT unless $map =~ m|/[^/]+\.[^/]+$|;
+    if (!open(FILE,"loadkeys -m $map |")) {
+	print STDERR "loadkeys -m $map: $!\n";
+	exit 1;
+    }
+    undef $current;
+    $empty = 1;
+    while (<FILE>) {
+	chop;
+	if (/^(static\s+)?u_short\s+(\S+)_map\[\S*\]\s+=\s+{\s*$/) {
+	    die "active at beginning of map" if defined $current;
+	    $current = $pfx.":".$2;
+	    next;
+	}
+	undef $current if /^};\s*$/;
+	next unless defined $current;
+	s/\s//g;
+	$map{$current} .= $_;
+	$empty = 0;
+    }
+    close FILE;
+    return unless $empty;
+    print STDERR "Keymap is empty\n";
+    exit 1;
+}
+
+
+sub build_table
+{
+    local (@maps) = @_;
+    local (@tmp);
+
+    $set = 0;
+    for $map (@maps) {
+	$code = $set;
+	for (split(",",$map{"def:".$map})) {
+	    die "bad map entry $_ (def, map $map)" unless /^0x\S\S(\S\S)$/;
+	    $tmp[$code] = hex $1 unless $tmp[$code];
+	    $code++;
+	}
+	$set += 256;
+    }
+    $set = 0;
+    for $map (@maps) {
+	$code = $set;
+	for (split(",",$map{"kbd:".$map})) {
+	    die "bad map entry $_ (kbd, map $map)" unless /^0x\S\S(\S\S)$/;
+	    $table[$tmp[$code]] = hex $1 unless $table[$tmp[$code]];
+	    $code++;
+	}
+	$set += 256;
+    }
+    $table[0] = 0;
+}
diff --git a/contrib/syslinux-4.02/utils/lss16toppm b/contrib/syslinux-4.02/utils/lss16toppm
new file mode 100755
index 0000000..18b7f64
--- /dev/null
+++ b/contrib/syslinux-4.02/utils/lss16toppm
@@ -0,0 +1,111 @@
+#!/usr/bin/perl
+## -----------------------------------------------------------------------
+##
+##   Copyright 2001-2008 H. Peter Anvin - All Rights Reserved
+##
+##   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, Inc., 53 Temple Place Ste 330,
+##   Boston MA 02111-1307, USA; either version 2 of the License, or
+##   (at your option) any later version; incorporated herein by reference.
+##
+## -----------------------------------------------------------------------
+
+##
+## lss16toppm:
+## Convert an LSS-16 image to PPM
+##
+## Usage:
+##
+##	lss16toppm [-map] < file.lss > file.ppm
+##
+## The -map causes the color map to be output on stderr.
+##
+
+eval { use bytes; };
+eval { binmode STDIN; };
+eval { binmode STDOUT; };
+
+$map = 0;
+foreach $arg ( @ARGV ) {
+    if ( $arg eq '-map' ) {
+	$map = 1;
+    } else {
+	print STDERR "$0: Unknown option: $arg\n";
+	exit 127;
+    }
+}
+
+if ( read(STDIN, $header, 56) != 56 ) {
+    print STDERR "$0: Short file\n";
+    exit 1;
+}
+
+($magic, $xsize, $ysize, @colorset) = unpack("Vvvc48", $header);
+
+if ( $magic != 0x1413f33d ) {
+    print STDERR "$0: Invalid file format\n";
+    exit 1;
+}
+
+%color = ();
+for ( $i = 0 ; $i < 16 ; $i++ ) {
+    $r = int((shift @colorset) * 255 / 63 + 0.5);
+    $g = int((shift @colorset) * 255 / 63 + 0.5);
+    $b = int((shift @colorset) * 255 / 63 + 0.5);
+
+    $color{$i} = pack("ccc", $r, $g, $b);
+
+    if ( $map ) {
+	printf STDERR "#%02x%02x%02x=%d\n", $r, $g, $b, $i;
+    }
+}
+
+sub get_nybble() {
+    my($ch,$n);
+    if ( defined($nybble_buf) ) {
+	$n = $nybble_buf;
+	undef $nybble_buf;
+    } else {
+	if ( read(STDIN, $ch, 1) != 1 ) {
+	    print STDERR "$0: Short read on input (file corrupt)\n";
+	    exit 1;
+	}
+	$ch = ord($ch);
+	$nybble_buf = $ch >> 4;
+	$n = $ch & 0xF;
+    }
+    return $n;
+}
+
+print "P6\n";
+print "$xsize $ysize\n";
+print "255\n";
+
+for ( $y = 0 ; $y < $ysize ; $y++ ) {
+    $x = 0;
+    $last = 0;
+    undef $nybble_buf;		# Nybble buffer starts clear on each line
+    while ( $x < $xsize ) {
+	$n = get_nybble();
+
+	if ( $n != $last ) {
+	    print $color{$n};
+	    $last = $n;
+	    $x++;
+	} else {
+	    $c = get_nybble();
+	    if ( $c == 0 ) {
+		# Double-nybble run
+		$c = get_nybble();
+		$c += get_nybble() << 4;
+		$c += 16;
+	    }
+	    # Truncate overlong runs
+	    $c = $xsize-$x if ( $c > $xsize-$x );
+	    # Output run
+	    print $color{$n} x $c;
+	    $x += $c;
+	}
+    }
+}
diff --git a/contrib/syslinux-4.02/utils/md5pass b/contrib/syslinux-4.02/utils/md5pass
new file mode 100755
index 0000000..3404f1d
--- /dev/null
+++ b/contrib/syslinux-4.02/utils/md5pass
@@ -0,0 +1,34 @@
+#!/usr/bin/perl
+
+use bytes;
+use Crypt::PasswdMD5;
+use MIME::Base64;
+
+sub random_bytes($) {
+    my($n) = @_;
+    my($v, $i);
+
+    if ( open(RANDOM, '<', '/dev/random') ||
+	 open(RANDOM, '<', '/dev/urandom') ) {
+	read(RANDOM, $v, $n);
+    } else {
+	# No real RNG available...
+	srand($$ ^ time);
+	$v = '';
+	for ( $i = 0 ; $i < $n ; $i++ ) {
+	    $v .= ord(int(rand() * 256));
+	}
+    }
+
+    return $v;
+}
+
+
+($pass, $salt) = @ARGV;
+
+unless (defined($salt)) {
+    $salt = MIME::Base64::encode(random_bytes(6), '');
+    $salt =~ tr/\+/./;		# . not +
+}
+
+print unix_md5_crypt($pass, $salt), "\n";
diff --git a/contrib/syslinux-4.02/utils/memdiskfind.c b/contrib/syslinux-4.02/utils/memdiskfind.c
new file mode 100644
index 0000000..decc788
--- /dev/null
+++ b/contrib/syslinux-4.02/utils/memdiskfind.c
@@ -0,0 +1,158 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 2010 Intel Corporation; author: H. Peter Anvin
+ *
+ *   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, Inc., 51 Franklin St, Fifth Floor,
+ *   Boston MA 02110-1301, USA; either version 2 of the License, or
+ *   (at your option) any later version; incorporated herein by reference.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * memdiskfind.c
+ *
+ * Simple utility to search for a MEMDISK instance and output the parameters
+ * needed to use the "phram" driver in Linux to map it.
+ */
+
+#include <errno.h>
+#include <fcntl.h>
+#include <inttypes.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include "../memdisk/mstructs.h"
+
+#define MBFT_MIN_LENGTH	(36+4+26)
+
+static bool valid_mbft(const struct mBFT *mbft, size_t space)
+{
+    uint8_t csum;
+    size_t i;
+
+    if (memcmp(mbft->acpi.signature, "mBFT", 4))
+	return false;
+
+    if (mbft->acpi.length < MBFT_MIN_LENGTH)
+	return false;
+
+    if (mbft->acpi.length > space)
+	return false;
+
+    if ((size_t)mbft->acpi.length != (size_t)mbft->mdi.bytes + 36+4)
+	return false;
+
+    csum = 0;
+    for (i = 0; i < mbft->acpi.length; i++)
+	csum += ((const uint8_t *)mbft)[i];
+
+    if (csum)
+	return false;
+
+    return true;
+}
+
+static void output_params(const struct mBFT *mbft)
+{
+    int sector_shift = mbft->mdi.sector_shift;
+
+    if (!sector_shift)
+	sector_shift = 9;
+
+    printf("%#x,%#x\n",
+	   mbft->mdi.diskbuf, mbft->mdi.disksize << sector_shift);
+}
+
+static size_t memlimit(void)
+{
+    char txtline[256], user[256];
+    size_t maxram = 0;
+    unsigned long long start, end;
+    FILE *iomem;
+
+    iomem = fopen("/proc/iomem", "r");
+    if (!iomem)
+	return 0;
+
+    while (fgets(txtline, sizeof txtline, iomem) != NULL) {
+	if (sscanf(txtline, "%llx-%llx : %[^\n]", &start, &end, user) != 3)
+	    continue;
+	if (strcmp(user, "System RAM"))
+	    continue;
+	if (start >= 0xa0000)
+	    continue;
+	maxram = (end >= 0xa0000) ? 0xa0000 : end+1;
+    }
+    fclose(iomem);
+
+    return maxram;
+}
+
+int main(int argc, char *argv[])
+{
+    const char *map;
+    int memfd;
+    size_t fbm;
+    const char *ptr, *end;
+    size_t page = sysconf(_SC_PAGESIZE);
+    size_t mapbase, maplen;
+    int err = 1;
+
+    (void)argc;
+
+    mapbase = memlimit() & ~(page - 1);
+    if (!mapbase)
+	return 2;
+
+    memfd = open("/dev/mem", O_RDONLY);
+    if (memfd < 0) {
+	fprintf(stderr, "%s: cannot open /dev/mem: %s\n",
+		argv[0], strerror(errno));
+	return 2;
+    }
+
+    map = mmap(NULL, page, PROT_READ, MAP_SHARED, memfd, 0);
+    if (map == MAP_FAILED) {
+	fprintf(stderr, "%s: cannot map page 0: %s\n",
+		argv[0], strerror(errno));
+	return 2;
+    }
+
+    fbm = *(uint16_t *)(map + 0x413) << 10;
+    if (fbm < mapbase)
+	fbm = mapbase;
+
+    munmap((void *)map, page);
+
+    if (fbm < 64*1024 || fbm >= 640*1024)
+	return 1;
+
+    maplen  = 0xa0000 - mapbase;
+    map = mmap(NULL, maplen, PROT_READ, MAP_SHARED, memfd, mapbase);
+    if (map == MAP_FAILED) {
+	fprintf(stderr, "%s: cannot map base memory: %s\n",
+		argv[0], strerror(errno));
+	return 2;
+    }
+
+    ptr = map + (fbm - mapbase);
+    end = map + (0xa0000 - mapbase);
+    while (ptr < end) {
+	if (valid_mbft((const struct mBFT *)ptr, end-ptr)) {
+	    output_params((const struct mBFT *)ptr);
+	    err = 0;
+	    break;
+	}
+	ptr += 16;
+    }
+
+    munmap((void *)map, maplen);
+
+    return err;
+}
diff --git a/contrib/syslinux-4.02/utils/mkdiskimage.in b/contrib/syslinux-4.02/utils/mkdiskimage.in
new file mode 100644
index 0000000..533193a
--- /dev/null
+++ b/contrib/syslinux-4.02/utils/mkdiskimage.in
@@ -0,0 +1,321 @@
+#!/usr/bin/perl
+## -----------------------------------------------------------------------
+##
+##   Copyright 2002-2008 H. Peter Anvin - All Rights Reserved
+##   Copyright 2009-2010 Intel Corporation; author: H. Peter Anvin
+##
+##   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, Inc., 53 Temple Place Ste 330,
+##   Boston MA 02111-1307, USA; either version 2 of the License, or
+##   (at your option) any later version; incorporated herein by reference.
+##
+## -----------------------------------------------------------------------
+
+#
+# Creates a blank MS-DOS formatted hard disk image
+#
+
+use bytes;
+use integer;
+use Fcntl;
+use Errno;
+use Cwd;
+use IO::Handle;			# For flush()
+
+sub absolute_path($) {
+    my($f) = @_;
+    my($c);
+
+    return $f if ( $f =~ /^\// );
+    $c = cwd();
+    $c = '' if ( $c eq '/' );
+    return $c.'/'.$f;
+}
+
+sub is_linux() {
+    return !!eval '{ '.
+	'use POSIX; '.
+	'($sysname, $nodename, $release, $version, $machine) = POSIX::uname(); '.
+	"return \$sysname eq \'Linux\'; }";
+}
+
+sub get_random() {
+    # Get a 32-bit random number
+    my $rfd, $rnd;
+    my $rid;
+
+    if (open($rfd, "< /dev/urandom\0") && read($rfd, $rnd, 4) == 4) {
+	$rid = unpack("V", $rnd);
+    }
+
+    close($rfd) if (defined($rfd));
+    return $rid if (defined($rid));
+
+    # This sucks but is better than nothing...
+    return ($$+time()) & 0xffffffff;
+}
+
+sub get_hex_data() {
+    my $mbr = '';
+    my $line, $byte;
+    while ( $line = <DATA> ) {
+	chomp $line;
+	last if ($line eq '*');
+	foreach $byte ( split(/\s+/, $line) ) {
+	    $mbr .= chr(hex($byte));
+	}
+    }
+    return $mbr;
+}
+
+$is_linux = is_linux();
+if ( $is_linux ) {
+    # IOCTL numbers
+    $BLKRRPART    = 0x125f;
+    $BLKGETSIZE   = 0x1260;
+}
+
+%opt = ();
+@args = ();
+
+while (defined($a = shift(@ARGV))) {
+    if ( $a =~ /^\-/ ) {
+	foreach $o ( split(//, substr($a,1)) ) {
+	    $opt{$o} = 1;
+	    if ($o eq 'i') {
+		$id = shift(@ARGV);
+	    }
+	}
+    } else {
+	push(@args, $a);
+    }
+}
+
+($file,$c,$h,$s) = @args;
+$c += 0;  $h += 0;  $s += 0;
+
+$pentry = 1;
+$pentry = 2 if ( $opt{'2'} );
+$pentry = 3 if ( $opt{'3'} );
+$pentry = 4 if ( $opt{'4'} );
+
+if ( $opt{'z'} ) {
+    $h = $h || 64;
+    $s = $s || 32;
+}
+
+if ( $opt{'M'} && $h && $s ) {
+    # Specify size in megabytes, not in cylinders
+    $c = ($c*1024*2)/($h*$s);
+}
+
+$is_open = 0;
+
+if ( $c == 0 && $file ne '' ) {
+    $len = 0;
+    if ( sysopen(OUTPUT, $file, O_RDWR, 0666) ) {
+	$is_open = 1;
+
+	if ( (@filestat = stat(OUTPUT)) && S_ISREG($filestat[2]) ) {
+	    $len = $filestat[7] >> 9;
+	} elsif ( $is_linux && S_ISBLK($filestat[2]) ) {
+	    $blksize = pack("L!", 0);
+	    if ( ioctl(OUTPUT, $BLKGETSIZE, $blksize) == 0 ) {
+		$len = unpack("L!", $blksize); # In 512-byte sectors!
+	    }
+	}
+    }
+
+    if ( !$len ) {
+	print STDERR "$0: $file: don't know how to determine the size of this device\n";
+	exit 1;
+    }
+
+    $c = $len/($h*$s);
+}
+
+if ( $file eq '' || $c < 1 || $h < 1 || $h > 256 || $s < 1 || $s > 63 ) {
+    print STDERR "Usage: $0 [-doFMz4][-i id] file c h s (max: 1024 256 63)\n";
+    print STDERR "    -d    add DOSEMU header\n";
+    print STDERR "    -o    print filesystem offset to stdout\n";
+    print STDERR "    -F    format partition as FAT32\n";
+    print STDERR "    -M    \"c\" argument is megabytes, calculate cylinders\n";
+    print STDERR "    -z    use zipdisk geometry (h=64 s=32)\n";
+    print STDERR "    -4    use partition entry 4 (standard for zipdisks)\n";
+    print STDERR "    -i    specify the MBR ID\n";
+    print STDERR "    -s    output a sparse file (don't allocate all blocks)\n";
+    exit 1;
+}
+
+if ($c > 1024) {
+    print STDERR "Warning: more than 1024 cylinders ($c).\n";
+    print STDERR "Not all BIOSes will be able to boot this device.\n";
+    $cc = 1024;
+} else {
+    $cc = $c;
+}
+
+$cylsize = $h*$s*512;
+
+if ( !$is_open ) {
+    sysopen(OUTPUT, $file, O_CREAT|O_RDWR|O_TRUNC, 0666)
+	or die "$0: Cannot open: $file\n";
+}
+binmode OUTPUT;
+
+# Print out DOSEMU header, if requested
+if ( $opt{'d'} ) {
+    $emuhdr = "DOSEMU\0" . pack("VVVV", $h, $s, $c, 128);
+    $emuhdr .= "\0" x (128 - length($emuhdr));
+    print OUTPUT $emuhdr;
+}
+
+# Print the MBR and partition table
+$mbr = get_hex_data();
+if ( length($mbr) > 440 ) {
+    die "$0: Bad MBR code\n";
+}
+
+$mbr .= "\0" x (440 - length($mbr));
+if (defined($id)) {
+    $id = to_int($id);
+} else {
+    $id = get_random();
+}
+$mbr .= pack("V", $id);		# Offset 440: MBR ID
+$mbr .= "\0\0";			# Offset 446: actual partition table
+
+print OUTPUT $mbr;
+
+# Print partition table
+$psize = $c*$h*$s-$s;
+$bhead   = ($h > 1) ? 1 : 0;
+$bsect   = 1;
+$bcyl    = ($h > 1) ? 0 : 1;
+$ehead   = $h-1;
+$esect   = $s + ((($cc-1) & 0x300) >> 2);
+$ecyl    = ($cc-1) & 0xff;
+if ( $c > 1024 ) {
+    $fstype = 0x0e;
+} elsif ( $psize > 65536 ) {
+    $fstype = 0x06;
+} else {
+    $fstype = 0x04;
+}
+for ( $i = 1 ; $i <= 4 ; $i++ ) {
+    if ( $i == $pentry ) {
+	print OUTPUT pack("CCCCCCCCVV", 0x80, $bhead, $bsect, $bcyl, $fstype,
+			  $ehead, $esect, $ecyl, $s, $psize);
+    } else {
+	print OUTPUT "\0" x 16;
+    }
+}
+print OUTPUT "\x55\xaa";
+
+# Output blank file
+$totalsize = $c*$h*$s;
+$tracks    = $c*$h;
+
+# If -s is given, try to simply use truncate...
+unless ($opt{'s'} && truncate(OUTPUT, $totalsize)) {
+    $track = "\0" x (512*$s);
+
+    # Print fractional track
+    print OUTPUT "\0" x (512 * ($s-1));
+
+    for ( $i = 1 ; $i < $tracks ; $i++ ) {
+	print OUTPUT $track;
+    }
+}
+
+# Print mtools temp file
+$n = 0;
+while ( !defined($tmpdir) ) {
+    $tmpdir = "/tmp/mkdiskimage.$$.".($n++);
+    if ( !mkdir($tmpdir, 0700) ) {
+	die "$0: Failed to make temp directory: $tmpdir\n"
+	    if ( $! != EEXIST );
+	undef $tmpdir;
+    }
+}
+
+$cfgfile = $tmpdir.'/mtools.conf';
+$imglink = $tmpdir.'/disk.img';
+die "$0: Failed to create symlink $imglink\n"
+    if ( !symlink(absolute_path($file), $imglink) );
+
+$header_size = ($opt{'d'} ? 128 : 0);
+
+# Start of filesystem
+$offset = $s*512 + $header_size;
+
+# Start of partition table entry
+$pstart = $header_size + 446 + 16*($pentry-1);
+
+open(MCONFIG, "> ${cfgfile}") or die "$0: Cannot make mtools config\n";
+print MCONFIG "drive z:\n";
+print MCONFIG "file=\"${imglink}\"\n";
+print MCONFIG "cylinders=${c}\n";
+print MCONFIG "heads=${h}\n";
+print MCONFIG "sectors=${s}\n";
+print MCONFIG "offset=${offset}\n";
+print MCONFIG "mformat_only\n";
+close(MCONFIG);
+
+# Output the filesystem offset to stdout if appropriate
+if ( $opt{'o'} ) {
+    print $offset, "\n";
+}
+
+$ENV{'MTOOLSRC'} = $cfgfile;
+if ( $opt{'F'} ) {
+    system('mformat', '-F', 'z:');
+} else {
+    system('mformat', 'z:');
+}
+
+# Clean up in /tmp
+unlink($cfgfile);
+unlink($imglink);
+rmdir($tmpdir);
+
+# MTOOLS doesn't write the bsHiddenSecs field correctly
+seek(OUTPUT, $offset + 0x1c, 0);
+print OUTPUT pack("V", ($offset-$header_size)>>9);
+
+# Set the partition type
+if ( $opt{'F'} ) {
+    if ( $c > 1024 ) {
+	$fstype = 0x0c;		# FAT32 LBA
+    } else {
+	$fstype = 0x0b;
+    }
+} else {
+    if ( $c > 1024 ) {
+	$fstype = 0x0e;		# FAT16 LBA
+    } elsif ( $psize > 65536 ) {
+	$fstype = 0x06;		# FAT16 > 32MB
+    } else {
+	$fstype = 0x04;		# FAT16 <= 32MB
+    }
+    seek(OUTPUT, $offset + 0x36, 0);
+    read(OUTPUT, $fsname, 8);
+
+    # FAT12: adjust partition type
+    if ( $fsname eq 'FAT12   ' ) {
+	$fstype = 0x01;		# FAT12
+    }
+}
+seek(OUTPUT, $pstart+4, 0);
+print OUTPUT pack("C", $fstype);
+
+flush OUTPUT;
+
+# Just in case this is a block device, try to flush the partition table
+if ( $is_linux ) {
+    ioctl(OUTPUT, $BLKRRPART, 0);
+};
+
+exit 0;
+__END__
diff --git a/contrib/syslinux-4.02/utils/ppmtolss16 b/contrib/syslinux-4.02/utils/ppmtolss16
new file mode 100755
index 0000000..5af9083
--- /dev/null
+++ b/contrib/syslinux-4.02/utils/ppmtolss16
@@ -0,0 +1,393 @@
+#!/usr/bin/perl
+## -----------------------------------------------------------------------
+##
+##   Copyright 2004-2008 H. Peter Anvin - All Rights Reserved
+##
+##   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, Inc., 53 Temple Place Ste 330,
+##   Boston MA 02111-1307, USA; either version 2 of the License, or
+##   (at your option) any later version; incorporated herein by reference.
+##
+## -----------------------------------------------------------------------
+
+##
+## ppmtolss16
+##
+## Convert a PNM file with max 16 colors to a simple RLE-based format:
+##
+## uint32 0x1413f33d    ; magic (littleendian)
+## uint16 xsize		; littleendian
+## uint16 ysize		; littleendian
+## 16 x uint8 r,g,b	; color map, in 6-bit format (each byte is 0..63)
+##
+## Then, a sequence of nybbles:
+##
+## N	... if N is != previous pixel, one pixel of color N
+## ... otherwise run sequence follows ...
+## M    ... if M > 0 then run length is M
+## ... otherwise run sequence is encoded in two nybbles,
+##     littleendian, +16
+##
+## The nybble sequences are on a per-row basis; runs may not extend
+## across rows and odd-nybble rows are zero-padded.
+##
+## At the start of row, the "previous pixel" is assumed to be zero.
+##
+## Usage:
+##
+##	ppmtolss16 [#rrggbb=i ...] < input.ppm > output.rle
+##
+## Command line options of the form #rrggbb=i indicate that
+## the color #rrggbb (hex) should be assigned index i (decimal)
+##
+
+eval { use bytes; };
+eval { binmode STDIN; };
+eval { binmode STDOUT; };
+
+$magic = 0x1413f33d;
+
+# Get a token from the PPM header.  Ignore comments and leading
+# and trailing whitespace, as is required by the spec.
+# This routine eats exactly one character of trailing whitespace,
+# unless it is a comment (in which case it eats the comment up
+# to and including the end of line.)
+sub get_token() {
+    my($token, $ch);
+    my($ch);
+
+    do {
+	$ch = getc(STDIN);
+	return undef if ( !defined($ch) ); # EOF
+	if ( $ch eq '#' ) {
+	    do {
+		$ch = getc(STDIN);
+		return undef if ( !defined($ch) );
+	    } while ( $ch ne "\n" );
+	}
+    } while ( $ch =~ /^[ \t\n\v\f\r]$/ );
+
+    $token = $ch;
+    while ( 1 ) {
+	$ch = getc(STDIN);
+	last if ( $ch =~ /^[ \t\n\v\f\r\#]$/ );
+	$token .= $ch;
+    }
+    if ( $ch eq '#' ) {
+	do {
+	    $ch = getc(STDIN);
+	} while ( defined($ch) && $ch ne "\n" );
+    }
+    return $token;
+}
+
+# Get a token, and make sure it is numeric (and exists)
+sub get_numeric_token() {
+    my($token) = get_token();
+
+    if ( $token !~ /^[0-9]+$/ ) {
+	print STDERR "Format error on input\n";
+	exit 1;
+    }
+
+    return $token + 0;
+}
+
+# Must be called before each pixel row is read
+sub start_new_row() {
+    $getrgb_leftover_bit_cnt = 0;
+    $getrgb_leftover_bit_val = 0;
+}
+
+# Get a single RGB token depending on the PNM type
+sub getrgb($) {
+    my($form) = @_;
+    my($rgb,$r,$g,$b);
+
+    if ( $form == 6 ) {
+	# Raw PPM, most common
+	return undef unless ( read(STDIN,$rgb,3) == 3 );
+	return unpack("CCC", $rgb);
+    } elsif ( $form == 3 ) {
+	# Plain PPM
+	$r = get_numeric_token();
+	$g = get_numeric_token();
+	$b = get_numeric_token();
+	return ($r,$g,$b);
+    } elsif  ( $form == 5 ) {
+	# Raw PGM
+	return undef unless ( read(STDIN,$rgb,1) == 1 );
+	$r = unpack("C", $rgb);
+	return ($r,$r,$r);
+    } elsif ( $form == 2 ) {
+	# Plain PGM
+	$r = get_numeric_token();
+	return ($r,$r,$r);
+    } elsif ( $form == 4 ) {
+	# Raw PBM
+	if ( !$getrgb_leftover_bit_cnt ) {
+	    return undef unless ( read(STDIN,$rgb,1) == 1 );
+	    $getrgb_leftover_bit_val = unpack("C", $rgb);
+	    $getrgb_leftover_bit_cnt = 8;
+	}
+	$r = ( $getrgb_leftover_bit_val & 0x80 ) ? 0x00 : 0xff;
+	$getrgb_leftover_bit_val <<= 1;
+	$getrgb_leftover_bit_cnt--;
+
+	return ($r,$r,$r);
+    } elsif ( $form == 1 ) {
+	# Plain PBM
+	my($ch);
+
+	do {
+	    $ch = getc(STDIN);
+	    return undef if ( !defined($ch) );
+	    return (255,255,255) if ( $ch eq '0' ); # White
+	    return (0,0,0) if ( $ch eq '1'); # Black
+	    if ( $ch eq '#' ) {
+		do {
+		    $ch = getc(STDIN);
+		    return undef if ( !defined($ch) );
+		} while ( $ch ne "\n" );
+	    }
+	} while ( $ch =~ /^[ \t\n\v\f\r]$/ );
+	return undef;
+    } else {
+	die "Internal error: unknown format: $form\n";
+    }
+}
+
+sub rgbconvert($$$$) {
+    my($r,$g,$b,$maxmult) = @_;
+    my($rgb);
+
+    $r = int($r*$maxmult);
+    $g = int($g*$maxmult);
+    $b = int($b*$maxmult);
+    $rgb = pack("CCC", $r, $g, $b);
+    return $rgb;
+}
+
+foreach $arg ( @ARGV ) {
+    if ( $arg =~ /^\#([0-9a-f])([0-9a-f])([0-9a-f])=([0-9]+)$/i ) {
+	$r = hex($1) << 4;
+	$g = hex($2) << 4;
+	$b = hex($3) << 4;
+	$i = $4 + 0;
+    } elsif ( $arg =~ /^\#([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})=([0-9]+)$/i ) {
+	$r = hex($1);
+	$g = hex($2);
+	$b = hex($3);
+	$i = $4 + 0;
+    } elsif ( $arg =~ /^\#([0-9a-f]{3})([0-9a-f]{3})([0-9a-f]{3})=([0-9]+)$/i ) {
+	$r = hex($1) >> 4;
+	$g = hex($2) >> 4;
+	$b = hex($3) >> 4;
+	$i = $4 + 0;
+    } elsif ( $arg =~ /^\#([0-9a-f]{4})([0-9a-f]{4})([0-9a-f]{4})=([0-9]+)$/i ) {
+	$r = hex($1) >> 8;
+	$g = hex($2) >> 8;
+	$b = hex($3) >> 8;
+	$i = $4 + 0;
+    } else {
+	print STDERR "$0: Unknown argument: $arg\n";
+	next;
+    }
+
+    if ( $i > 15 ) {
+	print STDERR "$0: Color index out of range: $arg\n";
+	next;
+    }
+
+    $rgb = rgbconvert($r, $g, $b, 64/256);
+
+    if ( defined($index_forced{$i}) ) {
+	print STDERR "$0: More than one color index $i\n";
+	exit(1);
+    }
+    $index_forced{$i} = $rgb;
+    $force_index{$rgb} = $i;
+}
+
+$form = get_token();
+die "$0: stdin is not a PNM file" if ( $form !~ /^P([1-6])$/ );
+$form = $1+0;
+
+$xsize = get_numeric_token();
+$ysize = get_numeric_token();
+if ( $form == 1 || $form == 4 ) {
+    $maxcol = 255;		# Internal convention
+} else {
+    $maxcol = get_numeric_token();
+}
+$maxmult = 64/($maxcol+1);	# Equal buckets conversion
+
+@data = ();
+
+for ( $y = 0 ; $y < $ysize ; $y++ ) {
+    start_new_row();
+    for ( $x = 0 ; $x < $xsize ; $x++ ) {
+	die "$0: Premature EOF at ($x,$y) of ($xsize,$ysize)\n"
+	    if ( !defined(@pnmrgb = getrgb($form)) );
+	# Convert to 6-bit representation
+	$rgb = rgbconvert($pnmrgb[0], $pnmrgb[1], $pnmrgb[2], $maxmult);
+	$color_count{$rgb}++;
+	push(@data, $rgb);
+    }
+}
+
+# Sort list of colors according to freqency
+@colors = sort { $color_count{$b} <=> $color_count{$a} } keys(%color_count);
+
+# Now we have our pick of colors.  Sort according to intensity;
+# this is more or less an ugly hack to cover for the fact that
+# using PPM as input doesn't let the user set the color map,
+# which the user really needs to be able to do.
+
+sub by_intensity() {
+    my($ra,$ga,$ba) = unpack("CCC", $a);
+    my($rb,$gb,$bb) = unpack("CCC", $b);
+
+    my($ia) = $ra*0.299 + $ga*0.587 + $ba*0.114;
+    my($ib) = $rb*0.299 + $gb*0.587 + $bb*0.114;
+
+    return ( $ia <=> $ib ) if ( $ia != $ib );
+
+    # If same, sort based on RGB components,
+    # with highest priority given to G, then R, then B.
+
+    return ( $ga <=> $gb ) if ( $ga != $gb );
+    return ( $ra <=> $rb ) if ( $ra != $rb );
+    return ( $ba <=> $bb );
+}
+
+@icolors = sort by_intensity @colors;
+
+# Insert forced colors into "final" array
+@colors = (undef) x 16;
+foreach $rgb ( keys(%force_index) ) {
+    $i = $force_index{$rgb};
+    $colors[$i] = $rgb;
+    $color_index{$rgb} = $i;
+}
+
+undef %force_index;
+
+# Insert remaining colors in the remaining slots,
+# in luminosity-sorted order
+$nix = 0;
+while ( scalar(@icolors) ) {
+    # Advance to the next free slot
+    $nix++ while ( defined($colors[$nix]) && $nix < 16 );
+    last if ( $nix >= 16 );
+    $rgb = shift @icolors;
+    if ( !defined($color_index{$rgb}) ) {
+	$colors[$nix] = $rgb;
+	$color_index{$rgb} = $nix;
+    }
+}
+
+while ( scalar(@icolors) ) {
+    $rgb = shift @icolors;
+    $lost++ if ( !defined($color_index{$rgb}) );
+}
+
+if ( $lost ) {
+    printf STDERR
+	"$0: Warning: color palette truncated (%d colors ignored)\n", $lost;
+}
+
+undef @icolors;
+
+# Output header
+print pack("Vvv", $magic, $xsize, $ysize);
+
+# Output color map
+for ( $i = 0 ; $i < 16 ; $i++ ) {
+    if ( defined($colors[$i]) ) {
+	print $colors[$i];
+    } else {
+	# Padding for unused color entries
+	print pack("CCC", 63*$i/15, 63*$i/15, 63*$i/15);
+    }
+}
+
+sub output_nybble($) {
+    my($ny) = @_;
+
+    if ( !defined($ny) ) {
+	if ( defined($nybble_tmp) ) {
+	    $ny = 0;		# Force the last byte out
+	} else {
+	    return;
+	}
+    }
+
+    $ny = $ny & 0x0F;
+
+    if ( defined($nybble_tmp) ) {
+	$ny = ($ny << 4) | $nybble_tmp;
+	print chr($ny);
+	$bytes++;
+	undef $nybble_tmp;
+    } else {
+	$nybble_tmp = $ny;
+    }
+}
+
+sub output_run($$$) {
+    my($last,$this,$run) = @_;
+
+    if ( $this != $last ) {
+	output_nybble($this);
+	$run--;
+    }
+    while ( $run ) {
+	if ( $run >= 16 ) {
+	    output_nybble($this);
+	    output_nybble(0);
+	    if ( $run > 271 ) {
+		$erun = 255;
+		$run -= 271;
+	    } else {
+		$erun = $run-16;
+		$run = 0;
+	    }
+	    output_nybble($erun);
+	    output_nybble($erun >> 4);
+	} else {
+	    output_nybble($this);
+	    output_nybble($run);
+	    $run = 0;
+	}
+    }
+}
+
+$bytes  = 0;
+undef $nybble_tmp;
+
+for ( $y = 0 ; $y < $ysize ; $y++ ) {
+    $last = $prev = 0;
+    $run = 0;
+    for ( $x = 0 ; $x < $xsize ; $x++ ) {
+	$rgb = shift(@data);
+	$i   = $color_index{$rgb} + 0;
+	if ( $i == $last ) {
+	    $run++;
+	} else {
+	    output_run($prev, $last, $run);
+	    $prev = $last;
+	    $last = $i;
+	    $run  = 1;
+	}
+    }
+    # Output final datum for row; we're always at least one pixel behind
+    output_run($prev, $last, $run);
+    output_nybble(undef);	# Flush row
+}
+
+$pixels = $xsize * $ysize;
+$size = ($pixels+1)/2;
+printf STDERR "%d pixels, %d bytes, (%2.2f%% compression)\n",
+    $pixels, $bytes, 100*($size-$bytes)/$size;
diff --git a/contrib/syslinux-4.02/utils/pxelinux-options b/contrib/syslinux-4.02/utils/pxelinux-options
new file mode 100755
index 0000000..ab7075b
--- /dev/null
+++ b/contrib/syslinux-4.02/utils/pxelinux-options
@@ -0,0 +1,499 @@
+#!/usr/bin/perl
+#
+# Set PXELINUX hard-coded options
+#
+
+use Socket;			# For gethostbyname
+use Fcntl;
+use bytes;
+
+%option_names = (
+      6 => 'domain-name-servers',
+     15 => 'domain-name',
+     54 => 'next-server',
+    209 => 'config-file',
+    210 => 'path-prefix',
+    211 => 'reboottime'
+    );
+
+@fmt_oneip   = ("ip-address", \&parse_oneip, \&show_ip);
+@fmt_multiip = ("ip-address-list", \&parse_multiip, \&show_ip);
+@fmt_string  = ("string", \&parse_string, \&show_string);
+@fmt_uint32  = ("uint32", \&parse_uint32, \&show_uint32);
+
+%option_format = (
+      6 => \@fmt_multiip,
+     15 => \@fmt_string,
+     54 => \@fmt_oneip,
+     67 => \@fmt_string,
+    209 => \@fmt_string,
+    210 => \@fmt_string,
+    211 => \@fmt_uint32
+    );
+
+sub parse_oneip($)
+{
+    my($s) = @_;
+    my($name,$aliases,$addrtype,$length,@addrs) = gethostbyname($s);
+
+    return ($addrtype == AF_INET) ? $addrs[0] : undef;
+}
+
+sub parse_multiip($)
+{
+    my($l) = @_;
+    my $s;
+    my @a = ();
+    my $addr;
+    my $d = '';
+
+    foreach $s (split(/,/, $l)) {
+	my($name,$aliases,$addrtype,$length,@addrs)
+	    = gethostbyname($s);
+	if ($addrtype == AF_INET) {
+	    foreach $addr (@addrs) {
+		$d .= $addr;
+	    }
+	}
+    }
+
+    return $d ne '' ? $d : undef;
+}
+
+sub show_ip($)
+{
+    my($l) = @_;
+
+    if (length($l) & 3) {
+	return undef;
+    } else {
+	my @h = ();
+	my $i;
+
+	for ($i = 0; $i < length($l); $i += 4) {
+	    push(@h, inet_ntoa(substr($l, $i, 4)));
+	}
+
+	return join(',', @h);
+    }
+}
+
+sub parse_string($)
+{
+    return $_[0];
+}
+
+sub show_string($)
+{
+    my($s) = @_;
+    my $o, $i, $c;
+
+    $o = "\'";
+    for ($i = 0; $i < length($s); $i++) {
+	$c = substr($s, $i, 1);
+	if ($c eq "\'" || $c eq '!') {
+	    $o .= "\'\\$c\'";
+	} else {
+	    $o .= $c;
+	}
+    }
+    $o .= "\'";
+
+    return $o;
+}
+
+sub parse_uint32($)
+{
+    my($s) = @_;
+
+    if ($s =~ /^[0-9]+$/) {
+	return pack("N", $s);
+    } else {
+	return undef;
+    }
+}
+
+sub show_uint32($)
+{
+    my($l) = @_;
+
+    if (length($l) == 4) {
+	return unpack("N", $l);
+    } else {
+	return undef;
+    }
+}
+
+sub parse_generic($)
+{
+    my($s) = @_;
+
+    if ($s =~ /^[0-9a-f]{1,2}(:[0-9a-f]{1,2})*$/) {
+	my $h;
+	my @b = ();
+
+	foreach $h (split(/\:/, $s)) {
+	    push(@b, hex $h);
+	}
+
+	return pack("C", @b);
+    } else {
+	return undef;
+    }
+}
+
+sub show_generic($)
+{
+    my($l) = @_;
+    my $i;
+    my @h;
+
+    for ($i = 0; $i < length($l); $i++) {
+	push(@h, sprintf("%02x", unpack("C", substr($l, $i, $1))));
+    }
+
+    return join(':', @h);
+}
+
+sub parse_option($$)
+{
+    my($opt, $arg) = @_;
+    my $v;
+
+    if (defined($option_format{$opt})) {
+	$v = $option_format{$opt}[1]($arg);
+	return $v if (defined($v));
+    }
+
+    return parse_generic($arg);
+}
+
+sub show_option($$)
+{
+    my($opt, $arg) = @_;
+    my $v;
+
+    if (defined($option_format{$opt})) {
+	$v = $option_format{$opt}[2]($arg);
+	return $v if (defined($v));
+    }
+
+    return show_generic($arg);
+}
+
+sub option_number($)
+{
+    my($n) = @_;
+
+    if (defined($option_rnames{$n})) {
+	return $option_rnames{$n};
+    } elsif ($n =~ /^[0-9]+$/ && $n >= 1 && $n <= 254) {
+	return $n+0;
+    } else {
+	return undef;
+    }
+}
+
+sub read_optsets($)
+{
+    my($file) = @_;
+    my $data, $bdata, $adata;
+    my $patch_start = (stat($file))[7];
+
+    return undef unless (seek($file, 8, SEEK_SET));
+    return undef unless (read($file, $data, 7*4) == 7*4);
+
+    my($magic, $len, $flags, $boff, $blen, $aoff, $alen)
+	= unpack("VVVVVVV", $data);
+    return undef if ($magic != 0x2983c8ac);
+    return undef if ($len < 7*4);
+
+    if ($blen == 0) {
+	$bdata = '';
+    } else {
+	return undef unless (seek($file, $boff, SEEK_SET));
+	return undef unless (read($file, $bdata, $blen) == $blen);
+	$patch_start = $boff if ($boff < $patch_start);
+    }
+
+    if ($alen == 0) {
+	$adata = '';
+    } else {
+	return undef unless (seek($file, $aoff, SEEK_SET));
+	return undef unless (read($file, $adata, $alen) == $alen);
+	$patch_start = $aoff if ($aoff < $patch_start);
+    }
+
+    return ($patch_start, $bdata, $adata);
+}
+
+sub write_optsets($$@)
+{
+    my($file, $patch_start, $bdata, $adata) = @_;
+    my $boff = 0;
+    my $aoff = 0;
+
+    if (length($bdata) > 0) {
+	$bdata .= "\xff";
+	$boff = $patch_start;
+	return undef unless (seek($file, $boff, SEEK_SET));
+	return undef unless (print $file $bdata);
+	$patch_start += length($bdata);
+    }
+
+    if (length($adata) > 0) {
+	$adata .= "\xff";
+	$aoff = $patch_start;
+	return undef unless (seek($file, $aoff, SEEK_SET));
+	return undef unless (print $file $adata);
+	$patch_start += length($adata);
+    }
+
+    my $hdr = pack("VVVV", $boff, length($bdata), $aoff, length($adata));
+
+    return undef unless (seek($file, 8+3*4, SEEK_SET));
+    return undef unless (print $file $hdr);
+
+    truncate($file, $patch_start);
+    return 1;
+}
+
+sub delete_option($$)
+{
+    my ($num, $block) = @_;
+    my $o, $l, $c, $x;
+
+    $x = 0;
+    while ($x < length($block)) {
+	($o, $l) = unpack("CC", substr($block, $x, 2));
+	if ($o == $num) {
+	    # Delete this option
+	    substr($block, $x, $l+2) = '';
+	} elsif ($o == 0) {
+	    # Delete a null option
+	    substr($block, $x, 1) = '';
+	} elsif ($o == 255) {
+	    # End marker - truncate block
+	    $block = substr($block, 0, $x);
+	    last;
+	} else {
+	    # Skip to the next option
+	    $x += $l+2;
+	}
+    }
+
+    return $block;
+}
+
+sub add_option($$$)
+{
+    my ($num, $data, $block) = @_;
+
+    $block = delete_option($num, $block);
+
+    if (length($data) == 0) {
+	return $block;
+    } elsif (length($data) > 255) {
+	die "$0: option $num has too much data (max 255 bytes)\n";
+    } else {
+	return $block . pack("CC", $num, length($data)) . $data;
+    }
+}
+
+sub list_options($$)
+{
+    my($pfx, $data) = @_;
+    my $x, $o, $l;
+
+    while ($x < length($data)) {
+	($o, $l) = unpack("CC", substr($data, $x, 2));
+
+	if ($o == 0) {
+	    $x++;
+	} elsif ($o == 255) {
+	    last;
+	} else {
+	    my $odata = substr($data, $x+2, $l);
+	    last if (length($odata) != $l); # Incomplete option
+
+	    printf "%s%-20s %s\n", $pfx,
+		$option_names{$o} || sprintf("%d", $o),
+		show_option($o, $odata);
+
+	    $x += $l+2;
+	}
+    }
+}
+
+sub usage()
+{
+    my $i;
+
+    print STDERR "Usage: $0 options pxelinux.0\n";
+    print STDERR "Options:\n";
+    print STDERR "--before option value   -b   Add an option before DHCP data\n";
+    print STDERR "--after  option value   -a   Add an option after DHCP data\n";
+    print STDERR "--delete option         -d   Delete an option\n";
+    print STDERR "--list                  -l   List set options\n";
+    print STDERR "--dry-run               -n   Don't modify the target file\n";
+    print STDERR "--help                  -h   Display this help text\n";
+    print STDERR "\n";
+    print STDERR "The following DHCP options are currently recognized:\n";
+    printf STDERR "%-23s %-3s  %s\n", 'Name', 'Num', 'Value Format';
+
+    foreach $i (sort { $a <=> $b } keys(%option_names)) {
+	printf STDERR "%-23s %3d  %s\n",
+		$option_names{$i}, $i, $option_format{$i}[0];
+    }
+}
+
+%option_rnames = ();
+foreach $opt (keys(%option_names)) {
+    $option_rnames{$option_names{$opt}} = $opt;
+}
+
+%before   = ();
+%after    = ();
+@clear    = ();
+$usage    = 0;
+$err      = 0;
+$list     = 0;
+$no_write = 0;
+undef $file;
+
+while (defined($opt = shift(@ARGV))) {
+    if ($opt !~ /^-/) {
+	if (defined($file)) {
+	    $err = $usage = 1;
+	    last;
+	}
+	$file = $opt;
+    } elsif ($opt eq '-b' || $opt eq '--before') {
+	$oname = shift(@ARGV);
+	$odata = shift(@ARGV);
+
+	if (!defined($odata)) {
+	    $err = $usage = 1;
+	    last;
+	}
+
+	$onum = option_number($oname);
+	if (!defined($onum)) {
+	    print STDERR "$0: unknown option name: $oname\n";
+	    $err = 1;
+	    next;
+	}
+
+	$odata = parse_option($onum, $odata);
+	if (!defined($odata)) {
+	    print STDERR "$0: unable to parse data for option $oname\n";
+	    $err = 1;
+	    next;
+	}
+
+	delete $after{$onum};
+	$before{$onum} = $odata;
+	push(@clear, $onum);
+    } elsif ($opt eq '-a' || $opt eq '--after') {
+	$oname = shift(@ARGV);
+	$odata = shift(@ARGV);
+
+	if (!defined($odata)) {
+	    $err = $usage = 1;
+	    last;
+	}
+
+	$onum = option_number($oname);
+	if (!defined($onum)) {
+	    print STDERR "$0: unknown option name: $oname\n";
+	    $err = 1;
+	    next;
+	}
+
+	$odata = parse_option($onum, $odata);
+	if (!defined($odata)) {
+	    print STDERR "$0: unable to parse data for option $oname\n";
+	    $err = 1;
+	    next;
+	}
+
+	delete $before{$onum};
+	$after{$onum} = $odata;
+	push(@clear, $onum);
+    } elsif ($opt eq '-d' || $opt eq '--delete') {
+	$oname = shift(@ARGV);
+
+	if (!defined($oname)) {
+	    $err = $usage = 1;
+	    last;
+	}
+
+	$onum = option_number($oname);
+	if (!defined($onum)) {
+	    print STDERR "$0: unknown option name: $oname\n";
+	    $err = 1;
+	    next;
+	}
+
+	push(@clear, $onum);
+	delete $before{$onum};
+	delete $after{$onum};
+    } elsif ($opt eq '-n' || $opt eq '--no-write' || $opt eq '--dry-run') {
+	$no_write = 1;
+    } elsif ($opt eq '-l' || $opt eq '--list') {
+	$list = 1;
+    } elsif ($opt eq '-h' || $opt eq '--help') {
+	$usage = 1;
+    } else {
+	print STDERR "Invalid option: $opt\n";
+	$err = $usage = 1;
+    }
+}
+
+if (!defined($file) && !$usage) {
+    $err = $usage = 1;
+}
+if ($usage) {
+    usage();
+}
+if ($err || $usage) {
+    exit($err);
+}
+
+if (!scalar(@clear)) {
+    $no_write = 1;		# No modifications requested
+}
+
+$mode = $no_write ? '<' : '+<';
+
+open(FILE, $mode, $file)
+    or die "$0: cannot open: $file: $!\n";
+($patch_start, @data) = read_optsets(\*FILE);
+if (!defined($patch_start)) {
+    die "$0: $file: patch block not found or file corrupt\n";
+}
+
+foreach $o (@clear) {
+    $data[0] = delete_option($o, $data[0]);
+    $data[1] = delete_option($o, $data[1]);
+}
+foreach $o (keys(%before)) {
+    $data[0] = add_option($o, $before{$o}, $data[0]);
+}
+foreach $o (keys(%after)) {
+    $data[1] = add_option($o, $after{$o}, $data[1]);
+}
+
+if ($list) {
+    list_options('-b ', $data[0]);
+    list_options('-a ', $data[1]);
+}
+
+if (!$no_write) {
+    if (!write_optsets(\*FILE, $patch_start, @data)) {
+	die "$0: $file: failed to write options: $!\n";
+    }
+}
+
+close(FILE);
+exit 0;
diff --git a/contrib/syslinux-4.02/utils/sha1pass b/contrib/syslinux-4.02/utils/sha1pass
new file mode 100755
index 0000000..3be2dbc
--- /dev/null
+++ b/contrib/syslinux-4.02/utils/sha1pass
@@ -0,0 +1,34 @@
+#!/usr/bin/perl
+
+use bytes;
+use Digest::SHA1;
+use MIME::Base64;
+
+sub random_bytes($) {
+    my($n) = @_;
+    my($v, $i);
+
+    if ( open(RANDOM, '<', '/dev/random') ||
+	 open(RANDOM, '<', '/dev/urandom') ) {
+	read(RANDOM, $v, $n);
+    } else {
+	# No real RNG available...
+	srand($$ ^ time);
+	$v = '';
+	for ( $i = 0 ; $i < $n ; $i++ ) {
+	    $v .= ord(int(rand() * 256));
+	}
+    }
+
+    return $v;
+}
+
+
+($pass, $salt) = @ARGV;
+
+unless (defined($salt)) {
+    $salt = MIME::Base64::encode(random_bytes(6), '');
+}
+$pass = Digest::SHA1::sha1_base64($salt, $pass);
+
+print '$4$', $salt, '$', $pass, "\$\n";
diff --git a/contrib/syslinux-4.02/utils/syslinux2ansi b/contrib/syslinux-4.02/utils/syslinux2ansi
new file mode 100755
index 0000000..085f6c9
--- /dev/null
+++ b/contrib/syslinux-4.02/utils/syslinux2ansi
@@ -0,0 +1,53 @@
+#!/usr/bin/perl
+#
+# Perl script to convert a Syslinux-format screen to PC-ANSI
+# to display in a color xterm or on the Linux console
+#
+
+@ansicol = (0,4,2,6,1,5,3,7);
+
+$getting_file = 0;
+$enable = 1;
+
+while ( read(STDIN, $ch, 1) > 0 ) {
+    if ( $ch eq "\x1A" ) {	# <SUB> <Ctrl-Z> EOF
+	last;
+    } elsif ( $ch eq "\x0C" ) {	# <FF>  <Ctrl-L> Clear screen
+	print "\x1b[2J" if ( $enable && !$getting_file );
+    } elsif ( $ch eq "\x0F" ) {	# <SI>  <Ctrl-O> Attribute change
+	if ( !$getting_file ) {
+	    if ( read(STDIN, $attr, 2) == 2 ) {
+		$attr = hex $attr;
+		if ( $enable ) {
+		    print "\x1b[0;";
+		    if ( $attr & 0x80 ) {
+			print "5;";
+			$attr &= ~0x80;
+		    }
+		    if ( $attr & 0x08 ) {
+			print "1;";
+			$attr &= ~0x08;
+		    }
+		    printf "%d;%dm",
+		    $ansicol[$attr >> 4] + 40, $ansicol[$attr & 7] + 30;
+		}
+	    }
+	}
+    } elsif ( $ch eq "\x18" ) {	# <CAN> <Ctrl-X> Display image
+	# We can't display an image; pretend to be a text screen
+	# Ignore all input until end of line
+	$getting_file = 1;
+    } elsif ( (ord($ch) & ~07) == 0x10 ) { # Mode controls
+	$enable = (ord($ch) & 0x01); # Emulate the text screen
+    } elsif ( $ch eq "\x0D" ) {	# <CR>  <Ctrl-M> Carriage return
+	# Ignore
+    } elsif ( $ch eq "\x0A" ) { # <LF>  <Ctrl-J> Line feed
+	if ( $getting_file ) {
+	    $getting_file = 0;
+	} else {
+	    print $ch if ( $enable );
+	}
+    } else {
+	print $ch if ( $enable && !$getting_file );
+    }
+}