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

}

{

char szTmp[MAX_PATH];

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

ConfigReadCompareString ("SecurityTokenLibrary", "", szTmp, sizeof (szTmp) - 1, bOnlyCheckModified, pbSettingsModified);

MultiByteToWideChar (CP_UTF8, 0, szTmp, -1, SecurityTokenLibraryPath, ARRAYSIZE (SecurityTokenLibraryPath));

if (!bOnlyCheckModified && SecurityTokenLibraryPath[0])

{

InitSecurityTokenLibrary(hwndDlg);

}

}

// Hotkeys

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

ConfigReadCompareInt ("DisplayMsgBoxOnHotkeyDismount", TRUE, &bDisplayBalloonOnSuccessfulHkDismount, bOnlyCheckModified, pbSettingsModified);

ConfigReadCompareInt ("HotkeyModAutoMountDevices", 0, (int*) &Hotkeys [HK_AUTOMOUNT_DEVICES].vKeyModifiers, bOnlyCheckModified, pbSettingsModified);

ConfigReadCompareInt ("HotkeyCodeAutoMountDevices", 0, (int*) &Hotkeys [HK_AUTOMOUNT_DEVICES].vKeyCode, bOnlyCheckModified, pbSettingsModified);

ConfigReadCompareInt ("HotkeyModWipeCache", 0, (int*) &Hotkeys [HK_WIPE_CACHE].vKeyModifiers, bOnlyCheckModified, pbSettingsModified);

ConfigReadCompareInt ("HotkeyCodeWipeCache", 0, (int*) &Hotkeys [HK_WIPE_CACHE].vKeyCode, bOnlyCheckModified, pbSettingsModified);

ConfigReadCompareInt ("HotkeyModMountFavoriteVolumes", 0, (int*) &Hotkeys [HK_MOUNT_FAVORITE_VOLUMES].vKeyModifiers, bOnlyCheckModified, pbSettingsModified);

ConfigReadCompareInt ("HotkeyCodeMountFavoriteVolumes", 0, (int*) &Hotkeys [HK_MOUNT_FAVORITE_VOLUMES].vKeyCode, bOnlyCheckModified, pbSettingsModified);

ConfigReadCompareInt ("HotkeyModShowHideMainWindow", 0, (int*) &Hotkeys [HK_SHOW_HIDE_MAIN_WINDOW].vKeyModifiers, bOnlyCheckModified, pbSettingsModified);

ConfigReadCompareInt ("HotkeyCodeShowHideMainWindow", 0, (int*) &Hotkeys [HK_SHOW_HIDE_MAIN_WINDOW].vKeyCode, bOnlyCheckModified, pbSettingsModified);

ConfigReadCompareInt ("HotkeyModCloseSecurityTokenSessions", 0, (int*) &Hotkeys [HK_CLOSE_SECURITY_TOKEN_SESSIONS].vKeyModifiers, bOnlyCheckModified, pbSettingsModified);

ConfigReadCompareInt ("HotkeyCodeCloseSecurityTokenSessions", 0, (int*) &Hotkeys [HK_CLOSE_SECURITY_TOKEN_SESSIONS].vKeyCode, bOnlyCheckModified, pbSettingsModified);

// History

if (bHistoryCmdLine != TRUE)

{

LoadCombo (GetDlgItem (MainDlg, IDC_VOLUME), bHistory, bOnlyCheckModified, pbHistoryModified);

if (!bOnlyCheckModified && CmdLineVolumeSpecified)

SetWindowText (GetDlgItem (MainDlg, IDC_VOLUME), szFileName);

}

// Mount Options

ConfigReadCompareInt ("DefaultPRF", 0, &DefaultVolumePkcs5, bOnlyCheckModified, pbSettingsModified);

if (bOnlyCheckModified)

{

if (IsHiddenOSRunning())

ConfigWriteInt ("HiddenSystemLeakProtNotifStatus", HiddenSysLeakProtectionNotificationStatus);

// save last selected drive only when history enabled

if (bHistory)

{

// Drive Letter

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

if (LOWORD (lLetter) != 0xffff)

StringCbPrintfA (szTmp, sizeof(szTmp), "%lc:", (wchar_t) HIWORD (lLetter));

ConfigWriteString ("LastSelectedDrive", szTmp);

}

ConfigWriteInt ("CloseSecurityTokenSessionsAfterMount", CloseSecurityTokenSessionsAfterMount);

ConfigWriteInt ("EMVSupportEnabled", EMVSupportEnabled);

// Hotkeys

ConfigWriteInt ("HotkeyModAutoMountDevices", Hotkeys[HK_AUTOMOUNT_DEVICES].vKeyModifiers);

ConfigWriteInt ("HotkeyCodeAutoMountDevices", Hotkeys[HK_AUTOMOUNT_DEVICES].vKeyCode);

ConfigWriteInt ("HotkeyModWipeCache", Hotkeys[HK_WIPE_CACHE].vKeyModifiers);

ConfigWriteInt ("HotkeyCodeWipeCache", Hotkeys[HK_WIPE_CACHE].vKeyCode);

ConfigWriteInt ("HotkeyModMountFavoriteVolumes", Hotkeys[HK_MOUNT_FAVORITE_VOLUMES].vKeyModifiers);

ConfigWriteInt ("HotkeyCodeMountFavoriteVolumes", Hotkeys[HK_MOUNT_FAVORITE_VOLUMES].vKeyCode);

ConfigWriteInt ("HotkeyModShowHideMainWindow", Hotkeys[HK_SHOW_HIDE_MAIN_WINDOW].vKeyModifiers);

ConfigWriteInt ("HotkeyCodeShowHideMainWindow", Hotkeys[HK_SHOW_HIDE_MAIN_WINDOW].vKeyCode);

ConfigWriteInt ("HotkeyModCloseSecurityTokenSessions", Hotkeys[HK_CLOSE_SECURITY_TOKEN_SESSIONS].vKeyModifiers);

ConfigWriteInt ("HotkeyCodeCloseSecurityTokenSessions", Hotkeys[HK_CLOSE_SECURITY_TOKEN_SESSIONS].vKeyCode);

ConfigWriteInt ("PlaySoundOnHotkeyMountDismount", bPlaySoundOnSuccessfulHkDismount);

ConfigWriteInt ("DisplayMsgBoxOnHotkeyDismount", bDisplayBalloonOnSuccessfulHkDismount);

// Language

ConfigWriteString ("Language", GetPreferredLangId ());

// PKCS#11 Library Path

ConfigWriteStringW ("SecurityTokenLibrary", SecurityTokenLibraryPath[0] ? SecurityTokenLibraryPath : L"");

// Mount Options

ConfigWriteInt ("DefaultPRF", DefaultVolumePkcs5);

ConfigWriteEnd (hwndDlg);

}

if (kf)

{

DragQueryFile (hdrop, i++, kf->FileName, ARRAYSIZE (kf->FileName));

FirstKeyFile = KeyFileAdd (FirstKeyFile, kf);

KeyFilesEnable = TRUE;

}

}

SetCheckBox (hwndDlg, IDC_KEYFILES_ENABLE, KeyFilesEnable);

DragFinish (hdrop);

}

return 1;

}

return 0;

}

static void PreferencesDlgEnableButtons (HWND hwndDlg)

{

BOOL back = IsButtonChecked (GetDlgItem (hwndDlg, IDC_PREF_BKG_TASK_ENABLE));

BOOL installed = !IsNonInstallMode();

BOOL wtsEnabled = (hWtsLib != NULL) ? TRUE : FALSE;

EnableWindow (GetDlgItem (hwndDlg, IDC_CLOSE_BKG_TASK_WHEN_NOVOL), back && installed);

EnableWindow (GetDlgItem (hwndDlg, IDT_LOGON), installed);

EnableWindow (GetDlgItem (hwndDlg, IDC_PREF_LOGON_START), back && installed);

EnableWindow (GetDlgItem (hwndDlg, IDC_PREF_LOGON_MOUNT_DEVICES), installed);

EnableWindow (GetDlgItem (hwndDlg, IDT_MINUTES), back);

}

BOOL CALLBACK PreferencesDlgProc (HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)

{

static BOOL PreferencesDialogActive = FALSE;

static HWND ActivePreferencesDialogWindow;

WORD lw = LOWORD (wParam);

switch (msg)

{

case WM_INITDIALOG:

{

if (PreferencesDialogActive)

{

ShowWindow (ActivePreferencesDialogWindow, SW_SHOW);

SetForegroundWindow (ActivePreferencesDialogWindow);

EndDialog (hwndDlg, IDCANCEL);

return 1;

}

defaultMountOptions.PreserveTimestamp ? BST_CHECKED:BST_UNCHECKED, 0);

SendMessage (GetDlgItem (hwndDlg, IDC_SHOW_DISCONNECTED_NETWORK_DRIVES), BM_SETCHECK,

bShowDisconnectedNetworkDrives ? BST_CHECKED:BST_UNCHECKED, 0);

SendMessage (GetDlgItem (hwndDlg, IDC_HIDE_WAITING_DIALOG), BM_SETCHECK,

bHideWaitingDialog ? BST_CHECKED:BST_UNCHECKED, 0);

SendMessage (GetDlgItem (hwndDlg, IDC_SECURE_DESKTOP_PASSWORD_ENTRY), BM_SETCHECK,

bUseSecureDesktop ? BST_CHECKED:BST_UNCHECKED, 0);

SendMessage (GetDlgItem (hwndDlg, IDC_USE_LEGACY_MAX_PASSWORD_LENGTH), BM_SETCHECK,

bUseLegacyMaxPasswordLength ? BST_CHECKED:BST_UNCHECKED, 0);

SendMessage (GetDlgItem (hwndDlg, IDC_PREF_TEMP_CACHE_ON_MULTIPLE_MOUNT), BM_SETCHECK,

bCacheDuringMultipleMount ? BST_CHECKED:BST_UNCHECKED, 0);

SendMessage (GetDlgItem (hwndDlg, IDC_PREF_WIPE_CACHE_ON_EXIT), BM_SETCHECK,

bWipeCacheOnExit ? BST_CHECKED:BST_UNCHECKED, 0);

bWipeCacheOnAutoDismount ? BST_CHECKED:BST_UNCHECKED, 0);

SendMessage (GetDlgItem (hwndDlg, IDC_PREF_CACHE_PASSWORDS), BM_SETCHECK,

bCacheInDriver ? BST_CHECKED:BST_UNCHECKED, 0);

SendMessage (GetDlgItem (hwndDlg, IDC_PREF_CACHE_PIM), BM_SETCHECK,

bIncludePimInCache? BST_CHECKED:BST_UNCHECKED, 0);

SendMessage (GetDlgItem (hwndDlg, IDC_PREF_MOUNT_READONLY), BM_SETCHECK,

defaultMountOptions.ReadOnly ? BST_CHECKED:BST_UNCHECKED, 0);

SendMessage (GetDlgItem (hwndDlg, IDC_PREF_MOUNT_REMOVABLE), BM_SETCHECK,

defaultMountOptions.Removable ? BST_CHECKED:BST_UNCHECKED, 0);

SendMessage (GetDlgItem (hwndDlg, IDC_PREF_LOGON_START), BM_SETCHECK,

bStartOnLogon ? BST_CHECKED:BST_UNCHECKED, 0);

SendMessage (GetDlgItem (hwndDlg, IDC_PREF_LOGON_MOUNT_DEVICES), BM_SETCHECK,

bMountDevicesOnLogon ? BST_CHECKED:BST_UNCHECKED, 0);

SendMessage (GetDlgItem (hwndDlg, IDC_PREF_BKG_TASK_ENABLE), BM_SETCHECK,

bEnableBkgTask ? BST_CHECKED:BST_UNCHECKED, 0);

SendMessage (GetDlgItem (hwndDlg, IDC_CLOSE_BKG_TASK_WHEN_NOVOL), BM_SETCHECK,

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

PreferencesDlgEnableButtons (hwndDlg);

}

return 0;

case WM_COMMAND:

if (lw == IDC_PREF_BKG_TASK_ENABLE && !IsButtonChecked (GetDlgItem (hwndDlg, IDC_PREF_BKG_TASK_ENABLE)))

{

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

SetCheckBox (hwndDlg, IDC_PREF_BKG_TASK_ENABLE, TRUE);

}

// Forced dismount disabled warning

if (!q)

{

{

}

}

}

if (lw == IDCANCEL)

{

PreferencesDialogActive = FALSE;

EndDialog (hwndDlg, lw);

return 1;

}

if (lw == IDOK)

{

WaitCursor ();

bExplore = IsButtonChecked (GetDlgItem (hwndDlg, IDC_PREF_OPEN_EXPLORER));

bUseDifferentTrayIconIfVolMounted = IsButtonChecked (GetDlgItem (hwndDlg, IDC_PREF_USE_DIFF_TRAY_ICON_IF_VOL_MOUNTED));

bPreserveTimestamp = defaultMountOptions.PreserveTimestamp = IsButtonChecked (GetDlgItem (hwndDlg, IDC_PRESERVE_TIMESTAMPS));

bShowDisconnectedNetworkDrives = IsButtonChecked (GetDlgItem (hwndDlg, IDC_SHOW_DISCONNECTED_NETWORK_DRIVES));

bHideWaitingDialog = IsButtonChecked (GetDlgItem (hwndDlg, IDC_HIDE_WAITING_DIALOG));

bUseSecureDesktop = IsButtonChecked (GetDlgItem (hwndDlg, IDC_SECURE_DESKTOP_PASSWORD_ENTRY));

bUseLegacyMaxPasswordLength = IsButtonChecked (GetDlgItem (hwndDlg, IDC_USE_LEGACY_MAX_PASSWORD_LENGTH));

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

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

bCacheInDriverDefault = bCacheInDriver = IsButtonChecked (GetDlgItem (hwndDlg, IDC_PREF_CACHE_PASSWORDS));

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

bEnableBkgTask = IsButtonChecked (GetDlgItem (hwndDlg, IDC_PREF_BKG_TASK_ENABLE));

bCloseBkgTaskWhenNoVolumes = IsNonInstallMode() ? bCloseBkgTaskWhenNoVolumes : IsButtonChecked (GetDlgItem (hwndDlg, IDC_CLOSE_BKG_TASK_WHEN_NOVOL));

bStartOnLogon = IsButtonChecked (GetDlgItem (hwndDlg, IDC_PREF_LOGON_START));

bMountDevicesOnLogon = IsButtonChecked (GetDlgItem (hwndDlg, IDC_PREF_LOGON_MOUNT_DEVICES));

ManageStartupSeq ();

SaveSettings (hwndDlg);

NormalCursor ();

PreferencesDialogActive = FALSE;

EndDialog (hwndDlg, lw);

return 1;

}

if (lw == IDC_MORE_SETTINGS)

{

HMENU popup = CreatePopupMenu ();

if (popup)

{

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

af = _wfopen (dstPath, L"w,ccs=UNICODE");

if (af == NULL)

{

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

goto stop;

}

StringCbPrintfW (autoMount, sizeof(autoMount), L"VeraCrypt\\VeraCrypt.exe /q background%s%s%s%s /m rm /v %s",

drive > 0 ? driveLetter : L"",

openExplorer ? L" /e" : L"",

cacheInDriver ? (includePimInCache? L" /c p" : L" /c y") : L"",

bMountReadOnly ? L" /m ro" : L"",

volName);

fwprintf (af, L"[autorun]\nlabel=%s\nicon=VeraCrypt\\VeraCrypt.exe\n", GetString ("TC_TRAVELER_DISK"));

fwprintf (af, L"action=%s\n", bAutoMount ? GetString ("MOUNT_TC_VOLUME") : GetString ("IDC_PREF_LOGON_START"));

fwprintf (af, L"open=%s\n", bAutoMount ? autoMount : L"VeraCrypt\\VeraCrypt.exe");

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

CheckFileStreamWriteErrors (hwndDlg, af, dstPath);

fclose (af);

}

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

stop:

FreeAllFileBuffers ();

NormalCursor ();

return 1;

}

return 0;

}

return 0;

}

void BuildTree (HWND hwndDlg, HWND hTree)

{

HIMAGELIST hList;

BOOL interact;

int dismountMaxRetries;

int dismountAutoRetryDelay;

BOOL* pbResult;

DWORD* pdwResult;

DWORD dwLastError;

BOOL bReturn;

} DismountAllThreadParam;

void CALLBACK DismountAllThreadProc(void* pArg, HWND hwndDlg)

{

DismountAllThreadParam* pThreadParam = (DismountAllThreadParam*) pArg;

UNMOUNT_STRUCT* punmount = pThreadParam->punmount;

BOOL* pbResult = pThreadParam->pbResult;

DWORD* pdwResult = pThreadParam->pdwResult;

int dismountMaxRetries = pThreadParam->dismountMaxRetries;

int dismountAutoRetryDelay = pThreadParam->dismountAutoRetryDelay;

do

{

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

if ( punmount->nDosDriveNo < 0 || punmount->nDosDriveNo > 25

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

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

|| (punmount->nReturnCode < 0)

)

{

if (*pbResult)

SetLastError (ERROR_INTERNAL_ERROR);

*pbResult = FALSE;

}

if (*pbResult == FALSE)

{

NormalCursor();

handleWin32Error (hwndDlg, SRC_POS);

pThreadParam->dwLastError = GetLastError ();

pThreadParam->bReturn = FALSE;

return;

HWND hList = GetDlgItem (hwndDlg, IDC_DRIVELIST);

SetFocus (hList);

switch (LOWORD (GetSelectedLong (hList)))

{

case TC_MLIST_ITEM_FREE:

// No mounted volume at this drive letter

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

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

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;

case TC_MLIST_ITEM_NONSYS_VOL:

// There's a mounted non-system volume at this drive letter

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

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

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

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

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

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

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

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

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

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

break;

case TC_MLIST_ITEM_SYS_PARTITION:

case TC_MLIST_ITEM_SYS_DRIVE:

// System partition/drive

PopulateSysEncContextMenu (popup, FALSE);

break;

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

{

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

{

if ((LastKnownMountList.ulMountedDrives & (1 << i)) && IsNullTerminateString (LastKnownMountList.wszVolume[i], TC_MAX_PATH))

{

wchar_t s[1024];

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

if (wcsstr (vol, L"\\??\\")) vol += 4;

// first check label used for mounting. If empty, look for it in favorites.

bool useInExplorer = false;

wstring label;

if (IsNullTerminateString (LastKnownMountList.wszLabel[i], 33))

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

if (label.empty())

label = GetFavoriteVolumeLabel (vol, useInExplorer);

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

i + L'A',

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

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

}

}

if (LastKnownMountList.ulMountedDrives != 0)

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

}

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

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

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

GetCursorPos (&pos);

SetForegroundWindow(hwndDlg);

sel = TrackPopupMenu (popup,

TPM_RETURNCMD | TPM_LEFTALIGN | TPM_BOTTOMALIGN | TPM_RIGHTBUTTON,

pos.x,

pos.y,

0,

hwndDlg,

NULL);

if (sel >= TRAYICON_MENU_DRIVE_OFFSET && sel < TRAYICON_MENU_DRIVE_OFFSET + 26)

{

OpenVolumeExplorerWindow (sel - TRAYICON_MENU_DRIVE_OFFSET);

}

else if (sel >= TRAYICON_MENU_DRIVE_OFFSET + 26 && sel < TRAYICON_MENU_DRIVE_OFFSET + 26*2)

{

if (CheckMountList (hwndDlg, FALSE))

{

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

{

wchar_t txt [2048];

}

}

}

else if (sel == IDM_SHOW_HIDE)

{

ChangeMainWindowVisibility ();

}

else if (sel == IDM_HOMEPAGE_SYSTRAY)

{

Applink ("home");

}

else if (sel == IDCANCEL)

{

if ((LastKnownMountList.ulMountedDrives == 0

&& !SysEncDeviceActive (TRUE))

|| AskWarnNoYes ("CONFIRM_EXIT", hwndDlg) == IDYES)

{

// Close all other TC windows

EnumWindows (CloseTCWindowsEnum, 0);

// File-hosted volumes

PDEV_BROADCAST_VOLUME vol = (PDEV_BROADCAST_VOLUME) lParam;

int i;

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

{

if (LastKnownMountList.ulMountedDrives && (vol->dbcv_unitmask & (1 << i)) && !(GetUsedLogicalDrives() & (1 << i)))

{

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

{

if ((LastKnownMountList.ulMountedDrives & (1 << m)) && IsNullTerminateString (LastKnownMountList.wszVolume[m], TC_MAX_PATH))

{

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

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

vol += 4;

if (wszVol[1] == L':' && i == (wszVol[0] - (wszVol[0] <= L'Z' ? L'A' : L'a')))

{

UnmountVolume (hwndDlg, m, TRUE);

}

}

}

}

}

}

// Device-hosted volumes

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

{

if ((LastKnownMountList.ulMountedDrives & (1 << m)) && IsNullTerminateString (LastKnownMountList.wszVolume[m], TC_MAX_PATH))

{

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

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

vol += 4;

if (IsVolumeDeviceHosted (vol))

{

OPEN_TEST_STRUCT ots = {0};

if (!OpenDevice (vol, &ots, FALSE, FALSE))

{

UnmountVolume (hwndDlg, m, TRUE);

}

}

}

}

}

// Favorite volumes

UpdateDeviceHostedFavoriteVolumes();

return 1;

}

return 0;

case WM_NOTIFY:

if(wParam == IDC_DRIVELIST)

{

if (((LPNMHDR) lParam)->code == NM_CUSTOMDRAW)

{

int width = ListView_GetColumnWidth (GetDlgItem (hwndDlg, IDC_DRIVELIST), 1);

}

if ((lw == IDOK || lw == IDM_MOUNT_VOLUME || lw == IDM_MOUNT_VOLUME_OPTIONS || lw == IDC_MOUNTALL || lw == IDM_MOUNTALL)

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

{

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

return 1;

}

if ((lw == IDOK || lw == IDM_MOUNT_VOLUME || lw == IDM_MOUNT_VOLUME_OPTIONS || lw == IDM_MOUNIT_NO_CACHE))

{

MountSelectedVolume (hwndDlg, lw == IDM_MOUNT_VOLUME_OPTIONS, lw == IDM_MOUNIT_NO_CACHE);

return 1;

}

if (lw == IDC_UNMOUNTALL || lw == IDM_UNMOUNTALL)

{

if (DismountAll (hwndDlg, bForceUnmount, TRUE, UNMOUNT_MAX_AUTO_RETRIES, UNMOUNT_AUTO_RETRY_DELAY)

&& lw == IDM_UNMOUNTALL) // If initiated via the systray menu

{

}

return 1;

}

if (lw == IDC_MOUNTALL || lw == IDM_MOUNTALL)

{

// If Shift key is down and the password cache isn't empty, bypass password prompt

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

return 1;

}

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

{

SelectContainer (hwndDlg);

return 1;

}

if (lw == IDC_SELECT_DEVICE || lw == IDM_SELECT_DEVICE)

{

CommandHelp,

OptionHistory,

OptionKeyfile,

OptionLetter,

OptionMountOption,

OptionPassword,

OptionQuit,

OptionSilent,

OptionTokenLib,

OptionTokenPin,

OptionVolume,

CommandWipeCache,

OptionPkcs5,

OptionPim,

OptionTryEmptyPassword,

OptionNoWaitDlg,

OptionSecureDesktop,

OptionDisableDeviceUpdate,

OptionEnableMemoryProtection,

OptionSignalExit,

};

argument args[]=

{

{ OptionAuto, L"/auto", L"/a", FALSE },

{ OptionBeep, L"/beep", L"/b", FALSE },

{ OptionCache, L"/cache", L"/c", FALSE },

{ CommandDismount, L"/dismount", L"/d", FALSE },

{ OptionExplore, L"/explore", L"/e", FALSE },

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

{ OptionPkcs5, L"/hash", NULL , FALSE },

{ CommandHelp, L"/help", L"/?", FALSE },

{ OptionHistory, L"/history", L"/h", FALSE },

{ OptionKeyfile, L"/keyfile", L"/k", FALSE },

{ OptionLetter, L"/letter", L"/l", FALSE },

{ OptionMountOption, L"/mountoption", L"/m", FALSE },

{ OptionPassword, L"/password", L"/p", FALSE },

{ OptionPim, L"/pim", NULL, FALSE },

{ OptionQuit, L"/quit", L"/q", FALSE },

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

{ OptionTokenLib, L"/tokenlib", NULL, FALSE },

{ OptionTokenPin, L"/tokenpin", NULL, FALSE },

{ OptionVolume, L"/volume", L"/v", FALSE },

{ CommandWipeCache, L"/wipecache", L"/w", FALSE },

{ OptionTryEmptyPassword, L"/tryemptypass", NULL, FALSE },

{ OptionNoWaitDlg, L"/nowaitdlg", NULL, FALSE },

{ OptionSecureDesktop, L"/secureDesktop", NULL, FALSE },

{ OptionDisableDeviceUpdate, L"/disableDeviceUpdate", NULL, FALSE },

{ OptionEnableMemoryProtection, L"/protectMemory", NULL, FALSE },

{ OptionSignalExit, L"/signalExit", NULL, FALSE },

};

argumentspec as;

as.args = args;

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

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

{

case OptionAuto:

{

wchar_t szTmp[32] = {0};

bAuto = TRUE;

if (HAS_ARGUMENT == GetArgumentValue (lpszCommandLineArgs,

&i, nNoCommandLineArgs, szTmp, ARRAYSIZE (szTmp)))

{

if (!_wcsicmp (szTmp, L"devices"))

bAutoMountDevices = TRUE;

else if (!_wcsicmp (szTmp, L"favorites"))

bCacheInDriver = FALSE;

else if (!_wcsicmp(szTmp,L"y") || !_wcsicmp(szTmp,L"yes"))

bCacheInDriver = TRUE;

else if (!_wcsicmp(szTmp,L"p") || !_wcsicmp(szTmp,L"pim"))

{

bCacheInDriver = TRUE;

bIncludePimInCache = TRUE;

}

else if (!_wcsicmp(szTmp,L"f") || !_wcsicmp(szTmp,L"favorites"))

{

bCacheInDriver = FALSE;

bCmdCacheDuringMultipleMount = TRUE;

}

else

AbortProcess ("COMMAND_LINE_ERROR");

}

}

break;

case CommandDismount:

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

szDriveLetter, ARRAYSIZE (szDriveLetter)))

{

if ( (wcslen(szDriveLetter) == 1)

|| (wcslen(szDriveLetter) == 2 && szDriveLetter[1] == L':')

)

{

cmdUnmountDrive = towupper(szDriveLetter[0]) - L'A';

if ((cmdUnmountDrive < 0) || (cmdUnmountDrive > (L'Z' - L'A')))

AbortProcess ("BAD_DRIVE_LETTER");

}

else

AbortProcess ("BAD_DRIVE_LETTER");

}

else

cmdUnmountDrive = -1;

break;

int freeDrive = GetFirstAvailableDrive();

if (freeDrive != -1)

{

mountPoint[0] = (wchar_t) (freeDrive + L'A');

SetVolumeMountPoint (mountPoint.c_str(), prevVolumeAtMountPoint);

}

}

else

SetVolumeMountPoint (mountPoint.c_str(), prevVolumeAtMountPoint);

}

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

MountVolumesAsSystemFavorite = FALSE;

if (ServiceMode && LastMountedVolumeDirty)

{

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)

{

SystemFavoritesServiceLogError (wstring (L"The drive letter ") + (wchar_t) (drive + L'A') + wstring (L" used by favorite \"") + effectiveVolumePath + L"\" is already taken.\nThis system favorite will not be mounted");

}

return status;

}

BOOL MountFavoriteVolumes (HWND hwnd, BOOL systemFavorites, BOOL logOnMount, BOOL hotKeyMount, const FavoriteVolume &favoriteVolumeToMount)

{

BOOL bRet = TRUE, status = TRUE;

BOOL lastbExplore;

BOOL userForcedReadOnly = FALSE;

if (ServiceMode)

defaultKeyFilesParam.FirstKeyFile = param.FirstKeyFile;

RestoreDefaultKeyFilesParam ();

SaveDefaultKeyFilesParam (hwndDlg);

}

}

}

static void HandleHotKey (HWND hwndDlg, WPARAM wParam)

{

DWORD dwResult;

BOOL success = TRUE;

switch (wParam)

{

case HK_AUTOMOUNT_DEVICES:

MountAllDevices (hwndDlg, TRUE);

break;

WipeCache (hwndDlg, TRUE);

if (DismountAll (hwndDlg, FALSE, TRUE, UNMOUNT_MAX_AUTO_RETRIES, UNMOUNT_AUTO_RETRY_DELAY))

{

if (bDisplayBalloonOnSuccessfulHkDismount)

if (bPlaySoundOnSuccessfulHkDismount)

MessageBeep (0xFFFFFFFF);

}

break;

case HK_WIPE_CACHE:

WipeCache (hwndDlg, FALSE);

break;

success = DismountAll (hwndDlg, TRUE, FALSE, UNMOUNT_MAX_AUTO_RETRIES, UNMOUNT_AUTO_RETRY_DELAY);

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

if (success)

{

if (bDisplayBalloonOnSuccessfulHkDismount)

if (bPlaySoundOnSuccessfulHkDismount)

MessageBeep (0xFFFFFFFF);

}

break;

success = DismountAll (hwndDlg, TRUE, FALSE, UNMOUNT_MAX_AUTO_RETRIES, UNMOUNT_AUTO_RETRY_DELAY);

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

if (success)

{

if (bDisplayBalloonOnSuccessfulHkDismount)

if (bPlaySoundOnSuccessfulHkDismount)

MessageBeep (0xFFFFFFFF);

}

TaskBarIconRemove (hwndDlg);

UnregisterWtsAndPowerNotification(hwndDlg);

EndMainDlg (hwndDlg);

break;

case HK_MOUNT_FAVORITE_VOLUMES:

{

if (0 == _InterlockedCompareExchange(&FavoriteMountOnGoing, 1, 0))

{

mountFavoriteVolumeThreadParam* pParam = (mountFavoriteVolumeThreadParam*) calloc(1, sizeof(mountFavoriteVolumeThreadParam));

pParam->systemFavorites = FALSE;

pParam->logOnMount = FALSE;

pParam->hotKeyMount = TRUE;

pParam->favoriteVolumeToMount = NULL;

_beginthread(mountFavoriteVolumeThreadFunction, 0, pParam);

nStatus = ERR_OUTOFMEMORY;

handleError (hwndDlg, nStatus, SRC_POS);

return nStatus;

}

volume.VolumeIsOpen = FALSE;

hiddenVolume.VolumeIsOpen = FALSE;

switch (IsSystemDevicePath (lpszVolume, hwndDlg, TRUE))

{

case 1:

case 2:

if (AskErrNoYes ("BACKUP_HEADER_NOT_FOR_SYS_DEVICE", hwndDlg) == IDYES)

CreateRescueDisk (hwndDlg);

return 0;

}

if (IsMountedVolume (lpszVolume))

{

goto ret;

}

if (!VolumePathExists (lpszVolume))

{

handleWin32Error (hwndDlg, SRC_POS);

goto ret;

}

Info ("EXTERNAL_VOL_HEADER_BAK_FIRST_INFO", hwndDlg);

WaitCursor();

// Open both types of volumes

for (int type = TC_VOLUME_TYPE_NORMAL; type <= TC_VOLUME_TYPE_HIDDEN; ++type)

{

OpenVolumeContext *askVol = (type == TC_VOLUME_TYPE_HIDDEN ? &hiddenVolume : &volume);

Password *askPassword = (type == TC_VOLUME_TYPE_HIDDEN ? &hiddenVolPassword : &VolumePassword);

int* askPkcs5 = (type == TC_VOLUME_TYPE_HIDDEN ? &hiddenVolPkcs5 : &VolumePkcs5);

{

case 1:

case 2:

if (AskErrNoYes ("RESTORE_HEADER_NOT_FOR_SYS_DEVICE", hwndDlg) == IDYES)

CreateRescueDisk (hwndDlg);

return 0;

case -1:

// In some environments (such as PE), the system volume is not located on a hard drive.

// Therefore, we must interpret this return code as "Not a system device path" (otherwise,

// it would not be possible to restore headers on non-system devices in such environments).

// Note that this is rather safe, because bReliableRequired is set to TRUE.

// NOP

break;

}

if (IsMountedVolume (lpszVolume))

{

return 0;

}

if (!VolumePathExists (lpszVolume))

{

handleWin32Error (hwndDlg, SRC_POS);

return 0;

}

BOOL restoreInternalBackup;

// Ask the user to select the type of backup (internal/external)

char *volTypeChoices[] = {0, "HEADER_RESTORE_EXTERNAL_INTERNAL", "HEADER_RESTORE_INTERNAL", "HEADER_RESTORE_EXTERNAL", "IDCANCEL", 0};

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

{

case 1:

restoreInternalBackup = TRUE;

break;

case 2:

restoreInternalBackup = FALSE;