int SysEncDriveAnalysisStart;

BOOL bDontVerifyRescueDisk = FALSE;

BOOL bFirstSysEncResumeDone = FALSE;

int nMultiBoot = 0; /* The number of operating systems installed on the computer, according to the user. 0: undetermined, 1: one, 2: two or more */

volatile BOOL bHiddenVol = FALSE; /* If true, we are (or will be) creating a hidden volume. */

volatile BOOL bHiddenVolHost = FALSE; /* If true, we are (or will be) creating the host volume (called "outer") for a hidden volume. */

BOOL bWarnOuterVolSuitableFileSys = TRUE;

Password volumePassword; /* User password */

char szVerify[MAX_PASSWORD + 1]; /* Tmp password buffer */

char szRawPassword[MAX_PASSWORD + 1]; /* Password before keyfile was applied to it */

int volumePim = 0;

BOOL bHistoryCmdLine = FALSE; /* History control is always disabled */

BOOL ComServerMode = FALSE;

int CmdVolumeFilesystem = FILESYS_NONE;

unsigned __int64 CmdVolumeFileSize = 0;

BOOL CmdSparseFileSwitch = FALSE;

BOOL bForceOperation = FALSE;

BOOL bSystemIsGPT = FALSE;

int nPbar = 0; /* Control ID of progress bar:- for format code */

wchar_t HeaderKeyGUIView [KEY_GUI_VIEW_SIZE];

BOOL bDisplayPoolContents = TRUE;

volatile BOOL bSparseFileSwitch = FALSE;

volatile int fileSystem = FILESYS_NONE;

volatile int clusterSize = 0;

SYSENC_MULTIBOOT_CFG SysEncMultiBootCfg;

wchar_t SysEncMultiBootCfgOutcome [4096] = {L'N',L'/',L'A',0};

volatile int NonSysInplaceEncStatus = NONSYS_INPLACE_ENC_STATUS_NONE;

vector <HostDevice> DeferredNonSysInPlaceEncDevices;

// specific definitions and implementation for support of resume operation

// in wait dialog mechanism

if (device.Path == szDevicePath)

{

OpenVolumeContext volume;

if ( status == ERR_SUCCESS)

{

OpenVolumeContext volume;

{

if ((volume.CryptoInfo->HeaderFlags & TC_HEADER_FLAG_NONSYS_INPLACE_ENC) != 0

&& volume.CryptoInfo->EncryptedAreaLength.Value != volume.CryptoInfo->VolumeSize.Value)

}

}

{

wchar_t tmp[MAX_PASSWORD+1];

// Attempt to wipe passwords stored in the input field buffers

wmemset (tmp, L'X', MAX_PASSWORD);

tmp [MAX_PASSWORD] = 0;

burn (&szVerify[0], sizeof (szVerify));

burn (&volumePassword, sizeof (volumePassword));

burn (&CmdVolumePassword, sizeof (CmdVolumePassword));

burn (&CmdVolumePim, sizeof (CmdVolumePim));

KeyFileRemoveAll (&FirstKeyFile);

KeyFileRemoveAll (&defaultKeyFilesParam.FirstKeyFile);

WipeAbort();

RandStop (TRUE);

burn (szFileName, sizeof(szFileName));

burn (szDiskFile, sizeof(szDiskFile));

// Attempt to wipe the GUI fields showing portions of randpool, of the master and header keys

wmemset (tmp, L'X', ARRAYSIZE(tmp));

tmp [ARRAYSIZE(tmp)-1] = 0;

// If the previous mode was different, the password may have been typed using a different

// keyboard layout (which might confuse the user and cause other problems if system encryption

// was or will be involved).

}

if (newWizardMode != WIZARD_MODE_NONSYS_DEVICE)

ConfigReadCompareInt ("SaveVolumeHistory", FALSE, &bHistory, bOnlyCheckModified, pbSettingsModified);

{

char szTmp[MAX_PATH] = {0};

WideCharToMultiByte (CP_UTF8, 0, SecurityTokenLibraryPath, -1, szTmp, MAX_PATH, NULL, NULL);

LoadSettingsAndCheckModified (hwndDlg, FALSE, NULL, NULL);

}

{

WaitCursor ();

if (AskWarnYesNoString ((wstring (GetString ("SYSDRIVE_NON_STANDARD_PARTITIONS")) + L"\n\n" + GetString ("ASK_ENCRYPT_PARTITION_INSTEAD_OF_DRIVE")).c_str(), MainDlg) == IDYES)

bWholeSysDrive = FALSE;

}

}

else if (BootEncObj->SystemPartitionCoversWholeDrive()

&& !bWholeSysDrive)

int i, cnt = 0;

nIndex = (int) SendMessage (GetDlgItem (hwndDlg, IDC_COMBO_BOX), CB_GETITEMDATA, nIndex, 0);

if (wcscmp (name, L"AES") == 0)

{

{

if (lTmp * i > (bHiddenVolHost ? TC_MAX_HIDDEN_VOLUME_HOST_SIZE : TC_MAX_VOLUME_SIZE))

bEnable = FALSE;

}

}

nMultiBoot = 1;

#endif

SendMessage (GetDlgItem (hwndDlg, IDC_SINGLE_BOOT),

BM_SETCHECK,

nMultiBoot == 1 ? BST_CHECKED : BST_UNCHECKED,

volParams->headerFlags = (CreatingHiddenSysVol() ? TC_HEADER_FLAG_ENCRYPTED_SYSTEM : 0);

volParams->fileSystem = fileSystem;

volParams->clusterSize = clusterSize;

volParams->quickFormat = quickFormat;

volParams->sectorSize = GetFormatSectorSize();

volParams->realClusterSize = &realClusterSize;

volParams->password = &volumePassword;

{

Info("FORMAT_FINISHED_INFO", hwndDlg);

Warning("SPARSE_FILE_SIZE_NOTE", hwndDlg);

}

}

if (bPreserveTimestamp)

{

if (GetFileTime (hFile, NULL, &ftLastAccessTime, NULL) == 0)

bTimeStampValid = FALSE;

else

if (bPreserveTimestamp)

{

if (GetFileTime (hFile, NULL, &ftLastAccessTime, NULL) == 0)

bTimeStampValid = FALSE;

else

}

{

if (bHiddenVol && !bHiddenVolHost) // If it's a hidden volume

{

LARGE_INTEGER lDiskFree;

lDiskFree.QuadPart = nMaximumHiddenVolSize;

if (display)

PrintFreeSpace (hwndTextBox, NULL, &lDiskFree);

else if (bDevice == FALSE)

{

wchar_t root[TC_MAX_PATH];

ULARGE_INTEGER free;

if (!GetVolumePathName (szFileName, root, ARRAYSIZE (root)))

return FALSE;

}

if (!GetDiskFreeSpaceEx (root, &free, 0, 0))

{

if (display)

else

{

LARGE_INTEGER lDiskFree;

lDiskFree.QuadPart = free.QuadPart;

if (display)

PrintFreeSpace (hwndTextBox, root, &lDiskFree);

nVolumeSize = lDiskFree.QuadPart;

if (display)

nMultiplier = PrintFreeSpace (hwndTextBox, szDiskFile, &lDiskFree);

SendMessage (GetDlgItem (hwndDlg, IDC_CLUSTERSIZE), CB_RESETCONTENT, 0, 0);

AddComboPair (GetDlgItem (hwndDlg, IDC_CLUSTERSIZE), GetString ("DEFAULT"), 0);

{

wstringstream s;

DWORD size = GetFormatSectorSize() * i;

break;

/* ReFS supports only 4KiB and 64KiB clusters */

if ((fsType == FILESYS_REFS) && (size != 4*BYTES_PER_KB) && (size != 64*BYTES_PER_KB))

continue;

if (size == 512)

s << size / BYTES_PER_KB;

AddComboPair (GetDlgItem (hwndDlg, IDC_CLUSTERSIZE), s.str().c_str(), i);

}

SetWindowTextW (GetDlgItem (GetParent (hwndDlg), IDCANCEL), GetString ("CANCEL"));

RefreshMultiBootControls (hwndDlg);

EnableWindow (GetDlgItem (GetParent (hwndDlg), IDC_NEXT), nMultiBoot > 0);

EnableWindow (GetDlgItem (GetParent (hwndDlg), IDC_PREV), TRUE);

EnableWindow (GetDlgItem (GetParent (hwndDlg), IDCANCEL), TRUE);

for (ea = EAGetFirst (); ea != 0; ea = EAGetNext (ea))

{

if (EAIsFormatEnabled (ea) && (!SysEncInEffect () || bSystemIsGPT || EAIsMbrSysEncEnabled (ea)))

}

SelectAlgo (GetDlgItem (hwndDlg, IDC_COMBO_BOX), &nVolumeEA);

for (hid = FIRST_PRF_ID; hid <= LAST_PRF_ID; hid++)

{

AddComboPair (GetDlgItem (hwndDlg, IDC_COMBO_BOX_HASH_ALGO), HashGetName(hid), hid);

}

}

SendMessage (GetDlgItem (hwndDlg, IDC_SPACE_LEFT), WM_SETFONT, (WPARAM) hBoldFont, (LPARAM) TRUE);

SendMessage (GetDlgItem (hwndDlg, IDC_SIZEBOX), EM_LIMITTEXT, 12, 0);

{

nUIVolumeSize=0;

nVolumeSize=0;

/* make autodetection the default */

SendMessage (hComboBox, CB_SETCURSEL, 0, 0);

SetPassword (hwndDlg, IDC_PASSWORD_DIRECT, szRawPassword);

hPasswordInputField = GetDlgItem (hwndDlg, IDC_PASSWORD);

hVerifyPasswordInputField = GetDlgItem (hwndDlg, IDC_VERIFY);

if (SysEncInEffect ())

{

ToBootPwdField (hwndDlg, IDC_PASSWORD);

StringCbCopyW (str, sizeof(str), GetString ("PASSWORD_HELP"));

}

SetPassword (hwndDlg, IDC_PASSWORD, szRawPassword);

SetPassword (hwndDlg, IDC_VERIFY, szVerify);

SetCheckBox (hwndDlg, IDC_PIM_ENABLE, PimEnable);

SetCheckBox (hwndDlg, IDC_KEYFILES_ENABLE, KeyFilesEnable && !SysEncInEffect());

SetWindowTextW (GetDlgItem (hwndDlg, IDC_BOX_HELP), str);

}

SetFocus (GetDlgItem (hwndDlg, IDC_PIM));

SetWindowTextW (GetDlgItem (hwndDlg, IDC_BOX_HELP), GetString (SysEncInEffect () && hash_algo != SHA512 && hash_algo != WHIRLPOOL? "PIM_SYSENC_HELP" : "PIM_HELP"));

ToHyperlink (hwndDlg, IDC_LINK_PIM_INFO);

if (CreatingHiddenSysVol())

SetWindowTextW (GetDlgItem (GetParent (hwndDlg), IDC_NEXT), GetString ("NEXT"));

SetWindowTextW (GetDlgItem (GetParent (hwndDlg), IDC_PREV), GetString ("PREV"));

SetWindowTextW (GetDlgItem (hwndDlg, IDT_RESCUE_DISK_INFO), bSystemIsGPT? GetString ("RESCUE_DISK_EFI_INFO"): GetString ("RESCUE_DISK_INFO"));

SetDlgItemText (hwndDlg, IDC_RESCUE_DISK_ISO_PATH, szRescueDiskISO);

EnableWindow (GetDlgItem (GetParent (hwndDlg), IDC_NEXT), (GetWindowTextLength (GetDlgItem (hwndDlg, IDC_RESCUE_DISK_ISO_PATH)) > 1));

EnableWindow (GetDlgItem (GetParent (hwndDlg), IDC_PREV), TRUE);

else

SetWindowTextW (GetDlgItem (GetParent (hwndDlg), IDC_BOX_TITLE), GetString ("FORMAT_TITLE"));

/* Quick/Dynamic */

if (bHiddenVol)

{

quickFormat = !bHiddenVolHost;

bSparseFileSwitch = FALSE;

}

else

{

if (bDevice)

{

bSparseFileSwitch = FALSE;

}

else

{

wchar_t root[TC_MAX_PATH];

DWORD fileSystemFlags = 0;

/* Check if the host file system supports sparse files */

if (GetVolumePathName (szFileName, root, array_capacity (root)))

}

else

bSparseFileSwitch = FALSE;

}

}

}

//exFAT support added starting from Vista SP1

{

AddComboPair (GetDlgItem (hwndDlg, IDC_FILESYS), L"exFAT", FILESYS_EXFAT);

bEXFATallowed = TRUE;

int nIndex = (int) SendMessage (GetDlgItem (hCurPage, IDC_COMBO_BOX), CB_GETCURSEL, 0, 0);

nIndex = (int) SendMessage (GetDlgItem (hCurPage, IDC_COMBO_BOX), CB_GETITEMDATA, nIndex, 0);

if (wcscmp (name, L"AES") == 0)

Applink ("aes");

Applink ("serpent");

else if (wcscmp (name, L"Twofish") == 0)

Applink ("twofish");

else if (wcscmp (name, L"Kuznyechik") == 0)

Applink ("kuznyechik");

else if (wcscmp (name, L"Camellia") == 0)

if (hw == CBN_EDITCHANGE && nCurPageNo == VOLUME_LOCATION_PAGE)

{

EnableWindow (GetDlgItem (GetParent (hwndDlg), IDC_NEXT),

bDeviceTransformModeChoiceMade = FALSE;

bInPlaceEncNonSys = FALSE;

{

if (hw == EN_CHANGE)

{

volumePassword.Length = (unsigned __int32) strlen ((char *) volumePassword.Text);

return 1;

}

{

// Select file

return 1;

AddComboItem (GetDlgItem (hwndDlg, IDC_COMBO_BOX), szFileName, bHistory);

bHiddenVolHost = FALSE;

bSparseFileSwitch = FALSE;

quickFormat = FALSE;

return 1;

}

}

{

{

if (AskWarnYesNo("CONFIRM_SPARSE_FILE", MainDlg) == IDNO)

}

else

{

}

return 1;

}

{

wchar_t tmpszRescueDiskISO [TC_MAX_PATH+1];

return 1;

StringCbCopyW (szRescueDiskISO, sizeof(szRescueDiskISO), tmpszRescueDiskISO);

LoadSettings (hwndDlg);

LoadDefaultKeyFilesParam ();

RestoreDefaultKeyFilesParam ();

ExtractCommandLine (hwndDlg, (wchar_t *) lParam);

if (ComServerMode)

{

InitDialog (hwndDlg);

exit (0);

}

if (DirectCreationMode)

{

wchar_t root[TC_MAX_PATH];

showKeys = FALSE;

bGuiMode = FALSE;

AbortProcess ("ERR_PASSWORD_MISSING");

if (CmdVolumeFileSize == 0)

}

}

if (!GetDiskFreeSpaceEx (root, &free, 0, 0))

{

}

else

{

{

AbortProcess ("ERR_CONTAINER_SIZE_TOO_BIG");

}

}

}

if (volumePassword.Length > 0)

{

// Check password length (check also done for outer volume which is not the case in TrueCrypt).

}

}

volTransformThreadFunction (hwndDlg);

exit (bOperationSuccess? 0 : 1);

else

StringCbCatW (szRescueDiskISO, sizeof(szRescueDiskISO), L"\\VeraCrypt Rescue Disk.iso");

#ifdef _DEBUG

// For faster testing

#endif

PostMessage (hwndDlg, TC_APPMSG_PERFORM_POST_WMINIT_TASKS, 0, 0);

}

return 0;

{

// Keyboard layout is not standard US

SetPassword (hCurPage, IDC_PASSWORD, szRawPassword);

SetPassword (hCurPage, IDC_VERIFY, szVerify);

{

// Format has been aborted (did not finish)

EnableWindow (GetDlgItem (hCurPage, IDC_FILESYS), TRUE);

EnableWindow (GetDlgItem (hCurPage, IDC_CLUSTERSIZE), TRUE);

EnableWindow (GetDlgItem (hwndDlg, IDC_PREV), TRUE);

if (AskWarnYesNoString ((wstring (GetString ("SYSDRIVE_NON_STANDARD_PARTITIONS")) + L"\n\n" + GetString ("ASK_ENCRYPT_PARTITION_INSTEAD_OF_DRIVE")).c_str(), MainDlg) == IDYES)

bWholeSysDrive = FALSE;

}

}

if (!bWholeSysDrive && BootEncObj->SystemPartitionCoversWholeDrive())

if (bHiddenOS)

{

&& AskWarnYesNo ("CONFIRM_HIDDEN_OS_EXTRA_BOOT_PARTITION", hwndDlg) == IDNO)

{

TextInfoDialogBox (TC_TBXID_EXTRA_BOOT_PARTITION_REMOVAL_INSTRUCTIONS);

// Skip irrelevant pages

nNewPageNo = HIDDEN_VOL_HOST_PRE_CIPHER_PAGE - 1;

}

{

// Single-boot (not creating a hidden OS)

// Skip irrelevant pages

nNewPageNo = CIPHER_PAGE - 1;

else

{

// Either a standard Windows boot manager or no boot manager

}

}

if (bDevice)

{

{

MessageBoxW (hwndDlg, GetString ("CANT_GET_VOLSIZE"), lpszTitle, ICON_HAND);

NormalCursor ();

}

}

}

if (bHiddenVol && !bHiddenVolHost) // If it's a hidden volume

}

// Store the password in case we need to restore it after keyfile is applied to it

return 1;

if (!SysEncInEffect ())

nNewPageNo = PIM_PAGE;

volumePim = 0;

if (SysEncInEffect ())

{

nNewPageNo = SYSENC_COLLECTING_RANDOM_DATA_PAGE - 1; // Skip irrelevant pages

return 1;

}

if (volumePassword.Length > 0)

{

// Password character encoding

{

WaitCursor ();

{

NormalCursor ();

return 1;

volumePim = GetPim (hCurPage, IDC_PIM, 0);

// Store the password in case we need to restore it after keyfile is applied to it

{

NormalCursor ();

return 1;

bHiddenVolHost = FALSE;

bHiddenVolFinished = FALSE;

// Clear the outer volume password

RestoreDefaultKeyFilesParam ();

// Check that it is not a hidden or legacy volume

{

NormalCursor();

return 1;

mountOptions.UseBackupHeader = TRUE; // This must be TRUE at this point (we won't be using the regular header, which will be lost soon after the decryption process starts)

{

NormalCursor();

return 1;

else if (nCurPageNo == FORMAT_PAGE)

{

/* Format start (the 'Next' button has been clicked on the Format page) */

if (bVolTransformThreadRunning || bVolTransformThreadToRun)

return 1;

bVolTransformThreadToRun = TRUE;

fileSystem = (int) SendMessage (GetDlgItem (hCurPage, IDC_FILESYS), CB_GETITEMDATA,

SendMessage (GetDlgItem (hCurPage, IDC_FILESYS), CB_GETCURSEL, 0, 0) , 0);

clusterSize = (int) SendMessage (GetDlgItem (hCurPage, IDC_CLUSTERSIZE), CB_GETITEMDATA,

SendMessage (GetDlgItem (hCurPage, IDC_CLUSTERSIZE), CB_GETCURSEL, 0, 0) , 0);

if (!bHiddenVol && IsHiddenOSRunning())

{

if (fileSystem == FILESYS_NTFS || fileSystem == FILESYS_EXFAT) // The file system may have been changed in the previous block

{

&& AskYesNo("HIDDEN_VOL_HOST_NTFS_ASK", hwndDlg) == IDNO)

{

bVolTransformThreadToRun = FALSE;

}

else if (bHiddenVol)

{

}

EnableWindow (GetDlgItem (hwndDlg, IDC_NEXT), FALSE);

EnableWindow (GetDlgItem (hwndDlg, IDHELP), FALSE);

EnableWindow (GetDlgItem (hwndDlg, IDCANCEL), FALSE);

EnableWindow (GetDlgItem (hCurPage, IDC_CLUSTERSIZE), FALSE);

EnableWindow (GetDlgItem (hCurPage, IDC_FILESYS), FALSE);

EnableWindow (GetDlgItem (hCurPage, IDC_ABORT_BUTTON), TRUE);

SetWindowTextW (GetDlgItem (MainDlg, IDCANCEL), GetString ("CANCEL"));

bHiddenVolFinished = FALSE;

return 1;

}

nNewPageNo = HIDDEN_VOL_HOST_PRE_CIPHER_PAGE;

// Clear the outer volume password

EnableWindow (GetDlgItem (MainDlg, IDC_NEXT), TRUE);

NormalCursor ();

if (WizardMode == WIZARD_MODE_SYS_DEVICE)

{

nNewPageNo = SYSENC_MULTI_BOOT_OUTCOME_PAGE + 1; // Skip irrelevant pages

else

nNewPageNo = SYSENC_MULTI_BOOT_MODE_PAGE + 1; // Skip irrelevant pages

else if (nCurPageNo == PASSWORD_PAGE)

{

// Store the password in case we need to restore it after keyfile is applied to it

VerifyPasswordAndUpdate (hwndDlg, GetDlgItem (MainDlg, IDC_NEXT),

GetDlgItem (hCurPage, IDC_PASSWORD),

|| nCurPageNo == NONSYS_INPLACE_ENC_RESUME_PASSWORD_PAGE)

{

// Store the password in case we need to restore it after keyfile is applied to it

volumePassword.Length = (unsigned __int32) strlen ((char *) volumePassword.Text);

if (!bInPlaceEncNonSys)

case WM_CLOSE:

PostMessage (hwndDlg, TC_APPMSG_FORMAT_USER_QUIT, 0, 0);

return 1;

}

return 0;

OptionSilent,

OptionDynamic,

OptionForce,

};

argument args[]=

{ OptionSilent, L"/silent", NULL, FALSE },

{ OptionDynamic, L"/dynamic", NULL, FALSE },

{ OptionForce, L"/force", NULL, FALSE },

// Internal

{ CommandResumeSysEncLogOn, L"/acsysenc", L"/a", TRUE },

CmdVolumeFilesystem = FILESYS_FAT;

else if (_wcsicmp(szTmp, L"NTFS") == 0)

CmdVolumeFilesystem = FILESYS_NTFS;

CmdVolumeFilesystem = FILESYS_EXFAT;

else if (IsOSVersionAtLeast (WIN_10, 0) && _wcsicmp(szTmp, L"ReFS") == 0)

CmdVolumeFilesystem = FILESYS_REFS;

if (HAS_ARGUMENT == GetArgumentValue (lpszCommandLineArgs, &i, nNoCommandLineArgs,

szTmp, ARRAYSIZE (szTmp)))

{

burn (szTmp, sizeof (szTmp));

if (iLen > 0)

CmdVolumePassword.Length = (unsigned __int32) (iLen - 1);

CmdVolumePkcs5 = SHA512;

else if (_wcsicmp(szTmp, L"sha256") == 0)

CmdVolumePkcs5 = SHA256;

else

{

/* match using internal hash names */

bDontVerifyRescueDisk = TRUE;

break;

case OptionHistory:

{

wchar_t szTmp[8] = {0};

case OptionTokenPin:

{

if (GetArgumentValue (lpszCommandLineArgs, &i, nNoCommandLineArgs, szTmp, ARRAYSIZE (szTmp)) == HAS_ARGUMENT)

{

if (0 == WideCharToMultiByte (CP_UTF8, 0, szTmp, -1, CmdTokenPin, TC_MAX_PATH, nullptr, nullptr))

}

break;

default:

DialogBoxParamW (hInst, MAKEINTRESOURCEW (IDD_COMMANDHELP_DLG), hwndDlg, (DLGPROC)

CommandHelpDlgProc, (LPARAM) &as);

// The map will be scanned to determine the size of the uninterrupted block of free

// space (provided there is any) whose end is aligned with the end of the volume.

// The value will then be used to determine the maximum possible size of the hidden volume.

}

else if (!wcsncmp (szFileSystemNameBuffer, L"NTFS", 4) || !_wcsnicmp (szFileSystemNameBuffer, L"exFAT", 5))

{

// NTFS

bool bIsNtfs = (0 == wcsncmp (szFileSystemNameBuffer, L"NTFS", 4));

if (bIsNtfs && bHiddenVolDirect && GetVolumeDataAreaSize (FALSE, hiddenVolHostSize) <= TC_MAX_FAT_SECTOR_COUNT * GetFormatSectorSize())

Info ("HIDDEN_VOL_HOST_NTFS", hwndDlg);

{

// Unsupported file system

return 0;

}

mountOptions.PartitionInInactiveSysEncScope = FALSE;

mountOptions.UseBackupHeader = FALSE;

{

*driveNo = -3;

return ERR_VOL_MOUNT_FAILED;

atexit (localcleanup);

VirtualLock (&volumePassword, sizeof(volumePassword));

VirtualLock (szVerify, sizeof(szVerify));

VirtualLock (szRawPassword, sizeof(szRawPassword));

VirtualLock (&volumePim, sizeof(volumePim));

VirtualLock (&CmdVolumePassword, sizeof (CmdVolumePassword));

VirtualLock (MasterKeyGUIView, sizeof(MasterKeyGUIView));

InitApp (hInstance, lpszCommandLine);

#if TC_MAX_VOLUME_SECTOR_SIZE > 64 * 1024

#error TC_MAX_VOLUME_SECTOR_SIZE > 64 * 1024

#endif

DialogBoxParamW (hInstance, MAKEINTRESOURCEW (IDD_VOL_CREATION_WIZARD_DLG), NULL, (DLGPROC) MainDialogProc,

(LPARAM)lpszCommandLine);

return 0;

}