/*++ Copyright (c) 1996 Microsoft Corporation Module Name: disktest.c Abstract: Abstract Author: Rod Gamache (rodga) 4-Mar-1996 Environment: User Mode Revision History: --*/ #define INITGUID 1 //#include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include //#include #include #include #include #include "clusdisk.h" #include "disksp.h" #include "diskarbp.h" #ifndef ClusterHashGuid #define ClusterHashGuid(Guid) (((PULONG) &Guid)[0] ^ ((PULONG) &Guid)[1] ^ ((PULONG) &Guid)[2] ^ ((PULONG) &Guid)[3]) #endif NTSTATUS GetAssignedLetter ( PWCHAR deviceName, PCHAR driveLetter ); PVOID DoIoctlAndAllocate( IN HANDLE FileHandle, IN DWORD IoControlCode, IN PVOID InBuf, IN ULONG InBufSize, OUT PDWORD BytesReturned ); VOID GetSymbolicLink( IN PCHAR RootName, IN OUT PCHAR ObjectName, IN PDISK_INFO DiskInfo ); HANDLE OpenObject( LPSTR lpstrDirectory, LPSTR lpstrObject, PDISK_INFO DiskInfo ); PSTR PartitionName = "\\Device\\Harddisk%d\\Partition%d"; int __cdecl main( int argc, char *argv[] ); static DWORD Reset( HANDLE fileHandle, int argc, char *argv[] ); static DWORD Reserve( HANDLE fileHandle, int argc, char *argv[] ); static DWORD Release( HANDLE fileHandle, int argc, char *argv[] ); static DWORD Online( HANDLE fileHandle, int argc, char *argv[] ); static DWORD Offline( HANDLE fileHandle, int argc, char *argv[] ); DWORD Claim( HANDLE fileHandle, int argc, char *argv[] ); DWORD EjectVolumes( HANDLE fileHandle, int argc, char *argv[] ); DWORD PokeMountMgr ( VOID ); DWORD EnumMounts( HANDLE fileHandle, int argc, char *argv[] ); DWORD EnumExtents( HANDLE fileHandle, int argc, char *argv[] ); DWORD EnumNodes( HANDLE fileHandle, int argc, char *argv[] ); DWORD EnumDisks( HANDLE fileHandle, int argc, char *argv[] ); DWORD DisableNode( HANDLE fileHandle, int argc, char *argv[] ); DWORD EnableNode( HANDLE fileHandle, int argc, char *argv[] ); DWORD DisableDisk( HANDLE fileHandle, int argc, char *argv[] ); DWORD EnableDisk( HANDLE fileHandle, int argc, char *argv[] ); DWORD GetDiskGeometry( HANDLE fileHandle, int argc, char *argv[] ); DWORD GetScsiAddress( HANDLE fileHandle, int argc, char *argv[] ); DWORD GetDriveLayout( HANDLE fileHandle, int argc, char *argv[] ); DWORD GetDriveLayoutEx( HANDLE fileHandle, int argc, char *argv[] ); LPTSTR BooleanToString( BOOLEAN Value ); void FormatGuid( GUID* Guid, char* Str ); DWORD GetVolumeInfo( HANDLE fileHandle, int argc, char *argv[] ); DWORD SetDriveLayout( HANDLE fileHandle, int argc, char *argv[] ); DWORD Attach( HANDLE fileHandle, int argc, char *argv[] ); DWORD Detach( HANDLE fileHandle, int argc, char *argv[] ); DWORD HoldIO( HANDLE fileHandle, int argc, char *argv[] ); DWORD ResumeIO( HANDLE fileHandle, int argc, char *argv[] ); static DWORD GetPartitionInfo( HANDLE fileHandle, int argc, char *argv[] ); BOOLEAN AssignDriveLetters( PDISK_INFO DiskInfo ); DWORD AssignLetters( HANDLE fileHandle, int argc, char *argv[] ); BOOLEAN RemoveDriveLetters( PDISK_INFO DiskInfo ); DWORD RemoveLetters( HANDLE fileHandle, int argc, char *argv[] ); DWORD ReadSector( HANDLE fileHandle, int argc, char *argv[] ); DWORD ReadSectorViaIoctl( HANDLE fileHandle, int argc, char *argv[] ); DWORD FixDisk( HANDLE fileHandle, int argc, char *argv[] ); static DWORD FixDriveLayout( HANDLE fileHandle, int argc, char *argv[] ); static DWORD StartReserve( HANDLE fileHandle, int argc, char *argv[] ); static DWORD StopReserve( HANDLE fileHandle, int argc, char *argv[] ); static DWORD Active( HANDLE fileHandle, int argc, char *argv[] ); static DWORD NotClusterCapable( HANDLE fileHandle, int argc, char *argv[] ); static DWORD Test( HANDLE fileHandle, int argc, char *argv[] ); static DWORD Nt4Capable( HANDLE fileHandle, int argc, char *argv[] ); static DWORD GetDriveLetter( PUCHAR deviceNameString ); NTSTATUS GetVolumeInformationFromHandle( HANDLE Handle ); VOID PrintError( IN DWORD ErrorCode ); DWORD GetSerialNumber( HANDLE FileHandle ); static void usage( char *programName ); int ExecuteCommand( IN PSTR Command, IN int argc, IN char *argv[] ); // // Global data // PSTR DeviceName; PSTR ProgramName; int __cdecl main( int argc, char *argv[] ) /*++ Routine Description: Description Arguments: None Return Value: None --*/ { #define MAX_DEVICES 99 DWORD logicalDrives; DWORD letter; DWORD index; PSTR command; UCHAR buffer[128]; wchar_t * pBuffer; DWORD status; HANDLE handle; if (argc < 3) { usage( argv[0] ); return -1; } argc--; ProgramName = *argv++; // skip program name argc--; DeviceName = *argv++; argc--; command = *argv++; if ( ( lstrcmpi( DeviceName, "*" ) == 0 ) || ( lstrcmpi( DeviceName, "l*" ) == 0 ) ) { // this is a wildcard request for logical drives. logicalDrives = GetLogicalDrives(); for ( index = 0; index < 27; index++ ) { letter = 'A' + index; if ( (logicalDrives & 1) ) { sprintf( buffer, "%c:", letter ); printf( "\n ** For device ** %s\n", buffer ); DeviceName = buffer; status = ExecuteCommand( command, argc, argv ); // Don't stop on error. } logicalDrives = logicalDrives >> 1; } // for } else if ( lstrcmpi( DeviceName, "p*" ) == 0 ) { pBuffer = (wchar_t *)buffer; for ( index = 0; index < MAX_DEVICES; index++ ) { DWORD accessMode = GENERIC_READ; DWORD shareMode = FILE_SHARE_READ; wsprintfW( pBuffer, L"\\\\.\\PhysicalDrive%u", index ); handle = CreateFileW( pBuffer, shareMode, shareMode, NULL, OPEN_EXISTING, 0, NULL ); status = ERROR_INVALID_HANDLE; if ( handle != INVALID_HANDLE_VALUE ) { CloseHandle( handle ); status = ERROR_SUCCESS; printf( "\n ** For device ** %ws\n", pBuffer ); sprintf( buffer, "%ws", pBuffer ); DeviceName = buffer; status = ExecuteCommand( command, argc, argv ); if ( status != 0 ) { return( status ); } } } } else { status = ExecuteCommand( command, argc, argv ); } return(status); } int ExecuteCommand( IN PSTR Command, IN int argc, IN char *argv[] ) { PSTR device; HANDLE fileHandle; DWORD accessMode, shareMode; DWORD errorCode; BOOL failed = FALSE; UCHAR deviceNameString[128]; DWORD logicalDrives; DWORD letter; DWORD index; NTSTATUS ntStatus; ANSI_STRING objName; UNICODE_STRING unicodeName; OBJECT_ATTRIBUTES objAttributes; IO_STATUS_BLOCK ioStatusBlock; // // Note it is important to access the device with 0 access mode so that // the file open code won't do extra I/O to the device // shareMode = FILE_SHARE_READ | FILE_SHARE_WRITE; accessMode = GENERIC_READ | GENERIC_WRITE; strcpy(deviceNameString, "\\\\.\\"); strcat(deviceNameString, DeviceName); fileHandle = CreateFile(deviceNameString, accessMode, shareMode, NULL, OPEN_EXISTING, 0, NULL); if ( fileHandle == INVALID_HANDLE_VALUE ) { errorCode = GetLastError(); if ( (errorCode == ERROR_PATH_NOT_FOUND) || (errorCode == ERROR_FILE_NOT_FOUND) ) { strcpy(deviceNameString, "\\Device\\"); strcat(deviceNameString, DeviceName); RtlInitString(&objName, deviceNameString); ntStatus = RtlAnsiStringToUnicodeString( &unicodeName, &objName, TRUE ); if ( !NT_SUCCESS(ntStatus) ) { printf("Error converting device name %s to unicode. Error: %lx\n", deviceNameString, ntStatus); return -1; } InitializeObjectAttributes( &objAttributes, &unicodeName, OBJ_CASE_INSENSITIVE, NULL, NULL ); ntStatus = NtCreateFile( &fileHandle, SYNCHRONIZE | FILE_READ_DATA | FILE_WRITE_DATA, &objAttributes, &ioStatusBlock, NULL, FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ | FILE_SHARE_WRITE, FILE_OPEN, 0, NULL, 0 ); if ( !NT_SUCCESS(ntStatus) ) { failed = TRUE; } RtlFreeUnicodeString( &unicodeName ); } else { printf("Error opening %s. Error: %d\n", deviceNameString, errorCode = GetLastError()); PrintError(errorCode); return -1; } } if ( failed ) { strcpy(deviceNameString, "\\Device\\"); strcat(deviceNameString, DeviceName); //strcat(deviceNameString, "\\Partition0"); RtlInitString(&objName, deviceNameString); ntStatus = RtlAnsiStringToUnicodeString( &unicodeName, &objName, TRUE ); if ( !NT_SUCCESS(ntStatus) ) { printf("Error converting device name %s to unicode. Error: %lx\n", deviceNameString, ntStatus); return -1; } InitializeObjectAttributes( &objAttributes, &unicodeName, OBJ_CASE_INSENSITIVE, NULL, NULL ); ntStatus = NtCreateFile( &fileHandle, SYNCHRONIZE | FILE_READ_DATA | FILE_WRITE_DATA, &objAttributes, &ioStatusBlock, NULL, FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ | FILE_SHARE_WRITE, FILE_OPEN, 0, NULL, 0 ); if ( !NT_SUCCESS(ntStatus) ) { printf("Error opening device %ws. Error: %lx.\n", unicodeName.Buffer, ntStatus ); return -1; } RtlFreeUnicodeString( &unicodeName ); } //printf("Accessing %s ... \n", deviceNameString); if (!_stricmp( Command, "Reset" )) errorCode = Reset( fileHandle, argc, argv ); else if (!_stricmp( Command, "Reserve" )) errorCode = Reserve( fileHandle, argc, argv ); else if (!_stricmp( Command, "Release" )) errorCode = Release( fileHandle, argc, argv ); else if (!_stricmp( Command, "Online" )) errorCode = Online( fileHandle, argc, argv ); else if (!_stricmp( Command, "Offline" )) errorCode = Offline( fileHandle, argc, argv ); else if (!_stricmp( Command, "HoldIO" )) errorCode = HoldIO( fileHandle, argc, argv ); else if (!_stricmp( Command, "ResumeIO" )) errorCode = ResumeIO( fileHandle, argc, argv ); else if (!_stricmp( Command, "Claim" )) errorCode = Claim( fileHandle, argc, argv ); else if (!_stricmp( Command, "EjectVolumes" )) errorCode = EjectVolumes( fileHandle, argc, argv ); else if (!_stricmp( Command, "PokeMountMgr" )) errorCode = PokeMountMgr(); else if (!_stricmp( Command, "EnumMounts" )) errorCode = EnumMounts( fileHandle, argc, argv ); else if (!_stricmp( Command, "EnumExtents" )) errorCode = EnumExtents( fileHandle, argc, argv ); else if (!_stricmp( Command, "EnumNodes" )) errorCode = EnumNodes( fileHandle, argc, argv ); else if (!_stricmp( Command, "EnumDisks" )) errorCode = EnumDisks( fileHandle, argc, argv ); else if (!_stricmp( Command, "DisableNode" )) errorCode = DisableNode( fileHandle, argc, argv ); else if (!_stricmp( Command, "EnableNode" )) errorCode = EnableNode( fileHandle, argc, argv ); else if (!_stricmp( Command, "DisableDisk" )) errorCode = DisableDisk( fileHandle, argc, argv ); else if (!_stricmp( Command, "EnableDisk" )) errorCode = EnableDisk( fileHandle, argc, argv ); else if (!_stricmp( Command, "GetDiskGeometry" )) errorCode = GetDiskGeometry( fileHandle, argc, argv ); else if (!_stricmp( Command, "GetScsiAddress" )) errorCode = GetScsiAddress( fileHandle, argc, argv ); else if (!_stricmp( Command, "GetVolumeInfo" )) errorCode = GetVolumeInfo( fileHandle, argc, argv ); else if (!_stricmp( Command, "GetDriveLayout" )) errorCode = GetDriveLayout( fileHandle, argc, argv ); else if (!_stricmp( Command, "GetDriveLayoutEx" )) errorCode = GetDriveLayoutEx( fileHandle, argc, argv ); else if (!_stricmp( Command, "SetDriveLayout" )) errorCode = SetDriveLayout( fileHandle, argc, argv ); else if (!_stricmp( Command, "GetPartitionInfo" )) errorCode = GetPartitionInfo( fileHandle, argc, argv ); else if (!_stricmp( Command, "AssignLetters" )) errorCode = AssignLetters( fileHandle, argc, argv ); else if (!_stricmp( Command, "RemoveLetters" )) errorCode = RemoveLetters( fileHandle, argc, argv ); else if (!_stricmp( Command, "ReadSector" )) errorCode = ReadSector( fileHandle, argc, argv ); else if (!_stricmp( Command, "rs" )) errorCode = ReadSectorViaIoctl( fileHandle, argc, argv ); else if (!_stricmp( Command, "Attach" )) errorCode = Attach( fileHandle, argc, argv ); else if (!_stricmp( Command, "Detach" )) errorCode = Detach( fileHandle, argc, argv ); else if (!_stricmp( Command, "FixDisk" )) errorCode = FixDisk( fileHandle, argc, argv ); else if (!_stricmp( Command, "FixDriveLayout" )) errorCode = FixDriveLayout( fileHandle, argc, argv ); else if (!_stricmp( Command, "StartReserve" )) errorCode = StartReserve( fileHandle, argc, argv ); else if (!_stricmp( Command, "StopReserve" )) errorCode = StopReserve( fileHandle, argc, argv ); else if (!_stricmp( Command, "Test" )) errorCode = Test( fileHandle, argc, argv ); else if (!_stricmp( Command, "NT4Capable" )) errorCode = Nt4Capable( fileHandle, argc, argv ); else if (!_stricmp( Command, "Active")) errorCode = Active( fileHandle, argc, argv ); else if (!_stricmp( Command, "Capable")) errorCode = NotClusterCapable( fileHandle, argc, argv ); else if (!_stricmp( Command, "GetDriveLetter")) errorCode = GetDriveLetter( deviceNameString ); else if (!_stricmp( Command, "GetSerialNumber")) errorCode = GetSerialNumber( fileHandle ); else { printf( "Invalid command.\n" ); CloseHandle( fileHandle ); usage( ProgramName ); return(-1); } CloseHandle( fileHandle ); if (errorCode != ERROR_SUCCESS) { printf( "Error performing %s:, error %u.\n", Command, errorCode ); PrintError(errorCode); printf( "%s: failed.\n", ProgramName ); return(-1); } else return(0); } static DWORD Reset( HANDLE fileHandle, int argc, char *argv[] ) /*++ Routine Description: Description Arguments: None Return Value: None --*/ { BOOL success; DWORD errorCode, bytesReturned; SCSI_PASS_THROUGH scsiBlock; SCSI_ADDRESS scsiAddress; STORAGE_BUS_RESET_REQUEST storageReset; if (argc != 0) { printf( "usage: Reset\n" ); return ERROR_INVALID_NAME; } success = DeviceIoControl(fileHandle, IOCTL_SCSI_GET_ADDRESS, NULL, 0, &scsiAddress, sizeof(SCSI_ADDRESS), &bytesReturned, FALSE ); if ( !success || bytesReturned < sizeof(DWORD) ) { printf( "Error reading SCSI address, error = %d\n", errorCode = GetLastError()); PrintError(errorCode); return errorCode; } scsiBlock.PathId = scsiAddress.PathId; scsiBlock.TargetId = scsiAddress.TargetId; scsiBlock.Lun = 0; scsiBlock.Length = sizeof(SCSI_PASS_THROUGH); success = DeviceIoControl(fileHandle, IOCTL_DISK_CLUSTER_RESET_BUS, &scsiBlock, sizeof(SCSI_PASS_THROUGH), NULL, 0, &bytesReturned, FALSE); if (!success) { storageReset.PathId = scsiAddress.PathId; success = DeviceIoControl(fileHandle, IOCTL_STORAGE_RESET_BUS, &storageReset, sizeof(STORAGE_BUS_RESET_REQUEST), NULL, 0, &bytesReturned, FALSE); if (!success) { printf( "Error performing bus reset; error was %d\n", errorCode = GetLastError()); PrintError(errorCode); return errorCode; } } return ERROR_SUCCESS; } static DWORD Test( HANDLE fileHandle, int argc, char *argv[] ) /*++ Routine Description: Description Arguments: None Return Value: None --*/ { BOOL success; DWORD errorCode, bytesReturned; if (argc != 0) { printf( "usage: Test\n" ); return ERROR_INVALID_NAME; } success = DeviceIoControl(fileHandle, IOCTL_DISK_CLUSTER_TEST, NULL, 0, NULL, 0, &bytesReturned, FALSE); if (!success) { printf( "Error performing test; error was %d\n", errorCode = GetLastError()); PrintError(errorCode); return errorCode; } return ERROR_SUCCESS; } static DWORD Nt4Capable( HANDLE fileHandle, int argc, char *argv[] ) /*++ Routine Description: Description Arguments: None Return Value: None --*/ { BOOL success; DWORD errorCode, bytesReturned; if (argc != 0) { printf( "usage: NT4Capable\n" ); return ERROR_INVALID_NAME; } success = DeviceIoControl(fileHandle, IOCTL_DISK_CLUSTER_NT4_CAPABLE, NULL, 0, NULL, 0, &bytesReturned, FALSE); if (!success) { printf( "Error performing NT4Capable; error was %d\n", errorCode = GetLastError()); PrintError(errorCode); return errorCode; } return ERROR_SUCCESS; } static DWORD NotClusterCapable( HANDLE fileHandle, int argc, char *argv[] ) /*++ Routine Description: Description Arguments: None Return Value: None --*/ { BOOL success; DWORD errorCode, bytesReturned; if (argc != 0) { printf( "usage: Capable\n" ); return ERROR_INVALID_NAME; } success = DeviceIoControl(fileHandle, IOCTL_DISK_CLUSTER_NOT_CLUSTER_CAPABLE, NULL, 0, NULL, 0, &bytesReturned, FALSE); if (!success) { printf( "Error performing Capable; error was %d\n", errorCode = GetLastError()); PrintError(errorCode); return errorCode; } return ERROR_SUCCESS; } static DWORD StartReserve( HANDLE fileHandle, int argc, char *argv[] ) /*++ Routine Description: Description Arguments: None Return Value: None --*/ { BOOL success; DWORD errorCode, bytesReturned; DWORD signature; STRING ansiString; UNICODE_STRING numberString; if (argc != 1) { printf( "usage: StartReserve \n" ); return ERROR_INVALID_NAME; } RtlInitAnsiString( &ansiString, *argv ); printf(" Ansi string for signature is %s\n", ansiString.Buffer ); RtlAnsiStringToUnicodeString( &numberString, &ansiString, TRUE ); errorCode = RtlUnicodeStringToInteger( &numberString, 16, &signature ); RtlFreeUnicodeString( &numberString ); if ( !NT_SUCCESS(errorCode) ) { printf( "Error converting signature to hex number, NT status %u.\n", errorCode ); return(errorCode); } success = DeviceIoControl(fileHandle, IOCTL_DISK_CLUSTER_START_RESERVE, &signature, sizeof(DWORD), NULL, 0, &bytesReturned, FALSE); if (!success) { printf( "Error performing StartReserve; error was %d\n", errorCode = GetLastError()); PrintError(errorCode); return errorCode; } return ERROR_SUCCESS; } static DWORD StopReserve( HANDLE fileHandle, int argc, char *argv[] ) /*++ Routine Description: Description Arguments: None Return Value: None --*/ { BOOL success; DWORD errorCode, bytesReturned; if (argc != 0) { printf( "usage: StopReserve\n" ); return ERROR_INVALID_NAME; } success = DeviceIoControl(fileHandle, IOCTL_DISK_CLUSTER_STOP_RESERVE, NULL, 0, NULL, 0, &bytesReturned, FALSE); if (!success) { printf( "Error performing StopReserve; error was %d\n", errorCode = GetLastError()); PrintError(errorCode); return errorCode; } return ERROR_SUCCESS; } static DWORD Active( HANDLE fileHandle, int argc, char *argv[] ) /*++ Routine Description: Description Arguments: None Return Value: None --*/ { BOOL success; DWORD errorCode, bytesReturned; DWORD signatures[100]; DWORD number; DWORD i; if (argc != 0) { printf( "usage: Active\n" ); return ERROR_INVALID_NAME; } success = DeviceIoControl(fileHandle, IOCTL_DISK_CLUSTER_ACTIVE, NULL, 0, signatures, sizeof(signatures), &bytesReturned, FALSE); if (!success) { printf( "Error performing active; error was %d\n", errorCode = GetLastError()); PrintError(errorCode); return errorCode; } printf(" List of signatures:\n\n"); number = signatures[0]; for ( i = 1; i <= number; i++ ) { printf("\t%08lX\n", signatures[i]); } printf("\n"); return ERROR_SUCCESS; } static DWORD Reserve( HANDLE fileHandle, int argc, char *argv[] ) /*++ Routine Description: Description Arguments: None Return Value: None --*/ { BOOL success; DWORD errorCode, bytesReturned; SCSI_PASS_THROUGH scsiBlock; if (argc != 0) { printf( "usage: Reserve\n" ); return ERROR_INVALID_NAME; } scsiBlock.PathId = 1; scsiBlock.TargetId = 3; scsiBlock.Lun = 0; scsiBlock.Length = sizeof(SCSI_PASS_THROUGH); success = DeviceIoControl(fileHandle, IOCTL_DISK_RESERVE, &scsiBlock, sizeof(SCSI_PASS_THROUGH), &scsiBlock, sizeof(SCSI_PASS_THROUGH), &bytesReturned, FALSE); errorCode = GetLastError(); if ( errorCode == ERROR_NOT_READY ) { success = DeviceIoControl(fileHandle, IOCTL_DISK_CLUSTER_RESERVE, &scsiBlock, sizeof(SCSI_PASS_THROUGH), &scsiBlock, sizeof(SCSI_PASS_THROUGH), &bytesReturned, FALSE); } if (!success) { errorCode = GetLastError(); printf( "Error performing reserve; error was %d\n", errorCode); PrintError(errorCode); return errorCode; } return ERROR_SUCCESS; } // Reserve static DWORD Release( HANDLE fileHandle, int argc, char *argv[] ) /*++ Routine Description: Description Arguments: None Return Value: None --*/ { BOOL success; DWORD errorCode, bytesReturned; SCSI_PASS_THROUGH scsiBlock; if (argc != 0) { printf( "usage: Release\n" ); return ERROR_INVALID_NAME; } scsiBlock.PathId = 1; scsiBlock.TargetId = 3; scsiBlock.Lun = 0; scsiBlock.Length = sizeof(SCSI_PASS_THROUGH); success = DeviceIoControl(fileHandle, IOCTL_DISK_RELEASE, &scsiBlock, sizeof(SCSI_PASS_THROUGH), &scsiBlock, sizeof(SCSI_PASS_THROUGH), &bytesReturned, FALSE); if (!success) { printf( "Error performing release; error was %d\n", errorCode = GetLastError()); PrintError(errorCode); return errorCode; } return ERROR_SUCCESS; } // Release static DWORD Online( HANDLE fileHandle, int argc, char *argv[] ) /*++ Routine Description: Description Arguments: None Return Value: None --*/ { BOOL success; DWORD errorCode, bytesReturned; UCHAR newState; UCHAR oldState; if (argc != 0) { printf( "usage: Online\n" ); return ERROR_INVALID_NAME; } newState = DiskOnline; success = DeviceIoControl(fileHandle, IOCTL_DISK_CLUSTER_SET_STATE, &newState, sizeof(newState), &oldState, sizeof(oldState), &bytesReturned, FALSE); if (!success) { printf( "Error performing Online; error was %d\n", errorCode = GetLastError()); PrintError(errorCode); return errorCode; } return ERROR_SUCCESS; } // Online static DWORD Offline( HANDLE fileHandle, int argc, char *argv[] ) /*++ Routine Description: Description Arguments: None Return Value: None --*/ { BOOL success; DWORD errorCode; DWORD newState; DWORD oldState; DWORD bytesReturned; if (argc != 0) { printf( "usage: Offline\n" ); return ERROR_INVALID_NAME; } newState = DiskOffline; success = DeviceIoControl(fileHandle, IOCTL_DISK_CLUSTER_SET_STATE, &newState, sizeof(newState), &oldState, sizeof(oldState), &bytesReturned, FALSE); if (!success) { printf( "Error performing Offline; error was %d\n", errorCode = GetLastError()); PrintError(errorCode); return errorCode; } return ERROR_SUCCESS; } // Offline DWORD Claim( HANDLE fileHandle, int argc, char *argv[] ) /*++ Routine Description: Description Arguments: None Return Value: None --*/ { BOOL success; DWORD errorCode; DWORD bytesReturned; if (argc != 0) { printf( "usage: Claim \n" ); return ERROR_INVALID_NAME; } success = DeviceIoControl(fileHandle, IOCTL_PARTMGR_CHECK_UNCLAIMED_PARTITIONS, NULL, 0, NULL, 0, &bytesReturned, FALSE); if (!success) { printf( "Error performing Claim; error was %d\n", errorCode = GetLastError()); PrintError(errorCode); return errorCode; } return ERROR_SUCCESS; } // Claim DWORD EjectVolumes( HANDLE fileHandle, int argc, char *argv[] ) /*++ Routine Description: Description Arguments: None Return Value: None --*/ { BOOL success; DWORD errorCode; DWORD bytesReturned; if (argc != 0) { printf( "usage: EjectVolumes \n" ); return ERROR_INVALID_NAME; } success = DeviceIoControl(fileHandle, IOCTL_PARTMGR_EJECT_VOLUME_MANAGERS, NULL, 0, NULL, 0, &bytesReturned, FALSE); if (!success) { printf( "Error performing EjectVolumes; error was %d\n", errorCode = GetLastError()); PrintError(errorCode); return errorCode; } return ERROR_SUCCESS; } // EjectVolumes DWORD EnumMounts( HANDLE fileHandle, int argc, char *argv[] ) /*++ Routine Description: Description Arguments: None Return Value: None --*/ { BOOL success; DWORD status; DWORD bytesReturned; HANDLE handle; HANDLE mHandle; DWORD i; DWORD signature; UCHAR uniqueId[MAX_PATH]; DWORD idLength; STRING ansiString; UNICODE_STRING numberString; UCHAR volumeName[MAX_PATH]; UCHAR driveLetter; if (argc > 1) { printf( "usage: EnumMounts [signature]\n" ); return ERROR_INVALID_NAME; } if ( argc == 1 ) { RtlInitAnsiString( &ansiString, *argv ); printf(" Ansi string for signature is %s\n", ansiString.Buffer ); RtlAnsiStringToUnicodeString( &numberString, &ansiString, TRUE ); status = RtlUnicodeStringToInteger( &numberString, 16, &signature ); RtlFreeUnicodeString( &numberString ); if ( !NT_SUCCESS(status) ) { printf( "Error converting signature to hex number, NT status %u.\n", status ); return(status); } } else { signature = 0; } status = DevfileOpen( &mHandle, MOUNTMGR_DEVICE_NAME ); if ( status != ERROR_SUCCESS ) { printf( "DevfileOpen failed for %s, status = %u\n", MOUNTMGR_DEVICE_NAME, status ); return status; } idLength = MAX_PATH; status = FindFirstVolumeForSignature( mHandle, signature, volumeName, MAX_PATH, &handle, uniqueId, &idLength, &driveLetter ); if ( status != ERROR_SUCCESS ) { DevfileClose( mHandle ); if ( status == ERROR_NO_MORE_FILES ) { status = ERROR_SUCCESS; } else { printf( "FindFirstVolume failed, status = %u\n", status ); } return status; } i = 1; while ( status == ERROR_SUCCESS ) { printf( "Found match for volume %s\n", volumeName ); i++; idLength = MAX_PATH; status = FindNextVolumeForSignature( mHandle, signature, handle, volumeName, MAX_PATH, uniqueId, &idLength, &driveLetter ); } FindVolumeClose( handle ); DevfileClose( mHandle ); return ERROR_SUCCESS; } // EnumMounts DWORD EnumExtents( HANDLE fileHandle, int argc, char *argv[] ) /*++ Routine Description: Description Arguments: None Return Value: None --*/ { BOOL success; DWORD status; DWORD bytesReturned; DWORD diskExtentSize; PVOLUME_DISK_EXTENTS diskExtents; DWORD i; if (argc != 0) { printf( "usage: EnumExtents\n" ); return ERROR_INVALID_NAME; } diskExtentSize = sizeof(VOLUME_DISK_EXTENTS); diskExtents = LocalAlloc( LMEM_FIXED, diskExtentSize); if ( !diskExtents ) { return(ERROR_NOT_ENOUGH_MEMORY); } // // Get volume information for disk extents. // success = DeviceIoControl( fileHandle, IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS, NULL, 0, diskExtents, diskExtentSize, &bytesReturned, FALSE ); status = GetLastError(); if ( !success ) { if ( status == ERROR_MORE_DATA ) { diskExtentSize = sizeof(VOLUME_DISK_EXTENTS) + (sizeof(DISK_EXTENT) * diskExtents->NumberOfDiskExtents); LocalFree( diskExtents ); diskExtents = LocalAlloc( LMEM_FIXED, diskExtentSize); if ( !diskExtents ) { return(ERROR_NOT_ENOUGH_MEMORY); } status = ERROR_SUCCESS; success = DeviceIoControl( fileHandle, IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS, NULL, 0, diskExtents, diskExtentSize, &bytesReturned, FALSE ); if ( !success ) { status = GetLastError(); } } } printf( "\n Starting offset Length DiskNumber\n"); printf( " --------------- ------ ----------\n"); for ( i = 0; i < diskExtents->NumberOfDiskExtents; i++ ) { printf( " %08lx %08lx\t\t%08lx\t\t%u\n", diskExtents->Extents[i].StartingOffset.HighPart, diskExtents->Extents[i].StartingOffset.LowPart, diskExtents->Extents[i].ExtentLength.LowPart, diskExtents->Extents[i].DiskNumber ); } return status; } // EnumExtents DWORD EnumNodes( HANDLE fileHandle, int argc, char *argv[] ) /*++ Routine Description: Description Arguments: None Return Value: None --*/ { BOOL success; DWORD status; HDEVINFO hDevInfo; SP_DEVINFO_DATA devInfoData; DWORD index; DWORD size; LPDWORD dwGuid; UCHAR devDesc[MAX_PATH]; UCHAR devID[MAX_PATH]; hDevInfo = SetupDiGetClassDevs( NULL, NULL, NULL, DIGCF_ALLCLASSES | DIGCF_PRESENT ); if ( hDevInfo == INVALID_HANDLE_VALUE ) { status = GetLastError(); printf( "SetupDiGetClassDevs failed with error %u\n", status ); return status; } memset( &devInfoData, 0, sizeof(SP_DEVINFO_DATA)); devInfoData.cbSize = sizeof(SP_DEVINFO_DATA); // // First see if anything works... // success = SetupDiEnumDeviceInfo( hDevInfo, 0, &devInfoData ); if ( !success ) { status = GetLastError(); printf( "SetupDiEnumDeviceInfo failed, status = %u\n", status ); return status; } index = 0; while ( SetupDiEnumDeviceInfo( hDevInfo, index, &devInfoData ) ) { devDesc[0] = '\0'; size = sizeof(devDesc); printf( "Index = %u\n", index ); if ( CM_Get_DevNode_Registry_Property( devInfoData.DevInst, CM_DRP_DEVICEDESC, NULL, devDesc, &size, 0 ) == 0 ) { printf( "Device description = %s\n", devDesc ); dwGuid = (LPDWORD)&devInfoData.ClassGuid; printf( " GUID = %lx, %lx, %lx, %lx\n", dwGuid[0], dwGuid[1], dwGuid[2], dwGuid[3] ); devID[0] = '\0'; CM_Get_Device_ID( devInfoData.DevInst, devID, sizeof(devID), 0 ); if ( devID[0] ) { printf( " Device Id = %s\n", devID ); } } index++; } return ERROR_SUCCESS; } // EnumNodes DWORD EnumDisks( HANDLE fileHandle, int argc, char *argv[] ) /*++ Routine Description: Description Arguments: None Return Value: None --*/ { DWORD status; BOOL success; HDEVINFO DeviceInfoSet; SP_DEVICE_INTERFACE_DATA DeviceInterfaceData; DWORD i; PSP_DEVICE_INTERFACE_DETAIL_DATA_W DeviceInterfaceDetailData = NULL; DWORD DeviceInterfaceDetailDataSize = 0; DWORD RequiredSize; SP_DEVINFO_DATA DeviceInfoData; SP_PROPCHANGE_PARAMS PropChangeParams; BOOL disable = FALSE; BOOL parent = FALSE; //GUID mountDevGuid; GUID diskDevGuid; HANDLE devHandle; UCHAR driveLayoutBuf[sizeof(DRIVE_LAYOUT_INFORMATION) + (sizeof(PARTITION_INFORMATION) * 64 )]; PDRIVE_LAYOUT_INFORMATION driveLayout = (PDRIVE_LAYOUT_INFORMATION)driveLayoutBuf; if (argc > 1) { printf( "usage: EnumDisks [DISABLE | PARENT]\n" ); return ERROR_INVALID_NAME; } if ( argc == 1 ) { if (!_stricmp( *argv, "Disable" )) disable = TRUE; else if (!_stricmp( *argv, "Parent" )) parent = TRUE; else { printf( "usage: EnumDisks [DISABLE | PARENT]\n" ); return ERROR_INVALID_NAME; } } memcpy( &diskDevGuid, &DiskClassGuid, sizeof(GUID) ); //memcpy( &mountDevGuid, &MOUNTDEV_MOUNTED_DEVICE_GUID, sizeof(GUID) ); DeviceInfoSet = SetupDiGetClassDevs(&diskDevGuid, NULL, NULL, DIGCF_DEVICEINTERFACE | DIGCF_PRESENT ); DeviceInterfaceData.cbSize = sizeof(SP_DEVICE_INTERFACE_DATA); DeviceInfoData.cbSize = sizeof(SP_DEVINFO_DATA); for(i = 0; SetupDiEnumDeviceInterfaces(DeviceInfoSet, NULL, &diskDevGuid, i, &DeviceInterfaceData); i++) { // // To retrieve the device interface name (e.g., that you can call // CreateFile() on... // while(!SetupDiGetDeviceInterfaceDetailW(DeviceInfoSet, &DeviceInterfaceData, DeviceInterfaceDetailData, DeviceInterfaceDetailDataSize, &RequiredSize, &DeviceInfoData) ) { // // We failed to get the device interface detail data--was it because // our buffer was too small? (Hopefully so!) // status = GetLastError(); //printf("Call to SetupDiGetDeviceInterfaceData failed status = %u, required size = %u\n", // status, RequiredSize); // Free our current buffer since we failed anyway. free(DeviceInterfaceDetailData); DeviceInterfaceDetailData = NULL; if(status != ERROR_INSUFFICIENT_BUFFER) { // // Failure! // break; } DeviceInterfaceDetailData = malloc(RequiredSize); if(DeviceInterfaceDetailData) { DeviceInterfaceDetailDataSize = RequiredSize; DeviceInterfaceDetailData->cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA_W); } else { // // Failure! // DeviceInterfaceDetailDataSize = 0; break; } } if(!DeviceInterfaceDetailData) { // // We encountered a failure above--abort. // break; } // // Now we may use the device interface name contained in the // DeviceInterfaceDetailData->DevicePath field (e.g., in a call to // CreateFile). // printf("DevicePath = %ws\n", DeviceInterfaceDetailData->DevicePath ); devHandle = CreateFileW( DeviceInterfaceDetailData->DevicePath, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL ); if ( devHandle != INVALID_HANDLE_VALUE ) { // Get signature success = DeviceIoControl( devHandle, IOCTL_DISK_GET_DRIVE_LAYOUT, NULL, 0, driveLayout, sizeof(driveLayoutBuf), &RequiredSize, FALSE ); if ( success ) { printf( " Signature for device = %08lx\n", driveLayout->Signature ); } CloseHandle( devHandle ); } // // To open up the persistent storage registry key associated with this // device interface (e.g., to retrieve it's FriendlyName value entry), // use SetupDiCreateDeviceInterfaceRegKey or // SetupDiOpenDeviceInterfaceRegKey. // // // Notice that we retrieved the associated device information element // in the above call to SetupDiGetDeviceInterfaceDetail. We can thus // use this element in setupapi calls to effect changes to the devnode // (including invoking the class installer and any co-installers that // may be involved). // // For example, here's how we'd disable the device... // if ( disable ) { // Perform following only if we are supposed to disable #ifdef PERSISTENT PropChangeParams.ClassInstallHeader.cbSize = sizeof(SP_CLASSINSTALL_HEADER); PropChangeParams.ClassInstallHeader.InstallFunction = DIF_PROPERTYCHANGE; PropChangeParams.StateChange = DICS_DISABLE; PropChangeParams.Scope = DICS_FLAG_GLOBAL; // // No need to set PropChangeParams.HwProfile since we're doing global // property change. // if( !SetupDiSetClassInstallParamsW(DeviceInfoSet, &DeviceInfoData, (PSP_CLASSINSTALL_HEADER)&PropChangeParams, sizeof(PropChangeParams) ) ) { status = GetLastError(); printf( "SetupDiSetClassInstallParams failed with %u\n", status ); continue; } if ( !SetupDiCallClassInstaller(DIF_PROPERTYCHANGE, DeviceInfoSet, &DeviceInfoData ) ) { status = GetLastError(); printf( "SetupDiCallClassInstaller failed with %u\n", status ); continue; } printf("Disabled!\n"); getchar(); // // ...and here's how we'd re-enable it... // PropChangeParams.StateChange = DICS_ENABLE; if ( !SetupDiSetClassInstallParamsW(DeviceInfoSet, &DeviceInfoData, (PSP_CLASSINSTALL_HEADER)&PropChangeParams, sizeof(PropChangeParams) ) ) { status = GetLastError(); printf( "SetupDiSetClassInstallParams failed with %u\n", status ); continue; } if ( !SetupDiCallClassInstaller(DIF_PROPERTYCHANGE, DeviceInfoSet, &DeviceInfoData ) ) { status = GetLastError(); printf( "SetupDiCallClassInstaller failed with %u\n", status ); } #else #if 0 // we don't support multiple switches together - this would need disable // and parent set together! // // Try to find parent // if ( parent ) { status = CM_Get_Parent( parentDev, DeviceInfoData.DevInst, 0 ); if ( status != ERROR_SUCCESS ) { printf( "CM_Get_Parent failed with %u\n", status ); continue; } } #endif // // NOTE: The code above does a persistent disable/enable. If you only // wanted this to be temporary (i.e., in effect till reboot), then you // could retrieve the devnode handle from the DeviceInfoData.DevInst // field and call CM_Disable_DevNode and CM_Enable_DevNode directly. // status = CM_Disable_DevNode( DeviceInfoData.DevInst, 0 ); if ( status != ERROR_SUCCESS ) { printf( "CM_Disable_DevNode failed with %u\n", status ); continue; } printf("Disabled!\n"); getchar(); status = CM_Enable_DevNode( DeviceInfoData.DevInst, 0 ); if ( status != ERROR_SUCCESS ) { printf( "CM_Enable_DevNode failed with %u\n", status ); } #endif //PERSISTENT } else { // If we are supposed to disable the disk // // Try to find parent // if ( parent ) { DEVINST parentDev; DEVINST pParentDev = 0; WCHAR outBuffer[MAX_PATH]; HDEVINFO devInfoSet; SP_DEVINFO_DATA devInfoData; SP_DEVICE_INTERFACE_DATA devInterfaceData; do { status = CM_Get_Parent( &parentDev, DeviceInfoData.DevInst, 0 ); if ( status != ERROR_SUCCESS ) { printf( "CM_Get_Parent failed with %u\n", status ); break; } if ( pParentDev == parentDev ) { break; } pParentDev = parentDev; status = CM_Get_Device_IDW( parentDev, outBuffer, sizeof(outBuffer)/sizeof(WCHAR), 0 ); if ( status != ERROR_SUCCESS ) { printf( "CM_Get_Parent failed with %u\n", status ); //status = ERROR_SUCCESS; } else { printf( " ParentDev = %ws\n", outBuffer ); } } while ( status == ERROR_SUCCESS ); } } } SetupDiDestroyDeviceInfoList(DeviceInfoSet); return ERROR_SUCCESS; } // EnumDisks DWORD DisableNode( HANDLE fileHandle, int argc, char *argv[] ) /*++ Routine Description: Description Arguments: None Return Value: None --*/ { BOOL success; DWORD status; HDEVINFO hDevInfo; GUID devClassDisk; SP_DEVINFO_DATA devInfoData; DWORD index; DWORD size; LPDWORD dwGuid; UCHAR devDesc[MAX_PATH]; UCHAR devID[MAX_PATH]; printf( "Not supported yet\n"); return ERROR_SUCCESS; } // DisableNode DWORD EnableNode( HANDLE fileHandle, int argc, char *argv[] ) /*++ Routine Description: Description Arguments: None Return Value: None --*/ { BOOL success; DWORD status; HDEVINFO hDevInfo; GUID devClassDisk; SP_DEVINFO_DATA devInfoData; DWORD index; DWORD size; LPDWORD dwGuid; UCHAR devDesc[MAX_PATH]; UCHAR devID[MAX_PATH]; printf( "Not supported yet\n"); return ERROR_SUCCESS; } // EnableNode DWORD DisableDisk( HANDLE fileHandle, int argc, char *argv[] ) /*++ Routine Description: Description Arguments: None Return Value: None --*/ { BOOL success; DWORD status; HDEVINFO hDevInfo; GUID devClassDisk; SP_DEVINFO_DATA devInfoData; DWORD index; DWORD size; LPDWORD dwGuid; UCHAR devDesc[MAX_PATH]; UCHAR devID[MAX_PATH]; printf( "Not supported yet\n"); return ERROR_SUCCESS; } // DisableDisk DWORD EnableDisk( HANDLE fileHandle, int argc, char *argv[] ) /*++ Routine Description: Description Arguments: None Return Value: None --*/ { BOOL success; DWORD status; HDEVINFO hDevInfo; GUID devClassDisk; SP_DEVINFO_DATA devInfoData; DWORD index; DWORD size; LPDWORD dwGuid; UCHAR devDesc[MAX_PATH]; UCHAR devID[MAX_PATH]; printf( "Not supported yet\n"); return ERROR_SUCCESS; } // EnableDisk DWORD HoldIO( HANDLE fileHandle, int argc, char *argv[] ) /*++ Routine Description: Description Arguments: None Return Value: None --*/ { BOOL success; DWORD errorCode; DWORD bytesReturned; if (argc != 0) { printf( "usage: HoldIO\n" ); return ERROR_INVALID_NAME; } success = DeviceIoControl( fileHandle, IOCTL_DISK_CLUSTER_HOLD_IO, NULL, 0, NULL, 0, &bytesReturned, FALSE ); if (!success) { printf( "Error performing Hold IO, error %d\n", errorCode = GetLastError()); PrintError(errorCode); return errorCode; } return ERROR_SUCCESS; } // HoldIO DWORD ResumeIO( HANDLE fileHandle, int argc, char *argv[] ) /*++ Routine Description: Description Arguments: None Return Value: None --*/ { BOOL success; DWORD errorCode; DWORD bytesReturned; if (argc != 0) { printf( "usage: ResumeIO\n" ); return ERROR_INVALID_NAME; } success = DeviceIoControl( fileHandle, IOCTL_DISK_CLUSTER_RESUME_IO, NULL, 0, NULL, 0, &bytesReturned, FALSE ); if (!success) { printf( "Error performing Resume IO, error %d\n", errorCode = GetLastError()); PrintError(errorCode); return errorCode; } return ERROR_SUCCESS; } // ResumeIO DWORD GetDiskGeometry( HANDLE fileHandle, int argc, char *argv[] ) /*++ Routine Description: Description Arguments: None Return Value: None --*/ { BOOL success; DWORD errorCode; DWORD bytesReturned; DISK_GEOMETRY diskGeometry; if (argc != 0) { printf( "usage: GetDiskGeometry\n" ); return ERROR_INVALID_NAME; } ZeroMemory( &diskGeometry, sizeof(DISK_GEOMETRY) ); success = DeviceIoControl( fileHandle, IOCTL_DISK_GET_DRIVE_GEOMETRY, NULL, 0, &diskGeometry, sizeof(DISK_GEOMETRY), &bytesReturned, FALSE ); if (!success) { printf( "Error performing GetDiskGeometry, error %d\n", errorCode = GetLastError()); PrintError(errorCode); return errorCode; } if ( bytesReturned < sizeof(DISK_GEOMETRY) ) { printf("Error reading DiskGeometry information. Expected %u bytes, got %u bytes.\n", sizeof(DISK_GEOMETRY), bytesReturned); return(ERROR_INSUFFICIENT_BUFFER); } printf("GetDiskGeometry was successful, we got %d bytes returned.\n", bytesReturned); printf("Cylinders = %lx%lx, TracksPerCylinder = %lx, SectorsPerTrack = %lx, BytesPerSector = %lx\n", diskGeometry.Cylinders.HighPart, diskGeometry.Cylinders.LowPart, diskGeometry.TracksPerCylinder, diskGeometry.SectorsPerTrack, diskGeometry.BytesPerSector); return ERROR_SUCCESS; } // GetDiskGeometry DWORD GetScsiAddress( HANDLE fileHandle, int argc, char *argv[] ) /*++ Routine Description: Description Arguments: None Return Value: None --*/ { BOOL success; DWORD errorCode; DWORD bytesReturned; SCSI_ADDRESS scsiAddress; if (argc != 0) { printf( "usage: GetScsiAddress\n" ); return ERROR_INVALID_NAME; } ZeroMemory( &scsiAddress, sizeof(scsiAddress) ); success = DeviceIoControl( fileHandle, IOCTL_SCSI_GET_ADDRESS, NULL, 0, &scsiAddress, sizeof(DISK_GEOMETRY), &bytesReturned, FALSE ); if (!success) { printf( "Error performing GetScsiAddress, error %d\n", errorCode = GetLastError()); PrintError(errorCode); return errorCode; } if ( bytesReturned < sizeof(scsiAddress) ) { printf("Error reading ScsiAddress information. Expected %u bytes, got %u bytes.\n", sizeof(scsiAddress), bytesReturned); return(ERROR_INSUFFICIENT_BUFFER); } printf("GetScsiAddress was successful, we got %d bytes returned.\n", bytesReturned); printf("PortNumber = %x, PathId = %x, TargetId = %x, Lun = %x\n", scsiAddress.PortNumber, scsiAddress.PathId, scsiAddress.TargetId, scsiAddress.Lun); return ERROR_SUCCESS; } // GetScsiAddress DWORD GetDriveLayout( HANDLE fileHandle, int argc, char *argv[] ) /*++ Routine Description: Description Arguments: None Return Value: None --*/ { BOOL success; DWORD errorCode; DWORD bytesReturned; DWORD harddiskNo; DWORD i; PDRIVE_LAYOUT_INFORMATION driveLayout; PPARTITION_INFORMATION partInfo; if (argc != 0) { printf( "usage: GetDriveLayout\n" ); return ERROR_INVALID_NAME; } driveLayout = DoIoctlAndAllocate(fileHandle, IOCTL_DISK_GET_DRIVE_LAYOUT, NULL, 0, &bytesReturned); if (!driveLayout) { return GetLastError(); } printf("GetDriveLayout was successful, %d bytes returned.\n", bytesReturned); printf("Partition Count = %u \n", driveLayout->PartitionCount); printf("Signature = %lx\n", driveLayout->Signature); printf("\n"); printf("Part# Type Recog BootInd PartOff PartLeng HidSect Rewrite \n"); printf("===== ==== ===== ======= ============ ============ ======= ======= \n"); for (i = 0; i < driveLayout->PartitionCount; i++ ) { partInfo = &driveLayout->PartitionEntry[i]; printf(" %2u %2X %1u %1u %12I64X %12I64X %7u %s \n", partInfo->PartitionNumber, partInfo->PartitionType, partInfo->RecognizedPartition, partInfo->BootIndicator, partInfo->StartingOffset.QuadPart, partInfo->PartitionLength.QuadPart, partInfo->HiddenSectors, BooleanToString( partInfo->RewritePartition ) ); } free( driveLayout ); return ERROR_SUCCESS; } // GetDriveLayout DWORD GetDriveLayoutEx( HANDLE fileHandle, int argc, char *argv[] ) /*++ Routine Description: Description Arguments: None Return Value: None --*/ { PDRIVE_LAYOUT_INFORMATION_EX driveLayout = NULL; PPARTITION_INFORMATION_EX partInfo; DWORD errorCode = NO_ERROR; DWORD bytesReturned; DWORD harddiskNo; DWORD idx; DWORD nameIdx; BOOL success; TCHAR strGuid[MAX_PATH]; TCHAR strType[MAX_PATH]; if ( argc != 0 ) { printf( "usage: GetDriveLayoutEx \n" ); errorCode = ERROR_INVALID_NAME; goto FnExit; } driveLayout = DoIoctlAndAllocate( fileHandle, IOCTL_DISK_GET_DRIVE_LAYOUT_EX, NULL, 0, &bytesReturned ); if ( !driveLayout ) { errorCode = GetLastError(); printf("IOCTL_DISK_GET_DRIVE_LAYOUT_EX failed: %u \n", errorCode); PrintError( errorCode ); goto FnExit; } printf("GetDriveLayoutEx was successful: %d bytes returned.\n", bytesReturned); printf("Partition style = "); if ( PARTITION_STYLE_MBR == driveLayout->PartitionStyle ) { printf("MBR \n"); } else if ( PARTITION_STYLE_GPT == driveLayout->PartitionStyle ) { printf("GPT \n"); } else if ( PARTITION_STYLE_RAW == driveLayout->PartitionStyle ) { printf("RAW \n"); goto FnExit; } else { printf("Unknown \n"); goto FnExit; } printf("Partition Count = %u \n", driveLayout->PartitionCount); if ( PARTITION_STYLE_MBR == driveLayout->PartitionStyle ) { printf("Signature = %lx \n", driveLayout->Mbr.Signature); printf("\n"); printf("Part# Type Recog BootInd PartOff PartLeng HidSect Rewrite \n"); printf("===== ==== ===== ======= ============ ============ ======= ======= \n"); for ( idx = 0; idx < driveLayout->PartitionCount; idx++ ) { partInfo = &driveLayout->PartitionEntry[idx]; if ( PARTITION_STYLE_MBR != partInfo->PartitionStyle ) { printf("Skipping partition: style is not MBR (%u) \n", partInfo->PartitionStyle); continue; } printf(" %2u %2X %1u %1u %12I64X %12I64X %7u %s \n", partInfo->PartitionNumber, partInfo->Mbr.PartitionType, partInfo->Mbr.RecognizedPartition, partInfo->Mbr.BootIndicator, partInfo->StartingOffset.QuadPart, partInfo->PartitionLength.QuadPart, partInfo->Mbr.HiddenSectors, BooleanToString( partInfo->RewritePartition ) ); } } else { FormatGuid( &(driveLayout->Gpt.DiskId), strGuid ); printf("Signature (GUID) = %s \n", strGuid ); printf("Signature (hashed) = %08x \n", ClusterHashGuid( driveLayout->Gpt.DiskId ) ); printf("\n"); printf("Part# PartOff PartLeng Rewrite \n"); printf("===== ================ ================ ======= \n"); for ( idx = 0; idx < driveLayout->PartitionCount; idx++ ) { partInfo = &driveLayout->PartitionEntry[idx]; if ( idx ) { printf("\n"); } if ( PARTITION_STYLE_GPT != partInfo->PartitionStyle ) { printf("Skipping partition: style is not GPT (%u) \n", partInfo->PartitionStyle); continue; } printf(" %2u %16I64X %16I64X %s \n", partInfo->PartitionNumber, partInfo->StartingOffset.QuadPart, partInfo->PartitionLength.QuadPart, BooleanToString( partInfo->RewritePartition ) ); FormatGuid( &(partInfo->Gpt.PartitionType), strGuid); if ( !memcmp( &(partInfo->Gpt.PartitionType), &PARTITION_SYSTEM_GUID, sizeof(GUID) ) ) { sprintf(strType, "System"); } else if ( !memcmp( &(partInfo->Gpt.PartitionType), &PARTITION_MSFT_RESERVED_GUID, sizeof(GUID) ) ) { sprintf(strType, "Microsoft Reserved"); } else if ( !memcmp( &(partInfo->Gpt.PartitionType), &PARTITION_BASIC_DATA_GUID, sizeof(GUID) ) ) { sprintf(strType, "Basic Data"); } else if ( !memcmp( &(partInfo->Gpt.PartitionType), &PARTITION_LDM_METADATA_GUID, sizeof(GUID) ) ) { sprintf(strType, "LDM Metadata"); } else if ( !memcmp( &(partInfo->Gpt.PartitionType), &PARTITION_LDM_DATA_GUID, sizeof(GUID) ) ) { sprintf(strType, "LDM Data"); #if PARTITION_CLUSTER_GUID } else if ( !memcmp( &(partInfo->Gpt.PartitionType), &PARTITION_CLUSTER_GUID, sizeof(GUID) ) ) { sprintf(strType, "Cluster Data"); #endif } else { sprintf(strType, "Unknown partition type"); } printf("\n"); printf(" PartitionType = %s \n", strGuid); printf(" %s \n", strType); FormatGuid(&(partInfo->Gpt.PartitionId), strGuid); printf(" PartitionId = %s \n", strGuid); printf(" Attributes = %I64X \n", partInfo->Gpt.Attributes); printf(" Name: "); for ( nameIdx = 0; nameIdx < 36; nameIdx++ ) { printf("%c", partInfo->Gpt.Name[nameIdx]); } printf("\n"); } } FnExit: free( driveLayout ); return ERROR_SUCCESS; } // GetDriveLayoutEx LPTSTR BooleanToString( BOOLEAN Value ) { if ( Value ) { return "TRUE "; } return "FALSE"; } // BooleanToString void FormatGuid( GUID* Guid, char* Str ) { // // Code from guidgen // sprintf(Str, "{%08lX-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}", // first copy... Guid->Data1, Guid->Data2, Guid->Data3, Guid->Data4[0], Guid->Data4[1], Guid->Data4[2], Guid->Data4[3], Guid->Data4[4], Guid->Data4[5], Guid->Data4[6], Guid->Data4[7]); } DWORD GetVolumeInfo( HANDLE fileHandle, int argc, char *argv[] ) /*++ Routine Description: Description Arguments: None Return Value: None --*/ { BOOL success; DWORD errorCode; PCLUSPROP_PARTITION_INFO partInfo; ANSI_STRING ansiName; UNICODE_STRING unicodeName; NTSTATUS ntStatus; if (argc != 0) { printf( "usage: GetVolumeInfo\n" ); return ERROR_INVALID_NAME; } ntStatus = GetVolumeInformationFromHandle(fileHandle); if ( !NT_SUCCESS(ntStatus) ) { errorCode = RtlNtStatusToDosError( ntStatus ); printf( "GetVolumeInformationFromHandle failed with status %X, %u\n", ntStatus, errorCode ); } partInfo = LocalAlloc( LMEM_FIXED, sizeof(CLUSPROP_PARTITION_INFO) ); if ( !partInfo ) { return ERROR_NOT_ENOUGH_MEMORY; } ZeroMemory( partInfo, sizeof(CLUSPROP_PARTITION_INFO) ); RtlInitString(&ansiName, DeviceName); errorCode = RtlAnsiStringToUnicodeString( &unicodeName, &ansiName, TRUE ); if ( !NT_SUCCESS(errorCode) ) { return(errorCode); } // The following assumes a drive letter is used. // wsprintfW( partInfo->szDeviceName, L"%c:\\", unicodeName.Buffer[0] ); wcsncpy( partInfo->szDeviceName, unicodeName.Buffer, unicodeName.Length ); RtlFreeUnicodeString( &unicodeName ); if ( !GetVolumeInformationW( partInfo->szDeviceName, partInfo->szVolumeLabel, sizeof(partInfo->szVolumeLabel), &partInfo->dwSerialNumber, &partInfo->rgdwMaximumComponentLength, &partInfo->dwFileSystemFlags, partInfo->szFileSystem, sizeof(partInfo->szFileSystem) ) ) { partInfo->szVolumeLabel[0] = L'\0'; errorCode = GetLastError(); printf("Error reading volume information for %ws. Error %u.\n", partInfo->szDeviceName, errorCode); LocalFree( partInfo ); return( errorCode ); } printf("DeviceName = %ws\n", partInfo->szDeviceName); printf("VolumeLabel = %ws\n", partInfo->szVolumeLabel); printf("FileSystemFlags = %lx, FileSystem = %ws\n", partInfo->dwFileSystemFlags, partInfo->szFileSystem); LocalFree( partInfo ); return ERROR_SUCCESS; } // GetVolumeInfo DWORD SetDriveLayout( HANDLE fileHandle, int argc, char *argv[] ) /*++ Routine Description: Description Arguments: None Return Value: None --*/ { BOOL success; DWORD errorCode; DWORD bytesReturned; DWORD driveLayoutSize; PDRIVE_LAYOUT_INFORMATION driveLayout; PPARTITION_INFORMATION partInfo; DWORD index; DWORD partShift = 0; if (argc != 0) { printf( "usage: SetDriveLayout\n" ); return ERROR_INVALID_NAME; } driveLayoutSize = sizeof(DRIVE_LAYOUT_INFORMATION) + (sizeof(PARTITION_INFORMATION) * MAX_PARTITIONS); driveLayout = LocalAlloc( LMEM_FIXED, driveLayoutSize ); if ( !driveLayout ) { return(ERROR_OUTOFMEMORY); } ZeroMemory( driveLayout, driveLayoutSize ); success = DeviceIoControl( fileHandle, IOCTL_DISK_GET_DRIVE_LAYOUT, NULL, 0, driveLayout, driveLayoutSize, &bytesReturned, FALSE ); if (!success) { printf( "Error performing GetDriveLayout; error was %d\n", errorCode = GetLastError()); PrintError(errorCode); LocalFree( driveLayout ); return errorCode; } driveLayoutSize = sizeof(DRIVE_LAYOUT_INFORMATION) + (sizeof(PARTITION_INFORMATION) * (driveLayout->PartitionCount - 1)); if ( bytesReturned < driveLayoutSize ) { printf("Error reading DriveLayout information. Expected %u bytes, got %u bytes.\n", sizeof(DRIVE_LAYOUT_INFORMATION) + (sizeof(PARTITION_INFORMATION) * (driveLayout->PartitionCount - 1)), bytesReturned); LocalFree( driveLayout ); return(ERROR_INSUFFICIENT_BUFFER); } if ( driveLayout->PartitionCount > MAX_PARTITIONS ) { printf("SetDriveLayout, exiting - too many partitions!\n"); LocalFree( driveLayout ); return(ERROR_TOO_MANY_LINKS); } for ( index = 0; (index < driveLayout->PartitionCount) && (index < MAX_PARTITIONS ); index++ ) { partInfo = &driveLayout->PartitionEntry[index]; if ( (partInfo->PartitionType == PARTITION_ENTRY_UNUSED) || !partInfo->RecognizedPartition ) { continue; } if ( (index == 0) && (partInfo->PartitionNumber == 0) ) { partShift = 1; } printf("Partition %u was %s\n", partInfo->PartitionNumber, (partShift? "incremented" : "left alone")); partInfo->PartitionNumber += partShift; } success = DeviceIoControl( fileHandle, IOCTL_DISK_SET_DRIVE_LAYOUT, driveLayout, driveLayoutSize, NULL, 0, &bytesReturned, FALSE ); if ( !success ) { printf("Error performing SetDriveLayout, error %u.\n", errorCode = GetLastError()); PrintError(errorCode); LocalFree( driveLayout ); return(errorCode); } LocalFree( driveLayout ); printf("SetDriveLayout was successful. Set %d bytes.\n", driveLayoutSize); return ERROR_SUCCESS; } // SetDriveLayout static DWORD Attach( HANDLE fileHandle, int argc, char *argv[] ) /*++ Routine Description: Description Arguments: None Return Value: None --*/ { BOOL success; DWORD errorCode; DWORD bytesReturned; DWORD signature; STRING ansiString; UNICODE_STRING numberString; if (argc != 1) { printf( "usage: Attach \n" ); return ERROR_INVALID_NAME; } RtlInitAnsiString( &ansiString, *argv ); printf(" Ansi string for signature is %s\n", ansiString.Buffer ); RtlAnsiStringToUnicodeString( &numberString, &ansiString, TRUE ); errorCode = RtlUnicodeStringToInteger( &numberString, 16, &signature ); RtlFreeUnicodeString( &numberString ); if ( !NT_SUCCESS(errorCode) ) { printf( "Error converting signature to hex number, NT status %u.\n", errorCode ); return(errorCode); } success = DeviceIoControl( fileHandle, IOCTL_DISK_CLUSTER_ATTACH, &signature, sizeof(DWORD), NULL, 0, &bytesReturned, FALSE ); if (!success) { printf( "Error performing ATTACH, error was %d\n", errorCode = GetLastError()); PrintError(errorCode); return errorCode; } return ERROR_SUCCESS; } // Attach static DWORD Detach( HANDLE fileHandle, int argc, char *argv[] ) /*++ Routine Description: Description Arguments: None Return Value: None --*/ { BOOL success; DWORD errorCode; DWORD bytesReturned; DWORD signature; STRING ansiString; UNICODE_STRING numberString; if (argc != 1) { printf( "usage: Detach \n" ); return ERROR_INVALID_NAME; } RtlInitAnsiString( &ansiString, *argv ); printf(" Ansi string for signature is %s\n", ansiString.Buffer ); RtlAnsiStringToUnicodeString( &numberString, &ansiString, TRUE ); errorCode = RtlUnicodeStringToInteger( &numberString, 16, &signature ); RtlFreeUnicodeString( &numberString ); if ( !NT_SUCCESS(errorCode) ) { printf( "Error converting signature to hex number, NT status %u.\n", errorCode ); return(errorCode); } success = DeviceIoControl( fileHandle, IOCTL_DISK_CLUSTER_DETACH, &signature, sizeof(DWORD), NULL, 0, &bytesReturned, FALSE ); if (!success) { printf( "Error performing DETACH, error was %d\n", errorCode = GetLastError()); PrintError(errorCode); return errorCode; } return ERROR_SUCCESS; } // Detach static DWORD GetPartitionInfo( HANDLE fileHandle, int argc, char *argv[] ) /*++ Routine Description: Description Arguments: None Return Value: None --*/ { BOOL success; DWORD errorCode; DWORD bytesReturned; PARTITION_INFORMATION partInfo; if (argc != 0) { printf( "usage: GetPartitionInfo\n" ); return ERROR_INVALID_NAME; } success = DeviceIoControl( fileHandle, IOCTL_DISK_GET_PARTITION_INFO, NULL, 0, &partInfo, sizeof(PARTITION_INFORMATION), &bytesReturned, FALSE ); if (!success) { printf( "Error performing GetPartitionInfo; error was %d\n", errorCode = GetLastError()); PrintError(errorCode); return errorCode; } printf("GetPartitionInfo was successful, we got %d bytes returned.\n\n", bytesReturned); printf("Part# Type Recog BootInd PartOff PartLeng HidSect\n"); #if 0 Part# Type Recog BootInd PartOff PartLeng HidSect xx xx x x xxxxxxxxxxxx xxxxxxxxxxxx xxxxxxx #endif printf(" %2u %2X %1u %1u %12I64X %12I64X %7u\n", partInfo.PartitionNumber, partInfo.PartitionType, partInfo.RecognizedPartition, partInfo.BootIndicator, partInfo.StartingOffset.QuadPart, partInfo.PartitionLength.QuadPart, partInfo.HiddenSectors); return ERROR_SUCCESS; } // GetPartitionInfo DWORD AssignLetters( HANDLE fileHandle, int argc, char *argv[] ) /*++ Routine Description: Description Arguments: None Return Value: None --*/ { DWORD errorCode; LPSTR device; DISK_INFO diskInfo; DWORD count; if (argc != 0) { printf( "usage: AssignLetters\n" ); return ERROR_INVALID_NAME; } diskInfo.FileHandle = fileHandle; --argv; device = *--argv; count = sscanf( device, "physicaldrive%d", &diskInfo.PhysicalDrive ); if ( count != 1 ) { printf("AssignLetters, failed to get device drive number for '%s', count %u.\n", device, count); return(ERROR_INVALID_PARAMETER); } errorCode = AssignDriveLetters( &diskInfo ); return(errorCode); } // AssignLetters DWORD RemoveLetters( HANDLE fileHandle, int argc, char *argv[] ) /*++ Routine Description: Description Arguments: None Return Value: None --*/ { DWORD errorCode = ERROR_SUCCESS; LPSTR device; DISK_INFO diskInfo; DWORD count; UCHAR fileName[MAX_PATH]; UCHAR objectLink[MAX_PATH]; DWORD length; DWORD partitionNumber; DWORD deviceNumber; DWORD maxPartitions = 8; DWORD bytesReturned; HANDLE FileHandle; if (argc != 0) { printf( "usage: RemoveLetters\n" ); return ERROR_INVALID_NAME; } diskInfo.FileHandle = fileHandle; --argv; device = *--argv; count = sscanf( device, "physicaldrive%d", &diskInfo.PhysicalDrive ); if ( count != 1 ) { printf("RemoveLetters, failed to get device drive number for '%s', count %u.\n", device, count); return(ERROR_INVALID_PARAMETER); } //errorCode = RemoveDriveLetters( &diskInfo ); sprintf( objectLink, "PhysicalDrive%d", diskInfo.PhysicalDrive ); GetSymbolicLink( "\\DosDevices\\", objectLink, &diskInfo ); length = sscanf( objectLink, PartitionName, &deviceNumber, &partitionNumber ); if ( length != 2 || partitionNumber != 0 ) { printf("Cannot find partition info for %s.\n", objectLink); maxPartitions = 0; } length = strlen( objectLink ); objectLink[length-1] = '\0'; for ( partitionNumber = 1; partitionNumber <= maxPartitions; partitionNumber++ ) { sprintf( fileName, "%s%d\0", objectLink, partitionNumber ); FileHandle = OpenObject( "\\DosDevices", fileName, &diskInfo ); if ( FileHandle == INVALID_HANDLE_VALUE || FileHandle == NULL ) { #if 0 printf("Error opening partitions on device %s%s, error %u.\n", "\\DosDevices", fileName, GetLastError() ); #endif break; } if ( !DeviceIoControl( FileHandle, FSCTL_DISMOUNT_VOLUME, NULL, 0, NULL, 0, &bytesReturned, NULL ) ) { printf("Error dismounting volume, %u.\n", GetLastError() ); } CloseHandle( FileHandle ); } #if 0 errorCode = RemoveDriveLetters( &diskInfo ); #endif return(errorCode); } // RemoveLetters DWORD ReadSector( HANDLE fileHandle, int argc, char *argv[] ) /*++ Routine Description: Description Arguments: None Return Value: None --*/ { BOOL success; DWORD errorCode; DWORD status; DWORD bytesReturned; DWORD bytesRead; DWORD x,y; DISK_GEOMETRY diskGeometry; LPBYTE buf = 0; INT sectorNo; if (argc != 1) { printf( "usage: ReadSector No\n" ); return ERROR_INVALID_NAME; } status = sscanf(argv[0], "%d", §orNo); if ( 0 == status ) { printf("Unable to get sector number from input \n"); return ERROR_INVALID_PARAMETER; } ZeroMemory( &diskGeometry, sizeof(DISK_GEOMETRY) ); success = DeviceIoControl( fileHandle, IOCTL_DISK_GET_DRIVE_GEOMETRY, NULL, 0, &diskGeometry, sizeof(DISK_GEOMETRY), &bytesReturned, FALSE ); if (!success) { printf( "Error performing GetDiskGeometry, error %d\n", errorCode = GetLastError()); PrintError(errorCode); return errorCode; } if ( bytesReturned < sizeof(DISK_GEOMETRY) ) { printf("Error reading DiskGeometry information. Expected %u bytes, got %u bytes.\n", sizeof(DISK_GEOMETRY), bytesReturned); return(ERROR_INSUFFICIENT_BUFFER); } printf("GetDiskGeometry was successful, we got %d bytes returned.\n", bytesReturned); printf("Cylinders = %lx%lx, TracksPerCylinder = %lx, SectorsPerTrack = %lx, BytesPerSector = %lx\n", diskGeometry.Cylinders.HighPart, diskGeometry.Cylinders.LowPart, diskGeometry.TracksPerCylinder, diskGeometry.SectorsPerTrack, diskGeometry.BytesPerSector); errorCode = ERROR_SUCCESS; __try { buf = VirtualAlloc(0, diskGeometry.BytesPerSector, MEM_COMMIT, PAGE_READWRITE); if(buf == 0) { printf("Virtual Alloc failed\n"); errorCode = GetLastError(); __leave; } printf("Sector %d\n", sectorNo); status = SetFilePointer(fileHandle, diskGeometry.BytesPerSector * sectorNo, NULL, FILE_BEGIN); if( 0xFFFFFFFF == status ) { printf("Error setting file pointer to %lx \n", diskGeometry.BytesPerSector * sectorNo); errorCode = GetLastError(); __leave; } status = ReadFile(fileHandle, buf, diskGeometry.BytesPerSector, &bytesRead, NULL); if( status == 0 ) { printf("Error reading sector %lx \n.", sectorNo); errorCode = GetLastError(); __leave; } if ( bytesRead != diskGeometry.BytesPerSector ) { printf("Error reading sector. Expected %ul bytes, got %ul bytes.\n", diskGeometry.BytesPerSector, bytesRead); errorCode = ERROR_INSUFFICIENT_BUFFER; __leave; } for(x = 0; x < diskGeometry.BytesPerSector; x += 16) { for(y = 0; y < 16; ++y) { BYTE ch = buf[x+y]; if (ch >= ' ' && ch <= '~') { printf(" %c", ch); } else { printf(" %02x", ch); } } printf("\n"); } errorCode = ERROR_SUCCESS; } __finally { if(buf) { VirtualFree(buf, 0, MEM_RELEASE); } } return errorCode; } // ReadSector DWORD ReadSectorViaIoctl( HANDLE fileHandle, int argc, char *argv[] ) /*++ Routine Description: Description Arguments: None Return Value: None --*/ { BOOL success; DWORD errorCode; DWORD bytesReturned; DISK_GEOMETRY diskGeometry; DWORD bytesRead; DWORD status; DWORD x,y; ARBITRATION_READ_WRITE_PARAMS params; LPBYTE buf = 0; INT sectorNo; if (argc != 1) { printf( "usage: rs No\n" ); return ERROR_INVALID_NAME; } status = sscanf(argv[0], "%d", §orNo); if ( 0 == status ) { printf("Unable to get sector number from input \n"); return ERROR_INVALID_PARAMETER; } ZeroMemory( &diskGeometry, sizeof(DISK_GEOMETRY) ); success = DeviceIoControl( fileHandle, IOCTL_DISK_GET_DRIVE_GEOMETRY, NULL, 0, &diskGeometry, sizeof(DISK_GEOMETRY), &bytesReturned, FALSE ); if (!success) { printf( "Error performing GetDiskGeometry, error %d\n", errorCode = GetLastError()); PrintError(errorCode); return errorCode; } if ( bytesReturned < sizeof(DISK_GEOMETRY) ) { printf("Error reading DiskGeometry information. Expected %u bytes, got %u bytes.\n", sizeof(DISK_GEOMETRY), bytesReturned); return(ERROR_INSUFFICIENT_BUFFER); } printf("GetDiskGeometry was successful, we got %d bytes returned.\n", bytesReturned); printf("Cylinders = %lx%lx, TracksPerCylinder = %lx, SectorsPerTrack = %lx, BytesPerSector = %lx\n", diskGeometry.Cylinders.HighPart, diskGeometry.Cylinders.LowPart, diskGeometry.TracksPerCylinder, diskGeometry.SectorsPerTrack, diskGeometry.BytesPerSector); errorCode = ERROR_SUCCESS; __try { buf = VirtualAlloc(0, diskGeometry.BytesPerSector, MEM_COMMIT, PAGE_READWRITE); if(buf == 0) { printf("Virtual Alloc failed\n"); errorCode = GetLastError(); __leave; } printf("Sector %d\n", sectorNo); params.Operation = AE_READ; params.SectorSize = diskGeometry.BytesPerSector; params.SectorNo = sectorNo; params.Buffer = buf; success = DeviceIoControl( fileHandle, IOCTL_DISK_CLUSTER_ARBITRATION_ESCAPE, ¶ms, sizeof(params), NULL, 0, &bytesReturned, FALSE ); if(!success) { printf("Error reading sector %lx\n.", sectorNo); errorCode = GetLastError(); __leave; } for(x = 0; x < diskGeometry.BytesPerSector; x += 16) { for(y = 0; y < 16; ++y) { BYTE ch = buf[x+y]; if (ch >= ' ' && ch <= '~') { printf(" %c", ch); } else { printf(" %02x", ch); } } printf("\n"); } errorCode = ERROR_SUCCESS; } __finally { if(buf) { VirtualFree(buf, 0, MEM_RELEASE); } } return errorCode; } // ReadSectorViaIoctl DWORD FixDisk( HANDLE fileHandle, int argc, char *argv[] ) /*++ Routine Description: Fix the drive layout for the disk. Arguments: Return Value: ERROR_SUCCESS if successful. A Win32 error code on failure. --*/ { DWORD status; DWORD index; DWORD driveLayoutSize; DWORD bytesPerTrack; DWORD bytesPerCylinder; PDRIVE_LAYOUT_INFORMATION driveLayout; PPARTITION_INFORMATION partInfo; BOOL success; BOOL reset = FALSE; DWORD returnLength; DISK_GEOMETRY diskGeometry; LARGE_INTEGER partOffset; LARGE_INTEGER partLength; LARGE_INTEGER partSize; LARGE_INTEGER modulo; if (argc > 1) { printf( "usage: FixDisk [RESET]\n" ); return ERROR_INVALID_NAME; } if ( argc != 0 ) { if ( !_stricmp( *argv, "reset" ) ) { reset = TRUE; } } driveLayoutSize = sizeof(DRIVE_LAYOUT_INFORMATION) + (sizeof(PARTITION_INFORMATION) * (1 + MAX_PARTITIONS)); driveLayout = LocalAlloc( LMEM_FIXED, driveLayoutSize ); if ( !driveLayout ) { printf("FixDisk, failed to allocate drive layout info.\n"); return(ERROR_OUTOFMEMORY); } // // Read the drive capacity to get bytesPerSector and bytesPerCylinder. // success = DeviceIoControl( fileHandle, IOCTL_DISK_GET_DRIVE_GEOMETRY, NULL, 0, &diskGeometry, sizeof(DISK_GEOMETRY), &returnLength, FALSE ); if ( !success ) { printf("FixDriveLayout, error reading drive capacity. Error: %u.\n", status = GetLastError()); LocalFree( driveLayout ); return(status); } printf("FixDriveLayout, bps = %u, spt = %u, tpc = %u.\n", diskGeometry.BytesPerSector, diskGeometry.SectorsPerTrack, diskGeometry.TracksPerCylinder); // // If read of the partition table originally failed, then we rebuild // it! // if ( reset ) { driveLayout->PartitionCount = MAX_PARTITIONS; driveLayoutSize = sizeof(DRIVE_LAYOUT_INFORMATION) + (MAX_PARTITIONS * sizeof(PARTITION_INFORMATION)); driveLayout->Signature = 2196277081; bytesPerTrack = diskGeometry.SectorsPerTrack * diskGeometry.BytesPerSector; bytesPerCylinder = diskGeometry.TracksPerCylinder * bytesPerTrack; partInfo = &driveLayout->PartitionEntry[0]; partLength.QuadPart = bytesPerCylinder * diskGeometry.Cylinders.QuadPart; // // The partition offset is 1 track (in bytes). // Size is media_size - offset, rounded down to cylinder boundary. // partOffset.QuadPart = bytesPerTrack; partSize.QuadPart = partLength.QuadPart - partOffset.QuadPart; modulo.QuadPart = (partOffset.QuadPart + partSize.QuadPart) % bytesPerCylinder; partSize.QuadPart -= modulo.QuadPart; partInfo = driveLayout->PartitionEntry; // // Initialize first partition entry. // partInfo->RewritePartition = TRUE; partInfo->PartitionType = PARTITION_IFS; partInfo->BootIndicator = FALSE; partInfo->StartingOffset.QuadPart = partOffset.QuadPart; partInfo->PartitionLength.QuadPart = partSize.QuadPart; partInfo->HiddenSectors = 0; partInfo->PartitionNumber = 1; // // For now the remaining partition entries are unused. // for ( index = 1; index < driveLayout->PartitionCount; index++ ) { partInfo = &driveLayout->PartitionEntry[index]; partInfo->PartitionType = PARTITION_ENTRY_UNUSED; partInfo->RewritePartition = TRUE; partInfo->BootIndicator = FALSE; partInfo->StartingOffset.QuadPart = 0; partInfo->PartitionLength.QuadPart = 0; partInfo->HiddenSectors = 0; partInfo->PartitionNumber = 0; } } else { // // For now, the remaining partition entries are unused. // for ( index = 0; index < driveLayout->PartitionCount; index++ ) { partInfo = &driveLayout->PartitionEntry[index]; partInfo->RewritePartition = TRUE; partInfo->PartitionNumber = index+1; } #if 0 // // Recalculate the starting offset for the extended partitions. // for ( index = 0; index < driveLayout->PartitionCount; index++ ) { LARGE_INTEGER extendedOffset; LARGE_INTEGER bytesPerSector; bytesPerSector.QuadPart = diskGeometry.BytesPerSector; extendedOffset.QuadPart = 0; partInfo = &driveLayout->PartitionEntry[index]; partInfo->RewritePartition = TRUE; if ( IsContainerPartition(partInfo->PartitionType) ) { // // If this is the first extended partition, then remember // the offset to added to the next partition. // if ( extendedOffset.QuadPart == 0 ) { extendedOffset.QuadPart = bytesPerSector.QuadPart * (LONGLONG)partInfo->HiddenSectors; } else { // // We need to recalculate this extended partition's starting // offset based on the current 'HiddenSectors' field and // the first extended partition's offset. // partInfo->StartingOffset.QuadPart = extendedOffset.QuadPart + (bytesPerSector.QuadPart * (LONGLONG)partInfo->HiddenSectors); partInfo->HiddenSectors = 0; } } } #endif } // // Now set the new partition information. // success = DeviceIoControl( fileHandle, IOCTL_DISK_SET_DRIVE_LAYOUT, driveLayout, driveLayoutSize, NULL, 0, &returnLength, FALSE ); if ( !success ) { printf("FixDisk, error setting partition information. Error: %u.\n", status = GetLastError() ); LocalFree( driveLayout ); return(status); } LocalFree( driveLayout ); return(ERROR_SUCCESS); } // FixDisk static DWORD FixDriveLayout( HANDLE fileHandle, int argc, char *argv[] ) /*++ Routine Description: Fix the (broken) disk. Arguments: Return Value: ERROR_SUCCESS if successful. A Win32 error code on failure. --*/ { DWORD status; DWORD index; DWORD driveLayoutSize; DWORD bytesPerTrack; DWORD bytesPerCylinder; PDRIVE_LAYOUT_INFORMATION driveLayout; PPARTITION_INFORMATION partInfo; BOOL success; DWORD returnLength; DISK_GEOMETRY diskGeometry; LARGE_INTEGER partOffset; LARGE_INTEGER partLength; LARGE_INTEGER partSize; LARGE_INTEGER modulo; driveLayoutSize = sizeof(DRIVE_LAYOUT_INFORMATION) + (sizeof(PARTITION_INFORMATION) * 2 * MAX_PARTITIONS); driveLayout = LocalAlloc( LMEM_FIXED, driveLayoutSize ); if ( !driveLayout ) { printf("FixDriveLayout, failed to allocate drive layout info.\n"); return(ERROR_OUTOFMEMORY); } success = DeviceIoControl( fileHandle, IOCTL_DISK_GET_DRIVE_LAYOUT, NULL, 0, driveLayout, driveLayoutSize, &returnLength, FALSE ); if ( !success ) { printf("FixDriveLayout, error getting partition information. Error: %u.\n", status = GetLastError() ); LocalFree( driveLayout ); return(status); } printf("FixDriveLayout, disk signature is %u, partition count is %u.\n", driveLayout->Signature, driveLayout->PartitionCount); // // Read the drive capacity to get bytesPerSector and bytesPerCylinder. // success = DeviceIoControl( fileHandle, IOCTL_DISK_GET_DRIVE_GEOMETRY, NULL, 0, &diskGeometry, sizeof(DISK_GEOMETRY), &returnLength, FALSE ); if ( !success ) { printf("FixDriveLayout, error reading drive capacity. Error: %u.\n", status = GetLastError()); LocalFree( driveLayout ); return(status); } printf("FixDriveLayout, bps = %u, spt = %u, tpc = %u.\n", diskGeometry.BytesPerSector, diskGeometry.SectorsPerTrack, diskGeometry.TracksPerCylinder); // // If read of the partition table originally failed, then we rebuild // it! // if ( !driveLayout->PartitionCount ) { driveLayout->PartitionCount = MAX_PARTITIONS; bytesPerTrack = diskGeometry.SectorsPerTrack * diskGeometry.BytesPerSector; bytesPerCylinder = diskGeometry.TracksPerCylinder * bytesPerTrack; partInfo = &driveLayout->PartitionEntry[0]; partLength.QuadPart = partInfo->PartitionLength.QuadPart; // // The partition offset is 1 track (in bytes). // Size is media_size - offset, rounded down to cylinder boundary. // partOffset.QuadPart = bytesPerTrack; partSize.QuadPart = partLength.QuadPart - partOffset.QuadPart; modulo.QuadPart = (partOffset.QuadPart + partSize.QuadPart) % bytesPerCylinder; partSize.QuadPart -= modulo.QuadPart; partInfo = driveLayout->PartitionEntry; // // Initialize first partition entry. // partInfo->RewritePartition = TRUE; partInfo->PartitionType = PARTITION_HUGE; partInfo->BootIndicator = FALSE; partInfo->StartingOffset.QuadPart = partOffset.QuadPart; partInfo->PartitionLength.QuadPart = partSize.QuadPart; partInfo->HiddenSectors = 0; partInfo->PartitionNumber = 0; // // For now, the remaining partition entries are unused. // for ( index = 1; index < MAX_PARTITIONS; index++ ) { partInfo->RewritePartition = TRUE; partInfo->PartitionType = PARTITION_ENTRY_UNUSED; partInfo->BootIndicator = FALSE; partInfo->StartingOffset.QuadPart = 0; partInfo->PartitionLength.QuadPart = 0; partInfo->HiddenSectors = 0; partInfo->PartitionNumber = 0; } } else { // // Recalculate the starting offset for the extended partitions. // for ( index = 0; index < driveLayout->PartitionCount; index++ ) { LARGE_INTEGER extendedOffset; LARGE_INTEGER bytesPerSector; bytesPerSector.QuadPart = diskGeometry.BytesPerSector; extendedOffset.QuadPart = 0; partInfo = &driveLayout->PartitionEntry[index]; partInfo->RewritePartition = TRUE; if ( IsContainerPartition(partInfo->PartitionType) ) { // // If this is the first extended partition, then remember // the offset to added to the next partition. // if ( extendedOffset.QuadPart == 0 ) { extendedOffset.QuadPart = bytesPerSector.QuadPart * (LONGLONG)partInfo->HiddenSectors; } else { // // We need to recalculate this extended partition's starting // offset based on the current 'HiddenSectors' field and // the first extended partition's offset. // partInfo->StartingOffset.QuadPart = extendedOffset.QuadPart + (bytesPerSector.QuadPart * (LONGLONG)partInfo->HiddenSectors); partInfo->HiddenSectors = 0; } } } } // // Now set the new partition information. // success = DeviceIoControl( fileHandle, IOCTL_DISK_SET_DRIVE_LAYOUT, driveLayout, driveLayoutSize, NULL, 0, &returnLength, FALSE ); if ( !success ) { printf("FixDriveLayout, error setting partition information. Error: %u.\n", status = GetLastError() ); LocalFree( driveLayout ); return(status); } LocalFree( driveLayout ); return(ERROR_SUCCESS); } // FixDriveLayout static DWORD GetDriveLetter( PUCHAR deviceNameString ) { UCHAR driveLetter; WCHAR deviceName[MAX_PATH]; NTSTATUS status; mbstowcs( deviceName, deviceNameString, strlen(deviceNameString) ); status = GetAssignedLetter(deviceName, &driveLetter); if ( NT_SUCCESS(status) ) { if (driveLetter) { wprintf(L"%ws ----> %c:\n", deviceName, driveLetter); } else { wprintf(L"%ws has no drive letter\n", deviceName); } } return RtlNtStatusToDosError( status ); } static void usage( char *programName ) /*++ Routine Description: Description Arguments: None Return Value: None --*/ { printf( "usage: %s target_device command\n", programName ); printf( "commands:\n" ); printf( "\tReset\n" ); printf( "\tReserve\n" ); printf( "\tRelease\n" ); printf( "\tOnline\n" ); printf( "\tOffline\n" ); printf( "\tClaim\n" ); printf( "\tEjectVolumes\n"); printf( "\tHoldIO\n" ); printf( "\tResumeIO\n" ); printf( "\tPokeMountMgr\n" ); printf( "\tEnumMounts\n" ); printf( "\tEnumExtents\n" ); printf( "\tEnumNodes\n" ); printf( "\tEnumDisks\n" ); printf( "\tGetDiskGeometry\n" ); printf( "\tGetScsiAddress\n" ); printf( "\tGetDriveLayout\n" ); printf( "\tGetDriveLayoutEx\n"); printf( "\tSetDriveLayout\n" ); printf( "\tGetPartitionInfo\n" ); printf( "\tGetVolumeInfo\n" ); printf( "\tGetDriveLetter\n" ); printf( "\tGetSerialNumber\n"); printf( "\tAssignLetters\n" ); printf( "\tRemoveLetters\n" ); printf( "\tReadSector\n" ); printf( "\tTest\n" ); printf( "\tNt4Capable\n" ); printf( "\tAttach [ClusDisk0 device] \n" ); printf( "\tDetach [ClusDisk0 device] \n" ); printf( "\tStartReserve [ClusDisk0 device] \n" ); printf( "\tStopReserve [ClusDisk0 device] \n" ); printf( "\tActive [ClusDisk0 device] \n" ); printf( "target_device wildcards: \n" ); printf( "\tAll physical devices: use p* \n" ); printf( "\tAll logical devices: use l* or * \n" ); } NTSTATUS GetVolumeInformationFromHandle( HANDLE Handle ) { NTSTATUS Status; IO_STATUS_BLOCK IoStatusBlock; UCHAR VolumeInfoBuffer[ sizeof(FILE_FS_VOLUME_INFORMATION) + sizeof(WCHAR) * MAX_PATH ]; UCHAR AttrInfoBuffer[ sizeof(FILE_FS_ATTRIBUTE_INFORMATION) + sizeof(WCHAR) * MAX_PATH ]; ULONG VolumeInfoLength = sizeof(VolumeInfoBuffer); ULONG AttributeInfoLength = sizeof(AttrInfoBuffer); PFILE_FS_VOLUME_INFORMATION VolumeInfo = (PFILE_FS_VOLUME_INFORMATION)VolumeInfoBuffer; PFILE_FS_ATTRIBUTE_INFORMATION AttributeInfo = (PFILE_FS_ATTRIBUTE_INFORMATION)AttrInfoBuffer; ZeroMemory(VolumeInfoBuffer, (sizeof(FILE_FS_VOLUME_INFORMATION) + sizeof(WCHAR) * MAX_PATH)); ZeroMemory(AttrInfoBuffer, (sizeof(FILE_FS_ATTRIBUTE_INFORMATION) + sizeof(WCHAR) * MAX_PATH)); Status = NtQueryVolumeInformationFile( Handle, &IoStatusBlock, VolumeInfo, VolumeInfoLength, FileFsVolumeInformation ); if ( !NT_SUCCESS(Status) ) { return Status; } Status = NtQueryVolumeInformationFile( Handle, &IoStatusBlock, AttributeInfo, AttributeInfoLength, FileFsAttributeInformation ); if ( !NT_SUCCESS(Status) ) { return Status; } AttributeInfo->FileSystemName[AttributeInfo->FileSystemNameLength] = 0; VolumeInfo->VolumeLabel[VolumeInfo->VolumeLabelLength] = 0; printf("\nGetVolumeInformationFromHandle data: \n"); printf("Volume information: \n"); printf(" VolumeCreationTime 0x%lx : %lx \n", VolumeInfo->VolumeCreationTime.HighPart, VolumeInfo->VolumeCreationTime.LowPart); printf(" VolumeSerialNumber 0x%lx \n", VolumeInfo->VolumeSerialNumber); printf(" VolumeLabelLength 0x%lx \n", VolumeInfo->VolumeLabelLength); printf(" SupportsObjects (BOOL) 0x%lx \n", VolumeInfo->SupportsObjects); printf(" VolumeLabel %ws \n", VolumeInfo->VolumeLabel); printf("Attribute Information: \n"); printf(" FileSystemAttributes (Flags) 0x%lx \n", AttributeInfo->FileSystemAttributes); printf(" MaximumComponentNameLength 0x%lx \n", AttributeInfo->MaximumComponentNameLength); printf(" FileSystemNameLength 0x%lx \n", AttributeInfo->FileSystemNameLength); printf(" FileSystemName %ws \n\n", AttributeInfo->FileSystemName); return STATUS_SUCCESS; } #define FIRST_SHOT_SIZE 512 PVOID DoIoctlAndAllocate( IN HANDLE FileHandle, IN DWORD IoControlCode, IN PVOID InBuf, IN ULONG InBufSize, OUT PDWORD BytesReturned ) { UCHAR firstShot[ FIRST_SHOT_SIZE ]; DWORD status = ERROR_SUCCESS; BOOL success; DWORD outBufSize; PVOID outBuf = 0; DWORD bytesReturned; success = DeviceIoControl( FileHandle, IoControlCode, InBuf, InBufSize, &firstShot, sizeof(firstShot), &bytesReturned, (LPOVERLAPPED) NULL ); if ( success ) { outBufSize = bytesReturned; outBuf = malloc( outBufSize ); if (!outBuf) { status = ERROR_OUTOFMEMORY; } else { RtlCopyMemory(outBuf, &firstShot, outBufSize); status = ERROR_SUCCESS; } } else { outBufSize = sizeof(firstShot); for(;;) { status = GetLastError(); // // If it is not a buffer size related error, then we cannot do much // if ( status != ERROR_INSUFFICIENT_BUFFER && status != ERROR_MORE_DATA) { break; } // // Otherwise, try an outbut buffer twice the previous size // outBufSize *= 2; outBuf = malloc( outBufSize ); if ( !outBuf ) { status = ERROR_OUTOFMEMORY; break; } success = DeviceIoControl( FileHandle, IoControlCode, InBuf, InBufSize, outBuf, outBufSize, &bytesReturned, (LPOVERLAPPED) NULL ); if (success) { status = ERROR_SUCCESS; break; } free( outBuf ); } } if (status != ERROR_SUCCESS) { free( outBuf ); // free( 0 ) is legal // outBuf = 0; bytesReturned = 0; } SetLastError( status ); *BytesReturned = bytesReturned; return outBuf; } #define OUTPUT_BUFFER_LEN (1024) #define INPUT_BUFFER_LEN (sizeof(MOUNTMGR_MOUNT_POINT) + 2 * MAX_PATH * sizeof(WCHAR)) static NTSTATUS GetAssignedLetterM ( IN HANDLE MountMgrHandle, IN PWCHAR deviceName, OUT PCHAR driveLetter ) /*++ Routine Description: Get an assigned drive letter from MountMgr, if any Inputs: MountMgrHandle - deviceName - driveLetter - receives drive letter Return value: STATUS_SUCCESS - on success NTSTATUS code - on failure --*/ { DWORD status = STATUS_SUCCESS; PMOUNTMGR_MOUNT_POINT input = NULL; PMOUNTMGR_MOUNT_POINTS output = NULL; PMOUNTMGR_MOUNT_POINT out; DWORD len = wcslen( deviceName ) * sizeof(WCHAR); DWORD bytesReturned; DWORD idx; DWORD outputLen; DWORD inputLen; WCHAR wc; inputLen = INPUT_BUFFER_LEN; input = LocalAlloc( LPTR, inputLen ); if ( !input ) { goto FnExit; } input->SymbolicLinkNameOffset = 0; input->SymbolicLinkNameLength = 0; input->UniqueIdOffset = 0; input->UniqueIdLength = 0; input->DeviceNameOffset = sizeof(MOUNTMGR_MOUNT_POINT); input->DeviceNameLength = (USHORT) len; RtlCopyMemory((PCHAR)input + input->DeviceNameOffset, deviceName, len ); if (len > sizeof(WCHAR) && deviceName[1] == L'\\') { // convert Dos name to NT name ((PWCHAR)(input + input->DeviceNameOffset))[1] = L'?'; } outputLen = OUTPUT_BUFFER_LEN; output = LocalAlloc( LPTR, outputLen ); if ( !output ) { goto FnExit; } status = DevfileIoctl(MountMgrHandle, IOCTL_MOUNTMGR_QUERY_POINTS, input, inputLen, output, outputLen, &bytesReturned); if ( STATUS_BUFFER_OVERFLOW == status ) { outputLen = output->Size; LocalFree( output ); output = LocalAlloc( LPTR, outputLen ); if ( !output ) { goto FnExit; } status = DevfileIoctl(MountMgrHandle, IOCTL_MOUNTMGR_QUERY_POINTS, input, inputLen, output, outputLen, &bytesReturned); } if ( !NT_SUCCESS(status) ) { goto FnExit; } if (driveLetter) { *driveLetter = 0; } for ( idx = 0; idx < output->NumberOfMountPoints; ++idx ) { out = &output->MountPoints[idx]; if (out->SymbolicLinkNameLength/sizeof(WCHAR) == 14 && (_wcsnicmp((PWCHAR)((PCHAR)output + out->SymbolicLinkNameOffset), L"\\DosDevices\\", 12) == 0) && L':' == *((PCHAR)output + out->SymbolicLinkNameOffset + 13*sizeof(WCHAR)) ) { wc = *((PCHAR)output + out->SymbolicLinkNameOffset + 12*sizeof(WCHAR)); if (driveLetter && out->UniqueIdLength) { *driveLetter = (CHAR)toupper((UCHAR)wc); break; } } } FnExit: if ( output ) { LocalFree( output ); } if ( input ) { LocalFree( input ); } return status; } NTSTATUS GetAssignedLetter ( PWCHAR deviceName, PCHAR driveLetter ) { HANDLE MountMgrHandle; DWORD status = DevfileOpen( &MountMgrHandle, MOUNTMGR_DEVICE_NAME ); if (driveLetter) { *driveLetter = 0; } if ( NT_SUCCESS(status) ) { status = GetAssignedLetterM(MountMgrHandle, deviceName, driveLetter); DevfileClose(MountMgrHandle); } return status; } DWORD PokeMountMgr ( VOID ) { HANDLE MountMgrHandle; NTSTATUS ntStatus = DevfileOpen( &MountMgrHandle, MOUNTMGR_DEVICE_NAME ); DWORD status = ERROR_SUCCESS; if ( NT_SUCCESS(ntStatus) ) { BOOL success; DWORD bytesReturned; printf("About to call MOUNTMGR_CHECK_UNPROCESSED_VOLUMES..."); success = DeviceIoControl( MountMgrHandle, IOCTL_MOUNTMGR_CHECK_UNPROCESSED_VOLUMES, NULL, 0, NULL, 0, &bytesReturned, FALSE ); printf("complete.\n"); if (!success) { status = GetLastError(); } DevfileClose(MountMgrHandle); } else { status = RtlNtStatusToDosError(ntStatus); } return status; } VOID PrintError( IN DWORD ErrorCode ) { LPVOID lpMsgBuf; ULONG count; count = FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, ErrorCode, 0, (LPTSTR) &lpMsgBuf, 0, NULL ); if (count != 0) { printf(" (%d) %s\n", ErrorCode, (LPCTSTR) lpMsgBuf); LocalFree( lpMsgBuf ); } else { printf("Format message failed. Error: %d\n", GetLastError()); } } // PrintError DWORD GetSerialNumber( HANDLE FileHandle ) { PSTORAGE_DEVICE_DESCRIPTOR descriptor = NULL; PCHAR sigString; DWORD dwError = NO_ERROR; DWORD descriptorSize; DWORD bytesReturned; STORAGE_PROPERTY_QUERY propQuery; descriptorSize = sizeof( STORAGE_DEVICE_DESCRIPTOR) + 2048; descriptor = LocalAlloc( LPTR, descriptorSize ); if ( !descriptor ) { dwError = GetLastError(); printf("Unable to allocate output buffer: %d \n", dwError); PrintError( dwError ); goto FnExit; } ZeroMemory( &propQuery, sizeof( propQuery ) ); propQuery.PropertyId = StorageDeviceProperty; propQuery.QueryType = PropertyStandardQuery; if ( !DeviceIoControl( FileHandle, IOCTL_STORAGE_QUERY_PROPERTY, &propQuery, sizeof(propQuery), descriptor, descriptorSize, &bytesReturned, NULL ) ) { dwError = GetLastError(); printf("IOCTL_STORAGE_QUERY_PROPERTY failed: %d \n", dwError); PrintError( dwError ); goto FnExit; } if ( !bytesReturned || bytesReturned < sizeof( STORAGE_DEVICE_DESCRIPTOR ) ) { printf("Invalid byte length returned: %d \n", bytesReturned); goto FnExit; } // // IA64 sometimes returns -1 for SerialNumberOffset. // if ( 0 == descriptor->SerialNumberOffset || descriptor->SerialNumberOffset > descriptor->Size ) { printf("No serial number information available \n"); goto FnExit; } // // Serial number string is a zero terminated ASCII string. // // The header ntddstor.h says the for devices with no serial number, // the offset will be zero. This doesn't seem to be true. // // For devices with no serial number, it looks like a string with a single // null character '\0' is returned. // sigString = (PCHAR)descriptor + (DWORD)descriptor->SerialNumberOffset; if ( strlen(sigString) == 0) { printf("Serial number: NULL string returned \n"); } else { printf("Serial number: %s \n", sigString); } FnExit: if ( descriptor ) { LocalFree( descriptor ); } return dwError; } // GetSerialNumber