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

Include dependency graph for chkdsk.c:

Macros
#define	WIN32_NO_STATUS

#define	NTOS_MODE_USER

#define	FMIFS_IMPORT_DLL

Functions
static VOID	PrintWin32Error (int Message, DWORD ErrorCode)

BOOL WINAPI	CtrlCIntercept (DWORD dwCtrlType)

static VOID	Usage (PWCHAR ProgramName)

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

BOOLEAN WINAPI	ChkdskCallback (CALLBACKCOMMAND Command, DWORD Modifier, PVOID Argument)

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

Variables
BOOL	Error = FALSE

BOOL	FixErrors = FALSE

BOOL	SkipClean = FALSE

BOOL	ScanSectors = FALSE

BOOL	Verbose = FALSE

PWCHAR	Drive = NULL

WCHAR	CurrentDirectory [1024]

Macro Definition Documentation

◆ FMIFS_IMPORT_DLL

#define FMIFS_IMPORT_DLL

Definition at line 61 of file chkdsk.c.

◆ NTOS_MODE_USER

#define NTOS_MODE_USER

Definition at line 55 of file chkdsk.c.

◆ WIN32_NO_STATUS

#define WIN32_NO_STATUS

Definition at line 45 of file chkdsk.c.

Function Documentation

◆ ChkdskCallback()

BOOLEAN WINAPI ChkdskCallback	(	CALLBACKCOMMAND	Command,
		DWORD	Modifier,
		PVOID	Argument
	)

Definition at line 222 of file chkdsk.c.

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

◆ CtrlCIntercept()

BOOL WINAPI CtrlCIntercept ( DWORD dwCtrlType )

Definition at line 110 of file chkdsk.c.

{
    //
    // Handle the event so that the default handler doesn't
    //
    return TRUE;
}

Referenced by wmain().

◆ ParseCommandLine()

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

static

Definition at line 141 of file chkdsk.c.

{
    int i;
    BOOLEAN gotFix = FALSE;
    BOOLEAN gotVerbose = FALSE;
    BOOLEAN gotClean = FALSE;
    // BOOLEAN gotScan = FALSE;
 
    for (i = 1; i < argc; i++)
    {
        switch (argv[i][0])
        {
            case L'-': case L'/':
 
                switch (argv[i][1])
                {
                    // case L'?':
                        // Usage(argv[0]);
                        // return i;
 
                    case L'F': case L'f':
                    {
                        if (gotFix) return i;
                        FixErrors = TRUE;
                        gotFix = TRUE;
                        break;
                    }
 
                    case L'V': case L'v':
                    {
                        if (gotVerbose) return i;
                        Verbose = TRUE;
                        gotVerbose = TRUE;
                        break;
                    }
 
                    case L'R': case L'r':
                    {
                        if (gotFix) return i;
                        ScanSectors = TRUE;
                        gotFix = TRUE;
                        break;
                    }
 
                    case L'C': case L'c':
                    {
                        if (gotClean) return i;
                        SkipClean = TRUE;
                        gotClean = TRUE;
                        break;
                    }
 
                    default:
                        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	(	int	Message,
		DWORD	ErrorCode
	)

static

Definition at line 91 of file chkdsk.c.

{
    ConResPuts(StdErr, Message);
    ConMsgPuts(StdErr, FORMAT_MESSAGE_FROM_SYSTEM,
               NULL, ErrorCode, LANG_USER_DEFAULT);
    ConPuts(StdErr, L"\n");
}

Referenced by wmain().

◆ Usage()

static VOID Usage ( PWCHAR ProgramName )

static

Definition at line 127 of file chkdsk.c.

{
    ConResPrintf(StdOut, IDS_USAGE, ProgramName);
}

◆ wmain()

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

Definition at line 358 of file chkdsk.c.

{
    int badArg;
    HANDLE volumeHandle;
    WCHAR  fileSystem[1024];
    WCHAR  volumeName[1024];
    DWORD  serialNumber;
    DWORD  flags, maxComponent;
 
    /* Initialize the Console Standard Streams */
    ConInitStdStreams();
 
    ConResPuts(StdOut, IDS_ABOUT);
 
#ifndef FMIFS_IMPORT_DLL
    //
    // Get function pointers
    //
    if (!LoadFMIFSEntryPoints())
    {
        ConResPuts(StdErr, IDS_NO_ENTRY_POINT);
        return -1;
    }
#endif
 
    //
    // Parse command line
    //
    badArg = ParseCommandLine(argc, argv);
    if (badArg)
    {
        ConResPrintf(StdOut, IDS_BAD_ARGUMENT, argv[badArg]);
        Usage(argv[0]);
        return -1;
    }
 
    //
    // Get the drive's format
    //
    if (!Drive)
    {
        if (!GetCurrentDirectoryW(ARRAYSIZE(CurrentDirectory), CurrentDirectory))
        {
            PrintWin32Error(IDS_NO_CURRENT_DIR, GetLastError());
            return -1;
        }
    }
    else
    {
        wcscpy(CurrentDirectory, Drive);
    }
    CurrentDirectory[2] = L'\\';
    CurrentDirectory[3] = L'\0';
    Drive = CurrentDirectory;
 
    //
    // Determine the drive's file system format, which we need to
    // tell chkdsk
    //
    if (!GetVolumeInformationW(Drive,
                               volumeName,
                               ARRAYSIZE(volumeName),
                               &serialNumber,
                               &maxComponent,
                               &flags,
                               fileSystem,
                               ARRAYSIZE(fileSystem)))
    {
        PrintWin32Error(IDS_NO_QUERY_VOL, GetLastError());
        return -1;
    }
 
    //
    // If they want to fix, we need to have access to the drive
    //
    if (FixErrors)
    {
        swprintf(volumeName, L"\\\\.\\%C:", Drive[0]);
        volumeHandle = CreateFileW(volumeName,
                                   GENERIC_WRITE,
                                   0,
                                   NULL,
                                   OPEN_EXISTING,
                                   0,
                                   0);
        if (volumeHandle == INVALID_HANDLE_VALUE)
        {
            ConResPuts(StdErr, IDS_VOLUME_IN_USE_PROC);
            return -1;
        }
        CloseHandle(volumeHandle);
 
        //
        // Can't let the user break out of a chkdsk that can modify the drive
        //
        SetConsoleCtrlHandler(CtrlCIntercept, TRUE);
    }
 
    //
    // Just do it
    //
    ConResPrintf(StdOut, IDS_FILE_SYSTEM, fileSystem);
    Chkdsk(Drive,
           fileSystem,
           FixErrors,
           Verbose,
           SkipClean,
           ScanSectors,
           NULL,
           NULL,
           ChkdskCallback);
 
    if (Error) return -1;
    return 0;
}