![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to mount.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [truecrypt] / truecrypt / mount|
Return to mount.c CVS log | Up to [truecrypt] / truecrypt / mount |
1.1.1.3 root 1: /* The source code contained in this file has been derived from the source code
2: of Encryption for the Masses 2.02a by Paul Le Roux. Modifications and
3: additions to that source code contained in this file are Copyright (c) 2004
4: TrueCrypt Team and Copyright (c) 2004 TrueCrypt Foundation. Unmodified
5: parts are Copyright (c) 1998-99 Paul Le Roux. This is a TrueCrypt Foundation
6: release. Please see the file license.txt for full license details. */
1.1 root 7:
8: #include "TCdefs.h"
9:
10: #include "crypto.h"
11: #include "apidrvr.h"
12: #include "dlgcode.h"
13: #include "combo.h"
14: #include "registry.h"
15: #include "../common/resource.h"
16:
17: #include "resource.h"
18: #include "cmdline.h"
19: #include "Mount.h"
20:
21: #include "dismount.h"
22:
23: #include "Password.h"
24: #include <time.h>
25:
26: BOOL bExplore = FALSE; /* Display explorer window after mount */
27: BOOL bBeep = FALSE; /* Donot beep after mount */
28: char szFileName[TC_MAX_PATH]; /* Volume to mount */
29: char szDriveLetter[3]; /* Drive Letter to mount */
30: BOOL bCacheInDriver = FALSE; /* Cache any passwords we see */
31: BOOL bHistory = FALSE; /* Don't save history */
32: BOOL bHistoryCmdLine = FALSE; /* History control is always disabled */
33: BOOL bCloseDismountedWindows=TRUE; /* Close all open explorer windows of dismounted volume */
34: BOOL bWipeCacheOnExit = FALSE; /* Wipe password from chace on exit */
35:
36: BOOL bWipe = FALSE; /* Wipe driver passwords */
37: BOOL bAuto = FALSE; /* Do everything without user input */
38:
39: BOOL bQuiet = FALSE; /* No dialogs/messages */
1.1.1.3 root 40:
1.1.1.2 root 41: char commandLinePassword[MAX_PASSWORD + 1] = {0}; /* Password passed from command line */
1.1 root 42:
43: #define VMOUNTED 1
44: #define VFREE 0
45:
46: int nCurrentShowType = 0; /* current display mode, mount, unmount etc */
47: int nSelectedDriveIndex = 0; /* Item number of selected drive */
48:
49: void
50: localcleanup (void)
51: {
52: /* Free the application title */
53: if (lpszTitle != NULL)
54: free (lpszTitle);
55:
56: /* Cleanup common code resources */
57: cleanup ();
58: }
59:
60: void
61: RefreshMainDlg (HWND hwndDlg)
62: {
63: int drive = (char) (HIWORD (GetSelectedLong (GetDlgItem (hwndDlg, IDC_DRIVELIST))));
64:
65: MoveEditToCombo (GetDlgItem (hwndDlg, IDC_VOLUME));
66: LoadDriveLetters (GetDlgItem (hwndDlg, IDC_DRIVELIST), drive);
67: EnableDisableButtons (hwndDlg);
68: }
69:
70: void
71: EndMainDlg (HWND hwndDlg)
72: {
73: MoveEditToCombo (GetDlgItem (hwndDlg, IDC_VOLUME));
1.1.1.2 root 74: if (!bQuiet) SaveSettings (hwndDlg);
1.1 root 75:
76: if (bWipeCacheOnExit)
77: {
78: DWORD dwResult;
79: DeviceIoControl (hDriver, WIPE_CACHE, NULL, 0, NULL, 0, &dwResult, NULL);
80: }
81:
82: EndDialog (hwndDlg, 0);
83: }
84:
85: void
86: EnableDisableButtons (HWND hwndDlg)
87: {
88: HWND hOKButton = GetDlgItem (hwndDlg, IDOK);
89: HWND hChangeButton = GetDlgItem (hwndDlg, IDC_CHANGE_PASSWORD);
90: HWND hVolume = GetDlgItem (hwndDlg, IDC_VOLUME);
91: BOOL bEnable = TRUE;
92: WORD x;
93:
94: x = LOWORD (GetSelectedLong (GetDlgItem (hwndDlg, IDC_DRIVELIST)));
95:
96: if (GetWindowTextLength (GetDlgItem (hwndDlg, IDC_VOLUME)) > 0)
97: {
98: EnableWindow (hOKButton, TRUE);
99: EnableMenuItem (GetMenu (hwndDlg), ID_MOUNT_VOLUME, MF_ENABLED);
100:
101: EnableWindow (hChangeButton, TRUE);
102: EnableMenuItem (GetMenu (hwndDlg), IDC_CHANGE_PASSWORD, MF_ENABLED);
103: }
104: else
105: {
106: EnableWindow (hOKButton, FALSE);
107: EnableMenuItem (GetMenu (hwndDlg), ID_MOUNT_VOLUME, MF_GRAYED);
108:
109: EnableWindow (hChangeButton, FALSE);
110: EnableMenuItem (GetMenu (hwndDlg), IDC_CHANGE_PASSWORD, MF_GRAYED);
111: }
112:
113: if (x == VFREE)
114: {
115: SetWindowText (hOKButton, getstr (IDS_MOUNT_BUTTON));
116:
117: EnableMenuItem (GetMenu (hwndDlg), ID_UNMOUNT_VOLUME, MF_GRAYED);
118: }
119:
120: if (x == VMOUNTED)
121: {
122: SetWindowText (hOKButton, getstr (IDS_UNMOUNT_BUTTON));
123: EnableWindow (hOKButton, TRUE);
124:
125: EnableMenuItem (GetMenu (hwndDlg), ID_MOUNT_VOLUME, MF_GRAYED);
126: EnableMenuItem (GetMenu (hwndDlg), ID_UNMOUNT_VOLUME, MF_ENABLED);
127:
128: EnableWindow (GetDlgItem (hwndDlg, IDC_VOLUME_PROPERTIES), TRUE);
129: EnableMenuItem (GetMenu (hwndDlg), IDC_VOLUME_PROPERTIES, MF_ENABLED);
130: }
131: else
132: {
133: EnableWindow (GetDlgItem (hwndDlg, IDC_VOLUME_PROPERTIES), FALSE);
134: EnableMenuItem (GetMenu (hwndDlg), IDC_VOLUME_PROPERTIES, MF_GRAYED);
135: }
136:
137: EnableWindow (GetDlgItem (hwndDlg, IDC_WIPE_CACHE), !IsPasswordCacheEmpty());
138: EnableMenuItem (GetMenu (hwndDlg), IDC_WIPE_CACHE, IsPasswordCacheEmpty() ? MF_GRAYED:MF_ENABLED);
139: EnableMenuItem (GetMenu (hwndDlg), IDC_CLEAR_HISTORY, IsComboEmpty (GetDlgItem (hwndDlg, IDC_VOLUME)) ? MF_GRAYED:MF_ENABLED);
140: }
141:
142: void
143: OpenPageHelp (HWND hwndDlg)
144: {
145: int r = (int)ShellExecute (NULL, "open", szHelpFile, NULL, NULL, SW_SHOWNORMAL);
146:
147: if (r == ERROR_FILE_NOT_FOUND)
148: MessageBox (hwndDlg, getstr (IDS_HELP_ERROR), lpszTitle, MB_ICONERROR);
149:
150: if (r == SE_ERR_NOASSOC)
151: MessageBox (hwndDlg, getstr (IDS_HELP_READER_ERROR), lpszTitle, MB_ICONERROR);
152: }
153:
154: void
155: LoadSettings (HWND hwndDlg)
156: {
157:
158: // Options
159: bCacheInDriver = ReadRegistryInt ("CachePasswordsInDriver", FALSE);
160: bExplore = ReadRegistryInt ("OpenExplorerWindowAfterMount", FALSE);
161: bCloseDismountedWindows = ReadRegistryInt ("CloseExplorerWindowsOnDismount", TRUE);
162: bHistory = ReadRegistryInt ("SaveMountedVolumesHistory", FALSE);
163: bWipeCacheOnExit = ReadRegistryInt ("WipePasswordCacheOnExit", FALSE);
164:
165: // Drive Letter
166: ReadRegistryString ("LastSelectedDrive", "", szDriveLetter, sizeof (szDriveLetter));
167:
168: // History
169: if (bHistoryCmdLine != TRUE)
170: LoadCombo (GetDlgItem (hwndDlg, IDC_VOLUME), "LastMountedVolume");
171: }
172:
173: void
174: SaveSettings (HWND hwndDlg)
175: {
176: char szTmp[32] = {0};
177: LPARAM lLetter;
178:
179: // Options
180: WriteRegistryInt ("CachePasswordsInDriver", bCacheInDriver);
181: WriteRegistryInt ("OpenExplorerWindowAfterMount", bExplore);
182: WriteRegistryInt ("CloseExplorerWindowsOnDismount", bCloseDismountedWindows);
183: WriteRegistryInt ("SaveMountedVolumesHistory", !IsButtonChecked (GetDlgItem (hwndDlg, IDC_NO_HISTORY)));
184: WriteRegistryInt ("WipePasswordCacheOnExit", bWipeCacheOnExit);
185:
186: // Drive Letter
187: lLetter = GetSelectedLong (GetDlgItem (hwndDlg, IDC_DRIVELIST));
188: if (LOWORD (lLetter) != 0xffff)
189: sprintf (szTmp, "%c:", (char) HIWORD (lLetter));
190: WriteRegistryString ("LastSelectedDrive", szTmp);
191:
192: // History
193: DumpCombo (GetDlgItem (hwndDlg, IDC_VOLUME), "LastMountedVolume", IsButtonChecked (GetDlgItem (hwndDlg, IDC_NO_HISTORY)));
194: }
195:
196: BOOL
197: SelectItem (HWND hTree, char nLetter)
198: {
199: int i;
200: LVITEM item;
201:
202: for (i = 0; i < ListView_GetItemCount(hTree); i++)
203: {
204: memset(&item, 0, sizeof(LVITEM));
205: item.mask = LVIF_PARAM;
206: item.iItem = i;
207:
208: if (ListView_GetItem (hTree, &item) == FALSE)
209: return FALSE;
210: else
211: {
212: if (HIWORD (item.lParam) == nLetter)
213: {
214: memset(&item, 0, sizeof(LVITEM));
215: item.state = LVIS_FOCUSED|LVIS_SELECTED;
216: item.stateMask = LVIS_FOCUSED|LVIS_SELECTED;
217: item.mask = LVIF_STATE;
218: item.iItem = i;
219: SendMessage(hTree, LVM_SETITEMSTATE, i, (LPARAM) &item);
220: return TRUE;
221: }
222: }
223:
224: }
225:
226: return TRUE;
227: }
228:
229:
230: // Fills drive list
231: // drive>0 = update only the corresponding drive subitems
232: void
233: LoadDriveLetters (HWND hTree, int drive)
234: {
235: char *szDriveLetters[]=
236: {"A:", "B:", "C:", "D:",
237: "E:", "F:", "G:", "H:", "I:", "J:", "K:",
238: "L:", "M:", "N:", "O:", "P:", "Q:", "R:",
239: "S:", "T:", "U:", "V:", "W:", "X:", "Y:",
240: "Z:"};
241:
242: DWORD dwResult;
243: BOOL bResult;
244: DWORD dwUsedDrives;
245: MOUNT_LIST_STRUCT driver;
246:
247: LVITEM listItem;
248: int item = 0;
249: char i;
250:
251: bResult = DeviceIoControl (hDriver, MOUNT_LIST, &driver,
252: sizeof (driver), &driver, sizeof (driver), &dwResult,
253: NULL);
254:
255: if (bResult == FALSE)
256: {
257: handleWin32Error (hTree);
258: driver.ulMountedDrives = 0;
259: }
260:
261: dwUsedDrives = GetLogicalDrives();
262: if (dwUsedDrives == 0 && bQuiet == FALSE)
263: MessageBox (hTree, getstr (IDS_DRIVELETTERS), lpszTitle, ICON_HAND);
264:
265: if(drive == 0)
266: ListView_DeleteAllItems(hTree);
267:
268: for (i = 2; i < 26; i++)
269: {
270: int curDrive = 0;
271:
272: if(drive > 0)
273: {
274: LVITEM tmp;
275: memset(&tmp, 0, sizeof(LVITEM));
276: tmp.mask = LVIF_PARAM;
277: tmp.iItem = item;
278: if (ListView_GetItem (hTree, &tmp) != FALSE)
279: curDrive = HIWORD(tmp.lParam);
280: }
281:
282: if ( driver.ulMountedDrives & (1 << i) )
283: {
284: char szTmp[256];
285:
286: memset(&listItem, 0, sizeof(listItem));
287:
288: listItem.mask = LVIF_TEXT | LVIF_IMAGE | LVIF_PARAM;
289: listItem.iImage = 1;
290: listItem.iItem = item++;
291:
292: if(drive > 0 && drive != curDrive)
293: continue;
294:
295: if (nCurrentOS == WIN_NT)
296: ToSBCS ((void *) driver.wszVolume[i]);
297:
298: if (memcmp (driver.wszVolume[i], "\\Device", 7) == 0)
299: sprintf (szTmp, "%s", ((char *) driver.wszVolume[i]));
300: else
301: {
302: if (nCurrentOS == WIN_NT)
303: sprintf (szTmp, "%s", ((char *) driver.wszVolume[i]) + 4);
304: else
305: sprintf (szTmp, "%s", (char *) driver.wszVolume[i]);
306: }
307:
308: listItem.pszText = szDriveLetters[i];
309: listItem.lParam = MAKELONG (VMOUNTED, i + 'A');
310:
311: if(drive == 0)
312: ListView_InsertItem (hTree, &listItem);
313: else
314: ListView_SetItem (hTree, &listItem);
315:
316: listItem.mask=LVIF_TEXT;
317: listItem.pszText = szTmp;
318:
319: listItem.iSubItem = 1;
320: ListView_SetItem(hTree, &listItem);
321:
322: if(driver.diskLength[i] > 1024I64*1024*1024)
323: sprintf (szTmp,"%.1f GB",(double)(driver.diskLength[i]/1024.0/1024/1024));
324: else if(driver.diskLength[i] > 1024I64*1024)
325: sprintf (szTmp, "%I64d MB", driver.diskLength[i]/1024/1024);
326: else if(driver.diskLength[i] > 0)
327: sprintf (szTmp, "%I64d KB", driver.diskLength[i]/1024);
328: else
329: szTmp[0] = 0;
330:
331: listItem.iSubItem = 2;
332: ListView_SetItem(hTree, &listItem);
333:
334: sprintf (szTmp, "%s", get_cipher_name (driver.cipher[i]));
335: listItem.iSubItem = 3;
336: ListView_SetItem(hTree, &listItem);
337:
338: }
339: else
340: {
341: if (!(dwUsedDrives & 1 << i))
342: {
343: if(drive > 0 && drive != HIWORD (GetSelectedLong (hTree)))
344: {
345: item++;
346: continue;
347: }
348:
349: memset(&listItem,0,sizeof(listItem));
350:
351: listItem.mask = LVIF_TEXT | LVIF_IMAGE | LVIF_PARAM;
352: listItem.iImage = 0;
353: listItem.iItem = item++;
354: listItem.pszText = szDriveLetters[i];
355: listItem.lParam = MAKELONG (VFREE, i + 'A');
356:
357: if(drive == 0)
358: ListView_InsertItem (hTree, &listItem);
359: else
360: ListView_SetItem (hTree, &listItem);
361:
362: listItem.mask=LVIF_TEXT;
363: listItem.pszText = "";
364: listItem.iSubItem = 1;
365: ListView_SetItem(hTree, &listItem);
366: listItem.iSubItem = 2;
367: ListView_SetItem(hTree, &listItem);
368: listItem.iSubItem = 3;
369: ListView_SetItem(hTree, &listItem);
370:
371: }
372: }
373: }
374: }
375:
376:
377: /* Except in response to the WM_INITDIALOG message, the dialog box procedure
378: should return nonzero if it processes the message, and zero if it does
379: not. - see DialogProc */
380: BOOL WINAPI
381: PasswordChangeDlgProc (HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)
382: {
383:
384: WORD lw = LOWORD (wParam);
385: WORD hw = HIWORD (wParam);
386:
387: if (lParam); /* remove warning */
388: if (hw); /* remove warning */
389:
390: switch (msg)
391: {
392: case WM_INITDIALOG:
393: {
394: UINT nID[4];
1.1.1.3 root 395: LPARAM nIndex;
396: HWND hComboBox = GetDlgItem (hwndDlg, IDC_HASH_CHANGE);
397: int i;
1.1 root 398:
399: nID[0] = IDS_PASSWORD_HELP0;
400: nID[1] = IDS_PASSWORD_HELP1;
401: nID[2] = IDS_PASSWORD_HELP2;
402: nID[3] = IDS_PASSWORD_HELP3;
403:
404: SetDefaultUserFont (hwndDlg);
405:
406: SendMessage (GetDlgItem (hwndDlg, IDC_OLD_PASSWORD), EM_LIMITTEXT, MAX_PASSWORD, 0);
407: SendMessage (GetDlgItem (hwndDlg, IDC_PASSWORD), EM_LIMITTEXT, MAX_PASSWORD, 0);
408: SendMessage (GetDlgItem (hwndDlg, IDC_VERIFY), EM_LIMITTEXT, MAX_PASSWORD, 0);
409: SetWindowText (GetDlgItem (hwndDlg, IDC_BOX_HELP), getmultilinestr (nID));
410: EnableWindow (GetDlgItem (hwndDlg, IDOK), FALSE);
411:
1.1.1.3 root 412: SendMessage (hComboBox, CB_RESETCONTENT, 0, 0);
413:
414: nIndex = SendMessage (hComboBox, CB_ADDSTRING, 0, (LPARAM) "Unchanged");
415: SendMessage (hComboBox, CB_SETITEMDATA, nIndex, (LPARAM) 0);
416:
417: for (i = 1; i <= LAST_PRF_ID; i++)
418: {
419: nIndex = SendMessage (hComboBox, CB_ADDSTRING, 0, (LPARAM) get_hash_name(i));
420: SendMessage (hComboBox, CB_SETITEMDATA, nIndex, (LPARAM) i);
421: }
422:
423: SendMessage (hComboBox, CB_SETCURSEL, 0, 0);
424:
1.1 root 425: return 1;
426: }
427:
428: case WM_COMMAND:
429: if (lw == IDCANCEL)
430: {
431: // Attempt to wipe passwords stored in the input field buffers
432: char tmp[MAX_PASSWORD+1];
433: memset (tmp, 'X', MAX_PASSWORD);
434: tmp[MAX_PASSWORD] = 0;
435:
436: SetWindowText (GetDlgItem (hwndDlg, IDC_PASSWORD), tmp);
437: SetWindowText (GetDlgItem (hwndDlg, IDC_OLD_PASSWORD), tmp);
438: SetWindowText (GetDlgItem (hwndDlg, IDC_VERIFY), tmp);
439:
440: EndDialog (hwndDlg, IDCANCEL);
441: return 1;
442: }
443: if (hw == EN_CHANGE)
444: {
445: VerifyPasswordAndUpdate (hwndDlg, GetDlgItem (hwndDlg, IDOK), GetDlgItem (hwndDlg, IDC_PASSWORD),
446: GetDlgItem (hwndDlg, IDC_VERIFY), NULL, NULL);
447: return 1;
448: }
449: if (lw == IDOK)
450: {
451: HWND hParent = GetParent (hwndDlg);
452: char szOldPassword[MAX_PASSWORD + 1];
453: char szPassword[MAX_PASSWORD + 1];
454: int nStatus;
1.1.1.3 root 455: int pkcs5 = SendMessage (GetDlgItem (hwndDlg, IDC_HASH_CHANGE), CB_GETITEMDATA,
456: SendMessage (GetDlgItem (hwndDlg, IDC_HASH_CHANGE), CB_GETCURSEL, 0, 0), 0);
1.1 root 457:
458: GetWindowText (GetDlgItem (hParent, IDC_VOLUME), szFileName, sizeof (szFileName));
459:
460: GetWindowText (GetDlgItem (hwndDlg, IDC_OLD_PASSWORD), szOldPassword, sizeof (szOldPassword));
461:
462: GetWindowText (GetDlgItem (hwndDlg, IDC_PASSWORD), szPassword, sizeof (szPassword));
463:
1.1.1.3 root 464: nStatus = ChangePwd (szFileName, szOldPassword, szPassword, pkcs5);
1.1 root 465:
466: burn (szOldPassword, sizeof (szOldPassword));
467: burn (szPassword, sizeof (szPassword));
468:
469: if (nStatus != 0)
470: handleError (hwndDlg, nStatus);
471: else
472: {
473: // Attempt to wipe passwords stored in the input field buffers
474: char tmp[MAX_PASSWORD+1];
475: memset (tmp, 'X', MAX_PASSWORD);
476: tmp[MAX_PASSWORD] = 0;
477: SetWindowText (GetDlgItem (hwndDlg, IDC_PASSWORD), tmp);
478: SetWindowText (GetDlgItem (hwndDlg, IDC_OLD_PASSWORD), tmp);
479: SetWindowText (GetDlgItem (hwndDlg, IDC_VERIFY), tmp);
480:
481: EndDialog (hwndDlg, IDOK);
482: }
483:
484: return 1;
485: }
486: return 0;
487: }
488:
489: return 0;
490: }
491:
492: /* Except in response to the WM_INITDIALOG message, the dialog box procedure
493: should return nonzero if it processes the message, and zero if it does
494: not. - see DialogProc */
495: BOOL WINAPI
496: PasswordDlgProc (HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)
497: {
498: WORD lw = LOWORD (wParam);
499: static char* szXPwd;
500:
501: switch (msg)
502: {
503: case WM_INITDIALOG:
504: {
505: szXPwd = (char*) lParam;
506: SetDefaultUserFont (hwndDlg);
507: SendMessage (GetDlgItem (hwndDlg, IDC_PASSWORD), EM_LIMITTEXT, MAX_PASSWORD, 0);
508: SendMessage (GetDlgItem (hwndDlg, IDC_CACHE), BM_SETCHECK, bCacheInDriver ? BST_CHECKED:BST_UNCHECKED, 0);
509: return 1;
510: }
511:
512: case WM_COMMAND:
513:
514: if (lw == IDCANCEL || lw == IDOK)
515: {
516: char tmp[MAX_PASSWORD+1];
517:
518: if (lw == IDOK)
519: {
520: GetWindowText (GetDlgItem (hwndDlg, IDC_PASSWORD), szXPwd, MAX_PASSWORD + 1);
521: bCacheInDriver = IsButtonChecked (GetDlgItem (hwndDlg, IDC_CACHE));
522: }
523:
524: // Attempt to wipe password stored in the input field buffer
525: memset (tmp, 'X', MAX_PASSWORD);
526: tmp[MAX_PASSWORD] = 0;
527: SetWindowText (GetDlgItem (hwndDlg, IDC_PASSWORD), tmp);
528: SetWindowText (GetDlgItem (hwndDlg, IDC_PASSWORD), 0);
529:
530: EndDialog (hwndDlg, lw);
531: return 1;
532: }
533: return 0;
534: }
535:
536: return 0;
537: }
538:
539: BOOL WINAPI
540: PreferencesDlgProc (HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)
541: {
542: WORD lw = LOWORD (wParam);
543:
544: switch (msg)
545: {
546: case WM_INITDIALOG:
547: {
548: SetDefaultUserFont (hwndDlg);
549:
550: SendMessage (GetDlgItem (hwndDlg, IDC_PREF_OPEN_EXPLORER), BM_SETCHECK,
551: bExplore ? BST_CHECKED:BST_UNCHECKED, 0);
552:
553: SendMessage (GetDlgItem (hwndDlg, IDC_PREF_CLOSE_DISMOUNTED_WINDOWS), BM_SETCHECK,
554: bCloseDismountedWindows ? BST_CHECKED:BST_UNCHECKED, 0);
555:
556: SendMessage (GetDlgItem (hwndDlg, IDC_PREF_WIPE_CACHE_ON_EXIT), BM_SETCHECK,
557: bWipeCacheOnExit ? BST_CHECKED:BST_UNCHECKED, 0);
558:
559: SendMessage (GetDlgItem (hwndDlg, IDC_PREF_CACHE_PASSWORDS), BM_SETCHECK,
560: bCacheInDriver ? BST_CHECKED:BST_UNCHECKED, 0);
561:
562:
563: return 1;
564: }
565:
566: case WM_COMMAND:
567:
568: if (lw == IDCANCEL)
569: {
570: EndDialog (hwndDlg, lw);
571: return 1;
572: }
573:
574: if (lw == IDOK)
575: {
576: bExplore = IsButtonChecked (GetDlgItem (hwndDlg, IDC_PREF_OPEN_EXPLORER));
577: bCloseDismountedWindows = IsButtonChecked (GetDlgItem (hwndDlg, IDC_PREF_CLOSE_DISMOUNTED_WINDOWS));
578: bWipeCacheOnExit = IsButtonChecked (GetDlgItem (hwndDlg, IDC_PREF_WIPE_CACHE_ON_EXIT));
579: bCacheInDriver = IsButtonChecked (GetDlgItem (hwndDlg, IDC_PREF_CACHE_PASSWORDS));
580:
581: EndDialog (hwndDlg, lw);
582: return 1;
583: }
584: return 0;
585: }
586:
587: return 0;
588: }
589:
590: BOOL WINAPI
591: VolumePropertiesDlgProc (HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)
592: {
593: WORD lw = LOWORD (wParam);
594:
595: switch (msg)
596: {
597: case WM_INITDIALOG:
598: {
599: VOLUME_PROPERTIES_STRUCT prop;
600: DWORD dwResult;
601: BOOL bResult;
602:
603: LVCOLUMN lvCol;
604: LVITEM listItem;
605: HWND list = GetDlgItem (hwndDlg, IDC_VOLUME_PROPERTIES_LIST);
606: char szTmp[128];
607:
608: SetDefaultUserFont (hwndDlg);
609:
610: SendMessage (list,LVM_SETEXTENDEDLISTVIEWSTYLE,0,
611: LVS_EX_FULLROWSELECT
612: |LVS_EX_HEADERDRAGDROP
613: //|LVS_EX_GRIDLINES
614: //|LVS_EX_TWOCLICKACTIVATE
615: );
616:
617: memset (&lvCol,0,sizeof(lvCol));
618: lvCol.mask = LVCF_TEXT|LVCF_WIDTH|LVCF_SUBITEM|LVCF_FMT;
619: lvCol.pszText = "Value";
620: lvCol.cx = 220;
621: lvCol.fmt = LVCFMT_LEFT ;
622: SendMessage (list,LVM_INSERTCOLUMN,0,(LPARAM)&lvCol);
623:
624: lvCol.pszText = "Property";
625: lvCol.cx = 100;
626: lvCol.fmt = LVCFMT_LEFT;
627: SendMessage (list,LVM_INSERTCOLUMN,0,(LPARAM)&lvCol);
628:
629:
630: memset (&prop, 0, sizeof(prop));
631: prop.driveNo = HIWORD (GetSelectedLong (GetDlgItem (GetParent(hwndDlg), IDC_DRIVELIST))) - 'A';
632:
633: bResult = DeviceIoControl (hDriver, VOLUME_PROPERTIES, &prop,
634: sizeof (prop), &prop, sizeof (prop), &dwResult,
635: NULL);
636:
637: memset (&listItem, 0, sizeof(listItem));
638:
639: listItem.mask = LVIF_TEXT;
640: listItem.iItem = -1;
641:
642: listItem.pszText = "Volume Location";
643: listItem.iItem++;
644: listItem.iSubItem = 0;
645: ListView_InsertItem(list, &listItem);
646: listItem.iSubItem++;
647: listItem.pszText = (LPSTR)prop.wszVolume;
648: if (nCurrentOS == WIN_NT)
649: {
650: ToSBCS (prop.wszVolume);
651: if (prop.wszVolume[0] == '?\\')
652: listItem.pszText = (LPSTR)prop.wszVolume + 4;
653: }
654: ListView_SetItem(list, &listItem);
655:
656: listItem.pszText = "Volume Size";
657: listItem.iItem++;
658: listItem.iSubItem = 0;
659: ListView_InsertItem(list, &listItem);
660: listItem.iSubItem++;
661: sprintf (szTmp, "%I64d bytes", prop.diskLength);
662: listItem.pszText = szTmp;
663: ListView_SetItem (list, &listItem);
664:
665: listItem.pszText = "Cipher";
666: listItem.iItem++;
667: listItem.iSubItem = 0;
668: ListView_InsertItem(list, &listItem);
669: listItem.iSubItem++;
670: listItem.pszText = get_cipher_name (prop.cipher);
671: ListView_SetItem (list, &listItem);
672:
673: listItem.pszText = "Key Size";
674: listItem.iItem++;
675: listItem.iSubItem = 0;
676: ListView_InsertItem(list, &listItem);
677: listItem.iSubItem++;
678: sprintf (szTmp, "%d bits", get_key_size (prop.cipher)*8);
679: listItem.pszText = szTmp;
680: ListView_SetItem (list, &listItem);
681:
682: listItem.pszText = "PKCS5 PRF";
683: listItem.iItem++;
684: listItem.iSubItem = 0;
685: ListView_InsertItem(list, &listItem);
686: listItem.iSubItem++;
687: listItem.pszText = get_hash_name (prop.pkcs5);
688: ListView_SetItem (list, &listItem);
689:
690: listItem.pszText = "PKCS5 Iterations";
691: listItem.iItem++;
692: listItem.iSubItem = 0;
693: ListView_InsertItem(list, &listItem);
694: listItem.iSubItem++;
695: sprintf (szTmp, "%d", prop.pkcs5Iterations);
696: listItem.pszText = szTmp;
697: ListView_SetItem (list, &listItem);
698:
699: {
700: FILETIME ft, curFt;
701: SYSTEMTIME st;
702: char date[128];
703: memset (date, 0, sizeof (date));
704:
705: listItem.pszText = "Volume Created";
706: listItem.iItem++;
707: listItem.iSubItem = 0;
708: ListView_InsertItem (list, &listItem);
709:
710: listItem.iSubItem++;
711: *(unsigned __int64 *)(&ft) = prop.volumeCreationTime;
712: FileTimeToSystemTime (&ft, &st);
713: GetDateFormat (LOCALE_USER_DEFAULT, 0, &st, 0, (LPSTR) szTmp, sizeof (szTmp));
714: sprintf (date, "%s ", szTmp);
715: GetTimeFormat (LOCALE_USER_DEFAULT, 0, &st, 0, (LPSTR) szTmp, sizeof (szTmp));
716: strcat (date, szTmp);
717: listItem.pszText = date;
718: ListView_SetItem (list, &listItem);
719:
720: listItem.pszText = "Password Changed";
721: listItem.iItem++;
722: listItem.iSubItem = 0;
723: ListView_InsertItem (list, &listItem);
724:
725: listItem.iSubItem++;
726: *(unsigned __int64 *)(&ft) = prop.headerCreationTime;
727: FileTimeToSystemTime (&ft, &st);
728: GetDateFormat (LOCALE_USER_DEFAULT, 0, &st, 0, (LPSTR) szTmp, sizeof (szTmp));
729: sprintf (date, "%s ", szTmp);
730: GetTimeFormat (LOCALE_USER_DEFAULT, 0, &st, 0, (LPSTR) szTmp, sizeof (szTmp));
731: strcat (date, szTmp);
732:
733: GetLocalTime (&st);
734: SystemTimeToFileTime (&st, &curFt);
735: sprintf (date + strlen (date), " (%I64d days ago)"
736: , (*(__int64 *)&curFt - *(__int64 *)&ft)/1000000000000 );
737: listItem.pszText = date;
738: ListView_SetItem (list, &listItem);
739: }
740:
741: return 1;
742: }
743:
744: case WM_COMMAND:
745:
746: if (lw == IDCANCEL)
747: {
748: EndDialog (hwndDlg, lw);
749: return 1;
750: }
751:
752: if (lw == IDOK)
753: {
754: EndDialog (hwndDlg, lw);
755: return 1;
756: }
757: return 0;
758: }
759:
760: return 0;
761: }
762:
763: void
764: BuildTree (HWND hTree)
765: {
766: HIMAGELIST hList;
767: HBITMAP hBitmap, hBitmapMask;
768: LVCOLUMN lvCol;
769: SendMessage(hTree,LVM_SETEXTENDEDLISTVIEWSTYLE,0,
770: LVS_EX_FULLROWSELECT
771: |LVS_EX_HEADERDRAGDROP
772: //|LVS_EX_GRIDLINES
773: //|LVS_EX_TWOCLICKACTIVATE
774: );
775:
776: memset(&lvCol,0,sizeof(lvCol));
777:
778: lvCol.mask = LVCF_TEXT|LVCF_WIDTH|LVCF_SUBITEM|LVCF_FMT;
779: lvCol.pszText="Drive";
780: lvCol.cx=40;
781: lvCol.fmt = LVCFMT_COL_HAS_IMAGES|LVCFMT_LEFT ;
782: SendMessage (hTree,LVM_INSERTCOLUMN,0,(LPARAM)&lvCol);
783:
784: lvCol.pszText="Volume";
785: lvCol.cx=290;
786: lvCol.fmt = LVCFMT_LEFT;
787: SendMessage (hTree,LVM_INSERTCOLUMN,1,(LPARAM)&lvCol);
788:
789: lvCol.pszText="Size";
790: lvCol.cx=80;
791: lvCol.fmt = LVCFMT_RIGHT;
792: SendMessage (hTree,LVM_INSERTCOLUMN,2,(LPARAM)&lvCol);
793:
794: lvCol.pszText="Cipher";
795: lvCol.cx=110;
796: lvCol.fmt = LVCFMT_LEFT;
797: SendMessage (hTree,LVM_INSERTCOLUMN,3,(LPARAM)&lvCol);
798:
799: hBitmap = LoadBitmap (hInst, MAKEINTRESOURCE (IDB_DRIVEICON));
800: if (hBitmap == NULL)
801: return;
802: hBitmapMask = LoadBitmap (hInst, MAKEINTRESOURCE (IDB_DRIVEICON_MASK));
803:
804: hList = ImageList_Create (16, 12, ILC_COLOR8|ILC_MASK, 2, 2);
805: if (ImageList_Add (hList, hBitmap, hBitmapMask) == -1)
806: {
807: DeleteObject (hBitmap);
808: return;
809: }
810: else
811: DeleteObject (hBitmap);
812:
813: ListView_SetImageList (hTree, hList, LVSIL_NORMAL);
814: ListView_SetImageList (hTree, hList, LVSIL_SMALL);
815:
816: LoadDriveLetters (hTree, 0);
817: }
818:
819: LPARAM
820: GetSelectedLong (HWND hTree)
821: {
822: int hItem = ListView_GetSelectionMark (hTree);
823: LVITEM item;
824:
825: if (nSelectedDriveIndex != 0)
826: hItem = nSelectedDriveIndex;
827:
828: memset(&item, 0, sizeof(LVITEM));
829: item.mask = LVIF_PARAM;
830: item.iItem = hItem;
831:
832: if (ListView_GetItem (hTree, &item) == FALSE)
833: return MAKELONG (0xffff, 0xffff);
834: else
835: return item.lParam;
836: }
837:
838: LPARAM
839: GetItemLong (HWND hTree, int itemNo)
840: {
841: LVITEM item;
842:
843: memset(&item, 0, sizeof(LVITEM));
844: item.mask = LVIF_PARAM;
845: item.iItem = itemNo;
846:
847: if (ListView_GetItem (hTree, &item) == FALSE)
848: return MAKELONG (0xffff, 0xffff);
849: else
850: return item.lParam;
851: }
852:
853: static BOOL MountVolume (HWND hwndDlg, int driveNo, char *volumePath, char *szPassword, int quiet)
854: {
855: MOUNT_STRUCT driver;
856: DWORD dwResult;
857: BOOL bResult, bDevice;
858:
859: if (IsMountedVolume (volumePath))
860: {
861: if (!quiet)
862: MessageBox(0, getstr (IDS_ALREADY_MOUNTED), lpszTitle, MB_ICONASTERISK);
863: return FALSE;
864: }
865:
866: driver.nDosDriveNo = driveNo;
867: driver.bCache = bCacheInDriver;
868: driver.time = time (NULL);
869: driver.nPasswordLen = strlen (szPassword);
870: strcpy (driver.szPassword, szPassword);
871:
872: CreateFullVolumePath ((char *) driver.wszVolume, volumePath, &bDevice);
873:
874: if (nCurrentOS == WIN_NT)
875: ToUNICODE ((char *) driver.wszVolume);
876:
877: bResult = DeviceIoControl (hDriver, MOUNT, &driver,
878: sizeof (driver), &driver, sizeof (driver), &dwResult, NULL);
879:
880: burn (&driver.szPassword, sizeof (driver.szPassword));
881:
882: if (bResult == FALSE)
883: {
884: if (!quiet)
885: handleWin32Error (hwndDlg);
886: return bResult;
887: }
888: else
889: {
890: if (driver.nReturnCode == 0)
891: {
892: if (nCurrentOS == WIN_NT)
893: {
894: char *lpszPipeName = "\\\\.\\pipe\\truecryptservice";
895: DWORD bytesRead;
896: char inbuf[80];
897: char outbuf[80];
898:
899: sprintf (outbuf, "mount %d", driver.nDosDriveNo);
900:
901: bResult = CallNamedPipe (lpszPipeName,
902: outbuf, sizeof (outbuf),
903: inbuf, sizeof (inbuf),
904: &bytesRead, NMPWAIT_WAIT_FOREVER);
905:
906: if (bResult == FALSE)
907: {
908: handleWin32Error (hwndDlg);
909: }
910: else
911: {
912: DWORD os_err = 0;
913: int err = 0;
914:
915: sscanf (inbuf, "%s %d %lu", outbuf, &err, &os_err);
916:
917: if (*inbuf == '-' && !quiet)
918: {
919: if (err == ERR_OS_ERROR)
920: {
921: SetLastError (os_err);
922: handleWin32Error (hwndDlg);
923: }
924: else
925: {
926: handleError (hwndDlg, err);
927: }
928:
929: bResult = 0;
930: }
931:
932: }
933:
934: if (bResult == FALSE && !quiet)
1.1.1.2 root 935: {
936: MessageBox (hwndDlg, getstr (IDS_SYMLINK), lpszTitle, ICON_HAND);
1.1 root 937: return FALSE;
938: }
939:
940: }
941: else
942: {
943: EjectStop ((char)toupper(szFileName[0]), TRUE);
944: }
945: }
946: else
947: {
1.1.1.2 root 948: if (!quiet) handleError (hwndDlg, driver.nReturnCode);
1.1 root 949:
950: return FALSE;
951: }
952: }
953:
954: return TRUE;
955: }
956:
957: static BOOL IsPasswordCacheEmpty (void)
958: {
959: DWORD dw;
960: return !DeviceIoControl (hDriver, CACHE_STATUS, 0, 0, 0, 0, &dw, 0);
961: }
962:
963: static BOOL IsMountedVolume (char *volname)
964: {
965: MOUNT_LIST_STRUCT mlist;
966: DWORD dwResult;
967: int i;
968: char volume[TC_MAX_PATH*2+16];
969:
970: strcpy (volume, volname);
971: if (nCurrentOS == WIN_NT)
972: {
973: if (strstr (volname, "\\Device\\") != volname)
974: sprintf(volume, "\\??\\%s", volname);
975: ToUNICODE (volume);
976: }
977:
978: memset (&mlist, 0, sizeof (mlist));
979: DeviceIoControl (hDriver, MOUNT_LIST, &mlist,
980: sizeof (mlist), &mlist, sizeof (mlist), &dwResult,
981: NULL);
982:
983: for (i=0 ; i<26; i++)
984: if (nCurrentOS != WIN_NT && 0 == strcmp ((char *)mlist.wszVolume[i], volume)
985: || nCurrentOS == WIN_NT && 0 == wcscmp (mlist.wszVolume[i], (WCHAR *)volume))
986: return TRUE;
987:
988: return FALSE;
989: }
990:
991: static int AskUserPassword (HWND hwndDlg, char *password)
992: {
993: int result = DialogBoxParam (hInst,
994: MAKEINTRESOURCE (IDD_PASSWORD_DLG), hwndDlg,
995: (DLGPROC) PasswordDlgProc, (LPARAM) password);
996:
997: if (result != IDOK)
998: *password = 0;
999:
1000: return result == IDOK;
1001: }
1002:
1003: // GUI actions
1004:
1005: static void Mount (HWND hwndDlg)
1006: {
1007: char szPassword[MAX_PASSWORD + 1];
1008: int mounted = 0;
1009: int nDosDriveNo = HIWORD (GetSelectedLong (GetDlgItem (hwndDlg, IDC_DRIVELIST))) - 'A';
1010:
1011: burn (szPassword, sizeof (szPassword));
1012: GetWindowText (GetDlgItem (hwndDlg, IDC_VOLUME), szFileName,
1013: sizeof (szFileName));
1014:
1015: if (strlen(szFileName) == 0)
1016: return;
1017:
1018: if (IsMountedVolume (szFileName))
1019: {
1020: MessageBox(0, getstr (IDS_ALREADY_MOUNTED), lpszTitle, MB_ICONASTERISK);
1021: return;
1022: }
1023:
1024: // First try cached passwords and if they fail ask user for a new one
1025: ArrowWaitCursor ();
1026: mounted = MountVolume (hwndDlg, nDosDriveNo, szFileName, "", TRUE);
1027: NormalCursor ();
1028:
1029: while (!mounted)
1030: {
1031: if (!AskUserPassword (hwndDlg, szPassword))
1032: return;
1033:
1034: ArrowWaitCursor ();
1035: mounted = MountVolume (hwndDlg, nDosDriveNo, szFileName, szPassword, FALSE);
1036: NormalCursor ();
1037: }
1038:
1039: if (mounted)
1040: {
1041: if (bBeep == TRUE)
1042: MessageBeep (MB_OK);
1043:
1044: RefreshMainDlg(hwndDlg);
1045:
1046: if (bExplore == TRUE)
1047: {
1048: ArrowWaitCursor();
1049: OpenVolumeExplorerWindow (nDosDriveNo);
1050: NormalCursor();
1051: }
1052: }
1053:
1054: burn (szPassword, sizeof (szPassword));
1055: return;
1056: }
1057:
1058: void OpenVolumeExplorerWindow (int driveNo)
1059: {
1060: char dosName[5];
1061: SHFILEINFO fInfo;
1062:
1063: sprintf (dosName, "%c:\\", (char) driveNo + 'A');
1064:
1065: // Force explorer to discover the drive
1066: SHGetFileInfo (dosName, 0, &fInfo, sizeof (fInfo), 0);
1067:
1068: ShellExecute (NULL, "open", dosName, NULL, NULL, SW_SHOWNORMAL);
1069: }
1070:
1071: static BOOL CALLBACK CloseVolumeExplorerWindowsEnum( HWND hwnd, LPARAM driveNo)
1072: {
1073: char get[128], driveStr[10];
1074: HWND h;
1075:
1076: GetClassName (hwnd, get, sizeof get);
1077:
1078: if (strcmp (get, "CabinetWClass") == 0)
1079: {
1080: sprintf (driveStr, "%c:\\", driveNo + 'A');
1081:
1082: // Title bar
1083: GetWindowText (hwnd, get, sizeof get);
1084: if (strstr (get, driveStr) == get)
1085: {
1086: PostMessage (hwnd, WM_CLOSE, 0, 0);
1087: return TRUE;
1088: }
1089:
1090: // URL edit box
1091: h = FindWindowEx (hwnd, 0, "WorkerW", 0);
1092: if (!h) return TRUE;
1093: h = FindWindowEx (h, 0, "ReBarWindow32", 0);
1094: if (!h) return TRUE;
1095: h = FindWindowEx (h, 0, "ComboBoxEx32", 0);
1096: if (h)
1097: {
1098: SendMessage (h, WM_GETTEXT, sizeof get, (LPARAM) get);
1099: if (strstr (get, driveStr) == get)
1100: PostMessage (hwnd, WM_CLOSE, 0, 0);
1101: }
1102: }
1103: return TRUE;
1104: }
1105:
1106: void CloseVolumeExplorerWindows (HWND hwnd, int driveNo)
1107: {
1108: EnumWindows (CloseVolumeExplorerWindowsEnum, (LPARAM) driveNo);
1109: }
1110:
1.1.1.2 root 1111: static void Dismount (HWND hwndDlg, int nDosDriveNo)
1.1 root 1112: {
1113: char *lpszPipeName = "\\\\.\\pipe\\truecryptservice";
1114: DWORD bytesRead;
1115: BOOL bResult;
1116: char inbuf[80];
1117: char outbuf[80];
1118:
1.1.1.2 root 1119: if (nDosDriveNo == 0)
1120: nDosDriveNo = (char) (HIWORD (GetSelectedLong (GetDlgItem (hwndDlg, IDC_DRIVELIST))) - 'A');
1.1 root 1121:
1122: if (nCurrentOS == WIN_NT)
1123: {
1124:
1125: if (bCloseDismountedWindows)
1126: CloseVolumeExplorerWindows (hwndDlg, nDosDriveNo);
1127:
1128: /* Unmount the volume using the TrueCryptService,
1129: this is done to allow non-administrators
1130: to unmount volumes */
1131:
1132: sprintf (outbuf, "unmount %d", nDosDriveNo);
1133:
1134: ArrowWaitCursor ();
1135:
1136: bResult = CallNamedPipe (lpszPipeName,
1137: outbuf, sizeof (outbuf),
1138: inbuf, sizeof (inbuf),
1139: &bytesRead, NMPWAIT_WAIT_FOREVER);
1140:
1141: NormalCursor ();
1142:
1143: if (bResult == FALSE)
1144: {
1145: handleWin32Error (hwndDlg);
1146: }
1147: else
1148: {
1149: DWORD os_err = 0;
1150: int err = 0;
1151:
1152: sscanf (inbuf, "%s %d %lu", outbuf, &err, &os_err);
1153:
1154: if (*inbuf == '-')
1155: {
1156: //if (err == ERR_OS_ERROR)
1157: //{
1158: // SetLastError (os_err);
1159:
1160: // handleWin32Error (hwndDlg);
1161: //}
1162: //else
1163: //{
1164: // handleError (hwndDlg, err);
1165: //}
1166: MessageBox(0, getstr (IDS_UNMOUNT_FAILED), lpszTitle, MB_ICONEXCLAMATION);
1167: }
1168: else
1169: {
1170: //if (bBeep == TRUE)
1171: // MessageBeep (MB_OK);
1172:
1173: RefreshMainDlg(hwndDlg);
1174: }
1175: }
1176:
1177: }
1178: else
1179: {
1180: int err = 0;
1181:
1182: bResult = CloseSlot (nDosDriveNo, 0, &err);
1183:
1184: if (bResult == FALSE)
1185: {
1186: handleWin32Error (hwndDlg);
1187: }
1188: else
1189: {
1190: if (err != 0)
1191: {
1192: //handleError (hwndDlg, err);
1193: MessageBox(0, getstr (IDS_UNMOUNT_FAILED), lpszTitle, MB_ICONEXCLAMATION);
1194: }
1195: else
1196: {
1197: //if (bBeep == TRUE)
1198: // MessageBeep (MB_OK);
1199:
1200: RefreshMainDlg(hwndDlg);
1201: }
1202: }
1203: }
1204:
1205: return;
1206: }
1207:
1208:
1209:
1210: static void DismountAll (HWND hwndDlg)
1211: {
1212: char *lpszPipeName = "\\\\.\\pipe\\truecryptservice";
1213: DWORD bytesRead;
1214: BOOL bResult;
1215: int nDosDriveNo;
1216: char inbuf[80];
1217: char outbuf[80];
1218:
1219: nDosDriveNo = (char) (HIWORD (GetSelectedLong (GetDlgItem (hwndDlg, IDC_DRIVELIST))) -
1220: 'A');
1221:
1222: ArrowWaitCursor();
1223:
1224: if (nCurrentOS == WIN_NT)
1225: {
1226: if (bCloseDismountedWindows)
1227: {
1228: MOUNT_LIST_STRUCT driver;
1229: DWORD dwResult;
1230:
1231: if (DeviceIoControl (hDriver, MOUNT_LIST, &driver, sizeof (driver), &driver, sizeof (driver), &dwResult, NULL))
1232: {
1233: int i;
1234: for (i = 0; i < 26; i++)
1235: if ((driver.ulMountedDrives & 1 << i))
1236: CloseVolumeExplorerWindows (hwndDlg, i);
1237:
1238: }
1239: }
1240:
1241: /* Unmount the volume using the TrueCryptService,
1242: this is done to allow non-administrators
1243: to unmount volumes */
1244:
1245: strcpy (outbuf, "unmountall");
1246:
1247: ArrowWaitCursor ();
1248:
1249: bResult = CallNamedPipe (lpszPipeName,
1250: outbuf, sizeof (outbuf),
1251: inbuf, sizeof (inbuf),
1252: &bytesRead, NMPWAIT_WAIT_FOREVER);
1253:
1254: NormalCursor ();
1255:
1256: if (bResult == FALSE)
1257: {
1258: handleWin32Error (hwndDlg);
1259: }
1260: else
1261: {
1262: DWORD os_err = 0;
1263: int err = 0;
1264:
1265: sscanf (inbuf, "%s %d %lu", outbuf, &err, &os_err);
1266:
1267: if (*inbuf == '-')
1268: {
1269: //if (err == ERR_OS_ERROR)
1270: //{
1271: // SetLastError (os_err);
1272:
1273: // handleWin32Error (hwndDlg);
1274: //}
1275: //else
1276: //{
1277: // handleError (hwndDlg, err);
1278: //}
1279:
1280: RefreshMainDlg(hwndDlg);
1281: MessageBox(0, getstr (IDS_UNMOUNT_FAILED), lpszTitle, MB_ICONEXCLAMATION);
1282: }
1283: else
1284: {
1285: if (bBeep == TRUE)
1286: MessageBeep (MB_OK);
1287: }
1288: }
1289: }
1290: else
1291: {
1292: DWORD os_error;
1293: int i, err;
1294:
1295: for (i=0; i<26; i++)
1296: CloseSlot (i, 0, &err);
1297: }
1298:
1299: RefreshMainDlg (hwndDlg);
1300: NormalCursor();
1301: }
1302:
1303: static void MountAllPartitions (HWND hwndDlg)
1304: {
1305: HWND driveList = GetDlgItem (hwndDlg, IDC_DRIVELIST);
1306: int i, n, selDrive = ListView_GetSelectionMark (driveList);
1307: char szPassword[MAX_PASSWORD + 1];
1308:
1309: // User is always asked for password as we can't tell
1310: // for sure if it is needed or not
1311: burn (szPassword, sizeof (szPassword));
1312: if (!AskUserPassword (hwndDlg, szPassword))
1313: return;
1314:
1315: ArrowWaitCursor();
1316:
1317: for (i = 0; i < 64; i++)
1318: {
1319: BOOL drivePresent = FALSE;
1320:
1321: for (n = 1; n <= 32; n++)
1322: {
1323: char szFileName[TC_MAX_PATH];
1324: OPEN_TEST_STRUCT driver;
1325:
1326: sprintf (szFileName, "\\Device\\Harddisk%d\\Partition%d", i, n);
1327: if (OpenDevice (szFileName, &driver) == TRUE && !IsMountedVolume (szFileName))
1328: {
1329: int nDosDriveNo;
1330:
1331: while (LOWORD (GetItemLong (driveList, selDrive)) != 0xffff)
1332: {
1333: if(LOWORD (GetItemLong (driveList, selDrive)) != VFREE)
1334: {
1335: selDrive++;
1336: continue;
1337: }
1338: nDosDriveNo = HIWORD(GetItemLong (driveList, selDrive)) - 'A';
1339: break;
1340: }
1341:
1342: if (LOWORD (GetItemLong (driveList, selDrive)) == 0xffff)
1343: goto ret;
1344:
1345: // First try user password then cached passwords
1346: if (MountVolume (hwndDlg, nDosDriveNo, szFileName, szPassword, TRUE)
1347: || MountVolume (hwndDlg, nDosDriveNo, szFileName, "", TRUE))
1348: {
1349: LoadDriveLetters (driveList, (HIWORD (GetItemLong (GetDlgItem (hwndDlg, IDC_DRIVELIST), selDrive))));
1350: selDrive++;
1351:
1352: if (bExplore == TRUE)
1353: {
1354: ArrowWaitCursor();
1355: OpenVolumeExplorerWindow (nDosDriveNo);
1356: NormalCursor();
1357: }
1358: }
1359: }
1360: }
1361: }
1362:
1363: ret:
1364: burn (szPassword, sizeof (szPassword));
1365: EnableDisableButtons (hwndDlg);
1366: NormalCursor();
1367: }
1368:
1369: static void ChangePassword (HWND hwndDlg)
1370: {
1371: int result;
1372:
1373: GetWindowText (GetDlgItem (hwndDlg, IDC_VOLUME), szFileName, sizeof (szFileName));
1374: if (IsMountedVolume (szFileName))
1375: {
1376: MessageBox (hwndDlg, getstr (IDS_MOUNTED_NOPWCHANGE), lpszTitle, MB_ICONEXCLAMATION);
1377: return;
1378: }
1379:
1380: result = DialogBox (hInst, MAKEINTRESOURCE (IDD_PASSWORDCHANGE_DLG), hwndDlg,
1381: (DLGPROC) PasswordChangeDlgProc);
1382:
1383: if (result == IDOK)
1384: {
1385: HWND tmp = GetDlgItem (hwndDlg, IDC_PASSWORD);
1386: MessageBox (hwndDlg, getstr (IDS_PASSWORD_CHANGED), lpszTitle, MB_ICONASTERISK);
1387: SetFocus (tmp);
1388: }
1389: }
1390:
1391: static void SelectContainer (HWND hwndDlg)
1392: {
1393: if (BrowseFiles (hwndDlg, IDS_OPEN_TITLE, szFileName) == FALSE)
1394: return;
1395:
1396: AddComboItem (GetDlgItem (hwndDlg, IDC_VOLUME), szFileName);
1397: EnableDisableButtons (hwndDlg);
1398: SetFocus (GetDlgItem (hwndDlg, IDC_PASSWORD));
1399: }
1400:
1401: static void SelectPartition (HWND hwndDlg)
1402: {
1403: int nResult = DialogBoxParam (hInst, MAKEINTRESOURCE (IDD_RAWDEVICES_DLG), hwndDlg,
1404: (DLGPROC) RawDevicesDlgProc, (LPARAM) & szFileName[0]);
1405: if (nResult == IDOK)
1406: {
1407: AddComboItem (GetDlgItem (hwndDlg, IDC_VOLUME), szFileName);
1408: EnableDisableButtons (hwndDlg);
1409: SetFocus (GetDlgItem (hwndDlg, IDC_PASSWORD));
1410: }
1411: }
1412:
1413: static void WipeCache (HWND hwndDlg)
1414: {
1415: DWORD dwResult;
1416: BOOL bResult;
1417:
1418: bResult = DeviceIoControl (hDriver, WIPE_CACHE, NULL, 0, NULL, 0, &dwResult, NULL);
1419:
1420: if (bResult == FALSE)
1421: handleWin32Error (hwndDlg);
1422: else
1423: {
1424: EnableDisableButtons (hwndDlg);
1425:
1426: if (bQuiet == FALSE)
1427: MessageBox (hwndDlg, getstr (IDS_WIPE_CACHE), lpszTitle, MB_ICONINFORMATION);
1428: }
1429: }
1430:
1431:
1432: /* Except in response to the WM_INITDIALOG message, the dialog box procedure
1433: should return nonzero if it processes the message, and zero if it does
1434: not. - see DialogProc */
1435: BOOL CALLBACK
1436: MainDialogProc (HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
1437: {
1438: WORD lw = LOWORD (wParam);
1439: WORD hw = HIWORD (wParam);
1440: if (lParam); /* remove warning */
1441:
1442: switch (uMsg)
1443: {
1444:
1445: case WM_INITDIALOG:
1446: {
1.1.1.2 root 1447: ExtractCommandLine (hwndDlg, (char *) lParam);
1448:
1449: if (!bQuiet) LoadSettings (hwndDlg);
1.1 root 1450:
1451: /* Call the common dialog init code */
1452: InitDialog (hwndDlg);
1453: SetDefaultUserFont (hwndDlg);
1454:
1455: SendMessage (GetDlgItem (hwndDlg, IDC_VOLUME), CB_LIMITTEXT, TC_MAX_PATH, 0);
1456:
1457: SendMessage (GetDlgItem (hwndDlg, IDC_NO_DRIVES_STATIC), WM_SETFONT, (WPARAM) hBoldFont, (LPARAM) TRUE);
1458: SetWindowText (hwndDlg, lpszTitle);
1459:
1460: BuildTree (GetDlgItem (hwndDlg, IDC_DRIVELIST));
1461:
1462:
1463: if (*szDriveLetter != 0)
1464: {
1465: SelectItem (GetDlgItem (hwndDlg, IDC_DRIVELIST), *szDriveLetter);
1466:
1467: if(nSelectedDriveIndex > SendMessage (GetDlgItem (hwndDlg, IDC_DRIVELIST), LVM_GETITEMCOUNT, 0, 0)/2)
1468: SendMessage(GetDlgItem (hwndDlg, IDC_DRIVELIST), LVM_SCROLL, 0, 1000);
1469: }
1470:
1471: SendMessage (GetDlgItem (hwndDlg, IDC_NO_HISTORY), BM_SETCHECK, bHistory ? BST_UNCHECKED : BST_CHECKED, 0);
1472:
1473: EnableDisableButtons (hwndDlg);
1474:
1475: if (bWipe == TRUE)
1476: {
1.1.1.2 root 1477: WipeCache (hwndDlg);
1.1 root 1478: }
1479:
1.1.1.2 root 1480: // Automount
1.1 root 1481: if (bAuto == TRUE && IsWindowEnabled (GetDlgItem (hwndDlg, IDOK)))
1482: {
1.1.1.2 root 1483: if (!IsMountedVolume (szFileName))
1484: {
1485: BOOL mounted;
1486:
1487: // Cached password
1488: mounted = MountVolume (hwndDlg, szDriveLetter[0] - 'A', szFileName, "", TRUE);
1489:
1490: if (!mounted && commandLinePassword[0] != 0)
1491: {
1492: // Command line password
1493: mounted = MountVolume (hwndDlg, szDriveLetter[0] - 'A', szFileName, commandLinePassword, TRUE);
1494: burn (commandLinePassword, sizeof (commandLinePassword));
1495: }
1496:
1497: // Ask user for password
1498: while (!mounted)
1499: {
1500: char szPassword[MAX_PASSWORD + 1];
1501:
1502: if (!AskUserPassword (hwndDlg, szPassword))
1503: break;
1504:
1505: ArrowWaitCursor ();
1506: mounted = MountVolume (hwndDlg, szDriveLetter[0] - 'A', szFileName, szPassword, FALSE);
1507: burn (szPassword, sizeof (szPassword));
1508: NormalCursor ();
1509: }
1510:
1511: if (mounted)
1512: {
1513: if (bBeep == TRUE) MessageBeep (MB_OK);
1514: if (bExplore == TRUE) OpenVolumeExplorerWindow (szDriveLetter[0] - 'A');
1515: if (bQuiet) ExitProcess (0);
1516: }
1517: else if (bQuiet) ExitProcess (1);
1518:
1519: RefreshMainDlg(hwndDlg);
1520: }
1.1 root 1521: }
1522:
1.1.1.3 root 1523: if (bQuiet) ExitProcess (0);
1524:
1.1 root 1525: SetFocus (GetDlgItem (hwndDlg, IDC_DRIVELIST));
1526: }
1527: return 0;
1528:
1529: case WM_SYSCOMMAND:
1530: if (lw == IDC_ABOUT)
1531: {
1532: DialogBox (hInst, MAKEINTRESOURCE (IDD_ABOUT_DLG), hwndDlg, (DLGPROC) AboutDlgProc);
1533: return 1;
1534: }
1535: return 0;
1536:
1537: case WM_HELP:
1538: OpenPageHelp (hwndDlg);
1539: return 1;
1540:
1541: case WM_NOTIFY:
1542: // Single click in drive list
1543: if (((LPNMHDR) lParam)->code == LVN_ITEMCHANGED && (((LPNMLISTVIEW) lParam)->uNewState & LVIS_FOCUSED ))
1544: {
1545: nSelectedDriveIndex = ((LPNMLISTVIEW) lParam)->iItem;
1546: EnableDisableButtons (hwndDlg);
1547:
1548: return 1;
1549: }
1550:
1551: // Double click in drive list
1552: if (((LPNMHDR) lParam)->code == LVN_ITEMACTIVATE)
1553: {
1554: int state = GetItemLong(GetDlgItem (hwndDlg, IDC_DRIVELIST), ((LPNMITEMACTIVATE)lParam)->iItem );
1555: nSelectedDriveIndex = ((LPNMITEMACTIVATE)lParam)->iItem;
1556: if (LOWORD(state) == VMOUNTED)
1557: {
1558: // Open explorer window for mounted volume
1559: ArrowWaitCursor ();
1560: OpenVolumeExplorerWindow (HIWORD(state) - 'A');
1561: NormalCursor ();
1562: }
1563: else if (LOWORD (GetSelectedLong (GetDlgItem (hwndDlg, IDC_DRIVELIST))) == VFREE)
1564: {
1565: Mount (hwndDlg);
1566: }
1567: }
1568: return 0;
1569:
1570: case WM_ERASEBKGND:
1571: return 0;
1572:
1573: case WM_COMMAND:
1574:
1575: if (lw == IDCANCEL)
1576: {
1577: EndMainDlg (hwndDlg);
1578: return 1;
1579: }
1580:
1581: if (lw == IDHELP || lw == IDM_HELP)
1582: {
1583: OpenPageHelp (hwndDlg);
1584: return 1;
1585: }
1586:
1587: if (lw == IDM_ABOUT || lw == IDB_LOGO)
1588: {
1589: DialogBox (hInst, MAKEINTRESOURCE (IDD_ABOUT_DLG), hwndDlg, (DLGPROC) AboutDlgProc);
1590: return 1;
1591: }
1592:
1593: if ((lw == IDOK || lw == ID_MOUNT_VOLUME)
1594: && LOWORD (GetSelectedLong (GetDlgItem (hwndDlg, IDC_DRIVELIST))) == VFREE)
1595: {
1596:
1597: Mount (hwndDlg);
1598: return 1;
1599: }
1600:
1601: if ((lw == IDOK || lw == ID_MOUNT_VOLUME || lw == IDC_MOUNTALL)
1602: && LOWORD (GetSelectedLong (GetDlgItem (hwndDlg, IDC_DRIVELIST))) == 0xffff)
1603: {
1604: MessageBox (hwndDlg, "No drive selected.","TrueCrypt", MB_ICONEXCLAMATION);
1605: return 1;
1606: }
1607:
1608: if (lw == IDOK && LOWORD (GetSelectedLong (GetDlgItem (hwndDlg, IDC_DRIVELIST))) == VMOUNTED
1609: || lw == ID_UNMOUNT_VOLUME)
1610: {
1.1.1.2 root 1611: Dismount (hwndDlg, 0);
1.1 root 1612: return 1;
1613: }
1614:
1615: if (lw == IDUNMOUNTALL)
1616: {
1617: DismountAll (hwndDlg);
1618: return 1;
1619: }
1620:
1621: if (lw == IDC_MOUNTALL)
1622: {
1623: MountAllPartitions (hwndDlg);
1624: return 1;
1625: }
1626:
1627: if (lw == IDC_BROWSE_FILES)
1628: {
1629: SelectContainer (hwndDlg);
1630: return 1;
1631: }
1632:
1633: if (lw == IDC_BROWSE_DEVICES)
1634: {
1635: SelectPartition (hwndDlg);
1636: return 1;
1637: }
1638:
1639: if (lw == IDC_CHANGE_PASSWORD)
1640: {
1641: ChangePassword (hwndDlg);
1642: return 1;
1643: }
1644:
1645: if (lw == IDC_WIPE_CACHE)
1646: {
1647: WipeCache (hwndDlg);
1648: return 1;
1649: }
1650:
1651: if (lw == IDC_CLEAR_HISTORY)
1652: {
1653: ClearCombo (GetDlgItem (hwndDlg, IDC_VOLUME));
1654: DumpCombo (GetDlgItem (hwndDlg, IDC_VOLUME), "LastMountedVolume", TRUE);
1655: EnableDisableButtons (hwndDlg);
1656: return 1;
1657: }
1658:
1659: if (lw == IDC_CREATE_VOLUME)
1660: {
1661: char t[TC_MAX_PATH];
1662: char *tmp;
1663:
1664: GetModuleFileName (NULL, t, sizeof (t));
1665: tmp = strrchr (t, '\\');
1666: if (tmp)
1667: {
1668: strcpy (++tmp, "TrueCrypt Format.exe");
1669: ShellExecute (NULL, "open", t, NULL, NULL, SW_SHOWNORMAL);
1670: }
1671: return 1;
1672: }
1673:
1.1.1.3 root 1674: if (lw == ID_LICENSE)
1675: {
1676: char t[TC_MAX_PATH];
1677: char *tmp;
1678:
1679: GetModuleFileName (NULL, t, sizeof (t));
1680: tmp = strrchr (t, '\\');
1681: if (tmp)
1682: {
1683: strcpy (++tmp, "license.txt");
1684: ShellExecute (NULL, "open", t, NULL, NULL, SW_SHOWNORMAL);
1685: }
1686: return 1;
1687: }
1688:
1.1 root 1689: if (lw == ID_WEBSITE)
1690: {
1.1.1.4 ! root 1691: ShellExecute (NULL, "open", "http://truecrypt.sourceforge.net/applink.php?version="VERSION_STRING, NULL, NULL, SW_SHOWNORMAL);
1.1 root 1692: return 1;
1693: }
1.1.1.3 root 1694:
1.1 root 1695: if (lw == ID_PREFERENCES)
1696: {
1697: DialogBoxParam (hInst,
1698: MAKEINTRESOURCE (IDD_PREFERENCES_DLG), hwndDlg,
1699: (DLGPROC) PreferencesDlgProc, (LPARAM) 0);
1700: return 1;
1701: }
1702:
1703: if (lw == IDC_VOLUME_PROPERTIES)
1704: {
1705: DialogBoxParam (hInst,
1706: MAKEINTRESOURCE (IDD_VOLUME_PROPERTIES), hwndDlg,
1707: (DLGPROC) VolumePropertiesDlgProc, (LPARAM) 0);
1708: return 1;
1709: }
1710:
1711: if (lw == IDC_VOLUME && hw == CBN_EDITCHANGE)
1712: {
1713: PostMessage (hwndDlg, WM_USER, 0, 0);
1714: return 1;
1715: }
1716:
1717: if (lw == IDC_VOLUME && hw == CBN_SELCHANGE)
1718: {
1719: UpdateComboOrder (GetDlgItem (hwndDlg, IDC_VOLUME));
1720: MoveEditToCombo ((HWND) lParam);
1721: PostMessage (hwndDlg, WM_USER, 0, 0);
1722: return 1;
1723: }
1724:
1725: return 0;
1726:
1727: case WM_USER:
1728: EnableDisableButtons (hwndDlg);
1729: return 1;
1730:
1731: case WM_CLOSE:
1732: EndMainDlg (hwndDlg);
1733: return 1;
1734: }
1735:
1736: return 0;
1737: }
1738:
1739: void
1740: ExtractCommandLine (HWND hwndDlg, char *lpszCommandLine)
1741: {
1742: char **lpszCommandLineArgs; /* Array of command line arguments */
1743: int nNoCommandLineArgs; /* The number of arguments in the array */
1744:
1745: /* Extract command line arguments */
1746: nNoCommandLineArgs = Win32CommandLine (lpszCommandLine, &lpszCommandLineArgs);
1747: if (nNoCommandLineArgs > 0)
1748: {
1749: int i;
1750:
1751: for (i = 0; i < nNoCommandLineArgs; i++)
1752: {
1753: argument args[]=
1754: {
1755: {"/volume", "/v"},
1756: {"/letter", "/l"},
1757: {"/explore", "/e"},
1758: {"/beep", "/b"},
1759: {"/password", "/p"},
1760: {"/auto", "/a"},
1761: {"/cache", "/c"},
1762: {"/history", "/h"},
1.1.1.2 root 1763: {"/wipecache", "/w"},
1.1 root 1764: {"/quiet", "/q"},
1765: {"/help", "/?"},
1.1.1.2 root 1766: {"/dismount", "/d"}
1.1 root 1767: };
1768:
1769: argumentspec as;
1770:
1771: int nArgPos;
1772: int x;
1773:
1774: as.args = args;
1775: as.arg_cnt = sizeof(args)/ sizeof(args[0]);
1776:
1777: x = GetArgumentID (&as, lpszCommandLineArgs[i], &nArgPos);
1778:
1779: switch (x)
1780: {
1781: case 'd':
1.1.1.2 root 1782:
1783: if (HAS_ARGUMENT == GetArgumentValue (lpszCommandLineArgs, nArgPos, &i, nNoCommandLineArgs,
1784: szDriveLetter, sizeof (szDriveLetter)))
1785: Dismount (hwndDlg, (char)toupper(szDriveLetter[0]) - 'A');
1786: else
1787: DismountAll (hwndDlg);
1788:
1.1 root 1789: break;
1790:
1791: case 'v':
1792: if (HAS_ARGUMENT == GetArgumentValue (lpszCommandLineArgs, nArgPos, &i,
1793: nNoCommandLineArgs, szFileName, sizeof (szFileName)))
1.1.1.2 root 1794: {
1795: // Relative path must be converted to absolute
1796: if (szFileName[0] != '\\' && strchr (szFileName, ':') == 0)
1797: {
1798: char path[MAX_PATH*2];
1799: GetCurrentDirectory (MAX_PATH, path);
1800: strcat (path, "\\");
1801: strcat (path, szFileName);
1802: strncpy (szFileName, path, MAX_PATH-1);
1803: }
1.1 root 1804: AddComboItem (GetDlgItem (hwndDlg, IDC_VOLUME), szFileName);
1.1.1.2 root 1805: }
1.1 root 1806: break;
1807:
1808: case 'l':
1809: GetArgumentValue (lpszCommandLineArgs, nArgPos, &i, nNoCommandLineArgs,
1810: szDriveLetter, sizeof (szDriveLetter));
1811: *szDriveLetter = (char) toupper (*szDriveLetter);
1812: break;
1813:
1814: case 'e':
1815: bExplore = TRUE;
1816: break;
1817:
1818: case 'b':
1819: bBeep = TRUE;
1820: break;
1821:
1822: case 'p':
1.1.1.2 root 1823: GetArgumentValue (lpszCommandLineArgs, nArgPos, &i, nNoCommandLineArgs,
1824: commandLinePassword, sizeof (commandLinePassword));
1.1 root 1825: break;
1826:
1827: case 'a':
1828: bAuto = TRUE;
1829: break;
1830:
1831: case 'c':
1832: {
1833: char szTmp[8];
1834: GetArgumentValue (lpszCommandLineArgs, nArgPos, &i, nNoCommandLineArgs,
1835: szTmp, sizeof (szTmp));
1836: if (!_stricmp(szTmp,"y") || !_stricmp(szTmp,"yes"))
1837: bCacheInDriver = TRUE;
1838: if (!_stricmp(szTmp,"n") || !_stricmp(szTmp,"no"))
1839: bCacheInDriver = FALSE;
1840: }
1841: break;
1842:
1843: case 'h':
1844: {
1845: char szTmp[8];
1846: GetArgumentValue (lpszCommandLineArgs, nArgPos, &i, nNoCommandLineArgs,
1847: szTmp, sizeof (szTmp));
1848: if (!_stricmp(szTmp,"y") || !_stricmp(szTmp,"yes"))
1849: {
1850: bHistory = TRUE;
1851: bHistoryCmdLine = TRUE;
1852: }
1853:
1854: if (!_stricmp(szTmp,"n") || !_stricmp(szTmp,"no"))
1855: {
1856: bHistory = FALSE;
1857: bHistoryCmdLine = TRUE;
1858: }
1859: }
1860: break;
1861:
1862: case 'w':
1863: bWipe = TRUE;
1864: break;
1865:
1866: case 'q':
1867: bQuiet = TRUE;
1868: break;
1869:
1870: case '?':
1871: DialogBoxParam (hInst, MAKEINTRESOURCE (IDD_COMMANDHELP_DLG), hwndDlg, (DLGPROC)
1872: CommandHelpDlgProc, (LPARAM) &as);
1873: exit(0);
1874: break;
1875:
1876: // no option = file name
1877: default:
1.1.1.2 root 1878: {
1879: strncpy (szFileName, lpszCommandLineArgs[0], MAX_PATH-1);
1880: if (szFileName[0] != '\\' && strchr (szFileName, ':') == 0)
1881: {
1882: char path[MAX_PATH*2];
1883: GetCurrentDirectory (MAX_PATH, path);
1884: strcat (path, "\\");
1885: strcat (path, szFileName);
1886: strncpy (szFileName, path, MAX_PATH-1);
1887: }
1888: AddComboItem (GetDlgItem (hwndDlg, IDC_VOLUME), szFileName);
1889: }
1.1 root 1890: }
1891: }
1892: }
1893:
1894: /* Free up the command line arguments */
1895: while (--nNoCommandLineArgs >= 0)
1896: {
1897: free (lpszCommandLineArgs[nNoCommandLineArgs]);
1898: }
1899: }
1900:
1901: int WINAPI
1902: WINMAIN (HINSTANCE hInstance, HINSTANCE hPrevInstance, char *lpszCommandLine,
1903: int nCmdShow)
1904: {
1905: int status;
1906:
1907: if (nCmdShow && hPrevInstance); /* Remove unused parameter warning */
1908:
1909: atexit (localcleanup);
1910:
1911: /* Allocate, dup, then store away the application title */
1912: lpszTitle = err_strdup (getstr (IDS_TITLE));
1913:
1914: /* Call InitApp to initialize the common code */
1915: InitApp (hInstance);
1916:
1917: status = DriverAttach ();
1918: if (status != 0)
1919: {
1920: if (status == ERR_OS_ERROR)
1921: handleWin32Error (NULL);
1922: else
1923: handleError (NULL, status);
1924:
1925: AbortProcess (IDS_NODRIVER);
1926: }
1927:
1928: /* Create the main dialog box */
1929: DialogBoxParam (hInstance, MAKEINTRESOURCE (IDD_MOUNT_DLG), NULL, (DLGPROC) MainDialogProc,
1930: (LPARAM) lpszCommandLine);
1931:
1932: /* Terminate */
1933: return 0;
1934: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.