diskpart.h File Reference

#include <stdio.h>
#include <stdlib.h>
#include <windef.h>
#include <winbase.h>
#include <winnls.h>
#include <winreg.h>
#include <wincon.h>
#include <winioctl.h>
#include <winuser.h>
#include <ntsecapi.h>
#include <errno.h>
#include <strsafe.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 <ntddscsi.h>
#include <ntddstor.h>
#include <mountmgr.h>
#include <fmifs/fmifs.h>
#include <guiddef.h>
#include <diskguid.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	_MBR_PARTITION_DATA
struct	_GPT_PARTITION_DATA
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
#define	SIZE_1KB   (1024ULL)
#define	SIZE_10KB   (10ULL * 1024ULL)
#define	SIZE_1MB   (1024ULL * 1024ULL)
#define	SIZE_10MB   (10ULL * 1024ULL * 1024ULL)
#define	SIZE_1GB   (1024ULL * 1024ULL * 1024ULL)
#define	SIZE_10GB   (10ULL * 1024ULL * 1024ULL * 1024ULL)
#define	SIZE_1TB   (1024ULL * 1024ULL * 1024ULL * 1024ULL)
#define	SIZE_10TB   (10ULL * 1024ULL * 1024ULL * 1024ULL * 1024ULL)

Typedefs
typedef enum _EXIT_CODE	EXIT_CODE
typedef struct _COMMAND	COMMAND
typedef struct _COMMAND *	PCOMMAND
typedef enum _FORMATSTATE	FORMATSTATE
typedef enum _FORMATSTATE *	PFORMATSTATE
typedef enum _VOLUME_TYPE	VOLUME_TYPE
typedef enum _VOLUME_TYPE *	PVOLUME_TYPE
typedef struct _MBR_PARTITION_DATA	MBR_PARTITION_DATA
typedef struct _MBR_PARTITION_DATA *	PMBR_PARTITION_DATA
typedef struct _GPT_PARTITION_DATA	GPT_PARTITION_DATA
typedef struct _GPT_PARTITION_DATA *	PGPT_PARTITION_DATA
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	_EXIT_CODE {   EXIT_SUCCESS = 0 , EXIT_FATAL , EXIT_CMD_ARG , EXIT_FILE ,   EXIT_SERVICE , EXIT_SYNTAX , EXIT_EXIT }
enum	_FORMATSTATE {   Unformatted , UnformattedOrDamaged , UnknownFormat , Formatted ,   Unformatted , UnformattedOrDamaged , UnknownFormat , Preformatted ,   Formatted }
enum	_VOLUME_TYPE { VOLUME_TYPE_CDROM , VOLUME_TYPE_PARTITION , VOLUME_TYPE_REMOVABLE , VOLUME_TYPE_UNKNOWN }

Functions
EXIT_CODE	active_main (_In_ INT argc, _In_ PWSTR *argv)
EXIT_CODE	add_main (_In_ INT argc, _In_ PWSTR *argv)
EXIT_CODE	assign_main (_In_ INT argc, _In_ PWSTR *argv)
EXIT_CODE	attach_main (_In_ INT argc, _In_ PWSTR *argv)
EXIT_CODE	attributes_main (_In_ INT argc, _In_ PWSTR *argv)
EXIT_CODE	automount_main (_In_ INT argc, _In_ PWSTR *argv)
EXIT_CODE	break_main (_In_ INT argc, _In_ PWSTR *argv)
EXIT_CODE	clean_main (_In_ INT argc, _In_ PWSTR *argv)
EXIT_CODE	compact_main (_In_ INT argc, _In_ PWSTR *argv)
NTSTATUS	CreateDisk (_In_ ULONG DiskNumber, _In_ PCREATE_DISK DiskInfo)
EXIT_CODE	ConvertGPT (_In_ INT argc, _In_ PWSTR *argv)
EXIT_CODE	ConvertMBR (_In_ INT argc, _In_ PWSTR *argv)
EXIT_CODE	CreateEfiPartition (_In_ INT argc, _In_ PWSTR *argv)
EXIT_CODE	CreateExtendedPartition (_In_ INT argc, _In_ PWSTR *argv)
EXIT_CODE	CreateLogicalPartition (_In_ INT argc, _In_ PWSTR *argv)
EXIT_CODE	CreateMsrPartition (_In_ INT argc, _In_ PWSTR *argv)
EXIT_CODE	CreatePrimaryPartition (_In_ INT argc, _In_ PWSTR *argv)
EXIT_CODE	DeleteDisk (_In_ INT argc, _In_ PWSTR *argv)
EXIT_CODE	DeletePartition (_In_ INT argc, _In_ PWSTR *argv)
EXIT_CODE	DeleteVolume (_In_ INT argc, _In_ PWSTR *argv)
EXIT_CODE	detach_main (_In_ INT argc, _In_ PWSTR *argv)
EXIT_CODE	DetailDisk (INT argc, PWSTR *argv)
EXIT_CODE	DetailPartition (INT argc, PWSTR *argv)
EXIT_CODE	DetailVolume (INT argc, PWSTR *argv)
EXIT_CODE	DumpDisk (_In_ INT argc, _In_ LPWSTR *argv)
EXIT_CODE	DumpPartition (_In_ INT argc, _In_ LPWSTR *argv)
EXIT_CODE	expand_main (_In_ INT argc, _In_ PWSTR *argv)
EXIT_CODE	extend_main (_In_ INT argc, _In_ PWSTR *argv)
EXIT_CODE	filesystems_main (_In_ INT argc, _In_ PWSTR *argv)
EXIT_CODE	format_main (_In_ INT argc, _In_ PWSTR *argv)
EXIT_CODE	gpt_main (_In_ INT argc, _In_ PWSTR *argv)
EXIT_CODE	help_main (_In_ INT argc, _In_ PWSTR *argv)
VOID	HelpCommandList (VOID)
EXIT_CODE	HelpCommand (_In_ PCOMMAND pCommand)
EXIT_CODE	import_main (_In_ INT argc, _In_ PWSTR *argv)
EXIT_CODE	inactive_main (_In_ INT argc, _In_ PWSTR *argv)
EXIT_CODE	InterpretScript (_In_ LPWSTR line)
EXIT_CODE	InterpretCmd (_In_ INT argc, _In_ PWSTR *argv)
VOID	InterpretMain (VOID)
EXIT_CODE	ListDisk (INT argc, PWSTR *argv)
EXIT_CODE	ListPartition (INT argc, PWSTR *argv)
EXIT_CODE	ListVolume (INT argc, PWSTR *argv)
EXIT_CODE	ListVirtualDisk (INT argc, PWSTR *argv)
VOID	PrintDisk (_In_ PDISKENTRY DiskEntry)
VOID	PrintVolume (_In_ PVOLENTRY VolumeEntry)
EXIT_CODE	merge_main (_In_ INT argc, _In_ PWSTR *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)
PWSTR	DuplicateQuotedString (_In_ PWSTR pszInString)
PWSTR	DuplicateString (_In_ PWSTR pszInString)
VOID	CreateGUID (_Out_ GUID *pGuid)
VOID	CreateSignature (_Out_ PDWORD pSignature)
VOID	PrintGUID (_Out_ PWSTR pszBuffer, _In_ GUID *pGuid)
BOOL	StringToGUID (_Out_ GUID *pGuid, _In_ PWSTR pszString)
VOID	PrintBusType (_Out_ PWSTR pszBuffer, _In_ INT cchBufferMax, _In_ STORAGE_BUS_TYPE Bustype)
BOOL	GetAutomountState (_Out_ PBOOL State)
BOOL	SetAutomountState (_In_ BOOL bEnable)
BOOL	ScrubAutomount (VOID)
BOOL	AssignDriveLetter (_In_ PWSTR DeviceName, _In_ WCHAR DriveLetter)
BOOL	AssignNextDriveLetter (_In_ PWSTR DeviceName, _Out_ PWCHAR DriveLetter)
BOOL	DeleteDriveLetter (_In_ WCHAR DriveLetter)
EXIT_CODE	offline_main (_In_ INT argc, _In_ PWSTR *argv)
EXIT_CODE	online_main (_In_ INT argc, _In_ PWSTR *argv)
ULONGLONG	AlignDown (_In_ ULONGLONG Value, _In_ ULONG Alignment)
NTSTATUS	CreatePartitionList (VOID)
VOID	DestroyPartitionList (VOID)
NTSTATUS	CreateVolumeList (VOID)
VOID	DestroyVolumeList (VOID)
VOID	ScanForUnpartitionedMbrDiskSpace (PDISKENTRY DiskEntry)
VOID	ScanForUnpartitionedGptDiskSpace (PDISKENTRY DiskEntry)
VOID	ReadLayoutBuffer (_In_ HANDLE FileHandle, _In_ PDISKENTRY DiskEntry)
NTSTATUS	WriteMbrPartitions (_In_ PDISKENTRY DiskEntry)
NTSTATUS	WriteGptPartitions (_In_ PDISKENTRY DiskEntry)
VOID	UpdateMbrDiskLayout (_In_ PDISKENTRY DiskEntry)
VOID	UpdateGptDiskLayout (_In_ PDISKENTRY DiskEntry, _In_ BOOL DeleteEntry)
PPARTENTRY	GetPrevUnpartitionedEntry (_In_ PPARTENTRY PartEntry)
PPARTENTRY	GetNextUnpartitionedEntry (_In_ PPARTENTRY PartEntry)
ULONG	GetPrimaryPartitionCount (_In_ PDISKENTRY DiskEntry)
NTSTATUS	DismountVolume (_In_ PPARTENTRY PartEntry)
PVOLENTRY	GetVolumeFromPartition (_In_ PPARTENTRY PartEntry)
VOID	RemoveVolume (_In_ PVOLENTRY VolumeEntry)
EXIT_CODE	recover_main (_In_ INT argc, _In_ PWSTR *argv)
EXIT_CODE	remove_main (_In_ INT argc, _In_ PWSTR *argv)
EXIT_CODE	repair_main (_In_ INT argc, _In_ PWSTR *argv)
EXIT_CODE	rescan_main (_In_ INT argc, _In_ PWSTR *argv)
EXIT_CODE	retain_main (_In_ INT argc, _In_ PWSTR *argv)
EXIT_CODE	san_main (_In_ INT argc, _In_ PWSTR *argv)
EXIT_CODE	SelectDisk (INT argc, PWSTR *argv)
EXIT_CODE	SelectPartition (INT argc, PWSTR *argv)
EXIT_CODE	SelectVolume (INT argc, PWSTR *argv)
EXIT_CODE	setid_main (_In_ INT argc, _In_ PWSTR *argv)
EXIT_CODE	shrink_main (_In_ INT argc, _In_ PWSTR *argv)
EXIT_CODE	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 97 of file diskpart.h.

MAX_STRING_SIZE

#define MAX_STRING_SIZE   1024

Definition at line 96 of file diskpart.h.

NTOS_MODE_USER

#define NTOS_MODE_USER

Definition at line 42 of file diskpart.h.

SIZE_10GB

#define SIZE_10GB   (10ULL * 1024ULL * 1024ULL * 1024ULL)

Definition at line 262 of file diskpart.h.

SIZE_10KB

#define SIZE_10KB   (10ULL * 1024ULL)

Definition at line 258 of file diskpart.h.

SIZE_10MB

#define SIZE_10MB   (10ULL * 1024ULL * 1024ULL)

Definition at line 260 of file diskpart.h.

SIZE_10TB

#define SIZE_10TB   (10ULL * 1024ULL * 1024ULL * 1024ULL * 1024ULL)

Definition at line 264 of file diskpart.h.

SIZE_1GB

#define SIZE_1GB   (1024ULL * 1024ULL * 1024ULL)

Definition at line 261 of file diskpart.h.

SIZE_1KB

#define SIZE_1KB   (1024ULL)

Definition at line 257 of file diskpart.h.

SIZE_1MB

#define SIZE_1MB   (1024ULL * 1024ULL)

Definition at line 259 of file diskpart.h.

SIZE_1TB

#define SIZE_1TB   (1024ULL * 1024ULL * 1024ULL * 1024ULL)

Definition at line 263 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

EXIT_CODE

typedef enum _EXIT_CODE EXIT_CODE

FORMATSTATE

typedef enum _FORMATSTATE FORMATSTATE

GPT_PARTITION_DATA

typedef struct _GPT_PARTITION_DATA GPT_PARTITION_DATA

MBR_PARTITION_DATA

typedef struct _MBR_PARTITION_DATA MBR_PARTITION_DATA

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

PGPT_PARTITION_DATA

typedef struct _GPT_PARTITION_DATA * PGPT_PARTITION_DATA

PMBR_PARTITION_DATA

typedef struct _MBR_PARTITION_DATA * PMBR_PARTITION_DATA

PPARTENTRY

typedef struct _PARTENTRY * PPARTENTRY

PVOLENTRY

typedef struct _VOLENTRY * PVOLENTRY

PVOLUME_TYPE

typedef enum _VOLUME_TYPE * PVOLUME_TYPE

VOLENTRY

typedef struct _VOLENTRY VOLENTRY

VOLUME_TYPE

typedef enum _VOLUME_TYPE VOLUME_TYPE

Enumeration Type Documentation

_EXIT_CODE

enum _EXIT_CODE

Enumerator
EXIT_SUCCESS
EXIT_FATAL
EXIT_CMD_ARG
EXIT_FILE
EXIT_SERVICE
EXIT_SYNTAX
EXIT_EXIT

Definition at line 73 of file diskpart.h.

{
    EXIT_SUCCESS = 0,
    EXIT_FATAL,
    EXIT_CMD_ARG,
    EXIT_FILE,
    EXIT_SERVICE,
    EXIT_SYNTAX,
    EXIT_EXIT       /* Only used by the exit command */
} EXIT_CODE;

_FORMATSTATE

enum _FORMATSTATE

Enumerator
Unformatted
UnformattedOrDamaged
UnknownFormat
Formatted
Unformatted
UnformattedOrDamaged
UnknownFormat
Preformatted
Formatted

Definition at line 100 of file diskpart.h.

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

_VOLUME_TYPE

enum _VOLUME_TYPE

Enumerator
VOLUME_TYPE_CDROM
VOLUME_TYPE_PARTITION
VOLUME_TYPE_REMOVABLE
VOLUME_TYPE_UNKNOWN

Definition at line 109 of file diskpart.h.

{
    VOLUME_TYPE_CDROM,
    VOLUME_TYPE_PARTITION,
    VOLUME_TYPE_REMOVABLE,
    VOLUME_TYPE_UNKNOWN
} VOLUME_TYPE, *PVOLUME_TYPE;

Function Documentation

active_main()

EXIT_CODE active_main	(	_In_ INT	argc,
		_In_ PWSTR *	argv
	)

Definition at line 16 of file active.c.

{
    NTSTATUS Status;
 
    DPRINT("Active()\n");
 
    if (CurrentDisk == NULL)
    {
        ConResPuts(StdOut, IDS_SELECT_NO_DISK);
        return EXIT_SUCCESS;
    }
 
    if (CurrentPartition == NULL)
    {
        ConResPuts(StdOut, IDS_SELECT_NO_PARTITION);
        return EXIT_SUCCESS;
    }
 
    if (CurrentDisk->PartitionStyle == PARTITION_STYLE_MBR)
    {
        if (CurrentPartition->Mbr.BootIndicator)
        {
            ConResPuts(StdOut, IDS_ACTIVE_ALREADY);
            return EXIT_SUCCESS;
        }
 
        CurrentPartition->Mbr.BootIndicator = TRUE;
        CurrentDisk->Dirty = TRUE;
        UpdateMbrDiskLayout(CurrentDisk);
        Status = WriteMbrPartitions(CurrentDisk);
        if (NT_SUCCESS(Status))
        {
            ConResPuts(StdOut, IDS_ACTIVE_SUCCESS);
        }
        else
        {
            ConResPuts(StdOut, IDS_ACTIVE_FAIL);
        }
    }
    else
    {
        ConResPuts(StdOut, IDS_ACTIVE_NO_MBR);
    }
 
    return EXIT_SUCCESS;
}

add_main()

EXIT_CODE add_main	(	_In_ INT	argc,
		_In_ PWSTR *	argv
	)

Definition at line 12 of file add.c.

{
    return EXIT_SUCCESS;
}

AlignDown()

ULONGLONG AlignDown	(	_In_ ULONGLONG	Value,
		_In_ ULONG	Alignment
	)

Definition at line 189 of file partlist.c.

{
    ULONGLONG Temp;
 
    Temp = Value / Alignment;
 
    return Temp * Alignment;
}

assign_main()

EXIT_CODE assign_main	(	_In_ INT	argc,
		_In_ PWSTR *	argv
	)

AssignDriveLetter()

BOOL AssignDriveLetter	(	_In_ PWSTR	DeviceName,
		_In_ WCHAR	DriveLetter
	)

Definition at line 181 of file mountmgr.c.

{
    WCHAR DosDeviceName[30];
    ULONG DosDeviceNameLength, DeviceNameLength; 
    ULONG InputBufferLength;
    PMOUNTMGR_CREATE_POINT_INPUT InputBuffer;
    HANDLE MountMgrHandle = NULL;
    IO_STATUS_BLOCK Iosb;
    NTSTATUS Status;
    BOOL Ret = TRUE;
 
    DPRINT1("AssignDriveLetter(%S %c)\n", DeviceName, DriveLetter);
 
    DeviceNameLength = wcslen(DeviceName) * sizeof(WCHAR);
 
    swprintf(DosDeviceName, L"\\DosDevices\\%c:", DriveLetter);
    DosDeviceNameLength = wcslen(DosDeviceName) * sizeof(WCHAR);
 
    /* Allocate the input buffer for the MountMgr */
    InputBufferLength = DosDeviceNameLength + DeviceNameLength + sizeof(MOUNTMGR_CREATE_POINT_INPUT);
    InputBuffer = RtlAllocateHeap(RtlGetProcessHeap(), HEAP_ZERO_MEMORY, InputBufferLength);
    if (InputBuffer == NULL)
    {
        DPRINT1("InputBuffer allocation failed!\n");
        return FALSE;
    }
 
    /* Fill the input buffer */
    InputBuffer->SymbolicLinkNameOffset = sizeof(MOUNTMGR_CREATE_POINT_INPUT);
    InputBuffer->SymbolicLinkNameLength = DosDeviceNameLength;
    InputBuffer->DeviceNameOffset = DosDeviceNameLength + sizeof(MOUNTMGR_CREATE_POINT_INPUT);
    InputBuffer->DeviceNameLength = DeviceNameLength;
    RtlCopyMemory((PVOID)((ULONG_PTR)InputBuffer + sizeof(MOUNTMGR_CREATE_POINT_INPUT)),
                  DosDeviceName,
                  DosDeviceNameLength);
    RtlCopyMemory((PVOID)((ULONG_PTR)InputBuffer + InputBuffer->DeviceNameOffset),
                  DeviceName,
                  DeviceNameLength);
 
DPRINT1("\n");
    Status = OpenMountManager(&MountMgrHandle, GENERIC_READ | GENERIC_WRITE);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("OpenMountManager() failed (Status 0x%08lx)\n", Status);
        Ret = FALSE;
        goto done;
    }
 
DPRINT1("\n");
    Status = NtDeviceIoControlFile(MountMgrHandle,
                                   NULL,
                                   NULL,
                                   NULL,
                                   &Iosb,
                                   IOCTL_MOUNTMGR_CREATE_POINT,
                                   InputBuffer,
                                   InputBufferLength,
                                   NULL,
                                   0);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("NtDeviceIoControlFile() failed (Status 0x%08lx)\n", Status);
        Ret = FALSE;
        goto done;
    }
 
DPRINT1("\n");
done:
    if (MountMgrHandle)
        NtClose(MountMgrHandle);
 
    RtlFreeHeap(RtlGetProcessHeap(), 0, InputBuffer);
 
    return Ret;
}

Referenced by assign_main().

AssignNextDriveLetter()

BOOL AssignNextDriveLetter	(	_In_ PWSTR	DeviceName,
		_Out_ PWCHAR	DriveLetter
	)

Definition at line 261 of file mountmgr.c.

{
    MOUNTMGR_DRIVE_LETTER_INFORMATION LetterInfo;
    PMOUNTMGR_DRIVE_LETTER_TARGET InputBuffer;
    ULONG DeviceNameLength, InputBufferLength;
    HANDLE MountMgrHandle = NULL;
    IO_STATUS_BLOCK Iosb;
    NTSTATUS Status;
    BOOL Ret = TRUE;
 
    DPRINT1("AssignNextDriveLetter(%S %p)\n", DeviceName, DriveLetter);
 
    DeviceNameLength = wcslen(DeviceName) * sizeof(WCHAR);
 
    InputBufferLength = DeviceNameLength + FIELD_OFFSET(MOUNTMGR_DRIVE_LETTER_TARGET, DeviceName);
    InputBuffer = RtlAllocateHeap(RtlGetProcessHeap(), HEAP_ZERO_MEMORY, InputBufferLength);
    if (InputBuffer == NULL)
    {
        DPRINT1("InputBuffer allocation failed!\n");
        return FALSE;
    }
 
    /* And fill it with the device hat needs a drive letter */
    InputBuffer->DeviceNameLength = DeviceNameLength;
    RtlCopyMemory(&InputBuffer->DeviceName[0],
                  DeviceName,
                  DeviceNameLength);
 
DPRINT1("\n");
    Status = OpenMountManager(&MountMgrHandle, GENERIC_READ | GENERIC_WRITE);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("OpenMountManager() failed (Status 0x%08lx)\n", Status);
        Ret = FALSE;
        goto done;
    }
 
DPRINT1("\n");
    Status = NtDeviceIoControlFile(MountMgrHandle,
                                   NULL,
                                   NULL,
                                   NULL,
                                   &Iosb,
                                   IOCTL_MOUNTMGR_CREATE_POINT,
                                   InputBuffer,
                                   InputBufferLength,
                                   &LetterInfo,
                                   sizeof(LetterInfo));
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("NtDeviceIoControlFile() failed (Status 0x%08lx)\n", Status);
        Ret = FALSE;
        goto done;
    }
 
DPRINT1("\n");
done:
    if (MountMgrHandle)
        NtClose(MountMgrHandle);
 
    RtlFreeHeap(RtlGetProcessHeap(), 0, InputBuffer);
 
    if (Ret)
    {
        if (LetterInfo.DriveLetterWasAssigned)
            *DriveLetter = LetterInfo.CurrentDriveLetter;
        else
            *DriveLetter = UNICODE_NULL;
    }
 
    return Ret;
}

Referenced by assign_main().

attach_main()

EXIT_CODE attach_main	(	_In_ INT	argc,
		_In_ PWSTR *	argv
	)

Definition at line 12 of file attach.c.

{
    return EXIT_SUCCESS;
}

attributes_main()

EXIT_CODE attributes_main	(	_In_ INT	argc,
		_In_ PWSTR *	argv
	)

Definition at line 12 of file attributes.c.

{
    return EXIT_SUCCESS;
}

automount_main()

EXIT_CODE automount_main	(	_In_ INT	argc,
		_In_ PWSTR *	argv
	)

Definition at line 16 of file automount.c.

{
    BOOL bDisable = FALSE, bEnable = FALSE, bScrub = FALSE;
#if 0
    BOOL bNoErr = FALSE;
#endif
    INT i;
    BOOL Result, State;
 
    DPRINT("Automount()\n");
 
    for (i = 1; i < argc; i++)
    {
        if (_wcsicmp(argv[i], L"noerr") == 0)
        {
            /* noerr */
#if 0
            bNoErr = TRUE;
#endif
        }
    }
 
    for (i = 1; i < argc; i++)
    {
        if (_wcsicmp(argv[i], L"disable") == 0)
        {
            /* set automount state */
            bDisable = TRUE;
        }
        else if (_wcsicmp(argv[i], L"enable") == 0)
        {
            /* set automount state */
            bEnable = TRUE;
        }
        else if (_wcsicmp(argv[i], L"scrub") == 0)
        {
            /* scrub automount */
            bScrub = TRUE;
        }
        else if (_wcsicmp(argv[i], L"noerr") == 0)
        {
            /* noerr - Already handled above */
        }
        else
        {
            ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
            return TRUE;
        }
    }
 
    DPRINT("bDisable %u\n", bDisable);
    DPRINT("bEnable  %u\n", bEnable);
    DPRINT("bScrub   %u\n", bScrub);
 
    if (bDisable && bEnable)
    {
        ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
        return TRUE;
    }
 
    if ((bDisable == FALSE) && (bEnable == FALSE) && (bScrub == FALSE))
    {
        DPRINT("Show automount\n");
        Result = GetAutomountState(&State);
        if (Result == FALSE)
        {
//            ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
            return TRUE;
        }
 
        if (State)
            ConResPuts(StdOut, IDS_AUTOMOUNT_ENABLED);
        else
            ConResPuts(StdOut, IDS_AUTOMOUNT_DISABLED);
        ConPuts(StdOut, L"\n");
    }
 
    if (bDisable)
    {
        DPRINT("Disable automount\n");
        Result = SetAutomountState(FALSE);
        if (Result == FALSE)
        {
//            ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
            return TRUE;
        }
 
        ConResPuts(StdOut, IDS_AUTOMOUNT_DISABLED);
        ConPuts(StdOut, L"\n");
    }
 
    if (bEnable)
    {
        DPRINT("Enable automount\n");
        Result = SetAutomountState(TRUE);
        if (Result == FALSE)
        {
//            ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
            return TRUE;
        }
 
        ConResPuts(StdOut, IDS_AUTOMOUNT_ENABLED);
        ConPuts(StdOut, L"\n");
    }
 
    if (bScrub)
    {
        DPRINT("Scrub automount\n");
        Result = ScrubAutomount();
        if (Result == FALSE)
        {
//            ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
            return TRUE;
        }
 
        ConResPuts(StdOut, IDS_AUTOMOUNT_SCRUBBED);
        ConPuts(StdOut, L"\n");
    }
 
    return EXIT_SUCCESS;
}

break_main()

EXIT_CODE break_main	(	_In_ INT	argc,
		_In_ PWSTR *	argv
	)

Definition at line 12 of file break.c.

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

clean_main()

EXIT_CODE clean_main	(	_In_ INT	argc,
		_In_ PWSTR *	argv
	)

Definition at line 16 of file clean.c.

{
    PLIST_ENTRY Entry;
    PPARTENTRY PartEntry;
    PVOLENTRY VolumeEntry;
    BOOL bAll = FALSE;
    PUCHAR SectorsBuffer = NULL;
    ULONG LayoutBufferSize, Size;
    INT i;
    WCHAR Buffer[MAX_PATH];
    UNICODE_STRING Name;
    OBJECT_ATTRIBUTES ObjectAttributes;
    IO_STATUS_BLOCK IoStatusBlock;
    HANDLE FileHandle = NULL;
    LARGE_INTEGER Offset, Count, MaxCount;
    NTSTATUS Status;
 
    DPRINT("Clean()\n");
 
    if (CurrentDisk == NULL)
    {
        ConResPuts(StdOut, IDS_SELECT_NO_DISK);
        return EXIT_SUCCESS;
    }
 
    /* Do not allow to clean the boot disk */
    if ((CurrentDisk->BiosFound == TRUE) &&
        (CurrentDisk->BiosDiskNumber == 0))
    {
        ConResPuts(StdOut, IDS_CLEAN_SYSTEM);
        return EXIT_SUCCESS;
    }
 
    for (i = 1; i < argc; i++)
    {
        if (_wcsicmp(argv[1], L"all") == 0)
        {
            bAll = TRUE;
        }
    }
 
    /* Dismount and remove all logical partitions */
    while (!IsListEmpty(&CurrentDisk->LogicalPartListHead))
    {
        Entry = RemoveHeadList(&CurrentDisk->LogicalPartListHead);
        PartEntry = CONTAINING_RECORD(Entry, PARTENTRY, ListEntry);
 
        /* Dismount the logical partition */
        if (PartEntry->Mbr.PartitionType != 0)
        {
            DismountVolume(PartEntry);
            VolumeEntry = GetVolumeFromPartition(PartEntry);
            if (VolumeEntry)
                RemoveVolume(VolumeEntry);
        }
 
        /* Delete it */
        RtlFreeHeap(RtlGetProcessHeap(), 0, PartEntry);
    }
 
    /* Dismount and remove all primary partitions */
    while (!IsListEmpty(&CurrentDisk->PrimaryPartListHead))
    {
        Entry = RemoveHeadList(&CurrentDisk->PrimaryPartListHead);
        PartEntry = CONTAINING_RECORD(Entry, PARTENTRY, ListEntry);
 
        /* Dismount the primary partition */
        if ((PartEntry->Mbr.PartitionType != 0) &&
            (IsContainerPartition(PartEntry->Mbr.PartitionType) == FALSE))
        {
            DismountVolume(PartEntry);
            VolumeEntry = GetVolumeFromPartition(PartEntry);
            if (VolumeEntry)
                RemoveVolume(VolumeEntry);
        }
 
        /* Delete it */
        RtlFreeHeap(RtlGetProcessHeap(), 0, PartEntry);
    }
 
    /* Initialize the disk entry */
    CurrentDisk->ExtendedPartition = NULL;
    CurrentDisk->Dirty = FALSE;
    CurrentDisk->NewDisk = TRUE;
    CurrentDisk->PartitionStyle = PARTITION_STYLE_RAW;
 
    /* Wipe the layout buffer */
    RtlFreeHeap(RtlGetProcessHeap(), 0, CurrentDisk->LayoutBuffer);
 
    LayoutBufferSize = sizeof(DRIVE_LAYOUT_INFORMATION_EX) +
                       ((4 - ANYSIZE_ARRAY) * sizeof(PARTITION_INFORMATION_EX));
    CurrentDisk->LayoutBuffer = RtlAllocateHeap(RtlGetProcessHeap(),
                                                HEAP_ZERO_MEMORY,
                                                LayoutBufferSize);
    if (CurrentDisk->LayoutBuffer == NULL)
    {
        DPRINT1("Failed to allocate the disk layout buffer!\n");
        return EXIT_SUCCESS;
    }
 
    CurrentDisk->LayoutBuffer->PartitionStyle = PARTITION_STYLE_RAW;
 
    /* Allocate a 1MB sectors buffer */
    SectorsBuffer = RtlAllocateHeap(RtlGetProcessHeap(),
                                    HEAP_ZERO_MEMORY,
                                    1024 * 1024);
    if (SectorsBuffer == NULL)
    {
        DPRINT1("Failed to allocate the sectors buffer!\n");
        goto done;
    }
 
    /* Open the disk for writing */
    StringCchPrintfW(Buffer, ARRAYSIZE(Buffer),
                     L"\\Device\\Harddisk%d\\Partition0",
                     CurrentDisk->DiskNumber);
 
    RtlInitUnicodeString(&Name, Buffer);
 
    InitializeObjectAttributes(&ObjectAttributes,
                               &Name,
                               OBJ_CASE_INSENSITIVE,
                               NULL,
                               NULL);
 
    Status = NtOpenFile(&FileHandle,
                        GENERIC_READ | GENERIC_WRITE | SYNCHRONIZE,
                        &ObjectAttributes,
                        &IoStatusBlock,
                        0,
                        FILE_SYNCHRONOUS_IO_NONALERT);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Failed to open the disk! (Status 0x%08lx)\n", Status);
        ConResPuts(StdOut, IDS_CLEAN_FAIL);
        goto done;
    }
 
    /* Clean sectors */
    if (bAll)
    {
        MaxCount.QuadPart = (CurrentDisk->SectorCount.QuadPart * CurrentDisk->BytesPerSector) / (1024 * 1024);
        for (Count.QuadPart = 0; Count.QuadPart < MaxCount.QuadPart; Count.QuadPart++)
        {
            Offset.QuadPart = Count.QuadPart * (1024 * 1024);
            Status = NtWriteFile(FileHandle,
                                 NULL,
                                 NULL,
                                 NULL,
                                 &IoStatusBlock,
                                 SectorsBuffer,
                                 1024 * 1024,
                                 &Offset,
                                 NULL);
            if (!NT_SUCCESS(Status))
            {
                DPRINT1("Failed to write MB! (Status 0x%08lx)\n", Status);
                ConResPuts(StdOut, IDS_CLEAN_FAIL);
                goto done;
            }
        }
 
        Size = (ULONG)(CurrentDisk->SectorCount.QuadPart * CurrentDisk->BytesPerSector) % (1024 * 1024);
        if (Size != 0)
        {
            Offset.QuadPart += (1024 * 1024);
            Status = NtWriteFile(FileHandle,
                                 NULL,
                                 NULL,
                                 NULL,
                                 &IoStatusBlock,
                                 SectorsBuffer,
                                 Size,
                                 &Offset,
                                 NULL);
            if (!NT_SUCCESS(Status))
            {
                DPRINT1("Failed to write the last part! (Status 0x%08lx)\n", Status);
                ConResPuts(StdOut, IDS_CLEAN_FAIL);
                goto done;
            }
        }
    }
    else
    {
        /* Clean the first MB */
        Offset.QuadPart = 0;
        Status = NtWriteFile(FileHandle,
                             NULL,
                             NULL,
                             NULL,
                             &IoStatusBlock,
                             SectorsBuffer,
                             1024 * 1024,
                             &Offset,
                             NULL);
        if (!NT_SUCCESS(Status))
        {
            DPRINT1("Failed to write the first MB! (Status 0x%08lx)\n", Status);
            ConResPuts(StdOut, IDS_CLEAN_FAIL);
            goto done;
        }
 
        /* Clean the last MB */
        Offset.QuadPart = (CurrentDisk->SectorCount.QuadPart * CurrentDisk->BytesPerSector) - (1024 * 1024);
        Status = NtWriteFile(FileHandle,
                             NULL,
                             NULL,
                             NULL,
                             &IoStatusBlock,
                             SectorsBuffer,
                             1024 * 1024,
                             &Offset,
                             NULL);
        if (!NT_SUCCESS(Status))
        {
            DPRINT1("Failed to write the last MB! (Status 0x%08lx)\n", Status);
            ConResPuts(StdOut, IDS_CLEAN_FAIL);
            goto done;
        }
    }
 
    ConResPuts(StdOut, IDS_CLEAN_SUCCESS);
 
done:
    if (FileHandle != NULL)
        NtClose(FileHandle);
 
    if (SectorsBuffer != NULL)
        RtlFreeHeap(RtlGetProcessHeap(), 0, SectorsBuffer);
 
    return EXIT_SUCCESS;
}

compact_main()

EXIT_CODE compact_main	(	_In_ INT	argc,
		_In_ PWSTR *	argv
	)

Definition at line 12 of file compact.c.

{
    return EXIT_SUCCESS;
}

ConvertGPT()

EXIT_CODE ConvertGPT	(	_In_ INT	argc,
		_In_ PWSTR *	argv
	)

Definition at line 88 of file convert.c.

{
    CREATE_DISK DiskInfo;
    NTSTATUS Status;
 
    DPRINT("ConvertGPT()\n");
 
    if (CurrentDisk == NULL)
    {
        ConResPuts(StdOut, IDS_SELECT_NO_DISK);
        return EXIT_SUCCESS;
    }
 
    if (CurrentDisk->PartitionStyle == PARTITION_STYLE_GPT)
    {
        ConResPuts(StdOut, IDS_CONVERT_GPT_ALREADY);
        return EXIT_SUCCESS;
    }
 
    if (GetPrimaryPartitionCount(CurrentDisk) != 0)
    {
        ConResPuts(StdOut, IDS_CONVERT_GPT_NOT_EMPTY);
        return EXIT_SUCCESS;
    }
 
#if 0
    /* Fail if disk size is less than 128MB */
    if (CurrentDisk->SectorCount.QuadPart * CurrentDisk->BytesPerSector < 128ULL * 1024ULL * 1024ULL)
    {
        ConResPuts(StdOut, IDS_CONVERT_GPT_TOO_SMALL);
        return EXIT_SUCCESS;
    }
#endif
 
    DiskInfo.PartitionStyle = PARTITION_STYLE_GPT;
    CreateGUID(&DiskInfo.Gpt.DiskId);
    DiskInfo.Gpt.MaxPartitionCount = 128;
 
    Status = CreateDisk(CurrentDisk->DiskNumber, &DiskInfo);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("CreateDisk() failed!\n");
        return EXIT_SUCCESS;
    }
 
    CurrentDisk->StartSector.QuadPart = AlignDown(CurrentDisk->LayoutBuffer->Gpt.StartingUsableOffset.QuadPart / CurrentDisk->BytesPerSector,
                                                  CurrentDisk->SectorAlignment) + (ULONGLONG)CurrentDisk->SectorAlignment;
    CurrentDisk->EndSector.QuadPart = AlignDown(CurrentDisk->StartSector.QuadPart + (CurrentDisk->LayoutBuffer->Gpt.UsableLength.QuadPart / CurrentDisk->BytesPerSector) - 1,
                                                CurrentDisk->SectorAlignment);
 
    ScanForUnpartitionedGptDiskSpace(CurrentDisk);
    ConResPuts(StdOut, IDS_CONVERT_GPT_SUCCESS);
 
    return EXIT_SUCCESS;
}

ConvertMBR()

EXIT_CODE ConvertMBR	(	_In_ INT	argc,
		_In_ PWSTR *	argv
	)

Definition at line 148 of file convert.c.

{
    CREATE_DISK DiskInfo;
    NTSTATUS Status;
 
    DPRINT("ConvertMBR()\n");
 
    if (CurrentDisk == NULL)
    {
        ConResPuts(StdOut, IDS_SELECT_NO_DISK);
        return EXIT_SUCCESS;
    }
 
    if ((CurrentDisk->PartitionStyle == PARTITION_STYLE_MBR) ||
        (CurrentDisk->PartitionStyle == PARTITION_STYLE_RAW))
    {
        ConResPuts(StdOut, IDS_CONVERT_MBR_ALREADY);
        return EXIT_SUCCESS;
    }
 
    if (GetPrimaryPartitionCount(CurrentDisk) != 0)
    {
        ConResPuts(StdOut, IDS_CONVERT_MBR_NOT_EMPTY);
        return EXIT_SUCCESS;
    }
 
    DiskInfo.PartitionStyle = PARTITION_STYLE_MBR;
    CreateSignature(&DiskInfo.Mbr.Signature);
 
    Status = CreateDisk(CurrentDisk->DiskNumber, &DiskInfo);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("CreateDisk() failed!\n");
        return EXIT_SUCCESS;
    }
 
    CurrentDisk->StartSector.QuadPart = (ULONGLONG)CurrentDisk->SectorAlignment;
    CurrentDisk->EndSector.QuadPart = min(CurrentDisk->SectorCount.QuadPart, 0x100000000) - 1;
 
    ScanForUnpartitionedMbrDiskSpace(CurrentDisk);
    ConResPuts(StdOut, IDS_CONVERT_MBR_SUCCESS);
 
    return EXIT_SUCCESS;
}

CreateDisk()

NTSTATUS CreateDisk	(	_In_ ULONG	DiskNumber,
		_In_ PCREATE_DISK	DiskInfo
	)

Definition at line 15 of file convert.c.

{
    WCHAR DstPath[MAX_PATH];
    OBJECT_ATTRIBUTES ObjectAttributes;
    UNICODE_STRING Name;
    HANDLE FileHandle = NULL;
    IO_STATUS_BLOCK Iosb;
    NTSTATUS Status;
 
    DPRINT("CreateDisk(%lu %p)\n", DiskNumber, DiskInfo);
 
    StringCchPrintfW(DstPath, ARRAYSIZE(DstPath),
                     L"\\Device\\Harddisk%lu\\Partition0",
                     CurrentDisk->DiskNumber);
    RtlInitUnicodeString(&Name, DstPath);
 
    InitializeObjectAttributes(&ObjectAttributes,
                               &Name,
                               OBJ_CASE_INSENSITIVE,
                               NULL,
                               NULL);
 
    Status = NtOpenFile(&FileHandle,
                        GENERIC_READ | GENERIC_WRITE | SYNCHRONIZE,
                        &ObjectAttributes,
                        &Iosb,
                        0,
                        FILE_SYNCHRONOUS_IO_NONALERT);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("NtOpenFile() failed (Status %lx)\n", Status);
        goto done;
    }
 
    Status = NtDeviceIoControlFile(FileHandle,
                                   NULL,
                                   NULL,
                                   NULL,
                                   &Iosb,
                                   IOCTL_DISK_CREATE_DISK,
                                   DiskInfo,
                                   sizeof(*DiskInfo),
                                   NULL,
                                   0);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("NtDeviceIoControlFile() failed (Status %lx)\n", Status);
        goto done;
    }
 
    /* Free the layout buffer */
    if (CurrentDisk->LayoutBuffer)
        RtlFreeHeap(RtlGetProcessHeap(), 0, CurrentDisk->LayoutBuffer);
 
    CurrentDisk->LayoutBuffer = NULL;
    CurrentDisk->ExtendedPartition = NULL;
    CurrentDisk->Dirty = FALSE;
    CurrentDisk->NewDisk = TRUE;
    CurrentDisk->PartitionStyle = DiskInfo->PartitionStyle;
 
    ReadLayoutBuffer(FileHandle, CurrentDisk);
 
done:
    if (FileHandle)
        NtClose(FileHandle);
 
    return Status;
}

Referenced by ConvertGPT(), ConvertMBR(), CreateExtendedPartition(), and CreatePrimaryPartition().

CreateEfiPartition()

EXIT_CODE CreateEfiPartition	(	_In_ INT	argc,
		_In_ PWSTR *	argv
	)

Definition at line 16 of file create.c.

{
    PPARTENTRY PartEntry, NewPartEntry;
    PLIST_ENTRY ListEntry;
    ULONGLONG ullSize = 0ULL;
    ULONGLONG ullSectorCount;
#if 0
    ULONGLONG ullOffset = 0ULL;
    BOOL bNoErr = FALSE;
#endif
    INT i;
    PWSTR pszSuffix = NULL;
    NTSTATUS Status;
 
    DPRINT1("CreateEfiPartition()\n");
 
    if (CurrentDisk == NULL)
    {
        ConResPuts(StdOut, IDS_SELECT_NO_DISK);
        return EXIT_SUCCESS;
    }
 
    if (CurrentDisk->PartitionStyle != PARTITION_STYLE_GPT)
    {
        ConResPuts(StdOut, IDS_CREATE_PARTITION_INVALID_STYLE);
        return EXIT_SUCCESS;
    }
 
    for (i = 3; i < argc; i++)
    {
        if (_wcsicmp(argv[i], L"noerr") == 0)
        {
            /* noerr */
            DPRINT("NoErr\n", pszSuffix);
            ConPuts(StdOut, L"The NOERR option is not supported yet!\n");
#if 0
            bNoErr = TRUE;
#endif
        }
    }
 
    for (i = 3; i < argc; i++)
    {
        if (HasPrefix(argv[i], L"size=", &pszSuffix))
        {
            /* size=<N> (MB) */
            DPRINT("Size : %s\n", pszSuffix);
 
            ullSize = _wcstoui64(pszSuffix, NULL, 10);
            if ((ullSize == 0) && (errno == ERANGE))
            {
                ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
                return EXIT_SUCCESS;
            }
        }
        else if (HasPrefix(argv[i], L"offset=", &pszSuffix))
        {
            /* offset=<N> (KB) */
            DPRINT("Offset : %s\n", pszSuffix);
            ConPuts(StdOut, L"The OFFSET option is not supported yet!\n");
#if 0
            ullOffset = _wcstoui64(pszSuffix, NULL, 10);
            if ((ullOffset == 0) && (errno == ERANGE))
            {
                ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
                return TRUE;
            }
#endif
        }
        else if (_wcsicmp(argv[i], L"noerr") == 0)
        {
            /* noerr - Already handled above */
        }
        else
        {
            ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
            return EXIT_SUCCESS;
        }
    }
 
    DPRINT1("Size: %I64u\n", ullSize);
#if 0
    DPRINT1("Offset: %I64u\n", ullOffset);
#endif
 
    /* Size */
    if (ullSize != 0)
        ullSectorCount = (ullSize * 1024 * 1024) / CurrentDisk->BytesPerSector;
    else
        ullSectorCount = 0;
 
    DPRINT1("SectorCount: %I64u\n", ullSectorCount);
 
#ifdef DUMP_PARTITION_LIST
    DumpPartitionList(CurrentDisk);
#endif
 
    for (ListEntry = CurrentDisk->PrimaryPartListHead.Flink;
         ListEntry != &CurrentDisk->PrimaryPartListHead;
         ListEntry = ListEntry->Flink)
    {
        PartEntry = CONTAINING_RECORD(ListEntry, PARTENTRY, ListEntry);
        if (PartEntry->IsPartitioned)
            continue;
 
        if (ullSectorCount == 0)
        {
            DPRINT("Claim whole unused space!\n");
            PartEntry->IsPartitioned = TRUE;
            PartEntry->New = TRUE;
            CopyMemory(&PartEntry->Gpt.PartitionType, &PARTITION_SYSTEM_GUID, sizeof(GUID));
            CreateGUID(&PartEntry->Gpt.PartitionId);
            PartEntry->Gpt.Attributes = 0ULL;
            PartEntry->PartitionNumber = 0;
            PartEntry->FormatState = Unformatted;
            PartEntry->FileSystemName[0] = L'\0';
 
            CurrentPartition = PartEntry;
            CurrentDisk->Dirty = TRUE;
            break;
        }
        else
        {
            if (ullSectorCount == PartEntry->SectorCount.QuadPart)
            {
                DPRINT("Claim matching unused space!\n");
                PartEntry->IsPartitioned = TRUE;
                PartEntry->New = TRUE;
                CopyMemory(&PartEntry->Gpt.PartitionType, &PARTITION_SYSTEM_GUID, sizeof(GUID));
                CreateGUID(&PartEntry->Gpt.PartitionId);
                PartEntry->Gpt.Attributes = 0ULL;
                PartEntry->PartitionNumber = 0;
                PartEntry->FormatState = Unformatted;
                PartEntry->FileSystemName[0] = L'\0';
 
                CurrentPartition = PartEntry;
                CurrentDisk->Dirty = TRUE;
                break;
            }
            else if (ullSectorCount < PartEntry->SectorCount.QuadPart)
            {
                DPRINT("Claim part of unused space\n");
                NewPartEntry = RtlAllocateHeap(RtlGetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(PPARTENTRY));
                if (NewPartEntry == NULL)
                {
                    ConPuts(StdOut, L"Memory allocation failed!\n");
                    return TRUE;
                }
 
                NewPartEntry->DiskEntry = PartEntry->DiskEntry;
 
                NewPartEntry->StartSector.QuadPart = PartEntry->StartSector.QuadPart;
                NewPartEntry->SectorCount.QuadPart = ullSectorCount;
 
                NewPartEntry->LogicalPartition = FALSE;
                NewPartEntry->IsPartitioned = TRUE;
                NewPartEntry->New = TRUE;
                CopyMemory(&NewPartEntry->Gpt.PartitionType, &PARTITION_SYSTEM_GUID, sizeof(GUID));
                CreateGUID(&NewPartEntry->Gpt.PartitionId);
                NewPartEntry->Gpt.Attributes = 0ULL;
                NewPartEntry->PartitionNumber = 0;
                NewPartEntry->FormatState = Unformatted;
                NewPartEntry->FileSystemName[0] = L'\0';
 
                PartEntry->StartSector.QuadPart += ullSectorCount;
                PartEntry->SectorCount.QuadPart -= ullSectorCount;
 
                InsertTailList(ListEntry, &NewPartEntry->ListEntry);
 
                CurrentPartition = NewPartEntry;
                CurrentDisk->Dirty = TRUE;
                break;
            }
        }
    }
 
#ifdef DUMP_PARTITION_LIST
    DumpPartitionList(CurrentDisk);
#endif
 
    UpdateGptDiskLayout(CurrentDisk, FALSE);
    Status = WriteGptPartitions(CurrentDisk);
    if (!NT_SUCCESS(Status))
    {
        ConResPuts(StdOut, IDS_CREATE_PARTITION_FAIL);
        CurrentPartition = NULL;
        return EXIT_SUCCESS;
    }
 
    ConResPuts(StdOut, IDS_CREATE_PARTITION_SUCCESS);
 
    return EXIT_SUCCESS;
}

CreateExtendedPartition()

EXIT_CODE CreateExtendedPartition	(	_In_ INT	argc,
		_In_ PWSTR *	argv
	)

Definition at line 214 of file create.c.

{
    PPARTENTRY PartEntry, NewPartEntry;
    PLIST_ENTRY ListEntry;
    ULONGLONG ullSize = 0ULL;
    ULONGLONG ullSectorCount;
#if 0
    ULONGLONG ullOffset = 0ULL;
    BOOL bNoErr = FALSE;
#endif
    INT i;
    PWSTR pszSuffix = NULL;
    NTSTATUS Status;
 
    if (CurrentDisk == NULL)
    {
        ConResPuts(StdOut, IDS_SELECT_NO_DISK);
        return EXIT_SUCCESS;
    }
 
    if (CurrentDisk->PartitionStyle == PARTITION_STYLE_GPT)
    {
        ConResPuts(StdOut, IDS_CREATE_PARTITION_INVALID_STYLE);
        return EXIT_SUCCESS;
    }
    else if (CurrentDisk->PartitionStyle == PARTITION_STYLE_RAW)
    {
        CREATE_DISK DiskInfo;
        NTSTATUS Status;
 
        DiskInfo.PartitionStyle = PARTITION_STYLE_MBR;
        CreateSignature(&DiskInfo.Mbr.Signature);
 
        Status = CreateDisk(CurrentDisk->DiskNumber, &DiskInfo);
        if (!NT_SUCCESS(Status))
        {
            DPRINT1("CreateDisk() failed!\n");
            return EXIT_SUCCESS;
        }
 
        CurrentDisk->StartSector.QuadPart = (ULONGLONG)CurrentDisk->SectorAlignment;
        CurrentDisk->EndSector.QuadPart = min(CurrentDisk->SectorCount.QuadPart, 0x100000000) - 1;
 
        ScanForUnpartitionedMbrDiskSpace(CurrentDisk);
    }
 
    for (i = 3; i < argc; i++)
    {
        if (_wcsicmp(argv[i], L"noerr") == 0)
        {
            /* noerr */
            DPRINT("NoErr\n", pszSuffix);
            ConPuts(StdOut, L"The NOERR option is not supported yet!\n");
#if 0
            bNoErr = TRUE;
#endif
        }
    }
 
    for (i = 3; i < argc; i++)
    {
        if (HasPrefix(argv[i], L"size=", &pszSuffix))
        {
            /* size=<N> (MB) */
            DPRINT("Size : %s\n", pszSuffix);
 
            ullSize = _wcstoui64(pszSuffix, NULL, 10);
            if ((ullSize == 0) && (errno == ERANGE))
            {
                ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
                return EXIT_SUCCESS;
            }
        }
        else if (HasPrefix(argv[i], L"offset=", &pszSuffix))
        {
            /* offset=<N> (KB) */
            DPRINT("Offset : %s\n", pszSuffix);
            ConPuts(StdOut, L"The OFFSET option is not supported yet!\n");
#if 0
            ullOffset = _wcstoui64(pszSuffix, NULL, 10);
            if ((ullOffset == 0) && (errno == ERANGE))
            {
                ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
                return EXIT_SUCCESS;
            }
#endif
        }
        else if (HasPrefix(argv[i], L"align=", &pszSuffix))
        {
            /* align=<N> */
            DPRINT("Align : %s\n", pszSuffix);
            ConPuts(StdOut, L"The ALIGN option is not supported yet!\n");
#if 0
            bAlign = TRUE;
#endif
        }
        else if (_wcsicmp(argv[i], L"noerr") == 0)
        {
            /* noerr - Already handled above */
        }
        else
        {
            ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
            return EXIT_SUCCESS;
        }
    }
 
    DPRINT1("Size: %I64u\n", ullSize);
#if 0
    DPRINT1("Offset: %I64u\n", ullOffset);
#endif
 
    if (GetPrimaryPartitionCount(CurrentDisk) >= 4)
    {
        ConPuts(StdOut, L"No space left for an extended partition!\n");
        return EXIT_SUCCESS;
    }
 
    if (CurrentDisk->ExtendedPartition != NULL)
    {
        ConPuts(StdOut, L"We already have an extended partition on this disk!\n");
        return EXIT_SUCCESS;
    }
 
    if (ullSize != 0)
        ullSectorCount = (ullSize * 1024 * 1024) / CurrentDisk->BytesPerSector;
    else
        ullSectorCount = 0;
 
    DPRINT1("SectorCount: %I64u\n", ullSectorCount);
 
    ListEntry = CurrentDisk->PrimaryPartListHead.Blink;
 
    PartEntry = CONTAINING_RECORD(ListEntry, PARTENTRY, ListEntry);
    if (PartEntry->IsPartitioned)
    {
        ConPuts(StdOut, L"No disk space left for an extended partition!\n");
        return EXIT_SUCCESS;
    }
 
    if (ullSectorCount == 0)
    {
        PartEntry->IsPartitioned = TRUE;
        PartEntry->New = TRUE;
        PartEntry->Mbr.PartitionType = PARTITION_EXTENDED;
        PartEntry->FormatState = Unformatted;
        PartEntry->FileSystemName[0] = L'\0';
 
        CurrentPartition = PartEntry;
        CurrentDisk->Dirty = TRUE;
    }
    else
    {
        if (PartEntry->SectorCount.QuadPart == ullSectorCount)
        {
            PartEntry->IsPartitioned = TRUE;
            PartEntry->New = TRUE;
            PartEntry->Mbr.PartitionType = PARTITION_EXTENDED;
            PartEntry->FormatState = Unformatted;
            PartEntry->FileSystemName[0] = L'\0';
 
            CurrentPartition = PartEntry;
            CurrentDisk->Dirty = TRUE;
        }
        else if (PartEntry->SectorCount.QuadPart > ullSectorCount)
        {
            NewPartEntry = RtlAllocateHeap(RtlGetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(PPARTENTRY));
            if (NewPartEntry == NULL)
            {
                ConPuts(StdOut, L"Memory allocation failed!\n");
                return TRUE;
            }
 
            NewPartEntry->DiskEntry = PartEntry->DiskEntry;
 
            NewPartEntry->StartSector.QuadPart = PartEntry->StartSector.QuadPart;
            NewPartEntry->SectorCount.QuadPart = ullSectorCount;
 
            NewPartEntry->LogicalPartition = FALSE;
            NewPartEntry->IsPartitioned = TRUE;
            NewPartEntry->New = TRUE;
            NewPartEntry->Mbr.PartitionType = PARTITION_EXTENDED;
            NewPartEntry->FormatState = Unformatted;
            NewPartEntry->FileSystemName[0] = L'\0';
 
            PartEntry->StartSector.QuadPart += ullSectorCount;
            PartEntry->SectorCount.QuadPart -= ullSectorCount;
 
            InsertTailList(ListEntry, &NewPartEntry->ListEntry);
 
            CurrentPartition = NewPartEntry;
            CurrentDisk->Dirty = TRUE;
        }
    }
 
    UpdateMbrDiskLayout(CurrentDisk);
    Status = WriteMbrPartitions(CurrentDisk);
    if (!NT_SUCCESS(Status))
    {
        ConResPuts(StdOut, IDS_CREATE_PARTITION_FAIL);
        CurrentPartition = NULL;
        return EXIT_SUCCESS;
    }
 
    ConResPuts(StdOut, IDS_CREATE_PARTITION_SUCCESS);
 
    return EXIT_SUCCESS;
}

CreateGUID()

VOID CreateGUID

(

_Out_ GUID *

pGuid

)

Definition at line 152 of file misc.c.

{
    RtlGenRandom(pGuid, sizeof(*pGuid));
    /* Clear the version bits and set the version (4) */
    pGuid->Data3 &= 0x0fff;
    pGuid->Data3 |= (4 << 12);
    /* Set the topmost bits of Data4 (clock_seq_hi_and_reserved) as
     * specified in RFC 4122, section 4.4.
     */
    pGuid->Data4[0] &= 0x3f;
    pGuid->Data4[0] |= 0x80;
}

Referenced by ConvertGPT(), CreateEfiPartition(), CreateMsrPartition(), and CreatePrimaryGptPartition().

CreateLogicalPartition()

EXIT_CODE CreateLogicalPartition	(	_In_ INT	argc,
		_In_ PWSTR *	argv
	)

Definition at line 427 of file create.c.

{
    PPARTENTRY PartEntry, NewPartEntry;
    PLIST_ENTRY ListEntry;
    ULONGLONG ullSize = 0ULL;
    ULONGLONG ullSectorCount;
#if 0
    ULONGLONG ullOffset = 0ULL;
    BOOL bNoErr = FALSE;
#endif
    UCHAR PartitionType = PARTITION_HUGE;
    INT i, length;
    PWSTR pszSuffix = NULL;
    NTSTATUS Status;
 
    if (CurrentDisk == NULL)
    {
        ConResPuts(StdOut, IDS_SELECT_NO_DISK);
        return EXIT_SUCCESS;
    }
 
    if (CurrentDisk->PartitionStyle != PARTITION_STYLE_MBR)
    {
        ConResPuts(StdOut, IDS_CREATE_PARTITION_INVALID_STYLE);
        return EXIT_SUCCESS;
    }
 
    for (i = 3; i < argc; i++)
    {
        if (_wcsicmp(argv[i], L"noerr") == 0)
        {
            /* noerr */
            DPRINT("NoErr\n", pszSuffix);
            ConPuts(StdOut, L"The NOERR option is not supported yet!\n");
#if 0
            bNoErr = TRUE;
#endif
        }
    }
 
    for (i = 3; i < argc; i++)
    {
        if (HasPrefix(argv[i], L"size=", &pszSuffix))
        {
            /* size=<N> (MB) */
            DPRINT("Size : %s\n", pszSuffix);
 
            ullSize = _wcstoui64(pszSuffix, NULL, 10);
            if ((ullSize == 0) && (errno == ERANGE))
            {
                ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
                return EXIT_SUCCESS;
            }
        }
        else if (HasPrefix(argv[i], L"offset=", &pszSuffix))
        {
            /* offset=<N> (KB) */
            DPRINT("Offset : %s\n", pszSuffix);
            ConPuts(StdOut, L"The OFFSET option is not supported yet!\n");
#if 0
            ullOffset = _wcstoui64(pszSuffix, NULL, 10);
            if ((ullOffset == 0) && (errno == ERANGE))
            {
                ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
                return EXIT_SUCCESS;
            }
#endif
        }
        else if (HasPrefix(argv[i], L"id=", &pszSuffix))
        {
            /* id=<Byte> */
            DPRINT("Id : %s\n", pszSuffix);
 
            length = wcslen(pszSuffix);
            if ((length == 1) || (length == 2))
            {
                /* Byte */
                PartitionType = (UCHAR)wcstoul(pszSuffix, NULL, 16);
                if ((PartitionType == 0) && (errno == ERANGE))
                {
                    ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
                    return EXIT_SUCCESS;
                }
            }
            else
            {
                ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
                return EXIT_SUCCESS;
            }
        }
        else if (HasPrefix(argv[i], L"align=", &pszSuffix))
        {
            /* align=<N> */
            DPRINT("Align : %s\n", pszSuffix);
            ConPuts(StdOut, L"The ALIGN option is not supported yet!\n");
#if 0
            bAlign = TRUE;
#endif
        }
        else if (_wcsicmp(argv[i], L"noerr") == 0)
        {
            /* noerr - Already handled above */
        }
        else
        {
            ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
            return EXIT_SUCCESS;
        }
    }
 
    DPRINT1("Size: %I64u\n", ullSize);
#if 0
    DPRINT1("Offset: %I64u\n", ullOffset);
#endif
    DPRINT1("Partition Type: %hx\n", PartitionType);
 
    if (ullSize != 0)
        ullSectorCount = (ullSize * 1024 * 1024) / CurrentDisk->BytesPerSector;
    else
        ullSectorCount = 0;
 
    DPRINT1("SectorCount: %I64u\n", ullSectorCount);
 
    for (ListEntry = CurrentDisk->LogicalPartListHead.Flink;
         ListEntry != &CurrentDisk->LogicalPartListHead;
         ListEntry = ListEntry->Flink)
    {
        PartEntry = CONTAINING_RECORD(ListEntry, PARTENTRY, ListEntry);
        if (PartEntry->IsPartitioned)
            continue;
 
        if (ullSectorCount == 0)
        {
            PartEntry->IsPartitioned = TRUE;
            PartEntry->New = TRUE;
            PartEntry->Mbr.PartitionType = PartitionType;
            PartEntry->FormatState = Unformatted;
            PartEntry->FileSystemName[0] = L'\0';
 
            CurrentPartition = PartEntry;
            CurrentDisk->Dirty = TRUE;
            break;
        }
        else
        {
            if (PartEntry->SectorCount.QuadPart == ullSectorCount)
            {
                PartEntry->IsPartitioned = TRUE;
                PartEntry->New = TRUE;
                PartEntry->Mbr.PartitionType = PartitionType;
                PartEntry->FormatState = Unformatted;
                PartEntry->FileSystemName[0] = L'\0';
 
                CurrentPartition = PartEntry;
                CurrentDisk->Dirty = TRUE;
                break;
            }
            else if (PartEntry->SectorCount.QuadPart > ullSectorCount)
            {
                NewPartEntry = RtlAllocateHeap(RtlGetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(PPARTENTRY));
                if (NewPartEntry == NULL)
                {
                    ConPuts(StdOut, L"Memory allocation failed!\n");
                    return TRUE;
                }
 
                NewPartEntry->DiskEntry = PartEntry->DiskEntry;
 
                NewPartEntry->StartSector.QuadPart = PartEntry->StartSector.QuadPart;
                NewPartEntry->SectorCount.QuadPart = ullSectorCount;
 
                NewPartEntry->LogicalPartition = TRUE;
                NewPartEntry->IsPartitioned = TRUE;
                NewPartEntry->New = TRUE;
                NewPartEntry->Mbr.PartitionType = PartitionType;
                NewPartEntry->FormatState = Unformatted;
                NewPartEntry->FileSystemName[0] = L'\0';
 
                PartEntry->StartSector.QuadPart += ullSectorCount;
                PartEntry->SectorCount.QuadPart -= ullSectorCount;
 
                InsertTailList(ListEntry, &NewPartEntry->ListEntry);
 
                CurrentPartition = NewPartEntry;
                CurrentDisk->Dirty = TRUE;
                break;
            }
        }
    }
 
    UpdateMbrDiskLayout(CurrentDisk);
    Status = WriteMbrPartitions(CurrentDisk);
    if (!NT_SUCCESS(Status))
    {
        ConResPuts(StdOut, IDS_CREATE_PARTITION_FAIL);
        CurrentPartition = NULL;
        return EXIT_SUCCESS;
    }
 
    ConResPuts(StdOut, IDS_CREATE_PARTITION_SUCCESS);
 
    return EXIT_SUCCESS;
}

CreateMsrPartition()

EXIT_CODE CreateMsrPartition	(	_In_ INT	argc,
		_In_ PWSTR *	argv
	)

Definition at line 635 of file create.c.

{
    PPARTENTRY PartEntry, NewPartEntry;
    PLIST_ENTRY ListEntry;
    ULONGLONG ullSize = 0ULL;
    ULONGLONG ullSectorCount;
#if 0
    ULONGLONG ullOffset = 0ULL;
    BOOL bNoErr = FALSE;
#endif
    INT i;
    PWSTR pszSuffix = NULL;
    NTSTATUS Status;
 
    DPRINT1("CreateMsrPartition()\n");
 
    if (CurrentDisk == NULL)
    {
        ConResPuts(StdOut, IDS_SELECT_NO_DISK);
        return EXIT_SUCCESS;
    }
 
    if (CurrentDisk->PartitionStyle != PARTITION_STYLE_GPT)
    {
        ConResPuts(StdOut, IDS_CREATE_PARTITION_INVALID_STYLE);
        return EXIT_SUCCESS;
    }
 
    for (i = 3; i < argc; i++)
    {
        if (_wcsicmp(argv[i], L"noerr") == 0)
        {
            /* noerr */
            DPRINT("NoErr\n", pszSuffix);
            ConPuts(StdOut, L"The NOERR option is not supported yet!\n");
#if 0
            bNoErr = TRUE;
#endif
        }
    }
 
    for (i = 3; i < argc; i++)
    {
        if (HasPrefix(argv[i], L"size=", &pszSuffix))
        {
            /* size=<N> (MB) */
            DPRINT("Size : %s\n", pszSuffix);
 
            ullSize = _wcstoui64(pszSuffix, NULL, 10);
            if ((ullSize == 0) && (errno == ERANGE))
            {
                ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
                return EXIT_SUCCESS;
            }
        }
        else if (HasPrefix(argv[i], L"offset=", &pszSuffix))
        {
            /* offset=<N> (KB) */
            DPRINT("Offset : %s\n", pszSuffix);
            ConPuts(StdOut, L"The OFFSET option is not supported yet!\n");
#if 0
            ullOffset = _wcstoui64(pszSuffix, NULL, 10);
            if ((ullOffset == 0) && (errno == ERANGE))
            {
                ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
                return EXIT_SUCCESS;
            }
#endif
        }
        else if (_wcsicmp(argv[i], L"noerr") == 0)
        {
            /* noerr - Already handled above */
        }
        else
        {
            ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
            return EXIT_SUCCESS;
        }
    }
 
    DPRINT1("Size: %I64u\n", ullSize);
#if 0
    DPRINT1("Offset: %I64u\n", ullOffset);
#endif
 
    /* Size */
    if (ullSize != 0)
        ullSectorCount = (ullSize * 1024 * 1024) / CurrentDisk->BytesPerSector;
    else
        ullSectorCount = 0;
 
    DPRINT1("SectorCount: %I64u\n", ullSectorCount);
 
#ifdef DUMP_PARTITION_LIST
    DumpPartitionList(CurrentDisk);
#endif
 
    for (ListEntry = CurrentDisk->PrimaryPartListHead.Flink;
         ListEntry != &CurrentDisk->PrimaryPartListHead;
         ListEntry = ListEntry->Flink)
    {
        PartEntry = CONTAINING_RECORD(ListEntry, PARTENTRY, ListEntry);
        if (PartEntry->IsPartitioned)
            continue;
 
        if (ullSectorCount == 0)
        {
            DPRINT("Claim whole unused space!\n");
            PartEntry->IsPartitioned = TRUE;
            PartEntry->New = TRUE;
            CopyMemory(&PartEntry->Gpt.PartitionType, &PARTITION_MSFT_RESERVED_GUID, sizeof(GUID));
            CreateGUID(&PartEntry->Gpt.PartitionId);
            PartEntry->Gpt.Attributes = 0ULL;
            PartEntry->PartitionNumber = 0;
            PartEntry->FormatState = Unformatted;
            PartEntry->FileSystemName[0] = L'\0';
 
            CurrentPartition = PartEntry;
            CurrentDisk->Dirty = TRUE;
            break;
        }
        else
        {
            if (ullSectorCount == PartEntry->SectorCount.QuadPart)
            {
                DPRINT("Claim matching unused space!\n");
                PartEntry->IsPartitioned = TRUE;
                PartEntry->New = TRUE;
                CopyMemory(&PartEntry->Gpt.PartitionType, &PARTITION_MSFT_RESERVED_GUID, sizeof(GUID));
                CreateGUID(&PartEntry->Gpt.PartitionId);
                PartEntry->Gpt.Attributes = 0ULL;
                PartEntry->PartitionNumber = 0;
                PartEntry->FormatState = Unformatted;
                PartEntry->FileSystemName[0] = L'\0';
 
                CurrentPartition = PartEntry;
                CurrentDisk->Dirty = TRUE;
                break;
            }
            else if (ullSectorCount < PartEntry->SectorCount.QuadPart)
            {
                DPRINT("Claim part of unused space\n");
                NewPartEntry = RtlAllocateHeap(RtlGetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(PPARTENTRY));
                if (NewPartEntry == NULL)
                {
                    ConPuts(StdOut, L"Memory allocation failed!\n");
                    return TRUE;
                }
 
                NewPartEntry->DiskEntry = PartEntry->DiskEntry;
 
                NewPartEntry->StartSector.QuadPart = PartEntry->StartSector.QuadPart;
                NewPartEntry->SectorCount.QuadPart = ullSectorCount;
 
                NewPartEntry->LogicalPartition = FALSE;
                NewPartEntry->IsPartitioned = TRUE;
                NewPartEntry->New = TRUE;
                CopyMemory(&NewPartEntry->Gpt.PartitionType, &PARTITION_MSFT_RESERVED_GUID, sizeof(GUID));
                CreateGUID(&NewPartEntry->Gpt.PartitionId);
                NewPartEntry->Gpt.Attributes = 0ULL;
                NewPartEntry->PartitionNumber = 0;
                NewPartEntry->FormatState = Unformatted;
                NewPartEntry->FileSystemName[0] = L'\0';
 
                PartEntry->StartSector.QuadPart += ullSectorCount;
                PartEntry->SectorCount.QuadPart -= ullSectorCount;
 
                InsertTailList(ListEntry, &NewPartEntry->ListEntry);
 
                CurrentPartition = NewPartEntry;
                CurrentDisk->Dirty = TRUE;
                break;
            }
        }
    }
 
#ifdef DUMP_PARTITION_LIST
    DumpPartitionList(CurrentDisk);
#endif
 
    UpdateGptDiskLayout(CurrentDisk, FALSE);
    Status = WriteGptPartitions(CurrentDisk);
    if (!NT_SUCCESS(Status))
    {
        ConResPuts(StdOut, IDS_CREATE_PARTITION_FAIL);
        CurrentPartition = NULL;
        return EXIT_SUCCESS;
    }
 
    ConResPuts(StdOut, IDS_CREATE_PARTITION_SUCCESS);
 
    return EXIT_SUCCESS;
}

CreatePartitionList()

NTSTATUS CreatePartitionList

(

VOID

)

Definition at line 1988 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)
        return NULL;
 
    List->SystemPartition = NULL;
 
    InitializeListHead(&List->DiskListHead);
    InitializeListHead(&List->BiosDiskListHead);
    InitializeListHead(&List->VolumesList);
 
    /*
     * 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\n", 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()

EXIT_CODE CreatePrimaryPartition	(	_In_ INT	argc,
		_In_ PWSTR *	argv
	)

Definition at line 1094 of file create.c.

{
    ULONGLONG ullSize = 0ULL;
#if 0
    ULONGLONG ullOffset = 0ULL;
    BOOL bNoErr = FALSE;
#endif
    INT i;
    PWSTR pszSuffix = NULL;
    PWSTR pszPartitionType = NULL;
 
    if (CurrentDisk == NULL)
    {
        ConResPuts(StdOut, IDS_SELECT_NO_DISK);
        return EXIT_SUCCESS;
    }
 
    if (CurrentDisk->PartitionStyle == PARTITION_STYLE_RAW)
    {
        CREATE_DISK DiskInfo;
        NTSTATUS Status;
 
        DiskInfo.PartitionStyle = PARTITION_STYLE_MBR;
        CreateSignature(&DiskInfo.Mbr.Signature);
 
        Status = CreateDisk(CurrentDisk->DiskNumber, &DiskInfo);
        if (!NT_SUCCESS(Status))
        {
            DPRINT1("CreateDisk() failed!\n");
            return EXIT_SUCCESS;
        }
 
        CurrentDisk->StartSector.QuadPart = (ULONGLONG)CurrentDisk->SectorAlignment;
        CurrentDisk->EndSector.QuadPart = min(CurrentDisk->SectorCount.QuadPart, 0x100000000) - 1;
 
        ScanForUnpartitionedMbrDiskSpace(CurrentDisk);
    }
 
    for (i = 3; i < argc; i++)
    {
        if (_wcsicmp(argv[i], L"noerr") == 0)
        {
            /* noerr */
            DPRINT("NoErr\n", pszSuffix);
            ConPuts(StdOut, L"The NOERR option is not supported yet!\n");
#if 0
            bNoErr = TRUE;
#endif
        }
    }
 
    for (i = 3; i < argc; i++)
    {
        if (HasPrefix(argv[i], L"size=", &pszSuffix))
        {
            /* size=<N> (MB) */
            DPRINT("Size : %s\n", pszSuffix);
 
            ullSize = _wcstoui64(pszSuffix, NULL, 10);
            if ((ullSize == 0) && (errno == ERANGE))
            {
                ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
                return EXIT_SUCCESS;
            }
        }
        else if (HasPrefix(argv[i], L"offset=", &pszSuffix))
        {
            /* offset=<N> (KB) */
            DPRINT("Offset : %s\n", pszSuffix);
            ConPuts(StdOut, L"The OFFSET option is not supported yet!\n");
#if 0
            ullOffset = _wcstoui64(pszSuffix, NULL, 10);
            if ((ullOffset == 0) && (errno == ERANGE))
            {
                ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
                return EXIT_SUCCESS;
            }
#endif
        }
        else if (HasPrefix(argv[i], L"id=", &pszSuffix))
        {
            /* id=<Byte>|<GUID> */
            DPRINT("Id : %s\n", pszSuffix);
            pszPartitionType = pszSuffix;
        }
        else if (HasPrefix(argv[i], L"align=", &pszSuffix))
        {
            /* align=<N> */
            DPRINT("Align : %s\n", pszSuffix);
            ConPuts(StdOut, L"The ALIGN option is not supported yet!\n");
#if 0
            bAlign = TRUE;
#endif
        }
        else if (_wcsicmp(argv[i], L"noerr") == 0)
        {
            /* noerr - Alread handled above */
        }
        else
        {
            ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
            return EXIT_SUCCESS;
        }
    }
 
    DPRINT("Size: %I64u\n", ullSize);
#if 0
    DPRINT1("Offset: %I64u\n", ullOffset);
#endif
 
    if (CurrentDisk->PartitionStyle == PARTITION_STYLE_MBR)
    {
        DPRINT("Partition Type: %s\n", pszPartitionType);
        CreatePrimaryMbrPartition(ullSize, pszPartitionType);
    }
    else if (CurrentDisk->PartitionStyle == PARTITION_STYLE_GPT)
    {
        CreatePrimaryGptPartition(ullSize, pszPartitionType);
    }
 
    return EXIT_SUCCESS;
}

CreateSignature()

VOID CreateSignature

(

_Out_ PDWORD

pSignature

)

Definition at line 168 of file misc.c.

{
    LARGE_INTEGER SystemTime;
    TIME_FIELDS TimeFields;
    PUCHAR Buffer;
 
    NtQuerySystemTime(&SystemTime);
    RtlTimeToTimeFields(&SystemTime, &TimeFields);
 
    Buffer = (PUCHAR)pSignature;
    Buffer[0] = (UCHAR)(TimeFields.Year & 0xFF) + (UCHAR)(TimeFields.Hour & 0xFF);
    Buffer[1] = (UCHAR)(TimeFields.Year >> 8) + (UCHAR)(TimeFields.Minute & 0xFF);
    Buffer[2] = (UCHAR)(TimeFields.Month & 0xFF) + (UCHAR)(TimeFields.Second & 0xFF);
    Buffer[3] = (UCHAR)(TimeFields.Day & 0xFF) + (UCHAR)(TimeFields.Milliseconds & 0xFF);
}

Referenced by ConvertMBR(), CreateExtendedPartition(), and CreatePrimaryPartition().

CreateVolumeList()

NTSTATUS CreateVolumeList

(

VOID

)

Definition at line 1967 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().

DeleteDisk()

EXIT_CODE DeleteDisk	(	_In_ INT	argc,
		_In_ PWSTR *	argv
	)

Definition at line 28 of file delete.c.

{
    return EXIT_SUCCESS;
}

DeleteDriveLetter()

BOOL DeleteDriveLetter

(

_In_ WCHAR

DriveLetter

)

Definition at line 338 of file mountmgr.c.

{
    PMOUNTMGR_MOUNT_POINT InputBuffer = NULL;
    PMOUNTMGR_MOUNT_POINTS OutputBuffer = NULL;
    WCHAR DosDeviceName[30];
    ULONG InputBufferLength, DosDeviceNameLength;
    HANDLE MountMgrHandle = NULL;
    IO_STATUS_BLOCK Iosb;
    NTSTATUS Status;
    BOOL Ret = TRUE;
 
    DPRINT1("DeleteDriveLetter(%c)\n", DriveLetter);
 
    /* Setup the device name of the letter to delete */
    swprintf(DosDeviceName, L"\\DosDevices\\%c:", DriveLetter);
    DosDeviceNameLength = wcslen(DosDeviceName) * sizeof(WCHAR);
 
    /* Allocate the input buffer for MountMgr */
    InputBufferLength = DosDeviceNameLength + sizeof(MOUNTMGR_MOUNT_POINT);
    InputBuffer = RtlAllocateHeap(RtlGetProcessHeap(), HEAP_ZERO_MEMORY, InputBufferLength);
    if (InputBuffer == NULL)
    {
        DPRINT1("InputBuffer allocation failed!\n");
        return FALSE;
    }
 
    /* Fill it in */
//    RtlZeroMemory(InputBuffer, InputBufferLength);
    InputBuffer->SymbolicLinkNameOffset = sizeof(MOUNTMGR_MOUNT_POINT);
    InputBuffer->SymbolicLinkNameLength = DosDeviceNameLength;
    RtlCopyMemory(&InputBuffer[1], DosDeviceName, DosDeviceNameLength);
 
    /* Allocate big enough output buffer (we don't care about the output) */
    OutputBuffer = RtlAllocateHeap(GetProcessHeap(), HEAP_ZERO_MEMORY, 0x1000);
    if (OutputBuffer == NULL)
    {
        DPRINT1("OutputBuffer allocation failed!\n");
        Ret = FALSE;
        goto done;
    }
 
DPRINT1("\n");
    Status = OpenMountManager(&MountMgrHandle, GENERIC_READ | GENERIC_WRITE);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("OpenMountManager() failed (Status 0x%08lx)\n", Status);
        Ret = FALSE;
        goto done;
    }
 
DPRINT1("\n");
    Status = NtDeviceIoControlFile(MountMgrHandle,
                                   NULL,
                                   NULL,
                                   NULL,
                                   &Iosb,
                                   IOCTL_MOUNTMGR_DELETE_POINTS,
                                   InputBuffer,
                                   InputBufferLength,
                                   OutputBuffer,
                                   0x1000);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("NtDeviceIoControlFile() failed (Status 0x%08lx)\n", Status);
        Ret = FALSE;
        goto done;
    }
 
DPRINT1("\n");
done:
    if (MountMgrHandle)
        NtClose(MountMgrHandle);
 
    if (InputBuffer)
        RtlFreeHeap(RtlGetProcessHeap(), 0, InputBuffer);
 
    if (OutputBuffer)
        RtlFreeHeap(RtlGetProcessHeap(), 0, OutputBuffer);
 
    return Ret;
}

Referenced by assign_main(), and remove_main().

DeletePartition()

EXIT_CODE DeletePartition	(	_In_ INT	argc,
		_In_ PWSTR *	argv
	)

Definition at line 274 of file delete.c.

{
    INT i;
    BOOL bOverride = FALSE;
 
    DPRINT("DeletePartition()\n");
 
    if (CurrentDisk == NULL)
    {
        ConResPuts(StdOut, IDS_SELECT_NO_DISK);
        return EXIT_SUCCESS;
    }
 
    if (CurrentPartition == NULL)
    {
        ConResPuts(StdOut, IDS_SELECT_NO_PARTITION);
        return EXIT_SUCCESS;
    }
 
    for (i = 2; i < argc; i++)
    {
        if (_wcsicmp(argv[i], L"noerr") == 0)
        {
            /* noerr */
            DPRINT("NOERR\n");
            ConPuts(StdOut, L"The NOERR option is not supported yet!\n");
#if 0
            bNoErr = TRUE;
#endif
        }
    }
 
    for (i = 2; i < argc; i++)
    {
        if (_wcsicmp(argv[i], L"noerr") == 0)
        {
            /* noerr - Already handled above */
        }
        else if (_wcsicmp(argv[i], L"override") == 0)
        {
            /* override */
            DPRINT("OVERRIDE\n");
            bOverride = TRUE;
        }
        else
        {
            ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
            return EXIT_SUCCESS;
        }
    }
 
    if (CurrentDisk->PartitionStyle == PARTITION_STYLE_MBR)
    {
        DeleteMbrPartition(bOverride);
    }
    else if (CurrentDisk->PartitionStyle == PARTITION_STYLE_GPT)
    {
        DeleteGptPartition(bOverride);
    }
 
    return EXIT_SUCCESS;
}

DeleteVolume()

EXIT_CODE DeleteVolume	(	_In_ INT	argc,
		_In_ PWSTR *	argv
	)

Definition at line 341 of file delete.c.

{
    return EXIT_SUCCESS;
}

DestroyPartitionList()

VOID DestroyPartitionList

(

VOID

)

Definition at line 1611 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);
 
        if (DiskEntry->Description != NULL)
            RtlFreeHeap(RtlGetProcessHeap(), 0, DiskEntry->Description);
 
        if (DiskEntry->Location != NULL)
            RtlFreeHeap(RtlGetProcessHeap(), 0, DiskEntry->Location);
 
        /* 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 2005 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);
 
        if (VolumeEntry->pExtents)
            RtlFreeHeap(RtlGetProcessHeap(), 0, VolumeEntry->pExtents);
 
        /* Release disk entry */
        RtlFreeHeap(RtlGetProcessHeap(), 0, VolumeEntry);
    }
}

Referenced by rescan_main(), and wmain().

detach_main()

EXIT_CODE detach_main	(	_In_ INT	argc,
		_In_ PWSTR *	argv
	)

Definition at line 12 of file detach.c.

{
    return EXIT_SUCCESS;
}

DetailDisk()

EXIT_CODE DetailDisk	(	INT	argc,
		PWSTR *	argv
	)

DetailPartition()

EXIT_CODE DetailPartition	(	INT	argc,
		PWSTR *	argv
	)

DetailVolume()

EXIT_CODE DetailVolume	(	INT	argc,
		PWSTR *	argv
	)

DismountVolume()

NTSTATUS DismountVolume

(

_In_ PPARTENTRY

PartEntry

)

Definition at line 2687 of file partlist.c.

{
    NTSTATUS Status;
    NTSTATUS LockStatus;
    UNICODE_STRING Name;
    OBJECT_ATTRIBUTES ObjectAttributes;
    IO_STATUS_BLOCK IoStatusBlock;
    HANDLE PartitionHandle;
    WCHAR Buffer[MAX_PATH];
 
    /* Check whether the partition is valid and was mounted by the system */
    if (!PartEntry->IsPartitioned ||
        IsContainerPartition(PartEntry->Mbr.PartitionType)   ||
        !IsRecognizedPartition(PartEntry->Mbr.PartitionType) ||
        PartEntry->FormatState == UnknownFormat ||
        // NOTE: If FormatState == Unformatted but *FileSystem != 0 this means
        // it has been usually mounted with RawFS and thus needs to be dismounted.
/*        !*PartEntry->FileSystem || */
        PartEntry->PartitionNumber == 0)
    {
        /* The partition is not mounted, so just return success */
        return STATUS_SUCCESS;
    }
 
    ASSERT(PartEntry->Mbr.PartitionType != PARTITION_ENTRY_UNUSED);
 
    /* Open the volume */
    StringCchPrintfW(Buffer, ARRAYSIZE(Buffer),
                     L"\\Device\\Harddisk%lu\\Partition%lu",
                     PartEntry->DiskEntry->DiskNumber,
                     PartEntry->PartitionNumber);
    RtlInitUnicodeString(&Name, Buffer);
 
    InitializeObjectAttributes(&ObjectAttributes,
                               &Name,
                               OBJ_CASE_INSENSITIVE,
                               NULL,
                               NULL);
 
    Status = NtOpenFile(&PartitionHandle,
                        GENERIC_READ | GENERIC_WRITE | SYNCHRONIZE,
                        &ObjectAttributes,
                        &IoStatusBlock,
                        FILE_SHARE_READ | FILE_SHARE_WRITE,
                        FILE_SYNCHRONOUS_IO_NONALERT);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("ERROR: Cannot open volume %wZ for dismounting! (Status 0x%lx)\n", &Name, Status);
        return Status;
    }
 
    /* Lock the volume */
    LockStatus = NtFsControlFile(PartitionHandle,
                                 NULL,
                                 NULL,
                                 NULL,
                                 &IoStatusBlock,
                                 FSCTL_LOCK_VOLUME,
                                 NULL,
                                 0,
                                 NULL,
                                 0);
    if (!NT_SUCCESS(LockStatus))
    {
        DPRINT1("WARNING: Failed to lock volume! Operations may fail! (Status 0x%lx)\n", LockStatus);
    }
 
    /* Dismount the volume */
    Status = NtFsControlFile(PartitionHandle,
                             NULL,
                             NULL,
                             NULL,
                             &IoStatusBlock,
                             FSCTL_DISMOUNT_VOLUME,
                             NULL,
                             0,
                             NULL,
                             0);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Failed to unmount volume (Status 0x%lx)\n", Status);
    }
 
    /* Unlock the volume */
    LockStatus = NtFsControlFile(PartitionHandle,
                                 NULL,
                                 NULL,
                                 NULL,
                                 &IoStatusBlock,
                                 FSCTL_UNLOCK_VOLUME,
                                 NULL,
                                 0,
                                 NULL,
                                 0);
    if (!NT_SUCCESS(LockStatus))
    {
        DPRINT1("Failed to unlock volume (Status 0x%lx)\n", LockStatus);
    }
 
    /* Close the volume */
    NtClose(PartitionHandle);
 
    return Status;
}

DumpDisk()

EXIT_CODE DumpDisk	(	_In_ INT	argc,
		_In_ LPWSTR *	argv
	)

DumpPartition()

EXIT_CODE DumpPartition	(	_In_ INT	argc,
		_In_ LPWSTR *	argv
	)

DuplicateQuotedString()

PWSTR DuplicateQuotedString

(

_In_ PWSTR

pszInString

)

Definition at line 84 of file misc.c.

{
    PWSTR pszOutString = NULL;
    PWSTR pStart, pEnd;
    INT nLength;
 
    if ((pszInString == NULL) || (pszInString[0] == UNICODE_NULL))
        return NULL;
 
    if (pszInString[0] == L'"')
    {
        if (pszInString[1] == UNICODE_NULL)
            return NULL;
 
        pStart = &pszInString[1];
        pEnd = wcschr(pStart, '"');
        if (pEnd == NULL)
        {
            nLength = wcslen(pStart);
        }
        else
        {
            nLength = (pEnd - pStart);
        }
    }
    else
    {
        pStart = pszInString;
        nLength = wcslen(pStart);
    }
 
    pszOutString = RtlAllocateHeap(RtlGetProcessHeap(),
                                   HEAP_ZERO_MEMORY,
                                   (nLength + 1) * sizeof(WCHAR));
    if (pszOutString == NULL)
        return NULL;
 
    wcsncpy(pszOutString, pStart, nLength);
 
    return pszOutString;
}

DuplicateString()

PWSTR DuplicateString

(

_In_ PWSTR

pszInString

)

Definition at line 129 of file misc.c.

{
    PWSTR pszOutString = NULL;
    INT nLength;
 
    if ((pszInString == NULL) || (pszInString[0] == UNICODE_NULL))
        return NULL;
 
    nLength = wcslen(pszInString);
    pszOutString = RtlAllocateHeap(RtlGetProcessHeap(),
                                   HEAP_ZERO_MEMORY,
                                   (nLength + 1) * sizeof(WCHAR));
    if (pszOutString == NULL)
        return NULL;
 
    wcscpy(pszOutString, pszInString);
 
    return pszOutString;
}

expand_main()

EXIT_CODE expand_main	(	_In_ INT	argc,
		_In_ PWSTR *	argv
	)

Definition at line 12 of file expand.c.

{
    return EXIT_SUCCESS;
}

extend_main()

EXIT_CODE extend_main	(	_In_ INT	argc,
		_In_ PWSTR *	argv
	)

Definition at line 12 of file extend.c.

{
    return EXIT_SUCCESS;
}

filesystems_main()

EXIT_CODE filesystems_main	(	_In_ INT	argc,
		_In_ PWSTR *	argv
	)

Definition at line 88 of file filesystems.c.

{
    if (CurrentVolume == NULL)
    {
        ConResPuts(StdOut, IDS_SELECT_NO_VOLUME);
        return EXIT_SUCCESS;
    }
 
    ConPuts(StdOut, L"\n");
 
    ShowFileSystemInfo(CurrentVolume);
    ShowInstalledFileSystems(CurrentVolume);
 
    return EXIT_SUCCESS;
}

format_main()

EXIT_CODE format_main	(	_In_ INT	argc,
		_In_ PWSTR *	argv
	)

Definition at line 95 of file format.c.

{
    UNICODE_STRING usDriveRoot;
    UNICODE_STRING LabelString;
    PWSTR pszSuffix = NULL;
    PWSTR pszFileSystem = NULL;
    PWSTR pszLabel = NULL;
    BOOLEAN bQuickFormat = FALSE;
    ULONG ulClusterSize = 0;
    HMODULE hModule = NULL;
    PULIB_FORMAT pFormat = NULL;
//    FMIFS_MEDIA_FLAG MediaType = FMIFS_HARDDISK;
    INT i;
    BOOLEAN Success = FALSE;
 
 
    if (CurrentVolume == NULL)
    {
        ConResPuts(StdOut, IDS_SELECT_NO_VOLUME);
        return EXIT_SUCCESS;
    }
 
    for (i = 1; i < argc; i++)
    {
        if (_wcsicmp(argv[i], L"noerr") == 0)
        {
            /* noerr */
            DPRINT("NoErr\n", pszSuffix);
            ConPuts(StdOut, L"The NOERR option is not supported yet!\n");
#if 0
            bNoErr = TRUE;
#endif
        }
    }
 
    for (i = 1; i < argc; i++)
    {
        ConPrintf(StdOut, L"%s\n", argv[i]);
 
        if (HasPrefix(argv[i], L"fs=", &pszSuffix))
        {
            /* fs=<fs> */
            pszFileSystem = pszSuffix;
        }
        else if (HasPrefix(argv[i], L"revision=", &pszSuffix))
        {
            /* revision=<X.XX> */
            ConPuts(StdOut, L"The REVISION option is not supported yet!\n");
        }
        else if (HasPrefix(argv[i], L"label=", &pszSuffix))
        {
            /* label=<"label"> */
            pszLabel = pszSuffix;
        }
        else if (HasPrefix(argv[i], L"unit=", &pszSuffix))
        {
            /* unit=<N> */
            ulClusterSize = wcstoul(pszSuffix, NULL, 0);
            if ((ulClusterSize == 0) && (errno == ERANGE))
            {
                ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
                goto done;
            }
        }
        else if (_wcsicmp(argv[i], L"recommended") == 0)
        {
            /* recommended */
            ConPuts(StdOut, L"The RECOMMENDED option is not supported yet!\n");
        }
        else if (_wcsicmp(argv[i], L"quick") == 0)
        {
            /* quick */
            bQuickFormat = TRUE;
        }
        else if (_wcsicmp(argv[i], L"compress") == 0)
        {
            /* compress */
            ConPuts(StdOut, L"The COMPRESS option is not supported yet!\n");
        }
        else if (_wcsicmp(argv[i], L"override") == 0)
        {
            /* override */
            ConPuts(StdOut, L"The OVERRIDE option is not supported yet!\n");
        }
        else if (_wcsicmp(argv[i], L"duplicate") == 0)
        {
            /* duplicate */
            ConPuts(StdOut, L"The DUPLICATE option is not supported yet!\n");
        }
        else if (_wcsicmp(argv[i], L"nowait") == 0)
        {
            /* nowait */
            ConPuts(StdOut, L"The NOWAIT option is not supported yet!\n");
        }
        else if (_wcsicmp(argv[i], L"noerr") == 0)
        {
            /* noerr - Already handled above */
        }
        else
        {
            ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
            return EXIT_SUCCESS;
        }
    }
 
    DPRINT("VolumeName    : %S\n", CurrentVolume->VolumeName);
    DPRINT("DeviceName    : %S\n", CurrentVolume->DeviceName);
    DPRINT("DriveLetter   : %C\n", CurrentVolume->DriveLetter);
#if 0
    switch (CurrentVolume->VolumeType)
    {
        case VOLUME_TYPE_CDROM:
            MediaType = FMIFS_REMOVABLE; // ???
            break;
 
        case VOLUME_TYPE_PARTITION:
            MediaType = FMIFS_HARDDISK;
            break;
 
        case VOLUME_TYPE_REMOVABLE:
            MediaType = FMIFS_REMOVABLE; // ???
            break;
 
        case VOLUME_TYPE_UNKNOWN:
        default:
            MediaType = FMIFS_REMOVABLE; // ???
            break;
    }
#endif
 
    DPRINT("FileSystem: %S\n", pszFileSystem);
    DPRINT("Label: %S\n", pszLabel);
    DPRINT("Quick: %d\n", bQuickFormat);
    DPRINT("ClusterSize: %lu\n", ulClusterSize);
 
    RtlDosPathNameToNtPathName_U(CurrentVolume->VolumeName, &usDriveRoot, NULL, NULL);
 
    /* Remove trailing backslash */
    if (usDriveRoot.Buffer[(usDriveRoot.Length / sizeof(WCHAR)) - 1] == L'\\')
    {
        usDriveRoot.Buffer[(usDriveRoot.Length / sizeof(WCHAR)) - 1] = UNICODE_NULL;
        usDriveRoot.Length -= sizeof(WCHAR);
    }
 
    DPRINT("DriveRoot: %wZ\n", &usDriveRoot);
 
    /* Use the FAT filesystem as default */
    if (pszFileSystem == NULL)
        pszFileSystem = L"FAT";
 
    BOOLEAN bBackwardCompatible = FALSE; // Default to latest FS versions.
    if (_wcsicmp(pszFileSystem, L"FAT") == 0)
        bBackwardCompatible = TRUE;
    // else if (wcsicmp(pszFileSystem, L"FAT32") == 0)
        // bBackwardCompatible = FALSE;
 
    if (pszLabel == NULL)
        pszLabel = L"";
 
    RtlInitUnicodeString(&LabelString, pszLabel);
 
    if (!GetFsModule(pszFileSystem, &hModule))
    {
        DPRINT1("GetFsModule() failed\n");
        goto done;
    }
 
    pFormat = (PULIB_FORMAT)GetProcAddress(hModule, "Format");
    if (pFormat)
    {
        Success = (pFormat)(&usDriveRoot,
                            FormatCallback,
                            bQuickFormat,
                            bBackwardCompatible,
                            FMIFS_HARDDISK, //MediaType,
                            &LabelString,
                            ulClusterSize);
    }
 
done:
    ConPuts(StdOut, L"\n");
    if (Success)
        ConResPrintf(StdOut, IDS_FORMAT_SUCCESS);
    else
        ConResPrintf(StdOut, IDS_FORMAT_FAIL);
 
    if (hModule)
        FreeLibrary(hModule);
 
    RtlFreeUnicodeString(&usDriveRoot);
 
    return EXIT_SUCCESS;
}

GetAutomountState()

BOOL GetAutomountState

(

_Out_ PBOOL

State

)

Definition at line 46 of file mountmgr.c.

{
    HANDLE MountMgrHandle;
    MOUNTMGR_QUERY_AUTO_MOUNT AutoMount;
    IO_STATUS_BLOCK Iosb;
    NTSTATUS Status;
 
    DPRINT("ShowAutomountState()\n");
 
    Status = OpenMountManager(&MountMgrHandle, GENERIC_READ);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("OpenMountManager() Status 0x%08lx\n", Status);
        return FALSE;
    }
 
    Status = NtDeviceIoControlFile(MountMgrHandle,
                                   NULL,
                                   NULL,
                                   NULL,
                                   &Iosb,
                                   IOCTL_MOUNTMGR_QUERY_AUTO_MOUNT,
                                   NULL,
                                   0,
                                   &AutoMount,
                                   sizeof(AutoMount));
 
    NtClose(MountMgrHandle);
 
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("NtDeviceIoControlFile() Status 0x%08lx\n", Status);
        return FALSE;
    }
 
    if (State)
        *State = (AutoMount.CurrentState == Enabled);
 
    return TRUE;
}

Referenced by automount_main().

GetNextUnpartitionedEntry()

PPARTENTRY GetNextUnpartitionedEntry

(

_In_ PPARTENTRY

PartEntry

)

Definition at line 2658 of file partlist.c.

{
    PDISKENTRY DiskEntry = PartEntry->DiskEntry;
    PPARTENTRY NextPartEntry;
    PLIST_ENTRY ListHead;
 
    if (PartEntry->LogicalPartition)
        ListHead = &DiskEntry->LogicalPartListHead;
    else
        ListHead = &DiskEntry->PrimaryPartListHead;
 
    if (PartEntry->ListEntry.Flink != ListHead)
    {
        NextPartEntry = CONTAINING_RECORD(PartEntry->ListEntry.Flink,
                                          PARTENTRY,
                                          ListEntry);
        if (!NextPartEntry->IsPartitioned)
        {
            ASSERT(NextPartEntry->Mbr.PartitionType == PARTITION_ENTRY_UNUSED);
            return NextPartEntry;
        }
    }
 
    return NULL;
}

Referenced by DeleteGptPartition(), and DeleteMbrPartition().

GetPrevUnpartitionedEntry()

PPARTENTRY GetPrevUnpartitionedEntry

(

_In_ PPARTENTRY

PartEntry

)

Definition at line 2629 of file partlist.c.

{
    PDISKENTRY DiskEntry = PartEntry->DiskEntry;
    PPARTENTRY PrevPartEntry;
    PLIST_ENTRY ListHead;
 
    if (PartEntry->LogicalPartition)
        ListHead = &DiskEntry->LogicalPartListHead;
    else
        ListHead = &DiskEntry->PrimaryPartListHead;
 
    if (PartEntry->ListEntry.Blink != ListHead)
    {
        PrevPartEntry = CONTAINING_RECORD(PartEntry->ListEntry.Blink,
                                          PARTENTRY,
                                          ListEntry);
        if (!PrevPartEntry->IsPartitioned)
        {
            ASSERT(PrevPartEntry->Mbr.PartitionType == PARTITION_ENTRY_UNUSED);
            return PrevPartEntry;
        }
    }
 
    return NULL;
}

Referenced by DeleteGptPartition(), and DeleteMbrPartition().

GetPrimaryPartitionCount()

ULONG GetPrimaryPartitionCount

(

_In_ PDISKENTRY

DiskEntry

)

Definition at line 2266 of file partlist.c.

{
    PLIST_ENTRY Entry;
    PPARTENTRY PartEntry;
    ULONG Count = 0;
 
    for (Entry = DiskEntry->PrimaryPartListHead.Flink;
         Entry != &DiskEntry->PrimaryPartListHead;
         Entry = Entry->Flink)
    {
        PartEntry = CONTAINING_RECORD(Entry, PARTENTRY, ListEntry);
        if (PartEntry->IsPartitioned)
            Count++;
    }
 
    return Count;
}

GetVolumeFromPartition()

PVOLENTRY GetVolumeFromPartition

(

_In_ PPARTENTRY

PartEntry

)

Definition at line 2795 of file partlist.c.

{
    PLIST_ENTRY Entry;
    PVOLENTRY VolumeEntry;
    ULONG i;
 
    if ((PartEntry == NULL) ||
        (PartEntry->DiskEntry == NULL))
        return NULL;
 
    Entry = VolumeListHead.Flink;
    while (Entry != &VolumeListHead)
    {
        VolumeEntry = CONTAINING_RECORD(Entry, VOLENTRY, ListEntry);
 
        if (VolumeEntry->pExtents == NULL)
            return NULL;
 
        for (i = 0; i < VolumeEntry->pExtents->NumberOfDiskExtents; i++)
        {
            if (VolumeEntry->pExtents->Extents[i].DiskNumber == PartEntry->DiskEntry->DiskNumber)
            {
                if ((VolumeEntry->pExtents->Extents[i].StartingOffset.QuadPart == PartEntry->StartSector.QuadPart * PartEntry->DiskEntry->BytesPerSector) &&
                    (VolumeEntry->pExtents->Extents[i].ExtentLength.QuadPart == PartEntry->SectorCount.QuadPart * PartEntry->DiskEntry->BytesPerSector))
                    return VolumeEntry;
            }
        }
 
        Entry = Entry->Flink;
    }
 
    return NULL;
}

Referenced by clean_main().

gpt_main()

EXIT_CODE gpt_main	(	_In_ INT	argc,
		_In_ PWSTR *	argv
	)

Definition at line 16 of file gpt.c.

{
    ULONGLONG ullAttributes = 0ULL;
    PWSTR pszSuffix = NULL;
    INT i;
    NTSTATUS Status;
 
    if (CurrentDisk == NULL)
    {
        ConResPuts(StdOut, IDS_SELECT_NO_DISK);
        return EXIT_SUCCESS;
    }
 
    if (CurrentPartition == NULL)
    {
        ConResPuts(StdOut, IDS_SELECT_NO_PARTITION);
        return EXIT_SUCCESS;
    }
 
    if (CurrentDisk->PartitionStyle != PARTITION_STYLE_GPT)
    {
        ConResPuts(StdOut, IDS_CREATE_PARTITION_INVALID_STYLE);
        return EXIT_SUCCESS;
    }
 
    for (i = 1; i < argc; i++)
    {
        if (HasPrefix(argv[i], L"attributes=", &pszSuffix))
        {
            /* attributes=<N> */
            DPRINT("Attributes: %s\n", pszSuffix);
 
            ullAttributes = _wcstoui64(pszSuffix, NULL, 0);
            if ((ullAttributes == 0) && (errno == ERANGE))
            {
                ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
                return EXIT_SUCCESS;
            }
        }
       else
        {
            ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
            return EXIT_SUCCESS;
        }
    }
 
    DPRINT("Attributes: 0x%I64x\n", ullAttributes);
    CurrentPartition->Gpt.Attributes = ullAttributes;
    CurrentDisk->Dirty = TRUE;
 
    UpdateGptDiskLayout(CurrentDisk, FALSE);
    Status = WriteGptPartitions(CurrentDisk);
    if (!NT_SUCCESS(Status))
    {
        ConResPuts(StdOut, IDS_GPT_FAIL);
        return EXIT_SUCCESS;
    }
 
    ConResPuts(StdOut, IDS_GPT_SUCCESS);
 
    return EXIT_SUCCESS;
}

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(), assign_main(), CreateEfiPartition(), CreateExtendedPartition(), CreateLogicalPartition(), CreateMsrPartition(), CreatePrimaryPartition(), format_main(), gpt_main(), remove_main(), setid_main(), and UniqueIdDisk().

help_main()

EXIT_CODE help_main	(	_In_ INT	argc,
		_In_ PWSTR *	argv
	)

Definition at line 121 of file help.c.

{
    PCOMMAND cmdptr;
    PCOMMAND cmdptr1 = NULL;
    PCOMMAND cmdptr2 = NULL;
    PCOMMAND cmdptr3 = NULL;
 
    if (argc == 1)
    {
        HelpCommandList();
        return EXIT_SUCCESS;
    }
 
    /* Scan internal command table */
    for (cmdptr = cmds; cmdptr->cmd1; cmdptr++)
    {
        if ((cmdptr1 == NULL) &&
            (cmdptr->cmd1 != NULL && _wcsicmp(argv[1], cmdptr->cmd1) == 0))
        {
            cmdptr1 = cmdptr;
        }
 
        if ((cmdptr2 == NULL) &&
            (argc >= 3) &&
            (cmdptr->cmd1 != NULL && _wcsicmp(argv[1], cmdptr->cmd1) == 0) &&
            (cmdptr->cmd2 != NULL && _wcsicmp(argv[2], cmdptr->cmd2) == 0))
        {
            cmdptr2 = cmdptr;
        }
 
        if ((cmdptr3 == NULL) &&
            (argc >= 4) &&
            (cmdptr->cmd1 != NULL && _wcsicmp(argv[1], cmdptr->cmd1) == 0) &&
            (cmdptr->cmd2 != NULL && _wcsicmp(argv[2], cmdptr->cmd2) == 0) &&
            (cmdptr->cmd3 != NULL && _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 EXIT_SUCCESS;
}

HelpCommand()

EXIT_CODE HelpCommand

(

_In_ PCOMMAND

pCommand

)

Referenced by 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) &&
            (cmdptr->help != IDS_NONE))
        {
            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()

EXIT_CODE import_main	(	_In_ INT	argc,
		_In_ PWSTR *	argv
	)

Definition at line 12 of file import.c.

{
    return EXIT_SUCCESS;
}

inactive_main()

EXIT_CODE inactive_main	(	_In_ INT	argc,
		_In_ PWSTR *	argv
	)

Definition at line 16 of file inactive.c.

{
    NTSTATUS Status;
 
    DPRINT("Inactive()\n");
 
    if (CurrentDisk == NULL)
    {
        ConResPuts(StdOut, IDS_SELECT_NO_DISK);
        return EXIT_SUCCESS;
    }
 
    if (CurrentPartition == NULL)
    {
        ConResPuts(StdOut, IDS_SELECT_NO_PARTITION);
        return EXIT_SUCCESS;
    }
 
    if (CurrentDisk->PartitionStyle == PARTITION_STYLE_MBR)
    {
        if (!CurrentPartition->Mbr.BootIndicator)
        {
            ConResPuts(StdOut, IDS_INACTIVE_ALREADY);
            return EXIT_SUCCESS;
        }
 
        CurrentPartition->Mbr.BootIndicator = FALSE;
        CurrentDisk->Dirty = TRUE;
        UpdateMbrDiskLayout(CurrentDisk);
        Status = WriteMbrPartitions(CurrentDisk);
        if (NT_SUCCESS(Status))
        {
            ConResPuts(StdOut, IDS_INACTIVE_SUCCESS);
        }
        else
        {
            ConResPuts(StdOut, IDS_INACTIVE_FAIL);
        }
    }
    else
    {
        ConResPuts(StdOut, IDS_INACTIVE_NO_MBR);
    }
 
    return EXIT_SUCCESS;
}

InterpretCmd()

EXIT_CODE InterpretCmd	(	_In_ INT	argc,
		_In_ PWSTR *	argv
	)

InterpretMain()

VOID InterpretMain

(

VOID

)

Definition at line 232 of file interpreter.c.

{
    WCHAR input_line[MAX_STRING_SIZE];
    LPWSTR args_vector[MAX_ARGS_COUNT];
    INT args_count = 0;
    BOOL bWhiteSpace = TRUE;
    BOOL bQuote = FALSE;
    EXIT_CODE ExitCode = EXIT_SUCCESS;
    LPWSTR ptr;
 
    while (ExitCode != EXIT_EXIT)
    {
        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);
 
        bQuote = FALSE;
        ptr = input_line;
        while (*ptr != 0)
        {
            if (*ptr == L'"')
                bQuote = !bQuote;
 
            if ((iswspace(*ptr) && (bQuote == FALSE))|| *ptr == L'\n')
            {
                *ptr = 0;
                bWhiteSpace = TRUE;
            }
            else
            {
                if ((bWhiteSpace != FALSE) && (bQuote == FALSE) && (args_count < MAX_ARGS_COUNT))
                {
                    args_vector[args_count] = ptr;
                    args_count++;
                }
                bWhiteSpace = FALSE;
            }
            ptr++;
        }
 
        /* Send the string to find the command */
        ExitCode = InterpretCmd(args_count, args_vector);
    }
}

Referenced by wmain().

InterpretScript()

EXIT_CODE InterpretScript

(

_In_ LPWSTR

line

)

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()

EXIT_CODE ListDisk	(	INT	argc,
		PWSTR *	argv
	)

ListPartition()

EXIT_CODE ListPartition	(	INT	argc,
		PWSTR *	argv
	)

ListVirtualDisk()

EXIT_CODE ListVirtualDisk	(	INT	argc,
		PWSTR *	argv
	)

ListVolume()

EXIT_CODE ListVolume	(	INT	argc,
		PWSTR *	argv
	)

merge_main()

EXIT_CODE merge_main	(	_In_ INT	argc,
		_In_ PWSTR *	argv
	)

Definition at line 12 of file merge.c.

{
    return EXIT_SUCCESS;
}

offline_main()

EXIT_CODE offline_main	(	_In_ INT	argc,
		_In_ PWSTR *	argv
	)

Definition at line 12 of file offline.c.

{
    return EXIT_SUCCESS;
}

online_main()

EXIT_CODE online_main	(	_In_ INT	argc,
		_In_ PWSTR *	argv
	)

Definition at line 12 of file online.c.

{
    return EXIT_SUCCESS;
}

PrintBusType()

VOID PrintBusType	(	_Out_ PWSTR	pszBuffer,
		_In_ INT	cchBufferMax,
		_In_ STORAGE_BUS_TYPE	Bustype
	)

Definition at line 295 of file misc.c.

{
    if (BusType <= BusTypeMax)
        LoadStringW(GetModuleHandle(NULL),
                    IDS_BUSTYPE_UNKNOWN + BusType,
                    pszBuffer,
                    cchBufferMax);
    else
        LoadStringW(GetModuleHandle(NULL),
                    IDS_BUSTYPE_OTHER,
                    pszBuffer,
                    cchBufferMax);
}

Referenced by DetailDisk().

PrintDisk()

VOID PrintDisk

(

_In_ PDISKENTRY

DiskEntry

)

Definition at line 83 of file list.c.

{
    ULONGLONG DiskSize;
    ULONGLONG FreeSize;
    LPWSTR lpSizeUnit;
    LPWSTR lpFreeUnit;
 
    DiskSize = DiskEntry->SectorCount.QuadPart *
               (ULONGLONG)DiskEntry->BytesPerSector;
 
    if (DiskSize >= SIZE_10TB) /* 10 TB */
    {
        DiskSize = RoundingDivide(DiskSize, SIZE_1TB);
        lpSizeUnit = L"TB";
    }
    else if (DiskSize >= SIZE_10GB) /* 10 GB */
    {
        DiskSize = RoundingDivide(DiskSize, SIZE_1GB);
        lpSizeUnit = L"GB";
    }
    else
    {
        DiskSize = RoundingDivide(DiskSize, SIZE_1MB);
        if (DiskSize == 0)
            DiskSize = 1;
        lpSizeUnit = L"MB";
    }
 
    FreeSize = GetFreeDiskSize(DiskEntry);
    if (FreeSize >= SIZE_10TB) /* 10 TB */
    {
        FreeSize = RoundingDivide(FreeSize, SIZE_1TB);
        lpFreeUnit = L"TB";
    }
    else if (FreeSize >= SIZE_10GB) /* 10 GB */
    {
        FreeSize = RoundingDivide(FreeSize, SIZE_1GB);
        lpFreeUnit = L"GB";
    }
    else if (FreeSize >= SIZE_10MB) /* 10 MB */
    {
        FreeSize = RoundingDivide(FreeSize, SIZE_1MB);
        lpFreeUnit = L"MB";
    }
    else if (FreeSize >= SIZE_10KB) /* 10 KB */
    {
        FreeSize = RoundingDivide(FreeSize, SIZE_1KB);
        lpFreeUnit = L"KB";
    }
    else
    {
        lpFreeUnit = L"B";
    }
 
    ConResPrintf(StdOut, IDS_LIST_DISK_FORMAT,
                 (CurrentDisk == DiskEntry) ? L'*' : L' ',
                 DiskEntry->DiskNumber,
                 L"Online",
                 DiskSize,
                 lpSizeUnit,
                 FreeSize,
                 lpFreeUnit,
                 L" ",
                 (DiskEntry->PartitionStyle == PARTITION_STYLE_GPT) ? L"*" : L" ");
}

Referenced by DetailVolume(), and ListDisk().

PrintGUID()

VOID PrintGUID	(	_Out_ PWSTR	pszBuffer,
		_In_ GUID *	pGuid
	)

Definition at line 187 of file misc.c.

{
    swprintf(pszBuffer,
             L"%08lx-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
             pGuid->Data1,
             pGuid->Data2,
             pGuid->Data3,
             pGuid->Data4[0],
             pGuid->Data4[1],
             pGuid->Data4[2],
             pGuid->Data4[3],
             pGuid->Data4[4],
             pGuid->Data4[5],
             pGuid->Data4[6],
             pGuid->Data4[7]);
}

Referenced by DetailDisk(), DetailPartition(), and UniqueIdDisk().

PrintVolume()

VOID PrintVolume

(

_In_ PVOLENTRY

VolumeEntry

)

Definition at line 471 of file list.c.

{
    ULONGLONG VolumeSize;
    PWSTR pszSizeUnit;
    PWSTR pszVolumeType;
 
    VolumeSize = VolumeEntry->Size.QuadPart;
    if (VolumeSize >= SIZE_10TB) /* 10 TB */
    {
        VolumeSize = RoundingDivide(VolumeSize, SIZE_1TB);
        pszSizeUnit = L"TB";
    }
    else if (VolumeSize >= SIZE_10GB) /* 10 GB */
    {
        VolumeSize = RoundingDivide(VolumeSize, SIZE_1GB);
        pszSizeUnit = L"GB";
    }
    else if (VolumeSize >= SIZE_10MB) /* 10 MB */
    {
        VolumeSize = RoundingDivide(VolumeSize, SIZE_1MB);
        pszSizeUnit = L"MB";
    }
    else
    {
        VolumeSize = RoundingDivide(VolumeSize, SIZE_1KB);
        pszSizeUnit = L"KB";
    }
 
    switch (VolumeEntry->VolumeType)
    {
        case VOLUME_TYPE_CDROM:
            pszVolumeType = L"DVD";
            break;
        case VOLUME_TYPE_PARTITION:
            pszVolumeType = L"Partition";
            break;
        case VOLUME_TYPE_REMOVABLE:
            pszVolumeType = L"Removable";
            break;
        case VOLUME_TYPE_UNKNOWN:
        default:
            pszVolumeType = L"Unknown";
            break;
    }
 
    ConResPrintf(StdOut, IDS_LIST_VOLUME_FORMAT,
                 (CurrentVolume == VolumeEntry) ? L'*' : L' ',
                 VolumeEntry->VolumeNumber,
                 VolumeEntry->DriveLetter,
                 (VolumeEntry->pszLabel) ? VolumeEntry->pszLabel : L"",
                 (VolumeEntry->pszFilesystem) ? VolumeEntry->pszFilesystem : L"",
                 pszVolumeType,
                 VolumeSize, pszSizeUnit,
                 L"", L"");
}

Referenced by DetailDisk(), DetailPartition(), and ListVolume().

ReadLayoutBuffer()

VOID ReadLayoutBuffer	(	_In_ HANDLE	FileHandle,
		_In_ PDISKENTRY	DiskEntry
	)

Definition at line 1065 of file partlist.c.

{
    ULONG LayoutBufferSize;
    PDRIVE_LAYOUT_INFORMATION_EX NewLayoutBuffer;
    IO_STATUS_BLOCK Iosb;
    NTSTATUS Status;
 
    /* Allocate a layout buffer with 4 partition entries first */
    LayoutBufferSize = sizeof(DRIVE_LAYOUT_INFORMATION_EX) +
                       ((4 - ANYSIZE_ARRAY) * sizeof(PARTITION_INFORMATION_EX));
    DiskEntry->LayoutBuffer = RtlAllocateHeap(RtlGetProcessHeap(),
                                              HEAP_ZERO_MEMORY,
                                              LayoutBufferSize);
    if (DiskEntry->LayoutBuffer == NULL)
    {
        DPRINT1("Failed to allocate the disk layout buffer!\n");
        return;
    }
 
    for (;;)
    {
        DPRINT("Buffer size: %lu\n", LayoutBufferSize);
        Status = NtDeviceIoControlFile(FileHandle,
                                       NULL,
                                       NULL,
                                       NULL,
                                       &Iosb,
                                       IOCTL_DISK_GET_DRIVE_LAYOUT_EX,
                                       NULL,
                                       0,
                                       DiskEntry->LayoutBuffer,
                                       LayoutBufferSize);
        if (NT_SUCCESS(Status))
            break;
 
        if (Status != STATUS_BUFFER_TOO_SMALL)
        {
            DPRINT1("NtDeviceIoControlFile() failed (Status: 0x%08lx)\n", Status);
            return;
        }
 
        LayoutBufferSize += 4 * sizeof(PARTITION_INFORMATION_EX);
        NewLayoutBuffer = RtlReAllocateHeap(RtlGetProcessHeap(),
                                            HEAP_ZERO_MEMORY,
                                            DiskEntry->LayoutBuffer,
                                            LayoutBufferSize);
        if (NewLayoutBuffer == NULL)
        {
            DPRINT1("Failed to reallocate the disk layout buffer!\n");
            return;
        }
 
        DiskEntry->LayoutBuffer = NewLayoutBuffer;
    }
}

Referenced by AddDiskToList(), and CreateDisk().

recover_main()

EXIT_CODE recover_main	(	_In_ INT	argc,
		_In_ PWSTR *	argv
	)

Definition at line 12 of file recover.c.

{
    return EXIT_SUCCESS;
}

remove_main()

EXIT_CODE remove_main	(	_In_ INT	argc,
		_In_ PWSTR *	argv
	)

Definition at line 15 of file remove.c.

{
    PWSTR pszSuffix = NULL;
    WCHAR DriveLetter = UNICODE_NULL;
    INT i, nExclusive = 0;
    BOOL bResult;
 
    DPRINT("remove_main()\n");
 
    if (CurrentVolume == NULL)
    {
        ConResPuts(StdOut, IDS_SELECT_NO_VOLUME);
        return EXIT_SUCCESS;
    }
 
    if (CurrentVolume->DriveLetter == UNICODE_NULL)
    {
        ConResPuts(StdOut, IDS_REMOVE_NO_LETTER);
        return EXIT_SUCCESS;
    }
 
    for (i = 1; i < argc; i++)
    {
        if (_wcsicmp(argv[i], L"noerr") == 0)
        {
            /* noerr */
            ConPuts(StdOut, L"The NOERR option is not supported yet!\n");
#if 0
            bNoErr = TRUE;
#endif
        }
    }
 
    for (i = 1; i < argc; i++)
    {
        if (HasPrefix(argv[i], L"letter=", &pszSuffix))
        {
            if (wcslen(pszSuffix) == 1)
            {
                DriveLetter = towupper(*pszSuffix);
                nExclusive++;
            }
            else
            {
                ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
                return EXIT_SUCCESS; 
            }
        }
        else if (HasPrefix(argv[i], L"mount=", &pszSuffix))
        {
            DPRINT("Mount\n", pszSuffix);
            ConPuts(StdOut, L"The MOUNT option is not supported yet!\n");
            nExclusive++;
        }
        else if (_wcsicmp(argv[i], L"all") == 0)
        {
            ConPuts(StdOut, L"The ALL option is not supported yet!\n");
            nExclusive++;
        }
        else if (_wcsicmp(argv[i], L"dismount") == 0)
        {
            ConPuts(StdOut, L"The DISMOUNT option is not supported yet!\n");
        }
        else if (_wcsicmp(argv[i], L"noerr") == 0)
        {
            /* noerr - Already handled above */
        }
        else
        {
            ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
            return EXIT_SUCCESS;
        }
    }
 
    if (nExclusive > 1)
    {
        ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
        return EXIT_SUCCESS;
    }
 
    DPRINT("VolumeName: %S\n", CurrentVolume->VolumeName);
    DPRINT("DeviceName: %S\n", CurrentVolume->DeviceName);
    DPRINT("DriveLetter: %C\n", CurrentVolume->DriveLetter);
 
    if (DriveLetter != UNICODE_NULL)
    {
        DPRINT1("DriveLetter: %C\n", DriveLetter);
 
        if ((DriveLetter < L'C') || (DriveLetter > L'Z'))
        {
            ConResPuts(StdOut, IDS_ASSIGN_INVALID_LETTER);
            return EXIT_SUCCESS;
        }
 
        if (DriveLetter != CurrentVolume->DriveLetter)
        {
            ConResPuts(StdOut, IDS_REMOVE_WRONG_LETTER);
            return EXIT_SUCCESS;
        }
    }
    else
    {
        DriveLetter = CurrentVolume->DriveLetter;
    }
 
    bResult = DeleteDriveLetter(DriveLetter);
    if (bResult == FALSE)
    {
        ConResPuts(StdOut, IDS_REMOVE_FAIL);
        return EXIT_SUCCESS;
    }
 
    CurrentVolume->DriveLetter = UNICODE_NULL;
    ConResPuts(StdOut, IDS_REMOVE_SUCCESS);
 
    return EXIT_SUCCESS;
}

RemoveVolume()

VOID RemoveVolume

(

_In_ PVOLENTRY

VolumeEntry

)

Definition at line 2832 of file partlist.c.

{
    if (VolumeEntry == NULL)
        return;
 
    if (VolumeEntry == CurrentVolume)
        CurrentVolume = NULL;
 
    RemoveEntryList(&VolumeEntry->ListEntry);
 
    if (VolumeEntry->pszLabel)
        RtlFreeHeap(RtlGetProcessHeap(), 0, VolumeEntry->pszLabel);
 
    if (VolumeEntry->pszFilesystem)
        RtlFreeHeap(RtlGetProcessHeap(), 0, VolumeEntry->pszFilesystem);
 
    if (VolumeEntry->pExtents)
        RtlFreeHeap(RtlGetProcessHeap(), 0, VolumeEntry->pExtents);
 
    /* Release disk entry */
    RtlFreeHeap(RtlGetProcessHeap(), 0, VolumeEntry);
}

Referenced by clean_main().

repair_main()

EXIT_CODE repair_main	(	_In_ INT	argc,
		_In_ PWSTR *	argv
	)

Definition at line 12 of file repair.c.

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

rescan_main()

EXIT_CODE rescan_main	(	_In_ INT	argc,
		_In_ PWSTR *	argv
	)

Definition at line 12 of file rescan.c.

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

retain_main()

EXIT_CODE retain_main	(	_In_ INT	argc,
		_In_ PWSTR *	argv
	)

Definition at line 12 of file retain.c.

{
    return EXIT_SUCCESS;
}

RoundingDivide()

ULONGLONG RoundingDivide	(	_In_ ULONGLONG	Dividend,
		_In_ ULONGLONG	Divisor
	)

Definition at line 75 of file misc.c.

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

san_main()

EXIT_CODE san_main	(	_In_ INT	argc,
		_In_ PWSTR *	argv
	)

Definition at line 12 of file san.c.

{
    return EXIT_SUCCESS;
}

ScanForUnpartitionedGptDiskSpace()

VOID ScanForUnpartitionedGptDiskSpace

(

PDISKENTRY

DiskEntry

)

Definition at line 921 of file partlist.c.

{
    ULONGLONG LastStartSector;
    ULONGLONG LastSectorCount;
    ULONGLONG LastUnusedSectorCount;
    PPARTENTRY PartEntry;
    PPARTENTRY NewPartEntry;
    PLIST_ENTRY Entry;
 
    DPRINT("ScanForUnpartitionedGptDiskSpace()\n");
 
#ifdef DUMP_PARTITION_LIST
    DumpPartitionList(DiskEntry);
#endif
 
    if (IsListEmpty(&DiskEntry->PrimaryPartListHead))
    {
        DPRINT("No partitions!\n");
 
        /* Create a partition table that represents the empty disk */
        NewPartEntry = RtlAllocateHeap(RtlGetProcessHeap(),
                                       HEAP_ZERO_MEMORY,
                                       sizeof(PARTENTRY));
        if (NewPartEntry == NULL)
            return;
 
        NewPartEntry->DiskEntry = DiskEntry;
 
        NewPartEntry->IsPartitioned = FALSE;
        NewPartEntry->StartSector.QuadPart = DiskEntry->StartSector.QuadPart;
        NewPartEntry->SectorCount.QuadPart = DiskEntry->EndSector.QuadPart - DiskEntry->StartSector.QuadPart + 1;
 
        DPRINT("First Sector: %I64u\n", NewPartEntry->StartSector.QuadPart);
        DPRINT("Last Sector: %I64u\n", NewPartEntry->StartSector.QuadPart + NewPartEntry->SectorCount.QuadPart - 1);
        DPRINT("Total Sectors: %I64u\n", NewPartEntry->SectorCount.QuadPart);
 
        NewPartEntry->FormatState = Unformatted;
 
        InsertTailList(&DiskEntry->PrimaryPartListHead,
                       &NewPartEntry->ListEntry);
 
#ifdef DUMP_PARTITION_LIST
        DumpPartitionList(DiskEntry);
#endif
 
        return;
    }
 
    /* Start at the first usable sector */
    LastStartSector = DiskEntry->StartSector.QuadPart;
    LastSectorCount = 0ULL;
    LastUnusedSectorCount = 0ULL;
 
    Entry = DiskEntry->PrimaryPartListHead.Flink;
    while (Entry != &DiskEntry->PrimaryPartListHead)
    {
        PartEntry = CONTAINING_RECORD(Entry, PARTENTRY, ListEntry);
 
        if (!IsEqualGUID(&PartEntry->Gpt.PartitionType, &PARTITION_ENTRY_UNUSED_GUID) ||
            PartEntry->SectorCount.QuadPart != 0ULL)
        {
            LastUnusedSectorCount =
                PartEntry->StartSector.QuadPart - (LastStartSector + LastSectorCount);
 
            if (PartEntry->StartSector.QuadPart > (LastStartSector + LastSectorCount) &&
                LastUnusedSectorCount >= (ULONGLONG)DiskEntry->SectorAlignment)
            {
                DPRINT("Unpartitioned disk space %I64u sectors\n", LastUnusedSectorCount);
 
                NewPartEntry = RtlAllocateHeap(RtlGetProcessHeap(),
                                               HEAP_ZERO_MEMORY,
                                               sizeof(PARTENTRY));
                if (NewPartEntry == NULL)
                    return;
 
                NewPartEntry->DiskEntry = DiskEntry;
 
                NewPartEntry->IsPartitioned = FALSE;
                NewPartEntry->StartSector.QuadPart = LastStartSector + LastSectorCount;
                NewPartEntry->SectorCount.QuadPart = AlignDown(NewPartEntry->StartSector.QuadPart + LastUnusedSectorCount, DiskEntry->SectorAlignment) -
                                                     NewPartEntry->StartSector.QuadPart;
 
                DPRINT("First Sector: %I64u\n", NewPartEntry->StartSector.QuadPart);
                DPRINT("Last Sector: %I64u\n", NewPartEntry->StartSector.QuadPart + NewPartEntry->SectorCount.QuadPart - 1);
                DPRINT("Total Sectors: %I64u\n", NewPartEntry->SectorCount.QuadPart);
 
                NewPartEntry->FormatState = Unformatted;
 
                /* Insert the table into the list */
                InsertTailList(&PartEntry->ListEntry,
                               &NewPartEntry->ListEntry);
            }
 
            LastStartSector = PartEntry->StartSector.QuadPart;
            LastSectorCount = PartEntry->SectorCount.QuadPart;
        }
 
        Entry = Entry->Flink;
    }
 
    /* Check for trailing unpartitioned disk space */
    if ((LastStartSector + LastSectorCount) < DiskEntry->EndSector.QuadPart + 1)
    {
        LastUnusedSectorCount = AlignDown(DiskEntry->EndSector.QuadPart + 1 - (LastStartSector + LastSectorCount), DiskEntry->SectorAlignment);
 
        if (LastUnusedSectorCount >= (ULONGLONG)DiskEntry->SectorAlignment)
        {
            DPRINT("Unpartitioned disk space: %I64u sectors\n", LastUnusedSectorCount);
 
            NewPartEntry = RtlAllocateHeap(RtlGetProcessHeap(),
                                           HEAP_ZERO_MEMORY,
                                           sizeof(PARTENTRY));
            if (NewPartEntry == NULL)
                return;
 
            NewPartEntry->DiskEntry = DiskEntry;
 
            NewPartEntry->IsPartitioned = FALSE;
            NewPartEntry->StartSector.QuadPart = LastStartSector + LastSectorCount;
            NewPartEntry->SectorCount.QuadPart = AlignDown(NewPartEntry->StartSector.QuadPart + LastUnusedSectorCount, DiskEntry->SectorAlignment) -
                                                 NewPartEntry->StartSector.QuadPart;
 
            DPRINT("First Sector: %I64u\n", NewPartEntry->StartSector.QuadPart);
            DPRINT("Last Sector: %I64u\n", NewPartEntry->StartSector.QuadPart + NewPartEntry->SectorCount.QuadPart - 1);
            DPRINT("Total Sectors: %I64u\n", NewPartEntry->SectorCount.QuadPart);
 
            NewPartEntry->FormatState = Unformatted;
 
            /* Append the table to the list */
            InsertTailList(&DiskEntry->PrimaryPartListHead,
                           &NewPartEntry->ListEntry);
        }
    }
 
#ifdef DUMP_PARTITION_LIST
    DumpPartitionList(DiskEntry);
#endif
 
    DPRINT("ScanForUnpartitionedGptDiskSpace() done\n");
}

Referenced by AddDiskToList(), and ConvertGPT().

ScanForUnpartitionedMbrDiskSpace()

VOID ScanForUnpartitionedMbrDiskSpace

(

PDISKENTRY

DiskEntry

)

Definition at line 660 of file partlist.c.

{
    ULONGLONG StartSector, EndSector;
    ULONGLONG LastStartSector;
    ULONGLONG LastSectorCount;
    ULONGLONG LastUnusedSectorCount;
    PPARTENTRY PartEntry;
    PPARTENTRY NewPartEntry;
    PLIST_ENTRY Entry;
 
    DPRINT("ScanForUnpartitionedMbrDiskSpace()\n");
 
    /* Calculate the disk sector limits */
    /* Limit the SectorCount to 2^32 sectors for MBR disks */
    StartSector = (ULONGLONG)DiskEntry->SectorAlignment;
    EndSector = min(DiskEntry->SectorCount.QuadPart, 0x100000000) - 1;
 
    if (IsListEmpty(&DiskEntry->PrimaryPartListHead))
    {
        DPRINT1("No primary partition!\n");
 
        /* Create a partition table that represents the empty disk */
        NewPartEntry = RtlAllocateHeap(RtlGetProcessHeap(),
                                       HEAP_ZERO_MEMORY,
                                       sizeof(PARTENTRY));
        if (NewPartEntry == NULL)
            return;
 
        NewPartEntry->DiskEntry = DiskEntry;
 
        NewPartEntry->IsPartitioned = FALSE;
        NewPartEntry->StartSector.QuadPart = StartSector;
        NewPartEntry->SectorCount.QuadPart = AlignDown(EndSector + 1, DiskEntry->SectorAlignment) -
                                             NewPartEntry->StartSector.QuadPart;
 
        DPRINT1("First Sector: %I64u\n", NewPartEntry->StartSector.QuadPart);
        DPRINT1("Last Sector: %I64u\n", NewPartEntry->StartSector.QuadPart + NewPartEntry->SectorCount.QuadPart - 1);
        DPRINT1("Total Sectors: %I64u\n", NewPartEntry->SectorCount.QuadPart);
 
        NewPartEntry->FormatState = Unformatted;
 
        InsertTailList(&DiskEntry->PrimaryPartListHead,
                       &NewPartEntry->ListEntry);
 
        return;
    }
 
    /* Start at the first usable sector */
    LastStartSector = StartSector;
    LastSectorCount = 0ULL;
    LastUnusedSectorCount = 0ULL;
 
    Entry = DiskEntry->PrimaryPartListHead.Flink;
    while (Entry != &DiskEntry->PrimaryPartListHead)
    {
        PartEntry = CONTAINING_RECORD(Entry, PARTENTRY, ListEntry);
 
        if (PartEntry->Mbr.PartitionType != PARTITION_ENTRY_UNUSED ||
            PartEntry->SectorCount.QuadPart != 0ULL)
        {
            LastUnusedSectorCount =
                PartEntry->StartSector.QuadPart - (LastStartSector + LastSectorCount);
 
            if (PartEntry->StartSector.QuadPart > (LastStartSector + LastSectorCount) &&
                LastUnusedSectorCount >= (ULONGLONG)DiskEntry->SectorAlignment)
            {
                DPRINT("Unpartitioned disk space %I64u sectors\n", LastUnusedSectorCount);
 
                NewPartEntry = RtlAllocateHeap(RtlGetProcessHeap(),
                                               HEAP_ZERO_MEMORY,
                                               sizeof(PARTENTRY));
                if (NewPartEntry == NULL)
                    return;
 
                NewPartEntry->DiskEntry = DiskEntry;
 
                NewPartEntry->IsPartitioned = FALSE;
                NewPartEntry->StartSector.QuadPart = LastStartSector + LastSectorCount;
                NewPartEntry->SectorCount.QuadPart = AlignDown(NewPartEntry->StartSector.QuadPart + LastUnusedSectorCount, DiskEntry->SectorAlignment) -
                                                     NewPartEntry->StartSector.QuadPart;
 
                DPRINT1("First Sector: %I64u\n", NewPartEntry->StartSector.QuadPart);
                DPRINT1("Last Sector: %I64u\n", NewPartEntry->StartSector.QuadPart + NewPartEntry->SectorCount.QuadPart - 1);
                DPRINT1("Total Sectors: %I64u\n", NewPartEntry->SectorCount.QuadPart);
 
                NewPartEntry->FormatState = Unformatted;
 
                /* Insert the table into the list */
                InsertTailList(&PartEntry->ListEntry,
                               &NewPartEntry->ListEntry);
            }
 
            LastStartSector = PartEntry->StartSector.QuadPart;
            LastSectorCount = PartEntry->SectorCount.QuadPart;
        }
 
        Entry = Entry->Flink;
    }
 
    /* Check for trailing unpartitioned disk space */
    if ((LastStartSector + LastSectorCount) < (EndSector + 1))
    {
        LastUnusedSectorCount = AlignDown((EndSector + 1) - (LastStartSector + LastSectorCount), DiskEntry->SectorAlignment);
 
        if (LastUnusedSectorCount >= (ULONGLONG)DiskEntry->SectorAlignment)
        {
            DPRINT1("Unpartitioned disk space: %I64u sectors\n", LastUnusedSectorCount);
 
            NewPartEntry = RtlAllocateHeap(RtlGetProcessHeap(),
                                           HEAP_ZERO_MEMORY,
                                           sizeof(PARTENTRY));
            if (NewPartEntry == NULL)
                return;
 
            NewPartEntry->DiskEntry = DiskEntry;
 
            NewPartEntry->IsPartitioned = FALSE;
            NewPartEntry->StartSector.QuadPart = LastStartSector + LastSectorCount;
            NewPartEntry->SectorCount.QuadPart = AlignDown(NewPartEntry->StartSector.QuadPart + LastUnusedSectorCount, DiskEntry->SectorAlignment) -
                                                 NewPartEntry->StartSector.QuadPart;
 
            DPRINT1("First Sector: %I64u\n", NewPartEntry->StartSector.QuadPart);
            DPRINT1("Last Sector: %I64u\n", NewPartEntry->StartSector.QuadPart + NewPartEntry->SectorCount.QuadPart - 1);
            DPRINT1("Total Sectors: %I64u\n", NewPartEntry->SectorCount.QuadPart);
 
            NewPartEntry->FormatState = Unformatted;
 
            /* Append the table to the list */
            InsertTailList(&DiskEntry->PrimaryPartListHead,
                           &NewPartEntry->ListEntry);
        }
    }
 
    if (DiskEntry->ExtendedPartition != NULL)
    {
        if (IsListEmpty(&DiskEntry->LogicalPartListHead))
        {
            DPRINT1("No logical partition!\n");
 
            /* Create a partition table entry that represents the empty extended partition */
            NewPartEntry = RtlAllocateHeap(RtlGetProcessHeap(),
                                           HEAP_ZERO_MEMORY,
                                           sizeof(PARTENTRY));
            if (NewPartEntry == NULL)
                return;
 
            NewPartEntry->DiskEntry = DiskEntry;
            NewPartEntry->LogicalPartition = TRUE;
 
            NewPartEntry->IsPartitioned = FALSE;
            NewPartEntry->StartSector.QuadPart = DiskEntry->ExtendedPartition->StartSector.QuadPart + (ULONGLONG)DiskEntry->SectorAlignment;
            NewPartEntry->SectorCount.QuadPart = DiskEntry->ExtendedPartition->SectorCount.QuadPart - (ULONGLONG)DiskEntry->SectorAlignment;
 
            DPRINT1("First Sector: %I64u\n", NewPartEntry->StartSector.QuadPart);
            DPRINT1("Last Sector: %I64u\n", NewPartEntry->StartSector.QuadPart + NewPartEntry->SectorCount.QuadPart - 1);
            DPRINT1("Total Sectors: %I64u\n", NewPartEntry->SectorCount.QuadPart);
 
            NewPartEntry->FormatState = Unformatted;
 
            InsertTailList(&DiskEntry->LogicalPartListHead,
                           &NewPartEntry->ListEntry);
 
            return;
        }
 
        /* Start partition at head 1, cylinder 0 */
        LastStartSector = DiskEntry->ExtendedPartition->StartSector.QuadPart + (ULONGLONG)DiskEntry->SectorAlignment;
        LastSectorCount = 0ULL;
        LastUnusedSectorCount = 0ULL;
 
        Entry = DiskEntry->LogicalPartListHead.Flink;
        while (Entry != &DiskEntry->LogicalPartListHead)
        {
            PartEntry = CONTAINING_RECORD(Entry, PARTENTRY, ListEntry);
 
            if (PartEntry->Mbr.PartitionType != PARTITION_ENTRY_UNUSED ||
                PartEntry->SectorCount.QuadPart != 0ULL)
            {
                LastUnusedSectorCount =
                    PartEntry->StartSector.QuadPart - (ULONGLONG)DiskEntry->SectorAlignment - (LastStartSector + LastSectorCount);
 
                if ((PartEntry->StartSector.QuadPart - (ULONGLONG)DiskEntry->SectorAlignment) > (LastStartSector + LastSectorCount) &&
                    LastUnusedSectorCount >= (ULONGLONG)DiskEntry->SectorAlignment)
                {
                    DPRINT("Unpartitioned disk space %I64u sectors\n", LastUnusedSectorCount);
 
                    NewPartEntry = RtlAllocateHeap(RtlGetProcessHeap(),
                                                   HEAP_ZERO_MEMORY,
                                                   sizeof(PARTENTRY));
                    if (NewPartEntry == NULL)
                        return;
 
                    NewPartEntry->DiskEntry = DiskEntry;
                    NewPartEntry->LogicalPartition = TRUE;
 
                    NewPartEntry->IsPartitioned = FALSE;
                    NewPartEntry->StartSector.QuadPart = LastStartSector + LastSectorCount;
                    NewPartEntry->SectorCount.QuadPart = AlignDown(NewPartEntry->StartSector.QuadPart + LastUnusedSectorCount, DiskEntry->SectorAlignment) -
                                                         NewPartEntry->StartSector.QuadPart;
 
                    DPRINT("First Sector: %I64u\n", NewPartEntry->StartSector.QuadPart);
                    DPRINT("Last Sector: %I64u\n", NewPartEntry->StartSector.QuadPart + NewPartEntry->SectorCount.QuadPart - 1);
                    DPRINT("Total Sectors: %I64u\n", NewPartEntry->SectorCount.QuadPart);
 
                    NewPartEntry->FormatState = Unformatted;
 
                    /* Insert the table into the list */
                    InsertTailList(&PartEntry->ListEntry,
                                   &NewPartEntry->ListEntry);
                }
 
                LastStartSector = PartEntry->StartSector.QuadPart;
                LastSectorCount = PartEntry->SectorCount.QuadPart;
            }
 
            Entry = Entry->Flink;
        }
 
        /* Check for trailing unpartitioned disk space */
        if ((LastStartSector + LastSectorCount) < DiskEntry->ExtendedPartition->StartSector.QuadPart + DiskEntry->ExtendedPartition->SectorCount.QuadPart)
        {
            LastUnusedSectorCount = AlignDown(DiskEntry->ExtendedPartition->StartSector.QuadPart + DiskEntry->ExtendedPartition->SectorCount.QuadPart - (LastStartSector + LastSectorCount),
                                              DiskEntry->SectorAlignment);
 
            if (LastUnusedSectorCount >= (ULONGLONG)DiskEntry->SectorAlignment)
            {
                DPRINT("Unpartitioned disk space: %I64u sectors\n", LastUnusedSectorCount);
 
                NewPartEntry = RtlAllocateHeap(RtlGetProcessHeap(),
                                               HEAP_ZERO_MEMORY,
                                               sizeof(PARTENTRY));
                if (NewPartEntry == NULL)
                    return;
 
                NewPartEntry->DiskEntry = DiskEntry;
                NewPartEntry->LogicalPartition = TRUE;
 
                NewPartEntry->IsPartitioned = FALSE;
                NewPartEntry->StartSector.QuadPart = LastStartSector + LastSectorCount;
                NewPartEntry->SectorCount.QuadPart = AlignDown(NewPartEntry->StartSector.QuadPart + LastUnusedSectorCount, DiskEntry->SectorAlignment) -
                                                     NewPartEntry->StartSector.QuadPart;
 
                DPRINT("First Sector: %I64u\n", NewPartEntry->StartSector.QuadPart);
                DPRINT("Last Sector: %I64u\n", NewPartEntry->StartSector.QuadPart + NewPartEntry->SectorCount.QuadPart - 1);
                DPRINT("Total Sectors: %I64u\n", NewPartEntry->SectorCount.QuadPart);
 
                NewPartEntry->FormatState = Unformatted;
 
                /* Append the table to the list */
                InsertTailList(&DiskEntry->LogicalPartListHead,
                               &NewPartEntry->ListEntry);
            }
        }
    }
 
    DPRINT("ScanForUnpartitionedMbrDiskSpace() done\n");
}

Referenced by AddDiskToList(), ConvertMBR(), CreateExtendedPartition(), and CreatePrimaryPartition().

ScrubAutomount()

BOOL ScrubAutomount

(

VOID

)

Definition at line 141 of file mountmgr.c.

{
    HANDLE MountMgrHandle;
    IO_STATUS_BLOCK Iosb;
    NTSTATUS Status;
 
    DPRINT("ScrubAutomount()\n");
 
    Status = OpenMountManager(&MountMgrHandle, GENERIC_READ | GENERIC_WRITE);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("OpenMountManager() Status 0x%08lx\n", Status);
        return FALSE;
    }
 
    Status = NtDeviceIoControlFile(MountMgrHandle,
                                   NULL,
                                   NULL,
                                   NULL,
                                   &Iosb,
                                   IOCTL_MOUNTMGR_SCRUB_REGISTRY,
                                   NULL,
                                   0,
                                   NULL,
                                   0);
 
    NtClose(MountMgrHandle);
 
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("NtDeviceIoControlFile() Status 0x%08lx\n", Status);
        return FALSE;
    }
 
    return TRUE;
}

Referenced by automount_main().

SelectDisk()

EXIT_CODE SelectDisk	(	INT	argc,
		PWSTR *	argv
	)

SelectPartition()

EXIT_CODE SelectPartition	(	INT	argc,
		PWSTR *	argv
	)

SelectVolume()

EXIT_CODE SelectVolume	(	INT	argc,
		PWSTR *	argv
	)

SetAutomountState()

BOOL SetAutomountState

(

_In_ BOOL

bEnable

)

Definition at line 90 of file mountmgr.c.

{
    HANDLE MountMgrHandle;
    MOUNTMGR_SET_AUTO_MOUNT AutoMount;
    IO_STATUS_BLOCK Iosb;
    NTSTATUS Status;
 
    DPRINT("SetAutomountState()\n");
 
    Status = OpenMountManager(&MountMgrHandle, GENERIC_READ | GENERIC_WRITE);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("OpenMountManager() Status 0x%08lx\n", Status);
        return TRUE;
    }
 
    if (bEnable)
        AutoMount.NewState = Enabled;
    else
        AutoMount.NewState = Disabled;
 
    Status = NtDeviceIoControlFile(MountMgrHandle,
                                   NULL,
                                   NULL,
                                   NULL,
                                   &Iosb,
                                   IOCTL_MOUNTMGR_SET_AUTO_MOUNT,
                                   &AutoMount,
                                   sizeof(AutoMount),
                                   NULL,
                                   0);
 
    NtClose(MountMgrHandle);
 
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("NtDeviceIoControlFile() Status 0x%08lx\n", Status);
        return TRUE;
    }
 
    if (AutoMount.NewState == Enabled)
        ConResPuts(StdOut, IDS_AUTOMOUNT_ENABLED);
    else
        ConResPuts(StdOut, IDS_AUTOMOUNT_DISABLED);
    ConPuts(StdOut, L"\n");
 
    return TRUE;
}

Referenced by automount_main().

setid_main()

EXIT_CODE setid_main	(	_In_ INT	argc,
		_In_ PWSTR *	argv
	)

Definition at line 16 of file setid.c.

{
    INT i, length;
    PWSTR pszSuffix, pszId = NULL;
    NTSTATUS Status;
 
    DPRINT("SetId()\n");
 
    if (CurrentDisk == NULL)
    {
        ConResPuts(StdOut, IDS_SELECT_NO_DISK);
        return EXIT_SUCCESS;
    }
 
    if (CurrentPartition == NULL)
    {
        ConResPuts(StdOut, IDS_SELECT_NO_PARTITION);
        return EXIT_SUCCESS;
    }
 
    for (i = 1; i < argc; i++)
    {
        if (_wcsicmp(argv[i], L"noerr") == 0)
        {
            /* noerr */
            DPRINT("NOERR\n");
            ConPuts(StdOut, L"The NOERR option is not supported yet!\n");
        }
    }
 
    for (i = 1; i < argc; i++)
    {
        if (HasPrefix(argv[i], L"id=", &pszSuffix))
        {
            /* id=<Byte>|<GUID> */
            DPRINT("ID : %s\n", pszSuffix);
            pszId = pszSuffix;
        }
        else if (_wcsicmp(argv[i], L"noerr") == 0)
        {
            /* noerr - Already handled above */
        }
        else if (_wcsicmp(argv[i], L"override") == 0)
        {
            /* override */
            DPRINT("OVERRIDE\n");
            ConPuts(StdOut, L"The OVERRIDE option is not supported yet!\n");
        }
        else
        {
            ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
            return EXIT_SUCCESS;
        }
    }
 
    if (CurrentDisk->PartitionStyle == PARTITION_STYLE_GPT)
    {
        if (!StringToGUID(&CurrentPartition->Gpt.PartitionType, pszId))
        {
            ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
            return EXIT_SUCCESS;
        }
 
        CurrentDisk->Dirty = TRUE;
        UpdateGptDiskLayout(CurrentDisk, FALSE);
        Status = WriteGptPartitions(CurrentDisk);
        if (!NT_SUCCESS(Status))
        {
            ConResPuts(StdOut, IDS_SETID_FAIL);
            return EXIT_SUCCESS;
        }
    }
    else if (CurrentDisk->PartitionStyle == PARTITION_STYLE_MBR)
    {
        UCHAR PartitionType = 0;
 
        length = wcslen(pszId);
        if (length == 0)
        {
            ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
            return EXIT_SUCCESS;
        }
 
        if (length > 2)
        {
            ConResPuts(StdErr, IDS_SETID_INVALID_FORMAT);
            return EXIT_SUCCESS;
        }
 
        PartitionType = (UCHAR)wcstoul(pszSuffix, NULL, 16);
        if ((PartitionType == 0) && (errno == ERANGE))
        {
            ConResPuts(StdErr, IDS_SETID_INVALID_FORMAT);
            return EXIT_SUCCESS;
        }
 
        if (PartitionType == 0x42)
        {
            ConResPuts(StdErr, IDS_SETID_INVALID_TYPE);
            return EXIT_SUCCESS;
        }
 
        CurrentPartition->Mbr.PartitionType = PartitionType;
        CurrentDisk->Dirty = TRUE;
        UpdateMbrDiskLayout(CurrentDisk);
        Status = WriteMbrPartitions(CurrentDisk);
        if (!NT_SUCCESS(Status))
        {
            ConResPuts(StdOut, IDS_SETID_FAIL);
            return EXIT_SUCCESS;
        }
    }
 
    ConResPuts(StdOut, IDS_SETID_SUCCESS);
 
    return EXIT_SUCCESS;
}

shrink_main()

EXIT_CODE shrink_main	(	_In_ INT	argc,
		_In_ PWSTR *	argv
	)

Definition at line 12 of file shrink.c.

{
    return EXIT_SUCCESS;
}

StringToGUID()

BOOL StringToGUID	(	_Out_ GUID *	pGuid,
		_In_ PWSTR	pszString
	)

Definition at line 227 of file misc.c.

{
    INT i;
 
    if (pszString == NULL)
        return FALSE;
 
    pGuid->Data1 = 0;
    for (i = 0; i < 8; i++)
    {
        if (!iswxdigit(pszString[i]))
            return FALSE;
 
        pGuid->Data1 = (pGuid->Data1 << 4) | CharToByte(pszString[i]);
    }
 
    if (pszString[8] != L'-')
        return FALSE;
 
    pGuid->Data2 = 0;
    for (i = 9; i < 13; i++)
    {
        if (!iswxdigit(pszString[i]))
            return FALSE;
 
        pGuid->Data2 = (pGuid->Data2 << 4) | CharToByte(pszString[i]);
    }
 
    if (pszString[13] != L'-')
        return FALSE;
 
    pGuid->Data3 = 0;
    for (i = 14; i < 18; i++)
    {
        if (!iswxdigit(pszString[i]))
            return FALSE;
 
        pGuid->Data3 = (pGuid->Data3 << 4) | CharToByte(pszString[i]);
    }
 
    if (pszString[18] != L'-')
        return FALSE;
 
    for (i = 19; i < 36; i += 2)
    {
        if (i == 23)
        {
            if (pszString[i] != L'-')
                return FALSE;
            i++;
        }
 
        if (!iswxdigit(pszString[i]) || !iswxdigit(pszString[i + 1]))
            return FALSE;
 
        pGuid->Data4[(i - 19) / 2] = CharToByte(pszString[i]) << 4 | CharToByte(pszString[i + 1]);
    }
 
    if (pszString[36] == L'\0')
        return TRUE;
 
    return FALSE;
}

Referenced by CreatePrimaryGptPartition(), setid_main(), and UniqueIdDisk().

UniqueIdDisk()

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

Definition at line 17 of file uniqueid.c.

{
    WCHAR szBuffer[40];
    PWSTR pszSuffix, pszId = NULL;
    INT i;
    ULONG ulValue;
 
    if (CurrentDisk == NULL)
    {
        ConResPuts(StdOut, IDS_SELECT_NO_DISK);
        return EXIT_SUCCESS;
    }
 
    if (argc == 2)
    {
        ConPuts(StdOut, L"\n");
        if (CurrentDisk->LayoutBuffer->PartitionStyle == PARTITION_STYLE_GPT)
            PrintGUID(szBuffer, &CurrentDisk->LayoutBuffer->Gpt.DiskId);
        else if (CurrentDisk->LayoutBuffer->PartitionStyle == PARTITION_STYLE_MBR)
            swprintf(szBuffer, L"%08lx", CurrentDisk->LayoutBuffer->Mbr.Signature);
        else
            wcscpy(szBuffer, L"00000000");
        ConPrintf(StdOut, L"Disk ID: %s\n", szBuffer);
        ConPuts(StdOut, L"\n");
        return EXIT_SUCCESS;
    }
 
    if (argc != 3)
    {
        ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
        return EXIT_SUCCESS;
    }
 
    for (i = 1; i < argc; i++)
    {
        if (_wcsicmp(argv[i], L"noerr") == 0)
        {
            /* noerr */
            DPRINT("NOERR\n");
            ConPuts(StdOut, L"The NOERR option is not supported yet!\n");
        }
    }
 
    for (i = 1; i < argc; i++)
    {
        if (HasPrefix(argv[2], L"id=", &pszSuffix))
        {
            /* id=<Byte>|<GUID> */
            DPRINT("ID : %s\n", pszSuffix);
            pszId = pszSuffix;
        }
        else if (_wcsicmp(argv[i], L"noerr") == 0)
        {
            /* noerr - Already handled above */
        }
        else
        {
            ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
            return EXIT_SUCCESS;
        }
    }
 
    if (CurrentDisk->PartitionStyle == PARTITION_STYLE_GPT)
    {
        if (!StringToGUID(&CurrentDisk->LayoutBuffer->Gpt.DiskId, pszId))
        {
            ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
            return EXIT_SUCCESS;
        }
 
        CurrentDisk->Dirty = TRUE;
        UpdateGptDiskLayout(CurrentDisk, FALSE);
        WriteGptPartitions(CurrentDisk);
    }
    else if (CurrentDisk->PartitionStyle == PARTITION_STYLE_MBR)
    {
        if ((pszId == NULL) ||
            (wcslen(pszId) != 8) ||
            (IsHexString(pszId) == FALSE))
        {
            ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
            return EXIT_SUCCESS;
        }
 
        ulValue = wcstoul(pszId, NULL, 16);
        if ((ulValue == 0) && (errno == ERANGE))
        {
            ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
            return EXIT_SUCCESS;
        }
 
        DPRINT("New Signature: 0x%08lx\n", ulValue);
        CurrentDisk->LayoutBuffer->Mbr.Signature = ulValue;
        CurrentDisk->Dirty = TRUE;
        UpdateMbrDiskLayout(CurrentDisk);
        WriteMbrPartitions(CurrentDisk);
    }
    else
    {
        ConResPuts(StdOut, IDS_UNIQUID_DISK_INVALID_STYLE);
    }
 
    return EXIT_SUCCESS;
}

UpdateGptDiskLayout()

VOID UpdateGptDiskLayout	(	_In_ PDISKENTRY	DiskEntry,
		_In_ BOOL	DeleteEntry
	)

Definition at line 2539 of file partlist.c.

{
    PLIST_ENTRY ListEntry;
    PPARTENTRY PartEntry;
    PPARTITION_INFORMATION_EX PartitionInfo;
    ULONG Count, Index;
 
    DPRINT("UpdateGptDiskLayout()\n");
 
    /* Count used partition entries */
    Count = 0;
    for (ListEntry = DiskEntry->PrimaryPartListHead.Flink;
         ListEntry != &DiskEntry->PrimaryPartListHead;
         ListEntry = ListEntry->Flink)
    {
        PartEntry = CONTAINING_RECORD(ListEntry, PARTENTRY, ListEntry);
 
        if (!IsEqualGUID(&PartEntry->Gpt.PartitionType, &PARTITION_ENTRY_UNUSED_GUID))
            Count++;
    }
 
    DPRINT("Used partition entries: %lu\n", Count);
 
    if (DeleteEntry)
        Count++;
 
    /* Reallocate the layout buffer */
    if (Count != DiskEntry->LayoutBuffer->PartitionCount)
    {
        PDRIVE_LAYOUT_INFORMATION_EX NewLayoutBuffer;
        ULONG NewLayoutBufferSize;
 
        NewLayoutBufferSize = sizeof(DRIVE_LAYOUT_INFORMATION_EX) +
                              ((Count - ANYSIZE_ARRAY) * sizeof(PARTITION_INFORMATION_EX));
        NewLayoutBuffer = RtlReAllocateHeap(RtlGetProcessHeap(),
                                            HEAP_ZERO_MEMORY,
                                            DiskEntry->LayoutBuffer,
                                            NewLayoutBufferSize);
        if (NewLayoutBuffer == NULL)
        {
            DPRINT1("Failed to allocate the new layout buffer (size: %lu)\n", NewLayoutBufferSize);
            return;
        }
 
        NewLayoutBuffer->PartitionCount = Count;
        DiskEntry->LayoutBuffer = NewLayoutBuffer;
    }
 
    /* Fill the new layout buffer */
    Index = 0;
    for (ListEntry = DiskEntry->PrimaryPartListHead.Flink;
         ListEntry != &DiskEntry->PrimaryPartListHead;
         ListEntry = ListEntry->Flink)
    {
        PartEntry = CONTAINING_RECORD(ListEntry, PARTENTRY, ListEntry);
 
        if (!IsEqualGUID(&PartEntry->Gpt.PartitionType, &PARTITION_ENTRY_UNUSED_GUID))
        {
            PartitionInfo = &DiskEntry->LayoutBuffer->PartitionEntry[Index];
            PartEntry->PartitionIndex = Index;
 
            DPRINT("Updating primary partition entry %lu\n", Index);
            PartitionInfo->PartitionStyle = PARTITION_STYLE_GPT;
            PartitionInfo->StartingOffset.QuadPart = PartEntry->StartSector.QuadPart * DiskEntry->BytesPerSector;
            PartitionInfo->PartitionLength.QuadPart = PartEntry->SectorCount.QuadPart * DiskEntry->BytesPerSector;
            PartitionInfo->PartitionNumber = Index + 1;
            PartitionInfo->RewritePartition = TRUE;
            CopyMemory(&PartitionInfo->Gpt.PartitionType, &PartEntry->Gpt.PartitionType, sizeof(GUID));
            CopyMemory(&PartitionInfo->Gpt.PartitionId, &PartEntry->Gpt.PartitionId, sizeof(GUID));
            PartitionInfo->Gpt.Attributes = PartEntry->Gpt.Attributes;
            ZeroMemory(&PartitionInfo->Gpt.Name, 36 * sizeof(WCHAR)); /* ??? */
 
            PartEntry->PartitionNumber = PartitionInfo->PartitionNumber;
 
            Index++;
        }
    }
 
    if (DeleteEntry)
    {
        PartitionInfo = &DiskEntry->LayoutBuffer->PartitionEntry[Index];
        ZeroMemory(PartitionInfo, sizeof(PARTITION_INFORMATION_EX));
        PartitionInfo->RewritePartition = TRUE;
    }
}

Referenced by CreateEfiPartition(), CreateMsrPartition(), CreatePrimaryGptPartition(), DeleteGptPartition(), gpt_main(), setid_main(), and UniqueIdDisk().

UpdateMbrDiskLayout()

VOID UpdateMbrDiskLayout

(

_In_ PDISKENTRY

DiskEntry

)

Definition at line 2362 of file partlist.c.

{
    PPARTITION_INFORMATION_EX PartitionInfo;
    PPARTITION_INFORMATION_EX LinkInfo = NULL;
    PLIST_ENTRY ListEntry;
    PPARTENTRY PartEntry;
    LARGE_INTEGER HiddenSectors64;
    ULONG Index;
    ULONG PartitionNumber = 1;
 
    DPRINT("UpdateMbrDiskLayout()\n");
 
    /* Resize the layout buffer if necessary */
    if (ReAllocateLayoutBuffer(DiskEntry) == FALSE)
    {
        DPRINT("ReAllocateLayoutBuffer() failed.\n");
        return;
    }
 
    DiskEntry->LayoutBuffer->PartitionStyle = PARTITION_STYLE_MBR;
 
    /* Update the primary partition table */
    Index = 0;
    for (ListEntry = DiskEntry->PrimaryPartListHead.Flink;
         ListEntry != &DiskEntry->PrimaryPartListHead;
         ListEntry = ListEntry->Flink)
    {
        PartEntry = CONTAINING_RECORD(ListEntry, PARTENTRY, ListEntry);
 
        if (PartEntry->IsPartitioned)
        {
            ASSERT(PartEntry->Mbr.PartitionType != PARTITION_ENTRY_UNUSED);
 
            PartitionInfo = &DiskEntry->LayoutBuffer->PartitionEntry[Index];
            PartEntry->PartitionIndex = Index;
 
            /* Reset the current partition number only for newly-created (unmounted) partitions */
            if (PartEntry->New)
                PartEntry->PartitionNumber = 0;
 
            PartEntry->OnDiskPartitionNumber = (!IsContainerPartition(PartEntry->Mbr.PartitionType) ? PartitionNumber : 0);
 
            if (!IsSamePrimaryLayoutEntry(PartitionInfo, DiskEntry, PartEntry))
            {
                DPRINT1("Updating primary partition entry %lu\n", Index);
 
                PartitionInfo->PartitionStyle = PARTITION_STYLE_MBR;
                PartitionInfo->StartingOffset.QuadPart = PartEntry->StartSector.QuadPart * DiskEntry->BytesPerSector;
                PartitionInfo->PartitionLength.QuadPart = PartEntry->SectorCount.QuadPart * DiskEntry->BytesPerSector;
                PartitionInfo->Mbr.HiddenSectors = PartEntry->StartSector.LowPart;
                PartitionInfo->PartitionNumber = PartEntry->PartitionNumber;
                PartitionInfo->Mbr.PartitionType = PartEntry->Mbr.PartitionType;
                PartitionInfo->Mbr.BootIndicator = PartEntry->Mbr.BootIndicator;
                PartitionInfo->Mbr.RecognizedPartition = IsRecognizedPartition(PartEntry->Mbr.PartitionType);
                PartitionInfo->RewritePartition = TRUE;
            }
 
            if (!IsContainerPartition(PartEntry->Mbr.PartitionType))
                PartitionNumber++;
 
            Index++;
        }
    }
 
    ASSERT(Index <= 4);
 
    /* Update the logical partition table */
    Index = 4;
    for (ListEntry = DiskEntry->LogicalPartListHead.Flink;
         ListEntry != &DiskEntry->LogicalPartListHead;
         ListEntry = ListEntry->Flink)
    {
        PartEntry = CONTAINING_RECORD(ListEntry, PARTENTRY, ListEntry);
 
        if (PartEntry->IsPartitioned)
        {
            ASSERT(PartEntry->Mbr.PartitionType != PARTITION_ENTRY_UNUSED);
 
            PartitionInfo = &DiskEntry->LayoutBuffer->PartitionEntry[Index];
            PartEntry->PartitionIndex = Index;
 
            /* Reset the current partition number only for newly-created (unmounted) partitions */
            if (PartEntry->New)
                PartEntry->PartitionNumber = 0;
 
            PartEntry->OnDiskPartitionNumber = PartitionNumber;
 
            DPRINT1("Updating logical partition entry %lu\n", Index);
 
            PartitionInfo->PartitionStyle = PARTITION_STYLE_MBR;
            PartitionInfo->StartingOffset.QuadPart = PartEntry->StartSector.QuadPart * DiskEntry->BytesPerSector;
            PartitionInfo->PartitionLength.QuadPart = PartEntry->SectorCount.QuadPart * DiskEntry->BytesPerSector;
            PartitionInfo->Mbr.HiddenSectors = DiskEntry->SectorAlignment;
            PartitionInfo->PartitionNumber = PartEntry->PartitionNumber;
            PartitionInfo->Mbr.PartitionType = PartEntry->Mbr.PartitionType;
            PartitionInfo->Mbr.BootIndicator = FALSE;
            PartitionInfo->Mbr.RecognizedPartition = IsRecognizedPartition(PartEntry->Mbr.PartitionType);
            PartitionInfo->RewritePartition = TRUE;
 
            /* Fill the link entry of the previous partition entry */
            if (LinkInfo != NULL)
            {
                LinkInfo->PartitionStyle = PARTITION_STYLE_MBR;
                LinkInfo->StartingOffset.QuadPart = (PartEntry->StartSector.QuadPart - DiskEntry->SectorAlignment) * DiskEntry->BytesPerSector;
                LinkInfo->PartitionLength.QuadPart = (PartEntry->StartSector.QuadPart + DiskEntry->SectorAlignment) * DiskEntry->BytesPerSector;
                HiddenSectors64.QuadPart = PartEntry->StartSector.QuadPart - DiskEntry->SectorAlignment - DiskEntry->ExtendedPartition->StartSector.QuadPart;
                LinkInfo->Mbr.HiddenSectors = HiddenSectors64.LowPart;
                LinkInfo->PartitionNumber = 0;
                LinkInfo->Mbr.PartitionType = PARTITION_EXTENDED;
                LinkInfo->Mbr.BootIndicator = FALSE;
                LinkInfo->Mbr.RecognizedPartition = FALSE;
                LinkInfo->RewritePartition = TRUE;
            }
 
            /* Save a pointer to the link entry of the current partition entry */
            LinkInfo = &DiskEntry->LayoutBuffer->PartitionEntry[Index + 1];
 
            PartitionNumber++;
            Index += 4;
        }
    }
 
    /* Wipe unused primary partition entries */
    for (Index = GetPrimaryPartitionCount(DiskEntry); Index < 4; Index++)
    {
        DPRINT1("Primary partition entry %lu\n", Index);
 
        PartitionInfo = &DiskEntry->LayoutBuffer->PartitionEntry[Index];
 
        if (!IsEmptyLayoutEntry(PartitionInfo))
        {
            DPRINT1("Wiping primary partition entry %lu\n", Index);
 
            PartitionInfo->PartitionStyle = PARTITION_STYLE_MBR;
            PartitionInfo->StartingOffset.QuadPart = 0;
            PartitionInfo->PartitionLength.QuadPart = 0;
            PartitionInfo->Mbr.HiddenSectors = 0;
            PartitionInfo->PartitionNumber = 0;
            PartitionInfo->Mbr.PartitionType = PARTITION_ENTRY_UNUSED;
            PartitionInfo->Mbr.BootIndicator = FALSE;
            PartitionInfo->Mbr.RecognizedPartition = FALSE;
            PartitionInfo->RewritePartition = TRUE;
        }
    }
 
    /* Wipe unused logical partition entries */
    for (Index = 4; Index < DiskEntry->LayoutBuffer->PartitionCount; Index++)
    {
        if (Index % 4 >= 2)
        {
            DPRINT1("Logical partition entry %lu\n", Index);
 
            PartitionInfo = &DiskEntry->LayoutBuffer->PartitionEntry[Index];
 
            if (!IsEmptyLayoutEntry(PartitionInfo))
            {
                DPRINT1("Wiping partition entry %lu\n", Index);
 
                PartitionInfo->PartitionStyle = PARTITION_STYLE_MBR;
                PartitionInfo->StartingOffset.QuadPart = 0;
                PartitionInfo->PartitionLength.QuadPart = 0;
                PartitionInfo->Mbr.HiddenSectors = 0;
                PartitionInfo->PartitionNumber = 0;
                PartitionInfo->Mbr.PartitionType = PARTITION_ENTRY_UNUSED;
                PartitionInfo->Mbr.BootIndicator = FALSE;
                PartitionInfo->Mbr.RecognizedPartition = FALSE;
                PartitionInfo->RewritePartition = TRUE;
            }
        }
    }
 
    DiskEntry->Dirty = TRUE;
}

Referenced by active_main(), CreateExtendedPartition(), CreateLogicalPartition(), CreatePrimaryMbrPartition(), DeleteMbrPartition(), inactive_main(), setid_main(), and UniqueIdDisk().

WriteGptPartitions()

NTSTATUS WriteGptPartitions

(

_In_ PDISKENTRY

DiskEntry

)

Definition at line 2158 of file partlist.c.

{
    NTSTATUS Status;
    OBJECT_ATTRIBUTES ObjectAttributes;
    UNICODE_STRING Name;
    HANDLE FileHandle;
    IO_STATUS_BLOCK Iosb;
    ULONG BufferSize;
    WCHAR DstPath[MAX_PATH];
 
    DPRINT("WriteGptPartitions() Disk: %lu\n", DiskEntry->DiskNumber);
 
    /* If the disk is not dirty, there is nothing to do */
    if (!DiskEntry->Dirty)
        return STATUS_SUCCESS;
 
    StringCchPrintfW(DstPath, ARRAYSIZE(DstPath),
                     L"\\Device\\Harddisk%lu\\Partition0",
                     DiskEntry->DiskNumber);
    RtlInitUnicodeString(&Name, DstPath);
 
    InitializeObjectAttributes(&ObjectAttributes,
                               &Name,
                               OBJ_CASE_INSENSITIVE,
                               NULL,
                               NULL);
 
    Status = NtOpenFile(&FileHandle,
                        GENERIC_READ | GENERIC_WRITE | SYNCHRONIZE,
                        &ObjectAttributes,
                        &Iosb,
                        0,
                        FILE_SYNCHRONOUS_IO_NONALERT);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("NtOpenFile() failed (Status %lx)\n", Status);
        return Status;
    }
 
    //
    // FIXME: We first *MUST* use IOCTL_DISK_CREATE_DISK to initialize
    // the disk in MBR or GPT format in case the disk was not initialized!!
    // For this we must ask the user which format to use.
    //
 
    /* Set the new disk layout and retrieve its updated version with possibly modified partition numbers */
    BufferSize = sizeof(DRIVE_LAYOUT_INFORMATION_EX) +
                 ((DiskEntry->LayoutBuffer->PartitionCount - 1) * sizeof(PARTITION_INFORMATION_EX));
    Status = NtDeviceIoControlFile(FileHandle,
                                   NULL,
                                   NULL,
                                   NULL,
                                   &Iosb,
                                   IOCTL_DISK_SET_DRIVE_LAYOUT_EX,
                                   DiskEntry->LayoutBuffer,
                                   BufferSize,
                                   DiskEntry->LayoutBuffer,
                                   BufferSize);
    NtClose(FileHandle);
 
    /* Check whether the IOCTL_DISK_SET_DRIVE_LAYOUT_EX call succeeded */
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("IOCTL_DISK_SET_DRIVE_LAYOUT_EX failed (Status 0x%08lx)\n", Status);
        return Status;
    }
 
    /* The layout has been successfully updated, the disk is not dirty anymore */
    DiskEntry->Dirty = FALSE;
 
    return Status;
}

Referenced by CreateEfiPartition(), CreateMsrPartition(), CreatePrimaryGptPartition(), DeleteGptPartition(), gpt_main(), setid_main(), and UniqueIdDisk().

WriteMbrPartitions()

NTSTATUS WriteMbrPartitions

(

_In_ PDISKENTRY

DiskEntry

)

Definition at line 2034 of file partlist.c.

{
    NTSTATUS Status;
    OBJECT_ATTRIBUTES ObjectAttributes;
    UNICODE_STRING Name;
    HANDLE FileHandle;
    IO_STATUS_BLOCK Iosb;
    ULONG BufferSize;
    PPARTITION_INFORMATION_EX PartitionInfo;
    ULONG PartitionCount;
    PLIST_ENTRY ListEntry;
    PPARTENTRY PartEntry;
    WCHAR DstPath[MAX_PATH];
 
    DPRINT("WriteMbrPartitions() Disk: %lu\n", DiskEntry->DiskNumber);
 
    /* If the disk is not dirty, there is nothing to do */
    if (!DiskEntry->Dirty)
        return STATUS_SUCCESS;
 
    StringCchPrintfW(DstPath, ARRAYSIZE(DstPath),
                     L"\\Device\\Harddisk%lu\\Partition0",
                     DiskEntry->DiskNumber);
    RtlInitUnicodeString(&Name, DstPath);
 
    InitializeObjectAttributes(&ObjectAttributes,
                               &Name,
                               OBJ_CASE_INSENSITIVE,
                               NULL,
                               NULL);
 
    Status = NtOpenFile(&FileHandle,
                        GENERIC_READ | GENERIC_WRITE | SYNCHRONIZE,
                        &ObjectAttributes,
                        &Iosb,
                        0,
                        FILE_SYNCHRONOUS_IO_NONALERT);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("NtOpenFile() failed (Status %lx)\n", Status);
        return Status;
    }
 
    //
    // FIXME: We first *MUST* use IOCTL_DISK_CREATE_DISK to initialize
    // the disk in MBR or GPT format in case the disk was not initialized!!
    // For this we must ask the user which format to use.
    //
 
    /* Save the original partition count to be restored later (see comment below) */
    PartitionCount = DiskEntry->LayoutBuffer->PartitionCount;
 
    /* Set the new disk layout and retrieve its updated version with possibly modified partition numbers */
    BufferSize = sizeof(DRIVE_LAYOUT_INFORMATION_EX) +
                 ((PartitionCount - 1) * sizeof(PARTITION_INFORMATION_EX));
    Status = NtDeviceIoControlFile(FileHandle,
                                   NULL,
                                   NULL,
                                   NULL,
                                   &Iosb,
                                   IOCTL_DISK_SET_DRIVE_LAYOUT_EX,
                                   DiskEntry->LayoutBuffer,
                                   BufferSize,
                                   DiskEntry->LayoutBuffer,
                                   BufferSize);
    NtClose(FileHandle);
 
    /*
     * IOCTL_DISK_SET_DRIVE_LAYOUT calls IoWritePartitionTable(), which converts
     * DiskEntry->LayoutBuffer->PartitionCount into a partition *table* count,
     * where such a table is expected to enumerate up to 4 partitions:
     * partition *table* count == ROUND_UP(PartitionCount, 4) / 4 .
     * Due to this we need to restore the original PartitionCount number.
     */
    DiskEntry->LayoutBuffer->PartitionCount = PartitionCount;
 
    /* Check whether the IOCTL_DISK_SET_DRIVE_LAYOUT call succeeded */
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("IOCTL_DISK_SET_DRIVE_LAYOUT failed (Status 0x%08lx)\n", Status);
        return Status;
    }
 
    /* Update the partition numbers */
 
    /* Update the primary partition table */
    for (ListEntry = DiskEntry->PrimaryPartListHead.Flink;
         ListEntry != &DiskEntry->PrimaryPartListHead;
         ListEntry = ListEntry->Flink)
    {
        PartEntry = CONTAINING_RECORD(ListEntry, PARTENTRY, ListEntry);
 
        if (PartEntry->IsPartitioned)
        {
            ASSERT(PartEntry->Mbr.PartitionType != PARTITION_ENTRY_UNUSED);
            PartitionInfo = &DiskEntry->LayoutBuffer->PartitionEntry[PartEntry->PartitionIndex];
            PartEntry->PartitionNumber = PartitionInfo->PartitionNumber;
        }
    }
 
    /* Update the logical partition table */
    for (ListEntry = DiskEntry->LogicalPartListHead.Flink;
         ListEntry != &DiskEntry->LogicalPartListHead;
         ListEntry = ListEntry->Flink)
    {
        PartEntry = CONTAINING_RECORD(ListEntry, PARTENTRY, ListEntry);
 
        if (PartEntry->IsPartitioned)
        {
            ASSERT(PartEntry->Mbr.PartitionType != PARTITION_ENTRY_UNUSED);
            PartitionInfo = &DiskEntry->LayoutBuffer->PartitionEntry[PartEntry->PartitionIndex];
            PartEntry->PartitionNumber = PartitionInfo->PartitionNumber;
        }
    }
 
    /* The layout has been successfully updated, the disk is not dirty anymore */
    DiskEntry->Dirty = FALSE;
 
    return Status;
}

Referenced by active_main(), CreateExtendedPartition(), CreateLogicalPartition(), CreatePrimaryMbrPartition(), DeleteMbrPartition(), inactive_main(), setid_main(), and UniqueIdDisk().

Variable Documentation

BiosDiskListHead

LIST_ENTRY BiosDiskListHead

extern

Definition at line 72 of file partlist.c.

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

cmds

COMMAND cmds[]

extern

Definition at line 21 of file main.c.

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

CurrentDisk

PDISKENTRY CurrentDisk

extern

Definition at line 75 of file partlist.c.

Referenced by active_main(), clean_main(), ConvertGPT(), ConvertMBR(), CreateDisk(), CreateEfiPartition(), CreateExtendedPartition(), CreateLogicalPartition(), CreateMsrPartition(), CreatePartitionList(), CreatePrimaryGptPartition(), CreatePrimaryMbrPartition(), CreatePrimaryPartition(), DeleteGptPartition(), DeleteMbrPartition(), DeletePartition(), DestroyPartitionList(), DetailDisk(), DetailPartition(), DumpDisk(), DumpPartition(), GetNextPartition(), GetPrevPartition(), gpt_main(), inactive_main(), ListPartition(), PrintDisk(), SelectDisk(), SelectPartition(), SelectVolume(), setid_main(), and UniqueIdDisk().

CurrentPartition

PPARTENTRY CurrentPartition

extern

Definition at line 76 of file partlist.c.

Referenced by CreatePartitionList(), and DestroyPartitionList().

CurrentVolume

PVOLENTRY CurrentVolume

extern

Definition at line 77 of file partlist.c.

Referenced by assign_main(), CreateVolumeList(), DestroyVolumeList(), DetailVolume(), filesystems_main(), format_main(), PrintVolume(), remove_main(), RemoveVolume(), and SelectVolume().

DiskListHead

LIST_ENTRY DiskListHead

extern

Definition at line 71 of file partlist.c.

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

VolumeListHead

LIST_ENTRY VolumeListHead

extern

Definition at line 73 of file partlist.c.

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