diskpart.h File Reference

#include <stdio.h>
#include <stdlib.h>
#include <windef.h>
#include <winbase.h>
#include <winreg.h>
#include <wincon.h>
#include <winioctl.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 <fmifs/fmifs.h>
#include "resource.h"

Include dependency graph for diskpart.h:

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

Go to the source code of this file.

Classes
struct	_COMMAND
struct	_PARTENTRY
struct	_BIOSDISKENTRY
struct	_DISKENTRY
struct	_VOLENTRY

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

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

Enumerations
enum	_FORMATSTATE {   Unformatted , UnformattedOrDamaged , UnknownFormat , Formatted ,   Unformatted , UnformattedOrDamaged , UnknownFormat , Preformatted ,   Formatted }
enum	_VOLUME_TYPE { VOLUME_TYPE_CDROM , VOLUME_TYPE_PARTITION , VOLUME_TYPE_REMOVABLE , VOLUME_TYPE_UNKNOWN }

Functions
BOOL	active_main (INT argc, LPWSTR *argv)
BOOL	add_main (INT argc, LPWSTR *argv)
BOOL	assign_main (INT argc, LPWSTR *argv)
BOOL	attach_main (INT argc, LPWSTR *argv)
BOOL	attributes_main (INT argc, LPWSTR *argv)
BOOL	automount_main (INT argc, LPWSTR *argv)
BOOL	break_main (INT argc, LPWSTR *argv)
BOOL	clean_main (INT argc, LPWSTR *argv)
BOOL	compact_main (INT argc, LPWSTR *argv)
BOOL	convert_main (INT argc, LPWSTR *argv)
BOOL	CreateExtendedPartition (_In_ INT argc, _In_ PWSTR *argv)
BOOL	CreateLogicalPartition (_In_ INT argc, _In_ PWSTR *argv)
BOOL	CreatePrimaryPartition (_In_ INT argc, _In_ PWSTR *argv)
BOOL	DeleteDisk (_In_ INT argc, _In_ PWSTR *argv)
BOOL	DeletePartition (_In_ INT argc, _In_ PWSTR *argv)
BOOL	DeleteVolume (_In_ INT argc, _In_ PWSTR *argv)
BOOL	detach_main (INT argc, LPWSTR *argv)
BOOL	DetailDisk (INT argc, PWSTR *argv)
BOOL	DetailPartition (INT argc, PWSTR *argv)
BOOL	DetailVolume (INT argc, PWSTR *argv)
BOOL	DumpDisk (_In_ INT argc, _In_ LPWSTR *argv)
BOOL	DumpPartition (_In_ INT argc, _In_ LPWSTR *argv)
BOOL	expand_main (INT argc, LPWSTR *argv)
BOOL	extend_main (INT argc, LPWSTR *argv)
BOOL	filesystems_main (INT argc, LPWSTR *argv)
BOOL	format_main (INT argc, LPWSTR *argv)
BOOL	gpt_main (INT argc, LPWSTR *argv)
BOOL	help_main (INT argc, LPWSTR *argv)
VOID	HelpCommandList (VOID)
BOOL	HelpCommand (PCOMMAND pCommand)
BOOL	import_main (INT argc, LPWSTR *argv)
BOOL	inactive_main (INT argc, LPWSTR *argv)
BOOL	InterpretScript (LPWSTR line)
BOOL	InterpretCmd (INT argc, LPWSTR *argv)
VOID	InterpretMain (VOID)
BOOL	ListDisk (INT argc, PWSTR *argv)
BOOL	ListPartition (INT argc, PWSTR *argv)
BOOL	ListVolume (INT argc, PWSTR *argv)
BOOL	ListVirtualDisk (INT argc, PWSTR *argv)
VOID	PrintDisk (_In_ PDISKENTRY DiskEntry)
VOID	PrintVolume (_In_ PVOLENTRY VolumeEntry)
BOOL	merge_main (INT argc, LPWSTR *argv)
BOOL	IsDecString (_In_ PWSTR pszDecString)
BOOL	IsHexString (_In_ PWSTR pszHexString)
BOOL	HasPrefix (_In_ PWSTR pszString, _In_ PWSTR pszPrefix, _Out_opt_ PWSTR *pszSuffix)
ULONGLONG	RoundingDivide (_In_ ULONGLONG Dividend, _In_ ULONGLONG Divisor)
PWSTR	DuplicateQuotedString (_In_ PWSTR pszInString)
PWSTR	DuplicateString (_In_ PWSTR pszInString)
BOOL	offline_main (INT argc, LPWSTR *argv)
BOOL	online_main (INT argc, LPWSTR *argv)
ULONGLONG	AlignDown (_In_ ULONGLONG Value, _In_ ULONG Alignment)
NTSTATUS	CreatePartitionList (VOID)
VOID	DestroyPartitionList (VOID)
NTSTATUS	CreateVolumeList (VOID)
VOID	DestroyVolumeList (VOID)
NTSTATUS	WritePartitions (_In_ PDISKENTRY DiskEntry)
VOID	UpdateDiskLayout (_In_ PDISKENTRY DiskEntry)
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)
BOOL	recover_main (INT argc, LPWSTR *argv)
BOOL	remove_main (INT argc, LPWSTR *argv)
BOOL	repair_main (INT argc, LPWSTR *argv)
BOOL	rescan_main (INT argc, LPWSTR *argv)
BOOL	retain_main (INT argc, LPWSTR *argv)
BOOL	san_main (INT argc, LPWSTR *argv)
BOOL	SelectDisk (INT argc, PWSTR *argv)
BOOL	SelectPartition (INT argc, PWSTR *argv)
BOOL	SelectVolume (INT argc, PWSTR *argv)
BOOL	setid_main (INT argc, LPWSTR *argv)
BOOL	shrink_main (INT argc, LPWSTR *argv)
BOOL	UniqueIdDisk (_In_ INT argc, _In_ PWSTR *argv)

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

Macro Definition Documentation

MAX_ARGS_COUNT

#define MAX_ARGS_COUNT   256

Definition at line 78 of file diskpart.h.

MAX_STRING_SIZE

#define MAX_STRING_SIZE   1024

Definition at line 77 of file diskpart.h.

NTOS_MODE_USER

#define NTOS_MODE_USER

Definition at line 39 of file diskpart.h.

WIN32_NO_STATUS

#define WIN32_NO_STATUS

Definition at line 17 of file diskpart.h.

Typedef Documentation

BIOSDISKENTRY

typedef struct _BIOSDISKENTRY BIOSDISKENTRY

COMMAND

typedef struct _COMMAND COMMAND

DISKENTRY

typedef struct _DISKENTRY DISKENTRY

FORMATSTATE

typedef enum _FORMATSTATE FORMATSTATE

PARTENTRY

typedef struct _PARTENTRY PARTENTRY

PBIOSDISKENTRY

typedef struct _BIOSDISKENTRY * PBIOSDISKENTRY

PCOMMAND

typedef struct _COMMAND * PCOMMAND

PDISKENTRY

typedef struct _DISKENTRY * PDISKENTRY

PFORMATSTATE

typedef enum _FORMATSTATE * PFORMATSTATE

PPARTENTRY

typedef struct _PARTENTRY * PPARTENTRY

PVOLENTRY

typedef struct _VOLENTRY * PVOLENTRY

PVOLUME_TYPE

typedef enum _VOLUME_TYPE * PVOLUME_TYPE

VOLENTRY

typedef struct _VOLENTRY VOLENTRY

VOLUME_TYPE

typedef enum _VOLUME_TYPE VOLUME_TYPE

Enumeration Type Documentation

_FORMATSTATE

enum _FORMATSTATE

Enumerator
Unformatted
UnformattedOrDamaged
UnknownFormat
Formatted
Unformatted
UnformattedOrDamaged
UnknownFormat
Preformatted
Formatted

Definition at line 81 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 90 of file diskpart.h.

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

Function Documentation

active_main()

BOOL active_main	(	INT	argc,
		LPWSTR *	argv
	)

add_main()

BOOL add_main	(	INT	argc,
		LPWSTR *	argv
	)

Definition at line 11 of file add.c.

{
    return TRUE;
}

AlignDown()

ULONGLONG AlignDown	(	_In_ ULONGLONG	Value,
		_In_ ULONG	Alignment
	)

Definition at line 84 of file partlist.c.

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

assign_main()

BOOL assign_main	(	INT	argc,
		LPWSTR *	argv
	)

Definition at line 11 of file assign.c.

{
    return TRUE;
}

attach_main()

BOOL attach_main	(	INT	argc,
		LPWSTR *	argv
	)

Definition at line 11 of file attach.c.

{
    return TRUE;
}

attributes_main()

BOOL attributes_main	(	INT	argc,
		LPWSTR *	argv
	)

Definition at line 11 of file attributes.c.

{
    return TRUE;
}

automount_main()

BOOL automount_main	(	INT	argc,
		LPWSTR *	argv
	)

Definition at line 11 of file automount.c.

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

break_main()

BOOL break_main	(	INT	argc,
		LPWSTR *	argv
	)

Definition at line 11 of file break.c.

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

clean_main()

BOOL clean_main	(	INT	argc,
		LPWSTR *	argv
	)

compact_main()

BOOL compact_main	(	INT	argc,
		LPWSTR *	argv
	)

Definition at line 11 of file compact.c.

{
    return 0;
}

convert_main()

BOOL convert_main	(	INT	argc,
		LPWSTR *	argv
	)

Definition at line 11 of file convert.c.

{
    return TRUE;
}

CreateExtendedPartition()

BOOL CreateExtendedPartition	(	_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;
 
    if (CurrentDisk == NULL)
    {
        ConResPuts(StdOut, IDS_SELECT_NO_DISK);
        return TRUE;
    }
 
    for (i = 3; i < argc; i++)
    {
        if (HasPrefix(argv[i], L"size=", &pszSuffix))
        {
            /* size=<N> (MB) */
            DPRINT("Size : %s\n", pszSuffix);
 
            ullSize = _wcstoui64(pszSuffix, NULL, 10);
            if ((ullSize == 0) && (errno == ERANGE))
            {
                ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
                return TRUE;
            }
        }
        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 (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 */
            DPRINT("NoErr\n", pszSuffix);
            ConPuts(StdOut, L"The NOERR option is not supported yet!\n");
#if 0
            bNoErr = TRUE;
#endif
        }
        else
        {
            ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
            return TRUE;
        }
    }
 
    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 TRUE;
    }
 
    if (CurrentDisk->ExtendedPartition != NULL)
    {
        ConPuts(StdOut, L"We already have an extended partition on this disk!\n");
        return TRUE;
    }
 
    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 TRUE;
    }
 
    if (ullSectorCount == 0)
    {
        PartEntry->IsPartitioned = TRUE;
        PartEntry->New = TRUE;
        PartEntry->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->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->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;
        }
    }
 
    UpdateDiskLayout(CurrentDisk);
    Status = WritePartitions(CurrentDisk);
    if (!NT_SUCCESS(Status))
    {
        ConResPuts(StdOut, IDS_CREATE_PARTITION_FAIL);
        CurrentPartition = NULL;
        return TRUE;
    }
 
    ConResPuts(StdOut, IDS_CREATE_PARTITION_SUCCESS);
 
    return TRUE;
}

CreateLogicalPartition()

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

Definition at line 195 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 TRUE;
    }
 
    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 TRUE;
            }
        }
        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 (HasPrefix(argv[i], L"id=", &pszSuffix))
        {
            /* id=<Byte>|<GUID> */
            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 TRUE;
                }
            }
#if 0
            else if ()
            {
                /* GUID */
            }
#endif
            else
            {
                ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
                return TRUE; 
            }
        }
        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 */
            DPRINT("NoErr\n", pszSuffix);
            ConPuts(StdOut, L"The NOERR option is not supported yet!\n");
#if 0
            bNoErr = TRUE;
#endif
        }
        else
        {
            ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
            return TRUE;
        }
    }
 
    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->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->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->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;
            }
        }
    }
 
    UpdateDiskLayout(CurrentDisk);
    Status = WritePartitions(CurrentDisk);
    if (!NT_SUCCESS(Status))
    {
        ConResPuts(StdOut, IDS_CREATE_PARTITION_FAIL);
        CurrentPartition = NULL;
        return TRUE;
    }
 
    ConResPuts(StdOut, IDS_CREATE_PARTITION_SUCCESS);
 
    return TRUE;
}

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

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

Definition at line 395 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 TRUE;
    }
 
    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 TRUE;
            }
        }
        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 (HasPrefix(argv[i], L"id=", &pszSuffix))
        {
            /* id=<Byte>|<GUID> */
            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 TRUE;
                }
            }
#if 0
            else if ()
            {
                /* GUID */
            }
#endif
            else
            {
                ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
                return TRUE; 
            }
        }
        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 */
            DPRINT("NoErr\n", pszSuffix);
            ConPuts(StdOut, L"The NOERR option is not supported yet!\n");
#if 0
            bNoErr = TRUE;
#endif
        }
        else
        {
            ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
            return TRUE;
        }
    }
 
    DPRINT1("Size: %I64u\n", ullSize);
#if 0
    DPRINT1("Offset: %I64u\n", ullOffset);
#endif
    DPRINT1("Partition Type: %hx\n", PartitionType);
 
    if (GetPrimaryPartitionCount(CurrentDisk) >= 4)
    {
        ConPuts(StdOut, L"No space left for another primary partition!\n");
        return TRUE;
    }
 
    if (ullSize != 0)
        ullSectorCount = (ullSize * 1024 * 1024) / CurrentDisk->BytesPerSector;
    else
        ullSectorCount = 0;
 
    DPRINT1("SectorCount: %I64u\n", ullSectorCount);
 
    for (ListEntry = CurrentDisk->PrimaryPartListHead.Flink;
         ListEntry != &CurrentDisk->PrimaryPartListHead;
         ListEntry = ListEntry->Flink)
    {
        PartEntry = CONTAINING_RECORD(ListEntry, PARTENTRY, ListEntry);
        if (PartEntry->IsPartitioned)
            continue;
 
        if (ullSectorCount == 0)
        {
            PartEntry->IsPartitioned = TRUE;
            PartEntry->New = TRUE;
            PartEntry->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->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 = FALSE;
                NewPartEntry->IsPartitioned = TRUE;
                NewPartEntry->New = TRUE;
                NewPartEntry->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;
            }
        }
    }
 
    UpdateDiskLayout(CurrentDisk);
    Status = WritePartitions(CurrentDisk);
    if (!NT_SUCCESS(Status))
    {
        ConResPuts(StdOut, IDS_CREATE_PARTITION_FAIL);
        CurrentPartition = NULL;
        return TRUE;
    }
 
    ConResPuts(StdOut, IDS_CREATE_PARTITION_SUCCESS);
 
    return TRUE;
}

CreateVolumeList()

NTSTATUS CreateVolumeList

(

VOID

)

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

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

Definition at line 28 of file delete.c.

{
    return TRUE;
}

DeletePartition()

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

Definition at line 37 of file delete.c.

{
    PPARTENTRY PrevPartEntry;
    PPARTENTRY NextPartEntry;
    PPARTENTRY LogicalPartEntry;
    PLIST_ENTRY Entry;
    INT i;
    BOOL bOverride = FALSE;
    NTSTATUS Status;
 
    DPRINT("DeletePartition()\n");
 
    if (CurrentDisk == NULL)
    {
        ConResPuts(StdOut, IDS_SELECT_NO_DISK);
        return TRUE;
    }
 
    if (CurrentPartition == NULL)
    {
        ConResPuts(StdOut, IDS_SELECT_NO_PARTITION);
        return TRUE;
    }
 
    ASSERT(CurrentPartition->PartitionType != PARTITION_ENTRY_UNUSED);
 
    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
        }
        else if (_wcsicmp(argv[i], L"override") == 0)
        {
            /* override */
            DPRINT("OVERRIDE\n");
            bOverride = TRUE;
        }
        else
        {
            ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
            return TRUE;
        }
    }
 
 
    /* Clear the system partition if it is being deleted */
#if 0
    if (List->SystemPartition == PartEntry)
    {
        ASSERT(List->SystemPartition);
        List->SystemPartition = NULL;
    }
#endif
 
    if ((bOverride == FALSE) && (IsKnownPartition(CurrentPartition) == FALSE))
    {
        ConResPuts(StdOut, IDS_DELETE_PARTITION_FAIL);
        return FALSE;
    }
 
    /* Check which type of partition (primary/logical or extended) is being deleted */
    if (CurrentDisk->ExtendedPartition == CurrentPartition)
    {
        /* An extended partition is being deleted: delete all logical partition entries */
        while (!IsListEmpty(&CurrentDisk->LogicalPartListHead))
        {
            Entry = RemoveHeadList(&CurrentDisk->LogicalPartListHead);
            LogicalPartEntry = CONTAINING_RECORD(Entry, PARTENTRY, ListEntry);
 
            /* Dismount the logical partition */
            DismountVolume(LogicalPartEntry);
 
            /* Delete it */
            RtlFreeHeap(RtlGetProcessHeap(), 0, LogicalPartEntry);
        }
 
        CurrentDisk->ExtendedPartition = NULL;
    }
    else
    {
        /* A primary partition is being deleted: dismount it */
        DismountVolume(CurrentPartition);
    }
 
    /* Adjust the unpartitioned disk space entries */
 
    /* Get pointer to previous and next unpartitioned entries */
    PrevPartEntry = GetPrevUnpartitionedEntry(CurrentPartition);
    NextPartEntry = GetNextUnpartitionedEntry(CurrentPartition);
 
    if (PrevPartEntry != NULL && NextPartEntry != NULL)
    {
        /* Merge the previous, current and next unpartitioned entries */
 
        /* Adjust the previous entry length */
        PrevPartEntry->SectorCount.QuadPart += (CurrentPartition->SectorCount.QuadPart + NextPartEntry->SectorCount.QuadPart);
 
        /* Remove the current and next entries */
        RemoveEntryList(&CurrentPartition->ListEntry);
        RtlFreeHeap(RtlGetProcessHeap(), 0, CurrentPartition);
        RemoveEntryList(&NextPartEntry->ListEntry);
        RtlFreeHeap(RtlGetProcessHeap(), 0, NextPartEntry);
    }
    else if (PrevPartEntry != NULL && NextPartEntry == NULL)
    {
        /* Merge the current and the previous unpartitioned entries */
 
        /* Adjust the previous entry length */
        PrevPartEntry->SectorCount.QuadPart += CurrentPartition->SectorCount.QuadPart;
 
        /* Remove the current entry */
        RemoveEntryList(&CurrentPartition->ListEntry);
        RtlFreeHeap(RtlGetProcessHeap(), 0, CurrentPartition);
    }
    else if (PrevPartEntry == NULL && NextPartEntry != NULL)
    {
        /* Merge the current and the next unpartitioned entries */
 
        /* Adjust the next entry offset and length */
        NextPartEntry->StartSector.QuadPart = CurrentPartition->StartSector.QuadPart;
        NextPartEntry->SectorCount.QuadPart += CurrentPartition->SectorCount.QuadPart;
 
        /* Remove the current entry */
        RemoveEntryList(&CurrentPartition->ListEntry);
        RtlFreeHeap(RtlGetProcessHeap(), 0, CurrentPartition);
    }
    else
    {
        /* Nothing to merge but change the current entry */
        CurrentPartition->IsPartitioned = FALSE;
        CurrentPartition->OnDiskPartitionNumber = 0;
        CurrentPartition->PartitionNumber = 0;
        // CurrentPartition->PartitionIndex = 0;
        CurrentPartition->BootIndicator = FALSE;
        CurrentPartition->PartitionType = PARTITION_ENTRY_UNUSED;
        CurrentPartition->FormatState = Unformatted;
        CurrentPartition->FileSystemName[0] = L'\0';
        CurrentPartition->DriveLetter = 0;
        RtlZeroMemory(CurrentPartition->VolumeLabel, sizeof(CurrentPartition->VolumeLabel));
    }
 
    CurrentPartition = NULL;
 
    UpdateDiskLayout(CurrentDisk);
    Status = WritePartitions(CurrentDisk);
    if (!NT_SUCCESS(Status))
    {
        ConResPuts(StdOut, IDS_DELETE_PARTITION_FAIL);
        return TRUE;
    }
 
    ConResPuts(StdOut, IDS_DELETE_PARTITION_SUCCESS);
 
    return TRUE;
}

DeleteVolume()

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

Definition at line 203 of file delete.c.

{
    return TRUE;
}

DestroyPartitionList()

VOID DestroyPartitionList

(

VOID

)

Definition at line 1133 of file partlist.c.

{
    PDISKENTRY DiskEntry;
    PBIOSDISKENTRY BiosDiskEntry;
    PPARTENTRY PartEntry;
    PLIST_ENTRY Entry;
 
    CurrentDisk = NULL;
    CurrentPartition = NULL;
 
    /* Release disk and partition info */
    while (!IsListEmpty(&DiskListHead))
    {
        Entry = RemoveHeadList(&DiskListHead);
        DiskEntry = CONTAINING_RECORD(Entry, DISKENTRY, ListEntry);
 
        /* Release driver name */
        RtlFreeUnicodeString(&DiskEntry->DriverName);
 
        /* Release primary partition list */
        while (!IsListEmpty(&DiskEntry->PrimaryPartListHead))
        {
            Entry = RemoveHeadList(&DiskEntry->PrimaryPartListHead);
            PartEntry = CONTAINING_RECORD(Entry, PARTENTRY, ListEntry);
 
            RtlFreeHeap(RtlGetProcessHeap(), 0, PartEntry);
        }
 
        /* Release logical partition list */
        while (!IsListEmpty(&DiskEntry->LogicalPartListHead))
        {
            Entry = RemoveHeadList(&DiskEntry->LogicalPartListHead);
            PartEntry = CONTAINING_RECORD(Entry, PARTENTRY, ListEntry);
 
            RtlFreeHeap(RtlGetProcessHeap(), 0, PartEntry);
        }
 
        /* Release layout buffer */
        if (DiskEntry->LayoutBuffer != NULL)
            RtlFreeHeap(RtlGetProcessHeap(), 0, DiskEntry->LayoutBuffer);
 
 
        /* Release disk entry */
        RtlFreeHeap(RtlGetProcessHeap(), 0, DiskEntry);
    }
 
    /* Release the bios disk info */
    while (!IsListEmpty(&BiosDiskListHead))
    {
        Entry = RemoveHeadList(&BiosDiskListHead);
        BiosDiskEntry = CONTAINING_RECORD(Entry, BIOSDISKENTRY, ListEntry);
 
        RtlFreeHeap(RtlGetProcessHeap(), 0, BiosDiskEntry);
    }
}

DestroyVolumeList()

VOID DestroyVolumeList

(

VOID

)

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

BOOL detach_main	(	INT	argc,
		LPWSTR *	argv
	)

Definition at line 11 of file detach.c.

{
    return TRUE;
}

DetailDisk()

BOOL DetailDisk	(	INT	argc,
		PWSTR *	argv
	)

DetailPartition()

BOOL DetailPartition	(	INT	argc,
		PWSTR *	argv
	)

DetailVolume()

BOOL DetailVolume	(	INT	argc,
		PWSTR *	argv
	)

DismountVolume()

NTSTATUS DismountVolume

(

_In_ PPARTENTRY

PartEntry

)

Definition at line 1960 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->PartitionType)   ||
        !IsRecognizedPartition(PartEntry->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->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()

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

Definition at line 48 of file dump.c.

{
    OBJECT_ATTRIBUTES ObjectAttributes;
    IO_STATUS_BLOCK Iosb;
    NTSTATUS Status;
    WCHAR Buffer[MAX_PATH];
    UNICODE_STRING Name;
    HANDLE FileHandle = NULL;
    PUCHAR pSectorBuffer = NULL;
    LARGE_INTEGER FileOffset;
    LONGLONG Sector;
    LPWSTR endptr = NULL;
 
#if 0
    if (argc == 2)
    {
        ConResPuts(StdOut, IDS_HELP_CMD_DUMP_DISK);
        return TRUE;
    }
#endif
 
    if (CurrentDisk == NULL)
    {
        ConResPuts(StdOut, IDS_SELECT_NO_DISK);
        return TRUE;
    }
 
    Sector = _wcstoi64(argv[2], &endptr, 0);
    if (((Sector == 0) && (endptr == argv[2])) ||
        (Sector < 0))
    {
        ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
        return TRUE;
    }
 
    pSectorBuffer = RtlAllocateHeap(RtlGetProcessHeap(), HEAP_ZERO_MEMORY, CurrentDisk->BytesPerSector);
    if (pSectorBuffer == NULL)
    {
        DPRINT1("\n");
        /* Error message */
        goto done;
    }
 
    swprintf(Buffer,
             L"\\Device\\Harddisk%d\\Partition0",
             CurrentDisk->DiskNumber);
    RtlInitUnicodeString(&Name,
                        Buffer);
 
    InitializeObjectAttributes(&ObjectAttributes,
                               &Name,
                               0,
                               NULL,
                               NULL);
 
    Status = NtOpenFile(&FileHandle,
                        FILE_READ_DATA | FILE_READ_ATTRIBUTES | SYNCHRONIZE,
                        &ObjectAttributes,
                        &Iosb,
                        FILE_SHARE_READ,
                        FILE_SYNCHRONOUS_IO_NONALERT);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("\n");
        goto done;
    }
 
    FileOffset.QuadPart = Sector * CurrentDisk->BytesPerSector;
    Status = NtReadFile(FileHandle,
                        NULL,
                        NULL,
                        NULL,
                        &Iosb,
                        (PVOID)pSectorBuffer,
                        CurrentDisk->BytesPerSector,
                        &FileOffset,
                        NULL);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("NtReadFile failed, status=%x\n", Status);
        goto done;
    }
 
    HexDump(pSectorBuffer, CurrentDisk->BytesPerSector);
 
done:
    if (FileHandle)
        NtClose(FileHandle);
 
    RtlFreeHeap(RtlGetProcessHeap(), 0, pSectorBuffer);
 
    return TRUE;
}

DumpPartition()

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

Definition at line 146 of file dump.c.

{
    OBJECT_ATTRIBUTES ObjectAttributes;
    IO_STATUS_BLOCK Iosb;
    NTSTATUS Status;
    WCHAR Buffer[MAX_PATH];
    UNICODE_STRING Name;
    HANDLE FileHandle = NULL;
    PUCHAR pSectorBuffer = NULL;
    LARGE_INTEGER FileOffset;
    LONGLONG Sector;
    LPWSTR endptr = NULL;
 
 
#if 0
    if (argc == 2)
    {
        ConResPuts(StdOut, IDS_HELP_CMD_DUMP_DISK);
        return TRUE;
    }
#endif
 
    if (CurrentDisk == NULL)
    {
        ConResPuts(StdOut, IDS_SELECT_NO_DISK);
        return TRUE;
    }
 
    if (CurrentPartition == NULL)
    {
        ConResPuts(StdOut, IDS_SELECT_NO_PARTITION);
        return TRUE;
    }
 
    Sector = _wcstoi64(argv[2], &endptr, 0);
    if (((Sector == 0) && (endptr == argv[2])) ||
        (Sector < 0))
    {
        ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
        return TRUE;
    }
 
    pSectorBuffer = RtlAllocateHeap(RtlGetProcessHeap(), HEAP_ZERO_MEMORY, CurrentDisk->BytesPerSector);
    if (pSectorBuffer == NULL)
    {
        DPRINT1("\n");
        /* Error message */
        goto done;
    }
 
    swprintf(Buffer,
             L"\\Device\\Harddisk%d\\Partition%d",
             CurrentDisk->DiskNumber,
             CurrentPartition->PartitionNumber);
    RtlInitUnicodeString(&Name,
                        Buffer);
 
    InitializeObjectAttributes(&ObjectAttributes,
                               &Name,
                               0,
                               NULL,
                               NULL);
 
    Status = NtOpenFile(&FileHandle,
                        FILE_READ_DATA | FILE_READ_ATTRIBUTES | SYNCHRONIZE,
                        &ObjectAttributes,
                        &Iosb,
                        FILE_SHARE_READ,
                        FILE_SYNCHRONOUS_IO_NONALERT);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("\n");
        goto done;
    }
 
    FileOffset.QuadPart = Sector * CurrentDisk->BytesPerSector;
    Status = NtReadFile(FileHandle,
                        NULL,
                        NULL,
                        NULL,
                        &Iosb,
                        (PVOID)pSectorBuffer,
                        CurrentDisk->BytesPerSector,
                        &FileOffset,
                        NULL);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("NtReadFile failed, status=%x\n", Status);
        goto done;
    }
 
    HexDump(pSectorBuffer, CurrentDisk->BytesPerSector);
 
done:
    if (FileHandle)
        NtClose(FileHandle);
 
    RtlFreeHeap(RtlGetProcessHeap(), 0, pSectorBuffer);
 
    return TRUE;
}

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

BOOL expand_main	(	INT	argc,
		LPWSTR *	argv
	)

Definition at line 11 of file expand.c.

{
    return TRUE;
}

extend_main()

BOOL extend_main	(	INT	argc,
		LPWSTR *	argv
	)

Definition at line 11 of file extend.c.

{
    return TRUE;
}

filesystems_main()

BOOL filesystems_main	(	INT	argc,
		LPWSTR *	argv
	)

format_main()

BOOL format_main	(	INT	argc,
		LPWSTR *	argv
	)

Definition at line 11 of file format.c.

{
    return TRUE;
}

GetNextUnpartitionedEntry()

PPARTENTRY GetNextUnpartitionedEntry

(

_In_ PPARTENTRY

PartEntry

)

Definition at line 1932 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->PartitionType == PARTITION_ENTRY_UNUSED);
            return NextPartEntry;
        }
    }
 
    return NULL;
}

Referenced by DeletePartition().

GetPrevUnpartitionedEntry()

PPARTENTRY GetPrevUnpartitionedEntry

(

_In_ PPARTENTRY

PartEntry

)

Definition at line 1903 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->PartitionType == PARTITION_ENTRY_UNUSED);
            return PrevPartEntry;
        }
    }
 
    return NULL;
}

Referenced by DeletePartition().

GetPrimaryPartitionCount()

ULONG GetPrimaryPartitionCount

(

_In_ PDISKENTRY

DiskEntry

)

Definition at line 1637 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 2068 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()

BOOL gpt_main	(	INT	argc,
		LPWSTR *	argv
	)

Definition at line 11 of file gpt.c.

{
    return TRUE;
}

HasPrefix()

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

Definition at line 58 of file misc.c.

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

Referenced by AcpiExGetNameString(), CreateExtendedPartition(), CreateLogicalPartition(), CreatePrimaryPartition(), setid_main(), and UniqueIdDisk().

help_main()

BOOL help_main	(	INT	argc,
		LPWSTR *	argv
	)

Definition at line 120 of file help.c.

{
    PCOMMAND cmdptr;
    PCOMMAND cmdptr1 = NULL;
    PCOMMAND cmdptr2 = NULL;
    PCOMMAND cmdptr3 = NULL;
 
    if (argc == 1)
    {
        HelpCommandList();
        return TRUE;
    }
 
    /* Scan internal command table */
    for (cmdptr = cmds; cmdptr->cmd1; cmdptr++)
    {
        if ((cmdptr1 == NULL) &&
            (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 TRUE;
}

HelpCommand()

BOOL HelpCommand

(

PCOMMAND

pCommand

)

Definition at line 46 of file help.c.

{
    PCOMMAND cmdptr;
    BOOL bSubCommands = FALSE;
    WCHAR szFormat[64];
    WCHAR szOutput[256];
 
    K32LoadStringW(GetModuleHandle(NULL), IDS_HELP_FORMAT_STRING, szFormat, ARRAYSIZE(szFormat));
 
    ConPuts(StdOut, L"\n");
 
    /* List all the commands and the basic descriptions */
    for (cmdptr = cmds; cmdptr->cmd1; cmdptr++)
    {
        if (pCommand->cmd1 != NULL && pCommand->cmd2 == NULL && pCommand->cmd3 == NULL)
        {
            if ((cmdptr->cmd1 != NULL && _wcsicmp(pCommand->cmd1, cmdptr->cmd1) == 0) &&
                (cmdptr->cmd2 != NULL) &&
                (cmdptr->cmd3 == NULL) &&
                (cmdptr->help != IDS_NONE))
            {
                K32LoadStringW(GetModuleHandle(NULL), cmdptr->help, szOutput, ARRAYSIZE(szOutput));
                ConPrintf(StdOut, szFormat, cmdptr->cmd2, szOutput);
                bSubCommands = TRUE;
            }
        }
        else if (pCommand->cmd1 != NULL && pCommand->cmd2 != NULL && pCommand->cmd3 == NULL)
        {
            if ((cmdptr->cmd1 != NULL && _wcsicmp(pCommand->cmd1, cmdptr->cmd1) == 0) &&
                (cmdptr->cmd2 != NULL && _wcsicmp(pCommand->cmd2, cmdptr->cmd2) == 0) &&
                (cmdptr->cmd3 != NULL) &&
                (cmdptr->help != IDS_NONE))
            {
                K32LoadStringW(GetModuleHandle(NULL), cmdptr->help, szOutput, ARRAYSIZE(szOutput));
                ConPrintf(StdOut, szFormat, cmdptr->cmd3, szOutput);
                bSubCommands = TRUE;
            }
        }
        else if (pCommand->cmd1 != NULL && pCommand->cmd2 != NULL && pCommand->cmd3 != NULL)
        {
            if ((cmdptr->cmd1 != NULL && _wcsicmp(pCommand->cmd1, cmdptr->cmd1) == 0) &&
                (cmdptr->cmd2 != NULL && _wcsicmp(pCommand->cmd2, cmdptr->cmd2) == 0) &&
                (cmdptr->cmd3 != NULL && _wcsicmp(pCommand->cmd3, cmdptr->cmd3) == 0) &&
                (cmdptr->help_detail != MSG_NONE))
            {
                ConMsgPuts(StdOut,
                           FORMAT_MESSAGE_FROM_HMODULE,
                           NULL,
                           cmdptr->help_detail,
                           LANG_USER_DEFAULT);
                bSubCommands = TRUE;
            }
        }
    }
 
    if ((bSubCommands == FALSE) && (pCommand->help_detail != MSG_NONE))
    {
        ConMsgPuts(StdOut,
                   FORMAT_MESSAGE_FROM_HMODULE,
                   NULL,
                   pCommand->help_detail,
                   LANG_USER_DEFAULT);
    }
 
    ConPuts(StdOut, L"\n");
 
    return TRUE;
}

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

BOOL import_main	(	INT	argc,
		LPWSTR *	argv
	)

Definition at line 11 of file import.c.

{
    return TRUE;
}

inactive_main()

BOOL inactive_main	(	INT	argc,
		LPWSTR *	argv
	)

InterpretCmd()

BOOL InterpretCmd	(	INT	argc,
		LPWSTR *	argv
	)

InterpretMain()

VOID InterpretMain

(

VOID

)

Definition at line 231 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;
    BOOL bRun = TRUE;
    LPWSTR ptr;
 
    while (bRun != FALSE)
    {
        args_count = 0;
        memset(args_vector, 0, sizeof(args_vector));
 
        /* Shown just before the input where the user places commands */
        ConResPuts(StdOut, IDS_APP_PROMPT);
 
        /* Get input from the user. */
        fgetws(input_line, MAX_STRING_SIZE, stdin);
 
        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 */
        bRun = InterpretCmd(args_count, args_vector);
    }
}

Referenced by wmain().

InterpretScript()

BOOL InterpretScript

(

LPWSTR

line

)

Definition at line 183 of file interpreter.c.

{
    LPWSTR args_vector[MAX_ARGS_COUNT];
    INT args_count = 0;
    BOOL bWhiteSpace = TRUE;
    BOOL bQuote = FALSE;
    LPWSTR ptr;
 
    memset(args_vector, 0, sizeof(args_vector));
 
    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++;
    }
 
    /* sends the string to find the command */
    return InterpretCmd(args_count, args_vector);
}

IsDecString()

BOOL IsDecString

(

_In_ PWSTR

pszDecString

)

Definition at line 14 of file misc.c.

{
    PWSTR ptr;
 
    if ((pszDecString == NULL) || (*pszDecString == UNICODE_NULL))
        return FALSE;
 
    ptr = pszDecString;
    while (*ptr != UNICODE_NULL)
    {
        if (!iswdigit(*ptr))
            return FALSE;
 
        ptr++;
    }
 
    return TRUE;
}

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

IsHexString()

BOOL IsHexString

(

_In_ PWSTR

pszHexString

)

Definition at line 36 of file misc.c.

{
    PWSTR ptr;
 
    if ((pszHexString == NULL) || (*pszHexString == UNICODE_NULL))
        return FALSE;
 
    ptr = pszHexString;
    while (*ptr != UNICODE_NULL)
    {
        if (!iswxdigit(*ptr))
            return FALSE;
 
        ptr++;
    }
 
    return TRUE;
}

Referenced by UniqueIdDisk().

ListDisk()

BOOL ListDisk	(	INT	argc,
		PWSTR *	argv
	)

Definition at line 59 of file list.c.

{
    PLIST_ENTRY Entry;
    PDISKENTRY DiskEntry;
 
    /* Header labels */
    ConPuts(StdOut, L"\n");
    ConResPuts(StdOut, IDS_LIST_DISK_HEAD);
    ConResPuts(StdOut, IDS_LIST_DISK_LINE);
 
    Entry = DiskListHead.Flink;
    while (Entry != &DiskListHead)
    {
        DiskEntry = CONTAINING_RECORD(Entry, DISKENTRY, ListEntry);
 
        PrintDisk(DiskEntry);
 
        Entry = Entry->Flink;
    }
 
    ConPuts(StdOut, L"\n\n");
 
    return TRUE;
}

ListPartition()

BOOL ListPartition	(	INT	argc,
		PWSTR *	argv
	)

Definition at line 88 of file list.c.

{
    PLIST_ENTRY Entry;
    PPARTENTRY PartEntry;
    ULONGLONG PartSize;
    ULONGLONG PartOffset;
    LPWSTR lpSizeUnit;
    LPWSTR lpOffsetUnit;
    ULONG PartNumber = 1;
 
    if (CurrentDisk == NULL)
    {
        ConResPuts(StdOut, IDS_LIST_PARTITION_NO_DISK);
        return TRUE;
    }
 
    /* Header labels */
    ConPuts(StdOut, L"\n");
    ConResPuts(StdOut, IDS_LIST_PARTITION_HEAD);
    ConResPuts(StdOut, IDS_LIST_PARTITION_LINE);
 
    Entry = CurrentDisk->PrimaryPartListHead.Flink;
    while (Entry != &CurrentDisk->PrimaryPartListHead)
    {
        PartEntry = CONTAINING_RECORD(Entry, PARTENTRY, ListEntry);
 
        if (PartEntry->PartitionType != 0)
        {
            PartSize = PartEntry->SectorCount.QuadPart * CurrentDisk->BytesPerSector;
 
            if (PartSize >= 10737418240) /* 10 GB */
            {
                PartSize = RoundingDivide(PartSize, 1073741824);
                lpSizeUnit = L"GB";
            }
            else if (PartSize >= 10485760) /* 10 MB */
            {
                PartSize = RoundingDivide(PartSize, 1048576);
                lpSizeUnit = L"MB";
            }
            else
            {
                PartSize = RoundingDivide(PartSize, 1024);
                lpSizeUnit = L"KB";
            }
 
            PartOffset = PartEntry->StartSector.QuadPart * CurrentDisk->BytesPerSector;
 
            if (PartOffset >= 10737418240) /* 10 GB */
            {
                PartOffset = RoundingDivide(PartOffset, 1073741824);
                lpOffsetUnit = L"GB";
            }
            else if (PartOffset >= 10485760) /* 10 MB */
            {
                PartOffset = RoundingDivide(PartOffset, 1048576);
                lpOffsetUnit = L"MB";
            }
            else
            {
                PartOffset = RoundingDivide(PartOffset, 1024);
                lpOffsetUnit = L"KB";
            }
 
            ConResPrintf(StdOut, IDS_LIST_PARTITION_FORMAT,
                         (CurrentPartition == PartEntry) ? L'*' : L' ',
                         PartNumber++,
                         IsContainerPartition(PartEntry->PartitionType) ? L"Extended" : L"Primary",
                         PartSize,
                         lpSizeUnit,
                         PartOffset,
                         lpOffsetUnit);
        }
 
        Entry = Entry->Flink;
    }
 
    Entry = CurrentDisk->LogicalPartListHead.Flink;
    while (Entry != &CurrentDisk->LogicalPartListHead)
    {
        PartEntry = CONTAINING_RECORD(Entry, PARTENTRY, ListEntry);
 
        if (PartEntry->PartitionType != 0)
        {
            PartSize = PartEntry->SectorCount.QuadPart * CurrentDisk->BytesPerSector;
 
            if (PartSize >= 10737418240) /* 10 GB */
            {
                PartSize = RoundingDivide(PartSize, 1073741824);
                lpSizeUnit = L"GB";
            }
            else if (PartSize >= 10485760) /* 10 MB */
            {
                PartSize = RoundingDivide(PartSize, 1048576);
                lpSizeUnit = L"MB";
            }
            else
            {
                PartSize = RoundingDivide(PartSize, 1024);
                lpSizeUnit = L"KB";
            }
 
            PartOffset = PartEntry->StartSector.QuadPart * CurrentDisk->BytesPerSector;
 
            if (PartOffset >= 10737418240) /* 10 GB */
            {
                PartOffset = RoundingDivide(PartOffset, 1073741824);
                lpOffsetUnit = L"GB";
            }
            else if (PartOffset >= 10485760) /* 10 MB */
            {
                PartOffset = RoundingDivide(PartOffset, 1048576);
                lpOffsetUnit = L"MB";
            }
            else
            {
                PartOffset = RoundingDivide(PartOffset, 1024);
                lpOffsetUnit = L"KB";
            }
 
            ConResPrintf(StdOut, IDS_LIST_PARTITION_FORMAT,
                         (CurrentPartition == PartEntry) ? L'*' : L' ',
                         PartNumber++,
                         L"Logical",
                         PartSize,
                         lpSizeUnit,
                         PartOffset,
                         lpOffsetUnit);
        }
 
        Entry = Entry->Flink;
    }
 
    ConPuts(StdOut, L"\n");
 
    return TRUE;
}

ListVirtualDisk()

BOOL ListVirtualDisk	(	INT	argc,
		PWSTR *	argv
	)

Definition at line 310 of file list.c.

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

ListVolume()

BOOL ListVolume	(	INT	argc,
		PWSTR *	argv
	)

Definition at line 282 of file list.c.

{
    PLIST_ENTRY Entry;
    PVOLENTRY VolumeEntry;
 
    ConPuts(StdOut, L"\n");
    ConResPuts(StdOut, IDS_LIST_VOLUME_HEAD);
    ConResPuts(StdOut, IDS_LIST_VOLUME_LINE);
 
    Entry = VolumeListHead.Flink;
    while (Entry != &VolumeListHead)
    {
        VolumeEntry = CONTAINING_RECORD(Entry, VOLENTRY, ListEntry);
 
        PrintVolume(VolumeEntry);
 
        Entry = Entry->Flink;
    }
 
    ConPuts(StdOut, L"\n");
 
    return TRUE;
}

merge_main()

BOOL merge_main	(	INT	argc,
		LPWSTR *	argv
	)

Definition at line 11 of file merge.c.

{
    return TRUE;
}

offline_main()

BOOL offline_main	(	INT	argc,
		LPWSTR *	argv
	)

Definition at line 11 of file offline.c.

{
    return TRUE;
}

online_main()

BOOL online_main	(	INT	argc,
		LPWSTR *	argv
	)

Definition at line 11 of file online.c.

{
    return TRUE;
}

PrintDisk()

VOID PrintDisk

(

_In_ PDISKENTRY

DiskEntry

)

Definition at line 17 of file list.c.

{
    ULONGLONG DiskSize;
    ULONGLONG FreeSize;
    LPWSTR lpSizeUnit;
    LPWSTR lpFreeUnit;
 
    DiskSize = DiskEntry->SectorCount.QuadPart *
               (ULONGLONG)DiskEntry->BytesPerSector;
 
    if (DiskSize >= 10737418240) /* 10 GB */
    {
        DiskSize = RoundingDivide(DiskSize, 1073741824);
        lpSizeUnit = L"GB";
    }
    else
    {
        DiskSize = RoundingDivide(DiskSize, 1048576);
        if (DiskSize == 0)
            DiskSize = 1;
        lpSizeUnit = L"MB";
    }
 
    /* FIXME */
    FreeSize = 0;
    lpFreeUnit = L"B";
 
    ConResPrintf(StdOut, IDS_LIST_DISK_FORMAT,
                 (CurrentDisk == DiskEntry) ? L'*' : L' ',
                 DiskEntry->DiskNumber,
                 L"Online",
                 DiskSize,
                 lpSizeUnit,
                 FreeSize,
                 lpFreeUnit,
                 L" ",
                 L" ");
}

Referenced by DetailVolume(), and ListDisk().

PrintVolume()

VOID PrintVolume

(

_In_ PVOLENTRY

VolumeEntry

)

Definition at line 230 of file list.c.

{
    ULONGLONG VolumeSize;
    PWSTR pszSizeUnit;
    PWSTR pszVolumeType;
 
    VolumeSize = VolumeEntry->Size.QuadPart;
    if (VolumeSize >= 10737418240) /* 10 GB */
    {
        VolumeSize = RoundingDivide(VolumeSize, 1073741824);
        pszSizeUnit = L"GB";
    }
    else if (VolumeSize >= 10485760) /* 10 MB */
    {
        VolumeSize = RoundingDivide(VolumeSize, 1048576);
        pszSizeUnit = L"MB";
    }
    else
    {
        VolumeSize = RoundingDivide(VolumeSize, 1024);
        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);
}

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

recover_main()

BOOL recover_main	(	INT	argc,
		LPWSTR *	argv
	)

Definition at line 11 of file recover.c.

{
    return TRUE;
}

remove_main()

BOOL remove_main	(	INT	argc,
		LPWSTR *	argv
	)

Definition at line 11 of file remove.c.

{
    return TRUE;
}

RemoveVolume()

VOID RemoveVolume

(

_In_ PVOLENTRY

VolumeEntry

)

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

BOOL repair_main	(	INT	argc,
		LPWSTR *	argv
	)

Definition at line 11 of file repair.c.

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

rescan_main()

BOOL rescan_main	(	INT	argc,
		LPWSTR *	argv
	)

Definition at line 11 of file rescan.c.

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

retain_main()

BOOL retain_main	(	INT	argc,
		LPWSTR *	argv
	)

Definition at line 11 of file retain.c.

{
    return TRUE;
}

RoundingDivide()

ULONGLONG RoundingDivide	(	_In_ ULONGLONG	Dividend,
		_In_ ULONGLONG	Divisor
	)

Definition at line 75 of file misc.c.

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

san_main()

BOOL san_main	(	INT	argc,
		LPWSTR *	argv
	)

Definition at line 11 of file san.c.

{
    return TRUE;
}

SelectDisk()

BOOL SelectDisk	(	INT	argc,
		PWSTR *	argv
	)

Definition at line 17 of file select.c.

{
    PLIST_ENTRY Entry;
    PDISKENTRY DiskEntry;
    ULONG ulValue;
 
    DPRINT("Select Disk()\n");
 
    if (argc > 3)
    {
        ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
        return TRUE;
    }
 
    if (argc == 2)
    {
        if (CurrentDisk == NULL)
            ConResPuts(StdOut, IDS_SELECT_NO_DISK);
        else
            ConResPrintf(StdOut, IDS_SELECT_DISK, CurrentDisk->DiskNumber);
        return TRUE;
    }
 
    if (!_wcsicmp(argv[2], L"system"))
    {
        CurrentDisk = NULL;
 
        Entry = DiskListHead.Flink;
        DiskEntry = CONTAINING_RECORD(Entry, DISKENTRY, ListEntry);
 
        CurrentDisk = DiskEntry;
        CurrentPartition = NULL;
        ConResPrintf(StdOut, IDS_SELECT_DISK, CurrentDisk->DiskNumber);
        return TRUE;
    }
    else if (!_wcsicmp(argv[2], L"next"))
    {
        if (CurrentDisk == NULL)
        {
            CurrentPartition = NULL;
            ConResPuts(StdErr, IDS_SELECT_DISK_ENUM_NO_START);
            return TRUE;
        }
 
        if (CurrentDisk->ListEntry.Flink == &DiskListHead)
        {
            CurrentDisk = NULL;
            CurrentPartition = NULL;
            ConResPuts(StdErr, IDS_SELECT_DISK_ENUM_FINISHED);
            return TRUE;
        }
 
        Entry = CurrentDisk->ListEntry.Flink;
 
        DiskEntry = CONTAINING_RECORD(Entry, DISKENTRY, ListEntry);
 
        CurrentDisk = DiskEntry;
        CurrentPartition = NULL;
        ConResPrintf(StdOut, IDS_SELECT_DISK, CurrentDisk->DiskNumber);
        return TRUE;
    }
    else if (IsDecString(argv[2]))
    {
        ulValue = wcstoul(argv[2], NULL, 10);
        if ((ulValue == 0) && (errno == ERANGE))
        {
            ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
            return TRUE;
        }
 
        CurrentDisk = NULL;
 
        Entry = DiskListHead.Flink;
        while (Entry != &DiskListHead)
        {
            DiskEntry = CONTAINING_RECORD(Entry, DISKENTRY, ListEntry);
 
            if (DiskEntry->DiskNumber == ulValue)
            {
                CurrentDisk = DiskEntry;
                CurrentPartition = NULL;
                ConResPrintf(StdOut, IDS_SELECT_DISK, CurrentDisk->DiskNumber);
                return TRUE;
            }
 
            Entry = Entry->Flink;
        }
    }
    else
    {
        ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
        return TRUE;
    }
 
    ConResPuts(StdErr, IDS_SELECT_DISK_INVALID);
    return TRUE;
}

SelectPartition()

BOOL SelectPartition	(	INT	argc,
		PWSTR *	argv
	)

Definition at line 119 of file select.c.

{
    PLIST_ENTRY Entry;
    PPARTENTRY PartEntry;
    ULONG ulValue;
    ULONG PartNumber = 1;
 
    DPRINT("Select Partition()\n");
 
    if (argc > 3)
    {
        ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
        return TRUE;
    }
 
    if (CurrentDisk == NULL)
    {
        ConResPuts(StdOut, IDS_SELECT_PARTITION_NO_DISK);
        return TRUE;
    }
 
    if (argc == 2)
    {
        if (CurrentPartition == NULL)
            ConResPuts(StdOut, IDS_SELECT_NO_PARTITION);
        else
            ConResPrintf(StdOut, IDS_SELECT_PARTITION, CurrentPartition);
        return TRUE;
    }
 
    if (!IsDecString(argv[2]))
    {
        ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
        return TRUE;
    }
 
    ulValue = wcstoul(argv[2], NULL, 10);
    if ((ulValue == 0) && (errno == ERANGE))
    {
        ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
        return TRUE;
    }
 
    Entry = CurrentDisk->PrimaryPartListHead.Flink;
    while (Entry != &CurrentDisk->PrimaryPartListHead)
    {
        PartEntry = CONTAINING_RECORD(Entry, PARTENTRY, ListEntry);
 
        if (PartEntry->PartitionType != 0)
        {
            if (PartNumber == ulValue)
            {
                CurrentPartition = PartEntry;
                ConResPrintf(StdOut, IDS_SELECT_PARTITION, PartNumber);
                return TRUE;
            }
 
            PartNumber++;
        }
 
        Entry = Entry->Flink;
    }
 
    Entry = CurrentDisk->LogicalPartListHead.Flink;
    while (Entry != &CurrentDisk->LogicalPartListHead)
    {
        PartEntry = CONTAINING_RECORD(Entry, PARTENTRY, ListEntry);
 
        if (PartEntry->PartitionType != 0)
        {
            if (PartNumber == ulValue)
            {
                CurrentPartition = PartEntry;
                ConResPrintf(StdOut, IDS_SELECT_PARTITION, PartNumber);
                return TRUE;
            }
 
            PartNumber++;
        }
        Entry = Entry->Flink;
    }
 
    ConResPuts(StdErr, IDS_SELECT_PARTITION_INVALID);
    return TRUE;
}

SelectVolume()

BOOL SelectVolume	(	INT	argc,
		PWSTR *	argv
	)

Definition at line 209 of file select.c.

{
    PLIST_ENTRY Entry;
    PVOLENTRY VolumeEntry;
    ULONG ulValue;
 
    DPRINT("SelectVolume()\n");
 
    if (argc > 3)
    {
        ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
        return TRUE;
    }
 
    if (argc == 2)
    {
        if (CurrentDisk == NULL)
            ConResPuts(StdOut, IDS_SELECT_NO_VOLUME);
        else
            ConResPrintf(StdOut, IDS_SELECT_VOLUME, CurrentVolume->VolumeNumber);
        return TRUE;
    }
 
    if (!IsDecString(argv[2]))
    {
        ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
        return TRUE;
    }
 
    ulValue = wcstoul(argv[2], NULL, 10);
    if ((ulValue == 0) && (errno == ERANGE))
    {
        ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
        return TRUE;
    }
 
    CurrentVolume = NULL;
 
    Entry = VolumeListHead.Flink;
    while (Entry != &VolumeListHead)
    {
        VolumeEntry = CONTAINING_RECORD(Entry, VOLENTRY, ListEntry);
 
        if (VolumeEntry->VolumeNumber == ulValue)
        {
            CurrentVolume = VolumeEntry;
            ConResPrintf(StdOut, IDS_SELECT_VOLUME, CurrentVolume->VolumeNumber);
            return TRUE;
        }
 
        Entry = Entry->Flink;
    }
 
    ConResPuts(StdErr, IDS_SELECT_VOLUME_INVALID);
    return TRUE;
}

setid_main()

BOOL setid_main	(	INT	argc,
		LPWSTR *	argv
	)

shrink_main()

BOOL shrink_main	(	INT	argc,
		LPWSTR *	argv
	)

Definition at line 11 of file shrink.c.

{
    return TRUE;
}

UniqueIdDisk()

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

Definition at line 17 of file uniqueid.c.

{
    PWSTR pszSuffix = NULL;
    ULONG ulValue;
 
    if (CurrentDisk == NULL)
    {
        ConResPuts(StdOut, IDS_SELECT_NO_DISK);
        return TRUE;
    }
 
    if (argc == 2)
    {
        ConPuts(StdOut, L"\n");
        ConPrintf(StdOut, L"Disk ID: %08lx\n", CurrentDisk->LayoutBuffer->Signature);
        ConPuts(StdOut, L"\n");
        return TRUE;
    }
 
    if (argc != 3)
    {
        ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
        return TRUE;
    }
 
    if (!HasPrefix(argv[2], L"ID=", &pszSuffix))
    {
        ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
        return TRUE;
    }
 
    if ((pszSuffix == NULL) ||
        (wcslen(pszSuffix) != 8) ||
        (IsHexString(pszSuffix) == FALSE))
    {
        ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
        return TRUE;
    }
 
    ulValue = wcstoul(pszSuffix, NULL, 16);
    if ((ulValue == 0) && (errno == ERANGE))
    {
        ConResPuts(StdErr, IDS_ERROR_INVALID_ARGS);
        return TRUE;
    }
 
    DPRINT("New Signature: 0x%08lx\n", ulValue);
    CurrentDisk->LayoutBuffer->Signature = ulValue;
    CurrentDisk->Dirty = TRUE;
    UpdateDiskLayout(CurrentDisk);
    WritePartitions(CurrentDisk);
 
    return TRUE;
}

UpdateDiskLayout()

VOID UpdateDiskLayout

(

_In_ PDISKENTRY

DiskEntry

)

Definition at line 1733 of file partlist.c.

{
    PPARTITION_INFORMATION PartitionInfo;
    PPARTITION_INFORMATION LinkInfo = NULL;
    PLIST_ENTRY ListEntry;
    PPARTENTRY PartEntry;
    LARGE_INTEGER HiddenSectors64;
    ULONG Index;
    ULONG PartitionNumber = 1;
 
    DPRINT1("UpdateDiskLayout()\n");
 
    /* Resize the layout buffer if necessary */
    if (ReAllocateLayoutBuffer(DiskEntry) == FALSE)
    {
        DPRINT("ReAllocateLayoutBuffer() failed.\n");
        return;
    }
 
    /* 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->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->PartitionType) ? PartitionNumber : 0);
 
            if (!IsSamePrimaryLayoutEntry(PartitionInfo, DiskEntry, PartEntry))
            {
                DPRINT1("Updating primary partition entry %lu\n", Index);
 
                PartitionInfo->StartingOffset.QuadPart = PartEntry->StartSector.QuadPart * DiskEntry->BytesPerSector;
                PartitionInfo->PartitionLength.QuadPart = PartEntry->SectorCount.QuadPart * DiskEntry->BytesPerSector;
                PartitionInfo->HiddenSectors = PartEntry->StartSector.LowPart;
                PartitionInfo->PartitionNumber = PartEntry->PartitionNumber;
                PartitionInfo->PartitionType = PartEntry->PartitionType;
                PartitionInfo->BootIndicator = PartEntry->BootIndicator;
                PartitionInfo->RecognizedPartition = IsRecognizedPartition(PartEntry->PartitionType);
                PartitionInfo->RewritePartition = TRUE;
            }
 
            if (!IsContainerPartition(PartEntry->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->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->StartingOffset.QuadPart = PartEntry->StartSector.QuadPart * DiskEntry->BytesPerSector;
            PartitionInfo->PartitionLength.QuadPart = PartEntry->SectorCount.QuadPart * DiskEntry->BytesPerSector;
            PartitionInfo->HiddenSectors = DiskEntry->SectorAlignment;
            PartitionInfo->PartitionNumber = PartEntry->PartitionNumber;
            PartitionInfo->PartitionType = PartEntry->PartitionType;
            PartitionInfo->BootIndicator = FALSE;
            PartitionInfo->RecognizedPartition = IsRecognizedPartition(PartEntry->PartitionType);
            PartitionInfo->RewritePartition = TRUE;
 
            /* Fill the link entry of the previous partition entry */
            if (LinkInfo != NULL)
            {
                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->HiddenSectors = HiddenSectors64.LowPart;
                LinkInfo->PartitionNumber = 0;
                LinkInfo->PartitionType = PARTITION_EXTENDED;
                LinkInfo->BootIndicator = FALSE;
                LinkInfo->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->StartingOffset.QuadPart = 0;
            PartitionInfo->PartitionLength.QuadPart = 0;
            PartitionInfo->HiddenSectors = 0;
            PartitionInfo->PartitionNumber = 0;
            PartitionInfo->PartitionType = PARTITION_ENTRY_UNUSED;
            PartitionInfo->BootIndicator = FALSE;
            PartitionInfo->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->StartingOffset.QuadPart = 0;
                PartitionInfo->PartitionLength.QuadPart = 0;
                PartitionInfo->HiddenSectors = 0;
                PartitionInfo->PartitionNumber = 0;
                PartitionInfo->PartitionType = PARTITION_ENTRY_UNUSED;
                PartitionInfo->BootIndicator = FALSE;
                PartitionInfo->RecognizedPartition = FALSE;
                PartitionInfo->RewritePartition = TRUE;
            }
        }
    }
 
    DiskEntry->Dirty = TRUE;
}

WritePartitions()

NTSTATUS WritePartitions

(

_In_ PDISKENTRY

DiskEntry

)

Definition at line 1481 of file partlist.c.

{
    NTSTATUS Status;
    OBJECT_ATTRIBUTES ObjectAttributes;
    UNICODE_STRING Name;
    HANDLE FileHandle;
    IO_STATUS_BLOCK Iosb;
    ULONG BufferSize;
    PPARTITION_INFORMATION PartitionInfo;
    ULONG PartitionCount;
    PLIST_ENTRY ListEntry;
    PPARTENTRY PartEntry;
    WCHAR DstPath[MAX_PATH];
 
    DPRINT("WritePartitions() 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) +
                 ((PartitionCount - 1) * sizeof(PARTITION_INFORMATION));
    Status = NtDeviceIoControlFile(FileHandle,
                                   NULL,
                                   NULL,
                                   NULL,
                                   &Iosb,
                                   IOCTL_DISK_SET_DRIVE_LAYOUT,
                                   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->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->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;
}

Variable Documentation

BiosDiskListHead

LIST_ENTRY BiosDiskListHead

extern

Definition at line 73 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_OleCommandTarget(), and wmain().

CurrentDisk

PDISKENTRY CurrentDisk

extern

Definition at line 76 of file partlist.c.

Referenced by active_main(), clean_main(), CreateExtendedPartition(), CreateLogicalPartition(), CreatePartitionList(), CreatePrimaryPartition(), DeletePartition(), DestroyPartitionList(), DetailDisk(), DetailPartition(), DumpDisk(), DumpPartition(), GetNextPartition(), GetPrevPartition(), inactive_main(), ListPartition(), PrintDisk(), SelectDisk(), SelectPartition(), SelectVolume(), setid_main(), and UniqueIdDisk().

CurrentPartition

PPARTENTRY CurrentPartition

extern

Definition at line 77 of file partlist.c.

Referenced by CreatePartitionList(), and DestroyPartitionList().

CurrentVolume

PVOLENTRY CurrentVolume

extern

Definition at line 78 of file partlist.c.

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

DiskListHead

LIST_ENTRY DiskListHead

extern

Definition at line 72 of file partlist.c.

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

VolumeListHead

LIST_ENTRY VolumeListHead

extern

Definition at line 74 of file partlist.c.

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