BOOL bExplore = FALSE; /* Display explorer window after mount */

BOOL bBeep = FALSE; /* Donot beep after mount */

BOOL bCacheInDriver = FALSE; /* Cache any passwords we see */

BOOL bCacheInDriverDefault = FALSE;

BOOL bCacheDuringMultipleMount = FALSE;

KeyFile *FirstCmdKeyFile;

HBITMAP hbmLogoBitmapRescaled = NULL;

BOOL bKeyboardLayoutChanged = FALSE; /* TRUE if the keyboard layout was changed to the standard US keyboard layout (from any other layout). */

BOOL bKeybLayoutAltKeyWarningShown = FALSE; /* TRUE if the user has been informed that it is not possible to type characters by pressing keys while the right Alt key is held down. */

{

if (!hWtsLib)

{

if (GetSystemDirectory(dllPath, MAX_PATH))

else

hWtsLib = LoadLibrary(dllPath);

if (hWtsLib)

void RefreshMainDlg (HWND hwndDlg)

{

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

LoadDriveLetters (hwndDlg, GetDlgItem (hwndDlg, IDC_DRIVELIST), drive);

if (!bHistory)

{

ClearHistory (GetDlgItem (hwndDlg, IDC_VOLUME));

}

return (GetWindowTextLength (GetDlgItem (hwndDlg, IDC_VOLUME)) > 0);

}

{

GetWindowText (GetDlgItem (hwndDlg, IDC_VOLUME), szPath, nMaxCount);

CorrectFileName (szPath);

{

int retCode = 0;

retCode = IsSystemDevicePath (szFileName, MainDlg, FALSE);

// 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).

{

LPARAM selectedDrive = GetSelectedLong (GetDlgItem (MainDlg, IDC_DRIVELIST));

wchar_t volPathDriveListW [TC_MAX_PATH];

VOLUME_PROPERTIES_STRUCT prop;

DWORD dwResult;

if (VolumeSelected (MainDlg))

{

// volPathInputField will contain the volume path (if any) from the input field below the drive list

if (!ambig)

}

if (LOWORD (selectedDrive) != TC_MLIST_ITEM_FREE && LOWORD (selectedDrive) != 0xffff && HIWORD (selectedDrive) != 0xffff)

switch (LOWORD (selectedDrive))

{

case TC_MLIST_ITEM_NONSYS_VOL:

if (!DeviceIoControl (hDriver, TC_IOCTL_GET_VOLUME_PROPERTIES, &prop, sizeof (prop), &prop, sizeof (prop), &dwResult, NULL) || dwResult == 0)

{

// The driver did not return any path for this drive letter (the volume may have been dismounted).

// Return whatever is in the input field below the drive list (even if empty)

}

// volPathDriveListWStr will contain the volume path selected in the main drive list

break;

case TC_MLIST_ITEM_SYS_PARTITION:

if (bCachedSysDevicePathsValid)

{

}

break;

if (bCachedSysDevicePathsValid)

{

}

break;

{

/* We have two paths. Compare them and if they don't match, ask the user to select one of them. Otherwise, return the path without asking. */

{

// The volume path starts with "\\??\\" which is used for file-hosted containers. We're going to strip this prefix.

}

{

// The path selected in the input field is different from the path to the volume selected

// in the drive lettter list. We have to resolve possible ambiguity.

wchar_t *tmp[] = {L"", L"", L"", L"", L"", 0};

const int maxVolPathLen = 80;

{

// Ellipsis (path too long)

}

if (volPathInputFieldWStr.length () > maxVolPathLen)

{

}

tmp[1] = GetString ("AMBIGUOUS_VOL_SELECTION");

tmp[3] = (wchar_t *) volPathInputFieldWStr.c_str();

tmp[4] = GetString ("IDCANCEL");

break;

case 2:

break;

default:

if (driveNoPtr != NULL)

*driveNoPtr = -1;

}

}

else

{

// Both selected paths are the same

}

}

if (driveNoPtr != NULL)

{

// The selected volume path starts with "\\??\\" which is used for file-hosted containers. We're going to strip this prefix.

}

return retPath;

// Drive letter - command line arg overrides registry

if (!bOnlyCheckModified && bHistory && szDriveLetter[0] == 0)

if (bHistory && pbSettingsModified)

{

// only check for last drive modification if history enabled

LPARAM lLetter;

lLetter = GetSelectedLong (GetDlgItem (hwndDlg, IDC_DRIVELIST));

if (LOWORD (lLetter) != 0xffff)

ConfigReadCompareString ("LastSelectedDrive", "", szTmp, sizeof (szTmp), bOnlyCheckModified, pbSettingsModified);

}

// Hotkeys

ConfigReadCompareInt ("PlaySoundOnHotkeyMountDismount", TRUE, &bPlaySoundOnSuccessfulHkDismount, bOnlyCheckModified, pbSettingsModified);

// Drive Letter

lLetter = GetSelectedLong (GetDlgItem (hwndDlg, IDC_DRIVELIST));

if (LOWORD (lLetter) != 0xffff)

ConfigWriteString ("LastSelectedDrive", szTmp);

}

ConfigWriteString ("Language", GetPreferredLangId ());

// PKCS#11 Library Path

// Mount Options

ConfigWriteInt ("DefaultPRF", DefaultVolumePkcs5);

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

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

}

}

AppendMenuW (popup, MF_STRING, IDM_CHANGE_SYS_PASSWORD, GetString ("IDM_CHANGE_SYS_PASSWORD"));

// AppendMenuW (popup, MF_STRING, IDM_CHANGE_SYS_HEADER_KEY_DERIV_ALGO, GetString ("IDM_CHANGE_SYS_HEADER_KEY_DERIV_ALGO"));

AppendMenuW (popup, MF_STRING, IDM_SYS_ENC_SETTINGS, GetString ("IDM_SYS_ENC_SETTINGS"));

if (!IsHiddenOSRunning())

{

AppendMenuW (popup, MF_STRING, IDM_CREATE_RESCUE_DISK, GetString ("IDM_CREATE_RESCUE_DISK"));

AppendMenuW (popup, MF_STRING, IDM_VERIFY_RESCUE_DISK, GetString ("IDM_VERIFY_RESCUE_DISK"));

AppendMenuW (popup, MF_STRING, IDM_VERIFY_RESCUE_DISK_ISO, GetString ("IDM_VERIFY_RESCUE_DISK_ISO"));

{

if (SysDriveOrPartitionFullyEncrypted (FALSE) && !IsHiddenOSRunning())

{

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

}

AppendMenuW (popup, MF_STRING, IDM_VOLUME_PROPERTIES, GetString ("IDPM_PROPERTIES"));

}

}

// mounting a partition (as a regular volume) that is within key scope of system encryption.

// Returns TRUE if the partition can be mounted as a partition within key scope of inactive system encryption.

// If devicePath is empty, the currently selected partition in the GUI is checked.

{

BOOL tmpbDevice;

{

CreateFullVolumePath (szDiskFile, sizeof(szDiskFile), szDevicePath, &tmpbDevice);

if (!tmpbDevice)

}

}

else

if (!partionPortion

{

// Only partitions are supported (not whole drives)

if (!quiet)

{

int retCode = 0;

int driveNo;

{

if (!quiet)

Error ("INVALID_PATH", hwndDlg);

return FALSE;

}

sizeof (parentDrivePath),

driveNo);

WaitCursor ();

// 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

{

int driveNo;

if (bPrebootPasswordDlgMode)

return FALSE;

return FALSE;

sizeof (parentDrivePath),

driveNo);

BootEncStatus = BootEncObj->GetStatus();

}

{

if (nLetter == 0)

{

// The caller specified an invalid drive letter (typically because it is unknown).

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

}

int i;

}

{

if (tmp)

{

STARTUPINFO si;

PROCESS_INFORMATION pi;

ZeroMemory (&si, sizeof (si));

// check if there is a suffix in VeraCrypt file name

// in order to use the same for "VeraCrypt Format"

if (suffix)

{

}

else

*tmp = 0;

if (!FileExists(t))

Error ("VOL_CREATION_WIZARD_NOT_FOUND", hwndDlg); // Display a user-friendly error message and advise what to do

{

}

{

handleWin32Error (hwndDlg, SRC_POS);

}

static void LaunchVolExpander (HWND hwndDlg)

{

if (tmp)

{

// check if there is a suffix in VeraCrypt file name

// in order to use the same for "VeraCrypt Format"

if (suffix)

{

}

else

*tmp = 0;

if (!FileExists(t))

Error ("VOL_EXPANDER_NOT_FOUND", hwndDlg); // Display a user-friendly error message and advise what to do

{

handleWin32Error (hwndDlg, SRC_POS);

}

// Remember the top-most visible item

int lastTopMostVisibleItem = ListView_GetTopIndex (hTree);

DWORD dwResult;

BOOL bResult;

DWORD dwUsedDrives;

MOUNT_LIST_STRUCT driver;

VOLUME_PROPERTIES_STRUCT propSysEnc;

BOOL bSysEnc = FALSE;

BOOL bWholeSysDriveEncryption = FALSE;

}

{

wchar_t szTmpW[1024];

memset(&listItem, 0, sizeof(listItem));

listItem.iItem = item++;

listItem.pszText = szTmp;

szTmp[1] = 0;

listItem.lParam = MAKELONG (TC_MLIST_ITEM_SYS_DRIVE, ENC_SYSDRIVE_PSEUDO_DRIVE_LETTER);

}

}

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

EAGetName (szTmp, propSysEnc.ea, 1);

listItem.iSubItem = 3;

ListView_SetItem (hTree, &listItem);

}

}

{

int curDrive = 0;

if (drive > 0)

{

if (driver.ulMountedDrives & (1 << i)

|| bSysEncPartition)

{

wchar_t szTmpW[1024];

wchar_t *ws;

listItem.lParam = MAKELONG (

bSysEncPartition ? TC_MLIST_ITEM_SYS_PARTITION : TC_MLIST_ITEM_NONSYS_VOL,

listItem.pszText = szDriveLetters[i];

}

}

}

else

{

path += 4;

listItem.iSubItem = 1;

if (label.empty())

label = GetFavoriteVolumeLabel (path, useInExplorer);

if (!label.empty())

else

}

GetSizeString (bSysEncPartition ? GetSysEncDeviceSize(TRUE) : driver.diskLength[i], szTmpW, sizeof(szTmpW));

EAGetName (szTmp, bSysEncPartition ? propSysEnc.ea : driver.ea[i], 1);

listItem.iSubItem = 3;

{

ws = GetString (IsHiddenOSRunning() ? "HIDDEN" : "SYSTEM_VOLUME_TYPE_ADJECTIVE");

VolumeNotificationsList.bHidVolDamagePrevReported[i] = FALSE;

}

else

{

if (driver.truecryptMode[i])

{

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

}

else

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

{

wchar_t szTmp[4096];

VolumeNotificationsList.bHidVolDamagePrevReported[i] = TRUE;

SetForegroundWindow (GetParent(hTree));

MessageBoxW (GetParent(hTree), szTmp, lpszTitle, MB_ICONWARNING | MB_SETFOREGROUND | MB_TOPMOST);

}

ListView_SetItem (hTree, &listItem);

listItem.mask=LVIF_TEXT;

listItem.iSubItem = 1;

ListView_SetItem (hTree, &listItem);

listItem.iSubItem = 2;

char password[MAX_PASSWORD + 1];

char newPassword[MAX_PASSWORD + 1];

char newVerify[MAX_PASSWORD + 1];

BOOL bEnable = TRUE;

if (pwdChangeDlgMode == PCDM_CHANGE_PKCS5_PRF)

newKeyFilesEnabled = keyFilesEnabled;

case PCDM_CHANGE_PKCS5_PRF:

memcpy (newPassword, password, sizeof (newPassword));

memcpy (newVerify, password, sizeof (newVerify));

break;

default:

}

bEnable = FALSE;

else if (strcmp (newPassword, newVerify) != 0)

bEnable = FALSE;

bEnable = FALSE;

burn (password, sizeof (password));

burn (newPassword, sizeof (newPassword));

burn (newVerify, sizeof (newVerify));

EnableWindow (GetDlgItem (hwndDlg, button), bEnable);

}

typedef struct

{

BOOL bRequireConfirmation;

int* iResult;

} BackupHeaderThreadParam;

typedef struct

{

int* iResult;

} RestoreHeaderThreadParam;

/* we are in the case of a volume. Store its name to use it in the key file dialog

* this will help avoid using the current container file as a key file

*/

}

SetWindowTextW (hwndDlg, GetString ("IDD_PASSWORDCHANGE_DLG"));

if ((DWORD) GetKeyboardLayout (NULL) != 0x00000409 && (DWORD) GetKeyboardLayout (NULL) != 0x04090409)

{

if (keybLayout != 0x00000409 && keybLayout != 0x04090409)

{

// Keyboard layout is not standard US

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

tmp [MAX_PASSWORD] = 0;

SetWindowText (GetDlgItem (hwndDlg, IDC_OLD_PASSWORD), tmp);

SetWindowText (GetDlgItem (hwndDlg, IDC_PASSWORD), tmp);

SetWindowText (GetDlgItem (hwndDlg, IDC_VERIFY), tmp);

if (keybLayout != 0x00000409 && keybLayout != 0x04090409)

{

if (lw == IDCANCEL)

{

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

tmp[MAX_PASSWORD] = 0;

SetWindowText (GetDlgItem (hwndDlg, IDC_PASSWORD), tmp);

SetWindowText (GetDlgItem (hwndDlg, IDC_OLD_PASSWORD), tmp);

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

{

GetDlgItemText (hwndDlg, IDC_OLD_PIM, tmp, MAX_PIM + 1);

SetDlgItemText (hwndDlg, IDC_PIM, tmp);

}

return 1;

}

{

Error ("UNSUPPORTED_CHARS_IN_PWD", hwndDlg);

return 1;

return 1;

}

switch (pwdChangeDlgMode)

{

break;

default:

}

WaitCursor ();

if (nStatus == 0)

{

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

tmp[MAX_PASSWORD] = 0;

SetWindowText (GetDlgItem (hwndDlg, IDC_PASSWORD), tmp);

SetWindowText (GetDlgItem (hwndDlg, IDC_OLD_PASSWORD), tmp);

return 0;

}

static BOOL PasswordDialogDisableMountOptions;

static char *PasswordDialogTitleStringId;

{

SetWindowTextW (hwndDlg, GetString (PasswordDialogTitleStringId));

}

{

wchar_t s[1024];

RECT rect;

}

else

{

StringCbPrintfW (s, sizeof(s), GetString ("ENTER_PASSWORD_FOR"), FitPathInGfxWidth (hwndDlg, WindowTitleBarFont, rect.right - rect.left - GetTextGfxWidth (hwndDlg, s, WindowTitleBarFont), PasswordDlgVolume).c_str());

}

ToBootPwdField (hwndDlg, IDC_PASSWORD);

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

tmp [MAX_PASSWORD] = 0;

SetWindowText (GetDlgItem (hwndDlg, IDC_PASSWORD), tmp);

if (keybLayout != 0x00000409 && keybLayout != 0x04090409)

{

// Keyboard layout is not standard US

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

tmp [MAX_PASSWORD] = 0;

SetWindowText (GetDlgItem (hwndDlg, IDC_PASSWORD), tmp);

if (keybLayout != 0x00000409 && keybLayout != 0x04090409)

{

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

{

if (lw == IDOK)

{

if (mountOptions.ProtectHiddenVolume && hidVolProtKeyFilesParam.EnableKeyFiles)

bCacheInDriver = IsButtonChecked (GetDlgItem (hwndDlg, IDC_CACHE));

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

}

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

tmp[MAX_PASSWORD] = 0;

SetWindowText (GetDlgItem (hwndDlg, IDC_PASSWORD), tmp);

SetWindowText (GetDlgItem (hwndDlg, IDC_PASSWORD_PROT_HIDVOL), tmp);

SendDlgItemMessage (hwndDlg, IDC_PIM, EM_LIMITTEXT, MAX_PIM, 0);

if (mountOptions->ProtectedHidVolPassword.Length > 0)

SetPim (hwndDlg, IDC_PIM, mountOptions->ProtectedHidVolPim);

if (lw == IDCANCEL)

{

// Cleanup

tmp[MAX_PASSWORD] = 0;

SetWindowText (GetDlgItem (hwndDlg, IDC_PASSWORD_PROT_HIDVOL), tmp);

if (lw == IDOK)

{

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

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

if (mountOptions->ProtectHiddenVolume)

{

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

}

// Cleanup

tmp[MAX_PASSWORD] = 0;

SetWindowText (GetDlgItem (hwndDlg, IDC_PASSWORD_PROT_HIDVOL), tmp);

LVCOLUMNW lvCol;

HWND list = GetDlgItem (hwndDlg, IDC_VOLUME_PROPERTIES_LIST);

wchar_t sw[1024];

wchar_t *s;

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

memset (&prop, 0, sizeof(prop));

if (bSysEnc)

{

}

// Location

if (bSysEnc)

else

// Size

StringCbPrintfW (sw, sizeof(sw), L"%I64u %s", prop.diskLength, GetString ("BYTES"));

// Type

if (bSysEnc)

else

{

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

if (truecryptMode)

{

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

}

else

}

if (!bSysEnc)

{

// Write protection

if (prop.readOnly || prop.hiddenVolProtection == HIDVOL_PROT_STATUS_ACTION_TAKEN)

s = GetString ("UISTR_YES");

else

s = GetString ("UISTR_NO");

// Hidden Volume Protection

if (prop.hiddenVolume)

s = GetString ("NOT_APPLICABLE_OR_NOT_AVAILABLE");

else if (prop.hiddenVolProtection == HIDVOL_PROT_STATUS_NONE)

else if (prop.hiddenVolProtection == HIDVOL_PROT_STATUS_ACTION_TAKEN)

s = GetString ("HID_VOL_DAMAGE_PREVENTED");

}

// Encryption algorithm

if (prop.ea == 0 || prop.ea > EAGetCount ())

{

return 1;

}

// Key size(s)

{

int size = EAGetKeySize (prop.ea);

EAGetName (name, prop.ea, 1);

// Primary key

StringCbPrintfW (sw, sizeof(sw), L"%d %s", size * 8, GetString ("BITS"));

{

// Secondary key (XTS)

}

}

// Block size

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

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

// Mode

ListSubItemSet (list, i++, 1, EAGetModeName (prop.ea, prop.mode, TRUE));

// PKCS 5 PRF

if (prop.volumePim == 0)

ListSubItemSet (list, i++, 1, get_pkcs5_prf_name (prop.pkcs5));

else

{

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

}

#if 0

// PCKS 5 iterations

sprintf (szTmp, "%d", prop.pkcs5Iterations);

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

#endif

memset (date, 0, sizeof (date));

// Volume date

*(unsigned __int64 *)(&ft) = prop.volumeCreationTime;

FileTimeToSystemTime (&ft, &st);

GetDateFormatW (LOCALE_USER_DEFAULT, 0, &st, 0, sw, sizeof (sw)/2);

swprintf (date, L"%s ", sw);

GetTimeFormatW (LOCALE_USER_DEFAULT, 0, &st, 0, sw, sizeof (sw)/2);

wcscat (date, sw);

// Header date

*(unsigned __int64 *)(&ft) = prop.headerCreationTime;

FileTimeToSystemTime (&ft, &st);

GetDateFormatW (LOCALE_USER_DEFAULT, 0, &st, 0, sw, sizeof (sw)/2);

ft64.LowPart = ft.dwLowDateTime;

swprintf (date + wcslen (date), GetString ("VOLUME_HEADER_DAYS")

, (curFt64.QuadPart - ft64.QuadPart)/(24LL*3600*10000000));

}

#endif // 0

if (!bSysEnc || IsHiddenOSRunning())

{

// Volume format version

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

// Backup header

}

// Total data read

GetSizeString (prop.totalBytesRead, sw, sizeof(sw));

// Total data written

GetSizeString (prop.totalBytesWritten, sw, sizeof(sw));

if (bSysEnc)

{

// TrueCrypt Boot Loader version

// Encrypted portion

if (GetSysEncDeviceEncryptedPartSize (FALSE) == GetSysEncDeviceSize (FALSE))

else if (GetSysEncDeviceEncryptedPartSize (FALSE) <= 1)

else

{

GetString ("PROCESSED_PORTION_X_PERCENT"),

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

}

}

if (lw == IDC_BROWSE_FILES)

{

if (BrowseFilesInDir (hwndDlg, "OPEN_TITLE", dstDir, volName, bHistory, FALSE, NULL))

return 1;

}

if (lw == IDC_BROWSE_DIRS)

{

if (BrowseDirectories (hwndDlg, "SELECT_DEST_DIR", dstPath))

SetDlgItemText (hwndDlg, IDC_DIRECTORY, dstPath);

else

StringCbPrintfW (srcPath, sizeof(srcPath), L"%s\\VeraCrypt.exe", appDir);

StringCbPrintfW (dstPath, sizeof(dstPath), L"%s\\VeraCrypt\\VeraCrypt.exe", dstDir);

{

handleWin32Error (hwndDlg, SRC_POS);

goto stop;

else

StringCbPrintfW (srcPath, sizeof(srcPath), L"%s\\VeraCrypt-x64.exe", appDir);

StringCbPrintfW (dstPath, sizeof(dstPath), L"%s\\VeraCrypt\\VeraCrypt-x64.exe", dstDir);

{

handleWin32Error (hwndDlg, SRC_POS);

goto stop;

else

StringCbPrintfW (srcPath, sizeof(srcPath), L"%s\\VeraCrypt Format.exe", appDir);

StringCbPrintfW (dstPath, sizeof(dstPath), L"%s\\VeraCrypt\\VeraCrypt Format.exe", dstDir);

{

handleWin32Error (hwndDlg, SRC_POS);

goto stop;

else

StringCbPrintfW (srcPath, sizeof(srcPath), L"%s\\VeraCrypt Format-x64.exe", appDir);

StringCbPrintfW (dstPath, sizeof(dstPath), L"%s\\VeraCrypt\\VeraCrypt Format-x64.exe", dstDir);

{

handleWin32Error (hwndDlg, SRC_POS);

goto stop;

else

StringCbPrintfW (srcPath, sizeof(srcPath), L"%s\\VeraCryptExpander.exe", appDir);

StringCbPrintfW (dstPath, sizeof(dstPath), L"%s\\VeraCrypt\\VeraCryptExpander.exe", dstDir);

{

handleWin32Error (hwndDlg, SRC_POS);

goto stop;

else

StringCbPrintfW (srcPath, sizeof(srcPath), L"%s\\VeraCryptExpander-x64.exe", appDir);

StringCbPrintfW (dstPath, sizeof(dstPath), L"%s\\VeraCrypt\\VeraCryptExpander-x64.exe", dstDir);

{

handleWin32Error (hwndDlg, SRC_POS);

goto stop;

// Driver

StringCbPrintfW (srcPath, sizeof(srcPath), L"%s\\veracrypt.sys", appDir);

StringCbPrintfW (dstPath, sizeof(dstPath), L"%s\\VeraCrypt\\veracrypt.sys", dstDir);

{

handleWin32Error (hwndDlg, SRC_POS);

goto stop;

// Driver x64

StringCbPrintfW (srcPath, sizeof(srcPath), L"%s\\veracrypt-x64.sys", appDir);

StringCbPrintfW (dstPath, sizeof(dstPath), L"%s\\VeraCrypt\\veracrypt-x64.sys", dstDir);

{

handleWin32Error (hwndDlg, SRC_POS);

goto stop;

// Language pack

StringCbPrintfW (srcPath, sizeof(srcPath), L"%s\\Language.%hs.xml", appDir, GetPreferredLangId ());

StringCbPrintfW (dstPath, sizeof(dstPath), L"%s\\VeraCrypt\\Language.%hs.xml", dstDir, GetPreferredLangId ());

}

// AutoRun

fwprintf (af, L"shell\\start=%s\nshell\\start\\command=VeraCrypt\\VeraCrypt.exe\n", GetString ("IDC_PREF_LOGON_START"));

fwprintf (af, L"shell\\dismount=%s\nshell\\dismount\\command=VeraCrypt\\VeraCrypt.exe /q /d\n", GetString ("DISMOUNT_ALL_TC_VOLUMES"));

fclose (af);

}

MessageBoxW (hwndDlg, GetString ("TRAVELER_DISK_CREATED"), lpszTitle, MB_ICONINFORMATION);

// GUI actions

{

BOOL status = FALSE;

int mounted = 0, EffectiveVolumePkcs5 = CmdVolumePkcs5;

BOOL EffectiveVolumeTrueCryptMode = CmdVolumeTrueCryptMode;

int EffectiveVolumePim = (pim < 0)? CmdVolumePim : pim;

bPrebootPasswordDlgMode = mountOptions.PartitionInInactiveSysEncScope;

if (nDosDriveNo == 0)

if (!MultipleMountOperationInProgress)

{

if (szFileName == NULL)

{

szFileName = fileName;

}

{

status = FALSE;

goto ret;

int GuiPkcs5 = EffectiveVolumePkcs5;

BOOL GuiTrueCryptMode = EffectiveVolumeTrueCryptMode;

int GuiPim = EffectiveVolumePim;

if (!AskVolumePassword (hwndDlg, &VolumePassword, &GuiPkcs5, &GuiPim, &GuiTrueCryptMode, NULL, TRUE))

goto ret;

mounted = MountVolume (hwndDlg, nDosDriveNo, szFileName, &VolumePassword, VolumePkcs5, VolumePim, VolumeTrueCryptMode, bCacheInDriver, bForceMount, &mountOptions, Silent, !Silent);

NormalCursor ();

// Check for problematic file extensions (exe, dll, sys)

if (mounted > 0 && CheckFileExtension (szFileName))

Warning ("EXE_FILE_EXTENSION_MOUNT_WARNING", hwndDlg);

WaitCursor ();

if (nDosDriveNo == -2)

if (bCloseDismountedWindows)

{

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

SetForegroundWindow (hwndDlg);

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

{

if (mountList.ulMountedDrives & (1 << i))

{

SHChangeNotify (SHCNE_DRIVEADD, SHCNF_PATH, root, NULL);

}

}

foreach (const HostDevice &device, partitions)

{

BOOL mounted = IsMountedVolume (szFileName);

// Skip other partitions of the disk if partition0 (whole disk) is mounted

selDrive++;

continue;

}

break;

}

Info ("HIDVOL_PROT_WARN_AFTER_MOUNT", hwndDlg);

}

if (status && CloseSecurityTokenSessionsAfterMount)

SecurityToken::CloseAllSessions();

INT_PTR result;

int newPimValue = -1;

if (IsMountedVolume (szFileName))

{

Warning (pwdChangeDlgMode == PCDM_CHANGE_PKCS5_PRF ? "MOUNTED_NO_PKCS5_PRF_CHANGE" : "MOUNTED_NOPWCHANGE", hwndDlg);

if (CreateSysEncMutex ()) // If no instance of the wizard is currently taking care of system encryption

{

bSysEncPwdChangeDlgMode = TRUE;

if (!MutexExistsOnSystem (TC_MUTEX_NAME_SYSENC)) // If no instance of the wizard is currently taking care of system encryption

{

}

else

Warning ("SYSTEM_ENCRYPTION_IN_PROGRESS_ELSEWHERE", hwndDlg);

if (!MutexExistsOnSystem (TC_MUTEX_NAME_SYSENC)) // If no instance of the wizard is currently taking care of system encryption

{

}

else

Warning ("SYSTEM_ENCRYPTION_IN_PROGRESS_ELSEWHERE", hwndDlg);

}

CloseSysEncMutex ();

}

else

Warning ("SYSTEM_ENCRYPTION_IN_PROGRESS_ELSEWHERE", hwndDlg);

// such information, but will exit (displaying only an error meessage).

Info("HIDDEN_OS_PREINFO", hwndDlg);

}

static void DecryptNonSysDevice (HWND hwndDlg, BOOL bResolveAmbiguousSelection, BOOL bUseDriveListSel)

{

if (bResolveAmbiguousSelection)

{

DWORD bytesReturned;

memset (&prop, 0, sizeof (prop));

if (!DeviceIoControl (hDriver, TC_IOCTL_GET_VOLUME_PROPERTIES, &prop, sizeof (prop), &prop, sizeof (prop), &bytesReturned, NULL))

{

return;

}

}

else

return;

{

// Decrypt volume specified in the input field below the main drive list

scPath = volPath;

}

WaitCursor();

{

case 1:

case 2:

return;

}

}

{

// The system drive MAY be entirely encrypted (external access without PBA) and the potentially encrypted OS is not running

NormalCursor ();

return;

if (AskWarnNoYes ("CONFIRM_DECRYPT_NON_SYS_DEVICE_CAUTION", hwndDlg) == IDNO)

return;

}

// Blindly attempts (without any checks) to instruct the wizard to resume whatever system encryption process

{

if (!MutexExistsOnSystem (TC_MUTEX_NAME_SYSENC)) // If no instance of the wizard is currently taking care of system encryption

{

}

else

Warning ("SYSTEM_ENCRYPTION_IN_PROGRESS_ELSEWHERE", hwndDlg);

try

{

wchar_t szTmp [8096];

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

{

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

}

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

if (checkIsoFile)

{

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

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

// IMPORTANT: This function must not check any config files! Otherwise, if a config file was lost or corrupt,

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

}

BOOL SelectContainer (HWND hwndDlg)

if (LastKnownLogicalDrives != GetLogicalDrives()

|| memcmp (&LastKnownMountList, &current, sizeof (current)) != 0)

{

WaitCursor ();

LastKnownMountList = current;

LoadDriveLetters (hwndDlg, GetDlgItem (MainDlg, IDC_DRIVELIST), 0);

NormalCursor ();

{

nSelectedDriveIndex = -1;

return FALSE;

{

/* System encryption status change */

int driveLetterToRefresh;

if (RecentBootEncStatus.DriveMounted == newBootEncStatus.DriveMounted) // If an icon (and whole new line) for a system device isn't to be added/removed

driveLetterToRefresh = 0;

}

LoadDriveLetters (hwndDlg, GetDlgItem (MainDlg, IDC_DRIVELIST), driveLetterToRefresh);

RecentBootEncStatus = newBootEncStatus;

{

nSelectedDriveIndex = -1;

}

// No mounted volume at this drive letter

AppendMenuW (popup, MF_STRING, IDM_MOUNT_VOLUME, GetString ("IDM_MOUNT_VOLUME"));

AppendMenuW (popup, MF_STRING, IDPM_SELECT_FILE_AND_MOUNT, GetString ("SELECT_FILE_AND_MOUNT"));

AppendMenuW (popup, MF_STRING, IDPM_SELECT_DEVICE_AND_MOUNT, GetString ("SELECT_DEVICE_AND_MOUNT"));

break;

AppendMenuW (popup, MF_STRING, IDM_UNMOUNT_VOLUME, GetString ("DISMOUNT"));

AppendMenuW (popup, MF_STRING, IDPM_OPEN_VOLUME, GetString ("OPEN"));

AppendMenuW (popup, MF_STRING, IDPM_CHECK_FILESYS, GetString ("IDPM_CHECK_FILESYS"));

AppendMenuW (popup, MF_STRING, IDPM_REPAIR_FILESYS, GetString ("IDPM_REPAIR_FILESYS"));

AppendMenuW (popup, MF_STRING, IDPM_ADD_TO_FAVORITES, GetString ("IDPM_ADD_TO_FAVORITES"));

AppendMenuW (popup, MF_STRING, IDPM_ADD_TO_SYSTEM_FAVORITES, GetString ("IDPM_ADD_TO_SYSTEM_FAVORITES"));

AppendMenuW (popup, MF_STRING, IDM_DECRYPT_NONSYS_VOL, GetString ("IDM_DECRYPT_NONSYS_VOL"));

AppendMenuW (popup, MF_STRING, IDM_VOLUME_PROPERTIES, GetString ("IDPM_PROPERTIES"));

break;

LPARAM lLetter = GetSelectedLong (hList);

if (LOWORD (lLetter) != 0xffff)

}

break;

state = GetItemLong (hList, nSelectedDriveIndex );

WaitCursor ();

NormalCursor ();

}

break;

LPARAM selectedDrive = GetSelectedLong (hList);

if (LOWORD (selectedDrive) == TC_MLIST_ITEM_NONSYS_VOL)

}

break;

ResetWrongPwdRetryCount ();

try

{

{

// No drive letter specified on command line

if (commandLineDrive == 0)

if (bAutoMountDevices)

{

EffectiveVolumeTrueCryptMode = DefaultVolumeTrueCryptMode;

// Cached password

// Command line password or keyfiles

if (!mounted && (CmdVolumePassword.Length != 0 || (FirstCmdKeyFile && (CmdVolumePasswordValid || bEffectiveTryEmptyPasswordWhenKeyfileUsed))))

if (FirstCmdKeyFile)

KeyFilesApply (hwndDlg, &CmdVolumePassword, FirstCmdKeyFile, szFileName);

szFileName, &CmdVolumePassword, EffectiveVolumePkcs5, CmdVolumePim, EffectiveVolumeTrueCryptMode, bCacheInDriver, bForceMount,

&mountOptions, Silent, reportBadPasswd);

BOOL GuiTrueCryptMode = EffectiveVolumeTrueCryptMode;

VolumePassword.Length = 0;

if (!AskVolumePassword (hwndDlg, &VolumePassword, &GuiPkcs5, &GuiPim, &GuiTrueCryptMode, NULL, TRUE))

break;

else

if (KeyFilesEnable && FirstKeyFile)

KeyFilesApply (hwndDlg, &VolumePassword, FirstKeyFile, szFileName);

burn (&VolumePassword, sizeof (VolumePassword));

burn (&VolumePkcs5, sizeof (VolumePkcs5));

MessageBeep (0xFFFFFFFF);

if (bExplore)

RefreshMainDlg(hwndDlg);

COPYDATASTRUCT cd;

memcpy (&cd.dwData, WM_COPY_SET_VOLUME_NAME, 4);

cd.lpData = szFileName;

SendMessage (h, WM_COPYDATA, (WPARAM)hwndDlg, (LPARAM)&cd);

}

GetMountList (&LastKnownMountList);

SetTimer (hwndDlg, TIMER_ID_MAIN, TIMER_INTERVAL_MAIN, NULL);

SetFocus (GetDlgItem (hwndDlg, IDC_DRIVELIST));

// to resume the encryption/decryption process.

}

}

}

if (IsMountedVolume (favorite.Path.c_str()))

continue;

if (QueryDosDevice (favorite.VolumePathId.substr (4, favorite.VolumePathId.size() - 5).c_str(), volDevPath, TC_MAX_PATH) == 0)

continue;

favorite.DisconnectedDevice = false;

}

{

if (resolvedPath.empty())

continue;

continue;

}

if (favorite->VolumePathId.size() > 5

&& QueryDosDevice (favorite->VolumePathId.substr (4, favorite->VolumePathId.size() - 5).c_str(), volDevPath, TC_MAX_PATH) != 0)

{

if (MainWindowHidden)

{

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

}

else if (bEnableBkgTask

&& (!(LastKnownMountList.ulMountedDrives == 0

&& GetDriverRefCount () < 2)))

{

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

}

AppendMenuW (popup, MF_STRING, IDM_MOUNTALL, GetString ("IDC_MOUNTALL"));

AppendMenuW (popup, MF_STRING, IDM_MOUNT_FAVORITE_VOLUMES, GetString ("IDM_MOUNT_FAVORITE_VOLUMES"));

AppendMenuW (popup, MF_STRING, IDM_UNMOUNTALL, GetString ("IDC_UNMOUNTALL"));

for (n = 0; n < 2; n++)

{

bool useInExplorer = false;

wstring label = (wchar_t *) LastKnownMountList.wszLabel[i];

if (label.empty())

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

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

}

}

if (LastKnownMountList.ulMountedDrives != 0)

}

AppendMenuW (popup, MF_STRING, IDM_HELP, GetString ("MENU_HELP"));

AppendMenuW (popup, MF_STRING, IDM_HOMEPAGE_SYSTRAY, GetString ("HOMEPAGE"));

AppendMenuW (popup, MF_STRING, IDM_PREFERENCES, GetString ("IDM_PREFERENCES"));

AppendMenuW (popup, MF_STRING, IDM_ABOUT, GetString ("IDM_ABOUT"));

AppendMenuW (popup, MF_STRING, IDCANCEL, GetString ("EXIT"));

GetCursorPos (&pos);

if (LastKnownMountList.ulMountedDrives & (1 << m))

{

wchar_t *vol = (wchar_t *) LastKnownMountList.wszVolume[m];

if (wcsstr (vol, L"\\??\\") == vol)

vol += 4;

{

OPEN_TEST_STRUCT ots = {0};

{

UnmountVolume (hwndDlg, m, TRUE);

WarningBalloon ("HOST_DEVICE_REMOVAL_DISMOUNT_WARN_TITLE", "HOST_DEVICE_REMOVAL_DISMOUNT_WARN", hwndDlg);

{

// Open explorer window for mounted volume

WaitCursor ();

NormalCursor ();

}

else if (LOWORD (GetSelectedLong (GetDlgItem (hwndDlg, IDC_DRIVELIST))) == TC_MLIST_ITEM_FREE)

if (mountOptions.ProtectHiddenVolume && hidVolProtKeyFilesParam.EnableKeyFiles)

{

KeyFilesApply (hwndDlg, &mountOptions.ProtectedHidVolPassword, hidVolProtKeyFilesParam.FirstKeyFile, selectedVolume);

}

}

break;

case IDM_MOUNT_SYSENC_PART_WITHOUT_PBA:

{

mountOptions = defaultMountOptions;

mountOptions.PartitionInInactiveSysEncScope = TRUE;

/* Volume Tools popup menu */

int menuItem;

HMENU popup = CreatePopupMenu ();

RECT rect;

{

AppendMenuW (popup, MF_STRING, IDM_CHANGE_PASSWORD, GetString ("IDM_CHANGE_PASSWORD"));

AppendMenuW (popup, MF_STRING, IDM_CHANGE_HEADER_KEY_DERIV_ALGO, GetString ("IDM_CHANGE_HEADER_KEY_DERIV_ALGO"));

AppendMenuW (popup, MF_STRING, IDM_ADD_REMOVE_VOL_KEYFILES, GetString ("IDM_ADD_REMOVE_VOL_KEYFILES"));

AppendMenuW (popup, MF_STRING, IDM_REMOVE_ALL_KEYFILES_FROM_VOL, GetString ("IDM_REMOVE_ALL_KEYFILES_FROM_VOL"));

AppendMenuW (popup, MF_STRING, IDM_DECRYPT_NONSYS_VOL, GetString ("IDM_DECRYPT_NONSYS_VOL"));

AppendMenu (popup, MF_SEPARATOR, 0, NULL);

AppendMenuW (popup, MF_STRING, IDM_BACKUP_VOL_HEADER, GetString ("IDM_BACKUP_VOL_HEADER"));

}

else

{

WaitCursor ();

if (lw == IDC_CREATE_VOLUME || lw == IDM_CREATE_VOLUME || lw == IDM_VOLUME_WIZARD)

{

return 1;

}

{

LPARAM selectedDrive = GetSelectedLong (GetDlgItem (hwndDlg, IDC_DRIVELIST));

// volPathLower will contain the volume path (if any) from the input field below the drive list

if (LOWORD (selectedDrive) != TC_MLIST_ITEM_NONSYS_VOL

&& !(VolumeSelected (hwndDlg) && IsMountedVolume (volPathLower)))

DWORD dwResult;

memset (&prop, 0, sizeof(prop));

if (!DeviceIoControl (hDriver, TC_IOCTL_GET_VOLUME_PROPERTIES, &prop, sizeof (prop), &prop, sizeof (prop), &dwResult, NULL) || dwResult == 0)

{

// volPathHigher will contain the volume path selected in the main drive list

wstring volPathHigher (prop.wszVolume);

{

// The path selected in the input field is different from the path to the volume selected

// in the drive lettter list. We have to resolve possible ambiguity.

volPathHigher = wstring (L"...") + volPathHigher.substr (volPathHigher.length () - maxVolPathLen, maxVolPathLen);

}

if (volPathLowerWStr.length () > maxVolPathLen)

{

switch (AskMultiChoice ((void **) tmp, FALSE, hwndDlg))

{

case 1:

break;

case 2:

}

else

{

}

}

}

else

{

}

AddMountedVolumeToFavorites (hwndDlg, driveNo, lw == IDM_ADD_VOLUME_TO_SYSTEM_FAVORITES);

}

else

{

WaitCursor ();

}

else

{

WaitCursor ();

if (nSelectedDriveIndex >= 0)

{

SelectItem (GetDlgItem (hwndDlg, IDC_DRIVELIST),

}

NormalCursor ();

if (IsMountedVolume (FavoriteVolumes[favoriteIndex].Path.c_str()))

{

WaitCursor();

NormalCursor();

}

else

{

if (cd->cbData > 0)

{

}

EnableDisableButtons (hwndDlg);

return 0;

}

{

int nNoCommandLineArgs; /* The number of arguments in the array */

/* Defaults */

mountOptions.PreserveTimestamp = TRUE;

{

ComServerMode = TRUE;

return;

}

/* Extract command line arguments */

if (nNoCommandLineArgs > 0)

{

argument args[]=

{

};

argumentspec as;

{

case OptionAuto:

{

bAuto = TRUE;

if (HAS_ARGUMENT == GetArgumentValue (lpszCommandLineArgs,

&i, nNoCommandLineArgs, szTmp, sizeof (szTmp)))

{

bAutoMountDevices = TRUE;

bAutoMountFavorites = TRUE;

LogOn = TRUE;

else

AbortProcess ("COMMAND_LINE_ERROR");

case OptionTryEmptyPassword:

{

bCmdTryEmptyPasswordWhenKeyfileUsed = TRUE;

bCmdTryEmptyPasswordWhenKeyfileUsedValid = TRUE;

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

szTmp, sizeof (szTmp)))

{

bCmdTryEmptyPasswordWhenKeyfileUsed = FALSE;

bCmdTryEmptyPasswordWhenKeyfileUsed = TRUE;

else

AbortProcess ("COMMAND_LINE_ERROR");

case OptionCache:

{

bCacheInDriver = TRUE;

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

szTmp, sizeof (szTmp)))

{

bCacheInDriver = FALSE;

bCacheInDriver = TRUE;

{

bCacheInDriver = FALSE;

bCmdCacheDuringMultipleMount = TRUE;

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

szDriveLetter, sizeof (szDriveLetter)))

{

)

{

AbortProcess ("BAD_DRIVE_LETTER");

}

else

kf = (KeyFile *) malloc (sizeof (KeyFile));

if (kf)

{

FirstCmdKeyFile = KeyFileAdd (FirstCmdKeyFile, kf);

}

}

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

szDriveLetter, sizeof (szDriveLetter)))

{

)

{

AbortProcess ("BAD_DRIVE_LETTER");

}

else

case OptionHistory:

{

bHistory = bHistoryCmdLine = TRUE;

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

szTmp, sizeof (szTmp)))

{

bHistory = FALSE;

bHistory = TRUE;

else

AbortProcess ("COMMAND_LINE_ERROR");

case OptionMountOption:

{

if (HAS_ARGUMENT == GetArgumentValue (lpszCommandLineArgs,

&i, nNoCommandLineArgs, szTmp, sizeof (szTmp)))

{

mountOptions.ReadOnly = TRUE;

mountOptions.Removable = TRUE;

mountOptions.PreserveTimestamp = FALSE;

mountOptions.PartitionInInactiveSysEncScope = bPrebootPasswordDlgMode = TRUE;

mountOptions.UseBackupHeader = TRUE;

mountOptions.RecoveryMode = TRUE;

{

// get the label

}

else

AbortProcess ("COMMAND_LINE_ERROR");

break;

case OptionPassword:

{

}

break;

case OptionVolume:

case OptionQuit:

{

if (HAS_ARGUMENT == GetArgumentValue (lpszCommandLineArgs,

&i, nNoCommandLineArgs, szTmp, sizeof (szTmp)))

{

break;

{

Quit = TRUE;

UsePreferences = TRUE;

break;

}

bEnableBkgTask = TRUE;

else

case OptionPkcs5:

{

if (HAS_ARGUMENT == GetArgumentValue (lpszCommandLineArgs,

&i, nNoCommandLineArgs, szTmp, sizeof (szTmp)))

{

CmdVolumePkcs5 = SHA512;

CmdVolumePkcs5 = WHIRLPOOL;

CmdVolumePkcs5 = SHA256;

CmdVolumePkcs5 = RIPEMD160;

else

{

case OptionPim:

{

if (HAS_ARGUMENT == GetArgumentValue (lpszCommandLineArgs,

&i, nNoCommandLineArgs, szTmp, sizeof (szTmp)))

{

{

CmdVolumePim = 0;

AbortProcess ("COMMAND_LINE_ERROR");

{

if (nNoCommandLineArgs == 1)

{

RelativePath2Absolute (szFileName);

CmdLineVolumeSpecified = TRUE;

static SERVICE_STATUS SystemFavoritesServiceStatus;

static SERVICE_STATUS_HANDLE SystemFavoritesServiceStatusHandle;

{

HANDLE eventSource = RegisterEventSource (NULL, TC_SYSTEM_FAVORITES_SERVICE_NAME);

}

}

{

SystemFavoritesServiceLogMessage (errorMessage, EVENTLOG_ERROR_TYPE);

}

{

SystemFavoritesServiceLogMessage (warningMessage, EVENTLOG_WARNING_TYPE);

}

{

SystemFavoritesServiceLogMessage (infoMessage, EVENTLOG_INFORMATION_TYPE);

}

SystemFavoritesServiceSetStatus (SERVICE_START_PENDING, 120000);

try

{

if (status)

{

}

else

{

}

SystemFavoritesServiceSetStatus (SERVICE_RUNNING);

}

#ifndef VCEXPANDER

{

int argc;

LPWSTR *argv = CommandLineToArgvW (GetCommandLineW(), &argc);

return StartSystemFavoritesService() ? 0 : 1;

int status;

// Only one icon may be created

if (TaskBarIconMutex != NULL) return TRUE;

if (TaskBarIconMutex == NULL || GetLastError () == ERROR_ALREADY_EXISTS)

{

if (TaskBarIconMutex != NULL)

{

BOOL status = TRUE;

int drive;

mountOptions.ReadOnly = favorite.ReadOnly || userForcedReadOnly;

mountOptions.Removable = favorite.Removable;

{

MountVolumesAsSystemFavorite = systemFavorites;

if (systemFavorites)

{

// Partitions of new drives are assigned free drive letters by Windows on boot. Make sure this does not prevent system favorite volumes

// from being mounted. Each partition (using the same drive letter as a system favorite volume) is assigned another free drive letter.

DeleteVolumeMountPoint (mountPoint.c_str());

else

prevVolumeAtMountPoint[0] = 0;

BOOL prevReadOnly = mountOptions.ReadOnly;

if (ServiceMode)

if (ServiceMode)

{

if (status)

{

}

else

{

}

}

int freeDrive = GetFirstAvailableDrive();

if (freeDrive != -1)

{

SetVolumeMountPoint (mountPoint.c_str(), prevVolumeAtMountPoint);

}

}

DWORD bytesOut;

DeviceIoControl (hDriver, TC_IOCTL_SET_SYSTEM_FAVORITE_VOLUME_DIRTY, NULL, 0, NULL, 0, &bytesOut, NULL);

}

}

else if (!systemFavorites && !favoriteVolumeToMount.Path.empty())

Error ("DRIVE_LETTER_UNAVAILABLE", MainDlg);

else if (ServiceMode && systemFavorites)

{

}

return status;

try

{

if (ServiceMode)

LoadFavoriteVolumes (favorites, true);

if (ServiceMode)

{

}

}

catch (...)

{

if (ServiceMode)

return false;

}

}

if (ServiceMode && systemFavorites && favorite.DisconnectedDevice)

{

skippedSystemFavorites.push_back (favorite);

}

if (favorite.DisconnectedDevice

{

Sleep (5000);

// Update the service status to avoid being killed

SystemFavoritesServiceStatus.dwCheckPoint++;

if (favorite->DisconnectedDevice)

{

// check if the favorite is here and get its path

if (!resolvedPath.empty())

{

favorite->DisconnectedDevice = false;

remainingFavorites--;

// favorite OK.

status = MountFavoriteVolumeBase (hwnd, *favorite, lastbExplore, userForcedReadOnly, systemFavorites, logOnMount, hotKeyMount, favoriteVolumeToMount);

if (!status)

}

if (remainingFavorites == 0)

else

{

}

}

}

if (defaultKeyFilesParam.FirstKeyFile == NULL)

{

/* No keyfiles selected */

}

else

{

FILE *f;

KeyFile *kf = FirstKeyFile;

if (f == NULL)

{

handleWin32Error (MainDlg, SRC_POS);

XmlWriteHeader (f);

while (kf != NULL)

{

kf = kf->Next;

}

XmlWriteFooter (f);

}

{

int nStatus = ERR_OS_ERROR;

wchar_t szTmp[4096];

goto ret;

/* Conceive the backup file */

{

nStatus = ERR_OS_ERROR;

goto error;

}

{

int nDosLinkCreated = -1, nStatus = ERR_OS_ERROR;

void *dev = INVALID_HANDLE_VALUE;

DWORD dwError;

BOOL bDevice;

{

int GuiPkcs5 = ((EffectiveVolumePkcs5 > 0) && (VolumePkcs5 == 0))? EffectiveVolumePkcs5 : VolumePkcs5;

int GuiPim = ((EffectiveVolumePim > 0) && (VolumePim <= 0))? EffectiveVolumePim : VolumePim;

if (!AskVolumePassword (hwndDlg, &VolumePassword, &GuiPkcs5, &GuiPim, &VolumeTrueCryptMode, NULL, FALSE))

{

nStatus = ERR_SUCCESS;

CreateFullVolumePath (szDiskFile, sizeof(szDiskFile), lpszVolume, &bDevice);

if (bDevice == FALSE)

else

{

nDosLinkCreated = FakeDosNameForDevice (szDiskFile, szDosDevice, sizeof(szDosDevice),szCFDevice, sizeof(szCFDevice),FALSE);

if (ReadEncryptionThreadPoolFreeCpuCountLimit() != cpuFreeCount)

{

Warning ("SETTING_REQUIRES_REBOOT", hwndDlg);

}

case IDOK:

{

if (securityTokenLibraryPath[0] == 0)

{

}

else

{

if (!InitSecurityTokenLibrary(hwndDlg))

{

return 1;

}

}

case IDC_AUTO_DETECT_PKCS11_MODULE:

{

WIN32_FIND_DATA findData;

bool found = false;

WaitCursor();

while (!found && find != INVALID_HANDLE_VALUE)

{

DWORD fileSize;

char *file = LoadFile (dllPathname.c_str(), &fileSize);

case IDC_SELECT_PKCS11_MODULE:

{

wchar_t browseFilter[1024];

Info ("SELECT_PKCS11_MODULE_HELP", hwndDlg);

StringCbPrintfW (browseFilter, sizeof(browseFilter), L"%ls (*.dll)%c*.dll%c%c", GetString ("DLL_FILES"), 0, 0, 0);

if (BrowseFilesInDir (hwndDlg, "SELECT_PKCS11_MODULE", systemDir, securityTokenLibraryPath, TRUE, FALSE, browseFilter))

SetDlgItemText (hwndDlg, IDC_PKCS11_MODULE, securityTokenLibraryPath);

Warning ("BOOT_LOADER_VERSION_INCORRECT_PREFERENCES", hwndDlg);

SendMessage (GetDlgItem (hwndDlg, IDC_CUSTOM_BOOT_LOADER_MESSAGE), EM_LIMITTEXT, TC_BOOT_SECTOR_USER_MESSAGE_MAX_LENGTH, 0);

CheckDlgButton (hwndDlg, IDC_DISABLE_BOOT_LOADER_OUTPUT, (userConfig & TC_BOOT_USER_CFG_FLAG_SILENT_MODE) ? BST_CHECKED : BST_UNCHECKED);

CheckDlgButton (hwndDlg, IDC_ALLOW_ESC_PBA_BYPASS, (userConfig & TC_BOOT_USER_CFG_FLAG_DISABLE_ESC) ? BST_UNCHECKED : BST_CHECKED);

}

char customUserMessage[TC_BOOT_SECTOR_USER_MESSAGE_MAX_LENGTH + 1];

byte userConfig;

try

if (mountOptions.ProtectHiddenVolume && hidVolProtKeyFilesParam.EnableKeyFiles)

{

KeyFilesApply (hwndDlg, &mountOptions.ProtectedHidVolPassword, hidVolProtKeyFilesParam.FirstKeyFile, selectedVolume);

}

}