home *** CD-ROM | disk | FTP | other *** search
/ PC World 1999 August / PCWorld_1999-08_cd.bin / dosutils / fips15c / source / logdr_st.h < prev    next >
C/C++ Source or Header  |  1997-12-20  |  8KB  |  232 lines
  1. /*
  2.     FIPS - the First nondestructive Interactive Partition Splitting program
  3.  
  4.     Module logdr_st.h
  5.  
  6.     RCS - Header:
  7.     $Header: c:/daten/fips/source/main/RCS/logdr_st.h 1.4 1995/01/19 00:01:27 schaefer Exp $
  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 LOGDR_ST_H
  32. #define LOGDR_ST_H
  33.  
  34. #include "types.h"
  35. #include "disk_io.h"
  36.  
  37.  
  38. /* ----------------------------------------------------------------------- */
  39. /* Class boot_sector - derived from structure sector                       */
  40. /* Must be initialized with pointer to logical drive object                */
  41. /* Read() and write() read/write sector 0 of logical drive                 */
  42. /* ----------------------------------------------------------------------- */
  43.  
  44. class boot_sector:public sector
  45. {
  46.     class logical_drive *logical_drive;
  47. public:
  48. // constructor
  49.  
  50.     boot_sector (class logical_drive *logical_drive)
  51.     { boot_sector::logical_drive = logical_drive; }
  52.  
  53.  
  54. // functions
  55.  
  56.     int read (void);
  57.     int write (void);
  58. };
  59.  
  60.  
  61. /* ----------------------------------------------------------------------- */
  62. /* Class fsinfo_sector - derived from structure sector                     */
  63. /* Must be initialized with pointer to logical drive object                */
  64. /* Read() and write() read/write sector 0 of logical drive                 */
  65. /* ----------------------------------------------------------------------- */
  66.  
  67. class fsinfo_sector:public sector
  68. {
  69.     class logical_drive *logical_drive;
  70. public:
  71. // constructor
  72.  
  73.     fsinfo_sector (class logical_drive *logical_drive)
  74.     { fsinfo_sector::logical_drive = logical_drive; }
  75.  
  76.  
  77. // functions
  78.  
  79.     int read (void);
  80.     int write (void);
  81. };
  82.  
  83.  
  84. /* ------------------------------------------------------------------------ */
  85. /* Bios Parameter Block structure                                           */
  86. /* This is not exactly the BPB as understood by DOS, because it contains    */
  87. /* the additional fields that are in the boot_sector like jump_instruction, */
  88. /* oem_name etc. Get() extracts info from the boot_sector, put() writes the */
  89. /* info back into the boot_sector buffer.                                   */
  90. /* ------------------------------------------------------------------------ */
  91.  
  92. struct bios_parameter_block
  93. {
  94.     byte jump_instruction[3];    // EB xx 90 or E9 xx xx
  95.     char oem_name[9];
  96.     word bytes_per_sector;          // usually 512
  97.     byte sectors_per_cluster;       // may differ
  98.     word reserved_sectors;          // usually 1 (boot_sector)
  99.     byte no_of_fats;                // usually 2
  100.     word no_of_rootdir_entries;     // usually 512 for HDs (?), 224 for
  101.                     // HD-Floppies, 112 for DD-Floppies
  102.     word no_of_sectors;             // 0 on BIGDOS partitions
  103.     byte media_descriptor;          // usually F8h
  104.     word sectors_per_fat16;         // depends on partition size
  105.     word sectors_per_track;         // depends on drive
  106.     word drive_heads;               // dto.
  107.     dword hidden_sectors;           // first sector of partition or 0 for FDs
  108.     dword no_of_sectors_long;       // number of sectors on BIGDOS partitions
  109.  
  110.     // These next values are only used for FAT32
  111.     dword sectors_per_fat;        // sectors per FAT in FAT32
  112.     word  flags;            // bit 8: fat mirroring, low 4: active fat
  113.     byte  version[2];        // major, minor filesystem version
  114.     dword root_cluster;        // first cluster in root directory
  115.     word  info_sector;        // filesystem info sector
  116.     word  backup_boot;        // backup boot sector
  117.     word  reserved[6];        // Unused
  118.  
  119.     byte phys_drive_no;             // usually 80h
  120.     byte signature;                 // usually 29h
  121.     dword serial_number;            // random
  122.     char volume_label[12];
  123.     char file_system_id[9];
  124.  
  125.     void get (boot_sector *boot_sector);
  126.     void put (boot_sector *boot_sector);
  127. };
  128.  
  129.  
  130. /* ----------------------------------------------------------------------- */
  131. /* Some miscellaneous figures about the drive                              */
  132. /* Get() extracts this info from the BPB                                   */
  133. /* ----------------------------------------------------------------------- */
  134.  
  135. struct logical_drive_info
  136. {
  137.     dword start_fat1;
  138.     dword start_fat2;
  139.     dword start_rootdir;
  140.     dword start_data;
  141.     dword no_of_clusters;
  142.  
  143.     virtual void get (const bios_parameter_block &bpb);
  144. };
  145.  
  146.  
  147. /* ----------------------------------------------------------------------- */
  148. /* Abstract Class logical_drive. This can be any DOS drive that allows     */
  149. /* direct reading and writing of sectors, like Harddisk Partitions, Floppy */
  150. /* disks or Ramdisks                                                       */
  151. /* ----------------------------------------------------------------------- */
  152.  
  153. class logical_drive
  154. {
  155. // private data
  156.  
  157.     struct bios_parameter_block pr_bpb;
  158.     struct logical_drive_info pr_info;
  159.  
  160. public:
  161.  
  162. // public data
  163.  
  164.     class boot_sector *boot_sector;
  165.     class fsinfo_sector *fsinfo_sector;
  166.  
  167. // member access functions
  168.  
  169.     virtual bios_parameter_block &bpb() { return pr_bpb; }
  170.     virtual logical_drive_info &info() { return pr_info; }
  171.  
  172. // functions
  173.  
  174.     virtual int read_sector (dword number,sector *sector) = 0;
  175.     virtual int write_sector (dword number,sector *sector) = 0;
  176.     // pure virtual functions
  177.  
  178.     int read_boot_sector (void) { return (boot_sector->read ()); }
  179.     int write_boot_sector (void) { return (boot_sector->write ()); }
  180.  
  181.     int read_fsinfo_sector (void) { return (fsinfo_sector->read ()); }
  182.     int write_fsinfo_sector (void) { return (fsinfo_sector->write ()); }
  183.  
  184.     void get_bpb (void) { bpb().get (boot_sector); }
  185.     void put_bpb (void) { bpb().put (boot_sector); }
  186.  
  187.     void get_info (void) { info().get (bpb ()); }
  188. };
  189.  
  190.  
  191. /* ----------------------------------------------------------------------- */
  192. /* Function to read boot_sector from logical drive                         */
  193. /* It must be in the header file because it is inline                      */
  194. /* ----------------------------------------------------------------------- */
  195.  
  196. inline int boot_sector::read (void)
  197. {
  198.     return logical_drive->read_sector (0,this);
  199. }
  200.  
  201.  
  202. /* ----------------------------------------------------------------------- */
  203. /* Function to write boot_sector to logical drive                          */
  204. /* ----------------------------------------------------------------------- */
  205.  
  206. inline int boot_sector::write (void)
  207. {
  208.     return logical_drive->write_sector (0,this);
  209. }
  210.  
  211. /* ----------------------------------------------------------------------- */
  212. /* Function to read fsinfo_sector from logical drive                       */
  213. /* It must be in the header file because it is inline                      */
  214. /* ----------------------------------------------------------------------- */
  215.  
  216. inline int fsinfo_sector::read (void)
  217. {
  218.     return logical_drive->read_sector (1,this);
  219. }
  220.  
  221.  
  222. /* ----------------------------------------------------------------------- */
  223. /* Function to write fsinfo_sector to logical drive                        */
  224. /* ----------------------------------------------------------------------- */
  225.  
  226. inline int fsinfo_sector::write (void)
  227. {
  228.     return logical_drive->write_sector (1,this);
  229. }
  230.  
  231. #endif
  232.