Ignore:
Timestamp:
Apr 13, 2002, 8:31:53 AM (23 years ago)
Author:
bird
Message:

Optimized and rearranged OSLibGetDriveType. (Removed used of static IOCtl data, etc.).

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/kernel32/oslibdos.cpp

    r7927 r8259  
    1 /* $Id: oslibdos.cpp,v 1.96 2002-02-15 19:14:52 sandervl Exp $ */
     1/* $Id: oslibdos.cpp,v 1.97 2002-04-13 06:31:53 bird Exp $ */
    22/*
    33 * Wrappers for OS/2 Dos* API
    … …  
    170170    case ERROR_INVALID_ACCESS: //12
    171171        return ERROR_INVALID_ACCESS_W;
    172    
     172
    173173    case ERROR_INVALID_DATA: //13
    174174      return ERROR_INVALID_DATA_W;
    175    
     175
    176176    case ERROR_INVALID_DRIVE: //15
    177177      return ERROR_INVALID_DRIVE_W;
    178    
     178
    179179    case ERROR_CURRENT_DIRECTORY: // 16
    180180        return ERROR_CURRENT_DIRECTORY_W;
    181    
     181
    182182    case ERROR_NO_MORE_FILES: //18
    183183        return ERROR_NO_MORE_FILES_W;
    … …  
    185185    case ERROR_WRITE_PROTECT: //19
    186186        return ERROR_WRITE_PROTECT_W;
    187  
     187
    188188    case ERROR_BAD_UNIT: //20
    189189        return ERROR_BAD_UNIT_W;
    … …  
    191191    case ERROR_NOT_READY: //21
    192192        return ERROR_NOT_READY_W;
    193    
     193
    194194    case ERROR_CRC: //23
    195195        return ERROR_CRC_W;
    196    
     196
    197197    case ERROR_NOT_DOS_DISK: //26
    198198        return ERROR_NOT_DOS_DISK_W;
    … …  
    209209    case ERROR_LOCK_VIOLATION: //32
    210210        return ERROR_LOCK_VIOLATION_W;
    211    
     211
    212212    case ERROR_WRONG_DISK: //34
    213213        return ERROR_WRONG_DISK_W;
    214    
     214
    215215    case ERROR_SHARING_BUFFER_EXCEEDED: //36
    216216        return ERROR_SHARING_BUFFER_EXCEEDED_W;
    … …  
    233233    case ERROR_TOO_MANY_SEMAPHORES: //100
    234234        return ERROR_TOO_MANY_SEMAPHORES_W;
    235    
     235
    236236    case ERROR_DISK_CHANGE: // 107
    237237        return ERROR_DISK_CHANGE_W;
    238    
     238
    239239    case ERROR_DRIVE_LOCKED: //108
    240240        return ERROR_DRIVE_LOCKED_W;
    … …  
    272272    case ERROR_DISCARDED: //157
    273273        return ERROR_DISCARDED_W;
    274    
     274
    275275    case ERROR_INVALID_EXE_SIGNATURE: // 191
    276276      return ERROR_INVALID_EXE_SIGNATURE_W;
    277    
     277
    278278    case ERROR_EXE_MARKED_INVALID: // 192
    279279      return ERROR_EXE_MARKED_INVALID_W;
    280    
     280
    281281    case ERROR_BAD_EXE_FORMAT: // 193
    282282      return ERROR_BAD_EXE_FORMAT_W;
    283    
     283
    284284    case ERROR_FILENAME_EXCED_RANGE: //206
    285285        return ERROR_FILENAME_EXCED_RANGE_W;
    … …  
    311311    case ERROR_EAS_DIDNT_FIT: //275
    312312        return ERROR_EAS_DIDNT_FIT;
    313    
     313
    314314    // device driver specific error codes (I24)
    315315    case ERROR_USER_DEFINED_BASE + ERROR_I24_WRITE_PROTECT:
    316316       return ERROR_WRITE_PROTECT_W;
    317    
     317
    318318    case ERROR_USER_DEFINED_BASE + ERROR_I24_BAD_UNIT:
    319319       return ERROR_BAD_UNIT_W;
    320    
     320
    321321    case ERROR_USER_DEFINED_BASE + ERROR_I24_NOT_READY:
    322322       return ERROR_NOT_READY_W;
    323    
     323
    324324    case ERROR_USER_DEFINED_BASE + ERROR_I24_BAD_COMMAND:
    325325       return ERROR_BAD_COMMAND_W;
    326    
     326
    327327    case ERROR_USER_DEFINED_BASE + ERROR_I24_CRC:
    328328       return ERROR_CRC_W;
    329    
     329
    330330    case ERROR_USER_DEFINED_BASE + ERROR_I24_BAD_LENGTH:
    331331       return ERROR_BAD_LENGTH_W;
    332    
     332
    333333    case ERROR_USER_DEFINED_BASE + ERROR_I24_SEEK:
    334334       return ERROR_SEEK_W;
    335    
     335
    336336    case ERROR_USER_DEFINED_BASE + ERROR_I24_NOT_DOS_DISK:
    337337       return ERROR_NOT_DOS_DISK_W;
    338    
     338
    339339    case ERROR_USER_DEFINED_BASE + ERROR_I24_SECTOR_NOT_FOUND:
    340340       return ERROR_SECTOR_NOT_FOUND_W;
    341    
     341
    342342// @@@PH this error code is not defined in winconst.h
    343343//    case ERROR_USER_DEFINED_BASE + ERROR_I24_OUT_OF_PAPER:
    … …  
    346346    case ERROR_USER_DEFINED_BASE + ERROR_I24_WRITE_FAULT:
    347347       return ERROR_WRITE_FAULT_W;
    348  
     348
    349349    case ERROR_USER_DEFINED_BASE + ERROR_I24_READ_FAULT:
    350350       return ERROR_READ_FAULT_W;
    351    
     351
    352352    case ERROR_USER_DEFINED_BASE + ERROR_I24_GEN_FAILURE:
    353353       return ERROR_GEN_FAILURE_W;
    354    
     354
    355355    case ERROR_USER_DEFINED_BASE + ERROR_I24_DISK_CHANGE:
    356356       return ERROR_DISK_CHANGE_W;
    357    
     357
    358358    case ERROR_USER_DEFINED_BASE + ERROR_I24_WRONG_DISK:
    359359       return ERROR_WRONG_DISK_W;
    360    
     360
    361361    case ERROR_USER_DEFINED_BASE + ERROR_I24_INVALID_PARAMETER:
    362362       return ERROR_INVALID_PARAMETER_W;
    363  
     363
    364364    case ERROR_USER_DEFINED_BASE + ERROR_I24_DEVICE_IN_USE:
    365365       return ERROR_DEVICE_IN_USE_W;
    366    
     366
    367367    default:
    368368        dprintf(("WARNING: error2WinError: error %d not included!!!!", rc));
    … …  
    487487        *lplpMemAddr = pvMemAddr;
    488488
    489     return rc; 
     489    return rc;
    490490}
    491491//******************************************************************************
    … …  
    587587 ULONG  ulAction;
    588588 DWORD  os2flags = OPEN_FLAGS_NOINHERIT;
    589  char lOemFileName[260];       
     589 char lOemFileName[260];
    590590
    591591 CharToOemA(lpszFileName, lOemFileName);
    … …  
    617617               os2flags,
    618618               0L);                            /* No extended attribute */
    619   if(rc) 
    620   {
    621     if(rc == ERROR_TOO_MANY_OPEN_FILES) 
     619  if(rc)
     620  {
     621    if(rc == ERROR_TOO_MANY_OPEN_FILES)
    622622    {
    623623      ULONG CurMaxFH;
    … …  
    625625
    626626      rc = DosSetRelMaxFH(&ReqCount, &CurMaxFH);
    627       if(rc) 
     627      if(rc)
    628628      {
    629629        dprintf(("DosSetRelMaxFH returned %d", rc));
    … …  
    633633      goto tryopen;
    634634    }
    635    
     635
    636636    SetLastError(error2WinError(rc));
    637637    return 0;
    638638  }
    639  
     639
    640640  // OK, file was opened
    641641  SetLastError(ERROR_SUCCESS_W);
    … …  
    808808{
    809809 APIRET rc;
    810  char lOemFileName[260];       
     810 char lOemFileName[260];
    811811
    812812 CharToOemA(lpszFileName, lOemFileName);
    … …  
    16711671   DWORD hPipe;
    16721672   DWORD rc, ulAction;
    1673    
     1673
    16741674  if (dwOpenMode & PIPE_ACCESS_DUPLEX_W)
    16751675    dwOS2Mode |= NP_ACCESS_DUPLEX;
    … …  
    17241724  //create the named pipe
    17251725  rc = DosOpen(lpOS2Name, &hPipe, &ulAction, 0, FILE_NORMAL, FILE_OPEN,
    1726                ((dwOpenMode & PIPE_ACCESS_INBOUND_W) ? OPEN_ACCESS_READWRITE : OPEN_ACCESS_READONLY) | 
     1726               ((dwOpenMode & PIPE_ACCESS_INBOUND_W) ? OPEN_ACCESS_READWRITE : OPEN_ACCESS_READONLY) |
    17271727               OPEN_SHARE_DENYNONE, NULL);
    17281728
    … …  
    17921792                       DWORD fuCreate,
    17931793                       DWORD fuAttrFlags)
    1794 { 
     1794{
    17951795  LPSTR lpOS2Name;
    17961796  ULONG hPipe;
    … …  
    17981798  ULONG openFlag = 0;
    17991799  ULONG openMode = 0;
    1800    
     1800
    18011801
    18021802   switch(fuCreate)
    … …  
    18671867  else lpOS2Name = (LPSTR)lpName;
    18681868
    1869   rc = DosOpen(lpOS2Name, &hPipe, &ulAction, 0, 0, 
     1869  rc = DosOpen(lpOS2Name, &hPipe, &ulAction, 0, 0,
    18701870               openFlag, openMode, NULL);
    18711871
    … …  
    22852285
    22862286  ULONG oldmode = SetErrorMode(SEM_FAILCRITICALERRORS_W);
    2287   char    lOemFileName[260];       
     2287  char    lOemFileName[260];
    22882288
    22892289  CharToOemA(lpFileName, lOemFileName);
    … …  
    23392339
    23402340  ULONG oldmode = SetErrorMode(SEM_FAILCRITICALERRORS_W);
    2341   char  lOemFileName[260];       
     2341  char  lOemFileName[260];
    23422342
    23432343  CharToOemA(lpFileName, lOemFileName);
    … …  
    26142614//******************************************************************************
    26152615
    2616 #define FSAttachSpace 100
    2617 
    26182616#define CDType         0x8000
    26192617#define FloppyType     0x4000
    … …  
    26382636
    26392637// used for input to logical disk Get device parms Ioctl
    2640 struct {
    2641         UCHAR Infotype;
    2642         UCHAR DriveUnit;
    2643         } DriveRequest;
    2644 
    2645 // used for CD number of units Ioctl
    2646 struct {
    2647         USHORT count;
    2648         USHORT first;
    2649         } cdinfo;
    2650 
    2651 //******************************************************************************
    2652 ULONG OSLibGetDriveType(ULONG DriveIndex)
    2653 {
    2654  ULONG  ulDriveNum = 0;
    2655  ULONG  ulDriveMap = 0;
    2656  APIRET rc;
    2657  ULONG  parmsize,datasize;
    2658  ULONG  mask,Action;
    2659  HFILE  handle;
    2660  UCHAR  devname[5]="c:";
    2661  PFSQBUFFER2 fsinfo;
    2662  ULONG  len;
    2663  PSZ    name;
    2664  BIOSPARAMETERBLOCK device = {0};
    2665  UINT   type;
    2666 
    2667     rc = DosQueryCurrentDisk(&ulDriveNum, &ulDriveMap);
    2668     mask = 1 << DriveIndex;
    2669 
    2670     if(rc == NO_ERROR && (mask & ulDriveMap))
    2671     {//drive present??
    2672         parmsize=sizeof(DriveRequest);
    2673         datasize=sizeof(device);
    2674         DriveRequest.Infotype  = 0;
    2675         DriveRequest.DriveUnit = (UCHAR)DriveIndex;
    2676 
    2677         // Get BIOS parameter block
    2678         if(DosDevIOCtl(-1, IOCTL_DISK,DSK_GETDEVICEPARAMS,
    2679                        (PVOID)&DriveRequest, sizeof(DriveRequest),
    2680                        &parmsize, (PVOID)&device,
    2681                        sizeof(BIOSPARAMETERBLOCK), &datasize) == NO_ERROR)
     2638#pragma pack(1)
     2639typedef struct
     2640{
     2641    UCHAR   Infotype;
     2642    UCHAR   DriveUnit;
     2643} DSKREQ;
     2644
     2645/*------------------------------------------------*
     2646 * Cat 0x82, Func 0x60:  Return Drive Letter Info *
     2647 *------------------------------------------------*/
     2648typedef struct DriveLetter_Data
     2649{
     2650    USHORT  drive_count;
     2651    USHORT  first_drive_number;
     2652} CDDRVLTR;
     2653#pragma pack()
     2654
     2655
     2656/**
     2657 * Determin the type of a specific drive or the current drive.
     2658 *
     2659 * @returns DRIVE_UNKNOWN
     2660 *          DRIVE_NO_ROOT_DIR
     2661 *          DRIVE_CANNOTDETERMINE
     2662 *          DRIVE_DOESNOTEXIST
     2663 *          DRIVE_REMOVABLE
     2664 *          DRIVE_FIXED
     2665 *          DRIVE_REMOTE
     2666 *          DRIVE_CDROM
     2667 *          DRIVE_RAMDISK
     2668 *
     2669 * @param   ulDrive     Index of the drive which type we query.
     2670 *
     2671 * @status  completely implemented and tested
     2672 * @author  Vitali Pelenyov <sunlover@anduin.net>
     2673 * @author  bird
     2674 */
     2675ULONG OSLibGetDriveType(ULONG ulDrive)
     2676{
     2677    ULONG       cbParm;
     2678    ULONG       cbData;
     2679    ULONG       ulDriveNum = 0;
     2680    ULONG       ulDriveMap = 0;
     2681    APIRET      rc;
     2682    ULONG       ulDriveType;
     2683
     2684
     2685    /*
     2686     * Check if drive is present in the logical drive mask,
     2687     */
     2688    if (    DosQueryCurrentDisk(&ulDriveNum, &ulDriveMap)
     2689        || !(ulDriveMap & (1 << ulDrive))
     2690            )
     2691        return DRIVE_DOESNOTEXIST_W;
     2692
     2693
     2694    /*
     2695     * Optimize floppy queries for A: and B:.
     2696     * (I don't hope these are any subject of change.)
     2697     */
     2698    static ULONG ulFloppyMask = 0;
     2699    if (ulFloppyMask & (1 << ulDrive))
     2700        return DRIVE_REMOVABLE_W;
     2701
     2702
     2703    /*
     2704     * Check for CD drives
     2705     * We don't have to this everytime. I mean, the os2cdrom.dmd is
     2706     * exactly very dynamic when it comes to this info.
     2707     */
     2708    static  CDDRVLTR    cdDrvLtr = {0xffff, 0xffff};
     2709    if (cdDrvLtr.drive_count == 0xffff)
     2710    {
     2711        HFILE           hCDRom2;
     2712        ULONG           ulAction = 0;
     2713
     2714        if (DosOpen("\\DEV\\CD-ROM2$", &hCDRom2, &ulAction, 0,
     2715                    FILE_NORMAL, OPEN_ACTION_OPEN_IF_EXISTS,
     2716                    OPEN_SHARE_DENYNONE | OPEN_ACCESS_READONLY, NULL)
     2717            == NO_ERROR)
    26822718        {
    2683             if(device.bDeviceType == 0 && device.fsDeviceAttr == 0)
    2684             {   // fix for LAN type drives
    2685                 device.fsDeviceAttr = LanType;
    2686             }
    2687         }
    2688         else {//could be a LAN drive
    2689             device.fsDeviceAttr = LanType;
     2719            #define IOC_CDROM_2                 0x82 /* from cdioctl.h (ddk, os2cdrom.dmd sample) */
     2720            #define IOCD_RETURN_DRIVE_LETTER    0x60
     2721            cbData = sizeof(cdDrvLtr);
     2722            rc = DosDevIOCtl(hCDRom2,
     2723                             IOC_CDROM_2,
     2724                             IOCD_RETURN_DRIVE_LETTER,
     2725                             NULL, 0, NULL,
     2726                             (PVOID)&cdDrvLtr, sizeof(cdDrvLtr), &cbData);
     2727            DosClose(hCDRom2);
    26902728        }
    26912729    }
    2692     else {
    2693         //drive not present -> fail
    2694         return DRIVE_DOESNOTEXIST_W;
     2730
     2731
     2732    /*
     2733     * Is the drive present?? Lets the the BPB to check this.
     2734     * this should be a pretty speedy call if I'm not much mistaken.
     2735     */
     2736    BIOSPARAMETERBLOCK  bpb = {0};
     2737    DSKREQ              DskReq;
     2738    DskReq.Infotype  = 0;
     2739    DskReq.DriveUnit = (UCHAR)ulDrive;
     2740    cbParm = sizeof(DskReq);
     2741    cbData = sizeof(bpb);
     2742    if (DosDevIOCtl(-1, IOCTL_DISK, DSK_GETDEVICEPARAMS,
     2743                    (PVOID)&DskReq, sizeof(DskReq), &cbParm,
     2744                    (PVOID)&bpb, sizeof(BIOSPARAMETERBLOCK), &cbData)
     2745        == NO_ERROR)
     2746    {
     2747        if (bpb.bDeviceType == 0 && bpb.fsDeviceAttr == 0)
     2748            bpb.fsDeviceAttr = LanType;  // fix for LAN type drives
    26952749    }
    2696 
    2697     // check for CD drives
    2698     if(DosOpen("\\DEV\\CD-ROM2$", &handle,&Action,
    2699                0, FILE_NORMAL, OPEN_ACTION_OPEN_IF_EXISTS,
    2700                OPEN_SHARE_DENYNONE|OPEN_ACCESS_READONLY, NULL) == 0)
     2750    else
     2751        bpb.fsDeviceAttr = LanType; //could be a LAN drive - could it??
     2752
     2753
     2754    /*
     2755     * This is a CDROM/DVD drive
     2756     *
     2757     * Fix: When the cdrom is not last drive letter that
     2758     *      sometimes reports wrong index, have to check
     2759     *      that device type can be a CDROM one.
     2760     */
     2761    if (    cdDrvLtr.drive_count > 0
     2762        &&  (bpb.bDeviceType == DEVTYPE_UNKNOWN || bpb.bDeviceType == DEVTYPE_OPTICAL) // Other or RW optical
     2763        &&  ulDrive >= cdDrvLtr.first_drive_number
     2764        &&  ulDrive <  cdDrvLtr.first_drive_number + cdDrvLtr.drive_count
     2765            )
     2766        bpb.fsDeviceAttr |= CDType;
     2767
     2768
     2769    if (bpb.bDeviceType || bpb.fsDeviceAttr == LanType)
    27012770    {
    2702         datasize=sizeof(cdinfo);
    2703         rc = DosDevIOCtl(handle, 0x82, 0x60,
    2704                          NULL, 0,
    2705                          NULL, (PVOID)&cdinfo,
    2706                          sizeof(cdinfo),
    2707                          &datasize);
    2708         if(rc == NO_ERROR)
    2709         {
    2710             // this is a CDROM/DVD drive
    2711             // CDROM detection fix
    2712             // when cdrom is not last drive letter that sometimes
    2713             // reports wrong index, have to check that device type
    2714             // can be a CDROM one
    2715             if(device.bDeviceType == 7 || device.bDeviceType == 8) // Other or RW optical
    2716             // /CDROM detection fix
    2717                 if(cdinfo.first <= DriveIndex && DriveIndex < cdinfo.first + cdinfo.count)
    2718                     device.fsDeviceAttr |= CDType;
    2719         }
    2720         DosClose(handle);
    2721     }
    2722 
    2723     // disable error popups
    2724     DosError(FERR_DISABLEEXCEPTION | FERR_DISABLEHARDERR);
    2725 
    2726     fsinfo = (PFSQBUFFER2)malloc(FSAttachSpace);
    2727 
    2728     // if the device is removable and NOT a CD
    2729     if(device.bDeviceType || device.fsDeviceAttr == LanType)
    2730     {
    2731         if((device.fsDeviceAttr & (CDType | NonRemovable)) == 0)
    2732         {
    2733             devname[0] = (UCHAR)(DriveIndex+Binary_to_Printable);
    2734             len        = FSAttachSpace;
    2735             rc = DosQueryFSAttach((PSZ) devname, 0L, FSAIL_QUERYNAME,
    2736                                   fsinfo, &len);
    2737             if(rc == NO_ERROR)
     2771        if ((bpb.fsDeviceAttr & (CDType | NonRemovable)) == 0)
     2772        {   // if the device is removable and NOT a CD
     2773            CHAR        szDevName[4] = "A:";
     2774            PFSQBUFFER2 pfsqbuf2;
     2775
     2776            szDevName[0] += ulDrive;
     2777            cbData = sizeof(PFSQBUFFER2) + 3 * CCHMAXPATH;
     2778            pfsqbuf2 = (PFSQBUFFER2)malloc(cbData);
     2779            DosError(FERR_DISABLEEXCEPTION | FERR_DISABLEHARDERR); // disable error popups
     2780            rc = DosQueryFSAttach(&szDevName[0], 0L, FSAIL_QUERYNAME, pfsqbuf2, &cbData);
     2781            if (rc == NO_ERROR)
    27382782            {
    2739                 if(fsinfo->iType == FSAT_REMOTEDRV) {
    2740                    device.fsDeviceAttr |= LanType;
    2741                 }
    2742                 else
    2743                 if(fsinfo->iType == FSAT_LOCALDRV)
     2783                if (pfsqbuf2->iType == FSAT_REMOTEDRV)
     2784                    bpb.fsDeviceAttr |= LanType;
     2785                else if (pfsqbuf2->iType == FSAT_LOCALDRV)
    27442786                {
    2745                     name = (char *) fsinfo->szName;
    2746                     name += strlen(name)+1;
    2747                     if(strcmp(name,"FAT") == 0)
     2787                    PSZ pszFSName = (PSZ)pfsqbuf2->szName + pfsqbuf2->cbName;
     2788                    if (!strcmp(pszFSName, "FAT"))
    27482789                    {
    27492790                        // device is a removable FAT drive, so it MUST be diskette
    27502791                        // as Optical has another name as does LAN and SRVIFS
    2751                         if(device.bSectorsPerCluster != OpticalSectorsPerCluster)
    2752                         {
    2753                              device.fsDeviceAttr |= FloppyType;
    2754                         }
    2755                         else device.fsDeviceAttr |= OpticalType;
     2792                        if (bpb.bSectorsPerCluster != OpticalSectorsPerCluster)
     2793                            bpb.fsDeviceAttr |= FloppyType;
     2794                        else
     2795                            bpb.fsDeviceAttr |= OpticalType;
    27562796                    }
    2757                     // CDROM detection fix
     2797                    /*
     2798                     * CDROM detection fix
     2799                     */
    27582800                    else
    27592801                    {
    27602802                        // device is removable non-FAT, maybe it is CD?
    2761                         if (device.bDeviceType == 7 &&
    2762                             device.bMedia == 5 &&
    2763                             device.usBytesPerSector > 512)
    2764                         {
    2765                             device.fsDeviceAttr |= CDType;
    2766                         }
     2803                        if (    bpb.bDeviceType == DEVTYPE_UNKNOWN
     2804                            &&  bpb.bMedia == 5
     2805                            &&  bpb.usBytesPerSector > 512
     2806                                )
     2807                            bpb.fsDeviceAttr |= CDType;
    27672808                    }
    27682809                    // CDROM detection fix
    2769                  }
     2810                }
    27702811            }
    27712812            else // must be no media or audio only (for CDs at least)
    27722813            {
    2773                 if(device.cCylinders <= DisketteCylinders) // floppies will always be 80
    2774                 {                                          // or less cylinders
    2775                     if(device.bSectorsPerCluster != OpticalSectorsPerCluster) {
    2776                          device.fsDeviceAttr |= FloppyType;
    2777                     }
    2778                     else device.fsDeviceAttr |= OpticalType;
     2814                if (bpb.cCylinders <= DisketteCylinders) // floppies will always be 80
     2815                {
     2816                    // or less cylinders
     2817                    if (bpb.bSectorsPerCluster != OpticalSectorsPerCluster)
     2818                        bpb.fsDeviceAttr |= FloppyType;
     2819                    else
     2820                        bpb.fsDeviceAttr |= OpticalType;
    27792821                }
    27802822            }
    2781         }
    2782         else     
     2823
     2824            //Enable error popups again
     2825            DosError(FERR_ENABLEEXCEPTION | FERR_ENABLEHARDERR);
     2826
     2827            free(pfsqbuf2);
     2828        }
     2829        else
    27832830        {// non removable or CD type. maybe RAM disk
    2784             if(!(device.fsDeviceAttr & CDType))       // if NOT CD
     2831            if (!(bpb.fsDeviceAttr & CDType))       // if NOT CD
    27852832            {
    2786                 if(device.cFATs == 1)                 // is there only one FAT?
    2787                    device.fsDeviceAttr |= VDISKType;  // -> RAM disk
     2833                if (bpb.cFATs == 1)                 // is there only one FAT?
     2834                    bpb.fsDeviceAttr |= VDISKType;  // -> RAM disk
    27882835            }
    27892836        }
    27902837    }
    2791     free(fsinfo);
    2792 
    2793     if(device.fsDeviceAttr & FloppyType) {
    2794         type = DRIVE_REMOVABLE_W;
     2838
     2839
     2840    /*
     2841     * Determin return value.
     2842     */
     2843    if (bpb.fsDeviceAttr & FloppyType)
     2844    {
     2845        ulDriveType = DRIVE_REMOVABLE_W;
     2846        /* update floppy cache if A or B */
     2847        if (ulDrive <= 1)
     2848            ulFloppyMask |= 1 << ulDrive;
    27952849    }
    2796     else
    2797     if(device.fsDeviceAttr & CDType) {
    2798         type = DRIVE_CDROM_W;
    2799     }
    2800     else
    2801     if(device.fsDeviceAttr & LanType) {
    2802         type = DRIVE_REMOTE_W;
    2803     }
    2804     else
    2805     if(device.fsDeviceAttr & VDISKType) {
    2806         type = DRIVE_RAMDISK_W;
    2807     }
    2808     else
    2809     if(device.fsDeviceAttr & OpticalType || device.bDeviceType == DEVTYPE_OPTICAL) {
    2810         type = DRIVE_FIXED_W;
    2811     }
    2812     else
    2813     if(device.bDeviceType == DEVTYPE_FIXED) {
    2814         type = DRIVE_FIXED_W;
    2815     }
    2816     else type = 0;
    2817 
    2818     //Enable error popups again
    2819     DosError(FERR_ENABLEEXCEPTION | FERR_ENABLEHARDERR);
    2820 
    2821     return type;
     2850    else if (bpb.fsDeviceAttr & CDType)
     2851        ulDriveType = DRIVE_CDROM_W;
     2852    else if (bpb.fsDeviceAttr & LanType)
     2853        ulDriveType = DRIVE_REMOTE_W;
     2854    else if (bpb.fsDeviceAttr & VDISKType)
     2855        ulDriveType = DRIVE_RAMDISK_W;
     2856    else if (bpb.fsDeviceAttr & OpticalType || bpb.bDeviceType == DEVTYPE_OPTICAL)
     2857        ulDriveType = DRIVE_FIXED_W;
     2858    else if (bpb.bDeviceType == DEVTYPE_FIXED)
     2859        ulDriveType = DRIVE_FIXED_W;
     2860    else
     2861        ulDriveType = DRIVE_UNKNOWN_W;
     2862
     2863    return ulDriveType;
    28222864}
    28232865//******************************************************************************
    … …  
    28962938  PVOID pTiledData    = pData;
    28972939  BOOL  flagTiledData = FALSE;
    2898  
     2940
    28992941#define MEM_TILED_CEILING 0x1fffffff
    2900  
     2942
    29012943  // bounce buffer support
    29022944  // make sure no parameter or data buffer can pass the tiled memory region
    … …  
    29102952    if (rc)
    29112953      goto _exit_ioctl;
    2912    
     2954
    29132955    flagTiledParm = TRUE;
    29142956  }
    2915  
     2957
    29162958  if (pTiledData && (((DWORD)pTiledData + max(dwDataMaxLen, *pdwDataLen)) > MEM_TILED_CEILING))
    29172959  {
    … …  
    29192961    if (rc)
    29202962        goto _exit_ioctl;
    2921    
     2963
    29222964    flagTiledData = TRUE;
    29232965  }
    … …  
    29272969  if (pTiledParm != pParm)
    29282970    memcpy(pTiledParm, pParm, *pdwParmLen);
    2929  
     2971
    29302972  if (pTiledData != pData)
    29312973    memcpy(pTiledData, pData, *pdwDataLen);
    … …  
    29352977                     pParm, dwParmMaxLen, pdwParmLen,
    29362978                     pData, dwDataMaxLen, pdwDataLen);
    2937  
     2979
    29382980  // copy data from bounce buffers to real
    29392981  // target buffers if necessary
    29402982  if (pTiledParm != pParm)
    29412983    memcpy(pParm, pTiledParm, *pdwParmLen);
    2942  
     2984
    29432985  if (pTiledData != pData)
    29442986    memcpy(pData, pTiledData, *pdwDataLen);
    2945  
    2946  
     2987
     2988
    29472989  _exit_ioctl:
    2948  
     2990
    29492991  // deallocate bounce buffers
    29502992  if (flagTiledParm)
    29512993    DosFreeMem(pTiledParm);
    2952  
     2994
    29532995  if (flagTiledData)
    29542996    DosFreeMem(pTiledData);
    2955  
     2997
    29562998  rc = error2WinError(rc, ERROR_INVALID_HANDLE);
    29572999  SetLastError(rc);
    … …  
    30913133      CHAR pszError[32], pszModule[CCHMAXPATH];
    30923134
    3093       if(DosQueryModuleName( hmod, CCHMAXPATH, pszModule ) == 0 && 
    3094          DosLoadModule( pszError, 32, pszModule, &hmod ) == 0) 
     3135      if(DosQueryModuleName( hmod, CCHMAXPATH, pszModule ) == 0 &&
     3136         DosLoadModule( pszError, 32, pszModule, &hmod ) == 0)
    30953137      {
    30963138          rc = DosQueryProcAddr(hmod, ordinal, (PSZ)lpszProc, &pfn);
    … …  
    31103152  APIRET      rc;
    31113153
    3112     if(fInit == FALSE && pfnDosSetThreadAffinity == NULL) 
     3154    if(fInit == FALSE && pfnDosSetThreadAffinity == NULL)
    31133155    {
    31143156        ULONG nrCPUs;
    31153157
    31163158        rc = DosQuerySysInfo(QSV_NUMPROCESSORS, QSV_NUMPROCESSORS, &nrCPUs, sizeof(nrCPUs));
    3117         if (rc != 0 || nrCPUs == 1) 
     3159        if (rc != 0 || nrCPUs == 1)
    31183160        {//not supported
    31193161            fInit = TRUE;
    … …  
    31523194  APIRET      rc;
    31533195
    3154     if(fInit == FALSE && pfnDosQueryThreadAffinity == NULL) 
     3196    if(fInit == FALSE && pfnDosQueryThreadAffinity == NULL)
    31553197    {
    31563198        ULONG nrCPUs;
    31573199
    31583200        rc = DosQuerySysInfo(QSV_NUMPROCESSORS, QSV_NUMPROCESSORS, &nrCPUs, sizeof(nrCPUs));
    3159         if (rc != 0 || nrCPUs == 1) 
     3201        if (rc != 0 || nrCPUs == 1)
    31603202        {//not supported
    31613203            fInit = TRUE;
    … …  
    31993241    APIRET rc;
    32003242
    3201     switch(priority) 
     3243    switch(priority)
    32023244    {
    32033245    case THREAD_PRIORITY_IDLE_W:
Note: See TracChangeset for help on using the changeset viewer.