cpgpdiskimpdrv98.cpp

PGP8.0源码 请认真阅读您的文件包然后写出其具体功能

/*____________________________________________________________________________
		Copyright (C) 2002 PGP Corporation
        All rights reserved.

        $Id: CPGPdiskImpDrv98.cpp,v 1.6 2002/08/06 20:09:30 dallen Exp $
____________________________________________________________________________*/

#include "pgpClassesConfig.h"
#include <winerror.h>

#include "CString.h"
#include "UDebug.h"
#include "UMath.h"

#include "UFileSys.h"

#include "CFilesystemWatcher.h"
#include "CIop.h"
#include "CPGPdiskImpDrv98.h"
#include "CDriverSubsystemsDrv98.h"
#include "UConstantNamesDrv98.h"

_USING_PGP

// Class CPGPdiskImpDrv98 member functions

CComboError 
CPGPdiskImpDrv98::Read(
	void		*buf, 
	PGPUInt64	posInBlocks, 
	PGPUInt32	nBlocks) const
{
	CComboError	error;

	// Satisfy from cache if bootblock read.
	if (posInBlocks == 0)
	{
		pgpAssertAddrValid(buf, VoidAlign);

		UDebug::DebugOut("PGPdisk: Reading PGPdisk %s from bootblock "
			"cache.\n", Root());

		pgpCopyMemory(mBootBlock, buf, kPGPdiskBlockSize);

		if (nBlocks > 1)
		{
			error = CPGPdiskImp::Read(static_cast<PGPUInt8 *>(buf) + 
				kPGPdiskBlockSize, 1, nBlocks - 1);
		}
	}
	else
	{
		error = CPGPdiskImp::Read(buf, posInBlocks, nBlocks);
	}

	return error;
}

CComboError 
CPGPdiskImpDrv98::Write(
	const void	*buf, 
	PGPUInt64	posInBlocks, 
	PGPUInt32	nBlocks)
{
	CComboError	error;

	// Update cache if bootblock written.
	if (posInBlocks == 0)
	{
		pgpAssertAddrValid(buf, VoidAlign);
		pgpCopyMemory(buf, mBootBlock, kPGPdiskBlockSize);
	}

	error = CPGPdiskImp::Write(buf, posInBlocks, nBlocks);

	return error;
}

CComboError 
CPGPdiskImpDrv98::Unmount(PGPBoolean isForced)
{
	CComboError	error;

	error = CPGPdiskImp::Unmount(isForced);

	if (error.IsntError())
	{
		CDriverSubsystemsDrv98::FilesystemWatcher().StopWatchingForBuffer(
			mBufferToWatchFor);
		mBufferToWatchFor = NULL;
	}

	return error;
}

CComboError 
CPGPdiskImpDrv98::CalcBlockSizeOfHost(
	const char	*path, 
	PGPUInt32&	hostBlockSize) const
{
	pgpAssertStrValid(path);

	CComboError	error;

	// Determine block size.
	CString	hostRoot;
	CVolume	host;

	error = hostRoot.Status();

	if (error.IsntError())
		hostRoot.Format("%c:\\", path[0]);

	if (error.IsntError())
	{
		error = host.AttachVolume(hostRoot);

		if (error.IsntError())
		{
			hostBlockSize = host.BlockSize();
			host.DetachVolume();
		}

		// Network path if error.
		if (error.IsError())
		{
			error = CComboError();
			hostBlockSize = FileSys::kTypicalBlockSize;
		}
	}

	return error;
}

CComboError 
CPGPdiskImpDrv98::GetDevParamsFat16(FileSys::DevParamsFat16& dp16) const
{
	pgpAssert(IsMounted());

	CComboError	error;

	// concoct a likely story
	FileSys::Type		fsType;
	PGPUInt32			secsPerTrack, tracksPerCyl;
	PGPUInt64			cylinders, megsDisk;
	UFileSys::FatData	fatData;

	pgpClearMemory(&dp16, sizeof(dp16));
	megsDisk = UFileSys::CalcMegsDisk(TotalBlocks(), kPGPdiskBlockSize);

	error = GetFsId(fsType);

	if (error.IsntError() && UFileSys::IsFatFileSys(fsType))
	{
		// use the boot block
		FileSys::BootSectorFat16	*pBS16	= 
			reinterpret_cast<FileSys::BootSectorFat16 *>(mBootBlock);

		dp16.dpDevType		= 0x05;		// we are a hard disk
		dp16.dpDevAttr		= 1;		// we are not removable
		dp16.dpCylinders	= FileSys::kMaxCyls - 1;
		dp16.dpMediaType	= pBS16->bsMedia;

		dp16.dpBytesPerSec	= pBS16->bsBytesPerSec;
		dp16.dpSecPerClust	= pBS16->bsSecPerClust;
		dp16.dpResSectors	= pBS16->bsResSectors;
		dp16.dpFats			= pBS16->bsFats;
		dp16.dpRootDirEnts	= pBS16->bsRootDirEnts;
		dp16.dpSectors		= pBS16->bsSectors;
		dp16.dpMedia		= pBS16->bsMedia;
		dp16.dpFatSecs		= pBS16->bsFatSecs;
		dp16.dpSecPerTrack	= pBS16->bsSecPerTrack;
		dp16.dpHeads		= pBS16->bsHeads;
		dp16.dpHiddenSecs	= pBS16->bsHiddenSecs;
		dp16.dpHugeSectors	= pBS16->bsHugeSectors;
	}
	else
	{
		// the boot block is wigged, fake it
		error = CComboError();

		if (megsDisk < FileSys::kMinFat16Megs)
			fsType = FileSys::kFat12FileSys;
		else
			fsType = FileSys::kFat16FileSys;

		UFileSys::InitFatData(static_cast<PGPUInt32>(TotalBlocks()), fsType, 
			fatData);
		UFileSys::CalcFakeFatGeom(kPGPdiskBlockSize, tracksPerCyl, 
			cylinders, secsPerTrack);

		dp16.dpDevType		= 0x05;				// we are a hard disk
		dp16.dpDevAttr		= 1;				// we are not removable
		dp16.dpCylinders	= static_cast<PGPUInt16>(cylinders);
		dp16.dpMediaType	= FileSys::kFatMediaByte;

		dp16.dpBytesPerSec	= kPGPdiskBlockSize;
		dp16.dpSecPerClust	= static_cast<PGPUInt8>(fatData.fdSpc);
		dp16.dpResSectors	= fatData.fdReservedSecs;
		dp16.dpFats			= fatData.fdFatCount;
		dp16.dpRootDirEnts	= fatData.fdRootDirEnts;
		dp16.dpSectors		= static_cast<PGPUInt16>(megsDisk < 32 ? 
			TotalBlocks() : 0);
		dp16.dpMedia		= FileSys::kFatMediaByte;
		dp16.dpFatSecs		= static_cast<PGPUInt16>(fatData.fdFatSize);
		dp16.dpSecPerTrack	= static_cast<PGPUInt16>(secsPerTrack);
		dp16.dpHeads		= static_cast<PGPUInt16>(tracksPerCyl);
		dp16.dpHiddenSecs	= 0;
		dp16.dpHugeSectors	= static_cast<PGPUInt32>(megsDisk >= 32 ? 
			TotalBlocks() : 0);
	}

	return error;
}

CComboError 
CPGPdiskImpDrv98::GetDevParamsFat32(FileSys::DevParamsFat32 &dp32) const
{
	pgpAssert(IsMounted());

	CComboError	error;

	// concoct a likely story
	FileSys::Type		fsType;
	PGPUInt32			secsPerTrack, tracksPerCyl;
	PGPUInt64			cylinders, megsDisk;
	UFileSys::FatData	fatData;
	
	pgpClearMemory(&dp32, sizeof(dp32));

	megsDisk = UFileSys::CalcMegsDisk(TotalBlocks(), 
		kPGPdiskBlockSize);

	error = GetFsId(fsType);

	if (error.IsntError() && UFileSys::IsFatFileSys(fsType))
	{
		FileSys::BootSectorFat32	*pBS32	= 
			reinterpret_cast<FileSys::BootSectorFat32 *>(mBootBlock);

		dp32.dpDevType		= 0x05;			// we are a hard disk
		dp32.dpDevAttr		= 1;			// we are not removable
		dp32.dpCylinders	= FileSys::kMaxCyls - 1;
		dp32.dpMediaType	= pBS32->bsMedia;

		dp32.dpBytesPerSector	= pBS32->bsBytesPerSec;
		dp32.dpSectorsPerClust	= pBS32->bsSecPerClust;
		dp32.dpReservedSectors	= pBS32->bsResSectors;
		dp32.dpNumberOfFats		= pBS32->bsFats;
		dp32.dpRootEntries		= pBS32->bsRootDirEnts;
		dp32.dpTotalSectors		= pBS32->bsSectors;
		dp32.dpMediaDescriptor	= pBS32->bsMedia;
		dp32.dpSectorsPerFat	= pBS32->bsFatSecs;
		dp32.dpSectorsPerTrack	= pBS32->bsSecPerTrack;
		dp32.dpHeads			= pBS32->bsHeads;
		dp32.dpHiddenSectors	= pBS32->bsHiddenSecs;
		dp32.dpBigTotalSectors	= pBS32->bsHugeSectors;
		dp32.dpBigSectorsPerFat	= pBS32->bsBigSectorsPerFat;
		dp32.dpExtFlags			= pBS32->bsExtFlags;
		dp32.dpFS_Version		= pBS32->bsFS_Version;
		dp32.dpRootDirStrtClus	= pBS32->bsRootDirStrtClus;
		dp32.dpFsInfoSec		= pBS32->bsFsInfoSec;
		dp32.dpBkUpBootSec		= pBS32->bsBkUpBootSec;
	}
	else
	{
		// the boot block is wigged, fake it
		error = CComboError();

		if (megsDisk < FileSys::kMinFat16Megs)
			fsType = FileSys::kFat12FileSys;
		else if (megsDisk < FileSys::kMinFat32Megs)
			fsType = FileSys::kFat16FileSys;
		else
			fsType = FileSys::kFat32FileSys;

		UFileSys::InitFatData(static_cast<PGPUInt32>(TotalBlocks()), fsType, 
			fatData);
		UFileSys::CalcFakeFatGeom(kPGPdiskBlockSize, tracksPerCyl, cylinders, 
			secsPerTrack);

		dp32.dpDevType		= 0x05;			// we are a hard disk
		dp32.dpDevAttr		= 1;			// we are not removable
		dp32.dpCylinders	= static_cast<PGPUInt16>(cylinders);
		dp32.dpMediaType	= FileSys::kFatMediaByte;

		dp32.dpBytesPerSector	= kPGPdiskBlockSize;
		dp32.dpSectorsPerClust	= static_cast<PGPUInt8>(fatData.fdSpc);
		dp32.dpReservedSectors	= fatData.fdReservedSecs;
		dp32.dpNumberOfFats		= fatData.fdFatCount;
		dp32.dpRootEntries		= fatData.fdRootDirEnts;
		dp32.dpTotalSectors		= static_cast<PGPUInt16>(
			megsDisk < 32 ? TotalBlocks() : 0);
		dp32.dpMediaDescriptor	= FileSys::kFatMediaByte;
		dp32.dpSectorsPerFat	= (fsType == FileSys::kFat32FileSys ? 0 : 
			static_cast<PGPUInt16>(fatData.fdFatSize));
		dp32.dpSectorsPerTrack	= static_cast<PGPUInt16>(secsPerTrack);
		dp32.dpHeads			= static_cast<PGPUInt16>(tracksPerCyl);
		dp32.dpHiddenSectors	= 0;
		dp32.dpBigTotalSectors	= static_cast<PGPUInt32>(
			megsDisk >= 32 ? TotalBlocks() : 0);
		dp32.dpBigSectorsPerFat	= (fsType != FileSys::kFat32FileSys ? 0 : 
			fatData.fdFatSize);
	}

	return error;
}

CComboError 
CPGPdiskImpDrv98::GetFsId(FileSys::Type &fsType) const
{
	pgpAssert(IsMounted());

	CComboError	error;
	fsType = FileSys::kUnknownFileSys;

	FileSys::MID	mid;
	error = GetMID(mid);

	if (error.IsntError())
	{
		char	*fsStr	= reinterpret_cast<char *>(mid.midFileSysType);

		if (!strncmp(fsStr, FileSys::kFat12IdStr, 5))
			fsType = FileSys::kFat12FileSys;
		else if (!strncmp(fsStr, FileSys::kFat16IdStr, 5))
			fsType = FileSys::kFat16FileSys;
		else if (!strncmp(fsStr, FileSys::kFat32IdStr, 5))
			fsType = FileSys::kFat32FileSys;
	}

	return error;
}

CComboError 
CPGPdiskImpDrv98::GetMID(FileSys::MID& mid) const
{
	pgpAssert(IsMounted());

	CComboError	error;
	PGPBoolean	foundRecognizedFileSys	= FALSE;

	mid.midInfoLevel = 0;

	char	*fsStr	= reinterpret_cast<char *>(mBootBlock) + 
		FileSys::kFat12Offset;

	if (!strncmp(fsStr, FileSys::kFat12IdStr, 5))
	{
		FileSys::BootSectorFat12	*pBS12	= reinterpret_cast<
			FileSys::BootSectorFat12 *>(mBootBlock);

		foundRecognizedFileSys = TRUE;
		mid.midSerialNum = pBS12->bsVolumeId;

		strncpy(reinterpret_cast<char *>(mid.midVolLabel), 
			pBS12->bsVolumeLabel, 11);
		strncpy(reinterpret_cast<char *>(mid.midFileSysType), 
			pBS12->bsFileSysType, 8);
	}

	fsStr = reinterpret_cast<char *>(mBootBlock) + FileSys::kFat16Offset;

	if (!strncmp(fsStr, FileSys::kFat16IdStr, 5))
	{
		FileSys::BootSectorFat16	*pBS16	= reinterpret_cast<
			FileSys::BootSectorFat16 *>(mBootBlock);

		foundRecognizedFileSys = TRUE;
		mid.midSerialNum = pBS16->bsVolumeId;

		strncpy(reinterpret_cast<char *>(mid.midVolLabel), 
			pBS16->bsVolumeLabel, 11);
		strncpy(reinterpret_cast<char *>(mid.midFileSysType), 
			pBS16->bsFileSysType, 8);
	}

	fsStr = reinterpret_cast<char *>(mBootBlock) + FileSys::kFat32Offset;

	if (!strncmp(fsStr, FileSys::kFat32IdStr, 5))
	{
		FileSys::BootSectorFat32	*pBS32	= reinterpret_cast<
			FileSys::BootSectorFat32 *>(mBootBlock);

		foundRecognizedFileSys = TRUE;
		mid.midSerialNum = pBS32->bsVolumeId;

		strncpy(reinterpret_cast<char *>(mid.midVolLabel), 
			pBS32->bsVolumeLabel, 11);
		strncpy(reinterpret_cast<char *>(mid.midFileSysType), 
			pBS32->bsFileSysType, 8);
	}

	// Special case for incorrectly formatted floppy drives. If the
	// FileSystem is unknown but the media is a floppy, assume FAT12.

	if (!foundRecognizedFileSys)
	{
		FileSys::BootSectorFat12	*pBS12	= reinterpret_cast<
			FileSys::BootSectorFat12 *>(mBootBlock);

		if (pBS12->bsMedia == FileSys::kFloppyMediaId)
		{
			mid.midSerialNum = pBS12->bsVolumeId;

			strncpy(reinterpret_cast<char *>(mid.midVolLabel), 
				pBS12->bsVolumeLabel, 11);
			strncpy(reinterpret_cast<char *>(mid.midFileSysType), 
				FileSys::kFat12IdStr, 8);
		}
	}