Changeset 4285 for trunk/src


Ignore:
Timestamp:
Sep 20, 2000, 11:32:58 PM (25 years ago)
Author:
hugh
Message:

Implemented Serial APIs

Location:
trunk/src/kernel32
Files:
13 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/kernel32/Fileio.cpp

    r4279 r4285  
    1 /* $Id: Fileio.cpp,v 1.40 2000-09-18 19:26:15 sandervl Exp $ */
     1/* $Id: Fileio.cpp,v 1.41 2000-09-20 21:32:50 hugh Exp $ */
    22
    33/*
    … …  
    9191  dprintf(("FindFirstFileA %s", lpFileName));
    9292  if(lpFileName == NULL || lpFindFileData == NULL) {
    93         SetLastError(ERROR_INVALID_PARAMETER);
    94         return -1;
     93  SetLastError(ERROR_INVALID_PARAMETER);
     94  return -1;
    9595  }
    9696  namelen = strlen(lpFileName);
    9797  if(lpFileName[namelen-1] == '\\') {
    98         filename = (char *)alloca(namelen+1);
    99         strcpy(filename, lpFileName);
    100         filename[namelen-1] = 0;
    101   }
    102   else  filename = (char *)lpFileName;
     98  filename = (char *)alloca(namelen+1);
     99  strcpy(filename, lpFileName);
     100  filename[namelen-1] = 0;
     101  }
     102  else  filename = (char *)lpFileName;
    103103
    104104  return (HANDLE)OSLibDosFindFirst(filename,lpFindFileData);
    … …  
    244244{
    245245   if (lpft1 == NULL || lpft2 == NULL) {
    246         SetLastError(ERROR_INVALID_PARAMETER);
    247         return -1;
    248    }     
     246  SetLastError(ERROR_INVALID_PARAMETER);
     247  return -1;
     248   }
    249249
    250250   if(lpft1->dwHighDateTime > lpft2->dwHighDateTime)
    251         return 1;
     251  return 1;
    252252
    253253   if(lpft1->dwHighDateTime < lpft2->dwHighDateTime)
    254         return -1;
     254  return -1;
    255255
    256256   if(lpft1->dwLowDateTime > lpft2->dwLowDateTime)
    257         return 1;
     257  return 1;
    258258
    259259   if(lpft1->dwLowDateTime < lpft2->dwLowDateTime)
    260         return -1;
     260  return -1;
    261261
    262262   return 0; //equal
    … …  
    342342  if((dwCopyFlags & COPY_FILE_FAIL_IF_EXISTS) != 0)
    343343  {
    344         failIfExists = TRUE;
     344      failIfExists = TRUE;
    345345  }
    346346
    … …  
    416416  rc = OSLibDosDelete((LPSTR)lpszFile);
    417417  if(!rc) {
    418         dprintf(("DeleteFileA %s returned FALSE; last error %x", lpszFile, GetLastError()));
    419         if(GetLastError() == 20) {
    420                 return TRUE;
    421         }
    422   } 
     418    dprintf(("DeleteFileA %s returned FALSE; last error %x", lpszFile, GetLastError()));
     419  if(GetLastError() == 20) {
     420    return TRUE;
     421  }
     422  }
    423423  else  dprintf(("DeleteFileA %s", lpszFile));
    424424
    … …  
    509509//******************************************************************************
    510510//******************************************************************************
    511 ODINFUNCTION5(BOOL,         ReadFileEx, 
     511ODINFUNCTION5(BOOL,         ReadFileEx,
    512512              HANDLE,       hFile,
    513513              LPVOID,       lpBuffer,
    … …  
    557557 *****************************************************************************/
    558558
    559 ODINFUNCTION5(BOOL,         WriteFileEx, 
     559ODINFUNCTION5(BOOL,         WriteFileEx,
    560560              HANDLE,       hFile,
    561561              LPVOID,       lpBuffer,
    … …  
    599599    }
    600600    else {
    601         rc = O32_GetFileAttributes((LPSTR)lpszFileName);
    602         if(rc == -1 && lpszFileName[strlen(lpszFileName)-1] != '\\') {
    603                 char *filename = (char *)alloca(strlen(lpszFileName)+2); //+2!!!!!!
    604                 strcpy(filename, lpszFileName);
     601  rc = O32_GetFileAttributes((LPSTR)lpszFileName);
     602  if(rc == -1 && lpszFileName[strlen(lpszFileName)-1] != '\\') {
     603    char *filename = (char *)alloca(strlen(lpszFileName)+2); //+2!!!!!!
     604    strcpy(filename, lpszFileName);
    605605                strcat(filename, "\\");
    606                 rc = O32_GetFileAttributes((LPSTR)filename);
    607         }
     606    rc = O32_GetFileAttributes((LPSTR)filename);
     607  }
    608608    }
    609609    //SvL: Open32 returns FILE_ATTRIBUTE_DIRECTORY|FILE_ATTRIBUTE_NORMAL for
    610610    //     directories whereas NT 4 (SP6) only returns FILE_ATTRIBUTE_DIRECTORY
    611611    if(rc != -1 && (rc & FILE_ATTRIBUTE_DIRECTORY)) {
    612         rc = FILE_ATTRIBUTE_DIRECTORY;
     612  rc = FILE_ATTRIBUTE_DIRECTORY;
    613613    }
    614614
    … …  
    671671{
    672672    char *ptr;
    673     dprintf(("KERNEL32:  GetFullPathName %s\n", arg1));
     673    DWORD rc;
     674    dprintf(("KERNEL32:  GetFullPathName called with %s %d %s \n", arg1, arg2, arg3));
    674675      while((ptr = strchr(arg1, '/')) != NULL)
    675676        *ptr = '\\';
    … …  
    913914  length = lstrlenA(lpszLongPath) + 1;
    914915  if(length > cchBuffer) {
    915         if(lpszShortPath) {
    916                 *lpszShortPath = 0;
    917         }
     916  if(lpszShortPath) {
     917          *lpszShortPath = 0;
     918  }
    918919        return(length); //return length required (including 0 terminator)
    919920  }
    … …  
    938939  length = lstrlenW(lpszLongPath) + 1;
    939940  if(length > cchBuffer) {
    940         if(lpszShortPath) {
    941                 *lpszShortPath = 0;
    942         }
     941  if(lpszShortPath) {
     942          *lpszShortPath = 0;
     943  }
    943944        return(length); //return length required (including 0 terminator)
    944945  }
    … …  
    11421143
    11431144    lpAsciiPath = UnicodeToAsciiString( (LPWSTR) lpPathName);
    1144     hChange = FindFirstChangeNotificationA(lpAsciiPath, bWatchSubtree, 
     1145    hChange = FindFirstChangeNotificationA(lpAsciiPath, bWatchSubtree,
    11451146                                           dwNotifyFilter );
    11461147    if (lpAsciiPath) FreeAsciiString(lpAsciiPath);

  • trunk/src/kernel32/HandleManager.cpp

    r4256 r4285  
    1 /* $Id: HandleManager.cpp,v 1.49 2000-09-13 21:10:56 sandervl Exp $ */
     1/* $Id: HandleManager.cpp,v 1.50 2000-09-20 21:32:50 hugh Exp $ */
    22
    33/*
    … …  
    1212 */
    1313
    14 #undef DEBUG_LOCAL
    15 //#define DEBUG_LOCAL
     14//#undef DEBUG_LOCAL
     15#define DEBUG_LOCAL
    1616
    1717
    … …  
    6363#include <vmutex.h>
    6464
    65 #define DBG_LOCALLOG    DBG_handlemanager
     65#define DBG_LOCALLOG  DBG_handlemanager
    6666#include "dbglocal.h"
    6767
    … …  
    7878 *****************************************************************************/
    7979
     80typedef struct _HMDEVICE;
    8081
    8182typedef struct _HMHANDLE
    … …  
    9293  LPSTR           pszDeviceName;       /* name or alias of the pseudo-device */
    9394  HMDeviceHandler *pDeviceHandler;         /* handler for this pseudo-device */
     95  VOID            *pDevData;         /* Pointer To Device data */
    9496} HMDEVICE, *PHMDEVICE;
    9597
    … …  
    155157static ULONG            _Optlink _HMHandleQuery(HANDLE hHandle);
    156158
     159// Get GlobalDeviceData
     160static VOID *_HMDeviceGetData (LPSTR pszDeviceName);
    157161
    158162
    … …  
    199203  return (HMGlobals.pHMOpen32);    /* haven't found anything, return default */
    200204}
    201 
     205/*****************************************************************************
     206 * Name      : static VOID *_HMDeviceGetData
     207 * Purpose   : obtain pointer to device data from the table by searching
     208 *             for a device name or alias
     209 * Parameters: PSZ pszDeviceName
     210 * Variables :
     211 * Result    : VOID * - pointer to the handlers device data
     212 * Remark    :
     213 * Status    :
     214 *
     215 * Author    : Markus Montkowski
     216 *****************************************************************************/
     217
     218static VOID *_HMDeviceGetData (LPSTR pszDeviceName)
     219{
     220  PHMDEVICE pHMDevice;                     /* iterator over the device table */
     221
     222  if (pszDeviceName != NULL)
     223    for (pHMDevice = TabWin32Devices;  /* loop over all devices in the table */
     224         pHMDevice != NULL;
     225         pHMDevice = pHMDevice->pNext)
     226    {
     227      if (stricmp(pHMDevice->pszDeviceName,       /* case-insensitive search */
     228                  pszDeviceName) == 0)
     229        return (pHMDevice->pDevData);    /* OK, we've found our device */
     230    }
     231
     232  return (NULL);    /* haven't found anything, return NULL */
     233}
    202234
    203235/*****************************************************************************
    … …  
    227259                                                       /* free handle found ? */
    228260    if (INVALID_HANDLE_VALUE == TabWin32Handles[ulLoop].hmHandleData.hHMHandle) {
    229         TabWin32Handles[ulLoop].hmHandleData.dwUserData     = 0;
    230         TabWin32Handles[ulLoop].hmHandleData.dwInternalType = HMTYPE_UNKNOWN;
    231         handleMutex.leave();
    232         return (ulLoop);                    /* OK, then return it to the caller */
     261  TabWin32Handles[ulLoop].hmHandleData.dwUserData     = 0;
     262  TabWin32Handles[ulLoop].hmHandleData.dwInternalType = HMTYPE_UNKNOWN;
     263  TabWin32Handles[ulLoop].hmHandleData.lpDeviceData   = NULL;
     264      handleMutex.leave();
     265        return (ulLoop);                    /* OK, then return it to the caller */
    233266    }
    234267  }
    … …  
    261294}
    262295
    263 
    264296/*****************************************************************************
    265297 * Name      : static int _HMHandleQuery
    … …  
    301333 *****************************************************************************/
    302334
    303 DWORD   HMDeviceRegister(LPSTR           pszDeviceName,
    304                          HMDeviceHandler *pDeviceHandler)
     335DWORD   HMDeviceRegisterEx(LPSTR           pszDeviceName,
     336                           HMDeviceHandler *pDeviceHandler,
     337                           VOID            *pDevData)
    305338{
    306339  PHMDEVICE pHMDevice;                     /* our new device to be allocated */
    … …  
    324357  pHMDevice->pDeviceHandler = pDeviceHandler;     /* store pointer to device */
    325358  pHMDevice->pNext = TabWin32Devices;                   /* establish linkage */
     359  pHMDevice->pDevData = pDevData;
    326360
    327361  TabWin32Devices = pHMDevice;        /* insert new node as root in the list */
    … …  
    330364}
    331365
     366DWORD   HMDeviceRegister(LPSTR           pszDeviceName,
     367                         HMDeviceHandler *pDeviceHandler)
     368{
     369  return HMDeviceRegisterEx(pszDeviceName, pDeviceHandler, NULL);
     370}
    332371
    333372/*****************************************************************************
    … …  
    355394    // fill handle table
    356395    for(ulIndex = 0; ulIndex < MAX_OS2_HMHANDLES; ulIndex++) {
    357         TabWin32Handles[ulIndex].hmHandleData.hHMHandle = INVALID_HANDLE_VALUE;
     396        TabWin32Handles[ulIndex].hmHandleData.hHMHandle = INVALID_HANDLE_VALUE;
    358397    }
    359398    handleMutex.leave();
    … …  
    471510
    472511  if(ulHandle == 0) {
    473         ulHandle = 1; //SvL: Start searching from index 1
     512  ulHandle = 1; //SvL: Start searching from index 1
    474513  }
    475514  do
    … …  
    478517    if (TabWin32Handles[ulHandle].hmHandleData.hHMHandle == INVALID_HANDLE_VALUE)
    479518    {
    480         *phHandle16 = ulHandle;
    481         TabWin32Handles[ulHandle].hmHandleData.hHMHandle = hHandleOS2;
    482         HMGlobals.ulHandleLast = ulHandle;          /* to shorten search times */
    483 
    484         handleMutex.leave();
    485         return (NO_ERROR);                                               /* OK */
     519      *phHandle16 = ulHandle;
     520        TabWin32Handles[ulHandle].hmHandleData.hHMHandle = hHandleOS2;
     521        TabWin32Handles[ulHandle].hmHandleData.lpDeviceData = NULL;
     522        HMGlobals.ulHandleLast = ulHandle;          /* to shorten search times */
     523
     524    handleMutex.leave();
     525        return (NO_ERROR);                                               /* OK */
    486526    }
    487527
    … …  
    771811
    772812  if((fdwOdinOptions & DUPLICATE_ACCESS_READWRITE) == DUPLICATE_ACCESS_READWRITE) {
    773         pHMHandleData->dwAccess = GENERIC_READ | GENERIC_WRITE;
    774   }
    775   else 
     813  pHMHandleData->dwAccess = GENERIC_READ | GENERIC_WRITE;
     814  }
     815  else
    776816  if(fdwOdinOptions & DUPLICATE_ACCESS_READ) {
    777         pHMHandleData->dwAccess = GENERIC_READ;
     817  pHMHandleData->dwAccess = GENERIC_READ;
    778818  }
    779819
    780820  if(fdwOdinOptions & DUPLICATE_SHARE_READ) {
    781         pHMHandleData->dwShare = FILE_SHARE_READ;
    782   } 
     821  pHMHandleData->dwShare = FILE_SHARE_READ;
     822  }
    783823  else
    784824  if(fdwOdinOptions & DUPLICATE_SHARE_DENYNONE) {
    785         pHMHandleData->dwShare = FILE_SHARE_READ | FILE_SHARE_WRITE;
     825  pHMHandleData->dwShare = FILE_SHARE_READ | FILE_SHARE_WRITE;
    786826  }
    787827  else  pHMHandleData->dwShare = TabWin32Handles[srchandle].hmHandleData.dwShare;
    … …  
    798838  TabWin32Handles[iIndexNew].hmHandleData.hHMHandle = iIndexNew;
    799839  TabWin32Handles[iIndexNew].pDeviceHandler         = pDeviceHandler;
    800 
    801840                                                  /* call the device handler */
    802841  rc = pDeviceHandler->DuplicateHandle(&TabWin32Handles[iIndexNew].hmHandleData,
    … …  
    854893  PHMHANDLEDATA   pHMHandleData;
    855894  HMHANDLEDATA    HMHandleTemp;          /* temporary buffer for handle data */
     895  VOID            *pDevData;
    856896
    857897  /* create new handle by either lpFileName or hTemplateFile */
    … …  
    874914  {
    875915    pDeviceHandler = _HMDeviceFind((LPSTR)lpFileName);        /* find device */
    876 
    877916    if (NULL == pDeviceHandler)                /* this name is unknown to us */
    878917    {
    … …  
    883922      pHMHandleData  = NULL;
    884923
     924    pDevData       = _HMDeviceGetData((LPSTR)lpFileName);
     925
    885926    if(pDeviceHandler == HMGlobals.pHMOpen32) {
    886         pDeviceHandler = HMGlobals.pHMFile;
     927  pDeviceHandler = HMGlobals.pHMFile;
    887928    }
    888929  }
    … …  
    910951    HMHandleTemp.dwFlags    = dwFlagsAndAttributes;
    911952    HMHandleTemp.lpHandlerData = NULL;
     953    HMHandleTemp.lpDeviceData  = pDevData;
    912954  }
    913955
    … …  
    918960  HMHandleTemp.hHMHandle                    = iIndexNew;
    919961  TabWin32Handles[iIndexNew].pDeviceHandler = pDeviceHandler;
    920 
    921962                                  /* now copy back our temporary handle data */
    922963  memcpy(&TabWin32Handles[iIndexNew].hmHandleData,
    … …  
    10081049  int             iIndexNew;                  /* index into the handle table */
    10091050  HMDeviceHandler *pDeviceHandler;         /* device handler for this handle */
     1051  VOID            *pDevData;
    10101052  PHMHANDLEDATA   pHMHandleData;
    10111053  DWORD           rc;                                     /* API return code */
    … …  
    10201062  else
    10211063    pHMHandleData  = NULL;
     1064
     1065  pDevData       = _HMDeviceGetData((LPSTR)lpFileName);
    10221066
    10231067  if(pDeviceHandler == HMGlobals.pHMOpen32) {
    … …  
    10461090  pHMHandleData->dwFlags    = 0;
    10471091  pHMHandleData->lpHandlerData = NULL;
    1048 
     1092  pHMHandleData->lpDeviceData  = pDevData;
    10491093
    10501094      /* we've got to mark the handle as occupied here, since another device */
    … …  
    10531097          /* write appropriate entry into the handle table if open succeeded */
    10541098  TabWin32Handles[iIndexNew].hmHandleData.hHMHandle = iIndexNew;
    1055   TabWin32Handles[iIndexNew].pDeviceHandler       = pDeviceHandler;
     1099  TabWin32Handles[iIndexNew].pDeviceHandler         = pDeviceHandler;
    10561100
    10571101  rc = pDeviceHandler->OpenFile  (lpFileName,     /* call the device handler */
    … …  
    10691113  if(rc != NO_ERROR)     /* oops, creation failed within the device handler */
    10701114  {
    1071         TabWin32Handles[iIndexNew].hmHandleData.hHMHandle = INVALID_HANDLE_VALUE;
    1072         SetLastError(pOFStruct->nErrCode);
    1073         return (INVALID_HANDLE_VALUE);                           /* signal error */
     1115      TabWin32Handles[iIndexNew].hmHandleData.hHMHandle = INVALID_HANDLE_VALUE;
     1116      SetLastError(pOFStruct->nErrCode);
     1117      return (INVALID_HANDLE_VALUE);                           /* signal error */
    10741118  }
    10751119  else {
    1076         if(fuMode & (OF_DELETE|OF_EXIST)) {
    1077                 //file handle already closed
    1078                 TabWin32Handles[iIndexNew].hmHandleData.hHMHandle = INVALID_HANDLE_VALUE;
    1079                 return TRUE; //TODO: correct?
    1080         }
    1081         if(fuMode & OF_PARSE) {
    1082                 TabWin32Handles[iIndexNew].hmHandleData.hHMHandle = INVALID_HANDLE_VALUE;
    1083                 return 0;
    1084         }
    1085         if(fuMode & OF_VERIFY) {
    1086                 TabWin32Handles[iIndexNew].hmHandleData.hHMHandle = INVALID_HANDLE_VALUE;
    1087                 return 1; //TODO: correct?
    1088         }
     1120    if(fuMode & (OF_DELETE|OF_EXIST)) {
     1121    //file handle already closed
     1122        TabWin32Handles[iIndexNew].hmHandleData.hHMHandle = INVALID_HANDLE_VALUE;
     1123    return TRUE; //TODO: correct?
     1124  }
     1125  if(fuMode & OF_PARSE) {
     1126        TabWin32Handles[iIndexNew].hmHandleData.hHMHandle = INVALID_HANDLE_VALUE;
     1127    return 0;
     1128  }
     1129  if(fuMode & OF_VERIFY) {
     1130        TabWin32Handles[iIndexNew].hmHandleData.hHMHandle = INVALID_HANDLE_VALUE;
     1131    return 1; //TODO: correct?
     1132  }
    10891133  }
    10901134
    … …  
    10921136  dprintf(("KERNEL32/HandleManager: OpenFile(%s)=%08xh\n",
    10931137           lpFileName,
    1094            hResult));
     1138           iIndexNew));
    10951139#endif
    10961140
    … …  
    18041848    dprintf(("KERNEL32: HandleManager:HMWaitForSingleObject(%08xh) passed on to Open32.\n",
    18051849             hObject));
    1806    
     1850
    18071851    // maybe handles from CreateProcess() ...
    18081852    dwResult = O32_WaitForSingleObject(hObject, dwTimeout);
    … …  
    25762620  if (rc != NO_ERROR)     /* oops, creation failed within the device handler */
    25772621  {
    2578         TabWin32Handles[iIndexNew].hmHandleData.hHMHandle = INVALID_HANDLE_VALUE;
    2579         SetLastError(rc);          /* Hehe, OS/2 and NT are pretty compatible :) */
    2580         if(rc == ERROR_ALREADY_EXISTS) {
    2581                 return hOldMemMap; //return handle of existing file mapping
    2582         }
    2583         else    return (NULL);                                           /* signal error */
     2622      TabWin32Handles[iIndexNew].hmHandleData.hHMHandle = INVALID_HANDLE_VALUE;
     2623      SetLastError(rc);          /* Hehe, OS/2 and NT are pretty compatible :) */
     2624    if(rc == ERROR_ALREADY_EXISTS) {
     2625    return hOldMemMap; //return handle of existing file mapping
     2626  }
     2627  else  return (NULL);                                           /* signal error */
    25842628  }
    25852629  else
    … …  
    27582802               *pLoop1));
    27592803
    2760           *pLoop2 = *pLoop1;
     2804    *pLoop2 = *pLoop1;
    27612805////      O32_SetLastError(ERROR_INVALID_HANDLE);
    27622806////      return (WAIT_FAILED);
    … …  
    28132857 *****************************************************************************/
    28142858
    2815 DWORD  HMMsgWaitForMultipleObjects  (DWORD                      nCount,
    2816                                      LPHANDLE                   pHandles,
    2817                                      BOOL                       fWaitAll,
    2818                                      DWORD                      dwMilliseconds,
    2819                                      DWORD                      dwWakeMask)
     2859DWORD  HMMsgWaitForMultipleObjects  (DWORD      nCount,
     2860                                     LPHANDLE       pHandles,
     2861                                     BOOL       fWaitAll,
     2862                                     DWORD      dwMilliseconds,
     2863                                     DWORD      dwWakeMask)
    28202864{
    28212865  ULONG   ulIndex;
    … …  
    28292873  if (pArrayOfHandles == NULL)
    28302874  {
    2831         dprintf(("ERROR: HMMsgWaitForMultipleObjects: alloca failed to allocate %d handles", nCount));
    2832         O32_SetLastError(ERROR_NOT_ENOUGH_MEMORY);
    2833         return WAIT_FAILED;
     2875  dprintf(("ERROR: HMMsgWaitForMultipleObjects: alloca failed to allocate %d handles", nCount));
     2876      O32_SetLastError(ERROR_NOT_ENOUGH_MEMORY);
     2877      return WAIT_FAILED;
    28342878  }
    28352879  else
    … …  
    28542898               *pLoop1));
    28552899
    2856           *pLoop2 = *pLoop1;
     2900    *pLoop2 = *pLoop1;
    28572901////      O32_SetLastError(ERROR_INVALID_HANDLE);
    28582902////      return (WAIT_FAILED);
    … …  
    29102954
    29112955
    2912 /*****************************************************************************
    2913  * Name      : HMSetupComm
    2914  * Purpose   : router function for SetupComm
    2915  * Parameters:
    2916  * Variables :
    2917  * Result    :
    2918  * Remark    :
    2919  * Status    :
    2920  *
    2921  * Author    : Achim Hasenmueller [Sat, 1999/11/27 13:13]
    2922  *****************************************************************************/
    2923 
    2924 BOOL HMSetupComm(HANDLE hFile, DWORD dwInQueue, DWORD dwOutQueue)
     2956
     2957/*****************************************************************************
     2958 * Name      : HMCOMGetCommState
     2959 * Purpose   : router function for GetCommState
     2960 * Parameters:
     2961 * Variables :
     2962 * Result    :
     2963 * Remark    :
     2964 * Status    :
     2965 *
     2966 * Author    : Achim Hasenmueller [Sat, 1999/11/27 13:40]
     2967 *****************************************************************************/
     2968
     2969BOOL HMCommGetCommState(HANDLE hCommDev, LPDCB lpdcb)
    29252970{
    29262971  int       iIndex;                           /* index into the handle table */
    … …  
    29292974
    29302975                                                          /* validate handle */
    2931   iIndex = _HMHandleQuery(hFile);              /* get the index */
     2976  iIndex = _HMHandleQuery(hCommDev);              /* get the index */
    29322977  if (-1 == iIndex)                                               /* error ? */
    29332978  {
    … …  
    29362981  }
    29372982
    2938   pHMHandle = &TabWin32Handles[iIndex];               /* call device handler */
    2939   bResult = pHMHandle->pDeviceHandler->SetupComm(&pHMHandle->hmHandleData,
    2940                                                  dwInQueue, dwOutQueue);
    2941 
    2942   return (bResult);                                  /* deliver return code */
    2943 }
    2944 
    2945 
    2946 /*****************************************************************************
    2947  * Name      : HMGetCommState
    2948  * Purpose   : router function for GetCommState
    2949  * Parameters:
    2950  * Variables :
    2951  * Result    :
    2952  * Remark    :
    2953  * Status    :
    2954  *
    2955  * Author    : Achim Hasenmueller [Sat, 1999/11/27 13:40]
    2956  *****************************************************************************/
    2957 
    2958 BOOL HMGetCommState(INT hCommDev, LPDCB lpdcb)
    2959 {
    2960   int       iIndex;                           /* index into the handle table */
    2961   BOOL      bResult;                /* result from the device handler's API */
    2962   PHMHANDLE pHMHandle;       /* pointer to the handle structure in the table */
    2963 
    2964                                                           /* validate handle */
    2965   iIndex = _HMHandleQuery(hCommDev);              /* get the index */
    2966   if (-1 == iIndex)                                               /* error ? */
    2967   {
    2968     SetLastError(ERROR_INVALID_HANDLE);       /* set win32 error information */
    2969     return (NULL);                                         /* signal failure */
     2983  if(IsBadWritePtr(lpdcb,sizeof(DCB)))
     2984  {
     2985    SetLastError(ERROR_INVALID_PARAMETER);
     2986    return FALSE;
    29702987  }
    29712988
    … …  
    29732990  bResult = pHMHandle->pDeviceHandler->GetCommState(&pHMHandle->hmHandleData,
    29742991                                                    lpdcb);
     2992
     2993  return (bResult);                                  /* deliver return code */
     2994}
     2995
     2996BOOL HMCommWaitCommEvent( HANDLE hCommDev,
     2997                          LPDWORD lpfdwEvtMask,
     2998                          LPOVERLAPPED lpo)
     2999{
     3000  int       iIndex;                           /* index into the handle table */
     3001  BOOL      bResult;                /* result from the device handler's API */
     3002  PHMHANDLE pHMHandle;       /* pointer to the handle structure in the table */
     3003
     3004                                                          /* validate handle */
     3005  iIndex = _HMHandleQuery(hCommDev);              /* get the index */
     3006  if (-1 == iIndex)                                               /* error ? */
     3007  {
     3008    SetLastError(ERROR_INVALID_HANDLE);       /* set win32 error information */
     3009    return FALSE;                                         /* signal failure */
     3010  }
     3011
     3012  if(NULL!=lpo && IsBadReadPtr(lpo,sizeof(OVERLAPPED)) )
     3013  {
     3014    SetLastError(ERROR_INVALID_PARAMETER);
     3015    return FALSE;
     3016  }
     3017
     3018  pHMHandle = &TabWin32Handles[iIndex];               /* call device handler */
     3019  bResult = pHMHandle->pDeviceHandler->WaitCommEvent( &pHMHandle->hmHandleData,
     3020                                                      lpfdwEvtMask,
     3021                                                      lpo);
     3022
     3023  return (bResult);                                  /* deliver return code */
     3024}
     3025
     3026BOOL HMCommGetCommProperties( HANDLE hCommDev,
     3027                              LPCOMMPROP lpcmmp)
     3028{
     3029  int       iIndex;                           /* index into the handle table */
     3030  BOOL      bResult;                /* result from the device handler's API */
     3031  PHMHANDLE pHMHandle;       /* pointer to the handle structure in the table */
     3032
     3033                                                          /* validate handle */
     3034  iIndex = _HMHandleQuery(hCommDev);              /* get the index */
     3035  if (-1 == iIndex)                                               /* error ? */
     3036  {
     3037    SetLastError(ERROR_INVALID_HANDLE);       /* set win32 error information */
     3038    return (NULL);                                         /* signal failure */
     3039  }
     3040
     3041  if(IsBadWritePtr(lpcmmp,sizeof(COMMPROP)) )
     3042  {
     3043    SetLastError(ERROR_INVALID_PARAMETER);
     3044    return FALSE;
     3045  }
     3046
     3047  pHMHandle = &TabWin32Handles[iIndex];               /* call device handler */
     3048  bResult = pHMHandle->pDeviceHandler->GetCommProperties( &pHMHandle->hmHandleData,
     3049                                                          lpcmmp);
     3050
     3051  return (bResult);                                  /* deliver return code */
     3052}
     3053
     3054BOOL HMCommGetCommMask( HANDLE hCommDev,
     3055                        LPDWORD lpfdwEvtMask)
     3056{
     3057  int       iIndex;                           /* index into the handle table */
     3058  BOOL      bResult;                /* result from the device handler's API */
     3059  PHMHANDLE pHMHandle;       /* pointer to the handle structure in the table */
     3060
     3061                                                          /* validate handle */
     3062  iIndex = _HMHandleQuery(hCommDev);              /* get the index */
     3063  if (-1 == iIndex)                                               /* error ? */
     3064  {
     3065    SetLastError(ERROR_INVALID_HANDLE);       /* set win32 error information */
     3066    return (NULL);                                         /* signal failure */
     3067  }
     3068
     3069  if(IsBadWritePtr(lpfdwEvtMask,sizeof(DWORD)) )
     3070  {
     3071    SetLastError(ERROR_INVALID_PARAMETER);
     3072    return FALSE;
     3073  }
     3074
     3075  pHMHandle = &TabWin32Handles[iIndex];               /* call device handler */
     3076  bResult = pHMHandle->pDeviceHandler->GetCommMask( &pHMHandle->hmHandleData,
     3077                                                    lpfdwEvtMask);
     3078
     3079  return (bResult);                                  /* deliver return code */
     3080}
     3081
     3082BOOL HMCommSetCommMask( HANDLE hCommDev,
     3083                        DWORD fdwEvtMask)
     3084{
     3085  int       iIndex;                           /* index into the handle table */
     3086  BOOL      bResult;                /* result from the device handler's API */
     3087  PHMHANDLE pHMHandle;       /* pointer to the handle structure in the table */
     3088
     3089                                                          /* validate handle */
     3090  iIndex = _HMHandleQuery(hCommDev);              /* get the index */
     3091  if (-1 == iIndex)                                               /* error ? */
     3092  {
     3093    SetLastError(ERROR_INVALID_HANDLE);       /* set win32 error information */
     3094    return (NULL);                                         /* signal failure */
     3095  }
     3096
     3097  pHMHandle = &TabWin32Handles[iIndex];               /* call device handler */
     3098  bResult = pHMHandle->pDeviceHandler->SetCommMask( &pHMHandle->hmHandleData,
     3099                                                    fdwEvtMask);
     3100
     3101  return (bResult);                                  /* deliver return code */
     3102}
     3103
     3104BOOL HMCommPurgeComm( HANDLE hCommDev,
     3105                      DWORD fdwAction)
     3106{
     3107  int       iIndex;                           /* index into the handle table */
     3108  BOOL      bResult;                /* result from the device handler's API */
     3109  PHMHANDLE pHMHandle;       /* pointer to the handle structure in the table */
     3110
     3111                                                          /* validate handle */
     3112  iIndex = _HMHandleQuery(hCommDev);              /* get the index */
     3113  if (-1 == iIndex)                                               /* error ? */
     3114  {
     3115    SetLastError(ERROR_INVALID_HANDLE);       /* set win32 error information */
     3116    return (NULL);                                         /* signal failure */
     3117  }
     3118
     3119
     3120  pHMHandle = &TabWin32Handles[iIndex];               /* call device handler */
     3121  bResult = pHMHandle->pDeviceHandler->PurgeComm( &pHMHandle->hmHandleData,
     3122                                                  fdwAction);
     3123
     3124  return (bResult);                                  /* deliver return code */
     3125}
     3126
     3127BOOL HMCommClearCommError( HANDLE hCommDev,
     3128                           LPDWORD lpdwErrors,
     3129                           LPCOMSTAT lpcst)
     3130{
     3131  int       iIndex;                           /* index into the handle table */
     3132  BOOL      bResult;                /* result from the device handler's API */
     3133  PHMHANDLE pHMHandle;       /* pointer to the handle structure in the table */
     3134
     3135                                                          /* validate handle */
     3136  iIndex = _HMHandleQuery(hCommDev);              /* get the index */
     3137  if (-1 == iIndex)                                               /* error ? */
     3138  {
     3139    SetLastError(ERROR_INVALID_HANDLE);       /* set win32 error information */
     3140    return (NULL);                                         /* signal failure */
     3141  }
     3142
     3143  if(IsBadWritePtr(lpdwErrors,sizeof(DWORD)) ||
     3144     (NULL!=lpcst && IsBadWritePtr(lpcst,sizeof(COMSTAT)) ) )
     3145  {
     3146    SetLastError(ERROR_INVALID_PARAMETER);
     3147    return FALSE;
     3148  }
     3149
     3150  pHMHandle = &TabWin32Handles[iIndex];               /* call device handler */
     3151  bResult = pHMHandle->pDeviceHandler->ClearCommError(&pHMHandle->hmHandleData,
     3152                                                      lpdwErrors,
     3153                                                      lpcst);
     3154
     3155  return (bResult);                                  /* deliver return code */
     3156}
     3157
     3158BOOL HMCommSetCommState( HANDLE hCommDev,
     3159                         LPDCB lpdcb)
     3160{
     3161  int       iIndex;                           /* index into the handle table */
     3162  BOOL      bResult;                /* result from the device handler's API */
     3163  PHMHANDLE pHMHandle;       /* pointer to the handle structure in the table */
     3164
     3165                                                          /* validate handle */
     3166  iIndex = _HMHandleQuery(hCommDev);              /* get the index */
     3167  if (-1 == iIndex)                                               /* error ? */
     3168  {
     3169    SetLastError(ERROR_INVALID_HANDLE);       /* set win32 error information */
     3170    return (NULL);                                         /* signal failure */
     3171  }
     3172
     3173  if(IsBadReadPtr(lpdcb,sizeof(DCB)) )
     3174  {
     3175    SetLastError(ERROR_INVALID_PARAMETER);
     3176    return FALSE;
     3177  }
     3178
     3179
     3180  pHMHandle = &TabWin32Handles[iIndex];               /* call device handler */
     3181  bResult = pHMHandle->pDeviceHandler->SetCommState(&pHMHandle->hmHandleData,
     3182                                                    lpdcb);
     3183
     3184  return (bResult);                                  /* deliver return code */
     3185}
     3186
     3187
     3188BOOL HMCommGetCommTimeouts( HANDLE hCommDev,
     3189                            LPCOMMTIMEOUTS lpctmo)
     3190{
     3191  int       iIndex;                           /* index into the handle table */
     3192  BOOL      bResult;                /* result from the device handler's API */
     3193  PHMHANDLE pHMHandle;       /* pointer to the handle structure in the table */
     3194
     3195                                                          /* validate handle */
     3196  iIndex = _HMHandleQuery(hCommDev);              /* get the index */
     3197  if (-1 == iIndex)                                               /* error ? */
     3198  {
     3199    SetLastError(ERROR_INVALID_HANDLE);       /* set win32 error information */
     3200    return (NULL);                                         /* signal failure */
     3201  }
     3202
     3203  if(IsBadWritePtr(lpctmo,sizeof(COMMTIMEOUTS)) )
     3204  {
     3205    SetLastError(ERROR_INVALID_PARAMETER);
     3206    return FALSE;
     3207  }
     3208
     3209  pHMHandle = &TabWin32Handles[iIndex];               /* call device handler */
     3210  bResult = pHMHandle->pDeviceHandler->GetCommTimeouts( &pHMHandle->hmHandleData,
     3211                                                        lpctmo);
     3212
     3213  return (bResult);                                  /* deliver return code */
     3214}
     3215BOOL HMCommGetCommModemStatus( HANDLE hCommDev,
     3216                               LPDWORD lpModemStat )
     3217{
     3218  int       iIndex;                           /* index into the handle table */
     3219  BOOL      bResult;                /* result from the device handler's API */
     3220  PHMHANDLE pHMHandle;       /* pointer to the handle structure in the table */
     3221
     3222                                                          /* validate handle */
     3223  iIndex = _HMHandleQuery(hCommDev);              /* get the index */
     3224  if (-1 == iIndex)                                               /* error ? */
     3225  {
     3226    SetLastError(ERROR_INVALID_HANDLE);       /* set win32 error information */
     3227    return (NULL);                                         /* signal failure */
     3228  }
     3229
     3230  if(IsBadWritePtr(lpModemStat,sizeof(DWORD)) )
     3231  {
     3232    SetLastError(ERROR_INVALID_PARAMETER);
     3233    return FALSE;
     3234  }
     3235
     3236  pHMHandle = &TabWin32Handles[iIndex];               /* call device handler */
     3237  bResult = pHMHandle->pDeviceHandler->GetCommModemStatus( &pHMHandle->hmHandleData,
     3238                                                           lpModemStat);
     3239
     3240  return (bResult);                                  /* deliver return code */
     3241}
     3242
     3243BOOL HMCommSetCommTimeouts( HANDLE hCommDev,
     3244                            LPCOMMTIMEOUTS lpctmo)
     3245{
     3246  int       iIndex;                           /* index into the handle table */
     3247  BOOL      bResult;                /* result from the device handler's API */
     3248  PHMHANDLE pHMHandle;       /* pointer to the handle structure in the table */
     3249
     3250                                                          /* validate handle */
     3251  iIndex = _HMHandleQuery(hCommDev);              /* get the index */
     3252  if (-1 == iIndex)                                               /* error ? */
     3253  {
     3254    SetLastError(ERROR_INVALID_HANDLE);       /* set win32 error information */
     3255    return (NULL);                                         /* signal failure */
     3256  }
     3257
     3258  if(IsBadReadPtr(lpctmo,sizeof(COMMTIMEOUTS)) )
     3259  {
     3260    SetLastError(ERROR_INVALID_PARAMETER);
     3261    return FALSE;
     3262  }
     3263
     3264  pHMHandle = &TabWin32Handles[iIndex];               /* call device handler */
     3265  bResult = pHMHandle->pDeviceHandler->SetCommTimeouts( &pHMHandle->hmHandleData,
     3266                                                        lpctmo);
     3267
     3268  return (bResult);                                  /* deliver return code */
     3269}
     3270
     3271BOOL HMCommTransmitCommChar( HANDLE hCommDev,
     3272                             CHAR cChar )
     3273{
     3274  int       iIndex;                           /* index into the handle table */
     3275  BOOL      bResult;                /* result from the device handler's API */
     3276  PHMHANDLE pHMHandle;       /* pointer to the handle structure in the table */
     3277
     3278                                                          /* validate handle */
     3279  iIndex = _HMHandleQuery(hCommDev);              /* get the index */
     3280  if (-1 == iIndex)                                               /* error ? */
     3281  {
     3282    SetLastError(ERROR_INVALID_HANDLE);       /* set win32 error information */
     3283    return (NULL);                                         /* signal failure */
     3284  }
     3285
     3286  pHMHandle = &TabWin32Handles[iIndex];               /* call device handler */
     3287  bResult = pHMHandle->pDeviceHandler->TransmitCommChar( &pHMHandle->hmHandleData,
     3288                                                         cChar);
     3289
     3290  return (bResult);                                  /* deliver return code */
     3291}
     3292
     3293BOOL HMCommSetCommConfig( HANDLE hCommDev,
     3294                          LPCOMMCONFIG lpCC,
     3295                          DWORD dwSize )
     3296{
     3297  int       iIndex;                           /* index into the handle table */
     3298  BOOL      bResult;                /* result from the device handler's API */
     3299  PHMHANDLE pHMHandle;       /* pointer to the handle structure in the table */
     3300
     3301                                                          /* validate handle */
     3302  iIndex = _HMHandleQuery(hCommDev);              /* get the index */
     3303  if (-1 == iIndex)                                               /* error ? */
     3304  {
     3305    SetLastError(ERROR_INVALID_HANDLE);       /* set win32 error information */
     3306    return (NULL);                                         /* signal failure */
     3307  }
     3308
     3309  if( IsBadReadPtr(lpCC,sizeof(COMMCONFIG)) ||
     3310      dwSize < sizeof(COMMCONFIG) )
     3311  {
     3312    SetLastError(ERROR_INVALID_PARAMETER);
     3313    return FALSE;
     3314  }
     3315
     3316  pHMHandle = &TabWin32Handles[iIndex];               /* call device handler */
     3317  bResult = pHMHandle->pDeviceHandler->SetCommConfig( &pHMHandle->hmHandleData,
     3318                                                      lpCC,
     3319                                                      dwSize);
     3320
     3321  return (bResult);                                  /* deliver return code */
     3322}
     3323
     3324BOOL HMCommSetCommBreak( HANDLE hCommDev )
     3325{
     3326  int       iIndex;                           /* index into the handle table */
     3327  BOOL      bResult;                /* result from the device handler's API */
     3328  PHMHANDLE pHMHandle;       /* pointer to the handle structure in the table */
     3329
     3330                                                          /* validate handle */
     3331  iIndex = _HMHandleQuery(hCommDev);              /* get the index */
     3332  if (-1 == iIndex)                                               /* error ? */
     3333  {
     3334    SetLastError(ERROR_INVALID_HANDLE);       /* set win32 error information */
     3335    return (NULL);                                         /* signal failure */
     3336  }
     3337
     3338  pHMHandle = &TabWin32Handles[iIndex];               /* call device handler */
     3339  bResult = pHMHandle->pDeviceHandler->SetCommBreak( &pHMHandle->hmHandleData);
     3340
     3341  return (bResult);                                  /* deliver return code */
     3342}
     3343
     3344BOOL HMCommGetCommConfig( HANDLE hCommDev,
     3345                          LPCOMMCONFIG lpCC,
     3346                          LPDWORD lpdwSize )
     3347{
     3348  int       iIndex;                           /* index into the handle table */
     3349  BOOL      bResult;                /* result from the device handler's API */
     3350  PHMHANDLE pHMHandle;       /* pointer to the handle structure in the table */
     3351
     3352                                                          /* validate handle */
     3353  iIndex = _HMHandleQuery(hCommDev);              /* get the index */
     3354  if (-1 == iIndex)                                               /* error ? */
     3355  {
     3356    SetLastError(ERROR_INVALID_HANDLE);       /* set win32 error information */
     3357    return (NULL);                                         /* signal failure */
     3358  }
     3359
     3360  if(IsBadWritePtr(lpdwSize,sizeof(DWORD)) )
     3361  {
     3362    SetLastError(ERROR_INVALID_PARAMETER);
     3363    return FALSE;
     3364  }
     3365
     3366  if( IsBadWritePtr(lpCC,sizeof(COMMCONFIG)) ||
     3367      *lpdwSize< sizeof(COMMCONFIG) )
     3368  {
     3369    SetLastError(ERROR_INSUFFICIENT_BUFFER);
     3370    *lpdwSize= sizeof(COMMCONFIG);
     3371    return FALSE;
     3372  }
     3373
     3374  pHMHandle = &TabWin32Handles[iIndex];               /* call device handler */
     3375  bResult = pHMHandle->pDeviceHandler->GetCommConfig( &pHMHandle->hmHandleData,
     3376                                                      lpCC,
     3377                                                      lpdwSize);
     3378
     3379  return (bResult);                                  /* deliver return code */
     3380}
     3381
     3382BOOL HMCommEscapeCommFunction( HANDLE hCommDev,
     3383                               UINT dwFunc )
     3384{
     3385  int       iIndex;                           /* index into the handle table */
     3386  BOOL      bResult;                /* result from the device handler's API */
     3387  PHMHANDLE pHMHandle;       /* pointer to the handle structure in the table */
     3388
     3389                                                          /* validate handle */
     3390  iIndex = _HMHandleQuery(hCommDev);              /* get the index */
     3391  if (-1 == iIndex)                                               /* error ? */
     3392  {
     3393    SetLastError(ERROR_INVALID_HANDLE);       /* set win32 error information */
     3394    return (NULL);                                         /* signal failure */
     3395  }
     3396
     3397  pHMHandle = &TabWin32Handles[iIndex];               /* call device handler */
     3398
     3399  switch(dwFunc)
     3400  {
     3401    case CLRDTR:
     3402    case CLRRTS:
     3403    case SETDTR:
     3404    case SETRTS:
     3405    case SETXOFF:
     3406    case SETXON:
     3407      bResult = pHMHandle->pDeviceHandler->EscapeCommFunction( &pHMHandle->hmHandleData,
     3408                                                               dwFunc);
     3409      break;
     3410    case SETBREAK:
     3411      bResult = pHMHandle->pDeviceHandler->SetCommBreak(&pHMHandle->hmHandleData);
     3412      break;
     3413    case CLRBREAK:
     3414      bResult = pHMHandle->pDeviceHandler->ClearCommBreak(&pHMHandle->hmHandleData);
     3415      break;
     3416    default:
     3417      SetLastError(ERROR_INVALID_PARAMETER);
     3418      bResult = FALSE;
     3419  }
     3420
     3421
     3422  return (bResult);                                  /* deliver return code */
     3423}
     3424
     3425BOOL HMCommSetupComm( HANDLE hCommDev,
     3426                      DWORD dwInQueue,
     3427                      DWORD dwOutQueue)
     3428{
     3429  int       iIndex;                           /* index into the handle table */
     3430  BOOL      bResult;                /* result from the device handler's API */
     3431  PHMHANDLE pHMHandle;       /* pointer to the handle structure in the table */
     3432
     3433                                                          /* validate handle */
     3434  iIndex = _HMHandleQuery(hCommDev);              /* get the index */
     3435  if (-1 == iIndex)                                               /* error ? */
     3436  {
     3437    SetLastError(ERROR_INVALID_HANDLE);       /* set win32 error information */
     3438    return (NULL);                                         /* signal failure */
     3439  }
     3440
     3441  pHMHandle = &TabWin32Handles[iIndex];               /* call device handler */
     3442  bResult = pHMHandle->pDeviceHandler->SetupComm(&pHMHandle->hmHandleData,
     3443                                                 dwInQueue,
     3444                                                 dwOutQueue);
     3445
     3446  return (bResult);                                  /* deliver return code */
     3447}
     3448
     3449BOOL HMCommClearCommBreak(HANDLE hCommDev)
     3450{
     3451  int       iIndex;                           /* index into the handle table */
     3452  BOOL      bResult;                /* result from the device handler's API */
     3453  PHMHANDLE pHMHandle;       /* pointer to the handle structure in the table */
     3454
     3455                                                          /* validate handle */
     3456  iIndex = _HMHandleQuery(hCommDev);              /* get the index */
     3457  if (-1 == iIndex)                                               /* error ? */
     3458  {
     3459    SetLastError(ERROR_INVALID_HANDLE);       /* set win32 error information */
     3460    return (NULL);                                         /* signal failure */
     3461  }
     3462
     3463  pHMHandle = &TabWin32Handles[iIndex];               /* call device handler */
     3464  bResult = pHMHandle->pDeviceHandler->ClearCommBreak(&pHMHandle->hmHandleData);
     3465
     3466  return (bResult);                                  /* deliver return code */
     3467}
     3468
     3469BOOL HMCommSetDefaultCommConfig( HANDLE hCommDev,
     3470                                 LPCOMMCONFIG lpCC,
     3471                                 DWORD dwSize)
     3472{
     3473  int       iIndex;                           /* index into the handle table */
     3474  BOOL      bResult;                /* result from the device handler's API */
     3475  PHMHANDLE pHMHandle;       /* pointer to the handle structure in the table */
     3476
     3477                                                          /* validate handle */
     3478  iIndex = _HMHandleQuery(hCommDev);              /* get the index */
     3479  if (-1 == iIndex)                                               /* error ? */
     3480  {
     3481    SetLastError(ERROR_INVALID_HANDLE);       /* set win32 error information */
     3482    return (NULL);                                         /* signal failure */
     3483  }
     3484
     3485  if( (lpCC!=NULL) &&
     3486      ( IsBadReadPtr(lpCC,sizeof(COMMCONFIG)) ||
     3487        dwSize != sizeof(COMMCONFIG) ) )
     3488  {
     3489    SetLastError(ERROR_INVALID_PARAMETER);
     3490    return FALSE;
     3491  }
     3492
     3493  pHMHandle = &TabWin32Handles[iIndex];               /* call device handler */
     3494  bResult = pHMHandle->pDeviceHandler->SetDefaultCommConfig(&pHMHandle->hmHandleData,
     3495                                                            lpCC,
     3496                                                            dwSize);
     3497
     3498  return (bResult);                                  /* deliver return code */
     3499}
     3500
     3501BOOL HMCommGetDefaultCommConfig( HANDLE hCommDev,
     3502                                 LPCOMMCONFIG lpCC,
     3503                                 LPDWORD lpdwSize)
     3504{
     3505  int       iIndex;                           /* index into the handle table */
     3506  BOOL      bResult;                /* result from the device handler's API */
     3507  PHMHANDLE pHMHandle;       /* pointer to the handle structure in the table */
     3508
     3509                                                          /* validate handle */
     3510  iIndex = _HMHandleQuery(hCommDev);              /* get the index */
     3511  if (-1 == iIndex)                                               /* error ? */
     3512  {
     3513    SetLastError(ERROR_INVALID_HANDLE);       /* set win32 error information */
     3514    return (NULL);                                         /* signal failure */
     3515  }
     3516
     3517  if(IsBadWritePtr(lpdwSize,sizeof(DWORD)))
     3518  {
     3519    SetLastError(ERROR_INVALID_PARAMETER);
     3520    return FALSE;
     3521  }
     3522
     3523  pHMHandle = &TabWin32Handles[iIndex];               /* call device handler */
     3524  bResult = pHMHandle->pDeviceHandler->GetDefaultCommConfig( &pHMHandle->hmHandleData,
     3525                                                             lpCC,
     3526                                                             lpdwSize);
    29753527
    29763528  return (bResult);                                  /* deliver return code */
    … …  
    30063558  {
    30073559    SetLastError(ERROR_NOT_ENOUGH_MEMORY);      /* use this as error message */
    3008     return ERROR_NOT_ENOUGH_MEMORY; 
     3560    return ERROR_NOT_ENOUGH_MEMORY;
    30093561  }
    30103562
    … …  
    30363588  if (rc != NO_ERROR)     /* oops, creation failed within the device handler */
    30373589  {
    3038         TabWin32Handles[iIndexNew].hmHandleData.hHMHandle = INVALID_HANDLE_VALUE;
    3039         return (rc);                                           /* signal error */
     3590      TabWin32Handles[iIndexNew].hmHandleData.hHMHandle = INVALID_HANDLE_VALUE;
     3591  return (rc);                                           /* signal error */
    30403592  }
    30413593  else
    … …  
    30743626  {
    30753627    SetLastError(ERROR_NOT_ENOUGH_MEMORY);      /* use this as error message */
    3076     return ERROR_NOT_ENOUGH_MEMORY; 
     3628    return ERROR_NOT_ENOUGH_MEMORY;
    30773629  }
    30783630
    … …  
    31043656  if (rc != NO_ERROR)     /* oops, creation failed within the device handler */
    31053657  {
    3106         TabWin32Handles[iIndexNew].hmHandleData.hHMHandle = INVALID_HANDLE_VALUE;
    3107         return (rc);                                           /* signal error */
     3658      TabWin32Handles[iIndexNew].hmHandleData.hHMHandle = INVALID_HANDLE_VALUE;
     3659  return (rc);                                           /* signal error */
    31083660  }
    31093661  else
    … …  
    31463698  {
    31473699    SetLastError(ERROR_NOT_ENOUGH_MEMORY);      /* use this as error message */
    3148     return 0; 
     3700    return 0;
    31493701  }
    31503702
    … …  
    31763728  if (rc == 0)     /* oops, creation failed within the device handler */
    31773729  {
    3178         TabWin32Handles[iIndexNew].hmHandleData.hHMHandle = INVALID_HANDLE_VALUE;
    3179         return 0;                                           /* signal error */
     3730      TabWin32Handles[iIndexNew].hmHandleData.hHMHandle = INVALID_HANDLE_VALUE;
     3731  return 0;                                           /* signal error */
    31803732  }
    31813733
    … …  
    34333985/*****************************************************************************
    34343986 * Name      : HMSetThreadTerminated
    3435  * Purpose   : 
     3987 * Purpose   :
    34363988 * Parameters:
    34373989 * Variables :
    … …  
    34654017/*****************************************************************************
    34664018 * Name      : HMPeekNamedPipe
    3467  * Purpose   : 
     4019 * Purpose   :
    34684020 * Parameters:
    34694021 * Variables :
    … …  
    34954047
    34964048  pHMHandle = &TabWin32Handles[iIndex];               /* call device handler */
    3497   lpResult = pHMHandle->pDeviceHandler->PeekNamedPipe(&TabWin32Handles[iIndex].hmHandleData, 
     4049  lpResult = pHMHandle->pDeviceHandler->PeekNamedPipe(&TabWin32Handles[iIndex].hmHandleData,
    34984050                                                      lpvBuffer,
    34994051                                                      cbBuffer,
    … …  
    35074059/*****************************************************************************
    35084060 * Name      : HMCreateNamedPipe
    3509  * Purpose   : 
     4061 * Purpose   :
    35104062 * Parameters:
    35114063 * Variables :
    … …  
    35164068 * Author    : Przemyslaw Dobrowolski
    35174069 *****************************************************************************/
    3518 DWORD HMCreateNamedPipe(LPCTSTR lpName, 
    3519                       DWORD   dwOpenMode, 
     4070DWORD HMCreateNamedPipe(LPCTSTR lpName,
     4071                      DWORD   dwOpenMode,
    35204072                      DWORD   dwPipeMode,
    3521                       DWORD   nMaxInstances, 
     4073                      DWORD   nMaxInstances,
    35224074                      DWORD   nOutBufferSize,
    3523                       DWORD   nInBufferSize, 
     4075                      DWORD   nInBufferSize,
    35244076                      DWORD   nDefaultTimeOut,
    35254077                      LPSECURITY_ATTRIBUTES lpSecurityAttributes)
    … …  
    35394091  {
    35404092    SetLastError(ERROR_NOT_ENOUGH_MEMORY);      /* use this as error message */
    3541     return 0; 
     4093    return 0;
    35424094  }
    35434095
    … …  
    35684120  if (rc == 0)     /* oops, creation failed within the device handler */
    35694121  {
    3570         TabWin32Handles[iIndexNew].hmHandleData.hHMHandle = INVALID_HANDLE_VALUE;
    3571         return 0;                                           /* signal error */
     4122      TabWin32Handles[iIndexNew].hmHandleData.hHMHandle = INVALID_HANDLE_VALUE;
     4123  return 0;                                           /* signal error */
    35724124  }
    35734125
    … …  
    35794131/*****************************************************************************
    35804132 * Name      : HMConnectNamedPipe
    3581  * Purpose   : 
     4133 * Purpose   :
    35824134 * Parameters:
    35834135 * Variables :
    … …  
    36044156
    36054157  pHMHandle = &TabWin32Handles[iIndex];               /* call device handler */
    3606   lpResult = pHMHandle->pDeviceHandler->ConnectNamedPipe(&TabWin32Handles[iIndex].hmHandleData, 
     4158  lpResult = pHMHandle->pDeviceHandler->ConnectNamedPipe(&TabWin32Handles[iIndex].hmHandleData,
    36074159                                                         lpOverlapped);
    36084160
    … …  
    36124164/*****************************************************************************
    36134165 * Name      : HMDisconnectNamedPipe
    3614  * Purpose   : 
     4166 * Purpose   :
    36154167 * Parameters:
    36164168 * Variables :
    … …  
    36444196/*****************************************************************************
    36454197 * Name      : HMGetNamedPipeHandleState
    3646  * Purpose   : 
     4198 * Purpose   :
    36474199 * Parameters:
    36484200 * Variables :
    … …  
    36894241/*****************************************************************************
    36904242 * Name      : HMGetNamedPipeInfo
    3691  * Purpose   : 
     4243 * Purpose   :
    36924244 * Parameters:
    36934245 * Variables :
    … …  
    37294281/*****************************************************************************
    37304282 * Name      : HMTransactNamedPipe
    3731  * Purpose   : 
     4283 * Purpose   :
    37324284 * Parameters:
    37334285 * Variables :
    … …  
    37734325/*****************************************************************************
    37744326 * Name      : HMSetNamedPipeHandleState
    3775  * Purpose   : 
     4327 * Purpose   :
    37764328 * Parameters:
    37774329 * Variables :
    … …  
    38114363/*****************************************************************************
    38124364 * Name      : HMCreatePipe
    3813  * Purpose   : 
     4365 * Purpose   :
    38144366 * Parameters:
    38154367 * Variables :
    … …  
    38224374BOOL HMCreatePipe(PHANDLE phRead,
    38234375                PHANDLE phWrite,
    3824                 LPSECURITY_ATTRIBUTES lpsa, 
     4376                LPSECURITY_ATTRIBUTES lpsa,
    38254377                DWORD                 cbPipe)
    38264378{
    … …  
    38404392  {
    38414393    SetLastError(ERROR_NOT_ENOUGH_MEMORY);      /* use this as error message */
    3842     return 0; 
     4394    return 0;
    38434395  }
    38444396
    … …  
    38474399  {
    38484400    SetLastError(ERROR_NOT_ENOUGH_MEMORY);      /* use this as error message */
    3849     return 0; 
     4401    return 0;
    38504402  }
    38514403
    … …  
    38914443  if (rc == 0)     /* oops, creation failed within the device handler */
    38924444  {
    3893         TabWin32Handles[iIndexNewRead].hmHandleData.hHMHandle = INVALID_HANDLE_VALUE;
    3894         TabWin32Handles[iIndexNewWrite].hmHandleData.hHMHandle = INVALID_HANDLE_VALUE;
    3895         return FALSE;                                           /* signal error */
     4445      TabWin32Handles[iIndexNewRead].hmHandleData.hHMHandle = INVALID_HANDLE_VALUE;
     4446      TabWin32Handles[iIndexNewWrite].hmHandleData.hHMHandle = INVALID_HANDLE_VALUE;
     4447  return FALSE;                                           /* signal error */
    38964448  }
    38974449

  • trunk/src/kernel32/cio.h

    r99 r4285  
    1 /* $Id: cio.h,v 1.4 1999-06-10 19:11:29 phaller Exp $ */
     1/* $Id: cio.h,v 1.5 2000-09-20 21:32:54 hugh Exp $ */
    22
    33/* Copyright (C) 1995 by Holger Veit (Holger.Veit@gmd.de) */
    … …  
    1616#endif
    1717
    18 int CDECL io_init(void);
    19 int CDECL io_exit(void);
     18int io_init1(void);
     19int io_init2(short);
     20int io_exit1(void);
    2021
    21 int CDECL io_init1(void);
    22 int CDECL io_exit1(void);
    23 
    24 char CDECL  c_inb(short);
    25 short CDECL c_inw(short);
    26 long CDECL  c_inl(short);
    27 void CDECL  c_outb(short,char);
    28 void CDECL  c_outw(short,short);
    29 void CDECL  c_outl(short,long);
    30 void CDECL  c_readmsr(long, long *);
     22char c_inb(short);
     23short c_inw(short);
     24long c_inl(short);
     25void c_outb(short,char);
     26void c_outw(short,short);
     27void c_outl(short,long);
     28//void CDECL  c_readmsr(long, long *);
    3129
    3230#ifdef __cplusplus

  • trunk/src/kernel32/comm.cpp

    r2802 r4285  
    1 /* $Id: comm.cpp,v 1.4 2000-02-16 14:25:30 sandervl Exp $ */
     1/* $Id: comm.cpp,v 1.5 2000-09-20 21:32:49 hugh Exp $ */
    22
    33/*
    4  * PE2LX dialog conversion code
     4 * Comport functions
    55 *
    66 * Copyright 1998 Patrick Haller (?)
    7  * Copyright 1998 Felix Maschek  (?)
     7 * Copyright 1998 Felix Maschek  (?)
     8 * Copyright 2000 Markus Montkowski
    89 *
    910 * Project Odin Software License can be found in LICENSE.TXT
    1011 *
    1112 */
    12 /*
    13  * *Comm* stubs
    14  */
    1513#include <os2win.h>
     14#include <odinwrap.h>
     15#include <ctype.h>
     16#include <string.h>
     17#include <stdio.h>
     18#include "winreg.h"
     19#include "global.h"
     20#include "winnt.h"
     21#include "winerror.h"
     22#include "winreg.h"
     23
    1624#include "unicode.h"
    1725#include "handlemanager.h"
    1826
    19 #define DBG_LOCALLOG    DBG_comm
     27#define DBG_LOCALLOG  DBG_comm
    2028#include "dbglocal.h"
    21 
    22 //------------------------------------------------------------------------------
     29ODINDEBUGCHANNEL(KERNEL32-COMM)
     30
     31/*****************************************************************************
     32 * @returns   True on success and fills the COMMCONFIG structure
     33 * @param     lpDef        Pointer to device-control string
     34 * @param     lpDCB        Pointer to device-control buffer
     35 * @remark
     36 * @status    untested
     37 * @author    Markus Montkowski
     38 *****************************************************************************/
    2339
    2440BOOL WIN32API BuildCommDCBA( LPCSTR lpDef, LPDCB lpDCB )
    2541{
    26   dprintf(("BuildCommDCBA Not implemented (TRUE)\n"));
    27   return(TRUE);
     42  return BuildCommDCBAndTimeoutsA(lpDef,lpDCB,NULL);
    2843}
    2944
    … …  
    3247BOOL WIN32API BuildCommDCBW( LPCWSTR lpDef, LPDCB lpDCB )
    3348{
    34   dprintf(("BuildCommDCBW Not implemented (TRUE)\n"));
    35   return(TRUE);
    36 }
    37 
    38 //------------------------------------------------------------------------------
     49  char *asciiname;
     50  BOOL rc;
     51
     52  asciiname  = UnicodeToAsciiString((LPWSTR)lpDef);
     53  rc = BuildCommDCBAndTimeoutsA(asciiname, lpDCB, NULL);
     54  FreeAsciiString(asciiname);
     55  return(rc);
     56}
     57
     58//------------------------------------------------------------------------------
     59
     60BOOL ValidCOMPort(int Port)
     61{
     62  // @@@ Todo check in the handlemanager for a registered COM DeviceHandle for this number
     63  //     We currently only do static add COM1-COM8 so we simply check for 8
     64  return (Port <=8);
     65}
     66
     67/*****************************************************************************
     68 * @returns   True on success and fills the COMMCONFIG structure
     69 * @param     lpDef          Pointer to device-control string
     70 * @param     lpDCB          Pointer to device-control buffer
     71 * @param     lpCommTimeouts Pointer to COMMTIMEOUTS
     72 * @remark
     73 * @status    partly implemented
     74 * @author    Markus Montkowski
     75 *****************************************************************************/
     76
    3977
    4078BOOL WIN32API BuildCommDCBAndTimeoutsA( LPCSTR lpDef, LPDCB lpDCB, LPCOMMTIMEOUTS lpCommTimeouts )
    4179{
    42   dprintf(("BuildCommDCBAndTimeoutsA Not implemented (TRUE)\n"));
    43   return(TRUE);
     80  int port,i;
     81  char szNumber[4];
     82  char  *ptr,*temp;
     83
     84  dprintf(("(%s,%p,%p)\n",lpDef,lpDCB,lpCommTimeouts));
     85
     86  port = -1;
     87
     88  if (!strnicmp(lpDef,"COM",3))
     89  {
     90
     91    for(i=0;((lpDef[3+i]!=':') && (i<3));i++)
     92      szNumber[i] = lpDef[3+i];
     93    szNumber[i] = 0;
     94
     95    port = atoi(szNumber);
     96    if (port==0 || lpDef[i]!=':')
     97    {
     98      SetLastError(ERROR_INVALID_PARAMETER);
     99      return FALSE;
     100    }
     101
     102    if (!ValidCOMPort(port))
     103    {
     104      SetLastError(ERROR_FILE_NOT_FOUND);
     105      return FALSE;
     106    }
     107    temp=(LPSTR)(lpDef+4+i);
     108  }
     109  else
     110    temp=(LPSTR)lpDef;
     111
     112  lpDCB->DCBlength  = sizeof(DCB);
     113  if (strchr(temp,','))
     114  {
     115    // old style
     116
     117    char  last=temp[strlen(temp)-1];
     118
     119    ptr = strtok(temp, ", ");
     120
     121
     122    lpDCB->BaudRate = atoi(ptr);
     123    dprintf(("baudrate (%d)\n", lpDCB->BaudRate));
     124
     125    ptr = strtok(NULL, ", ");
     126    if (islower(*ptr))
     127      *ptr = toupper(*ptr);
     128
     129    dprintf(("parity (%c)\n", *ptr));
     130    lpDCB->fParity = TRUE;
     131    switch (*ptr)
     132    {
     133      case 'N':
     134        lpDCB->Parity = NOPARITY;
     135        lpDCB->fParity = FALSE;
     136        break;
     137      case 'E':
     138        lpDCB->Parity = EVENPARITY;
     139        break;
     140      case 'M':
     141        lpDCB->Parity = MARKPARITY;
     142        break;
     143      case 'O':
     144        lpDCB->Parity = ODDPARITY;
     145        break;
     146      default:
     147        SetLastError(ERROR_INVALID_PARAMETER);
     148        dprintf(("Unknown parity `%c'!\n", *ptr));
     149        return FALSE;
     150    }
     151
     152    ptr = strtok(NULL, ", ");
     153    dprintf(("charsize (%c)\n", *ptr));
     154    lpDCB->ByteSize = *ptr - '0';
     155
     156    if((lpDCB->ByteSize<5) ||
     157       (lpDCB->ByteSize>8))
     158    {
     159      SetLastError(ERROR_INVALID_PARAMETER);
     160      dprintf(("Unsupported bytesize `%d'!\n", lpDCB->ByteSize));
     161      return FALSE;
     162    }
     163
     164    ptr = strtok(NULL, ", ");
     165    dprintf(("stopbits (%c%c%c)\n", *ptr,*(ptr+1)=='.'?'.':' ',*(ptr+1)=='.'?*(ptr+2):' '));
     166    switch (*ptr)
     167    {
     168      case '1':
     169        if(*(ptr+1)=='.')
     170        {
     171          if(*(ptr+2)=='5')
     172            lpDCB->StopBits = ONE5STOPBITS;
     173          else
     174          {
     175            SetLastError(ERROR_INVALID_PARAMETER);
     176            dprintf(("Unsupported # of stopbits !\n"));
     177            return FALSE;
     178          }
     179        }
     180        else
     181          lpDCB->StopBits = ONESTOPBIT;
     182        break;
     183      case '2':
     184        lpDCB->StopBits = TWOSTOPBITS;
     185        break;
     186      default:
     187        SetLastError(ERROR_INVALID_PARAMETER);
     188        dprintf(("Unknown # of stopbits `%c'!\n", *ptr));
     189        return FALSE;
     190    }
     191
     192    if(lpDCB->BaudRate==110)
     193      lpDCB->StopBits =2;
     194
     195    if(((lpDCB->ByteSize==5)&&(lpDCB->StopBits==TWOSTOPBITS))||
     196       ((lpDCB->ByteSize!=5)&&(lpDCB->StopBits==ONE5STOPBITS)) )
     197    {
     198      dprintf(("Unsupported Combination of Bytesize `%d' and StopBits %s!\n",
     199              lpDCB->ByteSize,lpDCB->StopBits==ONE5STOPBITS?"1.5":"2"));
     200      SetLastError(ERROR_INVALID_PARAMETER);
     201      return FALSE;
     202    }
     203
     204    lpDCB->fBinary    = TRUE;
     205    lpDCB->fNull      = FALSE;
     206
     207    if (last == 'x')
     208    {
     209      lpDCB->fInX   = TRUE;
     210      lpDCB->fOutX    = TRUE;
     211      lpDCB->fOutxCtsFlow = FALSE;
     212      lpDCB->fOutxDsrFlow = FALSE;
     213      lpDCB->fDtrControl  = DTR_CONTROL_ENABLE;
     214      lpDCB->fRtsControl  = RTS_CONTROL_ENABLE;
     215    }
     216    else
     217      if (last=='p')
     218      {
     219        lpDCB->fInX   = FALSE;
     220        lpDCB->fOutX    = FALSE;
     221        lpDCB->fOutxCtsFlow = TRUE;
     222        lpDCB->fOutxDsrFlow = TRUE;
     223        lpDCB->fDtrControl  = DTR_CONTROL_HANDSHAKE;
     224        lpDCB->fRtsControl  = RTS_CONTROL_HANDSHAKE;
     225      }
     226      else
     227      {
     228        lpDCB->fInX   = FALSE;
     229        lpDCB->fOutX    = FALSE;
     230        lpDCB->fOutxCtsFlow = FALSE;
     231        lpDCB->fOutxDsrFlow = FALSE;
     232        lpDCB->fDtrControl  = DTR_CONTROL_ENABLE;
     233        lpDCB->fRtsControl  = RTS_CONTROL_ENABLE;
     234      }
     235    lpDCB->XonChar    = 0;
     236    lpDCB->XoffChar   = 0;
     237    lpDCB->ErrorChar  = 0;
     238    lpDCB->fErrorChar = 0;
     239    lpDCB->EofChar    = 0;
     240    lpDCB->EvtChar    = 0;
     241    lpDCB->XonLim     = 0;
     242    lpDCB->XoffLim    = 0;
     243    return TRUE;
     244  }
     245
     246  ptr=strtok(temp," ");
     247  while (ptr)
     248  {
     249    DWORD flag,x;
     250
     251    flag=0;
     252    if (!strnicmp("baud=",ptr,5))
     253    {
     254      if (!sscanf(ptr+5,"%ld",&x))
     255      {
     256        dprintf(("Couldn't parse %s\n",ptr));
     257        SetLastError(ERROR_INVALID_PARAMETER);
     258        return FALSE;
     259      }
     260      lpDCB->BaudRate = x;
     261      flag=1;
     262    }
     263    if (!strnicmp("stop=",ptr,5))
     264    {
     265      if (!sscanf(ptr+5,"%ld",&x))
     266      {
     267        dprintf(("Couldn't parse %s\n",ptr));
     268        SetLastError(ERROR_INVALID_PARAMETER);
     269        return FALSE;
     270      }
     271      lpDCB->StopBits = x;
     272      flag=1;
     273    }
     274    if (!strnicmp("data=",ptr,5))
     275    {
     276      if (!sscanf(ptr+5,"%ld",&x))
     277      {
     278        dprintf(("Couldn't parse %s\n",ptr));
     279        SetLastError(ERROR_INVALID_PARAMETER);
     280        return FALSE;
     281      }
     282      lpDCB->ByteSize = x;
     283      flag=1;
     284    }
     285    if (!strnicmp("parity=",ptr,7))
     286    {
     287      lpDCB->fParity  = TRUE;
     288      switch (ptr[8])
     289      {
     290        case 'N':case 'n':
     291          lpDCB->fParity  = FALSE;
     292          lpDCB->Parity = NOPARITY;
     293          break;
     294        case 'E':case 'e':
     295          lpDCB->Parity = EVENPARITY;
     296          break;
     297        case 'O':case 'o':
     298          lpDCB->Parity = ODDPARITY;
     299          break;
     300        case 'M':case 'm':
     301          lpDCB->Parity = MARKPARITY;
     302          break;
     303      }
     304      flag=1;
     305    }
     306    if (!strnicmp("to=",ptr,3))
     307    {
     308      if (!strnicmp("on",ptr+3,2))
     309      {
     310        if(NULL==lpCommTimeouts)
     311        {
     312          dprintf(("TO=ON and no lpCommTimeout"));
     313          SetLastError(ERROR_INVALID_PARAMETER);
     314          return FALSE;
     315        }
     316        else
     317        {
     318          // @@@ Todo Implement timout handling
     319          flag=1;
     320        }
     321      }
     322      if (!strnicmp("off",ptr+3,3))
     323      {
     324        flag=1;
     325      }
     326    }
     327
     328    if (!flag)
     329    {
     330      dprintf(("Unhandled specifier '%s', please report.\n",ptr));
     331      SetLastError(ERROR_INVALID_PARAMETER);
     332      return FALSE;
     333    }
     334    ptr=strtok(NULL," ");
     335  }
     336
     337  if (lpDCB->BaudRate==110)
     338    lpDCB->StopBits = 2;
     339  return TRUE;
    44340}
    45341
    … …  
    48344BOOL WIN32API BuildCommDCBAndTimeoutsW( LPCWSTR lpDef, LPDCB lpDCB, LPCOMMTIMEOUTS lpCommTimeouts )
    49345{
    50   dprintf(("BuildCommDCBAndTimeoutsW Not implemented (TRUE)\n"));
    51   return(TRUE);
    52 }
    53 
    54 //------------------------------------------------------------------------------
     346  char *asciiname;
     347  BOOL rc;
     348
     349  asciiname  = UnicodeToAsciiString((LPWSTR)lpDef);
     350  rc = BuildCommDCBAndTimeoutsA(asciiname, lpDCB, lpCommTimeouts);
     351  FreeAsciiString(asciiname);
     352  return(rc);
     353}
     354
     355//------------------------------------------------------------------------------
     356
     357typedef BOOL (* WIN32API COMMDLGFUNC)(LPCSTR, HWND, LPCOMMCONFIG );
    55358
    56359BOOL WIN32API CommConfigDialogA( LPCSTR lpszName, HWND hWnd, LPCOMMCONFIG lpCC )
    57360{
    58   dprintf(("CommConfigDialogA Not implemented (TRUE)\n"));
    59   return(TRUE);
     361  COMMDLGFUNC lpfnCommDialog;
     362  HMODULE hConfigModule;
     363  char    szSerialUI[MAX_PATH+1];
     364  char    szKeyname[5];
     365  BOOL r;
     366  HKEY hkPorts, hkName;
     367  LONG rc;
     368  DWORD dwType,dwSize;
     369  int port;
     370
     371  dprintf(("CommConfigDialogA (%p %x %p)\n",lpszName, hWnd, lpCC));
     372
     373  if( strnicmp(lpszName,"com",3) ||
     374      strlen(lpszName)<4 ||
     375      strlen(lpszName)>7)
     376  {
     377    SetLastError(ERROR_INVALID_PARAMETER);
     378    return FALSE;
     379  }
     380  port = atoi(lpszName+3);
     381  if( (0==port) ||(port>9999))
     382  {
     383    SetLastError(ERROR_INVALID_PARAMETER);
     384    return FALSE;
     385  }
     386  port--;
     387
     388  sprintf(szKeyname,"%04d",port);
     389  dprintf(("CommConfigDialogA look in reg for port %s",szKeyname));
     390  rc = RegOpenKeyExA( HKEY_LOCAL_MACHINE,
     391                      "System\\CurrentControlSet\\Services\\Class\\Ports",
     392                      0,
     393                      KEY_READ,
     394                      &hkPorts);
     395
     396  if(rc!=ERROR_SUCCESS)
     397  {
     398    SetLastError(ERROR_DEV_NOT_EXIST);
     399    return FALSE;
     400  }
     401
     402  rc = RegOpenKeyExA( hkPorts,
     403                      szKeyname,
     404                      0,
     405                      KEY_READ,
     406                      &hkName);
     407
     408  if(rc!=ERROR_SUCCESS)
     409  {
     410    SetLastError(ERROR_DEV_NOT_EXIST);
     411    RegCloseKey(hkPorts);
     412    return FALSE;
     413  }
     414
     415  dwSize = sizeof(szSerialUI);
     416
     417  rc = RegQueryValueExA( hkName,
     418                         "ConfigDialog",
     419                         NULL,
     420                         &dwType,
     421                         (LPBYTE)szSerialUI,
     422                         &dwSize);
     423
     424  RegCloseKey(hkName);
     425  RegCloseKey(hkPorts);
     426  if( (rc!=ERROR_SUCCESS) && (dwType!=REG_SZ) )
     427  {
     428    SetLastError(ERROR_DEV_NOT_EXIST);
     429    return FALSE;
     430  }
     431
     432  hConfigModule = LoadLibraryA(szSerialUI);
     433  if(!hConfigModule)
     434    return FALSE;
     435
     436  lpfnCommDialog = (COMMDLGFUNC)GetProcAddress(hConfigModule, (LPCSTR)3L);
     437
     438  if(!lpfnCommDialog)
     439    return FALSE;
     440
     441  SetLastError(ERROR_SUCCESS);
     442
     443  r = lpfnCommDialog(lpszName,hWnd,lpCC);
     444
     445  FreeLibrary(hConfigModule);
     446
     447  return r;
    60448}
    61449
    … …  
    64452BOOL WIN32API CommConfigDialogW( LPCWSTR lpszName, HWND hWnd, LPCOMMCONFIG lpCC )
    65453{
    66   dprintf(("CommConfigDialogW Not implemented (TRUE)\n"));
    67   return(TRUE);
    68 }
    69 
    70 //------------------------------------------------------------------------------
    71 
    72 BOOL WIN32API GetDefaultCommConfigA( LPCSTR lpszName, LPCOMMCONFIG lpCC, LPDWORD lpdwSize )
    73 {
    74   dprintf(("GetDefaultCommConfigA Not implemented (TRUE)\n"));
    75   return(TRUE);
     454  char *asciiname;
     455  BOOL rc;
     456
     457  asciiname  = UnicodeToAsciiString((LPWSTR)lpszName);
     458  rc = CommConfigDialogA(asciiname,hWnd,lpCC);
     459  FreeAsciiString(asciiname);
     460  return rc;
     461}
     462
     463/*****************************************************************************
     464 * @returns   True on success and fills the COMMCONFIG structure
     465 * @param     lpszName     Pointer to devicename
     466 * @param     lpCC         Pointer to COMMCONFIG buffer.
     467 * @param     lpdwSize     [in]    Pointer to size of Buffer pointed to by lpCC
     468 *                         [out]   Number of bytes copied to the buffer
     469 *                         [error] If buffer to small Number of bytes needed
     470 * @remark
     471 * @status    untested
     472 * @author    Markus Montkowski
     473 *****************************************************************************/
     474
     475ODINFUNCTION3(BOOL,GetDefaultCommConfigA,
     476               LPCSTR, lpszName,
     477               LPCOMMCONFIG, lpCC,
     478               LPDWORD, lpdwSize )
     479{
     480  HFILE hCOM;
     481  BOOL rc;
     482
     483  dprintf(("GetDefaultCommConfigA untested stub \n"));
     484  SetLastError(ERROR_SUCCESS);
     485
     486  if(IsBadReadPtr(lpszName,5) ||
     487     IsBadWritePtr(lpdwSize,sizeof(DWORD)) ||
     488     IsBadWritePtr(lpCC,*lpdwSize) )
     489  {
     490    SetLastError(ERROR_INVALID_PARAMETER);    /* set win32 error information */
     491    return(FALSE);
     492  }
     493
     494  if(strnicmp(lpszName,"COM",3) &&
     495     strnicmp(lpszName,"\\COM",4) &&
     496     strnicmp(lpszName,"\\dev\\COM",8) )
     497  {
     498    SetLastError(ERROR_FILE_NOT_FOUND);       /* set win32 error information */
     499    return(FALSE);
     500  }
     501
     502  hCOM = HMCreateFile( lpszName,
     503                        GENERIC_READ | GENERIC_WRITE,
     504                        0,
     505                        NULL,
     506                        OPEN_EXISTING,
     507                        FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED,
     508                        NULL);
     509  if(0!=hCOM)
     510  {
     511    rc = HMCommGetDefaultCommConfig(hCOM, lpCC, lpdwSize);
     512    HMCloseHandle(hCOM);
     513    return(rc);
     514  }
     515  return(FALSE);
    76516}
    77517
    … …  
    80520BOOL WIN32API GetDefaultCommConfigW( LPCWSTR lpszName, LPCOMMCONFIG lpCC, LPDWORD lpdwSize )
    81521{
    82   dprintf(("GetDefaultCommConfigW Not implemented (TRUE)\n"));
    83   return(TRUE);
    84 }
    85 
    86 //------------------------------------------------------------------------------
    87 
    88 BOOL WIN32API SetDefaultCommConfigA( LPCSTR lpszName, LPCOMMCONFIG lpCC, DWORD dwSize )
    89 {
    90   dprintf(("SetDefaultCommConfigA Not implemented (TRUE)\n"));
    91   return(TRUE);
     522  char *asciiname;
     523  BOOL rc;
     524
     525  asciiname  = UnicodeToAsciiString((LPWSTR)lpszName);
     526  rc = GetDefaultCommConfigA(asciiname, lpCC, lpdwSize);
     527  FreeAsciiString(asciiname);
     528  return(rc);
     529}
     530
     531/*****************************************************************************
     532 * @returns   True on Success
     533 * @param     lpszName     Pointer to devicename
     534 * @param     lpCC         Pointer to COMMCONFIG buffer.
     535 * @param     dwSize       Size of Buffer pointed to by lpCC
     536 * @remark
     537 * @status    untested
     538 * @author    Markus Montkowski
     539 *****************************************************************************/
     540
     541ODINFUNCTION3(BOOL, SetDefaultCommConfigA,
     542               LPCSTR, lpszName,
     543               LPCOMMCONFIG, lpCC,
     544               DWORD, dwSize )
     545{
     546  HFILE hCOM;
     547  BOOL rc;
     548
     549  dprintf(("SetDefaultCommConfigA untested stub \n"));
     550  SetLastError(ERROR_INVALID_PARAMETER);    /* set win32 error information */
     551  rc = FALSE;
     552
     553  if(!IsBadReadPtr(lpszName,5) &&
     554     !IsBadWritePtr(lpCC,dwSize)&&
     555     lpCC->dwSize== dwSize )
     556  {
     557    switch(lpCC->dwProviderSubType)
     558    {
     559      case PST_RS232:
     560        if(strnicmp(lpszName,"COM",3) &&
     561           strnicmp(lpszName,"\\COM",4) &&
     562           strnicmp(lpszName,"\\dev\\COM",8) )
     563        {
     564          SetLastError(ERROR_FILE_NOT_FOUND);       /* set win32 error information */
     565          return(FALSE);
     566        }
     567
     568        SetLastError(ERROR_SUCCESS);
     569
     570        hCOM = HMCreateFile( lpszName,
     571                              GENERIC_READ | GENERIC_WRITE,
     572                              0,
     573                              NULL,
     574                              OPEN_EXISTING,
     575                              FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED,
     576                              NULL);
     577        if(0!=hCOM)
     578        {
     579          rc = HMCommSetDefaultCommConfig(hCOM, lpCC, dwSize);
     580          HMCloseHandle(hCOM);
     581          return(rc);
     582        }
     583        break;
     584      case PST_PARALLELPORT:
     585      case PST_MODEM:
     586      default:
     587        SetLastError(ERROR_FILE_NOT_FOUND);
     588        dprintf(("SetDefaultCommConfigA: ProviderSubType &d Not implemented (FALSE)\n",lpCC->dwProviderSubType));
     589        break;
     590    }
     591  }
     592  return(rc);
    92593}
    93594
    … …  
    96597BOOL WIN32API SetDefaultCommConfigW( LPCWSTR lpszName, LPCOMMCONFIG lpCC, DWORD dwSize )
    97598{
    98   dprintf(("SetDefaultCommConfigW Not implemented (TRUE)\n"));
    99   return(TRUE);
    100 }
    101 
    102 //------------------------------------------------------------------------------
    103 
    104 BOOL WIN32API ClearCommBreak( HANDLE hFile )
    105 {
    106   dprintf(("ClearCommBreak Not implemented (TRUE)\n"));
    107   return(TRUE);
    108 }
    109 
    110 //------------------------------------------------------------------------------
    111 
    112 BOOL WIN32API SetupComm( HANDLE hFile, DWORD dwInQueue, DWORD dwOutQueue )
    113 {
    114   return HMSetupComm(hFile, dwInQueue, dwOutQueue);
    115 }
    116 
    117 //------------------------------------------------------------------------------
    118 
    119 BOOL WIN32API EscapeCommFunction( HANDLE hFile, UINT dwFunc )
    120 {
    121   dprintf(("EscapeCommFunction Not implemented (TRUE)\n"));
    122   return(TRUE);
     599  char *asciiname;
     600  BOOL rc;
     601
     602  asciiname  = UnicodeToAsciiString((LPWSTR)lpszName);
     603  rc = SetDefaultCommConfigA(asciiname, lpCC, dwSize);
     604  FreeAsciiString(asciiname);
     605  return(rc);
     606}
     607
     608/*****************************************************************************
     609 * @returns
     610 * @param     hFile       Comport handle
     611 * @remark
     612 * @status    untested
     613 * @author    Markus Montkowski
     614 *****************************************************************************/
     615
     616ODINFUNCTION1(BOOL, ClearCommBreak, HANDLE, hFile )
     617{
     618  return HMCommClearCommBreak(hFile);
     619}
     620
     621/*****************************************************************************
     622 * @returns
     623 * @param     hFile       Comport handle
     624 * @param     dwInQueue   recommended internal buffer size in bytes
     625 * @param     dwOutQueue  recommended internal buffer size in bytes
     626 * @remark
     627 * @status    untested
     628 * @author    Markus Montkowski
     629 *****************************************************************************/
     630
     631ODINFUNCTION3(BOOL, SetupComm,
     632               HANDLE, hFile,
     633               DWORD, dwInQueue,
     634               DWORD, dwOutQueue )
     635{
     636  return HMCommSetupComm(hFile, dwInQueue, dwOutQueue);
     637}
     638
     639/*****************************************************************************
     640 * @returns
     641 * @param     hFile       Comport handle
     642 * @param     dwFunc      extended function to perform
     643 * @remark
     644 * @status    untested
     645 * @author    Markus Montkowski
     646 *****************************************************************************/
     647
     648ODINFUNCTION2 (BOOL, EscapeCommFunction,
     649                 HANDLE, hFile,
     650                 UINT, dwFunc )
     651{
     652  return HMCommEscapeCommFunction(hFile, dwFunc);
    123653}
    124654
    … …  
    127657BOOL WIN32API GetCommConfig( HANDLE hCommDev, LPCOMMCONFIG lpCC, LPDWORD lpdwSize )
    128658{
    129   dprintf(("GetCommConfig Not implemented (TRUE)\n"));
    130   return(TRUE);
     659  return HMCommGetCommConfig(hCommDev,lpCC, lpdwSize);
    131660}
    132661
    … …  
    135664BOOL WIN32API GetCommModemStatus( HANDLE hFile, LPDWORD lpModemStat )
    136665{
    137   dprintf(("GetCommModemStatus Not implemented (TRUE)\n"));
    138   return(TRUE);
     666  return HMCommGetCommModemStatus(hFile,lpModemStat);
    139667}
    140668
    … …  
    143671BOOL WIN32API SetCommBreak( HANDLE hFile )
    144672{
    145   dprintf(("SetCommBreak Not implemented (TRUE)\n"));
    146   return(TRUE);
     673  return HMCommSetCommBreak(hFile);
    147674}
    148675
    … …  
    151678BOOL WIN32API SetCommConfig( HANDLE hCommDev, LPCOMMCONFIG lpCC, DWORD dwSize )
    152679{
    153   dprintf(("SetCommConfig Not implemented (TRUE)\n"));
    154   return(TRUE);
    155 }
    156 
    157 //------------------------------------------------------------------------------
    158 
    159 BOOL WIN32API TransmitCommChar( INT hFile, CHAR cChar )
    160 {
    161   dprintf(("TransmitCommChar Not implemented (TRUE)\n"));
    162   return(TRUE);
    163 }
    164 
    165 //------------------------------------------------------------------------------
    166 
    167 BOOL WIN32API SetCommTimeouts(INT hCommDev, LPCOMMTIMEOUTS lpctmo)
    168 {
    169   dprintf(("OS2SetCommTimeouts Not implemented (TRUE)\n"));
    170   return(TRUE);
    171 }
    172 
    173 //------------------------------------------------------------------------------
    174 
    175 BOOL WIN32API GetCommTimeouts(INT hCommDev, LPCOMMTIMEOUTS lpctmo)
    176 {
    177   dprintf(("OS2GetCommTimeouts Not implemented\n"));
    178   return(FALSE);
    179 }
    180 
    181 //------------------------------------------------------------------------------
    182 
    183 BOOL WIN32API GetCommState(INT hCommDev, LPDCB lpdcb)
    184 {
    185   return HMGetCommState(hCommDev, lpdcb);
    186 }
    187 
    188 //------------------------------------------------------------------------------
    189 
    190 BOOL WIN32API SetCommState(INT hCommDev, LPDCB lpdcb)
    191 {
    192   dprintf(("OS2SetCommState Not implemented\n"));
    193   return(FALSE);
    194 }
    195 
    196 //------------------------------------------------------------------------------
    197 
    198 BOOL WIN32API ClearCommError(INT hCommDev, LPDWORD lpdwErrors, LPCOMSTAT lpcst)
    199 {
    200   dprintf(("OS2ClearCommError Not implemented\n"));
    201   return(FALSE);
     680  return HMCommSetCommConfig(hCommDev,lpCC, dwSize);
     681}
     682
     683//------------------------------------------------------------------------------
     684
     685BOOL WIN32API TransmitCommChar( HANDLE hFile, CHAR cChar )
     686{
     687  return HMCommTransmitCommChar(hFile,cChar);
     688}
     689
     690//------------------------------------------------------------------------------
     691
     692BOOL WIN32API SetCommTimeouts( HANDLE hCommDev, LPCOMMTIMEOUTS lpctmo)
     693{
     694  return HMCommSetCommTimeouts(hCommDev, lpctmo);
     695}
     696
     697//------------------------------------------------------------------------------
     698
     699BOOL WIN32API GetCommTimeouts(HANDLE hCommDev, LPCOMMTIMEOUTS lpctmo)
     700{
     701  return HMCommGetCommTimeouts(hCommDev, lpctmo);
     702}
     703
     704//------------------------------------------------------------------------------
     705
     706BOOL WIN32API GetCommState(HANDLE hCommDev, LPDCB lpDCB)
     707{
     708  return HMCommGetCommState(hCommDev, lpDCB);
     709}
     710
     711//------------------------------------------------------------------------------
     712
     713BOOL WIN32API SetCommState(HANDLE hCommDev, LPDCB lpDCB)
     714{
     715  return HMCommSetCommState(hCommDev, lpDCB);
     716}
     717
     718//------------------------------------------------------------------------------
     719
     720BOOL WIN32API ClearCommError(HANDLE hCommDev, LPDWORD lpdwErrors, LPCOMSTAT lpcst)
     721{
     722  return HMCommClearCommError(hCommDev, lpdwErrors, lpcst);
    202723}
    203724
    … …  
    206727BOOL WIN32API PurgeComm(HANDLE hCommDev, DWORD fdwAction)
    207728{
    208   dprintf(("OS2PurgeComm Not implemented (TRUE)\n"));
    209   return(TRUE);
    210 }
    211 
    212 //------------------------------------------------------------------------------
    213 
    214 BOOL WIN32API SetCommMask(INT hCommDev, DWORD fdwEvtMask)
    215 {
    216   dprintf(("SetCommMask Not implemented (TRUE)\n"));
    217   return(TRUE);
    218 }
    219 
    220 //------------------------------------------------------------------------------
    221 
    222 BOOL WIN32API GetCommMask(HANDLE hCommDev, LPDWORD fdwEvtMask)
    223 {
    224   dprintf(("GetCommMask Not implemented (TRUE)\n"));
    225   return(TRUE);
     729  return HMCommPurgeComm(hCommDev,fdwAction);
     730}
     731
     732//------------------------------------------------------------------------------
     733
     734BOOL WIN32API SetCommMask(HANDLE hCommDev, DWORD fdwEvtMask)
     735{
     736  return HMCommSetCommMask( hCommDev,fdwEvtMask);
     737}
     738
     739//------------------------------------------------------------------------------
     740
     741BOOL WIN32API GetCommMask(HANDLE hCommDev, LPDWORD lpfdwEvtMask)
     742{
     743  return HMCommGetCommMask( hCommDev,lpfdwEvtMask);
    226744}
    227745
    … …  
    230748BOOL WIN32API GetCommProperties(HANDLE hCommDev, LPCOMMPROP lpcmmp)
    231749{
    232   dprintf(("GetCommProperties Not implemented (TRUE)\n"));
    233   return(TRUE);
    234 }
    235 
    236 //------------------------------------------------------------------------------
    237 
    238 BOOL WIN32API WaitCommEvent(HANDLE hCommDev, LPDWORD lpfdwEvtMask,
    239                    LPOVERLAPPED lpo)
    240 {
    241   dprintf(("WaitCommEvent Not implemented (TRUE)\n"));
    242   return(TRUE);
    243 }
    244 
    245 //------------------------------------------------------------------------------
    246 
     750  return HMCommGetCommProperties(hCommDev, lpcmmp);
     751}
     752
     753//------------------------------------------------------------------------------
     754
     755BOOL WIN32API WaitCommEvent( HANDLE hCommDev,
     756                             LPDWORD lpfdwEvtMask,
     757                             LPOVERLAPPED lpo)
     758{
     759  return HMCommWaitCommEvent(hCommDev, lpfdwEvtMask, lpo);
     760}
     761
     762//------------------------------------------------------------------------------
     763

  • trunk/src/kernel32/hmcomm.cpp

    r2802 r4285  
    1 /* $Id: hmcomm.cpp,v 1.4 2000-02-16 14:23:58 sandervl Exp $ */
     1/* $Id: hmcomm.cpp,v 1.5 2000-09-20 21:32:51 hugh Exp $ */
    22
    33/*
    … …  
    1010 */
    1111
    12 #include <odin.h>
    13 #include <win32type.h>
    14 #include <misc.h>
     12
     13
     14#include <os2win.h>
     15#include <string.h>
    1516#include "handlemanager.h"
    1617#include "hmdevice.h"
    … …  
    1819#include "oslibdos.h"
    1920
    20 #define DBG_LOCALLOG    DBG_hmcomm
     21#define DBG_LOCALLOG  DBG_hmcomm
    2122#include "dbglocal.h"
    2223
     24#define MAGIC_COM 0x12abcd34
     25
     26#define IOCTL_ASYNC          0x01
     27#define ASYNC_GETDCBINFO     0x73
     28#define ASYNC_SETDCBINFO     0x53
     29#define ASYNC_SETLINECTRL    0x42
     30#define ASYNC_GETCOMMEVENT   0x72
     31#define ASYNC_EXTGETBAUDRATE 0x63
     32#define ASYNC_EXTSETBAUDRATE 0x43
     33#define ASYNC_GETCOMMERROR   0x6D
     34#define ASYNC_GETCOMMSTATUS  0x65
     35#define ASYNC_GETINQUECOUNT  0x68
     36#define ASYNC_GETOUTQUECOUNT 0x69
     37#define ASYNC_GETMODEMINPUT  0x67
     38#define ASYNC_TRANSMITIMM    0x44
     39#define ASYNC_SETBREAKON     0x4B
     40#define ASYNC_SETBREAKOFF    0x45
     41#define ASYNC_SETMODEMCTRL   0x46
     42#define ASYNC_STARTTRANSMIT  0x48
     43#define ASYNC_STOPTRANSMIT   0x47
     44
     45
     46
     47#pragma pack(1)
     48typedef struct _DCBINFO
     49{
     50  USHORT   usWriteTimeout;         /*  Time period used for Write Timeout processing. */
     51  USHORT   usReadTimeout;          /*  Time period used for Read Timeout processing. */
     52  BYTE     fbCtlHndShake;          /*  HandShake Control flag. */
     53  BYTE     fbFlowReplace;          /*  Flow Control flag. */
     54  BYTE     fbTimeOut;              /*  Timeout flag. */
     55  BYTE     bErrorReplacementChar;  /*  Error Replacement Character. */
     56  BYTE     bBreakReplacementChar;  /*  Break Replacement Character. */
     57  BYTE     bXONChar;               /*  Character XON. */
     58  BYTE     bXOFFChar;              /*  Character XOFF. */
     59} DCBINFO;
     60typedef DCBINFO *PDCBINFO;
     61
     62
     63typedef struct _RXQUEUE
     64{
     65  USHORT   cch;  /*  Number of characters in the queue. */
     66  USHORT   cb;   /*  Size of receive/transmit queue. */
     67} RXQUEUE;
     68
     69typedef RXQUEUE *PRXQUEUE;
     70
     71
     72typedef struct _MODEMSTATUS
     73{
     74  BYTE   fbModemOn;   /*  Modem Control Signals ON Mask. */
     75  BYTE   fbModemOff;  /*  Modem Control Signals OFF Mask. */
     76} MODEMSTATUS;
     77
     78typedef MODEMSTATUS *PMODEMSTATUS;
     79
     80
     81#pragma pack()
     82
     83
     84
     85
     86
     87typedef struct _HMDEVCOMDATA
     88{
     89  ULONG ulMagic;
     90  // Win32 Device Control Block
     91  COMMCONFIG   CommCfg;
     92  COMMTIMEOUTS CommTOuts;
     93  DWORD dwInBuffer, dwOutBuffer;
     94  DWORD dwEventMask;
     95  //OS/2 Device Control Block
     96  DCBINFO dcbOS2;
     97} HMDEVCOMDATA, *PHMDEVCOMDATA;
     98
     99VOID * CreateDevData()
     100{
     101  PHMDEVCOMDATA pData;
     102  pData = new HMDEVCOMDATA();
     103  if(NULL!=pData)
     104  {
     105    memset(pData,0,sizeof(HMDEVCOMDATA));
     106    pData->ulMagic = MAGIC_COM;
     107    pData->CommCfg.dwSize   = sizeof(COMMCONFIG);
     108    pData->CommCfg.wVersion = 1;
     109    pData->CommCfg.dwProviderSubType = PST_RS232;
     110    pData->CommCfg.dcb.DCBlength = sizeof(DCB);
     111    pData->CommCfg.dcb.BaudRate  = CBR_1200;
     112    pData->CommCfg.dcb.ByteSize = 8;
     113    pData->CommCfg.dcb.Parity   = NOPARITY;
     114    pData->CommCfg.dcb.StopBits = ONESTOPBIT;
     115    pData->dwInBuffer  = 16;
     116    pData->dwOutBuffer = 16;
     117  }
     118  return pData;
     119}
    23120
    24121HMDeviceCommClass::HMDeviceCommClass(LPCSTR lpDeviceName) : HMDeviceHandler(lpDeviceName)
    25122{
    26   dprintf(("HMDeviceCommClass: Register COM1 to COM4 with Handle Manager\n"));
    27   HMDeviceRegister("COM1", this);
    28   HMDeviceRegister("COM2", this);
    29   HMDeviceRegister("COM3", this);
    30   HMDeviceRegister("COM4", this);
    31   HMDeviceRegister("COM5", this);
    32   HMDeviceRegister("COM6", this);
    33   HMDeviceRegister("COM7", this);
    34   HMDeviceRegister("COM8", this);
    35 }
    36 
    37 
     123  VOID *pData;
     124  dprintf(("HMDeviceCommClass: Register COM1 to COM8 with Handle Manager\n"));
     125  pData = CreateDevData();
     126  if(pData!= NULL)
     127    HMDeviceRegisterEx("COM1", this, pData);
     128  pData = CreateDevData();
     129  if(pData!= NULL)
     130    HMDeviceRegisterEx("COM2", this, pData);
     131  pData = CreateDevData();
     132  if(pData!= NULL)
     133    HMDeviceRegisterEx("COM3", this, pData);
     134  pData = CreateDevData();
     135  if(pData!= NULL)
     136    HMDeviceRegisterEx("COM4", this, pData);
     137  pData = CreateDevData();
     138  if(pData!= NULL)
     139    HMDeviceRegisterEx("COM5", this, pData);
     140  pData = CreateDevData();
     141  if(pData!= NULL)
     142    HMDeviceRegisterEx("COM6", this, pData);
     143  pData = CreateDevData();
     144  if(pData!= NULL)
     145    HMDeviceRegisterEx("COM7", this, pData);
     146  pData = CreateDevData();
     147  if(pData!= NULL)
     148    HMDeviceRegisterEx("COM8", this, pData);
     149}
    38150
    39151DWORD HMDeviceCommClass::CreateFile(LPCSTR lpFileName,
    … …  
    46158  pHMHandleData->hHMHandle = 0;
    47159
    48   //AH: TODO parse Win32 security handles   
     160  //AH: TODO parse Win32 security handles
    49161  OSLibDosDisableHardError(TRUE);
    50162  pHMHandleData->hHMHandle = OSLibDosOpen((char*)lpFileName,
    … …  
    54166  OSLibDosDisableHardError(FALSE);
    55167  if (pHMHandleData->hHMHandle != 0)
     168  {
     169    ULONG ulLen;
     170    APIRET rc;
     171
     172    pHMHandleData->lpHandlerData = new HMDEVCOMDATA();
     173    // Init The handle instance with the default default device config
     174    memcpy( pHMHandleData->lpHandlerData,
     175            pHMHandleData->lpDeviceData,
     176            sizeof(HMDEVCOMDATA));
     177
     178    ulLen = sizeof(DCBINFO);
     179
     180    rc = OSLibDosDevIOCtl( pHMHandleData->hHMHandle,
     181                      IOCTL_ASYNC,
     182                      ASYNC_GETDCBINFO,
     183                      0,0,0,
     184                      &((PHMDEVCOMDATA)pHMHandleData->lpHandlerData)->dcbOS2,ulLen,&ulLen);
     185
     186    if(!rc)
     187    {
     188      return -1;
     189    }
    56190    return 0;
     191  }
    57192  else
    58193    return  -1;
    … …  
    64199{
    65200  dprintf(("HMComm: Serial communication port close request\n"));
     201  delete pHMHandleData->lpHandlerData;
    66202  return OSLibDosClose(pHMHandleData->hHMHandle);
    67203}
    68204
    69205/*****************************************************************************
    70  * Name      : DWORD HMDeviceHandler::SetupComm     
     206 * Name      : DWORD HMDeviceHandler::SetupComm
    71207 * Purpose   : set com port parameters (queue)
    72208 * Variables :
    73  * Result    : 
     209 * Result    :
    74210 * Remark    :
    75211 * Status    :
    … …  
    78214 *****************************************************************************/
    79215
    80 BOOL HMDeviceCommClass::SetupComm(PHMHANDLEDATA pHMHandleData, DWORD dwInQueue, DWORD dwOutQueue)
    81 {
    82   dprintf(("HMDeviceCommClass::SetupComm unimplemented stub!"));
    83 
    84 
    85   return(TRUE);
    86 }
     216BOOL HMDeviceCommClass::SetupComm( PHMHANDLEDATA pHMHandleData,
     217                                   DWORD dwInQueue,
     218                                   DWORD dwOutQueue)
     219{
     220  dprintf(("HMDeviceCommClass::SetupComm "));
     221  PHMDEVCOMDATA pDevData = (PHMDEVCOMDATA)pHMHandleData->lpHandlerData;
     222  if((NULL==pDevData) || (pDevData->ulMagic != MAGIC_COM) )
     223  {
     224    O32_SetLastError(ERROR_INVALID_HANDLE);
     225    return FALSE;
     226  }
     227  pDevData->dwInBuffer  = dwInQueue;
     228  pDevData->dwOutBuffer = dwOutQueue;
     229
     230  return(TRUE);
     231}
     232
     233BOOL HMDeviceCommClass::WaitCommEvent( PHMHANDLEDATA pHMHandleData,
     234                                       LPDWORD lpfdwEvtMask,
     235                                       LPOVERLAPPED lpo)
     236{
     237  APIRET rc;
     238  ULONG ulLen;
     239  USHORT COMEvt;
     240  DWORD dwEvent,dwMask;
     241
     242  PHMDEVCOMDATA pDevData = (PHMDEVCOMDATA)pHMHandleData->lpHandlerData;
     243
     244  dprintf(("HMDeviceCommClass::WaitCommEvent"));
     245  ulLen = sizeof(CHAR);
     246
     247  dwEvent = 0;
     248  rc = 0;
     249  ulLen = sizeof(COMEvt);
     250  dwMask = pDevData->dwEventMask;
     251  while( (0==rc) &&
     252        !(dwEvent & dwMask) &&
     253        (dwMask ==pDevData->dwEventMask) ) // Exit if the Mask gets changed
     254  {
     255    rc = OSLibDosDevIOCtl( pHMHandleData->hHMHandle,
     256                      IOCTL_ASYNC,
     257                      ASYNC_GETCOMMEVENT,
     258                      0,0,0,
     259                      &COMEvt,ulLen,&ulLen);
     260    if(!rc)
     261    {
     262      dwEvent |= (COMEvt&0x0001)? EV_RXCHAR:0;
     263      //dwEvent |= (COMEvt&0x0002)? 0:0;
     264      dwEvent |= (COMEvt&0x0004)? EV_TXEMPTY:0;
     265      dwEvent |= (COMEvt&0x0008)? EV_CTS:0;
     266      dwEvent |= (COMEvt&0x0010)? EV_DSR:0;
     267      //dwEvent |= (COMEvt&0x0020)? 0:0; DCS = RLSD?
     268      dwEvent |= (COMEvt&0x0040)? EV_BREAK:0;
     269      dwEvent |= (COMEvt&0x0080)? EV_ERR:0;
     270      dwEvent |= (COMEvt&0x0100)? EV_RING:0;
     271    }
     272    DosSleep(100);
     273  }
     274  *lpfdwEvtMask = rc==0?dwEvent:0;
     275  return(rc==0);
     276}
     277
     278
     279#pragma pack(1)
     280typedef struct
     281{
     282  ULONG ulCurrBaud;
     283  UCHAR ucCurrFrac;
     284  ULONG ulMinBaud;
     285  UCHAR ucMinFrac;
     286  ULONG ulMaxBaud;
     287  UCHAR ucMaxFrac;
     288} EXTBAUDGET, *PEXTBAUDGET;
     289
     290typedef struct
     291{
     292  ULONG ulBaud;
     293  UCHAR ucFrac;
     294} EXTBAUDSET, *PEXTBAUDSET;
     295#pragma pack()
     296
     297BAUDTABLEENTRY BaudTable[] =
     298{
     299  {75,BAUD_075},
     300  {110,BAUD_110},
     301  {134,BAUD_134_5},
     302  {150,BAUD_150},
     303  {300,BAUD_300},
     304  {600,BAUD_600},
     305  {1200,BAUD_1200},
     306  {1800,BAUD_1800},
     307  {2400,BAUD_2400},
     308  {4800,BAUD_4800},
     309  {7200,BAUD_7200},
     310  {9600,BAUD_9600},
     311  {14400,BAUD_14400},
     312  {19200,BAUD_19200},
     313  {38400,BAUD_38400},
     314  {56000,BAUD_56K},
     315  {57600,BAUD_57600},
     316  {115200,BAUD_115200},
     317  {128000,BAUD_128K}
     318};
     319
     320#define BaudTableSize (sizeof(BaudTable)/sizeof(BAUDTABLEENTRY))
     321
     322BOOL HMDeviceCommClass::GetCommProperties( PHMHANDLEDATA pHMHandleData,
     323                                           LPCOMMPROP lpcmmp)
     324{
     325  EXTBAUDGET BaudInfo;
     326  APIRET rc;
     327  ULONG ulLen;
     328  USHORT COMErr;
     329  int i;
     330  dprintf(("HMDeviceCommClass::GetCommProperties"));
     331
     332  ulLen = sizeof(EXTBAUDGET);
     333  rc = OSLibDosDevIOCtl( pHMHandleData->hHMHandle,
     334                    IOCTL_ASYNC,
     335                    ASYNC_EXTGETBAUDRATE,
     336                    0,0,0,
     337                    &BaudInfo,ulLen,&ulLen);
     338  memset(lpcmmp,0,sizeof(COMMPROP));
     339  lpcmmp->wPacketLength  = sizeof(COMMPROP);
     340  lpcmmp->wPacketVersion = 1; //???
     341  lpcmmp->dwServiceMask  = SP_SERIALCOMM;
     342  for(i=0;i<BaudTableSize && BaudInfo.ulMaxBaud <= BaudTable[i].dwBaudRate;i++);
     343  lpcmmp->dwMaxBaud      = BaudTable[i].dwBaudFlag;
     344  lpcmmp->dwProvSubType =  PST_RS232;
     345  lpcmmp->dwProvCapabilities = PCF_DTRDSR | PCF_PARITY_CHECK |
     346                               PCF_RTSCTS | PCF_SETXCHAR |
     347                               PCF_XONXOFF;
     348  lpcmmp->dwSettableParams   = SP_BAUD | SP_DATABITS |
     349                               SP_HANDSHAKEING | SP_PARITY |
     350                               SP_PARITY_CHECK | SP_STOPBIT;
     351  lpcmmp->dwSettableBaud = 0;
     352  for(i=0;i<BaudTableSize;i++)
     353  {
     354    if ( (BaudTable[i].dwBaudRate>=BaudInfo.ulMinBaud) &&
     355         (BaudTable[i].dwBaudRate<=BaudInfo.ulMaxBaud) )
     356      lpcmmp->dwSettableBaud |= BaudTable[i].dwBaudFlag;
     357  }
     358  lpcmmp->dwSettableBaud |= BAUD_USER;
     359  lpcmmp->wSettableData = DATABITS_5 | DATABITS_6 | DATABITS_7 | DATABITS_8;
     360  lpcmmp->wSettableStopParity = STOPBITS_10 | STOPBITS_15 | STOPBITS_20 |
     361                                PARITY_NONE | PARITY_ODD | PARITY_EVEN |
     362                                PARITY_MARK | PARITY_SPACE;
     363  return(rc==0);
     364}
     365
     366BOOL HMDeviceCommClass::GetCommMask( PHMHANDLEDATA pHMHandleData,
     367                                     LPDWORD lpfdwEvtMask)
     368{
     369  PHMDEVCOMDATA pDevData = (PHMDEVCOMDATA)pHMHandleData->lpHandlerData;
     370
     371  dprintf(("HMDeviceCommClass::GetCommMask"));
     372
     373  *lpfdwEvtMask = pDevData->dwEventMask;
     374  return(TRUE);
     375}
     376
     377BOOL HMDeviceCommClass::SetCommMask( PHMHANDLEDATA pHMHandleData,
     378                                     DWORD fdwEvtMask)
     379{
     380  PHMDEVCOMDATA pDevData = (PHMDEVCOMDATA)pHMHandleData->lpHandlerData;
     381  dprintf(("HMDeviceCommClass::SetCommMask"));
     382
     383  pDevData->dwEventMask = fdwEvtMask & ~(EV_RLSD|EV_RXFLAG); // Clear the 2 not supported Flags.
     384  return(TRUE);
     385}
     386
     387BOOL HMDeviceCommClass::PurgeComm( PHMHANDLEDATA pHMHandleData,
     388                                   DWORD fdwAction)
     389{
     390  dprintf(("HMDeviceCommClass::PurgeComm unimplemented stub!"));
     391  // ToDo: find a way to stop the current transmision didn't find
     392  // any clue how to in Control Program Guide and reference
     393
     394  return(TRUE);
     395}
     396BOOL HMDeviceCommClass::ClearCommError( PHMHANDLEDATA pHMHandleData,
     397                                        LPDWORD lpdwErrors,
     398                                        LPCOMSTAT lpcst)
     399{
     400  APIRET rc;
     401  ULONG ulLen;
     402  USHORT COMErr;
     403
     404  dprintf(("HMDeviceCommClass::ClearCommError"));
     405  ulLen = sizeof(USHORT);
     406
     407  rc = OSLibDosDevIOCtl( pHMHandleData->hHMHandle,
     408                    IOCTL_ASYNC,
     409                    ASYNC_GETCOMMERROR,
     410                    0,0,0,
     411                    &COMErr,2,&ulLen);
     412  *lpdwErrors = 0;
     413  *lpdwErrors |= (COMErr & 0x0001)?CE_OVERRUN:0;
     414  *lpdwErrors |= (COMErr & 0x0002)?CE_RXOVER:0;
     415  *lpdwErrors |= (COMErr & 0x0004)?CE_RXPARITY:0;
     416  *lpdwErrors |= (COMErr & 0x0008)?CE_FRAME:0;
     417
     418  if(lpcst)
     419  {
     420    UCHAR ucStatus;
     421    RXQUEUE qInfo;
     422    ulLen = 1;
     423    rc = OSLibDosDevIOCtl( pHMHandleData->hHMHandle,
     424                      IOCTL_ASYNC,
     425                      ASYNC_GETCOMMSTATUS,
     426                      0,0,0,
     427                      &ucStatus,ulLen,&ulLen);
     428    if(!rc)
     429    {
     430      lpcst->fCtsHold  = ((ucStatus & 0x01)>0);
     431      lpcst->fDsrHold  = ((ucStatus & 0x02)>0);
     432      lpcst->fRlsdHold = FALSE;//(ucStatus & 0x04)>0);
     433      lpcst->fXoffHold = ((ucStatus & 0x08)>0);
     434      lpcst->fXoffSend = ((ucStatus & 0x10)>0);
     435      lpcst->fEof      = ((ucStatus & 0x20)>0);// Is break = Eof ??
     436      lpcst->fTxim     = ((ucStatus & 0x40)>0);
     437
     438      ulLen = sizeof(qInfo);
     439      rc = OSLibDosDevIOCtl( pHMHandleData->hHMHandle,
     440                        IOCTL_ASYNC,
     441                        ASYNC_GETINQUECOUNT,
     442                        0,0,0,
     443                        &qInfo,ulLen,&ulLen);
     444      if(!rc)
     445      {
     446        lpcst->cbInQue   = qInfo.cch;
     447        rc = OSLibDosDevIOCtl( pHMHandleData->hHMHandle,
     448                          IOCTL_ASYNC,
     449                          ASYNC_GETOUTQUECOUNT,
     450                          0,0,0,
     451                          &qInfo,ulLen,&ulLen);
     452        if(!rc)
     453          lpcst->cbOutQue = qInfo.cch;
     454      }
     455    }
     456  }
     457
     458  return(rc==0);
     459}
     460BOOL HMDeviceCommClass::SetCommState( PHMHANDLEDATA pHMHandleData,
     461                                      LPDCB lpDCB)
     462{
     463  APIRET rc;
     464  PHMDEVCOMDATA pDevData = (PHMDEVCOMDATA)pHMHandleData->lpHandlerData;
     465  DCB *pCurDCB = &pDevData->CommCfg.dcb;
     466  dprintf(("HMDeviceCommClass::SetCommState"));
     467
     468  rc = 0;
     469  if(pCurDCB->BaudRate != lpDCB->BaudRate)
     470    rc = SetBaud( pHMHandleData,
     471                  lpDCB->BaudRate);
     472
     473  if(!rc)
     474  {
     475    if( (pCurDCB->ByteSize != lpDCB->ByteSize) ||
     476        (pCurDCB->Parity   != lpDCB->Parity) ||
     477        (pCurDCB->StopBits != lpDCB->StopBits))
     478      rc = SetLine( pHMHandleData,
     479                    lpDCB->ByteSize,
     480                    lpDCB->Parity,
     481                    lpDCB->StopBits);
     482  }
     483
     484  if(!rc)
     485  {
     486    if( (pCurDCB->fOutxCtsFlow       != lpDCB->fOutxCtsFlow) ||
     487        (pCurDCB->fOutxDsrFlow       != lpDCB->fOutxDsrFlow) ||
     488        (pCurDCB->fDtrControl        != lpDCB->fDtrControl) ||
     489        (pCurDCB->fDsrSensitivity    != lpDCB->fDsrSensitivity) ||
     490        (pCurDCB->fTXContinueOnXoff  != lpDCB->fTXContinueOnXoff) ||
     491        (pCurDCB->fOutX              != lpDCB->fOutX) ||
     492        (pCurDCB->fInX               != lpDCB->fInX) ||
     493        (pCurDCB->fErrorChar         != lpDCB->fErrorChar) ||
     494        (pCurDCB->fNull              != lpDCB->fNull) ||
     495        (pCurDCB->fRtsControl        != lpDCB->fRtsControl) ||
     496        (pCurDCB->fAbortOnError      != lpDCB->fAbortOnError) ||
     497        (pCurDCB->XonChar            != lpDCB->XonChar) ||
     498        (pCurDCB->XoffChar           != lpDCB->XoffChar) ||
     499        (pCurDCB->ErrorChar          != lpDCB->ErrorChar))
     500      SetOS2DCB( pHMHandleData,
     501                 lpDCB->fOutxCtsFlow, lpDCB->fOutxDsrFlow,
     502                 lpDCB->fDtrControl,  lpDCB->fDsrSensitivity,
     503                 lpDCB->fTXContinueOnXoff, lpDCB->fOutX,
     504                 lpDCB->fInX, lpDCB->fErrorChar,
     505                 lpDCB->fNull, lpDCB->fRtsControl,
     506                 lpDCB->fAbortOnError, lpDCB->XonChar,
     507                 lpDCB->XoffChar,lpDCB->ErrorChar);
     508  }
     509
     510  return(rc==0);
     511}
     512BOOL HMDeviceCommClass::GetCommState( PHMHANDLEDATA pHMHandleData,
     513                                      LPDCB lpdcb)
     514{
     515  PHMDEVCOMDATA pDevData = (PHMDEVCOMDATA)pHMHandleData->lpHandlerData;
     516
     517  dprintf(("HMDeviceCommClass::GetCommState"));
     518  memcpy(lpdcb,&pDevData->CommCfg.dcb,sizeof(DCB));
     519
     520  return(TRUE);
     521}
     522BOOL HMDeviceCommClass::GetCommModemStatus( PHMHANDLEDATA pHMHandleData,
     523                                          LPDWORD lpModemStat )
     524{
     525  APIRET rc;
     526  ULONG ulLen;
     527  USHORT COMErr;
     528  UCHAR ucStatus;
     529
     530  dprintf(("HMDeviceCommClass::TransmitCommChar partly implemented"));
     531  ulLen = sizeof(CHAR);
     532
     533  ulLen = 1;
     534  *lpModemStat = 0;
     535
     536  rc = OSLibDosDevIOCtl( pHMHandleData->hHMHandle,
     537                    IOCTL_ASYNC,
     538                    ASYNC_GETMODEMINPUT,
     539                    0,0,0,
     540                    &ucStatus,ulLen,&ulLen);
     541  if(!rc)
     542  {
     543    *lpModemStat |= (ucStatus & 0x10)? MS_CTS_ON:0;
     544    *lpModemStat |= (ucStatus & 0x20)? MS_DSR_ON:0;
     545    *lpModemStat |= (ucStatus & 0x40)? MS_RING_ON:0;
     546    //*lpModemStat |= (ucStatus & 0x80)? MS_RSLD_ON:0;
     547  }
     548
     549  return(rc==0);
     550}
     551
     552BOOL HMDeviceCommClass::GetCommTimeouts( PHMHANDLEDATA pHMHandleData,
     553                                         LPCOMMTIMEOUTS lpctmo)
     554{
     555  PHMDEVCOMDATA pDevData = (PHMDEVCOMDATA)pHMHandleData->lpHandlerData;
     556
     557  dprintf(("HMDeviceCommClass::GetCommTimeouts stub"));
     558  memcpy( lpctmo,
     559          &pDevData->CommTOuts,
     560          sizeof(COMMTIMEOUTS));
     561  return(TRUE);
     562}
     563BOOL HMDeviceCommClass::SetCommTimeouts( PHMHANDLEDATA pHMHandleData,
     564                                         LPCOMMTIMEOUTS lpctmo)
     565{
     566  PHMDEVCOMDATA pDevData = (PHMDEVCOMDATA)pHMHandleData->lpHandlerData;
     567  DCBINFO os2dcb;
     568  ULONG ulLen;
     569  APIRET rc;
     570
     571  memcpy( &pDevData->CommTOuts,
     572          lpctmo,
     573          sizeof(COMMTIMEOUTS));
     574
     575  memcpy(&os2dcb,&pDevData->dcbOS2,sizeof(DCBINFO));
     576
     577  os2dcb.fbTimeOut = 0x01;
     578  if(MAXDWORD==pDevData->CommTOuts.ReadIntervalTimeout)
     579  {
     580    if( (0==pDevData->CommTOuts.ReadTotalTimeoutMultiplier) &&
     581        (0==pDevData->CommTOuts.ReadTotalTimeoutConstant))
     582      os2dcb.fbTimeOut = 0x03;
     583    else
     584      os2dcb.fbTimeOut = 0x02;
     585  }
     586  else
     587  {
     588    DWORD dwTimeout;
     589    dwTimeout = pDevData->CommTOuts.ReadIntervalTimeout/10;
     590    if(dwTimeout)
     591      dwTimeout--; // 0=10 ms unit is 10ms or .01s
     592    os2dcb.usWriteTimeout = 0x0000FFFF & dwTimeout;
     593    os2dcb.usReadTimeout  = 0x0000FFFF & dwTimeout;
     594  }
     595  ulLen = sizeof(DCBINFO);
     596  rc = OSLibDosDevIOCtl( pHMHandleData->hHMHandle,
     597                          IOCTL_ASYNC,
     598                          ASYNC_SETDCBINFO,
     599                          &os2dcb,ulLen,&ulLen,
     600                          NULL,0,NULL);
     601
     602  return(0==rc);
     603}
     604BOOL HMDeviceCommClass::TransmitCommChar( PHMHANDLEDATA pHMHandleData,
     605                                          CHAR cChar )
     606{
     607  APIRET rc;
     608  ULONG ulLen;
     609  USHORT COMErr;
     610
     611  dprintf(("HMDeviceCommClass::TransmitCommChar"));
     612  ulLen = sizeof(CHAR);
     613
     614  rc = OSLibDosDevIOCtl( pHMHandleData->hHMHandle,
     615                    IOCTL_ASYNC,
     616                    ASYNC_TRANSMITIMM,
     617                    &cChar,ulLen,&ulLen,
     618                    NULL,0,NULL);
     619
     620  return(rc==0);
     621}
     622
     623BOOL HMDeviceCommClass::SetCommBreak( PHMHANDLEDATA pHMHandleData )
     624{
     625  APIRET rc;
     626  ULONG ulLen;
     627  USHORT COMErr;
     628
     629  dprintf(("HMDeviceCommClass::SetCommBreak"));
     630  ulLen = sizeof(USHORT);
     631
     632  rc = OSLibDosDevIOCtl( pHMHandleData->hHMHandle,
     633                    IOCTL_ASYNC,
     634                    ASYNC_SETBREAKON,
     635                    0,0,0,
     636                    &COMErr,2,&ulLen);
     637
     638  return(rc==0);
     639}
     640
     641BOOL HMDeviceCommClass::ClearCommBreak( PHMHANDLEDATA pHMHandleData)
     642{
     643  APIRET rc;
     644  ULONG ulLen;
     645  USHORT COMErr;
     646
     647  dprintf(("HMDeviceCommClass::ClearCommBreak"));
     648  ulLen = sizeof(USHORT);
     649
     650  rc = OSLibDosDevIOCtl( pHMHandleData->hHMHandle,
     651                    IOCTL_ASYNC,
     652                    ASYNC_SETBREAKOFF,
     653                    0,0,0,
     654                    &COMErr,2,&ulLen);
     655
     656  return(rc==0);
     657}
     658
     659BOOL HMDeviceCommClass::SetCommConfig( PHMHANDLEDATA pHMHandleData,
     660                                       LPCOMMCONFIG lpCC,
     661                                       DWORD dwSize )
     662{
     663  dprintf(("HMDeviceCommClass::SetCommConfig"));
     664
     665
     666  return(TRUE);
     667}
     668
     669BOOL HMDeviceCommClass::GetCommConfig( PHMHANDLEDATA pHMHandleData,
     670                                       LPCOMMCONFIG lpCC,
     671                                       LPDWORD lpdwSize )
     672{
     673  PHMDEVCOMDATA pDevData = (PHMDEVCOMDATA)pHMHandleData->lpHandlerData;
     674
     675  dprintf(("HMDeviceCommClass::GetCommConfig"));
     676
     677  if( O32_IsBadWritePtr(lpCC,sizeof(COMMCONFIG)) ||
     678      *lpdwSize< sizeof(COMMCONFIG) )
     679  {
     680    O32_SetLastError(ERROR_INSUFFICIENT_BUFFER);
     681    *lpdwSize= sizeof(COMMCONFIG);
     682    return FALSE;
     683  }
     684
     685  if((NULL==pDevData) || (pDevData->ulMagic != MAGIC_COM) )
     686  {
     687    O32_SetLastError(ERROR_INVALID_HANDLE);
     688    return FALSE;
     689  }
     690
     691  memcpy(lpCC,&pDevData->CommCfg,sizeof(COMMCONFIG));
     692  *lpdwSize = sizeof(COMMCONFIG);
     693  return(TRUE);
     694
     695
     696  return(TRUE);
     697}
     698
     699BOOL HMDeviceCommClass::EscapeCommFunction( PHMHANDLEDATA pHMHandleData,
     700                                            UINT dwFunc )
     701{
     702  APIRET rc;
     703  ULONG ulDLen,ulPLen;
     704  USHORT COMErr;
     705  MODEMSTATUS mdm;
     706
     707  dprintf(("HMDeviceCommClass::EscapeCommFunction"));
     708
     709  ulDLen = sizeof(USHORT);
     710  ulPLen = sizeof(MODEMSTATUS);
     711  switch(dwFunc)
     712  {
     713    case CLRDTR:
     714      mdm.fbModemOn  = 0x00;
     715      mdm.fbModemOff = 0XFE;
     716      rc = OSLibDosDevIOCtl( pHMHandleData->hHMHandle,
     717                             IOCTL_ASYNC,
     718                             ASYNC_SETMODEMCTRL,
     719                             &mdm,ulPLen,&ulPLen,
     720                             &COMErr,ulDLen,&ulDLen);
     721      break;
     722    case CLRRTS:
     723      mdm.fbModemOn  = 0x00;
     724      mdm.fbModemOff = 0XFD;
     725      rc = OSLibDosDevIOCtl( pHMHandleData->hHMHandle,
     726                             IOCTL_ASYNC,
     727                             ASYNC_SETMODEMCTRL,
     728                             &mdm,ulPLen,&ulPLen,
     729                             &COMErr,ulDLen,&ulDLen);
     730      break;
     731    case SETDTR:
     732      mdm.fbModemOn  = 0x01;
     733      mdm.fbModemOff = 0XFF;
     734      rc = OSLibDosDevIOCtl( pHMHandleData->hHMHandle,
     735                             IOCTL_ASYNC,
     736                             ASYNC_SETMODEMCTRL,
     737                             &mdm,ulPLen,&ulPLen,
     738                             &COMErr,ulDLen,&ulDLen);
     739      break;
     740    case SETRTS:
     741      mdm.fbModemOn  = 0x02;
     742      mdm.fbModemOff = 0XFF;
     743      rc = OSLibDosDevIOCtl( pHMHandleData->hHMHandle,
     744                             IOCTL_ASYNC,
     745                             ASYNC_SETMODEMCTRL,
     746                             &mdm,ulPLen,&ulPLen,
     747                             &COMErr,ulDLen,&ulDLen);
     748      break;
     749    case SETXOFF:
     750      rc = OSLibDosDevIOCtl( pHMHandleData->hHMHandle,
     751                             IOCTL_ASYNC,
     752                             ASYNC_STOPTRANSMIT,
     753                             0,0,0,
     754                             0,0,0);
     755      break;
     756    case SETXON:
     757      rc = OSLibDosDevIOCtl( pHMHandleData->hHMHandle,
     758                             IOCTL_ASYNC,
     759                             ASYNC_STARTTRANSMIT,
     760                             0,0,0,
     761                             0,0,0);
     762      break;
     763    default:
     764      O32_SetLastError(ERROR_INVALID_PARAMETER);
     765      return(FALSE);
     766  }
     767
     768  return(rc==0);
     769}
     770
     771BOOL HMDeviceCommClass::SetDefaultCommConfig( PHMHANDLEDATA pHMHandleData,
     772                                              LPCOMMCONFIG lpCC,
     773                                              DWORD dwSize)
     774{
     775  PHMDEVCOMDATA pDevData = (PHMDEVCOMDATA)pHMHandleData->lpDeviceData;
     776  if((NULL==pDevData) || (pDevData->ulMagic != MAGIC_COM) )
     777  {
     778    O32_SetLastError(ERROR_INVALID_HANDLE);
     779    return FALSE;
     780  }
     781  memset(&pDevData->CommCfg,0, sizeof(COMMCONFIG));
     782  memcpy(&pDevData->CommCfg,lpCC,dwSize>sizeof(COMMCONFIG)?sizeof(COMMCONFIG):dwSize);
     783
     784  return(TRUE);
     785}
     786BOOL HMDeviceCommClass::GetDefaultCommConfig( PHMHANDLEDATA pHMHandleData,
     787                                              LPCOMMCONFIG lpCC,
     788                                              LPDWORD lpdwSize)
     789{
     790  PHMDEVCOMDATA pDevData = (PHMDEVCOMDATA)pHMHandleData->lpDeviceData;
     791
     792  if( O32_IsBadWritePtr(lpCC,sizeof(COMMCONFIG)) ||
     793      *lpdwSize< sizeof(COMMCONFIG) )
     794  {
     795    O32_SetLastError(ERROR_INSUFFICIENT_BUFFER);
     796    *lpdwSize= sizeof(COMMCONFIG);
     797    return FALSE;
     798  }
     799
     800  if((NULL==pDevData) || (pDevData->ulMagic != MAGIC_COM) )
     801  {
     802    O32_SetLastError(ERROR_INVALID_HANDLE);
     803    return FALSE;
     804  }
     805
     806  memcpy(lpCC,&pDevData->CommCfg,sizeof(COMMCONFIG));
     807  *lpdwSize = sizeof(COMMCONFIG);
     808  return(TRUE);
     809}
     810APIRET HMDeviceCommClass::SetLine( PHMHANDLEDATA pHMHandleData,
     811                                   UCHAR ucSize,
     812                                   UCHAR ucParity,
     813                                   UCHAR ucStop)
     814{
     815  APIRET rc;
     816  ULONG ulLen;
     817  PHMDEVCOMDATA pDevData = (PHMDEVCOMDATA)pHMHandleData->lpHandlerData;
     818  DCB *pCurDCB = &pDevData->CommCfg.dcb;
     819  struct
     820  {
     821    UCHAR ucSize;
     822    UCHAR ucParity;
     823    UCHAR ucStop;
     824    UCHAR ucPadding;
     825  }Param;
     826
     827  ulLen = 3;
     828  Param.ucSize   = ucSize;
     829  Param.ucParity = ucParity;
     830  Param.ucStop   = ucStop;
     831
     832  rc = OSLibDosDevIOCtl( pHMHandleData->hHMHandle,
     833                    IOCTL_ASYNC,
     834                    ASYNC_SETLINECTRL,
     835                    &Param,ulLen,&ulLen,
     836                    NULL,0,NULL);
     837
     838  if(0==rc)
     839  {
     840    pCurDCB->ByteSize = ucSize;
     841    pCurDCB->Parity   = ucParity;
     842    pCurDCB->StopBits = ucStop;
     843  }
     844
     845  return rc;
     846}
     847
     848APIRET HMDeviceCommClass::SetOS2DCB( PHMHANDLEDATA pHMHandleData,
     849                                     BOOL fOutxCtsFlow, BOOL fOutxDsrFlow,
     850                                     UCHAR ucDtrControl,  BOOL fDsrSensitivity,
     851                                     BOOL fTXContinueOnXoff, BOOL fOutX,
     852                                     BOOL fInX, BOOL fErrorChar,
     853                                     BOOL fNull, UCHAR ucRtsControl,
     854                                     BOOL fAbortOnError, BYTE XonChar,
     855                                     BYTE XoffChar,BYTE ErrorChar)
     856{
     857  APIRET rc;
     858  ULONG ulLen;
     859  DCBINFO os2dcb;
     860
     861  PHMDEVCOMDATA pDevData = (PHMDEVCOMDATA)pHMHandleData->lpHandlerData;
     862  DCB *pCurDCB = &pDevData->CommCfg.dcb;
     863
     864  memcpy(&os2dcb,&pDevData->dcbOS2,sizeof(DCBINFO));
     865  os2dcb.fbCtlHndShake = (ucDtrControl & 0x03) |
     866                         (fOutxCtsFlow?0x08:0x00) |
     867                         (fOutxDsrFlow?0x10:0x00) |
     868                         // No DCD support in Win32 ?!
     869                         (fDsrSensitivity?0x40:0x00);
     870  os2dcb.fbFlowReplace = (fOutX?0x01:0x00) |
     871                         (fInX?0x02:0x00) |
     872                         (fErrorChar?0x04:0x00)|
     873                         (fNull?0x08:0x00)|
     874                         (fTXContinueOnXoff?0x02:0x00)| // Not sure if thats the right flag to test
     875                         (ucRtsControl<<6);
     876
     877  os2dcb.fbTimeOut = 0x01;
     878  if(MAXDWORD==pDevData->CommTOuts.ReadIntervalTimeout)
     879  {
     880    if( (0==pDevData->CommTOuts.ReadTotalTimeoutMultiplier) &&
     881        (0==pDevData->CommTOuts.ReadTotalTimeoutConstant))
     882      os2dcb.fbTimeOut = 0x03;
     883    else
     884      os2dcb.fbTimeOut = 0x02;
     885  }
     886  else
     887  {
     888    DWORD dwTimeout;
     889    dwTimeout = pDevData->CommTOuts.ReadIntervalTimeout/10;
     890    if(dwTimeout)
     891      dwTimeout--; // 0=10 ms unit is 10ms or .01s
     892    os2dcb.usWriteTimeout = 0x0000FFFF & dwTimeout;
     893    os2dcb.usReadTimeout  = 0x0000FFFF & dwTimeout;
     894  }
     895  os2dcb.bErrorReplacementChar = ErrorChar;
     896  os2dcb.bXONChar              = XonChar;
     897  os2dcb.bXOFFChar             = XoffChar;
     898  ulLen = sizeof(DCBINFO);
     899  rc = OSLibDosDevIOCtl( pHMHandleData->hHMHandle,
     900                          IOCTL_ASYNC,
     901                          ASYNC_SETDCBINFO,
     902                          &os2dcb,ulLen,&ulLen,
     903                          NULL,0,NULL);
     904
     905  if(0==rc)
     906  {
     907    memcpy(&pDevData->dcbOS2,&os2dcb,sizeof(DCBINFO));
     908    pCurDCB->fOutxCtsFlow       = fOutxCtsFlow;
     909    pCurDCB->fOutxDsrFlow       = fOutxDsrFlow;
     910    pCurDCB->fDtrControl        = ucDtrControl;
     911    pCurDCB->fDsrSensitivity    = fDsrSensitivity;
     912    pCurDCB->fTXContinueOnXoff  = fTXContinueOnXoff;
     913    pCurDCB->fOutX              = fOutX;
     914    pCurDCB->fInX               = fInX;
     915    pCurDCB->fErrorChar         = fErrorChar;
     916    pCurDCB->fNull              = fNull;
     917    pCurDCB->fRtsControl        = ucRtsControl;
     918    pCurDCB->fAbortOnError      = fAbortOnError;
     919    pCurDCB->XonChar            = XonChar;
     920    pCurDCB->XoffChar           = XoffChar;
     921    pCurDCB->ErrorChar          = ErrorChar;
     922  }
     923
     924  return rc;
     925
     926}
     927
     928APIRET HMDeviceCommClass::SetBaud( PHMHANDLEDATA pHMHandleData,
     929                                   DWORD dwNewBaud)
     930{
     931  APIRET rc;
     932  ULONG ulLen;
     933  EXTBAUDSET SetBaud;
     934  EXTBAUDGET GetBaud;
     935  ulLen = sizeof(SetBaud);
     936  SetBaud.ulBaud = dwNewBaud;
     937  rc = OSLibDosDevIOCtl( pHMHandleData->hHMHandle,
     938                    IOCTL_ASYNC,
     939                    ASYNC_EXTSETBAUDRATE,
     940                    &SetBaud,ulLen,&ulLen,
     941                    NULL,0,NULL);
     942  if(0==rc)
     943  {
     944    ulLen = sizeof(GetBaud);
     945    rc = OSLibDosDevIOCtl( pHMHandleData->hHMHandle,
     946                      IOCTL_ASYNC,
     947                      ASYNC_EXTGETBAUDRATE,
     948                      NULL,0,NULL,
     949                      &GetBaud,ulLen,&ulLen);
     950    if(0==rc)
     951    {
     952      if(dwNewBaud !=GetBaud.ulCurrBaud)
     953        rc = 1; // ToDo set a proper Errorhandling
     954      else
     955      {
     956        ((PHMDEVCOMDATA)pHMHandleData->lpDeviceData)->CommCfg.dcb.BaudRate = dwNewBaud;
     957        ((PHMDEVCOMDATA)pHMHandleData->lpDeviceData)->CommCfg.dcb.BaudRate = dwNewBaud;
     958      }
     959    }
     960  }
     961  return rc;
     962}
     963

  • trunk/src/kernel32/hmcomm.h

    r1858 r4285  
    1 /* $Id: hmcomm.h,v 1.4 1999-11-27 12:48:26 achimha Exp $ */
     1/* $Id: hmcomm.h,v 1.5 2000-09-20 21:32:54 hugh Exp $ */
    22
    33/*
    … …  
    1212#ifndef _HM_COMM_H_
    1313#define _HM_COMM_H_
     14typedef struct
     15{
     16  DWORD dwBaudRate;
     17  DWORD dwBaudFlag;
     18}BAUDTABLEENTRY;
    1419
    1520class HMDeviceCommClass : public HMDeviceHandler
    … …  
    2934
    3035  /* this is the handler method for SetComm() */
    31   virtual BOOL SetupComm(PHMHANDLEDATA pHMHandleData, DWORD dwInQueue, DWORD dwOutQueue);
     36  virtual BOOL WaitCommEvent( PHMHANDLEDATA pHMHandleData,
     37                              LPDWORD lpfdwEvtMask,
     38                              LPOVERLAPPED lpo);
    3239
     40  virtual BOOL GetCommProperties( PHMHANDLEDATA pHMHandleData,
     41                                  LPCOMMPROP lpcmmp);
     42  virtual BOOL GetCommMask( PHMHANDLEDATA pHMHandleData,
     43                            LPDWORD lpfdwEvtMask);
     44  virtual BOOL SetCommMask( PHMHANDLEDATA pHMHandleData,
     45                            DWORD fdwEvtMask);
     46  virtual BOOL PurgeComm( PHMHANDLEDATA pHMHandleData,
     47                          DWORD fdwAction);
     48  virtual BOOL ClearCommError( PHMHANDLEDATA pHMHandleData,
     49                               LPDWORD lpdwErrors,
     50                               LPCOMSTAT lpcst);
     51  virtual BOOL SetCommState( PHMHANDLEDATA pHMHandleData,
     52                             LPDCB lpdcb) ;
     53  virtual BOOL GetCommState( PHMHANDLEDATA pHMHandleData,
     54                             LPDCB lpdcb);
     55  virtual BOOL GetCommModemStatus( PHMHANDLEDATA pHMHandleData,
     56                                   LPDWORD lpModemStat );
     57  virtual BOOL GetCommTimeouts( PHMHANDLEDATA pHMHandleData,
     58                                LPCOMMTIMEOUTS lpctmo);
     59  virtual BOOL SetCommTimeouts( PHMHANDLEDATA pHMHandleData,
     60                                LPCOMMTIMEOUTS lpctmo);
     61  virtual BOOL TransmitCommChar( PHMHANDLEDATA pHMHandleData,
     62                                 CHAR cChar );
     63  virtual BOOL SetCommConfig( PHMHANDLEDATA pHMHandleData,
     64                              LPCOMMCONFIG lpCC,
     65                              DWORD dwSize );
     66  virtual BOOL SetCommBreak( PHMHANDLEDATA pHMHandleData );
     67  virtual BOOL GetCommConfig( PHMHANDLEDATA pHMHandleData,
     68                              LPCOMMCONFIG lpCC,
     69                              LPDWORD lpdwSize );
     70  virtual BOOL EscapeCommFunction( PHMHANDLEDATA pHMHandleData,
     71                                   UINT dwFunc );
     72  virtual BOOL SetupComm( PHMHANDLEDATA pHMHandleData,
     73                          DWORD dwInQueue,
     74                          DWORD dwOutQueue);
     75  virtual BOOL ClearCommBreak( PHMHANDLEDATA pHMHandleData);
     76  virtual BOOL SetDefaultCommConfig( PHMHANDLEDATA pHMHandleData,
     77                                     LPCOMMCONFIG lpCC,
     78                                     DWORD dwSize);
     79  virtual BOOL GetDefaultCommConfig( PHMHANDLEDATA pHMHandleData,
     80                                     LPCOMMCONFIG lpCC,
     81                                     LPDWORD lpdwSize);
     82  private:
     83  APIRET SetLine( PHMHANDLEDATA pHMHandleData,
     84                  UCHAR ucSize,UCHAR Parity, UCHAR Stop);
     85  APIRET SetOS2DCB( PHMHANDLEDATA pHMHandleData,
     86                    BOOL fOutxCtsFlow, BOOL fOutxDsrFlow,
     87                    UCHAR ucDtrControl,  BOOL fDsrSensitivity,
     88                    BOOL fTXContinueOnXoff, BOOL fOutX,
     89                    BOOL fInX, BOOL fErrorChar,
     90                    BOOL fNull, UCHAR ucRtsControl,
     91                    BOOL fAbortOnError, BYTE XonChar,
     92                    BYTE XoffChar,BYTE ErrorChar);
     93  APIRET SetBaud( PHMHANDLEDATA pHMHandleData,
     94                  DWORD dwNewBaud);
    3395};
    3496

  • trunk/src/kernel32/hmdevice.cpp

    r3948 r4285  
    1 /* $Id: hmdevice.cpp,v 1.22 2000-08-04 21:12:06 sandervl Exp $ */
     1/* $Id: hmdevice.cpp,v 1.23 2000-09-20 21:32:52 hugh Exp $ */
    22
    33/*
    … …  
    2424#include "HMDevice.h"
    2525
    26 #define DBG_LOCALLOG    DBG_hmdevice
     26#define DBG_LOCALLOG  DBG_hmdevice
    2727#include "dbglocal.h"
    2828
    … …  
    117117                               HANDLE  destprocess,
    118118                               PHANDLE desthandle,
    119                                DWORD   fdwAccess,
    120                                BOOL    fInherit,
     119                               DWORD   fdwAccess,
     120                               BOOL    fInherit,
    121121                               DWORD   fdwOptions,
    122122                               DWORD   fdwOdinOptions)
    … …  
    10851085                                         DWORD                      dwMaximumSizeHigh,
    10861086                                         DWORD                      dwMaximumSizeLow,
    1087                                          LPCSTR lpName,   
    1088                                          HFILE *hOldMap)  // if create an existing memmap, return handle of old one
     1087                                 LPCSTR lpName,
     1088                 HFILE *hOldMap)  // if create an existing memmap, return handle of old one
    10891089{
    10901090  dprintf(("KERNEL32: HandleManager::DeviceHandler::CreateFileMapping(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh,%s)\n",
    … …  
    11231123  dprintf(("KERNEL32: HandleManager::DeviceHandler::OpenFileMapping(%08xh,%08xh,%08xh,%08xh)\n",
    11241124           pHMHandleData->hHMHandle,
    1125            fdwAccess,
     1125     fdwAccess,
    11261126           fInherit,
    11271127           lpName));
    … …  
    11511151                                      DWORD         dwFileOffsetLow,
    11521152                                      DWORD         dwNumberOfBytesToMap,
    1153                                       LPVOID        lpBaseAddress)
     1153                    LPVOID        lpBaseAddress)
    11541154{
    11551155  dprintf(("KERNEL32: HandleManager::DeviceHandler::MapViewOfFileEx(%08xh,%08xh,%08xh,%08xh,%08xh,%08xh)\n",
    … …  
    11671167 * Purpose   : send command to device driver
    11681168 * Variables :
    1169  * Result    : 
     1169 * Result    :
    11701170 * Remark    :
    11711171 * Status    :
    … …  
    11911191
    11921192/*****************************************************************************
    1193  * Name      : DWORD HMDeviceHandler::SetupComm     
     1193 * Name      : DWORD HMDeviceHandler::SetupComm
    11941194 * Purpose   : set com port parameters (queue)
    11951195 * Variables :
    1196  * Result    : 
     1196 * Result    :
    11971197 * Remark    :
    11981198 * Status    :
    … …  
    12061206           pHMHandleData->hHMHandle,
    12071207           dwInQueue, dwOutQueue));
    1208 
    1209   return(FALSE);
    1210 }
    1211 
    1212 
    1213 /*****************************************************************************
    1214  * Name      : DWORD HMDeviceHandler::GetCommState   
    1215  * Purpose   : query com port control block   
    1216  * Variables :
    1217  * Result    : 
     1208  SetLastError(ERROR_INVALID_HANDLE);
     1209  return(FALSE);
     1210}
     1211
     1212
     1213/*****************************************************************************
     1214 * Name      : DWORD HMDeviceHandler::GetCommState
     1215 * Purpose   : query com port control block
     1216 * Variables :
     1217 * Result    :
    12181218 * Remark    :
    12191219 * Status    :
    … …  
    12261226           pHMHandleData->hHMHandle,
    12271227           lpdcb));
    1228 
     1228  SetLastError(ERROR_INVALID_HANDLE);
     1229  return(FALSE);
     1230}
     1231
     1232BOOL HMDeviceHandler::WaitCommEvent( PHMHANDLEDATA pHMHandleData,
     1233                                     LPDWORD lpfdwEvtMask,
     1234                                     LPOVERLAPPED lpo)
     1235{
     1236  dprintf(("KERNEL32: HandleManager::DeviceHandler::WaitCommEvent(%08xh,%08xh,%08xh)\n",
     1237           pHMHandleData->hHMHandle,
     1238           lpfdwEvtMask,
     1239           lpo));
     1240  SetLastError(ERROR_INVALID_HANDLE);
     1241  return(FALSE);
     1242}
     1243
     1244BOOL HMDeviceHandler::GetCommProperties( PHMHANDLEDATA pHMHandleData,
     1245                                         LPCOMMPROP lpcmmp)
     1246{
     1247  dprintf(("KERNEL32: HandleManager::DeviceHandler::GetCommProperties(%08xh,%08xh)\n",
     1248           pHMHandleData->hHMHandle,
     1249           lpcmmp));
     1250  SetLastError(ERROR_INVALID_HANDLE);
     1251  return(FALSE);
     1252}
     1253
     1254BOOL HMDeviceHandler::GetCommMask( PHMHANDLEDATA pHMHandleData,
     1255                                   LPDWORD lpfdwEvtMask)
     1256{
     1257  dprintf(("KERNEL32: HandleManager::DeviceHandler::GetCommMask(%08xh,%08xh)\n",
     1258           pHMHandleData->hHMHandle,
     1259           lpfdwEvtMask));
     1260  SetLastError(ERROR_INVALID_HANDLE);
     1261  return(FALSE);
     1262}
     1263
     1264BOOL HMDeviceHandler::SetCommMask( PHMHANDLEDATA pHMHandleData,
     1265                                   DWORD fdwEvtMask)
     1266{
     1267  dprintf(("KERNEL32: HandleManager::DeviceHandler::SetCommMask(%08xh,%08xh)\n",
     1268           pHMHandleData->hHMHandle,
     1269           fdwEvtMask));
     1270  SetLastError(ERROR_INVALID_HANDLE);
     1271  return(FALSE);
     1272}
     1273
     1274BOOL HMDeviceHandler::PurgeComm( PHMHANDLEDATA pHMHandleData,
     1275                                 DWORD fdwAction)
     1276{
     1277  dprintf(("KERNEL32: HandleManager::DeviceHandler::PurgeComm(%08xh,%08xh)\n",
     1278           pHMHandleData->hHMHandle,
     1279           fdwAction));
     1280  SetLastError(ERROR_INVALID_HANDLE);
     1281  return(FALSE);
     1282}
     1283
     1284BOOL HMDeviceHandler::ClearCommError( PHMHANDLEDATA pHMHandleData,
     1285                                      LPDWORD lpdwErrors,
     1286                                      LPCOMSTAT lpcst)
     1287{
     1288  dprintf(("KERNEL32: HandleManager::DeviceHandler::ClearCommError(%08xh,%08xh,%08xh)\n",
     1289           pHMHandleData->hHMHandle,
     1290           lpdwErrors,
     1291           lpcst));
     1292  SetLastError(ERROR_INVALID_HANDLE);
     1293  return(FALSE);
     1294}
     1295
     1296BOOL HMDeviceHandler::SetCommState( PHMHANDLEDATA pHMHandleData,
     1297                                    LPDCB lpdcb)
     1298{
     1299  dprintf(("KERNEL32: HandleManager::DeviceHandler::SetCommState(%08xh,%08xh)\n",
     1300           pHMHandleData->hHMHandle,
     1301           lpdcb));
     1302  SetLastError(ERROR_INVALID_HANDLE);
     1303  return(FALSE);
     1304}
     1305
     1306BOOL HMDeviceHandler::GetCommTimeouts( PHMHANDLEDATA pHMHandleData,
     1307                                       LPCOMMTIMEOUTS lpctmo)
     1308{
     1309  dprintf(("KERNEL32: HandleManager::DeviceHandler::GetCommTimeouts(%08xh,%08xh)\n",
     1310           pHMHandleData->hHMHandle,
     1311           lpctmo));
     1312  SetLastError(ERROR_INVALID_HANDLE);
     1313  return(FALSE);
     1314}
     1315BOOL HMDeviceHandler::GetCommModemStatus( PHMHANDLEDATA pHMHandleData,
     1316                                          LPDWORD lpModemStat )
     1317{
     1318  dprintf(("KERNEL32: HandleManager::DeviceHandler::GetCommModemStatus(%08xh,%08xh)\n",
     1319           pHMHandleData->hHMHandle,
     1320           lpModemStat));
     1321  SetLastError(ERROR_INVALID_HANDLE);
     1322  return(FALSE);
     1323}
     1324
     1325BOOL HMDeviceHandler::SetCommTimeouts( PHMHANDLEDATA pHMHandleData,
     1326                                       LPCOMMTIMEOUTS lpctmo)
     1327{
     1328  dprintf(("KERNEL32: HandleManager::DeviceHandler::SetCommTimeouts(%08xh,%08xh)\n",
     1329           pHMHandleData->hHMHandle,
     1330           lpctmo));
     1331  SetLastError(ERROR_INVALID_HANDLE);
     1332  return(FALSE);
     1333}
     1334
     1335BOOL HMDeviceHandler::TransmitCommChar( PHMHANDLEDATA pHMHandleData,
     1336                                        CHAR cChar )
     1337{
     1338  dprintf(("KERNEL32: HandleManager::DeviceHandler::TransmitCommChar(%08xh,%02xh)\n",
     1339           pHMHandleData->hHMHandle,
     1340           cChar));
     1341  SetLastError(ERROR_INVALID_HANDLE);
     1342  return(FALSE);
     1343}
     1344
     1345BOOL HMDeviceHandler::SetCommConfig( PHMHANDLEDATA pHMHandleData,
     1346                                     LPCOMMCONFIG lpCC,
     1347                                     DWORD dwSize )
     1348{
     1349  dprintf(("KERNEL32: HandleManager::DeviceHandler::SetCommConfig(%08xh,%08xh,%08xh)\n",
     1350           pHMHandleData->hHMHandle,
     1351           lpCC,
     1352           dwSize));
     1353  SetLastError(ERROR_INVALID_HANDLE);
     1354  return(FALSE);
     1355}
     1356
     1357BOOL HMDeviceHandler::SetCommBreak( PHMHANDLEDATA pHMHandleData )
     1358{
     1359  dprintf(("KERNEL32: HandleManager::DeviceHandler::SetCommBreak(%08xh)\n",
     1360           pHMHandleData->hHMHandle));
     1361  SetLastError(ERROR_INVALID_HANDLE);
     1362  return(FALSE);
     1363}
     1364
     1365BOOL HMDeviceHandler::GetCommConfig( PHMHANDLEDATA pHMHandleData,
     1366                                     LPCOMMCONFIG lpCC,
     1367                                     LPDWORD lpdwSize )
     1368{
     1369  dprintf(("KERNEL32: HandleManager::DeviceHandler::GetCommConfig(%08xh,%08xh,%08xh)\n",
     1370           pHMHandleData->hHMHandle,
     1371           lpCC,
     1372           lpdwSize));
     1373  SetLastError(ERROR_INVALID_HANDLE);
     1374  return(FALSE);
     1375}
     1376
     1377BOOL HMDeviceHandler::EscapeCommFunction( PHMHANDLEDATA pHMHandleData,
     1378                                          UINT dwFunc )
     1379{
     1380  dprintf(("KERNEL32: HandleManager::DeviceHandler::EscapeCommFunction(%08xh,%08xh)\n",
     1381           pHMHandleData->hHMHandle,
     1382           dwFunc));
     1383  SetLastError(ERROR_INVALID_HANDLE);
     1384  return(FALSE);
     1385}
     1386
     1387BOOL HMDeviceHandler::ClearCommBreak( PHMHANDLEDATA pHMHandleData)
     1388{
     1389  dprintf(("KERNEL32: HandleManager::DeviceHandler::ClearCommBreak(%08xh)\n",
     1390           pHMHandleData->hHMHandle));
     1391  SetLastError(ERROR_INVALID_HANDLE);
     1392  return(FALSE);
     1393}
     1394
     1395BOOL HMDeviceHandler::SetDefaultCommConfig( PHMHANDLEDATA pHMHandleData,
     1396                                            LPCOMMCONFIG lpCC,
     1397                                            DWORD dwSize)
     1398{
     1399  dprintf(("KERNEL32: HandleManager::DeviceHandler::SetDefaultCommConfig(%08xh,%08xh,%08xh)\n",
     1400           pHMHandleData->hHMHandle,
     1401           lpCC,
     1402           dwSize));
     1403  SetLastError(ERROR_INVALID_HANDLE);
     1404  return(FALSE);
     1405}
     1406
     1407BOOL HMDeviceHandler::GetDefaultCommConfig( PHMHANDLEDATA pHMHandleData,
     1408                                            LPCOMMCONFIG lpCC,
     1409                                            LPDWORD lpdwSize)
     1410{
     1411  dprintf(("KERNEL32: HandleManager::DeviceHandler::GetDefaultCommConfig(%08xh,%08xh,%08xh)\n",
     1412           pHMHandleData->hHMHandle,
     1413           lpCC,
     1414           lpdwSize));
     1415  SetLastError(ERROR_INVALID_HANDLE);
    12291416  return(FALSE);
    12301417}
    … …  
    12321419/*****************************************************************************
    12331420 * Name      : DWORD HMDeviceHandler::OpenThreadToken
    1234  * Purpose   : 
    1235  * Variables :
    1236  * Result    : 
     1421 * Purpose   :
     1422 * Variables :
     1423 * Result    :
    12371424 * Remark    :
    12381425 * Status    :
    … …  
    12411428 *****************************************************************************/
    12421429
    1243 DWORD HMDeviceHandler::OpenThreadToken(PHMHANDLEDATA pHMHandleData, 
     1430DWORD HMDeviceHandler::OpenThreadToken(PHMHANDLEDATA pHMHandleData,
    12441431                                       HANDLE  ThreadHandle,
    12451432                                       BOOL    OpenAsSelf)
    … …  
    12541441/*****************************************************************************
    12551442 * Name      : DWORD HMDeviceHandler::OpenThreadToken
    1256  * Purpose   : 
    1257  * Variables :
    1258  * Result    : 
     1443 * Purpose   :
     1444 * Variables :
     1445 * Result    :
    12591446 * Remark    :
    12601447 * Status    :
    … …  
    12631450 *****************************************************************************/
    12641451
    1265 DWORD HMDeviceHandler::OpenProcessToken(PHMHANDLEDATA pHMHandleData, 
     1452DWORD HMDeviceHandler::OpenProcessToken(PHMHANDLEDATA pHMHandleData,
    12661453                                        DWORD dwUserData,
    12671454                                        HANDLE  ProcessHandle)
    … …  
    12751462/*****************************************************************************
    12761463 * Name      : DWORD HMDeviceHandler::CreateThread
    1277  * Purpose   : 
    1278  * Variables :
    1279  * Result    : 
     1464 * Purpose   :
     1465 * Variables :
     1466 * Result    :
    12801467 * Remark    :
    12811468 * Status    :
    … …  
    12891476                                     LPVOID                 lpvThreadParm,
    12901477                                     DWORD                  fdwCreate,
    1291                                      LPDWORD                lpIDThread, 
     1478                                     LPDWORD                lpIDThread,
    12921479                                     BOOL                   fFirstThread)
    12931480{
    … …  
    12991486/*****************************************************************************
    13001487 * Name      : DWORD HMDeviceHandler::GetThreadPriority
    1301  * Purpose   : 
    1302  * Variables :
    1303  * Result    : 
     1488 * Purpose   :
     1489 * Variables :
     1490 * Result    :
    13041491 * Remark    :
    13051492 * Status    :
    … …  
    13161503/*****************************************************************************
    13171504 * Name      : DWORD HMDeviceHandler::SuspendThread
    1318  * Purpose   : 
    1319  * Variables :
    1320  * Result    : 
     1505 * Purpose   :
     1506 * Variables :
     1507 * Result    :
    13211508 * Remark    :
    13221509 * Status    :
    … …  
    13331520/*****************************************************************************
    13341521 * Name      : DWORD HMDeviceHandler::SetThreadPriority
    1335  * Purpose   : 
    1336  * Variables :
    1337  * Result    : 
     1522 * Purpose   :
     1523 * Variables :
     1524 * Result    :
    13381525 * Remark    :
    13391526 * Status    :
    … …  
    13501537/*****************************************************************************
    13511538 * Name      : DWORD HMDeviceHandler::GetThreadContext
    1352  * Purpose   : 
    1353  * Variables :
    1354  * Result    : 
     1539 * Purpose   :
     1540 * Variables :
     1541 * Result    :
    13551542 * Remark    :
    13561543 * Status    :
    … …  
    13671554/*****************************************************************************
    13681555 * Name      : DWORD HMDeviceHandler::SetThreadContext
    1369  * Purpose   : 
    1370  * Variables :
    1371  * Result    : 
     1556 * Purpose   :
     1557 * Variables :
     1558 * Result    :
    13721559 * Remark    :
    13731560 * Status    :
    … …  
    13841571/*****************************************************************************
    13851572 * Name      : DWORD HMDeviceHandler::TerminateThread
    1386  * Purpose   : 
    1387  * Variables :
    1388  * Result    : 
     1573 * Purpose   :
     1574 * Variables :
     1575 * Result    :
    13891576 * Remark    :
    13901577 * Status    :
    … …  
    14011588/*****************************************************************************
    14021589 * Name      : DWORD HMDeviceHandler::ResumeThread
    1403  * Purpose   : 
    1404  * Variables :
    1405  * Result    : 
     1590 * Purpose   :
     1591 * Variables :
     1592 * Result    :
    14061593 * Remark    :
    14071594 * Status    :
    … …  
    14181605/*****************************************************************************
    14191606 * Name      : DWORD HMDeviceHandler::GetExitCodeThread
    1420  * Purpose   : 
    1421  * Variables :
    1422  * Result    : 
     1607 * Purpose   :
     1608 * Variables :
     1609 * Result    :
    14231610 * Remark    :
    14241611 * Status    :
    … …  
    14351622/*****************************************************************************
    14361623 * Name      : DWORD HMDeviceHandler::SetThreadTerminated
    1437  * Purpose   : 
    1438  * Variables :
    1439  * Result    : 
     1624 * Purpose   :
     1625 * Variables :
     1626 * Result    :
    14401627 * Remark    :
    14411628 * Status    :
    … …  
    14501637/*****************************************************************************
    14511638 * Name      : DWORD HMDeviceHandler::PeekNamedPipe
    1452  * Purpose   : 
    1453  * Variables :
    1454  * Result    : 
     1639 * Purpose   :
     1640 * Variables :
     1641 * Result    :
    14551642 * Remark    :
    14561643 * Status    :
    … …  
    14731660/*****************************************************************************
    14741661 * Name      : DWORD HMDeviceHandler::CreateNamedPipe
    1475  * Purpose   : 
    1476  * Variables :
    1477  * Result    : 
     1662 * Purpose   :
     1663 * Variables :
     1664 * Result    :
    14781665 * Remark    :
    14791666 * Status    :
    … …  
    14821669 *****************************************************************************/
    14831670DWORD HMDeviceHandler::CreateNamedPipe(PHMHANDLEDATA pHMHandleData,
    1484                                          LPCTSTR lpName, 
    1485                                          DWORD  dwOpenMode, 
     1671                                         LPCTSTR lpName,
     1672                                         DWORD  dwOpenMode,
    14861673                                         DWORD  dwPipeMode,
    1487                                          DWORD  nMaxInstances, 
     1674                                         DWORD  nMaxInstances,
    14881675                                         DWORD  nOutBufferSize,
    1489                                          DWORD  nInBufferSize, 
     1676                                         DWORD  nInBufferSize,
    14901677                                         DWORD  nDefaultTimeOut,
    14911678                                         LPSECURITY_ATTRIBUTES lpSecurityAttributes)
    … …  
    14991686/*****************************************************************************
    15001687 * Name      : BOOL HMDeviceHandler::ConnectNamedPipe
    1501  * Purpose   : 
    1502  * Variables :
    1503  * Result    : 
     1688 * Purpose   :
     1689 * Variables :
     1690 * Result    :
    15041691 * Remark    :
    15051692 * Status    :
    … …  
    15071694 * Author    : Przemyslaw Dobrowolski
    15081695 *****************************************************************************/
    1509 BOOL HMDeviceHandler::ConnectNamedPipe( PHMHANDLEDATA pHMHandleData, 
     1696BOOL HMDeviceHandler::ConnectNamedPipe( PHMHANDLEDATA pHMHandleData,
    15101697                                          LPOVERLAPPED lpOverlapped)
    15111698{
    … …  
    15181705/*****************************************************************************
    15191706 * Name      : BOOL HMDeviceHandler::DisconnectNamedPipe
    1520  * Purpose   : 
    1521  * Variables :
    1522  * Result    : 
     1707 * Purpose   :
     1708 * Variables :
     1709 * Result    :
    15231710 * Remark    :
    15241711 * Status    :
    … …  
    15361723/*****************************************************************************
    15371724 * Name      : BOOL HMDeviceHandler::GetNamedPipeHandleState
    1538  * Purpose   : 
    1539  * Variables :
    1540  * Result    : 
     1725 * Purpose   :
     1726 * Variables :
     1727 * Result    :
    15411728 * Remark    :
    15421729 * Status    :
    … …  
    15601747/*****************************************************************************
    15611748 * Name      : BOOL HMDeviceHandler::GetNamedPipeInfo
    1562  * Purpose   : 
    1563  * Variables :
    1564  * Result    : 
     1749 * Purpose   :
     1750 * Variables :
     1751 * Result    :
    15651752 * Remark    :
    15661753 * Status    :
    … …  
    15821769/*****************************************************************************
    15831770 * Name      : DWORD HMDeviceHandler::TransactNamedPipe
    1584  * Purpose   : 
    1585  * Variables :
    1586  * Result    : 
     1771 * Purpose   :
     1772 * Variables :
     1773 * Result    :
    15871774 * Remark    :
    15881775 * Status    :
    … …  
    16061793/*****************************************************************************
    16071794 * Name      : BOOL HMDeviceHandler::SetNamedPipeHandleState
    1608  * Purpose   : 
    1609  * Variables :
    1610  * Result    : 
     1795 * Purpose   :
     1796 * Variables :
     1797 * Result    :
    16111798 * Remark    :
    16121799 * Status    :
    … …  
    16271814/*****************************************************************************
    16281815 * Name      : BOOL HMDeviceHandler::CreatePipe
    1629  * Purpose   : 
    1630  * Variables :
    1631  * Result    : 
     1816 * Purpose   :
     1817 * Variables :
     1818 * Result    :
    16321819 * Remark    :
    16331820 * Status    :
    … …  
    16371824BOOL HMDeviceHandler::CreatePipe(PHMHANDLEDATA pHMHandleDataRead,
    16381825                                 PHMHANDLEDATA pHMHandleDataWrite,
    1639                                  LPSECURITY_ATTRIBUTES lpsa, 
     1826                                 LPSECURITY_ATTRIBUTES lpsa,
    16401827                                 DWORD         cbPipe)
    1641 { 
     1828{
    16421829  dprintf(("KERNEL32: ERROR: HandleManager::DeviceHandler::CreatePipe (%08x,%08x)\n",
    16431830           pHMHandleDataRead->hHMHandle,pHMHandleDataWrite->hHMHandle));

  • trunk/src/kernel32/hmdevice.h

    r3948 r4285  
    1 /* $Id: hmdevice.h,v 1.22 2000-08-04 21:12:07 sandervl Exp $ */
     1/* $Id: hmdevice.h,v 1.23 2000-09-20 21:32:54 hugh Exp $ */
    22
    33/*
    … …  
    2525 *****************************************************************************/
    2626
    27 #define HMTYPE_UNKNOWN          0
    28 #define HMTYPE_MEMMAP           1
    29 #define HMTYPE_DEVICE           2
    30 #define HMTYPE_PROCESSTOKEN     3
    31 #define HMTYPE_THREADTOKEN      4
     27#define HMTYPE_UNKNOWN    0
     28#define HMTYPE_MEMMAP   1
     29#define HMTYPE_DEVICE     2
     30#define HMTYPE_PROCESSTOKEN   3
     31#define HMTYPE_THREADTOKEN  4
    3232#define HMTYPE_THREAD           5
    3333#define HMTYPE_PIPE             6
    … …  
    5353
    5454  LPVOID          lpHandlerData;    /* for private use of the device handler */
     55  LPVOID          lpDeviceData;
    5556} HMHANDLEDATA, *PHMHANDLEDATA;
    5657
    … …  
    289290                                     DWORD                      dwMaximumSizeLow,
    290291                                     LPCSTR                     lpName,
    291                                      HFILE                     *hOldMap);
     292               HFILE                     *hOldMap);
    292293
    293294                  /* this is a handler method for calls to OpenFileMapping() */
    294295  virtual DWORD OpenFileMapping     (PHMHANDLEDATA              pHMHandleData,
    295                                      DWORD access,   /* [in] Access mode */
     296                         DWORD access,   /* [in] Access mode */
    296297                                     BOOL                       fInherit,
    297298                                     LPCSTR                     lpName);
    … …  
    303304                                     DWORD                      dwFileOffsetLow,
    304305                                     DWORD                      dwNumberOfBytesToMap,
    305                                      LPVOID                     lpBaseAddress);
     306                   LPVOID                     lpBaseAddress);
    306307
    307308                    /* this is a handler method for calls to DeviceIoControl() */
    … …  
    312313
    313314 /* COM ports */
    314  virtual BOOL SetupComm(PHMHANDLEDATA pHMHandleData, DWORD dwInQueue, DWORD dwOutQueue);
    315 
    316  virtual BOOL GetCommState(PHMHANDLEDATA pHMHandleData, LPDCB lpdcb);
    317 
    318  virtual DWORD  OpenThreadToken(PHMHANDLEDATA pHMHandleData,
     315 virtual BOOL SetupComm( PHMHANDLEDATA pHMHandleData,
     316                         DWORD dwInQueue,
     317                         DWORD dwOutQueue);
     318
     319 virtual BOOL GetCommState( PHMHANDLEDATA pHMHandleData,
     320                            LPDCB lpdcb);
     321 virtual BOOL WaitCommEvent( PHMHANDLEDATA pHMHandleData,
     322                             LPDWORD lpfdwEvtMask,
     323                             LPOVERLAPPED lpo);
     324
     325 virtual BOOL GetCommProperties( PHMHANDLEDATA pHMHandleData,
     326                                 LPCOMMPROP lpcmmp);
     327 virtual BOOL GetCommMask( PHMHANDLEDATA pHMHandleData,
     328                           LPDWORD lpfdwEvtMask);
     329 virtual BOOL SetCommMask( PHMHANDLEDATA pHMHandleData,
     330                           DWORD fdwEvtMask);
     331 virtual BOOL PurgeComm( PHMHANDLEDATA pHMHandleData,
     332                         DWORD fdwAction);
     333 virtual BOOL ClearCommError( PHMHANDLEDATA pHMHandleData,
     334                              LPDWORD lpdwErrors,
     335                              LPCOMSTAT lpcst);
     336 virtual BOOL SetCommState( PHMHANDLEDATA pHMHandleData,
     337                            LPDCB lpdcb) ;
     338 virtual BOOL GetCommModemStatus( PHMHANDLEDATA pHMHandleData,
     339                               LPDWORD lpModemStat );
     340 virtual BOOL GetCommTimeouts( PHMHANDLEDATA pHMHandleData,
     341                               LPCOMMTIMEOUTS lpctmo);
     342 virtual BOOL SetCommTimeouts( PHMHANDLEDATA pHMHandleData,
     343                               LPCOMMTIMEOUTS lpctmo);
     344 virtual BOOL TransmitCommChar( PHMHANDLEDATA pHMHandleData,
     345                                CHAR cChar );
     346 virtual BOOL SetCommConfig( PHMHANDLEDATA pHMHandleData,
     347                             LPCOMMCONFIG lpCC,
     348                             DWORD dwSize );
     349 virtual BOOL SetCommBreak( PHMHANDLEDATA pHMHandleData );
     350 virtual BOOL GetCommConfig( PHMHANDLEDATA pHMHandleData,
     351                             LPCOMMCONFIG lpCC,
     352                             LPDWORD lpdwSize );
     353 virtual BOOL EscapeCommFunction( PHMHANDLEDATA pHMHandleData,
     354                                  UINT dwFunc );
     355 virtual BOOL ClearCommBreak( PHMHANDLEDATA pHMHandleData);
     356 virtual BOOL SetDefaultCommConfig( PHMHANDLEDATA pHMHandleData,
     357                                    LPCOMMCONFIG lpCC,
     358                                    DWORD dwSize);
     359 virtual BOOL GetDefaultCommConfig( PHMHANDLEDATA pHMHandleData,
     360                                    LPCOMMCONFIG lpCC,
     361                                    LPDWORD lpdwSize);
     362
     363 virtual DWORD  OpenThreadToken(PHMHANDLEDATA pHMHandleData,
    319364                                 HANDLE  ThreadHandle,
    320365                                 BOOL    OpenAsSelf);
    … …  
    329374                             LPVOID                 lpvThreadParm,
    330375                             DWORD                  fdwCreate,
    331                              LPDWORD                lpIDThread, 
     376                             LPDWORD                lpIDThread,
    332377                             BOOL                   fFirstThread);
    333378
    … …  
    392437  virtual BOOL  CreatePipe(PHMHANDLEDATA pHMHandleDataRead,
    393438                           PHMHANDLEDATA pHMHandleDataWrite,
    394                            LPSECURITY_ATTRIBUTES lpsa, 
     439                           LPSECURITY_ATTRIBUTES lpsa,
    395440                           DWORD         cbPipe);
    396441
    … …  
    406451                        HMDeviceHandler *pDeviceHandler);
    407452
     453DWORD  HMDeviceRegisterEx(LPSTR           pszDeviceName,
     454                          HMDeviceHandler *pDeviceHandler,
     455                          VOID            *pDevData);
    408456
    409457#endif /* _HM_DEVICE_H_ */

  • trunk/src/kernel32/hmdevio.cpp

    r3005 r4285  
    1 /* $Id: hmdevio.cpp,v 1.4 2000-03-04 19:52:36 sandervl Exp $ */
     1/* $Id: hmdevio.cpp,v 1.5 2000-09-20 21:32:52 hugh Exp $ */
    22
    33/*
    … …  
    1818#define INCL_DOSPROCESS          /* DOS Process values       */
    1919#define INCL_DOSMISC             /* DOS Miscellanous values  */
    20 #include <os2wrap.h>    //Odin32 OS/2 api wrappers
     20#include <os2wrap.h>  //Odin32 OS/2 api wrappers
    2121#include <string.h>
    2222
    … …  
    2828#include "exceptutil.h"
    2929
    30 #define DBG_LOCALLOG    DBG_hmdevio
     30#define DBG_LOCALLOG  DBG_hmdevio
    3131#include "dbglocal.h"
    3232
    3333static fX86Init  = FALSE;
    3434//SvL: Used in iccio.asm (how can you put these in the .asm data segment without messing things up?)
    35 ULONG  ioentry   = 0;
    36 USHORT gdt       = 0;
     35//ULONG  ioentry   = 0;
     36//USHORT gdt       = 0;
    3737char   devname[] = "/dev/fastio$";
    3838
    … …  
    4242
    4343static WIN32DRV knownDriver[] =
    44     {{"\\\\.\\GpdDev", "",      TRUE,  666,   GpdDevIOCtl},
     44    {{"\\\\.\\GpdDev", "/dev/fastio$", TRUE,  666,   GpdDevIOCtl},
    4545    { "\\\\.\\MAPMEM", "PMAP$", FALSE, 0,     MAPMEMIOCtl},
    4646    { "FXMEMMAP.VXD",  "PMAP$", FALSE, 0,     FXMEMMAPIOCtl}};
    … …  
    5555 DWORD rc;
    5656
    57     for(int i=0;i<nrKnownDrivers;i++) 
     57    for(int i=0;i<nrKnownDrivers;i++)
    5858    {
    59         driver = new HMDeviceDriver(knownDriver[i].szWin32Name,
     59  driver = new HMDeviceDriver(knownDriver[i].szWin32Name,
    6060                                    knownDriver[i].szOS2Name,
    6161                                    knownDriver[i].fCreateFile,
    6262                                    knownDriver[i].devIOCtl);
    6363
    64         rc = HMDeviceRegister(knownDriver[i].szWin32Name, driver);
    65         if (rc != NO_ERROR)                                  /* check for errors */
    66                 dprintf(("KERNEL32:RegisterDevices: registering %s failed with %u.\n",
    67                           knownDriver[i].szWin32Name, rc));
     64  rc = HMDeviceRegister(knownDriver[i].szWin32Name, driver);
     65      if (rc != NO_ERROR)                                  /* check for errors */
     66          dprintf(("KERNEL32:RegisterDevices: registering %s failed with %u.\n",
     67                    knownDriver[i].szWin32Name, rc));
    6868    }
    6969    return;
    … …  
    7171//******************************************************************************
    7272//******************************************************************************
    73 HMDeviceDriver::HMDeviceDriver(LPCSTR lpDeviceName, LPSTR lpOS2DevName, BOOL fCreate, 
     73HMDeviceDriver::HMDeviceDriver(LPCSTR lpDeviceName, LPSTR lpOS2DevName, BOOL fCreate,
    7474                               WINIOCTL pDevIOCtl)
    7575                : HMDeviceKernelObjectClass(lpDeviceName)
    … …  
    110110
    111111  if(szOS2Name[0] == 0) {
    112         pHMHandleData->hHMHandle = 0;
    113         return (NO_ERROR);
     112      pHMHandleData->hHMHandle = 0;
     113      return (NO_ERROR);
    114114  }
    115115
    116116tryopen:
    117   rc = DosOpen( szOS2Name,                        /* File path name */
    118                 &hfFileHandle,                  /* File handle */
    119                 &ulAction,                      /* Action taken */
    120                 0,
    121                 FILE_NORMAL,
    122                 FILE_OPEN,
    123                 sharetype,
    124                 0L);                            /* No extended attribute */
     117  rc = DosOpen( szOS2Name,                        /* File path name */
     118                &hfFileHandle,                  /* File handle */
     119                &ulAction,                      /* Action taken */
     120          0,
     121          FILE_NORMAL,
     122            FILE_OPEN,
     123            sharetype,
     124                0L);                            /* No extended attribute */
    125125
    126126  if(rc == ERROR_TOO_MANY_OPEN_FILES) {
    … …  
    128128   LONG  ReqCount = 32;
    129129
    130         rc = DosSetRelMaxFH(&ReqCount, &CurMaxFH);
    131         if(rc) {
    132                 dprintf(("DosSetRelMaxFH returned %d", rc));
    133                 return rc;
    134         }
    135         dprintf(("DosOpen failed -> increased nr open files to %d", CurMaxFH));
    136         goto tryopen;
     130  rc = DosSetRelMaxFH(&ReqCount, &CurMaxFH);
     131  if(rc) {
     132    dprintf(("DosSetRelMaxFH returned %d", rc));
     133    return rc;
     134  }
     135  dprintf(("DosOpen failed -> increased nr open files to %d", CurMaxFH));
     136  goto tryopen;
    137137  }
    138138
    139139  dprintf(("DosOpen %s returned %d\n", szOS2Name, rc));
    140140
    141   if(rc == NO_ERROR) {
    142         pHMHandleData->hHMHandle = hfFileHandle;
    143         return (NO_ERROR);
    144   }
    145   else  return(rc);
     141  if(rc == NO_ERROR)
     142  {
     143    pHMHandleData->hHMHandle = hfFileHandle;
     144    return (NO_ERROR);
     145  }
     146  else
     147    return(rc);
    146148}
    147149//******************************************************************************
    … …  
    166168{
    167169 ULONG port, val = 0;
    168 
    169   if(fX86Init == FALSE) {
    170         if(io_init() == 0)
    171                 fX86Init = TRUE;
    172         else    return(FALSE);
     170 WORD  gdt;
     171 HRESULT rc;
     172 ULONG ulAction;
     173
     174  if(fX86Init == FALSE)
     175  {
     176    rc = DosDevIOCtl( hDevice, 118, 100, 0,0,0,&gdt,2,&ulAction);
     177
     178    if(rc)
     179      return FALSE;
     180
     181    io_init2(gdt);
     182
     183    fX86Init = TRUE;
    173184  }
    174185
    … …  
    298309  rc = DosTmrQueryTime(&time);
    299310  if(rc) {
    300         dprintf(("DosTmrQueryTime returned %d\n", rc));
    301         return(FALSE);
     311      dprintf(("DosTmrQueryTime returned %d\n", rc));
     312      return(FALSE);
    302313  }
    303314  lpPerformanceCount->u.LowPart  = time.ulLo;
    … …  
    314325  rc = DosTmrQueryFreq(&freq);
    315326  if(rc) {
    316         dprintf(("DosTmrQueryFreq returned %d\n", rc));
    317         return(FALSE);
     327      dprintf(("DosTmrQueryFreq returned %d\n", rc));
     328      return(FALSE);
    318329  }
    319330  lpFrequency->u.LowPart  = freq;

  • trunk/src/kernel32/hmopen32.cpp

    r3948 r4285  
    1 /* $Id: hmopen32.cpp,v 1.25 2000-08-04 21:12:08 sandervl Exp $ */
     1/* $Id: hmopen32.cpp,v 1.26 2000-09-20 21:32:52 hugh Exp $ */
    22
    33/*
    … …  
    1212 */
    1313
    14 //#define DEBUG_LOCAL
     14#define DEBUG_LOCAL
    1515
    1616#ifdef DEBUG_LOCAL
    … …  
    3131#include "mmap.h"
    3232
    33 #define DBG_LOCALLOG    DBG_hmopen32
     33#define DBG_LOCALLOG  DBG_hmopen32
    3434#include "dbglocal.h"
    3535
    … …  
    101101 * Name      : HMDeviceHandler::DuplicateHandle
    102102 * Purpose   : dummy version
    103  * Parameters: 
     103 * Parameters:
    104104 *             various parameters as required
    105105 * Variables :
    … …  
    115115                               HANDLE  destprocess,
    116116                               PHANDLE desthandle,
    117                                DWORD   fdwAccess,
    118                                BOOL    fInherit,
     117                               DWORD   fdwAccess,
     118                               BOOL    fInherit,
    119119                               DWORD   fdwOptions,
    120120                               DWORD   fdwOdinOptions)
    … …  
    130130
    131131  if(rc == TRUE) {
    132         pHMHandleData->hHMHandle = *desthandle;
    133         return TRUE;
     132      pHMHandleData->hHMHandle = *desthandle;
     133      return TRUE;
    134134  }
    135135  else  return FALSE;
    … …  
    205205            pHMHandleData->hHMHandle,
    206206            dwTimeout));
    207  
     207
    208208  if(dwTimeout) {
    209         starttime = O32_GetCurrentTime();
     209    starttime = O32_GetCurrentTime();
    210210  }
    211211  rc =  (O32_WaitForSingleObject(pHMHandleData->hHMHandle,
    212212                                 dwTimeout));
    213213  if(dwTimeout) {
    214         endtime = O32_GetCurrentTime();
    215         dprintf(("KERNEL32: HandleManager::WaitForSingleObject %x delta = %x (rc=%x)", pHMHandleData->hHMHandle, endtime - starttime, rc));
     214    endtime = O32_GetCurrentTime();
     215    dprintf(("KERNEL32: HandleManager::WaitForSingleObject %x delta = %x (rc=%x)", pHMHandleData->hHMHandle, endtime - starttime, rc));
    216216  }
    217217  else dprintf(("KERNEL32: HandleManager::WaitForSingleObject %x rc=%x", pHMHandleData->hHMHandle, rc));

  • trunk/src/kernel32/oslibdos.cpp

    r4256 r4285  
    1 /* $Id: oslibdos.cpp,v 1.42 2000-09-13 21:11:00 sandervl Exp $ */
     1/* $Id: oslibdos.cpp,v 1.43 2000-09-20 21:32:53 hugh Exp $ */
    22/*
    33 * Wrappers for OS/2 Dos* API
    … …  
    4545
    4646  if(DosQueryModuleHandle("DOSCALLS", &hDoscalls) != NO_ERROR) {
    47         return;
     47  return;
    4848  }
    4949  if(DosQueryProcAddr(hDoscalls, 989, NULL, (PFN *)&DosSetFileSizeLProc) != NO_ERROR) {
    50         return;
     50  return;
    5151  }
    5252  if(DosQueryProcAddr(hDoscalls, 988, NULL, (PFN *)&DosSetFilePtrLProc) != NO_ERROR) {
    53         return;
     53  return;
    5454  }
    5555  if(DosQueryProcAddr(hDoscalls, 986, NULL, (PFN *)&DosSetFileLocksLProc) != NO_ERROR) {
    56         return;
     56  return;
    5757  }
    5858  f64BitIO = TRUE;
    … …  
    104104  {
    105105    case NO_ERROR: //0
    106         return ERROR_SUCCESS_W;
     106        return ERROR_SUCCESS_W;
    107107
    108108    case ERROR_INVALID_FUNCTION: //1
    … …  
    110110
    111111    case ERROR_FILE_NOT_FOUND: //2
    112         return ERROR_FILE_NOT_FOUND_W;
     112        return ERROR_FILE_NOT_FOUND_W;
    113113
    114114    case ERROR_PATH_NOT_FOUND: //3
    115         return ERROR_PATH_NOT_FOUND_W;
     115        return ERROR_PATH_NOT_FOUND_W;
    116116
    117117    case ERROR_TOO_MANY_OPEN_FILES: //4
    118         return ERROR_TOO_MANY_OPEN_FILES_W;
     118        return ERROR_TOO_MANY_OPEN_FILES_W;
    119119
    120120    case ERROR_ACCESS_DENIED: //5
    121         return ERROR_ACCESS_DENIED_W;
     121        return ERROR_ACCESS_DENIED_W;
    122122
    123123    case ERROR_INVALID_HANDLE: //6
    124         return ERROR_INVALID_HANDLE_W;
     124        return ERROR_INVALID_HANDLE_W;
    125125
    126126    case ERROR_NOT_ENOUGH_MEMORY: //8
    127         return ERROR_NOT_ENOUGH_MEMORY_W;
     127        return ERROR_NOT_ENOUGH_MEMORY_W;
    128128
    129129    case ERROR_BAD_FORMAT: //11
    130         return ERROR_BAD_FORMAT_W;
     130        return ERROR_BAD_FORMAT_W;
    131131
    132132    case ERROR_INVALID_ACCESS: //12
    133         return ERROR_INVALID_ACCESS_W;
     133      return ERROR_INVALID_ACCESS_W;
    134134
    135135    case ERROR_NO_MORE_FILES: //18
    136         return ERROR_NO_MORE_FILES_W;
     136        return ERROR_NO_MORE_FILES_W;
    137137
    138138    case ERROR_WRITE_PROTECT: //19
    … …  
    140140
    141141    case ERROR_NOT_DOS_DISK: //26
    142         return ERROR_NOT_DOS_DISK_W;
     142        return ERROR_NOT_DOS_DISK_W;
    143143
    144144    case ERROR_WRITE_FAULT: //29
    … …  
    146146
    147147    case ERROR_SHARING_VIOLATION: //32
    148         return ERROR_SHARING_VIOLATION_W;
     148        return ERROR_SHARING_VIOLATION_W;
    149149
    150150    case ERROR_LOCK_VIOLATION: //32
    151         return ERROR_LOCK_VIOLATION_W;
     151        return ERROR_LOCK_VIOLATION_W;
    152152
    153153    case ERROR_SHARING_BUFFER_EXCEEDED: //36
    154         return ERROR_SHARING_BUFFER_EXCEEDED_W;
     154        return ERROR_SHARING_BUFFER_EXCEEDED_W;
    155155
    156156    case ERROR_CANNOT_MAKE: //82
    … …  
    158158
    159159    case ERROR_OUT_OF_STRUCTURES: //84
    160         return ERROR_OUT_OF_STRUCTURES_W;
     160        return ERROR_OUT_OF_STRUCTURES_W;
    161161
    162162    case ERROR_INVALID_PARAMETER: //87
    163         return ERROR_INVALID_PARAMETER_W;
     163        return ERROR_INVALID_PARAMETER_W;
    164164
    165165    case ERROR_INTERRUPT: //95
    166         return ERROR_INVALID_AT_INTERRUPT_TIME_W; //CB: right???
     166        return ERROR_INVALID_AT_INTERRUPT_TIME_W; //CB: right???
    167167
    168168    case ERROR_DEVICE_IN_USE: //99
    169         return ERROR_DEVICE_IN_USE_W;
     169  return ERROR_DEVICE_IN_USE_W;
    170170
    171171    case ERROR_DRIVE_LOCKED: //108
    172         return ERROR_DRIVE_LOCKED_W;
     172        return ERROR_DRIVE_LOCKED_W;
    173173
    174174    case ERROR_BROKEN_PIPE: //109
    175         return ERROR_BROKEN_PIPE_W;
     175        return ERROR_BROKEN_PIPE_W;
    176176
    177177    case ERROR_OPEN_FAILED: //110
    178         return ERROR_OPEN_FAILED_W;
     178  return ERROR_OPEN_FAILED_W;
    179179
    180180    case ERROR_BUFFER_OVERFLOW: //111
    181         return ERROR_BUFFER_OVERFLOW_W;
     181        return ERROR_BUFFER_OVERFLOW_W;
    182182
    183183    case ERROR_DISK_FULL: //112
    184         return ERROR_DISK_FULL_W;
     184  return ERROR_DISK_FULL_W;
    185185
    186186    case ERROR_NO_MORE_SEARCH_HANDLES: //113
    187         return ERROR_NO_MORE_SEARCH_HANDLES_W;
     187        return ERROR_NO_MORE_SEARCH_HANDLES_W;
    188188
    189189    case ERROR_SEM_TIMEOUT: //121
    190         return ERROR_SEM_TIMEOUT_W;
     190        return ERROR_SEM_TIMEOUT_W;
    191191
    192192    case ERROR_DIRECT_ACCESS_HANDLE: //130
    … …  
    200200
    201201    case ERROR_DISCARDED: //157
    202         return ERROR_DISCARDED_W;
     202        return ERROR_DISCARDED_W;
    203203
    204204    case ERROR_FILENAME_EXCED_RANGE: //206
    205         return ERROR_FILENAME_EXCED_RANGE_W;
     205        return ERROR_FILENAME_EXCED_RANGE_W;
    206206
    207207    case ERROR_META_EXPANSION_TOO_LONG: //208
    208         return ERROR_META_EXPANSION_TOO_LONG_W;
     208        return ERROR_META_EXPANSION_TOO_LONG_W;
    209209
    210210    case ERROR_BAD_PIPE: //230
    211         return ERROR_BAD_PIPE_W;
     211        return ERROR_BAD_PIPE_W;
    212212
    213213    case ERROR_PIPE_BUSY: //231
    214         return ERROR_PIPE_BUSY_W;
     214        return ERROR_PIPE_BUSY_W;
    215215
    216216    case ERROR_NO_DATA: //232
    217         return ERROR_NO_DATA_W;
     217        return ERROR_NO_DATA_W;
    218218
    219219    case ERROR_PIPE_NOT_CONNECTED: //233
    220         return ERROR_PIPE_NOT_CONNECTED_W;
     220        return ERROR_PIPE_NOT_CONNECTED_W;
    221221
    222222    case ERROR_MORE_DATA: //234
    223         return ERROR_MORE_DATA_W;
     223        return ERROR_MORE_DATA_W;
    224224
    225225    case ERROR_INVALID_EA_NAME: //254
    226         return ERROR_INVALID_EA_NAME_W;
     226        return ERROR_INVALID_EA_NAME_W;
    227227
    228228    case ERROR_EA_LIST_INCONSISTENT: //255
    229         return ERROR_EA_LIST_INCONSISTENT_W;
     229        return ERROR_EA_LIST_INCONSISTENT_W;
    230230
    231231    case ERROR_EAS_DIDNT_FIT: //275
    232         return ERROR_EAS_DIDNT_FIT;
     232        return ERROR_EAS_DIDNT_FIT;
    233233
    234234    default:
    235         dprintf(("WARNING: error2WinError: error %d not included!!!!", rc));
    236         return defaultCode;
     235      dprintf(("WARNING: error2WinError: error %d not included!!!!", rc));
     236        return defaultCode;
    237237  }
    238238}
    … …  
    554554  rc = DosDelete(lpszFileName);
    555555  if(rc) {
    556         SetLastError(error2WinError(rc));       
    557         return FALSE;
     556  SetLastError(error2WinError(rc));
     557  return FALSE;
    558558  }
    559559  return TRUE;
    … …  
    660660        }
    661661        strncpy(full_name, name, length_fullname);
    662         full_name[length_fullname-1] = 0;
     662  full_name[length_fullname-1] = 0;
    663663        return strlen(full_name);
    664664  }
    … …  
    697697   if(rc == ERROR_TOO_MANY_OPEN_FILES)
    698698   {
    699         LONG  reqCount = 2;
    700         ULONG maxFiles;
    701 
    702         if(DosSetRelMaxFH(&reqCount, &maxFiles) == NO_ERROR)
    703                 rc = DosQueryPathInfo(pszPathName, ulInfoLevel,
     699        LONG  reqCount = 2;
     700        ULONG maxFiles;
     701
     702        if(DosSetRelMaxFH(&reqCount, &maxFiles) == NO_ERROR)
     703          rc = DosQueryPathInfo(pszPathName, ulInfoLevel,
    704704                                      pInfoBuf, cbInfoBuf );
    705705   }
    … …  
    727727
    728728   if(fuAttrFlags & FILE_ATTRIBUTE_ARCHIVE_W)
    729         fileAttr |= FILE_ARCHIVED;
     729        fileAttr |= FILE_ARCHIVED;
    730730   if(fuAttrFlags & FILE_ATTRIBUTE_HIDDEN_W)
    731731        fileAttr |= FILE_HIDDEN;
    … …  
    739739   {
    740740   case CREATE_NEW_W:
    741         openFlag |= OPEN_ACTION_CREATE_IF_NEW | OPEN_ACTION_FAIL_IF_EXISTS;
     741  openFlag |= OPEN_ACTION_CREATE_IF_NEW | OPEN_ACTION_FAIL_IF_EXISTS;
    742742        break;
    743743   case CREATE_ALWAYS_W:
    … …  
    764764   //TODO: FILE_SHARE_DELETE
    765765   if((fuShare & (FILE_SHARE_READ_W | FILE_SHARE_WRITE_W)) == 0 )
    766         openMode |= OPEN_SHARE_DENYREADWRITE;
     766  openMode |= OPEN_SHARE_DENYREADWRITE;
    767767   else
    768768   if((fuShare & (FILE_SHARE_READ_W | FILE_SHARE_WRITE_W)) == (FILE_SHARE_READ_W | FILE_SHARE_WRITE_W))
    769         openMode |= OPEN_SHARE_DENYNONE;
     769        openMode |= OPEN_SHARE_DENYNONE;
    770770   else
    771771   if(fuShare & FILE_SHARE_READ_W)
    … …  
    773773   else
    774774   if(fuShare & FILE_SHARE_WRITE_W)
    775         openMode |= OPEN_SHARE_DENYREAD;
     775  openMode |= OPEN_SHARE_DENYREAD;
    776776
    777777   if(fuAccess == (GENERIC_READ_W | GENERIC_WRITE_W))
    778         openMode |= OPEN_ACCESS_READWRITE;
     778  openMode |= OPEN_ACCESS_READWRITE;
    779779   else
    780780   if(fuAccess & GENERIC_READ_W)
    781         openMode |= OPEN_ACCESS_READONLY;
     781  openMode |= OPEN_ACCESS_READONLY;
    782782   else
    783783   if(fuAccess & GENERIC_WRITE_W)
    784         openMode |= OPEN_ACCESS_WRITEONLY;
     784        openMode |= OPEN_ACCESS_WRITEONLY;
    785785
    786786#if 0
    … …  
    799799
    800800   if(strlen(lpszFile) == 2 && lpszFile[1] == ':') {
    801         //app tries to open physical disk
    802         openMode |= OPEN_FLAGS_DASD;
     801  //app tries to open physical disk
     802  openMode |= OPEN_FLAGS_DASD;
    803803   }
    804804   int retry = 0;
    … …  
    814814                      openMode,
    815815                      NULL);
    816         if(rc == ERROR_TOO_MANY_OPEN_FILES)
     816    if(rc == ERROR_TOO_MANY_OPEN_FILES)
    817817        {
    818           ULONG CurMaxFH;
    819           LONG  ReqCount = 32;
    820 
    821                 rc = DosSetRelMaxFH(&ReqCount, &CurMaxFH);
    822                 if(rc) {
    823                         dprintf(("DosSetRelMaxFH returned %d", rc));
    824                         SetLastError(ERROR_TOO_MANY_OPEN_FILES_W);
    825                         return INVALID_HANDLE_VALUE_W;
    826                 }
    827                 dprintf(("DosOpen failed -> increased nr open files to %d", CurMaxFH));
    828         }
    829         else    break;
    830         retry++;
     818      ULONG CurMaxFH;
     819      LONG  ReqCount = 32;
     820
     821    rc = DosSetRelMaxFH(&ReqCount, &CurMaxFH);
     822    if(rc) {
     823      dprintf(("DosSetRelMaxFH returned %d", rc));
     824      SetLastError(ERROR_TOO_MANY_OPEN_FILES_W);
     825      return INVALID_HANDLE_VALUE_W;
     826    }
     827    dprintf(("DosOpen failed -> increased nr open files to %d", CurMaxFH));
     828    }
     829  else  break;
     830  retry++;
    831831   }
    832832
    … …  
    853853   if(!(fuMode & (OF_CREATE_W | OF_READWRITE_W | OF_WRITE_W)))
    854854   {
    855         openMode |= OPEN_ACCESS_READONLY;
    856         openFlag |= OPEN_ACTION_OPEN_IF_EXISTS;
     855        openMode |= OPEN_ACCESS_READONLY;
     856        openFlag |= OPEN_ACTION_OPEN_IF_EXISTS;
    857857   }
    858858   else
    859859   {
    860         if(fuMode & OF_CREATE_W) {
    861                 openFlag |= OPEN_ACTION_CREATE_IF_NEW |
     860        if(fuMode & OF_CREATE_W) {
     861            openFlag |= OPEN_ACTION_CREATE_IF_NEW |
    862862                            OPEN_ACTION_REPLACE_IF_EXISTS;
    863         }
    864         else    openFlag |= OPEN_ACTION_OPEN_IF_EXISTS;                                //180575
    865 
    866         if(fuMode & OF_READWRITE_W)
    867                 openMode |= OPEN_ACCESS_READWRITE;
    868         else
    869         if(fuMode & OF_WRITE_W)
    870                 openMode |= OPEN_ACCESS_WRITEONLY;
    871         else
    872         if(fuMode & OF_CREATE_W)
    873                 openMode |= OPEN_ACCESS_READWRITE;
     863  }
     864        else    openFlag |= OPEN_ACTION_OPEN_IF_EXISTS;                                //180575
     865
     866        if(fuMode & OF_READWRITE_W)
     867            openMode |= OPEN_ACCESS_READWRITE;
     868        else
     869  if(fuMode & OF_WRITE_W)
     870            openMode |= OPEN_ACCESS_WRITEONLY;
     871        else
     872  if(fuMode & OF_CREATE_W)
     873            openMode |= OPEN_ACCESS_READWRITE;
    874874   }
    875875
    876876   if((fuMode & OF_SHARE_DENY_WRITE_W) ||
    877877      !(fuMode & (OF_SHARE_DENY_READ_W | OF_SHARE_DENY_NONE_W | OF_SHARE_EXCLUSIVE_W)))
    878         openMode |= OPEN_SHARE_DENYWRITE;
     878        openMode |= OPEN_SHARE_DENYWRITE;
    879879   else
    880880   if (fuMode & OF_SHARE_DENY_NONE_W)
    881         openMode |= OPEN_SHARE_DENYNONE;
     881        openMode |= OPEN_SHARE_DENYNONE;
    882882   else
    883883   if (fuMode & OF_SHARE_DENY_READ_W)
    884         openMode |= OPEN_SHARE_DENYREAD;
     884        openMode |= OPEN_SHARE_DENYREAD;
    885885   else
    886886   if (fuMode & OF_SHARE_EXCLUSIVE_W)
    887         openMode |= OPEN_SHARE_DENYREADWRITE;
     887        openMode |= OPEN_SHARE_DENYREADWRITE;
    888888
    889889   rc = DosOpen((PSZ)lpszFile,
    … …  
    898898   if(rc != NO_ERROR)
    899899   {
    900         if(fuMode & OF_EXIST_W)
    901         {
    902                 if(rc == ERROR_OPEN_FAILED || rc == ERROR_FILE_NOT_FOUND)
    903                 {
    904                         SetLastError(ERROR_FILE_NOT_FOUND_W);
    905                         return HFILE_ERROR_W;
    906                 }
    907         }
    908         if((rc == ERROR_OPEN_FAILED) && (openFlag & OPEN_ACTION_OPEN_IF_EXISTS))
    909         {
    910                 SetLastError(ERROR_FILE_NOT_FOUND_W);
    911         }
    912         else    SetLastError(error2WinError(rc));
    913 
    914         return HFILE_ERROR_W;
     900        if(fuMode & OF_EXIST_W)
     901        {
     902            if(rc == ERROR_OPEN_FAILED || rc == ERROR_FILE_NOT_FOUND)
     903            {
     904                SetLastError(ERROR_FILE_NOT_FOUND_W);
     905                return HFILE_ERROR_W;
     906            }
     907        }
     908        if((rc == ERROR_OPEN_FAILED) && (openFlag & OPEN_ACTION_OPEN_IF_EXISTS))
     909        {
     910            SetLastError(ERROR_FILE_NOT_FOUND_W);
     911        }
     912        else    SetLastError(error2WinError(rc));
     913
     914        return HFILE_ERROR_W;
    915915   }
    916916   SetLastError(ERROR_SUCCESS_W);
    … …  
    930930
    931931   if(lpOverlapped) {//TODO:
    932         dprintf(("OSLibDosLockFile: overlapped lock not yet implemented!!"));
     932  dprintf(("OSLibDosLockFile: overlapped lock not yet implemented!!"));
    933933   }
    934934   //TODO: Locking region crossing end of file is permitted. Works in OS/2??
    … …  
    937937    FILELOCKL lockRangeL;
    938938
    939         lockRangeL.lOffset.ulLo = OffsetLow;
    940         lockRangeL.lOffset.ulHi = OffsetHigh;
    941         lockRangeL.lRange.ulLo  = nNumberOfBytesToLockLow;
    942         lockRangeL.lRange.ulHi  = nNumberOfBytesToLockHigh;
    943 
    944         rc = OdinDosSetFileLocksL(hFile, NULL, &lockRangeL,
     939  lockRangeL.lOffset.ulLo = OffsetLow;
     940  lockRangeL.lOffset.ulHi = OffsetHigh;
     941  lockRangeL.lRange.ulLo  = nNumberOfBytesToLockLow;
     942  lockRangeL.lRange.ulHi  = nNumberOfBytesToLockHigh;
     943
     944    rc = OdinDosSetFileLocksL(hFile, NULL, &lockRangeL,
    945945                                  (dwFlags & LOCKFILE_FAIL_IMMEDIATELY_W) ? 0 : 5000, 0);
    946946        //SvL: 64 bits values are only supported by JFS
    … …  
    948948        //     (TODO: should check the partition type instead)
    949949        if(rc == ERROR_INVALID_PARAMETER && (OffsetHigh || nNumberOfBytesToLockHigh)) {
    950                 goto oldlock;
     950    goto oldlock;
    951951        }
    952952   }
    … …  
    956956    FILELOCK lockRange = { OffsetLow, nNumberOfBytesToLockLow };
    957957
    958         rc = DosSetFileLocks(hFile, NULL, &lockRange,
     958    rc = DosSetFileLocks(hFile, NULL, &lockRange,
    959959                             (dwFlags & LOCKFILE_FAIL_IMMEDIATELY_W) ? 0 : 5000, 0);
    960960   }
    961961   if(rc) {
    962         SetLastError(error2WinError(rc));
    963         return FALSE;
     962    SetLastError(error2WinError(rc));
     963  return FALSE;
    964964   }
    965965   SetLastError(ERROR_SUCCESS_W);
    … …  
    978978
    979979   if(lpOverlapped) {//TODO:
    980         dprintf(("OSLibDosUnlockFile: overlapped unlock not yet implemented!!"));
     980  dprintf(("OSLibDosUnlockFile: overlapped unlock not yet implemented!!"));
    981981   }
    982982   if(f64BitIO)
    … …  
    984984    FILELOCKL unlockRangeL;
    985985
    986         unlockRangeL.lOffset.ulLo = OffsetLow;
    987         unlockRangeL.lOffset.ulHi = OffsetHigh;
    988         unlockRangeL.lRange.ulLo  = nNumberOfBytesToLockLow;
    989         unlockRangeL.lRange.ulHi  = nNumberOfBytesToLockHigh;
    990 
    991         rc = OdinDosSetFileLocksL(hFile, &unlockRangeL, NULL, 5000, 0);
     986  unlockRangeL.lOffset.ulLo = OffsetLow;
     987  unlockRangeL.lOffset.ulHi = OffsetHigh;
     988  unlockRangeL.lRange.ulLo  = nNumberOfBytesToLockLow;
     989  unlockRangeL.lRange.ulHi  = nNumberOfBytesToLockHigh;
     990
     991    rc = OdinDosSetFileLocksL(hFile, &unlockRangeL, NULL, 5000, 0);
    992992        //SvL: 64 bits values are only supported by JFS
    993993        //     Try the 32 bits DosSetFileLocks if it fails
    994994        //     (TODO: should check the partition type instead)
    995995        if(rc == ERROR_INVALID_PARAMETER && (OffsetHigh || nNumberOfBytesToLockHigh)) {
    996                 goto oldlock;
     996    goto oldlock;
    997997        }
    998998   }
    … …  
    10051005   }
    10061006   if(rc) {
    1007         SetLastError(error2WinError(rc));
    1008         return FALSE;
     1007    SetLastError(error2WinError(rc));
     1008  return FALSE;
    10091009   }
    10101010   SetLastError(ERROR_SUCCESS_W);
    … …  
    10331033     ULONG        ulBufSize       = sizeof(FILESTATUS3L);
    10341034
    1035         rc = DosQueryFileInfo(hFile, FIL_STANDARDL, &fsts3ConfigInfoL, ulBufSize);
    1036         if(lpdwFileSizeHigh) {
    1037                 *lpdwFileSizeHigh = fsts3ConfigInfoL.cbFile.ulHi;
    1038         }
    1039         sizeLow = fsts3ConfigInfoL.cbFile.ulLo;
     1035    rc = DosQueryFileInfo(hFile, FIL_STANDARDL, &fsts3ConfigInfoL, ulBufSize);
     1036    if(lpdwFileSizeHigh) {
     1037      *lpdwFileSizeHigh = fsts3ConfigInfoL.cbFile.ulHi;
     1038  }
     1039  sizeLow = fsts3ConfigInfoL.cbFile.ulLo;
    10401040   }
    10411041   else
    … …  
    10441044     ULONG       ulBufSize       = sizeof(FILESTATUS3);
    10451045
    1046         if(lpdwFileSizeHigh) {
    1047                 *lpdwFileSizeHigh = 0;
    1048         }
    1049         rc = DosQueryFileInfo(hFile, FIL_STANDARD, &fsts3ConfigInfo, ulBufSize);
    1050         sizeLow = fsts3ConfigInfo.cbFile;
     1046    if(lpdwFileSizeHigh) {
     1047      *lpdwFileSizeHigh = 0;
     1048  }
     1049    rc = DosQueryFileInfo(hFile, FIL_STANDARD, &fsts3ConfigInfo, ulBufSize);
     1050  sizeLow = fsts3ConfigInfo.cbFile;
    10511051   }
    10521052   if(rc) {
    1053         SetLastError(error2WinError(rc));
    1054         return -1;
     1053    SetLastError(error2WinError(rc));
     1054    return -1;
    10551055   }
    10561056   SetLastError(ERROR_SUCCESS_W);
    … …  
    10851085  if( (f64BitIO) && (OffsetHigh) )
    10861086  {
    1087         offsetL.ulLo = OffsetLow;
    1088         offsetL.ulHi = (OffsetHigh) ? *OffsetHigh : 0;
    1089         rc = OdinDosSetFilePtrL(hFile, offsetL, method, &newoffsetL);
    1090         if(OffsetHigh) {
    1091                 *OffsetHigh = newoffsetL.ulHi;
    1092         }
    1093         newoffset = newoffsetL.ulLo;
     1087  offsetL.ulLo = OffsetLow;
     1088  offsetL.ulHi = (OffsetHigh) ? *OffsetHigh : 0;
     1089  rc = OdinDosSetFilePtrL(hFile, offsetL, method, &newoffsetL);
     1090  if(OffsetHigh) {
     1091    *OffsetHigh = newoffsetL.ulHi;
     1092  }
     1093  newoffset = newoffsetL.ulLo;
    10941094   }
    10951095  else
    … …  
    11141114
    11151115   if(f64BitIO) {
    1116         rc = OdinDosSetFilePtrL(hFile, FilePosL, FILE_CURRENT, &newFilePosL);
    1117         if(rc == 0) {
    1118                 rc = OdinDosSetFileSizeL(hFile, newFilePosL);
    1119         }
     1116  rc = OdinDosSetFilePtrL(hFile, FilePosL, FILE_CURRENT, &newFilePosL);
     1117  if(rc == 0) {
     1118          rc = OdinDosSetFileSizeL(hFile, newFilePosL);
     1119  }
    11201120   }
    11211121   else {
    1122         rc = DosSetFilePtr(hFile, 0, FILE_CURRENT, &newFilePos);
    1123         if(rc == 0) {
    1124                 rc = DosSetFileSize(hFile, newFilePos);
    1125         }
     1122    rc = DosSetFilePtr(hFile, 0, FILE_CURRENT, &newFilePos);
     1123  if(rc == 0) {
     1124          rc = DosSetFileSize(hFile, newFilePos);
     1125  }
    11261126   }
    11271127   if(rc) {
    1128         SetLastError(error2WinError(rc));
    1129         return FALSE;
     1128    SetLastError(error2WinError(rc));
     1129    return FALSE;
    11301130   }
    11311131   SetLastError(ERROR_SUCCESS_W);
    … …  
    11421142     FILESTATUS4L statusL = { 0 };
    11431143
    1144         rc = DosQueryFileInfo(hFile,
    1145                               FIL_QUERYEASIZEL,
    1146                               &statusL,
     1144    rc = DosQueryFileInfo(hFile,
     1145                        FIL_QUERYEASIZEL,
     1146                        &statusL,
    11471147                              sizeof(statusL));
    1148         if(rc == NO_ERROR)
    1149         {
    1150                 pInfo->dwFileAttributes = 0;
    1151                 if(!(statusL.attrFile & NOT_NORMAL))
    1152                         pInfo->dwFileAttributes |= FILE_ATTRIBUTE_NORMAL_W;
    1153                 if(statusL.attrFile & FILE_READONLY)
    1154                         pInfo->dwFileAttributes |= FILE_ATTRIBUTE_READONLY_W;
    1155                 if(statusL.attrFile & FILE_HIDDEN)
    1156                         pInfo->dwFileAttributes |= FILE_ATTRIBUTE_HIDDEN_W;
    1157                 if(statusL.attrFile & FILE_SYSTEM)
    1158                         pInfo->dwFileAttributes |= FILE_ATTRIBUTE_SYSTEM_W;
    1159                 if(statusL.attrFile & FILE_DIRECTORY)
    1160                         pInfo->dwFileAttributes |= FILE_ATTRIBUTE_DIRECTORY_W;
    1161                 if(statusL.attrFile & FILE_ARCHIVED)
    1162                         pInfo->dwFileAttributes |= FILE_ATTRIBUTE_ARCHIVE_W;
    1163                        
    1164                 pmDateTimeToFileTime(&statusL.fdateCreation,
    1165                                      &statusL.ftimeCreation,
    1166                                      &pInfo->ftCreationTime);
    1167                 pmDateTimeToFileTime(&statusL.fdateLastAccess,
    1168                                      &statusL.ftimeLastAccess,
    1169                                      &pInfo->ftLastAccessTime);
    1170                 pmDateTimeToFileTime(&statusL.fdateLastWrite,
    1171                                      &statusL.ftimeLastWrite,
    1172                                      &pInfo->ftLastWriteTime);
    1173        
    1174                 pInfo->nFileSizeHigh = statusL.cbFile.ulHi;
    1175                 pInfo->nFileSizeLow  = statusL.cbFile.ulLo;
    1176                 pInfo->dwVolumeSerialNumber = 0; //todo
    1177                 pInfo->nNumberOfLinks = 1;
    1178                 pInfo->nFileIndexHigh = 0;
    1179                 pInfo->nFileIndexLow  = 0;
    1180            }
     1148    if(rc == NO_ERROR)
     1149    {
     1150      pInfo->dwFileAttributes = 0;
     1151    if(!(statusL.attrFile & NOT_NORMAL))
     1152        pInfo->dwFileAttributes |= FILE_ATTRIBUTE_NORMAL_W;
     1153    if(statusL.attrFile & FILE_READONLY)
     1154            pInfo->dwFileAttributes |= FILE_ATTRIBUTE_READONLY_W;
     1155    if(statusL.attrFile & FILE_HIDDEN)
     1156            pInfo->dwFileAttributes |= FILE_ATTRIBUTE_HIDDEN_W;
     1157    if(statusL.attrFile & FILE_SYSTEM)
     1158            pInfo->dwFileAttributes |= FILE_ATTRIBUTE_SYSTEM_W;
     1159    if(statusL.attrFile & FILE_DIRECTORY)
     1160            pInfo->dwFileAttributes |= FILE_ATTRIBUTE_DIRECTORY_W;
     1161    if(statusL.attrFile & FILE_ARCHIVED)
     1162            pInfo->dwFileAttributes |= FILE_ATTRIBUTE_ARCHIVE_W;
     1163
     1164    pmDateTimeToFileTime(&statusL.fdateCreation,
     1165                               &statusL.ftimeCreation,
     1166                               &pInfo->ftCreationTime);
     1167    pmDateTimeToFileTime(&statusL.fdateLastAccess,
     1168                               &statusL.ftimeLastAccess,
     1169                               &pInfo->ftLastAccessTime);
     1170    pmDateTimeToFileTime(&statusL.fdateLastWrite,
     1171                               &statusL.ftimeLastWrite,
     1172                               &pInfo->ftLastWriteTime);
     1173
     1174    pInfo->nFileSizeHigh = statusL.cbFile.ulHi;
     1175    pInfo->nFileSizeLow  = statusL.cbFile.ulLo;
     1176    pInfo->dwVolumeSerialNumber = 0; //todo
     1177    pInfo->nNumberOfLinks = 1;
     1178    pInfo->nFileIndexHigh = 0;
     1179    pInfo->nFileIndexLow  = 0;
     1180     }
    11811181   }
    11821182   else
    … …  
    11841184     FILESTATUS4  status  = { 0 };
    11851185
    1186         rc = DosQueryFileInfo(hFile,
    1187                               FIL_QUERYEASIZE,
    1188                               &status,
     1186    rc = DosQueryFileInfo(hFile,
     1187                        FIL_QUERYEASIZE,
     1188                        &status,
    11891189                              sizeof(status));
    1190         if(rc == NO_ERROR)
    1191         {
    1192                 pInfo->dwFileAttributes = 0;
    1193                 if(!(status.attrFile & NOT_NORMAL))
    1194                         pInfo->dwFileAttributes |= FILE_ATTRIBUTE_NORMAL_W;
    1195                 if(status.attrFile & FILE_READONLY)
    1196                         pInfo->dwFileAttributes |= FILE_ATTRIBUTE_READONLY_W;
    1197                 if(status.attrFile & FILE_HIDDEN)
    1198                         pInfo->dwFileAttributes |= FILE_ATTRIBUTE_HIDDEN_W;
    1199                 if(status.attrFile & FILE_SYSTEM)
    1200                         pInfo->dwFileAttributes |= FILE_ATTRIBUTE_SYSTEM_W;
    1201                 if(status.attrFile & FILE_DIRECTORY)
    1202                         pInfo->dwFileAttributes |= FILE_ATTRIBUTE_DIRECTORY_W;
    1203                 if(status.attrFile & FILE_ARCHIVED)
    1204                         pInfo->dwFileAttributes |= FILE_ATTRIBUTE_ARCHIVE_W;
    1205                        
    1206                 pmDateTimeToFileTime(&status.fdateCreation,
    1207                                      &status.ftimeCreation,
    1208                                      &pInfo->ftCreationTime);
    1209                 pmDateTimeToFileTime(&status.fdateLastAccess,
    1210                                      &status.ftimeLastAccess,
    1211                                      &pInfo->ftLastAccessTime);
    1212                 pmDateTimeToFileTime(&status.fdateLastWrite,
    1213                                      &status.ftimeLastWrite,
    1214                                      &pInfo->ftLastWriteTime);
    1215        
    1216                 pInfo->nFileSizeHigh = 0;
    1217                 pInfo->nFileSizeLow = status.cbFile;
    1218                 pInfo->dwVolumeSerialNumber = 0; //todo
    1219                 pInfo->nNumberOfLinks = 1;
    1220                 pInfo->nFileIndexHigh = 0;
    1221                 pInfo->nFileIndexLow = 0;
    1222            }
     1190    if(rc == NO_ERROR)
     1191    {
     1192      pInfo->dwFileAttributes = 0;
     1193    if(!(status.attrFile & NOT_NORMAL))
     1194        pInfo->dwFileAttributes |= FILE_ATTRIBUTE_NORMAL_W;
     1195    if(status.attrFile & FILE_READONLY)
     1196            pInfo->dwFileAttributes |= FILE_ATTRIBUTE_READONLY_W;
     1197    if(status.attrFile & FILE_HIDDEN)
     1198            pInfo->dwFileAttributes |= FILE_ATTRIBUTE_HIDDEN_W;
     1199    if(status.attrFile & FILE_SYSTEM)
     1200            pInfo->dwFileAttributes |= FILE_ATTRIBUTE_SYSTEM_W;
     1201    if(status.attrFile & FILE_DIRECTORY)
     1202            pInfo->dwFileAttributes |= FILE_ATTRIBUTE_DIRECTORY_W;
     1203    if(status.attrFile & FILE_ARCHIVED)
     1204            pInfo->dwFileAttributes |= FILE_ATTRIBUTE_ARCHIVE_W;
     1205
     1206    pmDateTimeToFileTime(&status.fdateCreation,
     1207                               &status.ftimeCreation,
     1208                               &pInfo->ftCreationTime);
     1209    pmDateTimeToFileTime(&status.fdateLastAccess,
     1210                               &status.ftimeLastAccess,
     1211                               &pInfo->ftLastAccessTime);
     1212    pmDateTimeToFileTime(&status.fdateLastWrite,
     1213                               &status.ftimeLastWrite,
     1214                               &pInfo->ftLastWriteTime);
     1215
     1216    pInfo->nFileSizeHigh = 0;
     1217    pInfo->nFileSizeLow = status.cbFile;
     1218    pInfo->dwVolumeSerialNumber = 0; //todo
     1219    pInfo->nNumberOfLinks = 1;
     1220    pInfo->nFileIndexHigh = 0;
     1221    pInfo->nFileIndexLow = 0;
     1222     }
    12231223   }
    12241224   if(rc) {
    1225         SetLastError(error2WinError(rc));
    1226         return FALSE;
     1225        SetLastError(error2WinError(rc));
     1226    return FALSE;
    12271227   }
    12281228   SetLastError(ERROR_SUCCESS_W);
    … …  
    12421242  if(rc == NO_ERROR)
    12431243  {
    1244         if(creationdate && creationtime) {
    1245                 fileInfo.fdateCreation   = *(FDATE *)&creationdate;
    1246                 fileInfo.ftimeCreation   = *(FTIME *)&creationtime;
    1247         }
    1248         if(lastaccessdate && lastaccesstime) {
    1249                 fileInfo.fdateLastAccess = *(FDATE *)&lastaccessdate;
    1250                 fileInfo.ftimeLastAccess = *(FTIME *)&lastaccesstime;
    1251         }
    1252         if(lastwritedate && lastwritetime) {
    1253                 fileInfo.fdateLastWrite  = *(FDATE *)&lastwritedate;
    1254                 fileInfo.ftimeLastWrite  = *(FTIME *)&lastwritetime;
    1255         }
    1256 
    1257         rc = DosSetFileInfo(hFile, FIL_STANDARD, &fileInfo, sizeof(fileInfo));
     1244  if(creationdate && creationtime) {
     1245    fileInfo.fdateCreation   = *(FDATE *)&creationdate;
     1246          fileInfo.ftimeCreation   = *(FTIME *)&creationtime;
     1247  }
     1248  if(lastaccessdate && lastaccesstime) {
     1249    fileInfo.fdateLastAccess = *(FDATE *)&lastaccessdate;
     1250          fileInfo.ftimeLastAccess = *(FTIME *)&lastaccesstime;
     1251  }
     1252  if(lastwritedate && lastwritetime) {
     1253    fileInfo.fdateLastWrite  = *(FDATE *)&lastwritedate;
     1254          fileInfo.ftimeLastWrite  = *(FTIME *)&lastwritetime;
     1255  }
     1256
     1257  rc = DosSetFileInfo(hFile, FIL_STANDARD, &fileInfo, sizeof(fileInfo));
    12581258  }
    12591259
    12601260  if(rc)
    12611261  {
    1262         SetLastError(error2WinError(rc));
    1263         return FALSE;
     1262        SetLastError(error2WinError(rc));
     1263      return FALSE;
    12641264  }
    12651265  SetLastError(ERROR_SUCCESS_W);
    … …  
    12791279  if(rc == NO_ERROR)
    12801280  {
    1281         *creationdate   = *(WORD *)&fileInfo.fdateCreation;
     1281  *creationdate   = *(WORD *)&fileInfo.fdateCreation;
    12821282        *creationtime   = *(WORD *)&fileInfo.ftimeCreation;
    1283         *lastaccessdate = *(WORD *)&fileInfo.fdateLastAccess;
     1283  *lastaccessdate = *(WORD *)&fileInfo.fdateLastAccess;
    12841284        *lastaccesstime = *(WORD *)&fileInfo.ftimeLastAccess;
    1285         *lastwritedate  = *(WORD *)&fileInfo.fdateLastWrite;
     1285  *lastwritedate  = *(WORD *)&fileInfo.fdateLastWrite;
    12861286        *lastwritetime  = *(WORD *)&fileInfo.ftimeLastWrite;
    12871287  }
    … …  
    12891289  if(rc)
    12901290  {
    1291         SetLastError(error2WinError(rc));
    1292         return FALSE;
     1291        SetLastError(error2WinError(rc));
     1292      return FALSE;
    12931293  }
    12941294  SetLastError(ERROR_SUCCESS_W);
    … …  
    13051305   rc = DosSetFilePtr(hFile, offset, method, &newoffset);
    13061306   if(rc) {
    1307         dprintf(("DosSetFilePtr Error rc:%d", rc));
    1308         return -1;
     1307      dprintf(("DosSetFilePtr Error rc:%d", rc));
     1308      return -1;
    13091309   }
    13101310   else  return newoffset;
    … …  
    17491749        DosFindClose(hDir);
    17501750        SetLastError(error2WinError(rc));
    1751         return INVALID_HANDLE_VALUE_W;
     1751  return INVALID_HANDLE_VALUE_W;
    17521752  }
    17531753  translateFindResults(&result,lpFindFileData);
    … …  
    18531853}
    18541854//******************************************************************************
    1855 #define FSATTACH_SIZE   256
     1855#define FSATTACH_SIZE 256
    18561856//******************************************************************************
    18571857DWORD OSLibDosQueryVolumeFS(int drive, LPSTR lpFileSystemNameBuffer, DWORD nFileSystemNameSize)
    … …  
    18641864
    18651865   if(lpFileSystemNameBuffer == NULL) {
    1866         DebugInt3();
    1867         return ERROR_INVALID_PARAMETER_W;
     1866  DebugInt3();
     1867  return ERROR_INVALID_PARAMETER_W;
    18681868   }
    18691869   drv[0] = (char)('A' + drive - 1);
    … …  
    18751875   switch(rc) {
    18761876   case ERROR_INVALID_DRIVE:
    1877         return ERROR_INVALID_DRIVE_W;
     1877  return ERROR_INVALID_DRIVE_W;
    18781878   case ERROR_NO_VOLUME_LABEL:
    1879         return ERROR_NO_VOLUME_LABEL_W;
     1879  return ERROR_NO_VOLUME_LABEL_W;
    18801880   case NO_ERROR:
    1881         break;
     1881  break;
    18821882   default:
    1883         return ERROR_NOT_ENOUGH_MEMORY; //whatever
     1883  return ERROR_NOT_ENOUGH_MEMORY; //whatever
    18841884   }
    18851885
    … …  
    18941894  /*
    18951895   if(strlen(fsname) < nFileSystemNameSize) {
    1896         strcpy(lpFileSystemNameBuffer, fsname);
    1897    }
    1898    else return ERROR_BUFFER_OVERFLOW_W;
     1896  strcpy(lpFileSystemNameBuffer, fsname);
     1897   }
     1898   else return ERROR_BUFFER_OVERFLOW_W;
    18991899   */
    19001900   return 0;
    … …  
    19031903typedef struct _FSINFOBUF
    19041904{
    1905         ULONG           ulVolser;          /* Volume serial number            */
    1906         VOLUMELABEL     vol;               /* Volume lable                    */
     1905  ULONG     ulVolser;          /* Volume serial number            */
     1906  VOLUMELABEL vol;               /* Volume lable                    */
    19071907} FSINFOBUF;
    19081908//******************************************************************************
    … …  
    19191919   switch(rc) {
    19201920   case ERROR_INVALID_DRIVE:
    1921         return ERROR_INVALID_DRIVE_W;
     1921  return ERROR_INVALID_DRIVE_W;
    19221922   case ERROR_NO_VOLUME_LABEL:
    1923         return ERROR_NO_VOLUME_LABEL_W;
     1923  return ERROR_NO_VOLUME_LABEL_W;
    19241924   case NO_ERROR:
    1925         break;
     1925  break;
    19261926   default:
    1927         return ERROR_NOT_ENOUGH_MEMORY; //whatever
     1927  return ERROR_NOT_ENOUGH_MEMORY; //whatever
    19281928   }
    19291929
    … …  
    19331933   if(lpVolumeNameBuffer)
    19341934   {
    1935         if(nVolumeNameSize > fsi.vol.cch) {
     1935    if(nVolumeNameSize > fsi.vol.cch) {
    19361936             strcpy(lpVolumeNameBuffer, (PCHAR)fsi.vol.szVolLabel);
    1937         }
     1937  }
    19381938        else return ERROR_BUFFER_OVERFLOW_W;
    19391939   }
    … …  
    19721972        *lpNumberOfFreeClusters  = fsAlloc.cUnitAvail;
    19731973        *lpTotalNumberOfClusters = fsAlloc.cUnit;
    1974         SetLastError(ERROR_SUCCESS_W);
     1974  SetLastError(ERROR_SUCCESS_W);
    19751975        return TRUE;
    19761976   }
    … …  
    20062006  }
    20072007  return NO_ERROR;
     2008}
     2009//******************************************************************************
     2010//******************************************************************************
     2011DWORD OSLibDosDevIOCtl( DWORD hFile, DWORD dwCat, DWORD dwFunc,
     2012                        PVOID pParm, DWORD dwParmMaxLen, DWORD *pdwParmLen,
     2013                        PVOID pData, DWORD dwDataMaxLen, DWORD *pdwDataLen)
     2014{
     2015  APIRET rc;
     2016  USHORT sel = RestoreOS2FS();
     2017
     2018  rc = DosDevIOCtl( (HFILE)hFile, dwCat, dwFunc,
     2019                     pParm, dwParmMaxLen, pdwParmLen,
     2020                     pData, dwDataMaxLen, pdwDataLen);
     2021  SetFS(sel);
     2022  SetLastError(error2WinError(rc,ERROR_INVALID_HANDLE));
     2023  return (DWORD)rc;
    20082024}
    20092025

  • trunk/src/kernel32/oslibdos.h

    r4235 r4285  
    1 /* $Id: oslibdos.h,v 1.22 2000-09-12 04:27:45 bird Exp $ */
     1/* $Id: oslibdos.h,v 1.23 2000-09-20 21:32:55 hugh Exp $ */
    22
    33/*
    … …  
    195195DWORD OSLibDosQueryVolumeFS(int drive, LPSTR lpFileSystemNameBuffer, DWORD nFileSystemNameSize);
    196196DWORD OSLibDosQueryVolumeSerialAndName(int drive, LPDWORD lpVolumeSerialNumber, LPSTR lpVolumeNameBuffer, DWORD nVolumeNameSize);
     197DWORD OSLibDosDevIOCtl( DWORD hFile, DWORD dwCat, DWORD dwFunc,
     198                        PVOID pParm, DWORD dwParmMaxLen, DWORD *pdwParmLen,
     199                        PVOID pData, DWORD dwDataMaxLen, DWORD *pdwDataLen);
    197200
    198201BOOL OSLibGetDiskFreeSpace(LPSTR lpRootPathName, LPDWORD lpSectorsPerCluster,

  • trunk/src/kernel32/wintls.cpp

    r3975 r4285  
    1 /* $Id: wintls.cpp,v 1.11 2000-08-09 18:59:03 sandervl Exp $ */
     1/* $Id: wintls.cpp,v 1.12 2000-09-20 21:32:54 hugh Exp $ */
    22/*
    33 * Win32 TLS API functions
    … …  
    1717#include "exceptutil.h"
    1818
    19 #define DBG_LOCALLOG    DBG_wintls
     19#define DBG_LOCALLOG  DBG_wintls
    2020#include "dbglocal.h"
    2121
    2222//******************************************************************************
    2323//******************************************************************************
    24 void Win32ImageBase::tlsAlloc() //Allocate TLS index for this module
    25 {
    26    if(!tlsAddress) 
    27         return;
     24void Win32ImageBase::tlsAlloc() //Allocate TLS index for this module
     25{
     26   if(!tlsAddress)
     27  return;
    2828
    2929   tlsIndex = TlsAlloc();
    3030   if(tlsIndex >= TLS_MINIMUM_AVAILABLE) {
    31         dprintf(("tlsAttachThread: invalid tlsIndex %x!!!!", tlsIndex));
    32         DebugInt3();
    33         return;         
     31  dprintf(("tlsAttachThread: invalid tlsIndex %x!!!!", tlsIndex));
     32  DebugInt3();
     33  return;
    3434   }
    3535   dprintf(("Win32ImageBase::tlsAlloc (%d) for module %x", tlsIndex, hinstance));
    … …  
    3737//******************************************************************************
    3838//******************************************************************************
    39 void Win32ImageBase::tlsDelete()        //Free TLS index for this module
    40 {
    41    if(!tlsAddress) 
    42         return;
     39void Win32ImageBase::tlsDelete()  //Free TLS index for this module
     40{
     41   if(!tlsAddress)
     42  return;
    4343
    4444   if(tlsIndex >= TLS_MINIMUM_AVAILABLE) {
    45         dprintf(("tlsAttachThread: invalid tlsIndex %x!!!!", tlsIndex));
    46         DebugInt3();
    47         return;         
     45  dprintf(("tlsAttachThread: invalid tlsIndex %x!!!!", tlsIndex));
     46  DebugInt3();
     47  return;
    4848   }
    4949   dprintf(("Win32ImageBase::tlsDestroy (%d) for module %x", tlsIndex, hinstance));
    … …  
    5353//******************************************************************************
    5454//******************************************************************************
    55 void Win32ImageBase::tlsAttachThread()  //setup TLS structures for new thread
     55void Win32ImageBase::tlsAttachThread()  //setup TLS structures for new thread
    5656{
    5757 EXCEPTION_FRAME      exceptFrame;
    … …  
    5959 LPVOID               tibmem;
    6060
    61    if(!tlsAddress) 
    62         return;
     61   if(!tlsAddress)
     62  return;
    6363
    6464   if(tlsIndex >= TLS_MINIMUM_AVAILABLE) {
    65         dprintf(("tlsAttachThread: invalid tlsIndex %x!!!!", tlsIndex));
    66         DebugInt3();
    67         return;         
     65  dprintf(("tlsAttachThread: invalid tlsIndex %x!!!!", tlsIndex));
     66  DebugInt3();
     67  return;
    6868   }
    6969
    … …  
    7777   tibmem = VirtualAlloc(0, tlsTotalSize, MEM_RESERVE|MEM_COMMIT, PAGE_READWRITE);
    7878   if(tibmem == NULL) {
    79         dprintf(("tlsAttachThread: tibmem == NULL!!!!"));
    80         DebugInt3();
    81         return;
     79  dprintf(("tlsAttachThread: tibmem == NULL!!!!"));
     80  DebugInt3();
     81  return;
    8282   }
    8383   memset(tibmem, 0, tlsTotalSize);
    … …  
    8888
    8989   if(tlsCallBackAddr && (ULONG)*tlsCallBackAddr != 0) {
    90         pCallback = tlsCallBackAddr;
    91         while(*pCallback) {
    92                 dprintf(("tlsAttachThread: calling TLS Callback %x", *pCallback));
    93 
    94                 (*pCallback)((LPVOID)hinstance, DLL_THREAD_ATTACH, 0);
    95 
    96                 dprintf(("tlsAttachThread: finished calling TLS Callback %x", *pCallback));
    97                 *pCallback++;
    98         }
     90  pCallback = tlsCallBackAddr;
     91  while(*pCallback) {
     92    dprintf(("tlsAttachThread: calling TLS Callback %x", *pCallback));
     93
     94    (*pCallback)((LPVOID)hinstance, DLL_THREAD_ATTACH, 0);
     95
     96    dprintf(("tlsAttachThread: finished calling TLS Callback %x", *pCallback));
     97    *pCallback++;
     98  }
    9999   }
    100100   return;
    … …  
    102102//******************************************************************************
    103103//******************************************************************************
    104 void Win32ImageBase::tlsDetachThread()  //destroy TLS structures
     104void Win32ImageBase::tlsDetachThread()  //destroy TLS structures
    105105{
    106106 EXCEPTION_FRAME      exceptFrame;
    … …  
    108108 LPVOID tlsmem;
    109109
    110    if(!tlsAddress) 
    111         return;
     110   if(!tlsAddress)
     111  return;
    112112
    113113   dprintf(("Win32ImageBase::tlsDetachThread for module %x, thread id %x", hinstance, GetCurrentThreadId()));
    114114
    115115   if(tlsCallBackAddr && (ULONG)*tlsCallBackAddr != 0) {
    116         pCallback = tlsCallBackAddr;
    117         while(*pCallback) {
    118                 dprintf(("tlsDetachThread: calling TLS Callback %x", *pCallback));
    119 
    120                 (*pCallback)((LPVOID)hinstance, DLL_THREAD_DETACH, 0);
    121 
    122                 dprintf(("tlsDetachThread: finished calling TLS Callback %x", *pCallback));
    123                 *pCallback++;
    124         }
     116  pCallback = tlsCallBackAddr;
     117  while(*pCallback) {
     118    dprintf(("tlsDetachThread: calling TLS Callback %x", *pCallback));
     119
     120    (*pCallback)((LPVOID)hinstance, DLL_THREAD_DETACH, 0);
     121
     122    dprintf(("tlsDetachThread: finished calling TLS Callback %x", *pCallback));
     123    *pCallback++;
     124  }
    125125   }
    126126   tlsmem = TlsGetValue(tlsIndex);
    127127   if(tlsmem) {
    128         VirtualFree(tlsmem, tlsTotalSize, MEM_RELEASE);
     128    VirtualFree(tlsmem, tlsTotalSize, MEM_RELEASE);
    129129   }
    130130   else {
    131         dprintf(("ERROR: tlsDetachThread: tlsmem == NULL!!!"));
     131  dprintf(("ERROR: tlsDetachThread: tlsmem == NULL!!!"));
    132132   }
    133133   TlsFree(tlsIndex);
    … …  
    154154  tibidx = 0;
    155155  if(pdb->tls_bits[0] == 0xFFFFFFFF) {
    156         if(pdb->tls_bits[1] == 0xFFFFFFFF) {
    157                 LeaveCriticalSection(&pdb->crit_section);
    158                 SetLastError(ERROR_NO_MORE_ITEMS);  //TODO: correct error?
    159                 return -1;
    160         }
    161         tibidx = 1;
     156    if(pdb->tls_bits[1] == 0xFFFFFFFF) {
     157      LeaveCriticalSection(&pdb->crit_section);
     158      SetLastError(ERROR_NO_MORE_ITEMS);  //TODO: correct error?
     159    return -1;
     160  }
     161  tibidx = 1;
    162162  }
    163163  for(i=0;i<32;i++) {
    164         mask = (1 << i);
    165         if((pdb->tls_bits[tibidx] & mask) == 0) {
    166                 pdb->tls_bits[tibidx] |= mask;
    167                 index = (tibidx*32) + i;
    168                 break;
    169         }
     164  mask = (1 << i);
     165  if((pdb->tls_bits[tibidx] & mask) == 0) {
     166    pdb->tls_bits[tibidx] |= mask;
     167    index = (tibidx*32) + i;
     168    break;
     169  }
    170170  }
    171171  LeaveCriticalSection(&pdb->crit_section);
    … …  
    200200  tlsidx = 0;
    201201  if(index > 32) {
    202         tlsidx++;
     202  tlsidx++;
    203203  }
    204204  mask = (1 << index);
    205205  if(pdb->tls_bits[tlsidx] & mask) {
    206206        LeaveCriticalSection(&pdb->crit_section);
    207         pdb->tls_bits[tlsidx] &= ~mask;
     207  pdb->tls_bits[tlsidx] &= ~mask;
    208208        thdb->tls_array[index] = 0;
    209209        SetLastError(ERROR_SUCCESS);
    210         return TRUE;
     210  return TRUE;
    211211  }
    212212  LeaveCriticalSection(&pdb->crit_section);
Note: See TracChangeset for help on using the changeset viewer.