Ignore:
Timestamp:
Nov 28, 2001, 4:35:15 PM (24 years ago)
Author:
sandervl
Message:

com fixes

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/kernel32/hmcomm.cpp

    r7463 r7471  
    1 /* $Id: hmcomm.cpp,v 1.16 2001-11-27 12:33:23 sandervl Exp $ */
     1/* $Id: hmcomm.cpp,v 1.17 2001-11-28 15:35:15 sandervl Exp $ */
    22
    33/*
    … …  
    2727#include "dbglocal.h"
    2828
     29#undef dprintf
     30#define dprintf(a) WriteLog a
     31#undef dprintf2
     32#define dprintf2(a) WriteLog a
    2933
    3034BAUDTABLEENTRY BaudTable[] =
    … …  
    104108BOOL HMDeviceCommClass::FindDevice(LPCSTR lpClassDevName, LPCSTR lpDeviceName, int namelength)
    105109{
    106     dprintf(("HMDeviceCommClass::FindDevice %s %s", lpClassDevName, lpDeviceName));
     110    dprintf2(("HMDeviceCommClass::FindDevice %s %s", lpClassDevName, lpDeviceName));
    107111
    108112    if(namelength > 5) {
    109         if(lstrncmpA(lpDeviceName, "\\\\.\\", 4) != 0) {
     113        if(namelength != 9 || lstrncmpA(lpDeviceName, "\\\\.\\", 4) != 0) {
    110114            return FALSE;  //can't be com name
    111115        }
    … …  
    156160
    157161  //AH: TODO parse Win32 security handles
    158   ULONG oldmode = SetErrorMode(SEM_FAILCRITICALERRORS);
     162  ULONG oldmode = ::SetErrorMode(SEM_FAILCRITICALERRORS);
    159163  pHMHandleData->hHMHandle = OSLibDosOpen(comname,
    160164                                          OSLIB_ACCESS_READWRITE |
    161165                                          OSLIB_ACCESS_SHAREDENYREAD |
    162166                                          OSLIB_ACCESS_SHAREDENYWRITE);
    163   SetErrorMode(oldmode);
     167  ::SetErrorMode(oldmode);
    164168  if (pHMHandleData->hHMHandle != 0)
    165169  {
    … …  
    288292  if((pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED) && !lpOverlapped) {
    289293    dprintf(("FILE_FLAG_OVERLAPPED flag set, but lpOverlapped NULL!!"));
    290     SetLastError(ERROR_INVALID_PARAMETER);
     294    ::SetLastError(ERROR_INVALID_PARAMETER);
    291295    return FALSE;
    292296  }
    … …  
    300304  if(lpNumberOfBytesWritten) {
    301305       *lpNumberOfBytesWritten = (ret) ? ulBytesWritten : 0;
     306       dprintf2(("KERNEL32:HMDeviceCommClass::WriteFile %d bytes written", ulBytesWritten));
    302307  }
    303308  if(ret == FALSE) {
    … …  
    344349  if(!(pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED)) {
    345350      dprintf(("!WARNING!: Handle not created with FILE_FLAG_OVERLAPPED!"));
    346       SetLastError(ERROR_ACCESS_DENIED); //todo: right error?
     351      ::SetLastError(ERROR_ACCESS_DENIED); //todo: right error?
    347352      return FALSE;
    348353  }
    349354
    350   SetLastError(ERROR_INVALID_FUNCTION);
     355  ::SetLastError(ERROR_INVALID_FUNCTION);
    351356  return FALSE;
    352357}
    … …  
    386391  if((pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED) && !lpOverlapped) {
    387392    dprintf(("FILE_FLAG_OVERLAPPED flag set, but lpOverlapped NULL!!"));
    388     SetLastError(ERROR_INVALID_PARAMETER);
     393    ::SetLastError(ERROR_INVALID_PARAMETER);
    389394    return FALSE;
    390395  }
    … …  
    398403  if(lpNumberOfBytesRead) {
    399404       *lpNumberOfBytesRead = (ret) ? ulBytesRead : 0;
     405       dprintf2(("KERNEL32:HMDeviceCommClass::ReadFile %d bytes read", ulBytesRead));
    400406  }
    401407  if(ret == FALSE) {
    … …  
    443449  if(!(pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED)) {
    444450      dprintf(("!WARNING!: Handle not created with FILE_FLAG_OVERLAPPED!"));
    445       SetLastError(ERROR_ACCESS_DENIED); //todo: right error?
     451      ::SetLastError(ERROR_ACCESS_DENIED); //todo: right error?
    446452      return FALSE;
    447453  }
    448454
    449   SetLastError(ERROR_INVALID_FUNCTION);
     455  ::SetLastError(ERROR_INVALID_FUNCTION);
    450456  return FALSE;
    451457}
    … …  
    469475  if((NULL==pDevData) || (pDevData->ulMagic != MAGIC_COM) )
    470476  {
    471       SetLastError(ERROR_INVALID_HANDLE);
     477      ::SetLastError(ERROR_INVALID_HANDLE);
    472478      return FALSE;
    473479  }
    … …  
    491497  DWORD         dwEvent,dwMask;
    492498
    493   dprintf(("SerialCommThread %x entered", hComm));
    494499  pHMHandleData = HMQueryHandleData(hComm);
    495500  if(!pHMHandleData) {
    … …  
    500505  pDevData = (PHMDEVCOMDATA)pHMHandleData->lpHandlerData;
    501506  if(!pDevData) {
     507      dprintf(("!ERROR! SerialCommThread !pDevData"));
    502508      DebugInt3();
    503509      return 0;
    … …  
    506512  HANDLE hCommOS2 = pHMHandleData->hHMHandle;
    507513  if(!hCommOS2 || !hEvent) {
     514      dprintf(("!ERROR! SerialCommThread !hCommOS2 || !hEvent"));
    508515      DebugInt3();
    509516      return 0;
    510517  }
     518  dprintf(("SerialCommThread %x entered", hComm));
    511519
    512520  while(TRUE)
    … …  
    598606          pDevData->overlapped.Internal |= (rc==0) ? (dwEvent & dwMask) : 0;
    599607          pDevData->dwLastError = rc;
     608
     609          //We're also supposed to write the result to the address supplied
     610          //by the call to WaitCommEvent
     611          if(pDevData->lpfdwEvtMask) *pDevData->lpfdwEvtMask = (rc==0) ? (dwEvent & dwMask) : 0;
    600612          dprintf(("Overlapped: WaitCommEvent returned %x", pDevData->overlapped.Internal));
    601613
    … …  
    619631  PHMDEVCOMDATA pDevData = (PHMDEVCOMDATA)pHMHandleData->lpHandlerData;
    620632
    621   dprintf2(("HMDeviceCommClass::WaitCommEvent %x", pHMHandleData->hHMHandle));
     633  dprintf(("HMDeviceCommClass::WaitCommEvent %x %x %x", pHMHandleData->hHMHandle, lpfdwEvtMask, lpo));
    622634
    623635  if((pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED) && !lpo) {
    624636      dprintf(("!WARNING! pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED) && !lpo"));
    625       SetLastError(ERROR_INVALID_PARAMETER);
     637      ::SetLastError(ERROR_INVALID_PARAMETER);
    626638      return FALSE;
    627639  }
    … …  
    664676        pDevData->overlapped.Offset       = 0;
    665677        pDevData->overlapped.OffsetHigh   = 0;
     678        //We're also supposed to write the result to the address supplied
     679        //by this call
     680        pDevData->lpfdwEvtMask            = lpfdwEvtMask;
     681        //Set app event semaphore to non-signalled state
     682        ::ResetEvent(lpo->hEvent);
     683
    666684        //signal async comm thread to start polling comm status
    667685        ::SetEvent(pDevData->hEventSem);
    668         SetLastError(ERROR_IO_PENDING);
     686        ::SetLastError(ERROR_IO_PENDING);
    669687        return FALSE;
    670688    }
    … …  
    677695  else  *lpfdwEvtMask = 0;
    678696
    679   SetLastError(rc);
     697  ::SetLastError(rc);
    680698  return (rc==0);
    681699}
    … …  
    696714    dprintf(("HMDeviceCommClass::CancelIo"));
    697715    if(pDevData == NULL || !(pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED)) {
    698         SetLastError(ERROR_ACCESS_DENIED); //todo: wrong error?
     716        ::SetLastError(ERROR_ACCESS_DENIED); //todo: wrong error?
    699717        return FALSE;
    700718    }
    … …  
    704722    ::SetEvent(pDevData->hEventSem);
    705723
    706     SetLastError(ERROR_SUCCESS);
     724    ::SetLastError(ERROR_SUCCESS);
    707725    return(TRUE);
    708726}
    … …  
    728746  PHMDEVCOMDATA pDevData = (PHMDEVCOMDATA)pHMHandleData->lpHandlerData;
    729747
    730   dprintf(("KERNEL32-WARNING: HMDeviceCommClass::GetOverlappedResult(%08xh,%08xh,%08xh,%08xh) STUB!!",
     748  dprintf(("KERNEL32-WARNING: HMDeviceCommClass::GetOverlappedResult(%08xh,%08xh,%08xh,%08xh) partly implemented",
    731749            pHMHandleData->hHMHandle,
    732750            lpoOverlapped,
    … …  
    735753
    736754  if(pDevData == NULL || !(pHMHandleData->dwFlags & FILE_FLAG_OVERLAPPED)) {
    737       SetLastError(ERROR_ACCESS_DENIED); //todo: wrong error?
     755      ::SetLastError(ERROR_ACCESS_DENIED); //todo: wrong error?
    738756      return FALSE;
    739757  }
    740758  if(!lpoOverlapped) {
    741       SetLastError(ERROR_INVALID_PARAMETER);
     759      ::SetLastError(ERROR_INVALID_PARAMETER);
    742760      return FALSE;
    743761  }
    744762  if(lpoOverlapped->hEvent != pDevData->overlapped.hEvent) {
    745763      dprintf(("!WARNING!: GetOverlappedResult called for unknown operation"));
    746       SetLastError(ERROR_ACCESS_DENIED); //todo: wrong error?
     764      ::SetLastError(ERROR_ACCESS_DENIED); //todo: wrong error?
    747765      return FALSE;
    748766  }
    … …  
    751769      pDevData->overlapped.Internal = 0; //not entirely safe
    752770      pDevData->dwLastError         = 0;
    753       SetLastError(pDevData->dwLastError);
     771      ::SetLastError(pDevData->dwLastError);
    754772      return lpoOverlapped->Internal;
    755773  }
    … …  
    759777      lpoOverlapped->Internal       = pDevData->overlapped.Internal;
    760778      pDevData->overlapped.Internal = 0; //not entirely safe
    761       SetLastError(ERROR_SUCCESS);
     779      ::SetLastError(ERROR_SUCCESS);
    762780      return lpoOverlapped->Internal;
    763781  }
    764782  else {
    765       SetLastError(ERROR_IO_PENDING);
     783      ::SetLastError(ERROR_IO_PENDING);
    766784      return FALSE;
    767785  }
    … …  
    927945
    928946  rc = 0;
    929   if(pCurDCB->BaudRate != lpDCB->BaudRate)
    930     rc = SetBaud( pHMHandleData,
    931                   lpDCB->BaudRate);
     947  if(pCurDCB->BaudRate != lpDCB->BaudRate) {
     948      dprintf(("SetCommState: change baud rate from %d to %d", pCurDCB->BaudRate, lpDCB->BaudRate));
     949      rc = SetBaud( pHMHandleData,
     950                    lpDCB->BaudRate);
     951  }
    932952
    933953  if(!rc)
    … …  
    936956        (pCurDCB->Parity   != lpDCB->Parity) ||
    937957        (pCurDCB->StopBits != lpDCB->StopBits))
     958    {
     959      dprintf(("SetCommState: change line %d %d %d", lpDCB->ByteSize, lpDCB->Parity, lpDCB->StopBits));
    938960      rc = SetLine( pHMHandleData,
    939961                    lpDCB->ByteSize,
    940962                    lpDCB->Parity,
    941963                    lpDCB->StopBits);
     964    }
    942965  }
    943966
    … …  
    958981        (pCurDCB->XoffChar           != lpDCB->XoffChar) ||
    959982        (pCurDCB->ErrorChar          != lpDCB->ErrorChar))
     983    {
     984      dprintf(("SetCommState: change flags cts %d dsr %d dtr %d dsr %d tx %d out %d in %d ferror %d null %d rts %d abort %d xon %d xoff %d error %d", lpDCB->fOutxCtsFlow, lpDCB->fOutxDsrFlow,lpDCB->fDtrControl,lpDCB->fDsrSensitivity,lpDCB->fDsrSensitivity,lpDCB->fTXContinueOnXoff,lpDCB->fOutX, lpDCB->fInX,lpDCB->fErrorChar,lpDCB->fNull,lpDCB->fRtsControl,lpDCB->fAbortOnError,lpDCB->XonChar,lpDCB->XoffChar,lpDCB->ErrorChar));
    960985      SetOS2DCB( pHMHandleData,
    961986                 lpDCB->fOutxCtsFlow, lpDCB->fOutxDsrFlow,
    … …  
    966991                 lpDCB->fAbortOnError, lpDCB->XonChar,
    967992                 lpDCB->XoffChar,lpDCB->ErrorChar);
     993    }
    968994  }
    969995
    … …  
    9771003  PHMDEVCOMDATA pDevData = (PHMDEVCOMDATA)pHMHandleData->lpHandlerData;
    9781004
    979   dprintf(("HMDeviceCommClass::GetCommState"));
     1005  dprintf(("HMDeviceCommClass::GetCommState %x", lpdcb));
     1006
     1007  if(lpdcb == NULL) {
     1008      ::SetLastError(ERROR_INVALID_PARAMETER);
     1009      return FALSE;
     1010  }
     1011
    9801012  memcpy(lpdcb,&pDevData->CommCfg.dcb,sizeof(DCB));
    981 
    9821013  return(TRUE);
    9831014}
    … …  
    9931024
    9941025  dprintf(("HMDeviceCommClass::GetCommModemStatus %x", lpModemStat));
     1026  if(lpModemStat == NULL) {
     1027      ::SetLastError(ERROR_INVALID_PARAMETER);
     1028      return FALSE;
     1029  }
     1030
    9951031  ulLen = sizeof(CHAR);
    9961032
    … …  
    10111047  }
    10121048
     1049  dprintf2(("HMDeviceCommClass::GetCommModemStatus -> %x rc=%d", *lpModemStat, rc));
    10131050  return(rc==0);
    10141051}
    … …  
    10201057  PHMDEVCOMDATA pDevData = (PHMDEVCOMDATA)pHMHandleData->lpHandlerData;
    10211058
    1022   dprintf(("HMDeviceCommClass::GetCommTimeouts stub"));
     1059  dprintf(("HMDeviceCommClass::GetCommTimeouts %x stub", lpctmo));
     1060
     1061  if(lpctmo == NULL) {
     1062      ::SetLastError(ERROR_INVALID_PARAMETER);
     1063      return FALSE;
     1064  }
     1065
    10231066  memcpy( lpctmo,
    10241067          &pDevData->CommTOuts,
    … …  
    10361079  APIRET rc;
    10371080  UCHAR fbTimeOut;
     1081
     1082  if(lpctmo == NULL) {
     1083      dprintf(("!WARNING! HMDeviceCommClass::SetCommTimeouts %x -> invalid parameter", lpctmo));
     1084      ::SetLastError(ERROR_INVALID_PARAMETER);
     1085      return FALSE;
     1086  }
     1087
    10381088  dprintf(("HMDeviceCommClass::SetCommTimeouts\n"
    10391089           " ReadIntervalTimeout         : 0x%x\n"
    … …  
    11871237      *lpdwSize< sizeof(COMMCONFIG) )
    11881238  {
    1189     SetLastError(ERROR_INSUFFICIENT_BUFFER);
     1239    ::SetLastError(ERROR_INSUFFICIENT_BUFFER);
    11901240    *lpdwSize= sizeof(COMMCONFIG);
    11911241    return FALSE;
    … …  
    11941244  if((NULL==pDevData) || (pDevData->ulMagic != MAGIC_COM) )
    11951245  {
    1196     SetLastError(ERROR_INVALID_HANDLE);
     1246    ::SetLastError(ERROR_INVALID_HANDLE);
    11971247    return FALSE;
    11981248  }
    … …  
    12871337    default:
    12881338      dprintf(("!ERROR!: EscapeCommFunction: unknown function"));
    1289       SetLastError(ERROR_INVALID_PARAMETER);
     1339      ::SetLastError(ERROR_INVALID_PARAMETER);
    12901340      return(FALSE);
    12911341  }
    … …  
    13021352  if((NULL==pDevData) || (pDevData->ulMagic != MAGIC_COM) )
    13031353  {
    1304     SetLastError(ERROR_INVALID_HANDLE);
     1354    ::SetLastError(ERROR_INVALID_HANDLE);
    13051355    return FALSE;
    13061356  }
     1357
     1358  dprintf(("SetDefaultCommConfig %x %d", lpCC, dwSize));
    13071359  memset(&pDevData->CommCfg,0, sizeof(COMMCONFIG));
    13081360  memcpy(&pDevData->CommCfg,lpCC,dwSize>sizeof(COMMCONFIG)?sizeof(COMMCONFIG):dwSize);
    … …  
    13211373      *lpdwSize< sizeof(COMMCONFIG) )
    13221374  {
    1323     SetLastError(ERROR_INSUFFICIENT_BUFFER);
     1375    ::SetLastError(ERROR_INSUFFICIENT_BUFFER);
    13241376    *lpdwSize= sizeof(COMMCONFIG);
    13251377    return FALSE;
    … …  
    13281380  if((NULL==pDevData) || (pDevData->ulMagic != MAGIC_COM) )
    13291381  {
    1330     SetLastError(ERROR_INVALID_HANDLE);
     1382    ::SetLastError(ERROR_INVALID_HANDLE);
    13311383    return FALSE;
    13321384  }
     1385  dprintf(("GetDefaultCommConfig %x %x", lpCC, lpdwSize));
    13331386
    13341387  memcpy(lpCC,&pDevData->CommCfg,sizeof(COMMCONFIG));
    … …  
    13721425    pCurDCB->StopBits = ucStop;
    13731426  }
    1374 
     1427  else {
     1428    dprintf(("!ERROR! SetLine: OSLibDosDevIOCtl failed with rc %d", rc));
     1429  }
    13751430  return rc;
    13761431}
    … …  
    14661521  EXTBAUDSET SetBaud;
    14671522  EXTBAUDGET GetBaud;
     1523  PHMDEVCOMDATA pDevData = (PHMDEVCOMDATA)pHMHandleData->lpHandlerData;
     1524
    14681525  ulLen = sizeof(SetBaud);
    14691526  SetBaud.ulBaud = dwNewBaud;
     1527  SetBaud.ucFrac = 0;
    14701528  rc = OSLibDosDevIOCtl( pHMHandleData->hHMHandle,
    14711529                    IOCTL_ASYNC,
    … …  
    14831541    if(0==rc)
    14841542    {
    1485       if(dwNewBaud !=GetBaud.ulCurrBaud)
     1543      if(dwNewBaud != GetBaud.ulCurrBaud) {
     1544        dprintf(("!WARNING! dwNewBaud (%d) != GetBaud.ulCurrBaud (%d)", dwNewBaud, GetBaud.ulCurrBaud));
    14861545        rc = 1; // ToDo set a proper Errorhandling
     1546      }
    14871547      else
    14881548      {
    1489         ((PHMDEVCOMDATA)pHMHandleData->lpDeviceData)->CommCfg.dcb.BaudRate = dwNewBaud;
    1490         ((PHMDEVCOMDATA)pHMHandleData->lpDeviceData)->CommCfg.dcb.BaudRate = dwNewBaud;
     1549        pDevData->CommCfg.dcb.BaudRate = dwNewBaud;
    14911550      }
    14921551    }
     1552    else {
     1553        dprintf(("!WARNING! SetBaud: (get) OSLibDosDevIOCtl failed with rc %d", rc));
     1554    }
     1555  }
     1556  else {
     1557    dprintf(("!WARNING! SetBaud: (set) OSLibDosDevIOCtl failed with rc %d", rc));
    14931558  }
    14941559  return rc;
Note: See TracChangeset for help on using the changeset viewer.