format.c File Reference

#include <stdio.h>
#include <windef.h>
#include <winbase.h>
#include <conutils.h>
#include <ndk/rtlfuncs.h>
#include <fmifs/fmifs.h>
#include "resource.h"

Include dependency graph for format.c:

Go to the source code of this file.

Classes
struct	SIZEDEFINITION

Macros
#define	WIN32_NO_STATUS
#define	NTOS_MODE_USER
#define	FMIFS_IMPORT_DLL

Typedefs
typedef struct SIZEDEFINITION *	PSIZEDEFINITION

Functions
static VOID	PrintWin32Error (UINT Message, DWORD ErrorCode)
static int	ParseCommandLine (int argc, WCHAR *argv[])
BOOLEAN WINAPI	FormatExCallback (CALLBACKCOMMAND Command, ULONG Modifier, PVOID Argument)
static VOID	Usage (LPWSTR ProgramName)
int	wmain (int argc, WCHAR *argv[])

Variables
BOOL	Error = FALSE
BOOL	QuickFormat = FALSE
DWORD	ClusterSize = 0
BOOL	CompressDrive = FALSE
BOOL	GotALabel = FALSE
PWCHAR	Label = L""
PWCHAR	Drive = NULL
PWCHAR	FileSystem = L"FAT"
WCHAR	RootDirectory [MAX_PATH]
WCHAR	LabelString [12]
SIZEDEFINITION	LegalSizes []

Macro Definition Documentation

FMIFS_IMPORT_DLL

#define FMIFS_IMPORT_DLL

Definition at line 59 of file format.c.

NTOS_MODE_USER

#define NTOS_MODE_USER

Definition at line 51 of file format.c.

WIN32_NO_STATUS

#define WIN32_NO_STATUS

Definition at line 45 of file format.c.

Typedef Documentation

PSIZEDEFINITION

typedef struct SIZEDEFINITION * PSIZEDEFINITION

Function Documentation

FormatExCallback()

BOOLEAN WINAPI FormatExCallback	(	CALLBACKCOMMAND	Command,
		ULONG	Modifier,
		PVOID	Argument
	)

Definition at line 220 of file format.c.

{
    PDWORD      percent;
    PTEXTOUTPUT output;
    PBOOLEAN    status;
 
    //
    // We get other types of commands, but we don't have to pay attention to them
    //
    switch (Command)
    {
        case PROGRESS:
            percent = (PDWORD)Argument;
            ConResPrintf(StdOut, STRING_COMPLETE, *percent);
            break;
 
        case OUTPUT:
            output = (PTEXTOUTPUT)Argument;
            ConPrintf(StdOut, L"%S\n", output->Output);
            break;
 
        case DONE:
            status = (PBOOLEAN)Argument;
            if (*status == FALSE)
            {
                ConResPuts(StdOut, STRING_FORMAT_FAIL);
                Error = TRUE;
            }
            break;
 
        case DONEWITHSTRUCTURE:
        case UNKNOWN2:
        case UNKNOWN3:
        case UNKNOWN4:
        case UNKNOWN5:
        case INSUFFICIENTRIGHTS:
        case FSNOTSUPPORTED:
        case VOLUMEINUSE:
        case UNKNOWN9:
        case UNKNOWNA:
        case UNKNOWNC:
        case UNKNOWND:
        case STRUCTUREPROGRESS:
        case CLUSTERSIZETOOSMALL:
            ConResPuts(StdOut, STRING_NO_SUPPORT);
            return FALSE;
    }
    return TRUE;
}

Referenced by wmain().

ParseCommandLine()

static int ParseCommandLine ( int  argc, WCHAR *  argv[]  )

static

Definition at line 138 of file format.c.

{
    int i, j;
    BOOLEAN gotFormat = FALSE;
    BOOLEAN gotQuick = FALSE;
    BOOLEAN gotSize = FALSE;
    BOOLEAN gotLabel = FALSE;
    BOOLEAN gotCompressed = FALSE;
 
    for (i = 1; i < argc; i++)
    {
        switch (argv[i][0])
        {
            case L'-': case L'/':
 
                if (!_wcsnicmp(&argv[i][1], L"FS:", 3))
                {
                    if (gotFormat) return -1;
                    FileSystem = &argv[i][4];
                    gotFormat = TRUE;
                }
                else if (!_wcsnicmp(&argv[i][1], L"A:", 2))
                {
                    if (gotSize) return -1;
                    j = 0;
                    while (LegalSizes[j].ClusterSize &&
                           _wcsicmp(LegalSizes[j].SizeString, &argv[i][3]))
                    {
                        j++;
                    }
 
                    if (!LegalSizes[j].ClusterSize) return i;
                    ClusterSize = LegalSizes[j].ClusterSize;
                    gotSize = TRUE;
                }
                else if (!_wcsnicmp(&argv[i][1], L"V:", 2))
                {
                    if (gotLabel) return -1;
                    Label = &argv[i][3];
                    gotLabel = TRUE;
                    GotALabel = TRUE;
                }
                else if (!_wcsicmp(&argv[i][1], L"Q"))
                {
                    if (gotQuick) return -1;
                    QuickFormat = TRUE;
                    gotQuick = TRUE;
                }
                else if (!_wcsicmp(&argv[i][1], L"C"))
                {
                    if (gotCompressed) return -1;
                    CompressDrive = TRUE;
                    gotCompressed = TRUE;
                }
                else
                {
                    return i;
                }
                break;
 
            default:
            {
                if (Drive) return i;
                if (argv[i][1] != L':') return i;
 
                Drive = argv[i];
                break;
            }
        }
    }
    return 0;
}

Referenced by wmain().

PrintWin32Error()

static VOID PrintWin32Error ( UINT  Message, DWORD  ErrorCode  )

static

Definition at line 116 of file format.c.

{
    PCWSTR pszMsg;
    INT Len;
 
    Len = LoadStringW(NULL, Message, (PWSTR)&pszMsg, 0);
    if (Len > 0)
        ConPrintf(StdErr, L"%.*s: ", Len, pszMsg);
 
    ConMsgPuts(StdErr, FORMAT_MESSAGE_FROM_SYSTEM,
               NULL, ErrorCode, LANG_USER_DEFAULT);
    ConPuts(StdErr, L"\n");
}

Referenced by wmain().

Usage()

static VOID Usage ( LPWSTR  ProgramName )

static

Definition at line 320 of file format.c.

{
    WCHAR szFormats[MAX_PATH];
    WCHAR szFormatW[MAX_PATH];
    DWORD Index = 0;
    BYTE dummy;
    BOOLEAN latestVersion;
 
    szFormats[0] = UNICODE_NULL;
    while (QueryAvailableFileSystemFormat(Index++, szFormatW, &dummy, &dummy, &latestVersion))
    {
        if (!latestVersion)
            continue;
        if (szFormats[0])
            wcscat(szFormats, L", ");
 
        wcscat(szFormats, szFormatW);
    }
    ConResPrintf(StdOut, STRING_HELP, ProgramName, szFormats);
}

wmain()

int wmain	(	int	argc,
		WCHAR *	argv[]
	)

Definition at line 354 of file format.c.

{
    int badArg;
    DEVICE_INFORMATION DeviceInformation;
    FMIFS_MEDIA_FLAG media = FMIFS_HARDDISK;
    DWORD driveType;
    WCHAR fileSystem[1024];
    WCHAR volumeName[1024];
    WCHAR input[1024];
    DWORD serialNumber;
    ULARGE_INTEGER totalNumberOfBytes, totalNumberOfFreeBytes;
    DWORD dwError;
    PCWSTR pszMsg;
    INT Len;
 
    /* Initialize the Console Standard Streams */
    ConInitStdStreams();
 
    ConPuts(StdOut,
        L"\n"
        L"Formatx v1.0 by Mark Russinovich\n"
        L"Systems Internals - http://www.sysinternals.com\n"
        L"ReactOS adaptation 1999 by Emanuele Aliberti\n\n");
 
#ifndef FMIFS_IMPORT_DLL
    //
    // Get function pointers
    //
    if (!LoadFMIFSEntryPoints())
    {
        ConResPuts(StdErr, STRING_FMIFS_FAIL);
        return -1;
    }
#endif
 
    //
    // Parse command line
    //
    badArg = ParseCommandLine(argc, argv);
    if (badArg)
    {
        ConResPrintf(StdErr, STRING_UNKNOW_ARG, argv[badArg]);
        Usage(argv[0]);
        return -1;
    }
 
    //
    // Get the drive's format
    //
    if (!Drive)
    {
        ConResPuts(StdErr, STRING_DRIVE_PARM);
        Usage(argv[0]);
        return -1;
    }
    else
    {
        wcscpy(RootDirectory, Drive);
    }
    RootDirectory[2] = L'\\';
    RootDirectory[3] = L'\0';
 
    //
    // See if the drive is removable or not
    //
    driveType = GetDriveTypeW(RootDirectory);
    switch (driveType)
    {
        case DRIVE_UNKNOWN:
        case DRIVE_NO_ROOT_DIR: // This case used to report STRING_NO_VOLUME, which has no ".\n".
            ConResPuts(StdErr, STRING_ERROR_DRIVE_TYPE);
            return -1;
 
        case DRIVE_REMOTE:
        case DRIVE_CDROM:
            ConResPuts(StdOut, STRING_NO_SUPPORT);
            return -1;
 
        case DRIVE_REMOVABLE:
            ConResPrintf(StdOut, STRING_INSERT_DISK, RootDirectory[0]);
            fgetws(input, ARRAYSIZE(input), stdin);
            media = FMIFS_FLOPPY;
            break;
 
        case DRIVE_FIXED:
        case DRIVE_RAMDISK:
            media = FMIFS_HARDDISK;
            break;
    }
 
    // Reject attempts to format the system drive
    {
        WCHAR path[MAX_PATH + 1];
        UINT rc;
        rc = GetWindowsDirectoryW(path, MAX_PATH);
        if (rc == 0 || rc > MAX_PATH)
            // todo: Report "Unable to query system directory"
            return -1;
        if (towlower(path[0]) == towlower(Drive[0]))
        {
            // todo: report "Cannot format system drive"
            ConResPuts(StdOut, STRING_NO_SUPPORT);
            return -1;
        }
    }
 
    //
    // Get the existing name and file system, and print out the latter
    //
    if (!GetVolumeInformationW(RootDirectory,
                               volumeName, ARRAYSIZE(volumeName),
                               NULL, NULL, NULL,
                               fileSystem, ARRAYSIZE(fileSystem)))
    {
        dwError = GetLastError();
        if (dwError == ERROR_UNRECOGNIZED_VOLUME)
        {
            // Unformatted volume
            volumeName[0] = UNICODE_NULL;
            wcscpy(fileSystem, L"RAW");
        }
        else
        {
            PrintWin32Error(STRING_NO_VOLUME, dwError);
            return -1;
        }
    }
 
    ConResPrintf(StdOut, STRING_FILESYSTEM, fileSystem);
 
    if (!QueryDeviceInformation(RootDirectory, &DeviceInformation, sizeof(DeviceInformation)))
    {
        totalNumberOfBytes.QuadPart = 0;
    }
    else
    {
        totalNumberOfBytes.QuadPart = DeviceInformation.SectorSize *
                                      DeviceInformation.SectorCount.QuadPart;
    }
 
    /* QueryDeviceInformation returns more accurate volume length and works with
     * unformatted volumes, however it will NOT return volume length on XP/2003.
     * Fallback to GetFreeDiskSpaceExW if we did not get any volume length. */
    if (totalNumberOfBytes.QuadPart == 0 &&
        !GetDiskFreeSpaceExW(RootDirectory,
                             NULL,
                             &totalNumberOfBytes,
                             NULL))
    {
        dwError = GetLastError();
        PrintWin32Error(STRING_NO_VOLUME_SIZE, dwError);
        return -1;
    }
 
    //
    // Make sure they want to do this
    //
    if (driveType == DRIVE_FIXED)
    {
        if (volumeName[0])
        {
            while (TRUE)
            {
                ConResPrintf(StdOut, STRING_LABEL_NAME_EDIT, RootDirectory[0]);
                fgetws(input, ARRAYSIZE(input), stdin);
                input[wcslen(input) - 1] = UNICODE_NULL;
 
                if (!_wcsicmp(input, volumeName))
                    break;
 
                ConResPuts(StdOut, STRING_ERROR_LABEL);
            }
        }
 
        ConResPrintf(StdOut, STRING_YN_FORMAT, RootDirectory[0]);
 
        Len = LoadStringW(NULL, STRING_YES_NO_FAQ, (PWSTR)&pszMsg, 0);
        if (Len < 2) pszMsg = L"YN";
        while (TRUE)
        {
            fgetws(input, ARRAYSIZE(input), stdin);
            if (towupper(input[0]) == pszMsg[0])
                break;
            if (towupper(input[0]) == pszMsg[1])
            {
                ConPuts(StdOut, L"\n");
                return 0;
            }
        }
    }
 
    //
    // Tell the user we're doing a long format if appropriate
    //
    if (!QuickFormat)
    {
        Len = LoadStringW(NULL, STRING_VERIFYING, (PWSTR)&pszMsg, 0);
        if (totalNumberOfBytes.QuadPart > 1024*1024*10)
        {
            ConPrintf(StdOut, L"%.*s %luM\n", Len, pszMsg,
                (DWORD)(totalNumberOfBytes.QuadPart/(1024*1024)));
        }
        else
        {
            ConPrintf(StdOut, L"%.*s %.1fM\n", Len, pszMsg,
                ((float)(LONGLONG)totalNumberOfBytes.QuadPart)/(float)(1024.0*1024.0));
        }
    }
    else
    {
        Len = LoadStringW(NULL, STRING_FAST_FMT, (PWSTR)&pszMsg, 0);
        if (totalNumberOfBytes.QuadPart > 1024*1024*10)
        {
            ConPrintf(StdOut, L"%.*s %luM\n", Len, pszMsg,
                (DWORD)(totalNumberOfBytes.QuadPart/(1024*1024)));
        }
        else
        {
            ConPrintf(StdOut, L"%.*s %.2fM\n", Len, pszMsg,
                ((float)(LONGLONG)totalNumberOfBytes.QuadPart)/(float)(1024.0*1024.0));
        }
        ConResPuts(StdOut, STRING_CREATE_FSYS);
    }
 
    //
    // Format away!
    //
    FormatEx(RootDirectory, media, FileSystem, Label, QuickFormat,
             ClusterSize, FormatExCallback);
    if (Error) return -1;
    ConPuts(StdOut, L"\n");
    ConResPuts(StdOut, STRING_FMT_COMPLETE);
 
    //
    // Enable compression if desired
    //
    if (CompressDrive)
    {
        if (!EnableVolumeCompression(RootDirectory, TRUE))
            ConResPuts(StdOut, STRING_VOL_COMPRESS);
    }
 
    //
    // Get the label if we don't have it
    //
    if (!GotALabel)
    {
        ConResPuts(StdOut, STRING_ENTER_LABEL);
        fgetws(input, ARRAYSIZE(LabelString), stdin);
        input[wcslen(input) - 1] = UNICODE_NULL;
 
        if (!SetVolumeLabelW(RootDirectory, input))
        {
            dwError = GetLastError();
            PrintWin32Error(STRING_NO_LABEL, dwError);
            return -1;
        }
    }
 
    //
    // Get and print out some stuff including the formatted size
    //
    if (!GetDiskFreeSpaceExW(RootDirectory,
                             NULL,
                             &totalNumberOfBytes,
                             &totalNumberOfFreeBytes))
    {
        dwError = GetLastError();
        PrintWin32Error(STRING_NO_VOLUME_SIZE, dwError);
        return -1;
    }
 
    ConResPrintf(StdOut, STRING_FREE_SPACE, totalNumberOfBytes.QuadPart,
                                            totalNumberOfFreeBytes.QuadPart);
 
    //
    // Get and print out the new serial number
    //
    if (!GetVolumeInformationW(RootDirectory,
                               NULL, 0,
                               &serialNumber, NULL, NULL,
                               NULL, 0))
    {
        dwError = GetLastError();
        PrintWin32Error(STRING_NO_VOLUME, dwError);
        return -1;
    }
 
    ConResPrintf(StdOut, STRING_SERIAL_NUMBER,
                         (unsigned int)(serialNumber >> 16),
                         (unsigned int)(serialNumber & 0xFFFF));
 
    return 0;
}

Variable Documentation

ClusterSize

DWORD ClusterSize = 0

Definition at line 66 of file format.c.

Referenced by _Function_class_(), CheckAgainstNTFS(), CmpOpenHiveFiles(), RecycleBin5::DeleteFile(), Ext2Format(), Fat12Format(), Fat16Format(), Fat32Format(), FatExamineFatEntries(), FormatDrive(), FormatEx(), FormatFileSystem(), FormatFileSystem_UStr(), FormatPartition(), FormatVolume(), GetDefaultClusterSize(), InsertDefaultClusterSizeForFs(), MiReleaseSystemPtes(), MiReserveAlignedSystemPtes(), NtfsHasFileSystem(), ParseCommandLine(), UpdateFileSize(), VfatFormat(), VfatSetAllocationSizeInformation(), and wmain().

CompressDrive

BOOL CompressDrive = FALSE

Definition at line 67 of file format.c.

Referenced by ParseCommandLine(), and wmain().

Drive

PWCHAR Drive = NULL

Definition at line 70 of file format.c.

Referenced by ParseCommandLine(), and wmain().

Error

BOOL Error = FALSE

Definition at line 62 of file format.c.

Referenced by FormatExCallback(), and wmain().

FileSystem

PWCHAR FileSystem = L"FAT"

Definition at line 71 of file format.c.

Referenced by AddProvider(), CheckVolume(), ChkdskFileSystem_UStr(), FileSystemToMBRPartitionType(), FormatDlgProcWorker(), FormatFileSystem_UStr(), GetProvider(), InstallBootManagerAndBootEntries(), InstallBootManagerAndBootEntriesWorker(), OpenVolume(), ParseCommandLine(), PrintVolumeInfo(), QueryAvailableFileSystemFormat(), VolumeInfoMain(), and wmain().

GotALabel

BOOL GotALabel = FALSE

Definition at line 68 of file format.c.

Referenced by ParseCommandLine(), and wmain().

Label

PWCHAR Label = L""

Definition at line 69 of file format.c.

Referenced by DisplayStatus(), CDFParser::DoDiskLabel(), Ext2Format(), Ext2InitializeLabel(), Fat12Format(), Fat16Format(), Fat32Format(), FatConstructLabelDirent(), Format(), FormatEx(), FormatEx2(), FormatFileSystem(), FormatFileSystem_UStr(), FormatPartition(), FormatVolume(), JustForCheckClearInterrupt(), LISTVIEW_GetItemMetrics(), main(), CDFParser::OnDiskLabel(), ParseCommandLine(), ReportTimes(), CDrivesFolder::SetDriveLabel(), VfatFormat(), and wmain().

LabelString

WCHAR LabelString[12]

Definition at line 74 of file format.c.

Referenced by format_main(), and wmain().

LegalSizes

SIZEDEFINITION LegalSizes[]

Initial value:

= {
    { L"512", 512 },
    { L"1024", 1024 },
    { L"2048", 2048 },
    { L"4096", 4096 },
    { L"8192", 8192 },
    { L"16K", 16384 },
    { L"32K", 32768 },
    { L"64K", 65536 },
    { L"128K", 65536 * 2 },
    { L"256K", 65536 * 4 },
    { L"", 0 },
}

Definition at line 94 of file format.c.

Referenced by ParseCommandLine().

QuickFormat

BOOL QuickFormat = FALSE

Definition at line 65 of file format.c.

Referenced by Ext2Format(), Fat12Format(), Fat16Format(), Fat32Format(), FatxFormat(), Format(), FormatDrive(), FormatEx(), FormatFileSystem(), FormatFileSystem_UStr(), FormatPartition(), FormatVolume(), ParseCommandLine(), VfatFormat(), VfatxFormat(), and wmain().

RootDirectory

WCHAR RootDirectory[MAX_PATH]

Definition at line 73 of file format.c.

Referenced by BaseFormatObjectAttributes(), CheckForValidPEAndVendor(), CmpLinkHiveToMaster(), ConnectRegistry(), CreateRegistryFile(), DoesPathExist(), DoesPathExist_UStr(), FatBufferDirectory(), FltGetDestinationFileNameInformation(), MyDeleteFile(), ObpLookupObjectName(), OpenAndMapFile(), OpenDirectoryByHandleOrPath(), QueryVolumeName(), RtlInitializeRXact(), RXactInitializeContext(), RXactpOpenTargetKey(), TestObRootSecurity(), and wmain().