Changeset 7564 for trunk/src/kernel32


Ignore:
Timestamp:
Dec 7, 2001, 12:28:11 PM (24 years ago)
Author:
sandervl
Message:

overlappedio, com & lpt updates

Location:
trunk/src/kernel32
Files:
9 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/kernel32/Fileio.cpp

    r7560 r7564  
    1 /* $Id: Fileio.cpp,v 1.61 2001-12-06 15:57:51 sandervl Exp $ */
     1/* $Id: Fileio.cpp,v 1.62 2001-12-07 11:28:09 sandervl Exp $ */
    22
    33/*
    … …  
    16601660              BOOL, bWait)                /* [in] wait for the transfer to complete ? */
    16611661{
     1662  //NOTE: According to the SDK docs lpOverlapped->hEvent can be 0. This function
     1663  //      is supposed to wait on the file handle in that case. We don't support
     1664  //      this, so we just fail.
    16621665  if(lpOverlapped == NULL || lpOverlapped->hEvent == 0) {
    16631666      dprintf(("!ERROR!: lpOverlapped == NULL || lpOverlapped->hEvent == 0"));

  • trunk/src/kernel32/hmcomm.cpp

    r7550 r7564  
    1 /* $Id: hmcomm.cpp,v 1.27 2001-12-05 18:06:00 sandervl Exp $ */
     1/* $Id: hmcomm.cpp,v 1.28 2001-12-07 11:28:09 sandervl Exp $ */
    22
    33/*
    … …  
    99 * 2001 Sander van Leeuwen <sandervl@xs4all.nl>
    1010 *
    11  * TODO: Overlapped IO only supports one request at a time
    12  * TODO: Overlapped IO not thread safe
    1311 *
    1412 */
    … …  
    2119#include "handlenames.h"
    2220#include <heapstring.h>
    23 #include "hmdevice.h"
    2421#include "hmcomm.h"
    2522#include "oslibdos.h"
    … …  
    6158#define BaudTableSize (sizeof(BaudTable)/sizeof(BAUDTABLEENTRY))
    6259
     60static BOOL CommReadIOHandler(LPASYNCIOREQUEST lpRequest, DWORD *lpdwResult, DWORD *lpdwTimeOut);
     61static BOOL CommWriteIOHandler(LPASYNCIOREQUEST lpRequest, DWORD *lpdwResult, DWORD *lpdwTimeOut);
     62static BOOL CommPollIOHandler(LPASYNCIOREQUEST lpRequest, DWORD *lpdwResult, DWORD *lpdwTimeOut);
     63
    6364//******************************************************************************
    6465//******************************************************************************
    6566static VOID *CreateDevData()
    6667{
    67   PHMDEVCOMDATA pData;
    68   pData = new HMDEVCOMDATA();
    69   if(NULL!=pData)
    70   {
    71     memset(pData,0,sizeof(HMDEVCOMDATA));
    72     pData->ulMagic = MAGIC_COM;
    73     pData->CommCfg.dwSize   = sizeof(COMMCONFIG);
    74     pData->CommCfg.wVersion = 1;
    75     pData->CommCfg.dwProviderSubType = PST_RS232;
    76     pData->CommCfg.dcb.DCBlength = sizeof(DCB);
    77     pData->CommCfg.dcb.BaudRate  = CBR_1200;
    78     pData->CommCfg.dcb.ByteSize = 8;
    79     pData->CommCfg.dcb.Parity   = NOPARITY;
    80     pData->CommCfg.dcb.StopBits = ONESTOPBIT;
    81     pData->dwInBuffer  = 16;
    82     pData->dwOutBuffer = 16;
    83   }
    84   return pData;
     68    PHMDEVCOMDATA pData;
     69
     70    pData = new HMDEVCOMDATA();
     71    if(NULL!=pData)
     72    {
     73        memset(pData,0,sizeof(HMDEVCOMDATA));
     74        pData->ulMagic = MAGIC_COM;
     75        pData->CommCfg.dwSize   = sizeof(COMMCONFIG);
     76        pData->CommCfg.wVersion = 1;
     77        pData->CommCfg.dwProviderSubType = PST_RS232;
     78        pData->CommCfg.dcb.DCBlength = sizeof(DCB);
     79        pData->CommCfg.dcb.BaudRate  = CBR_1200;
     80        pData->CommCfg.dcb.ByteSize = 8;
     81        pData->CommCfg.dcb.Parity   = NOPARITY;
     82        pData->CommCfg.dcb.StopBits = ONESTOPBIT;
     83        pData->dwInBuffer  = 16;
     84        pData->dwOutBuffer = 16;
     85    }
     86    return pData;
    8587}
    8688//******************************************************************************
    … …  
    8890HMDeviceCommClass::HMDeviceCommClass(LPCSTR lpDeviceName) : HMDeviceHandler(lpDeviceName)
    8991{
    90   VOID *pData;
    91   dprintf(("HMDeviceCommClass: Register COM1 to COM8 with Handle Manager\n"));
    92   pData = CreateDevData();
    93   if(pData!= NULL)
    94     HMDeviceRegisterEx("COM1", this, pData);
    95  
    96   // add symbolic links to the "real name" of the device
    97   {
     92    VOID *pData;
     93
     94    dprintf(("HMDeviceCommClass: Register COM1 to COM8 with Handle Manager\n"));
     95    pData = CreateDevData();
     96    if(pData!= NULL)
     97        HMDeviceRegisterEx("COM1", this, pData);
     98
     99    // add symbolic links to the "real name" of the device
    98100    // @@@PH what's the long device name: SerialPortx ?
    99101    // HandleNamesAddSymbolicLink("\\Device\\ParallelPort3", "COM3");
    100102    // Note: \\.\COMx: is invalid (NT4SP6)
    101    
     103
    102104    PSZ pszCOM = strdup("\\\\.\\COMx");
    103     for (char ch = '1'; ch <= '9'; ch++)
     105    for (char ch = '1'; ch < '9'; ch++)
    104106    {
    105       pszCOM[7] = ch;
    106       HandleNamesAddSymbolicLink(pszCOM, pszCOM+4);
     107        pszCOM[7] = ch;
     108        HandleNamesAddSymbolicLink(pszCOM, pszCOM+4);
    107109    }
    108110    free(pszCOM);
    109  
     111
    110112    // add "AUX" device
    111113    HandleNamesAddSymbolicLink("AUX",        "COM1");
    112114    HandleNamesAddSymbolicLink("AUX:",       "COM1");
    113115    HandleNamesAddSymbolicLink("\\\\.\\AUX", "COM1");
    114   }
    115116}
    116117
    … …  
    131132{
    132133    dprintf2(("HMDeviceCommClass::FindDevice %s %s", lpClassDevName, lpDeviceName));
    133  
     134
    134135    //first 3 letters 'COM'?
    135136    if(lstrncmpiA(lpDeviceName, lpClassDevName, 3) != 0) {
    … …  
    163164 DWORD ret = ERROR_SUCCESS;
    164165
    165   dprintf(("HMComm: Serial communication port %s open request\n", lpFileName));
    166 
    167   if(strlen(lpFileName) > 5) {
    168       lpFileName += 4; //skip prefix
    169   }
    170 
    171   pHMHandleData->hHMHandle = 0;
    172 
    173   strcpy(comname, lpFileName);
    174   comname[4] = 0;   //get rid of : (if present) (eg COM1:)
    175 
    176   //AH: TODO parse Win32 security handles
    177   ULONG oldmode = ::SetErrorMode(SEM_FAILCRITICALERRORS);
    178   pHMHandleData->hHMHandle = OSLibDosOpen(comname,
    179                                           OSLIB_ACCESS_READWRITE |
    180                                           OSLIB_ACCESS_SHAREDENYREAD |
    181                                           OSLIB_ACCESS_SHAREDENYWRITE);
    182   ::SetErrorMode(oldmode);
    183   if (pHMHandleData->hHMHandle != 0)
    184   {
    185     ULONG ulLen;
    186     APIRET rc;
    187     pHMHandleData->lpHandlerData = new HMDEVCOMDATA();
    188     // Init The handle instance with the default default device config
    189     memcpy( pHMHandleData->lpHandlerData,
    190             pHMHandleData->lpDeviceData,
    191             sizeof(HMDEVCOMDATA));
    192 
    193     ulLen = sizeof(DCBINFO);
    194 
    195     rc = OSLibDosDevIOCtl( pHMHandleData->hHMHandle,
    196                            IOCTL_ASYNC,
    197                            ASYNC_GETDCBINFO,
    198                            0,0,0,
    199                            &((PHMDEVCOMDATA)pHMHandleData->lpHandlerData)->dcbOS2,ulLen,&ulLen);
    200     dprintf(("DCB Of %s :\n"
    201              " WriteTimeout           : %d\n"
    202              " ReadTimeout            : %d\n"
    203              " CtlHandshake           : 0x%x\n"
    204              " FlowReplace            : 0x%x\n"
    205              " Timeout                : 0x%x\n"
    206              " Error replacement Char : 0x%x\n"
    207              " Break replacement Char : 0x%x\n"
    208              " XON Char               : 0x%x\n"
    209              " XOFF Char              : 0x%x\n",
    210              comname,
    211              ((PHMDEVCOMDATA)pHMHandleData->lpHandlerData)->dcbOS2.usWriteTimeout,
    212              ((PHMDEVCOMDATA)pHMHandleData->lpHandlerData)->dcbOS2.usReadTimeout,
    213              ((PHMDEVCOMDATA)pHMHandleData->lpHandlerData)->dcbOS2.fbCtlHndShake,
    214              ((PHMDEVCOMDATA)pHMHandleData->lpHandlerData)->dcbOS2.fbFlowReplace,
    215              ((PHMDEVCOMDATA)pHMHandleData->lpHandlerData)->dcbOS2.fbTimeOut,
    216              ((PHMDEVCOMDATA)pHMHandleData->lpHandlerData)->dcbOS2.bErrorReplacementChar,
    217              ((PHMDEVCOMDATA)pHMHandleData->lpHandlerData)->dcbOS2.bBreakReplacementChar,
    218              ((PHMDEVCOMDATA)pHMHandleData->lpHandlerData)->dcbOS2.bXONChar,
    219              ((PHMDEVCOMDATA)pHMHandleData->lpHandlerData)->dcbOS2.bXOFFChar));
    220 
    221     if(rc)
     166    dprintf(("HMComm: Serial communication port %s open request\n", lpFileName));
     167
     168    if(strlen(lpFileName) > 5) {
     169        lpFileName += 4; //skip prefix
     170    }
     171
     172    pHMHandleData->hHMHandle = 0;
     173
     174    strcpy(comname, lpFileName);
     175    comname[4] = 0;   //get rid of : (if present) (eg COM1:)
     176
     177    //AH: TODO parse Win32 security handles
     178    ULONG oldmode = ::SetErrorMode(SEM_FAILCRITICALERRORS);
     179    pHMHandleData->hHMHandle = OSLibDosOpen(comname,
     180                                            OSLIB_ACCESS_READWRITE |
     181                                            OSLIB_ACCESS_SHAREDENYREAD |
     182                                            OSLIB_ACCESS_SHAREDENYWRITE);
     183    ::SetErrorMode(oldmode);
     184    if (pHMHandleData->hHMHandle != 0)
    222185    {
    223       OSLibDosClose(pHMHandleData->hHMHandle);
    224       delete pHMHandleData->lpHandlerData;
    225       return rc;
    226     }
    227     rc = SetBaud(pHMHandleData,9600);
    228     dprintf(("Init Baud to 9600 rc = %d",rc));
    229     rc = SetLine(pHMHandleData,8,0,0);
    230     dprintf(("Set Line to 8/N/1 rc = %d",rc));
    231 
    232     if(pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED)
    233     {
    234         PHMDEVCOMDATA pDevData = (PHMDEVCOMDATA)pHMHandleData->lpHandlerData;
    235         DWORD         dwThreadId;
    236 
    237     }
    238     return ERROR_SUCCESS;
    239   }
    240   else
    241     return ERROR_ACCESS_DENIED;
    242 
     186        ULONG ulLen;
     187        APIRET rc;
     188        pHMHandleData->lpHandlerData = new HMDEVCOMDATA();
     189        // Init The handle instance with the default default device config
     190        memcpy( pHMHandleData->lpHandlerData,
     191                pHMHandleData->lpDeviceData,
     192                sizeof(HMDEVCOMDATA));
     193
     194        ulLen = sizeof(DCBINFO);
     195
     196        rc = OSLibDosDevIOCtl( pHMHandleData->hHMHandle,
     197                               IOCTL_ASYNC,
     198                               ASYNC_GETDCBINFO,
     199                               0,0,0,
     200                               &((PHMDEVCOMDATA)pHMHandleData->lpHandlerData)->dcbOS2,ulLen,&ulLen);
     201        dprintf(("DCB Of %s :\n"
     202                 " WriteTimeout           : %d\n"
     203                 " ReadTimeout            : %d\n"
     204                 " CtlHandshake           : 0x%x\n"
     205                 " FlowReplace            : 0x%x\n"
     206                 " Timeout                : 0x%x\n"
     207                 " Error replacement Char : 0x%x\n"
     208                 " Break replacement Char : 0x%x\n"
     209                 " XON Char               : 0x%x\n"
     210                 " XOFF Char              : 0x%x\n",
     211                 comname,
     212                 ((PHMDEVCOMDATA)pHMHandleData->lpHandlerData)->dcbOS2.usWriteTimeout,
     213                 ((PHMDEVCOMDATA)pHMHandleData->lpHandlerData)->dcbOS2.usReadTimeout,
     214                 ((PHMDEVCOMDATA)pHMHandleData->lpHandlerData)->dcbOS2.fbCtlHndShake,
     215                 ((PHMDEVCOMDATA)pHMHandleData->lpHandlerData)->dcbOS2.fbFlowReplace,
     216                 ((PHMDEVCOMDATA)pHMHandleData->lpHandlerData)->dcbOS2.fbTimeOut,
     217                 ((PHMDEVCOMDATA)pHMHandleData->lpHandlerData)->dcbOS2.bErrorReplacementChar,
     218                 ((PHMDEVCOMDATA)pHMHandleData->lpHandlerData)->dcbOS2.bBreakReplacementChar,
     219                 ((PHMDEVCOMDATA)pHMHandleData->lpHandlerData)->dcbOS2.bXONChar,
     220                 ((PHMDEVCOMDATA)pHMHandleData->lpHandlerData)->dcbOS2.bXOFFChar));
     221
     222        if(rc)
     223        {
     224            OSLibDosClose(pHMHandleData->hHMHandle);
     225            delete pHMHandleData->lpHandlerData;
     226            return rc;
     227        }
     228        rc = SetBaud(pHMHandleData,9600);
     229        dprintf(("Init Baud to 9600 rc = %d",rc));
     230        rc = SetLine(pHMHandleData,8,0,0);
     231        dprintf(("Set Line to 8/N/1 rc = %d",rc));
     232
     233        if(pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED)
     234        {
     235            PHMDEVCOMDATA pDevData = (PHMDEVCOMDATA)pHMHandleData->lpHandlerData;
     236            int           comnr;
     237
     238            comnr = comname[3] - '1';
     239
     240            if(handler[comnr] == NULL) {
     241                try {
     242                    handler[comnr] = new OverlappedIOHandler(CommReadIOHandler, CommWriteIOHandler, CommPollIOHandler);
     243                }
     244                catch(...)
     245                {
     246                    ret = ERROR_NOT_ENOUGH_MEMORY;
     247                    goto fail;
     248                }
     249            }
     250            pDevData->iohandler = handler[comnr];
     251        }
     252        return ERROR_SUCCESS;
     253    }
     254    else
     255        return ERROR_ACCESS_DENIED;
    243256
    244257fail:
    245258
    246   delete pHMHandleData->lpHandlerData;
    247   OSLibDosClose(pHMHandleData->hHMHandle);
    248   return ret;
     259    delete pHMHandleData->lpHandlerData;
     260    OSLibDosClose(pHMHandleData->hHMHandle);
     261    return ret;
    249262}
    250263/*****************************************************************************
    … …  
    262275DWORD HMDeviceCommClass::GetFileType(PHMHANDLEDATA pHMHandleData)
    263276{
    264   dprintf(("KERNEL32: HMDeviceCommClass::GetFileType %s(%08x)\n",
    265            lpHMDeviceName,
    266            pHMHandleData));
    267 
    268   return FILE_TYPE_CHAR;
     277    dprintf(("KERNEL32: HMDeviceCommClass::GetFileType %s(%08x)\n",
     278             lpHMDeviceName, pHMHandleData));
     279
     280    return FILE_TYPE_CHAR;
    269281}
    270282//******************************************************************************
    … …  
    272284BOOL HMDeviceCommClass::CloseHandle(PHMHANDLEDATA pHMHandleData)
    273285{
    274   PHMDEVCOMDATA pDevData = (PHMDEVCOMDATA)pHMHandleData->lpHandlerData;
    275   dprintf(("HMComm: Serial communication port close request"));
    276 
    277   if(pDevData && pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED)
    278   {
    279       DebugInt3();
    280   }
    281   delete pHMHandleData->lpHandlerData;
    282   return OSLibDosClose(pHMHandleData->hHMHandle);
     286    PHMDEVCOMDATA pDevData = (PHMDEVCOMDATA)pHMHandleData->lpHandlerData;
     287    dprintf(("HMComm: Serial communication port close request"));
     288
     289    if(pDevData && pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED)
     290    {
     291        DebugInt3();
     292    }
     293    delete pHMHandleData->lpHandlerData;
     294    return OSLibDosClose(pHMHandleData->hHMHandle);
     295}
     296//******************************************************************************
     297//Overlapped read handler
     298//******************************************************************************
     299BOOL CommReadIOHandler(LPASYNCIOREQUEST lpRequest, DWORD *lpdwResult, DWORD *lpdwTimeOut)
     300{
     301    return FALSE;
     302}
     303//******************************************************************************
     304//Overlapped write handler
     305//******************************************************************************
     306BOOL CommWriteIOHandler(LPASYNCIOREQUEST lpRequest, DWORD *lpdwResult, DWORD *lpdwTimeOut)
     307{
     308    return FALSE;
     309}
     310//******************************************************************************
     311//Overlapped WaitCommEvent handler
     312//******************************************************************************
     313BOOL CommPollIOHandler(LPASYNCIOREQUEST lpRequest, DWORD *lpdwResult, DWORD *lpdwTimeOut)
     314{
     315    *lpdwTimeOut = TIMEOUT_COMM;
     316    return FALSE;
    283317}
    284318/*****************************************************************************
    … …  
    304338                                  LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine)
    305339{
    306   dprintf(("KERNEL32:HMDeviceCommClass::WriteFile %s(%08x,%08x,%08x,%08x,%08x)",
    307            lpHMDeviceName,
    308            pHMHandleData->hHMHandle,
    309            lpBuffer,
    310            nNumberOfBytesToWrite,
    311            lpNumberOfBytesWritten,
    312            lpOverlapped));
    313 
    314   BOOL  ret;
    315   ULONG ulBytesWritten;
    316 
    317   if((pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED) && !lpOverlapped) {
    318     dprintf(("FILE_FLAG_OVERLAPPED flag set, but lpOverlapped NULL!!"));
    319     ::SetLastError(ERROR_INVALID_PARAMETER);
    320     return FALSE;
    321   }
    322   if(!(pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED) && lpOverlapped) {
    323     dprintf(("Warning: lpOverlapped != NULL & !FILE_FLAG_OVERLAPPED; sync operation"));
    324   }
    325   if(lpCompletionRoutine) {
    326       dprintf(("!WARNING!: lpCompletionRoutine not supported -> fall back to sync IO"));
    327   }
    328 
    329 //testestestest
    330   dprintf2(("Bytes to write:"));
    331   for(int i=0;i<nNumberOfBytesToWrite;i++) {
    332           dprintf2(("%x %c", ((char *)lpBuffer)[i], ((char *)lpBuffer)[i]));
    333   }
    334 //testestestset
    335 
    336   ret = OSLibDosWrite(pHMHandleData->hHMHandle, (LPVOID)lpBuffer, nNumberOfBytesToWrite,
    337                       &ulBytesWritten);
    338 
    339   if(lpNumberOfBytesWritten) {
     340    PHMDEVCOMDATA pDevData = (PHMDEVCOMDATA)pHMHandleData->lpHandlerData;
     341    BOOL  ret;
     342    ULONG ulBytesWritten;
     343
     344    dprintf(("KERNEL32:HMDeviceCommClass::WriteFile %s(%08x,%08x,%08x,%08x,%08x)",
     345             lpHMDeviceName, pHMHandleData->hHMHandle, lpBuffer, nNumberOfBytesToWrite,
     346             lpNumberOfBytesWritten, lpOverlapped));
     347
     348
     349    if((NULL==pDevData) || (pDevData->ulMagic != MAGIC_COM) )
     350    {
     351        ::SetLastError(ERROR_INVALID_HANDLE);
     352        return FALSE;
     353    }
     354
     355    if((pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED) && !lpOverlapped) {
     356        dprintf(("FILE_FLAG_OVERLAPPED flag set, but lpOverlapped NULL!!"));
     357        ::SetLastError(ERROR_INVALID_PARAMETER);
     358        return FALSE;
     359    }
     360    if(!(pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED) && lpOverlapped) {
     361        dprintf(("Warning: lpOverlapped != NULL & !FILE_FLAG_OVERLAPPED; sync operation"));
     362    }
     363    if(lpCompletionRoutine) {
     364        dprintf(("!WARNING!: lpCompletionRoutine not supported -> fall back to sync IO"));
     365    }
     366
     367    if(pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED) {
     368        return pDevData->iohandler->WriteFile(pHMHandleData->hWin32Handle, lpBuffer, nNumberOfBytesToWrite,
     369                                              lpNumberOfBytesWritten, lpOverlapped, lpCompletionRoutine, (DWORD)pDevData);
     370    }
     371
     372    //testestestest
     373    dprintf2(("Bytes to write:"));
     374    for(int i=0;i<nNumberOfBytesToWrite;i++) {
     375        dprintf2(("%x %c", ((char *)lpBuffer)[i], ((char *)lpBuffer)[i]));
     376    }
     377    //testestestset
     378
     379    ret = OSLibDosWrite(pHMHandleData->hHMHandle, (LPVOID)lpBuffer, nNumberOfBytesToWrite,
     380                        &ulBytesWritten);
     381
     382    if(lpNumberOfBytesWritten) {
    340383       *lpNumberOfBytesWritten = (ret) ? ulBytesWritten : 0;
    341384       dprintf2(("KERNEL32:HMDeviceCommClass::WriteFile %d byte(s) written", *lpNumberOfBytesWritten));
    342   }
    343   if(ret == FALSE) {
     385    }
     386    if(ret == FALSE) {
    344387       dprintf(("!ERROR!: WriteFile failed with rc %d", GetLastError()));
    345   }
    346 
    347   return ret;
     388    }
     389
     390    return ret;
    348391}
    349392/*****************************************************************************
    … …  
    370413                                 LPOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine)
    371414{
    372   dprintf(("KERNEL32:HMDeviceCommClass::ReadFile %s(%08x,%08x,%08x,%08x,%08x)",
    373            lpHMDeviceName,
    374            pHMHandleData->hHMHandle,
    375            lpBuffer,
    376            nNumberOfBytesToRead,
    377            lpNumberOfBytesRead,
    378            lpOverlapped));
    379 
    380   BOOL  ret;
    381   ULONG ulBytesRead;
    382 
    383   if((pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED) && !lpOverlapped) {
    384     dprintf(("FILE_FLAG_OVERLAPPED flag set, but lpOverlapped NULL!!"));
    385     ::SetLastError(ERROR_INVALID_PARAMETER);
    386     return FALSE;
    387   }
    388   if(!(pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED) && lpOverlapped) {
    389     dprintf(("!WARNING!: lpOverlapped != NULL & !FILE_FLAG_OVERLAPPED; sync operation"));
    390   }
    391 
    392   if(lpCompletionRoutine) {
    393       dprintf(("!WARNING!: lpCompletionRoutine not supported -> fall back to sync IO"));
    394   }
    395 
    396   RXQUEUE qInfo;
    397   ULONG ulLen = sizeof(qInfo);
    398   ULONG rc = OSLibDosDevIOCtl( pHMHandleData->hHMHandle,
    399                         IOCTL_ASYNC,
    400                         ASYNC_GETINQUECOUNT,
    401                         0,0,0,
    402                         &qInfo,ulLen,&ulLen);
    403   dprintf(("ASYNC_GETINQUECOUNT -> qInfo.cch %d (queue size %d) rc %d", qInfo.cch, qInfo.cb, rc));
    404 
    405   ret = OSLibDosRead(pHMHandleData->hHMHandle, (LPVOID)lpBuffer, nNumberOfBytesToRead,
    406                      &ulBytesRead);
    407 
    408   if(lpNumberOfBytesRead) {
    409        *lpNumberOfBytesRead = (ret) ? ulBytesRead : 0;
    410        dprintf2(("KERNEL32:HMDeviceCommClass::ReadFile %d bytes read", *lpNumberOfBytesRead));
    411   }
    412   if(ret == FALSE) {
    413        dprintf(("!ERROR!: ReadFile failed with rc %d", GetLastError()));
    414   }
    415   else {
    416 //testestestest
    417       dprintf2(("%d Bytes read:", ulBytesRead));
    418       for(int i=0;i<ulBytesRead;i++) {
    419           dprintf2(("%x %c", ((char *)lpBuffer)[i], ((char *)lpBuffer)[i]));
    420       }
    421 //testestestset
    422   }
    423   return ret;
    424 }
    425 
     415    PHMDEVCOMDATA pDevData = (PHMDEVCOMDATA)pHMHandleData->lpHandlerData;
     416    BOOL  ret;
     417    ULONG ulBytesRead;
     418
     419    dprintf(("KERNEL32:HMDeviceCommClass::ReadFile %s(%08x,%08x,%08x,%08x,%08x)",
     420             lpHMDeviceName, pHMHandleData->hHMHandle, lpBuffer, nNumberOfBytesToRead,
     421             lpNumberOfBytesRead, lpOverlapped));
     422
     423    if((NULL==pDevData) || (pDevData->ulMagic != MAGIC_COM) )
     424    {
     425        ::SetLastError(ERROR_INVALID_HANDLE);
     426        return FALSE;
     427    }
     428
     429    if((pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED) && !lpOverlapped) {
     430        dprintf(("FILE_FLAG_OVERLAPPED flag set, but lpOverlapped NULL!!"));
     431        ::SetLastError(ERROR_INVALID_PARAMETER);
     432        return FALSE;
     433    }
     434    if(!(pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED) && lpOverlapped) {
     435        dprintf(("!WARNING!: lpOverlapped != NULL & !FILE_FLAG_OVERLAPPED; sync operation"));
     436    }
     437
     438    if(lpCompletionRoutine) {
     439        dprintf(("!WARNING!: lpCompletionRoutine not supported -> fall back to sync IO"));
     440    }
     441
     442    if(pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED) {
     443        return pDevData->iohandler->ReadFile(pHMHandleData->hWin32Handle, lpBuffer, nNumberOfBytesToRead,
     444                                             lpNumberOfBytesRead, lpOverlapped, lpCompletionRoutine, (DWORD)pDevData);
     445    }
     446
     447    RXQUEUE qInfo;
     448    ULONG ulLen = sizeof(qInfo);
     449    ULONG rc = OSLibDosDevIOCtl(pHMHandleData->hHMHandle,
     450                                IOCTL_ASYNC,
     451                                ASYNC_GETINQUECOUNT,
     452                                0,0,0,
     453                                &qInfo,ulLen,&ulLen);
     454    dprintf(("ASYNC_GETINQUECOUNT -> qInfo.cch %d (queue size %d) rc %d", qInfo.cch, qInfo.cb, rc));
     455
     456    ret = OSLibDosRead(pHMHandleData->hHMHandle, (LPVOID)lpBuffer, nNumberOfBytesToRead,
     457                       &ulBytesRead);
     458
     459    if(lpNumberOfBytesRead) {
     460        *lpNumberOfBytesRead = (ret) ? ulBytesRead : 0;
     461        dprintf2(("KERNEL32:HMDeviceCommClass::ReadFile %d bytes read", *lpNumberOfBytesRead));
     462    }
     463    if(ret == FALSE) {
     464        dprintf(("!ERROR!: ReadFile failed with rc %d", GetLastError()));
     465    }
     466    else {
     467        //testestestest
     468        dprintf2(("%d Bytes read:", ulBytesRead));
     469        for(int i=0;i<ulBytesRead;i++) {
     470            dprintf2(("%x %c", ((char *)lpBuffer)[i], ((char *)lpBuffer)[i]));
     471        }
     472        //testestestset
     473    }
     474    return ret;
     475}
    426476/*****************************************************************************
    427477 * Name      : DWORD HMDeviceHandler::SetupComm
    … …  
    439489                                   DWORD dwOutQueue)
    440490{
    441   dprintf(("HMDeviceCommClass::SetupComm "));
    442   PHMDEVCOMDATA pDevData = (PHMDEVCOMDATA)pHMHandleData->lpHandlerData;
    443   if((NULL==pDevData) || (pDevData->ulMagic != MAGIC_COM) )
    444   {
    445       ::SetLastError(ERROR_INVALID_HANDLE);
    446       return FALSE;
    447   }
    448   pDevData->dwInBuffer  = dwInQueue;
    449   pDevData->dwOutBuffer = dwOutQueue;
    450 
    451   return(TRUE);
    452 }
    453 //******************************************************************************
    454 #define TIMEOUT_COMM 50
     491    PHMDEVCOMDATA pDevData = (PHMDEVCOMDATA)pHMHandleData->lpHandlerData;
     492
     493    dprintf(("HMDeviceCommClass::SetupComm "));
     494    if((NULL==pDevData) || (pDevData->ulMagic != MAGIC_COM) )
     495    {
     496        ::SetLastError(ERROR_INVALID_HANDLE);
     497        return FALSE;
     498    }
     499    pDevData->dwInBuffer  = dwInQueue;
     500    pDevData->dwOutBuffer = dwOutQueue;
     501
     502    return(TRUE);
     503}
     504//******************************************************************************
    455505//******************************************************************************
    456506BOOL HMDeviceCommClass::WaitCommEvent( PHMHANDLEDATA pHMHandleData,
    … …  
    458508                                       LPOVERLAPPED lpo)
    459509{
    460   APIRET rc;
    461   ULONG ulLen;
    462   USHORT COMEvt;
    463   DWORD dwEvent,dwMask;
    464 
    465   PHMDEVCOMDATA pDevData = (PHMDEVCOMDATA)pHMHandleData->lpHandlerData;
    466 
    467   dprintf(("HMDeviceCommClass::WaitCommEvent %x %x %x", pHMHandleData->hHMHandle, lpfdwEvtMask, lpo));
    468 
    469   if((pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED) && !lpo) {
    470       dprintf(("!WARNING! pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED) && !lpo"));
    471       ::SetLastError(ERROR_INVALID_PARAMETER);
    472       return FALSE;
    473   }
    474 
    475   ulLen = sizeof(CHAR);
    476 
    477   dwEvent = 0;
    478   rc = 0;
    479   ulLen = sizeof(COMEvt);
    480   dwMask = pDevData->dwEventMask;
    481   while( (0==rc) &&
    482         !(dwEvent & dwMask) &&
    483         (dwMask ==pDevData->dwEventMask) ) // Exit if the Mask gets changed
    484   {
    485     rc = OSLibDosDevIOCtl(pHMHandleData->hHMHandle,
    486                           IOCTL_ASYNC,
    487                           ASYNC_GETCOMMEVENT,
    488                           0,0,0,
    489                           &COMEvt,ulLen,&ulLen);
    490     if(!rc)
     510    APIRET rc;
     511    ULONG ulLen;
     512    USHORT COMEvt;
     513    DWORD dwEvent,dwMask;
     514
     515    PHMDEVCOMDATA pDevData = (PHMDEVCOMDATA)pHMHandleData->lpHandlerData;
     516
     517    dprintf(("HMDeviceCommClass::WaitCommEvent %x %x %x", pHMHandleData->hHMHandle, lpfdwEvtMask, lpo));
     518
     519    if((pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED) && !lpo) {
     520        dprintf(("!WARNING! pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED) && !lpo"));
     521        ::SetLastError(ERROR_INVALID_PARAMETER);
     522        return FALSE;
     523    }
     524
     525    ulLen = sizeof(CHAR);
     526
     527    dwEvent = 0;
     528    rc = 0;
     529    ulLen = sizeof(COMEvt);
     530    dwMask = pDevData->dwEventMask;
     531    while( (0==rc) &&
     532           !(dwEvent & dwMask) &&
     533           (dwMask ==pDevData->dwEventMask) ) // Exit if the Mask gets changed
    491534    {
    492         dwEvent |= (COMEvt&0x0001)? EV_RXCHAR:0;
    493         //dwEvent |= (COMEvt&0x0002)? 0:0;
    494         dwEvent |= (COMEvt&0x0004)? EV_TXEMPTY:0;
    495         dwEvent |= (COMEvt&0x0008)? EV_CTS:0;
    496         dwEvent |= (COMEvt&0x0010)? EV_DSR:0;
    497         //dwEvent |= (COMEvt&0x0020)? 0:0; DCS = RLSD?
    498         dwEvent |= (COMEvt&0x0040)? EV_BREAK:0;
    499         dwEvent |= (COMEvt&0x0080)? EV_ERR:0;
    500         dwEvent |= (COMEvt&0x0100)? EV_RING:0;
    501         if((dwEvent & dwMask)) break;
    502     }
    503     else break;
    504 
    505     if(pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED)
    506     {
    507         memcpy(&pDevData->overlapped, lpo, sizeof(pDevData->overlapped));
    508         pDevData->overlapped.Internal     = 0;
    509         pDevData->overlapped.InternalHigh = 0;
    510         pDevData->overlapped.Offset       = 0;
    511         pDevData->overlapped.OffsetHigh   = 0;
    512         //We're also supposed to write the result to the address supplied
    513         //by this call
    514         pDevData->lpfdwEvtMask            = lpfdwEvtMask;
    515         //Set app event semaphore to non-signalled state
    516         ::ResetEvent(lpo->hEvent);
    517 
    518         ::SetLastError(ERROR_IO_PENDING);
    519         return FALSE;
    520     }
    521     DosSleep(TIMEOUT_COMM);
    522   }
    523   if(dwMask == pDevData->dwEventMask) {
    524        *lpfdwEvtMask = (rc==0) ? (dwEvent & dwMask) : 0;
    525        dprintf(("WaitCommEvent returned %x", *lpfdwEvtMask));
    526   }
    527   else  *lpfdwEvtMask = 0;
    528 
    529   ::SetLastError(rc);
    530   return (rc==0);
     535        rc = OSLibDosDevIOCtl(pHMHandleData->hHMHandle,
     536                              IOCTL_ASYNC,
     537                              ASYNC_GETCOMMEVENT,
     538                              0,0,0,
     539                              &COMEvt,ulLen,&ulLen);
     540        if(!rc)
     541        {
     542            dwEvent |= (COMEvt&0x0001)? EV_RXCHAR:0;
     543            //dwEvent |= (COMEvt&0x0002)? 0:0;
     544            dwEvent |= (COMEvt&0x0004)? EV_TXEMPTY:0;
     545            dwEvent |= (COMEvt&0x0008)? EV_CTS:0;
     546            dwEvent |= (COMEvt&0x0010)? EV_DSR:0;
     547            //dwEvent |= (COMEvt&0x0020)? 0:0; DCS = RLSD?
     548            dwEvent |= (COMEvt&0x0040)? EV_BREAK:0;
     549            dwEvent |= (COMEvt&0x0080)? EV_ERR:0;
     550            dwEvent |= (COMEvt&0x0100)? EV_RING:0;
     551            if((dwEvent & dwMask)) break;
     552        }
     553        else break;
     554
     555        if(pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED)
     556        {
     557            return pDevData->iohandler->WaitForEvent(pHMHandleData->hWin32Handle, lpfdwEvtMask,
     558                                                     lpo, NULL, (DWORD)pDevData);
     559        }
     560        DosSleep(TIMEOUT_COMM);
     561    }
     562    if(dwMask == pDevData->dwEventMask) {
     563        *lpfdwEvtMask = (rc==0) ? (dwEvent & dwMask) : 0;
     564        dprintf(("WaitCommEvent returned %x", *lpfdwEvtMask));
     565    }
     566    else  *lpfdwEvtMask = 0;
     567
     568    ::SetLastError(rc);
     569    return (rc==0);
    531570}
    532571/*****************************************************************************
    … …  
    550589    }
    551590
    552     //signal serial thread to cancel pending IO operation
    553     pDevData->fCancelIo = TRUE;
    554 //    ::SetEvent(pDevData->hEventSem);
    555 
    556     ::SetLastError(ERROR_SUCCESS);
    557     return(TRUE);
     591    return pDevData->iohandler->CancelIo(pHMHandleData->hWin32Handle);
    558592}
    559593/*****************************************************************************
    … …  
    572606 *****************************************************************************/
    573607BOOL HMDeviceCommClass::GetOverlappedResult(PHMHANDLEDATA pHMHandleData,
    574                                             LPOVERLAPPED  lpoOverlapped,
     608                                            LPOVERLAPPED  lpOverlapped,
    575609                                            LPDWORD       lpcbTransfer,
    576610                                            BOOL          fWait)
    … …  
    578612  PHMDEVCOMDATA pDevData = (PHMDEVCOMDATA)pHMHandleData->lpHandlerData;
    579613
    580   dprintf(("KERNEL32-WARNING: HMDeviceCommClass::GetOverlappedResult(%08xh,%08xh,%08xh,%08xh) partly implemented",
    581             pHMHandleData->hHMHandle,
    582             lpoOverlapped,
    583             lpcbTransfer,
    584             fWait));
    585 
    586   if(pDevData == NULL || !(pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED)) {
    587       ::SetLastError(ERROR_ACCESS_DENIED); //todo: wrong error?
    588       return FALSE;
    589   }
    590   if(!lpoOverlapped) {
    591       ::SetLastError(ERROR_INVALID_PARAMETER);
    592       return FALSE;
    593   }
    594   if(lpoOverlapped->hEvent != pDevData->overlapped.hEvent) {
    595       dprintf(("!WARNING!: GetOverlappedResult called for unknown operation"));
    596       ::SetLastError(ERROR_ACCESS_DENIED); //todo: wrong error?
    597       return FALSE;
    598   }
    599   if(pDevData->overlapped.Internal) {
    600       lpoOverlapped->Internal       = pDevData->overlapped.Internal;
    601       pDevData->overlapped.Internal = 0; //not entirely safe
    602       pDevData->dwLastError         = 0;
    603       ::SetLastError(pDevData->dwLastError);
    604       return lpoOverlapped->Internal;
    605   }
    606   if(fWait) {
    607       ::WaitForSingleObject(pDevData->overlapped.hEvent, INFINITE);
    608       ::ResetEvent(pDevData->overlapped.hEvent);
    609       lpoOverlapped->Internal       = pDevData->overlapped.Internal;
    610       pDevData->overlapped.Internal = 0; //not entirely safe
    611       ::SetLastError(ERROR_SUCCESS);
    612       return lpoOverlapped->Internal;
    613   }
    614   else {
    615       ::SetLastError(ERROR_IO_PENDING);
    616       return FALSE;
    617   }
    618 }
    619 //******************************************************************************
    620 //******************************************************************************
    621 BOOL HMDeviceCommClass::GetCommProperties( PHMHANDLEDATA pHMHandleData,
    622                                            LPCOMMPROP lpcmmp)
     614    dprintf(("KERNEL32-WARNING: HMDeviceCommClass::GetOverlappedResult(%08xh,%08xh,%08xh,%08xh) partly implemented",
     615             pHMHandleData->hHMHandle, lpOverlapped, lpcbTransfer, fWait));
     616
     617    if(!(pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED)) {
     618        dprintf(("!WARNING!: GetOverlappedResult called for a handle that wasn't opened with FILE_FLAG_OVERLAPPED"));
     619        return TRUE; //NT4, SP6 doesn't fail
     620    }
     621
     622    if(pDevData == NULL) {
     623        ::SetLastError(ERROR_ACCESS_DENIED); //todo: wrong error?
     624        return FALSE;
     625    }
     626    if(!lpOverlapped) {
     627        ::SetLastError(ERROR_INVALID_PARAMETER);
     628        return FALSE;
     629    }
     630    return pDevData->iohandler->GetOverlappedResult(pHMHandleData->hWin32Handle, lpOverlapped, lpcbTransfer, fWait);
     631}
     632//******************************************************************************
     633//******************************************************************************
     634BOOL HMDeviceCommClass::GetCommProperties(PHMHANDLEDATA pHMHandleData,
     635                                          LPCOMMPROP lpcmmp)
    623636{
    624637  EXTBAUDGET BaudInfo;
    … …  
    719732  }
    720733  if(rc) {
    721       dprintf(("!WARNING! OSLibDosDevIOCtl failed with rc %d", rc)); 
     734      dprintf(("!WARNING! OSLibDosDevIOCtl failed with rc %d", rc));
    722735  }
    723736  return (rc == ERROR_SUCCESS);
    … …  
    980993  }
    981994  if( (0==pDevData->CommTOuts.WriteTotalTimeoutMultiplier) &&
    982       (0==pDevData->CommTOuts.WriteTotalTimeoutConstant)) 
     995      (0==pDevData->CommTOuts.WriteTotalTimeoutConstant))
    983996  {//no timeout used for writing
    984997    os2dcb.fbTimeOut |= 1; //write infinite timeout
    … …  
    14231436//******************************************************************************
    14241437//******************************************************************************
    1425 
    1426 
     1438void HMDeviceCommClass::CloseOverlappedIOHandlers()
     1439{
     1440    for(int i=0;i<MAX_COMPORTS;i++) {
     1441        if(handler[i]) {
     1442            delete handler[i];
     1443            handler[i] = NULL;
     1444        }
     1445    }
     1446}
     1447//******************************************************************************
     1448//******************************************************************************
     1449OverlappedIOHandler *HMDeviceCommClass::handler[MAX_COMPORTS] = {NULL};
     1450

  • trunk/src/kernel32/hmcomm.h

    r7549 r7564  
    1 /* $Id: hmcomm.h,v 1.12 2001-12-05 14:15:59 sandervl Exp $ */
     1/* $Id: hmcomm.h,v 1.13 2001-12-07 11:28:10 sandervl Exp $ */
    22
    33/*
    … …  
    1313#define _HM_COMM_H_
    1414
    15 #define MAGIC_COM 0x12abcd34
     15#include <handlemanager.h>
     16#include "hmdevice.h"
     17#include "overlappedio.h"
     18
     19#define MAX_COMPORTS        8
     20#define MAGIC_COM           0x12abcd34
     21
     22#define TIMEOUT_COMM        50
    1623
    1724typedef struct
    … …  
    8491typedef struct _HMDEVCOMDATA
    8592{
    86   ULONG ulMagic;
     93  ULONG                 ulMagic;
    8794  // Win32 Device Control Block
    88   COMMCONFIG   CommCfg;
    89   COMMTIMEOUTS CommTOuts;
    90   DWORD dwInBuffer, dwOutBuffer;
    91   DWORD dwEventMask;
    92   OVERLAPPED overlapped;
    93   DWORD *lpfdwEvtMask;
    94   BOOL fCancelIo;
    95   DWORD dwLastError;
     95  COMMCONFIG            CommCfg;
     96  COMMTIMEOUTS          CommTOuts;
     97  DWORD                 dwInBuffer;
     98  DWORD                 dwOutBuffer;
     99  DWORD                 dwEventMask;
     100  OverlappedIOHandler  *iohandler;
    96101  //OS/2 Device Control Block
    97   DCBINFO dcbOS2;
     102  DCBINFO               dcbOS2;
    98103} HMDEVCOMDATA, *PHMDEVCOMDATA;
    99104
    … …  
    115120} EXTBAUDSET, *PEXTBAUDSET;
    116121#pragma pack()
     122
     123
    117124
    118125class HMDeviceCommClass : public HMDeviceHandler
    … …  
    209216                                   BOOL          arg4);
    210217
     218  static void CloseOverlappedIOHandlers();
     219
    211220  private:
     221
    212222  APIRET SetLine( PHMHANDLEDATA pHMHandleData,
    213223                  UCHAR ucSize,UCHAR Parity, UCHAR Stop);
    … …  
    222232  APIRET SetBaud( PHMHANDLEDATA pHMHandleData,
    223233                  DWORD dwNewBaud);
     234
     235
     236    static OverlappedIOHandler *handler[MAX_COMPORTS];
    224237};
    225238

  • trunk/src/kernel32/hmparport.cpp

    r7550 r7564  
    1 /* $Id: hmparport.cpp,v 1.17 2001-12-05 18:06:02 sandervl Exp $ */
     1/* $Id: hmparport.cpp,v 1.18 2001-12-07 11:28:10 sandervl Exp $ */
    22
    33/*
    … …  
    4848#define PRT_QUERDEVICEID                   0x0074
    4949
    50 
    51 #if 0
    52 #pragma pack(1)
    53 typedef struct _DCBINFO
    54 {
    55   USHORT   usWriteTimeout;         /*  Time period used for Write Timeout processing. */
    56   USHORT   usReadTimeout;          /*  Time period used for Read Timeout processing. */
    57   BYTE     fbCtlHndShake;          /*  HandShake Control flag. */
    58   BYTE     fbFlowReplace;          /*  Flow Control flag. */
    59   BYTE     fbTimeOut;              /*  Timeout flag. */
    60   BYTE     bErrorReplacementChar;  /*  Error Replacement Character. */
    61   BYTE     bBreakReplacementChar;  /*  Break Replacement Character. */
    62   BYTE     bXONChar;               /*  Character XON. */
    63   BYTE     bXOFFChar;              /*  Character XOFF. */
    64 } DCBINFO;
    65 typedef DCBINFO *PDCBINFO;
    66 
    67 
    68 typedef struct _RXQUEUE
    69 {
    70   USHORT   cch;  /*  Number of characters in the queue. */
    71   USHORT   cb;   /*  Size of receive/transmit queue. */
    72 } RXQUEUE;
    73 
    74 typedef RXQUEUE *PRXQUEUE;
    75 
    76 
    77 typedef struct _MODEMSTATUS
    78 {
    79   BYTE   fbModemOn;   /*  Modem Control Signals ON Mask. */
    80   BYTE   fbModemOff;  /*  Modem Control Signals OFF Mask. */
    81 } MODEMSTATUS;
    82 
    83 typedef MODEMSTATUS *PMODEMSTATUS;
    84 
    85 
    86 #pragma pack()
    87 
    88 
    89 #endif
    90 
    91 
    9250// Hardwired parallel port configuration information.
    9351// @@@PH better query the Resource Manager
    … …  
    12179} HMDEVPARPORTDATA, *PHMDEVPARPORTDATA;
    12280
     81//******************************************************************************
     82//******************************************************************************
    12383static VOID *CreateDevData()
    12484{
    … …  
    13595  return pData;
    13696}
    137 
    138 
     97//******************************************************************************
     98//******************************************************************************
    13999HMDeviceParPortClass::HMDeviceParPortClass(LPCSTR lpDeviceName) :
    140100  HMDeviceHandler(lpDeviceName)
    … …  
    231191  return FALSE;
    232192}
    233 
     193//******************************************************************************
     194//******************************************************************************
    234195DWORD HMDeviceParPortClass::CreateFile(LPCSTR lpFileName,
    235196                                       PHMHANDLEDATA pHMHandleData,
    … …  
    298259}
    299260
    300 
    301                       /* this is a handler method for calls to CloseHandle() */
     261/*****************************************************************************
     262 * Name      : DWORD HMDeviceParPortClass::GetFileType
     263 * Purpose   : determine the handle type
     264 * Parameters: PHMHANDLEDATA pHMHandleData
     265 * Variables :
     266 * Result    : API returncode
     267 * Remark    :
     268 * Status    :
     269 *
     270 * Author    : SvL
     271 *****************************************************************************/
     272
     273DWORD HMDeviceParPortClass::GetFileType(PHMHANDLEDATA pHMHandleData)
     274{
     275    dprintf(("KERNEL32: HMDeviceParPortClass::GetFileType %s(%08x)\n",
     276             lpHMDeviceName, pHMHandleData));
     277
     278    return FILE_TYPE_PIPE; //this is what NT4 returns
     279}
     280//******************************************************************************
     281/* this is a handler method for calls to CloseHandle() */
     282//******************************************************************************
    302283BOOL HMDeviceParPortClass::CloseHandle(PHMHANDLEDATA pHMHandleData)
    303284{
    … …  
    426407  return ret;
    427408}
    428 
    429 BOOL HMDeviceParPortClass::GetCommProperties( PHMHANDLEDATA pHMHandleData,
    430                                              LPCOMMPROP lpcmmp)
    431 {
    432   dprintf(("HMDeviceParPortClass::GetCommProperties(%08xh, %08xh)\n",
    433            pHMHandleData,
    434            lpcmmp));
    435  
    436   APIRET rc;
    437   ULONG ulLen;
    438   int i;
    439  
    440 #if 0
    441   USHORT COMErr;
    442   EXTBAUDGET BaudInfo;
    443   ulLen = sizeof(EXTBAUDGET);
    444   rc = OSLibDosDevIOCtl( pHMHandleData->hHMHandle,
    445                     IOCTL_ASYNC,
    446                     ASYNC_EXTGETBAUDRATE,
    447                     0,0,0,
    448                         &BaudInfo,ulLen,&ulLen);
    449 #endif
    450   rc = NO_ERROR;
    451  
    452   memset(lpcmmp,0,sizeof(COMMPROP));
    453   lpcmmp->wPacketLength  = sizeof(COMMPROP);
    454   lpcmmp->wPacketVersion = 1; //???
    455   lpcmmp->dwProvSubType =  PST_PARALLELPORT;
    456  
    457 #if 0
    458   lpcmmp->dwServiceMask  = SP_SERIALCOMM;
    459   for(i=0;i<BaudTableSize && BaudInfo.ulMaxBaud <= BaudTable[i].dwBaudRate;i++);
    460   lpcmmp->dwMaxBaud      = BaudTable[i].dwBaudFlag;
    461   lpcmmp->dwProvCapabilities = PCF_DTRDSR | PCF_PARITY_CHECK |
    462                                PCF_RTSCTS | PCF_SETXCHAR |
    463                                PCF_XONXOFF;
    464   lpcmmp->dwSettableParams   = SP_BAUD | SP_DATABITS |
    465                                SP_HANDSHAKEING | SP_PARITY |
    466                                SP_PARITY_CHECK | SP_STOPBIT;
    467   lpcmmp->dwSettableBaud = 0;
    468   for(i=0;i<BaudTableSize;i++)
    469   {
    470     if ( (BaudTable[i].dwBaudRate>=BaudInfo.ulMinBaud) &&
    471          (BaudTable[i].dwBaudRate<=BaudInfo.ulMaxBaud) )
    472       lpcmmp->dwSettableBaud |= BaudTable[i].dwBaudFlag;
    473   }
    474   lpcmmp->dwSettableBaud |= BAUD_USER;
    475   lpcmmp->wSettableData = DATABITS_5 | DATABITS_6 | DATABITS_7 | DATABITS_8;
    476   lpcmmp->wSettableStopParity = STOPBITS_10 | STOPBITS_15 | STOPBITS_20 |
    477                                 PARITY_NONE | PARITY_ODD | PARITY_EVEN |
    478     PARITY_MARK | PARITY_SPACE;
    479 #endif
    480  
    481   return(rc==0);
    482 }
    483 
    484 BOOL HMDeviceParPortClass::ClearCommError( PHMHANDLEDATA pHMHandleData,
    485                                           LPDWORD lpdwErrors,
    486                                           LPCOMSTAT lpcst)
    487 {
    488   dprintf(("HMDeviceParPortClass::ClearCommError(%08xh,%08xh,%08xh)\n",
    489            pHMHandleData,
    490            lpdwErrors,
    491            lpcst));
    492  
    493   APIRET rc;
    494   ULONG ulLen;
    495   USHORT COMErr;
    496 
    497   ulLen = sizeof(USHORT);
    498  
    499   *lpdwErrors = 0;
    500   rc = NO_ERROR;
    501  
    502 #if 0
    503   // ParPort: CE_DNS, CE_OOP CE_PTO
    504  
    505   rc = OSLibDosDevIOCtl( pHMHandleData->hHMHandle,
    506                     IOCTL_ASYNC,
    507                     ASYNC_GETCOMMERROR,
    508                     0,0,0,
    509                     &COMErr,2,&ulLen);
    510   *lpdwErrors |= (COMErr & 0x0001)?CE_OVERRUN:0;
    511   *lpdwErrors |= (COMErr & 0x0002)?CE_RXOVER:0;
    512   *lpdwErrors |= (COMErr & 0x0004)?CE_RXPARITY:0;
    513   *lpdwErrors |= (COMErr & 0x0008)?CE_FRAME:0;
    514 
    515   if(lpcst)
    516   {
    517     UCHAR ucStatus;
    518     RXQUEUE qInfo;
    519     ulLen = 1;
    520     rc = OSLibDosDevIOCtl( pHMHandleData->hHMHandle,
    521                       IOCTL_ASYNC,
    522                       ASYNC_GETCOMMSTATUS,
    523                       0,0,0,
    524                       &ucStatus,ulLen,&ulLen);
    525     if(!rc)
    526     {
    527       lpcst->fCtsHold  = ((ucStatus & 0x01)>0);
    528       lpcst->fDsrHold  = ((ucStatus & 0x02)>0);
    529       lpcst->fRlsdHold = FALSE;//(ucStatus & 0x04)>0);
    530       lpcst->fXoffHold = ((ucStatus & 0x08)>0);
    531       lpcst->fXoffSend = ((ucStatus & 0x10)>0);
    532       lpcst->fEof      = ((ucStatus & 0x20)>0);// Is break = Eof ??
    533       lpcst->fTxim     = ((ucStatus & 0x40)>0);
    534 
    535       ulLen = sizeof(qInfo);
    536       rc = OSLibDosDevIOCtl( pHMHandleData->hHMHandle,
    537                         IOCTL_ASYNC,
    538                         ASYNC_GETINQUECOUNT,
    539                         0,0,0,
    540                         &qInfo,ulLen,&ulLen);
    541       if(!rc)
    542       {
    543         lpcst->cbInQue   = qInfo.cch;
    544         rc = OSLibDosDevIOCtl( pHMHandleData->hHMHandle,
    545                           IOCTL_ASYNC,
    546                           ASYNC_GETOUTQUECOUNT,
    547                           0,0,0,
    548                           &qInfo,ulLen,&ulLen);
    549         if(!rc)
    550           lpcst->cbOutQue = qInfo.cch;
    551       }
    552     }
    553   }
    554 #endif
    555  
    556   return(rc==NO_ERROR);
    557 }
    558 
    559 
     409//******************************************************************************
     410//******************************************************************************
    560411BOOL HMDeviceParPortClass::DeviceIoControl(PHMHANDLEDATA pHMHandleData,
    561412                                           DWORD dwIoControlCode,
    … …  
    719570    return FALSE;
    720571}
    721 
    722 
    723 BOOL HMDeviceParPortClass::SetDefaultCommConfig( PHMHANDLEDATA pHMHandleData,
    724                                                 LPCOMMCONFIG lpCC,
    725                                                 DWORD dwSize)
    726 {
    727   dprintf(("HMDeviceParPortClass::SetDefaultCommConfig(%08xh,%08xh,%08xh)\n",
    728            pHMHandleData,
    729            lpCC,
    730            dwSize));
    731  
    732   PHMDEVPARPORTDATA pDevData = (PHMDEVPARPORTDATA)pHMHandleData->lpDeviceData;
    733   if((NULL==pDevData) || (pDevData->ulMagic != MAGIC_PARPORT) )
    734   {
    735     SetLastError(ERROR_INVALID_HANDLE);
    736     return FALSE;
    737   }
    738   memset(&pDevData->CommCfg,0, sizeof(COMMCONFIG));
    739   memcpy(&pDevData->CommCfg,lpCC,dwSize>sizeof(COMMCONFIG)?sizeof(COMMCONFIG):dwSize);
    740 
    741   return(TRUE);
    742 }
    743 
    744 
    745 BOOL HMDeviceParPortClass::GetDefaultCommConfig( PHMHANDLEDATA pHMHandleData,
    746                                                 LPCOMMCONFIG lpCC,
    747                                                 LPDWORD lpdwSize)
    748 {
    749   dprintf(("HMDeviceParPortClass::GetDefaultCommConfig(%08xh,%08xh,%08xh)\n",
    750            pHMHandleData,
    751            lpCC,
    752            lpdwSize));
    753 
    754  
    755   PHMDEVPARPORTDATA pDevData = (PHMDEVPARPORTDATA)pHMHandleData->lpDeviceData;
    756 
    757   if( O32_IsBadWritePtr(lpCC,sizeof(COMMCONFIG)) ||
    758       *lpdwSize< sizeof(COMMCONFIG) )
    759   {
    760     SetLastError(ERROR_INSUFFICIENT_BUFFER);
    761     *lpdwSize= sizeof(COMMCONFIG);
    762     return FALSE;
    763   }
    764 
    765   if((NULL==pDevData) || (pDevData->ulMagic != MAGIC_PARPORT) )
    766   {
    767     SetLastError(ERROR_INVALID_HANDLE);
    768     return FALSE;
    769   }
    770 
    771   memcpy(lpCC,&pDevData->CommCfg,sizeof(COMMCONFIG));
    772   *lpdwSize = sizeof(COMMCONFIG);
    773   return(TRUE);
    774 }
    775 
    776 
    777 BOOL HMDeviceParPortClass::SetCommConfig( PHMHANDLEDATA pHMHandleData,
    778                                          LPCOMMCONFIG lpCC,
    779                                          DWORD dwSize )
    780 {
    781   dprintf(("HMDeviceParPortClass::SetCommConfig not implemented"));
    782 
    783   return(TRUE);
    784 }
    785 
    786 
    787 BOOL HMDeviceParPortClass::GetCommConfig( PHMHANDLEDATA pHMHandleData,
    788                                          LPCOMMCONFIG lpCC,
    789                                          LPDWORD lpdwSize )
    790 {
    791   PHMDEVPARPORTDATA pDevData = (PHMDEVPARPORTDATA)pHMHandleData->lpHandlerData;
    792 
    793   dprintf(("HMDeviceParPortClass::GetCommConfig(%08xh,%08xh,%08xh)\n",
    794            pHMHandleData,
    795            lpCC,
    796            lpdwSize));
    797 
    798   if( O32_IsBadWritePtr(lpCC,sizeof(COMMCONFIG)) ||
    799       *lpdwSize< sizeof(COMMCONFIG) )
    800   {
    801     SetLastError(ERROR_INSUFFICIENT_BUFFER);
    802     *lpdwSize= sizeof(COMMCONFIG);
    803     return FALSE;
    804   }
    805 
    806   if((NULL==pDevData) || (pDevData->ulMagic != MAGIC_PARPORT) )
    807   {
    808     SetLastError(ERROR_INVALID_HANDLE);
    809     return FALSE;
    810   }
    811 
    812   memcpy(lpCC,&pDevData->CommCfg,sizeof(COMMCONFIG));
    813   *lpdwSize = sizeof(COMMCONFIG);
    814   return(TRUE);
    815 }
     572//******************************************************************************
     573//******************************************************************************
     574
     575

  • trunk/src/kernel32/hmparport.h

    r7549 r7564  
    1 /* $Id: hmparport.h,v 1.6 2001-12-05 14:16:05 sandervl Exp $ */
     1/* $Id: hmparport.h,v 1.7 2001-12-07 11:28:10 sandervl Exp $ */
    22
    33/*
    … …  
    2828                             PHMHANDLEDATA pHMHandleDataTemplate);
    2929
     30  /* this is a handler method for calls to GetFileType() */
     31  virtual DWORD GetFileType (PHMHANDLEDATA pHMHandleData);
     32
    3033  /* this is the handler method for calls to CloseHandle() */
    3134  virtual BOOL CloseHandle(PHMHANDLEDATA pHMHandleData);
    3235
    33   virtual BOOL GetCommProperties( PHMHANDLEDATA pHMHandleData,
    34                                  LPCOMMPROP lpcmmp);
    35  
    36   virtual BOOL ClearCommError( PHMHANDLEDATA pHMHandleData,
    37                                LPDWORD lpdwErrors,
    38                                LPCOMSTAT lpcst);
    39  
    40   virtual BOOL SetCommConfig( PHMHANDLEDATA pHMHandleData,
    41                               LPCOMMCONFIG lpCC,
    42                               DWORD dwSize );
    43  
    44   virtual BOOL GetCommConfig( PHMHANDLEDATA pHMHandleData,
    45                               LPCOMMCONFIG lpCC,
    46                               LPDWORD lpdwSize );
    47  
    48   virtual BOOL SetDefaultCommConfig( PHMHANDLEDATA pHMHandleData,
    49                                      LPCOMMCONFIG lpCC,
    50                                      DWORD dwSize);
    51  
    52   virtual BOOL GetDefaultCommConfig( PHMHANDLEDATA pHMHandleData,
    53                                      LPCOMMCONFIG lpCC,
    54                                      LPDWORD lpdwSize);
    55  
    5636  /* this is a handler method for calls to DeviceIoControl() */
    5737  virtual BOOL   DeviceIoControl    (PHMHANDLEDATA pHMHandleData, DWORD dwIoControlCode,

  • trunk/src/kernel32/initkernel32.cpp

    r7447 r7564  
    1 /* $Id: initkernel32.cpp,v 1.9 2001-11-24 13:55:57 sandervl Exp $
     1/* $Id: initkernel32.cpp,v 1.10 2001-12-07 11:28:11 sandervl Exp $
    22 *
    33 * KERNEL32 DLL entry point
    … …  
    4747#include "directory.h"
    4848#include "hmdevio.h"
     49#include "hmcomm.h"
    4950#include <windllbase.h>
    5051#include "winexepe2lx.h"
    … …  
    215216{
    216217    dprintf(("kernel32 exit %d\n", ulReason));
     218
     219    HMDeviceCommClass::CloseOverlappedIOHandlers();
     220
    217221    //Flush and delete all open memory mapped files
    218222    Win32MemMap::deleteAll();

  • trunk/src/kernel32/overlappedio.cpp

    r7560 r7564  
    1 /* $Id: overlappedio.cpp,v 1.5 2001-12-06 15:57:52 sandervl Exp $ */
     1/* $Id: overlappedio.cpp,v 1.6 2001-12-07 11:28:11 sandervl Exp $ */
    22
    33/*
    … …  
    2525//******************************************************************************
    2626//******************************************************************************
    27 OverlappedIOHandler::OverlappedIOHandler(LPOVERLAPPED_HANDLER lpReadHandler, 
    28                                          LPOVERLAPPED_HANDLER lpWriteHandler, 
     27OverlappedIOHandler::OverlappedIOHandler(LPOVERLAPPED_HANDLER lpReadHandler,
     28                                         LPOVERLAPPED_HANDLER lpWriteHandler,
    2929                                         LPOVERLAPPED_HANDLER lpPollHandler) :
    3030                   hThreadRead(0), hThreadWrite(0), hThreadPoll(0)
    … …  
    4949    hEventWrite  = ::CreateEventA(NULL, FALSE, FALSE, NULL);
    5050
    51     //the exit event semaphore is manual reset, because signalling this event
     51    //the exit event semaphore is manual reset, because this event
    5252    //must be able to wake up multiple threads
    5353    hEventExit   = ::CreateEventA(NULL, TRUE, FALSE, NULL);
    … …  
    5858        goto failed;
    5959    }
    60    
     60
    6161    DWORD dwThreadId;
    6262    LPOVERLAPPED_THREAD_PARAM threadparam;
    … …  
    8989    }
    9090
    91     if((lpPollHandler && !hThreadPoll) || !hThreadRead || (lpWriteHandler && !hThreadWrite)) 
     91    if((lpPollHandler && !hThreadPoll) || !hThreadRead || (lpWriteHandler && !hThreadWrite))
    9292    {
    9393        DebugInt3();
    … …  
    9797    return;
    9898
    99 outofmem: 
     99outofmem:
    100100    errcode = OutOfMemory;
    101101    //fall through
    102102failed:
    103     //SvL: NOTE: We might not fail gracefully when threads have already been 
     103    //SvL: NOTE: We might not fail gracefully when threads have already been
    104104    //           created. (thread accessing memory that has been freed)
    105105    //           Don't feel like wasting time to fix this as this should never
    … …  
    223223        case ASYNCIO_READ:
    224224        case ASYNCIO_READWRITE:
    225             lpReadHandler(lpRequest, &dwResult, NULL);
     225            lpReadHandler(lpRequest, &dwResult, NULL);
    226226            lpOverlapped->Internal     = lpRequest->dwLastError;
    227227            lpOverlapped->InternalHigh = dwResult;
    … …  
    235235
    236236        case ASYNCIO_WRITE:
    237             lpWriteHandler(lpRequest, &dwResult, NULL);
     237            lpWriteHandler(lpRequest, &dwResult, NULL);
    238238            lpOverlapped->Internal     = lpRequest->dwLastError;
    239239            lpOverlapped->InternalHigh = dwResult;
    … …  
    247247
    248248        case ASYNCIO_POLL:
    249             while(TRUE) 
     249            while(TRUE)
    250250            {
    251251                dwTimeOut = 0;
    … …  
    281281                                    LPOVERLAPPED  lpOverlapped,
    282282                                    LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine,
    283                                     DWORD         dwUserData)
     283                                    DWORD         dwUserData,
     284                                    DWORD         dwTimeOut)
    284285{
    285286    LPASYNCIOREQUEST lpRequest, current;
    … …  
    290291        return FALSE;
    291292    }
    292  
     293
    293294    lpRequest = new ASYNCIOREQUEST;
    294295    if(lpRequest == NULL) {
    … …  
    304305    lpRequest->lpCompletionRoutine = lpCompletionRoutine;
    305306    lpRequest->dwUserData          = dwUserData;
     307    lpRequest->dwTimeOut           = dwTimeOut;
    306308    lpRequest->next                = NULL;
    307309
    … …  
    322324    ::LeaveCriticalSection(&critsect);
    323325
    324     lpOverlapped->Internal     = STATUS_PENDING;
     326    lpOverlapped->Internal     = ERROR_IO_PENDING;
    325327    lpOverlapped->InternalHigh = 0;
    326328    lpOverlapped->Offset       = 0;
    … …  
    343345                                   LPOVERLAPPED  lpOverlapped,
    344346                                   LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine,
    345                                    DWORD         dwUserData)
     347                                   DWORD         dwUserData,
     348                                   DWORD         dwTimeOut)
    346349{
    347350    LPASYNCIOREQUEST lpRequest, current;
    … …  
    351354        return FALSE;
    352355    }
    353  
     356
    354357    lpRequest = new ASYNCIOREQUEST;
    355358    if(lpRequest == NULL) {
    … …  
    365368    lpRequest->lpCompletionRoutine = lpCompletionRoutine;
    366369    lpRequest->dwUserData          = dwUserData;
     370    lpRequest->dwTimeOut           = dwTimeOut;
    367371    lpRequest->next                = NULL;
    368372
    … …  
    378382    ::LeaveCriticalSection(&critsect);
    379383
    380     lpOverlapped->Internal     = STATUS_PENDING;
     384    lpOverlapped->Internal     = ERROR_IO_PENDING;
    381385    lpOverlapped->InternalHigh = 0;
    382386    lpOverlapped->Offset       = 0;
    … …  
    396400                                       LPOVERLAPPED  lpOverlapped,
    397401                                       LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine,
    398                                        DWORD         dwUserData)
     402                                       DWORD         dwUserData,
     403                                       DWORD         dwTimeOut)
    399404{
    400405    LPASYNCIOREQUEST lpRequest, current;
    … …  
    404409        return FALSE;
    405410    }
    406  
     411
    407412    lpRequest = new ASYNCIOREQUEST;
    408413    if(lpRequest == NULL) {
    … …  
    418423    lpRequest->lpCompletionRoutine = lpCompletionRoutine;
    419424    lpRequest->dwUserData          = dwUserData;
     425    lpRequest->dwTimeOut           = dwTimeOut;
    420426    lpRequest->next                = NULL;
    421427
    … …  
    431437    ::LeaveCriticalSection(&critsect);
    432438
    433     lpOverlapped->Internal     = STATUS_PENDING;
     439    lpOverlapped->Internal     = ERROR_IO_PENDING;
    434440    lpOverlapped->InternalHigh = 0;
    435441    lpOverlapped->Offset       = 0;
    … …  
    449455    LPASYNCIOREQUEST lpRequest;
    450456
    451     for(int i=ASYNC_INDEX_READ;i<NR_ASYNC_OPERATIONS;i++) 
     457    for(int i=ASYNC_INDEX_READ;i<NR_ASYNC_OPERATIONS;i++)
    452458    {
    453459        while(TRUE) {
    … …  
    468474                                              LPOVERLAPPED  lpOverlapped,
    469475                                              LPDWORD       lpcbTransfer,
    470                                               DWORD         dwTimeout)
     476                                              BOOL          fWait)
    471477{
    472478    DWORD ret;
    473479
    474     ret = ::WaitForSingleObject(lpOverlapped->hEvent, dwTimeout);
     480    ret = ::WaitForSingleObject(lpOverlapped->hEvent, (fWait) ? INFINITE : 0);
    475481
    476482    if(lpcbTransfer)
    … …  
    488494
    489495    ::EnterCriticalSection(&critsect);
    490     if(pending[index]) 
     496    if(pending[index])
    491497    {
    492         if(pending[index]->hHandle != hHandle) 
     498        if(pending[index]->hHandle != hHandle)
    493499        {
    494500            lpRequest = pending[index];

  • trunk/src/kernel32/overlappedio.h

    r7560 r7564  
    1 /* $Id: overlappedio.h,v 1.4 2001-12-06 15:57:52 sandervl Exp $ */
     1/* $Id: overlappedio.h,v 1.5 2001-12-07 11:28:11 sandervl Exp $ */
    22
    33/*
    … …  
    1313#define __OVERLAPPEDIO_H__
    1414
    15 #define NR_ASYNC_OPERATIONS     3
     15#define NR_ASYNC_OPERATIONS 3
    1616#define ASYNC_INDEX_READ        0
    1717#define ASYNC_INDEX_WRITE       1
    1818#define ASYNC_INDEX_POLL        2
    1919
    20 #define ASYNCIO_READ            1
    21 #define ASYNCIO_WRITE           2
    22 #define ASYNCIO_READWRITE       4
    23 #define ASYNCIO_POLL            8
     20#define ASYNCIO_READ        1
     21#define ASYNCIO_WRITE       2
     22#define ASYNCIO_READWRITE   4
     23#define ASYNCIO_POLL        8
    2424
    2525//forward decl
    … …  
    3535  HANDLE              hHandle;
    3636  LPCVOID             lpBuffer;
    37   ULONG               nNumberOfBytes;
     37  DWORD               nNumberOfBytes;
     38  DWORD               dwTimeOut;
    3839  LPOVERLAPPED        lpOverlapped;
    3940  LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine;
    … …  
    4445} ASYNCIOREQUEST, *LPASYNCIOREQUEST;
    4546
    46 typedef BOOL (* SYSTEM LPOVERLAPPED_HANDLER)(LPASYNCIOREQUEST lpRequest, DWORD *lpdwResult, DWORD *lpdwTimeOut);
     47typedef BOOL (* LPOVERLAPPED_HANDLER)(LPASYNCIOREQUEST lpRequest, DWORD *lpdwResult, DWORD *lpdwTimeOut);
    4748
    4849enum OverlappedIOError {
    … …  
    5354{
    5455public:
    55      OverlappedIOHandler(LPOVERLAPPED_HANDLER lpReadHandler, 
    56                          LPOVERLAPPED_HANDLER lpWriteHandler, 
     56     OverlappedIOHandler(LPOVERLAPPED_HANDLER lpReadHandler,
     57                         LPOVERLAPPED_HANDLER lpWriteHandler,
    5758                         LPOVERLAPPED_HANDLER lpPollHandler = NULL);
    5859    ~OverlappedIOHandler();
    … …  
    6465                      LPOVERLAPPED  lpOverlapped,
    6566                      LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine,
    66                       DWORD         dwUserData);
     67                      DWORD         dwUserData,
     68                      DWORD         dwTimeOut = INFINITE);
    6769
    6870     BOOL   ReadFile(HANDLE        hHandle,
    … …  
    7274                     LPOVERLAPPED  lpOverlapped,
    7375                     LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine,
    74                      DWORD         dwUserData);
     76                     DWORD         dwUserData,
     77                     DWORD         dwTimeOut = INFINITE);
    7578
    7679     BOOL   WaitForEvent(HANDLE        hHandle,
    … …  
    7881                         LPOVERLAPPED  lpOverlapped,
    7982                         LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine,
    80                          DWORD         dwUserData);
     83                         DWORD         dwUserData,
     84                         DWORD         dwTimeOut = INFINITE);
    8185
    8286     BOOL   CancelIo(HANDLE hHandle);
    … …  
    8589                                LPOVERLAPPED  lpoOverlapped,
    8690                                LPDWORD       lpcbTransfer,
    87                                 DWORD         dwTimeout);
     91                                BOOL          fWait);
    8892
    8993protected:

  • trunk/src/kernel32/wprocess.cpp

    r7532 r7564  
    1 /* $Id: wprocess.cpp,v 1.139 2001-12-03 12:13:10 sandervl Exp $ */
     1/* $Id: wprocess.cpp,v 1.140 2001-12-07 11:28:11 sandervl Exp $ */
    22
    33/*
    … …  
    3737#include "oslibmisc.h"
    3838#include "oslibdebug.h"
     39#include "hmcomm.h"
    3940
    4041#include "console.h"
    … …  
    424425    }
    425426
     427    HMDeviceCommClass::CloseOverlappedIOHandlers();
     428
    426429    //Note: Needs to be done after deleting WinExe (destruction of exe + dll objects)
    427430    //Flush and delete all open memory mapped files
Note: See TracChangeset for help on using the changeset viewer.