www.pudn.com > minix.instalation.cd-rom-2.0.rar > HDSTRUCT.H

/*  
	FIPS - the First nondestructive Interactive Partition Splitting program  
  
	Module hdstruct.h  
  
	RCS - Header:  
	$Header: c:/daten/fips/source/main/RCS/hdstruct.h 1.4 1995/01/19 00:01:26 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"  
  
  
/* ----------------------------------------------------------------------- */  
/* Class root_sector - 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 root_sector:public sector  
{  
	physical_drive *drive;  
public:  
// constructors and operators  
  
	root_sector (physical_drive *drive) { root_sector::drive = drive; }  
	root_sector (root_sector &rs);  
	void operator= (root_sector &rs);  
  
  
// functions  
  
	int read (void) { return drive->read_sector (this, 0); }  
	int write (void) { return drive->write_sector (this, 0); }  
};  
  
  
/* ----------------------------------------------------------------------- */  
/* 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 (boot_sector)  
	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 root_sector, put() writes the   */  
/* data back into the root_sector buffer                                    */  
/* ----------------------------------------------------------------------- */  
  
struct partition_table  
{  
	partition_info partition_info[4];  
	void get (root_sector *root_sector);  
	void put (root_sector *root_sector);  
};  
  
  
/* ----------------------------------------------------------------------- */  
/* Harddrive Class, derived from physical_drive                            */  
/* Represents one physical harddrive. Must be initialized with the drive   */  
/* number (0x80 for 1st HDD). Contains the root_sector and partition table. */  
/* ----------------------------------------------------------------------- */  
  
class harddrive:public physical_drive  
{  
	partition_table pr_partition_table;  
  
public:  
// constructors, destructors, operators  
  
	harddrive (int number):physical_drive (number)  
	{  
		root_sector = new class root_sector (this);  
	}  
	harddrive (harddrive &hd):physical_drive (hd)  
	{  
		root_sector = new class root_sector (*(hd.root_sector));  
		partition_table () = hd.partition_table ();  
	}  
	void operator= (harddrive &hd);  
	~harddrive (void) { delete root_sector; }  
  
// public data  
  
	root_sector *root_sector;  
  
// member access functions  
  
	virtual partition_table &partition_table() { return pr_partition_table; }  
  
// functions  
  
	int read_root_sector (void) { return (root_sector->read ()); }  
	int write_root_sector (void) { return (root_sector->write ()); }  
  
	void get_partition_table (void);	// extract pt data from root sector  
	void put_partition_table (void)		// put pt data into root sector  
	{partition_table().put (root_sector);}  
};  
  
#endif