/* ----------------------------------------------------------------------- *
 *
 *   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.
 *
 * ----------------------------------------------------------------------- */

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