#include "tclWinInt.h"
#include <fcntl.h>
#include <io.h>
#include <sys/stat.h>
static int initialized = 0;
TCL_DECLARE_MUTEX(serialMutex)
#define SERIAL_PENDING (1<<0)
#define SERIAL_ASYNC (1<<1)
#define SERIAL_EOF (1<<2)
#define SERIAL_ERROR (1<<4)
#define SERIAL_DEFAULT_BLOCKTIME 10
#define SERIAL_READ_ERRORS ( CE_RXOVER | CE_OVERRUN | CE_RXPARITY \
| CE_FRAME | CE_BREAK )
#define SERIAL_WRITE_ERRORS ( CE_TXFULL | CE_PTO )
typedef struct SerialInfo {
HANDLE handle;
struct SerialInfo *nextPtr;
Tcl_Channel channel;
int validMask;
int watchMask;
int flags;
int readable;
int writable;
int blockTime;
unsigned int lastEventTime;
DWORD error;
DWORD lastError;
DWORD sysBufRead;
DWORD sysBufWrite;
Tcl_ThreadId threadId;
OVERLAPPED osRead;
OVERLAPPED osWrite;
HANDLE writeThread;
CRITICAL_SECTION csWrite;
HANDLE evWritable;
HANDLE evStartWriter;
DWORD writeError;
char *writeBuf;
int writeBufLen;
int toWrite;
int writeQueue;
} SerialInfo;
typedef struct ThreadSpecificData {
SerialInfo *firstSerialPtr;
} ThreadSpecificData;
static Tcl_ThreadDataKey dataKey;
typedef struct SerialEvent {
Tcl_Event header;
SerialInfo *infoPtr;
} SerialEvent;
static COMMTIMEOUTS no_timeout = {
0,
0,
0,
0,
0,
};
static int SerialBlockProc(ClientData instanceData, int mode);
static void SerialCheckProc(ClientData clientData, int flags);
static int SerialCloseProc(ClientData instanceData,
Tcl_Interp *interp);
static int SerialEventProc(Tcl_Event *evPtr, int flags);
static void SerialExitHandler(ClientData clientData);
static int SerialGetHandleProc(ClientData instanceData,
int direction, ClientData *handlePtr);
static ThreadSpecificData *SerialInit(void);
static int SerialInputProc(ClientData instanceData, char *buf,
int toRead, int *errorCode);
static int SerialOutputProc(ClientData instanceData, CONST char *buf,
int toWrite, int *errorCode);
static void SerialSetupProc(ClientData clientData, int flags);
static void SerialWatchProc(ClientData instanceData, int mask);
static void ProcExitHandler(ClientData clientData);
static int SerialGetOptionProc _ANSI_ARGS_((ClientData instanceData,
Tcl_Interp *interp, CONST char *optionName,
Tcl_DString *dsPtr));
static int SerialSetOptionProc _ANSI_ARGS_((ClientData instanceData,
Tcl_Interp *interp, CONST char *optionName,
CONST char *value));
static DWORD WINAPI SerialWriterThread(LPVOID arg);
static Tcl_ChannelType serialChannelType = {
"serial",
TCL_CHANNEL_VERSION_2,
SerialCloseProc,
SerialInputProc,
SerialOutputProc,
NULL,
SerialSetOptionProc,
SerialGetOptionProc,
SerialWatchProc,
SerialGetHandleProc,
NULL,
SerialBlockProc,
NULL,
NULL,
};
static ThreadSpecificData *
SerialInit()
{
ThreadSpecificData *tsdPtr;
if (!initialized) {
Tcl_MutexLock(&serialMutex);
if (!initialized) {
initialized = 1;
Tcl_CreateExitHandler(ProcExitHandler, NULL);
}
Tcl_MutexUnlock(&serialMutex);
}
tsdPtr = (ThreadSpecificData *)TclThreadDataKeyGet(&dataKey);
if (tsdPtr == NULL) {
tsdPtr = TCL_TSD_INIT(&dataKey);
tsdPtr->firstSerialPtr = NULL;
Tcl_CreateEventSource(SerialSetupProc, SerialCheckProc, NULL);
Tcl_CreateThreadExitHandler(SerialExitHandler, NULL);
}
return tsdPtr;
}
static void
SerialExitHandler(
ClientData clientData)
{
ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
SerialInfo *infoPtr;
for (infoPtr = tsdPtr->firstSerialPtr; infoPtr != NULL;
infoPtr = infoPtr->nextPtr) {
PurgeComm(infoPtr->handle, PURGE_TXABORT | PURGE_RXABORT | PURGE_TXCLEAR
| PURGE_RXCLEAR);
}
Tcl_DeleteEventSource(SerialSetupProc, SerialCheckProc, NULL);
}
static void
ProcExitHandler(
ClientData clientData)
{
Tcl_MutexLock(&serialMutex);
initialized = 0;
Tcl_MutexUnlock(&serialMutex);
}
static void
SerialBlockTime(
int msec)
{
Tcl_Time blockTime;
blockTime.sec = msec / 1000;
blockTime.usec = (msec % 1000) * 1000;
Tcl_SetMaxBlockTime(&blockTime);
}
static unsigned int
SerialGetMilliseconds(
void)
{
Tcl_Time time;
TclpGetTime(&time);
return (time.sec * 1000 + time.usec / 1000);
}
void
SerialSetupProc(
ClientData data,
int flags)
{
SerialInfo *infoPtr;
int block = 1;
int msec = INT_MAX;
ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
if (!(flags & TCL_FILE_EVENTS)) {
return;
}
for (infoPtr = tsdPtr->firstSerialPtr; infoPtr != NULL;
infoPtr = infoPtr->nextPtr) {
if (infoPtr->watchMask & TCL_WRITABLE) {
if (WaitForSingleObject(infoPtr->evWritable, 0) != WAIT_TIMEOUT) {
block = 0;
msec = min( msec, infoPtr->blockTime );
}
}
if( infoPtr->watchMask & TCL_READABLE ) {
block = 0;
msec = min( msec, infoPtr->blockTime );
}
}
if (!block) {
SerialBlockTime(msec);
}
}
static void
SerialCheckProc(
ClientData data,
int flags)
{
SerialInfo *infoPtr;
SerialEvent *evPtr;
int needEvent;
ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
COMSTAT cStat;
unsigned int time;
if (!(flags & TCL_FILE_EVENTS)) {
return;
}
for (infoPtr = tsdPtr->firstSerialPtr; infoPtr != NULL;
infoPtr = infoPtr->nextPtr) {
if (infoPtr->flags & SERIAL_PENDING) {
continue;
}
needEvent = 0;
if (infoPtr->watchMask & TCL_WRITABLE) {
if (WaitForSingleObject(infoPtr->evWritable, 0) != WAIT_TIMEOUT) {
infoPtr->writable = 1;
needEvent = 1;
}
}
if( infoPtr->watchMask & TCL_READABLE ) {
if( ClearCommError( infoPtr->handle, &infoPtr->error, &cStat ) ) {
if( infoPtr->watchMask & TCL_READABLE ) {
if( (cStat.cbInQue > 0) ||
(infoPtr->error & SERIAL_READ_ERRORS) ) {
infoPtr->readable = 1;
time = SerialGetMilliseconds();
if ((unsigned int) (time - infoPtr->lastEventTime)
>= (unsigned int) infoPtr->blockTime) {
needEvent = 1;
infoPtr->lastEventTime = time;
}
}
}
}
}
if (needEvent) {
infoPtr->flags |= SERIAL_PENDING;
evPtr = (SerialEvent *) ckalloc(sizeof(SerialEvent));
evPtr->header.proc = SerialEventProc;
evPtr->infoPtr = infoPtr;
Tcl_QueueEvent((Tcl_Event *) evPtr, TCL_QUEUE_TAIL);
}
}
}
static int
SerialBlockProc(
ClientData instanceData,
int mode)
{
int errorCode = 0;
SerialInfo *infoPtr = (SerialInfo *) instanceData;
if (mode == TCL_MODE_NONBLOCKING) {
infoPtr->flags |= SERIAL_ASYNC;
} else {
infoPtr->flags &= ~(SERIAL_ASYNC);
}
return errorCode;
}
static int
SerialCloseProc(
ClientData instanceData,
Tcl_Interp *interp)
{
SerialInfo *serialPtr = (SerialInfo *) instanceData;
int errorCode, result = 0;
SerialInfo *infoPtr, **nextPtrPtr;
ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
errorCode = 0;
if (serialPtr->validMask & TCL_READABLE) {
PurgeComm(serialPtr->handle, PURGE_RXABORT | PURGE_RXCLEAR);
CloseHandle(serialPtr->osRead.hEvent);
}
serialPtr->validMask &= ~TCL_READABLE;
if (serialPtr->validMask & TCL_WRITABLE) {
Tcl_MutexLock(&serialMutex);
TerminateThread(serialPtr->writeThread, 0);
Tcl_MutexUnlock(&serialMutex);
WaitForSingleObject(serialPtr->writeThread, INFINITE);
CloseHandle(serialPtr->writeThread);
CloseHandle(serialPtr->evWritable);
CloseHandle(serialPtr->evStartWriter);
serialPtr->writeThread = NULL;
PurgeComm(serialPtr->handle, PURGE_TXABORT | PURGE_TXCLEAR);
}
serialPtr->validMask &= ~TCL_WRITABLE;
if (!TclInExit()
|| ((GetStdHandle(STD_INPUT_HANDLE) != serialPtr->handle)
&& (GetStdHandle(STD_OUTPUT_HANDLE) != serialPtr->handle)
&& (GetStdHandle(STD_ERROR_HANDLE) != serialPtr->handle))) {
if (CloseHandle(serialPtr->handle) == FALSE) {
TclWinConvertError(GetLastError());
errorCode = errno;
}
}
serialPtr->watchMask &= serialPtr->validMask;
for (nextPtrPtr = &(tsdPtr->firstSerialPtr), infoPtr = *nextPtrPtr;
infoPtr != NULL;
nextPtrPtr = &infoPtr->nextPtr, infoPtr = *nextPtrPtr) {
if (infoPtr == (SerialInfo *)serialPtr) {
*nextPtrPtr = infoPtr->nextPtr;
break;
}
}
if (serialPtr->writeBuf != NULL) {
ckfree(serialPtr->writeBuf);
serialPtr->writeBuf = NULL;
}
ckfree((char*) serialPtr);
if (errorCode == 0) {
return result;
}
return errorCode;
}
static int
blockingRead(
SerialInfo *infoPtr,
LPVOID buf,
DWORD bufSize,
LPDWORD lpRead,
LPOVERLAPPED osPtr )
{
osPtr->Offset = osPtr->OffsetHigh = 0;
ResetEvent(osPtr->hEvent);
if (! ReadFile(infoPtr->handle, buf, bufSize, lpRead, osPtr) ) {
if (GetLastError() != ERROR_IO_PENDING) {
return FALSE;
} else {
if (! GetOverlappedResult(infoPtr->handle, osPtr, lpRead, TRUE) ) {
return FALSE;
}
}
} else {
}
return TRUE;
}
static int
blockingWrite(
SerialInfo *infoPtr,
LPVOID buf,
DWORD bufSize,
LPDWORD lpWritten,
LPOVERLAPPED osPtr )
{
int result;
ResetEvent(osPtr->hEvent);
EnterCriticalSection(&infoPtr->csWrite);
infoPtr->writeQueue -= bufSize;
osPtr->Offset = osPtr->OffsetHigh = 0;
result = WriteFile(infoPtr->handle, buf, bufSize, lpWritten, osPtr);
LeaveCriticalSection(&infoPtr->csWrite);
if (result == FALSE ) {
int err = GetLastError();
switch (err) {
case ERROR_IO_PENDING:
if (! GetOverlappedResult(infoPtr->handle, osPtr, lpWritten, TRUE) ) {
return FALSE;
}
break;
case ERROR_COUNTER_TIMEOUT:
break;
default:
return FALSE;
}
} else {
}
EnterCriticalSection(&infoPtr->csWrite);
infoPtr->writeQueue += (*lpWritten - bufSize);
LeaveCriticalSection(&infoPtr->csWrite);
return TRUE;
}
static int
SerialInputProc(
ClientData instanceData,
char *buf,
int bufSize,
int *errorCode)
{
SerialInfo *infoPtr = (SerialInfo *) instanceData;
DWORD bytesRead = 0;
COMSTAT cStat;
*errorCode = 0;
if( infoPtr->error & SERIAL_READ_ERRORS ){
goto commError;
}
if( ClearCommError( infoPtr->handle, &infoPtr->error, &cStat ) ) {
if( infoPtr->error & SERIAL_READ_ERRORS ) {
goto commError;
}
if( infoPtr->flags & SERIAL_ASYNC ) {
if( cStat.cbInQue > 0 ) {
if( (DWORD) bufSize > cStat.cbInQue ) {
bufSize = cStat.cbInQue;
}
} else {
errno = *errorCode = EAGAIN;
return -1;
}
} else {
if( cStat.cbInQue > 0 ) {
if( (DWORD) bufSize > cStat.cbInQue ) {
bufSize = cStat.cbInQue;
}
} else {
bufSize = 1;
}
}
}
if( bufSize == 0 ) {
return bytesRead = 0;
}
if (blockingRead(infoPtr, (LPVOID) buf, (DWORD) bufSize, &bytesRead,
&infoPtr->osRead) == FALSE) {
goto error;
}
return bytesRead;
error:
TclWinConvertError(GetLastError());
*errorCode = errno;
return -1;
commError:
infoPtr->lastError = infoPtr->error;
infoPtr->error = 0;
*errorCode = EIO;
return -1;
}
static int
SerialOutputProc(
ClientData instanceData,
CONST char *buf,
int toWrite,
int *errorCode)
{
SerialInfo *infoPtr = (SerialInfo *) instanceData;
int bytesWritten, timeout;
*errorCode = 0;
if( ! initialized || TclInExit() ) {
return toWrite;
}
if( infoPtr->error & SERIAL_WRITE_ERRORS ){
infoPtr->lastError = infoPtr->error;
infoPtr->error = 0;
errno = EIO;
goto error;
}
timeout = (infoPtr->flags & SERIAL_ASYNC) ? 0 : INFINITE;
if (WaitForSingleObject(infoPtr->evWritable, timeout) == WAIT_TIMEOUT) {
errno = EWOULDBLOCK;
goto error1;
}
if (infoPtr->writeError) {
TclWinConvertError(infoPtr->writeError);
infoPtr->writeError = 0;
goto error1;
}
EnterCriticalSection(&infoPtr->csWrite);
infoPtr->writeQueue += toWrite;
LeaveCriticalSection(&infoPtr->csWrite);
if (infoPtr->flags & SERIAL_ASYNC) {
if (toWrite > infoPtr->writeBufLen) {
if (infoPtr->writeBuf) {
ckfree(infoPtr->writeBuf);
}
infoPtr->writeBufLen = toWrite;
infoPtr->writeBuf = ckalloc(toWrite);
}
memcpy(infoPtr->writeBuf, buf, toWrite);
infoPtr->toWrite = toWrite;
ResetEvent(infoPtr->evWritable);
SetEvent(infoPtr->evStartWriter);
bytesWritten = toWrite;
} else {
if (! blockingWrite(infoPtr, (LPVOID) buf, (DWORD) toWrite,
&bytesWritten, &infoPtr->osWrite) ) {
goto writeError;
}
if (bytesWritten != toWrite) {
infoPtr->lastError |= CE_PTO;
errno = EIO;
goto error;
}
}
return bytesWritten;
writeError:
TclWinConvertError(GetLastError());
error:
error1:
*errorCode = errno;
return -1;
}
static int
SerialEventProc(
Tcl_Event *evPtr,
int flags)
{
SerialEvent *serialEvPtr = (SerialEvent *)evPtr;
SerialInfo *infoPtr;
int mask;
ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
if (!(flags & TCL_FILE_EVENTS)) {
return 0;
}
for (infoPtr = tsdPtr->firstSerialPtr; infoPtr != NULL;
infoPtr = infoPtr->nextPtr) {
if (serialEvPtr->infoPtr == infoPtr) {
infoPtr->flags &= ~(SERIAL_PENDING);
break;
}
}
if (!infoPtr) {
return 1;
}
mask = 0;
if( infoPtr->watchMask & TCL_WRITABLE ) {
if( infoPtr->writable ) {
mask |= TCL_WRITABLE;
infoPtr->writable = 0;
}
}
if( infoPtr->watchMask & TCL_READABLE ) {
if( infoPtr->readable ) {
mask |= TCL_READABLE;
infoPtr->readable = 0;
}
}
Tcl_NotifyChannel(infoPtr->channel, infoPtr->watchMask & mask);
return 1;
}
static void
SerialWatchProc(
ClientData instanceData,
int mask)
{
SerialInfo **nextPtrPtr, *ptr;
SerialInfo *infoPtr = (SerialInfo *) instanceData;
int oldMask = infoPtr->watchMask;
ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
infoPtr->watchMask = mask & infoPtr->validMask;
if (infoPtr->watchMask) {
if (!oldMask) {
infoPtr->nextPtr = tsdPtr->firstSerialPtr;
tsdPtr->firstSerialPtr = infoPtr;
}
SerialBlockTime(infoPtr->blockTime);
} else {
if (oldMask) {
for (nextPtrPtr = &(tsdPtr->firstSerialPtr), ptr = *nextPtrPtr;
ptr != NULL;
nextPtrPtr = &ptr->nextPtr, ptr = *nextPtrPtr) {
if (infoPtr == ptr) {
*nextPtrPtr = ptr->nextPtr;
break;
}
}
}
}
}
static int
SerialGetHandleProc(
ClientData instanceData,
int direction,
ClientData *handlePtr)
{
SerialInfo *infoPtr = (SerialInfo *) instanceData;
*handlePtr = (ClientData) infoPtr->handle;
return TCL_OK;
}
static DWORD WINAPI
SerialWriterThread(LPVOID arg)
{
SerialInfo *infoPtr = (SerialInfo *)arg;
HANDLE *handle = infoPtr->handle;
DWORD bytesWritten, toWrite;
char *buf;
OVERLAPPED myWrite;
for (;;) {
WaitForSingleObject(infoPtr->evStartWriter, INFINITE);
buf = infoPtr->writeBuf;
toWrite = infoPtr->toWrite;
myWrite.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
while (toWrite > 0) {
if (infoPtr->writeError) {
break;
}
if (blockingWrite(infoPtr, (LPVOID) buf, (DWORD) toWrite,
&bytesWritten, &myWrite) == FALSE) {
infoPtr->writeError = GetLastError();
break;
}
if (bytesWritten != toWrite) {
infoPtr->writeError = ERROR_WRITE_FAULT;
break;
}
toWrite -= bytesWritten;
buf += bytesWritten;
}
CloseHandle(myWrite.hEvent);
SetEvent(infoPtr->evWritable);
Tcl_MutexLock(&serialMutex);
Tcl_ThreadAlert(infoPtr->threadId);
Tcl_MutexUnlock(&serialMutex);
}
return 0;
}
HANDLE
TclWinSerialReopen(handle, name, access)
HANDLE handle;
CONST TCHAR *name;
DWORD access;
{
ThreadSpecificData *tsdPtr;
tsdPtr = SerialInit();
if (CloseHandle(handle) == FALSE) {
return INVALID_HANDLE_VALUE;
}
handle = (*tclWinProcs->createFileProc)(name, access,
0, 0, OPEN_EXISTING, FILE_FLAG_OVERLAPPED, 0);
return handle;
}
Tcl_Channel
TclWinOpenSerialChannel(handle, channelName, permissions)
HANDLE handle;
char *channelName;
int permissions;
{
SerialInfo *infoPtr;
ThreadSpecificData *tsdPtr;
DWORD id;
tsdPtr = SerialInit();
infoPtr = (SerialInfo *) ckalloc((unsigned) sizeof(SerialInfo));
memset(infoPtr, 0, sizeof(SerialInfo));
infoPtr->validMask = permissions;
infoPtr->handle = handle;
wsprintfA(channelName, "file%lx", (int) infoPtr);
infoPtr->channel = Tcl_CreateChannel(&serialChannelType, channelName,
(ClientData) infoPtr, permissions);
infoPtr->readable = 0;
infoPtr->writable = 1;
infoPtr->toWrite = infoPtr->writeQueue = 0;
infoPtr->blockTime = SERIAL_DEFAULT_BLOCKTIME;
infoPtr->lastEventTime = 0;
infoPtr->lastError = infoPtr->error = 0;
infoPtr->threadId = Tcl_GetCurrentThread();
infoPtr->sysBufRead = infoPtr->sysBufWrite = 4096;
SetupComm(handle, infoPtr->sysBufRead, infoPtr->sysBufWrite);
PurgeComm(handle, PURGE_TXABORT | PURGE_RXABORT | PURGE_TXCLEAR
| PURGE_RXCLEAR);
SetCommTimeouts(handle, &no_timeout);
if (permissions & TCL_READABLE) {
infoPtr->osRead.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
}
if (permissions & TCL_WRITABLE) {
infoPtr->osWrite.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
infoPtr->evWritable = CreateEvent(NULL, TRUE, TRUE, NULL);
infoPtr->evStartWriter = CreateEvent(NULL, FALSE, FALSE, NULL);
InitializeCriticalSection(&infoPtr->csWrite);
infoPtr->writeThread = CreateThread(NULL, 8000, SerialWriterThread,
infoPtr, 0, &id);
}
Tcl_SetChannelOption(NULL, infoPtr->channel, "-translation", "auto");
Tcl_SetChannelOption(NULL, infoPtr->channel, "-eofchar", "\032 {}");
return infoPtr->channel;
}
static void
SerialErrorStr(error, dsPtr)
DWORD error;
Tcl_DString *dsPtr;
{
if( (error & CE_RXOVER) != 0) {
Tcl_DStringAppendElement(dsPtr, "RXOVER");
}
if( (error & CE_OVERRUN) != 0) {
Tcl_DStringAppendElement(dsPtr, "OVERRUN");
}
if( (error & CE_RXPARITY) != 0) {
Tcl_DStringAppendElement(dsPtr, "RXPARITY");
}
if( (error & CE_FRAME) != 0) {
Tcl_DStringAppendElement(dsPtr, "FRAME");
}
if( (error & CE_BREAK) != 0) {
Tcl_DStringAppendElement(dsPtr, "BREAK");
}
if( (error & CE_TXFULL) != 0) {
Tcl_DStringAppendElement(dsPtr, "TXFULL");
}
if( (error & CE_PTO) != 0) {
Tcl_DStringAppendElement(dsPtr, "TIMEOUT");
}
if( (error & ~(SERIAL_READ_ERRORS | SERIAL_WRITE_ERRORS)) != 0) {
char buf[TCL_INTEGER_SPACE + 1];
wsprintfA(buf, "%d", error);
Tcl_DStringAppendElement(dsPtr, buf);
}
}
static void
SerialModemStatusStr(status, dsPtr)
DWORD status;
Tcl_DString *dsPtr;
{
Tcl_DStringAppendElement(dsPtr, "CTS");
Tcl_DStringAppendElement(dsPtr, (status & MS_CTS_ON) ? "1" : "0");
Tcl_DStringAppendElement(dsPtr, "DSR");
Tcl_DStringAppendElement(dsPtr, (status & MS_DSR_ON) ? "1" : "0");
Tcl_DStringAppendElement(dsPtr, "RING");
Tcl_DStringAppendElement(dsPtr, (status & MS_RING_ON) ? "1" : "0");
Tcl_DStringAppendElement(dsPtr, "DCD");
Tcl_DStringAppendElement(dsPtr, (status & MS_RLSD_ON) ? "1" : "0");
}
static int
SerialSetOptionProc(instanceData, interp, optionName, value)
ClientData instanceData;
Tcl_Interp *interp;
CONST char *optionName;
CONST char *value;
{
SerialInfo *infoPtr;
DCB dcb;
BOOL result, flag;
size_t len, vlen;
Tcl_DString ds;
CONST TCHAR *native;
int argc;
char **argv;
infoPtr = (SerialInfo *) instanceData;
len = strlen(optionName);
vlen = strlen(value);
if ((len > 2) && (strncmp(optionName, "-mode", len) == 0)) {
if (! GetCommState(infoPtr->handle, &dcb)) {
if (interp) {
Tcl_AppendResult(interp,
"can't get comm state", (char *) NULL);
}
return TCL_ERROR;
}
native = Tcl_WinUtfToTChar(value, -1, &ds);
result = (*tclWinProcs->buildCommDCBProc)(native, &dcb);
Tcl_DStringFree(&ds);
if (result == FALSE) {
if (interp) {
Tcl_AppendResult(interp,
"bad value for -mode: should be baud,parity,data,stop",
(char *) NULL);
}
return TCL_ERROR;
}
dcb.fBinary = TRUE;
dcb.fErrorChar = FALSE;
dcb.fNull = FALSE;
dcb.fAbortOnError = FALSE;
if (! SetCommState(infoPtr->handle, &dcb) ) {
if (interp) {
Tcl_AppendResult(interp,
"can't set comm state", (char *) NULL);
}
return TCL_ERROR;
}
return TCL_OK;
}
if ((len > 1) && (strncmp(optionName, "-handshake", len) == 0)) {
if (! GetCommState(infoPtr->handle, &dcb)) {
if (interp) {
Tcl_AppendResult(interp,
"can't get comm state", (char *) NULL);
}
return TCL_ERROR;
}
dcb.fOutX = dcb.fInX = FALSE;
dcb.fOutxCtsFlow = dcb.fOutxDsrFlow = dcb.fDsrSensitivity = FALSE;
dcb.fDtrControl = DTR_CONTROL_ENABLE;
dcb.fRtsControl = RTS_CONTROL_ENABLE;
dcb.fTXContinueOnXoff = FALSE;
dcb.XonLim = (WORD) (infoPtr->sysBufRead*1/2);
dcb.XoffLim = (WORD) (infoPtr->sysBufRead*1/4);
if (strnicmp(value, "NONE", vlen) == 0) {
} else if (strnicmp(value, "XONXOFF", vlen) == 0) {
dcb.fOutX = dcb.fInX = TRUE;
} else if (strnicmp(value, "RTSCTS", vlen) == 0) {
dcb.fOutxCtsFlow = TRUE;
dcb.fRtsControl = RTS_CONTROL_HANDSHAKE;
} else if (strnicmp(value, "DTRDSR", vlen) == 0) {
dcb.fOutxDsrFlow = TRUE;
dcb.fDtrControl = DTR_CONTROL_HANDSHAKE;
} else {
if (interp) {
Tcl_AppendResult(interp, "bad value for -handshake: ",
"must be one of xonxoff, rtscts, dtrdsr or none",
(char *) NULL);
return TCL_ERROR;
}
}
if (! SetCommState(infoPtr->handle, &dcb)) {
if (interp) {
Tcl_AppendResult(interp,
"can't set comm state", (char *) NULL);
}
return TCL_ERROR;
}
return TCL_OK;
}
if ((len > 1) && (strncmp(optionName, "-xchar", len) == 0)) {
if (! GetCommState(infoPtr->handle, &dcb)) {
if (interp) {
Tcl_AppendResult(interp,
"can't get comm state", (char *) NULL);
}
return TCL_ERROR;
}
if (Tcl_SplitList(interp, value, &argc, &argv) == TCL_ERROR) {
return TCL_ERROR;
}
if (argc == 2) {
dcb.XonChar = argv[0][0];
dcb.XoffChar = argv[1][0];
} else {
if (interp) {
Tcl_AppendResult(interp,
"bad value for -xchar: should be a list of two elements",
(char *) NULL);
}
return TCL_ERROR;
}
if (! SetCommState(infoPtr->handle, &dcb)) {
if (interp) {
Tcl_AppendResult(interp,
"can't set comm state", (char *) NULL);
}
return TCL_ERROR;
}
return TCL_OK;
}
if ((len > 4) && (strncmp(optionName, "-ttycontrol", len) == 0)) {
if (Tcl_SplitList(interp, value, &argc, &argv) == TCL_ERROR) {
return TCL_ERROR;
}
if ((argc % 2) == 1) {
if (interp) {
Tcl_AppendResult(interp,
"bad value for -ttycontrol: should be a list of signal,value pairs",
(char *) NULL);
}
return TCL_ERROR;
}
while (argc > 1) {
if (Tcl_GetBoolean(interp, argv[1], &flag) == TCL_ERROR) {
return TCL_ERROR;
}
if (strnicmp(argv[0], "DTR", strlen(argv[0])) == 0) {
if (! EscapeCommFunction(infoPtr->handle, flag ? SETDTR : CLRDTR)) {
if (interp) {
Tcl_AppendResult(interp,
"can't set DTR signal", (char *) NULL);
}
return TCL_ERROR;
}
} else if (strnicmp(argv[0], "RTS", strlen(argv[0])) == 0) {
if (! EscapeCommFunction(infoPtr->handle, flag ? SETRTS : CLRRTS)) {
if (interp) {
Tcl_AppendResult(interp,
"can't set RTS signal", (char *) NULL);
}
return TCL_ERROR;
}
} else if (strnicmp(argv[0], "BREAK", strlen(argv[0])) == 0) {
if (! EscapeCommFunction(infoPtr->handle, flag ? SETBREAK : CLRBREAK)) {
if (interp) {
Tcl_AppendResult(interp,
"can't set BREAK signal", (char *) NULL);
}
return TCL_ERROR;
}
} else {
if (interp) {
Tcl_AppendResult(interp,
"bad signal for -ttycontrol: must be DTR, RTS or BREAK",
(char *) NULL);
}
return TCL_ERROR;
}
argc -= 2, argv += 2;
}
return TCL_OK;
}
if ((len > 1) && (strncmp(optionName, "-sysbuffer", len) == 0)) {
size_t inSize = -1, outSize = -1;
if (Tcl_SplitList(interp, value, &argc, &argv) == TCL_ERROR) {
return TCL_ERROR;
}
if (argc == 1) {
inSize = atoi(argv[0]);
outSize = infoPtr->sysBufWrite;
} else if (argc == 2) {
inSize = atoi(argv[0]);
outSize = atoi(argv[1]);
}
if ( (inSize <= 0) || (outSize <= 0) ) {
if (interp) {
Tcl_AppendResult(interp,
"bad value for -sysbuffer: should be a list of one or two integers > 0",
(char *) NULL);
}
return TCL_ERROR;
}
if (! SetupComm(infoPtr->handle, inSize, outSize)) {
if (interp) {
Tcl_AppendResult(interp,
"can't setup comm buffers", (char *) NULL);
}
return TCL_ERROR;
}
infoPtr->sysBufRead = inSize;
infoPtr->sysBufWrite = outSize;
if (! GetCommState(infoPtr->handle, &dcb)) {
if (interp) {
Tcl_AppendResult(interp,
"can't get comm state", (char *) NULL);
}
return TCL_ERROR;
}
dcb.XonLim = (WORD) (infoPtr->sysBufRead*1/2);
dcb.XoffLim = (WORD) (infoPtr->sysBufRead*1/4);
if (! SetCommState(infoPtr->handle, &dcb)) {
if (interp) {
Tcl_AppendResult(interp,
"can't set comm state", (char *) NULL);
}
return TCL_ERROR;
}
return TCL_OK;
}
if ((len > 1) && (strncmp(optionName, "-pollinterval", len) == 0)) {
if ( Tcl_GetInt(interp, value, &(infoPtr->blockTime)) != TCL_OK ) {
return TCL_ERROR;
}
return TCL_OK;
}
if ((len > 2) && (strncmp(optionName, "-timeout", len) == 0)) {
int msec;
COMMTIMEOUTS tout = {0,0,0,0,0};
if ( Tcl_GetInt(interp, value, &msec) != TCL_OK ) {
return TCL_ERROR;
}
tout.ReadTotalTimeoutConstant = msec;
if (! SetCommTimeouts(infoPtr->handle, &tout)) {
if (interp) {
Tcl_AppendResult(interp,
"can't set comm timeouts", (char *) NULL);
}
return TCL_ERROR;
}
return TCL_OK;
}
return Tcl_BadChannelOption(interp, optionName,
"mode handshake pollinterval sysbuffer timeout ttycontrol xchar");
}
static int
SerialGetOptionProc(instanceData, interp, optionName, dsPtr)
ClientData instanceData;
Tcl_Interp *interp;
CONST char *optionName;
Tcl_DString *dsPtr;
{
SerialInfo *infoPtr;
DCB dcb;
size_t len;
int valid = 0;
infoPtr = (SerialInfo *) instanceData;
if (optionName == NULL) {
len = 0;
} else {
len = strlen(optionName);
}
if (len == 0) {
Tcl_DStringAppendElement(dsPtr, "-mode");
}
if ((len == 0) ||
((len > 2) && (strncmp(optionName, "-mode", len) == 0))) {
char parity;
char *stop;
char buf[2 * TCL_INTEGER_SPACE + 16];
if (! GetCommState(infoPtr->handle, &dcb)) {
if (interp) {
Tcl_AppendResult(interp,
"can't get comm state", (char *) NULL);
}
return TCL_ERROR;
}
valid = 1;
parity = 'n';
if (dcb.Parity <= 4) {
parity = "noems"[dcb.Parity];
}
stop = (dcb.StopBits == ONESTOPBIT) ? "1" :
(dcb.StopBits == ONE5STOPBITS) ? "1.5" : "2";
wsprintfA(buf, "%d,%c,%d,%s", dcb.BaudRate, parity,
dcb.ByteSize, stop);
Tcl_DStringAppendElement(dsPtr, buf);
}
if (len == 0) {
Tcl_DStringAppendElement(dsPtr, "-pollinterval");
}
if ((len == 0) ||
((len > 1) && (strncmp(optionName, "-pollinterval", len) == 0))) {
char buf[TCL_INTEGER_SPACE + 1];
valid = 1;
wsprintfA(buf, "%d", infoPtr->blockTime);
Tcl_DStringAppendElement(dsPtr, buf);
}
if (len == 0) {
Tcl_DStringAppendElement(dsPtr, "-sysbuffer");
Tcl_DStringStartSublist(dsPtr);
}
if ((len == 0) ||
((len > 1) && (strncmp(optionName, "-sysbuffer", len) == 0))) {
char buf[TCL_INTEGER_SPACE + 1];
valid = 1;
wsprintfA(buf, "%d", infoPtr->sysBufRead);
Tcl_DStringAppendElement(dsPtr, buf);
wsprintfA(buf, "%d", infoPtr->sysBufWrite);
Tcl_DStringAppendElement(dsPtr, buf);
}
if (len == 0) {
Tcl_DStringEndSublist(dsPtr);
}
if (len == 0) {
Tcl_DStringAppendElement(dsPtr, "-xchar");
Tcl_DStringStartSublist(dsPtr);
}
if ((len == 0) ||
((len > 1) && (strncmp(optionName, "-xchar", len) == 0))) {
char buf[4];
valid = 1;
if (! GetCommState(infoPtr->handle, &dcb)) {
if (interp) {
Tcl_AppendResult(interp,
"can't get comm state", (char *) NULL);
}
return TCL_ERROR;
}
sprintf(buf, "%c", dcb.XonChar);
Tcl_DStringAppendElement(dsPtr, buf);
sprintf(buf, "%c", dcb.XoffChar);
Tcl_DStringAppendElement(dsPtr, buf);
}
if (len == 0) {
Tcl_DStringEndSublist(dsPtr);
}
if ( (len > 1) && (strncmp(optionName, "-lasterror", len) == 0) ) {
valid = 1;
SerialErrorStr(infoPtr->lastError, dsPtr);
}
if ((len > 1) && (strncmp(optionName, "-queue", len) == 0)) {
char buf[TCL_INTEGER_SPACE + 1];
COMSTAT cStat;
int error;
int inBuffered, outBuffered, count;
valid = 1;
inBuffered = Tcl_InputBuffered(infoPtr->channel);
outBuffered = Tcl_OutputBuffered(infoPtr->channel);
EnterCriticalSection(&infoPtr->csWrite);
ClearCommError( infoPtr->handle, &error, &cStat );
count = (int)cStat.cbOutQue + infoPtr->writeQueue;
LeaveCriticalSection(&infoPtr->csWrite);
wsprintfA(buf, "%d", inBuffered + cStat.cbInQue);
Tcl_DStringAppendElement(dsPtr, buf);
wsprintfA(buf, "%d", outBuffered + count);
Tcl_DStringAppendElement(dsPtr, buf);
}
if ( (len > 4) && (strncmp(optionName, "-ttystatus", len) == 0) ) {
DWORD status;
if (! GetCommModemStatus(infoPtr->handle, &status)) {
if (interp) {
Tcl_AppendResult(interp,
"can't get tty status", (char *) NULL);
}
return TCL_ERROR;
}
valid = 1;
SerialModemStatusStr(status, dsPtr);
}
if (valid) {
return TCL_OK;
} else {
return Tcl_BadChannelOption(interp, optionName,
"mode pollinterval lasterror queue sysbuffer ttystatus xchar");
}
}