/*
	FIPS - the First nondestructive Interactive Partition Splitting program

	Module hdstruct.h

	RCS - Header:
	$Header: c:/daten/fips/source/main/RCS/hdstruct.h 1.1 1994/05/25 22:20:25 schaefer Exp schaefer $

	Copyright (C) 1993 Arno Schaefer

	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; either version 2 of the License, or
	(at your option) any later version.

	This program is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
	GNU General Public License for more details.

	You should have received a copy of the GNU General Public License
	along with this program; if not, write to the Free Software
	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.


	Report problems and direct all questions to:

	schaefer@rbg.informatik.th-darmstadt.de
*/

#ifndef HDSTRUCT_H
#define HDSTRUCT_H

#include "types.h"
#include "disk_io.h"
#include "logdr_st.h"

/* ----------------------------------------------------------------------- */
/* Class rootsector - derived from structure sector                        */
/* Must be initialized with a pointer to a physical_drive object           */
/* Read() and Write() read/write sector 0 of physical drive                */
/* ----------------------------------------------------------------------- */

class rootsector:public sector
{
	physical_drive *drive;
public:
	int read (void) { return sector::read (drive,0); }
	int write (void) { return sector::write (drive,0); }

	rootsector (physical_drive *drive) { rootsector::drive = drive; }
	rootsector (rootsector &rs);
	void operator= (rootsector &rs);
};

/* ----------------------------------------------------------------------- */
/* Partition Info Structure                                                */
/* Each entry in the partition table contains this information             */
/* ----------------------------------------------------------------------- */

struct partition_info
{
	byte bootable;                  // 80h or 0
	byte start_head;                // location of first sector (bootsector)
	word start_cylinder;
	byte start_sector;
	byte system;			// 1 = 12-bit FAT
					// 4 = 16-bit FAT & 16-bit sector number
					// 6 = 16-bit FAT & 32-bit sector number (BIGDOS)
	byte end_head;                  // location of last sector
	word end_cylinder;
	byte end_sector;
	dword start_sector_abs;         // = start_cylinder * heads * sectors
					// + start_head * sectors + start_sector - 1
	dword no_of_sectors_abs;        // = end_cylinder * heads * sectors + end_head * sectors
					// + end_sector - start_sector_abs
};

/* ----------------------------------------------------------------------- */
/* Partition Table Structure                                               */
/* The partition table consists of 4 entries for the 4 possible partitions */
/* Get() reads the partition table from the rootsector, put() writes the   */
/* data back into the rootsector buffer                                    */
/* ----------------------------------------------------------------------- */

struct partition_table
{
	partition_info partition_info[4];
	void get (rootsector *rootsector);
	void put (rootsector *rootsector);
};

/* ----------------------------------------------------------------------- */
/* Harddrive Class, derived from physical_drive                            */
/* Represents one physical harddrive. Must be initialized with the drive   */
/* number (0x80 for 1st HDD). Contains the rootsector and partition table. */
/* ----------------------------------------------------------------------- */

class harddrive:public physical_drive
{
	partition_table pr_partition_table;
public:
	rootsector *rootsector;
	virtual partition_table &partition_table() { return pr_partition_table; }

	harddrive (int number):physical_drive (number)
	{
		rootsector = new class rootsector (this);
	}
	harddrive (harddrive &hd):physical_drive (hd)
	{
		rootsector = new class rootsector (*(hd.rootsector));
		partition_table () = hd.partition_table();
	}
	void operator= (harddrive &hd);
	~harddrive (void) { delete rootsector; }
};

/* ----------------------------------------------------------------------- */
/* Raw Partition Class                                                     */
/* Represents one partition from the partition table (may be non-DOS)      */
/* Initialization with the pointer to the harddrive object and the         */
/* partition number (0-3)                                                  */
/* ----------------------------------------------------------------------- */

class raw_partition
{
public:
	int number;
	physical_drive *drive;
	partition_info *partition_info;

	raw_partition (class harddrive *drive,int number)
	{
		raw_partition::number = number;
		raw_partition::drive = drive;
		partition_info = &(drive->partition_table().partition_info[number]);
	}
};
	
/* ----------------------------------------------------------------------- */
/* Partition Class, derived from logical_drive and raw_partition           */
/* Represents one primary DOS partition. Read_sector() and write_sector()  */
/* are instances of the virtual functions in the logical_drive class       */
/* ----------------------------------------------------------------------- */

class partition:public logical_drive,public raw_partition
{
public:
	int read_sector (dword number,sector *sector)
	{
		return (sector->read (drive,partition_info->start_sector_abs + number));
	}
	int write_sector (dword number,sector *sector)
	{
		return (sector->write (drive,partition_info->start_sector_abs + number));
	}

	partition (class harddrive *drive,int number):raw_partition(drive,number)
	{
		bootsector = new class bootsector (this);
	}
	~partition (void) { delete bootsector; }
};

#endif