ircomm.c

WinCE5.0部分核心源码

        //
      case IOCTL_SERIAL_SET_RTS:
        DEBUGMSG(ZONE_FUNCTION, (TEXT("IRCOMM: IOCTL_SERIAL_SET_RTS\r\n")));
        break;

        //  @func   BOOL | IOCTL_SERIAL_CLR_RTS |
        //      Device IO control routine to set RTS low.
        //
        //  @parm DWORD | dwOpenData | value returned from ttt_Open call
        //  @parm DWORD | dwCode | IOCTL_SERIAL_CLR_RTS
        //  @parm PBYTE | pBufIn | Ignored
        //  @parm DWORD | dwLenIn | Ignored
        //  @parm PBYTE | pBufOut | Ignored
        //  @parm DWORD | dwLenOut | Ignored
        //  @parm PDWORD | pdwActualOut | Ignored
        //
        //  @rdesc  Returns TRUE for success, FALSE for failure (and
        //      sets thread error code)
        //
        //  @xref   <f IOCTL_SERIAL_SET_RTS>
        //
      case IOCTL_SERIAL_CLR_RTS:
        DEBUGMSG(ZONE_FUNCTION, (TEXT("IRCOMM: IOCTL_SERIAL_CLR_RTS\r\n")));
        break;

        //  @func   BOOL | IOCTL_SERIAL_SET_XOFF |
        //      Device IO control routine to cause transmission
        //      to act as if an XOFF character has been received.
        //
        //  @parm DWORD | dwOpenData | value returned from ttt_Open call
        //  @parm DWORD | dwCode | IOCTL_SERIAL_SET_XOFF
        //  @parm PBYTE | pBufIn | Ignored
        //  @parm DWORD | dwLenIn | Ignored
        //  @parm PBYTE | pBufOut | Ignored
        //  @parm DWORD | dwLenOut | Ignored
        //  @parm PDWORD | pdwActualOut | Ignored
        //
        //  @rdesc  Returns TRUE for success, FALSE for failure (and
        //      sets thread error code)
        //
        //  @xref   <f IOCTL_SERIAL_SET_XON>
        //
      case IOCTL_SERIAL_SET_XOFF:
        DEBUGMSG(ZONE_FUNCTION, (TEXT("IRCOMM: IOCTL_SERIAL_SET_XOFF\r\n")));
        break;

        //  @func   BOOL | IOCTL_SERIAL_SET_XON |
        //      Device IO control routine to cause transmission
        //      to act as if an XON character has been received.
        //
        //  @parm DWORD | dwOpenData | value returned from ttt_Open call
        //  @parm DWORD | dwCode | IOCTL_SERIAL_SET_XON
        //  @parm PBYTE | pBufIn | Ignored
        //  @parm DWORD | dwLenIn | Ignored
        //  @parm PBYTE | pBufOut | Ignored
        //  @parm DWORD | dwLenOut | Ignored
        //  @parm PDWORD | pdwActualOut | Ignored
        //
        //  @rdesc  Returns TRUE for success, FALSE for failure (and
        //      sets thread error code)
        //
        //  @xref   <f IOCTL_SERIAL_SET_XOFF>
        //
      case IOCTL_SERIAL_SET_XON:
        DEBUGMSG(ZONE_FUNCTION, (TEXT("IRCOMM: IOCTL_SERIAL_SET_XON\r\n")));
        break;

        //  @func   BOOL | IOCTL_SERIAL_GET_WAIT_MASK |
        //      Device IO control routine to retrieve the value
        //      of the event mask.
        //
        //  @parm DWORD | dwOpenData | value returned from ttt_Open call
        //  @parm DWORD | dwCode | IOCTL_SERIAL_GET_WAIT_MASK
        //  @parm PBYTE | pBufIn | Ignored
        //  @parm DWORD | dwLenIn | Ignored
        //  @parm PBYTE | pBufOut | Points to DWORD to place event mask
        //  @parm DWORD | dwLenOut | should be sizeof(DWORD) or larger
        //  @parm PDWORD | pdwActualOut | Points to DWORD to return length
        //      of returned data (should be set to sizeof(DWORD) if no error)
        //
        //  @rdesc  Returns TRUE for success, FALSE for failure (and
        //      sets thread error code)
        //
        //  @xref   <f IOCTL_SERIAL_SET_WAIT_MASK>
        //          <f IOCTL_SERIAL_WAIT_ON_MASK>
        //
      case IOCTL_SERIAL_GET_WAIT_MASK:

        if ((dwLenOut < sizeof(DWORD)) || 
            (NULL == pBufOut)          ||
            (NULL == pdwActualOut)) 
        {
            SetLastError(ERROR_INVALID_PARAMETER);
            RetVal = FALSE;
            break;
        }
        
        // Set The Wait Mask
        *(DWORD *)pBufOut = pOpen->dwEventMask;
        
        // Return the size
        *pdwActualOut = sizeof(DWORD);
        DEBUGMSG (ZONE_FUNCTION, (TEXT("IRCOMM: GET_WAIT_MASK %x\r\n"), pOpen->dwEventMask));
        break;

        //  @func   BOOL | IOCTL_SERIAL_SET_WAIT_MASK |
        //      Device IO control routine to set the value
        //      of the event mask.
        //
        //  @parm DWORD | dwOpenData | value returned from ttt_Open call
        //  @parm DWORD | dwCode | IOCTL_SERIAL_SET_WAIT_MASK
        //  @parm PBYTE | pBufIn | Pointer to the DWORD mask value
        //  @parm DWORD | dwLenIn | should be sizeof(DWORD)
        //  @parm PBYTE | pBufOut | Ignored
        //  @parm DWORD | dwLenOut | Ignored
        //  @parm PDWORD | pdwActualOut | Ignored
        //
        //  @rdesc  Returns TRUE for success, FALSE for failure (and
        //      sets thread error code)
        //
        //  @xref   <f IOCTL_SERIAL_GET_WAIT_MASK>
        //          <f IOCTL_SERIAL_WAIT_ON_MASK>
        //
      case IOCTL_SERIAL_SET_WAIT_MASK:
        DEBUGMSG(ZONE_FUNCTION, (TEXT("IRCOMM: SET_WAIT_MASK 0x%X\r\n"), vEventMask));
        
		if (State == IRCOMM_CLOSED)
		{
			DEBUGMSG(ZONE_ERROR, (TEXT("IRCOMM: ERROR SetCommEvent while state==IRCOMM_CLOSED\n")));
			SetLastError(ERROR_INVALID_HANDLE);
            RetVal = FALSE;
			break;
		}
        else if ((dwLenIn < sizeof(DWORD)) || 
            (NULL == pBufIn)) 
        {
            SetLastError(ERROR_INVALID_PARAMETER);
            RetVal = FALSE;
            break;
        }

        EnterCriticalSection(&IrcommCs);
        if (!SocketsCreated) {
            if (CreateSockets() == FALSE) {
                LeaveCriticalSection(&IrcommCs);
                DEBUGMSG(ZONE_FUNCTION|ZONE_ERROR, (TEXT("IRCOMM:SetCommEvent: CreateSockets failed\r\n")));
                SetLastError(ERROR_GEN_FAILURE);
                RetVal = FALSE;
                break;
            }
        }

        // Set the event so any currently waiting will return with an error
        Priority256 = CeGetThreadPriority(GetCurrentThread());
        CeSetThreadPriority(GetCurrentThread(), g_dwHighThreadPrio);

        {
            DWORD i;
            i = pOpen->dwWaitThds;
            while (i) {
                SetEvent(pOpen->hCommEvent);
                i--;
            }
        }
        
        pOpen->dwEventMask = (*(DWORD *) pBufIn);

        ComputeEventMaskOR();

        LeaveCriticalSection(&IrcommCs);
        CeSetThreadPriority(GetCurrentThread(), Priority256);
        DEBUGMSG(ZONE_FUNCTION, (TEXT("IRCOMM: New MASK 0x%X\r\n"), vEventMask));
        break;

        //  @func   BOOL | IOCTL_SERIAL_WAIT_ON_MASK |
        //      Device IO control routine to wait for a communications
        //      event that matches one in the event mask
        //
        //  @parm DWORD | dwOpenData | value returned from ttt_Open call
        //  @parm DWORD | dwCode | IOCTL_SERIAL_WAIT_ON_MASK
        //  @parm PBYTE | pBufIn | Ignored
        //  @parm DWORD | dwLenIn | Ignored
        //  @parm PBYTE | pBufOut | Points to DWORD to place event mask.
        //      The returned mask will show the event that terminated
        //      the wait.  If a process attempts to change the device
        //      handle's event mask by using the IOCTL_SERIAL_SET_WAIT_MASK
        //      call the driver should return immediately with (DWORD)0 as
        //      the returned event mask.
        //  @parm DWORD | dwLenOut | should be sizeof(DWORD) or larger
        //  @parm PDWORD | pdwActualOut | Points to DWORD to return length
        //      of returned data (should be set to sizeof(DWORD) if no error)
        //
        //  @rdesc  Returns TRUE for success, FALSE for failure (and
        //      sets thread error code)
        //
        //  @xref   <f IOCTL_SERIAL_GET_WAIT_MASK>
        //          <f IOCTL_SERIAL_SET_WAIT_MASK>
        //
      case IOCTL_SERIAL_WAIT_ON_MASK:
        DEBUGMSG(ZONE_FUNCTION, (TEXT("IRCOMM: IOCTL_SERIAL_WAIT_ON_MASK\r\n")));

        if ((dwLenOut < sizeof(DWORD)) || 
            (NULL == pBufOut)          ||
            (NULL == pdwActualOut))
        {
            SetLastError(ERROR_INVALID_PARAMETER);
            RetVal = FALSE;
            break;
        }
        
        RetVal = WaitEvent(pOpen, (DWORD *)pBufOut);
        
        // Return the size
        *pdwActualOut = sizeof(DWORD);
        break;

        //  @func   BOOL | IOCTL_SERIAL_GET_COMMSTATUS |
        //      Device IO control routine to clear any pending
        //      communications errors and return the current communication
        //      status.
        //
        //  @parm DWORD | dwOpenData | value returned from ttt_Open call
        //  @parm DWORD | dwCode | IOCTL_SERIAL_GET_COMMSTATUS
        //  @parm PBYTE | pBufIn | Ignored
        //  @parm DWORD | dwLenIn | Ignored
        //  @parm PBYTE | pBufOut | Points to a <f SERIAL_DEV_STATUS>
        //      structure for the returned status information
        //  @parm DWORD | dwLenOut | should be sizeof(SERIAL_DEV_STATUS)
        //      or larger
        //  @parm PDWORD | pdwActualOut | Points to DWORD to return length
        //      of returned data (should be set to sizeof(SERIAL_DEV_STATUS)
        //      if no error)
        //
        //  @rdesc  Returns TRUE for success, FALSE for failure (and
        //      sets thread error code)
        //
        //
      case IOCTL_SERIAL_GET_COMMSTATUS:
        DEBUGMSG(ZONE_FUNCTION, (TEXT("IRCOMM: IOCTL_SERIAL_GET_COMMSTATUS\r\n")));

        if ((dwLenOut < sizeof(SERIAL_DEV_STATUS)) ||
            (NULL == pBufOut)                      ||
            (NULL == pdwActualOut)) 
        {
            SetLastError(ERROR_INVALID_PARAMETER);
            RetVal = FALSE;
            break;
        }
        
        // Set The Error Mask
        ((PSERIAL_DEV_STATUS)pBufOut)->Errors = 0;

        // Clear the ComStat structure
        memset ((char *) &(((PSERIAL_DEV_STATUS)pBufOut)->ComStat), 0,
                sizeof(COMSTAT));

        // Return the size
        *pdwActualOut = sizeof(SERIAL_DEV_STATUS);
        break;

        //  @func   BOOL | IOCTL_SERIAL_GET_MODEMSTATUS |
        //      Device IO control routine to retrieve current
        //      modem control-register values
        //
        //  @parm DWORD | dwOpenData | value returned from ttt_Open call
        //  @parm DWORD | dwCode | IOCTL_SERIAL_GET_MODEMSTATUS
        //  @parm PBYTE | pBufIn | Ignored
        //  @parm DWORD | dwLenIn | Ignored
        //  @parm PBYTE | pBufOut | Points to a DWORD for the returned
        //      modem status information
        //  @parm DWORD | dwLenOut | should be sizeof(DWORD)
        //      or larger
        //  @parm PDWORD | pdwActualOut | Points to DWORD to return length
        //      of returned data (should be set to sizeof(DWORD)
        //      if no error)
        //
        //  @rdesc  Returns TRUE for success, FALSE for failure (and
        //      sets thread error code)
        //
        //
      case IOCTL_SERIAL_GET_MODEMSTATUS:
        DEBUGMSG(ZONE_FUNCTION, (TEXT("IRCOMM: IOCTL_SERIAL_GET_MODEMSTATUS\r\n")));

        if ((dwLenOut < sizeof(DWORD))  || 
            (NULL == pBufOut)           ||
            (NULL == pdwActualOut)) 
        {
            SetLastError(ERROR_INVALID_PARAMETER);
            RetVal = FALSE;
            break;
        }
        
        // Set the Modem Status dword
        *(DWORD *) pBufOut = 0;
        if (State == IRCOMM_CONNECTED)
            *(DWORD *)pBufOut = MS_RLSD_ON;

        // Return the size
        *pdwActualOut = sizeof(DWORD);
        break;

        //  @func   BOOL | IOCTL_SERIAL_GET_PROPERTIES |
        //      Device IO control routine to retrieve information
        //      about the communications properties for the device.
        //
        //  @parm DWORD | dwOpenData | value returned from ttt_Open call
        //  @parm DWORD | dwCode | IOCTL_SERIAL_GET_PROPERTIES
        //  @parm PBYTE | pBufIn | Ignored
        //  @parm DWORD | dwLenIn | Ignored
        //  @parm PBYTE | pBufOut | Points to a <f COMMPROP> structure
        //      for the returned information.
        //  @parm DWORD | dwLenOut | should be sizeof(COMMPROP)
        //      or larger
        //  @parm PDWORD | pdwActualOut | Points to DWORD to return length
        //      of returned data (should be set to sizeof(COMMPROP)
        //      if no error)
        //
        //  @rdesc  Returns TRUE for success, FALSE for failure (and
        //      sets thread error code)
        //
        //
      case IOCTL_SERIAL_GET_PROPERTIES:
        DEBUGMSG(ZONE_FUNCTION, (TEXT("IRCOMM: IOCTL_SERIAL_GET_PROPERTIES\r\n")));

        if ((dwLenOut < sizeof(COMMPROP)) ||
            (NULL == pBufOut)             ||
            (NULL == pdwActualOut)) 
        {
            SetLastError(ERROR_INVALID_PARAMETER);
            RetVal = FALSE;
            break;
        }
        
        // Clear the ComMProp structure
        memset ((char *) ((COMMPROP *)pBufOut), 0, sizeof(COMMPROP));

        // Return the size
        *pdwActualOut = sizeof(COMMPROP);
        break;

        //  @func   BOOL | IOCTL_SERIAL_SET_TIMEOUTS |
        //      Device IO control routine to set the time-out parameters
        //      for all read and write operations on a specified
        //      communications device
        //
        //  @parm DWORD | dwOpenData | value returned from ttt_Open call
        //  @parm DWORD | dwCode | IOCTL_SERIAL_SET_TIMEOUTS
        //  @parm PBYTE | pBufIn | Pointer to the <f COMMTIMEOUTS> structure
        //  @parm DWORD | dwLenIn | should be sizeof(COMMTIMEOUTS)
        //  @parm PBYTE | pBufOut | Ignored
        //  @parm DWORD | dwLenOut | Ignored
        //  @parm PDWORD | pdwActualOut | Ignored
        //
        //  @rdesc  Returns TRUE for success, FALSE for failure (and
        //      sets thread error code)
        //
        //  @xref   <f IOCTL_SERIAL_GET_TIMEOUTS>
        //
      case IOCTL_SERIAL_SET_TIMEOUTS :
        if ((dwLenIn < sizeof(COMMTIMEOUTS)) || (NULL == pBufIn)) 
        {
            SetLastError(ERROR_INVALID_PARAMETER);
            RetVal = FALSE;
            break;
        }

        DEBUGMSG (ZONE_FUNCTION,
            (TEXT("IRCOMM: IOCTL_SERIAL_SET_COMMTIMEOUTS (%d,%d,%d,%d,%d)\r\n"),
            ((COMMTIMEOUTS *)pBufIn)->ReadIntervalTimeout,
            ((COMMTIMEOUTS *)pBufIn)->ReadTotalTimeoutMultiplier,
            ((COMMTIMEOUTS *)pBufIn)->ReadTotalTimeoutConstant,
            ((COMMTIMEOUTS *)pBufIn)->WriteTotalTimeoutMultiplier,
            ((COMMTIMEOUTS *)pBufIn)->WriteTotalTimeoutConstant));

        CommTimeouts.ReadIntervalTimeout =
            ((COMMTIMEOUTS *)pBufIn)->ReadIntervalTimeout;
        CommTimeouts.ReadTotalTimeoutMultiplier =
            ((COMMTIMEOUTS *)pBufIn)->ReadTotalTimeoutMultiplier;
        CommTimeouts.ReadTotalTimeoutConstant =
            ((COMMTIMEOUTS *)pBufIn)->ReadTotalTimeoutConstant;
        CommTimeouts.WriteTotalTimeoutMultiplier =
            ((COMMTIMEOUTS *)pBufIn)->WriteTotalTimeoutMultiplier;
        CommTimeouts.WriteTotalTimeoutConstant =
            ((COMMTIMEOUTS *)pBufIn)->WriteTotalTimeoutConstant;

        // Normally we would do something with the passed in parameter.
        break;

        //  @func   BOOL | IOCTL_SERIAL_GET_TIMEOUTS |
        //      Device IO control routine to set the time-out parameters