Changeset 7457 for trunk/src


Ignore:
Timestamp:
Nov 26, 2001, 3:54:03 PM (24 years ago)
Author:
sandervl
Message:

preliminary work on overlapped serial comm IO

Location:
trunk/src/kernel32
Files:
26 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/kernel32/Fileio.cpp

    r7342 r7457  
    1 /* $Id: Fileio.cpp,v 1.55 2001-11-14 18:39:52 sandervl Exp $ */
     1/* $Id: Fileio.cpp,v 1.56 2001-11-26 14:53:57 sandervl Exp $ */
    22
    33/*
    … …  
    14601460                             lpOutBuffer, nOutBufferSize, lpBytesReturned, lpOverlapped);
    14611461}
    1462 //******************************************************************************
    1463 //******************************************************************************
     1462/*****************************************************************************
     1463 * Name      : BOOL WIN32API CancelIo
     1464 * Purpose   : The CancelIO function cancels all pending input and output
     1465 *             (I/O) operations that were issued by the calling thread for
     1466 *             the specified file handle. The function does not cancel
     1467 *             I/O operations issued for the file handle by other threads.
     1468 * Parameters: HANDLE hFile   file handle for which to cancel I/O
     1469 * Variables :
     1470 * Result    : If the function succeeds, the return value is nonzero All pending
     1471 *             I/O operations issued by the calling thread for the file handle
     1472 *             were successfully canceled.
     1473 *             If the function fails, the return value is zero.
     1474 *             To get extended error information, call GetLastError.
     1475 * Remark    : If there are any I/O operations in progress for the specified
     1476 *             file handle, and they were issued by the calling thread, the
     1477 *             CancelIO function cancels them.
     1478 *             Note that the I/O operations must have been issued as
     1479 *             overlapped I/O. If they were not, the I/O operations would not
     1480 *             have returned to allow the thread to call the CancelIO function.
     1481 *             Calling the CancelIO function with a file handle that was not
     1482 *             opened with FILE_FLAG_OVERLAPPED does nothing.
     1483 *             All I/O operations that are canceled will complete with the
     1484 *             error ERROR_OPERATION_ABORTED. All completion notifications
     1485 *             for the I/O operations will occur normally.
     1486 * Status    : UNTESTED STUB
     1487 *
     1488 * Author    : Markus Montkowski [Thu, 1998/05/19 11:46]
     1489 *****************************************************************************/
     1490ODINFUNCTION1(BOOL, CancelIo, HANDLE, hFile)
     1491{
     1492  return HMCancelIo(hFile);
     1493}
     1494//******************************************************************************
     1495//******************************************************************************

  • trunk/src/kernel32/HandleManager.cpp

    r7443 r7457  
    1 /* $Id: HandleManager.cpp,v 1.75 2001-11-23 18:58:24 phaller Exp $ */
     1/* $Id: HandleManager.cpp,v 1.76 2001-11-26 14:53:57 sandervl Exp $ */
    22
    33/*
    … …  
    10491049         sizeof(HMHANDLEDATA));
    10501050
    1051   rc = pDeviceHandler->CreateFile(lpFileName,     /* call the device handler */
     1051  rc = pDeviceHandler->CreateFile((HANDLE)iIndexNew, lpFileName,     /* call the device handler */
    10521052                                  &HMHandleTemp,
    10531053                                  lpSecurityAttributes,
    … …  
    12011201  TabWin32Handles[iIndexNew].pDeviceHandler         = pDeviceHandler;
    12021202
    1203   rc = pDeviceHandler->OpenFile  (lpFileName,     /* call the device handler */
     1203  rc = pDeviceHandler->OpenFile  ((HANDLE)iIndexNew,  lpFileName,     /* call the device handler */
    12041204                                  &TabWin32Handles[iIndexNew].hmHandleData,
    12051205                                  pOFStruct,
    … …  
    32033203  return (fResult);                                   /* deliver return code */
    32043204}
    3205 
    3206 
    3207 
     3205/*****************************************************************************
     3206 * Name      : HMCancelIo
     3207 * Purpose   : router function for CancelIo
     3208 * Parameters:
     3209 * Variables :
     3210 * Result    :
     3211 * Remark    :
     3212 * Status    :
     3213 *
     3214 * Author    : Sander van Leeuwen
     3215 *****************************************************************************/
     3216BOOL  HMCancelIo(HANDLE hDevice)
     3217{
     3218  int       iIndex;                           /* index into the handle table */
     3219  BOOL      fResult;       /* result from the device handler's CloseHandle() */
     3220  PHMHANDLE pHMHandle;       /* pointer to the handle structure in the table */
     3221
     3222                                                          /* validate handle */
     3223  iIndex = _HMHandleQuery(hDevice);                           /* get the index */
     3224  if (-1 == iIndex)                                               /* error ? */
     3225  {
     3226    SetLastError(ERROR_INVALID_HANDLE);       /* set win32 error information */
     3227    return (FALSE);                                        /* signal failure */
     3228  }
     3229
     3230  pHMHandle = &TabWin32Handles[iIndex];               /* call device handler */
     3231  fResult = pHMHandle->pDeviceHandler->CancelIo(&pHMHandle->hmHandleData);
     3232
     3233  return (fResult);                                   /* deliver return code */
     3234}
    32083235/*****************************************************************************
    32093236 * Name      : HMCOMGetCommState

  • trunk/src/kernel32/comm.cpp

    r4301 r7457  
    1 /* $Id: comm.cpp,v 1.6 2000-09-21 20:14:39 sandervl Exp $ */
     1/* $Id: comm.cpp,v 1.7 2001-11-26 14:53:57 sandervl Exp $ */
    22
    33/*
    … …  
    761761                             LPOVERLAPPED lpo)
    762762{
     763  dprintf(("WaitCommEvent %x %x %x", hCommDev, lpfdwEvtMask, lpo));
    763764  return HMCommWaitCommEvent(hCommDev, lpfdwEvtMask, lpo);
    764765}

  • trunk/src/kernel32/conbuffer.cpp

    r4525 r7457  
    1 /* $Id: conbuffer.cpp,v 1.14 2000-10-23 19:35:09 sandervl Exp $ */
     1/* $Id: conbuffer.cpp,v 1.15 2001-11-26 14:53:58 sandervl Exp $ */
    22
    33/*
    … …  
    9898 *****************************************************************************/
    9999
    100 DWORD HMDeviceConsoleBufferClass::CreateFile (LPCSTR        lpFileName,
     100DWORD HMDeviceConsoleBufferClass::CreateFile (HANDLE        hHandle,
     101                                              LPCSTR        lpFileName,
    101102                                              PHMHANDLEDATA pHMHandleData,
    102103                                              PVOID         lpSecurityAttributes,

  • trunk/src/kernel32/conbuffer.h

    r4502 r7457  
    1 /* $Id: conbuffer.h,v 1.3 2000-10-20 11:46:44 sandervl Exp $ */
     1/* $Id: conbuffer.h,v 1.4 2001-11-26 14:53:58 sandervl Exp $ */
    22
    33/*
    … …  
    5555
    5656                       /* this is a handler method for calls to CreateFile() */
    57   virtual DWORD  CreateFile (LPCSTR        lpFileName,
     57  virtual DWORD  CreateFile (HANDLE        hHandle,
     58                             LPCSTR        lpFileName,
    5859                             PHMHANDLEDATA pHMHandleData,
    5960                             PVOID         lpSecurityAttributes,

  • trunk/src/kernel32/conin.cpp

    r4525 r7457  
    1 /* $Id: conin.cpp,v 1.14 2000-10-23 19:35:10 sandervl Exp $ */
     1/* $Id: conin.cpp,v 1.15 2001-11-26 14:53:58 sandervl Exp $ */
    22
    33/*
    … …  
    6868 *****************************************************************************/
    6969
    70 DWORD HMDeviceConsoleInClass::CreateFile (LPCSTR        lpFileName,
     70DWORD HMDeviceConsoleInClass::CreateFile (HANDLE        hHandle,
     71                                          LPCSTR        lpFileName,
    7172                                          PHMHANDLEDATA pHMHandleData,
    7273                                          PVOID         lpSecurityAttributes,

  • trunk/src/kernel32/conin.h

    r4407 r7457  
    1 /* $Id: conin.h,v 1.3 2000-10-03 17:28:28 sandervl Exp $ */
     1/* $Id: conin.h,v 1.4 2001-11-26 14:53:59 sandervl Exp $ */
    22
    33/*
    … …  
    5656
    5757                       /* this is a handler method for calls to CreateFile() */
    58   virtual DWORD  CreateFile (LPCSTR        lpFileName,
     58  virtual DWORD  CreateFile (HANDLE        hHandle,
     59                             LPCSTR        lpFileName,
    5960                             PHMHANDLEDATA pHMHandleData,
    6061                             PVOID         lpSecurityAttributes,

  • trunk/src/kernel32/conout.cpp

    r5308 r7457  
    1 /* $Id: conout.cpp,v 1.10 2001-03-13 18:45:32 sandervl Exp $ */
     1/* $Id: conout.cpp,v 1.11 2001-11-26 14:53:59 sandervl Exp $ */
    22
    33/*
    … …  
    9494 *****************************************************************************/
    9595
    96 DWORD HMDeviceConsoleOutClass::CreateFile (LPCSTR        lpFileName,
     96DWORD HMDeviceConsoleOutClass::CreateFile (HANDLE        hHandle,
     97                                           LPCSTR        lpFileName,
    9798                                           PHMHANDLEDATA pHMHandleData,
    9899                                           PVOID         lpSecurityAttributes,

  • trunk/src/kernel32/conout.h

    r4407 r7457  
    1 /* $Id: conout.h,v 1.2 2000-10-03 17:28:29 sandervl Exp $ */
     1/* $Id: conout.h,v 1.3 2001-11-26 14:53:59 sandervl Exp $ */
    22
    33/*
    … …  
    5454
    5555                       /* this is a handler method for calls to CreateFile() */
    56   virtual DWORD  CreateFile (LPCSTR        lpFileName,
     56  virtual DWORD  CreateFile (HANDLE        hHandle,
     57                             LPCSTR        lpFileName,
    5758                             PHMHANDLEDATA pHMHandleData,
    5859                             PVOID         lpSecurityAttributes,

  • trunk/src/kernel32/hmcomm.cpp

    r7301 r7457  
    1 /* $Id: hmcomm.cpp,v 1.13 2001-11-08 15:38:42 phaller Exp $ */
     1/* $Id: hmcomm.cpp,v 1.14 2001-11-26 14:53:59 sandervl Exp $ */
    22
    33/*
    … …  
    77 *
    88 * 1999 Achim Hasenmueller <achimha@innotek.de>
     9 * 2001 Sander van Leeuwen <sandervl@xs4all.nl>
     10 *
     11 * TODO: Overlapped IO only supports one request at a time
    912 *
    1013 */
    … …  
    2326#include "dbglocal.h"
    2427
    25 #define MAGIC_COM 0x12abcd34
    26 
    27 #define IOCTL_ASYNC          0x01
    28 #define ASYNC_GETDCBINFO     0x73
    29 #define ASYNC_SETDCBINFO     0x53
    30 #define ASYNC_SETLINECTRL    0x42
    31 #define ASYNC_GETCOMMEVENT   0x72
    32 #define ASYNC_EXTGETBAUDRATE 0x63
    33 #define ASYNC_EXTSETBAUDRATE 0x43
    34 #define ASYNC_GETCOMMERROR   0x6D
    35 #define ASYNC_GETCOMMSTATUS  0x65
    36 #define ASYNC_GETINQUECOUNT  0x68
    37 #define ASYNC_GETOUTQUECOUNT 0x69
    38 #define ASYNC_GETMODEMINPUT  0x67
    39 #define ASYNC_TRANSMITIMM    0x44
    40 #define ASYNC_SETBREAKON     0x4B
    41 #define ASYNC_SETBREAKOFF    0x45
    42 #define ASYNC_SETMODEMCTRL   0x46
    43 #define ASYNC_STARTTRANSMIT  0x48
    44 #define ASYNC_STOPTRANSMIT   0x47
    45 #define ASYNC_GETMODEMOUTPUT 0x66
    46 
    47 
    48 #pragma pack(1)
    49 typedef struct _DCBINFO
    50 {
    51   USHORT   usWriteTimeout;         /*  Time period used for Write Timeout processing. */
    52   USHORT   usReadTimeout;          /*  Time period used for Read Timeout processing. */
    53   BYTE     fbCtlHndShake;          /*  HandShake Control flag. */
    54   BYTE     fbFlowReplace;          /*  Flow Control flag. */
    55   BYTE     fbTimeOut;              /*  Timeout flag. */
    56   BYTE     bErrorReplacementChar;  /*  Error Replacement Character. */
    57   BYTE     bBreakReplacementChar;  /*  Break Replacement Character. */
    58   BYTE     bXONChar;               /*  Character XON. */
    59   BYTE     bXOFFChar;              /*  Character XOFF. */
    60 } DCBINFO;
    61 typedef DCBINFO *PDCBINFO;
    62 
    63 
    64 typedef struct _RXQUEUE
    65 {
    66   USHORT   cch;  /*  Number of characters in the queue. */
    67   USHORT   cb;   /*  Size of receive/transmit queue. */
    68 } RXQUEUE;
    69 
    70 typedef RXQUEUE *PRXQUEUE;
    71 
    72 
    73 typedef struct _MODEMSTATUS
    74 {
    75   BYTE   fbModemOn;   /*  Modem Control Signals ON Mask. */
    76   BYTE   fbModemOff;  /*  Modem Control Signals OFF Mask. */
    77 } MODEMSTATUS;
    78 
    79 typedef MODEMSTATUS *PMODEMSTATUS;
    80 
    81 
    82 #pragma pack()
    83 
    84 
    85 
    86 
    87 
    88 typedef struct _HMDEVCOMDATA
    89 {
    90   ULONG ulMagic;
    91   // Win32 Device Control Block
    92   COMMCONFIG   CommCfg;
    93   COMMTIMEOUTS CommTOuts;
    94   DWORD dwInBuffer, dwOutBuffer;
    95   DWORD dwEventMask;
    96   //OS/2 Device Control Block
    97   DCBINFO dcbOS2;
    98 } HMDEVCOMDATA, *PHMDEVCOMDATA;
    99 
     28
     29BAUDTABLEENTRY BaudTable[] =
     30{
     31  {75,BAUD_075},
     32  {110,BAUD_110},
     33  {134,BAUD_134_5},
     34  {150,BAUD_150},
     35  {300,BAUD_300},
     36  {600,BAUD_600},
     37  {1200,BAUD_1200},
     38  {1800,BAUD_1800},
     39  {2400,BAUD_2400},
     40  {4800,BAUD_4800},
     41  {7200,BAUD_7200},
     42  {9600,BAUD_9600},
     43  {14400,BAUD_14400},
     44  {19200,BAUD_19200},
     45  {38400,BAUD_38400},
     46  {56000,BAUD_56K},
     47  {57600,BAUD_57600},
     48  {115200,BAUD_115200},
     49  {128000,BAUD_128K}
     50};
     51
     52#define BaudTableSize (sizeof(BaudTable)/sizeof(BAUDTABLEENTRY))
     53
     54DWORD CALLBACK SerialCommThread(LPVOID lpThreadParam);
     55
     56//******************************************************************************
     57//******************************************************************************
    10058static VOID *CreateDevData()
    10159{
    … …  
    11977  return pData;
    12078}
    121 
     79//******************************************************************************
     80//******************************************************************************
    12281HMDeviceCommClass::HMDeviceCommClass(LPCSTR lpDeviceName) : HMDeviceHandler(lpDeviceName)
    12382{
    … …  
    168127    return FALSE;
    169128}
    170 
    171 DWORD HMDeviceCommClass::CreateFile(LPCSTR lpFileName,
     129//******************************************************************************
     130//******************************************************************************
     131DWORD HMDeviceCommClass::CreateFile(HANDLE hComm,
     132                                    LPCSTR lpFileName,
    172133                                    PHMHANDLEDATA pHMHandleData,
    173134                                    PVOID lpSecurityAttributes,
    … …  
    179140
    180141  if(strlen(lpFileName) > 5) {
    181     return -1;  //safety check (unnecessary..)
     142    return ERROR_INVALID_PARAMETER;  //safety check (unnecessary..)
    182143  }
    183144  pHMHandleData->hHMHandle = 0;
    … …  
    233194    if(rc)
    234195    {
    235       return -1;
     196      delete pHMHandleData->lpHandlerData;
     197      return rc;
    236198    }
    237199    rc = SetBaud(pHMHandleData,9600);
    … …  
    239201    rc = SetLine(pHMHandleData,8,0,0);
    240202    dprintf(("Set Line to 8/N/1 rc = %d",rc));
    241     return 0;
     203
     204    if(pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED)
     205    {
     206        PHMDEVCOMDATA pDevData = (PHMDEVCOMDATA)pHMHandleData->lpHandlerData;
     207        DWORD         dwThreadId;
     208
     209        pDevData->hEventSem = ::CreateEventA(NULL, TRUE, FALSE, NULL);
     210        pDevData->hThread   = ::CreateThread(NULL, 32*1024, SerialCommThread, (LPVOID)hComm, 0, &dwThreadId);
     211
     212        if(!pDevData->hEventSem || !pDevData->hThread)
     213        {
     214            DebugInt3();
     215            if(pDevData->hEventSem) ::CloseHandle(pDevData->hEventSem);
     216            delete pHMHandleData->lpHandlerData;
     217            return ERROR_NOT_ENOUGH_MEMORY;
     218        }
     219    }
     220    return ERROR_SUCCESS;
    242221  }
    243222  else
    244     return  -1;
    245 }
    246 
    247 
    248                       /* this is a handler method for calls to CloseHandle() */
     223    return ERROR_ACCESS_DENIED;
     224}
     225//******************************************************************************
     226//******************************************************************************
    249227BOOL HMDeviceCommClass::CloseHandle(PHMHANDLEDATA pHMHandleData)
    250228{
    251   dprintf(("HMComm: Serial communication port close request\n"));
     229  PHMDEVCOMDATA pDevData = (PHMDEVCOMDATA)pHMHandleData->lpHandlerData;
     230  dprintf(("HMComm: Serial communication port close request"));
     231
     232  if(pDevData && pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED)
     233  {
     234      pDevData->fClosing = TRUE;
     235      dprintf(("signalling serial thread"));
     236      ::SetEvent(pDevData->hEventSem);
     237      ::ResetEvent(pDevData->hEventSem);
     238
     239      //Wait for thread to clean up
     240      dprintf(("waiting for serial thread"));
     241      DWORD ret = ::WaitForSingleObject(pDevData->hEventSem, 200);
     242      dprintf(("waiting for serial thread done -> %x", ret));
     243      ::CloseHandle(pDevData->hEventSem);
     244  }
    252245  delete pHMHandleData->lpHandlerData;
    253246  return OSLibDosClose(pHMHandleData->hHMHandle);
    254247}
    255 
     248/*****************************************************************************
     249 * Name      : BOOL HMDeviceCommClass::WriteFile
     250 * Purpose   : write data to handle / device
     251 * Parameters: PHMHANDLEDATA pHMHandleData,
     252 *             LPCVOID       lpBuffer,
     253 *             DWORD         nNumberOfBytesToWrite,
     254 *             LPDWORD       lpNumberOfBytesWritten,
     255 *             LPOVERLAPPED  lpOverlapped
     256 * Variables :
     257 * Result    : Boolean
     258 * Remark    :
     259 * Status    :
     260 *
     261 * Author    : SvL
     262 *****************************************************************************/
     263BOOL HMDeviceCommClass::WriteFile(PHMHANDLEDATA pHMHandleData,
     264                                  LPCVOID       lpBuffer,
     265                                  DWORD         nNumberOfBytesToWrite,
     266                                  LPDWORD       lpNumberOfBytesWritten,
     267                                  LPOVERLAPPED  lpOverlapped)
     268{
     269  dprintf(("KERNEL32:HMDeviceCommClass::WriteFile %s(%08x,%08x,%08x,%08x,%08x)",
     270           lpHMDeviceName,
     271           pHMHandleData->hHMHandle,
     272           lpBuffer,
     273           nNumberOfBytesToWrite,
     274           lpNumberOfBytesWritten,
     275           lpOverlapped));
     276
     277  BOOL  ret;
     278  ULONG ulBytesWritten;
     279
     280  if((pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED) && !lpOverlapped) {
     281    dprintf(("FILE_FLAG_OVERLAPPED flag set, but lpOverlapped NULL!!"));
     282    SetLastError(ERROR_INVALID_PARAMETER);
     283    return FALSE;
     284  }
     285  if(!(pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED) && lpOverlapped) {
     286    dprintf(("Warning: lpOverlapped != NULL & !FILE_FLAG_OVERLAPPED; sync operation"));
     287  }
     288
     289  ret = OSLibDosWrite(pHMHandleData->hHMHandle, (LPVOID)lpBuffer, nNumberOfBytesToWrite,
     290                      &ulBytesWritten);
     291
     292  if(lpNumberOfBytesWritten) {
     293       *lpNumberOfBytesWritten = (ret) ? ulBytesWritten : 0;
     294  }
     295  if(ret == FALSE) {
     296       dprintf(("!ERROR!: WriteFile failed with rc %d", GetLastError()));
     297  }
     298
     299  return ret;
     300}
     301/*****************************************************************************
     302 * Name      : BOOL WriteFileEx
     303 * Purpose   : The WriteFileEx function writes data to a file. It is designed
     304 *             solely for asynchronous operation, unlike WriteFile, which is
     305 *             designed for both synchronous and asynchronous operation.
     306 *             WriteFileEx reports its completion status asynchronously,
     307 *             calling a specified completion routine when writing is completed
     308 *             and the calling thread is in an alertable wait state.
     309 * Parameters: HANDLE       hFile                handle of file to write
     310 *             LPVOID       lpBuffer             address of buffer
     311 *             DWORD        nNumberOfBytesToRead number of bytes to write
     312 *             LPOVERLAPPED lpOverlapped         address of offset
     313 *             LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine address of completion routine
     314 * Variables :
     315 * Result    : TRUE / FALSE
     316 * Remark    :
     317 * Status    : UNTESTED STUB
     318 *
     319 * Author    : SvL
     320 *****************************************************************************/
     321
     322BOOL HMDeviceCommClass::WriteFileEx(PHMHANDLEDATA pHMHandleData,
     323                           LPVOID       lpBuffer,
     324                           DWORD        nNumberOfBytesToWrite,
     325                           LPOVERLAPPED lpOverlapped,
     326                           LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine)
     327{
     328  dprintf(("!ERROR!: WriteFileEx %s (%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
     329           lpHMDeviceName,
     330           pHMHandleData->hHMHandle,
     331           lpBuffer,
     332           nNumberOfBytesToWrite,
     333           lpOverlapped,
     334           lpCompletionRoutine));
     335
     336  if(!(pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED)) {
     337      dprintf(("!WARNING!: Handle not created with FILE_FLAG_OVERLAPPED!"));
     338      SetLastError(ERROR_ACCESS_DENIED); //todo: right error?
     339      return FALSE;
     340  }
     341
     342  SetLastError(ERROR_INVALID_FUNCTION);
     343  return FALSE;
     344}
     345/*****************************************************************************
     346 * Name      : BOOL HMDeviceCommClass::ReadFile
     347 * Purpose   : read data from handle / device
     348 * Parameters: PHMHANDLEDATA pHMHandleData,
     349 *             LPCVOID       lpBuffer,
     350 *             DWORD         nNumberOfBytesToRead,
     351 *             LPDWORD       lpNumberOfBytesRead,
     352 *             LPOVERLAPPED  lpOverlapped
     353 * Variables :
     354 * Result    : Boolean
     355 * Remark    :
     356 * Status    :
     357 *
     358 * Author    : SvL
     359 *****************************************************************************/
     360
     361BOOL HMDeviceCommClass::ReadFile(PHMHANDLEDATA pHMHandleData,
     362                                 LPCVOID       lpBuffer,
     363                                 DWORD         nNumberOfBytesToRead,
     364                                 LPDWORD       lpNumberOfBytesRead,
     365                                 LPOVERLAPPED  lpOverlapped)
     366{
     367  dprintf(("KERNEL32:HMDeviceCommClass::ReadFile %s(%08x,%08x,%08x,%08x,%08x)",
     368           lpHMDeviceName,
     369           pHMHandleData->hHMHandle,
     370           lpBuffer,
     371           nNumberOfBytesToRead,
     372           lpNumberOfBytesRead,
     373           lpOverlapped));
     374
     375  BOOL  ret;
     376  ULONG ulBytesRead;
     377
     378  if((pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED) && !lpOverlapped) {
     379    dprintf(("FILE_FLAG_OVERLAPPED flag set, but lpOverlapped NULL!!"));
     380    SetLastError(ERROR_INVALID_PARAMETER);
     381    return FALSE;
     382  }
     383  if(!(pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED) && lpOverlapped) {
     384    dprintf(("!WARNING!: lpOverlapped != NULL & !FILE_FLAG_OVERLAPPED; sync operation"));
     385  }
     386
     387  ret = OSLibDosRead(pHMHandleData->hHMHandle, (LPVOID)lpBuffer, nNumberOfBytesToRead,
     388                     &ulBytesRead);
     389
     390  if(lpNumberOfBytesRead) {
     391       *lpNumberOfBytesRead = (ret) ? ulBytesRead : 0;
     392  }
     393  if(ret == FALSE) {
     394       dprintf(("!ERROR!: ReadFile failed with rc %d", GetLastError()));
     395  }
     396  return ret;
     397}
     398
     399/*****************************************************************************
     400 * Name      : BOOL ReadFileEx
     401 * Purpose   : The ReadFileEx function reads data from a file asynchronously.
     402 *             It is designed solely for asynchronous operation, unlike the
     403 *             ReadFile function, which is designed for both synchronous and
     404 *             asynchronous operation. ReadFileEx lets an application perform
     405 *             other processing during a file read operation.
     406 *             The ReadFileEx function reports its completion status asynchronously,
     407 *             calling a specified completion routine when reading is completed
     408 *             and the calling thread is in an alertable wait state.
     409 * Parameters: HANDLE       hFile                handle of file to read
     410 *             LPVOID       lpBuffer             address of buffer
     411 *             DWORD        nNumberOfBytesToRead number of bytes to read
     412 *             LPOVERLAPPED lpOverlapped         address of offset
     413 *             LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine address of completion routine
     414 * Variables :
     415 * Result    : TRUE / FALSE
     416 * Remark    :
     417 * Status    : UNTESTED STUB
     418 *
     419 * Author    : SvL
     420 *****************************************************************************/
     421BOOL HMDeviceCommClass::ReadFileEx(PHMHANDLEDATA pHMHandleData,
     422                                   LPVOID       lpBuffer,
     423                                   DWORD        nNumberOfBytesToRead,
     424                                   LPOVERLAPPED lpOverlapped,
     425                                   LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine)
     426{
     427  dprintf(("!ERROR!: ReadFileEx %s (%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
     428           lpHMDeviceName,
     429           pHMHandleData->hHMHandle,
     430           lpBuffer,
     431           nNumberOfBytesToRead,
     432           lpOverlapped,
     433           lpCompletionRoutine));
     434
     435  if(!(pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED)) {
     436      dprintf(("!WARNING!: Handle not created with FILE_FLAG_OVERLAPPED!"));
     437      SetLastError(ERROR_ACCESS_DENIED); //todo: right error?
     438      return FALSE;
     439  }
     440
     441  SetLastError(ERROR_INVALID_FUNCTION);
     442  return FALSE;
     443}
    256444/*****************************************************************************
    257445 * Name      : DWORD HMDeviceHandler::SetupComm
    … …  
    273461  if((NULL==pDevData) || (pDevData->ulMagic != MAGIC_COM) )
    274462  {
    275     SetLastError(ERROR_INVALID_HANDLE);
    276     return FALSE;
     463      SetLastError(ERROR_INVALID_HANDLE);
     464      return FALSE;
    277465  }
    278466  pDevData->dwInBuffer  = dwInQueue;
    … …  
    281469  return(TRUE);
    282470}
    283 
     471//******************************************************************************
     472#define TIMEOUT_COMM  50
     473//******************************************************************************
     474DWORD CALLBACK SerialCommThread(LPVOID lpThreadParam)
     475{
     476  HANDLE        hComm = (HANDLE)lpThreadParam;
     477  PHMHANDLEDATA pHMHandleData;
     478  PHMDEVCOMDATA pDevData;
     479  DWORD         ret;
     480  APIRET        rc;
     481  ULONG         ulLen;
     482  USHORT        COMEvt;
     483  DWORD         dwEvent,dwMask;
     484
     485  dprintf(("SerialCommThread %x entered", hComm));
     486  pHMHandleData = HMQueryHandleData(hComm);
     487  if(!pHMHandleData) {
     488      dprintf(("!ERROR!: Invalid handle -> aborting"));
     489      return 0;
     490  }
     491
     492  pDevData = (PHMDEVCOMDATA)pHMHandleData->lpHandlerData;
     493  if(!pDevData) {
     494      DebugInt3();
     495      return 0;
     496  }
     497  HANDLE hEvent   = pDevData->hEventSem;
     498  HANDLE hCommOS2 = pHMHandleData->hHMHandle;
     499  if(!hCommOS2 || !hEvent) {
     500      DebugInt3();
     501      return 0;
     502  }
     503
     504  while(TRUE)
     505  {
     506      //validate handle
     507      pHMHandleData = HMQueryHandleData(hComm);
     508      if(!pHMHandleData) {
     509          dprintf(("!ERROR!: Invalid handle -> aborting"));
     510          return 0;
     511      }
     512      if(pDevData->fClosing) {
     513          dprintf(("Cleaning up async comm thread"));
     514          SetEvent(hEvent); //signal to CloseHandle that we're done
     515          return 0;
     516      }
     517
     518      //Wait for the app to call WaitCommEvent
     519      dprintf(("SerialCommThread: wait for WaitCommEvent"));
     520      ret = WaitForSingleObject(hEvent, INFINITE);
     521      ResetEvent(hEvent);
     522      dprintf(("SerialCommThread: wait for WaitCommEvent done %x", ret));
     523
     524      //validate handle first
     525      pHMHandleData = HMQueryHandleData(hComm);
     526      if(!pHMHandleData) {
     527          dprintf(("!ERROR!: Invalid handle -> aborting"));
     528          return 0;
     529      }
     530
     531      if(pDevData->fClosing) {
     532          dprintf(("Cleaning up async comm thread"));
     533          SetEvent(hEvent); //signal to CloseHandle that we're done
     534          return 0;
     535      }
     536
     537      HANDLE hOverlappedEvent = pDevData->overlapped.hEvent;
     538      if(!hOverlappedEvent) {
     539          DebugInt3();
     540          return 0;
     541      }
     542
     543      ulLen   = sizeof(CHAR);
     544      dwEvent = 0;
     545      rc      = 0;
     546      ulLen   = sizeof(COMEvt);
     547      dwMask  = pDevData->dwEventMask;
     548
     549      while( (0==rc) &&
     550            !(dwEvent & dwMask) &&
     551            (dwMask == pDevData->dwEventMask) &&
     552            !(pDevData->fCancelIo) && !(pDevData->fClosing) ) // Exit if the Mask gets changed
     553      {
     554          rc = OSLibDosDevIOCtl(hCommOS2,
     555                                IOCTL_ASYNC,
     556                                ASYNC_GETCOMMEVENT,
     557                                0,0,0,
     558                                &COMEvt,ulLen,&ulLen);
     559          if(!rc)
     560          {
     561              dwEvent |= (COMEvt&0x0001)? EV_RXCHAR:0;
     562              //dwEvent |= (COMEvt&0x0002)? 0:0;
     563              dwEvent |= (COMEvt&0x0004)? EV_TXEMPTY:0;
     564              dwEvent |= (COMEvt&0x0008)? EV_CTS:0;
     565              dwEvent |= (COMEvt&0x0010)? EV_DSR:0;
     566              //dwEvent |= (COMEvt&0x0020)? 0:0; DCS = RLSD?
     567              dwEvent |= (COMEvt&0x0040)? EV_BREAK:0;
     568              dwEvent |= (COMEvt&0x0080)? EV_ERR:0;
     569              dwEvent |= (COMEvt&0x0100)? EV_RING:0;
     570              if((dwEvent & dwMask)) break;
     571          }
     572          else break;
     573
     574          DosSleep(TIMEOUT_COMM);
     575      }
     576      if((dwEvent & dwMask) && (dwMask == pDevData->dwEventMask)) {
     577          pDevData->overlapped.Internal |= (rc==0) ? (dwEvent & dwMask) : 0;
     578          pDevData->dwLastError = rc;
     579          dprintf(("Overlapped: WaitCommEvent returned %x", pDevData->overlapped.Internal));
     580
     581          //signal to app that a comm event has occurred
     582          SetEvent(hOverlappedEvent);
     583      }
     584  }
     585  return 0;
     586}
     587//******************************************************************************
     588//******************************************************************************
    284589BOOL HMDeviceCommClass::WaitCommEvent( PHMHANDLEDATA pHMHandleData,
    285590                                       LPDWORD lpfdwEvtMask,
    … …  
    293598  PHMDEVCOMDATA pDevData = (PHMDEVCOMDATA)pHMHandleData->lpHandlerData;
    294599
    295   dprintf(("HMDeviceCommClass::WaitCommEvent"));
     600  dprintf2(("HMDeviceCommClass::WaitCommEvent %x", pHMHandleData->hHMHandle));
     601
     602  if((pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED) && !lpo) {
     603      dprintf(("!WARNING! pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED) && !lpo"));
     604      SetLastError(ERROR_INVALID_PARAMETER);
     605      return FALSE;
     606  }
     607
    296608  ulLen = sizeof(CHAR);
    297609
    … …  
    304616        (dwMask ==pDevData->dwEventMask) ) // Exit if the Mask gets changed
    305617  {
    306     rc = OSLibDosDevIOCtl( pHMHandleData->hHMHandle,
    307                       IOCTL_ASYNC,
    308                       ASYNC_GETCOMMEVENT,
    309                       0,0,0,
    310                       &COMEvt,ulLen,&ulLen);
     618    rc = OSLibDosDevIOCtl(pHMHandleData->hHMHandle,
     619                          IOCTL_ASYNC,
     620                          ASYNC_GETCOMMEVENT,
     621                          0,0,0,
     622                          &COMEvt,ulLen,&ulLen);
    311623    if(!rc)
    312624    {
    313       dwEvent |= (COMEvt&0x0001)? EV_RXCHAR:0;
    314       //dwEvent |= (COMEvt&0x0002)? 0:0;
    315       dwEvent |= (COMEvt&0x0004)? EV_TXEMPTY:0;
    316       dwEvent |= (COMEvt&0x0008)? EV_CTS:0;
    317       dwEvent |= (COMEvt&0x0010)? EV_DSR:0;
    318       //dwEvent |= (COMEvt&0x0020)? 0:0; DCS = RLSD?
    319       dwEvent |= (COMEvt&0x0040)? EV_BREAK:0;
    320       dwEvent |= (COMEvt&0x0080)? EV_ERR:0;
    321       dwEvent |= (COMEvt&0x0100)? EV_RING:0;
     625        dwEvent |= (COMEvt&0x0001)? EV_RXCHAR:0;
     626        //dwEvent |= (COMEvt&0x0002)? 0:0;
     627        dwEvent |= (COMEvt&0x0004)? EV_TXEMPTY:0;
     628        dwEvent |= (COMEvt&0x0008)? EV_CTS:0;
     629        dwEvent |= (COMEvt&0x0010)? EV_DSR:0;
     630        //dwEvent |= (COMEvt&0x0020)? 0:0; DCS = RLSD?
     631        dwEvent |= (COMEvt&0x0040)? EV_BREAK:0;
     632        dwEvent |= (COMEvt&0x0080)? EV_ERR:0;
     633        dwEvent |= (COMEvt&0x0100)? EV_RING:0;
     634        if((dwEvent & dwMask)) break;
    322635    }
    323     DosSleep(100);
    324   }
    325   *lpfdwEvtMask = rc==0?dwEvent:0;
    326   return(rc==0);
    327 }
    328 
    329 
    330 #pragma pack(1)
    331 typedef struct
    332 {
    333   ULONG ulCurrBaud;
    334   UCHAR ucCurrFrac;
    335   ULONG ulMinBaud;
    336   UCHAR ucMinFrac;
    337   ULONG ulMaxBaud;
    338   UCHAR ucMaxFrac;
    339 } EXTBAUDGET, *PEXTBAUDGET;
    340 
    341 typedef struct
    342 {
    343   ULONG ulBaud;
    344   UCHAR ucFrac;
    345 } EXTBAUDSET, *PEXTBAUDSET;
    346 #pragma pack()
    347 
    348 BAUDTABLEENTRY BaudTable[] =
    349 {
    350   {75,BAUD_075},
    351   {110,BAUD_110},
    352   {134,BAUD_134_5},
    353   {150,BAUD_150},
    354   {300,BAUD_300},
    355   {600,BAUD_600},
    356   {1200,BAUD_1200},
    357   {1800,BAUD_1800},
    358   {2400,BAUD_2400},
    359   {4800,BAUD_4800},
    360   {7200,BAUD_7200},
    361   {9600,BAUD_9600},
    362   {14400,BAUD_14400},
    363   {19200,BAUD_19200},
    364   {38400,BAUD_38400},
    365   {56000,BAUD_56K},
    366   {57600,BAUD_57600},
    367   {115200,BAUD_115200},
    368   {128000,BAUD_128K}
    369 };
    370 
    371 #define BaudTableSize (sizeof(BaudTable)/sizeof(BAUDTABLEENTRY))
    372 
     636    else break;
     637
     638    if(pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED)
     639    {
     640        memcpy(&pDevData->overlapped, lpo, sizeof(pDevData->overlapped));
     641        pDevData->overlapped.Internal     = 0;
     642        pDevData->overlapped.InternalHigh = 0;
     643        pDevData->overlapped.Offset       = 0;
     644        pDevData->overlapped.OffsetHigh   = 0;
     645        //signal async comm thread to start polling comm status
     646        ::SetEvent(pDevData->hEventSem);
     647        SetLastError(ERROR_IO_PENDING);
     648        return FALSE;
     649    }
     650    DosSleep(TIMEOUT_COMM);
     651  }
     652  if(dwMask == pDevData->dwEventMask) {
     653       *lpfdwEvtMask = (rc==0) ? (dwEvent & dwMask) : 0;
     654       dprintf(("WaitCommEvent returned %x", *lpfdwEvtMask));
     655  }
     656  else  *lpfdwEvtMask = 0;
     657
     658  return (rc==0);
     659}
     660/*****************************************************************************
     661 * Name      : DWORD HMDeviceCommClass::CancelIo
     662 * Purpose   : cancel pending IO operation
     663 * Variables :
     664 * Result    :
     665 * Remark    :
     666 * Status    :
     667 *
     668 * Author    : SvL
     669 *****************************************************************************/
     670BOOL HMDeviceCommClass::CancelIo(PHMHANDLEDATA pHMHandleData)
     671{
     672    PHMDEVCOMDATA pDevData = (PHMDEVCOMDATA)pHMHandleData->lpHandlerData;
     673
     674    dprintf(("HMDeviceCommClass::CancelIo"));
     675    if(pDevData == NULL || !(pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED)) {
     676        SetLastError(ERROR_ACCESS_DENIED); //todo: wrong error?
     677        return FALSE;
     678    }
     679
     680    //signal serial thread to cancel pending IO operation
     681    pDevData->fCancelIo = TRUE;
     682    ::SetEvent(pDevData->hEventSem);
     683
     684    SetLastError(ERROR_SUCCESS);
     685    return(TRUE);
     686}
     687/*****************************************************************************
     688 * Name      : DWORD HMDeviceFileClass::GetOverlappedResult
     689 * Purpose   : asynchronus I/O
     690 * Parameters: PHMHANDLEDATA pHMHandleData
     691 *             LPOVERLAPPED  arg2
     692 *             LPDWORD       arg3
     693 *             BOOL          arg4
     694 * Variables :
     695 * Result    : API returncode
     696 * Remark    :
     697 * Status    :
     698 *
     699 * Author    : SvL
     700 *****************************************************************************/
     701BOOL HMDeviceCommClass::GetOverlappedResult(PHMHANDLEDATA pHMHandleData,
     702                                            LPOVERLAPPED  lpoOverlapped,
     703                                            LPDWORD       lpcbTransfer,
     704                                            BOOL          fWait)
     705{
     706  PHMDEVCOMDATA pDevData = (PHMDEVCOMDATA)pHMHandleData->lpHandlerData;
     707
     708  dprintf(("KERNEL32-WARNING: HMDeviceCommClass::GetOverlappedResult(%08xh,%08xh,%08xh,%08xh) STUB!!",
     709            pHMHandleData->hHMHandle,
     710            lpoOverlapped,
     711            lpcbTransfer,
     712            fWait));
     713
     714  if(pDevData == NULL || !(pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED)) {
     715      SetLastError(ERROR_ACCESS_DENIED); //todo: wrong error?
     716      return FALSE;
     717  }
     718  if(!lpoOverlapped) {
     719      SetLastError(ERROR_INVALID_PARAMETER);
     720      return FALSE;
     721  }
     722  if(lpoOverlapped->hEvent != pDevData->overlapped.hEvent) {
     723      dprintf(("!WARNING!: GetOverlappedResult called for unknown operation"));
     724      SetLastError(ERROR_ACCESS_DENIED); //todo: wrong error?
     725      return FALSE;
     726  }
     727  if(pDevData->overlapped.Internal) {
     728      lpoOverlapped->Internal       = pDevData->overlapped.Internal;
     729      pDevData->overlapped.Internal = 0; //not entirely safe
     730      pDevData->dwLastError         = 0;
     731      SetLastError(pDevData->dwLastError);
     732      return lpoOverlapped->Internal;
     733  }
     734  if(fWait) {
     735      ::WaitForSingleObject(pDevData->overlapped.hEvent, INFINITE);
     736      ::ResetEvent(pDevData->overlapped.hEvent);
     737      lpoOverlapped->Internal       = pDevData->overlapped.Internal;
     738      pDevData->overlapped.Internal = 0; //not entirely safe
     739      SetLastError(ERROR_SUCCESS);
     740      return lpoOverlapped->Internal;
     741  }
     742  else {
     743      SetLastError(ERROR_IO_PENDING);
     744      return FALSE;
     745  }
     746}
     747//******************************************************************************
     748//******************************************************************************
    373749BOOL HMDeviceCommClass::GetCommProperties( PHMHANDLEDATA pHMHandleData,
    374750                                           LPCOMMPROP lpcmmp)
    … …  
    414790  return(rc==0);
    415791}
    416 
     792//******************************************************************************
     793//******************************************************************************
    417794BOOL HMDeviceCommClass::GetCommMask( PHMHANDLEDATA pHMHandleData,
    418795                                     LPDWORD lpfdwEvtMask)
    … …  
    425802  return(TRUE);
    426803}
    427 
     804//******************************************************************************
     805//******************************************************************************
    428806BOOL HMDeviceCommClass::SetCommMask( PHMHANDLEDATA pHMHandleData,
    429807                                     DWORD fdwEvtMask)
    430808{
    431809  PHMDEVCOMDATA pDevData = (PHMDEVCOMDATA)pHMHandleData->lpHandlerData;
    432   dprintf(("HMDeviceCommClass::SetCommMask"));
     810  dprintf(("HMDeviceCommClass::SetCommMask %x", fdwEvtMask));
     811
     812  if(fdwEvtMask & (EV_RLSD|EV_RXFLAG)) {
     813      dprintf(("!WARNING! SetCommMask: unsupported flags EV_RLSD and/or EV_RXFLAG!!"));
     814  }
    433815
    434816  pDevData->dwEventMask = fdwEvtMask & ~(EV_RLSD|EV_RXFLAG); // Clear the 2 not supported Flags.
    435817  return(TRUE);
    436818}
    437 
     819//******************************************************************************
     820//******************************************************************************
    438821BOOL HMDeviceCommClass::PurgeComm( PHMHANDLEDATA pHMHandleData,
    439822                                   DWORD fdwAction)
    … …  
    445828  return(TRUE);
    446829}
     830//******************************************************************************
     831//******************************************************************************
    447832BOOL HMDeviceCommClass::ClearCommError( PHMHANDLEDATA pHMHandleData,
    448833                                        LPDWORD lpdwErrors,
    … …  
    509894  return(rc==0);
    510895}
     896//******************************************************************************
     897//******************************************************************************
    511898BOOL HMDeviceCommClass::SetCommState( PHMHANDLEDATA pHMHandleData,
    512899                                      LPDCB lpDCB)
    … …  
    561948  return(rc==0);
    562949}
     950//******************************************************************************
     951//******************************************************************************
    563952BOOL HMDeviceCommClass::GetCommState( PHMHANDLEDATA pHMHandleData,
    564953                                      LPDCB lpdcb)
    … …  
    571960  return(TRUE);
    572961}
     962//******************************************************************************
     963//******************************************************************************
    573964BOOL HMDeviceCommClass::GetCommModemStatus( PHMHANDLEDATA pHMHandleData,
    574965                                          LPDWORD lpModemStat )
    … …  
    579970  UCHAR ucStatus;
    580971
    581   dprintf(("HMDeviceCommClass::TransmitCommChar partly implemented"));
     972  dprintf(("HMDeviceCommClass::GetCommModemStatus %x", lpModemStat));
    582973  ulLen = sizeof(CHAR);
    583974
    … …  
    600991  return(rc==0);
    601992}
    602 
     993//******************************************************************************
     994//******************************************************************************
    603995BOOL HMDeviceCommClass::GetCommTimeouts( PHMHANDLEDATA pHMHandleData,
    604996                                         LPCOMMTIMEOUTS lpctmo)
    … …  
    6121004  return(TRUE);
    6131005}
     1006//******************************************************************************
     1007//******************************************************************************
    6141008BOOL HMDeviceCommClass::SetCommTimeouts( PHMHANDLEDATA pHMHandleData,
    6151009                                         LPCOMMTIMEOUTS lpctmo)
    … …  
    6901084  return(0==rc);
    6911085}
     1086//******************************************************************************
     1087//******************************************************************************
    6921088BOOL HMDeviceCommClass::TransmitCommChar( PHMHANDLEDATA pHMHandleData,
    6931089                                          CHAR cChar )
    … …  
    7081104  return(rc==0);
    7091105}
    710 
    711 /*****************************************************************************
    712  * Name      : BOOL HMDeviceCommClass::WriteFile
    713  * Purpose   : write data to handle / device
    714  * Parameters: PHMHANDLEDATA pHMHandleData,
    715  *             LPCVOID       lpBuffer,
    716  *             DWORD         nNumberOfBytesToWrite,
    717  *             LPDWORD       lpNumberOfBytesWritten,
    718  *             LPOVERLAPPED  lpOverlapped
    719  * Variables :
    720  * Result    : Boolean
    721  * Remark    :
    722  * Status    :
    723  *
    724  * Author    : SvL
    725  *****************************************************************************/
    726 
    727 BOOL HMDeviceCommClass::WriteFile(PHMHANDLEDATA pHMHandleData,
    728                                   LPCVOID       lpBuffer,
    729                                   DWORD         nNumberOfBytesToWrite,
    730                                   LPDWORD       lpNumberOfBytesWritten,
    731                                   LPOVERLAPPED  lpOverlapped)
    732 {
    733   dprintf(("KERNEL32:HMDeviceCommClass::WriteFile %s(%08x,%08x,%08x,%08x,%08x)",
    734            lpHMDeviceName,
    735            pHMHandleData->hHMHandle,
    736            lpBuffer,
    737            nNumberOfBytesToWrite,
    738            lpNumberOfBytesWritten,
    739            lpOverlapped));
    740 
    741   BOOL  ret;
    742   ULONG ulBytesWritten;
    743 
    744   if((pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED) && !lpOverlapped) {
    745     dprintf(("FILE_FLAG_OVERLAPPED flag set, but lpOverlapped NULL!!"));
    746     SetLastError(ERROR_INVALID_PARAMETER);
    747     return FALSE;
    748   }
    749   if(!(pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED) && lpOverlapped) {
    750     dprintf(("Warning: lpOverlapped != NULL & !FILE_FLAG_OVERLAPPED; sync operation"));
    751   }
    752 
    753   ret = OSLibDosWrite(pHMHandleData->hHMHandle, (LPVOID)lpBuffer, nNumberOfBytesToWrite,
    754                       &ulBytesWritten);
    755 
    756   if(lpNumberOfBytesWritten) {
    757        *lpNumberOfBytesWritten = (ret) ? ulBytesWritten : 0;
    758   }
    759   if(ret == FALSE) {
    760        dprintf(("ERROR: WriteFile failed with rc %d", GetLastError()));
    761   }
    762 
    763   return ret;
    764 }
    765 
    766 /*****************************************************************************
    767  * Name      : BOOL WriteFileEx
    768  * Purpose   : The WriteFileEx function writes data to a file. It is designed
    769  *             solely for asynchronous operation, unlike WriteFile, which is
    770  *             designed for both synchronous and asynchronous operation.
    771  *             WriteFileEx reports its completion status asynchronously,
    772  *             calling a specified completion routine when writing is completed
    773  *             and the calling thread is in an alertable wait state.
    774  * Parameters: HANDLE       hFile                handle of file to write
    775  *             LPVOID       lpBuffer             address of buffer
    776  *             DWORD        nNumberOfBytesToRead number of bytes to write
    777  *             LPOVERLAPPED lpOverlapped         address of offset
    778  *             LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine address of completion routine
    779  * Variables :
    780  * Result    : TRUE / FALSE
    781  * Remark    :
    782  * Status    : UNTESTED STUB
    783  *
    784  * Author    : Patrick Haller [Mon, 1998/06/15 08:00]
    785  *****************************************************************************/
    786 
    787 BOOL HMDeviceCommClass::WriteFileEx(PHMHANDLEDATA pHMHandleData,
    788                            LPVOID       lpBuffer,
    789                            DWORD        nNumberOfBytesToWrite,
    790                            LPOVERLAPPED lpOverlapped,
    791                            LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine)
    792 {
    793   dprintf(("ERROR: WriteFileEx %s (%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
    794            lpHMDeviceName,
    795            pHMHandleData->hHMHandle,
    796            lpBuffer,
    797            nNumberOfBytesToWrite,
    798            lpOverlapped,
    799            lpCompletionRoutine));
    800 
    801   SetLastError(ERROR_INVALID_FUNCTION);
    802   return FALSE;
    803 }
    804 
    805 /*****************************************************************************
    806  * Name      : BOOL HMDeviceCommClass::ReadFile
    807  * Purpose   : read data from handle / device
    808  * Parameters: PHMHANDLEDATA pHMHandleData,
    809  *             LPCVOID       lpBuffer,
    810  *             DWORD         nNumberOfBytesToRead,
    811  *             LPDWORD       lpNumberOfBytesRead,
    812  *             LPOVERLAPPED  lpOverlapped
    813  * Variables :
    814  * Result    : Boolean
    815  * Remark    :
    816  * Status    :
    817  *
    818  * Author    : SvL
    819  *****************************************************************************/
    820 
    821 BOOL HMDeviceCommClass::ReadFile(PHMHANDLEDATA pHMHandleData,
    822                                  LPCVOID       lpBuffer,
    823                                  DWORD         nNumberOfBytesToRead,
    824                                  LPDWORD       lpNumberOfBytesRead,
    825                                  LPOVERLAPPED  lpOverlapped)
    826 {
    827   dprintf(("KERNEL32:HMDeviceCommClass::ReadFile %s(%08x,%08x,%08x,%08x,%08x)",
    828            lpHMDeviceName,
    829            pHMHandleData->hHMHandle,
    830            lpBuffer,
    831            nNumberOfBytesToRead,
    832            lpNumberOfBytesRead,
    833            lpOverlapped));
    834 
    835   BOOL  ret;
    836   ULONG ulBytesRead;
    837 
    838   if((pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED) && !lpOverlapped) {
    839     dprintf(("FILE_FLAG_OVERLAPPED flag set, but lpOverlapped NULL!!"));
    840     SetLastError(ERROR_INVALID_PARAMETER);
    841     return FALSE;
    842   }
    843   if(!(pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED) && lpOverlapped) {
    844     dprintf(("Warning: lpOverlapped != NULL & !FILE_FLAG_OVERLAPPED; sync operation"));
    845   }
    846 
    847   ret = OSLibDosRead(pHMHandleData->hHMHandle, (LPVOID)lpBuffer, nNumberOfBytesToRead,
    848                      &ulBytesRead);
    849 
    850   if(lpNumberOfBytesRead) {
    851        *lpNumberOfBytesRead = (ret) ? ulBytesRead : 0;
    852   }
    853   if(ret == FALSE) {
    854        dprintf(("ERROR: ReadFile failed with rc %d", GetLastError()));
    855   }
    856   return ret;
    857 }
    858 
    859 /*****************************************************************************
    860  * Name      : BOOL ReadFileEx
    861  * Purpose   : The ReadFileEx function reads data from a file asynchronously.
    862  *             It is designed solely for asynchronous operation, unlike the
    863  *             ReadFile function, which is designed for both synchronous and
    864  *             asynchronous operation. ReadFileEx lets an application perform
    865  *             other processing during a file read operation.
    866  *             The ReadFileEx function reports its completion status asynchronously,
    867  *             calling a specified completion routine when reading is completed
    868  *             and the calling thread is in an alertable wait state.
    869  * Parameters: HANDLE       hFile                handle of file to read
    870  *             LPVOID       lpBuffer             address of buffer
    871  *             DWORD        nNumberOfBytesToRead number of bytes to read
    872  *             LPOVERLAPPED lpOverlapped         address of offset
    873  *             LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine address of completion routine
    874  * Variables :
    875  * Result    : TRUE / FALSE
    876  * Remark    :
    877  * Status    : UNTESTED STUB
    878  *
    879  * Author    : Patrick Haller [Mon, 1998/06/15 08:00]
    880  *****************************************************************************/
    881 BOOL HMDeviceCommClass::ReadFileEx(PHMHANDLEDATA pHMHandleData,
    882                            LPVOID       lpBuffer,
    883                            DWORD        nNumberOfBytesToRead,
    884                            LPOVERLAPPED lpOverlapped,
    885                            LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine)
    886 {
    887   dprintf(("ERROR: ReadFileEx %s (%08xh,%08xh,%08xh,%08xh,%08xh) not implemented.\n",
    888            lpHMDeviceName,
    889            pHMHandleData->hHMHandle,
    890            lpBuffer,
    891            nNumberOfBytesToRead,
    892            lpOverlapped,
    893            lpCompletionRoutine));
    894 
    895   SetLastError(ERROR_INVALID_FUNCTION);
    896   return FALSE;
    897 }
    898 
     1106//******************************************************************************
     1107//******************************************************************************
    8991108BOOL HMDeviceCommClass::SetCommBreak( PHMHANDLEDATA pHMHandleData )
    9001109{
    … …  
    9141123  return(rc==0);
    9151124}
    916 
     1125//******************************************************************************
     1126//******************************************************************************
    9171127BOOL HMDeviceCommClass::ClearCommBreak( PHMHANDLEDATA pHMHandleData)
    9181128{
    … …  
    9321142  return(rc==0);
    9331143}
    934 
     1144//******************************************************************************
     1145//******************************************************************************
    9351146BOOL HMDeviceCommClass::SetCommConfig( PHMHANDLEDATA pHMHandleData,
    9361147                                       LPCOMMCONFIG lpCC,
    9371148                                       DWORD dwSize )
    9381149{
    939   dprintf(("HMDeviceCommClass::SetCommConfig"));
    940 
     1150  dprintf(("HMDeviceCommClass::SetCommConfig NOT IMPLEMENTED"));
    9411151
    9421152  return(TRUE);
    9431153}
    944 
     1154//******************************************************************************
     1155//******************************************************************************
    9451156BOOL HMDeviceCommClass::GetCommConfig( PHMHANDLEDATA pHMHandleData,
    9461157                                       LPCOMMCONFIG lpCC,
    … …  
    9691180  return(TRUE);
    9701181}
    971 
     1182//******************************************************************************
     1183//******************************************************************************
    9721184BOOL HMDeviceCommClass::EscapeCommFunction( PHMHANDLEDATA pHMHandleData,
    9731185                                            UINT dwFunc )
    … …  
    9781190  MODEMSTATUS mdm;
    9791191
    980   dprintf(("HMDeviceCommClass::EscapeCommFunction"));
     1192  dprintf(("HMDeviceCommClass::EscapeCommFunction %x", dwFunc));
    9811193
    9821194  ulDLen = sizeof(USHORT);
    … …  
    10491261      break;
    10501262    default:
     1263      dprintf(("!ERROR!: EscapeCommFunction: unknown function"));
    10511264      SetLastError(ERROR_INVALID_PARAMETER);
    10521265      return(FALSE);
    … …  
    10551268  return(rc==0);
    10561269}
    1057 
     1270//******************************************************************************
     1271//******************************************************************************
    10581272BOOL HMDeviceCommClass::SetDefaultCommConfig( PHMHANDLEDATA pHMHandleData,
    10591273                                              LPCOMMCONFIG lpCC,
    … …  
    10711285  return(TRUE);
    10721286}
     1287//******************************************************************************
     1288//******************************************************************************
    10731289BOOL HMDeviceCommClass::GetDefaultCommConfig( PHMHANDLEDATA pHMHandleData,
    10741290                                              LPCOMMCONFIG lpCC,
    … …  
    10951311  return(TRUE);
    10961312}
     1313//******************************************************************************
     1314//******************************************************************************
    10971315APIRET HMDeviceCommClass::SetLine( PHMHANDLEDATA pHMHandleData,
    10981316                                   UCHAR ucSize,
    … …  
    11321350  return rc;
    11331351}
    1134 
     1352//******************************************************************************
     1353//******************************************************************************
    11351354APIRET HMDeviceCommClass::SetOS2DCB( PHMHANDLEDATA pHMHandleData,
    11361355                                     BOOL fOutxCtsFlow, BOOL fOutxDsrFlow,
    … …  
    12131432
    12141433}
    1215 
     1434//******************************************************************************
     1435//******************************************************************************
    12161436APIRET HMDeviceCommClass::SetBaud( PHMHANDLEDATA pHMHandleData,
    12171437                                   DWORD dwNewBaud)
    … …  
    12491469  return rc;
    12501470}
    1251 
    1252 
     1471//******************************************************************************
     1472//******************************************************************************
     1473
     1474

  • trunk/src/kernel32/hmcomm.h

    r5587 r7457  
    1 /* $Id: hmcomm.h,v 1.8 2001-04-26 13:22:44 sandervl Exp $ */
     1/* $Id: hmcomm.h,v 1.9 2001-11-26 14:54:00 sandervl Exp $ */
    22
    33/*
    … …  
    1212#ifndef _HM_COMM_H_
    1313#define _HM_COMM_H_
     14
     15#define MAGIC_COM 0x12abcd34
     16
    1417typedef struct
    1518{
    … …  
    1821}BAUDTABLEENTRY;
    1922
     23#define IOCTL_ASYNC          0x01
     24#define ASYNC_GETDCBINFO     0x73
     25#define ASYNC_SETDCBINFO     0x53
     26#define ASYNC_SETLINECTRL    0x42
     27#define ASYNC_GETCOMMEVENT   0x72
     28#define ASYNC_EXTGETBAUDRATE 0x63
     29#define ASYNC_EXTSETBAUDRATE 0x43
     30#define ASYNC_GETCOMMERROR   0x6D
     31#define ASYNC_GETCOMMSTATUS  0x65
     32#define ASYNC_GETINQUECOUNT  0x68
     33#define ASYNC_GETOUTQUECOUNT 0x69
     34#define ASYNC_GETMODEMINPUT  0x67
     35#define ASYNC_TRANSMITIMM    0x44
     36#define ASYNC_SETBREAKON     0x4B
     37#define ASYNC_SETBREAKOFF    0x45
     38#define ASYNC_SETMODEMCTRL   0x46
     39#define ASYNC_STARTTRANSMIT  0x48
     40#define ASYNC_STOPTRANSMIT   0x47
     41#define ASYNC_GETMODEMOUTPUT 0x66
     42
     43
     44#pragma pack(1)
     45typedef struct _DCBINFO
     46{
     47  USHORT   usWriteTimeout;         /*  Time period used for Write Timeout processing. */
     48  USHORT   usReadTimeout;          /*  Time period used for Read Timeout processing. */
     49  BYTE     fbCtlHndShake;          /*  HandShake Control flag. */
     50  BYTE     fbFlowReplace;          /*  Flow Control flag. */
     51  BYTE     fbTimeOut;              /*  Timeout flag. */
     52  BYTE     bErrorReplacementChar;  /*  Error Replacement Character. */
     53  BYTE     bBreakReplacementChar;  /*  Break Replacement Character. */
     54  BYTE     bXONChar;               /*  Character XON. */
     55  BYTE     bXOFFChar;              /*  Character XOFF. */
     56} DCBINFO;
     57typedef DCBINFO *PDCBINFO;
     58
     59
     60typedef struct _RXQUEUE
     61{
     62  USHORT   cch;  /*  Number of characters in the queue. */
     63  USHORT   cb;   /*  Size of receive/transmit queue. */
     64} RXQUEUE;
     65
     66typedef RXQUEUE *PRXQUEUE;
     67
     68
     69typedef struct _MODEMSTATUS
     70{
     71  BYTE   fbModemOn;   /*  Modem Control Signals ON Mask. */
     72  BYTE   fbModemOff;  /*  Modem Control Signals OFF Mask. */
     73} MODEMSTATUS;
     74
     75typedef MODEMSTATUS *PMODEMSTATUS;
     76
     77
     78#pragma pack()
     79
     80typedef struct _HMDEVCOMDATA
     81{
     82  ULONG ulMagic;
     83  // Win32 Device Control Block
     84  COMMCONFIG   CommCfg;
     85  COMMTIMEOUTS CommTOuts;
     86  DWORD dwInBuffer, dwOutBuffer;
     87  DWORD dwEventMask;
     88  //overlapped IO info
     89  HANDLE     hThread;
     90  HANDLE     hEventSem;
     91  OVERLAPPED overlapped;
     92  DWORD      dwLastError;
     93  BOOL       fClosing;
     94  BOOL       fCancelIo;
     95  //OS/2 Device Control Block
     96  DCBINFO dcbOS2;
     97} HMDEVCOMDATA, *PHMDEVCOMDATA;
     98
     99#pragma pack(1)
     100typedef struct
     101{
     102  ULONG ulCurrBaud;
     103  UCHAR ucCurrFrac;
     104  ULONG ulMinBaud;
     105  UCHAR ucMinFrac;
     106  ULONG ulMaxBaud;
     107  UCHAR ucMaxFrac;
     108} EXTBAUDGET, *PEXTBAUDGET;
     109
     110typedef struct
     111{
     112  ULONG ulBaud;
     113  UCHAR ucFrac;
     114} EXTBAUDSET, *PEXTBAUDSET;
     115#pragma pack()
     116
    20117class HMDeviceCommClass : public HMDeviceHandler
    21118{
    … …  
    28125
    29126  /* this is the handler method for calls to CreateFile() */
    30   virtual DWORD  CreateFile (LPCSTR        lpFileName,
     127  virtual DWORD  CreateFile (HANDLE        hHandle,
     128                             LPCSTR        lpFileName,
    31129                             PHMHANDLEDATA pHMHandleData,
    32130                             PVOID         lpSecurityAttributes,
    … …  
    112210                            LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine);
    113211
     212  virtual BOOL   CancelIo           (PHMHANDLEDATA pHMHandleData);
     213
     214                /* this is a handler method for calls to GetOverlappedResult */
     215  virtual BOOL GetOverlappedResult(PHMHANDLEDATA pHMHandleData,
     216                                   LPOVERLAPPED  arg2,
     217                                   LPDWORD       arg3,
     218                                   BOOL          arg4);
     219
    114220  private:
    115221  APIRET SetLine( PHMHANDLEDATA pHMHandleData,

  • trunk/src/kernel32/hmdevice.cpp

    r6060 r7457  
    1 /* $Id: hmdevice.cpp,v 1.28 2001-06-21 21:07:53 sandervl Exp $ */
     1/* $Id: hmdevice.cpp,v 1.29 2001-11-26 14:54:00 sandervl Exp $ */
    22
    33/*
    … …  
    169169 *****************************************************************************/
    170170
    171 DWORD HMDeviceHandler::CreateFile (LPCSTR        lpFileName,
     171DWORD HMDeviceHandler::CreateFile (HANDLE        hHandle,
     172                                   LPCSTR        lpFileName,
    172173                                   PHMHANDLEDATA pHMHandleData,
    173174                                   PVOID         lpSecurityAttributes,
    … …  
    626627 *****************************************************************************/
    627628
    628 DWORD HMDeviceHandler::OpenFile (LPCSTR        lpFileName,
     629DWORD HMDeviceHandler::OpenFile (HANDLE        hHandle,
     630                                 LPCSTR        lpFileName,
    629631                                 PHMHANDLEDATA pHMHandleData,
    630632                                 OFSTRUCT      *pOFStruct,
    … …  
    11601162}
    11611163
    1162 
     1164/*****************************************************************************
     1165 * Name      : DWORD HMDeviceHandler::CancelIo
     1166 * Purpose   : cancel pending IO operation
     1167 * Variables :
     1168 * Result    :
     1169 * Remark    :
     1170 * Status    :
     1171 *
     1172 * Author    : SvL
     1173 *****************************************************************************/
     1174BOOL HMDeviceHandler::CancelIo(PHMHANDLEDATA pHMHandleData)
     1175{
     1176  dprintf(("KERNEL32: HandleManager::DeviceHandler::CancelIo(%08xh)",
     1177           pHMHandleData->hHMHandle));
     1178  SetLastError(ERROR_INVALID_HANDLE);
     1179  return(FALSE);
     1180}
    11631181/*****************************************************************************
    11641182 * Name      : DWORD HMDeviceHandler::SetupComm

  • trunk/src/kernel32/hmdevice.h

    r6084 r7457  
    1 /* $Id: hmdevice.h,v 1.29 2001-06-23 16:59:27 sandervl Exp $ */
     1/* $Id: hmdevice.h,v 1.30 2001-11-26 14:54:00 sandervl Exp $ */
    22
    33/*
    … …  
    100100
    101101                       /* this is a handler method for calls to CreateFile() */
    102   virtual DWORD  CreateFile (LPCSTR        lpFileName,
     102  virtual DWORD  CreateFile (HANDLE        hHandle,
     103                             LPCSTR        lpFileName,
    103104                             PHMHANDLEDATA pHMHandleData,
    104105                             PVOID         lpSecurityAttributes,
    … …  
    106107
    107108                       /* this is a handler method for calls to   OpenFile() */
    108   virtual DWORD  OpenFile   (LPCSTR        lpFileName,
     109  virtual DWORD  OpenFile   (HANDLE        hHandle,
     110                             LPCSTR        lpFileName,
    109111                             PHMHANDLEDATA pHMHandleData,
    110112                             OFSTRUCT*     pOFStruct,
    … …  
    329331                                     LPVOID lpOutBuffer, DWORD nOutBufferSize,
    330332                                     LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped);
     333
     334  virtual BOOL   CancelIo           (PHMHANDLEDATA pHMHandleData);
    331335
    332336 /* COM ports */

  • trunk/src/kernel32/hmdevio.cpp

    r7245 r7457  
    1 /* $Id: hmdevio.cpp,v 1.15 2001-10-28 12:48:04 sandervl Exp $ */
     1/* $Id: hmdevio.cpp,v 1.16 2001-11-26 14:54:00 sandervl Exp $ */
    22
    33/*
    … …  
    166166//******************************************************************************
    167167//******************************************************************************
    168 DWORD HMDeviceDriver::CreateFile (LPCSTR lpFileName,
     168DWORD HMDeviceDriver::CreateFile (HANDLE        hHandle,
     169                                  LPCSTR lpFileName,
    169170                                  PHMHANDLEDATA pHMHandleData,
    170171                                  PVOID         lpSecurityAttributes,

  • trunk/src/kernel32/hmdevio.h

    r7245 r7457  
    1 /* $Id: hmdevio.h,v 1.4 2001-10-28 12:48:04 sandervl Exp $ */
     1/* $Id: hmdevio.h,v 1.5 2001-11-26 14:54:01 sandervl Exp $ */
    22
    33#ifndef __DEVIO_H__
    … …  
    123123
    124124                       /* this is a handler method for calls to CreateFile() */
    125   virtual DWORD  CreateFile (LPCSTR        lpFileName,
     125  virtual DWORD  CreateFile (HANDLE        hHandle,
     126                             LPCSTR        lpFileName,
    126127                             PHMHANDLEDATA pHMHandleData,
    127128                             PVOID         lpSecurityAttributes,

  • trunk/src/kernel32/hmdisk.cpp

    r7430 r7457  
    1 /* $Id: hmdisk.cpp,v 1.28 2001-11-22 16:03:23 sandervl Exp $ */
     1/* $Id: hmdisk.cpp,v 1.29 2001-11-26 14:54:01 sandervl Exp $ */
    22
    33/*
    … …  
    8888//TODO: PHYSICALDRIVEn!!
    8989//******************************************************************************
    90 DWORD HMDeviceDiskClass::CreateFile (LPCSTR        lpFileName,
     90DWORD HMDeviceDiskClass::CreateFile (HANDLE        hHandle,
     91                                     LPCSTR        lpFileName,
    9192                                     PHMHANDLEDATA pHMHandleData,
    9293                                     PVOID         lpSecurityAttributes,

  • trunk/src/kernel32/hmdisk.h

    r7430 r7457  
    1 /* $Id: hmdisk.h,v 1.6 2001-11-22 16:03:23 sandervl Exp $ */
     1/* $Id: hmdisk.h,v 1.7 2001-11-26 14:54:01 sandervl Exp $ */
    22
    33#ifndef __HMDISK_H__
    … …  
    2525
    2626  /* this is a handler method for calls to CreateFile() */
    27   virtual DWORD  CreateFile (LPCSTR        lpFileName,
     27  virtual DWORD  CreateFile (HANDLE        hHandle,
     28                             LPCSTR        lpFileName,
    2829                             PHMHANDLEDATA pHMHandleData,
    2930                             PVOID         lpSecurityAttributes,

  • trunk/src/kernel32/hmfile.cpp

    r7293 r7457  
    1 /* $Id: hmfile.cpp,v 1.29 2001-11-07 15:35:36 sandervl Exp $ */
     1/* $Id: hmfile.cpp,v 1.30 2001-11-26 14:54:01 sandervl Exp $ */
    22
    33/*
    … …  
    5656 *****************************************************************************/
    5757
    58 DWORD HMDeviceFileClass::CreateFile (LPCSTR        lpFileName,
     58DWORD HMDeviceFileClass::CreateFile (HANDLE        hHandle,
     59                                     LPCSTR        lpFileName,
    5960                                     PHMHANDLEDATA pHMHandleData,
    6061                                     PVOID         lpSecurityAttributes,
    … …  
    151152 *****************************************************************************/
    152153
    153 DWORD HMDeviceFileClass::OpenFile (LPCSTR        lpszFileName,
     154DWORD HMDeviceFileClass::OpenFile (HANDLE        hHandle,
     155                                   LPCSTR        lpszFileName,
    154156                                   PHMHANDLEDATA pHMHandleData,
    155157                                   OFSTRUCT      *pOFStruct,
    … …  
    350352        duphdata.dwCreation = OPEN_EXISTING;
    351353
    352         if(CreateFile(srcfileinfo->lpszFileName, &duphdata,
     354        if(CreateFile(0, srcfileinfo->lpszFileName, &duphdata,
    353355                      srcfileinfo->lpSecurityAttributes, NULL) == NO_ERROR)
    354356        {

  • trunk/src/kernel32/hmfile.h

    r5587 r7457  
    1 /* $Id: hmfile.h,v 1.5 2001-04-26 13:22:45 sandervl Exp $ */
     1/* $Id: hmfile.h,v 1.6 2001-11-26 14:54:02 sandervl Exp $ */
    22
    33/*
    … …  
    4545
    4646                       /* this is a handler method for calls to CreateFile() */
    47   virtual DWORD  CreateFile (LPCSTR        lpFileName,
     47  virtual DWORD  CreateFile (HANDLE        hHandle,
     48                             LPCSTR        lpFileName,
    4849                             PHMHANDLEDATA pHMHandleData,
    4950                             PVOID         lpSecurityAttributes,
    … …  
    5152
    5253                       /* this is a handler method for calls to   OpenFile() */
    53   virtual DWORD  OpenFile   (LPCSTR        lpFileName,
     54  virtual DWORD  OpenFile   (HANDLE        hHandle,
     55                             LPCSTR        lpFileName,
    5456                             PHMHANDLEDATA pHMHandleData,
    5557                             OFSTRUCT*     pOFStruct,

  • trunk/src/kernel32/hmmailslot.cpp

    r6646 r7457  
    1 /* $Id: hmmailslot.cpp,v 1.2 2001-09-05 12:57:58 bird Exp $
     1/* $Id: hmmailslot.cpp,v 1.3 2001-11-26 14:54:02 sandervl Exp $
    22 *
    33 * Win32 mailslot APIs
    … …  
    176176 *****************************************************************************/
    177177
    178 DWORD HMMailslotClass::CreateFile (LPCSTR        lpFileName,
     178DWORD HMMailslotClass::CreateFile (HANDLE        hHandle,
     179                                   LPCSTR        lpFileName,
    179180                                   PHMHANDLEDATA pHMHandleData,
    180181                                   PVOID         lpSecurityAttributes,

  • trunk/src/kernel32/hmmailslot.h

    r5587 r7457  
    6969
    7070  /* this is a handler method for calls to CreateFile() */
    71   virtual DWORD  CreateFile (LPCSTR        lpFileName,
     71  virtual DWORD  CreateFile (HANDLE        hHandle,
     72                             LPCSTR        lpFileName,
    7273                             PHMHANDLEDATA pHMHandleData,
    7374                             PVOID         lpSecurityAttributes,

  • trunk/src/kernel32/hmnpipe.cpp

    r7293 r7457  
    1 /* $Id: hmnpipe.cpp,v 1.3 2001-11-07 15:35:37 sandervl Exp $ */
     1/* $Id: hmnpipe.cpp,v 1.4 2001-11-26 14:54:02 sandervl Exp $ */
    22/*
    33 * Project Odin Software License can be found in LICENSE.TXT
    … …  
    128128 *****************************************************************************/
    129129
    130 DWORD HMDeviceNamedPipeClass::CreateFile (LPCSTR        lpFileName,
     130DWORD HMDeviceNamedPipeClass::CreateFile (HANDLE        hHandle,
     131                                          LPCSTR        lpFileName,
    131132                                          PHMHANDLEDATA pHMHandleData,
    132133                                          PVOID         lpSecurityAttributes,

  • trunk/src/kernel32/hmnpipe.h

    r7293 r7457  
    1 /* $Id: hmnpipe.h,v 1.3 2001-11-07 15:35:37 sandervl Exp $ */
     1/* $Id: hmnpipe.h,v 1.4 2001-11-26 14:54:03 sandervl Exp $ */
    22/*
    33 * Project Odin Software License can be found in LICENSE.TXT
    … …  
    3232
    3333  /* this is a handler method for calls to CreateFile() */
    34   virtual DWORD  CreateFile (LPCSTR        lpFileName,
     34  virtual DWORD  CreateFile (HANDLE        hHandle,
     35                             LPCSTR        lpFileName,
    3536                             PHMHANDLEDATA pHMHandleData,
    3637                             PVOID         lpSecurityAttributes,

  • trunk/src/kernel32/hmparport.cpp

    r7443 r7457  
    1 /* $Id: hmparport.cpp,v 1.7 2001-11-23 18:58:24 phaller Exp $ */
     1/* $Id: hmparport.cpp,v 1.8 2001-11-26 14:54:03 sandervl Exp $ */
    22
    33/*
    … …  
    196196}
    197197
    198 DWORD HMDeviceParPortClass::CreateFile(LPCSTR lpFileName,
     198DWORD HMDeviceParPortClass::CreateFile(HANDLE        hHandle,
     199                                       LPCSTR lpFileName,
    199200                                       PHMHANDLEDATA pHMHandleData,
    200201                                       PVOID lpSecurityAttributes,

  • trunk/src/kernel32/hmparport.h

    r7301 r7457  
    1 /* $Id: hmparport.h,v 1.3 2001-11-08 15:38:42 phaller Exp $ */
     1/* $Id: hmparport.h,v 1.4 2001-11-26 14:54:03 sandervl Exp $ */
    22
    33/*
    … …  
    2323
    2424  /* this is the handler method for calls to CreateFile() */
    25   virtual DWORD  CreateFile (LPCSTR        lpFileName,
     25  virtual DWORD  CreateFile (HANDLE        hHandle,
     26                             LPCSTR        lpFileName,
    2627                             PHMHANDLEDATA pHMHandleData,
    2728                             PVOID         lpSecurityAttributes,

  • trunk/src/kernel32/stubs.cpp

    r7318 r7457  
    1 /* $Id: stubs.cpp,v 1.33 2001-11-10 12:47:47 sandervl Exp $
     1/* $Id: stubs.cpp,v 1.34 2001-11-26 14:54:03 sandervl Exp $
    22 *
    33 * Win32 KERNEL32 Subsystem for OS/2
    … …  
    410410
    411411  return (NULL);
    412 }
    413 
    414 /*****************************************************************************
    415  * Name      : BOOL WIN32API CancelIo
    416  * Purpose   : The CancelIO function cancels all pending input and output
    417  *             (I/O) operations that were issued by the calling thread for
    418  *             the specified file handle. The function does not cancel
    419  *             I/O operations issued for the file handle by other threads.
    420  * Parameters: HANDLE hFile   file handle for which to cancel I/O
    421  * Variables :
    422  * Result    : If the function succeeds, the return value is nonzero All pending
    423  *             I/O operations issued by the calling thread for the file handle
    424  *             were successfully canceled.
    425  *             If the function fails, the return value is zero.
    426  *             To get extended error information, call GetLastError.
    427  * Remark    : If there are any I/O operations in progress for the specified
    428  *             file handle, and they were issued by the calling thread, the
    429  *             CancelIO function cancels them.
    430  *             Note that the I/O operations must have been issued as
    431  *             overlapped I/O. If they were not, the I/O operations would not
    432  *             have returned to allow the thread to call the CancelIO function.
    433  *             Calling the CancelIO function with a file handle that was not
    434  *             opened with FILE_FLAG_OVERLAPPED does nothing.
    435  *             All I/O operations that are canceled will complete with the
    436  *             error ERROR_OPERATION_ABORTED. All completion notifications
    437  *             for the I/O operations will occur normally.
    438  * Status    : UNTESTED STUB
    439  *
    440  * Author    : Markus Montkowski [Thu, 1998/05/19 11:46]
    441  *****************************************************************************/
    442 
    443 BOOL WIN32API CancelIo(HANDLE hFile)
    444 {
    445 
    446   dprintf(("KERNEL32:CancelIo(%08x) not implemented\n",
    447            hFile
    448           ));
    449 
    450   return (FALSE);
    451412}
    452413
Note: See TracChangeset for help on using the changeset viewer.