![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to mfmt.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / samples / floppy|
Return to mfmt.c CVS log | Up to [WindowsNT SDKs] / mstools / samples / floppy |
1.1 root 1:
2: /******************************************************************************\
3: * This is a part of the Microsoft Source Code Samples.
4: * Copyright (C) 1993 Microsoft Corporation.
5: * All rights reserved.
6: * This source code is only intended as a supplement to
7: * Microsoft Development Tools and/or WinHelp documentation.
8: * See these sources for detailed information regarding the
9: * Microsoft samples programs.
10: \******************************************************************************/
11:
12: /*++
13:
14: Module Name:
15:
16: mfmt.c
17:
18: Abstract:
19:
20: This program is designed to show how to access a physical floppy
21: disk using the Win32 API set.
22:
23: This program has two major functions.
24:
25: - It can be used to display the geometry of a disk
26:
27: mfmt -g a:
28:
29: - It can be used to produce a disk image, or to write a disk
30: image to a floppy.
31:
32: mfmt -c a: bootdisk - produce a disk image of a:
33:
34: mfmt -c bootdisk a: - make a: identical to bootdisk image
35:
36: This program is very very simple. Minimal error checking is done. It is
37: meant to provide an example of how to:
38:
39: - Open a physical disk
40:
41: - Read a disk's geometry
42:
43: - Perform a low level format operation
44:
45: - read and write physical sectors
46:
47: --*/
48:
49: #include <stdlib.h>
50: #include <stdio.h>
51: #include <windows.h>
52: #include <winioctl.h>
53: #include <string.h>
54: #include <ctype.h>
55: #include <memory.h>
56:
57: DISK_GEOMETRY SupportedGeometry[20];
58: DWORD SupportedGeometryCount;
59:
60: BOOL
61: GetDiskGeometry(
62: HANDLE hDisk,
63: PDISK_GEOMETRY lpGeometry
64: )
65:
66: {
67: DWORD ReturnedByteCount;
68:
69: return DeviceIoControl(
70: hDisk,
71: IOCTL_DISK_GET_DRIVE_GEOMETRY,
72: NULL,
73: 0,
74: lpGeometry,
75: sizeof(*lpGeometry),
76: &ReturnedByteCount,
77: NULL
78: );
79: }
80:
81: DWORD
82: GetSupportedGeometrys(
83: HANDLE hDisk
84: )
85: {
86: DWORD ReturnedByteCount;
87: BOOL b;
88: DWORD NumberSupported;
89:
90: b = DeviceIoControl(
91: hDisk,
92: IOCTL_DISK_GET_MEDIA_TYPES,
93: NULL,
94: 0,
95: SupportedGeometry,
96: sizeof(SupportedGeometry),
97: &ReturnedByteCount,
98: NULL
99: );
100: if ( b ) {
101: NumberSupported = ReturnedByteCount / sizeof(DISK_GEOMETRY);
102: }
103: else {
104: NumberSupported = 0;
105: }
106: SupportedGeometryCount = NumberSupported;
107:
108: return NumberSupported;
109: }
110:
111: VOID
112: PrintGeometry(
113: LPSTR lpDriveName,
114: PDISK_GEOMETRY lpGeometry
115: )
116: {
117: LPSTR MediaType;
118:
119: if (lpDriveName) {
120: printf("Geometry for Drive %s\n",lpDriveName);
121: }
122:
123: switch ( lpGeometry->MediaType ) {
124: case F5_1Pt2_512: MediaType = "5.25, 1.2MB, 512 bytes/sector";break;
125: case F3_1Pt44_512: MediaType = "3.5, 1.44MB, 512 bytes/sector";break;
126: case F3_2Pt88_512: MediaType = "3.5, 2.88MB, 512 bytes/sector";break;
127: case F3_20Pt8_512: MediaType = "3.5, 20.8MB, 512 bytes/sector";break;
128: case F3_720_512: MediaType = "3.5, 720KB, 512 bytes/sector";break;
129: case F5_360_512: MediaType = "5.25, 360KB, 512 bytes/sector";break;
130: case F5_320_512: MediaType = "5.25, 320KB, 512 bytes/sector";break;
131: case F5_320_1024: MediaType = "5.25, 320KB, 1024 bytes/sector";break;
132: case F5_180_512: MediaType = "5.25, 180KB, 512 bytes/sector";break;
133: case F5_160_512: MediaType = "5.25, 160KB, 512 bytes/sector";break;
134: case RemovableMedia: MediaType = "Removable media other than floppy";break;
135: case FixedMedia: MediaType = "Fixed hard disk media";break;
136: default: MediaType = "Unknown";break;
137: }
138: printf(" Media Type %s\n",MediaType);
139: printf(" Cylinders %d Tracks/Cylinder %d Sectors/Track %d\n",
140: lpGeometry->Cylinders.LowPart,
141: lpGeometry->TracksPerCylinder,
142: lpGeometry->SectorsPerTrack
143: );
144: }
145:
146: BOOL
147: LowLevelFormat(
148: HANDLE hDisk,
149: PDISK_GEOMETRY lpGeometry
150: )
151: {
152: FORMAT_PARAMETERS FormatParameters;
153: PBAD_TRACK_NUMBER lpBadTrack;
154: UINT i;
155: BOOL b;
156: DWORD ReturnedByteCount;
157:
158: FormatParameters.MediaType = lpGeometry->MediaType;
159: FormatParameters.StartHeadNumber = 0;
160: FormatParameters.EndHeadNumber = lpGeometry->TracksPerCylinder - 1;
161: lpBadTrack = (PBAD_TRACK_NUMBER) LocalAlloc(LMEM_ZEROINIT,lpGeometry->TracksPerCylinder*sizeof(*lpBadTrack));
162:
163: for (i = 0; i < lpGeometry->Cylinders.LowPart; i++) {
164:
165: FormatParameters.StartCylinderNumber = i;
166: FormatParameters.EndCylinderNumber = i;
167:
168: b = DeviceIoControl(
169: hDisk,
170: IOCTL_DISK_FORMAT_TRACKS,
171: &FormatParameters,
172: sizeof(FormatParameters),
173: lpBadTrack,
174: lpGeometry->TracksPerCylinder*sizeof(*lpBadTrack),
175: &ReturnedByteCount,
176: NULL
177: );
178:
179: if (!b ) {
180: LocalFree(lpBadTrack);
181: return b;
182: }
183: }
184:
185: LocalFree(lpBadTrack);
186:
187: return TRUE;
188: }
189:
190: BOOL
191: LockVolume(
192: HANDLE hDisk
193: )
194: {
195: DWORD ReturnedByteCount;
196:
197: return DeviceIoControl(
198: hDisk,
199: FSCTL_LOCK_VOLUME,
200: NULL,
201: 0,
202: NULL,
203: 0,
204: &ReturnedByteCount,
205: NULL
206: );
207: }
208:
209: BOOL
210: UnlockVolume(
211: HANDLE hDisk
212: )
213: {
214: DWORD ReturnedByteCount;
215:
216: return DeviceIoControl(
217: hDisk,
218: FSCTL_UNLOCK_VOLUME,
219: NULL,
220: 0,
221: NULL,
222: 0,
223: &ReturnedByteCount,
224: NULL
225: );
226: }
227:
228: BOOL
229: DismountVolume(
230: HANDLE hDisk
231: )
232: {
233: DWORD ReturnedByteCount;
234:
235: return DeviceIoControl(
236: hDisk,
237: FSCTL_DISMOUNT_VOLUME,
238: NULL,
239: 0,
240: NULL,
241: 0,
242: &ReturnedByteCount,
243: NULL
244: );
245: }
246:
247: DWORD
248: _cdecl
249: main(
250: int argc,
251: char *argv[],
252: char *envp[]
253: )
254: {
255: char Drive[MAX_PATH];
256: HANDLE hDrive, hDiskImage;
257: DISK_GEOMETRY Geometry;
258: UINT i;
259: char c, *p;
260: LPSTR DriveName;
261: BOOL fUsage = TRUE;
262: BOOL fShowGeometry = FALSE;
263: BOOL fDiskImage = FALSE;
264: BOOL SourceIsDrive;
265: LPSTR Source, Destination, DiskImage;
266:
267: if ( argc > 1 ) {
268: fUsage = FALSE;
269: while (--argc > 0 ) {
270: p = *++argv;
271: if (*p == '/' || *p == '-') {
272: while (c = *++p)
273: switch (toupper( c )) {
274: case '?':
275: fUsage = TRUE;
276: break;
277:
278: case 'C':
279: fDiskImage = TRUE;
280: argc--, argv++;
281: Source = *argv;
282: argc--, argv++;
283: Destination = *argv;
284: break;
285:
286: case 'G':
287: argc--, argv++;
288: if ( (DriveName = *argv ) && *DriveName &&
289: isalpha(*DriveName) )
290: fShowGeometry = TRUE;
291: else
292: {
293: printf( "MFMT: Missing drive letter after -G\n" );
294: DriveName = NULL;
295: fUsage = TRUE;
296: }
297: break;
298:
299: default:
300: printf("MFMT: Invalid switch - /%c\n", c );
301: fUsage = TRUE;
302: break;
303: }
304: }
305: }
306: }
307:
308: if ( fUsage ) {
309: printf("usage: MFMT switches \n" );
310: printf(" [-?] display this message\n" );
311: printf(" [-g drive] shows disk geometry\n" );
312: printf(" [-c source destination] produce diskimage\n" );
313: ExitProcess(1);
314: }
315:
316: if ( fShowGeometry ) {
317: sprintf(Drive,"\\\\.\\%s",DriveName);
318: hDrive = CreateFile(
319: Drive,
320: GENERIC_READ | GENERIC_WRITE,
321: 0,
322: NULL,
323: OPEN_EXISTING,
324: 0,
325: NULL
326: );
327: if ( hDrive == INVALID_HANDLE_VALUE ) {
328: printf("MFMT: Open %s failed %d\n",DriveName,GetLastError());
329: ExitProcess(1);
330: }
331:
332: LockVolume(hDrive);
333:
334: if ( !GetDiskGeometry(hDrive,&Geometry) ) {
335: printf("MFMT: GetDiskGeometry %s failed %d\n",DriveName,GetLastError());
336: ExitProcess(1);
337: }
338: PrintGeometry(DriveName,&Geometry);
339:
340: if ( !GetSupportedGeometrys(hDrive) ) {
341: printf("MFMT: GetSupportedGeometrys %s failed %d\n",DriveName,GetLastError());
342: ExitProcess(1);
343: }
344: printf("\nDrive %s supports the following disk geometries\n",DriveName);
345:
346: for(i=0;i<SupportedGeometryCount;i++) {
347: printf("\n");
348: PrintGeometry(NULL,&SupportedGeometry[i]);
349: }
350:
351: printf("\n");
352: ExitProcess(0);
353: }
354:
355: if ( fDiskImage ) {
356: SourceIsDrive = FALSE;
357: if ( Source[strlen(Source)-1] == ':' ) {
358: SourceIsDrive = TRUE;
359: sprintf(Drive,"\\\\.\\%s",Source);
360: DiskImage = Destination;
361: }
362: if ( Destination[strlen(Destination)-1] == ':' ) {
363: if ( SourceIsDrive ) {
364: printf("MFMT: Source and Destination cannot both be drives\n");
365: ExitProcess(1);
366: }
367: SourceIsDrive = FALSE;
368: sprintf(Drive,"\\\\.\\%s",Destination);
369: DiskImage = Source;
370: }
371: else {
372: if ( !SourceIsDrive ) {
373: printf("MFMT: Either Source or Destination must be a drive\n");
374: ExitProcess(1);
375: }
376: }
377:
378: //
379: // Open and Lock the drive
380: //
381:
382: hDrive = CreateFile(
383: Drive,
384: GENERIC_READ | GENERIC_WRITE,
385: 0,
386: NULL,
387: OPEN_EXISTING,
388: 0,
389: NULL
390: );
391: if ( hDrive == INVALID_HANDLE_VALUE ) {
392: printf("MFMT: Open %s failed %d\n",DriveName,GetLastError());
393: ExitProcess(1);
394: }
395: LockVolume(hDrive);
396:
397: if ( !GetDiskGeometry(hDrive,&Geometry) ) {
398: printf("MFMT: GetDiskGeometry %s failed %d\n",DriveName,GetLastError());
399: ExitProcess(1);
400: }
401:
402: if ( !GetSupportedGeometrys(hDrive) ) {
403: printf("MFMT: GetSupportedGeometrys %s failed %d\n",DriveName,GetLastError());
404: ExitProcess(1);
405: }
406:
407: //
408: // Open the disk image file
409: //
410:
411: hDiskImage = CreateFile(
412: DiskImage,
413: GENERIC_READ | GENERIC_WRITE,
414: 0,
415: NULL,
416: SourceIsDrive ? CREATE_ALWAYS : OPEN_EXISTING,
417: 0,
418: NULL
419: );
420: if ( hDiskImage == INVALID_HANDLE_VALUE ) {
421: printf("MFMT: Open %s failed %d\n",DiskImage,GetLastError());
422: ExitProcess(1);
423: }
424:
425: //
426: // Now do the copy
427: //
428: {
429: LPVOID IoBuffer;
430: BOOL b;
431: DWORD BytesRead, BytesWritten;
432: DWORD FileSize;
433: DWORD GeometrySize;
434:
435: //
436: // If we are copying from floppy to file, just do the copy
437: // Otherwise, we might have to format the floppy first
438: //
439:
440: if ( SourceIsDrive ) {
441:
442: //
443: // Device reads must be sector aligned. VirtualAlloc will
444: // garuntee alignment
445: //
446:
447: GeometrySize = Geometry.Cylinders.LowPart *
448: Geometry.TracksPerCylinder *
449: Geometry.SectorsPerTrack *
450: Geometry.BytesPerSector;
451:
452: IoBuffer = VirtualAlloc(NULL,GeometrySize,MEM_COMMIT,PAGE_READWRITE);
453:
454: if ( !IoBuffer ) {
455: printf("MFMT: Buffer Allocation Failed\n");
456: ExitProcess(1);
457: }
458:
459: b = ReadFile(hDrive,IoBuffer, GeometrySize, &BytesRead, NULL);
460: if (b && BytesRead){
461: b = WriteFile(hDiskImage,IoBuffer, BytesRead, &BytesWritten, NULL);
462: if ( !b || ( BytesRead != BytesWritten ) ) {
463: printf("MFMT: Fatal Write Error %d\n",GetLastError());
464: ExitProcess(1);
465: }
466: }
467: else {
468: printf("MFMT: Fatal Read Error %d\n",GetLastError());
469: ExitProcess(1);
470: }
471: }
472: else {
473:
474: //
475: // Check to see if the image will fit on the floppy. If it
476: // will, then LowLevelFormat the floppy and press on
477: //
478:
479: FileSize = GetFileSize(hDiskImage,NULL);
480:
481: b = FALSE;
482: for(i=0;i<SupportedGeometryCount;i++) {
483: GeometrySize = SupportedGeometry[i].Cylinders.LowPart *
484: SupportedGeometry[i].TracksPerCylinder *
485: SupportedGeometry[i].SectorsPerTrack *
486: SupportedGeometry[i].BytesPerSector;
487: if ( GeometrySize >= FileSize ) {
488:
489: IoBuffer = VirtualAlloc(NULL,GeometrySize,MEM_COMMIT,PAGE_READWRITE);
490:
491: if ( !IoBuffer ) {
492: printf("MFMT: Buffer Allocation Failed\n");
493: ExitProcess(1);
494: }
495:
496: //
497: // Format the floppy
498: //
499:
500: LowLevelFormat(hDrive,&SupportedGeometry[i]);
501:
502: b = ReadFile(hDiskImage,IoBuffer, GeometrySize, &BytesRead, NULL);
503: if (b && BytesRead){
504: b = WriteFile(hDrive,IoBuffer, BytesRead, &BytesWritten, NULL);
505: if ( !b || ( BytesRead != BytesWritten ) ) {
506: printf("MFMT: Fatal Write Error %d\n",GetLastError());
507: ExitProcess(1);
508: }
509: }
510: else {
511: printf("MFMT: Fatal Read Error %d\n",GetLastError());
512: ExitProcess(1);
513: }
514: b = TRUE;
515: break;
516: }
517: }
518:
519: if ( !b ) {
520: printf("MFMT: FileSize %d is not supported on drive %s\n",FileSize,DriveName);
521: ExitProcess(1);
522: }
523: }
524: }
525:
526: //
527: // Dismounting forces the filesystem to re-evaluate the media id
528: // and geometry. This is the same as popping the floppy in and out
529: // of the disk drive
530: //
531:
532: DismountVolume(hDrive);
533: UnlockVolume(hDrive);
534:
535: ExitProcess(0);
536: }
537: return (0);
538: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.