#include "dfioctl.h" #include #include #pragma warning(disable: 4200) #include #include #include #include "dferr.h" #include "dfhlprs.h" #include "drvfull.h" #include "dfeject.h" #define ARRAYSIZE(a) (sizeof((a))/sizeof((a)[0])) /////////////////////////////////////////////////////////////////////////////// // MEDIA_TYPE _sFLAG_DESCR _mediatypeFD[] = { FLAG_DESCR_COMMENT(Unknown, TEXT("Format is unknown")), FLAG_DESCR_COMMENT(F5_1Pt2_512, TEXT("5.25, 1.2MB, 512 bytes/sector")), FLAG_DESCR_COMMENT(F3_1Pt44_512, TEXT("3.5, 1.44MB, 512 bytes/sector")), FLAG_DESCR_COMMENT(F3_2Pt88_512, TEXT("3.5, 2.88MB, 512 bytes/sector")), FLAG_DESCR_COMMENT(F3_20Pt8_512, TEXT("3.5, 20.8MB, 512 bytes/sector")), FLAG_DESCR_COMMENT(F3_720_512, TEXT("3.5, 720KB, 512 bytes/sector")), FLAG_DESCR_COMMENT(F5_360_512, TEXT("5.25, 360KB, 512 bytes/sector")), FLAG_DESCR_COMMENT(F5_320_512, TEXT("5.25, 320KB, 512 bytes/sector")), FLAG_DESCR_COMMENT(F5_320_1024, TEXT("5.25, 320KB, 1024 bytes/sector")), FLAG_DESCR_COMMENT(F5_180_512, TEXT("5.25, 180KB, 512 bytes/sector")), FLAG_DESCR_COMMENT(F5_160_512, TEXT("5.25, 160KB, 512 bytes/sector")), FLAG_DESCR_COMMENT(RemovableMedia, TEXT("Removable media other than floppy")), FLAG_DESCR_COMMENT(FixedMedia, TEXT("Fixed hard disk media")), FLAG_DESCR_COMMENT(F3_120M_512, TEXT("3.5, 120M Floppy")), FLAG_DESCR_COMMENT(F3_640_512, TEXT("3.5 , 640KB, 512 bytes/sector")), FLAG_DESCR_COMMENT(F5_640_512, TEXT("5.25, 640KB, 512 bytes/sector")), FLAG_DESCR_COMMENT(F5_720_512, TEXT("5.25, 720KB, 512 bytes/sector")), FLAG_DESCR_COMMENT(F3_1Pt2_512, TEXT("3.5 , 1.2Mb, 512 bytes/sector")), FLAG_DESCR_COMMENT(F3_1Pt23_1024, TEXT("3.5 , 1.23Mb, 1024 bytes/sector")), FLAG_DESCR_COMMENT(F5_1Pt23_1024, TEXT("5.25, 1.23MB, 1024 bytes/sector")), FLAG_DESCR_COMMENT(F3_128Mb_512, TEXT("3.5 MO 128Mb 512 bytes/sector")), FLAG_DESCR_COMMENT(F3_230Mb_512, TEXT("3.5 MO 230Mb 512 bytes/sector")), FLAG_DESCR_COMMENT(F8_256_128, TEXT("8, 256KB, 128 bytes/sector")), // FLAG_DESCR_COMMENT(DDS_4mm, TEXT("Tape - DAT DDS1,2,... (all vendors)")), FLAG_DESCR_COMMENT(MiniQic, TEXT("Tape - miniQIC Tape")), FLAG_DESCR_COMMENT(Travan, TEXT("Tape - Travan TR-1,2,3,...")), FLAG_DESCR_COMMENT(QIC, TEXT("Tape - QIC")), FLAG_DESCR_COMMENT(MP_8mm, TEXT("Tape - 8mm Exabyte Metal Particle")), FLAG_DESCR_COMMENT(AME_8mm, TEXT("Tape - 8mm Exabyte Advanced Metal Evap")), FLAG_DESCR_COMMENT(AIT1_8mm, TEXT("Tape - 8mm Sony AIT1")), FLAG_DESCR_COMMENT(DLT, TEXT("Tape - DLT Compact IIIxt, IV")), FLAG_DESCR_COMMENT(NCTP, TEXT("Tape - Philips NCTP")), FLAG_DESCR_COMMENT(IBM_3480, TEXT("Tape - IBM 3480")), FLAG_DESCR_COMMENT(IBM_3490E, TEXT("Tape - IBM 3490E")), FLAG_DESCR_COMMENT(IBM_Magstar_3590, TEXT("Tape - IBM Magstar 3590")), FLAG_DESCR_COMMENT(IBM_Magstar_MP, TEXT("Tape - IBM Magstar MP")), FLAG_DESCR_COMMENT(STK_DATA_D3, TEXT("Tape - STK Data D3")), FLAG_DESCR_COMMENT(SONY_DTF, TEXT("Tape - Sony DTF")), FLAG_DESCR_COMMENT(DV_6mm, TEXT("Tape - 6mm Digital Video")), FLAG_DESCR_COMMENT(DMI, TEXT("Tape - Exabyte DMI and compatibles")), FLAG_DESCR_COMMENT(SONY_D2, TEXT("Tape - Sony D2S and D2L")), FLAG_DESCR_COMMENT(CLEANER_CARTRIDGE, TEXT("Cleaner - All Drive types that support Drive Cleaners")), FLAG_DESCR_COMMENT(CD_ROM, TEXT("Opt_Disk - CD")), FLAG_DESCR_COMMENT(CD_R, TEXT("Opt_Disk - CD-Recordable (Write Once)")), FLAG_DESCR_COMMENT(CD_RW, TEXT("Opt_Disk - CD-Rewriteable")), FLAG_DESCR_COMMENT(DVD_ROM, TEXT("Opt_Disk - DVD-ROM")), FLAG_DESCR_COMMENT(DVD_R, TEXT("Opt_Disk - DVD-Recordable (Write Once)")), FLAG_DESCR_COMMENT(DVD_RW, TEXT("Opt_Disk - DVD-Rewriteable")), FLAG_DESCR_COMMENT(MO_3_RW, TEXT("Opt_Disk - 3.5\" Rewriteable MO Disk")), FLAG_DESCR_COMMENT(MO_5_WO, TEXT("Opt_Disk - MO 5.25\" Write Once")), FLAG_DESCR_COMMENT(MO_5_RW, TEXT("Opt_Disk - MO 5.25\" Rewriteable (not LIMDOW)")), FLAG_DESCR_COMMENT(MO_5_LIMDOW, TEXT("Opt_Disk - MO 5.25\" Rewriteable (LIMDOW)")), FLAG_DESCR_COMMENT(PC_5_WO, TEXT("Opt_Disk - Phase Change 5.25\" Write Once Optical")), FLAG_DESCR_COMMENT(PC_5_RW, TEXT("Opt_Disk - Phase Change 5.25\" Rewriteable")), FLAG_DESCR_COMMENT(PD_5_RW, TEXT("Opt_Disk - PhaseChange Dual Rewriteable")), FLAG_DESCR_COMMENT(ABL_5_WO, TEXT("Opt_Disk - Ablative 5.25\" Write Once Optical")), FLAG_DESCR_COMMENT(PINNACLE_APEX_5_RW, TEXT("Opt_Disk - Pinnacle Apex 4.6GB Rewriteable Optical")), FLAG_DESCR_COMMENT(SONY_12_WO, TEXT("Opt_Disk - Sony 12\" Write Once")), FLAG_DESCR_COMMENT(PHILIPS_12_WO, TEXT("Opt_Disk - Philips/LMS 12\" Write Once")), FLAG_DESCR_COMMENT(HITACHI_12_WO, TEXT("Opt_Disk - Hitachi 12\" Write Once")), FLAG_DESCR_COMMENT(CYGNET_12_WO, TEXT("Opt_Disk - Cygnet/ATG 12\" Write Once")), FLAG_DESCR_COMMENT(KODAK_14_WO, TEXT("Opt_Disk - Kodak 14\" Write Once")), FLAG_DESCR_COMMENT(MO_NFR_525, TEXT("Opt_Disk - Near Field Recording (Terastor)")), FLAG_DESCR_COMMENT(NIKON_12_RW, TEXT("Opt_Disk - Nikon 12\" Rewriteable")), FLAG_DESCR_COMMENT(IOMEGA_ZIP, TEXT("Mag_Disk - Iomega Zip")), FLAG_DESCR_COMMENT(IOMEGA_JAZ, TEXT("Mag_Disk - Iomega Jaz")), FLAG_DESCR_COMMENT(SYQUEST_EZ135, TEXT("Mag_Disk - Syquest EZ135")), FLAG_DESCR_COMMENT(SYQUEST_EZFLYER, TEXT("Mag_Disk - Syquest EzFlyer")), FLAG_DESCR_COMMENT(SYQUEST_SYJET, TEXT("Mag_Disk - Syquest SyJet")), FLAG_DESCR_COMMENT(AVATAR_F2, TEXT("Mag_Disk - 2.5\" Floppy")), FLAG_DESCR_COMMENT(MP2_8mm, TEXT("Tape - 8mm Hitachi")), FLAG_DESCR_COMMENT(DST_S, TEXT("Ampex DST Small Tapes")), FLAG_DESCR_COMMENT(DST_M, TEXT("Ampex DST Medium Tapes")), FLAG_DESCR_COMMENT(DST_L, TEXT("Ampex DST Large Tapes")), FLAG_DESCR_COMMENT(VXATape_1, TEXT("Ecrix 8mm Tape")), FLAG_DESCR_COMMENT(VXATape_2, TEXT("Ecrix 8mm Tape")), FLAG_DESCR_COMMENT(LTO_Ultrium, TEXT("IBM, HP, Seagate LTO Ultrium")), FLAG_DESCR_COMMENT(LTO_Accelis, TEXT("IBM, HP, Seagate LTO Accelis")), }; int _PrintMediaTypeReport(DWORD dwFlags[], DWORD cchIndent, MEDIA_TYPE mt) { int i = 0; // for now let's assume raw i += _PrintFlag(mt, _mediatypeFD, ARRAYSIZE(_mediatypeFD), cchIndent, TRUE, TRUE, TRUE, FALSE); return i; } /////////////////////////////////////////////////////////////////////////////// // IOCTL_DISK_GET_DRIVE_LAYOUT _sFLAG_DESCR _partitiontypeFD[] = { FLAG_DESCR_COMMENT(PARTITION_ENTRY_UNUSED, TEXT("Entry unused")), FLAG_DESCR_COMMENT(PARTITION_FAT_12, TEXT("12-bit FAT entries")), FLAG_DESCR_COMMENT(PARTITION_XENIX_1, TEXT("Xenix")), FLAG_DESCR_COMMENT(PARTITION_XENIX_2, TEXT("Xenix")), FLAG_DESCR_COMMENT(PARTITION_FAT_16, TEXT("16-bit FAT entries")), FLAG_DESCR_COMMENT(PARTITION_EXTENDED, TEXT("Extended partition entry")), FLAG_DESCR_COMMENT(PARTITION_HUGE, TEXT("Huge partition MS-DOS V4")), FLAG_DESCR_COMMENT(PARTITION_IFS, TEXT("IFS Partition")), FLAG_DESCR_COMMENT(PARTITION_FAT32, TEXT("FAT32")), FLAG_DESCR_COMMENT(PARTITION_FAT32_XINT13, TEXT("FAT32 using extended int13 services")), FLAG_DESCR_COMMENT(PARTITION_XINT13, TEXT("Win95 partition using extended int13 services")), FLAG_DESCR_COMMENT(PARTITION_XINT13_EXTENDED, TEXT("Same as type 5 but uses extended int13 services")), FLAG_DESCR_COMMENT(PARTITION_PREP, TEXT("PowerPC Reference Platform (PReP) Boot Partition")), FLAG_DESCR_COMMENT(PARTITION_LDM, TEXT("Logical Disk Manager partition")), FLAG_DESCR_COMMENT(PARTITION_UNIX, TEXT("Unix")), }; int _PrintLayoutReport(DWORD dwFlags[], DWORD cchIndent, DRIVE_LAYOUT_INFORMATION* pdli) { int i = 0; // for now let's assume raw _PrintIndent(cchIndent); i += wprintf(TEXT("Oper: CreateFile + GENERIC_READ; DeviceIoControl + "\ TEXT("IOCTL_DISK_GET_DRIVE_LAYOUT;\n"))); _PrintElapsedTime(cchIndent, TRUE); _PrintIndent(cchIndent); i += wprintf(TEXT("DRIVE_LAYOUT_INFORMATION\n")); _PrintIndent(cchIndent); i += wprintf(TEXT("{\n")); _PrintIndent(cchIndent + 2); i += wprintf(TEXT("0x%02u (DWORD PartitionCount)\n"), pdli->PartitionCount); _PrintIndent(cchIndent + 2); i += wprintf(TEXT("0x%08X (DWORD Signature)\n"), pdli->Signature); _PrintIndent(cchIndent + 2); i += wprintf(TEXT("{\n")); for (DWORD dw = 0; dw < pdli->PartitionCount; ++dw) { PARTITION_INFORMATION* ppi = &(pdli->PartitionEntry[dw]); LPTSTR pszBool; TCHAR szTrue[] = TEXT("TRUE"); TCHAR szFalse[] = TEXT("FALSE"); _PrintIndent(cchIndent + 4); i += wprintf(TEXT("PARTITION_INFORMATION\n")); _PrintIndent(cchIndent + 4); i += wprintf(TEXT("{\n")); _PrintIndent(cchIndent + 6); i += wprintf(TEXT("0x%08X (lo), 0x%08X (hi) (LARGE_INTEGER StartingOffset)\n"), ppi->StartingOffset.LowPart, ppi->StartingOffset.HighPart); _PrintIndent(cchIndent + 6); i += wprintf(TEXT("0x%08X (lo), 0x%08X (hi) (LARGE_INTEGER PartitionLength)\n"), ppi->PartitionLength.LowPart, ppi->PartitionLength.HighPart); _PrintIndent(cchIndent + 6); i += wprintf(TEXT("0x%08X (DWORD HiddenSectors)\n"), ppi->HiddenSectors); _PrintIndent(cchIndent + 6); i += wprintf(TEXT("0x%02u (DWORD PartitionNumber)\n"), ppi->PartitionNumber); i += _PrintFlag(ppi->PartitionType, _partitiontypeFD, ARRAYSIZE(_partitiontypeFD), cchIndent + 6, TRUE, TRUE, TRUE, FALSE); i += wprintf(TEXT(" (BYTE PartitionType)\n")); if (ppi->BootIndicator) { pszBool = szTrue; } else { pszBool = szFalse; } _PrintIndent(cchIndent + 6); i += wprintf(TEXT("%s (BOOLEAN BootIndicator)\n"), pszBool); if (ppi->RecognizedPartition) { pszBool = szTrue; } else { pszBool = szFalse; } _PrintIndent(cchIndent + 6); i += wprintf(TEXT("%s (BOOLEAN RecognizedPartition)\n"), pszBool); if (ppi->RewritePartition) { pszBool = szTrue; } else { pszBool = szFalse; } _PrintIndent(cchIndent + 6); i += wprintf(TEXT("%s (BOOLEAN RewritePartition)\n"), pszBool); _PrintIndent(cchIndent + 4); i += wprintf(TEXT("}\n")); } _PrintIndent(cchIndent + 2); i += wprintf(TEXT("}\n")); _PrintIndent(cchIndent); i += wprintf(TEXT("}\n")); return i; } HRESULT _IOCTLLayout(DWORD dwFlags[], LPTSTR pszArg, DWORD cchIndent) { HRESULT hres = E_FAIL; HANDLE hDevice; _StartClock(); hDevice = _GetDeviceHandle(pszArg, GENERIC_READ); if (INVALID_HANDLE_VALUE != hDevice) { DWORD dwDummy; BOOL b; DWORD cbdli = 4096;//sizeof(DRIVE_LAYOUT_INFORMATION) + 8 * sizeof(PARTITION_INFORMATION); DRIVE_LAYOUT_INFORMATION* pdli = (DRIVE_LAYOUT_INFORMATION*)LocalAlloc(LPTR, cbdli); b = DeviceIoControl(hDevice, IOCTL_DISK_GET_DRIVE_LAYOUT, // dwIoControlCode operation to perform NULL, // lpInBuffer; must be NULL 0, // nInBufferSize; must be zero (LPVOID)pdli, // pointer to output buffer (DWORD)cbdli, // size of output buffer &dwDummy, // receives number of bytes returned NULL); _StopClock(); if (b) { _PrintLayoutReport(dwFlags, cchIndent, pdli); hres = S_OK; } else { _PrintGetLastError(cchIndent); hres = E_FAIL; } CloseHandle(hDevice); } else { _PrintIndent(cchIndent); wprintf(TEXT("Cannot open device\n")); _PrintGetLastError(cchIndent); hres = E_DF_CANNOTOPENDEVICE; } return hres; } /////////////////////////////////////////////////////////////////////////////// // IOCTL_DISK_GET_DRIVE_GEOMETRY int _PrintGeometryReport(DWORD dwFlags[], DWORD cchIndent, DISK_GEOMETRY* pdg) { int i = 0; // for now let's assume raw _PrintIndent(cchIndent); i += wprintf(TEXT("Oper: CreateFile + GENERIC_READ; DeviceIoControl + "\ TEXT("IOCTL_DISK_GET_DRIVE_GEOMETRY;\n"))); _PrintElapsedTime(cchIndent, TRUE); _PrintIndent(cchIndent); i += wprintf(TEXT("DISK_GEOMETRY\n")); _PrintIndent(cchIndent); i += wprintf(TEXT("{\n")); _PrintIndent(cchIndent + 2); i += wprintf(TEXT("0x%08X (lo), 0x%08X (hi) (LARGE_INTEGER Cylinders)\n"), pdg->Cylinders.LowPart, pdg->Cylinders.HighPart); i += _PrintMediaTypeReport(dwFlags, cchIndent + 2, pdg->MediaType); i += wprintf(TEXT(" (MEDIA_TYPE MediaType)\n")); _PrintIndent(cchIndent + 2); i += wprintf(TEXT("%u (DWORD TracksPerCylinder)\n"), pdg->TracksPerCylinder); _PrintIndent(cchIndent + 2); i += wprintf(TEXT("%u (DWORD SectorsPerTrack)\n"), pdg->SectorsPerTrack); _PrintIndent(cchIndent + 2); i += wprintf(TEXT("%u (DWORD BytesPerSector)\n"), pdg->BytesPerSector); _PrintIndent(cchIndent); i += wprintf(TEXT("}\n")); return i; } HRESULT _IOCTLGeometry(DWORD dwFlags[], LPTSTR pszArg, DWORD cchIndent) { HRESULT hres = E_FAIL; HANDLE hDevice; _StartClock(); hDevice = _GetDeviceHandle(pszArg, GENERIC_READ); if (INVALID_HANDLE_VALUE != hDevice) { DWORD dwDummy; BOOL b; DISK_GEOMETRY dg = {0}; b = DeviceIoControl(hDevice, IOCTL_DISK_GET_DRIVE_GEOMETRY, // dwIoControlCode operation to perform NULL, // lpInBuffer; must be NULL 0, // nInBufferSize; must be zero &dg, // pointer to output buffer sizeof(dg), // size of output buffer &dwDummy, // receives number of bytes returned NULL); _StopClock(); if (b) { _PrintGeometryReport(dwFlags, cchIndent, &dg); hres = S_OK; } else { _PrintGetLastError(cchIndent); hres = E_FAIL; } CloseHandle(hDevice); } else { _PrintIndent(cchIndent); wprintf(TEXT("Cannot open device\n")); _PrintGetLastError(cchIndent); hres = E_DF_CANNOTOPENDEVICE; } return hres; } HRESULT _IOCTLPartition(DWORD dwFlags[], LPTSTR pszArg, DWORD cchIndent) { HRESULT hres = E_FAIL; if (_IsFlagSet(IOCTL_PARTITION, dwFlags)) { _PrintIndent(cchIndent); wprintf(TEXT("Are you really sure? You know what partioning a drive does, right? If so the real switch is \'-hpsure\'.\n")); hres = S_OK; } else { if (_IsFlagSet(IOCTL_PARTITIONSURE, dwFlags)) { HANDLE hDevice; _StartClock(); hDevice = _GetDeviceHandle(pszArg, GENERIC_WRITE | GENERIC_READ); if (INVALID_HANDLE_VALUE != hDevice) { DWORD dwDummy; BOOL b; DISK_GEOMETRY dg = {0}; b = DeviceIoControl(hDevice, IOCTL_DISK_GET_DRIVE_GEOMETRY, // dwIoControlCode operation to perform NULL, // lpInBuffer; must be NULL 0, // nInBufferSize; must be zero &dg, // pointer to output buffer sizeof(dg), // size of output buffer &dwDummy, // receives number of bytes returned NULL); if (b) { // Calc size DRIVE_LAYOUT_INFORMATION dli = {0}; dli.PartitionCount = 1; dli.Signature = 0x57EF57EF; dli.PartitionEntry[0].StartingOffset.QuadPart = ((LONGLONG)dg.SectorsPerTrack) * ((LONGLONG)dg.BytesPerSector); dli.PartitionEntry[0].PartitionLength.QuadPart = ((LONGLONG)(dg.Cylinders.QuadPart - 1)) * ((LONGLONG)dg.TracksPerCylinder) * ((LONGLONG)dg.SectorsPerTrack) * ((LONGLONG)dg.BytesPerSector) - ((LONGLONG)dg.SectorsPerTrack) * ((LONGLONG)dg.BytesPerSector); dli.PartitionEntry[0].PartitionNumber = 1; dli.PartitionEntry[0].PartitionType = PARTITION_IFS; // is that OK? dli.PartitionEntry[0].RecognizedPartition = TRUE; dli.PartitionEntry[0].RewritePartition = TRUE; b = DeviceIoControl(hDevice, IOCTL_DISK_SET_DRIVE_LAYOUT, // dwIoControlCode operation to perform &dli, // pointer to output buffer sizeof(dli), // size of output buffer NULL, // lpInBuffer; must be NULL 0, // nInBufferSize; must be zero &dwDummy, // receives number of bytes returned NULL); hres = S_OK; if (b) { wprintf(TEXT("Succeeded!\n")); } else { wprintf(TEXT("Failed!\n")); } } else { _PrintGetLastError(cchIndent); hres = E_FAIL; } CloseHandle(hDevice); } else { _PrintIndent(cchIndent); wprintf(TEXT("Cannot open device\n")); _PrintGetLastError(cchIndent); hres = E_DF_CANNOTOPENDEVICE; } } } return hres; } HRESULT _IOCTLPartitionGPT(DWORD dwFlags[], LPTSTR pszArg, DWORD cchIndent) { HRESULT hres = E_FAIL; //HANDLE hDevice = _GetDeviceHandle(pszArg, GENERIC_WRITE | GENERIC_READ); //HANDLE hDevice = _GetDeviceHandle(pszArg, GENERIC_READ); HANDLE hDevice = _GetDeviceHandle(pszArg, FILE_READ_ATTRIBUTES); if (hDevice) { PARTITION_INFORMATION_EX partitionEx; DWORD cbReturned; if (DeviceIoControl(hDevice, IOCTL_DISK_GET_PARTITION_INFO_EX, NULL, 0, (void*)&partitionEx, sizeof(PARTITION_INFORMATION_EX), &cbReturned, NULL)) { hres = S_OK; if (partitionEx.PartitionStyle == PARTITION_STYLE_GPT) { wprintf(TEXT("Succeeded!\n")); } else { wprintf(TEXT("Failed!\n")); } } else { _PrintGetLastError(cchIndent); } CloseHandle(hDevice); } else { _PrintIndent(cchIndent); wprintf(TEXT("Cannot open device\n")); _PrintGetLastError(cchIndent); hres = E_DF_CANNOTOPENDEVICE; } return hres; } /////////////////////////////////////////////////////////////////////////////// // IOCTL_CDROM_GET_CONFIGURATION HRESULT _IOCTLCDROMGetConfig(DWORD dwFlags[], LPTSTR pszArg, DWORD cchIndent) { HRESULT hres = E_FAIL; HANDLE hDevice; _StartClock(); hDevice = _GetDeviceHandle(pszArg, GENERIC_READ); if (INVALID_HANDLE_VALUE != hDevice) { DWORD cbReturned; GET_CONFIGURATION_IOCTL_INPUT input; // GET_CONFIGURATION_HEADER header; DWORD cbHeader = sizeof(GET_CONFIGURATION_HEADER) + sizeof(FEATURE_HEADER); GET_CONFIGURATION_HEADER* pheader = (GET_CONFIGURATION_HEADER*)LocalAlloc(LPTR, cbHeader); if (pheader) { LPWSTR pszSucceeded = NULL; LPWSTR pszFailed = NULL; input.RequestType = SCSI_GET_CONFIGURATION_REQUEST_TYPE_ONE; input.Reserved[0] = NULL; input.Reserved[1] = NULL; if (_IsFlagSet(IOCTL_CDROMGETCONFIGMMC2, dwFlags)) { input.Feature = FeatureProfileList; pszSucceeded = TEXT("MMC2 Compliant drive\n"); pszFailed = TEXT("NOT MMC2 Compliant drive\n"); } else { if (_IsFlagSet(IOCTL_CDROMGETCONFIGDVDRAM, dwFlags)) { input.Feature = FeatureDvdRead; pszSucceeded = TEXT("DVD RAM drive\n"); pszFailed = TEXT("NOT DVD RAM drive\n"); } else { if (_IsFlagSet(IOCTL_CDROMGETCONFIGRW, dwFlags)) { input.Feature = FeatureRandomWritable; pszSucceeded = TEXT("Random Writable drive\n"); pszFailed = TEXT("NOT Random Writable drive\n"); } else { if (_IsFlagSet(IOCTL_CDROMGETCONFIGWO, dwFlags)) { input.Feature = FeatureWriteOnce; pszSucceeded = TEXT("Write Once drive\n"); pszFailed = TEXT("NOT Write Once drive\n"); } else { if (_IsFlagSet(IOCTL_CDROMGETCONFIGISW, dwFlags)) { input.Feature = FeatureIncrementalStreamingWritable; pszSucceeded = TEXT("Inc Streaming Writable drive\n"); pszFailed = TEXT("NOT Inc Streaming Writable drive\n"); } else { pszSucceeded = TEXT("ERROR: Bad option!\n"); pszFailed = pszSucceeded; } } } } } BOOL f = DeviceIoControl(hDevice, IOCTL_CDROM_GET_CONFIGURATION, &input, sizeof(GET_CONFIGURATION_IOCTL_INPUT), pheader, // sizeof(GET_CONFIGURATION_HEADER), cbHeader, &cbReturned, NULL); FEATURE_HEADER* pfh = (FEATURE_HEADER*)(pheader->Data); _StopClock(); _PrintElapsedTime(cchIndent, TRUE); _PrintIndent(cchIndent); if (f) { hres = S_OK; wprintf(pszSucceeded); input.RequestType = SCSI_GET_CONFIGURATION_REQUEST_TYPE_CURRENT; f = DeviceIoControl(hDevice, IOCTL_CDROM_GET_CONFIGURATION, &input, sizeof(GET_CONFIGURATION_IOCTL_INPUT), pheader, cbHeader, &cbReturned, NULL); if (f) { if (pfh->Current) { wprintf(TEXT("Feature currently ON\n")); } else { wprintf(TEXT("Feature currently OFF\n")); } } } else { wprintf(pszFailed); } CloseHandle(hDevice); } else { _PrintIndent(cchIndent); wprintf(TEXT("Cannot open device\n")); _PrintGetLastError(cchIndent); hres = E_DF_CANNOTOPENDEVICE; } } return hres; } _sFLAG_DESCR _featurenumberFD[] = { FLAG_DESCR(FeatureProfileList), FLAG_DESCR(FeatureCore), FLAG_DESCR(FeatureMorphing), FLAG_DESCR(FeatureRemovableMedium), FLAG_DESCR(FeatureRandomReadable), FLAG_DESCR(FeatureMultiRead), FLAG_DESCR(FeatureCdRead), FLAG_DESCR(FeatureDvdRead), FLAG_DESCR(FeatureRandomWritable), FLAG_DESCR(FeatureIncrementalStreamingWritable), FLAG_DESCR(FeatureSectorErasable), FLAG_DESCR(FeatureFormattable), FLAG_DESCR(FeatureDefectManagement), FLAG_DESCR(FeatureWriteOnce), FLAG_DESCR(FeatureRestrictedOverwrite), FLAG_DESCR(FeatureWriteProtect), FLAG_DESCR(FeatureCdrwCAVWrite), FLAG_DESCR(FeatureRigidRestrictedOverwrite), FLAG_DESCR(FeatureCdTrackAtOnce), FLAG_DESCR(FeatureCdMastering), FLAG_DESCR(FeatureDvdRecordableWrite), FLAG_DESCR(FeaturePowerManagement), FLAG_DESCR(FeatureSMART), FLAG_DESCR(FeatureEmbeddedChanger), FLAG_DESCR(FeatureCDAudioAnalogPlay), FLAG_DESCR(FeatureMicrocodeUpgrade), FLAG_DESCR(FeatureTimeout), FLAG_DESCR(FeatureDvdCSS), FLAG_DESCR(FeatureRealTimeStreaming), FLAG_DESCR(FeatureLogicalUnitSerialNumber), FLAG_DESCR(FeatureDiscControlBlocks), FLAG_DESCR(FeatureDvdCPRM), }; /////////////////////////////////////////////////////////////////////////////// // IOCTL_CDROM_GET_CONFIGURATION HRESULT _IOCTLCDROMGetConfigListAll(DWORD dwFlags[], LPTSTR pszArg, DWORD cchIndent) { HRESULT hres = E_FAIL; HANDLE hDevice = _GetDeviceHandle(pszArg, GENERIC_READ); if (INVALID_HANDLE_VALUE != hDevice) { DWORD cbReturned; GET_CONFIGURATION_IOCTL_INPUT input; DWORD cbHeader = sizeof(GET_CONFIGURATION_HEADER) + sizeof(FEATURE_HEADER); GET_CONFIGURATION_HEADER* pheader = (GET_CONFIGURATION_HEADER*)LocalAlloc(LPTR, cbHeader); if (pheader) { FEATURE_HEADER* pfh; input.RequestType = SCSI_GET_CONFIGURATION_REQUEST_TYPE_ONE; input.Reserved[0] = NULL; input.Reserved[1] = NULL; _PrintIndent(cchIndent); wprintf(TEXT("Supported features (* = Current):\n\n")); for (DWORD dw = 0; dw < ARRAYSIZE(_featurenumberFD); ++dw) { input.Feature = (FEATURE_NUMBER)(_featurenumberFD[dw].dwFlag); BOOL f = DeviceIoControl(hDevice, IOCTL_CDROM_GET_CONFIGURATION, &input, sizeof(GET_CONFIGURATION_IOCTL_INPUT), pheader, cbHeader, &cbReturned, NULL); pfh = (FEATURE_HEADER*)(pheader->Data); if (f) { WORD w = (pfh->FeatureCode[0]) << 8 | (pfh->FeatureCode[1]); if (w == (WORD)(_featurenumberFD[dw].dwFlag)) { _PrintIndent(cchIndent +2); if (pfh->Current) { wprintf(TEXT("* ")); } else { wprintf(TEXT(" ")); } _PrintFlag(_featurenumberFD[dw].dwFlag, _featurenumberFD, ARRAYSIZE(_featurenumberFD), 0, FALSE, FALSE, FALSE, FALSE); _PrintCR(); } hres = S_OK; } } CloseHandle(hDevice); } else { _PrintIndent(cchIndent); wprintf(TEXT("Cannot open device\n")); _PrintGetLastError(cchIndent); hres = E_DF_CANNOTOPENDEVICE; } } return hres; } /////////////////////////////////////////////////////////////////////////////// // IOCTL_STORAGE_CHECK_VERIFY HRESULT _IOCTLCheckVerify(DWORD dwFlags[], LPTSTR pszArg, DWORD cchIndent) { HRESULT hres = E_FAIL; HANDLE hDevice; _StartClock(); hDevice = _GetDeviceHandle(pszArg, GENERIC_READ); if (INVALID_HANDLE_VALUE != hDevice) { DWORD dwDummy; SetLastError(0); BOOL b = DeviceIoControl(hDevice, IOCTL_STORAGE_CHECK_VERIFY, // dwIoControlCode operation to perform NULL, // lpInBuffer; must be NULL 0, // nInBufferSize; must be zero NULL, // pointer to output buffer 0, // size of output buffer &dwDummy, // receives number of bytes returned NULL); _StopClock(); _PrintIndent(cchIndent); wprintf(TEXT("Oper: CreateFile + GENERIC_READ; DeviceIoControl + "\ TEXT("IOCTL_STORAGE_CHECK_VERIFY;\n"))); _PrintElapsedTime(cchIndent, TRUE); _PrintIndent(cchIndent); wprintf(TEXT("Accessible: ")); hres = S_OK; if (b) { wprintf(TEXT("Y\n")); } else { if (ERROR_NOT_READY == GetLastError()) { wprintf(TEXT("N\n")); } else { _PrintGetLastError(cchIndent); hres = E_FAIL; } } CloseHandle(hDevice); } else { _PrintIndent(cchIndent); wprintf(TEXT("Cannot open device\n")); _PrintGetLastError(cchIndent); hres = E_DF_CANNOTOPENDEVICE; } return hres; } /////////////////////////////////////////////////////////////////////////////// // IOCTL_STORAGE_GET_DEVICE_NUMBER _sFLAG_DESCR _devicetypeFD[] = { FLAG_DESCR(FILE_DEVICE_BEEP), FLAG_DESCR(FILE_DEVICE_CD_ROM), FLAG_DESCR(FILE_DEVICE_CD_ROM_FILE_SYSTEM), FLAG_DESCR(FILE_DEVICE_CONTROLLER), FLAG_DESCR(FILE_DEVICE_DATALINK), FLAG_DESCR(FILE_DEVICE_DFS), FLAG_DESCR(FILE_DEVICE_DISK), FLAG_DESCR(FILE_DEVICE_DISK_FILE_SYSTEM), FLAG_DESCR(FILE_DEVICE_FILE_SYSTEM), FLAG_DESCR(FILE_DEVICE_INPORT_PORT), FLAG_DESCR(FILE_DEVICE_KEYBOARD), FLAG_DESCR(FILE_DEVICE_MAILSLOT), FLAG_DESCR(FILE_DEVICE_MIDI_IN), FLAG_DESCR(FILE_DEVICE_MIDI_OUT), FLAG_DESCR(FILE_DEVICE_MOUSE), FLAG_DESCR(FILE_DEVICE_MULTI_UNC_PROVIDER), FLAG_DESCR(FILE_DEVICE_NAMED_PIPE), FLAG_DESCR(FILE_DEVICE_NETWORK), FLAG_DESCR(FILE_DEVICE_NETWORK_BROWSER), FLAG_DESCR(FILE_DEVICE_NETWORK_FILE_SYSTEM), FLAG_DESCR(FILE_DEVICE_NULL), FLAG_DESCR(FILE_DEVICE_PARALLEL_PORT), FLAG_DESCR(FILE_DEVICE_PHYSICAL_NETCARD), FLAG_DESCR(FILE_DEVICE_PRINTER), FLAG_DESCR(FILE_DEVICE_SCANNER), FLAG_DESCR(FILE_DEVICE_SERIAL_MOUSE_PORT), FLAG_DESCR(FILE_DEVICE_SERIAL_PORT), FLAG_DESCR(FILE_DEVICE_SCREEN), FLAG_DESCR(FILE_DEVICE_SOUND), FLAG_DESCR(FILE_DEVICE_STREAMS), FLAG_DESCR(FILE_DEVICE_TAPE), FLAG_DESCR(FILE_DEVICE_TAPE_FILE_SYSTEM), FLAG_DESCR(FILE_DEVICE_TRANSPORT), FLAG_DESCR(FILE_DEVICE_UNKNOWN), FLAG_DESCR(FILE_DEVICE_VIDEO), FLAG_DESCR(FILE_DEVICE_VIRTUAL_DISK), FLAG_DESCR(FILE_DEVICE_WAVE_IN), FLAG_DESCR(FILE_DEVICE_WAVE_OUT), FLAG_DESCR(FILE_DEVICE_8042_PORT), FLAG_DESCR(FILE_DEVICE_NETWORK_REDIRECTOR), FLAG_DESCR(FILE_DEVICE_BATTERY), FLAG_DESCR(FILE_DEVICE_BUS_EXTENDER), FLAG_DESCR(FILE_DEVICE_MODEM), FLAG_DESCR(FILE_DEVICE_VDM), FLAG_DESCR(FILE_DEVICE_MASS_STORAGE), FLAG_DESCR(FILE_DEVICE_SMB), FLAG_DESCR(FILE_DEVICE_KS), FLAG_DESCR(FILE_DEVICE_CHANGER), FLAG_DESCR(FILE_DEVICE_SMARTCARD), FLAG_DESCR(FILE_DEVICE_ACPI), FLAG_DESCR(FILE_DEVICE_DVD), FLAG_DESCR(FILE_DEVICE_FULLSCREEN_VIDEO), FLAG_DESCR(FILE_DEVICE_DFS_FILE_SYSTEM), FLAG_DESCR(FILE_DEVICE_DFS_VOLUME), FLAG_DESCR(FILE_DEVICE_SERENUM), FLAG_DESCR(FILE_DEVICE_TERMSRV), FLAG_DESCR(FILE_DEVICE_KSEC), }; int _PrintDeviceNumberReport(DWORD dwFlags[], DWORD cchIndent, STORAGE_DEVICE_NUMBER* psdn) { int i = 0; // for now let's assume raw _PrintIndent(cchIndent); i += wprintf(TEXT("Oper: CreateFile + GENERIC_READ; DeviceIoControl + "\ TEXT("IOCTL_STORAGE_GET_DEVICE_NUMBER;\n"))); _PrintElapsedTime(cchIndent, TRUE); _PrintIndent(cchIndent); i += wprintf(TEXT("STORAGE_DEVICE_NUMBER\n")); _PrintIndent(cchIndent); i += wprintf(TEXT("{\n")); i += _PrintFlag(psdn->DeviceType, _devicetypeFD, ARRAYSIZE(_devicetypeFD), cchIndent + 2, TRUE, TRUE, FALSE, FALSE); i += wprintf(TEXT(" (DEVICE_TYPE DeviceType)\n")); _PrintIndent(cchIndent + 2); i += wprintf(TEXT("%u (DWORD DeviceNumber)\n"), psdn->DeviceNumber); _PrintIndent(cchIndent + 2); i += wprintf(TEXT("%u (DWORD PartitionNumber)\n"), psdn->PartitionNumber); _PrintIndent(cchIndent); i += wprintf(TEXT("}\n")); return i; } HRESULT _IOCTLDeviceNumber(DWORD dwFlags[], LPTSTR pszArg, DWORD cchIndent) { HRESULT hres = E_FAIL; HANDLE hDevice; _StartClock(); hDevice = _GetDeviceHandle(pszArg, 0); if (INVALID_HANDLE_VALUE != hDevice) { STORAGE_DEVICE_NUMBER sdn = {0}; DWORD dwDummy; BOOL b = DeviceIoControl(hDevice, IOCTL_STORAGE_GET_DEVICE_NUMBER, // dwIoControlCode operation to perform NULL, // lpInBuffer; must be NULL 0, // nInBufferSize; must be zero &sdn, sizeof(sdn), &dwDummy, // receives number of bytes returned NULL); _StopClock(); if (b) { _PrintDeviceNumberReport(dwFlags, cchIndent, &sdn); hres = S_OK; } else { _PrintGetLastError(cchIndent); hres = E_FAIL; } CloseHandle(hDevice); } else { _PrintIndent(cchIndent); wprintf(TEXT("Cannot open device\n")); _PrintGetLastError(cchIndent); hres = E_DF_CANNOTOPENDEVICE; } return hres; } /////////////////////////////////////////////////////////////////////////////// // IOCTL_STORAGE_MCN_CONTROL HRESULT _IOCTLMCNControl(DWORD dwFlags[], LPTSTR pszArg, DWORD cchIndent) { HRESULT hres = E_FAIL; HANDLE hDevice; _StartClock(); hDevice = _GetDeviceHandle(pszArg, FILE_READ_ATTRIBUTES); if (INVALID_HANDLE_VALUE != hDevice) { STORAGE_DEVICE_NUMBER sdn = {0}; DWORD dwDummy; PREVENT_MEDIA_REMOVAL mediaRemoval; mediaRemoval.PreventMediaRemoval = FALSE; BOOL b = DeviceIoControl(hDevice, IOCTL_STORAGE_MCN_CONTROL, // dwIoControlCode operation to perform &mediaRemoval, // lpInBuffer; must be NULL sizeof(mediaRemoval), // nInBufferSize; must be zero NULL, 0, &dwDummy, // receives number of bytes returned NULL); _StopClock(); if (b) { hres = S_OK; } else { _PrintGetLastError(cchIndent); hres = E_FAIL; } CloseHandle(hDevice); } else { _PrintIndent(cchIndent); wprintf(TEXT("Cannot open device\n")); _PrintGetLastError(cchIndent); hres = E_DF_CANNOTOPENDEVICE; } return hres; } /////////////////////////////////////////////////////////////////////////////// // IOCTL_DISK_IS_WRITABLE HRESULT _IOCTLDiskWritable(DWORD dwFlags[], LPTSTR pszArg, DWORD cchIndent) { HRESULT hres = E_FAIL; HANDLE hDevice; _StartClock(); hDevice = _GetDeviceHandle(pszArg, GENERIC_READ); if (INVALID_HANDLE_VALUE != hDevice) { DWORD dwDummy; SetLastError(0); BOOL b = DeviceIoControl(hDevice, IOCTL_DISK_IS_WRITABLE, // dwIoControlCode operation to perform NULL, // lpInBuffer; must be NULL 0, // nInBufferSize; must be zero NULL, // pointer to output buffer 0, // size of output buffer &dwDummy, // receives number of bytes returned NULL); _StopClock(); _PrintIndent(cchIndent); wprintf(TEXT("Oper: CreateFile + GENERIC_READ; DeviceIoControl + "\ TEXT("IOCTL_DISK_IS_WRITABLE;\n"))); _PrintElapsedTime(cchIndent, TRUE); _PrintIndent(cchIndent); wprintf(TEXT("Write protected: ")); hres = S_OK; // Don't check return value for nothing if (ERROR_WRITE_PROTECT == GetLastError()) { wprintf(L"Y\n"); } else { wprintf(L"N\n"); } CloseHandle(hDevice); } else { _PrintIndent(cchIndent); wprintf(TEXT("Cannot open device\n")); _PrintGetLastError(cchIndent); hres = E_DF_CANNOTOPENDEVICE; } return hres; } /////////////////////////////////////////////////////////////////////////////// // IOCTL_STORAGE_GET_MEDIA_TYPES HRESULT _IOCTLMediaTypes(DWORD dwFlags[], LPTSTR pszArg, DWORD cchIndent) { HRESULT hres = E_FAIL; HANDLE hDevice; _StartClock(); hDevice = _GetDeviceHandle(pszArg, GENERIC_READ); if (INVALID_HANDLE_VALUE != hDevice) { DWORD dwDummy; BOOL b; DISK_GEOMETRY dg[12] = {0}; DWORD cb = sizeof(dg); DWORD dwIoCtl; if (_IsFlagSet(IOCTL_MEDIATYPES, dwFlags)) { dwIoCtl = IOCTL_STORAGE_GET_MEDIA_TYPES; } else { dwIoCtl = IOCTL_DISK_GET_MEDIA_TYPES; } b = DeviceIoControl(hDevice, dwIoCtl, NULL, // lpInBuffer; must be NULL 0, // nInBufferSize; must be zero dg, cb, &dwDummy, // receives number of bytes returned NULL); _StopClock(); _PrintIndent(cchIndent); wprintf(TEXT("Oper: CreateFile + GENERIC_READ; DeviceIoControl + "\ TEXT("IOCTL_STORAGE_GET_MEDIA_TYPES;\n"))); _PrintElapsedTime(cchIndent, TRUE); _PrintIndent(cchIndent); if (b) { DWORD c = dwDummy / sizeof(DISK_GEOMETRY); wprintf(TEXT("Media types:\n")); for (DWORD dw = 0; dw < c; ++dw) { _PrintMediaTypeReport(dwFlags, cchIndent + 2, dg[dw].MediaType); _PrintCR(); } } else { _PrintGetLastError(cchIndent); hres = E_FAIL; } CloseHandle(hDevice); } else { _PrintIndent(cchIndent); wprintf(TEXT("Cannot open device\n")); _PrintGetLastError(cchIndent); hres = E_DF_CANNOTOPENDEVICE; } return hres; } /////////////////////////////////////////////////////////////////////////////// // FSCTL_GET_REPARSE_POINT HRESULT _FSCTLGetReparsePoint(DWORD dwFlags[], LPTSTR pszArg, DWORD cchIndent) { HRESULT hres = E_FAIL; HANDLE hDevice; _StartClock(); hDevice = _GetDeviceHandle(pszArg, GENERIC_READ, FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OPEN_REPARSE_POINT); if (INVALID_HANDLE_VALUE != hDevice) { DWORD dwDummy; BYTE buffer[1024]; BOOL b = DeviceIoControl(hDevice, // FSCTL_GET_REPARSE_POINT, // NULL, NULL, &buffer, sizeof(buffer), &dwDummy, NULL); _StopClock(); _PrintElapsedTime(cchIndent, TRUE); _PrintIndent(cchIndent); if (!b) { if (ERROR_MORE_DATA == GetLastError()) { // That's OK REPARSE_GUID_DATA_BUFFER* pb = (REPARSE_GUID_DATA_BUFFER*)&buffer; _PrintGUID(&(pb->ReparseGuid)); hres = S_OK; } else { _PrintGetLastError(cchIndent); hres = E_FAIL; } } else { REPARSE_GUID_DATA_BUFFER* pb = (REPARSE_GUID_DATA_BUFFER*)&buffer; _PrintGUID(&(pb->ReparseGuid)); hres = S_OK; } CloseHandle(hDevice); } else { _PrintIndent(cchIndent); wprintf(TEXT("Cannot open device\n")); _PrintGetLastError(cchIndent); hres = E_DF_CANNOTOPENDEVICE; } return hres; } /////////////////////////////////////////////////////////////////////////////// // IOCTL_DVD_READ_KEY HRESULT _IOCTLDvd(DWORD dwFlags[], LPTSTR pszArg, DWORD cchIndent) { HRESULT hres = E_FAIL; HANDLE hDevice; _StartClock(); hDevice = _GetDeviceHandle(pszArg, GENERIC_READ); if (INVALID_HANDLE_VALUE != hDevice) { DWORD dwDummy; BOOL b; BYTE bBuf[DVD_RPC_KEY_LENGTH]; DWORD cbBuf = DVD_RPC_KEY_LENGTH; DVD_COPY_PROTECT_KEY* pdcpk = (DVD_COPY_PROTECT_KEY*)bBuf; ZeroMemory(pdcpk, cbBuf); pdcpk->KeyLength = cbBuf; pdcpk->KeyType = DvdGetRpcKey; b = DeviceIoControl(hDevice, // IOCTL_DVD_READ_KEY, // pdcpk, cbBuf, pdcpk, cbBuf, &dwDummy, NULL); _StopClock(); _PrintIndent(cchIndent); wprintf(TEXT("Oper: CreateFile + GENERIC_READ; DeviceIoControl + "\ TEXT("IOCTL_DVD_READ_KEY;\n"))); _PrintElapsedTime(cchIndent, TRUE); _PrintIndent(cchIndent); if (b) { // If succeeded, DVD drive wprintf(TEXT("Succeeded.\n")); hres = S_OK; } else { // If fail with 1 (ERROR_INVALID_FUNCTION), then it is not a DVD drive _PrintGetLastError(cchIndent); hres = E_FAIL; } CloseHandle(hDevice); } else { _PrintIndent(cchIndent); wprintf(TEXT("Cannot open device\n")); _PrintGetLastError(cchIndent); hres = E_DF_CANNOTOPENDEVICE; } return hres; } /////////////////////////////////////////////////////////////////////////////// // IOCTL_STORAGE_GET_MEDIA_TYPES_EX _sFLAG_DESCR _devicemediatypeFD[] = { FLAG_DESCR(MEDIA_ERASEABLE), FLAG_DESCR(MEDIA_WRITE_ONCE), FLAG_DESCR(MEDIA_READ_ONLY), FLAG_DESCR(MEDIA_READ_WRITE), FLAG_DESCR(MEDIA_WRITE_PROTECTED), FLAG_DESCR(MEDIA_CURRENTLY_MOUNTED), }; int _PrintDeviceMediaInfoReport(DWORD dwFlags[], DWORD cchIndent, DEVICE_MEDIA_INFO* pdmi) { int i = 0; // for now let's assume raw // BUGBUG: We use DiskInfo whatever what the disk is _PrintIndent(cchIndent); i += wprintf(TEXT("DEVICE_MEDIA_INFO\n")); _PrintIndent(cchIndent); i += wprintf(TEXT("{\n")); _PrintIndent(cchIndent + 2); i += wprintf(TEXT("0x%08X (lo), 0x%08X (hi) (LARGE_INTEGER Cylinders)\n"), pdmi->DeviceSpecific.DiskInfo.Cylinders.LowPart, pdmi->DeviceSpecific.DiskInfo.Cylinders.HighPart); i += _PrintMediaTypeReport(dwFlags, cchIndent + 2, (MEDIA_TYPE)pdmi->DeviceSpecific.DiskInfo.MediaType); i += wprintf(TEXT(" (MEDIA_TYPE MediaType)\n")); _PrintIndent(cchIndent + 2); i += wprintf(TEXT("%u (DWORD TracksPerCylinder)\n"), pdmi->DeviceSpecific.DiskInfo.TracksPerCylinder); _PrintIndent(cchIndent + 2); i += wprintf(TEXT("%u (DWORD SectorsPerTrack)\n"), pdmi->DeviceSpecific.DiskInfo.SectorsPerTrack); _PrintIndent(cchIndent + 2); i += wprintf(TEXT("%u (DWORD BytesPerSector)\n"), pdmi->DeviceSpecific.DiskInfo.BytesPerSector); _PrintIndent(cchIndent + 2); i += wprintf(TEXT("%u (DWORD NumberMediaSides)\n"), pdmi->DeviceSpecific.DiskInfo.NumberMediaSides); _PrintIndent(cchIndent + 2); i += wprintf(TEXT("(DWORD MediaCharacteristics):\n")); i += _PrintFlag(pdmi->DeviceSpecific.DiskInfo.MediaCharacteristics, _devicemediatypeFD, ARRAYSIZE(_devicemediatypeFD), cchIndent + 4, TRUE, TRUE, FALSE, TRUE); _PrintCR(); _PrintIndent(cchIndent); i += wprintf(TEXT("}\n")); return i; } HRESULT _IOCTLMediaTypesEx(DWORD dwFlags[], LPTSTR pszArg, DWORD cchIndent) { HRESULT hres = E_FAIL; HANDLE hDevice; _StartClock(); hDevice = _GetDeviceHandle(pszArg, GENERIC_READ); if (INVALID_HANDLE_VALUE != hDevice) { DWORD dwDummy; BOOL b; BYTE bBuf[8192]; b = DeviceIoControl(hDevice, IOCTL_STORAGE_GET_MEDIA_TYPES_EX, NULL, 0, bBuf, sizeof(bBuf), &dwDummy, NULL); _StopClock(); _PrintIndent(cchIndent); wprintf(TEXT("Oper: CreateFile + GENERIC_READ; DeviceIoControl + "\ TEXT("IOCTL_STORAGE_GET_MEDIA_TYPES_EX;\n"))); _PrintElapsedTime(cchIndent, TRUE); _PrintIndent(cchIndent); wprintf(TEXT("Media types:\n")); if (b) { GET_MEDIA_TYPES* pgmt = (GET_MEDIA_TYPES*)bBuf; DEVICE_MEDIA_INFO* pMediaInfo = pgmt->MediaInfo; DWORD cMediaInfo = pgmt->MediaInfoCount; for (DWORD dw = 0; dw < cMediaInfo; ++dw) { pMediaInfo += dw; _PrintDeviceMediaInfoReport(dwFlags, cchIndent, pMediaInfo); _PrintCR(); } hres = S_OK; } else { _PrintGetLastError(cchIndent); hres = E_FAIL; } CloseHandle(hDevice); } else { _PrintIndent(cchIndent); wprintf(TEXT("Cannot open device\n")); _PrintGetLastError(cchIndent); hres = E_DF_CANNOTOPENDEVICE; } return hres; } /////////////////////////////////////////////////////////////////////////////// // typedef HRESULT (*_IOCTLHANDLER)(DWORD dwFlags[], LPTSTR pszArg, DWORD cchIndent); struct _sIOCtlHandler { DWORD dwFlag; _IOCTLHANDLER ioctlhandler; }; _sIOCtlHandler _ioctlhandlers[] = { { IOCTL_LAYOUT, _IOCTLLayout }, { IOCTL_GEOMETRY, _IOCTLGeometry }, { IOCTL_PARTITION, _IOCTLPartition }, { IOCTL_PARTITIONSURE, _IOCTLPartition }, { IOCTL_PARTITIONGPT, _IOCTLPartitionGPT }, { IOCTL_MEDIAACCESSIBLE, _IOCTLCheckVerify }, { IOCTL_DISKISWRITABLE, _IOCTLDiskWritable }, { IOCTL_VOLUMENUMBER, _IOCTLDeviceNumber }, { IOCTL_MEDIATYPES, _IOCTLMediaTypes }, { IOCTL_MEDIATYPESEX, _IOCTLMediaTypesEx }, { IOCTL_DVD, _IOCTLDvd }, { IOCTL_EJECT, _IOCTLEject }, { IOCTL_MCNCONTROL, _IOCTLMCNControl }, { IOCTL_GETREPARSEPOINT, _FSCTLGetReparsePoint }, { IOCTL_CDROMGETCONFIGMMC2, _IOCTLCDROMGetConfig }, { IOCTL_CDROMGETCONFIGDVDRAM, _IOCTLCDROMGetConfig }, { IOCTL_CDROMGETCONFIGRW, _IOCTLCDROMGetConfig }, { IOCTL_CDROMGETCONFIGWO, _IOCTLCDROMGetConfig }, { IOCTL_CDROMGETCONFIGISW, _IOCTLCDROMGetConfig }, { IOCTL_CDROMGETCONFIGALL, _IOCTLCDROMGetConfigListAll }, }; HRESULT _ProcessIOCTL(DWORD dwFlags[], LPTSTR pszArg, DWORD cchIndent) { HRESULT hres = E_INVALIDARG; for (DWORD dw = 0; dw < ARRAYSIZE(_ioctlhandlers); ++dw) { if (_IsFlagSet(_ioctlhandlers[dw].dwFlag, dwFlags)) { hres = (*(_ioctlhandlers[dw].ioctlhandler))(dwFlags, pszArg, cchIndent); } } return hres; } /* 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; } */ /* ++ Copyright (c) 1999 Microsoft Corporation Module Name: ntddfuji.c -- #include "getfeatures.h" #define NTDDFUJI_VERSION 3 // the version this file is based off of FUJI_STRING_INFO ProfileStrings[13] = { { ProfileInvalid, "ProfileInvalid" }, { ProfileNonRemovableDisk, "Non-Removable Disk" }, { ProfileRemovableDisk, "Removable Disk" }, { ProfileMOErasable, "Magneto-Optical Erasable" }, { ProfileMOWriteOnce, "Magneto-Optical Write-Once" }, { ProfileAS_MO, "AS Mageto-Optical" }, { ProfileCdrom, "CD-Rom" }, { ProfileCdRecordable, "CD Recordable" }, { ProfileCdRewritable, "CD Rewritable" }, { ProfileDvdRom, "DVD-Rom" }, { ProfileDvdRecordable, "DVD-Recordable" }, { ProfileDvdRam, "DVD-RAM" }, { ProfileNonStandard, "NonStandard Profile" } }; FUJI_STRING_INFO FeatureStrings[28] = { { FeatureProfileList , "Profile List" }, { FeatureCore , "Core" }, { FeatureMorphing , "Morphing" }, { FeatureRemovableMedium , "Removable Medium" }, { FeatureRandomReadable , "Random Readable" }, { FeatureMultiRead , "MultiRead" }, { FeatureCdRead , "CD Read" }, { FeatureDvdRead , "DVD Read" }, { FeatureRandomWritable , "Random Writable" }, { FeatureIncrementalStreamingWritable , "Incremental Stream Writing" }, { FeatureSectorErasable , "Sector Erasable" }, { FeatureFormattable , "Formattable" }, { FeatureDefectManagement , "Defect Management" }, { FeatureWriteOnce , "Write Once" }, { FeatureRestrictedOverwrite , "Restricted Overwrite" }, { FeatureCdTrackAtOnce , "CD Track-At-Once" }, { FeatureCdMastering , "CD Mastering" }, { FeatureDvdRecordableWrite , "DVD Recordable Writing" }, { FeaturePowerManagement , "Power Management" }, { FeatureSMART , "S.M.A.R.T." }, { FeatureEmbeddedChanger , "Embedded Changer" }, { FeatureCDAudioAnalogPlay , "CD Audio Analog Playback" }, { FeatureMicrocodeUpgrade , "Microcode Upgrade" }, { FeatureTimeout , "Timeout" }, { FeatureDvdCSS , "DVD CSS" }, { FeatureRealTimeStreaming , "Real-Time Streaming" }, { FeatureLogicalUnitSerialNumber , "Logical Unit Serial Number" }, { FeatureDiscControlBlocks , "Disc Control Blocks" } }; FEATURE_PAGE_LIST RequiredFeaturePagesNonRemovableDisk = { FeatureCore, FeatureRandomReadable, FeatureRandomWritable, FeatureDefectManagement, FeaturePowerManagement, FeatureSMART, FeatureProfileList }; FEATURE_PAGE_LIST RequiredFeaturePagesRemovableDisk = { FeatureCore, FeatureMorphing, FeatureRemovableMedium, FeatureRandomReadable, FeatureRandomWritable, FeatureFormattable, FeatureDefectManagement, FeaturePowerManagement, FeatureTimeout, FeatureProfileList }; FEATURE_PAGE_LIST RequiredFeaturePagesMOErasable = { FeatureCore, FeatureMorphing, FeatureRemovableMedium, FeatureRandomReadable, FeatureRandomWritable, FeatureSectorErasable, FeatureFormattable, FeatureDefectManagement, FeaturePowerManagement, FeatureTimeout, FeatureProfileList }; FEATURE_PAGE_LIST RequiredFeaturePagesMOWriteOnce = { FeatureCore, FeatureMorphing, FeatureRemovableMedium, FeatureRandomReadable, FeatureDefectManagement, FeatureWriteOnce, FeaturePowerManagement, FeatureTimeout, FeatureProfileList }; FEATURE_PAGE_LIST RequiredFeaturePagesAS_MO = { FeatureCore, FeatureMorphing, FeatureRemovableMedium, FeatureRandomReadable, FeatureRandomWritable, FeatureFormattable, FeatureDefectManagement, FeaturePowerManagement, FeatureTimeout, FeatureRealTimeStreaming, FeatureProfileList }; FEATURE_PAGE_LIST RequiredFeaturePagesCdrom = { FeatureCore, FeatureMorphing, FeatureRemovableMedium, FeatureRandomReadable, FeatureCdRead, FeaturePowerManagement, FeatureTimeout, FeatureProfileList }; FEATURE_PAGE_LIST RequiredFeaturePagesCdRecordable = { FeatureCore, FeatureMorphing, FeatureRemovableMedium, FeatureRandomReadable, FeatureCdRead, FeatureIncrementalStreamingWritable, FeatureCdTrackAtOnce, FeaturePowerManagement, FeatureTimeout, FeatureRealTimeStreaming, FeatureProfileList }; FEATURE_PAGE_LIST RequiredFeaturePagesCdRewritable = { FeatureCore, FeatureMorphing, FeatureRemovableMedium, FeatureRandomReadable, FeatureMultiRead, FeatureCdRead, FeatureIncrementalStreamingWritable, FeatureFormattable, FeatureRestrictedOverwrite, FeatureCdTrackAtOnce, FeaturePowerManagement, FeatureTimeout, FeatureRealTimeStreaming, FeatureProfileList }; FEATURE_PAGE_LIST RequiredFeaturePagesDvdRom = { FeatureCore, FeatureMorphing, FeatureRemovableMedium, FeatureRandomReadable, FeatureDvdRead, FeaturePowerManagement, FeatureTimeout, FeatureRealTimeStreaming, FeatureProfileList }; FEATURE_PAGE_LIST RequiredFeaturePagesDvdRecordable = { FeatureCore, FeatureMorphing, FeatureRemovableMedium, FeatureRandomReadable, FeatureDvdRead, FeatureIncrementalStreamingWritable, FeatureDvdRecordableWrite, FeaturePowerManagement, FeatureTimeout, FeatureRealTimeStreaming, FeatureLogicalUnitSerialNumber, FeatureProfileList }; FEATURE_PAGE_LIST RequiredFeaturePagesDvdRam = { FeatureCore, FeatureMorphing, FeatureRemovableMedium, FeatureRandomReadable, FeatureDvdRead, FeatureRandomWritable, FeatureFormattable, FeatureDefectManagement, FeaturePowerManagement, FeatureTimeout, FeatureRealTimeStreaming, FeatureProfileList }; FUJI_REQUIRED_FEATURE_PAGES const RequiredFeaturePages[] = { { ProfileNonRemovableDisk, &RequiredFeaturePagesNonRemovableDisk }, { ProfileRemovableDisk, &RequiredFeaturePagesRemovableDisk }, { ProfileMOErasable, &RequiredFeaturePagesMOErasable }, { ProfileMOWriteOnce, &RequiredFeaturePagesMOWriteOnce }, { ProfileAS_MO, &RequiredFeaturePagesAS_MO }, { ProfileCdrom, &RequiredFeaturePagesCdrom }, { ProfileCdRecordable, &RequiredFeaturePagesCdRecordable }, { ProfileCdRewritable, &RequiredFeaturePagesCdRewritable }, { ProfileDvdRom, &RequiredFeaturePagesDvdRom }, { ProfileDvdRecordable, &RequiredFeaturePagesDvdRecordable }, { ProfileDvdRam, &RequiredFeaturePagesDvdRam }, { 0, NULL } }; */