home *** CD-ROM | disk | FTP | other *** search
/ PC World 1999 August / PCWorld_1999-08_cd.bin / dosutils / fips20 / source / hdstruct.h < prev    next >
C/C++ Source or Header  |  1997-12-20  |  5KB  |  147 lines
  1. /*
  2.     FIPS - the First nondestructive Interactive Partition Splitting program
  3.  
  4.     Module hdstruct.h
  5.  
  6.     RCS - Header:
  7.     $Header: c:/daten/fips/source/main/RCS/hdstruct.h 1.4 1995/01/19 00:01:26 schaefer Exp schaefer $
  8.  
  9.     Copyright (C) 1993 Arno Schaefer
  10.  
  11.     This program is free software; you can redistribute it and/or modify
  12.     it under the terms of the GNU General Public License as published by
  13.     the Free Software Foundation; either version 2 of the License, or
  14.     (at your option) any later version.
  15.  
  16.     This program is distributed in the hope that it will be useful,
  17.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  18.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19.     GNU General Public License for more details.
  20.  
  21.     You should have received a copy of the GNU General Public License
  22.     along with this program; if not, write to the Free Software
  23.     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  24.  
  25.  
  26.     Report problems and direct all questions to:
  27.  
  28.     schaefer@rbg.informatik.th-darmstadt.de
  29. */
  30.  
  31. #ifndef HDSTRUCT_H
  32. #define HDSTRUCT_H
  33.  
  34. #include "types.h"
  35. #include "disk_io.h"
  36.  
  37.  
  38. /* ----------------------------------------------------------------------- */
  39. /* Class root_sector - derived from structure sector                        */
  40. /* Must be initialized with a pointer to a physical_drive object           */
  41. /* Read() and Write() read/write sector 0 of physical drive                */
  42. /* ----------------------------------------------------------------------- */
  43.  
  44. class root_sector:public sector
  45. {
  46.     physical_drive *drive;
  47. public:
  48. // constructors and operators
  49.  
  50.     root_sector (physical_drive *drive) { root_sector::drive = drive; }
  51.     root_sector (root_sector &rs);
  52.     void operator= (root_sector &rs);
  53.  
  54.  
  55. // functions
  56.  
  57.     int read (void) { return drive->read_sector (this, 0); }
  58.     int write (void) { return drive->write_sector (this, 0); }
  59. };
  60.  
  61.  
  62. /* ----------------------------------------------------------------------- */
  63. /* Partition Info Structure                                                */
  64. /* Each entry in the partition table contains this information             */
  65. /* ----------------------------------------------------------------------- */
  66.  
  67. struct partition_info
  68. {
  69.     byte bootable;                  // 80h or 0
  70.     byte start_head;                // location of first sector (boot_sector)
  71.     word start_cylinder;
  72.     byte start_sector;
  73.     byte system;            // 1 = 12-bit FAT
  74.                     // 4 = 16-bit FAT & 16-bit sector number
  75.                     // 6 = 16-bit FAT & 32-bit sector number (BIGDOS)
  76.                     // B = 32-bit FAT & 32-bit sector number
  77.                     // C = 32-bit FAT & 32-bit sector number
  78.     byte end_head;                  // location of last sector
  79.     word end_cylinder;
  80.     byte end_sector;
  81.     dword start_sector_abs;         // = start_cylinder * heads * sectors
  82.                     // + start_head * sectors + start_sector - 1
  83.     dword no_of_sectors_abs;        // = end_cylinder * heads * sectors + end_head * sectors
  84.                     // + end_sector - start_sector_abs
  85. };
  86.  
  87.  
  88. /* ----------------------------------------------------------------------- */
  89. /* Partition Table Structure                                               */
  90. /* The partition table consists of 4 entries for the 4 possible partitions */
  91. /* Get() reads the partition table from the root_sector, put() writes the   */
  92. /* data back into the root_sector buffer                                    */
  93. /* ----------------------------------------------------------------------- */
  94.  
  95. struct partition_table
  96. {
  97.     partition_info partition_info[4];
  98.     void get (root_sector *root_sector);
  99.     void put (root_sector *root_sector);
  100. };
  101.  
  102.  
  103. /* ----------------------------------------------------------------------- */
  104. /* Harddrive Class, derived from physical_drive                            */
  105. /* Represents one physical harddrive. Must be initialized with the drive   */
  106. /* number (0x80 for 1st HDD). Contains the root_sector and partition table. */
  107. /* ----------------------------------------------------------------------- */
  108.  
  109. class harddrive:public physical_drive
  110. {
  111.     partition_table pr_partition_table;
  112.  
  113. public:
  114. // constructors, destructors, operators
  115.  
  116.     harddrive (int number):physical_drive (number)
  117.     {
  118.         root_sector = new class root_sector (this);
  119.     }
  120.     harddrive (harddrive &hd):physical_drive (hd)
  121.     {
  122.         root_sector = new class root_sector (*(hd.root_sector));
  123.         partition_table () = hd.partition_table ();
  124.     }
  125.     void operator= (harddrive &hd);
  126.     ~harddrive (void) { delete root_sector; }
  127.  
  128. // public data
  129.  
  130.     root_sector *root_sector;
  131.  
  132. // member access functions
  133.  
  134.     virtual partition_table &partition_table() { return pr_partition_table; }
  135.  
  136. // functions
  137.  
  138.     int read_root_sector (void) { return (root_sector->read ()); }
  139.     int write_root_sector (void) { return (root_sector->write ()); }
  140.  
  141.     void get_partition_table (void);    // extract pt data from root sector
  142.     void put_partition_table (void)        // put pt data into root sector
  143.     {partition_table().put (root_sector);}
  144. };
  145.  
  146. #endif
  147.