/*

Legal Notice: Some portions of the source code contained in this file were

governed by the TrueCrypt License 3.0, also from the source code of

Encryption for the Masses 2.02a, which is Copyright (c) 1998-2000 Paul Le Roux

and all other portions of this file are Copyright (c) 2013-2016 IDRIX

and are governed by the Apache License 2.0 the full text of which is

contained in the file License.txt included in VeraCrypt binary and source

HBITMAP hbmLogoBitmapRescaled = NULL;

wchar_t OrigKeyboardLayout [8+1] = L"00000409";

static KeyFilesDlgParam hidVolProtKeyFilesParam;

static MOUNT_LIST_STRUCT LastKnownMountList;

static DWORD LastKnownLogicalDrives;

static HANDLE TaskBarIconMutex = NULL;

{

fnWtsRegisterSessionNotification = (WTSREGISTERSESSIONNOTIFICATION) GetProcAddress(hWtsLib, "WTSRegisterSessionNotification" );

fnWtsUnRegisterSessionNotification = (WTSUNREGISTERSESSIONNOTIFICATION) GetProcAddress(hWtsLib, "WTSUnRegisterSessionNotification" );

|| !fnWtsRegisterSessionNotification( hWnd, NOTIFY_FOR_THIS_SESSION )

)

{

void EndMainDlg (HWND hwndDlg)

{

MoveEditToCombo (GetDlgItem (hwndDlg, IDC_VOLUME), bHistory);

SaveSettings (hwndDlg);

if (bWipeCacheOnExit)

info.dwTypeData = str;

info.cch = (UINT) wcslen (str);

}

for (i = 0; popupTexts[i] != 0; i++)

info.dwTypeData = str;

info.cch = (UINT) wcslen (str);

}

// Disable menu item for changing system header key derivation algorithm until it's implemented

{

SelectItem (GetDlgItem (hwndDlg, IDC_DRIVELIST), *szDriveLetter);

SendMessage(GetDlgItem (hwndDlg, IDC_DRIVELIST), LVM_SCROLL, 0, 10000);

}

else

CorrectFileName (szPath);

}

WARNING: This function is very fast but not always reliable (for example, if the user manually types

has been invoked at least once, the correct system device paths are cached). Therefore, it must NOT

purposes. This function can be used only for preliminary GUI checks requiring very fast responses. */

BOOL ActiveSysEncDeviceSelected (void)

{

// When a function does not require the affected volume to be dismounted, there may be cases where we have two valid

// paths selected in the main window and we cannot be sure which of them the user really intends to apply the function to.

// drive list (whether mounted or not), or the path to the volume selected in the main drive list. If, however, both

// ask the user and returns the volume path directly (no selection ambiguity).

// If driveNoPtr is not NULL, and the volume is mounted, its drive letter is returned in *driveNoPtr (if no valid drive

// letter is resolved, -1 is stored instead).

if (VolumeSelected (MainDlg))

{

GetVolumePath (MainDlg, volPathInputField, ARRAYSIZE (volPathInputField));

if (!ambig)

case TC_MLIST_ITEM_SYS_PARTITION:

GetSysDevicePaths (MainDlg);

if (bCachedSysDevicePathsValid)

{

volPathDriveListStr = (wstring) SysPartitionDevicePath;

ConfigReadCompareInt ("DefaultTrueCryptMode", FALSE, &DefaultVolumeTrueCryptMode, bOnlyCheckModified, pbSettingsModified);

if (bOnlyCheckModified)

if (!IsNonInstallMode ())

{

ConfigReadString ("Language", "", langid, sizeof (langid));

// when installed, if no preferred language set by user, English is set default

if (langid [0] == 0)

StringCbCopyA (langid, sizeof(langid), "en");

return (SystemEncryptionStatus == SYSENC_STATUS_ENCRYPTING

|| SystemEncryptionStatus == SYSENC_STATUS_DECRYPTING

(

(

BootEncStatus.ConfiguredEncryptedAreaStart != BootEncStatus.EncryptedAreaStart

|| BootEncStatus.ConfiguredEncryptedAreaEnd != BootEncStatus.EncryptedAreaEnd

return 0;

}

|| BootEncStatus.EncryptedAreaStart < 0

|| BootEncStatus.EncryptedAreaEnd < BootEncStatus.EncryptedAreaStart

)

if (SystemEncryptionStatus != SYSENC_STATUS_DECRYPTING)

AppendMenuW (popup, MF_STRING, IDM_PERMANENTLY_DECRYPT_SYS, GetString ("PERMANENTLY_DECRYPT"));

AppendMenuW (popup, MF_STRING, IDM_ENCRYPT_SYSTEM_DEVICE, GetString ("ENCRYPT"));

AppendMenu (popup, MF_SEPARATOR, 0, L"");

}

// Returns TRUE if the host drive of the specified partition contains a portion of the TrueCrypt Boot Loader

// and if the drive is not within key scope of active system encryption (e.g. the system drive of the running OS).

// If bPrebootPasswordDlgMode is TRUE, this function returns FALSE (because the check would be redundant).

{

try

{

{

if (nLetter == 0)

{

// Find out which drive letter is currently selected in the list and use it.

nLetter = (wchar_t) (HIWORD (GetSelectedLong (hTree)));

}

int i;

LVITEM item;

for (i = 0; i < ListView_GetItemCount(hTree); i++)

{

memset(&item, 0, sizeof(LVITEM));

// drive>0 = update only the corresponding drive subitems

void LoadDriveLetters (HWND hwndDlg, HWND hTree, int drive)

{

int lastTopMostVisibleItem = ListView_GetTopIndex (hTree);

wchar_t *szDriveLetters[]=

L"Z:"};

DWORD dwResult;

DWORD dwUsedDrives;

MOUNT_LIST_STRUCT driver;

VOLUME_PROPERTIES_STRUCT propSysEnc;

listItem.mask = LVIF_TEXT | LVIF_IMAGE | LVIF_PARAM;

listItem.iImage = 2;

listItem.pszText = szTmp;

szTmp[0] = L' ';

szTmp[1] = 0;

ListView_InsertItem (hTree, &listItem);

else

ListView_SetItem (hTree, &listItem);

// Fully encrypted

if (SysDriveOrPartitionFullyEncrypted (TRUE))

if (BootEncStatus.SetupMode != SetupDecryption)

{

sizeof szTmpW,

GetString ("SYSTEM_DRIVE_ENCRYPTING"),

(double) GetSysEncDeviceEncryptedPartSize (TRUE) / (double) GetSysEncDeviceSize (TRUE) * 100.0);

}

else

{

sizeof szTmpW,

GetString ("SYSTEM_DRIVE_DECRYPTING"),

100.0 - ((double) GetSysEncDeviceEncryptedPartSize (TRUE) / (double) GetSysEncDeviceSize (TRUE) * 100.0));

}

else

{

sizeof szTmpW,

GetString ("SYSTEM_DRIVE_PARTIALLY_ENCRYPTED"),

(double) GetSysEncDeviceEncryptedPartSize (TRUE) / (double) GetSysEncDeviceSize (TRUE) * 100.0);

}

}

ListSubItemSet (hTree, listItem.iItem, 1, szTmpW);

GetSizeString (GetSysEncDeviceSize(TRUE), szTmpW, sizeof(szTmpW));

listItem.mask = LVIF_TEXT | LVIF_IMAGE | LVIF_PARAM;

listItem.iImage = bSysEncPartition ? 2 : 1;

if (drive > 0 && drive != curDrive)

continue;

listItem.lParam = MAKELONG (

i + L'A');

listItem.pszText = szDriveLetters[i];

ListView_InsertItem (hTree, &listItem);

else

ListView_SetItem (hTree, &listItem);

listItem.pszText = szTmp;

if (bSysEncPartition)

if (BootEncStatus.SetupMode != SetupDecryption)

{

sizeof szTmpW,

GetString ("SYSTEM_PARTITION_ENCRYPTING"),

(double) GetSysEncDeviceEncryptedPartSize (TRUE) / (double) GetSysEncDeviceSize (TRUE) * 100.0);

}

else

{

sizeof szTmpW,

GetString ("SYSTEM_PARTITION_DECRYPTING"),

100.0 - ((double) GetSysEncDeviceEncryptedPartSize (TRUE) / (double) GetSysEncDeviceSize (TRUE) * 100.0));

}

else

{

sizeof szTmpW,

GetString ("SYSTEM_PARTITION_PARTIALLY_ENCRYPTED"),

(double) GetSysEncDeviceEncryptedPartSize (TRUE) / (double) GetSysEncDeviceSize (TRUE) * 100.0);

default:

ws = L"?";

}

if (driver.truecryptMode[i])

{

StringCbPrintfW (szTmpW, sizeof(szTmpW), L"TrueCrypt-%s", ws);

ListSubItemSet (hTree, listItem.iItem, 4, ws);

if (driver.volumeType[i] == PROP_VOL_TYPE_OUTER_VOL_WRITE_PREVENTED) // Normal/outer volume (hidden volume protected AND write denied)

if (!VolumeNotificationsList.bHidVolDamagePrevReported[i])

{

wchar_t szTmp[4096];

listItem.mask = LVIF_TEXT | LVIF_IMAGE | LVIF_PARAM;

listItem.iImage = 0;

listItem.pszText = szDriveLetters[i];

listItem.lParam = MAKELONG (TC_MLIST_ITEM_FREE, i + 'A');

ListView_InsertItem (hTree, &listItem);

else

ListView_SetItem (hTree, &listItem);

listItem.pszText = L"";

listItem.iSubItem = 1;

ListView_SetItem (hTree, &listItem);

BOOL EffectiveVolumeTrueCryptMode = CmdVolumeTrueCryptMode;

int EffectiveVolumePim = CmdVolumePim;

* Default values used only when nothing specified in command line

*/

if (EffectiveVolumePkcs5 == 0)

wchar_t tmp[MAX_PASSWORD+1];

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

tmp[MAX_PASSWORD] = 0;

RestoreDefaultKeyFilesParam ();

EndDialog (hwndDlg, IDCANCEL);

PasswordChangeEnable (hwndDlg, IDOK,

IDC_OLD_PASSWORD,

KeyFilesEnable && FirstKeyFile != NULL,

if ((lw == IDC_OLD_PIM) && IsWindowEnabled (GetDlgItem (hwndDlg, IDC_PIM)))

{

{

KeyFilesEnable = param.EnableKeyFiles;

FirstKeyFile = param.FirstKeyFile;

SetCheckBox (hwndDlg, IDC_ENABLE_KEYFILES, KeyFilesEnable);

}

PasswordChangeEnable (hwndDlg, IDOK,

IDC_OLD_PASSWORD,

KeyFilesEnable && FirstKeyFile != NULL,

return 1;

}

if (lw == IDC_NEW_KEYFILES)

{

if (bSysEncPwdChangeDlgMode)

VerifyPasswordAndUpdate (hwndDlg, GetDlgItem (hwndDlg, IDOK), GetDlgItem (hwndDlg, IDC_PASSWORD),

GetDlgItem (hwndDlg, IDC_VERIFY), NULL, NULL,

}

PasswordChangeEnable (hwndDlg, IDOK,

IDC_OLD_PASSWORD,

KeyFilesEnable && FirstKeyFile != NULL,

return 1;

}

PasswordChangeEnable (hwndDlg, IDOK,

IDC_OLD_PASSWORD,

KeyFilesEnable && FirstKeyFile != NULL,

return 1;

}

PasswordChangeEnable (hwndDlg, IDOK,

IDC_OLD_PASSWORD,

KeyFilesEnable && FirstKeyFile != NULL,

return 1;

}

case IDC_PKCS5_PRF_ID:

if (bSysEncPwdChangeDlgMode)

{

SendMessage (GetDlgItem (hwndDlg, IDC_PKCS5_PRF_ID), CB_GETCURSEL, 0, 0), 0);

if (new_hash_algo_id != 0 && !HashForSystemEncryption(new_hash_algo_id))

Password oldPassword;

Password newPassword;

WipeAlgorithmId headerWiperMode = (WipeAlgorithmId) SendMessage (

0);

int nStatus;

SendMessage (GetDlgItem (hwndDlg, IDC_PKCS5_OLD_PRF_ID), CB_GETCURSEL, 0, 0), 0);

SendMessage (GetDlgItem (hwndDlg, IDC_PKCS5_PRF_ID), CB_GETCURSEL, 0, 0), 0);

BOOL truecryptMode = GetCheckBox (hwndDlg, IDC_TRUECRYPT_MODE);

wchar_t tmp[MAX_PASSWORD+1];

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

tmp[MAX_PASSWORD] = 0;

KeyFileRemoveAll (&newKeyFilesParam.FirstKeyFile);

RestoreDefaultKeyFilesParam ();

mountOptions.ProtectedHidVolPkcs5Prf = *pkcs5;

if (mountOptions.ProtectedHidVolPim == 0)

mountOptions.ProtectedHidVolPim = *pim;

MAKEINTRESOURCEW (IDD_MOUNT_OPTIONS), hwndDlg,

(DLGPROC) MountOptionsDlgProc, (LPARAM) &mountOptions);

if (lw == IDCANCEL || lw == IDOK)

{

wchar_t tmp[MAX_PASSWORD+1];

if (lw == IDOK)

{

if (mountOptions.ProtectHiddenVolume && hidVolProtKeyFilesParam.EnableKeyFiles)

else

return 1;

*pkcs5 = (int) SendMessage (GetDlgItem (hwndDlg, IDC_PKCS5_PRF_ID), CB_GETITEMDATA, SendMessage (GetDlgItem (hwndDlg, IDC_PKCS5_PRF_ID), CB_GETCURSEL, 0, 0), 0);

*truecryptMode = GetCheckBox (hwndDlg, IDC_TRUECRYPT_MODE);

*pim = GetPim (hwndDlg, IDC_PIM);

/* SHA-256 is not supported by TrueCrypt */

&& ((*pkcs5 == SHA256) || (mountOptions.ProtectHiddenVolume && mountOptions.ProtectedHidVolPkcs5Prf == SHA256))

)

{

return 1;

}

&& (*pim != 0)

)

{

// Attempt to wipe password stored in the input field buffer

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

tmp[MAX_PASSWORD] = 0;

if (hidVolProtKeyFilesParam.FirstKeyFile != NULL)

{

KillTimer (hwndDlg, TIMER_ID_KEYB_LAYOUT_GUARD);

// Restore the original keyboard layout

Warning ("CANNOT_RESTORE_KEYBOARD_LAYOUT", hwndDlg);

}

}

}

}

case WM_DROPFILES:

{

PreferencesDialogActive = TRUE;

LocalizeDialog (hwndDlg, "IDD_PREFERENCES_DLG");

bExplore ? BST_CHECKED:BST_UNCHECKED, 0);

bUseDifferentTrayIconIfVolMounted ? BST_CHECKED:BST_UNCHECKED, 0);

defaultMountOptions.PreserveTimestamp ? BST_CHECKED:BST_UNCHECKED, 0);

bShowDisconnectedNetworkDrives ? BST_CHECKED:BST_UNCHECKED, 0);

bHideWaitingDialog ? BST_CHECKED:BST_UNCHECKED, 0);

bCacheDuringMultipleMount ? BST_CHECKED:BST_UNCHECKED, 0);

bWipeCacheOnExit ? BST_CHECKED:BST_UNCHECKED, 0);

bWipeCacheOnAutoDismount ? BST_CHECKED:BST_UNCHECKED, 0);

bCacheInDriver ? BST_CHECKED:BST_UNCHECKED, 0);

bIncludePimInCache? BST_CHECKED:BST_UNCHECKED, 0);

defaultMountOptions.ReadOnly ? BST_CHECKED:BST_UNCHECKED, 0);

defaultMountOptions.Removable ? BST_CHECKED:BST_UNCHECKED, 0);

bStartOnLogon ? BST_CHECKED:BST_UNCHECKED, 0);

bMountDevicesOnLogon ? BST_CHECKED:BST_UNCHECKED, 0);

bEnableBkgTask ? BST_CHECKED:BST_UNCHECKED, 0);

bCloseBkgTaskWhenNoVolumes || IsNonInstallMode() ? BST_CHECKED:BST_UNCHECKED, 0);

bDismountOnLogOff ? BST_CHECKED:BST_UNCHECKED, 0);

bDismountOnSessionLocked ? BST_CHECKED:BST_UNCHECKED, 0);

bDismountOnPowerSaving ? BST_CHECKED:BST_UNCHECKED, 0);

bDismountOnScreenSaver ? BST_CHECKED:BST_UNCHECKED, 0);

bForceAutoDismount ? BST_CHECKED:BST_UNCHECKED, 0);

MaxVolumeIdleTime > 0 ? BST_CHECKED:BST_UNCHECKED, 0);

SetDlgItemInt (hwndDlg, IDC_PREF_DISMOUNT_INACTIVE_TIME, abs (MaxVolumeIdleTime), FALSE);

{

WaitCursor ();

bCacheDuringMultipleMount = IsButtonChecked (GetDlgItem (hwndDlg, IDC_PREF_TEMP_CACHE_ON_MULTIPLE_MOUNT));

bWipeCacheOnExit = IsButtonChecked (GetDlgItem (hwndDlg, IDC_PREF_WIPE_CACHE_ON_EXIT));

bWipeCacheOnAutoDismount = IsButtonChecked (GetDlgItem (hwndDlg, IDC_PREF_WIPE_CACHE_ON_AUTODISMOUNT));

bIncludePimInCache = IsButtonChecked (GetDlgItem (hwndDlg, IDC_PREF_CACHE_PIM));

defaultMountOptions.ReadOnly = IsButtonChecked (GetDlgItem (hwndDlg, IDC_PREF_MOUNT_READONLY));

defaultMountOptions.Removable = IsButtonChecked (GetDlgItem (hwndDlg, IDC_PREF_MOUNT_REMOVABLE));

bForceAutoDismount = IsButtonChecked (GetDlgItem (hwndDlg, IDC_PREF_FORCE_AUTO_DISMOUNT));

MaxVolumeIdleTime = GetDlgItemInt (hwndDlg, IDC_PREF_DISMOUNT_INACTIVE_TIME, NULL, FALSE)

* (IsButtonChecked (GetDlgItem (hwndDlg, IDC_PREF_DISMOUNT_INACTIVE)) ? 1 : -1);

ManageStartupSeq ();

case WM_INITDIALOG:

{

BOOL protect;

mountOptions = (MountOptions *) lParam;

LocalizeDialog (hwndDlg, "IDD_MOUNT_OPTIONS");

SendDlgItemMessage (hwndDlg, IDC_MOUNT_READONLY, BM_SETCHECK,

mountOptions->ReadOnly ? BST_CHECKED : BST_UNCHECKED, 0);

SendDlgItemMessage (hwndDlg, IDC_MOUNT_REMOVABLE, BM_SETCHECK,

SendDlgItemMessage (hwndDlg, IDC_USE_EMBEDDED_HEADER_BAK, BM_SETCHECK,

mountOptions->UseBackupHeader ? BST_CHECKED : BST_UNCHECKED, 0);

EnableWindow (GetDlgItem (hwndDlg, IDC_MOUNT_SYSENC_PART_WITHOUT_PBA), !bPrebootPasswordDlgMode);

SetDlgItemTextW (hwndDlg, IDC_VOLUME_LABEL, mountOptions->Label);

ShowWindow (GetDlgItem( hwndDlg, IDC_PIM), SW_SHOW);

ShowWindow (GetDlgItem( hwndDlg, IDC_PIM_HELP), SW_SHOW);

}

ToHyperlink (hwndDlg, IDC_LINK_HIDVOL_PROTECTION_INFO);

}

// Cleanup

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

tmp[MAX_PASSWORD] = 0;

EndDialog (hwndDlg, lw);

return 1;

if (lw == IDOK)

{

wchar_t tmp[MAX_PASSWORD+1];

mountOptions->ReadOnly = IsButtonChecked (GetDlgItem (hwndDlg, IDC_MOUNT_READONLY));

mountOptions->Removable = IsButtonChecked (GetDlgItem (hwndDlg, IDC_MOUNT_REMOVABLE));

mountOptions->ProtectHiddenVolume = IsButtonChecked (GetDlgItem (hwndDlg, IDC_PROTECT_HIDDEN_VOL));

mountOptions->UseBackupHeader = IsButtonChecked (GetDlgItem (hwndDlg, IDC_USE_EMBEDDED_HEADER_BAK));

GetDlgItemTextW (hwndDlg, IDC_VOLUME_LABEL, mountOptions->Label, sizeof (mountOptions->Label) /sizeof (wchar_t));

if (mountOptions->ProtectHiddenVolume)

{

GetPassword (hwndDlg, IDC_PASSWORD_PROT_HIDVOL,

mountOptions->ProtectedHidVolPassword.Length = (unsigned __int32) strlen ((char *) mountOptions->ProtectedHidVolPassword.Text);

SendMessage (GetDlgItem (hwndDlg, IDC_PKCS5_PRF_ID), CB_GETCURSEL, 0, 0), 0);

mountOptions->ProtectedHidVolPim = GetPim (hwndDlg, IDC_PIM);

// Cleanup

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

tmp[MAX_PASSWORD] = 0;

if ((mountOptions->ProtectHiddenVolume && !bEnableBkgTask)

&& (AskWarnYesNo ("HIDVOL_PROT_BKG_TASK_WARNING", hwndDlg) == IDYES))

}

int GetModeOfOperationByDriveNo (int nDosDriveNo)

{

VOLUME_PROPERTIES_STRUCT prop;

else

{

bool truecryptMode = prop.pkcs5Iterations == get_pkcs5_iteration_count(prop.pkcs5, 0, TRUE, prop.partitionInInactiveSysEncScope);

(prop.hiddenVolProtection != HIDVOL_PROT_STATUS_NONE ? GetString ("OUTER") : GetString ("NORMAL"));

if (truecryptMode)

{

StringCbPrintfW (sw, sizeof(sw), L"TrueCrypt - %s", s);

else

ListSubItemSet (list, i++, 1, s);

}

if (!bSysEnc)

{

// Write protection

// Key size(s)

{

wchar_t name[128];

EAGetName (name, prop.ea, 1);

// Primary key

// Block size

ListItemAdd (list, i, GetString ("BLOCK_SIZE"));

StringCbPrintfW (sw, sizeof(sw), L"%d ", CipherGetBlockSize (EAGetFirstCipher(prop.ea))*8);

StringCbCatW (sw, sizeof(sw), GetString ("BITS"));

ListSubItemSet (list, i++, 1, sw);

else

{

sizeof sw,

GetString ("PROCESSED_PORTION_X_PERCENT"),

(double) GetSysEncDeviceEncryptedPartSize (FALSE) / (double) GetSysEncDeviceSize (FALSE) * 100.0);

not open, because drag&drop operation would be initiated. Therefore, we're handling

RMB drag-and-drop operations as well. */

{

DisplayVolumePropertiesListContextMenu (hwndDlg, lParam);

return 1;

HWND hList = GetDlgItem (hwndDlg, IDC_VOLUME_PROPERTIES_LIST);

// only handle if it is coming from keyboard and if the drive

// list has focus. The other cases are handled elsewhere

&& (-1 == GET_Y_LPARAM(lParam))

)

{

DisplayVolumePropertiesListContextMenu (hwndDlg, NULL);

LocalizeDialog (hwndDlg, "IDD_TRAVELER_DLG");

BST_CHECKED, 0);

BST_CHECKED, 0);

BST_CHECKED, 0);

BST_CHECKED, 0);

SendDlgItemMessage (hwndDlg, IDC_DRIVELIST, CB_RESETCONTENT, 0, 0);

index = (int) SendDlgItemMessageW (hwndDlg, IDC_DRIVELIST, CB_ADDSTRING, 0, (LPARAM) drive);

SendDlgItemMessageW (hwndDlg, IDC_DRIVELIST, CB_SETITEMDATA, index, (LPARAM) i);

}

SendDlgItemMessageW (hwndDlg, IDC_DRIVELIST, CB_SETCURSEL, 0, 0);

return 0;

&& (lw == IDC_AUTORUN_DISABLE || lw == IDC_AUTORUN_MOUNT || lw == IDC_AUTORUN_START ))

{

BOOL enabled = IsButtonChecked (GetDlgItem (hwndDlg, IDC_AUTORUN_MOUNT));

EnableWindow (GetDlgItem (hwndDlg, IDC_BROWSE_FILES), enabled);

EnableWindow (GetDlgItem (hwndDlg, IDC_VOLUME_NAME), enabled);

EnableWindow (GetDlgItem (hwndDlg, IDC_TRAVEL_OPEN_EXPLORER), enabled);

GetDlgItemTextW (hwndDlg, IDC_DIRECTORY, dstDir, array_capacity (dstDir));

volName[0] = 0;

GetDlgItemTextW (hwndDlg, IDC_VOLUME_NAME, volName + 1, (array_capacity (volName)) - 1);

drive = (int) SendDlgItemMessage (hwndDlg, IDC_DRIVELIST, CB_GETCURSEL, 0, 0);

drive = (int) SendDlgItemMessage (hwndDlg, IDC_DRIVELIST, CB_GETITEMDATA, drive, 0);

return 1;

}

if (bAutoMount && volName[1] == 0)

{

SetFocus (GetDlgItem (hwndDlg, IDC_VOLUME_NAME));

SendMessage(hTree,LVM_SETEXTENDEDLISTVIEWSTYLE,0,

LVS_EX_FULLROWSELECT

lvCol.cx = CompensateXDPI (38);

lvCol.fmt = LVCFMT_COL_HAS_IMAGES|LVCFMT_LEFT ;

SendMessage (hTree,LVM_INSERTCOLUMNW,0,(LPARAM)&lvCol);

lvCol.fmt = LVCFMT_LEFT;

SendMessage (hTree,LVM_INSERTCOLUMNW,1,(LPARAM)&lvCol);

LastDriveListVolumeColumnWidth = ListView_GetColumnWidth (hTree, 1);

lvCol.cx = CompensateXDPI (55);

lvCol.fmt = LVCFMT_RIGHT;

SendMessage (hTree,LVM_INSERTCOLUMNW,2,(LPARAM)&lvCol);

lvCol.cx = CompensateXDPI (123);

lvCol.fmt = LVCFMT_LEFT;

SendMessage (hTree,LVM_INSERTCOLUMNW,3,(LPARAM)&lvCol);

lvCol.cx = CompensateXDPI (100);

lvCol.fmt = LVCFMT_LEFT;

SendMessage (hTree,LVM_INSERTCOLUMNW,4,(LPARAM)&lvCol);

DeleteObject (hBitmapMask);

}

ListView_SetImageList (hTree, hList, LVSIL_SMALL);

LoadDriveLetters (hwndDlg, hTree, 0);

dlgParam.pim = pim;

dlgParam.truecryptMode = truecryptMode;

MAKEINTRESOURCEW (IDD_PASSWORD_DLG), hwndDlg,

(DLGPROC) PasswordDlgProc, (LPARAM) &dlgParam);

BOOL bEffectiveTryEmptyPasswordWhenKeyfileUsed = bCmdTryEmptyPasswordWhenKeyfileUsedValid? bCmdTryEmptyPasswordWhenKeyfileUsed : bTryEmptyPasswordWhenKeyfileUsed;

BOOL bUseCmdVolumePassword = CmdVolumePasswordValid && ((CmdVolumePassword.Length > 0) || (KeyFilesEnable && FirstKeyFile));

* Default values used only when nothing specified in command line

*/

if (EffectiveVolumePkcs5 == 0)

mounted = MountVolume (hwndDlg, nDosDriveNo, szFileName, NULL, 0, 0, TRUE, bCacheInDriver, bIncludePimInCache, bForceMount, &mountOptions, Silent, FALSE);

if (!mounted)

mounted = MountVolume (hwndDlg, nDosDriveNo, szFileName, NULL, 0, EffectiveVolumePim, FALSE, bCacheInDriver, bIncludePimInCache, bForceMount, &mountOptions, Silent, FALSE);

// If keyfiles are enabled, test empty password first

if (!mounted && KeyFilesEnable && FirstKeyFile && bEffectiveTryEmptyPasswordWhenKeyfileUsed)

{

mounted = MountVolume (hwndDlg, nDosDriveNo, szFileName, &emptyPassword, 0, 0, TRUE, bCacheInDriver, bIncludePimInCache, bForceMount, &mountOptions, Silent, FALSE);

if (!mounted)

mounted = MountVolume (hwndDlg, nDosDriveNo, szFileName, &emptyPassword, 0, EffectiveVolumePim, FALSE, bCacheInDriver, bIncludePimInCache, bForceMount, &mountOptions, Silent, FALSE);

burn (&emptyPassword, sizeof (emptyPassword));

}

}

}

while (mounted == 0)

if (bUseCmdVolumePassword)

{

VolumePassword = CmdVolumePassword;

burn (&GuiPim, sizeof(GuiPim));

}

}

WaitCursor ();

if (KeyFilesEnable)

RefreshMainDlg(MainDlg);

if (bExplore)

WaitCursor();

OpenVolumeExplorerWindow (nDosDriveNo);

NormalCursor();

EnableWindow(hwndDlg, FALSE);

finally_do_arg2 (HWND, hwndDlg, BOOL, bIsForeground, { EnableWindow(finally_arg, TRUE); if (finally_arg2) BringToForeground (finally_arg); bPrebootPasswordDlgMode = FALSE;});

}

typedef struct

*pbResult = DeviceIoControl (hDriver, TC_IOCTL_DISMOUNT_ALL_VOLUMES, punmount,

sizeof (UNMOUNT_STRUCT), punmount, sizeof (UNMOUNT_STRUCT), pdwResult, NULL);

|| (punmount->ignoreOpenFiles != TRUE && punmount->ignoreOpenFiles != FALSE)

|| (punmount->HiddenVolumeProtectionTriggered != TRUE && punmount->HiddenVolumeProtectionTriggered != FALSE)

|| (punmount->nReturnCode < 0)

wchar_t msg[4096];

VolumeNotificationsList.bHidVolDamagePrevReported [punmount->nDosDriveNo] = TRUE;

StringCbPrintfW (msg, sizeof(msg), GetString ("DAMAGE_TO_HIDDEN_VOLUME_PREVENTED"), punmount->nDosDriveNo + L'A');

SetForegroundWindow (hwndDlg);

MessageBoxW (hwndDlg, msg, lpszTitle, MB_ICONWARNING | MB_SETFOREGROUND | MB_TOPMOST);

unmount.nDosDriveNo = 0;

unmount.ignoreOpenFiles = forceUnmount;

dismountAllThreadParam.punmount = &unmount;

dismountAllThreadParam.interact = interact;

dismountAllThreadParam.dismountMaxRetries = dismountMaxRetries;

if (interact && !Silent)

{

}

else

DismountAllThreadProc (&dismountAllThreadParam, hwndDlg);

return FALSE;

}

if (interact)

MessageBoxW (hwndDlg, GetString ("UNMOUNT_FAILED"), lpszTitle, MB_ICONERROR);

}

int EffectiveVolumePkcs5 = CmdVolumePkcs5;

BOOL EffectiveVolumeTrueCryptMode = CmdVolumeTrueCryptMode;

* Default values used only when nothing specified in command line

*/

if (EffectiveVolumePkcs5 == 0)

bPrebootPasswordDlgMode = FALSE;

VolumePim = -1;

selDrive = 0;

ResetWrongPwdRetryCount ();

continue;

if (!mounted)

int nDosDriveNo;

int driveAItem = -1, driveBItem = -1;

if (nDosDriveNo == 0)

{

driveAItem = selDrive;

continue;

}

if (nDosDriveNo == 1)

selDrive++;

if (bExplore)

WaitCursor();

OpenVolumeExplorerWindow (nDosDriveNo);

NormalCursor();

if (mountOptions.ProtectHiddenVolume)

{

Info ("HIDVOL_PROT_WARN_AFTER_MOUNT_PLURAL", hwndDlg);

else if (mountedVolCount == 1)

Info ("HIDVOL_PROT_WARN_AFTER_MOUNT", hwndDlg);

{

MountAllDevicesThreadParam* threadParam =(MountAllDevicesThreadParam*) pArg;

BOOL bPasswordPrompt = threadParam->bPasswordPrompt;

threadParam->bRet = MountAllDevicesThreadCode (hwndDlg, bPasswordPrompt);

}

{

INT_PTR result;

int newPimValue = -1;

GetVolumePath (hwndDlg, szFileName, ARRAYSIZE (szFileName));

if (!TranslateVolumeID (hwndDlg, szFileName, ARRAYSIZE (szFileName)))

{

bFavoriteFound = true;

favorite->Pim = newPimValue;

if (AskYesNo("FAVORITE_PIM_CHANGED", hwndDlg) == IDYES)

{

SaveFavoriteVolumes (hwndDlg, SystemFavoriteVolumes, true);

e.Show (MainDlg);

}

&& !BootEncStatus.DriveMounted

&& !BootEncStatus.VolumeHeaderPresent

&& !SysEncryptionOrDecryptionRequired ())

return;

}

|| BootEncStatus.SetupInProgress)

{

Warning ("SYSTEM_ENCRYPTION_NOT_COMPLETED", hwndDlg);

if (bKeyboardLayoutChanged)

{

// Restore the original keyboard layout

Warning ("CANNOT_RESTORE_KEYBOARD_LAYOUT", hwndDlg);

else

bKeyboardLayoutChanged = FALSE;

e.Show (MainDlg);

}

&& !BootEncStatus.DriveMounted

&& !SysEncryptionOrDecryptionRequired ())

{

e.Show (MainDlg);

}

&& !BootEncStatus.DriveMounted

&& !BootEncStatus.DeviceFilterActive

&& !BootEncStatus.VolumeHeaderPresent

if (BootEncStatus.SetupInProgress)

{

Error ("SYS_ENCRYPTION_OR_DECRYPTION_IN_PROGRESS", hwndDlg);

return;

}

LaunchVolCreationWizard (hwndDlg, L"/dsysenc");

}

else

// We allow the user to continue as we don't know if the drive is really an encrypted system drive.

// If it is, the user has been warned and he will not be able to start decrypting, because the

// external without-PBA access (the user will receive the 'Incorrect password' error message).

}

NormalCursor ();

if (AskNoYesString ((wstring (GetString ("CONFIRM_DECRYPT_NON_SYS_DEVICE")) + L"\n\n" + scPath).c_str(), hwndDlg) == IDNO)

return;

return;

}

&& !BootEncStatus.DriveMounted

&& !BootEncStatus.VolumeHeaderPresent

&& !SysEncryptionOrDecryptionRequired ())

return;

}

|| BootEncStatus.SetupInProgress)

{

Warning ("SYSTEM_ENCRYPTION_NOT_COMPLETED", hwndDlg);

wchar_t szRescueDiskISO [TC_MAX_PATH+1];

if (AskOkCancel ("RESCUE_DISK_NON_WIZARD_CREATION_SELECT_PATH", hwndDlg) != IDOK)

CloseSysEncMutex ();

return;

}

SHGetFolderPath (NULL, CSIDL_MYDOCUMENTS, NULL, 0, initialDir);

if (!BrowseFilesInDir (hwndDlg, "OPEN_TITLE", initialDir, szRescueDiskISO, FALSE, TRUE, NULL, L"VeraCrypt Rescue Disk.iso", L"iso"))

CloseSysEncMutex ();

return;

}

e.Show (MainDlg);

}

&& !BootEncStatus.DriveMounted

&& !BootEncStatus.VolumeHeaderPresent

&& !SysEncryptionOrDecryptionRequired ())

return;

}

|| BootEncStatus.SetupInProgress)

{

Warning ("SYSTEM_ENCRYPTION_NOT_COMPLETED", hwndDlg);

try

{

if (!checkIsoFile && (AskOkCancel ("RESCUE_DISK_NON_WIZARD_CHECK_INSERT", hwndDlg) != IDOK))

CloseSysEncMutex ();

return;

}

// Create a temporary up-to-date rescue disk image in RAM (with it the CD/DVD content will be compared)

BootEncObj->CreateRescueIsoImage (false, L"");

if (checkIsoFile)

{

wchar_t szRescueDiskISO [TC_MAX_PATH+1];

SHGetFolderPath (NULL, CSIDL_MYDOCUMENTS, NULL, 0, initialDir);

if (!BrowseFilesInDir (hwndDlg, "OPEN_TITLE", initialDir, szRescueDiskISO, FALSE, FALSE, NULL, L"VeraCrypt Rescue Disk.iso", L"iso"))

CloseSysEncMutex ();

return;

}

if (!BootEncObj->VerifyRescueDiskIsoImage (szRescueDiskISO))

Error ("RESCUE_DISK_ISO_IMAGE_CHECK_FAILED", hwndDlg);

else

}

else

{

return;

}

MAKEINTRESOURCEW (IDD_VOLUME_PROPERTIES), hwndDlg,

(DLGPROC) VolumePropertiesDlgProc, (LPARAM) TRUE);

static void ResumeInterruptedNonSysInplaceEncProcess (BOOL bDecrypt)

{

// the user would not be able resume encryption and the data on the volume would be inaccessible.

LaunchVolCreationWizard (MainDlg, bDecrypt? L"/resumeinplacedec" : L"/zinplace");

}

else

{

driveLetterToRefresh = GetSystemDriveLetter ();

}

}

else

{

// Full rebuild of the mount list

}

selDrive = (wchar_t) HIWORD (GetSelectedLong (GetDlgItem (MainDlg, IDC_DRIVELIST)));

if (ConfigBuffer == NULL)

{

// We need to load the config file because it is not done automatically when

// the settings to cache).

}

HiddenSysLeakProtectionNotificationStatus = TC_HIDDEN_OS_READ_ONLY_NOTIF_MODE_DISABLED;

SaveSettings (MainDlg);

if (ConfigBuffer == NULL)

{

// We need to load the config file because it is not done automatically when

// the settings to cache).

}

HiddenSysLeakProtectionNotificationStatus = TC_HIDDEN_OS_READ_ONLY_NOTIF_MODE_COMPACT;

SaveSettings (MainDlg);

break;

case IDM_VOLUME_PROPERTIES:

MAKEINTRESOURCEW (IDD_VOLUME_PROPERTIES), hwndDlg,

(DLGPROC) VolumePropertiesDlgProc, (LPARAM) FALSE);

break;

&& !BootEncObj->CheckBootloaderFingerprint ())

Warning ("BOOT_LOADER_FINGERPRINT_CHECK_FAILED", hwndDlg);

}

catch (...) { }

// Automount

}

else

{

* Default values used only when nothing specified in command line

*/

if (EffectiveVolumePkcs5 == 0)

if (mounted > 0)

{

MessageBeep (0xFFFFFFFF);

OpenVolumeExplorerWindow (szDriveLetter[0] - L'A');

RefreshMainDlg(hwndDlg);

OpenVolumeExplorerWindow (GetMountedVolumeDriveNo (szFileName));

else if (szFileName[0] != 0 && IsMountedVolume (szFileName))

Warning ("VOL_ALREADY_MOUNTED", hwndDlg);

if (!Quit)

RefreshMainDlg(hwndDlg);

}

// Wipe cache

if (bWipe)

WipeCache (hwndDlg, Silent);

Silent = FALSE;

GetMountList (&LastKnownMountList);

taskBarCreatedMsg = RegisterWindowMessage (L"TaskbarCreated");

ResetCurrentDirectory ();

}

return 0;

case WM_MOUSEWHEEL:

return HandleDriveListMouseWheelEvent (uMsg, wParam, lParam, FALSE);

HWND hList = GetDlgItem (hwndDlg, IDC_DRIVELIST);

// only handle if it is coming from keyboard and if the drive

// list has focus. The other cases are handled elsewhere

&& (-1 == GET_Y_LPARAM(lParam))

)

{

INT item = ListView_GetSelectionMark (hList);

DeviceIoControl (hDriver, TC_IOCTL_WIPE_PASSWORD_CACHE, NULL, 0, NULL, 0, &dwResult, NULL);

SecurityToken::CloseAllSessions();

}

DismountAll (hwndDlg, bForceAutoDismount, TRUE, UNMOUNT_MAX_AUTO_RETRIES, UNMOUNT_AUTO_RETRY_DELAY);

}

}

if (bWipeCacheOnAutoDismount)

DeviceIoControl (hDriver, TC_IOCTL_WIPE_PASSWORD_CACHE, NULL, 0, NULL, 0, &dwResult, NULL);

DismountAll (hwndDlg, bForceAutoDismount, FALSE, 1, 0);

}

if (LastKnownMountList.ulMountedDrives == 0

&& MainWindowHidden

#ifndef _DEBUG

&& !SysEncDeviceActive (TRUE)

#endif

&& GetDriverRefCount () < 2)

POINT pos;

HMENU popup = CreatePopupMenu ();

int sel, i, n;

if (MainWindowHidden)

{

AppendMenuW (popup, MF_STRING, IDM_SHOW_HIDE, GetString ("SHOW_TC"));

}

else if (bEnableBkgTask

&& (!(LastKnownMountList.ulMountedDrives == 0

&& !SysEncDeviceActive (TRUE)

&& GetDriverRefCount () < 2)))

{

StringCbPrintfW (s, sizeof(s), L"%s %c: (%s)",

GetString (n==0 ? "OPEN" : "DISMOUNT"),

label.empty() ? vol : label.c_str());

AppendMenuW (popup, MF_STRING, n*26 + TRAYICON_MENU_DRIVE_OFFSET + i, s);

}

if (Dismount (hwndDlg, sel - TRAYICON_MENU_DRIVE_OFFSET - 26))

{

wchar_t txt [2048];

InfoBalloonDirect (GetString ("SUCCESSFULLY_DISMOUNTED"), txt, hwndDlg);

}

case TC_APPMSG_SYSENC_CONFIG_UPDATE:

LoadSysEncSettings ();

// require us to update our cached settings.

LoadSettings (hwndDlg);

if (GetAsyncKeyState (VK_CONTROL) < 0)

{

* Default values used only when nothing specified in command line

*/

if (CmdVolumePkcs5 == 0)

mountOptions.ProtectedHidVolPkcs5Prf = CmdVolumePkcs5;

mountOptions.ProtectedHidVolPim = CmdVolumePim;

MAKEINTRESOURCEW (IDD_MOUNT_OPTIONS), hwndDlg,

(DLGPROC) MountOptionsDlgProc, (LPARAM) &mountOptions))

return 1;

not open, because drag&drop operation would be initiated. Therefore, we're handling

RMB drag-and-drop operations as well. */

{

DisplayDriveListContextMenu (hwndDlg, lParam);

return 1;

return 1;

}

&& LOWORD (GetSelectedLong (GetDlgItem (hwndDlg, IDC_DRIVELIST))) == 0xffff)

{

MessageBoxW (hwndDlg, GetString ("SELECT_FREE_DRIVE"), L"VeraCrypt", MB_ICONEXCLAMATION);

MountAllDevices (hwndDlg, !(GetAsyncKeyState (VK_SHIFT) < 0 && !IsPasswordCacheEmpty()));

return 1;

}

if (lw == IDC_SELECT_FILE || lw == IDM_SELECT_FILE)

{

SelectContainer (hwndDlg);

bPrebootPasswordDlgMode = TRUE;

if (CheckMountList (hwndDlg, FALSE))

}

break;

}

Warning ("NO_VOLUME_SELECTED", hwndDlg);

}

else

pwdChangeDlgMode = PCDM_REMOVE_ALL_KEYFILES_FROM_VOL;

ChangePassword (hwndDlg);

}

if (lw == IDM_KEYFILE_GENERATOR)

{

MAKEINTRESOURCEW (IDD_KEYFILE_GENERATOR), hwndDlg,

(DLGPROC) KeyfileGeneratorDlgProc, (LPARAM) 0);

TextInfoDialogBox (TC_TBXID_LEGAL_NOTICES);

return 1;

}

if (lw == IDM_WEBSITE)

{

Applink ("website", TRUE, "");

if (lw == IDM_PREFERENCES)

{

MAKEINTRESOURCEW (IDD_PREFERENCES_DLG), hwndDlg,

(DLGPROC) PreferencesDlgProc, (LPARAM) 0))

{

if (lw == IDM_HOTKEY_SETTINGS)

{

MAKEINTRESOURCEW (IDD_HOTKEYS_DLG), hwndDlg,

(DLGPROC) HotkeysDlgProc, (LPARAM) 0);

return 1;

wchar_t volPathLower[TC_MAX_PATH];

GetVolumePath (hwndDlg, volPathLower, ARRAYSIZE (volPathLower));

if (LOWORD (selectedDrive) != TC_MLIST_ITEM_NONSYS_VOL

if (lw == IDM_TRAVELER)

{

MAKEINTRESOURCEW (IDD_TRAVELER_DLG), hwndDlg,

(DLGPROC) TravelerDlgProc, (LPARAM) 0);

return 1;

if (lw == IDM_REFRESH_DRIVE_LETTERS)

{

DWORD driveMap = GetUsedLogicalDrives ();

WaitCursor ();

if (!(nCurrentOS == WIN_2000 && RemoteSession))

if (lw == IDC_VOLUME_PROPERTIES || lw == IDM_VOLUME_PROPERTIES)

{

MAKEINTRESOURCEW (IDD_VOLUME_PROPERTIES), hwndDlg,

(DLGPROC) VolumePropertiesDlgProc, (LPARAM) 0);

return 1;

/* Defaults */

mountOptions.PreserveTimestamp = TRUE;

if (_wcsicmp (lpszCommandLine, L"-Embedding") == 0)

{

ComServerMode = TRUE;

as.args = args;

as.arg_cnt = sizeof(args)/ sizeof(args[0]);

switch (GetArgumentID (&as, lpszCommandLineArgs[i]))

{

case OptionAuto:

AbortProcess ("BAD_DRIVE_LETTER");

}

cmdUnmountDrive = -1;

break;

else if (!_wcsicmp (szTmp, L"sm") || !_wcsicmp (szTmp, L"system"))

mountOptions.PartitionInInactiveSysEncScope = bPrebootPasswordDlgMode = TRUE;

else if (!_wcsicmp (szTmp, L"bk") || !_wcsicmp (szTmp, L"headerbak"))

mountOptions.UseBackupHeader = TRUE;

szTmp, ARRAYSIZE (szTmp)))

{

int iLen = WideCharToMultiByte (CP_UTF8, 0, szTmp, -1, (char*) CmdVolumePassword.Text, MAX_PASSWORD + 1, NULL, NULL);

if (iLen > 0)

{

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

CmdVolumePasswordValid = TRUE;

}

else

}

else

AbortProcess ("COMMAND_LINE_ERROR");

static SERVICE_STATUS_HANDLE SystemFavoritesServiceStatusHandle;

static void SystemFavoritesServiceLogMessage (const wstring &errorMessage, WORD wType)

HANDLE eventSource = RegisterEventSource (NULL, TC_SYSTEM_FAVORITES_SERVICE_NAME);

if (eventSource)

}

static void SystemFavoritesServiceLogError (const wstring &errorMessage)

SystemFavoritesServiceLogMessage (errorMessage, EVENTLOG_ERROR_TYPE);

}

static void SystemFavoritesServiceLogWarning (const wstring &warningMessage)

SystemFavoritesServiceLogMessage (warningMessage, EVENTLOG_WARNING_TYPE);

}

static void SystemFavoritesServiceLogInfo (const wstring &infoMessage)

SystemFavoritesServiceLogMessage (infoMessage, EVENTLOG_INFORMATION_TYPE);

}

static VOID WINAPI SystemFavoritesServiceCtrlHandler (DWORD control)

{

SystemFavoritesServiceSetStatus (SERVICE_STOP_PENDING);

else

SystemFavoritesServiceSetStatus (SystemFavoritesServiceStatus.dwCurrentState);

#endif

ZeroMemory (&tnid, sizeof (tnid));

return FALSE;

}

ScreenDPI >= 120 ? 0 : 16,

| LR_SHARED

| (nCurrentOS != WIN_2000 ? LR_DEFAULTCOLOR : LR_VGACOLOR)); // Windows 2000 cannot display more than 16 fixed colors in notification tray

StringCbCopyW (tnid.szTip, sizeof(tnid.szTip), L"VeraCrypt");

}

if (TaskBarIconMutex != NULL)

{

BOOL res;

ZeroMemory (&tnid, sizeof (tnid));

res = Shell_NotifyIcon (NIM_DELETE, &tnid);

if (TaskBarIconMutex)

}

if (TaskBarIconMutex == NULL)

return FALSE;

ZeroMemory (&tnid, sizeof (tnid));

ScreenDPI >= 120 ? 0 : 16,

| LR_SHARED

| (nCurrentOS != WIN_2000 ? LR_DEFAULTCOLOR : LR_VGACOLOR)); // Windows 2000 cannot display more than 16 fixed colors in notification tray

}

if (GetTickCount() > lastMinTickCount && GetTickCount() - lastMinTickCount < 60 * 1000)

return;

lastMinTickCount = GetTickCount();

for (i = 0; i < 26; i++)

bResult = DeviceIoControl (hDriver, TC_IOCTL_GET_VOLUME_PROPERTIES, &prop,

sizeof (prop), &prop, sizeof (prop), &dwResult, NULL);

&& prop.ea >= EAGetFirst() && prop.ea <= EAGetCount()

&& prop.pkcs5Iterations > 0

&& prop.hiddenVolProtection >= 0 && prop.volFormatVersion >= 0

&& prop.volumePim >= 0

)

)

{

&& LastWritten[i] == prop.totalBytesWritten

&& LastId[i] == prop.uniqueId)

{

}

return FALSE;

}

mountOptions.ReadOnly = favorite.ReadOnly || userForcedReadOnly;

mountOptions.Removable = favorite.Removable;

if (favorite.UseLabelInExplorer && !favorite.Label.empty())

&& !favoriteVolumeToMount.Path.empty()

&& GetAsyncKeyState (VK_CONTROL) < 0)

{

* Default values used only when nothing specified in command line

*/

if (CmdVolumePkcs5 == 0)

SystemFavoritesServiceLogInfo (wstring (L"Loaded ") + szTmp + wstring (L" favorites from the file"));

/* correct set the connected state of the system favorites */

favorite != favorites.end(); favorite++)

{

if (favorite->UseVolumeID)

if (systemFavorites && ServiceMode && !skippedSystemFavorites.empty())

{

// Some drives need more time to initialize correctly.

int retryCounter = 0;

size_t remainingFavorites = skippedSystemFavorites.size();

while ((remainingFavorites > 0) && (retryCounter++ < 4))

SystemFavoritesServiceStatus.dwCheckPoint++;

SystemFavoritesServiceSetStatus (SERVICE_START_PENDING, 120000);

favorite != skippedSystemFavorites.end(); favorite++)

{

if (favorite->DisconnectedDevice)

remainingFavorites--;

if (favorite->UseVolumeID)

SystemFavoritesServiceLogInfo (wstring (L"Favorite \"ID:") + ArrayToHexWideString (favorite->VolumeID, sizeof (favorite->VolumeID)) + L"\" is connected. Performing mount.");

else

{

if (defaultKeyFilesParam.FirstKeyFile == NULL)

{

_wremove (GetConfigPath (TC_APPD_FILENAME_DEFAULT_KEYFILES));

}

else

wchar_t q[TC_MAX_PATH * 2];

XmlQuoteTextW (kf->FileName, q, ARRAYSIZE (q));

kf = kf->Next;

}

XmlWriteFooter (f);

int EffectiveVolumePkcs5 = CmdVolumePkcs5;

int EffectiveVolumePim = CmdVolumePim;

* Default values used only when nothing specified in command line

*/

if (EffectiveVolumePkcs5 == 0)

StringCbPrintfW (szTmp, sizeof(szTmp), GetString ("CONFIRM_VOL_HEADER_BAK"), lpszVolume);

&& (MessageBoxW (hwndDlg, szTmp, lpszTitle, YES_NO|MB_ICONQUESTION|MB_DEFBUTTON1) == IDNO))

goto ret;

if (!RandgetBytes (hwndDlg, temporaryKey, EAGetKeySize (volume.CryptoInfo->ea), TRUE)

|| !RandgetBytes (hwndDlg, volume.CryptoInfo->k2, sizeof (volume.CryptoInfo->k2), FALSE))

{

goto error;

}

burn (&hiddenVolPassword, sizeof (hiddenVolPassword));

burn (temporaryKey, sizeof (temporaryKey));

burn (originalK2, sizeof (originalK2));

RestoreDefaultKeyFilesParam();

RandStop (FALSE);

NormalCursor();

int EffectiveVolumePkcs5 = CmdVolumePkcs5;

int EffectiveVolumePim = CmdVolumePim;

* Default values used only when nothing specified in command line

*/

if (EffectiveVolumePkcs5 == 0)

else

{

// Restore header from an external backup

StringCbPrintfW (szTmp, sizeof(szTmp), GetString ("CONFIRM_VOL_HEADER_RESTORE"), lpszVolume);

if (MessageBoxW (hwndDlg, szTmp, lpszTitle, YES_NO|MB_ICONWARNING|MB_DEFBUTTON2) == IDNO)

}

catch (...)

{

}

if (BootEncStatus.DriveMounted)

{

LocalizeDialog (hwndDlg, "IDD_DEFAULT_MOUNT_PARAMETERS");

DefaultVolumeTrueCryptMode ? BST_CHECKED:BST_UNCHECKED, 0);

/* Populate the PRF algorithms list */

return 0;

}

case WM_COMMAND:

switch (lw)

int pkcs5 = (int) SendMessage (GetDlgItem (hwndDlg, IDC_PKCS5_PRF_ID), CB_GETITEMDATA, SendMessage (GetDlgItem (hwndDlg, IDC_PKCS5_PRF_ID), CB_GETCURSEL, 0, 0), 0);

BOOL truecryptMode = GetCheckBox (hwndDlg, IDC_TRUECRYPT_MODE);

/* SHA-256 is not supported by TrueCrypt */

&& (pkcs5 == SHA256)

)

{

DefaultVolumePkcs5 = pkcs5;

SaveSettings (hwndDlg);

NormalCursor ();

EndDialog (hwndDlg, lw);

return 1;

}

if (mountWithOptions || GetAsyncKeyState (VK_CONTROL) < 0)

{

* Default values used only when nothing specified in command line

*/

if (CmdVolumePkcs5 == 0)

else

mountOptions.ProtectedHidVolPkcs5Prf = CmdVolumePkcs5;

mountOptions.ProtectedHidVolPim = CmdVolumePim;

MAKEINTRESOURCEW (IDD_MOUNT_OPTIONS), hwndDlg,

(DLGPROC) MountOptionsDlgProc, (LPARAM) &mountOptions))

return;

}

if (CheckMountList (hwndDlg, FALSE))

}

else

Warning ("SELECT_FREE_DRIVE", hwndDlg);