/*++ Copyright (c) 1993-1994 Microsoft Corporation Module Name: fmifs.c Abstract: This module contains the set of routines that work with the fmifs.dll Author: Bob Rinne (bobri) 11/15/93 Environment: User process. Notes: Revision History: --*/ #include "fdisk.h" #include "shellapi.h" #include "fmifs.h" #include #include // // defines unique to this module // #define FS_CANCELUPDATE (WM_USER + 0) #define FS_FINISHED (WM_USER + 1) BOOLEAN FmIfsCallback( IN FMIFS_PACKET_TYPE PacketType, IN DWORD PacketLength, IN PVOID PacketData ); // // Externals needed for IFS Dll support (format and label) // HINSTANCE IfsDllHandle = NULL; PFMIFS_FORMAT_ROUTINE FormatRoutine = NULL; PFMIFS_SETLABEL_ROUTINE LabelRoutine = NULL; #ifdef DOUBLE_SPACE_SUPPORT_INCLUDED PFMIFS_DOUBLESPACE_CREATE_ROUTINE DblSpaceCreateRoutine = NULL; PFMIFS_DOUBLESPACE_MOUNT_ROUTINE DblSpaceMountRoutine = NULL; PFMIFS_DOUBLESPACE_DELETE_ROUTINE DblSpaceDeleteRoutine = NULL; PFMIFS_DOUBLESPACE_DISMOUNT_ROUTINE DblSpaceDismountRoutine = NULL; PFMIFS_DOUBLESPACE_QUERY_INFO_ROUTINE DblSpaceQueryInfoRoutine = NULL; BOOLEAN DoubleSpaceSupported = TRUE; #endif // HACK HACK - clean this up if it works. #define SELECTED_REGION(i) (SelectedDS[i]->RegionArray[SelectedRG[i]]) #define MaxMembersInFtSet 32 extern DWORD SelectionCount; extern PDISKSTATE SelectedDS[MaxMembersInFtSet]; extern ULONG SelectedRG[MaxMembersInFtSet]; VOID setUnicode( char *astring, WCHAR *wstring ) /*++ Routine Description: Convert an ansii string to Unicode. Internal routine to fmifs module. Arguments: astring - ansii string to convert to Unicode wstring - resulting string location Return Value: None --*/ { int len = lstrlen(astring)+1; MultiByteToWideChar( CP_ACP, 0, astring, len, wstring, len ); } BOOL LoadIfsDll( VOID ) /*++ Routine Description: This routine will determine if the IFS Dll needs to be loaded. If so, it will load it and locate the format and label routines in the dll. Arguments: None Return Value: TRUE if Dll is loaded and the routines needed have been found FALSE if something fails --*/ { if (FormatRoutine) { // Library is already loaded and the routines needed // have been located. return TRUE; } IfsDllHandle = LoadLibrary(TEXT("fmifs.dll")); if (IfsDllHandle == (HANDLE)NULL) { // FMIFS not available. return FALSE; } // Library is loaded. Locate the two routines needed by // Disk Administrator. FormatRoutine = (PVOID)GetProcAddress(IfsDllHandle, "Format"); LabelRoutine = (PVOID)GetProcAddress(IfsDllHandle, "SetLabel"); if (!FormatRoutine || !LabelRoutine) { // something didn't get found so shut down all accesses // to the library by insuring FormatRoutine is NULL FreeLibrary(IfsDllHandle); FormatRoutine = NULL; return FALSE; } #ifdef DOUBLE_SPACE_SUPPORT_INCLUDED DblSpaceMountRoutine = (PVOID)GetProcAddress(IfsDllHandle, "DoubleSpaceMount"); DblSpaceDismountRoutine = (PVOID)GetProcAddress(IfsDllHandle, "DoubleSpaceDismount"); DblSpaceCreateRoutine = (PVOID)GetProcAddress(IfsDllHandle, "DoubleSpaceCreate"); DblSpaceDeleteRoutine = (PVOID)GetProcAddress(IfsDllHandle, "DoubleSpaceDelete"); DblSpaceQueryInfoRoutine = (PVOID)GetProcAddress(IfsDllHandle, "FmifsQueryDriveInformation"); if (!DblSpaceMountRoutine || !DblSpaceDismountRoutine || !DblSpaceQueryInfoRoutine) { // didn't get all of the DoubleSpace support routines // Allow format and label, just don't do DoubleSpace DoubleSpaceSupported = FALSE; } if (DblSpaceCreateRoutine && DblSpaceDeleteRoutine) { // Everything is there for read/write double space support. // This will change certain dialogs to allow creation and // deletion of double space volumes. IsFullDoubleSpace = TRUE; } #endif return TRUE; } VOID UnloadIfsDll( VOID ) /*++ Routine Description: This routine will free the FmIfs DLL if it was loaded. Arguments: None Return Value: None --*/ { if (FormatRoutine) { FreeLibrary(IfsDllHandle); FormatRoutine = NULL; IfsDllHandle = NULL; LabelRoutine = NULL; #ifdef DOUBLE_SPACE_SUPPORT_INCLUDED DblSpaceDismountRoutine = NULL; DblSpaceMountRoutine = NULL; DblSpaceCreateRoutine = NULL; DblSpaceDeleteRoutine = NULL; #endif } } PFORMAT_PARAMS ParamsForCallBack = NULL; BOOLEAN FmIfsCallback( IN FMIFS_PACKET_TYPE PacketType, IN DWORD PacketLength, IN PVOID PacketData ) /*++ Routine Description: This routine gets callbacks from fmifs.dll regarding progress and status of the ongoing format or doublespace create. It runs in the same thread as the format or create, which is a separate thread from the "cancel" button. If the user hits "cancel", this routine notices on the next callback and cancels the format or double space create. Arguments: [PacketType] -- an fmifs packet type [PacketLength] -- length of the packet data [PacketData] -- data associated with the packet Return Value: TRUE if the fmifs activity should continue, FALSE if the activity should halt immediately. Thus, we return FALSE if the user has hit "cancel" and we wish fmifs to clean up and return from the Format() entrypoint call. --*/ { PFORMAT_PARAMS formatParams = ParamsForCallBack; HWND hDlg = formatParams->DialogHwnd; // Quit if told to do so.. if (formatParams->Cancel) { formatParams->Result = MSG_FORMAT_CANCELLED; return FALSE; } switch (PacketType) { case FmIfsPercentCompleted: PostMessage(hDlg, FS_CANCELUPDATE, ((PFMIFS_PERCENT_COMPLETE_INFORMATION)PacketData)->PercentCompleted, 0); break; case FmIfsFormatReport: formatParams->TotalSpace = ((PFMIFS_FORMAT_REPORT_INFORMATION)PacketData)->KiloBytesTotalDiskSpace; formatParams->SpaceAvailable = ((PFMIFS_FORMAT_REPORT_INFORMATION)PacketData)->KiloBytesAvailable; break; case FmIfsIncompatibleFileSystem: formatParams->Result = MSG_INCOMPATIBLE_FILE_SYSTEM; break; case FmIfsInsertDisk: break; case FmIfsFormattingDestination: break; case FmIfsIncompatibleMedia: formatParams->Result = MSG_INCOMPATIBLE_MEDIA; break; case FmIfsAccessDenied: formatParams->Result = MSG_FORMAT_ACCESS_DENIED; break; case FmIfsMediaWriteProtected: formatParams->Result = MSG_WRITE_PROTECTED; break; case FmIfsCantLock: formatParams->Result = MSG_FORMAT_CANT_LOCK; break; case FmIfsBadLabel: formatParams->Result = MSG_BAD_LABEL; break; case FmIfsCantQuickFormat: formatParams->Result = MSG_CANT_QUICK_FORMAT; break; case FmIfsIoError: formatParams->Result = MSG_IO_ERROR; break; case FmIfsFinished: PostMessage(hDlg, FS_FINISHED, 0, 0); return FALSE; break; #ifdef DOUBLE_SPACE_SUPPORT_INCLUDED case FmIfsDblspaceCreateFailed: formatParams->Result = MSG_CANT_CREATE_DBLSPACE; break; case FmIfsDblspaceMountFailed: formatParams->Result = MSG_CANT_MOUNT_DBLSPACE; break; case FmIfsDblspaceDriveLetterFailed: formatParams->Result = MSG_DBLSPACE_LETTER_FAILED; break; case FmIfsDblspaceCreated: // Save the name of the double space file. if (formatParams->DblspaceFileName = (PWSTR) Malloc(PacketLength)) { memcpy(formatParams->DblspaceFileName, PacketData, PacketLength); } break; case FmIfsDblspaceMounted: break; #endif default: break; } return (formatParams->Result) ? FALSE : TRUE; } #ifdef DOUBLE_SPACE_SUPPORT_INCLUDED ULONG MountDismountResult; #define MOUNT_DISMOUNT_SUCCESS 0 BOOLEAN FmIfsMountDismountCallback( IN FMIFS_PACKET_TYPE PacketType, IN DWORD PacketLength, IN PVOID PacketData ) /*++ Routine Description: This routine gets callbacks from fmifs.dll regarding progress and status of the ongoing format or doublespace Arguments: [PacketType] -- an fmifs packet type [PacketLength] -- length of the packet data [PacketData] -- data associated with the packet Return Value: TRUE if the fmifs activity should continue, FALSE if the activity should halt immediately. Thus, we return FALSE if the user has hit "cancel" and we wish fmifs to clean up and return from the Format() entrypoint call. --*/ { switch (PacketType) { case FmIfsDblspaceMounted: MountDismountResult = MOUNT_DISMOUNT_SUCCESS; break; } return TRUE; } #endif VOID FormatVolume( IN PVOID ThreadParameter ) /*++ Routine Description: This routine converts the strings in the formatParams structure and calls the fmifs routines to perform the format. It assumes it is called by a separate thread and will exit the thread on completion of the format. Arguments: ThreadParameter - a pointer to the FORMAT_PARAMS structure Return Value: None --*/ { PFORMAT_PARAMS formatParams = (PFORMAT_PARAMS) ThreadParameter; PPERSISTENT_REGION_DATA regionData; DWORD index; WCHAR unicodeLabel[100], unicodeFsType[20], driveLetter[4]; // The fmifs interface doesn't allow for a context parameter // therefore the formatparams must be passed through an external. ParamsForCallBack = formatParams; // set up a unicode drive letter. regionData = (PPERSISTENT_REGION_DATA) formatParams->RegionData; driveLetter[1] = L':'; driveLetter[2] = 0; driveLetter[0] = (WCHAR) regionData->DriveLetter; // convert label to unicode setUnicode(formatParams->Label, unicodeLabel); // convert filesystem type to unicode for (index = 0; unicodeFsType[index] = (WCHAR)(formatParams->FileSystem[index]); index++) { // operation done in for loop } (*FormatRoutine)(driveLetter, FmMediaUnknown, unicodeFsType, unicodeLabel, (BOOLEAN)formatParams->QuickFormat, &FmIfsCallback); // Set the synchronization event to inform the windisk thread // that this is complete and all handles have been closed. formatParams->ThreadIsDone = 1; ExitThread(0L); } #ifdef DOUBLE_SPACE_SUPPORT_INCLUDED VOID FmIfsCreateDblspace( IN PVOID ThreadParameter ) /*++ Routine Description: This routine converts the strings in the formatParams structure and calls the fmifs routines to perform the double space create. It assumes it is called by a separate thread and will exit the thread on completion of the create. Arguments: ThreadParameter - a pointer to the FORMAT_PARAMS structure Return Value: None --*/ { PFORMAT_PARAMS formatParams = (PFORMAT_PARAMS) ThreadParameter; PPERSISTENT_REGION_DATA regionData; DWORD index; UCHAR letter; WCHAR unicodeLabel[100], newDriveLetter[4], driveLetter[4]; // The fmifs interface doesn't allow for a context parameter // therefore the formatparams must be passed through an external. ParamsForCallBack = formatParams; // set up a unicode drive letter. regionData = (PPERSISTENT_REGION_DATA) formatParams->RegionData; driveLetter[1] = L':'; driveLetter[2] = 0; driveLetter[0] = (WCHAR) regionData->DriveLetter; // set up the new letter newDriveLetter[1] = L':'; newDriveLetter[2] = 0; // Choose the first available. This should come from the dialog // newDriveLetter[0] = (WCHAR) formatParams->NewLetter; for (letter='C'; letter <= 'Z'; letter++) { if (DriveLetterIsAvailable((CHAR)letter)) { newDriveLetter[0] = (WCHAR) letter; break; } } // convert label to unicode setUnicode(formatParams->Label, unicodeLabel); (*DblSpaceCreateRoutine)(driveLetter, formatParams->SpaceAvailable * 1024 * 1024, unicodeLabel, newDriveLetter, &FmIfsCallback); ExitThread(0L); } BOOL FmIfsDismountDblspace( IN CHAR DriveLetter ) /*++ Routine Description: Convert the name provided into unicode and call the FmIfs support routine. Arguments: DriveLetter - the drive letter to dismount. Return Value: TRUE - it worked. --*/ { WCHAR unicodeLetter[4]; ULONG index; unicodeLetter[0] = (WCHAR) DriveLetter; unicodeLetter[1] = (WCHAR) ':'; unicodeLetter[2] = 0; // The only way to communicate with the fmifs callback // is through global externals. MountDismountResult = MSG_CANT_DISMOUNT_DBLSPACE; (*DblSpaceDismountRoutine)(unicodeLetter, &FmIfsMountDismountCallback); return MountDismountResult; } BOOL FmIfsMountDblspace( IN PCHAR FileName, IN CHAR HostDrive, IN CHAR NewDrive ) /*++ Routine Description: Convert the arguments into unicode characters and call the FmIfs support routine to mount the double space volume. Arguments: FileName - ASCII file name (i.e. dblspace.xxx) HostDrive - Drive drive letter containing double space volume NewDrive - Drive letter to be assigned to the volume Return Value: TRUE it worked. --*/ { WCHAR wideFileName[40]; WCHAR wideHostDrive[4]; WCHAR wideNewDrive[4]; ULONG index; // convert the double space file name. for (index = 0; wideFileName[index] = (WCHAR) FileName[index]; index++) { // all work done in for expression } // convert the drive names. wideNewDrive[1] = wideHostDrive[1] = (WCHAR) ':'; wideNewDrive[2] = wideHostDrive[2] = 0; wideNewDrive[0] = (WCHAR) NewDrive; wideHostDrive[0] = (WCHAR) HostDrive; // The only way to communicate with the fmifs callback // is through global externals. MountDismountResult = MSG_CANT_MOUNT_DBLSPACE; (*DblSpaceMountRoutine)(wideHostDrive, wideFileName, wideNewDrive, &FmIfsMountDismountCallback); return MountDismountResult; } BOOLEAN FmIfsQueryInformation( IN PWSTR DosDriveName, OUT PBOOLEAN IsRemovable, OUT PBOOLEAN IsFloppy, OUT PBOOLEAN IsCompressed, OUT PBOOLEAN Error, OUT PWSTR NtDriveName, IN ULONG MaxNtDriveNameLength, OUT PWSTR CvfFileName, IN ULONG MaxCvfFileNameLength, OUT PWSTR HostDriveName, IN ULONG MaxHostDriveNameLength ) /*++ Routine Description: Call through the pointer to the routine in the fmifs dll. Arguments: Same as the Fmifs routine in the DLL. Return Value: --*/ { if (!DblSpaceQueryInfoRoutine) { return FALSE; } return (*DblSpaceQueryInfoRoutine)(DosDriveName, IsRemovable, IsFloppy, IsCompressed, Error, NtDriveName, MaxNtDriveNameLength, CvfFileName, MaxCvfFileNameLength, HostDriveName, MaxHostDriveNameLength); } #endif BOOL CALLBACK CancelDlgProc( IN HWND hDlg, IN UINT uMsg, IN WPARAM wParam, IN LPARAM lParam ) /*++ Routine Description: Dialog procedure for the modeless progress & cancel dialog Two main purposes here: 1. if the user chooses CANCEL we set bCancel to TRUE which will end the PeekMessage background processing loop 2. handle the private FS_CANCELUPDATE message and draw a "gas gauge" indication of how far the background job has progressed Arguments: standard Windows dialog procedure Return Values: standard Windows dialog procedure --*/ { static DWORD percentDrawn; static RECT rectGG; // GasGauge rectangle static BOOL captionIsLoaded; static PFORMAT_PARAMS formatParams; TCHAR title[100], templateString[100]; switch (uMsg) { case WM_INITDIALOG: { PPERSISTENT_REGION_DATA regionData; HANDLE threadHandle; DWORD threadId; HWND hwndGauge = GetDlgItem(hDlg, IDC_GASGAUGE); // set up the dialog handle in the parameter block so the // call back routine can communicate with this routine // and initialize static variables. formatParams = (PFORMAT_PARAMS) lParam; formatParams->DialogHwnd = hDlg; regionData = (PPERSISTENT_REGION_DATA) formatParams->RegionData; percentDrawn = 0; captionIsLoaded = FALSE; // Set the caption string. LoadString(hModule, IDS_FORMAT_TITLE, templateString, sizeof(templateString)/sizeof(TCHAR)); wsprintf(title, templateString, regionData->DriveLetter); SetWindowText(hDlg, title); #ifdef DOUBLE_SPACE_SUPPORT_INCLUDED if (formatParams->DoubleSpace) { // start the double space create thread threadHandle = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) FmIfsCreateDblspace, (LPVOID) formatParams, (DWORD) 0, (LPDWORD) &threadId); } else { #endif // start the format thread threadHandle = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) FormatVolume, (LPVOID) formatParams, (DWORD) 0, (LPDWORD) &threadId); #ifdef DOUBLE_SPACE_SUPPORT_INCLUDED } #endif if (!threadHandle) { // can't do it now. formatParams->Result = MSG_COULDNT_CREATE_THREAD; EndDialog(hDlg, FALSE); return TRUE; } // no need to keep the handle around. CloseHandle(threadHandle); // Get the coordinates of the gas gauge static control rectangle, // and convert them to dialog client area coordinates GetClientRect(hwndGauge, &rectGG); ClientToScreen(hwndGauge, (LPPOINT)&rectGG.left); ClientToScreen(hwndGauge, (LPPOINT)&rectGG.right); ScreenToClient(hDlg, (LPPOINT)&rectGG.left); ScreenToClient(hDlg, (LPPOINT)&rectGG.right); return TRUE; } case WM_COMMAND: switch (wParam) { case IDCANCEL: formatParams->Result = MSG_FORMAT_CANCELLED; formatParams->Cancel = TRUE; EndDialog(hDlg, FALSE); } return TRUE; case WM_PAINT: { INT width = rectGG.right - rectGG.left; INT height = rectGG.bottom - rectGG.top; INT nDivideRects; HDC hDC; PAINTSTRUCT ps; TCHAR buffer[100]; SIZE size; INT xText, yText, byteCount; RECT rectDone, rectLeftToDo; // The gas gauge is drawn by drawing a text string stating // what percentage of the job is done into the middle of // the gas gauge rectangle, and by separating that rectangle // into two parts: rectDone (the left part, filled in blue) // and rectLeftToDo(the right part, filled in white). // nDivideRects is the x coordinate that divides these two rects. // // The text in the blue rectangle is drawn white, and vice versa // This is easy to do with ExtTextOut()! hDC = BeginPaint(hDlg, &ps); // If formatting quick, set this display if (!captionIsLoaded) { UINT resourceId = IDS_PERCENTCOMPLETE; if (formatParams->QuickFormat) { resourceId = IDS_QUICK_FORMAT; } #ifdef DOUBLE_SPACE_SUPPORT_INCLUDED if (formatParams->DoubleSpace) { resourceId = IDS_CREATING_DBLSPACE; } #endif LoadString(hModule, resourceId, buffer, sizeof(buffer)/sizeof(TCHAR)); if (!formatParams->QuickFormat) { SetDlgItemText(hDlg, IDC_TEXT, buffer); } captionIsLoaded = TRUE; } if (formatParams->QuickFormat) { nDivideRects = 0; byteCount = lstrlen(buffer); } else { byteCount = wsprintf(buffer, TEXT("%3d%%"), percentDrawn); nDivideRects = (width * percentDrawn) / 100; } GetTextExtentPoint(hDC, buffer, lstrlen(buffer), &size); xText = rectGG.left + (width - size.cx) / 2; yText = rectGG.top + (height - size.cy) / 2; // Paint in the "done so far" rectangle of the gas // gauge with blue background and white text SetRect(&rectDone, rectGG.left, rectGG.top, rectGG.left + nDivideRects, rectGG.bottom); SetTextColor(hDC, RGB(255, 255, 255)); SetBkColor(hDC, RGB(0, 0, 255)); ExtTextOut(hDC, xText, yText, ETO_CLIPPED | ETO_OPAQUE, &rectDone, buffer, byteCount/sizeof(TCHAR), NULL); // Paint in the "still left to do" rectangle of the gas // gauge with white background and blue text SetRect(&rectLeftToDo, rectGG.left + nDivideRects, rectGG.top, rectGG.right, rectGG.bottom); SetTextColor(hDC, RGB(0, 0, 255)); SetBkColor(hDC, RGB(255, 255, 255)); ExtTextOut(hDC, xText, yText, ETO_CLIPPED | ETO_OPAQUE, &rectLeftToDo, buffer, byteCount/sizeof(TCHAR), NULL); EndPaint(hDlg, &ps); return TRUE; } case FS_CANCELUPDATE: // wParam = % completed percentDrawn = (INT)wParam; InvalidateRect(hDlg, &rectGG, TRUE); UpdateWindow(hDlg); return TRUE; case FS_FINISHED: EndDialog(hDlg, TRUE); return TRUE; default: return FALSE; } } INT LabelDlgProc( IN HWND hDlg, IN UINT wMsg, IN WPARAM wParam, IN LPARAM lParam) /*++ Routine Description: This routine manages the label dialog. Upon completion of the dialog it will end the dialog with a result of TRUE to indicate that all is set up for the label operation. FALSE if the label operation has been cancelled by the user. Arguments: Standard Windows dialog procedure. Return Value: Standard Windows dialog procedure. --*/ { static PLABEL_PARAMS labelParams; static PREGION_DESCRIPTOR regionDescriptor; static PPERSISTENT_REGION_DATA regionData; char text[100]; TCHAR uniText[100]; int labelSize; TCHAR title[100], templateString[100]; switch (wMsg) { case WM_INITDIALOG: labelParams = (PLABEL_PARAMS) lParam; regionDescriptor = labelParams->RegionDescriptor; regionData = PERSISTENT_DATA(regionDescriptor); // Set the caption string. // LoadString(hModule, IDS_LABEL_TITLE, templateString, sizeof(templateString)/sizeof(TCHAR)); wsprintf(title, templateString, regionData->DriveLetter); SetWindowText(hDlg, title); // Convert the volume label into the proper type for windows. wsprintf(text, "%ws", regionData->VolumeLabel); UnicodeHack(text, uniText); SetDlgItemText(hDlg, IDC_NAME, uniText); return TRUE; case WM_COMMAND: switch (wParam) { case FD_IDHELP: DialogHelp(HC_DM_DLG_LABEL); break; case IDCANCEL: EndDialog(hDlg, FALSE); break; case IDOK: labelSize = GetDlgItemText(hDlg, IDC_NAME, text, 100); UnicodeHack(text, labelParams->NewLabel); EndDialog(hDlg, TRUE); break; } break; } return FALSE; } #define NUM_FSTYPES 2 #define MAX_FSTYPENAME_SIZE 6 // HPFS is not supported -- therefore commented out. TCHAR *FsTypes[NUM_FSTYPES + 1] = { "NTFS", /* "HPFS", */ "FAT" }; WCHAR *UnicodeFsTypes[NUM_FSTYPES] = { L"NTFS", /* L"HPFS", */ L"FAT" }; BOOL CALLBACK FormatDlgProc( IN HWND hDlg, IN UINT wMsg, IN WPARAM wParam, IN LPARAM lParam) /*++ Routine Description: This routine manages the format dialog. Upon completion it ends the dialog with a result value of TRUE to indicate that the format operation is to take place. FALSE is the result if the user cancels out of the dialog. Arguments: Standard Windows dialog procedure. Return Value: Standard Windows dialog procedure. --*/ { static HWND hwndCombo; static PFORMAT_PARAMS formatParams; static PREGION_DESCRIPTOR regionDescriptor; static PPERSISTENT_REGION_DATA regionData; char text[40]; TCHAR uniText[40]; INT i; DWORD selection; BOOL quickFormat = FALSE; HWND hwndButton; TCHAR title[100], templateString[100]; UNREFERENCED_PARAMETER(lParam); switch (wMsg) { case WM_INITDIALOG: { PWSTR typeName = NULL, volumeLabel = NULL; WCHAR driveLetter = L' '; // since the format params are static reset the quick format boolean. formatParams = (PFORMAT_PARAMS) lParam; formatParams->QuickFormat = FALSE; // get format params, set static values and // get information about the volume hwndCombo = GetDlgItem(hDlg, IDC_FSTYPE); regionDescriptor = formatParams->RegionDescriptor; DetermineRegionInfo(regionDescriptor, &typeName, &volumeLabel, &driveLetter); regionData = PERSISTENT_DATA(regionDescriptor); // Set the caption string. LoadString(hModule, IDS_FORMAT_TITLE, templateString, sizeof(templateString)/sizeof(TCHAR)); wsprintf(title, templateString, regionData->DriveLetter); SetWindowText(hDlg, title); // Convert the volume label into the proper type for windows // and set default values. wsprintf(text, "%ws", regionData->VolumeLabel); UnicodeHack(text, uniText); SetDlgItemText(hDlg, IDC_NAME, uniText); CheckDlgButton(hDlg, IDC_VERIFY, quickFormat); SendDlgItemMessage(hDlg, IDOK, EM_SETSEL, 0, -1); // If this volume is a mirror or stripe with parity, // disable Quick Format. if (regionData->FtObject != NULL && (regionData->FtObject->Set->Type == Mirror || regionData->FtObject->Set->Type == StripeWithParity)) { hwndButton = GetDlgItem(hDlg, IDC_VERIFY); if (hwndButton != NULL) { EnableWindow(hwndButton, FALSE); } } selection = 0; if (IsDiskRemovable[regionDescriptor->Disk]) { // If removable, start from the bottom of the list so FAT is first. // Load the available File system types. for (i = NUM_FSTYPES - 1; i >= 0; i--) { // Fill the drop down list. SendMessage(hwndCombo, CB_ADDSTRING, 0, (LONG)FsTypes[i]); } } else { // Load the available File system types. for (i = 0; i < NUM_FSTYPES; i++) { // While filling in the drop down, determine which FS // this volume is already formated for and make it the // default (if not found, NTFS is the default). if (wcscmp(typeName, UnicodeFsTypes[i]) == 0) { selection = i; } // set the FS type into the dialog. SendMessage(hwndCombo, CB_ADDSTRING, 0, (LONG)FsTypes[i]); } } SendMessage(hwndCombo, CB_SETCURSEL, selection, 0); return TRUE; break; } case WM_COMMAND: switch (wParam) { case FD_IDHELP: DialogHelp(HC_DM_DLG_FORMAT); break; case IDCANCEL: EndDialog(hDlg, FALSE); break; case IDOK: { int labelSize; // pull the parameters from the dialog // and return with success. selection = SendMessage(hwndCombo, CB_GETCURSEL, 0, 0); SendMessage(hwndCombo, CB_GETLBTEXT, selection, (LONG)formatParams->FileSystem); labelSize = GetDlgItemText(hDlg, IDC_NAME, (LPTSTR) formatParams->Label, 100); if (IsDlgButtonChecked(hDlg, IDC_VERIFY)) { formatParams->QuickFormat = TRUE; } EndDialog(hDlg, TRUE); break; } default: return FALSE; } default: break; } return FALSE; } VOID FormatPartition( PREGION_DESCRIPTOR RegionDescriptor ) /*++ Routine Description: Insure the IFS Dll is loaded and start the dialog for format of a volume. Arguments: RegionDescriptor - The region to format. Return Value: None --*/ { static FORMAT_PARAMS formatParams; // this is passed to other threads // it cannot be located on the stack PPERSISTENT_REGION_DATA regionData; int doFormat; ULONG diskSize; PWSTR tempName, tempLabel, typeName; TCHAR label[100], fileSystem[10], message[300], msgProto[300], title[200]; // Make sure format of this partition is allowed. It is not allowed // if it is the boot partition (or sys partition on x86). if ((DeletionIsAllowed(RegionDescriptor)) != NO_ERROR) { ErrorDialog(MSG_CANT_FORMAT_WINNT); return; } // must have a drive letter regionData = PERSISTENT_DATA(RegionDescriptor); if (!regionData->DriveLetter) { ErrorDialog(MSG_CANT_FORMAT_NO_LETTER); return; } // can only do this is the dll is loaded. if (!LoadIfsDll()) { // could not load the dll ErrorDialog(MSG_CANT_LOAD_FMIFS); return; } // set up the parameters and get the information from the user. formatParams.RegionDescriptor = RegionDescriptor; formatParams.Result = 0; formatParams.RegionData = regionData; formatParams.Label = (PUCHAR) label; formatParams.FileSystem = (PUCHAR) fileSystem; formatParams.QuickFormat = formatParams.Cancel = formatParams.DoubleSpace = FALSE; formatParams.TotalSpace = formatParams.SpaceAvailable = 0; doFormat = DialogBoxParam(hModule, MAKEINTRESOURCE(IDD_PARTITIONFORMAT), hwndFrame, FormatDlgProc, (ULONG) &formatParams); if (doFormat) { // do an are you sure message. doFormat = ConfirmationDialog(MSG_CONFIRM_FORMAT, MB_ICONQUESTION | MB_YESNO); if (doFormat == IDYES) { if (IsDiskRemovable[RegionDescriptor->Disk]) { PWSTR typeName, volumeLabel; BOOLEAN volumeChanged = FALSE; if (!RegionDescriptor->PartitionNumber) { // TODO: something has changed where the code gets to this // point with an incorrect partition number - This happens // when a partition is deleted and added to removable media. // For removable media the partition number is always 1. RegionDescriptor->PartitionNumber = 1; } if (GetVolumeTypeAndSize(RegionDescriptor->Disk, RegionDescriptor->PartitionNumber, &volumeLabel, &typeName, &diskSize) == OK_STATUS) { // Verify that this is still the same device. if (typeName) { if (!lstrcmpiW(typeName, L"raw")) { Free(typeName); typeName = Malloc((wcslen(wszUnknown) * sizeof(WCHAR)) + sizeof(WCHAR)); lstrcpyW(typeName, wszUnknown); } } else { typeName = Malloc((wcslen(wszUnknown) * sizeof(WCHAR)) + sizeof(WCHAR)); lstrcpyW(typeName, wszUnknown); } if (regionData) { if (regionData->VolumeLabel) { if (wcscmp(regionData->VolumeLabel, volumeLabel)) { volumeChanged = TRUE; } } if (regionData->TypeName) { // It is possible the region has no type // or is of type "Unformatted". // This says it is ok to format. if (*regionData->TypeName) { if (wcscmp(regionData->TypeName, wszUnformatted)) { // It has a type and it isn't // unformatted - see if it is // the same as before. if (wcscmp(regionData->TypeName, typeName)) { volumeChanged = TRUE; } } } } } if (Disks[RegionDescriptor->Disk]->DiskSizeMB != (diskSize/1024)) { volumeChanged = TRUE; } if (volumeChanged) { ErrorDialog(MSG_VOLUME_CHANGED); // since the user was told the volume changed, // update the display. SetCursor(hcurWait); if (GetVolumeTypeAndSize(RegionDescriptor->Disk, RegionDescriptor->PartitionNumber, &tempLabel, &tempName, &diskSize) == OK_STATUS) { Free(typeName); typeName = tempName; Free(volumeLabel); volumeLabel = tempLabel; } if (regionData->VolumeLabel) { Free(regionData->VolumeLabel); } regionData->VolumeLabel = volumeLabel; if (regionData->TypeName) { Free(regionData->TypeName); } regionData->TypeName = typeName; SetCursor(hcurNormal); TotalRedrawAndRepaint(); return; } else { if (volumeLabel) { Free(volumeLabel); } if (typeName) { Free(typeName); } } } } // Insure the partition is not to big if the requested format // is FAT. if (!strcmpi(formatParams.FileSystem, "FAT")) { if (GetVolumeSizeMB(RegionDescriptor->Disk, RegionDescriptor->PartitionNumber, &diskSize)) { if (diskSize > (4*1024)) { ErrorDialog(MSG_TOO_BIG_FOR_FAT); TotalRedrawAndRepaint(); return; } } else { // Just try the format anyway. } } // Initialize synchronization event to know when the // format thread is really complete. formatParams.ThreadIsDone = 0; // user still wants to format. DialogBoxParam(hModule, MAKEINTRESOURCE(IDD_FORMATCANCEL), hwndFrame, CancelDlgProc, (ULONG) &formatParams); if (formatParams.Result) { // the format failed. ErrorDialog(formatParams.Result); } else { LoadString(hModule, IDS_FORMATCOMPLETE, title, sizeof(title)/sizeof(TCHAR)); LoadString(hModule, IDS_FORMATSTATS, msgProto, sizeof(msgProto)/sizeof(TCHAR)); wsprintf(message, msgProto, formatParams.TotalSpace, formatParams.SpaceAvailable); MessageBox(GetActiveWindow(), message, title, MB_ICONINFORMATION | MB_OK); } // Synchronize with the format thread just in case // the user did a cancel and the format thread is // still buzy verifying 50MB or some such thing. // Rather than use an event this is a polling loop. SetCursor(hcurWait); while (!formatParams.ThreadIsDone) { Sleep(1000); } SetCursor(hcurNormal); // If the format was successful, update the volume // information in the data structures. if (!formatParams.Result) { // get the new label and FsType regardless of success of the // format (i.e. user cancel may have occurred, so this stuff // is not what it used to be even if the format failed. { // force mount by filesystem. This is done with the // extra \ on the end of the path. This must be done // in order to get the FS type. Otherwise the filesystem // recognisor may allow the open without actually getting // the file system involved. char ntDeviceName[100]; STATUS_CODE sc; HANDLE_T handle; sprintf(ntDeviceName, "\\DosDevices\\%c:\\", regionData->DriveLetter); sc = LowOpenNtName(ntDeviceName, &handle); if (sc == OK_STATUS) { LowCloseDisk(handle); } } typeName = NULL; GetTypeName(RegionDescriptor->Disk, RegionDescriptor->PartitionNumber, &typeName); if (!typeName) { // Failed to get the type after a cancel. This means // GetTypeName() could not open the volume for some reason. // This has been seen on Alpha's and x86 with large // hardware raid devices. Exiting and starting // over will get an FS type. For now, don't change the // data structures. TotalRedrawAndRepaint(); return; } tempLabel = NULL; if (GetVolumeLabel(RegionDescriptor->Disk, RegionDescriptor->PartitionNumber, &tempLabel) == NO_ERROR) { if (tempLabel) { Free(regionData->VolumeLabel); regionData->VolumeLabel = Malloc((lstrlenW(tempLabel) + 1) * sizeof(WCHAR)); lstrcpyW(regionData->VolumeLabel, tempLabel); } } else { *regionData->VolumeLabel = 0; } // update the type name. if (regionData->TypeName) { Free(regionData->TypeName); regionData->TypeName = typeName; } // update the file system type information for all // components of this region (i.e. fix up FT structures if // it is an FT item). This is done via knowledge about multiple // selections as opposed to walking through the FtObject list. if (SelectionCount > 1) { PPERSISTENT_REGION_DATA passedRegionData; ULONG index; // Need to update all involved. passedRegionData = regionData; for (index = 0; index < SelectionCount; index++) { RegionDescriptor = &SELECTED_REGION(index); regionData = PERSISTENT_DATA(RegionDescriptor); if (regionData == passedRegionData) { continue; } if (regionData->VolumeLabel) { Free(regionData->VolumeLabel); regionData->VolumeLabel = NULL; } if (tempLabel) { regionData->VolumeLabel = Malloc((lstrlenW(tempLabel) + 1) * sizeof(WCHAR)); lstrcpyW(regionData->VolumeLabel, tempLabel); } if (regionData->TypeName) { Free(regionData->TypeName); } regionData->TypeName = Malloc((lstrlenW(passedRegionData->TypeName) + 1) * sizeof(WCHAR)); lstrcpyW(regionData->TypeName, passedRegionData->TypeName); } } if (tempLabel) { Free(tempLabel); } } // force screen update. TotalRedrawAndRepaint(); } } } VOID LabelPartition( PREGION_DESCRIPTOR RegionDescriptor ) /*++ Routine Description: Insure the IFS Dll is loaded and start the dialog for label of a volume. Arguments: RegionDescriptor - the region for the label. Return Value: None --*/ { int doLabel; DWORD ec; TCHAR label[100]; WCHAR unicodeLabel[100]; LABEL_PARAMS labelParams; WCHAR driveLetter[4]; PWSTR tmpLabel; PPERSISTENT_REGION_DATA regionData; if (!LoadIfsDll()) { // could not load the Dll ErrorDialog(MSG_CANT_LOAD_FMIFS); return; } labelParams.RegionDescriptor = RegionDescriptor; labelParams.NewLabel = (LPTSTR)label; doLabel = DialogBoxParam(hModule, MAKEINTRESOURCE(IDD_PARTITIONLABEL), hwndFrame, LabelDlgProc, (ULONG) &labelParams); if (doLabel) { regionData = PERSISTENT_DATA(RegionDescriptor); if (IsDiskRemovable[RegionDescriptor->Disk]) { PWSTR typeName, volumeLabel; ULONG diskSize; BOOLEAN volumeChanged = FALSE; if (GetVolumeTypeAndSize(RegionDescriptor->Disk, RegionDescriptor->PartitionNumber, &volumeLabel, &typeName, &diskSize) == OK_STATUS) { // Verify that this is still the same device. if (regionData) { if (regionData->VolumeLabel) { if (wcscmp(regionData->VolumeLabel, volumeLabel)) { volumeChanged = TRUE; } } if (regionData->TypeName) { if (wcscmp(regionData->TypeName, typeName)) { volumeChanged = TRUE; } } } if (Disks[RegionDescriptor->Disk]->DiskSizeMB != (diskSize/1024)) { volumeChanged = TRUE; } if (volumeChanged) { PWSTR tempName, tempLabel; ErrorDialog(MSG_VOLUME_CHANGED); // since the user was told the volume changed, // update the display. SetCursor(hcurWait); if (GetVolumeTypeAndSize(RegionDescriptor->Disk, RegionDescriptor->PartitionNumber, &tempLabel, &tempName, &diskSize) == OK_STATUS) { Free(typeName); typeName = tempName; Free(volumeLabel); volumeLabel = tempLabel; } if (regionData->VolumeLabel) { Free(regionData->VolumeLabel); } regionData->VolumeLabel = volumeLabel; if (regionData->TypeName) { Free(regionData->TypeName); } regionData->TypeName = typeName; SetCursor(hcurNormal); TotalRedrawAndRepaint(); return; } else { Free(volumeLabel); Free(typeName); } } } driveLetter[1] = L':'; driveLetter[2] = 0; driveLetter[0] = (WCHAR)regionData->DriveLetter; // convert to unicode - use variable doLabel as an index. setUnicode(label, unicodeLabel); // perform the label. SetCursor(hcurWait); (*LabelRoutine)(driveLetter, unicodeLabel); ec = GetLastError(); if (ec != NO_ERROR) { SetCursor(hcurNormal); ErrorDialog(ec); SetCursor(hcurWait); } // get the new label to be certain it took and update // the internal structures. if (GetVolumeLabel(RegionDescriptor->Disk, RegionDescriptor->PartitionNumber, &tmpLabel) == NO_ERROR) { Free(regionData->VolumeLabel); regionData->VolumeLabel = Malloc((lstrlenW(tmpLabel) + 1) * sizeof(WCHAR)); lstrcpyW(regionData->VolumeLabel, tmpLabel); } else { *regionData->VolumeLabel = 0; } // update the label for all // components of this region (i.e. fix up FT structures if // it is an FT item). This is done via knowledge about multiple // selections as opposed to walking through the FtObject list. if (SelectionCount > 1) { PPERSISTENT_REGION_DATA passedRegionData; ULONG index; // Need to update all involved. passedRegionData = regionData; for (index = 0; index < SelectionCount; index++) { RegionDescriptor = &SELECTED_REGION(index); regionData = PERSISTENT_DATA(RegionDescriptor); if (regionData == passedRegionData) { continue; } if (regionData->VolumeLabel) { Free(regionData->VolumeLabel); regionData->VolumeLabel = NULL; } if (tmpLabel) { regionData->VolumeLabel = Malloc((lstrlenW(tmpLabel) + 1) * sizeof(WCHAR)); lstrcpyW(regionData->VolumeLabel, tmpLabel); } else { *regionData->VolumeLabel = 0; } } } if (tmpLabel) { Free(tmpLabel); } SetCursor(hcurNormal); // force screen update. TotalRedrawAndRepaint(); } }