diskpart.h File Reference

#include <stdio.h>
#include <stdlib.h>
#include <windef.h>
#include <winbase.h>
#include <winreg.h>
#include <wincon.h>
#include <errno.h>
#include <conutils.h>
#include <ndk/cmfuncs.h>
#include <ndk/exfuncs.h>
#include <ndk/iofuncs.h>
#include <ndk/kefuncs.h>
#include <ndk/mmfuncs.h>
#include <ndk/obfuncs.h>
#include <ndk/psfuncs.h>
#include <ndk/rtlfuncs.h>
#include <ndk/setypes.h>
#include <ndk/umfuncs.h>
#include "resource.h"

Include dependency graph for diskpart.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	_COMMAND
struct	_PARTENTRY
struct	_BIOSDISKENTRY
struct	_DISKENTRY
struct	_VOLENTRY

Macros
#define	WIN32_NO_STATUS
#define	NTOS_MODE_USER
#define	MAX_STRING_SIZE   1024
#define	MAX_ARGS_COUNT   256

Typedefs
typedef struct _COMMAND	COMMAND
typedef struct _COMMAND *	PCOMMAND
typedef enum _FORMATSTATE	FORMATSTATE
typedef enum _FORMATSTATE *	PFORMATSTATE
typedef struct _PARTENTRY	PARTENTRY
typedef struct _PARTENTRY *	PPARTENTRY
typedef struct _BIOSDISKENTRY	BIOSDISKENTRY
typedef struct _BIOSDISKENTRY *	PBIOSDISKENTRY
typedef struct _DISKENTRY	DISKENTRY
typedef struct _DISKENTRY *	PDISKENTRY
typedef struct _VOLENTRY	VOLENTRY
typedef struct _VOLENTRY *	PVOLENTRY

Enumerations
enum	_FORMATSTATE {   Unformatted, UnformattedOrDamaged, UnknownFormat, Preformatted,   Formatted, Unformatted, UnformattedOrDamaged, UnknownFormat,   Preformatted, Formatted }

Functions
BOOL	active_main (INT argc, LPWSTR *argv)
BOOL	add_main (INT argc, LPWSTR *argv)
BOOL	assign_main (INT argc, LPWSTR *argv)
BOOL	attach_main (INT argc, LPWSTR *argv)
BOOL	attributes_main (INT argc, LPWSTR *argv)
BOOL	automount_main (INT argc, LPWSTR *argv)
BOOL	break_main (INT argc, LPWSTR *argv)
BOOL	clean_main (INT argc, LPWSTR *argv)
BOOL	compact_main (INT argc, LPWSTR *argv)
BOOL	convert_main (INT argc, LPWSTR *argv)
BOOL	CreateExtendedPartition (INT argc, PWSTR *argv)
BOOL	CreateLogicalPartition (INT argc, PWSTR *argv)
BOOL	CreatePrimaryPartition (INT argc, PWSTR *argv)
BOOL	delete_main (INT argc, LPWSTR *argv)
BOOL	detach_main (INT argc, LPWSTR *argv)
BOOL	DetailDisk (INT argc, PWSTR *argv)
BOOL	DetailPartition (INT argc, PWSTR *argv)
BOOL	DetailVolume (INT argc, PWSTR *argv)
BOOL	dump_main (INT argc, LPWSTR *argv)
BOOL	expand_main (INT argc, LPWSTR *argv)
BOOL	extend_main (INT argc, LPWSTR *argv)
BOOL	filesystems_main (INT argc, LPWSTR *argv)
BOOL	format_main (INT argc, LPWSTR *argv)
BOOL	gpt_main (INT argc, LPWSTR *argv)
BOOL	help_main (INT argc, LPWSTR *argv)
VOID	HelpCommandList (VOID)
BOOL	HelpCommand (PCOMMAND pCommand)
BOOL	import_main (INT argc, LPWSTR *argv)
BOOL	inactive_main (INT argc, LPWSTR *argv)
BOOL	InterpretScript (LPWSTR line)
BOOL	InterpretCmd (INT argc, LPWSTR *argv)
VOID	InterpretMain (VOID)
BOOL	ListDisk (INT argc, PWSTR *argv)
BOOL	ListPartition (INT argc, PWSTR *argv)
BOOL	ListVolume (INT argc, PWSTR *argv)
BOOL	ListVirtualDisk (INT argc, PWSTR *argv)
BOOL	merge_main (INT argc, LPWSTR *argv)
BOOL	IsDecString (_In_ PWSTR pszDecString)
BOOL	IsHexString (_In_ PWSTR pszHexString)
BOOL	HasPrefix (_In_ PWSTR pszString, _In_ PWSTR pszPrefix, _Out_opt_ PWSTR *pszSuffix)
ULONGLONG	RoundingDivide (_In_ ULONGLONG Dividend, _In_ ULONGLONG Divisor)
BOOL	offline_main (INT argc, LPWSTR *argv)
BOOL	online_main (INT argc, LPWSTR *argv)
NTSTATUS	CreatePartitionList (VOID)
VOID	DestroyPartitionList (VOID)
NTSTATUS	CreateVolumeList (VOID)
VOID	DestroyVolumeList (VOID)
BOOL	recover_main (INT argc, LPWSTR *argv)
BOOL	remove_main (INT argc, LPWSTR *argv)
BOOL	repair_main (INT argc, LPWSTR *argv)
BOOL	rescan_main (INT argc, LPWSTR *argv)
BOOL	retain_main (INT argc, LPWSTR *argv)
BOOL	san_main (INT argc, LPWSTR *argv)
BOOL	SelectDisk (INT argc, PWSTR *argv)
BOOL	SelectPartition (INT argc, PWSTR *argv)
BOOL	SelectVolume (INT argc, PWSTR *argv)
BOOL	setid_main (INT argc, LPWSTR *argv)
BOOL	shrink_main (INT argc, LPWSTR *argv)
BOOL	UniqueIdDisk (_In_ INT argc, _In_ PWSTR *argv)

Variables
COMMAND	cmds []
LIST_ENTRY	DiskListHead
LIST_ENTRY	BiosDiskListHead
LIST_ENTRY	VolumeListHead
PDISKENTRY	CurrentDisk
PPARTENTRY	CurrentPartition
PVOLENTRY	CurrentVolume

Macro Definition Documentation

MAX_ARGS_COUNT

#define MAX_ARGS_COUNT   256

Definition at line 74 of file diskpart.h.

MAX_STRING_SIZE

#define MAX_STRING_SIZE   1024

Definition at line 73 of file diskpart.h.

NTOS_MODE_USER

#define NTOS_MODE_USER

Definition at line 37 of file diskpart.h.

WIN32_NO_STATUS

#define WIN32_NO_STATUS

Definition at line 17 of file diskpart.h.

Typedef Documentation

BIOSDISKENTRY

typedef struct _BIOSDISKENTRY BIOSDISKENTRY

COMMAND

typedef struct _COMMAND COMMAND

DISKENTRY

typedef struct _DISKENTRY DISKENTRY

FORMATSTATE

typedef enum _FORMATSTATE FORMATSTATE

PARTENTRY

typedef struct _PARTENTRY PARTENTRY

PBIOSDISKENTRY

typedef struct _BIOSDISKENTRY * PBIOSDISKENTRY

PCOMMAND

typedef struct _COMMAND * PCOMMAND

PDISKENTRY

typedef struct _DISKENTRY * PDISKENTRY

PFORMATSTATE

typedef enum _FORMATSTATE * PFORMATSTATE

PPARTENTRY

typedef struct _PARTENTRY * PPARTENTRY

PVOLENTRY

typedef struct _VOLENTRY * PVOLENTRY

VOLENTRY

typedef struct _VOLENTRY VOLENTRY

Enumeration Type Documentation

_FORMATSTATE

enum _FORMATSTATE

Enumerator
Unformatted
UnformattedOrDamaged
UnknownFormat
Preformatted
Formatted
Unformatted
UnformattedOrDamaged
UnknownFormat
Preformatted
Formatted

Definition at line 77 of file diskpart.h.

{
    Unformatted,
    UnformattedOrDamaged,
    UnknownFormat,
    Preformatted,
    Formatted
} FORMATSTATE, *PFORMATSTATE;

Function Documentation

active_main()

BOOL active_main	(	INT	argc,
		LPWSTR *	argv
	)

Definition at line 11 of file active.c.

{
    ConPuts(StdOut, L"\nActive\n");
    return TRUE;
}

add_main()

BOOL add_main	(	INT	argc,
		LPWSTR *	argv
	)

Definition at line 11 of file add.c.

{
    return TRUE;
}

assign_main()

BOOL assign_main	(	INT	argc,
		LPWSTR *	argv
	)

Definition at line 11 of file assign.c.

{
    return TRUE;
}

attach_main()

BOOL attach_main	(	INT	argc,
		LPWSTR *	argv
	)

Definition at line 11 of file attach.c.

{
    return TRUE;
}

attributes_main()

BOOL attributes_main	(	INT	argc,
		LPWSTR *	argv
	)

Definition at line 11 of file attributes.c.

{
    return TRUE;
}

automount_main()

BOOL automount_main	(	INT	argc,
		LPWSTR *	argv
	)

Definition at line 11 of file automount.c.

{
    ConPuts(StdOut, L"Automount\n");
    return TRUE;
}

break_main()

BOOL break_main	(	INT	argc,
		LPWSTR *	argv
	)

Definition at line 11 of file break.c.

{
    ConPuts(StdOut, L"\nTODO: Add code later since Win 7 Home Premium doesn't have this feature.\n");
    return TRUE;
}

clean_main()

BOOL clean_main	(	INT	argc,
		LPWSTR *	argv
	)

Definition at line 11 of file clean.c.

{
    return TRUE;
}

compact_main()

BOOL compact_main	(	INT	argc,
		LPWSTR *	argv
	)

Definition at line 11 of file compact.c.

{
    return 0;
}

convert_main()

BOOL convert_main	(	INT	argc,
		LPWSTR *	argv
	)

Definition at line 11 of file convert.c.

{
    return TRUE;
}

CreateExtendedPartition()

BOOL CreateExtendedPartition	(	INT	argc,
		PWSTR *	argv
	)

Definition at line 12 of file create.c.

{
    if (CurrentDisk == NULL)
    {
        ConResPuts(StdOut, IDS_SELECT_NO_DISK);
        return TRUE;
    }

    ConPrintf(StdOut, L"Not implemented yet!\n");

    return TRUE;
}

CreateLogicalPartition()

BOOL CreateLogicalPartition	(	INT	argc,
		PWSTR *	argv
	)

Definition at line 29 of file create.c.

{
    if (CurrentDisk == NULL)
    {
        ConResPuts(StdOut, IDS_SELECT_NO_DISK);
        return TRUE;
    }

    ConPrintf(StdOut, L"Not implemented yet!\n");

    return TRUE;
}

CreatePartitionList()

NTSTATUS CreatePartitionList

(

VOID

)

Definition at line 1847 of file partlist.c.

{
    PPARTLIST List;
    PDISKENTRY SystemDisk;
    OBJECT_ATTRIBUTES ObjectAttributes;
    SYSTEM_DEVICE_INFORMATION Sdi;
    IO_STATUS_BLOCK Iosb;
    ULONG ReturnSize;
    NTSTATUS Status;
    ULONG DiskNumber;
    HANDLE FileHandle;
    UNICODE_STRING Name;
    WCHAR Buffer[MAX_PATH];

    List = (PPARTLIST)RtlAllocateHeap(ProcessHeap,
                                      0,
                                      sizeof(PARTLIST));
    if (List == NULL)
        return NULL;

    List->SystemPartition = NULL;

    InitializeListHead(&List->DiskListHead);
    InitializeListHead(&List->BiosDiskListHead);

    /*
     * Enumerate the disks seen by the BIOS; this will be used later
     * to map drives seen by NTOS with their corresponding BIOS names.
     */
    EnumerateBiosDiskEntries(List);

    /* Enumerate disks seen by NTOS */
    Status = NtQuerySystemInformation(SystemDeviceInformation,
                                      &Sdi,
                                      sizeof(Sdi),
                                      &ReturnSize);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("NtQuerySystemInformation() failed, Status 0x%08lx", Status);
        RtlFreeHeap(ProcessHeap, 0, List);
        return NULL;
    }

    for (DiskNumber = 0; DiskNumber < Sdi.NumberOfDisks; DiskNumber++)
    {
        RtlStringCchPrintfW(Buffer, ARRAYSIZE(Buffer),
                            L"\\Device\\Harddisk%lu\\Partition0",
                            DiskNumber);
        RtlInitUnicodeString(&Name, Buffer);

        InitializeObjectAttributes(&ObjectAttributes,
                                   &Name,
                                   OBJ_CASE_INSENSITIVE,
                                   NULL,
                                   NULL);

        Status = NtOpenFile(&FileHandle,
                            FILE_READ_DATA | FILE_READ_ATTRIBUTES | SYNCHRONIZE,
                            &ObjectAttributes,
                            &Iosb,
                            FILE_SHARE_READ | FILE_SHARE_WRITE,
                            FILE_SYNCHRONOUS_IO_NONALERT);
        if (NT_SUCCESS(Status))
        {
            AddDiskToList(FileHandle, DiskNumber, List);
            NtClose(FileHandle);
        }
    }

    UpdateDiskSignatures(List);
    UpdateHwDiskNumbers(List);
    AssignDriveLetters(List);

    /*
     * Retrieve the system partition: the active partition on the system
     * disk (the one that will be booted by default by the hardware).
     */
    SystemDisk = GetSystemDisk(List);
    List->SystemPartition = (SystemDisk ? GetActiveDiskPartition(SystemDisk) : NULL);

    return List;
}

Referenced by LoadSetupData(), rescan_main(), SelectPartitionPage(), UpgradeRepairPage(), and wmain().

CreatePrimaryPartition()

BOOL CreatePrimaryPartition	(	INT	argc,
		PWSTR *	argv
	)

Definition at line 46 of file create.c.

{
    LARGE_INTEGER liSize, liOffset;
    INT i;
//    BOOL bNoErr = FALSE;
    PWSTR pszSuffix = NULL;

    liSize.QuadPart = -1;
    liOffset.QuadPart = -1;

/*
    if (CurrentDisk == NULL)
    {
        ConResPuts(StdOut, IDS_SELECT_NO_DISK);
        return TRUE;
    }
*/

    for (i = 3; i < argc; i++)
    {
        if (HasPrefix(argv[i], L"size=", &pszSuffix))
        {
            /* size=<N> (MB) */
            ConPrintf(StdOut, L"Size : %s\n", pszSuffix);

            liSize.QuadPart = _wcstoui64(pszSuffix, NULL, 10);
            if (((liSize.QuadPart == 0) && (errno == ERANGE)) ||
                (liSize.QuadPart < 0))
            {
                ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
                return TRUE;
            }
        }
        else if (HasPrefix(argv[i], L"offset=", &pszSuffix))
        {
            /* offset=<N> (KB) */
            ConPrintf(StdOut, L"Offset : %s\n", pszSuffix);

            liOffset.QuadPart = _wcstoui64(pszSuffix, NULL, 10);
            if (((liOffset.QuadPart == 0) && (errno == ERANGE)) ||
                (liOffset.QuadPart < 0))
            {
                ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
                return TRUE;
            }
        }
        else if (HasPrefix(argv[i], L"id=", &pszSuffix))
        {
            /* id=<Byte>|<GUID> */
            ConPrintf(StdOut, L"Id : %s\n", pszSuffix);
        }
        else if (HasPrefix(argv[i], L"align=", &pszSuffix))
        {
            /* align=<N> */
            ConPrintf(StdOut, L"Align : %s\n", pszSuffix);
        }
        else if (_wcsicmp(argv[i], L"noerr") == 0)
        {
            /* noerr */
            ConPrintf(StdOut, L"NoErr\n", pszSuffix);
//            bNoErr = TRUE;
        }
        else
        {
            ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
            return TRUE;
        }
    }

    ConPrintf(StdOut, L"Size: %I64d\n", liSize.QuadPart);
    ConPrintf(StdOut, L"Offset: %I64d\n", liOffset.QuadPart);

    return TRUE;
}

CreateVolumeList()

NTSTATUS CreateVolumeList

(

VOID

)

Definition at line 1250 of file partlist.c.

{
    HANDLE hVolume = INVALID_HANDLE_VALUE;
    WCHAR szVolumeName[MAX_PATH];
    ULONG ulVolumeNumber = 0;
    BOOL Success;

    CurrentVolume = NULL;

    InitializeListHead(&VolumeListHead);

    hVolume = FindFirstVolumeW(szVolumeName, ARRAYSIZE(szVolumeName));
    if (hVolume == INVALID_HANDLE_VALUE)
    {

        return STATUS_UNSUCCESSFUL;
    }

    AddVolumeToList(ulVolumeNumber++, szVolumeName);

    for (;;)
    {
        Success = FindNextVolumeW(hVolume, szVolumeName, ARRAYSIZE(szVolumeName));
        if (!Success)
        {
            break;
        }

        AddVolumeToList(ulVolumeNumber++, szVolumeName);
    }

    FindVolumeClose(hVolume);

    return STATUS_SUCCESS;
}

Referenced by rescan_main(), and wmain().

delete_main()

BOOL delete_main	(	INT	argc,
		LPWSTR *	argv
	)

Definition at line 11 of file delete.c.

{
    return TRUE;
}

DestroyPartitionList()

VOID DestroyPartitionList

(

VOID

)

Definition at line 1123 of file partlist.c.

{
    PDISKENTRY DiskEntry;
    PBIOSDISKENTRY BiosDiskEntry;
    PPARTENTRY PartEntry;
    PLIST_ENTRY Entry;

    CurrentDisk = NULL;
    CurrentPartition = NULL;

    /* Release disk and partition info */
    while (!IsListEmpty(&DiskListHead))
    {
        Entry = RemoveHeadList(&DiskListHead);
        DiskEntry = CONTAINING_RECORD(Entry, DISKENTRY, ListEntry);

        /* Release driver name */
        RtlFreeUnicodeString(&DiskEntry->DriverName);

        /* Release primary partition list */
        while (!IsListEmpty(&DiskEntry->PrimaryPartListHead))
        {
            Entry = RemoveHeadList(&DiskEntry->PrimaryPartListHead);
            PartEntry = CONTAINING_RECORD(Entry, PARTENTRY, ListEntry);

            RtlFreeHeap(RtlGetProcessHeap(), 0, PartEntry);
        }

        /* Release logical partition list */
        while (!IsListEmpty(&DiskEntry->LogicalPartListHead))
        {
            Entry = RemoveHeadList(&DiskEntry->LogicalPartListHead);
            PartEntry = CONTAINING_RECORD(Entry, PARTENTRY, ListEntry);

            RtlFreeHeap(RtlGetProcessHeap(), 0, PartEntry);
        }

        /* Release layout buffer */
        if (DiskEntry->LayoutBuffer != NULL)
            RtlFreeHeap(RtlGetProcessHeap(), 0, DiskEntry->LayoutBuffer);


        /* Release disk entry */
        RtlFreeHeap(RtlGetProcessHeap(), 0, DiskEntry);
    }

    /* Release the bios disk info */
    while (!IsListEmpty(&BiosDiskListHead))
    {
        Entry = RemoveHeadList(&BiosDiskListHead);
        BiosDiskEntry = CONTAINING_RECORD(Entry, BIOSDISKENTRY, ListEntry);

        RtlFreeHeap(RtlGetProcessHeap(), 0, BiosDiskEntry);
    }
}

DestroyVolumeList()

VOID DestroyVolumeList

(

VOID

)

Definition at line 1288 of file partlist.c.

{
    PLIST_ENTRY Entry;
    PVOLENTRY VolumeEntry;

    CurrentVolume = NULL;

    /* Release disk and partition info */
    while (!IsListEmpty(&VolumeListHead))
    {
        Entry = RemoveHeadList(&VolumeListHead);
        VolumeEntry = CONTAINING_RECORD(Entry, VOLENTRY, ListEntry);

        if (VolumeEntry->pszLabel)
            RtlFreeHeap(RtlGetProcessHeap(), 0, VolumeEntry->pszLabel);

        if (VolumeEntry->pszFilesystem)
            RtlFreeHeap(RtlGetProcessHeap(), 0, VolumeEntry->pszFilesystem);

        /* Release disk entry */
        RtlFreeHeap(RtlGetProcessHeap(), 0, VolumeEntry);
    }
}

Referenced by rescan_main(), and wmain().

detach_main()

BOOL detach_main	(	INT	argc,
		LPWSTR *	argv
	)

Definition at line 11 of file detach.c.

{
    return TRUE;
}

DetailDisk()

BOOL DetailDisk	(	INT	argc,
		PWSTR *	argv
	)

Definition at line 17 of file detail.c.

{
    DPRINT("DetailDisk()\n");

    if (argc > 2)
    {
        ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
        return TRUE;
    }

    if (CurrentDisk == NULL)
    {
        ConResPuts(StdOut, IDS_SELECT_NO_DISK);
        return TRUE;
    }

    /* TODO: Print more disk details */
    ConPuts(StdOut, L"\n");
    ConResPrintf(StdOut, IDS_DETAIL_INFO_DISK_ID, CurrentDisk->LayoutBuffer->Signature);
    ConResPrintf(StdOut, IDS_DETAIL_INFO_PATH, CurrentDisk->PathId);
    ConResPrintf(StdOut, IDS_DETAIL_INFO_TARGET, CurrentDisk->TargetId);
    ConResPrintf(StdOut, IDS_DETAIL_INFO_LUN_ID, CurrentDisk->Lun);
    ConPuts(StdOut, L"\n");

    return TRUE;
}

DetailPartition()

BOOL DetailPartition	(	INT	argc,
		PWSTR *	argv
	)

Definition at line 48 of file detail.c.

{
    PPARTENTRY PartEntry;
    ULONGLONG PartOffset;

    DPRINT("DetailPartition()\n");

    if (argc > 2)
    {
        ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
        return TRUE;
    }

    if (CurrentDisk == NULL)
    {
        ConResPuts(StdOut, IDS_SELECT_PARTITION_NO_DISK);
        return TRUE;
    }

    if (CurrentPartition == NULL)
    {
        ConResPuts(StdOut, IDS_SELECT_NO_PARTITION);
        return TRUE;
    }

    PartEntry = CurrentPartition;
    PartOffset = PartEntry->StartSector.QuadPart * CurrentDisk->BytesPerSector;

    /* TODO: Print more partition details */
    ConPuts(StdOut, L"\n");
    ConResPrintf(StdOut, IDS_DETAIL_PARTITION_NUMBER, PartEntry->PartitionNumber);
    ConResPrintf(StdOut, IDS_DETAIL_PARTITION_TYPE, PartEntry->PartitionType);
    ConResPrintf(StdOut, IDS_DETAIL_PARTITION_HIDDEN, "");
    ConResPrintf(StdOut, IDS_DETAIL_PARTITION_ACTIVE, PartEntry->BootIndicator ? L"Yes" : L"No");
    ConResPrintf(StdOut, IDS_DETAIL_PARTITION_OFFSET, PartOffset);
    ConPuts(StdOut, L"\n");

    return TRUE;
}

DetailVolume()

BOOL DetailVolume	(	INT	argc,
		PWSTR *	argv
	)

Definition at line 92 of file detail.c.

{
    DPRINT("DetailVolume()\n");

    if (argc > 2)
    {
        ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
        return TRUE;
    }

    if (CurrentVolume == NULL)
    {
        ConResPuts(StdOut, IDS_SELECT_NO_VOLUME);
        return TRUE;
    }

    /* TODO: Print volume details */

    return TRUE;
}

dump_main()

BOOL dump_main	(	INT	argc,
		LPWSTR *	argv
	)

expand_main()

BOOL expand_main	(	INT	argc,
		LPWSTR *	argv
	)

Definition at line 11 of file expand.c.

{
    return TRUE;
}

extend_main()

BOOL extend_main	(	INT	argc,
		LPWSTR *	argv
	)

Definition at line 11 of file extend.c.

{
    return TRUE;
}

filesystems_main()

BOOL filesystems_main	(	INT	argc,
		LPWSTR *	argv
	)

Definition at line 11 of file filesystems.c.

{
    return TRUE;
}

format_main()

BOOL format_main	(	INT	argc,
		LPWSTR *	argv
	)

Definition at line 11 of file format.c.

{
    return TRUE;
}

gpt_main()

BOOL gpt_main	(	INT	argc,
		LPWSTR *	argv
	)

Definition at line 11 of file gpt.c.

{
    return TRUE;
}

HasPrefix()

BOOL HasPrefix	(	_In_ PWSTR	pszString,
		_In_ PWSTR	pszPrefix,
		_Out_opt_ PWSTR *	pszSuffix
	)

Definition at line 58 of file misc.c.

{
    INT nPrefixLength, ret;

    nPrefixLength = wcslen(pszPrefix);
    ret = _wcsnicmp(pszString, pszPrefix, nPrefixLength);
    if ((ret == 0) && (ppszSuffix != NULL))
        *ppszSuffix = &pszString[nPrefixLength];

    return (ret == 0);
}

Referenced by AcpiExGetNameString(), CreatePrimaryPartition(), and UniqueIdDisk().

help_main()

BOOL help_main	(	INT	argc,
		LPWSTR *	argv
	)

Definition at line 102 of file help.c.

{
    PCOMMAND cmdptr;
    PCOMMAND cmdptr1 = NULL;
    PCOMMAND cmdptr2 = NULL;
    PCOMMAND cmdptr3 = NULL;

    if (argc == 1)
    {
        HelpCommandList();
        return TRUE;
    }

    /* Scan internal command table */
    for (cmdptr = cmds; cmdptr->cmd1; cmdptr++)
    {
        if ((cmdptr1 == NULL) &&
            (wcsicmp(argv[1], cmdptr->cmd1) == 0))
            cmdptr1 = cmdptr;

        if ((cmdptr2 == NULL) &&
            (argc >= 3) &&
            (wcsicmp(argv[1], cmdptr->cmd1) == 0) &&
            (wcsicmp(argv[2], cmdptr->cmd2) == 0))
            cmdptr2 = cmdptr;

        if ((cmdptr3 == NULL) &&
            (argc >= 4) &&
            (wcsicmp(argv[1], cmdptr->cmd1) == 0) &&
            (wcsicmp(argv[2], cmdptr->cmd2) == 0) &&
            (wcsicmp(argv[3], cmdptr->cmd3) == 0))
            cmdptr3 = cmdptr;
    }

    if (cmdptr3 != NULL)
    {
        return HelpCommand(cmdptr3);
    }
    else if (cmdptr2 != NULL)
    {
        return HelpCommand(cmdptr2);
    }
    else if (cmdptr1 != NULL)
    {
        return HelpCommand(cmdptr1);
    }

    HelpCommandList();

    return TRUE;
}

HelpCommand()

BOOL HelpCommand

(

PCOMMAND

pCommand

)

Definition at line 43 of file help.c.

{
    PCOMMAND cmdptr;
    BOOL bSubCommands = FALSE;
    WCHAR szFormat[64];
    WCHAR szOutput[256];

    K32LoadStringW(GetModuleHandle(NULL), IDS_HELP_FORMAT_STRING, szFormat, ARRAYSIZE(szFormat));

    ConPuts(StdOut, L"\n");

    /* List all the commands and the basic descriptions */
    for (cmdptr = cmds; cmdptr->cmd1; cmdptr++)
    {
        if (pCommand->cmd1 != NULL && pCommand->cmd2 == NULL && pCommand->cmd3 == NULL)
        {
            if (wcsicmp(pCommand->cmd1, cmdptr->cmd1) == 0 && cmdptr->cmd2 != NULL && cmdptr->cmd3 == NULL)
            {
                K32LoadStringW(GetModuleHandle(NULL), cmdptr->help, szOutput, ARRAYSIZE(szOutput));
                ConPrintf(StdOut, szFormat, cmdptr->cmd2, szOutput);
                bSubCommands = TRUE;
            }
        }
        else if (pCommand->cmd1 != NULL && pCommand->cmd2 != NULL && pCommand->cmd3 == NULL)
        {
            if ((wcsicmp(pCommand->cmd1, cmdptr->cmd1) == 0) &&
                (wcsicmp(pCommand->cmd2, cmdptr->cmd2) == 0) &&
                (cmdptr->cmd3 != NULL))
            {
                K32LoadStringW(GetModuleHandle(NULL), cmdptr->help, szOutput, ARRAYSIZE(szOutput));
                ConPrintf(StdOut, szFormat, cmdptr->cmd3, szOutput);
                bSubCommands = TRUE;
            }
        }
        else if (pCommand->cmd1 != NULL && pCommand->cmd2 != NULL && pCommand->cmd3 != NULL)
        {
            if ((wcsicmp(pCommand->cmd1, cmdptr->cmd1) == 0) &&
                (wcsicmp(pCommand->cmd2, cmdptr->cmd2) == 0) &&
                (wcsicmp(pCommand->cmd3, cmdptr->cmd3) == 0) &&
                (cmdptr->help_detail != IDS_NONE))
                ConResPuts(StdOut, cmdptr->help_detail);
        }
    }

    if ((bSubCommands == FALSE) && (pCommand->help_detail != IDS_NONE))
    {
        ConResPuts(StdOut, pCommand->help_detail);
    }

    ConPuts(StdOut, L"\n");

    return TRUE;
}

Referenced by help_main(), InterpretCmd(), and main().

HelpCommandList()

VOID HelpCommandList

(

VOID

)

Definition at line 16 of file help.c.

{
    PCOMMAND cmdptr;
    WCHAR szFormat[64];
    WCHAR szOutput[256];

    K32LoadStringW(GetModuleHandle(NULL), IDS_HELP_FORMAT_STRING, szFormat, ARRAYSIZE(szFormat));

    /* Print the header information */
    ConResPuts(StdOut, IDS_APP_HEADER);
    ConPuts(StdOut, L"\n");

    /* List all the commands and the basic descriptions */
    for (cmdptr = cmds; cmdptr->cmd1; cmdptr++)
    {
        if (cmdptr->cmd1 != NULL && cmdptr->cmd2 == NULL && cmdptr->cmd3 == NULL)
        {
            K32LoadStringW(GetModuleHandle(NULL), cmdptr->help, szOutput, ARRAYSIZE(szOutput));
            ConPrintf(StdOut, szFormat, cmdptr->cmd1, szOutput);
        }
    }

    ConPuts(StdOut, L"\n");
}

Referenced by help_main(), and InterpretCmd().

import_main()

BOOL import_main	(	INT	argc,
		LPWSTR *	argv
	)

Definition at line 11 of file import.c.

{
    return TRUE;
}

inactive_main()

BOOL inactive_main	(	INT	argc,
		LPWSTR *	argv
	)

Definition at line 11 of file inactive.c.

{
    return TRUE;
}

InterpretCmd()

BOOL InterpretCmd	(	INT	argc,
		LPWSTR *	argv
	)

InterpretMain()

VOID InterpretMain

(

VOID

)

Definition at line 218 of file interpreter.c.

{
    WCHAR input_line[MAX_STRING_SIZE];
    LPWSTR args_vector[MAX_ARGS_COUNT];
    INT args_count = 0;
    BOOL bWhiteSpace = TRUE;
    BOOL bRun = TRUE;
    LPWSTR ptr;

    while (bRun != FALSE)
    {
        args_count = 0;
        memset(args_vector, 0, sizeof(args_vector));

        /* Shown just before the input where the user places commands */
        ConResPuts(StdOut, IDS_APP_PROMPT);

        /* Get input from the user. */
        fgetws(input_line, MAX_STRING_SIZE, stdin);

        ptr = input_line;
        while (*ptr != 0)
        {
            if (iswspace(*ptr) || *ptr == L'\n')
            {
                *ptr = 0;
                bWhiteSpace = TRUE;
            }
            else
            {
                if ((bWhiteSpace != FALSE) && (args_count < MAX_ARGS_COUNT))
                {
                    args_vector[args_count] = ptr;
                    args_count++;
                }
                bWhiteSpace = FALSE;
            }
            ptr++;
        }

        /* Send the string to find the command */
        bRun = InterpretCmd(args_count, args_vector);
    }
}

Referenced by wmain().

InterpretScript()

BOOL InterpretScript

(

LPWSTR

line

)

Definition at line 175 of file interpreter.c.

{
    LPWSTR args_vector[MAX_ARGS_COUNT];
    INT args_count = 0;
    BOOL bWhiteSpace = TRUE;
    LPWSTR ptr;

    memset(args_vector, 0, sizeof(args_vector));

    ptr = input_line;
    while (*ptr != 0)
    {
        if (iswspace(*ptr) || *ptr == L'\n')
        {
            *ptr = 0;
            bWhiteSpace = TRUE;
        }
        else
        {
            if ((bWhiteSpace != FALSE) && (args_count < MAX_ARGS_COUNT))
            {
                args_vector[args_count] = ptr;
                args_count++;
            }

            bWhiteSpace = FALSE;
        }

        ptr++;
    }

    /* sends the string to find the command */
    return InterpretCmd(args_count, args_vector);
}

Referenced by RunScript().

IsDecString()

BOOL IsDecString

(

_In_ PWSTR

pszDecString

)

Definition at line 14 of file misc.c.

{
    PWSTR ptr;

    if ((pszDecString == NULL) || (*pszDecString == UNICODE_NULL))
        return FALSE;

    ptr = pszDecString;
    while (*ptr != UNICODE_NULL)
    {
        if (!iswdigit(*ptr))
            return FALSE;

        ptr++;
    }

    return TRUE;
}

Referenced by SelectDisk(), SelectPartition(), and SelectVolume().

IsHexString()

BOOL IsHexString

(

_In_ PWSTR

pszHexString

)

Definition at line 36 of file misc.c.

{
    PWSTR ptr;

    if ((pszHexString == NULL) || (*pszHexString == UNICODE_NULL))
        return FALSE;

    ptr = pszHexString;
    while (*ptr != UNICODE_NULL)
    {
        if (!iswxdigit(*ptr))
            return FALSE;

        ptr++;
    }

    return TRUE;
}

Referenced by UniqueIdDisk().

ListDisk()

BOOL ListDisk	(	INT	argc,
		PWSTR *	argv
	)

Definition at line 17 of file list.c.

{
    PLIST_ENTRY Entry;
    PDISKENTRY DiskEntry;
    ULONGLONG DiskSize;
    ULONGLONG FreeSize;
    LPWSTR lpSizeUnit;
    LPWSTR lpFreeUnit;

    /* Header labels */
    ConResPuts(StdOut, IDS_LIST_DISK_HEAD);
    ConResPuts(StdOut, IDS_LIST_DISK_LINE);

    Entry = DiskListHead.Flink;
    while (Entry != &DiskListHead)
    {
        DiskEntry = CONTAINING_RECORD(Entry, DISKENTRY, ListEntry);

        DiskSize = DiskEntry->SectorCount.QuadPart *
                   (ULONGLONG)DiskEntry->BytesPerSector;

        if (DiskSize >= 10737418240) /* 10 GB */
        {
             DiskSize = RoundingDivide(DiskSize, 1073741824);
             lpSizeUnit = L"GB";
        }
        else
        {
             DiskSize = RoundingDivide(DiskSize, 1048576);
             if (DiskSize == 0)
                 DiskSize = 1;
             lpSizeUnit = L"MB";
        }

        /* FIXME */
        FreeSize = 0;
        lpFreeUnit = L"B";

        ConResPrintf(StdOut, IDS_LIST_DISK_FORMAT,
                     (CurrentDisk == DiskEntry) ? L'*': ' ',
                     DiskEntry->DiskNumber,
                     L"Online",
                     DiskSize,
                     lpSizeUnit,
                     FreeSize,
                     lpFreeUnit,
                     L" ",
                     L" ");

        Entry = Entry->Flink;
    }

    ConPuts(StdOut, L"\n\n");

    return TRUE;
}

ListPartition()

BOOL ListPartition	(	INT	argc,
		PWSTR *	argv
	)

Definition at line 78 of file list.c.

{
    PLIST_ENTRY Entry;
    PPARTENTRY PartEntry;
    ULONGLONG PartSize;
    ULONGLONG PartOffset;
    LPWSTR lpSizeUnit;
    LPWSTR lpOffsetUnit;
    ULONG PartNumber = 1;

    if (CurrentDisk == NULL)
    {
        ConResPuts(StdOut, IDS_LIST_PARTITION_NO_DISK);
        return TRUE;
    }

    /* Header labels */
    ConResPuts(StdOut, IDS_LIST_PARTITION_HEAD);
    ConResPuts(StdOut, IDS_LIST_PARTITION_LINE);

    Entry = CurrentDisk->PrimaryPartListHead.Flink;
    while (Entry != &CurrentDisk->PrimaryPartListHead)
    {
        PartEntry = CONTAINING_RECORD(Entry, PARTENTRY, ListEntry);

        if (PartEntry->PartitionType != 0)
        {
            PartSize = PartEntry->SectorCount.QuadPart * CurrentDisk->BytesPerSector;

            if (PartSize >= 10737418240) /* 10 GB */
            {
                PartSize = RoundingDivide(PartSize, 1073741824);
                lpSizeUnit = L"GB";
            }
            else if (PartSize >= 10485760) /* 10 MB */
            {
                PartSize = RoundingDivide(PartSize, 1048576);
                lpSizeUnit = L"MB";
            }
            else
            {
                PartSize = RoundingDivide(PartSize, 1024);
                lpSizeUnit = L"KB";
            }

            PartOffset = PartEntry->StartSector.QuadPart * CurrentDisk->BytesPerSector;

            if (PartOffset >= 10737418240) /* 10 GB */
            {
                PartOffset = RoundingDivide(PartOffset, 1073741824);
                lpOffsetUnit = L"GB";
            }
            else if (PartOffset >= 10485760) /* 10 MB */
            {
                PartOffset = RoundingDivide(PartOffset, 1048576);
                lpOffsetUnit = L"MB";
            }
            else
            {
                PartOffset = RoundingDivide(PartOffset, 1024);
                lpOffsetUnit = L"KB";
            }

            ConResPrintf(StdOut, IDS_LIST_PARTITION_FORMAT,
                         (CurrentPartition == PartEntry) ? L'*': ' ',
                         PartNumber++,
                         IsContainerPartition(PartEntry->PartitionType) ? L"Extended" : L"Primary",
                         PartSize,
                         lpSizeUnit,
                         PartOffset,
                         lpOffsetUnit);
        }

        Entry = Entry->Flink;
    }

    Entry = CurrentDisk->LogicalPartListHead.Flink;
    while (Entry != &CurrentDisk->LogicalPartListHead)
    {
        PartEntry = CONTAINING_RECORD(Entry, PARTENTRY, ListEntry);

        if (PartEntry->PartitionType != 0)
        {
            PartSize = PartEntry->SectorCount.QuadPart * CurrentDisk->BytesPerSector;

            if (PartSize >= 10737418240) /* 10 GB */
            {
                PartSize = RoundingDivide(PartSize, 1073741824);
                lpSizeUnit = L"GB";
            }
            else if (PartSize >= 10485760) /* 10 MB */
            {
                PartSize = RoundingDivide(PartSize, 1048576);
                lpSizeUnit = L"MB";
            }
            else
            {
                PartSize = RoundingDivide(PartSize, 1024);
                lpSizeUnit = L"KB";
            }

            PartOffset = PartEntry->StartSector.QuadPart * CurrentDisk->BytesPerSector;

            if (PartOffset >= 10737418240) /* 10 GB */
            {
                PartOffset = RoundingDivide(PartOffset, 1073741824);
                lpOffsetUnit = L"GB";
            }
            else if (PartOffset >= 10485760) /* 10 MB */
            {
                PartOffset = RoundingDivide(PartOffset, 1048576);
                lpOffsetUnit = L"MB";
            }
            else
            {
                PartOffset = RoundingDivide(PartOffset, 1024);
                lpOffsetUnit = L"KB";
            }

            ConResPrintf(StdOut, IDS_LIST_PARTITION_FORMAT,
                         (CurrentPartition == PartEntry) ? L'*': ' ',
                         PartNumber++,
                         L"Logical",
                         PartSize,
                         lpSizeUnit,
                         PartOffset,
                         lpOffsetUnit);
        }

        Entry = Entry->Flink;
    }

    ConPuts(StdOut, L"\n");

    return TRUE;
}

ListVirtualDisk()

BOOL ListVirtualDisk	(	INT	argc,
		PWSTR *	argv
	)

Definition at line 271 of file list.c.

{
    ConPuts(StdOut, L"ListVirtualDisk()!\n");
    return TRUE;
}

ListVolume()

BOOL ListVolume	(	INT	argc,
		PWSTR *	argv
	)

Definition at line 219 of file list.c.

{
    PLIST_ENTRY Entry;
    PVOLENTRY VolumeEntry;
    ULONGLONG VolumeSize;
    LPWSTR lpSizeUnit;

    ConResPuts(StdOut, IDS_LIST_VOLUME_HEAD);
    ConResPuts(StdOut, IDS_LIST_VOLUME_LINE);

    Entry = VolumeListHead.Flink;
    while (Entry != &VolumeListHead)
    {
        VolumeEntry = CONTAINING_RECORD(Entry, VOLENTRY, ListEntry);

        VolumeSize = VolumeEntry->Size.QuadPart;
        if (VolumeSize >= 10737418240) /* 10 GB */
        {
            VolumeSize = RoundingDivide(VolumeSize, 1073741824);
            lpSizeUnit = L"GB";
        }
        else if (VolumeSize >= 10485760) /* 10 MB */
        {
            VolumeSize = RoundingDivide(VolumeSize, 1048576);
            lpSizeUnit = L"MB";
        }
        else
        {
            VolumeSize = RoundingDivide(VolumeSize, 1024);
            lpSizeUnit = L"KB";
        }

        ConResPrintf(StdOut, IDS_LIST_VOLUME_FORMAT,
                     VolumeEntry->VolumeNumber,
                     VolumeEntry->DriveLetter,
                     (VolumeEntry->pszLabel) ? VolumeEntry->pszLabel : L"",
                     (VolumeEntry->pszFilesystem) ? VolumeEntry->pszFilesystem : L"",
                     VolumeEntry->DriveType,
                     VolumeSize, lpSizeUnit);

        Entry = Entry->Flink;
    }

    ConPuts(StdOut, L"\n\n");

    return TRUE;
}

merge_main()

BOOL merge_main	(	INT	argc,
		LPWSTR *	argv
	)

Definition at line 11 of file merge.c.

{
    return TRUE;
}

offline_main()

BOOL offline_main	(	INT	argc,
		LPWSTR *	argv
	)

Definition at line 11 of file offline.c.

{
    return TRUE;
}

online_main()

BOOL online_main	(	INT	argc,
		LPWSTR *	argv
	)

Definition at line 11 of file online.c.

{
    return TRUE;
}

recover_main()

BOOL recover_main	(	INT	argc,
		LPWSTR *	argv
	)

Definition at line 11 of file recover.c.

{
    return TRUE;
}

remove_main()

BOOL remove_main	(	INT	argc,
		LPWSTR *	argv
	)

Definition at line 11 of file remove.c.

{
    return TRUE;
}

repair_main()

BOOL repair_main	(	INT	argc,
		LPWSTR *	argv
	)

Definition at line 11 of file repair.c.

{
    ConPuts(StdOut, L"\nTODO: Add code later since Win 7 Home Premium doesn't have this feature.\n");
    return TRUE;
}

rescan_main()

BOOL rescan_main	(	INT	argc,
		LPWSTR *	argv
	)

Definition at line 11 of file rescan.c.

{
    ConResPuts(StdOut, IDS_RESCAN_START);
    DestroyVolumeList();
    DestroyPartitionList();
    CreatePartitionList();
    CreateVolumeList();
    ConResPuts(StdOut, IDS_RESCAN_END);

    return TRUE;
}

retain_main()

BOOL retain_main	(	INT	argc,
		LPWSTR *	argv
	)

Definition at line 11 of file retain.c.

{
    return TRUE;
}

RoundingDivide()

ULONGLONG RoundingDivide	(	_In_ ULONGLONG	Dividend,
		_In_ ULONGLONG	Divisor
	)

Definition at line 75 of file misc.c.

{
    return (Dividend + Divisor / 2) / Divisor;
}

san_main()

BOOL san_main	(	INT	argc,
		LPWSTR *	argv
	)

Definition at line 11 of file san.c.

{
    return TRUE;
}

SelectDisk()

BOOL SelectDisk	(	INT	argc,
		PWSTR *	argv
	)

Definition at line 17 of file select.c.

{
    PLIST_ENTRY Entry;
    PDISKENTRY DiskEntry;
    ULONG ulValue;

    DPRINT("Select Disk()\n");

    if (argc > 3)
    {
        ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
        return TRUE;
    }

    if (argc == 2)
    {
        if (CurrentDisk == NULL)
            ConResPuts(StdOut, IDS_SELECT_NO_DISK);
        else
            ConResPrintf(StdOut, IDS_SELECT_DISK, CurrentDisk->DiskNumber);
        return TRUE;
    }

    if (!IsDecString(argv[2]))
    {
        ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
        return TRUE;
    }

    ulValue = wcstoul(argv[2], NULL, 10);
    if ((ulValue == 0) && (errno == ERANGE))
    {
        ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
        return TRUE;
    }

    CurrentDisk = NULL;

    Entry = DiskListHead.Flink;
    while (Entry != &DiskListHead)
    {
        DiskEntry = CONTAINING_RECORD(Entry, DISKENTRY, ListEntry);

        if (DiskEntry->DiskNumber == ulValue)
        {
            CurrentDisk = DiskEntry;
            CurrentPartition = NULL;
            ConResPrintf(StdOut, IDS_SELECT_DISK, CurrentDisk->DiskNumber);
            return TRUE;
        }

        Entry = Entry->Flink;
    }

    ConResPuts(StdErr, IDS_SELECT_DISK_INVALID);
    return TRUE;
}

SelectPartition()

BOOL SelectPartition	(	INT	argc,
		PWSTR *	argv
	)

Definition at line 79 of file select.c.

{
    PLIST_ENTRY Entry;
    PPARTENTRY PartEntry;
    ULONG ulValue;
    ULONG PartNumber = 1;

    DPRINT("Select Partition()\n");

    if (argc > 3)
    {
        ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
        return TRUE;
    }

    if (CurrentDisk == NULL)
    {
        ConResPuts(StdOut, IDS_SELECT_PARTITION_NO_DISK);
        return TRUE;
    }

    if (argc == 2)
    {
        if (CurrentPartition == NULL)
            ConResPuts(StdOut, IDS_SELECT_NO_PARTITION);
        else
            ConResPrintf(StdOut, IDS_SELECT_PARTITION, CurrentPartition);
        return TRUE;
    }

    if (!IsDecString(argv[2]))
    {
        ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
        return TRUE;
    }

    ulValue = wcstoul(argv[2], NULL, 10);
    if ((ulValue == 0) && (errno == ERANGE))
    {
        ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
        return TRUE;
    }

    Entry = CurrentDisk->PrimaryPartListHead.Flink;
    while (Entry != &CurrentDisk->PrimaryPartListHead)
    {
        PartEntry = CONTAINING_RECORD(Entry, PARTENTRY, ListEntry);

        if (PartEntry->PartitionType != 0)
        {
            if (PartNumber == ulValue)
            {
                CurrentPartition = PartEntry;
                ConResPrintf(StdOut, IDS_SELECT_PARTITION, PartNumber);
                return TRUE;
            }

            PartNumber++;
        }

        Entry = Entry->Flink;
    }

    Entry = CurrentDisk->LogicalPartListHead.Flink;
    while (Entry != &CurrentDisk->LogicalPartListHead)
    {
        PartEntry = CONTAINING_RECORD(Entry, PARTENTRY, ListEntry);

        if (PartEntry->PartitionType != 0)
        {
            if (PartNumber == ulValue)
            {
                CurrentPartition = PartEntry;
                ConResPrintf(StdOut, IDS_SELECT_PARTITION, PartNumber);
                return TRUE;
            }

            PartNumber++;
        }
        Entry = Entry->Flink;
    }

    ConResPuts(StdErr, IDS_SELECT_PARTITION_INVALID);
    return TRUE;
}

SelectVolume()

BOOL SelectVolume	(	INT	argc,
		PWSTR *	argv
	)

Definition at line 169 of file select.c.

{
    PLIST_ENTRY Entry;
    PVOLENTRY VolumeEntry;
    ULONG ulValue;

    DPRINT("SelectVolume()\n");

    if (argc > 3)
    {
        ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
        return TRUE;
    }

    if (argc == 2)
    {
        if (CurrentDisk == NULL)
            ConResPuts(StdOut, IDS_SELECT_NO_VOLUME);
        else
            ConResPrintf(StdOut, IDS_SELECT_VOLUME, CurrentVolume->VolumeNumber);
        return TRUE;
    }

    if (!IsDecString(argv[2]))
    {
        ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
        return TRUE;
    }

    ulValue = wcstoul(argv[2], NULL, 10);
    if ((ulValue == 0) && (errno == ERANGE))
    {
        ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
        return TRUE;
    }

    CurrentVolume = NULL;

    Entry = VolumeListHead.Flink;
    while (Entry != &VolumeListHead)
    {
        VolumeEntry = CONTAINING_RECORD(Entry, VOLENTRY, ListEntry);

        if (VolumeEntry->VolumeNumber == ulValue)
        {
            CurrentVolume = VolumeEntry;
            ConResPrintf(StdOut, IDS_SELECT_VOLUME, CurrentVolume->VolumeNumber);
            return TRUE;
        }

        Entry = Entry->Flink;
    }

    ConResPuts(StdErr, IDS_SELECT_VOLUME_INVALID);
    return TRUE;
}

setid_main()

BOOL setid_main	(	INT	argc,
		LPWSTR *	argv
	)

Definition at line 11 of file setid.c.

{
    return TRUE;
}

shrink_main()

BOOL shrink_main	(	INT	argc,
		LPWSTR *	argv
	)

Definition at line 11 of file shrink.c.

{
    return TRUE;
}

UniqueIdDisk()

BOOL UniqueIdDisk	(	_In_ INT	argc,
		_In_ PWSTR *	argv
	)

Definition at line 17 of file uniqueid.c.

{
    PWSTR pszSuffix = NULL;
    ULONG ulValue;

    if (CurrentDisk == NULL)
    {
        ConResPuts(StdOut, IDS_SELECT_NO_DISK);
        return TRUE;
    }

    if (argc == 2)
    {
        ConPuts(StdOut, L"\n");
        ConPrintf(StdOut, L"Disk ID: %08lx\n", CurrentDisk->LayoutBuffer->Signature);
        ConPuts(StdOut, L"\n");
        return TRUE;
    }

    if (argc != 3)
    {
        ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
        return TRUE;
    }

    if (!HasPrefix(argv[2], L"ID=", &pszSuffix))
    {
        ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
        return TRUE;
    }

    if ((pszSuffix == NULL) ||
        (wcslen(pszSuffix) > 8) ||
        (IsHexString(pszSuffix) == FALSE))
    {
        ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
        return TRUE;
    }

    ulValue = wcstoul(pszSuffix, NULL, 16);
    if ((ulValue == 0) && (errno == ERANGE))
    {
        ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
        return TRUE;
    }

    ConPrintf(StdOut, L"Setting the disk signature is not implemented yet!\n");
#if 0
    DPRINT1("New Signature: %lx\n", ulValue);
    CurrentDisk->LayoutBuffer->Signature = ulValue;
//    SetDiskLayout(CurrentDisk);
#endif

    return TRUE;
}

Variable Documentation

BiosDiskListHead

LIST_ENTRY BiosDiskListHead

Definition at line 71 of file partlist.c.

Referenced by AddDiskToList(), CreatePartitionList(), DestroyPartitionList(), and EnumerateBiosDiskEntries().

cmds

COMMAND cmds[]

Definition at line 21 of file main.c.

Referenced by DoCommand(), handle_arrow_key(), handle_edit_event(), help_main(), HelpCommand(), HelpCommandList(), InterpretCmd(), PrintCommandList(), test_ioctlsocket(), test_OleCommandTarget(), and wmain().

CurrentDisk

PDISKENTRY CurrentDisk

Definition at line 74 of file partlist.c.

Referenced by CreateExtendedPartition(), CreateLogicalPartition(), CreatePartitionList(), DestroyPartitionList(), DetailDisk(), DetailPartition(), DumpDisk(), DumpPartition(), GetNextPartition(), GetPrevPartition(), ListDisk(), ListPartition(), SelectDisk(), SelectPartition(), SelectVolume(), and UniqueIdDisk().

CurrentPartition

PPARTENTRY CurrentPartition

Definition at line 75 of file partlist.c.

Referenced by CreatePartitionList(), and DestroyPartitionList().

CurrentVolume

PVOLENTRY CurrentVolume

Definition at line 76 of file partlist.c.

Referenced by CreateVolumeList(), DestroyVolumeList(), DetailVolume(), and SelectVolume().

DiskListHead

LIST_ENTRY DiskListHead

Definition at line 70 of file partlist.c.

Referenced by AddDiskToList(), CreatePartitionList(), DestroyPartitionList(), ListDisk(), and SelectDisk().

VolumeListHead

LIST_ENTRY VolumeListHead

Definition at line 72 of file partlist.c.

Referenced by AddVolumeToList(), CreateVolumeList(), DestroyVolumeList(), ListVolume(), and SelectVolume().