archive
/
windows-nt-4.0
mirror of https://github.com/lianthony/NT4.0
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Windows NT 4.0 source code leak
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2 Commits
1 Branch
0 Tags
184 MiB
 
 
 
 
 
 
Tree: b4a8d373d8
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'b4a8d373d8'
${ noResults }
windows-nt-4.0/private/ntos/dd/qic117/cmd/tdump.c

804 lines
22 KiB
Raw Blame History

#include <windows.h>
#include <stdio.h>
#include <winioctl.h>
#define DRV_NTAPI
#include "..\include\public\adi_api.h"
#include "..\include\public\frb_api.h"
#include "..\include\public\vendor.h"
#include "..\frb.h"
#define BLOCK_SIZE 1024
int DumpTape(
HANDLE hTapeHandle,
int block,
int num,
int print
);
int FillTape(
HANDLE hTapeHandle,
int block,
int num,
int print
);
int SeekTape(
int type,
DWORD tape_pos,
HANDLE hTapeHandle
);
VOID DumpData(
UCHAR *buf,
ULONG size
);
int RewindTape(
HANDLE hTapeHandle
);
int DetectDrive(
HANDLE hTapeHandle
);
int EraseTheTape(
HANDLE hTapeHandle,
BOOL short_erase
);
int FormatTheTape(
HANDLE hTapeHandle
);
VOID ProcessCmd(
HANDLE hTapeHandle,
char *cmd
);
int ReadAbsTape(
int block,
int blocks,
int ecc,
HANDLE hTapeHandle
);
int GetInt(
char *prompt
);
DWORD DoOpen(
HANDLE *handle,
char *name
);
// Prototypes for string functions
char *GetDriveClassStr(int class);
char *GetTapeTypeStr(int class);
char *GetVendorStr(int vendor);
char *GetTapeClassStr(int info);
char *GetFDCStr(int info);
char *GetTapeFormatStr(int info);
char *GetModelStr(int vendor, int info);
int _cdecl main(int argc,char **argv)
{
HANDLE hTapeHandle;
char tmp[255];
DWORD err;
printf("CMS Tape Dump utility\n\n");
printf("NOTE: all values in HEX\n\n");
if (!(err = DoOpen(&hTapeHandle,argv[1]))) {
ProcessCmd(hTapeHandle,"help");
do {
printf(":");
gets(tmp);
if (tmp[0] && strcmp(tmp, "quit") != 0) {
ProcessCmd(hTapeHandle,tmp);
}
} while (strcmp(tmp, "quit") != 0);
CloseHandle( hTapeHandle ) ;
} else {
printf("Error opening \"%s\" (error %x)\n",argv[1], err);
printf("\n");
printf("Usage example: tdump \\\\.\\tape0\n");
}
return 0;
}
DWORD DoOpen(
HANDLE *handle,
char *name
)
{
DWORD status;
*handle = CreateFile(
name,
GENERIC_READ|GENERIC_WRITE,
0,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL
);
if (*handle == INVALID_HANDLE_VALUE) {
status = GetLastError();
} else {
status = 0;
}
return status;
}
VOID ProcessCmd(
HANDLE hTapeHandle,
char *cmd
)
{
int block=0;
int blocks;
int num;
int status;
int ecc;
if (strcmp(cmd,"dump") == 0) {
num = GetInt("number of blocks:");
status = GetInt("0=no print, 1=print:");
status = DumpTape(hTapeHandle, block, num, status);
} else
if (strcmp(cmd,"detect") == 0) {
status = DetectDrive(hTapeHandle);
} else
if (strcmp(cmd,"fill") == 0) {
num = GetInt("number of blocks:");
status = GetInt("0=no print, 1=print:");
status = FillTape(hTapeHandle, block, num, status);
} else
if (strcmp(cmd,"format") == 0) {
status = FormatTheTape(hTapeHandle);
} else
if (strcmp(cmd,"seekblk") == 0) {
block = GetInt("Block number:");
status = SeekTape(TAPE_ABSOLUTE_BLOCK,block, hTapeHandle);
} else
if (strcmp(cmd,"readabs") == 0) {
block = GetInt("Block number:");
blocks = GetInt("blocks to dump:");
ecc = GetInt("Use ECC [0=no, 1=yes]:");
status = ReadAbsTape(block, blocks, ecc, hTapeHandle);
} else
if (strcmp(cmd,"seekeod") == 0) {
status = SeekTape(TAPE_SPACE_END_OF_DATA, 0, hTapeHandle);
} else
if (strcmp(cmd,"seekfmk") == 0) {
block = GetInt("Filemarks to skip:");
status = SeekTape(TAPE_SPACE_FILEMARKS, block, hTapeHandle);
} else
if (strcmp(cmd,"erase") == 0) {
status = EraseTheTape(hTapeHandle, TRUE);
} else
if (strcmp(cmd,"rewind") == 0) {
status = RewindTape(hTapeHandle);
} else
if (strcmp(cmd,"quit") == 0) {
} else {
printf("Valid commands are: QUIT, DUMP, SEEKBLK, REWIND, DETECT,\n\
SEEKEOD, SEEKFMK, READABS, FORMAT and ERASE\n");
}
printf("Status: %x\n",status);
}
int GetInt(
char *prompt
)
{
char tmp[255];
int val;
printf(prompt);
gets(tmp);
sscanf(tmp,"%x",&val);
return val;
}
int DumpTape(
HANDLE hTapeHandle,
int block,
int num,
int print
)
{
ULONG amount_read;
UCHAR buf[BLOCK_SIZE];
int status;
ULONG *ptr,lft,cnt,ok,off,cur;
cnt = 0;
do {
cur = cnt;
status = -1L ;
if( !( status = ReadFile(
hTapeHandle,
buf,
BLOCK_SIZE,
&amount_read,
NULL
) ) ) {
status = GetLastError( ) ;
} else {
status = 0L ;
}
printf( "ReadTape(): Req = %lx, Read = %lx\n", BLOCK_SIZE, amount_read ) ;
printf("Block %x - status: %x\n",block++,status);
if (!status && print)
DumpData(buf,BLOCK_SIZE);
lft = sizeof(buf) / sizeof(ULONG);
ptr = (void *)buf;
ok = 1;
while (lft--) {
if (*ptr++ != cnt++) {
if (ok) off = cnt;
ok = 0;
}
}
if (!ok && !print) {
printf("Dump error at offset %x should be %x (buffer start: %x)\n",(off-cur)*sizeof(ULONG), off, cur);
DumpData(buf,BLOCK_SIZE);
}
if (status == ERROR_FILEMARK_DETECTED ||
status == ERROR_SETMARK_DETECTED) {
status = 0;
}
} while (!status && num--);
return status;
}
int FillTape(
HANDLE hTapeHandle,
int block,
int num,
int print
)
{
ULONG amount_written;
UCHAR buf[BLOCK_SIZE];
ULONG *ptr,lft,cnt;
int status;
cnt = 0;
do {
status = -1L ;
lft = sizeof(buf) / sizeof(ULONG);
ptr = (void *)buf;
while (lft--)
*ptr++ = cnt++;
if( !( status = WriteFile(
hTapeHandle,
buf,
BLOCK_SIZE,
&amount_written,
NULL
) ) ) {
status = GetLastError( ) ;
} else {
status = 0L ;
}
printf( "WriteTape(): Req = %lx, Wrote = %lx\n", BLOCK_SIZE, amount_written ) ;
printf("Block %x - status: %x\n",block++,status);
if (!status && print)
DumpData(buf,BLOCK_SIZE);
} while (status != ERROR_NO_DATA_DETECTED && num--);
return status;
}
int ReadAbsTape(
int block,
int blocks,
int ecc,
HANDLE hTapeHandle
)
{
ULONG bytesRead;
UCHAR buf[32*BLOCK_SIZE+sizeof(CMS_RW_ABS)];
PCMS_RW_ABS Read;
int status;
Read = (PCMS_RW_ABS)buf;
Read->Block = block;
if (blocks > 32) {
printf("Can't read more than a segment at a time\n");
blocks=32;
}
Read->Count = blocks;
Read->BadMap = 0;
Read->flags = ecc?RW_ABS_DOECC:0;
if (!DeviceIoControl(
hTapeHandle,
IOCTL_CMS_READ_ABS_BLOCK,
Read,
sizeof(buf),
Read,
sizeof(buf),
&bytesRead,
NULL) ) {
status = GetLastError( ) ;
} else {
status = 0L ;
}
if (!status)
DumpData((UCHAR *)(Read+1),bytesRead-sizeof(CMS_RW_ABS));
return status;
}
int DetectDrive(
HANDLE hTapeHandle
)
{
CMS_DETECT detect;
int status;
ULONG bytesRead;
if (!DeviceIoControl(
hTapeHandle,
IOCTL_CMS_DETECT_DEVICE,
&detect,
sizeof(detect),
&detect,
sizeof(detect),
&bytesRead,
NULL) ) {
status = GetLastError( ) ;
} else {
status = 0L ;
}
if (!status) {
// Removed some stuff that is uninteresting
if (!detect.driveConfigStatus) {
// printf("driveConfig.speed_change; %x\n",detect.driveConfig.speed_change);
// printf("driveConfig.alt_retrys; %x\n",detect.driveConfig.alt_retrys);
// printf("driveConfig.new_drive; %x\n",detect.driveConfig.new_drive);
// printf("driveConfig.select_byte; %x\n",detect.driveConfig.select_byte);
// printf("driveConfig.deselect_byte; %x\n",detect.driveConfig.deselect_byte);
// printf("driveConfig.drive_select; %x\n",detect.driveConfig.drive_select);
// printf("driveConfig.perp_mode_select; %x\n",detect.driveConfig.perp_mode_select);
// printf("driveConfig.supported_rates; %x\n",detect.driveConfig.supported_rates);
// printf("driveConfig.drive_id; %x\n",detect.driveConfig.drive_id);
// printf("\n");
} else {
printf("DriveConfig error %x\n", detect.driveConfigStatus);
}
if (!detect.driveDescriptorStatus) {
// printf("driveDescriptor.sector_size; %x\n",detect.driveDescriptor.sector_size);
// printf("driveDescriptor.segment_size; %x\n",detect.driveDescriptor.segment_size);
// printf("driveDescriptor.ecc_blocks; %x\n",detect.driveDescriptor.ecc_blocks);
printf("driveDescriptor.vendor; %x %s\n",detect.driveDescriptor.vendor,GetVendorStr(detect.driveDescriptor.vendor));
printf("driveDescriptor.model; %x %s\n",detect.driveDescriptor.model,GetModelStr(detect.driveDescriptor.vendor,detect.driveDescriptor.model));
printf("driveDescriptor.drive_class; %x %s\n",detect.driveDescriptor.drive_class,GetDriveClassStr(detect.driveDescriptor.drive_class));
printf("driveDescriptor.native_class; %x %s\n",detect.driveDescriptor.native_class,GetDriveClassStr(detect.driveDescriptor.native_class));
printf("driveDescriptor.fdc_type; %x %s\n",detect.driveDescriptor.fdc_type,GetFDCStr(detect.driveDescriptor.fdc_type));
printf("\n");
} else {
printf("DriveDescriptor error %x\n",detect.driveDescriptorStatus);
}
if (!detect.driveInfoStatus) {
// printf("driveInfo.drive_class; %x %s\n",detect.driveInfo.drive_class,GetDriveClassStr(detect.driveInfo.drive_class));
printf("driveInfo.vendor; %x %s\n",detect.driveInfo.vendor,GetVendorStr(detect.driveInfo.vendor));
// printf("driveInfo.model; %x\n",detect.driveInfo.model);
printf("driveInfo.version; %x\n",detect.driveInfo.version);
printf("driveInfo.manufacture_date; %x\n",detect.driveInfo.manufacture_date);
printf("driveInfo.serial_number; %x\n",detect.driveInfo.serial_number);
printf("driveInfo.oem_string[20]; %.20s\n",detect.driveInfo.oem_string);
printf("driveInfo.country_code[2]; %.2s\n",detect.driveInfo.country_code);
printf("\n");
} else {
printf("DriveInfo error %x\n",detect.driveInfoStatus);
}
if (!detect.tapeConfigStatus) {
printf("tapeConfig.log_segments; %x\n",detect.tapeConfig.log_segments);
printf("tapeConfig.formattable_segments; %x\n",detect.tapeConfig.formattable_segments);
printf("tapeConfig.formattable_tracks; %x\n",detect.tapeConfig.formattable_tracks);
printf("tapeConfig.seg_tape_track; %x\n",detect.tapeConfig.seg_tape_track);
printf("tapeConfig.num_tape_tracks; %x\n",detect.tapeConfig.num_tape_tracks);
printf("tapeConfig.write_protected; %x\n",detect.tapeConfig.write_protected);
printf("tapeConfig.read_only_media; %x\n",detect.tapeConfig.read_only_media);
printf("tapeConfig.formattable_media; %x\n",detect.tapeConfig.formattable_media);
// printf("tapeConfig.speed_change_ok; %x\n",detect.tapeConfig.speed_change_ok);
printf("tapeConfig.tape_class; %x %s\n",detect.tapeConfig.tape_class,GetTapeClassStr(detect.tapeConfig.tape_class));
// printf("tapeConfig.max_floppy_side; %x\n",detect.tapeConfig.max_floppy_side);
// printf("tapeConfig.max_floppy_track; %x\n",detect.tapeConfig.max_floppy_track);
// printf("tapeConfig.max_floppy_sector; %x\n",detect.tapeConfig.max_floppy_sector);
printf("tapeConfig.xfer_slow; %x\n",detect.tapeConfig.xfer_slow);
printf("tapeConfig.xfer_fast; %x\n",detect.tapeConfig.xfer_fast);
printf("tapeConfig.tape_format_code; %x %s\n",detect.tapeConfig.tape_format_code,GetTapeFormatStr(detect.tapeConfig.tape_format_code));
printf("tapeConfig.tape_type; %x %s\n",detect.tapeConfig.tape_type,GetTapeTypeStr(detect.tapeConfig.tape_type));
printf("\n");
} else {
printf("tapeConfig error %x\n",detect.tapeConfigStatus);
}
}
return status;
}
int SeekTape(
int type,
DWORD tape_pos,
HANDLE hTapeHandle
)
{
int status = -1L ;
printf( "SeekTape(): (%lx)\n", tape_pos ) ;
if( hTapeHandle != NULL ) {
if( status = SetTapePosition(
hTapeHandle,
type,
0,
tape_pos,
0,
FALSE ) ) {
// If call to SetTapePosition() fails, then Set the error
status = GetLastError( ) ;
} else {
status = 0L ;
}
}
return status ;
}
VOID DumpData(
UCHAR *buf,
ULONG size
)
{
int offset;
int i;
offset = 0;
while (size--) {
if ((offset % 16) == 0)
printf("%03x: ",offset);
printf("%02x ",*buf++);
if ((offset % 16) == 15) {
buf -= 16;
for (i=0;i<16;++i) {
if (*buf >= ' ' && *buf <= '~')
printf("%c",*buf);
else
printf(".");
++buf;
}
printf("\n");
}
++offset;
}
printf("\n");
}
int RewindTape(
HANDLE hTapeHandle
)
{
int status = -1L ;
printf( "RewindTape():\n" ) ;
// Check valid tape device handle
if( hTapeHandle != NULL ) {
if( status = SetTapePosition( hTapeHandle,
TAPE_REWIND,
0,
0,
0,
FALSE
) ) {
// Get the Win32 Error Code
status = GetLastError( ) ;
}
}
return( status ) ;
}
int EraseTheTape(
HANDLE hTapeHandle,
BOOL short_erase
)
{
int status = -1L ;
printf( "EraseTheTape():\n" ) ;
if( status = EraseTape(
hTapeHandle,
( short_erase ) ? TAPE_ERASE_SHORT : TAPE_ERASE_LONG,
FALSE
) ) {
// If call to GetTapePosition() fails, then Set the error
status = GetLastError( ) ;
}
return status ;
}
int FormatTheTape(
HANDLE hTapeHandle
)
{
int status = -1L ;
printf( "FormatTheTape():\n" ) ;
if( status = PrepareTape(
hTapeHandle,
TAPE_FORMAT,
FALSE
) ) {
// If call to GetTapePosition() fails, then Set the error
status = GetLastError( ) ;
}
return status ;
}
char *GetDriveClassStr(int class)
{
char *str;
switch(class) {
case UNKNOWN_DRIVE: str = "UNKNOWN DRIVE"; break;
case QIC40_DRIVE: str = "QIC-40 DRIVE"; break;
case QIC80_DRIVE: str = "QIC-80 DRIVE"; break;
case QIC3010_DRIVE: str = "QIC-3010 DRIVE"; break;
case QIC3020_DRIVE: str = "QIC-3020 DRIVE"; break;
case QIC80W_DRIVE: str = "QIC-80 WIDE DRIVE"; break;
default: str = "Bad Info";
}
return str;
}
char *GetTapeTypeStr(int class)
{
char *str;
switch(class) {
case TAPE_UNKNOWN: str = "TAPE_UNKNOWN"; break;
case TAPE_205: str = "QIC-40/80 205ft tape"; break;
case TAPE_425: str = "QIC-40/80 425ft tape"; break;
case TAPE_307: str = "QIC-40/80 307ft tape"; break;
case TAPE_FLEX_550: str = "QIC-3010 tape"; break;
case TAPE_FLEX_900: str = "QIC-3020 tape"; break;
case TAPE_FLEX_550_WIDE: str = "QIC-3010 Wide or Travan 2"; break;
case TAPE_FLEX_900_WIDE: str = "QIC-3020 Wide or Travan 3"; break;
default: str = "Bad Info";
}
return str;
}
char *GetVendorStr(int vendor)
{
char *str;
switch(vendor) {
case VENDOR_UNASSIGNED: str = "UNASSIGNED"; break;
case VENDOR_ALLOY_COMP: str = "ALLOY_COMP"; break;
case VENDOR_3M: str = "3M"; break;
case VENDOR_TANDBERG: str = "TANDBERG"; break;
case VENDOR_CMS_OLD: str = "CMS_OLD"; break;
case VENDOR_CMS: str = "CMS"; break;
case VENDOR_ARCHIVE_CONNER: str = "ARCHIVE_CONNER"; break;
case VENDOR_MOUNTAIN_SUMMIT: str = "MOUNTAIN_SUMMIT"; break;
case VENDOR_WANGTEK_REXON: str = "WANGTEK_REXON"; break;
case VENDOR_SONY: str = "SONY"; break;
case VENDOR_CIPHER: str = "CIPHER"; break;
case VENDOR_IRWIN: str = "IRWIN"; break;
case VENDOR_BRAEMAR: str = "BRAEMAR"; break;
case VENDOR_VERBATIM: str = "VERBATIM"; break;
case VENDOR_CORE: str = "CORE"; break;
case VENDOR_EXABYTE: str = "EXABYTE"; break;
case VENDOR_TEAC: str = "TEAC"; break;
case VENDOR_GIGATEK: str = "GIGATEK"; break;
case VENDOR_IOMEGA: str = "IOMEGA"; break;
case VENDOR_CMS_ENHANCEMENTS: str = "CMS_ENHANCEMENTS"; break;
case VENDOR_UNSUPPORTED: str = "UNSUPPORTED"; break;
case VENDOR_UNKNOWN: str = "UNKNOWN"; break;
default: str = "Bad Info";
}
return str;
}
char *GetTapeClassStr(int info)
{
char *str;
switch(info) {
case QIC40_FMT: str = "QIC40"; break;
case QIC80_FMT: str = "QIC80"; break;
case QIC3010_FMT: str = "QIC3010"; break;
case QIC3020_FMT: str = "QIC3020"; break;
case QIC80W_FMT: str = "QIC80 Wide"; break;
case QIC3010W_FMT: str = "QIC3010 Wide"; break;
case QIC3020W_FMT: str = "QIC3020 Wide"; break;
default: str = "Bad Info";
}
return str;
}
char *GetFDCStr(int info)
{
char *str;
switch(info) {
case FDC_UNKNOWN: str = "Unidentified Controller"; break;
case FDC_NORMAL: str = "NEC 765 Compatible"; break;
case FDC_ENHANCED: str = "Enhanced NEC 765"; break;
case FDC_82077: str = "Intel 82077"; break;
case FDC_82077AA: str = "Intel 82077AA"; break;
case FDC_82078_44: str = "Intel 82078 44 pin"; break;
case FDC_82078_64: str = "Intel 82078 64 pin"; break;
case FDC_NATIONAL: str = "National 8477"; break;
default: str = "Bad Info";
}
return str;
}
char *GetTapeFormatStr(int info)
{
char *str;
switch(info) {
case QIC_FORMAT: str = "205ft or 307ft QIC-40/80 tape format"; break;
case QICEST_FORMAT: str = "1100ft Pegasys tape"; break;
case QICFLX_FORMAT: str = "Flex format tape"; break;
case QIC_XLFORMAT: str = "305ft tape format"; break;
default: str = "Bad Info";
}
return str;
}
char *GetModelStr(int vendor, int info)
{
static char buffer[30];
char *str;
sprintf(buffer,"drive model unknown(%x)",info);
str = buffer;
switch(vendor) {
case VENDOR_CMS_OLD:
case VENDOR_CMS:
switch(info) {
case MODEL_CMS_QIC40: str = "Colorado 120"; break;
case MODEL_CMS_QIC80: str = "Colorado 250"; break;
case MODEL_CMS_QIC3010: str = "Colorado 700"; break;
case MODEL_CMS_QIC3020: str = "Colorado 1400"; break;
case MODEL_CMS_QIC80_STINGRAY: str = "Colorado STINGRAY"; break;
case MODEL_CMS_QIC80W: str = "Colorado T1000"; break;
case MODEL_CMS_TR3: str = "Colorado T3000"; break;
}
break;
case VENDOR_ARCHIVE_CONNER:
switch(info) {
case MODEL_CONNER_QIC80: str = "Conner TapeStor 420"; break;
case MODEL_CONNER_QIC80W: str = "Conner TapeStor 800"; break;
case MODEL_CONNER_QIC3010: str = "Conner TapeStor 700/880"; break;
case MODEL_CONNER_QIC3020: str = "Conner TapeStor 1360/1700"; break;
case MODEL_CONNER_TR3: str = "Conner TapeStor 3200"; break;
}
break;
case VENDOR_CORE:
switch(info) {
case MODEL_CORE_QIC80: str = "Core QIC80 Model"; break;
}
break;
case VENDOR_IOMEGA:
switch(info) {
case MODEL_IOMEGA_QIC80: str = "Iomega QIC80 Model"; break;
case MODEL_IOMEGA_QIC3010: str = "Iomega QIC3010 Model"; break;
case MODEL_IOMEGA_QIC3020: str = "Iomega QIC3020 Model"; break;
}
break;
case VENDOR_MOUNTAIN_SUMMIT:
switch(info) {
case MODEL_SUMMIT_QIC80: str = "Summit QIC80 Model"; break;
case MODEL_SUMMIT_QIC3010: str = "Summit QIC 3010 Model"; break;
}
break;
case VENDOR_WANGTEK_REXON:
switch(info) {
case MODEL_WANGTEK_QIC80: str = "Wangtek QIC80 Model"; break;
case MODEL_WANGTEK_QIC40: str = "Wangtek QIC40 Model"; break;
case MODEL_WANGTEK_QIC3010: str = "Wangtek QIC3010 Model"; break;
}
break;
}
return str;
}