/*
 * 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.
 *
 * Serial functionality implemented by Rolf.Schroedter@dlr.de
 *
 * RCS: @(#) $Id: tclWinSerial.c,v 1.28 2003/08/19 19:39:56 patthoyts Exp $
 * RCS: @(#) $Id: tclWinSerial.c,v 1.29 2005/01/27 00:23:35 andreas_kupries Exp $
 */

#include "tclWinInt.h"

#include <fcntl.h>
#include <io.h>
#include <sys/stat.h>

				    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 void             SerialThreadActionProc _ANSI_ARGS_ ((
			   ClientData instanceData, int action));

/*
 * This structure describes the channel type structure for command serial
 * based IO.
 */

static Tcl_ChannelType serialChannelType = {
    "serial",			/* Type name. */
    TCL_CHANNEL_VERSION_2,	/* v2 channel */
    TCL_CHANNEL_VERSION_4,	/* v4 channel */
    SerialCloseProc,		/* Close proc. */
    SerialInputProc,		/* Input proc. */
    SerialOutputProc,		/* Output proc. */
    NULL,			/* Seek proc. */
    SerialSetOptionProc,	/* Set option proc. */
    SerialGetOptionProc,	/* Get option proc. */
    SerialWatchProc,		/* Set up notifier to watch the channel. */
    SerialGetHandleProc,	/* Get an OS handle from channel. */
    NULL,			/* close2proc. */
    SerialBlockProc,		/* Set blocking or non-blocking mode.*/
    NULL,			/* flush proc. */
    NULL,			/* handler proc. */
    NULL,                       /* wide seek proc */
    SerialThreadActionProc,     /* thread action proc */
};

/*
 *----------------------------------------------------------------------
 *
 * SerialInit --
 *

	 * Alert the foreground thread.  Note that we need to treat
	 * this like a critical section so the foreground thread does
	 * not terminate this thread while we are holding a mutex in
	 * the notifier code.
	 */

	Tcl_MutexLock(&serialMutex);
	if (infoPtr->threadId != NULL) {
	    /* TIP #218. When in flight ignore the event, no one will receive it anyway */
	Tcl_ThreadAlert(infoPtr->threadId);
	    Tcl_ThreadAlert(infoPtr->threadId);
	}
	Tcl_MutexUnlock(&serialMutex);
    }

    return 0;
}

/*

Tcl_Channel
TclWinOpenSerialChannel(handle, channelName, permissions)
    HANDLE handle;
    char *channelName;
    int permissions;
{
    SerialInfo *infoPtr;
    ThreadSpecificData *tsdPtr;
    DWORD id;

    tsdPtr = SerialInit();
    SerialInit();

    infoPtr = (SerialInfo *) ckalloc((unsigned) sizeof(SerialInfo));
    memset(infoPtr, 0, sizeof(SerialInfo));

    infoPtr->validMask = permissions;
    infoPtr->handle = handle;
    infoPtr->validMask     = permissions;
    infoPtr->handle        = handle;
    infoPtr->channel       = (Tcl_Channel) NULL;
    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    = 4096;
    infoPtr->sysBufWrite   = 4096;

    /*
     * Use the pointer to keep the channel names unique, in case
     * the handles are shared between multiple channels (stdin/stdout).
     */

    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);

    /*
     * default is blocking

    if (valid) {
	return TCL_OK;
    } else {
	return Tcl_BadChannelOption(interp, optionName,
		"mode pollinterval lasterror queue sysbuffer ttystatus xchar");
    }
}

/*
 *----------------------------------------------------------------------
 *
 * SerialThreadActionProc --
 *
 *	Insert or remove any thread local refs to this channel.
 *
 * Results:
 *	None.
 *
 * Side effects:
 *	Changes thread local list of valid channels.
 *
 *----------------------------------------------------------------------
 */

static void
SerialThreadActionProc (instanceData, action)
     ClientData instanceData;
     int action;
{
    SerialInfo *infoPtr = (SerialInfo *) instanceData;

    /* We do not access firstSerialPtr in the thread structures. This is
     * not for all serials managed by the thread, but only those we are
     * watching. Removal of the filevent handlers before transfer thus
     * takes care of this structure.
     */

    Tcl_MutexLock(&serialMutex);
    if (action == TCL_CHANNEL_THREAD_INSERT) {
        /* We can't copy the thread information from the channel when
	 * the channel is created. At this time the channel back
	 * pointer has not been set yet. However in that case the
	 * threadId has already been set by TclpCreateCommandChannel
	 * itself, so the structure is still good.
	 */

        SerialInit ();
        if (infoPtr->channel != NULL) {
	    infoPtr->threadId = Tcl_GetChannelThread (infoPtr->channel);
	}
    } else {
	infoPtr->threadId = NULL;
    }
    Tcl_MutexUnlock(&serialMutex);
}