unit WinIOCTL;
// $Header: /home/itig/cvsroot/autoupdate/component/WinIOCTL.pas,v 1.1 2001/06/21 23:15:52 jn Exp $

// John Newbigin
// from winioctl.h

{$A+,Z+}

interface
   uses Windows;

const
   Large0 : _Large_Integer = (LowPart : 0; HighPart : 0) ;

function div2(a : LongInt; b : LongInt) : LongInt;

{   function DeviceIoControl(hDevice : THandle; dwIoControlCode : DWORD;
                           var lpInBuffer; nInBuffer : DWORD;
                           var lpOutuffer; nOutBuffer : DWORD;
                           var BytesReturned: DWORD; Overlapped : pOverlapped):BOOL; stdcall;
 }
   function DeviceIoControl(hDevice : THandle; dwIoControlCode : DWORD;
                           lpInBuffer : Pointer; nInBuffer : DWORD;
                           lpOutuffer : Pointer; nOutBuffer : DWORD;
                           var BytesReturned: DWORD; Overlapped : pOverlapped):BOOL; stdcall;

   function ReadFile2(hFile: THandle; Buffer : Pointer; nNumberOfBytesToRead: DWORD;
    var lpNumberOfBytesRead: DWORD; lpOverlapped: POverlapped): BOOL; stdcall;
   function WriteFile2(hFile: THandle; Buffer : Pointer; nNumberOfBytesToWrite: DWORD;
    var lpNumberOfBytesWritten: DWORD; lpOverlapped: POverlapped): BOOL; stdcall;


type
  DEVICE_TYPE=DWORD;


const
  FILE_DEVICE_BEEP               = $00000001;
  FILE_DEVICE_CD_ROM             = $00000002;
  FILE_DEVICE_CD_ROM_FILE_SYSTEM = $00000003;
  FILE_DEVICE_CONTROLLER         = $00000004;
  FILE_DEVICE_DATALINK           = $00000005;
  FILE_DEVICE_DFS                = $00000006;
  FILE_DEVICE_DISK               = $00000007;
  FILE_DEVICE_DISK_FILE_SYSTEM   = $00000008;
  FILE_DEVICE_FILE_SYSTEM        = $00000009;
  FILE_DEVICE_INPORT_PORT        = $0000000a;
  FILE_DEVICE_KEYBOARD           = $0000000b;
  FILE_DEVICE_MAILSLOT           = $0000000c;
  FILE_DEVICE_MIDI_IN            = $0000000d;
  FILE_DEVICE_MIDI_OUT           = $0000000e;
  FILE_DEVICE_MOUSE              = $0000000f;
  FILE_DEVICE_MULTI_UNC_PROVIDER = $00000010;
  FILE_DEVICE_NAMED_PIPE         = $00000011;
  FILE_DEVICE_NETWORK            = $00000012;
  FILE_DEVICE_NETWORK_BROWSER    = $00000013;
  FILE_DEVICE_NETWORK_FILE_SYSTEM= $00000014;
  FILE_DEVICE_NULL               = $00000015;
  FILE_DEVICE_PARALLEL_PORT      = $00000016;
  FILE_DEVICE_PHYSICAL_NETCARD   = $00000017;
  FILE_DEVICE_PRINTER            = $00000018;
  FILE_DEVICE_SCANNER            = $00000019;
  FILE_DEVICE_SERIAL_MOUSE_PORT  = $0000001a;
  FILE_DEVICE_SERIAL_PORT        = $0000001b;
  FILE_DEVICE_SCREEN             = $0000001c;
  FILE_DEVICE_SOUND              = $0000001d;
  FILE_DEVICE_STREAMS            = $0000001e;
  FILE_DEVICE_TAPE               = $0000001f;
  FILE_DEVICE_TAPE_FILE_SYSTEM   = $00000020;
  FILE_DEVICE_TRANSPORT          = $00000021;
  FILE_DEVICE_UNKNOWN            = $00000022;
  FILE_DEVICE_VIDEO              = $00000023;
  FILE_DEVICE_VIRTUAL_DISK       = $00000024;
  FILE_DEVICE_WAVE_IN            = $00000025;
  FILE_DEVICE_WAVE_OUT           = $00000026;
  FILE_DEVICE_8042_PORT          = $00000027;
  FILE_DEVICE_NETWORK_REDIRECTOR = $00000028;
  FILE_DEVICE_BATTERY            = $00000029;
  FILE_DEVICE_BUS_EXTENDER       = $0000002a;
  FILE_DEVICE_MODEM              = $0000002b;
  FILE_DEVICE_VDM                = $0000002c;
  FILE_DEVICE_MASS_STORAGE       = $0000002d;

  IOCTL_STORAGE_BASE = FILE_DEVICE_MASS_STORAGE;
{//
// Macro definition for defining IOCTL and FSCTL function control codes.  Note
// that function codes 0-2047 are reserved for Microsoft Corporation, and
// 2048-4095 are reserved for customers.
//

#define CTL_CODE( DeviceType, Function, Method, Access ) (                 \
    ((DeviceType) << 16) | ((Access) << 14) | ((Function) << 2) | (Method) \
)

//
// Define the method codes for how buffers are passed for I/O and FS controls
//}

const
  METHOD_BUFFERED   = 0;
  METHOD_IN_DIRECT  = 1;
  METHOD_OUT_DIRECT = 2;
  METHOD_NEITHER    = 3;

//
// Define the access check value for any access
//
//
// The FILE_READ_ACCESS and FILE_WRITE_ACCESS constants are also defined in
// ntioapi.h as FILE_READ_DATA and FILE_WRITE_DATA. The values for these
// constants *MUST* always be in sync.
//

const
  FILE_ANY_ACCESS   = $00;
  FILE_READ_ACCESS  = $01;    // file & pipe
  FILE_WRITE_ACCESS = $02;    // file & pipe

// end_ntddk end_nthal end_ntifs

//
// IoControlCode values for disk devices.
//

{
#define IOCTL_DISK_BASE                 FILE_DEVICE_DISK
#define IOCTL_DISK_GET_DRIVE_GEOMETRY   CTL_CODE(IOCTL_DISK_BASE, 0x0000, METHOD_BUFFERED, FILE_ANY_ACCESS)
#define IOCTL_DISK_GET_PARTITION_INFO   CTL_CODE(IOCTL_DISK_BASE, 0x0001, METHOD_BUFFERED, FILE_READ_ACCESS)
#define IOCTL_DISK_SET_PARTITION_INFO   CTL_CODE(IOCTL_DISK_BASE, 0x0002, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS)
#define IOCTL_DISK_GET_DRIVE_LAYOUT     CTL_CODE(IOCTL_DISK_BASE, 0x0003, METHOD_BUFFERED, FILE_READ_ACCESS)
#define IOCTL_DISK_SET_DRIVE_LAYOUT     CTL_CODE(IOCTL_DISK_BASE, 0x0004, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS)
#define IOCTL_DISK_VERIFY               CTL_CODE(IOCTL_DISK_BASE, 0x0005, METHOD_BUFFERED, FILE_ANY_ACCESS)
#define IOCTL_DISK_FORMAT_TRACKS        CTL_CODE(IOCTL_DISK_BASE, 0x0006, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS)
#define IOCTL_DISK_REASSIGN_BLOCKS      CTL_CODE(IOCTL_DISK_BASE, 0x0007, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS)
#define IOCTL_DISK_PERFORMANCE          CTL_CODE(IOCTL_DISK_BASE, 0x0008, METHOD_BUFFERED, FILE_ANY_ACCESS)
#define IOCTL_DISK_IS_WRITABLE          CTL_CODE(IOCTL_DISK_BASE, 0x0009, METHOD_BUFFERED, FILE_ANY_ACCESS)
#define IOCTL_DISK_LOGGING              CTL_CODE(IOCTL_DISK_BASE, 0x000a, METHOD_BUFFERED, FILE_ANY_ACCESS)
#define IOCTL_DISK_FORMAT_TRACKS_EX     CTL_CODE(IOCTL_DISK_BASE, 0x000b, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS)
}
//
// The following device control codes are common for all class drivers.  The
// functions codes defined here must match all of the other class drivers.
//

{
#define IOCTL_DISK_CHECK_VERIFY     CTL_CODE(IOCTL_DISK_BASE, 0x0200, METHOD_BUFFERED, FILE_READ_ACCESS)
#define IOCTL_DISK_MEDIA_REMOVAL    CTL_CODE(IOCTL_DISK_BASE, 0x0201, METHOD_BUFFERED, FILE_READ_ACCESS)
#define IOCTL_DISK_EJECT_MEDIA      CTL_CODE(IOCTL_DISK_BASE, 0x0202, METHOD_BUFFERED, FILE_READ_ACCESS)
#define IOCTL_DISK_LOAD_MEDIA       CTL_CODE(IOCTL_DISK_BASE, 0x0203, METHOD_BUFFERED, FILE_READ_ACCESS)
#define IOCTL_DISK_RESERVE          CTL_CODE(IOCTL_DISK_BASE, 0x0204, METHOD_BUFFERED, FILE_READ_ACCESS)
#define IOCTL_DISK_RELEASE          CTL_CODE(IOCTL_DISK_BASE, 0x0205, METHOD_BUFFERED, FILE_READ_ACCESS)
#define IOCTL_DISK_FIND_NEW_DEVICES CTL_CODE(IOCTL_DISK_BASE, 0x0206, METHOD_BUFFERED, FILE_READ_ACCESS)
#define IOCTL_DISK_REMOVE_DEVICE    CTL_CODE(IOCTL_DISK_BASE, 0x0207, METHOD_BUFFERED, FILE_READ_ACCESS)

#define IOCTL_DISK_GET_MEDIA_TYPES CTL_CODE(IOCTL_DISK_BASE, 0x0300, METHOD_BUFFERED, FILE_ANY_ACCESS)
}

//
// Define the partition types returnable by known disk drivers.
//

const
  PARTITION_ENTRY_UNUSED       = $00;      // Entry unused
  PARTITION_FAT_12             = $01;      // 12-bit FAT entries
  PARTITION_XENIX_1            = $02;      // Xenix
  PARTITION_XENIX_2            = $03;      // Xenix
  PARTITION_FAT_16             = $04;      // 16-bit FAT entries
  PARTITION_EXTENDED           = $05;      // Extended partition entry
  PARTITION_HUGE               = $06;      // Huge partition MS-DOS V4
  PARTITION_IFS                = $07;      // IFS Partition
  PARTITION_UNIX               = $63;      // Unix
  PARTITION_LINUX_SWAP         = $82;      // Linux Swap Partition
  PARTITION_LINUX              = $83;      // Linux Native Partition

  VALID_NTFT                   = $C0;      // NTFT uses high order bits

  PARTITION_EXTENDED_LINUX     = $85;      // Extended partition entry
  PARTITION_EXTENDED_WIN98     = $0f;      // Extended partition entry

  EXTENDED_PARTITIONS  = [ PARTITION_EXTENDED, PARTITION_EXTENDED_LINUX, PARTITION_EXTENDED_WIN98 ]; 

//
// The following macro is used to determine which partitions should be
// assigned drive letters.
//

//++
//
// BOOLEAN
// IsRecognizedPartition(
//     IN DWORD PartitionType
//     )
//
// Routine Description:
//
//     This macro is used to determine to which partitions drive letters
//     should be assigned.
//
// Arguments:
//
//     PartitionType - Supplies the type of the partition being examined.
//
// Return Value:
//
//     The return value is TRUE if the partition type is recognized,
//     otherwise FALSE is returned.
//
//--
{
#define IsRecognizedPartition( PartitionType ) (       \
    (((PartitionType & ~0xC0) == PARTITION_FAT_12) ||  \
     ((PartitionType & ~0xC0) == PARTITION_FAT_16) ||  \
     ((PartitionType & ~0xC0) == PARTITION_IFS)    ||  \
     ((PartitionType & ~0xC0) == PARTITION_HUGE)) )
}
//
// The high bit of the partition type code indicates that a partition
// is part of an NTFT mirror or striped array.
//

  PARTITION_NTFT  = $80;     // NTFT partition

//
// Define the media types supported by the driver.
//

{typedef enum _MEDIA_TYPE
    Unknown,                // Format is unknown
    F5_1Pt2_512,            // 5.25", 1.2MB,  512 bytes/sector
    F3_1Pt44_512,           // 3.5",  1.44MB, 512 bytes/sector
    F3_2Pt88_512,           // 3.5",  2.88MB, 512 bytes/sector
    F3_20Pt8_512,           // 3.5",  20.8MB, 512 bytes/sector
    F3_720_512,             // 3.5",  720KB,  512 bytes/sector
    F5_360_512,             // 5.25", 360KB,  512 bytes/sector
    F5_320_512,             // 5.25", 320KB,  512 bytes/sector
    F5_320_1024,            // 5.25", 320KB,  1024 bytes/sector
    F5_180_512,             // 5.25", 180KB,  512 bytes/sector
    F5_160_512,             // 5.25", 160KB,  512 bytes/sector
    RemovableMedia,         // Removable media other than floppy
    FixedMedia              // Fixed hard disk media
 MEDIA_TYPE, *PMEDIA_TYPE;}

const
  Media_Type_Unknown       = 0;        // Format is unknown
  Media_Type_F5_1Pt2_512   = 1;        // 5.25", 1.2MB,  512 bytes/sector
  Media_Type_F3_1Pt44_512  = 2;        // 3.5",  1.44MB, 512 bytes/sector
  Media_Type_F3_2Pt88_512  = 3;        // 3.5",  2.88MB, 512 bytes/sector
  Media_Type_F3_20Pt8_512  = 4;        // 3.5",  20.8MB, 512 bytes/sector
  Media_Type_F3_720_512    = 5;        // 3.5",  720KB,  512 bytes/sector
  Media_Type_F5_360_512    = 6;        // 5.25", 360KB,  512 bytes/sector
  Media_Type_F5_320_512    = 7;        // 5.25", 320KB,  512 bytes/sector
  Media_Type_F5_320_1024   = 8;        // 5.25", 320KB,  1024 bytes/sector
  Media_Type_F5_180_512    = 9;        // 5.25", 180KB,  512 bytes/sector
  Media_Type_F5_160_512    = 10;       // 5.25", 160KB,  512 bytes/sector
  Media_Type_RemovableMedia= 11;       // Removable media other than floppy
  Media_Type_FixedMedia    = 12;       // Fixed hard disk media

//
// Define the input buffer structure for the driver, when
// it is called with IOCTL_DISK_FORMAT_TRACKS.
//

type
  TFORMAT_PARAMETERS = record
    MediaType           : DWORD;
    StartCylinderNumber : DWORD ;
    EndCylinderNumber   : DWORD ;
    StartHeadNumber     : DWORD ;
    EndHeadNumber       : DWORD ;
  end;
  PFORMAT_PARAMETERS = ^TFORMAT_PARAMETERS;

//
// Define the BAD_TRACK_NUMBER type. An array of elements of this type is
// returned by the driver on IOCTL_DISK_FORMAT_TRACKS requests, to indicate
// what tracks were bad during formatting. The length of that array is
// reported in the `Information' field of the I/O Status Block.
//

//typedef WORD   BAD_TRACK_NUMBER;
//typedef WORD   *PBAD_TRACK_NUMBER;

//
// Define the input buffer structure for the driver, when
// it is called with IOCTL_DISK_FORMAT_TRACKS_EX.
//

type
  TFORMAT_EX_PARAMETERS = record
   MediaType : DWORD;
   StartCylinderNumber : DWORD;
   EndCylinderNumber : DWORD;
   StartHeadNumber : DWORD;
   EndHeadNumber   : DWORD;
   FormatGapLength : WORD;
   SectorsPerTrack : WORD;
   SectorNumber    : array[0..0] of WORD;
  end;


//
// The following structure is returned on an IOCTL_DISK_GET_DRIVE_GEOMETRY
// request and an array of them is returned on an IOCTL_DISK_GET_MEDIA_TYPES
// request.
//

type
  TDISK_GEOMETRY = record
    Cylinders : _LARGE_INTEGER;//TLargeInteger ;//LARGE_INTEGER ;
    MediaType : DWord;
    TracksPerCylinder : DWORD;