Tcl Source Code

/* 
 * Tclwinserial.c --
 *
 *	This file implements the Windows-specific serial port functions,
 *	and the "serial" channel driver.
 *
 * Copyright (c) 1999 by Scriptics Corp.
 *
 * See the file "license.terms" for information on usage and redistribution
 * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 *
 * RCS: @(#) $Id: tclWinSerial.c,v 1.1.2.2 1999/03/14 18:55:12 stanton Exp $
 * RCS: @(#) $Id: tclWinSerial.c,v 1.1.2.3 1999/03/24 02:37:14 redman Exp $
 */

#include "tclWinInt.h"

#include <dos.h>
#include <fcntl.h>
#include <io.h>

#define SERIAL_PENDING	(1<<0)	/* Message is pending in the queue. */
#define SERIAL_ASYNC	(1<<1)	/* Channel is non-blocking. */

/*
 * Bit masks used in the sharedFlags field of the SerialInfo structure below.
 */

#define SERIAL_EOF	(1<<2)	/* Serial has reached EOF. */

#define SERIAL_EOF	 (1<<2)  /* Serial has reached EOF. */
#define SERIAL_EXTRABYTE (1<<3)  /* Extra byte consumed while waiting for data */
/*
 * This structure describes per-instance data for a serial based channel.
 */

typedef struct SerialInfo {
    HANDLE handle;
    struct SerialInfo *nextPtr;	/* Pointer to next registered serial. */

    int readFlags;		/* Flags that are shared with the reader
				 * thread.  Access is synchronized with the
				 * readable object.  */
    int writeFlags;		/* Flags that are shared with the writer
				 * thread.  Access is synchronized with the
				 * readable object.  */
    int readyMask;              /* Events that need to be checked on. */
    char extraByte;
    
} SerialInfo;

typedef struct ThreadSpecificData {
    /*
     * The following pointer refers to the head of the list of serials
     * that are being watched for file events.
     */

	CloseHandle(serialPtr->startReader);
	serialPtr->readThread = NULL;
    }
    serialPtr->validMask &= ~TCL_READABLE;

    if (serialPtr->writeThread) {
	WaitForSingleObject(serialPtr->writable, INFINITE);
	TerminateThread(serialPtr->writeThread, 0);

	/*
	 * Wait for the thread to terminate.  This ensures that we are
	 * completely cleaned up before we leave this function. 
	 */

	WaitForSingleObject(serialPtr->writeThread, INFINITE);
	TerminateThread(serialPtr->writeThread, 0);
	CloseHandle(serialPtr->writeThread);
	CloseHandle(serialPtr->writable);
	CloseHandle(serialPtr->startWriter);
	serialPtr->writeThread = NULL;
    }
    serialPtr->validMask &= ~TCL_WRITABLE;

    int bufSize,			/* How much space is available
                                         * in the buffer? */
    int *errorCode)			/* Where to store error code. */
{
    SerialInfo *infoPtr = (SerialInfo *) instanceData;
    DWORD bytesRead = 0;
    int result;
    DWORD errors, err;
    DWORD err;
    DWORD mask = 0;
    COMSTAT stat;

    *errorCode = 0;

    /*
     * Synchronize with the reader thread.
     */
    
    result = WaitForRead(infoPtr, (infoPtr->flags & SERIAL_ASYNC) ? 0 : 1);
    
    /*
     * If an error occurred, return immediately.
     */
    
    if (result == -1) {
	*errorCode = errno;
	return -1;
    }

    infoPtr->readyMask &= ~TCL_READABLE;
    
    if (infoPtr->readFlags & SERIAL_EXTRABYTE) {
    if (ClearCommError(infoPtr->handle, &errors, &stat)) {

	/*
	 * If there are errors, then signal an I/O error.
	 */

	 * If a byte was consumed waiting, then put it in the buffer.
	if (errors != 0) {
	    *errorCode = EIO;
	    return -1;
	}

	/*
	 * Otherwise, it's not that fatal, so check the queue
	 */

	if (stat.cbInQue != 0) {
	    
	*buf = infoPtr->extraByte;
	    /* 
	     * If the buffer is bigger than the data in the queue,
	     * shrink the buffer size to match.
	     */
	    
	    if ((DWORD) bufSize > stat.cbInQue) {
		bufSize = stat.cbInQue;
	    }

	infoPtr->readFlags &= ~SERIAL_EXTRABYTE;
	buf++;
	bufSize--;
	bytesRead = 1;

	if (result == 0) {
	} else {
	    if (infoPtr->flags & SERIAL_ASYNC) {
		errno = *errorCode = EAGAIN;
		return -1;
	    return bytesRead;
	    } else {
		bufSize = 1;
	    }
	}
    }
	}
    }

    
    if (ReadFile(infoPtr->handle, (LPVOID) buf, (DWORD) bufSize, &bytesRead,
		 NULL) == FALSE) {
	err = GetLastError();
	if (err != ERROR_IO_PENDING) {
	    goto error;
	}
    }

static int
WaitForRead(
    SerialInfo *infoPtr,	/* Serial state. */
    int blocking)		/* Indicates whether call should be
				 * blocking or not. */
{
    DWORD timeout, err, mask;
    DWORD timeout, errors;
    HANDLE *handle = infoPtr->handle;
    COMSTAT stat;

    /*
     * Synchronize with the reader thread.
     */
    
    timeout = blocking ? INFINITE : 0;
    if (WaitForSingleObject(infoPtr->readable, timeout) == WAIT_TIMEOUT) {
	/*
	 * The reader thread is blocked waiting for data and the channel
	 * is in non-blocking mode.
	 */
	
	errno = EAGAIN;
	return -1;
    }
    
    /*
     * At this point, the two threads are synchronized, so it is safe
     * to access shared state.  This code is not called in the ReaderThread
     * in blocking mode, so it needs to be checked here.
     */
    
    while (1) {
	/*
	 * Synchronize with the reader thread.
	 */
	
	timeout = blocking ? INFINITE : 0;
	if (WaitForSingleObject(infoPtr->readable, timeout) == WAIT_TIMEOUT) {
	    /*
	     * The reader thread is blocked waiting for data and the channel
	     * is in non-blocking mode.
	     */
	    
	    errno = EAGAIN;
	    return -1;
	}
	
	/*
	 * At this point, the two threads are synchronized, so it is safe
	 * to access shared state.  This code is not called in the ReaderThread
	 * in blocking mode, so it needs to be checked here.
	 */

	/*
	 * If the serial has hit EOF, it is always readable.
	 */
    while (1) {
	if (WaitCommEvent(handle, &mask, NULL) == FALSE) {
	    err = GetLastError();
	    infoPtr->readFlags |= SERIAL_EOF;
	    break;
    
	if (infoPtr->readFlags & SERIAL_EOF) {
	    return 1;
	}
	
	if (ClearCommError(infoPtr->handle, &errors, &stat)) {
	    /*
	     * If there are errors, then signal an I/O error.
	     */

	    if (errors != 0) {
		errno = EIO;
		return -1;
	    }
	}
	
	/*
	 * If data is in the queue return 1
	 */
	
	if (stat.cbInQue != 0) {
	    return 1;
	}
	if (mask & EV_RXCHAR) {
	    break;

	/*
	 * if there is an extra byte that was consumed while
	 * waiting, but no data in the queue, return 0
	 */
	
	if (infoPtr->readFlags & SERIAL_EXTRABYTE) {
	    return 0;
	}
	    
	ResetEvent(infoPtr->readable);
	SetEvent(infoPtr->startReader);
    }
    
    /*
     * If the serial has hit EOF, it is always readable.
     */
    
    if (infoPtr->readFlags & SERIAL_EOF) {
	return 1;
    }
    
    return 1;
}

/*
 *----------------------------------------------------------------------
 *
 * SerialReaderThread --
 *

static DWORD WINAPI
SerialReaderThread(LPVOID arg)
{
    SerialInfo *infoPtr = (SerialInfo *)arg;
    HANDLE *handle = infoPtr->handle;
    DWORD mask = EV_RXCHAR;
    DWORD count;

    
    for (;;) {
	/*
	 * Wait for the main thread to signal before attempting to wait.
	 */

	WaitForSingleObject(infoPtr->startReader, INFINITE);

	/*
	 * Try waiting for a Comm event.
	 */

	
	WaitCommEvent(handle, NULL, NULL);
	
	while (1) {
	    if (WaitCommEvent(handle, &mask, NULL) == FALSE) {
		/*
		 * There is an error, signal an EOF.
		 */

		infoPtr->readFlags |= SERIAL_EOF;

	/*
	 * try to read one byte
	 */
	
	if (ReadFile(handle, &(infoPtr->extraByte), 1, &count, NULL)
		!= FALSE) {

	    /*
	     * one byte was consumed while waiting to read, keep it
	     */

	    if (count != 0) {
		infoPtr->readFlags |= SERIAL_EXTRABYTE;
	    }

	} else {
            /*
	     * There is an error, signal an EOF.
	     */
	    
	    infoPtr->readFlags |= SERIAL_EOF;
		break;
	    }
	}

	    /*
	     * Signal the main thread by signalling the readable event and
	     * then waking up the notifier thread.
	     */
	/*
	 * Signal the main thread by signalling the readable event and
	 * then waking up the notifier thread.
	 */

	    if (mask & EV_RXCHAR) {
		SetEvent(infoPtr->readable);
		Tcl_ThreadAlert(infoPtr->threadId);
	SetEvent(infoPtr->readable);
	Tcl_ThreadAlert(infoPtr->threadId);
		break;
	    }
	}
    }
    return 0;			/* NOT REACHED */
}

/*
 *----------------------------------------------------------------------
 *

    tsdPtr = SerialInit();

    SetCommMask(handle, EV_RXCHAR);
    SetupComm(handle, 4096, 4096);
    PurgeComm(handle, PURGE_TXABORT | PURGE_RXABORT | PURGE_TXCLEAR
	      | PURGE_RXCLEAR);
    cto.ReadIntervalTimeout = MAXDWORD;
    cto.ReadTotalTimeoutMultiplier = 0;
    cto.ReadTotalTimeoutConstant = 0;
    cto.ReadTotalTimeoutMultiplier = MAXDWORD;
    cto.ReadTotalTimeoutConstant = 1;
    cto.WriteTotalTimeoutMultiplier = 0;
    cto.WriteTotalTimeoutConstant = 0;
    SetCommTimeouts(handle, &cto);
    
    infoPtr = (SerialInfo *) ckalloc((unsigned) sizeof(SerialInfo));
    memset(infoPtr, 0, sizeof(SerialInfo));