int main(int argc, char *argv[])
{
DISK_GEOMETRY pdg; // disk drive geometry structure
BOOL bResult; // generic results flag
ULONGLONG DiskSize; // size of the drive, in bytes
bResult = GetDriveGeometry (&pdg);
if (bResult)
{
printf("Cylinders = %I64d\n", pdg.Cylinders);
printf("Tracks/cylinder = %ld\n", (ULONG) pdg.TracksPerCylinder);
printf("Sectors/track = %ld\n", (ULONG) pdg.SectorsPerTrack);
printf("Bytes/sector = %ld\n", (ULONG) pdg.BytesPerSector);
DiskSize = pdg.Cylinders.QuadPart * (ULONG)pdg.TracksPerCylinder *
(ULONG)pdg.SectorsPerTrack * (ULONG)pdg.BytesPerSector;
printf("Disk size = %I64d (Bytes) = %I64d (Gb)\n", DiskSize,
DiskSize / (1024 * 1024 * 1024));
}
else
{
printf ("GetDriveGeometry failed. Error %ld.\n", GetLastError ());
}
return 0;
}
BOOL P9xPhysicalDrive::Open( int iDrive )
{
Close();
// Cannot open if RAWIO32.DLL is not in place
if (RAWIO32 == 0)
return FALSE;
TRACE("About to get geometry\n");
m_bDriveNumber = (BYTE)(128 + iDrive);
DISK_GEOMETRY dg;
if( GetDriveGeometry(&dg) )
{
TRACE("Cylinders = %I64d\n", dg.Cylinders );
TRACE("TracksPerCylinder = %d\n", dg.TracksPerCylinder );
TRACE("SectorsPerTrack = %d\n", dg.SectorsPerTrack );
TRACE("BytesPerSector = %d\n", dg.BytesPerSector );
INT64 TotalSize = dg.Cylinders.QuadPart;
TotalSize *= dg.TracksPerCylinder;
TotalSize *= dg.SectorsPerTrack;
TotalSize *= dg.BytesPerSector;
TRACE( "Total Size In Bytes = %I64d\n", TotalSize );
TotalSize /= 1024L;
TotalSize /= 1024L;
TRACE( "Total Size In Megabytes = %I64d\n", TotalSize );
ReadPartitionInfoRecursive(0,0);
m_hDevice = (HANDLE) 1;
return TRUE;
}
return FALSE;
}
/**
* @brief Opens a HANDLE to a Windows Blockdevice or File.
*
**/
HANDLE fnOpen(char *strDevName, int nBlockSize) {
struct _DEV_INFO *ptDevInfo;
DISK_GEOMETRY_EX DiskGeo;
LARGE_INTEGER li, address;
BOOL IOError;
DWORD BytesReturned;
HANDLE hDisk;
WCHAR pWide[MAX_PATH];
MultiByteToWideChar(CP_ACP, 0, strDevName, -1, pWide, MAX_PATH);
hDisk = CreateFile(pWide, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING , 0, NULL);
IOError = GetLastError();
if(hDisk != INVALID_HANDLE_VALUE) {
// Dismount volume (allow Vista and Seven write access!)
IOError = DeviceIoControl(hDisk, FSCTL_DISMOUNT_VOLUME, NULL, 0, NULL, 0, &BytesReturned, NULL);
// if(IOError) { // Continue on error! This may be an image file!
ptDevInfo = (struct _DEV_INFO *) malloc(sizeof(struct _DEV_INFO));
if(GetDriveGeometry(&DiskGeo, hDisk)) {
ptDevInfo->BlockSize = DiskGeo.Geometry.BytesPerSector;
ptDevInfo->DiskSize = DiskGeo.DiskSize.QuadPart;
ptDevInfo->hDev = hDisk;
ptDevInfo->AccessSem = FF_CreateSemaphore();
return (HANDLE) ptDevInfo;
} else {
GetFileSizeEx(hDisk, &li);
address.QuadPart = 0;
if(!nBlockSize) {
ptDevInfo->BlockSize = 512; // Try to assume the most likely setting!
} else {
ptDevInfo->BlockSize = nBlockSize;
}
ptDevInfo->DiskSize = li.QuadPart;
ptDevInfo->hDev = hDisk;
ptDevInfo->AccessSem = FF_CreateSemaphore();
return (HANDLE) ptDevInfo;
}
//}
}
return (HANDLE) NULL;
}
BOOL PNtPhysicalDrive::Open(int iDrive)
{
Close();
TCHAR szPath[256];
_stprintf(szPath, _T("\\\\.\\PhysicalDrive%d"), iDrive);
m_hDevice = CreateFile(szPath, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, 0, OPEN_EXISTING, 0, 0);
if (m_hDevice != INVALID_HANDLE_VALUE)
{
DISK_GEOMETRY dg;
if (GetDriveGeometry(&dg))
{
m_BytesPerSector = dg.BytesPerSector;
return TRUE;
}
}
return FALSE;
}
HANDLE fnOpen(char *strDevName, int nBlockSize) {
struct _DEV_INFO *ptDevInfo;
DISK_GEOMETRY_EX DiskGeo;
LARGE_INTEGER li, address;
HANDLE hDisk;
hDisk = CreateFile(strDevName, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING , 0, NULL);
if(hDisk) {
ptDevInfo = (struct _DEV_INFO *) malloc(sizeof(struct _DEV_INFO));
if(GetDriveGeometry(&DiskGeo, hDisk)) {
ptDevInfo->BlockSize = DiskGeo.Geometry.BytesPerSector;
ptDevInfo->DiskSize = DiskGeo.DiskSize.QuadPart;
ptDevInfo->hDev = hDisk;
ptDevInfo->AccessSem = FF_CreateSemaphore();
return (HANDLE) ptDevInfo;
} else {
//GetFileSizeEx(hDisk, &li);
address.QuadPart = 0;
if(!nBlockSize) {
ptDevInfo->BlockSize = 512;
} else {
ptDevInfo->BlockSize = nBlockSize;
}
ptDevInfo->DiskSize = li.QuadPart;
ptDevInfo->hDev = hDisk;
ptDevInfo->AccessSem = FF_CreateSemaphore();
return (HANDLE) ptDevInfo;
}
}
return (HANDLE) NULL;
}
static BOOL BkInstallPayloadFromBuffer(
PCHAR Payload,
ULONG PayloadSize,
PCHSS PayloadAddress
)
{
BOOL Ret = FALSE;
PCHAR Vbs = NULL, Loader = NULL, Packed = NULL;
PVBR Vbr = NULL;
ULONG i, bSize = BIOS_DEFAULT_SECTOR_SIZE;
PPARTITION_TABLE PTable;
ULONG StartSector = 0, EndSector = 0, SectorSize = 0, PackedSize = 0;
PWCHAR TargetDrive = wszPhysicalDrive0;
PCHAR PayloadSectors = NULL;
ULONG PayloadSecSize;
ULONG RndSeed = GetTickCount();
DISK_GEOMETRY Dg = {0};
do // not a loop
{
if (!Payload || !PayloadAddress || !PayloadSize)
break;
if (!GetDriveGeometry(TargetDrive, &Dg))
break;
if (!(Vbs = Alloc(BIOS_DEFAULT_SECTOR_SIZE)))
// Not enough memory
break;
// Reading MBR sector
if (!ReadSectors(TargetDrive, Vbs, bSize, 0, 1))
// Reading failed
break;
// Check out we read a right one
if (*(PUSHORT)(Vbs + BIOS_DEFAULT_SECTOR_SIZE - sizeof(USHORT)) != BIOS_MBR_MAGIC)
// Wrong or corrupt sector loaded
break;
// Here we read the Driver Boot sector and searching for the Volume boot sector within it
PTable = (PPARTITION_TABLE)(Vbs + BIOS_PARTITION_TABLE_OFFSET);
// Calculating drive unpartitioned space
for (i=0; i<BIOS_MAX_PARTITION_COUNT; i++)
{
if (PTable->Entry[i].ActiveFlag & BIOS_PARTITION_ACTIVE_FLAG)
{
if (StartSector == 0 || StartSector > PTable->Entry[i].LBAStartSector)
StartSector = PTable->Entry[i].LBAStartSector;
if (EndSector < (PTable->Entry[i].LBAStartSector + PTable->Entry[i].PartitionSize))
EndSector = (PTable->Entry[i].LBAStartSector + PTable->Entry[i].PartitionSize);
}
} // for (i=0; i<BIOS_MAX_PARTITION_COUNT; i++)
PayloadSecSize = (PayloadSize + (Dg.BytesPerSector -1))/Dg.BytesPerSector;
if (((StartSector - 1)) > PayloadSecSize)
StartSector = 1 + RtlRandom(&RndSeed)%((StartSector - 1) - PayloadSecSize);
else
{
ULONG DriveLastSector = Dg.Cylinders.LowPart * Dg.TracksPerCylinder * Dg.SectorsPerTrack;
StartSector = DriveLastSector - PayloadSecSize - 2;
}
if (!(PayloadSectors = Alloc(PayloadSecSize * Dg.BytesPerSector)))
// Not enough memory
break;
memcpy(PayloadSectors, Payload, PayloadSize);
if (StartSector)
{
// Calculating Start sector CHSS address
PayloadAddress->StartSector.QuadPart = (ULONGLONG)StartSector;
PayloadAddress->NumberSectors = (USHORT)PayloadSecSize;
// Writing payload to the disk
Ret = WriteSectors(TargetDrive, PayloadSectors, (PayloadSecSize * Dg.BytesPerSector), StartSector, PayloadSecSize);
}
} while(FALSE);
if (Vbs)
Free(Vbs);
if (PayloadSectors)
Free(PayloadSectors);
return(Ret);
}
JNIEXPORT jobject JNICALL Java_org_gudy_azureus2_platform_win32_access_impl_AEWin32AccessInterface_getAvailableDrives
(JNIEnv *env, jclass cla)
{
DISK_GEOMETRY pdg; // disk drive geometry structure
BOOL bResult; // generic results flag
ULONGLONG DiskSize; // size of the drive, in bytes
HANDLE hDevice;
// create List
jclass clsArrayList = env->FindClass("java/util/ArrayList");
jmethodID constArrayList = env->GetMethodID(clsArrayList, "<init>", "()V");
jobject arrayList = env->NewObject(clsArrayList, constArrayList, "");
jmethodID methAdd = env->GetMethodID(clsArrayList, "add", "(Ljava/lang/Object;)Z");
// each bit returned is one drive, starting with "A:"
DWORD dwLogicalDrives = GetLogicalDrives();
for ( int nDrive = 0; nDrive<32; nDrive++ )
{
if ( (dwLogicalDrives & (1 << nDrive)) == 0 ) {
continue;
}
// Do an aditional check by using GetDriveGeometry. If it fails, then there's
// no "disk" in the drive
WCHAR drive[100];
wsprintfW(drive, L"\\\\.\\%C:", 'a' + nDrive);
hDevice = CreateFileW((LPCWSTR) drive, // drive to open
0, // no access to the drive
FILE_SHARE_READ | // share mode
FILE_SHARE_WRITE,
NULL, // default security attributes
OPEN_EXISTING, // disposition
0, // file attributes
NULL); // do not copy file attributes
char drive2[4];
wsprintfA(drive2, "%C:\\", 'a' + nDrive);
if (hDevice == INVALID_HANDLE_VALUE) // cannot open the drive
{
continue;
}
bResult = GetDriveGeometry (hDevice, &pdg);
if (bResult)
{
// Create File
jclass cls = env->FindClass("java/io/File");
jmethodID constructor = env->GetMethodID(cls, "<init>", "(Ljava/lang/String;)V");
jobject object = env->NewObject(cls, constructor, env->NewStringUTF(drive2));
// add to list
env->CallBooleanMethod( arrayList, methAdd, object );
}
CloseHandle(hDevice);
}
return arrayList;
}
JNIEXPORT jobject JNICALL Java_org_gudy_azureus2_platform_win32_access_impl_AEWin32AccessInterface_getDriveInfo
(JNIEnv *env, jclass cla, jchar driveLetter)
{
jclass clsHashMap = env->FindClass("java/util/HashMap");
jmethodID constHashMap = env->GetMethodID(clsHashMap, "<init>", "()V");
jobject hashMap = env->NewObject(clsHashMap, constHashMap, "");
jmethodID methPut = env->GetMethodID(clsHashMap, "put", "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;");
jclass clsLong = env->FindClass("java/lang/Long");
jmethodID longInit = env->GetMethodID(clsLong, "<init>", "(J)V");
DISK_GEOMETRY pdg; // disk drive geometry structure
BOOL bResult; // generic results flag
ULONGLONG DiskSize; // size of the drive, in bytes
HANDLE hDevice;
WCHAR drive[100];
wsprintf(drive, L"\\\\.\\%C:", driveLetter);
hDevice = CreateFile((LPCWSTR) drive, // drive to open
0, // no access to the drive
FILE_SHARE_READ | // share mode
FILE_SHARE_WRITE,
NULL, // default security attributes
OPEN_EXISTING, // disposition
0, // file attributes
NULL); // do not copy file attributes
WCHAR drive2[4];
wsprintf(drive2, L"%C:\\", driveLetter);
DWORD uType = GetDriveType(drive2);
addToMap(env, hashMap, methPut, clsLong, longInit, "DriveType", (jlong) uType);
if (hDevice == INVALID_HANDLE_VALUE) // cannot open the drive
{
return hashMap;
}
bResult = GetDriveGeometry (hDevice, &pdg);
if (bResult)
{
LONGLONG diskSize = pdg.Cylinders.QuadPart * pdg.TracksPerCylinder *
pdg.SectorsPerTrack * pdg.BytesPerSector;
addToMap(env, hashMap, methPut, clsLong, longInit, "MediaType", (jlong) pdg.MediaType);
addToMap(env, hashMap, methPut, clsLong, longInit, "DiskSize", (jlong) diskSize);
}
char OutBuf[1024] = {0}; // good enough, usually about 100 bytes
PSTORAGE_DEVICE_DESCRIPTOR pDevDesc = (PSTORAGE_DEVICE_DESCRIPTOR)OutBuf;
pDevDesc->Size = sizeof(OutBuf);
bResult = GetStorageProperty(hDevice, &pDevDesc);
if (bResult) {
addToMap(env, hashMap, methPut, clsLong, longInit, "BusType", (jlong) pDevDesc->BusType);
addToMap(env, hashMap, methPut, clsLong, longInit, "DeviceType", (jlong) pDevDesc->DeviceType);
addToMap(env, hashMap, methPut, clsLong, longInit, "Removable", (jlong) pDevDesc->RemovableMedia);
if (pDevDesc->VendorIdOffset != 0) {
addToMap(env, hashMap, methPut, clsLong, longInit, "VendorID", &OutBuf[pDevDesc->VendorIdOffset]);
}
if (pDevDesc->ProductIdOffset != 0) {
addToMap(env, hashMap, methPut, clsLong, longInit, "ProductID", &OutBuf[pDevDesc->ProductIdOffset]);
}
}
STORAGE_BUS_TYPE t;
CloseHandle(hDevice);
return hashMap;
}
void IPhysicalDrive::GetPartitionInfo(PList* lpList)
{
lpList->DeleteContents();
BYTE bLayoutInfo[20240];
DISK_GEOMETRY dg;
for( int iDrive = 0; iDrive < 8; iDrive++ )
{
if( !Open(iDrive) )
continue;
if( GetDriveGeometryEx( (DISK_GEOMETRY_EX*) bLayoutInfo, sizeof(bLayoutInfo) ) )
{
DISK_GEOMETRY& dgref = (((DISK_GEOMETRY_EX*)bLayoutInfo)->Geometry);
dg = dgref;
PartitionInfo* p = new PartitionInfo();
p->m_dwDrive = (DWORD) iDrive;
p->m_dwPartition = 0;
p->m_bIsPartition = TRUE;
p->m_dwBytesPerSector = dg.BytesPerSector;
p->m_NumberOfSectors = dg.Cylinders.QuadPart;
p->m_NumberOfSectors *= dg.SectorsPerTrack;
p->m_NumberOfSectors *= dg.TracksPerCylinder;
p->m_StartingOffset = 0;
p->m_StartingSector = 0;
p->m_PartitionLength = p->m_NumberOfSectors;
p->m_PartitionLength *= dg.BytesPerSector;
lpList->AddTail(p);
if( GetDriveLayoutEx( bLayoutInfo, sizeof(bLayoutInfo) ) )
{
PDRIVE_LAYOUT_INFORMATION_EX pLI = (PDRIVE_LAYOUT_INFORMATION_EX)bLayoutInfo;
for( DWORD iPartition = 0; iPartition < pLI->PartitionCount; iPartition++ )
{
PARTITION_INFORMATION_EX* pi = &(pLI->PartitionEntry[iPartition]);
PartitionInfo* p = new PartitionInfo();
p->m_dwDrive = (DWORD) iDrive;
p->m_dwPartition = (DWORD) iPartition;
p->m_bIsPartition = TRUE;
p->m_dwBytesPerSector = dg.BytesPerSector;
p->m_NumberOfSectors = pi->PartitionLength.QuadPart;
p->m_NumberOfSectors /= dg.BytesPerSector;
p->m_StartingOffset = pi->StartingOffset.QuadPart;
p->m_StartingSector = p->m_StartingOffset;
p->m_StartingSector /= dg.BytesPerSector;
p->m_PartitionLength = pi->PartitionLength.QuadPart;
lpList->AddTail(p);
}
}
}
else
{
if( GetDriveGeometry( &dg ) )
{
PartitionInfo* p = new PartitionInfo();
p->m_dwDrive = (DWORD) iDrive;
p->m_dwPartition = 0;
p->m_bIsPartition = FALSE;
p->m_dwBytesPerSector = dg.BytesPerSector;
p->m_NumberOfSectors = dg.Cylinders.QuadPart;
p->m_NumberOfSectors *= dg.SectorsPerTrack;
p->m_NumberOfSectors *= dg.TracksPerCylinder;
p->m_StartingOffset = 0;
p->m_StartingSector = 0;
p->m_PartitionLength = p->m_NumberOfSectors;
p->m_PartitionLength *= dg.BytesPerSector;
lpList->AddTail(p);
if( GetDriveLayout( bLayoutInfo, sizeof(bLayoutInfo) ) )
{
PDRIVE_LAYOUT_INFORMATION pLI = (PDRIVE_LAYOUT_INFORMATION)bLayoutInfo;
for( DWORD iPartition = 0; iPartition < pLI->PartitionCount; iPartition++ )
{
PARTITION_INFORMATION* pi = &(pLI->PartitionEntry[iPartition]);
if( !pi->PartitionLength.QuadPart )
continue;
PartitionInfo* p = new PartitionInfo();
p->m_dwDrive = (DWORD) iDrive;
p->m_dwPartition = (DWORD) iPartition;
p->m_bIsPartition = TRUE;
p->m_dwBytesPerSector = dg.BytesPerSector;
p->m_NumberOfSectors = pi->PartitionLength.QuadPart;
p->m_NumberOfSectors /= dg.BytesPerSector;
p->m_StartingOffset = pi->StartingOffset.QuadPart;
p->m_StartingSector = p->m_StartingOffset;
p->m_StartingSector /= dg.BytesPerSector;
p->m_PartitionLength = pi->PartitionLength.QuadPart;
lpList->AddTail(p);
}
}
}
}
Close();
}
}
JNIEXPORT jobject JNICALL Java_org_gudy_azureus2_platform_win32_access_impl_AEWin32AccessInterface_getDriveInfo
(JNIEnv *env, jclass cla, jchar driveLetter)
{
jclass clsHashMap = env->FindClass("java/util/HashMap");
jmethodID constHashMap = env->GetMethodID(clsHashMap, "<init>", "()V");
jobject hashMap = env->NewObject(clsHashMap, constHashMap, "");
jmethodID methPut = env->GetMethodID(clsHashMap, "put", "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;");
jclass clsLong = env->FindClass("java/lang/Long");
jmethodID longInit = env->GetMethodID(clsLong, "<init>", "(J)V");
DISK_GEOMETRY pdg; // disk drive geometry structure
BOOL bResult; // generic results flag
ULONGLONG DiskSize; // size of the drive, in bytes
char drive2[4];
wsprintfA(drive2, "%C:\\", driveLetter);
DWORD uType = GetDriveTypeA(drive2);
// CreateFileW on Windows 7 on a Remote Drive that isn't attached will crash this call and cause parent .exe to be unkillable
if (uType == DRIVE_REMOTE) {
return hashMap;
}
HANDLE hDevice;
WCHAR drive[100];
wsprintfW(drive, L"\\\\.\\%C:", driveLetter);
hDevice = CreateFileW((LPCWSTR) drive, // drive to open
0, // no access to the drive
FILE_SHARE_READ | // share mode
FILE_SHARE_WRITE,
NULL, // default security attributes
OPEN_EXISTING, // disposition
0, // file attributes
NULL); // do not copy file attributes
addToMap(env, hashMap, methPut, clsLong, longInit, "DriveType", (jlong) uType);
if (hDevice == INVALID_HANDLE_VALUE) // cannot open the drive
{
return hashMap;
}
bResult = GetDriveGeometry (hDevice, &pdg);
if (bResult)
{
LONGLONG diskSize = pdg.Cylinders.QuadPart * pdg.TracksPerCylinder *
pdg.SectorsPerTrack * pdg.BytesPerSector;
addToMap(env, hashMap, methPut, clsLong, longInit, "MediaType", (jlong) pdg.MediaType);
addToMap(env, hashMap, methPut, clsLong, longInit, "DiskSize", (jlong) diskSize);
}
char OutBuf[1024] = {0}; // good enough, usually about 100 bytes
PSTORAGE_DEVICE_DESCRIPTOR pDevDesc = (PSTORAGE_DEVICE_DESCRIPTOR)OutBuf;
pDevDesc->Size = sizeof(OutBuf);
bResult = GetStorageProperty(hDevice, &pDevDesc);
if (bResult) {
addToMap(env, hashMap, methPut, clsLong, longInit, "BusType", (jlong) pDevDesc->BusType);
addToMap(env, hashMap, methPut, clsLong, longInit, "DeviceType", (jlong) pDevDesc->DeviceType);
addToMap(env, hashMap, methPut, clsLong, longInit, "Removable", (jlong) pDevDesc->RemovableMedia);
if (pDevDesc->VendorIdOffset > 0 && pDevDesc->VendorIdOffset < pDevDesc->Size) {
addToMap(env, hashMap, methPut, "VendorID", &OutBuf[pDevDesc->VendorIdOffset]);
}
if (pDevDesc->ProductIdOffset > 0 && pDevDesc->ProductIdOffset < pDevDesc->Size) {
addToMap(env, hashMap, methPut, "ProductID", &OutBuf[pDevDesc->ProductIdOffset]);
}
if (pDevDesc->ProductRevisionOffset > 0 && pDevDesc->ProductRevisionOffset < pDevDesc->Size) {
addToMap(env, hashMap, methPut, "ProductRevision", &OutBuf[pDevDesc->ProductRevisionOffset]);
}
if (pDevDesc->SerialNumberOffset > 0 && pDevDesc->SerialNumberOffset < pDevDesc->Size) {
addToMap(env, hashMap, methPut, "SerialNumber", &OutBuf[pDevDesc->SerialNumberOffset]);
}
}
STORAGE_DEVICE_NUMBER Strage_Device_Number;
DWORD BytesReturned;
BOOL bResult6 = DeviceIoControl(
hDevice, // handle to a partition
IOCTL_STORAGE_GET_DEVICE_NUMBER, // dwIoControlCode
NULL, // lpInBuffer
0, // nInBufferSize
&Strage_Device_Number, // output buffer
sizeof Strage_Device_Number, // size of output buffer
&BytesReturned, // number of bytes returned
NULL // OVERLAPPED structure
);
if (bResult6) {
addToMap(env, hashMap, methPut, clsLong, longInit, "DeviceNumber", (jlong) Strage_Device_Number.DeviceNumber);
}
char subkey[14];
wsprintfA(subkey, "\\DosDevices\\%C:", driveLetter);
DWORD valuesize;
HKEY key;
int res;
subkey[12] = driveLetter;
res = RegOpenKeyExA( HKEY_LOCAL_MACHINE, "SYSTEM\\MountedDevices", NULL, KEY_QUERY_VALUE, &key);
if(RegQueryValueExA(key, subkey, NULL, NULL, NULL, &valuesize) == ERROR_SUCCESS && valuesize > 8) {
WCHAR *value = new WCHAR[valuesize / 2];
res = RegQueryValueExA(key, subkey, NULL, NULL,(LPBYTE) value, &valuesize);
valuesize /= 2;
if(res == ERROR_SUCCESS)
{
char *devname = new char[valuesize];
int pos = 0;
for (int i = 4; i < valuesize; i ++) {
char c = value[i];
if (c == '{') {
if (devname[pos - 1] == '\\') {
devname[pos - 1] = 0;
}
break;
}
if (c == '#') {
c = '\\';
}
devname[pos] = c;
pos++;
}
if (devname[0] != 0) {
devname[pos++] = 0;
devname[pos++] = 0;
addToMap(env, hashMap, methPut, "OSDeviceID", devname);
CMStuff(devname, env, hashMap, methPut);
}
delete[] devname;
}
delete[] value;
}
RegCloseKey(key);
CloseHandle(hDevice);
return hashMap;
}
void IPhysicalDrive::GetPartitionInfo(std::vector<PartitionInfo*> &list)
{
list.clear();
BYTE bLayoutInfo[20240];
DISK_GEOMETRY dg;
for( int iDrive = 0; iDrive < 8; iDrive++ )
{
if( !Open(iDrive) )
continue;
if( GetDriveGeometryEx( (DISK_GEOMETRY_EX*) bLayoutInfo, sizeof(bLayoutInfo) ) )
{
DISK_GEOMETRY& dgref = (((DISK_GEOMETRY_EX*)bLayoutInfo)->Geometry);
dg = dgref;
PartitionInfo* p = new PartitionInfo();
p->m_dwDrive = (DWORD) iDrive;
p->m_dwPartition = 0;
p->m_bIsPartition = FALSE; //! was TRUE. -AEB
p->m_dwBytesPerSector = dg.BytesPerSector;
p->m_NumberOfSectors = dg.Cylinders.QuadPart;
p->m_NumberOfSectors *= dg.SectorsPerTrack;
p->m_NumberOfSectors *= dg.TracksPerCylinder;
p->m_StartingOffset = 0;
p->m_StartingSector = 0;
p->m_PartitionLength = p->m_NumberOfSectors;
p->m_PartitionLength *= dg.BytesPerSector;
list.push_back(p);
if( GetDriveLayoutEx( bLayoutInfo, sizeof(bLayoutInfo) ) )
{
PDRIVE_LAYOUT_INFORMATION_EX pLI = (PDRIVE_LAYOUT_INFORMATION_EX)bLayoutInfo;
for( DWORD iPartition = 0; iPartition < pLI->PartitionCount; iPartition++ )
{
PARTITION_INFORMATION_EX* pi = &(pLI->PartitionEntry[iPartition]);
PartitionInfo* p = new PartitionInfo();
p->m_dwDrive = (DWORD) iDrive;
p->m_dwPartition = (DWORD) iPartition;
p->m_bIsPartition = TRUE;
p->m_dwBytesPerSector = dg.BytesPerSector;
p->m_NumberOfSectors = pi->PartitionLength.QuadPart;
p->m_NumberOfSectors /= dg.BytesPerSector;
p->m_StartingOffset = pi->StartingOffset.QuadPart;
p->m_StartingSector = p->m_StartingOffset;
p->m_StartingSector /= dg.BytesPerSector;
p->m_PartitionLength = pi->PartitionLength.QuadPart;
if (pi->PartitionStyle == PARTITION_STYLE_MBR)
{
p->m_nPartitionType = pi->Mbr.PartitionType;
}
list.push_back(p);
}
}
}
else
{
if( GetDriveGeometry( &dg ) )
{
PartitionInfo* p = new PartitionInfo();
p->m_dwDrive = (DWORD) iDrive;
p->m_dwPartition = 0;
p->m_bIsPartition = FALSE;
p->m_dwBytesPerSector = dg.BytesPerSector;
p->m_NumberOfSectors = dg.Cylinders.QuadPart;
p->m_NumberOfSectors *= dg.SectorsPerTrack;
p->m_NumberOfSectors *= dg.TracksPerCylinder;
p->m_StartingOffset = 0;
p->m_StartingSector = 0;
p->m_PartitionLength = p->m_NumberOfSectors;
p->m_PartitionLength *= dg.BytesPerSector;
list.push_back(p);
if( GetDriveLayout( bLayoutInfo, sizeof(bLayoutInfo) ) )
{
PDRIVE_LAYOUT_INFORMATION pLI = (PDRIVE_LAYOUT_INFORMATION)bLayoutInfo;
for( DWORD iPartition = 0; iPartition < pLI->PartitionCount; iPartition++ )
{
PARTITION_INFORMATION* pi = &(pLI->PartitionEntry[iPartition]);
if( !pi->PartitionLength.QuadPart )
continue;
PartitionInfo* p = new PartitionInfo();
p->m_dwDrive = (DWORD) iDrive;
p->m_dwPartition = (DWORD) iPartition;
p->m_bIsPartition = TRUE;
p->m_dwBytesPerSector = dg.BytesPerSector;
p->m_NumberOfSectors = pi->PartitionLength.QuadPart;
p->m_NumberOfSectors /= dg.BytesPerSector;
p->m_StartingOffset = pi->StartingOffset.QuadPart;
p->m_StartingSector = p->m_StartingOffset;
p->m_StartingSector /= dg.BytesPerSector;
p->m_PartitionLength = pi->PartitionLength.QuadPart;
list.push_back(p);
}
}
}
}
Close();
}
}
