fix typos.
[reactos.git] / rosapps / sysutils / format / format.c
1 //======================================================================
2 //
3 // $Id$
4 //
5 // Formatx
6 //
7 // Copyright (c) 1998 Mark Russinovich
8 // Systems Internals
9 // http://www.sysinternals.com/
10 //
11 // This software is free software; you can redistribute it and/or
12 // modify it under the terms of the GNU Library General Public License as
13 // published by the Free Software Foundation; either version 2 of the
14 // License, or (at your option) any later version.
15 //
16 // This software is distributed in the hope that it will be useful,
17 // but WITHOUT ANY WARRANTY; without even the implied warranty of
18 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 // Library General Public License for more details.
20 //
21 // You should have received a copy of the GNU Library General Public
22 // License along with this software; see the file COPYING.LIB. If
23 // not, write to the Free Software Foundation, Inc., 675 Mass Ave,
24 // Cambridge, MA 02139, USA.
25 //
26 // ---------------------------------------------------------------------
27 // Format clone that demonstrates the use of the FMIFS file system
28 // utility library.
29 //
30 // 1999 February (Emanuele Aliberti)
31 // Adapted for ReactOS and lcc-win32.
32 //
33 // 1999 April (Emanuele Aliberti)
34 // Adapted for ReactOS and egcs.
35 //
36 //======================================================================
37 #define UNICODE 1
38 #define _UNICODE 1
39 #include <windows.h>
40 #include <stdio.h>
41 #include "../../reactos/include/fmifs.h"
42 //#include <tchar.h>
43 #include "win32err.h"
44 #include "config.h"
45
46 #define WBUFSIZE(b) (sizeof(b) / sizeof (wchar_t))
47
48
49 //
50 // Globals
51 //
52 BOOL Error = FALSE;
53
54 // switches
55 BOOL QuickFormat = FALSE;
56 DWORD ClusterSize = 0;
57 BOOL CompressDrive = FALSE;
58 BOOL GotALabel = FALSE;
59 PWCHAR Label = L"";
60 PWCHAR Drive = NULL;
61 PWCHAR Format = L"FAT";
62
63 WCHAR RootDirectory [MAX_PATH];
64 WCHAR LabelString [12];
65
66 #ifndef FMIFS_IMPORT_DLL
67 //
68 // Functions in FMIFS.DLL
69 //
70 PFORMATEX FormatEx;
71 PENABLEVOLUMECOMPRESSION EnableVolumeCompression;
72 #endif /* ndef FMIFS_IMPORT_DLL */
73
74 //
75 // Size array
76 //
77 typedef
78 struct
79 {
80 WCHAR SizeString [16];
81 DWORD ClusterSize;
82
83 } SIZEDEFINITION, *PSIZEDEFINITION;
84
85
86 SIZEDEFINITION
87 LegalSizes [] =
88 {
89 { L"512", 512 },
90 { L"1024", 1024 },
91 { L"2048", 2048 },
92 { L"4096", 4096 },
93 { L"8192", 8192 },
94 { L"16K", 16384 },
95 { L"32K", 32768 },
96 { L"64K", 65536 },
97 { L"128K", 65536 * 2 },
98 { L"256K", 65536 * 4 },
99 { L"", 0 },
100 };
101
102
103 //----------------------------------------------------------------------
104 //
105 // Usage
106 //
107 // Tell the user how to use the program
108 //
109 // 1990218 EA ProgramName missing in wprintf arg list
110 //
111 //----------------------------------------------------------------------
112 VOID
113 Usage( PWCHAR ProgramName )
114 {
115 wprintf(
116 L"\
117 Usage: %s drive: [-FS:file-system] [-V:label] [-Q] [-A:size] [-C]\n\n\
118 [drive:] Specifies the drive to format.\n\
119 -FS:file-system Specifies the type of file system (e.g. FAT).\n\
120 -V:label Specifies volume label.\n\
121 -Q Performs a quick format.\n\
122 -A:size Overrides the default allocation unit size. Default settings\n\
123 are strongly recommended for general use\n\
124 NTFS supports 512, 1024, 2048, 4096, 8192, 16K, 32K, 64K.\n\
125 FAT supports 8192, 16K, 32K, 64K, 128K, 256K.\n\
126 NTFS compression is not supported for allocation unit sizes\n\
127 above 4096.\n\
128 -C Files created on the new volume will be compressed by\n\
129 default.\n\n",
130 ProgramName
131 );
132 }
133
134
135 //----------------------------------------------------------------------
136 //
137 // ParseCommandLine
138 //
139 // Get the switches.
140 //
141 // 19990218 EA switch characters '-' and '/' are wide
142 //
143 //----------------------------------------------------------------------
144 int
145 ParseCommandLine(
146 int argc,
147 WCHAR *argv []
148 )
149 {
150 int i,
151 j;
152 BOOLEAN gotFormat = FALSE;
153 BOOLEAN gotQuick = FALSE;
154 BOOLEAN gotSize = FALSE;
155 BOOLEAN gotLabel = FALSE;
156 BOOLEAN gotCompressed = FALSE;
157
158
159 for (
160 i = 1;
161 (i < argc);
162 i++
163 ) {
164 switch ( argv[i][0] )
165 {
166
167 case L'-':
168 case L'/':
169
170 if( !wcsnicmp( & argv[i][1], L"FS:", 3 ))
171 {
172 if( gotFormat) return -1;
173 Format = & argv[i][4];
174 gotFormat = TRUE;
175 }
176 else if( !wcsnicmp( & argv[i][1], L"A:", 2 ))
177 {
178 if ( gotSize ) return -1;
179 j = 0;
180 while ( LegalSizes[j].ClusterSize &&
181 wcsicmp(
182 LegalSizes[j].SizeString,
183 & argv[i][3]
184 )
185 ) {
186 j++;
187 }
188 if( !LegalSizes[j].ClusterSize ) return i;
189 ClusterSize = LegalSizes[j].ClusterSize;
190 gotSize = TRUE;
191 }
192 else if( !wcsnicmp( & argv[i][1], L"V:", 2 ))
193 {
194 if( gotLabel ) return -1;
195 Label = & argv[i][3];
196 gotLabel = TRUE;
197 GotALabel = TRUE;
198 }
199 else if ( !wcsicmp( & argv[i][1], L"Q" ))
200 {
201 if( gotQuick ) return -1;
202 QuickFormat = TRUE;
203 gotQuick = TRUE;
204 }
205 else if ( !wcsicmp( & argv[i][1], L"C" ))
206 {
207 if( gotCompressed ) return -1;
208 CompressDrive = TRUE;
209 gotCompressed = TRUE;
210 }
211 else
212 {
213 return i;
214 }
215 break;
216
217 default:
218
219 if ( Drive ) return i;
220 if ( argv[i][1] != L':' ) return i;
221
222 Drive = argv[i];
223 break;
224 }
225 }
226 return 0;
227 }
228
229
230 //----------------------------------------------------------------------
231 //
232 // FormatExCallback
233 //
234 // The file system library will call us back with commands that we
235 // can interpret. If we wanted to halt the chkdsk we could return FALSE.
236 //
237 //----------------------------------------------------------------------
238 BOOLEAN
239 __stdcall
240 FormatExCallback(
241 CALLBACKCOMMAND Command,
242 DWORD Modifier,
243 PVOID Argument
244 )
245 {
246 PDWORD percent;
247 PTEXTOUTPUT output;
248 PBOOLEAN status;
249 //static createStructures = FALSE;
250
251 //
252 // We get other types of commands, but we don't have to pay attention to them
253 //
254 switch ( Command )
255 {
256 case PROGRESS:
257 percent = (PDWORD) Argument;
258 wprintf(L"%d percent completed.\r", *percent);
259 break;
260
261 case OUTPUT:
262 output = (PTEXTOUTPUT) Argument;
263 fprintf(stdout, "%s", output->Output);
264 break;
265
266 case DONE:
267 status = (PBOOLEAN) Argument;
268 if ( *status == FALSE )
269 {
270 wprintf(L"FormatEx was unable to complete successfully.\n\n");
271 Error = TRUE;
272 }
273 break;
274 default:
275 break;
276 }
277 return TRUE;
278 }
279
280
281 #ifndef FMIFS_IMPORT_DLL
282 //----------------------------------------------------------------------
283 //
284 // LoadFMIFSEntryPoints
285 //
286 // Loads FMIFS.DLL and locates the entry point(s) we are going to use
287 //
288 // 19990216 EA ANSI strings in LoadFMIFSEntryPoints should be
289 // wide strings
290 //
291 //----------------------------------------------------------------------
292 BOOLEAN
293 LoadFMIFSEntryPoints(VOID)
294 {
295 LoadLibraryW( L"fmifs.dll" );
296
297 if ( !(FormatEx =
298 (void *) GetProcAddress(
299 GetModuleHandleW( L"fmifs.dll"),
300 "FormatEx"
301 )
302 )
303 ) {
304 return FALSE;
305 }
306 if ( !(EnableVolumeCompression =
307 (void *) GetProcAddress(
308 GetModuleHandleW( L"fmifs.dll"),
309 "EnableVolumeCompression"
310 )
311 )
312 ) {
313 return FALSE;
314 }
315 return TRUE;
316 }
317 #endif /* ndef FMIFS_IMPORT_DLL */
318
319
320 //----------------------------------------------------------------------
321 //
322 // WMain
323 //
324 // Engine. Just get command line switches and fire off a format. This
325 // could also be done in a GUI like Explorer does when you select a
326 // drive and run a check on it.
327 //
328 // We do this in UNICODE because the chkdsk command expects PWCHAR
329 // arguments.
330 //
331 //----------------------------------------------------------------------
332 int
333 wmain( int argc, WCHAR *argv[] )
334 {
335 int badArg;
336
337 DWORD media = 0;
338 DWORD driveType;
339
340 WCHAR fileSystem [1024];
341 WCHAR volumeName [1024];
342 WCHAR input [1024];
343
344 DWORD serialNumber;
345 DWORD flags,
346 maxComponent;
347
348 ULARGE_INTEGER freeBytesAvailableToCaller,
349 totalNumberOfBytes,
350 totalNumberOfFreeBytes;
351
352
353 wprintf( L"\
354 \nFormatx v1.0 by Mark Russinovich\n\
355 Systems Internals - http://www.sysinternals.com\n\
356 ReactOs adaptation 1999 by Emanuele Aliberti\n\n"
357 );
358
359 #ifndef FMIFS_IMPORT_DLL
360 //
361 // Get function pointers
362 //
363 if( !LoadFMIFSEntryPoints())
364 {
365 wprintf(L"Could not located FMIFS entry points.\n\n");
366 return -1;
367 }
368 #endif /* ndef FMIFS_IMPORT_DLL */
369 //
370 // Parse command line
371 //
372 if( (badArg = ParseCommandLine( argc, argv )))
373 {
374 wprintf(
375 L"Unknown argument: %s\n",
376 argv[badArg]
377 );
378 Usage(argv[0]);
379 return -1;
380 }
381 //
382 // Get the drive's format
383 //
384 if( !Drive )
385 {
386 wprintf(L"Required drive parameter is missing.\n\n");
387 Usage( argv[0] );
388 return -1;
389 }
390 else
391 {
392 wcscpy( RootDirectory, Drive );
393 }
394 RootDirectory[2] = L'\\';
395 RootDirectory[3] = L'\0';
396 //
397 // See if the drive is removable or not
398 //
399 driveType = GetDriveTypeW( RootDirectory );
400 if ( driveType != DRIVE_FIXED )
401 {
402 wprintf(
403 L"Insert a new floppy in drive %C:\nand press Enter when ready...",
404 RootDirectory[0]
405 );
406 fgetws(
407 input,
408 WBUFSIZE(input),
409 stdin
410 );
411 media = FMIFS_FLOPPY;
412 }
413 //
414 // Determine the drive's file system format
415 //
416 if ( !GetVolumeInformationW(
417 RootDirectory,
418 volumeName,
419 WBUFSIZE(volumeName),
420 & serialNumber,
421 & maxComponent,
422 & flags,
423 fileSystem,
424 WBUFSIZE(fileSystem) )
425 ) {
426 PrintWin32Error(
427 L"Could not query volume",
428 GetLastError()
429 );
430 return -1;
431 }
432 if( !GetDiskFreeSpaceExW(
433 RootDirectory,
434 & freeBytesAvailableToCaller,
435 & totalNumberOfBytes,
436 & totalNumberOfFreeBytes )
437 )
438 {
439 PrintWin32Error(
440 L"Could not query volume size",
441 GetLastError()
442 );
443 return -1;
444 }
445 wprintf(
446 L"The type of the file system is %s.\n",
447 fileSystem
448 );
449 //
450 // Make sure they want to do this
451 //
452 if ( driveType == DRIVE_FIXED )
453 {
454 if ( volumeName[0] )
455 {
456 while (1)
457 {
458 wprintf(
459 L"Enter current volume label for drive %C: ",
460 RootDirectory[0]
461 );
462 fgetws(
463 input,
464 WBUFSIZE(input),
465 stdin
466 );
467 input[ wcslen( input ) - 1 ] = 0;
468
469 if ( !wcsicmp( input, volumeName ))
470 {
471 break;
472 }
473 wprintf(L"An incorrect volume label was entered for this drive.\n");
474 }
475 }
476 while ( 1 )
477 {
478 wprintf(L"\nWARNING, ALL DATA ON NON_REMOVABLE DISK\n");
479 wprintf(L"DRIVE %C: WILL BE LOST!\n", RootDirectory[0] );
480 wprintf(L"Proceed with Format (Y/N)? " );
481 fgetws(
482 input,
483 WBUFSIZE(input),
484 stdin
485 );
486 if ( (input[0] == L'Y') || (input[0] == L'y') ) break;
487
488 if ( (input[0] == L'N') || (input[0] == L'n') )
489 {
490 wprintf(L"\n");
491 return 0;
492 }
493 }
494 media = FMIFS_HARDDISK;
495 }
496 //
497 // Tell the user we're doing a long format if appropriate
498 //
499 if ( !QuickFormat )
500 {
501 if ( totalNumberOfBytes.QuadPart > 1024*1024*10 )
502 {
503
504 wprintf(
505 L"Verifying %dM\n",
506 (DWORD) (totalNumberOfBytes.QuadPart/(1024*1024))
507 );
508 }
509 else
510 {
511 wprintf(
512 L"Verifying %.1fM\n",
513 ((float)(LONGLONG)totalNumberOfBytes.QuadPart)/(float)(1024.0*1024.0)
514 );
515 }
516 }
517 else
518 {
519 if ( totalNumberOfBytes.QuadPart > 1024*1024*10 )
520 {
521 wprintf(
522 L"QuickFormatting %dM\n",
523 (DWORD) (totalNumberOfBytes.QuadPart / (1024 * 1024))
524 );
525 }
526 else
527 {
528 wprintf(
529 L"QuickFormatting %.2fM\n",
530 ((float)(LONGLONG)totalNumberOfBytes.QuadPart) / (float)(1024.0*1024.0)
531 );
532 }
533 wprintf(L"Creating file system structures.\n");
534 }
535 //
536 // Format away!
537 //
538 FormatEx(
539 RootDirectory,
540 media,
541 Format,
542 Label,
543 QuickFormat,
544 ClusterSize,
545 FormatExCallback
546 );
547 if ( Error ) return -1;
548 wprintf(L"Format complete.\n");
549 //
550 // Enable compression if desired
551 //
552 if ( CompressDrive )
553 {
554 if( !EnableVolumeCompression( RootDirectory, TRUE ))
555 {
556 wprintf(L"Volume does not support compression.\n");
557 }
558 }
559 //
560 // Get the label if we don't have it
561 //
562 if( !GotALabel )
563 {
564 wprintf(L"Volume Label (11 characters, Enter for none)? " );
565 fgetws(
566 input,
567 WBUFSIZE(LabelString),
568 stdin
569 );
570
571 input[ wcslen(input) - 1 ] = 0;
572 if( !SetVolumeLabelW( RootDirectory, input ))
573 {
574 PrintWin32Error(
575 L"Could not label volume",
576 GetLastError()
577 );
578 return -1;
579 }
580 }
581 if ( !GetVolumeInformationW(
582 RootDirectory,
583 volumeName,
584 WBUFSIZE(volumeName),
585 & serialNumber,
586 & maxComponent,
587 & flags,
588 fileSystem,
589 WBUFSIZE(fileSystem) )
590 ) {
591 PrintWin32Error(
592 L"Could not query volume",
593 GetLastError()
594 );
595 return -1;
596 }
597 //
598 // Print out some stuff including the formatted size
599 //
600 if ( !GetDiskFreeSpaceExW(
601 RootDirectory,
602 & freeBytesAvailableToCaller,
603 & totalNumberOfBytes,
604 & totalNumberOfFreeBytes )
605 ) {
606 PrintWin32Error(
607 L"Could not query volume size",
608 GetLastError()
609 );
610 return -1;
611 }
612 wprintf(
613 L"\n%I64d bytes total disk space.\n",
614 totalNumberOfBytes.QuadPart
615 );
616 wprintf(
617 L"%I64d bytes available on disk.\n",
618 totalNumberOfFreeBytes.QuadPart
619 );
620 //
621 // Get the drive's serial number
622 //
623 if ( !GetVolumeInformationW(
624 RootDirectory,
625 volumeName,
626 WBUFSIZE(volumeName),
627 & serialNumber,
628 & maxComponent,
629 & flags,
630 fileSystem,
631 WBUFSIZE(fileSystem) )
632 ) {
633 PrintWin32Error(
634 L"Could not query volume",
635 GetLastError()
636 );
637 return -1;
638 }
639 wprintf(
640 L"\nVolume Serial Number is %04X-%04X\n",
641 serialNumber >> 16,
642 serialNumber & 0xFFFF
643 );
644 return 0;
645 }
646
647
648 /* EOF */