mount.c

加密硬盘、分区、虚拟盘的程序源码

		NormalCursor ();

		if (bResult == FALSE)
		{
			handleWin32Error (hwndDlg);
		}
		else
		{
			DWORD os_err = 0;
			int err = 0;

			sscanf (inbuf, "%s %d %lu", outbuf, &err, &os_err);

			if (*inbuf == '-')
			{
				//if (err == ERR_OS_ERROR)
				//{
				//	SetLastError (os_err);

				//	handleWin32Error (hwndDlg);
				//}
				//else
				//{
				//	handleError (hwndDlg, err);
				//}

				RefreshMainDlg(hwndDlg);
				MessageBox(0, getstr (IDS_UNMOUNT_FAILED), lpszTitle, MB_ICONEXCLAMATION);
			}
			else
			{
				if (bBeep == TRUE)
					MessageBeep (MB_OK);
			}
		}
	}
	else
	{
		DWORD os_error;
		int i, err;

		for (i=0; i<26; i++)
			CloseSlot (i, 0, &err);
	}

	RefreshMainDlg (hwndDlg);
	NormalCursor();
}

static void MountAllPartitions (HWND hwndDlg)
{
	HWND driveList = GetDlgItem (hwndDlg, IDC_DRIVELIST);
	int i, n, selDrive = ListView_GetSelectionMark (driveList);
	char szPassword[MAX_PASSWORD + 1];

	// User is always asked for password as we can't tell 
	// for sure if it is needed or not
	burn (szPassword, sizeof (szPassword));
	if (!AskUserPassword (hwndDlg, szPassword))
		return;

	ArrowWaitCursor();
	
	for (i = 0; i < 64; i++)
	{
		BOOL drivePresent = FALSE;

		for (n = 1; n <= 32; n++)
		{
			char szFileName[TC_MAX_PATH];
			OPEN_TEST_STRUCT driver;

			sprintf (szFileName, "\\Device\\Harddisk%d\\Partition%d", i, n);
			if (OpenDevice (szFileName, &driver) == TRUE && !IsMountedVolume (szFileName))
			{	
				int nDosDriveNo;

				while (LOWORD (GetItemLong (driveList, selDrive)) != 0xffff)
				{
					if(LOWORD (GetItemLong (driveList, selDrive)) != VFREE)
					{
						selDrive++;
						continue;
					}
					nDosDriveNo = HIWORD(GetItemLong (driveList, selDrive)) - 'A';
					break;
				}

				if (LOWORD (GetItemLong (driveList, selDrive)) == 0xffff)
					goto ret;

				// First try user password then cached passwords
				if (MountVolume (hwndDlg, nDosDriveNo, szFileName, szPassword, TRUE)
					|| MountVolume (hwndDlg, nDosDriveNo, szFileName, "", TRUE))
				{
					LoadDriveLetters (driveList, (HIWORD (GetItemLong (GetDlgItem (hwndDlg, IDC_DRIVELIST), selDrive))));
					selDrive++;

					if (bExplore == TRUE)
					{	
						ArrowWaitCursor();
						OpenVolumeExplorerWindow (nDosDriveNo);
						NormalCursor();
					}
				}
			}
		}
	}

ret:
	burn (szPassword, sizeof (szPassword));
	EnableDisableButtons (hwndDlg);
	NormalCursor();
}

static void ChangePassword (HWND hwndDlg)
{
	int result;
	
	GetWindowText (GetDlgItem (hwndDlg, IDC_VOLUME), szFileName, sizeof (szFileName));
	if (IsMountedVolume (szFileName))
	{
		MessageBox (hwndDlg, getstr (IDS_MOUNTED_NOPWCHANGE), lpszTitle, MB_ICONEXCLAMATION);
		return;
	}

	result = DialogBox (hInst, MAKEINTRESOURCE (IDD_PASSWORDCHANGE_DLG), hwndDlg,
		(DLGPROC) PasswordChangeDlgProc);

	if (result == IDOK)
	{
		HWND tmp = GetDlgItem (hwndDlg, IDC_PASSWORD);
		MessageBox (hwndDlg, getstr (IDS_PASSWORD_CHANGED), lpszTitle, MB_ICONASTERISK);
		SetFocus (tmp);
	}
}

static void SelectContainer (HWND hwndDlg)
{
	if (BrowseFiles (hwndDlg, IDS_OPEN_TITLE, szFileName) == FALSE)
		return;

	AddComboItem (GetDlgItem (hwndDlg, IDC_VOLUME), szFileName);
	EnableDisableButtons (hwndDlg);
	SetFocus (GetDlgItem (hwndDlg, IDC_PASSWORD));
}

static void SelectPartition (HWND hwndDlg)
{
	int nResult = DialogBoxParam (hInst, MAKEINTRESOURCE (IDD_RAWDEVICES_DLG), hwndDlg,
		(DLGPROC) RawDevicesDlgProc, (LPARAM) & szFileName[0]);
	if (nResult == IDOK)
	{
		AddComboItem (GetDlgItem (hwndDlg, IDC_VOLUME), szFileName);
		EnableDisableButtons (hwndDlg);
		SetFocus (GetDlgItem (hwndDlg, IDC_PASSWORD));
	}
}

static void WipeCache (HWND hwndDlg)
{
	DWORD dwResult;
	BOOL bResult;

	bResult = DeviceIoControl (hDriver, WIPE_CACHE, NULL, 0, NULL, 0, &dwResult, NULL);

	if (bResult == FALSE)
		handleWin32Error (hwndDlg);
	else
	{
		EnableDisableButtons (hwndDlg);

		if (bQuiet == FALSE)
			MessageBox (hwndDlg, getstr (IDS_WIPE_CACHE), lpszTitle, MB_ICONINFORMATION);
	}
}


/* Except in response to the WM_INITDIALOG message, the dialog box procedure
   should return nonzero if it processes the message, and zero if it does
   not. - see DialogProc */
BOOL CALLBACK
MainDialogProc (HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
	WORD lw = LOWORD (wParam);
	WORD hw = HIWORD (wParam);
	if (lParam);		/* remove warning */

	switch (uMsg)
	{

	case WM_INITDIALOG:
		{
			LoadSettings (hwndDlg);

			/* Call the common dialog init code */
			InitDialog (hwndDlg);
			SetDefaultUserFont (hwndDlg);

			SendMessage (GetDlgItem (hwndDlg, IDC_VOLUME), CB_LIMITTEXT, TC_MAX_PATH, 0);

			SendMessage (GetDlgItem (hwndDlg, IDC_NO_DRIVES_STATIC), WM_SETFONT, (WPARAM) hBoldFont, (LPARAM) TRUE);
			SetWindowText (hwndDlg, lpszTitle);

			BuildTree (GetDlgItem (hwndDlg, IDC_DRIVELIST));

			ExtractCommandLine (hwndDlg, (char *) lParam);

			if (*szDriveLetter != 0)
			{
				SelectItem (GetDlgItem (hwndDlg, IDC_DRIVELIST), *szDriveLetter);

				if(nSelectedDriveIndex > SendMessage (GetDlgItem (hwndDlg, IDC_DRIVELIST), LVM_GETITEMCOUNT, 0, 0)/2) 
					SendMessage(GetDlgItem (hwndDlg, IDC_DRIVELIST), LVM_SCROLL, 0, 1000);
			}

			SendMessage (GetDlgItem (hwndDlg, IDC_NO_HISTORY), BM_SETCHECK, bHistory ? BST_UNCHECKED : BST_CHECKED, 0);

			EnableDisableButtons (hwndDlg);

			if (bWipe == TRUE)
			{
				SendMessage (GetDlgItem (hwndDlg, IDC_WIPE_CACHE), BM_CLICK, 0, 0);
			}

			if (bAuto == TRUE && IsWindowEnabled (GetDlgItem (hwndDlg, IDOK)))
			{
				SendMessage (GetDlgItem (hwndDlg, IDOK), BM_CLICK, 0, 0);
			}

			SetFocus (GetDlgItem (hwndDlg, IDC_DRIVELIST));
		}
		return 0;

	case WM_SYSCOMMAND:
		if (lw == IDC_ABOUT)
		{
			DialogBox (hInst, MAKEINTRESOURCE (IDD_ABOUT_DLG), hwndDlg, (DLGPROC) AboutDlgProc);
			return 1;
		}
		return 0;

	case WM_HELP:
		OpenPageHelp (hwndDlg);
		return 1;

	case WM_NOTIFY:
		// Single click in drive list
		if (((LPNMHDR) lParam)->code == LVN_ITEMCHANGED && (((LPNMLISTVIEW) lParam)->uNewState & LVIS_FOCUSED ))
		{
			nSelectedDriveIndex = ((LPNMLISTVIEW) lParam)->iItem;
			EnableDisableButtons (hwndDlg);

			return 1;
		}

		// Double click in drive list
		if (((LPNMHDR) lParam)->code == LVN_ITEMACTIVATE)
		{
			int state = GetItemLong(GetDlgItem (hwndDlg, IDC_DRIVELIST), ((LPNMITEMACTIVATE)lParam)->iItem );
			nSelectedDriveIndex = ((LPNMITEMACTIVATE)lParam)->iItem;
			if (LOWORD(state) == VMOUNTED)
			{
				// Open explorer window for mounted volume
				ArrowWaitCursor ();
				OpenVolumeExplorerWindow (HIWORD(state) - 'A');
				NormalCursor ();
			}
			else if (LOWORD (GetSelectedLong (GetDlgItem (hwndDlg, IDC_DRIVELIST))) == VFREE)
			{
				Mount (hwndDlg);
			}
		}
		return 0;

	case WM_ERASEBKGND:
		return 0;

	case WM_COMMAND:

		if (lw == IDCANCEL)
		{
			EndMainDlg (hwndDlg);
			return 1;
		}

		if (lw == IDHELP || lw == IDM_HELP)
		{
			OpenPageHelp (hwndDlg);
			return 1;
		}

		if (lw == IDM_ABOUT || lw == IDB_LOGO)
		{
			DialogBox (hInst, MAKEINTRESOURCE (IDD_ABOUT_DLG), hwndDlg, (DLGPROC) AboutDlgProc);
			return 1;
		}

		if ((lw == IDOK || lw == ID_MOUNT_VOLUME) 
			&& LOWORD (GetSelectedLong (GetDlgItem (hwndDlg, IDC_DRIVELIST))) == VFREE)
		{

			Mount (hwndDlg);
			return 1;
		}

		if ((lw == IDOK || lw == ID_MOUNT_VOLUME || lw == IDC_MOUNTALL) 
			&& LOWORD (GetSelectedLong (GetDlgItem (hwndDlg, IDC_DRIVELIST))) == 0xffff)
		{
			MessageBox (hwndDlg, "No drive selected.","TrueCrypt", MB_ICONEXCLAMATION);
			return 1;
		}

		if (lw == IDOK && LOWORD (GetSelectedLong (GetDlgItem (hwndDlg, IDC_DRIVELIST))) == VMOUNTED
			|| lw == ID_UNMOUNT_VOLUME)
		{
			Dismount (hwndDlg);
			return 1;
		}

		if (lw == IDUNMOUNTALL)
		{
			DismountAll (hwndDlg);
			return 1;
		}

		if (lw == IDC_MOUNTALL)
		{
			MountAllPartitions (hwndDlg);
			return 1;
		}
		
		if (lw == IDC_BROWSE_FILES)
		{
			SelectContainer (hwndDlg);
			return 1;
		}

		if (lw == IDC_BROWSE_DEVICES)
		{
			SelectPartition (hwndDlg);
			return 1;
		}

		if (lw == IDC_CHANGE_PASSWORD)
		{
			ChangePassword (hwndDlg);
			return 1;
		}

		if (lw == IDC_WIPE_CACHE)
		{
			WipeCache (hwndDlg);
			return 1;
		}

		if (lw == IDC_CLEAR_HISTORY)
		{
			ClearCombo (GetDlgItem (hwndDlg, IDC_VOLUME));
			DumpCombo (GetDlgItem (hwndDlg, IDC_VOLUME), "LastMountedVolume", TRUE);
			EnableDisableButtons (hwndDlg);
			return 1;
		}

		if (lw == IDC_CREATE_VOLUME)
		{
			char t[TC_MAX_PATH];
			char *tmp;

			GetModuleFileName (NULL, t, sizeof (t));
			tmp = strrchr (t, '\\');
			if (tmp)
			{
				strcpy (++tmp, "TrueCrypt Format.exe");
				ShellExecute (NULL, "open", t, NULL, NULL, SW_SHOWNORMAL);
			}
			return 1;
		}

		if (lw == ID_WEBSITE)
		{
			ShellExecute (NULL, "open", "http://www.truecrypt.org", NULL, NULL, SW_SHOWNORMAL);
			return 1;
		}
		
		if (lw == ID_PREFERENCES)
		{
			DialogBoxParam (hInst, 
				MAKEINTRESOURCE (IDD_PREFERENCES_DLG), hwndDlg,
				(DLGPROC) PreferencesDlgProc, (LPARAM) 0);
			return 1;
		}

		if (lw == IDC_VOLUME_PROPERTIES)
		{
			DialogBoxParam (hInst, 
				MAKEINTRESOURCE (IDD_VOLUME_PROPERTIES), hwndDlg,
				(DLGPROC) VolumePropertiesDlgProc, (LPARAM) 0);
			return 1;
		}

		if (lw == IDC_VOLUME && hw == CBN_EDITCHANGE)
		{
			PostMessage (hwndDlg, WM_USER, 0, 0);
			return 1;
		}

		if (lw == IDC_VOLUME && hw == CBN_SELCHANGE)
		{
			UpdateComboOrder (GetDlgItem (hwndDlg, IDC_VOLUME));
			MoveEditToCombo ((HWND) lParam);
			PostMessage (hwndDlg, WM_USER, 0, 0);
			return 1;
		}

		return 0;

	case WM_USER:
		EnableDisableButtons (hwndDlg);
		return 1;

	case WM_CLOSE:
		EndMainDlg (hwndDlg);
		return 1;
	}

	return 0;
}

void
ExtractCommandLine (HWND hwndDlg, char *lpszCommandLine)
{
	char **lpszCommandLineArgs;	/* Array of command line arguments */
	int nNoCommandLineArgs;	/* The number of arguments in the array */

	/* Extract command line arguments */
	nNoCommandLineArgs = Win32CommandLine (lpszCommandLine, &lpszCommandLineArgs);
	if (nNoCommandLineArgs > 0)
	{
		int i;

		for (i = 0; i < nNoCommandLineArgs; i++)
		{
			argument args[]=
			{
				{"/volume", "/v"},
				{"/letter", "/l"},
				{"/explore", "/e"},
				{"/beep", "/b"},
				{"/password", "/p"},
				{"/auto", "/a"},
				{"/cache", "/c"},
				{"/history", "/h"},
				{"/wipecache", "/wc"},
				{"/quiet", "/q"},
				{"/help", "/?"},
				{"/dismountall", "/d"}
			};

			argumentspec as;

			int nArgPos;
			int x;

			as.args = args;
			as.arg_cnt = sizeof(args)/ sizeof(args[0]);
			
			x = GetArgumentID (&as, lpszCommandLineArgs[i], &nArgPos);

			switch (x)
			{
			case 'd':
				DismountAll (hwndDlg);
				ExitProcess (0);
				break;

			case 'v':
				if (HAS_ARGUMENT == GetArgumentValue (lpszCommandLineArgs, nArgPos, &i,
								      nNoCommandLineArgs, szFileName, sizeof (szFileName)))
					AddComboItem (GetDlgItem (hwndDlg, IDC_VOLUME), szFileName);
				break;

			case 'l':
				GetArgumentValue (lpszCommandLineArgs, nArgPos, &i, nNoCommandLineArgs,
				     szDriveLetter, sizeof (szDriveLetter));
				*szDriveLetter = (char) toupper (*szDriveLetter);
				break;

			case 'e':
				bExplore = TRUE;
				break;

			case 'b':
				bBeep = TRUE;
				break;

			case 'p':
				{
					char szTmp[MAX_PASSWORD + 1];
					
					GetArgumentValue (lpszCommandLineArgs, nArgPos, &i, nNoCommandLineArgs,
						     szTmp, sizeof (szTmp));

					if (strlen(szTmp) == 1 && *szTmp == '?') 
					{

						int result = DialogBoxParam (hInst, 
									MAKEINTRESOURCE (IDD_PASSWORD_DLG), hwndDlg,
					   				(DLGPROC) PasswordDlgProc, (LPARAM) szTmp);

						if (result != IDOK)
							*szTmp = 0;
					}

					SetWindowText (GetDlgItem (hwndDlg, IDC_PASSWORD), szTmp);
					burn (szTmp, sizeof (szTmp));
				}
				break;

			case 'a':
				bAuto = TRUE;
				break;

			case 'c':
				{
					char szTmp[8];
					GetArgumentValue (lpszCommandLineArgs, nArgPos, &i, nNoCommandLineArgs,
						     szTmp, sizeof (szTmp));
					if (!_stricmp(szTmp,"y") || !_stricmp(szTmp,"yes"))
						bCacheInDriver = TRUE;
					if (!_stricmp(szTmp,"n") || !_stricmp(szTmp,"no"))
						bCacheInDriver = FALSE;
				}
				break;

			case 'h':
				{
					char szTmp[8];
					GetArgumentValue (lpszCommandLineArgs, nArgPos, &i, nNoCommandLineArgs,
						     szTmp, sizeof (szTmp));
					if (!_stricmp(szTmp,"y") || !_stricmp(szTmp,"yes"))
					{
						bHistory = TRUE;
						bHistoryCmdLine = TRUE;
					}

					if (!_stricmp(szTmp,"n") || !_stricmp(szTmp,"no"))
					{
						bHistory = FALSE;
						bHistoryCmdLine = TRUE;
					}
				}
				break;

			case 'w':
				bWipe = TRUE;
				break;

			case 'q':
				bQuiet = TRUE;
				break;

			case '?':
				DialogBoxParam (hInst, MAKEINTRESOURCE (IDD_COMMANDHELP_DLG), hwndDlg, (DLGPROC)
						CommandHelpDlgProc, (LPARAM) &as);
				exit(0);
				break;

				// no option = file name
			default:
					AddComboItem (GetDlgItem (hwndDlg, IDC_VOLUME), lpszCommandLineArgs[0]);
			}
		}
	}

	/* Free up the command line arguments */
	while (--nNoCommandLineArgs >= 0)
	{
		free (lpszCommandLineArgs[nNoCommandLineArgs]);
	}
}

int WINAPI
WINMAIN (HINSTANCE hInstance, HINSTANCE hPrevInstance, char *lpszCommandLine,
	 int nCmdShow)
{
	int status;

	if (nCmdShow && hPrevInstance);	/* Remove unused parameter warning */

	atexit (localcleanup);

	/* Allocate, dup, then store away the application title */
	lpszTitle = err_strdup (getstr (IDS_TITLE));

	/* Call InitApp to initialize the common code */
	InitApp (hInstance);

	status = DriverAttach ();
	if (status != 0)
	{
		if (status == ERR_OS_ERROR)
			handleWin32Error (NULL);
		else
			handleError (NULL, status);

		AbortProcess (IDS_NODRIVER);
	}

	/* Create the main dialog box */
	DialogBoxParam (hInstance, MAKEINTRESOURCE (IDD_MOUNT_DLG), NULL, (DLGPROC) MainDialogProc,
			(LPARAM) lpszCommandLine);

	/* Terminate */
	return 0;
}