diff options
Diffstat (limited to 'libinstaller')
| -rw-r--r-- | libinstaller/syslinux.h | 51 | ||||
| -rw-r--r-- | libinstaller/syslxmod.c | 287 |
2 files changed, 338 insertions, 0 deletions
diff --git a/libinstaller/syslinux.h b/libinstaller/syslinux.h new file mode 100644 index 00000000..dd04aadf --- /dev/null +++ b/libinstaller/syslinux.h @@ -0,0 +1,51 @@ +/* ----------------------------------------------------------------------- * + * + * Copyright 1998-2004 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. + * + * ----------------------------------------------------------------------- */ + +#ifndef SYSLINUX_H +#define SYSLINUX_H + +#include <inttypes.h> +#include "advconst.h" + +/* The standard boot sector and ldlinux image */ +extern unsigned char syslinux_bootsect[]; +extern unsigned int syslinux_bootsect_len; +extern int syslinux_bootsect_mtime; + +extern unsigned char syslinux_ldlinux[]; +extern unsigned int syslinux_ldlinux_len; +extern int syslinux_ldlinux_mtime; + +extern unsigned char syslinux_mbr[]; +extern unsigned int syslinux_mbr_len; +extern int syslinux_mbr_mtime; + +/* This takes a boot sector and merges in the syslinux fields */ +void syslinux_make_bootsect(void *); + +/* Check to see that what we got was indeed an MS-DOS boot sector/superblock */ +const char *syslinux_check_bootsect(const void *bs); + +/* This patches the boot sector and ldlinux.sys based on a sector map */ +int syslinux_patch(const uint32_t *sectors, int nsectors, + int stupid, int raid_mode); + +/* ADV information */ +#define ADV_SIZE 512 /* Total size */ +#define ADV_LEN (ADV_SIZE-3*4) /* Usable data size */ +extern unsigned char syslinux_adv[2*ADV_SIZE]; + +int syslinux_setadv(int tag, size_t size, const void *data); +void syslinux_reset_adv(unsigned char *advbuf); +int syslinux_validate_adv(unsigned char *advbuf); + +#endif 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; +} |