text: /*
   * MS-DOS partition parsing code
   *
   * Copyright (C) 2009 Karel Zak <kzak@redhat.com>
   *
   * This file may be redistributed under the terms of the
   * GNU Lesser General Public License.
   *
   * Inspired by fdisk, partx, Linux kernel and libparted.
   */
  #include <stdio.h>
  #include <string.h>
  #include <stdlib.h>
  #include <stdint.h>
  
  #include "partitions.h"
  #include "aix.h"
  
  /* see superblocks/vfat.c */
  extern int blkid_probe_is_vfat(blkid_probe pr);
  
  static const struct dos_subtypes {
  	unsigned char type;
  	const struct blkid_idinfo *id;
  } dos_nested[] = {
  	{ MBR_FREEBSD_PARTITION, &bsd_pt_idinfo },
  	{ MBR_NETBSD_PARTITION, &bsd_pt_idinfo },
  	{ MBR_OPENBSD_PARTITION, &bsd_pt_idinfo },
  	{ MBR_UNIXWARE_PARTITION, &unixware_pt_idinfo },
  	{ MBR_SOLARIS_X86_PARTITION, &solaris_x86_pt_idinfo },
  	{ MBR_MINIX_PARTITION, &minix_pt_idinfo }
  };
  
  static inline int is_extended(struct dos_partition *p)
  {
  	return (p->sys_ind == MBR_DOS_EXTENDED_PARTITION ||
  		p->sys_ind == MBR_W95_EXTENDED_PARTITION ||
  		p->sys_ind == MBR_LINUX_EXTENDED_PARTITION);
  }
  
  static int parse_dos_extended(blkid_probe pr, blkid_parttable tab,
  		uint32_t ex_start, uint32_t ex_size, int ssf)
  {
  	blkid_partlist ls = blkid_probe_get_partlist(pr);
  	uint32_t cur_start = ex_start, cur_size = ex_size;
  	unsigned char *data;
  	int ct_nodata = 0;	/* count ext.partitions without data partitions */
  	int i;
  
  	while (1) {
  		struct dos_partition *p, *p0;
  		uint32_t start, size;
  
  		if (++ct_nodata > 100)
  			return BLKID_PROBE_OK;
  		data = blkid_probe_get_sector(pr, cur_start);
  		if (!data) {
  			if (errno)
  				return -errno;
  			goto leave;	/* malformed partition? */
  		}
  
  		if (!mbr_is_valid_magic(data))
  			goto leave;
  
  		p0 = mbr_get_partition(data, 0);
  
  		/* Usually, the first entry is the real data partition,
  		 * the 2nd entry is the next extended partition, or empty,
  		 * and the 3rd and 4th entries are unused.
  		 * However, DRDOS sometimes has the extended partition as
  		 * the first entry (when the data partition is empty),
  		 * and OS/2 seems to use all four entries.
  		 * -- Linux kernel fs/partitions/dos.c
  		 *
  		 * See also http://en.wikipedia.org/wiki/Extended_boot_record
  		 */
  
  		/* Parse data partition */
  		for (p = p0, i = 0; i < 4; i++, p++) {
  			uint32_t abs_start;
  			blkid_partition par;
  
  			/* the start is relative to the parental ext.partition */
  			start = dos_partition_get_start(p) * ssf;
  			size = dos_partition_get_size(p) * ssf;
  			abs_start = cur_start + start;	/* absolute start */
  
  			if (!size || is_extended(p))
  				continue;
  			if (i >= 2) {
  				/* extra checks to detect real data on
  				 * 3rd and 4th entries */
  				if (start + size > cur_size)
  					continue;
  				if (abs_start < ex_start)
  					continue;
  				if (abs_start + size > ex_start + ex_size)
  					continue;
  			}
  
  			par = blkid_partlist_add_partition(ls, tab, abs_start, size);
  			if (!par)
  				return -ENOMEM;
  
  			blkid_partition_set_type(par, p->sys_ind);
  			blkid_partition_set_flags(par, p->boot_ind);
  			blkid_partition_gen_uuid(par);
  			ct_nodata = 0;
  		}
  		/* The first nested ext.partition should be a link to the next
  		 * logical partition. Everything other (recursive ext.partitions)
  		 * is junk.
  		 */
  		for (p = p0, i = 0; i < 4; i++, p++) {
  			start = dos_partition_get_start(p) * ssf;
  			size = dos_partition_get_size(p) * ssf;
  
  			if (size && is_extended(p))
  				break;
  		}
  		if (i == 4)
  			goto leave;
  
  		cur_start = ex_start + start;
  		cur_size = size;
  	}
  leave:
  	return BLKID_PROBE_OK;
  }
  
  static int probe_dos_pt(blkid_probe pr,
  		const struct blkid_idmag *mag __attribute__((__unused__)))
  {
  	int i;
  	int ssf;
  	blkid_parttable tab = NULL;
  	blkid_partlist ls;
  	struct dos_partition *p0, *p;
  	unsigned char *data;
  	uint32_t start, size, id;
  	char idstr[37];
  
  
  	data = blkid_probe_get_sector(pr, 0);
  	if (!data) {
  		if (errno)
  			return -errno;
  		goto nothing;
  	}
  
  	/* ignore disks with AIX magic number -- for more details see aix.c */
  	if (memcmp(data, BLKID_AIX_MAGIC_STRING, BLKID_AIX_MAGIC_STRLEN) == 0)
  		goto nothing;
  
  	p0 = mbr_get_partition(data, 0);
  
  	/*
  	 * Reject PT where boot indicator is not 0 or 0x80.
  	 */
  	for (p = p0, i = 0; i < 4; i++, p++)
  		if (p->boot_ind != 0 && p->boot_ind != 0x80) {
  			DBG(LOWPROBE, ul_debug("missing boot indicator -- ignore"));
  			goto nothing;
  		}
  
  	/*
  	 * GPT uses valid MBR
  	 */
  	for (p = p0, i = 0; i < 4; i++, p++) {
  		if (p->sys_ind == MBR_GPT_PARTITION) {
  			DBG(LOWPROBE, ul_debug("probably GPT -- ignore"));
  			goto nothing;
  		}
  	}
  
  	/*
  	 * Now that the 55aa signature is present, this is probably
  	 * either the boot sector of a FAT filesystem or a DOS-type
  	 * partition table.
  	 */
  	if (blkid_probe_is_vfat(pr) == 1) {
  		DBG(LOWPROBE, ul_debug("probably FAT -- ignore"));
  		goto nothing;
  	}
  
  	blkid_probe_use_wiper(pr, MBR_PT_OFFSET, 512 - MBR_PT_OFFSET);
  
  	id = mbr_get_id(data);
  	if (id)
  		snprintf(idstr, sizeof(idstr), "%08x", id);
  
  	/*
  	 * Well, all checks pass, it's MS-DOS partiton table
  	 */
  	if (blkid_partitions_need_typeonly(pr)) {
  		/* Non-binary interface -- caller does not ask for details
  		 * about partitions, just set generic varibles only. */
  		if (id)
  			blkid_partitions_strcpy_ptuuid(pr, idstr);
  		return 0;
  	}
  
  	ls = blkid_probe_get_partlist(pr);
  	if (!ls)
  		goto nothing;
  
  	/* sector size factor (the start and size are in the real sectors, but
  	 * we need to convert all sizes to 512 logical sectors
  	 */
  	ssf = blkid_probe_get_sectorsize(pr) / 512;
  
  	/* allocate a new partition table */
  	tab = blkid_partlist_new_parttable(ls, "dos", MBR_PT_OFFSET);
  	if (!tab)
  		return -ENOMEM;
  
  	if (id)
  		blkid_parttable_set_id(tab, (unsigned char *) idstr);
  
  	/* Parse primary partitions */
  	for (p = p0, i = 0; i < 4; i++, p++) {
  		blkid_partition par;
  
  		start = dos_partition_get_start(p) * ssf;
  		size = dos_partition_get_size(p) * ssf;
  
  		if (!size) {
  			/* Linux kernel ignores empty partitions, but partno for
  			 * the empty primary partitions is not reused */
  			blkid_partlist_increment_partno(ls);
  			continue;
  		}
  		par = blkid_partlist_add_partition(ls, tab, start, size);
  		if (!par)
  			return -ENOMEM;
  
  		blkid_partition_set_type(par, p->sys_ind);
  		blkid_partition_set_flags(par, p->boot_ind);
  		blkid_partition_gen_uuid(par);
  	}
  
  	/* Linux uses partition numbers greater than 4
  	 * for all logical partition and all nested partition tables (bsd, ..)
  	 */
  	blkid_partlist_set_partno(ls, 5);
  
  	/* Parse logical partitions */
  	for (p = p0, i = 0; i < 4; i++, p++) {
  		start = dos_partition_get_start(p) * ssf;
  		size = dos_partition_get_size(p) * ssf;
  
  		if (!size)
  			continue;
  		if (is_extended(p) &&
  		    parse_dos_extended(pr, tab, start, size, ssf) == -1)
  			goto nothing;
  	}
  
  	/* Parse subtypes (nested partitions) on large disks */
  	if (!blkid_probe_is_tiny(pr)) {
  		for (p = p0, i = 0; i < 4; i++, p++) {
  			size_t n;
  			int rc;
  
  			if (!dos_partition_get_size(p) || is_extended(p))
  				continue;
  
  			for (n = 0; n < ARRAY_SIZE(dos_nested); n++) {
  				if (dos_nested[n].type != p->sys_ind)
  					continue;
  
  				rc = blkid_partitions_do_subprobe(pr,
  						blkid_partlist_get_partition(ls, i),
  						dos_nested[n].id);
  				if (rc < 0)
  					return rc;
  				break;
  			}
  		}
  	}
  	return BLKID_PROBE_OK;
  
  nothing:
  	return BLKID_PROBE_NONE;
  }
  
  
  const struct blkid_idinfo dos_pt_idinfo =
  {
  	.name		= "dos",
  	.probefunc	= probe_dos_pt,
  	.magics		=
  	{
  		/* DOS master boot sector:
  		 *
  		 *     0 | Code Area
  		 *   440 | Optional Disk signature
  		 *   446 | Partition table
  		 *   510 | 0x55
  		 *   511 | 0xAA
  		 */
  		{ .magic = "\x55\xAA", .len = 2, .sboff = 510 },
  		{ NULL }
  	}
  };
  
  