comm.c File Reference

#include <k32.h>
#include <ntddser.h>
#include <debug.h>

Include dependency graph for comm.c:

Go to the source code of this file.

Macros
#define	NDEBUG

Typedefs
typedef LARGE_INTEGER	PHYSICAL_ADDRESS
typedef LARGE_INTEGER *	PPHYSICAL_ADDRESS

Functions
	DEBUG_CHANNEL (comm)
static LPCWSTR	COMM_ParseStart (LPCWSTR ptr)
static LPCWSTR	COMM_ParseNumber (LPCWSTR ptr, LPDWORD lpnumber)
static LPCWSTR	COMM_ParseParity (LPCWSTR ptr, LPBYTE lpparity)
static LPCWSTR	COMM_ParseByteSize (LPCWSTR ptr, LPBYTE lpbytesize)
static LPCWSTR	COMM_ParseStopBits (LPCWSTR ptr, LPBYTE lpstopbits)
static LPCWSTR	COMM_ParseOnOff (LPCWSTR ptr, LPDWORD lponoff)
static BOOL	COMM_BuildOldCommDCB (LPCWSTR device, LPDCB lpdcb)
static BOOL	COMM_BuildNewCommDCB (LPCWSTR device, LPDCB lpdcb, LPCOMMTIMEOUTS lptimeouts)
BOOL WINAPI	BuildCommDCBA (LPCSTR device, LPDCB lpdcb)
BOOL WINAPI	BuildCommDCBAndTimeoutsA (LPCSTR device, LPDCB lpdcb, LPCOMMTIMEOUTS lptimeouts)
BOOL WINAPI	BuildCommDCBAndTimeoutsW (LPCWSTR devid, LPDCB lpdcb, LPCOMMTIMEOUTS lptimeouts)
BOOL WINAPI	BuildCommDCBW (LPCWSTR devid, LPDCB lpdcb)
BOOL WINAPI	SetCommBreak (HANDLE handle)
BOOL WINAPI	ClearCommBreak (HANDLE handle)
BOOL WINAPI	EscapeCommFunction (HANDLE handle, DWORD func)
BOOL WINAPI	PurgeComm (HANDLE handle, DWORD flags)
BOOL WINAPI	ClearCommError (HANDLE handle, LPDWORD errors, LPCOMSTAT lpStat)
BOOL WINAPI	SetupComm (HANDLE handle, DWORD insize, DWORD outsize)
BOOL WINAPI	GetCommMask (HANDLE handle, LPDWORD evtmask)
BOOL WINAPI	SetCommMask (HANDLE handle, DWORD evtmask)
static void	dump_dcb (const DCB *lpdcb)
BOOL WINAPI	SetCommState (HANDLE handle, LPDCB lpdcb)
BOOL WINAPI	GetCommState (HANDLE handle, LPDCB lpdcb)
BOOL WINAPI	TransmitCommChar (HANDLE hComm, CHAR chTransmit)
BOOL WINAPI	GetCommTimeouts (HANDLE hComm, LPCOMMTIMEOUTS lptimeouts)
BOOL WINAPI	SetCommTimeouts (HANDLE hComm, LPCOMMTIMEOUTS lptimeouts)
BOOL WINAPI	GetCommModemStatus (HANDLE hFile, LPDWORD lpModemStat)
BOOL WINAPI	WaitCommEvent (HANDLE hFile, LPDWORD lpdwEvents, LPOVERLAPPED lpOverlapped)
BOOL WINAPI	GetCommProperties (HANDLE hFile, LPCOMMPROP lpCommProp)
BOOL WINAPI	CommConfigDialogA (LPCSTR lpszDevice, HWND hWnd, LPCOMMCONFIG lpCommConfig)
BOOL WINAPI	CommConfigDialogW (LPCWSTR lpszDevice, HWND hWnd, LPCOMMCONFIG lpCommConfig)
BOOL WINAPI	GetCommConfig (HANDLE hFile, LPCOMMCONFIG lpCommConfig, LPDWORD lpdwSize)
BOOL WINAPI	SetCommConfig (HANDLE hFile, LPCOMMCONFIG lpCommConfig, DWORD dwSize)
BOOL WINAPI	SetDefaultCommConfigW (LPCWSTR lpszDevice, LPCOMMCONFIG lpCommConfig, DWORD dwSize)
BOOL WINAPI	SetDefaultCommConfigA (LPCSTR lpszDevice, LPCOMMCONFIG lpCommConfig, DWORD dwSize)
BOOL WINAPI	GetDefaultCommConfigW (LPCWSTR lpszName, LPCOMMCONFIG lpCC, LPDWORD lpdwSize)
BOOL WINAPI	GetDefaultCommConfigA (LPCSTR lpszName, LPCOMMCONFIG lpCC, LPDWORD lpdwSize)

Variables
static const WCHAR	lpszSerialUI []

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 44 of file comm.c.

Typedef Documentation

PHYSICAL_ADDRESS

typedef LARGE_INTEGER PHYSICAL_ADDRESS

Definition at line 23 of file comm.c.

PPHYSICAL_ADDRESS

typedef LARGE_INTEGER * PPHYSICAL_ADDRESS

Definition at line 23 of file comm.c.

Function Documentation

BuildCommDCBA()

BOOL WINAPI BuildCommDCBA	(	LPCSTR	device,
		LPDCB	lpdcb
	)

Definition at line 429 of file comm.c.

{
    return BuildCommDCBAndTimeoutsA(device,lpdcb,NULL);
}

Referenced by test_BuildCommDCBA().

BuildCommDCBAndTimeoutsA()

BOOL WINAPI BuildCommDCBAndTimeoutsA	(	LPCSTR	device,
		LPDCB	lpdcb,
		LPCOMMTIMEOUTS	lptimeouts
	)

Definition at line 447 of file comm.c.

{
    BOOL ret = FALSE;
    UNICODE_STRING deviceW;
 
    TRACE("(%s,%p,%p)\n",device,lpdcb,lptimeouts);
    if(device) RtlCreateUnicodeStringFromAsciiz(&deviceW,device);
    else deviceW.Buffer = NULL;
 
    if(deviceW.Buffer) ret = BuildCommDCBAndTimeoutsW(deviceW.Buffer,lpdcb,lptimeouts);
 
    RtlFreeUnicodeString(&deviceW);
    return ret;
}

Referenced by BuildCommDCBA(), and test_BuildCommDCBAndTimeoutsA().

BuildCommDCBAndTimeoutsW()

BOOL WINAPI BuildCommDCBAndTimeoutsW	(	LPCWSTR	devid,
		LPDCB	lpdcb,
		LPCOMMTIMEOUTS	lptimeouts
	)

Definition at line 476 of file comm.c.

{
    DCB dcb;
    COMMTIMEOUTS timeouts;
    BOOL result;
    LPCWSTR ptr = devid;
 
    TRACE("(%s,%p,%p)\n",debugstr_w(devid),lpdcb,lptimeouts);
 
    memset(&timeouts, 0, sizeof timeouts);
 
    /* Set DCBlength. (Windows NT does not do this, but 9x does) */
    lpdcb->DCBlength = sizeof(DCB);
 
    /* Make a copy of the original data structures to work with since if
       if there is an error in the device control string the originals
       should not be modified (except possibly DCBlength) */
    dcb = *lpdcb;
    if(lptimeouts) timeouts = *lptimeouts;
 
    ptr = COMM_ParseStart(ptr);
 
    if(ptr == NULL)
        result = FALSE;
    else if(strchrW(ptr, ','))
        result = COMM_BuildOldCommDCB(ptr, &dcb);
    else
        result = COMM_BuildNewCommDCB(ptr, &dcb, &timeouts);
 
    if(result)
    {
        *lpdcb = dcb;
        if(lptimeouts) *lptimeouts = timeouts;
        return TRUE;
    }
    else
    {
        WARN("Invalid device control string: %s\n", debugstr_w(devid));
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }   
}

Referenced by BuildCommDCBAndTimeoutsA(), BuildCommDCBW(), and test_BuildCommDCBAndTimeoutsW().

BuildCommDCBW()

BOOL WINAPI BuildCommDCBW	(	LPCWSTR	devid,
		LPDCB	lpdcb
	)

Definition at line 533 of file comm.c.

{
    return BuildCommDCBAndTimeoutsW(devid,lpdcb,NULL);
}

Referenced by test_BuildCommDCBW().

ClearCommBreak()

BOOL WINAPI ClearCommBreak

(

HANDLE

handle

)

Definition at line 580 of file comm.c.

{
    DWORD dwBytesReturned;
    return DeviceIoControl(handle, IOCTL_SERIAL_SET_BREAK_OFF, NULL, 0, NULL, 0, &dwBytesReturned, NULL);
}

Referenced by test_WaitBreak().

ClearCommError()

BOOL WINAPI ClearCommError	(	HANDLE	handle,
		LPDWORD	errors,
		LPCOMSTAT	lpStat
	)

Definition at line 663 of file comm.c.

{
    SERIAL_STATUS       ss;
    DWORD dwBytesReturned;
 
    if (!DeviceIoControl(handle, IOCTL_SERIAL_GET_COMMSTATUS, NULL, 0,
                         &ss, sizeof(ss), &dwBytesReturned, NULL))
        return FALSE;
 
    if (errors)
    {
        *errors = 0;
        if (ss.Errors & SERIAL_ERROR_BREAK)             *errors |= CE_BREAK;
        if (ss.Errors & SERIAL_ERROR_FRAMING)           *errors |= CE_FRAME;
        if (ss.Errors & SERIAL_ERROR_OVERRUN)           *errors |= CE_OVERRUN;
        if (ss.Errors & SERIAL_ERROR_QUEUEOVERRUN)      *errors |= CE_RXOVER;
        if (ss.Errors & SERIAL_ERROR_PARITY)            *errors |= CE_RXPARITY;
    }
 
    if (lpStat)
    {
        memset(lpStat, 0, sizeof(*lpStat));
 
        if (ss.HoldReasons & SERIAL_TX_WAITING_FOR_CTS)         lpStat->fCtsHold = TRUE;
        if (ss.HoldReasons & SERIAL_TX_WAITING_FOR_DSR)         lpStat->fDsrHold = TRUE;
        if (ss.HoldReasons & SERIAL_TX_WAITING_FOR_DCD)         lpStat->fRlsdHold = TRUE;
        if (ss.HoldReasons & SERIAL_TX_WAITING_FOR_XON)         lpStat->fXoffHold = TRUE;
        if (ss.HoldReasons & SERIAL_TX_WAITING_XOFF_SENT)       lpStat->fXoffSent = TRUE;
        if (ss.EofReceived)                                     lpStat->fEof = TRUE;
        if (ss.WaitForImmediate)                                lpStat->fTxim = TRUE;
        lpStat->cbInQue = ss.AmountInInQueue;
        lpStat->cbOutQue = ss.AmountInOutQueue;
    }
    return TRUE;
}

Referenced by main(), test_ClearCommError(), test_FlushFileBuffers(), test_non_pending_errors(), test_OpenComm(), and test_waittxempty().

COMM_BuildNewCommDCB()

static BOOL COMM_BuildNewCommDCB ( LPCWSTR  device, LPDCB  lpdcb, LPCOMMTIMEOUTS  lptimeouts  )

static

Definition at line 297 of file comm.c.

{
    DWORD temp;
    BOOL baud = FALSE, stop = FALSE;
    static const WCHAR baudW[] = {'b','a','u','d','=',0};
    static const WCHAR parityW[] = {'p','a','r','i','t','y','=',0};
    static const WCHAR dataW[] = {'d','a','t','a','=',0};
    static const WCHAR stopW[] = {'s','t','o','p','=',0};
    static const WCHAR toW[] = {'t','o','=',0};
    static const WCHAR xonW[] = {'x','o','n','=',0};
    static const WCHAR odsrW[] = {'o','d','s','r','=',0};
    static const WCHAR octsW[] = {'o','c','t','s','=',0};
    static const WCHAR dtrW[] = {'d','t','r','=',0};
    static const WCHAR rtsW[] = {'r','t','s','=',0};
    static const WCHAR idsrW[] = {'i','d','s','r','=',0};
 
    while(*device)
    {
        while(*device == ' ') device++;
 
        if(!strncmpiW(baudW, device, 5))
        {
            baud = TRUE;
            
            if(!(device = COMM_ParseNumber(device + 5, &lpdcb->BaudRate)))
                return FALSE;
        }
        else if(!strncmpiW(parityW, device, 7))
        {
            if(!(device = COMM_ParseParity(device + 7, &lpdcb->Parity)))
                return FALSE;
        }
        else if(!strncmpiW(dataW, device, 5))
        {
            if(!(device = COMM_ParseByteSize(device + 5, &lpdcb->ByteSize)))
                return FALSE;
        }
        else if(!strncmpiW(stopW, device, 5))
        {
            stop = TRUE;
            
            if(!(device = COMM_ParseStopBits(device + 5, &lpdcb->StopBits)))
                return FALSE;
        }
        else if(!strncmpiW(toW, device, 3))
        {
            if(!(device = COMM_ParseOnOff(device + 3, &temp)))
                return FALSE;
 
            lptimeouts->ReadIntervalTimeout = 0;
            lptimeouts->ReadTotalTimeoutMultiplier = 0;
            lptimeouts->ReadTotalTimeoutConstant = 0;
            lptimeouts->WriteTotalTimeoutMultiplier = 0;
            lptimeouts->WriteTotalTimeoutConstant = temp ? 60000 : 0;
        }
        else if(!strncmpiW(xonW, device, 4))
        {
            if(!(device = COMM_ParseOnOff(device + 4, &temp)))
                return FALSE;
 
            lpdcb->fOutX = temp;
            lpdcb->fInX = temp;
        }
        else if(!strncmpiW(odsrW, device, 5))
        {
            if(!(device = COMM_ParseOnOff(device + 5, &temp)))
                return FALSE;
 
            lpdcb->fOutxDsrFlow = temp;
        }
        else if(!strncmpiW(octsW, device, 5))
        {
            if(!(device = COMM_ParseOnOff(device + 5, &temp)))
                return FALSE;
 
            lpdcb->fOutxCtsFlow = temp;
        }
        else if(!strncmpiW(dtrW, device, 4))
        {
            if(!(device = COMM_ParseOnOff(device + 4, &temp)))
                return FALSE;
 
            lpdcb->fDtrControl = temp;
        }
        else if(!strncmpiW(rtsW, device, 4))
        {
            if(!(device = COMM_ParseOnOff(device + 4, &temp)))
                return FALSE;
 
            lpdcb->fRtsControl = temp;
        }
        else if(!strncmpiW(idsrW, device, 5))
        {
            if(!(device = COMM_ParseOnOff(device + 5, &temp)))
                return FALSE;
 
            /* Win NT sets the fDsrSensitivity member based on the
               idsr parameter.  Win 9x sets fOutxDsrFlow instead. */
            lpdcb->fDsrSensitivity = temp;
        }
        else
            return FALSE;
 
        /* After the above parsing, the next character (if not the end of
           the string) should be a space */
        if(*device && *device != ' ')
            return FALSE;
    }
 
    /* If stop bits were not specified, a default is always supplied. */
    if(!stop)
    {
        if(baud && lpdcb->BaudRate == 110)
            lpdcb->StopBits = TWOSTOPBITS;
        else
            lpdcb->StopBits = ONESTOPBIT;
    }
 
    return TRUE;
}

Referenced by BuildCommDCBAndTimeoutsW().

COMM_BuildOldCommDCB()

static BOOL COMM_BuildOldCommDCB ( LPCWSTR  device, LPDCB  lpdcb  )

static

Definition at line 197 of file comm.c.

{
    WCHAR last = 0;
 
    if(!(device = COMM_ParseNumber(device, &lpdcb->BaudRate)))
        return FALSE;
    
    switch(lpdcb->BaudRate)
    {
    case 11:
    case 30:
    case 60:
        lpdcb->BaudRate *= 10;
        break;
    case 12:
    case 24:
    case 48:
    case 96:
        lpdcb->BaudRate *= 100;
        break;
    case 19:
        lpdcb->BaudRate = 19200;
        break;
    }
 
    while(*device == ' ') device++;
    if(*device++ != ',') return FALSE;
    while(*device == ' ') device++;
 
    if(!(device = COMM_ParseParity(device, &lpdcb->Parity)))
        return FALSE;
 
    while(*device == ' ') device++;
    if(*device++ != ',') return FALSE;
    while(*device == ' ') device++;
        
    if(!(device = COMM_ParseByteSize(device, &lpdcb->ByteSize)))
        return FALSE;
 
    while(*device == ' ') device++;
    if(*device++ != ',') return FALSE;
    while(*device == ' ') device++;
 
    if(!(device = COMM_ParseStopBits(device, &lpdcb->StopBits)))
        return FALSE;
 
    /* The last parameter for flow control is optional. */
    while(*device == ' ') device++;
    if(*device == ',')
    {
        device++;
        while(*device == ' ') device++;
        if(*device) last = toupperW(*device++);
        while(*device == ' ') device++;
    }
 
    /* Win NT sets the flow control members based on (or lack of) the last
       parameter.  Win 9x does not set these members. */
    switch(last)
    {
    case 0:
        lpdcb->fInX = FALSE;
        lpdcb->fOutX = FALSE;
        lpdcb->fOutxCtsFlow = FALSE;
        lpdcb->fOutxDsrFlow = FALSE;
        lpdcb->fDtrControl = DTR_CONTROL_ENABLE;
        lpdcb->fRtsControl = RTS_CONTROL_ENABLE;
        break;
    case 'X':
        lpdcb->fInX = TRUE;
        lpdcb->fOutX = TRUE;
        lpdcb->fOutxCtsFlow = FALSE;
        lpdcb->fOutxDsrFlow = FALSE;
        lpdcb->fDtrControl = DTR_CONTROL_ENABLE;
        lpdcb->fRtsControl = RTS_CONTROL_ENABLE;
        break;
    case 'P':
        lpdcb->fInX = FALSE;
        lpdcb->fOutX = FALSE;
        lpdcb->fOutxCtsFlow = TRUE;
        lpdcb->fOutxDsrFlow = TRUE;
        lpdcb->fDtrControl = DTR_CONTROL_HANDSHAKE;
        lpdcb->fRtsControl = RTS_CONTROL_HANDSHAKE;
        break;
    default:
        return FALSE;
    }
 
    /* This should be the end of the string. */
    if(*device) return FALSE;
    
    return TRUE;
}

Referenced by BuildCommDCBAndTimeoutsW().

COMM_ParseByteSize()

static LPCWSTR COMM_ParseByteSize ( LPCWSTR  ptr, LPBYTE  lpbytesize  )

static

Definition at line 129 of file comm.c.

{
    DWORD temp;
 
    if(!(ptr = COMM_ParseNumber(ptr, &temp)))
        return NULL;
 
    if(temp >= 5 && temp <= 8)
    {
        *lpbytesize = temp;
        return ptr;
    }
    else
        return NULL;
}

Referenced by COMM_BuildNewCommDCB(), and COMM_BuildOldCommDCB().

COMM_ParseNumber()

static LPCWSTR COMM_ParseNumber ( LPCWSTR  ptr, LPDWORD  lpnumber  )

static

Definition at line 91 of file comm.c.

{
    if(*ptr < '0' || *ptr > '9') return NULL;
    *lpnumber = strtoulW(ptr, NULL, 10);
    while(*ptr >= '0' && *ptr <= '9') ptr++;
    return ptr;
}

Referenced by COMM_BuildNewCommDCB(), COMM_BuildOldCommDCB(), COMM_ParseByteSize(), and COMM_ParseStopBits().

COMM_ParseOnOff()

static LPCWSTR COMM_ParseOnOff ( LPCWSTR  ptr, LPDWORD  lponoff  )

static

Definition at line 171 of file comm.c.

{
    static const WCHAR onW[] = {'o','n',0};
    static const WCHAR offW[] = {'o','f','f',0};
 
    if(!strncmpiW(onW, ptr, 2))
    {
        ptr += 2;
        *lponoff = 1;
    }
    else if(!strncmpiW(offW, ptr, 3))
    {
        ptr += 3;
        *lponoff = 0;
    }
    else
        return NULL;
 
    return ptr;
}

Referenced by COMM_BuildNewCommDCB().

COMM_ParseParity()

static LPCWSTR COMM_ParseParity ( LPCWSTR  ptr, LPBYTE  lpparity  )

static

Definition at line 99 of file comm.c.

{
    /* Contrary to what you might expect, Windows only sets the Parity
       member of DCB and not fParity even when parity is specified in the
       device control string */
 
    switch(toupperW(*ptr++))
    {
    case 'E':
        *lpparity = EVENPARITY;
        break;
    case 'M':
        *lpparity = MARKPARITY;
        break;
    case 'N':
        *lpparity = NOPARITY;
        break;
    case 'O':
        *lpparity = ODDPARITY;
        break;
    case 'S':
        *lpparity = SPACEPARITY;
        break;
    default:
        return NULL;
    }
 
    return ptr;
}

Referenced by COMM_BuildNewCommDCB(), and COMM_BuildOldCommDCB().

COMM_ParseStart()

static LPCWSTR COMM_ParseStart ( LPCWSTR  ptr )

static

Definition at line 54 of file comm.c.

{
    static const WCHAR comW[] = {'C','O','M',0};
 
    /* The device control string may optionally start with "COMx" followed
       by an optional ':' and spaces. */
    if(!strncmpiW(ptr, comW, 3))
    {
        ptr += 3;
 
        /* Allow any com port above 0 as Win 9x does (NT only allows
           values for com ports which are actually present) */
        if(*ptr < '1' || *ptr > '9')
            return NULL;
        
        /* Advance pointer past port number */
        while(*ptr >= '0' && *ptr <= '9') ptr++;
        
        /* The com port number must be followed by a ':' or ' ' */
        if(*ptr != ':' && *ptr != ' ')
            return NULL;
 
        /* Advance pointer to beginning of next parameter */
        while(*ptr == ' ') ptr++;
        if(*ptr == ':')
        {
            ptr++;
            while(*ptr == ' ') ptr++;
        }
    }
    /* The device control string must not start with a space. */
    else if(*ptr == ' ')
        return NULL;
    
    return ptr;
}

Referenced by BuildCommDCBAndTimeoutsW().

COMM_ParseStopBits()

static LPCWSTR COMM_ParseStopBits ( LPCWSTR  ptr, LPBYTE  lpstopbits  )

static

Definition at line 145 of file comm.c.

{
    DWORD temp;
    static const WCHAR stopbits15W[] = {'1','.','5',0};
 
    if(!strncmpW(stopbits15W, ptr, 3))
    {
        ptr += 3;
        *lpstopbits = ONE5STOPBITS;
    }
    else
    {
        if(!(ptr = COMM_ParseNumber(ptr, &temp)))
            return NULL;
 
        if(temp == 1)
            *lpstopbits = ONESTOPBIT;
        else if(temp == 2)
            *lpstopbits = TWOSTOPBITS;
        else
            return NULL;
    }
    
    return ptr;
}

Referenced by COMM_BuildNewCommDCB(), and COMM_BuildOldCommDCB().

CommConfigDialogA()

BOOL WINAPI CommConfigDialogA	(	LPCSTR	lpszDevice,
		HWND	hWnd,
		LPCOMMCONFIG	lpCommConfig
	)

Definition at line 1214 of file comm.c.

{
    LPWSTR  lpDeviceW = NULL;
    DWORD   len;
    BOOL    r;
 
    TRACE("(%s, %p, %p)\n", debugstr_a(lpszDevice), hWnd, lpCommConfig);
 
    if (lpszDevice)
    {
        len = MultiByteToWideChar( CP_ACP, 0, lpszDevice, -1, NULL, 0 );
        lpDeviceW = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
        MultiByteToWideChar( CP_ACP, 0, lpszDevice, -1, lpDeviceW, len );
    }
    r = CommConfigDialogW(lpDeviceW, hWnd, lpCommConfig);
    HeapFree( GetProcessHeap(), 0, lpDeviceW );
    return r;
}

CommConfigDialogW()

BOOL WINAPI CommConfigDialogW	(	LPCWSTR	lpszDevice,
		HWND	hWnd,
		LPCOMMCONFIG	lpCommConfig
	)

Definition at line 1241 of file comm.c.

{
    DWORD (WINAPI *pCommConfigDialog)(LPCWSTR, HWND, LPCOMMCONFIG);
    HMODULE hConfigModule;
    DWORD   res = ERROR_INVALID_PARAMETER;
 
    TRACE("(%s, %p, %p)\n", debugstr_w(lpszDevice), hWnd, lpCommConfig);
    hConfigModule = LoadLibraryW(lpszSerialUI);
 
    if (hConfigModule) {
        pCommConfigDialog = (void *)GetProcAddress(hConfigModule, "drvCommConfigDialogW");
        if (pCommConfigDialog) {
            res = pCommConfigDialog(lpszDevice, hWnd, lpCommConfig);
        }
        FreeLibrary(hConfigModule);
    }
 
    if (res) SetLastError(res);
    return (res == ERROR_SUCCESS);
}

Referenced by CommConfigDialogA(), and dlg_configure_com().

DEBUG_CHANNEL()

DEBUG_CHANNEL

(

comm

)

dump_dcb()

static void dump_dcb ( const DCB *  lpdcb )

static

Definition at line 776 of file comm.c.

{
    TRACE("bytesize=%d baudrate=%d fParity=%d Parity=%d stopbits=%d\n",
          lpdcb->ByteSize, lpdcb->BaudRate, lpdcb->fParity, lpdcb->Parity,
          (lpdcb->StopBits == ONESTOPBIT) ? 1 :
          (lpdcb->StopBits == TWOSTOPBITS) ? 2 : 0);
    TRACE("%sIXON %sIXOFF\n", (lpdcb->fOutX) ? "" : "~", (lpdcb->fInX) ? "" : "~");
    TRACE("fOutxCtsFlow=%d fRtsControl=%d\n", lpdcb->fOutxCtsFlow, lpdcb->fRtsControl);
    TRACE("fOutxDsrFlow=%d fDtrControl=%d\n", lpdcb->fOutxDsrFlow, lpdcb->fDtrControl);
    if (lpdcb->fOutxCtsFlow || lpdcb->fRtsControl == RTS_CONTROL_HANDSHAKE)
        TRACE("CRTSCTS\n");
    else
        TRACE("~CRTSCTS\n");
}

Referenced by GetCommState(), and SetCommState().

EscapeCommFunction()

BOOL WINAPI EscapeCommFunction	(	HANDLE	handle,
		DWORD	func
	)

Definition at line 602 of file comm.c.

{
    DWORD       ioc;
    DWORD dwBytesReturned;
 
    switch (func)
    {
    case CLRDTR:        ioc = IOCTL_SERIAL_CLR_DTR;             break;
    case CLRRTS:        ioc = IOCTL_SERIAL_CLR_RTS;             break;
    case SETDTR:        ioc = IOCTL_SERIAL_SET_DTR;             break;
    case SETRTS:        ioc = IOCTL_SERIAL_SET_RTS;             break;
    case SETXOFF:       ioc = IOCTL_SERIAL_SET_XOFF;            break;
    case SETXON:        ioc = IOCTL_SERIAL_SET_XON;             break;
    case SETBREAK:      ioc = IOCTL_SERIAL_SET_BREAK_ON;        break;
    case CLRBREAK:      ioc = IOCTL_SERIAL_SET_BREAK_OFF;       break;
    case RESETDEV:      ioc = IOCTL_SERIAL_RESET_DEVICE;        break;
    default:
        ERR("Unknown function code (%u)\n", func);
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
    return DeviceIoControl(handle, ioc, NULL, 0, NULL, 0, &dwBytesReturned, NULL);
}

Referenced by main(), test_LoopbackCtsRts(), test_LoopbackDtrDcd(), test_LoopbackDtrDsr(), test_LoopbackDtrRing(), and toggle_ctlLine().

GetCommConfig()

BOOL WINAPI GetCommConfig	(	HANDLE	hFile,
		LPCOMMCONFIG	lpCommConfig,
		LPDWORD	lpdwSize
	)

Definition at line 1278 of file comm.c.

{
    BOOL r;
 
    TRACE("(%p, %p, %p) *lpdwSize: %u\n", hFile, lpCommConfig, lpdwSize, lpdwSize ? *lpdwSize : 0 );
 
    if(lpCommConfig == NULL)
        return FALSE;
    r = *lpdwSize < sizeof(COMMCONFIG); /* TRUE if not enough space */
    *lpdwSize = sizeof(COMMCONFIG);
    if(r)
        return FALSE;
 
    lpCommConfig->dwSize = sizeof(COMMCONFIG);
    lpCommConfig->wVersion = 1;
    lpCommConfig->wReserved = 0;
    r = GetCommState(hFile,&lpCommConfig->dcb);
    lpCommConfig->dwProviderSubType = PST_RS232;
    lpCommConfig->dwProviderOffset = 0;
    lpCommConfig->dwProviderSize = 0;
 
    return r;
}

GetCommMask()

BOOL WINAPI GetCommMask	(	HANDLE	handle,
		LPDWORD	evtmask
	)

Definition at line 744 of file comm.c.

{
    DWORD dwBytesReturned;
    TRACE("handle %p, mask %p\n", handle, evtmask);
    return DeviceIoControl(handle, IOCTL_SERIAL_GET_WAIT_MASK,
                           NULL, 0, evtmask, sizeof(*evtmask), &dwBytesReturned, NULL);
}

GetCommModemStatus()

BOOL WINAPI GetCommModemStatus	(	HANDLE	hFile,
		LPDWORD	lpModemStat
	)

Definition at line 1099 of file comm.c.

{
    DWORD dwBytesReturned;
    return DeviceIoControl(hFile, IOCTL_SERIAL_GET_MODEMSTATUS,
                           NULL, 0, lpModemStat, sizeof(DWORD), &dwBytesReturned, NULL);
}

Referenced by test_AbortWaitCts(), test_GetModemStatus(), test_LoopbackCtsRts(), test_LoopbackDtrDcd(), test_LoopbackDtrDsr(), test_LoopbackDtrRing(), test_WaitBreak(), test_WaitCts(), test_WaitDcd(), test_WaitDsr(), and test_WaitRing().

GetCommProperties()

BOOL WINAPI GetCommProperties	(	HANDLE	hFile,
		LPCOMMPROP	lpCommProp
	)

Definition at line 1144 of file comm.c.

{
    TRACE("(%p %p)\n",hFile,lpCommProp);
    if(!lpCommProp)
        return FALSE;
 
    /*
     * These values should be valid for LINUX's serial driver
     * FIXME: Perhaps they deserve an #ifdef LINUX
     */
    memset(lpCommProp,0,sizeof(COMMPROP));
    lpCommProp->wPacketLength       = 1;
    lpCommProp->wPacketVersion      = 1;
    lpCommProp->dwServiceMask       = SP_SERIALCOMM;
    lpCommProp->dwMaxTxQueue        = 4096;
    lpCommProp->dwMaxRxQueue        = 4096;
    lpCommProp->dwMaxBaud           = BAUD_115200;
    lpCommProp->dwProvSubType       = PST_RS232;
    lpCommProp->dwProvCapabilities  = PCF_DTRDSR | PCF_PARITY_CHECK | PCF_RTSCTS | PCF_TOTALTIMEOUTS;
    lpCommProp->dwSettableParams    = SP_BAUD | SP_DATABITS | SP_HANDSHAKING |
                                      SP_PARITY | SP_PARITY_CHECK | SP_STOPBITS ;
    lpCommProp->dwSettableBaud      = BAUD_075 | BAUD_110 | BAUD_134_5 | BAUD_150 |
                BAUD_300 | BAUD_600 | BAUD_1200 | BAUD_1800 | BAUD_2400 | BAUD_4800 |
                BAUD_9600 | BAUD_19200 | BAUD_38400 | BAUD_57600 | BAUD_115200 ;
    lpCommProp->wSettableData       = DATABITS_5 | DATABITS_6 | DATABITS_7 | DATABITS_8 ;
    lpCommProp->wSettableStopParity = STOPBITS_10 | STOPBITS_15 | STOPBITS_20 |
                PARITY_NONE | PARITY_ODD |PARITY_EVEN | PARITY_MARK | PARITY_SPACE;
    lpCommProp->dwCurrentTxQueue    = lpCommProp->dwMaxTxQueue;
    lpCommProp->dwCurrentRxQueue    = lpCommProp->dwMaxRxQueue;
 
    return TRUE;
}

GetCommState()

BOOL WINAPI GetCommState	(	HANDLE	handle,
		LPDCB	lpdcb
	)

Definition at line 904 of file comm.c.

{
    SERIAL_BAUD_RATE    sbr;
    SERIAL_LINE_CONTROL slc;
    SERIAL_HANDFLOW     shf;
    SERIAL_CHARS        sc;
    DWORD dwBytesReturned;
 
    TRACE("handle %p, ptr %p\n", handle, lpdcb);
 
    if (!lpdcb)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
    
    if (!DeviceIoControl(handle, IOCTL_SERIAL_GET_BAUD_RATE,
                         NULL, 0, &sbr, sizeof(sbr), &dwBytesReturned, NULL) ||
        !DeviceIoControl(handle, IOCTL_SERIAL_GET_LINE_CONTROL,
                         NULL, 0, &slc, sizeof(slc), &dwBytesReturned, NULL) ||
        !DeviceIoControl(handle, IOCTL_SERIAL_GET_HANDFLOW,
                         NULL, 0, &shf, sizeof(shf), &dwBytesReturned, NULL) ||
        !DeviceIoControl(handle, IOCTL_SERIAL_GET_CHARS,
                         NULL, 0, &sc, sizeof(sc), &dwBytesReturned, NULL))
        return FALSE;
 
    memset(lpdcb, 0, sizeof(*lpdcb));
    lpdcb->DCBlength = sizeof(*lpdcb);
 
    /* yes, they seem no never be (re)set on NT */
    lpdcb->fBinary = 1;
    lpdcb->fParity = 0;
 
    lpdcb->BaudRate = sbr.BaudRate;
 
    lpdcb->StopBits = slc.StopBits;
    lpdcb->Parity = slc.Parity;
    lpdcb->ByteSize = slc.WordLength;
 
    if (shf.ControlHandShake & SERIAL_CTS_HANDSHAKE)    lpdcb->fOutxCtsFlow = 1;
    if (shf.ControlHandShake & SERIAL_DSR_HANDSHAKE)    lpdcb->fOutxDsrFlow = 1;
    switch (shf.ControlHandShake & (SERIAL_DTR_CONTROL | SERIAL_DTR_HANDSHAKE))
    {
    case 0:                     lpdcb->fDtrControl = DTR_CONTROL_DISABLE; break;
    case SERIAL_DTR_CONTROL:    lpdcb->fDtrControl = DTR_CONTROL_ENABLE; break;
    case SERIAL_DTR_HANDSHAKE:  lpdcb->fDtrControl = DTR_CONTROL_HANDSHAKE; break;
    }
    switch (shf.FlowReplace & (SERIAL_RTS_CONTROL | SERIAL_RTS_HANDSHAKE))
    {
    case 0:                     lpdcb->fRtsControl = RTS_CONTROL_DISABLE; break;
    case SERIAL_RTS_CONTROL:    lpdcb->fRtsControl = RTS_CONTROL_ENABLE; break;
    case SERIAL_RTS_HANDSHAKE:  lpdcb->fRtsControl = RTS_CONTROL_HANDSHAKE; break;
    case SERIAL_RTS_CONTROL | SERIAL_RTS_HANDSHAKE:
                                lpdcb->fRtsControl = RTS_CONTROL_TOGGLE; break;
    }
    if (shf.ControlHandShake & SERIAL_DSR_SENSITIVITY)  lpdcb->fDsrSensitivity = 1;
    if (shf.ControlHandShake & SERIAL_ERROR_ABORT)      lpdcb->fAbortOnError = 1;
    if (shf.FlowReplace & SERIAL_ERROR_CHAR)            lpdcb->fErrorChar = 1;
    if (shf.FlowReplace & SERIAL_NULL_STRIPPING)        lpdcb->fNull = 1;
    if (shf.FlowReplace & SERIAL_XOFF_CONTINUE)         lpdcb->fTXContinueOnXoff = 1;
    lpdcb->XonLim = shf.XonLimit;
    lpdcb->XoffLim = shf.XoffLimit;
 
    if (shf.FlowReplace & SERIAL_AUTO_TRANSMIT) lpdcb->fOutX = 1;
    if (shf.FlowReplace & SERIAL_AUTO_RECEIVE)  lpdcb->fInX = 1;
 
    lpdcb->EofChar = sc.EofChar;
    lpdcb->ErrorChar = sc.ErrorChar;
    lpdcb->EvtChar = sc.EventChar;
    lpdcb->XonChar = sc.XonChar;
    lpdcb->XoffChar = sc.XoffChar;
 
    TRACE("OK\n");
    dump_dcb(lpdcb);
 
    return TRUE;
}

Referenced by GetCommConfig(), main(), Rs232ConfigurePortWin32(), SerialPortQuery(), test_AbortWaitCts(), test_LoopbackCtsRts(), test_LoopbackDtrDcd(), test_LoopbackDtrDsr(), test_LoopbackDtrRing(), test_LoopbackRead(), test_non_pending_errors(), test_read_write(), test_ReadTimeOut(), test_stdio(), test_WaitCts(), test_WaitDcd(), test_WaitDsr(), test_WaitRing(), and test_waittxempty().

GetCommTimeouts()

BOOL WINAPI GetCommTimeouts	(	HANDLE	hComm,
		LPCOMMTIMEOUTS	lptimeouts
	)

Definition at line 1020 of file comm.c.

{
    SERIAL_TIMEOUTS     st;
    DWORD dwBytesReturned;
 
    TRACE("(%p, %p)\n", hComm, lptimeouts);
    if (!lptimeouts)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
    if (!DeviceIoControl(hComm, IOCTL_SERIAL_GET_TIMEOUTS,
                         NULL, 0, &st, sizeof(st), &dwBytesReturned, NULL))
        return FALSE;
    lptimeouts->ReadIntervalTimeout         = st.ReadIntervalTimeout;
    lptimeouts->ReadTotalTimeoutMultiplier  = st.ReadTotalTimeoutMultiplier;
    lptimeouts->ReadTotalTimeoutConstant    = st.ReadTotalTimeoutConstant;
    lptimeouts->WriteTotalTimeoutMultiplier = st.WriteTotalTimeoutMultiplier;
    lptimeouts->WriteTotalTimeoutConstant   = st.WriteTotalTimeoutConstant;
    return TRUE;
}

Referenced by _SetTransmissionRetryTimeout(), Rs232SetCommunicationTimeoutsWin32(), and SerialPortQuery().

GetDefaultCommConfigA()

BOOL WINAPI GetDefaultCommConfigA	(	LPCSTR	lpszName,
		LPCOMMCONFIG	lpCC,
		LPDWORD	lpdwSize
	)

Definition at line 1436 of file comm.c.

{
    BOOL ret = FALSE;
    UNICODE_STRING lpszNameW;
 
    TRACE("(%s, %p, %p)  *lpdwSize: %u\n", debugstr_a(lpszName), lpCC, lpdwSize, lpdwSize ? *lpdwSize : 0 );
    if(lpszName) RtlCreateUnicodeStringFromAsciiz(&lpszNameW,lpszName);
    else lpszNameW.Buffer = NULL;
 
    ret = GetDefaultCommConfigW(lpszNameW.Buffer,lpCC,lpdwSize);
 
    RtlFreeUnicodeString(&lpszNameW);
    return ret;
}

Referenced by test_BuildCommDCB().

GetDefaultCommConfigW()

BOOL WINAPI GetDefaultCommConfigW	(	LPCWSTR	lpszName,
		LPCOMMCONFIG	lpCC,
		LPDWORD	lpdwSize
	)

Definition at line 1400 of file comm.c.

{
    DWORD (WINAPI *pGetDefaultCommConfig)(LPCWSTR, LPCOMMCONFIG, LPDWORD);
    HMODULE hConfigModule;
    DWORD   res = ERROR_INVALID_PARAMETER;
 
    TRACE("(%s, %p, %p)  *lpdwSize: %u\n", debugstr_w(lpszName), lpCC, lpdwSize, lpdwSize ? *lpdwSize : 0 );
    hConfigModule = LoadLibraryW(lpszSerialUI);
 
    if (hConfigModule) {
        pGetDefaultCommConfig = (void *)GetProcAddress(hConfigModule, "drvGetDefaultCommConfigW");
        if (pGetDefaultCommConfig) {
            res = pGetDefaultCommConfig(lpszName, lpCC, lpdwSize);
        }
        FreeLibrary(hConfigModule);
    }
 
    if (res) SetLastError(res);
    return (res == ERROR_SUCCESS);
}

Referenced by _HandleGetDefaultCommConfig(), and GetDefaultCommConfigA().

PurgeComm()

BOOL WINAPI PurgeComm	(	HANDLE	handle,
		DWORD	flags
	)

Definition at line 641 of file comm.c.

{
    DWORD dwBytesReturned;
    return DeviceIoControl(handle, IOCTL_SERIAL_PURGE, &flags, sizeof(flags),
                           NULL, 0, &dwBytesReturned, NULL);
}

SetCommBreak()

BOOL WINAPI SetCommBreak

(

HANDLE

handle

)

Definition at line 557 of file comm.c.

{
    DWORD dwBytesReturned;
    return DeviceIoControl(handle, IOCTL_SERIAL_SET_BREAK_ON, NULL, 0, NULL, 0, &dwBytesReturned, NULL);
}

Referenced by set_CommBreak().

SetCommConfig()

BOOL WINAPI SetCommConfig	(	HANDLE	hFile,
		LPCOMMCONFIG	lpCommConfig,
		DWORD	dwSize
	)

Definition at line 1316 of file comm.c.

{
    TRACE("(%p, %p, %u)\n", hFile, lpCommConfig, dwSize);
    return SetCommState(hFile,&lpCommConfig->dcb);
}

SetCommMask()

BOOL WINAPI SetCommMask	(	HANDLE	handle,
		DWORD	evtmask
	)

Definition at line 768 of file comm.c.

{
    DWORD dwBytesReturned;
    TRACE("handle %p, mask %x\n", handle, evtmask);
    return DeviceIoControl(handle, IOCTL_SERIAL_SET_WAIT_MASK,
                           &evtmask, sizeof(evtmask), NULL, 0, &dwBytesReturned, NULL);
}

Referenced by reset_CommMask(), test_AbortWaitCts(), test_LoopbackRead(), test_read_write(), test_WaitBreak(), test_WaitCommEvent(), test_WaitCts(), test_WaitDcd(), test_WaitDsr(), test_WaitRing(), test_WaitRx(), and test_waittxempty().

SetCommState()

BOOL WINAPI SetCommState	(	HANDLE	handle,
		LPDCB	lpdcb
	)

Definition at line 807 of file comm.c.

{
    SERIAL_BAUD_RATE           sbr;
    SERIAL_LINE_CONTROL        slc;
    SERIAL_HANDFLOW            shf;
    SERIAL_CHARS               sc;
    DWORD dwBytesReturned;
 
    TRACE("handle %p, ptr %p\n", handle, lpdcb);
 
    if (lpdcb == NULL)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
    dump_dcb(lpdcb);
 
    sbr.BaudRate = lpdcb->BaudRate;
             
    slc.StopBits = lpdcb->StopBits;
    slc.Parity = lpdcb->Parity;
    slc.WordLength = lpdcb->ByteSize;
 
    shf.ControlHandShake = 0;
    shf.FlowReplace = 0;
    if (lpdcb->fOutxCtsFlow)      shf.ControlHandShake |= SERIAL_CTS_HANDSHAKE;
    if (lpdcb->fOutxDsrFlow)      shf.ControlHandShake |= SERIAL_DSR_HANDSHAKE;
    switch (lpdcb->fDtrControl)
    {
    case DTR_CONTROL_DISABLE:                                                  break;
    case DTR_CONTROL_ENABLE:      shf.ControlHandShake |= SERIAL_DTR_CONTROL;  break;
    case DTR_CONTROL_HANDSHAKE:   shf.ControlHandShake |= SERIAL_DTR_HANDSHAKE;break;
    default:
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
    switch (lpdcb->fRtsControl)
    {
    case RTS_CONTROL_DISABLE:                                                  break;
    case RTS_CONTROL_ENABLE:      shf.FlowReplace |= SERIAL_RTS_CONTROL;       break;
    case RTS_CONTROL_HANDSHAKE:   shf.FlowReplace |= SERIAL_RTS_HANDSHAKE;     break;
    case RTS_CONTROL_TOGGLE:      shf.FlowReplace |= SERIAL_RTS_CONTROL | 
                                                     SERIAL_RTS_HANDSHAKE;     break;
    default:
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
    if (lpdcb->fDsrSensitivity)   shf.ControlHandShake |= SERIAL_DSR_SENSITIVITY;
    if (lpdcb->fAbortOnError)     shf.ControlHandShake |= SERIAL_ERROR_ABORT;
 
    if (lpdcb->fErrorChar)        shf.FlowReplace |= SERIAL_ERROR_CHAR;
    if (lpdcb->fNull)             shf.FlowReplace |= SERIAL_NULL_STRIPPING;
    if (lpdcb->fTXContinueOnXoff) shf.FlowReplace |= SERIAL_XOFF_CONTINUE;
    if (lpdcb->fOutX)             shf.FlowReplace |= SERIAL_AUTO_TRANSMIT;
    if (lpdcb->fInX)              shf.FlowReplace |= SERIAL_AUTO_RECEIVE;
 
    shf.XonLimit = lpdcb->XonLim;
    shf.XoffLimit = lpdcb->XoffLim;
 
    sc.EofChar = lpdcb->EofChar;
    sc.ErrorChar = lpdcb->ErrorChar;
    sc.BreakChar = 0;
    sc.EventChar = lpdcb->EvtChar;
    sc.XonChar = lpdcb->XonChar;
    sc.XoffChar = lpdcb->XoffChar;
 
    /* note: change DTR/RTS lines after setting the comm attributes,
     * so flow control does not interfere.
     */
    return (DeviceIoControl(handle, IOCTL_SERIAL_SET_BAUD_RATE,
                            &sbr, sizeof(sbr), NULL, 0, &dwBytesReturned, NULL) &&
            DeviceIoControl(handle, IOCTL_SERIAL_SET_LINE_CONTROL,
                            &slc, sizeof(slc), NULL, 0, &dwBytesReturned, NULL) &&
            DeviceIoControl(handle, IOCTL_SERIAL_SET_HANDFLOW,
                            &shf, sizeof(shf), NULL, 0, &dwBytesReturned, NULL) &&
            DeviceIoControl(handle, IOCTL_SERIAL_SET_CHARS,
                            &sc, sizeof(sc), NULL, 0, &dwBytesReturned, NULL));
}

Referenced by main(), Rs232ConfigurePortWin32(), SerialPortQuery(), SetCommConfig(), test_LoopbackRead(), test_non_pending_errors(), test_read_write(), test_ReadTimeOut(), test_WaitCts(), and test_waittxempty().

SetCommTimeouts()

BOOL WINAPI SetCommTimeouts	(	HANDLE	hComm,
		LPCOMMTIMEOUTS	lptimeouts
	)

Definition at line 1062 of file comm.c.

{
    SERIAL_TIMEOUTS     st;
    DWORD dwBytesReturned;
 
    TRACE("(%p, %p)\n", hComm, lptimeouts);
 
    if (lptimeouts == NULL)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
    st.ReadIntervalTimeout         = lptimeouts->ReadIntervalTimeout;
    st.ReadTotalTimeoutMultiplier  = lptimeouts->ReadTotalTimeoutMultiplier;
    st.ReadTotalTimeoutConstant    = lptimeouts->ReadTotalTimeoutConstant;
    st.WriteTotalTimeoutMultiplier = lptimeouts->WriteTotalTimeoutMultiplier;
    st.WriteTotalTimeoutConstant   = lptimeouts->WriteTotalTimeoutConstant;
 
    return DeviceIoControl(hComm, IOCTL_SERIAL_SET_TIMEOUTS,
                           &st, sizeof(st), NULL, 0, &dwBytesReturned, NULL);
}

Referenced by _SetTransmissionRetryTimeout(), LocalmonSetPortTimeOuts(), Rs232SetCommunicationTimeoutsWin32(), SerialPortQuery(), test_LoopbackRead(), test_read_write(), test_ReadTimeOut(), and test_waittxempty().

SetDefaultCommConfigA()

BOOL WINAPI SetDefaultCommConfigA	(	LPCSTR	lpszDevice,
		LPCOMMCONFIG	lpCommConfig,
		DWORD	dwSize
	)

Definition at line 1370 of file comm.c.

{
    BOOL r;
    LPWSTR lpDeviceW = NULL;
    DWORD len;
 
    TRACE("(%s, %p, %u)\n", debugstr_a(lpszDevice), lpCommConfig, dwSize);
 
    if (lpszDevice)
    {
        len = MultiByteToWideChar( CP_ACP, 0, lpszDevice, -1, NULL, 0 );
        lpDeviceW = HeapAlloc( GetProcessHeap(), 0, len*sizeof(WCHAR) );
        MultiByteToWideChar( CP_ACP, 0, lpszDevice, -1, lpDeviceW, len );
    }
    r = SetDefaultCommConfigW(lpDeviceW,lpCommConfig,dwSize);
    HeapFree( GetProcessHeap(), 0, lpDeviceW );
    return r;
}

SetDefaultCommConfigW()

BOOL WINAPI SetDefaultCommConfigW	(	LPCWSTR	lpszDevice,
		LPCOMMCONFIG	lpCommConfig,
		DWORD	dwSize
	)

Definition at line 1340 of file comm.c.

{
    BOOL (WINAPI *lpfnSetDefaultCommConfig)(LPCWSTR, LPCOMMCONFIG, DWORD);
    HMODULE hConfigModule;
    BOOL r = FALSE;
 
    TRACE("(%s, %p, %u)\n", debugstr_w(lpszDevice), lpCommConfig, dwSize);
 
    hConfigModule = LoadLibraryW(lpszSerialUI);
    if(!hConfigModule)
        return r;
 
    lpfnSetDefaultCommConfig = (void *)GetProcAddress(hConfigModule, "drvSetDefaultCommConfigW");
    if (lpfnSetDefaultCommConfig)
        r = lpfnSetDefaultCommConfig(lpszDevice, lpCommConfig, dwSize);
 
    FreeLibrary(hConfigModule);
 
    return r;
}

Referenced by _HandleSetDefaultCommConfig(), and SetDefaultCommConfigA().

SetupComm()

BOOL WINAPI SetupComm	(	HANDLE	handle,
		DWORD	insize,
		DWORD	outsize
	)

Definition at line 718 of file comm.c.

{
    SERIAL_QUEUE_SIZE   sqs;
    DWORD dwBytesReturned;
 
    sqs.InSize = insize;
    sqs.OutSize = outsize;
    return DeviceIoControl(handle, IOCTL_SERIAL_SET_QUEUE_SIZE,
                           &sqs, sizeof(sqs), NULL, 0, &dwBytesReturned, NULL);
}

Referenced by test_read_write(), and test_waittxempty().

TransmitCommChar()

BOOL WINAPI TransmitCommChar	(	HANDLE	hComm,
		CHAR	chTransmit
	)

Definition at line 998 of file comm.c.

{
    DWORD dwBytesReturned;
    return DeviceIoControl(hComm, IOCTL_SERIAL_IMMEDIATE_CHAR,
                           &chTransmit, sizeof(chTransmit), NULL, 0, &dwBytesReturned, NULL);
}

WaitCommEvent()

BOOL WINAPI WaitCommEvent	(	HANDLE	hFile,
		LPDWORD	lpdwEvents,
		LPOVERLAPPED	lpOverlapped
	)

Definition at line 1123 of file comm.c.

{
    return DeviceIoControl(hFile, IOCTL_SERIAL_WAIT_ON_MASK, NULL, 0,
                           lpdwEvents, sizeof(DWORD), NULL, lpOverlapped);
}

Referenced by test_AbortWaitCts(), test_LoopbackRead(), test_read_write(), test_WaitBreak(), test_WaitCommEvent(), test_WaitCts(), test_WaitDcd(), test_WaitDsr(), test_WaitRing(), test_WaitRx(), and test_waittxempty().

Variable Documentation

lpszSerialUI

const WCHAR lpszSerialUI[]

static

Initial value:

= { 
   's','e','r','i','a','l','u','i','.','d','l','l',0 }

Definition at line 1193 of file comm.c.

Referenced by CommConfigDialogW(), GetDefaultCommConfigW(), and SetDefaultCommConfigW().