aboutsummaryrefslogtreecommitdiffstats
path: root/libinstaller/syslxmod.c
diff options
context:
space:
mode:
Diffstat (limited to 'libinstaller/syslxmod.c')
-rw-r--r--libinstaller/syslxmod.c287
1 files changed, 287 insertions, 0 deletions
diff --git a/libinstaller/syslxmod.c b/libinstaller/syslxmod.c
new file mode 100644
index 00000000..425756f3
--- /dev/null
+++ b/libinstaller/syslxmod.c
@@ -0,0 +1,287 @@
+/* ----------------------------------------------------------------------- *
+ *
+ * Copyright 1998-2007 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.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * syslxmod.c - Code to provide a SYSLINUX code set to an installer.
+ */
+
+#define _XOPEN_SOURCE 500 /* Required on glibc 2.x */
+#define _BSD_SOURCE
+#include <stdio.h>
+#include <inttypes.h>
+#include <string.h>
+#include <stddef.h>
+
+#include "syslinux.h"
+
+#define LDLINUX_MAGIC 0x3eb202fe
+
+enum bs_offsets {
+ bsJump = 0x00,
+ bsOemName = 0x03,
+ bsBytesPerSec = 0x0b,
+ bsSecPerClust = 0x0d,
+ bsResSectors = 0x0e,
+ bsFATs = 0x10,
+ bsRootDirEnts = 0x11,
+ bsSectors = 0x13,
+ bsMedia = 0x15,
+ bsFATsecs = 0x16,
+ bsSecPerTrack = 0x18,
+ bsHeads = 0x1a,
+ bsHiddenSecs = 0x1c,
+ bsHugeSectors = 0x20,
+
+ /* FAT12/16 only */
+ bs16DriveNumber = 0x24,
+ bs16Reserved1 = 0x25,
+ bs16BootSignature = 0x26,
+ bs16VolumeID = 0x27,
+ bs16VolumeLabel = 0x2b,
+ bs16FileSysType = 0x36,
+ bs16Code = 0x3e,
+
+ /* FAT32 only */
+ bs32FATSz32 = 36,
+ bs32ExtFlags = 40,
+ bs32FSVer = 42,
+ bs32RootClus = 44,
+ bs32FSInfo = 48,
+ bs32BkBootSec = 50,
+ bs32Reserved = 52,
+ bs32DriveNumber = 64,
+ bs32Reserved1 = 65,
+ bs32BootSignature = 66,
+ bs32VolumeID = 67,
+ bs32VolumeLabel = 71,
+ bs32FileSysType = 82,
+ bs32Code = 90,
+
+ bsSignature = 0x1fe
+};
+
+#define bsHead bsJump
+#define bsHeadLen (bsOemName-bsHead)
+#define bsCode bs32Code /* The common safe choice */
+#define bsCodeLen (bsSignature-bs32Code)
+
+/*
+ * Access functions for littleendian numbers, possibly misaligned.
+ */
+static inline uint8_t get_8(const unsigned char *p)
+{
+ return *(const uint8_t *)p;
+}
+
+static inline uint16_t get_16(const unsigned char *p)
+{
+#if defined(__i386__) || defined(__x86_64__)
+ /* Littleendian and unaligned-capable */
+ return *(const uint16_t *)p;
+#else
+ return (uint16_t)p[0] + ((uint16_t)p[1] << 8);
+#endif
+}
+
+static inline uint32_t get_32(const unsigned char *p)
+{
+#if defined(__i386__) || defined(__x86_64__)
+ /* Littleendian and unaligned-capable */
+ return *(const uint32_t *)p;
+#else
+ return (uint32_t)p[0] + ((uint32_t)p[1] << 8) +
+ ((uint32_t)p[2] << 16) + ((uint32_t)p[3] << 24);
+#endif
+}
+
+static inline void set_16(unsigned char *p, uint16_t v)
+{
+#if defined(__i386__) || defined(__x86_64__)
+ /* Littleendian and unaligned-capable */
+ *(uint16_t *)p = v;
+#else
+ p[0] = (v & 0xff);
+ p[1] = ((v >> 8) & 0xff);
+#endif
+}
+
+static inline void set_32(unsigned char *p, uint32_t v)
+{
+#if defined(__i386__) || defined(__x86_64__)
+ /* Littleendian and unaligned-capable */
+ *(uint32_t *)p = v;
+#else
+ p[0] = (v & 0xff);
+ p[1] = ((v >> 8) & 0xff);
+ p[2] = ((v >> 16) & 0xff);
+ p[3] = ((v >> 24) & 0xff);
+#endif
+}
+
+void syslinux_make_bootsect(void *bs)
+{
+ unsigned char *bootsect = bs;
+
+ memcpy(bootsect+bsHead, syslinux_bootsect+bsHead, bsHeadLen);
+ memcpy(bootsect+bsCode, syslinux_bootsect+bsCode, bsCodeLen);
+}
+
+/*
+ * Check to see that what we got was indeed an MS-DOS boot sector/superblock;
+ * Return NULL if OK and otherwise an error message;
+ */
+const char *syslinux_check_bootsect(const void *bs)
+{
+ int veryold;
+ int sectorsize;
+ long long sectors, fatsectors, dsectors;
+ long long clusters;
+ int rootdirents, clustersize;
+ const unsigned char *sectbuf = bs;
+
+ veryold = 0;
+
+ /* Must be 0xF0 or 0xF8..0xFF */
+ if ( get_8(sectbuf+bsMedia) != 0xF0 &&
+ get_8(sectbuf+bsMedia) < 0xF8 )
+ goto invalid;
+
+ sectorsize = get_16(sectbuf+bsBytesPerSec);
+ if ( sectorsize == 512 )
+ ; /* ok */
+ else if ( sectorsize == 1024 || sectorsize == 2048 || sectorsize == 4096 )
+ return "only 512-byte sectors are supported";
+ else
+ goto invalid;
+
+ clustersize = get_8(sectbuf+bsSecPerClust);
+ if ( clustersize == 0 || (clustersize & (clustersize-1)) )
+ goto invalid; /* Must be nonzero and a power of 2 */
+
+ sectors = get_16(sectbuf+bsSectors);
+ sectors = sectors ? sectors : get_32(sectbuf+bsHugeSectors);
+
+ dsectors = sectors - get_16(sectbuf+bsResSectors);
+
+ fatsectors = get_16(sectbuf+bsFATsecs);
+ fatsectors = fatsectors ? fatsectors : get_32(sectbuf+bs32FATSz32);
+ fatsectors *= get_8(sectbuf+bsFATs);
+ dsectors -= fatsectors;
+
+ rootdirents = get_16(sectbuf+bsRootDirEnts);
+ dsectors -= (rootdirents+sectorsize/32-1)/sectorsize;
+
+ if ( dsectors < 0 || fatsectors == 0 )
+ goto invalid;
+
+ clusters = dsectors/clustersize;
+
+ if ( clusters < 0xFFF5 ) {
+ /* FAT12 or FAT16 */
+
+ if ( !get_16(sectbuf+bsFATsecs) )
+ goto invalid;
+
+ if ( get_8(sectbuf+bs16BootSignature) == 0x29 ) {
+ if ( !memcmp(sectbuf+bs16FileSysType, "FAT12 ", 8) ) {
+ if ( clusters >= 0xFF5 )
+ return "more than 4084 clusters but claims FAT12";
+ } else if ( !memcmp(sectbuf+bs16FileSysType, "FAT16 ", 8) ) {
+ if ( clusters < 0xFF5 )
+ return "less than 4084 clusters but claims FAT16";
+ } else if ( memcmp(sectbuf+bs16FileSysType, "FAT ", 8) ) {
+ static char fserr[] = "filesystem type \"????????\" not supported";
+ memcpy(fserr+17, sectbuf+bs16FileSysType, 8);
+ return fserr;
+ }
+ }
+ } else if ( clusters < 0x0FFFFFF5 ) {
+ /* FAT32 */
+ /* Moving the FileSysType and BootSignature was a lovely stroke of M$ idiocy */
+ if ( get_8(sectbuf+bs32BootSignature) != 0x29 ||
+ memcmp(sectbuf+bs32FileSysType, "FAT32 ", 8) )
+ goto invalid;
+ } else {
+ goto invalid;
+ }
+
+ return NULL;
+
+ invalid:
+ return "this doesn't look like a valid FAT filesystem";
+}
+
+/*
+ * This patches the boot sector and the first sector of ldlinux.sys
+ * based on an ldlinux.sys sector map passed in. Typically this is
+ * handled by writing ldlinux.sys, mapping it, and then overwrite it
+ * with the patched version. If this isn't safe to do because of
+ * an OS which does block reallocation, then overwrite it with
+ * direct access since the location is known.
+ *
+ * Return 0 if successful, otherwise -1.
+ */
+int syslinux_patch(const uint32_t *sectors, int nsectors,
+ int stupid, int raid_mode)
+{
+ unsigned char *patcharea, *p;
+ int nsect = (syslinux_ldlinux_len+511) >> 9;
+ uint32_t csum;
+ int i, dw;
+
+ if ( nsectors < nsect )
+ return -1;
+
+ /* Patch in options, as appropriate */
+ if (stupid) {
+ /* Access only one sector at a time */
+ set_16(syslinux_bootsect+0x1FC, 1);
+ }
+
+ i = get_16(syslinux_bootsect+0x1FE);
+ if (raid_mode)
+ set_16(syslinux_bootsect+i, 0x18CD); /* INT 18h */
+ set_16(syslinux_bootsect+0x1FE, 0xAA55);
+
+ /* First sector need pointer in boot sector */
+ set_32(syslinux_bootsect+0x1F8, *sectors++);
+ nsect--;
+
+ /* Search for LDLINUX_MAGIC to find the patch area */
+ for ( p = syslinux_ldlinux ; get_32(p) != LDLINUX_MAGIC ; p += 4 );
+ patcharea = p+8;
+
+ /* Set up the totals */
+ dw = syslinux_ldlinux_len >> 2; /* COMPLETE dwords! */
+ set_16(patcharea, dw);
+ set_16(patcharea+2, nsect); /* Does not include the first sector! */
+
+ /* Set the sector pointers */
+ p = patcharea+8;
+
+ memset(p, 0, 64*4);
+ while ( nsect-- ) {
+ set_32(p, *sectors++);
+ p += 4;
+ }
+
+ /* Now produce a checksum */
+ set_32(patcharea+4, 0);
+
+ csum = LDLINUX_MAGIC;
+ for ( i = 0, p = syslinux_ldlinux ; i < dw ; i++, p += 4 )
+ csum -= get_32(p); /* Negative checksum */
+
+ set_32(patcharea+4, csum);
+
+ return 0;
+}