windows-xp/Source/XPSP1/NT/sdktools/winobj/wfformat.c

/****************************************************************************/
/*                                                                          */
/*  WFFORMAT.C -                                                            */
/*                                                                          */
/*      Windows File Manager Diskette Formatting Routines                   */
/*                                                                          */
/****************************************************************************/

#include "winfile.h"


/* MyGetDriveType() returns */
#define NOCHANGE            0
#define CHANGE              1

/* Parameter Block for IOCTL Format call */
struct FORMATPARAMS {
    BYTE   bSpl;                    /* Special byte */
    WORD   wHead;
    WORD   wCylinder;
};


typedef struct _MEDIASENSE {
    BYTE IsDefault;
    BYTE DeviceType;
    BYTE res[10];
} MEDIASENSE;


/*--------------------------------------------------------------------------*/
/*  BIOS Parameter Block Table for Removable Media                          */
/*--------------------------------------------------------------------------*/

/* Each entry contains data about a floppy drive type in the following format:
 *                                                          Length
 *      cbSec               - Bytes/Sector                    2
 *      secPerClus          - Sectors/Cluster                 1
 *      cSecRes             - # of Reserved Sectors           2
 *      cFAT                - # of FATs                       1
 *      cDir                - # of Root Directory Entries     2
 *      cSec                - # of Sectors on the disk        2
 *      bMedia              - Media Descriptor Byte           1
 *      secPerFAT           - Sectors/FAT                     2
 *      secPerTrack         - Sectors/Track                   2
 *      cHead               - # of Disk Heads                 2
 *      cSecHidden          - # of Hidden Sectors             2
 */

BPB     bpbList[] =
{
    {512, 1, 1, 2,  64,  1*8*40, MEDIA_160,  1,  8, 1, 0}, /*  8sec SS 48tpi 160KB 5.25" DOS 1.0 & above */
    {512, 2, 1, 2, 112,  2*8*40, MEDIA_320,  1,  8, 2, 0}, /*  8sec DS 48tpi 320KB 5.25" DOS 1.1 & above */
    {512, 1, 1, 2,  64,  1*9*40, MEDIA_180,  2,  9, 1, 0}, /*  9sec SS 48tpi 180KB 5.25" DOS 2.0 & above */
    {512, 2, 1, 2, 112,  2*9*40, MEDIA_360,  2,  9, 2, 0}, /*  9sec DS 48tpi 360KB 5.25" DOS 2.0 & above */
    {512, 1, 1, 2, 224, 2*15*80, MEDIA_1200, 7, 15, 2, 0}, /* 15sec DS 96tpi 1.2MB 5.25" DOS 3.0 & above */
    {512, 2, 1, 2, 112,  2*9*80, MEDIA_720,  3,  9, 2, 0}, /*  9sec DS 96tpi 720KB  3.5" DOS 3.2 & above */
    {512, 1, 1, 2, 224, 2*18*80, MEDIA_1440, 9, 18, 2, 0}, /* 18sec DS 96tpi 1.44M  3.5" DOS 3.3 & above */
    {512, 2, 1, 2, 240, 2*36*80, MEDIA_2880, 9, 36, 2, 0}  /* 36sec DS 96tpi 2.88M  3.5" DOS 5.0 & above */
};


/* Precompute the total number of usable clusters...
 *   cCluster = (cSec/secPerClus) - { cSecRes
 *                                    + (cFAT * secPerFat)
 *                                    + (cDir*32+cbSec-1)/cbSec }/secPerClus;
 */
WORD cCluster[] = {0x0139, 0x013B, 0x015F, 0x0162, 0x0943, 0x02C9, 0x0B1F, 0xB2F, 0};





/*--------------------------------------------------------------------------*/
/*                                                                          */
/*  BuildDevPB() -                                                          */
/*                                                                          */
/*--------------------------------------------------------------------------*/

HANDLE
APIENTRY
BuildDevPB(
          PDevPB pDevPB
          )
{
    WORD              wCount;
    register HANDLE   hNewDevPB;
    PDevPB            pNewDevPB;
    WORD              wSecSize;
    register WORD     *wPtr;
    WORD              wTrackNumber;

    wCount = pDevPB->BPB.secPerTrack;

    if (!(hNewDevPB = LocalAlloc(LHND, TRACKLAYOUT_OFFSET+2+wCount*4)))
        return NULL;

    pNewDevPB = (PDevPB)LocalLock(hNewDevPB);

    memcpy(pNewDevPB, pDevPB, TRACKLAYOUT_OFFSET);
    wSecSize = pDevPB->BPB.cbSec;

    wPtr = (WORD *)((LPSTR)pNewDevPB + TRACKLAYOUT_OFFSET);
    *wPtr++ = wCount;

    for (wTrackNumber=1; wTrackNumber <= wCount; wTrackNumber++) {
        *wPtr++ = wTrackNumber;
        *wPtr++ = wSecSize;
    }

    LocalUnlock(hNewDevPB);
    return hNewDevPB;
}



/*--------------------------------------------------------------------------*/
/*                                                                          */
/*  SetDevParamsForFormat() -                                               */
/*                                                                          */
/*--------------------------------------------------------------------------*/

BOOL
SetDevParamsForFormat(
                     INT nDrive,
                     PDevPB pDevPB,
                     BOOL fLowCapacity
                     )
{
    HANDLE   hLocHandle;
    PDevPB   pNewDevPB;

    /* Allocate for the DPB with track layout */
    if (!(hLocHandle = BuildDevPB(pDevPB)))
        return FALSE;

    pNewDevPB = (PDevPB)LocalLock(hLocHandle);

    pNewDevPB->SplFunctions = 5;
    /* Is this a 360KB floppy in a 1.2Mb drive */
    if (fLowCapacity) {
        /* Yes! Then change the number of cylinders and Media type */
        /* Fix for Bug #???? --SANKAR-- 01-10-90 -- */
        pNewDevPB->NumCyls = 40;
        pNewDevPB->bMediaType = 1;
    }

    LocalUnlock(hLocHandle);
    LocalFree(hLocHandle);

    return TRUE;

}


/*--------------------------------------------------------------------------*/
/*                                                                          */
/*  GenericFormatTrack() -                                                  */
/*                                                                          */
/*--------------------------------------------------------------------------*/

/* This calls IOCTL format if DOS ver >= 3.2; Else calls BIOS.
 *
 *  Returns : 0 if no error
 *          > 0 if tolerable error (resuling in bad sectors);
 *          -1  if fatal error (Format has to be aborted);
 */

INT
APIENTRY
GenericFormatTrack(
                  WORD nDisk,
                  WORD wCylinder,
                  WORD wHead,
                  WORD wSecPerTrack,
                  LPSTR lpDiskBuffer
                  )
{
    struct FORMATPARAMS   FormatParams;
    INT                   iRetVal = -1;   /* FATAL Error by default */
    register INT          iErrCode;

#ifdef DEBUG
    wsprintf(szMessage, "Formatting Head #%d, Cylinder#%d\n\r", wHead, wCylinder);
    OutputDebugString(szMessage);
#endif

    /* Check the DOS version */
    if (wDOSversion >= DOS_320) {
        FormatParams.bSpl = 0;
        FormatParams.wHead = wHead;
        FormatParams.wCylinder = wCylinder;
        switch (iErrCode = 0) {
            case NOERROR:
            case CRCERROR:
            case SECNOTFOUND:
            case GENERALERROR:
                iRetVal = iErrCode;
                break;
        }
    } else {
        switch (iErrCode = FormatTrackHead(nDisk, wCylinder, wHead, wSecPerTrack, lpDiskBuffer)) {
            case NOERROR:
            case DATAERROR:
            case ADDMARKNOTFOUND:
            case SECTORNOTFOUND:
                iRetVal = iErrCode;
                break;
        }
    }
    return (iRetVal);
}


INT  APIENTRY GetMediaType(INT nDrive)
{
    return 0;
}


/*--------------------------------------------------------------------------*/
/*                                                                          */
/*  FormatFloppy() -                                                        */
/*                                                                          */
/*--------------------------------------------------------------------------*/

// note, the below comment is out of date.  leave for reference only

/* The Format routine is intended to mimic the actions of the FORMAT command
 * on MSDOS.  We restrict the possible set of operations that Format must use
 * in order to simplify life. The RESTRICTIONS are:
 *
 *  -- If the drive selected for formatting is a Quad density drive, then the
 *         user will be asked if he wants to format it for 1.2 MB or 360 KB
 *         and the format will proceed accordingly;
 *  -- For all other types of drives, it will format the disk to the maximum
 *         capacity that the drive can handle.
 *
 * The requirements for Format are:
 *
 *  1) there be a disk in a "source" drive that contains a valid boot sector
 *  2) there be a disk in a "destination" drive that is formattable.
 *
 * The algorithm for determining a drive's capacity is as follows:
 *
 *      If Source == Destination then
 *          error
 *      If dosversion >= 3.20
 *       {
 *         Use generic get_device_parameters and Get BPB.
 *         if (the drive is a Quad density drive (1.2 MB), and if user wants
 *             to format for 360KB), take BPB for 360KB from the bpbList[].
 *         In all other cases, use the BPB of the device.
 *       }
 *      else
 *       {
 *         Ask INT 13 for the drive type.
 *         If error then {
 *            assume 48tpi double side
 *            Attempt to format track 0, head 1
 *            If error then
 *               assume 48tpi single side
 *         else
 *            if sectors per track = 15 then
 *                assume 96tpi
 *                Ask user if he wants to format for 1.2MB or 360KB and
 *                use the proper BPB from bpbList[]
 *            else
 *                error
 *       }
 *
 * Note that this does NOT take into account non-contiguous drive letters
 * (see 3.2 spec) nor future drives nor user-installed device drivers.
 *
 * Format (dSrc, nDstDrive, nDstDriveInt13) will format drive nDstDrive using an updated
 * boot sector from drive dSrc. We will allocate two blocks of memory, but
 * only one at a time.  The first one we allocate is the bit-map of bad
 * clusters that we find during the format.  The second is for the boot
 * sector.
 *
 *  Returns:    0           Success
 *              <> 0        error code
 *                      1 =>  NOMEMORY
 *                      3 =>  Invalid boot sector.
 *                      4 =>  System area of the floppy is bad
 *                      7 =>  Problem in writing in Dest diskette.
 *                      8 =>  Internal error
 *                      9 =>  Format has been aborted by user.
 */

// in:
//     hWnd            window to base messages on
//
//     nSource         drive to swipe boot stuff from
//
//     nDest           drive to format
//
//     iCapacity       SS48
//                     DS48
//                     DS96
//                     DS720KB
//                     DS144M
//                     DS288M
//                     -1      (device capacity)
//
//     bMakeSysDisk    make a system disk too
//
//     bQuick          do a quick format
//
// returns:
//     0               success
//     != 0            error
//

INT
APIENTRY
FormatFloppy(
            HWND hWnd,
            WORD nDest,
            INT iCapacity,
            BOOL bMakeSysDisk,
            BOOL bQuick
            )
{
    DPB           DPB;
    DBT           dbtSave;                /* Disk Base Table */
    INT           iErrCode;
    PBPB pBPB;
    WORD          w;
    WORD          cClusters;
    WORD          wFATValue;
    WORD          wBadCluster;
    WORD          cBadSectors;
    WORD          cTotalTracks;
    WORD          wCurrentHead;
    WORD          wPercentDone;
    WORD          wCurrentTrack;
    WORD          cTracksToFormat;
    WORD          wFirstDataSector;
    WORD      nSource;
    DevPB         dpbDiskParms;           /* Device Parameters */
    LPDBT         lpDBT;
    LPSTR         lpDiskBuffer;
    LPSTR         lpBadClusterList;
    HANDLE        hDiskBuffer;
    HANDLE        hBadClusterList;
    HANDLE        hSaveDiskParms = NULL;
    PDevPB        pdpbSaveDiskParms;
    CHAR          szMsg[128];
    BOOL          fLowCapacity = FALSE; /* Is a 360KB floppy in a 1.2MB drive? */
    INT           ret = 0;        // default to success

    nSource = (WORD)GetBootDisk();

    /* Initialize for cleanup. */
    hDiskBuffer      = NULL;
    lpDiskBuffer     = NULL;
    hBadClusterList  = NULL;
    lpBadClusterList = NULL;
    bUserAbort       = FALSE;

    /* Create a dialogbox that displays the progress of formatting; and also
     * gives the user a chance to abort formatting at anytime.
     */
    hdlgProgress = CreateDialog(hAppInstance, MAKEINTRESOURCE(FORMATPROGRESSDLG), hWnd, ProgressDlgProc);
    if (!hdlgProgress) {
        ret = IDS_FFERR_MEM;      // out of memory
        goto FFErrExit1;
    }

    EnableWindow(hWnd, FALSE);

    /* Flush to DOS disk buffers. */
    DiskReset();

    /* Get the Disk Base Table. */
    if (!(lpDBT = GetDBT())) {
        ret = IDS_FFERR_MEM;
        goto FFErrExit2;
    }

    dbtSave = *lpDBT;

    // this checks to see if we are trying to format the boot drive
    // this is a no no

    if ((nDest == nSource) || (!IsRemovableDrive(nDest))) {
        ret = IDS_FFERR_SRCEQDST;
        goto FFErrExit3;
    }

    /* Check if the sector size is of standard size; If not report error */
    if (HIWORD(GetClusterInfo(nSource)) > CBSECTORSIZE) {
        ret = IDS_FFERR_SECSIZE;
        goto FFErrExit3;
    }

    /* Allocate boot sector, sector buffer, track buffer */
    if (!(hDiskBuffer = LocalAlloc(LHND, (LONG)(2*CBSECTORSIZE)))) {
        ret = IDS_FFERR_MEM;
        goto FFErrExit3;
    }

    lpDiskBuffer = LocalLock(hDiskBuffer);


    /* If DOS Version is 3.2 or above, use DeviceParameters() to get the BPB. */
    if (wDOSversion >= DOS_320) {

        /* NOTE: All the fields of dpbDiskParms must be initialized to 0,
         *           otherwise, INT 21h, Function 44h, Subfunction 0Dh does NOT work;
         *           This function is called in DeviceParameters().
         */
        memset(&dpbDiskParms, 0, sizeof(DevPB));
        pBPB = &(dpbDiskParms.BPB);

        if (iCapacity != -1) {

            w = (WORD)GetMediaType(nDest);

            if (w) {
                switch (w) {
                    case 2:         // 720
                        if (iCapacity > DS720KB) {
                            w = IDS_720KB;
                            iCapacity = DS720KB;
                        } else
                            goto SensePass;
                        break;

                    case 7:         // 1.44
                        if (iCapacity > DS144M) {
                            w = IDS_144MB;
                            iCapacity = DS144M;
                        } else
                            goto SensePass;
                        break;
                    default:        // 2.88 and unknown case
                        goto SensePass;
                }

                LoadString(hAppInstance, IDS_FFERR_MEDIASENSE, szMsg, sizeof(szMsg));
                LoadString(hAppInstance, w, szTitle, sizeof(szTitle));
                wsprintf(szMessage, szMsg, (LPSTR)szTitle);
                LoadString(hAppInstance, IDS_FORMATERR, szTitle, sizeof(szTitle));
                if (MessageBox(hdlgProgress, szMessage, szTitle, MB_YESNO | MB_ICONINFORMATION) != IDYES) {
                    ret = IDS_FFERR_USERABORT;
                    goto FFErrExit3;
                }
            }

            SensePass:

            pBPB = &bpbList[iCapacity];
            cClusters = cCluster[iCapacity];

            // if we are formatting a 360K disk in a 1.2 MB drive set this
            // special flag

            if (iCapacity == DS48) {
                // We must remember to change the number of cylinders
                // while doing Set Device parameters; So, set this flag;
                fLowCapacity = TRUE;
            }
        } else {
            DWORD dwSec = pBPB->cSec;

            // use the default device parameters
            // NOTE: pBPB already points to proper data

            /* HPVECTRA: DOS 3.2 and above gives wrong sector count. */
            if (!pBPB->cSec)
                dwSec = dpbDiskParms.NumCyls * pBPB->secPerTrack * pBPB->cHead;

            /* Calculate the clusters for the disk. */
            cClusters = (WORD)(dwSec / pBPB->secPerClus) -
                        (pBPB->cSecRes + (pBPB->cFAT * pBPB->secPerFAT) +
                         (pBPB->cDir*32 + pBPB->cbSec - 1) / pBPB->cbSec) / pBPB->secPerClus;
        }

        /* Save the DriveParameterBlock for restoration latter */
        hSaveDiskParms = BuildDevPB(&dpbDiskParms);
        if (!hSaveDiskParms) {
            ret = IDS_FFERR_MEM;
            goto FFErrExit3;
        }
        pdpbSaveDiskParms = (PDevPB)LocalLock(hSaveDiskParms);

        /* Modify the parameters just for format */
        memcpy(&(dpbDiskParms.BPB), pBPB, sizeof(BPB));
        if (!SetDevParamsForFormat(nDest, &dpbDiskParms, fLowCapacity)) {
            ret = IDS_FFERR_MEM;
            goto FFErrExit3;
        }

    } else {
        // DOS < 3.2

        /* See if INT 13 knows the drive type. */
        switch (MyGetDriveType(nDest)) {
            case NOCHANGE:
                /* We assume that the machine is using old ROMS...
                 * Assume that we are using a 9-sector Double-sided 48tpi diskette.
                 */
                pBPB = &bpbList[DS48];
                cClusters = cCluster[DS48];
                lpDBT->lastsector = (BYTE)pBPB->secPerTrack;
                lpDBT->gaplengthf = 0x50;

                /* Try to format a track on side 1.  If this fails, assume that we
                 * have a Single-sided 48tpi diskette.
                 */
                if (FormatTrackHead(nDest, 0, 1, pBPB->secPerTrack, lpDiskBuffer)) {
                    pBPB = &bpbList[SS48];
                    cClusters = cCluster[SS48];
                }
                break;

            case CHANGE:
                if (iCapacity == DS48) {
                    /* User wants to format a 360KB floppy. */
                    pBPB = &bpbList[DS48];
                    cClusters = cCluster[DS48];
                } else {
                    /* User wants to format a 1.2 MB floppy */
                    pBPB = &bpbList[DS96];
                    cClusters = cCluster[DS96];
                }
                break;

            default:
                ret = IDS_FFERR_DRIVETYPE;
                goto FFErrExit5;
        }
    }

    lpDBT->lastsector = (BYTE)pBPB->secPerTrack;
    lpDBT->gaplengthf = (BYTE)(pBPB->secPerTrack == 15 ? 0x54 : 0x50);

    if (wDOSversion < DOS_320) {
        /* If 96tpi, fix up the Disk Base Table. */
        if (pBPB->bMedia == MEDIA_1200)      /* high density */
            if (pBPB->secPerTrack == 15)     /* then 1.2 Meg Drive */
                SetDASD(nDest, 3);           /* 1.2 MB floppy in 1.2MB drive */
    }

    LoadString(hAppInstance, IDS_PERCENTCOMP, szMsg, sizeof(szMsg));

    /* We believe that we know EXACTLY what is out there.  Allocate the boot
     * sector and the bad-cluster bit-map.  The boot sector buffer is reused as
     * two consecutive sectors of the FAT.
     */
    if (!(hBadClusterList = LocalAlloc(LHND, (LONG)((2 + cClusters + 7) / 8)))) {
        ret = IDS_FFERR_MEM;
        goto FFErrExit5;
    }

    lpBadClusterList = LocalLock(hBadClusterList);

    /* Let's format 1 track at a time and record the bad sectors in the
     * bitmap.  Note that we round DOWN the number of tracks so that we
     * don't format what might not be ours.  Fail if there are any bad
     * sectors in the system area.
     */

    /* Compute number of tracks to format. */
    if (!pBPB->cSec)
        cTracksToFormat = (WORD)dpbDiskParms.NumCyls;
    else
        cTracksToFormat = (WORD)(pBPB->cSec / pBPB->secPerTrack);


    /* Compute the starting track and head. */
    wCurrentTrack = pBPB->cSecHidden / (pBPB->secPerTrack * pBPB->cHead);
    wCurrentHead = (pBPB->cSecHidden % (pBPB->secPerTrack * pBPB->cHead))/pBPB->secPerTrack;

    /* Compute the number of the first sector after the system area. */
    wFirstDataSector = pBPB->cSecRes + pBPB->cFAT * pBPB->secPerFAT +
                       (pBPB->cDir * 32 + pBPB->cbSec-1) / pBPB->cbSec;

    cTotalTracks = cTracksToFormat;

    if (bQuick) {

        // read the boot sector to make sure the capacity selected
        // matches what it has been formated to

        iErrCode = GenericReadWriteSector(lpDiskBuffer, INT13_READ, nDest, 0, 0, 1);

        if (iErrCode || ((iCapacity != -1) && ((BOOTSEC *)lpDiskBuffer)->BPB.bMedia != bpbList[iCapacity].bMedia)) {

            fFormatFlags &= ~FF_QUICK;
            bQuick = FALSE;

            LoadString(hAppInstance, IDS_FORMATQUICKFAILURE, szMessage, 128);
            LoadString(hAppInstance, IDS_FORMAT, szTitle, 128);

            iErrCode = MessageBox(hdlgProgress, szMessage, szTitle, MB_YESNO | MB_ICONEXCLAMATION);

            if (iErrCode == IDYES)
                goto NormalFormat;
            else {
                ret = IDS_FFERR_USERABORT;
                goto FFErrExit;
            }
        }

    } else {

        NormalFormat:

        /* Format tracks one by one, checking if the user has "Aborted"
        * after each track is formatted; DlgProgreeProc() will set the global
        * bUserAbort, if the user has aborted;
        */
        while (cTracksToFormat) {

            /* Has the user aborted? */
            if (WFQueryAbort()) {
                ret = IDS_FFERR_USERABORT;
                goto FFErrExit;
            }

            /* If no message is pending, go ahead and format one track */
            if ((iErrCode = GenericFormatTrack(nDest, wCurrentTrack, wCurrentHead, pBPB->secPerTrack, lpDiskBuffer))) {

                /* Check if it is a fatal error */
                if (iErrCode == -1) {
                    // ret = IDS_FFERR_BADTRACK;
                    ret = IDS_FFERR;
                    goto FFErrExit;
                }

                /* Bad Track.  Compute the number of the first bad sector */
                cBadSectors = (wCurrentTrack * pBPB->cHead + wCurrentHead) * pBPB->secPerTrack;

                /* Fail if bad sector is in the system area */
                if (cBadSectors < wFirstDataSector) {
                    // ret = IDS_FFERR_BADTRACK;
                    ret = IDS_FFERR;
                    goto FFErrExit;
                }

                /* Enumerate all bad sectors and mark the corresponding
                * clusters as bad.
                */
                for (w=cBadSectors; w < cBadSectors + pBPB->secPerTrack; w++) {
                    wBadCluster = (w - wFirstDataSector) / pBPB->secPerClus + 2;
                    lpBadClusterList[wBadCluster/8] |= 1 << (wBadCluster % 8);
                }
            }

            cTracksToFormat--;

            /* Display the percentage of progress message */
            wPercentDone = (WORD)MulDiv(cTotalTracks - cTracksToFormat, 100, cTotalTracks);

            /* All tracks might have been formatted. But,
            * Still FAT and Root dir are to be created; It takes time; So,
            * make the user believe that still 1% formatting is left.
            */
            if (wPercentDone == 100)
                LoadString(hAppInstance, IDS_CREATEROOT, szMessage, sizeof(szMessage));
            else
                wsprintf(szMessage, szMsg, wPercentDone);

            SendDlgItemMessage(hdlgProgress, IDD_PROGRESS, WM_SETTEXT, 0, (LPARAM)szMessage);

            if (++wCurrentHead >= pBPB->cHead) {
                wCurrentHead = 0;
                wCurrentTrack++;
            }
        }
    }

    /* Write out the boot sector(s). */
    w = (WORD)WriteBootSector(nSource, nDest, pBPB, lpDiskBuffer);
    if (w) {
        // ret = IDS_FFERR_WRITEBOOT;
        if (w == 0x16)            // int24 unknown command, assume
            ret = IDS_SYSDISKNOFILES; // the int25 read failed
        else
            ret = IDS_FFERR;
        goto FFErrExit;
    }

    /* Has the user aborted? */
    if (WFQueryAbort()) {
        ret = IDS_FFERR_USERABORT;
        goto FFErrExit;
    }

    /* Format is complete.  Create correct DPB in system */
    SetDPB(nDest, pBPB, &DPB);

    // if doing a quick format keep the old bad cluster list

    /* Create FAT entries for each of the formatted clusters. */
    for (w=2; w < (WORD)(cClusters+2); w++) {

        if (bQuick) {
            wFATValue = 0;

            // is this entry reserved or marked as bad

            if ((wFATValue >= 0xFFF0) &&
                (wFATValue <= 0xFFF7)) {
                // yes, don't change it!
            } else {
                // mark as free

                if (0) {
                    // ret = IDS_FFERR_WRITEFAT;
                    ret = IDS_FFERR;
                    goto FFErrExit;
                }
            }

        } else {
            /* Was this cluster bad? */
            if (lpBadClusterList[w/8] & (1 << (w % 8)))
                wFATValue = 0xFFF7;
            else
                wFATValue = 0;

            /* Add this entry to the FAT (possibly writing the sector). */
            if (0) {
                // ret = IDS_FFERR_WRITEFAT;
                ret = IDS_FFERR;
                goto FFErrExit;
            }

        }
        if (WFQueryAbort()) {           /* Has the user aborted? */
            ret = IDS_FFERR_USERABORT;
            goto FFErrExit;
        }
    }

    /* Clean out the root directory. */
    memset(lpDiskBuffer, 0, CBSECTORSIZE);

    for (w=0; w < (WORD)((pBPB->cDir*32 + pBPB->cbSec-1)/pBPB->cbSec); w++) {
        /* Has the user aborted? */
        if (WFQueryAbort()) {
            ret = IDS_FFERR_USERABORT;
            goto FFErrExit;
        }
    }

    /* Should we make it a system disk also? */
    if (bMakeSysDisk) {
        LoadString(hAppInstance, IDS_COPYSYSFILES, szMessage, 32);
        SendDlgItemMessage(hdlgProgress, IDD_PROGRESS, WM_SETTEXT, 0, (LPARAM)szMessage);
        if (MakeSystemDiskette(nDest, TRUE)) {
            if (bUserAbort)
                ret = IDS_FFERR_USERABORT;
            else
                ret = IDS_FFERR_SYSFILES;
            goto FFErrExit;
        }
    }

    /* Normal Exit. */

    LocalUnlock(hBadClusterList);
    LocalFree(hBadClusterList);
    LocalUnlock(hDiskBuffer);

    if (hSaveDiskParms) {
        /* Restore the DriveParameterBlock */
        pdpbSaveDiskParms->SplFunctions = 4;

        LocalUnlock(hSaveDiskParms);
        LocalFree(hSaveDiskParms);
    }

    LocalFree(hDiskBuffer);
    *lpDBT = dbtSave;
    EnableWindow(hWnd, TRUE);
    DestroyWindow(hdlgProgress);
    hdlgProgress = NULL;
    return TRUE;

    FFErrExit:
    LocalUnlock(hBadClusterList);
    LocalFree(hBadClusterList);
    FFErrExit5:
    if (hSaveDiskParms) {
        /* Restore the DriveParameterBlock */
        pdpbSaveDiskParms->SplFunctions = 4;

        LocalUnlock(hSaveDiskParms);
        LocalFree(hSaveDiskParms);
    }
    LocalUnlock(hDiskBuffer);
    LocalFree(hDiskBuffer);
    FFErrExit3:
    *lpDBT = dbtSave;
    FFErrExit2:
    EnableWindow(hWnd, TRUE);
    DestroyWindow(hdlgProgress);
    hdlgProgress = NULL;
    FFErrExit1:

    if (ret != IDS_FFERR_USERABORT) {
        LoadString(hAppInstance, IDS_FORMATERR, szTitle, sizeof(szTitle));
        LoadString(hAppInstance, ret, szMessage, sizeof(szMessage));
        MessageBox(hWnd, szMessage, szTitle, MB_OK | MB_ICONSTOP);
    }
    return FALSE;
}


/*--------------------------------------------------------------------------*/
/*                                                                          */
/*  GetDriveCapacity() -                                                    */
/*                                                                          */
/*--------------------------------------------------------------------------*/

/* Parameter:
 *    Drive number;
 * Returns:
 *    0  if Error;
 *    1  if 360KB floppy;
 *    2  if 1.2MB floppy;
 *    3  if 720KB, 3.5" floppy;
 *    4  if 1.44MB, 3.5" floppy;
 *    5  if 2.88MB, 3.5" floppy;
 *
 * these are used +2 as indexes into bpbList[] FIX31
 *
 * HACK ALERT:
 *    One might wonder why on earth we are not using int13h Fn 8 to
 * perform this function; The reason is that in old compaq 386/16
 * machines(though the BIOS is dated Sep 1986), this function is NOT
 * supported! So, we are forced to do the following:
 *    We check the DOS version; If it is >= 3.2, then we make IOCTL
 * calls to get the Drive parameters and we find the Drive capacity;
 * If DOS version is < 3.2, then there can't be 3.5" floppies at all;
 * The only high capacity floppy possible is the 5.25", 1.2MB floppy;
 * So, we call MyGetDriveType() (int13h, Fn 15h) to find if the
 * change-line is supported by the drive; If it is supported then it
 * must be a 1.2MB floppy; Otherwise, it is a 360KB floppy;
 *    What do you think?  Smart! Ugh?
 */

WORD
APIENTRY
GetDriveCapacity(
                WORD nDrive
                )
{
    DevPB dpbDiskParms;           /* Device Parameters */
    PBPB pBPB;


    if (wDOSversion >= DOS_320) {

        /* NOTE: All the fields of dpbDiskParms must be initialized to 0,
         *   otherwise, INT 21h, Function 44h, Subfunction 0Dh does NOT work;
         *   This function is called in DeviceParameters().
         */
        memset(&dpbDiskParms, 0, sizeof(DevPB));
        dpbDiskParms.SplFunctions = 0;

        pBPB = &(dpbDiskParms.BPB);

        /* Check if this is a 1.44MB drive */
        if (pBPB->bMedia == MEDIA_1440) {
            if (pBPB->secPerTrack == 18)
                return 4;     /* 1.44MB drive */
            else if (pBPB->secPerTrack == 36)
                return 5;     /* 2.88MB drive */
        }

        /* Check if this is a 720KB or 1.2MB drive */
        if (pBPB->bMedia == MEDIA_1200) {
            if (pBPB->secPerFAT == 3)
                return 3; /* 720KB drive */
            if (pBPB->secPerFAT == 7)
                return 2; /* 1.2MB drive */
        }

        if (pBPB->bMedia == MEDIA_360)
            return 1;       /* Must be a 386KB floppy. */

        return 0;                 // I don't know!
    } else {

        /* See if INT 13 Fn 15h knows the drive type. */
        switch (MyGetDriveType(nDrive)) {
            case NOCHANGE:
                /* We assume that the machine is using old ROMS... */
                return 1;  /* No changeline support! Must be 360KB floppy */
                break;

            case CHANGE:
                return 2;  /* DOS versions < 3.2 can not have 1.44 or 720KB
                             * drive; So, this has to be a 1.2MB drive
                             */
                break;
            default:
                return 0;
        }
    }
}