/* dump-boot-blocks.c

   Copyright 2011 DJ Delorie <dj@redhat.com>

   This file is distributed under the terms of the GNU General Public
   License, either version 2 or, at your choice, some lter version.

   The purpose of this program is to scan an SD card and check for
   various things that are known to prevent an OMAP processor from
   booting off it.  Just pass the block device name on the command
   line (you'll probably have to be root to do that).

*/

#include <sys/types.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <stdint.h>

#ifndef O_BINARY
#define O_BINARY 0
#endif

typedef uint8_t byte;

static int fd;

struct {
  int type;
  int active;
  uint32_t lba;
  uint32_t num_sectors;
} partitions[4];

struct {
  int part_type;
  char *developer;
  char *description;
} part_types[] = {
  { 0x00 , "IBM ", "Empty partition" },
  { 0x01 , "Microsoft ", "FAT 12" },
  { 0x02 , "Microsoft & SCO ", "XENIX root" },
  { 0x03 , "Microsoft & SCO ", "XENIX usr" },
  { 0x04 , "Microsoft ", "FAT 16 with a size < 32 MiB" },
  { 0x05 , "IBM ", "Extended partition" },
  { 0x06 , "Compaq ", "FAT 16 with size ≥32 MiB" },
  { 0x07 , "Microsoft ", "HPFS or NTFS" },
  { 0x08 , "IBM ", "AIX" },
  { 0x09 , "IBM ", "AIX bootable" },
  { 0x0A , "Microsoft & IBM ", "OS/2 Boot Manager" },
  { 0x0B , "Microsoft ", "Windows 95 FAT 32" },
  { 0x0C , "Microsoft ", "Windows 95 FAT 32 with LBA" },
  { 0x0E , "Microsoft ", "Windows 95 FAT 16 with LBA" },
  { 0x0F , "Microsoft ", "Extended partition with LBA" },
  { 0x10 , "AIM alliance & Taligent ", "OPUS" },
  { 0x11 , "Microsoft ", "Hidden FAT 12" },
  { 0x12 , "Compaq ", "Compaq diagnostics partition" },
  { 0x14 , "Microsoft ", "Hidden FAT 16" },
  { 0x17 , "Microsoft ", "Hidden HPFS or hidden NTFS" },
  { 0x1B , "Microsoft ", "Hidden FAT 32" },
  { 0x1C , "Microsoft ", "Hidden FAT 32 with LBA" },
  { 0x1D , "Microsoft ", "Hidden FAT 16 with LBA" },
  { 0x78 , "Geurt Vos ", "XOSL bootloader filesystem" },
  { 0x82 , "GNU/Linux ", "Linux swap space" },
  { 0x83 , "GNU/Linux ", "Any native Linux file system" },
  { 0x85 , "GNU/Linux ", "Linux extended" },
  { 0x86 , "Microsoft ", "Legacy FT FAT 16" },
  { 0x87 , "Microsoft ", "Legacy FT NTFS" },
  { 0x88 , "GNU/Linux ", "Linux plaintext" },
  { 0x89 , "GNU/Linux ", "Linux LVM" },
  { 0x8B , "Microsoft ", "Legacy FT FAT 32" },
  { 0x8C , "Microsoft ", "Legacy FT FAT 32 with LBA" },
  { 0x8E , " ?? ", "Linux LVM" },
  { 0xA5 , " ?? ", "BSD slice" },
  { 0xDA , " ?? ", "Raw data (no File System)" },
  { 0xDF , "TeraByte Unlimited ", "BootIt" },
  { 0xEB , "Be, Inc. ", "BFS (BeOS or Haiku)" },
  { 0xEF , "Intel ", "EFI" },
  { 0xFB , "VMware ", "VMware VMFS" },
  { 0xFC , "VMware ", "VMware VMKCORE" },
  { 0xFD , "GNU/Linux ", "Linux RAID auto" }
};
#define NPARTS (sizeof(part_types)/sizeof(part_types[0]))

uint8_t mbr[512];
uint8_t dosbb[512];

void
decode_chs (uint8_t *chs, int *c, int *h, int *s)
{
  *h = chs[0];
  *s = chs[1] & 0x3f;
  *c = (((int)chs[1] & 0xc0) << 2) | chs[2];
}

uint32_t
get4 (uint8_t *e)
{
  return (uint32_t)e[0] | ((uint32_t)e[1] << 8) | ((uint32_t)e[2] << 16) | ((uint32_t)e[3] << 24);
}

uint32_t
get2 (uint8_t *e)
{
  return (uint32_t)e[0] | ((uint32_t)e[1] << 8);
}

void
mbr_partition (int pnum, uint8_t *entry)
{
  int active;
  int sc, sh, ss;
  int partition_type;
  int ec, eh, es;
  uint32_t start_lba;
  uint32_t num_sectors;
  int i;
  char *pname = "unknown";

  active = entry[0];
  decode_chs (entry+1, &sc, &sh, &ss);
  partition_type = entry[4];
  decode_chs (entry+5, &ec, &eh, &es);
  start_lba = get4 (entry+8);
  num_sectors = get4 (entry+12);

  for (i=0; i<NPARTS; i++)
    if (part_types[i].part_type == partition_type)
      pname = part_types[i].description;

  partitions[pnum].type = partition_type;
  partitions[pnum].active = active;
  partitions[pnum].lba = start_lba;
  partitions[pnum].num_sectors = num_sectors;

  printf("%c %4d %3d %2d - %4d %3d %2d  %02x  %13d  %13d (%5d Mb)= %s\n",
	 active & 0x80 ? '*' : ' ',
	 sc, sh, ss,
	 ec, eh, es,
	 partition_type,
	 start_lba,
	 num_sectors,
	 (int)(num_sectors * 512LL / (1024*1024)),
	 pname);
}

void
scan_fatboot (int pnum)
{
  unsigned long start = partitions[pnum].lba * 512;
  int sec;

  lseek (fd, start, SEEK_SET);
  read (fd, dosbb, 512);

  sec = get2 (dosbb+0x13);
  if (sec == 0)
    sec = get4 (dosbb+0x20);

  printf("FAT %d at %8x: \"%8.8s\"  %d bps, %d spc, %d res, %d fats, %d roots, %d spf, %d spt, %d heads %d sec\n",
	 pnum, start, dosbb + 3,
	 get2(dosbb+0x0b), dosbb[0x0d],
	 get2(dosbb+0x0e), dosbb[0x10], get2(dosbb+0x11),
	 get2(dosbb+0x16), get2(dosbb+0x18), get2(dosbb+0x1a),
	 sec
	 );
}

void
scan_fat12 (int pnum)
{
  scan_fatboot (pnum);
}

void
scan_fat16 (int pnum)
{
  scan_fatboot (pnum);
}

void
scan_fat32 (int pnum)
{
  scan_fatboot (pnum);
  printf(" - FAT32: %lu spf, %d rootc\n", get4(dosbb+0x24), get4(dosbb+0x2c));
}

/*----------------------------------------------------------------------*/

typedef struct {
  byte jump[3];
  byte oem[8];
  byte bytes_per_sector[2];
  byte sectors_per_cluster;
  byte reserved_sector_count[2];
  byte num_fats;
  byte max_root_dir_entries[2];
  byte total_sectors_w[2];
  byte media_descriptor;
  byte sectors_per_fat[2];
  byte sectors_per_track[2];
  byte heads[2];
  byte hidden_sectors[4];
  byte total_sectors_l[4];
  union {
    struct {
      byte physical_drive_number;
      byte reserved;
      byte extended_boot_signature;
      byte serial_number[4];
      byte volume_label[11];
      byte fat_system_type[8];
      byte os_code[448];
    } f16;
    struct {
      byte sectors_per_fat[4];
      byte fat_glags[2];
      byte version[2];
      byte root_directory_cluster[4];
      byte other_stuff[42];
      byte os_code[420];
    } f32;
  };
  byte sig55;
  byte sigaa;
} BootSectorType;

typedef struct {
  byte name[8];
  byte ext[3];
  byte attributes;
  byte reserved;
  byte create_time_10ms;
  byte create_time[2];
  byte create_date[2];
  byte last_access[2];
  byte ea_index[2];
  byte last_mod_time[2];
  byte last_mod_date[2];
  byte first_cluster[2];
  byte file_size[4];
} DirectoryEntryType;

void get_block (int blocknum, void *buf)
{
  int b = blocknum + partitions[0].lba;
  /* printf("get_block %d\n", (int)b); */
  lseek (fd, b * 512, SEEK_SET);
  read (fd, buf, 512);
}

#define c2w(a) ((a)[0] + (a)[1]*256L)
#define c2l(a) ((a)[0] + (a)[1]*256L + (a)[2]*65536L + (a)[3]*16777216L)

int fat_start, fat_type, fat_cache_sec = -1;
uint32_t EOC = 0;
char fat_cache[512];
BootSectorType bootsec;

static uint32_t
get_next_cluster (int idx)
{
  int bidx = idx * ((fat_type == 16) ? 2 : 4);
  int sec = bidx / 512;
  if (EOC == 0)
    {
      EOC = -1;
      EOC = get_next_cluster (1);
    }
  /* printf("cluster after %d", idx); */
  if (sec != fat_cache_sec)
    {
      get_block (fat_start + sec, fat_cache);
      fat_cache_sec = sec;
    }
  if (fat_type == 16)
    {
      idx = c2w (fat_cache + bidx % 512);
    }
  else
    {
      idx = c2l (fat_cache + bidx % 512);
    }
  if (idx == EOC)
    idx = -1;
  /* printf(" = %d 0x%x\n", idx, idx); */
  return idx;
}

void
get_cluster_block_32 (int cluster, void *vbuf)
{
  byte *buf = (byte *)vbuf;
  int i;
  int csec = (fat_start
	      + (c2l (bootsec.f32.sectors_per_fat) * bootsec.num_fats));

  csec += (cluster - 2) * bootsec.sectors_per_cluster;
  /* printf("reading cluster %d at block %d\n", cluster, csec); */
  for (i=0; i<bootsec.sectors_per_cluster; i++)
    {
      get_block (csec, buf);
      csec ++;
      buf += 512;
    }
}

int
mlo_search_32 ()
{
  byte *buf = (byte *) malloc (512 * bootsec.sectors_per_cluster);
  DirectoryEntryType *dir = (DirectoryEntryType *)buf;
  int root_cluster = c2l (bootsec.f32.root_directory_cluster);
  int nd = 512 * bootsec.sectors_per_cluster / sizeof(DirectoryEntryType);
  int i;

  while (root_cluster > 0)
    {
      /* printf("root cluster %d\n", root_cluster); */
      get_cluster_block_32 (root_cluster, buf);

      for (i=0; i<nd; i++)
	{
	  /* Check for devices, subdirectories, etc.  */
	  if (dir[i].attributes & 0xDE)
	    continue;
	  /*printf("check: \"%11.11s\"\n", dir[i].name);*/
	  if (memcmp (dir[i].name, "MLO        ", 11) == 0
	      || memcmp (dir[i].name, "mlo        ", 11) == 0)
	    {
	      return c2w (dir[i].first_cluster);
	    }
	}
      root_cluster = get_next_cluster (root_cluster);
    }
  
}

int
mlo_search_16 ()
{
  DirectoryEntryType dir[512/sizeof(DirectoryEntryType)];
  int i, mlo_cluster = -1;
  int nroot;
  int root_sector = (c2w (bootsec.reserved_sector_count)
		     + (c2w (bootsec.sectors_per_fat)
			* bootsec.num_fats));

  for (nroot=0; nroot < c2w (bootsec.max_root_dir_entries) / (512/sizeof(DirectoryEntryType)); nroot++)
    {
      get_block (root_sector, &dir);

      for (i=0; i<512/sizeof(DirectoryEntryType); i++)
	{
	  /* Check for devices, subdirectories, etc.  */
	  if (dir[i].attributes & 0xDE)
	    continue;
	  if (memcmp (dir[i].name, "MLO        ", 11) == 0
	      || memcmp (dir[i].name, "mlo        ", 11) == 0)
	    {
	      return c2w (dir[i].first_cluster);
	    }
	}
      root_sector ++;
    }
  printf("Cannot find MLO (or mlo) in first partition.\n");
  return -1;
}

void
check_mlo_first (int fat_type)
{
  int fat_size;
  int mlo_cluster;
  int next_cluster;

  get_block (0, &bootsec);

  if (fat_type == 16)
    {
      fat_start = c2w (bootsec.reserved_sector_count);
      fat_size = c2w (bootsec.sectors_per_fat);
    }
  else
    {
      fat_start = c2w (bootsec.reserved_sector_count);
      fat_size = c2l (bootsec.f32.sectors_per_fat);
    }
#if 0
  printf("fat start: %d (%d), fat size: %d (%d)\n",
	 fat_start, fat_start * 512,
	 fat_size, fat_size * 512);
#endif

  if (fat_type == 32)
    mlo_cluster = mlo_search_32 ();
  else
    mlo_cluster = mlo_search_16 ();
  if (mlo_cluster <= 0)
    return;

  while (mlo_cluster > 0)
    {
      /* printf("MLO cluster: %d\n", mlo_cluster); */
      next_cluster = get_next_cluster (mlo_cluster);
      if (next_cluster <= 0)
	break;
      if (next_cluster != mlo_cluster + 1)
	{
	  printf("MLO data is not contiguous; it's recommended that MLO be the first file\n");
	  printf("copied to the disk after you format it (mkfs)\n");
	  return;
	}
      mlo_cluster = next_cluster;
    }
}

/*----------------------------------------------------------------------*/

int
main(int argc, char **argv)
{
  int i;
  int type_ok[4];

  if (argc < 2)
    {
      fprintf (stderr, "usage: %s </dev/sdd> (or whatever)\n", argv[0]);
      exit (1);
    }

  fd = open (argv[1], O_RDONLY | O_BINARY);
  if (fd < 0)
    {
      fprintf (stderr, "Cannot open %s for reading\n", argv[1]);
      perror("The error was:");
      exit (1);
    }

  lseek (fd, 0L, SEEK_SET);
  read (fd, mbr, 512);
  /*      *    0   1  1 -    5 254 63  04             63          96327 = FAT 16 with a size < 32 MiB */
  printf("\033[32m");
  printf("     C   H  S      C   H  S\n");
  printf("B? ----------    ----------  Type    start-lba    num-sectors\n");
  printf("\033[0m");

  for (i=0; i<4; i++)
    mbr_partition (i, mbr + 446 + i * 16);

  for (i=0; i<4; i++)
    {
      type_ok[i] = 0;
      switch (partitions[i].type)
	{
	case 0x01:
	case 0x11:
	  scan_fat12 (i);
	  break;
	case 0x04:
	case 0x06:
	case 0x0e:
	case 0x14:
	case 0x1e:
	  type_ok[i] = 16;
	  scan_fat16 (i);
	  break;
	case 0x0b:
	case 0x0c:
	case 0x1b:
	case 0x1c:
	  type_ok[i] = 32;
	  scan_fat32 (i);
	  break;
	}
    }

  if (! type_ok [0])
    {
      printf ("The partition type of the first partition is not FAT16 or FAT32.\n");
    }
  else
    {
      if (partitions[0].num_sectors & 1)
	{
	  printf ("The boot (first) partition has an odd number of sectors.  You likely specified\n");
	  printf ("an even number of cylinders, try using an odd number as the first track\n");
	  printf ("is not used in the first partition.\n");
	}

      if (!partitions[0].active)
	{
	  printf ("The first partition is not marked bootable (active).\n");
	}

      if (partitions[0].lba != 63)
	{
	  printf ("The first partition does not start on sector 63.  While the boot code normally\n");
	  printf ("ignores the C/H/S information, it does seem to assume 63 sectors per track.\n");
	  printf ("If you have trouble convincing your fdisk to start on sector 63, try enabling\n");
	  printf ("DOS compatibility mode.\n");
	}

      check_mlo_first (type_ok[0]);
    }


  close (fd);
  exit (0);
}