414 lines
15 KiB
C++
414 lines
15 KiB
C++
/*
|
|
* CiderPress
|
|
* Copyright (C) 2007 by faddenSoft, LLC. All Rights Reserved.
|
|
* See the file LICENSE for distribution terms.
|
|
*/
|
|
#ifdef _WIN32
|
|
/*
|
|
* Structures and functions for performing block-level I/O on Win32 logical
|
|
* and physical volumes.
|
|
*
|
|
* Under Win2K/XP this is pretty straightforward: open the volume and
|
|
* issue seek and read calls. It's not quite that simple -- reads need to
|
|
* be in 512-byte sectors for floppy and hard drives, seeks need to be on
|
|
* sector boundaries, and you can't seek from the end, which makes it hard
|
|
* to figure out how big the volume is -- but it's palatable.
|
|
*
|
|
* Under Win95/Win98/WinME, life is more difficult. You need to use the
|
|
* Int21h/7305h services to access logical volumes. Of course, those weren't
|
|
* available until Win95 OSR2, before which you used Int25h/6000h, but those
|
|
* don't work with FAT32 volumes. Access to physical devices requires Int13h,
|
|
* which is fine for floppies but requires 16-bit flat thunks for hard drives
|
|
* (see Q137176: "DeviceIoControl Int 13h Does Not Support Hard Disks").
|
|
*
|
|
* If Win98 can't recognize the volume on a floppy, it tries to reacquire
|
|
* the volume information every time you ask it to read a sector. This makes
|
|
* things *VERY* slow. The solution is to use the physical drive Int13h
|
|
* services. These come in two variants, one of which will work on just
|
|
* about any machine but only works with floppies. The other will work on
|
|
* anything built since about 1996.
|
|
*
|
|
* Figuring out whether something is or isn't a floppy requires yet
|
|
* another call. All things considered it's quite an ordeal. The block I/O
|
|
* functions are wrapped up in classes so nobody else has to worry about all
|
|
* this mess.
|
|
*
|
|
* Implementation note: this class is broken down by how the devices are
|
|
* opened, e.g. logical, physical, or ASPI address. Breaking it down by device
|
|
* type seems more appropriate, but Win98 vs Win2K can require completely
|
|
* different approaches (e.g. physical vs. logical for floppy disk, logical
|
|
* vs. ASPI for CD-ROM). There is no perfect decomposition.
|
|
*
|
|
* Summary:
|
|
* Win9x/ME physical drive: Int13h (doesn't work for hard drives)
|
|
* Win9x/ME logical drive: Int21h/7305h
|
|
* Win9x/ME SCSI drive or CD-ROM drive: ASPI
|
|
* Win2K/XP physical drive: CreateFile("\\.\PhysicalDriveN")
|
|
* Win2K/XP logical drive: CreateFile("\\.\X")
|
|
* Win2K/XP SCSI drive or CD-ROM drive: SPTI
|
|
*/
|
|
#ifndef DISKIMG_WIN32BLOCKIO_H
|
|
#define DISKIMG_WIN32BLOCKIO_H
|
|
|
|
|
|
namespace DiskImgLib {
|
|
|
|
extern bool IsWin9x(void);
|
|
|
|
|
|
/*
|
|
* Cache a contiguous set of blocks. This was originally motivated by poor
|
|
* write performance, but that problem was largely solved in other ways.
|
|
* It's still handy to write an entire track at once under Win98 though.
|
|
*
|
|
* Only storing continuous runs of blocks makes the cache less useful, but
|
|
* much easier to write, and hence less likely to break in unpleasant ways.
|
|
*
|
|
* This class just manages the blocks. The FlushCache() function in
|
|
* Win32LogicalVolume is responsible for actually pushing the writes through.
|
|
*
|
|
* (I'm not entirely happy with this, especially since it doesn't take into
|
|
* account the underlying device block size. This could've been a good place
|
|
* to handle the 2048-byte CD-ROM block size, rather than caching it again in
|
|
* the CD-ROM handler.)
|
|
*/
|
|
class CBCache {
|
|
public:
|
|
CBCache(void) : fFirstBlock(kEmpty), fNumBlocks(0)
|
|
{
|
|
for (int i = 0; i < kMaxCachedBlocks; i++)
|
|
fDirty[i] = false;
|
|
}
|
|
virtual ~CBCache(void) { Purge(); }
|
|
|
|
enum { kEmpty = -1 };
|
|
|
|
// is the block we want in the cache?
|
|
bool IsBlockInCache(long blockNum) const;
|
|
// read block out of cache (after verifying that it's present)
|
|
DIError GetFromCache(long blockNum, void* buf);
|
|
// can the cache store this block?
|
|
bool IsRoomInCache(long blockNum) const;
|
|
// write block to cache (after verifying that it will fit)
|
|
DIError PutInCache(long blockNum, const void* buf, bool isDirty);
|
|
|
|
// are there any dirty blocks in the cache?
|
|
bool IsDirty(void) const;
|
|
// get start, count, and buffer so we can write the cached data
|
|
void GetCachePointer(long* pFirstBlock, int* pNumBlocks, void** pBuf) const;
|
|
// clear all the dirty flags
|
|
void Scrub(void);
|
|
// purge all cache entries (ideally after writing w/help from GetCachePtr)
|
|
void Purge(void);
|
|
|
|
private:
|
|
enum {
|
|
kMaxCachedBlocks = 18, // one track on 1.4MB floppy
|
|
kBlockSize = 512, // must match with Win32LogicalVolume::
|
|
};
|
|
|
|
long fFirstBlock; // set to kEmpty when cache is empty
|
|
int fNumBlocks;
|
|
bool fDirty[kMaxCachedBlocks];
|
|
unsigned char fCache[kMaxCachedBlocks * kBlockSize];
|
|
};
|
|
|
|
|
|
/*
|
|
* This class encapsulates block access to a logical or physical volume.
|
|
*/
|
|
class Win32VolumeAccess {
|
|
public:
|
|
Win32VolumeAccess(void) :
|
|
fTotalBlocks(-1),
|
|
fpBlockAccess(NULL)
|
|
{}
|
|
virtual ~Win32VolumeAccess(void) {
|
|
if (fpBlockAccess != NULL) {
|
|
FlushCache(true);
|
|
fpBlockAccess->Close();
|
|
}
|
|
}
|
|
|
|
// "deviceName" has the form "X:\" (logical), "81:\" (physical), or
|
|
// "ASPI:x:y:z\" (ASPI)
|
|
DIError Open(const WCHAR* deviceName, bool readOnly);
|
|
// close the device
|
|
void Close(void);
|
|
// is the device open and working?
|
|
bool Ready(void) const { return fpBlockAccess != NULL; }
|
|
|
|
// return the volume's EOF
|
|
long GetTotalBlocks(void) const { return fTotalBlocks; }
|
|
// return the block size for this volume (always a power of 2)
|
|
int GetBlockSize(void) const { return BlockAccess::kBlockSize; }
|
|
|
|
// read one or more consecutive blocks
|
|
DIError ReadBlocks(long startBlock, short blockCount, void* buf);
|
|
// write one or more consecutive blocks
|
|
DIError WriteBlocks(long startBlock, short blockCount, const void* buf);
|
|
// flush our internal cache
|
|
DIError FlushCache(bool purge);
|
|
|
|
private:
|
|
/*
|
|
* Abstract base class with some handy functions.
|
|
*/
|
|
class BlockAccess {
|
|
public:
|
|
BlockAccess(void) { fIsWin9x = DiskImgLib::IsWin9x(); }
|
|
virtual ~BlockAccess(void) {}
|
|
|
|
typedef struct {
|
|
int numCyls;
|
|
int numHeads;
|
|
int numSectors;
|
|
long blockCount; // total #of blocks on this kind of disk
|
|
} DiskGeometry;
|
|
|
|
// generic interfaces
|
|
virtual DIError Open(const WCHAR* deviceName, bool readOnly) = 0;
|
|
virtual DIError DetectCapacity(long* pNumBlocks) = 0;
|
|
virtual DIError ReadBlocks(long startBlock, short blockCount,
|
|
void* buf) = 0;
|
|
virtual DIError WriteBlocks(long startBlock, short blockCount,
|
|
const void* buf) = 0;
|
|
virtual DIError Close(void) = 0;
|
|
|
|
static bool BlockToCylinderHeadSector(long blockNum,
|
|
const DiskGeometry* pGeometry, int* pCylinder, int* pHead,
|
|
int* pSector, long* pLastBlockOnTrack);
|
|
|
|
enum {
|
|
kNumLogicalVolumes = 26, // A-Z
|
|
kBlockSize = 512,
|
|
kCDROMSectorSize = 2048,
|
|
kMaxFloppyRetries = 3, // retry floppy reads/writes
|
|
};
|
|
|
|
// BIOS floppy disk drive type; doubles here as media type
|
|
typedef enum {
|
|
kFloppyUnknown = 0,
|
|
kFloppy525_360 = 1,
|
|
kFloppy525_1200 = 2,
|
|
kFloppy35_720 = 3,
|
|
kFloppy35_1440 = 4,
|
|
kFloppy35_2880 = 5,
|
|
|
|
kFloppyMax
|
|
} FloppyKind;
|
|
|
|
protected:
|
|
static DIError GetFloppyDriveKind(HANDLE handle, int unitNum,
|
|
FloppyKind* pKind);
|
|
// detect the #of blocks on the volume
|
|
static DIError ScanCapacity(BlockAccess* pThis, long* pNumBlocks);
|
|
// determine whether a block is readable
|
|
static bool CanReadBlock(BlockAccess* pThis, long blockNum);
|
|
// try to detect device capacity using SPTI
|
|
DIError DetectCapacitySPTI(HANDLE handle,
|
|
bool isCDROM, long* pNumBlocks);
|
|
|
|
static int ReadBlocksInt13h(HANDLE handle, int unitNum,
|
|
int cylinder, int head, int sector, short blockCount, void* buf);
|
|
static DIError ReadBlocksInt13h(HANDLE handle, int unitNum,
|
|
const DiskGeometry* pGeometry, long startBlock, short blockCount,
|
|
void* buf);
|
|
static int WriteBlocksInt13h(HANDLE handle, int unitNum,
|
|
int cylinder, int head, int sector, short blockCount,
|
|
const void* buf);
|
|
static DIError WriteBlocksInt13h(HANDLE handle, int unitNum,
|
|
const DiskGeometry* pGeometry, long startBlock, short blockCount,
|
|
const void* buf);
|
|
|
|
static DIError ReadBlocksInt21h(HANDLE handle, int driveNum,
|
|
long startBlock, short blockCount, void* buf);
|
|
static DIError WriteBlocksInt21h(HANDLE handle, int driveNum,
|
|
long startBlock, short blockCount, const void* buf);
|
|
|
|
static DIError ReadBlocksWin2K(HANDLE handle,
|
|
long startBlock, short blockCount, void* buf);
|
|
static DIError WriteBlocksWin2K(HANDLE handle,
|
|
long startBlock, short blockCount, const void* buf);
|
|
|
|
bool fIsWin9x; // Win9x/ME=true, Win2K/XP=false
|
|
};
|
|
|
|
/*
|
|
* Access to a logical volume (e.g. "C:\") under Win9x and Win2K/XP.
|
|
*/
|
|
class LogicalBlockAccess : public BlockAccess {
|
|
public:
|
|
LogicalBlockAccess(void) : fHandle(NULL), fIsCDROM(false),
|
|
fDriveNum(-1), fLastSectorCache(NULL), fLastSectorNum(-1)
|
|
{}
|
|
virtual ~LogicalBlockAccess(void) {
|
|
if (fHandle != NULL) {
|
|
//LOGI("HEY: LogicalBlockAccess: forcing close");
|
|
Close();
|
|
}
|
|
delete[] fLastSectorCache;
|
|
}
|
|
|
|
virtual DIError Open(const WCHAR* deviceName, bool readOnly);
|
|
virtual DIError DetectCapacity(long* pNumBlocks) {
|
|
/* use SCSI length value if at all possible */
|
|
DIError dierr;
|
|
dierr = DetectCapacitySPTI(fHandle, fIsCDROM, pNumBlocks);
|
|
if (fIsCDROM)
|
|
return dierr; // SPTI should always work for CD-ROM
|
|
if (dierr != kDIErrNone)
|
|
return ScanCapacity(this, pNumBlocks); // fall back on scan
|
|
else
|
|
return dierr;
|
|
}
|
|
virtual DIError ReadBlocks(long startBlock, short blockCount,
|
|
void* buf)
|
|
{
|
|
if (fIsCDROM)
|
|
return ReadBlocksCDROM(fHandle, startBlock, blockCount, buf);
|
|
if (fIsWin9x)
|
|
return ReadBlocksInt21h(fHandle, fDriveNum, startBlock,
|
|
blockCount, buf);
|
|
else
|
|
return ReadBlocksWin2K(fHandle, startBlock, blockCount, buf);
|
|
}
|
|
virtual DIError WriteBlocks(long startBlock, short blockCount,
|
|
const void* buf)
|
|
{
|
|
if (fIsCDROM)
|
|
return kDIErrWriteProtected;
|
|
if (fIsWin9x)
|
|
return WriteBlocksInt21h(fHandle, fDriveNum, startBlock,
|
|
blockCount, buf);
|
|
else
|
|
return WriteBlocksWin2K(fHandle, startBlock, blockCount, buf);
|
|
}
|
|
virtual DIError Close(void);
|
|
|
|
private:
|
|
//DIError DetectCapacitySPTI(long* pNumBlocks);
|
|
DIError ReadBlocksCDROM(HANDLE handle,
|
|
long startBlock, short numBlocks, void* buf);
|
|
|
|
// Win2K/XP and Win9x/ME
|
|
HANDLE fHandle;
|
|
bool fIsCDROM; // set for CD-ROM devices
|
|
// Win9x/ME
|
|
int fDriveNum; // 1=A, 3=C, etc
|
|
// CD-ROM goodies
|
|
unsigned char* fLastSectorCache;
|
|
long fLastSectorNum;
|
|
};
|
|
|
|
/*
|
|
* Access to a physical volume (e.g. 00h or 80h) under Win9x and
|
|
* Win2K/XP.
|
|
*/
|
|
class PhysicalBlockAccess : public BlockAccess {
|
|
public:
|
|
PhysicalBlockAccess(void) :
|
|
fHandle(NULL),
|
|
fInt13Unit(-1),
|
|
fFloppyKind(kFloppyUnknown)
|
|
{}
|
|
virtual ~PhysicalBlockAccess(void) {}
|
|
|
|
virtual DIError Open(const WCHAR* deviceName, bool readOnly);
|
|
virtual DIError DetectCapacity(long* pNumBlocks) {
|
|
/* try SPTI in case it happens to work */
|
|
DIError dierr;
|
|
dierr = DetectCapacitySPTI(fHandle, false, pNumBlocks);
|
|
if (dierr != kDIErrNone)
|
|
return ScanCapacity(this, pNumBlocks);
|
|
else
|
|
return dierr;
|
|
}
|
|
virtual DIError ReadBlocks(long startBlock, short blockCount,
|
|
void* buf)
|
|
{
|
|
if (fIsWin9x)
|
|
return ReadBlocksInt13h(fHandle, fInt13Unit,
|
|
&fGeometry, startBlock, blockCount, buf);
|
|
else
|
|
return ReadBlocksWin2K(fHandle,
|
|
startBlock, blockCount, buf);
|
|
}
|
|
virtual DIError WriteBlocks(long startBlock, short blockCount,
|
|
const void* buf)
|
|
{
|
|
if (fIsWin9x)
|
|
return WriteBlocksInt13h(fHandle, fInt13Unit,
|
|
&fGeometry, startBlock, blockCount, buf);
|
|
else
|
|
return WriteBlocksWin2K(fHandle,
|
|
startBlock, blockCount, buf);
|
|
}
|
|
virtual DIError Close(void);
|
|
|
|
private:
|
|
DIError DetectFloppyGeometry(void);
|
|
|
|
// Win2K/XP
|
|
HANDLE fHandle;
|
|
// Win9x/ME
|
|
int fInt13Unit; // 00h=floppy #1, 80h=HD#1
|
|
FloppyKind fFloppyKind;
|
|
DiskGeometry fGeometry;
|
|
};
|
|
|
|
#ifdef WANT_ASPI
|
|
/*
|
|
* Access to a SCSI volume via the ASPI interface.
|
|
*/
|
|
class ASPIBlockAccess : public BlockAccess {
|
|
public:
|
|
ASPIBlockAccess(void) : fpASPI(NULL),
|
|
fAdapter(0xff), fTarget(0xff), fLun(0xff), fReadOnly(false),
|
|
fLastChunkCache(NULL), fLastChunkNum(-1), fChunkSize(-1)
|
|
{}
|
|
virtual ~ASPIBlockAccess(void) { delete[] fLastChunkCache; }
|
|
|
|
virtual DIError Open(const char* deviceName, bool readOnly);
|
|
virtual DIError DetectCapacity(long* pNumBlocks);
|
|
virtual DIError ReadBlocks(long startBlock, short blockCount,
|
|
void* buf);
|
|
virtual DIError WriteBlocks(long startBlock, short blockCount,
|
|
const void* buf);
|
|
virtual DIError Close(void);
|
|
|
|
private:
|
|
int ExtractInt(const char** pStr, int* pResult);
|
|
|
|
ASPI* fpASPI;
|
|
unsigned char fAdapter;
|
|
unsigned char fTarget;
|
|
unsigned char fLun;
|
|
|
|
bool fReadOnly;
|
|
|
|
// block cache
|
|
unsigned char* fLastChunkCache;
|
|
long fLastChunkNum;
|
|
long fChunkSize; // set by DetectCapacity
|
|
};
|
|
#endif /*WANT_ASPI*/
|
|
|
|
// write a series of blocks to the volume
|
|
DIError DoWriteBlocks(long startBlock, short blockCount, const void* buf)
|
|
{
|
|
return fpBlockAccess->WriteBlocks(startBlock, blockCount, buf);
|
|
}
|
|
|
|
long fTotalBlocks;
|
|
BlockAccess* fpBlockAccess; // really LogicalBA or PhysicalBA
|
|
CBCache fBlockCache;
|
|
};
|
|
|
|
|
|
}; // namespace DiskImgLib
|
|
|
|
#endif /*DISKIMG_WIN32BLOCKIO_H*/
|
|
|
|
#endif /*_WIN32*/
|