diff options
Diffstat (limited to 'tcl8.6/generic/tclIO.c')
| -rw-r--r-- | tcl8.6/generic/tclIO.c | 11250 |
1 files changed, 11250 insertions, 0 deletions
diff --git a/tcl8.6/generic/tclIO.c b/tcl8.6/generic/tclIO.c new file mode 100644 index 0000000..64501fd --- /dev/null +++ b/tcl8.6/generic/tclIO.c @@ -0,0 +1,11250 @@ +/* + * tclIO.c -- + * + * This file provides the generic portions (those that are the same on + * all platforms and for all channel types) of Tcl's IO facilities. + * + * Copyright (c) 1998-2000 Ajuba Solutions + * Copyright (c) 1995-1997 Sun Microsystems, Inc. + * Contributions from Don Porter, NIST, 2014. (not subject to US copyright) + * + * See the file "license.terms" for information on usage and redistribution of + * this file, and for a DISCLAIMER OF ALL WARRANTIES. + */ + +#include "tclInt.h" +#include "tclIO.h" +#include <assert.h> + +/* + * For each channel handler registered in a call to Tcl_CreateChannelHandler, + * there is one record of the following type. All of records for a specific + * channel are chained together in a singly linked list which is stored in + * the channel structure. + */ + +typedef struct ChannelHandler { + Channel *chanPtr; /* The channel structure for this channel. */ + int mask; /* Mask of desired events. */ + Tcl_ChannelProc *proc; /* Procedure to call in the type of + * Tcl_CreateChannelHandler. */ + ClientData clientData; /* Argument to pass to procedure. */ + struct ChannelHandler *nextPtr; + /* Next one in list of registered handlers. */ +} ChannelHandler; + +/* + * This structure keeps track of the current ChannelHandler being invoked in + * the current invocation of Tcl_NotifyChannel. There is a potential + * problem if a ChannelHandler is deleted while it is the current one, since + * Tcl_NotifyChannel needs to look at the nextPtr field. To handle this + * problem, structures of the type below indicate the next handler to be + * processed for any (recursively nested) dispatches in progress. The + * nextHandlerPtr field is updated if the handler being pointed to is deleted. + * The nestedHandlerPtr field is used to chain together all recursive + * invocations, so that Tcl_DeleteChannelHandler can find all the recursively + * nested invocations of Tcl_NotifyChannel and compare the handler being + * deleted against the NEXT handler to be invoked in that invocation; when it + * finds such a situation, Tcl_DeleteChannelHandler updates the nextHandlerPtr + * field of the structure to the next handler. + */ + +typedef struct NextChannelHandler { + ChannelHandler *nextHandlerPtr; /* The next handler to be invoked in + * this invocation. */ + struct NextChannelHandler *nestedHandlerPtr; + /* Next nested invocation of + * Tcl_NotifyChannel. */ +} NextChannelHandler; + +/* + * The following structure is used by Tcl_GetsObj() to encapsulates the + * state for a "gets" operation. + */ + +typedef struct GetsState { + Tcl_Obj *objPtr; /* The object to which UTF-8 characters + * will be appended. */ + char **dstPtr; /* Pointer into objPtr's string rep where + * next character should be stored. */ + Tcl_Encoding encoding; /* The encoding to use to convert raw bytes + * to UTF-8. */ + ChannelBuffer *bufPtr; /* The current buffer of raw bytes being + * emptied. */ + Tcl_EncodingState state; /* The encoding state just before the last + * external to UTF-8 conversion in + * FilterInputBytes(). */ + int rawRead; /* The number of bytes removed from bufPtr + * in the last call to FilterInputBytes(). */ + int bytesWrote; /* The number of bytes of UTF-8 data + * appended to objPtr during the last call to + * FilterInputBytes(). */ + int charsWrote; /* The corresponding number of UTF-8 + * characters appended to objPtr during the + * last call to FilterInputBytes(). */ + int totalChars; /* The total number of UTF-8 characters + * appended to objPtr so far, just before the + * last call to FilterInputBytes(). */ +} GetsState; + +/* + * The following structure encapsulates the state for a background channel + * copy. Note that the data buffer for the copy will be appended to this + * structure. + */ + +typedef struct CopyState { + struct Channel *readPtr; /* Pointer to input channel. */ + struct Channel *writePtr; /* Pointer to output channel. */ + int readFlags; /* Original read channel flags. */ + int writeFlags; /* Original write channel flags. */ + Tcl_WideInt toRead; /* Number of bytes to copy, or -1. */ + Tcl_WideInt total; /* Total bytes transferred (written). */ + Tcl_Interp *interp; /* Interp that started the copy. */ + Tcl_Obj *cmdPtr; /* Command to be invoked at completion. */ + int bufSize; /* Size of appended buffer. */ + char buffer[1]; /* Copy buffer, this must be the last + * field. */ +} CopyState; + +/* + * All static variables used in this file are collected into a single instance + * of the following structure. For multi-threaded implementations, there is + * one instance of this structure for each thread. + * + * Notice that different structures with the same name appear in other files. + * The structure defined below is used in this file only. + */ + +typedef struct ThreadSpecificData { + NextChannelHandler *nestedHandlerPtr; + /* This variable holds the list of nested + * Tcl_NotifyChannel invocations. */ + ChannelState *firstCSPtr; /* List of all channels currently open, + * indexed by ChannelState, as only one + * ChannelState exists per set of stacked + * channels. */ + Tcl_Channel stdinChannel; /* Static variable for the stdin channel. */ + int stdinInitialized; + Tcl_Channel stdoutChannel; /* Static variable for the stdout channel. */ + int stdoutInitialized; + Tcl_Channel stderrChannel; /* Static variable for the stderr channel. */ + int stderrInitialized; + Tcl_Encoding binaryEncoding; +} ThreadSpecificData; + +static Tcl_ThreadDataKey dataKey; + +/* + * Structure to record a close callback. One such record exists for + * each close callback registered for a channel. + */ + +typedef struct CloseCallback { + Tcl_CloseProc *proc; /* The procedure to call. */ + ClientData clientData; /* Arbitrary one-word data to pass + * to the callback. */ + struct CloseCallback *nextPtr; /* For chaining close callbacks. */ +} CloseCallback; + +/* + * Static functions in this file: + */ + +static ChannelBuffer * AllocChannelBuffer(int length); +static void PreserveChannelBuffer(ChannelBuffer *bufPtr); +static void ReleaseChannelBuffer(ChannelBuffer *bufPtr); +static int IsShared(ChannelBuffer *bufPtr); +static void ChannelFree(Channel *chanPtr); +static void ChannelTimerProc(ClientData clientData); +static int ChanRead(Channel *chanPtr, char *dst, int dstSize); +static int CheckChannelErrors(ChannelState *statePtr, + int direction); +static int CheckForDeadChannel(Tcl_Interp *interp, + ChannelState *statePtr); +static void CheckForStdChannelsBeingClosed(Tcl_Channel chan); +static void CleanupChannelHandlers(Tcl_Interp *interp, + Channel *chanPtr); +static int CloseChannel(Tcl_Interp *interp, Channel *chanPtr, + int errorCode); +static int CloseChannelPart(Tcl_Interp *interp, Channel *chanPtr, + int errorCode, int flags); +static int CloseWrite(Tcl_Interp *interp, Channel *chanPtr); +static void CommonGetsCleanup(Channel *chanPtr); +static int CopyData(CopyState *csPtr, int mask); +static int MoveBytes(CopyState *csPtr); + +static void MBCallback(CopyState *csPtr, Tcl_Obj *errObj); +static void MBError(CopyState *csPtr, int mask, int errorCode); +static int MBRead(CopyState *csPtr); +static int MBWrite(CopyState *csPtr); +static void MBEvent(ClientData clientData, int mask); + +static void CopyEventProc(ClientData clientData, int mask); +static void CreateScriptRecord(Tcl_Interp *interp, + Channel *chanPtr, int mask, Tcl_Obj *scriptPtr); +static void DeleteChannelTable(ClientData clientData, + Tcl_Interp *interp); +static void DeleteScriptRecord(Tcl_Interp *interp, + Channel *chanPtr, int mask); +static int DetachChannel(Tcl_Interp *interp, Tcl_Channel chan); +static void DiscardInputQueued(ChannelState *statePtr, + int discardSavedBuffers); +static void DiscardOutputQueued(ChannelState *chanPtr); +static int DoRead(Channel *chanPtr, char *dst, int bytesToRead, + int allowShortReads); +static int DoReadChars(Channel *chan, Tcl_Obj *objPtr, int toRead, + int appendFlag); +static int FilterInputBytes(Channel *chanPtr, + GetsState *statePtr); +static int FlushChannel(Tcl_Interp *interp, Channel *chanPtr, + int calledFromAsyncFlush); +static int TclGetsObjBinary(Tcl_Channel chan, Tcl_Obj *objPtr); +static Tcl_Encoding GetBinaryEncoding(); +static void FreeBinaryEncoding(ClientData clientData); +static Tcl_HashTable * GetChannelTable(Tcl_Interp *interp); +static int GetInput(Channel *chanPtr); +static int HaveVersion(const Tcl_ChannelType *typePtr, + Tcl_ChannelTypeVersion minimumVersion); +static void PeekAhead(Channel *chanPtr, char **dstEndPtr, + GetsState *gsPtr); +static int ReadBytes(ChannelState *statePtr, Tcl_Obj *objPtr, + int charsLeft); +static int ReadChars(ChannelState *statePtr, Tcl_Obj *objPtr, + int charsLeft, int *factorPtr); +static void RecycleBuffer(ChannelState *statePtr, + ChannelBuffer *bufPtr, int mustDiscard); +static int StackSetBlockMode(Channel *chanPtr, int mode); +static int SetBlockMode(Tcl_Interp *interp, Channel *chanPtr, + int mode); +static void StopCopy(CopyState *csPtr); +static void TranslateInputEOL(ChannelState *statePtr, char *dst, + const char *src, int *dstLenPtr, int *srcLenPtr); +static void UpdateInterest(Channel *chanPtr); +static int Write(Channel *chanPtr, const char *src, + int srcLen, Tcl_Encoding encoding); +static Tcl_Obj * FixLevelCode(Tcl_Obj *msg); +static void SpliceChannel(Tcl_Channel chan); +static void CutChannel(Tcl_Channel chan); +static int WillRead(Channel *chanPtr); + +#define WriteChars(chanPtr, src, srcLen) \ + Write(chanPtr, src, srcLen, chanPtr->state->encoding) +#define WriteBytes(chanPtr, src, srcLen) \ + Write(chanPtr, src, srcLen, tclIdentityEncoding) + +/* + * Simplifying helper macros. All may use their argument(s) multiple times. + * The ANSI C "prototypes" for the macros are listed below, together with a + * short description of what the macro does. + * + * -------------------------------------------------------------------------- + * int BytesLeft(ChannelBuffer *bufPtr) + * + * Returns the number of bytes of data remaining in the buffer. + * + * int SpaceLeft(ChannelBuffer *bufPtr) + * + * Returns the number of bytes of space remaining at the end of the + * buffer. + * + * int IsBufferReady(ChannelBuffer *bufPtr) + * + * Returns whether a buffer has bytes available within it. + * + * int IsBufferEmpty(ChannelBuffer *bufPtr) + * + * Returns whether a buffer is entirely empty. Note that this is not the + * inverse of the above operation; trying to merge the two seems to lead + * to occasional crashes... + * + * int IsBufferFull(ChannelBuffer *bufPtr) + * + * Returns whether more data can be added to a buffer. + * + * int IsBufferOverflowing(ChannelBuffer *bufPtr) + * + * Returns whether a buffer has more data in it than it should. + * + * char *InsertPoint(ChannelBuffer *bufPtr) + * + * Returns a pointer to where characters should be added to the buffer. + * + * char *RemovePoint(ChannelBuffer *bufPtr) + * + * Returns a pointer to where characters should be removed from the + * buffer. + * -------------------------------------------------------------------------- + */ + +#define BytesLeft(bufPtr) ((bufPtr)->nextAdded - (bufPtr)->nextRemoved) + +#define SpaceLeft(bufPtr) ((bufPtr)->bufLength - (bufPtr)->nextAdded) + +#define IsBufferReady(bufPtr) ((bufPtr)->nextAdded > (bufPtr)->nextRemoved) + +#define IsBufferEmpty(bufPtr) ((bufPtr)->nextAdded == (bufPtr)->nextRemoved) + +#define IsBufferFull(bufPtr) ((bufPtr) && (bufPtr)->nextAdded >= (bufPtr)->bufLength) + +#define IsBufferOverflowing(bufPtr) ((bufPtr)->nextAdded>(bufPtr)->bufLength) + +#define InsertPoint(bufPtr) ((bufPtr)->buf + (bufPtr)->nextAdded) + +#define RemovePoint(bufPtr) ((bufPtr)->buf + (bufPtr)->nextRemoved) + +/* + * For working with channel state flag bits. + */ + +#define SetFlag(statePtr, flag) ((statePtr)->flags |= (flag)) +#define ResetFlag(statePtr, flag) ((statePtr)->flags &= ~(flag)) +#define GotFlag(statePtr, flag) ((statePtr)->flags & (flag)) + +/* + * Macro for testing whether a string (in optionName, length len) matches a + * value (prefix matching rules). Arguments are the minimum length to match + * and the value to match against. (Can't use Tcl_GetIndexFromObj as this is + * used in a situation where no objects are available.) + */ + +#define HaveOpt(minLength, nameString) \ + ((len > (minLength)) && (optionName[1] == (nameString)[1]) \ + && (strncmp(optionName, (nameString), len) == 0)) + +/* + * The ChannelObjType type. Used to store the result of looking up + * a channel name in the context of an interp. Saves the lookup + * result and values needed to check its continued validity. + */ + +typedef struct ResolvedChanName { + ChannelState *statePtr; /* The saved lookup result */ + Tcl_Interp *interp; /* The interp in which the lookup was done. */ + int epoch; /* The epoch of the channel when the lookup + * was done. Use to verify validity. */ + int refCount; /* Share this struct among many Tcl_Obj. */ +} ResolvedChanName; + +static void DupChannelIntRep(Tcl_Obj *objPtr, Tcl_Obj *copyPtr); +static void FreeChannelIntRep(Tcl_Obj *objPtr); + +static const Tcl_ObjType chanObjType = { + "channel", /* name for this type */ + FreeChannelIntRep, /* freeIntRepProc */ + DupChannelIntRep, /* dupIntRepProc */ + NULL, /* updateStringProc */ + NULL /* setFromAnyProc */ +}; + +#define BUSY_STATE(st, fl) \ + ((((st)->csPtrR) && ((fl) & TCL_READABLE)) || \ + (((st)->csPtrW) && ((fl) & TCL_WRITABLE))) + +#define MAX_CHANNEL_BUFFER_SIZE (1024*1024) + +/* + *--------------------------------------------------------------------------- + * + * ChanClose, ChanRead, ChanSeek, ChanThreadAction, ChanWatch, ChanWrite -- + * + * Simplify the access to selected channel driver "methods" that are used + * in multiple places in a stereotypical fashion. These are just thin + * wrappers around the driver functions. + * + *--------------------------------------------------------------------------- + */ + +static inline int +ChanClose( + Channel *chanPtr, + Tcl_Interp *interp) +{ + if (chanPtr->typePtr->closeProc != TCL_CLOSE2PROC) { + return chanPtr->typePtr->closeProc(chanPtr->instanceData, interp); + } else { + return chanPtr->typePtr->close2Proc(chanPtr->instanceData, interp, 0); + } +} + +static inline int +ChanCloseHalf( + Channel *chanPtr, + Tcl_Interp *interp, + int flags) +{ + return chanPtr->typePtr->close2Proc(chanPtr->instanceData, interp, flags); +} + +/* + *--------------------------------------------------------------------------- + * + * ChanRead -- + * + * Read up to dstSize bytes using the inputProc of chanPtr, store + * them at dst, and return the number of bytes stored. + * + * Results: + * The return value of the driver inputProc, + * - number of bytes stored at dst, ot + * - -1 on error, with a Posix error code available to the + * caller by calling Tcl_GetErrno(). + * + * Side effects: + * The CHANNEL_BLOCKED and CHANNEL_EOF flags of the channel state are + * set as appropriate. + * On EOF, the inputEncodingFlags are set to perform ending operations + * on decoding. + * TODO - Is this really the right place for that? + * + *--------------------------------------------------------------------------- + */ +static int +ChanRead( + Channel *chanPtr, + char *dst, + int dstSize) +{ + int bytesRead, result; + + /* + * If the caller asked for zero bytes, we'd force the inputProc + * to return zero bytes, and then misinterpret that as EOF. + */ + assert(dstSize > 0); + + /* + * Each read op must set the blocked and eof states anew, not let + * the effect of prior reads leak through. + */ + if (GotFlag(chanPtr->state, CHANNEL_EOF)) { + chanPtr->state->inputEncodingFlags |= TCL_ENCODING_START; + } + ResetFlag(chanPtr->state, CHANNEL_BLOCKED | CHANNEL_EOF); + chanPtr->state->inputEncodingFlags &= ~TCL_ENCODING_END; + if (WillRead(chanPtr) < 0) { + return -1; + } + + bytesRead = chanPtr->typePtr->inputProc(chanPtr->instanceData, + dst, dstSize, &result); + + /* Stop any flag leakage through stacked channel levels */ + if (GotFlag(chanPtr->state, CHANNEL_EOF)) { + chanPtr->state->inputEncodingFlags |= TCL_ENCODING_START; + } + ResetFlag(chanPtr->state, CHANNEL_BLOCKED | CHANNEL_EOF); + chanPtr->state->inputEncodingFlags &= ~TCL_ENCODING_END; + if (bytesRead > 0) { + /* + * If we get a short read, signal up that we may be BLOCKED. + * We should avoid calling the driver because on some + * platforms we will block in the low level reading code even + * though the channel is set into nonblocking mode. + */ + + if (bytesRead < dstSize) { + SetFlag(chanPtr->state, CHANNEL_BLOCKED); + } + } else if (bytesRead == 0) { + SetFlag(chanPtr->state, CHANNEL_EOF); + chanPtr->state->inputEncodingFlags |= TCL_ENCODING_END; + } else if (bytesRead < 0) { + if ((result == EWOULDBLOCK) || (result == EAGAIN)) { + SetFlag(chanPtr->state, CHANNEL_BLOCKED); + result = EAGAIN; + } + Tcl_SetErrno(result); + } + return bytesRead; +} + +static inline Tcl_WideInt +ChanSeek( + Channel *chanPtr, + Tcl_WideInt offset, + int mode, + int *errnoPtr) +{ + /* + * Note that we prefer the wideSeekProc if that field is available in the + * type and non-NULL. + */ + + if (HaveVersion(chanPtr->typePtr, TCL_CHANNEL_VERSION_3) && + chanPtr->typePtr->wideSeekProc != NULL) { + return chanPtr->typePtr->wideSeekProc(chanPtr->instanceData, + offset, mode, errnoPtr); + } + + if (offset<Tcl_LongAsWide(LONG_MIN) || offset>Tcl_LongAsWide(LONG_MAX)) { + *errnoPtr = EOVERFLOW; + return Tcl_LongAsWide(-1); + } + + return Tcl_LongAsWide(chanPtr->typePtr->seekProc(chanPtr->instanceData, + Tcl_WideAsLong(offset), mode, errnoPtr)); +} + +static inline void +ChanThreadAction( + Channel *chanPtr, + int action) +{ + Tcl_DriverThreadActionProc *threadActionProc = + Tcl_ChannelThreadActionProc(chanPtr->typePtr); + + if (threadActionProc != NULL) { + threadActionProc(chanPtr->instanceData, action); + } +} + +static inline void +ChanWatch( + Channel *chanPtr, + int mask) +{ + chanPtr->typePtr->watchProc(chanPtr->instanceData, mask); +} + +static inline int +ChanWrite( + Channel *chanPtr, + const char *src, + int srcLen, + int *errnoPtr) +{ + return chanPtr->typePtr->outputProc(chanPtr->instanceData, src, srcLen, + errnoPtr); +} + +/* + *--------------------------------------------------------------------------- + * + * TclInitIOSubsystem -- + * + * Initialize all resources used by this subsystem on a per-process + * basis. + * + * Results: + * None. + * + * Side effects: + * Depends on the memory subsystems. + * + *--------------------------------------------------------------------------- + */ + +void +TclInitIOSubsystem(void) +{ + /* + * By fetching thread local storage we take care of allocating it for each + * thread. + */ + + (void) TCL_TSD_INIT(&dataKey); +} + +/* + *------------------------------------------------------------------------- + * + * TclFinalizeIOSubsystem -- + * + * Releases all resources used by this subsystem on a per-process basis. + * Closes all extant channels that have not already been closed because + * they were not owned by any interp. + * + * Results: + * None. + * + * Side effects: + * Depends on encoding and memory subsystems. + * + *------------------------------------------------------------------------- + */ + + /* ARGSUSED */ +void +TclFinalizeIOSubsystem(void) +{ + ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey); + Channel *chanPtr = NULL; /* Iterates over open channels. */ + ChannelState *statePtr; /* State of channel stack */ + int active = 1; /* Flag == 1 while there's still work to do */ + int doflushnb; + + /* Fetch the pre-TIP#398 compatibility flag */ + { + const char *s; + Tcl_DString ds; + + s = TclGetEnv("TCL_FLUSH_NONBLOCKING_ON_EXIT", &ds); + doflushnb = ((s != NULL) && strcmp(s, "0")); + if (s != NULL) { + Tcl_DStringFree(&ds); + } + } + + /* + * Walk all channel state structures known to this thread and close + * corresponding channels. + */ + + while (active) { + /* + * Iterate through the open channel list, and find the first channel + * that isn't dead. We start from the head of the list each time, + * because the close action on one channel can close others. + */ + + active = 0; + for (statePtr = tsdPtr->firstCSPtr; + statePtr != NULL; + statePtr = statePtr->nextCSPtr) { + chanPtr = statePtr->topChanPtr; + if (GotFlag(statePtr, CHANNEL_DEAD)) { + continue; + } + if (!GotFlag(statePtr, CHANNEL_INCLOSE | CHANNEL_CLOSED ) + || GotFlag(statePtr, BG_FLUSH_SCHEDULED)) { + ResetFlag(statePtr, BG_FLUSH_SCHEDULED); + active = 1; + break; + } + } + + /* + * We've found a live (or bg-closing) channel. Close it. + */ + + if (active) { + + TclChannelPreserve((Tcl_Channel)chanPtr); + /* + * TIP #398: by default, we no longer set the channel back into + * blocking mode. To restore the old blocking behavior, the + * environment variable TCL_FLUSH_NONBLOCKING_ON_EXIT must be set + * and not be "0". + */ + if (doflushnb) { + /* Set the channel back into blocking mode to ensure that we wait + * for all data to flush out. + */ + + (void) Tcl_SetChannelOption(NULL, (Tcl_Channel) chanPtr, + "-blocking", "on"); + } + + if ((chanPtr == (Channel *) tsdPtr->stdinChannel) || + (chanPtr == (Channel *) tsdPtr->stdoutChannel) || + (chanPtr == (Channel *) tsdPtr->stderrChannel)) { + /* + * Decrement the refcount which was earlier artificially + * bumped up to keep the channel from being closed. + */ + + statePtr->refCount--; + } + + if (statePtr->refCount <= 0) { + /* + * Close it only if the refcount indicates that the channel is + * not referenced from any interpreter. If it is, that + * interpreter will close the channel when it gets destroyed. + */ + + (void) Tcl_Close(NULL, (Tcl_Channel) chanPtr); + } else { + /* + * The refcount is greater than zero, so flush the channel. + */ + + Tcl_Flush((Tcl_Channel) chanPtr); + + /* + * Call the device driver to actually close the underlying + * device for this channel. + */ + + (void) ChanClose(chanPtr, NULL); + + /* + * Finally, we clean up the fields in the channel data + * structure since all of them have been deleted already. We + * mark the channel with CHANNEL_DEAD to prevent any further + * IO operations on it. + */ + + chanPtr->instanceData = NULL; + SetFlag(statePtr, CHANNEL_DEAD); + } + TclChannelRelease((Tcl_Channel)chanPtr); + } + } + + TclpFinalizeSockets(); + TclpFinalizePipes(); +} + +/* + *---------------------------------------------------------------------- + * + * Tcl_SetStdChannel -- + * + * This function is used to change the channels that are used for + * stdin/stdout/stderr in new interpreters. + * + * Results: + * None + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +void +Tcl_SetStdChannel( + Tcl_Channel channel, + int type) /* One of TCL_STDIN, TCL_STDOUT, TCL_STDERR. */ +{ + ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey); + + switch (type) { + case TCL_STDIN: + tsdPtr->stdinInitialized = 1; + tsdPtr->stdinChannel = channel; + break; + case TCL_STDOUT: + tsdPtr->stdoutInitialized = 1; + tsdPtr->stdoutChannel = channel; + break; + case TCL_STDERR: + tsdPtr->stderrInitialized = 1; + tsdPtr->stderrChannel = channel; + break; + } +} + +/* + *---------------------------------------------------------------------- + * + * Tcl_GetStdChannel -- + * + * Returns the specified standard channel. + * + * Results: + * Returns the specified standard channel, or NULL. + * + * Side effects: + * May cause the creation of a standard channel and the underlying file. + * + *---------------------------------------------------------------------- + */ + +Tcl_Channel +Tcl_GetStdChannel( + int type) /* One of TCL_STDIN, TCL_STDOUT, TCL_STDERR. */ +{ + Tcl_Channel channel = NULL; + ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey); + + /* + * If the channels were not created yet, create them now and store them in + * the static variables. + */ + + switch (type) { + case TCL_STDIN: + if (!tsdPtr->stdinInitialized) { + tsdPtr->stdinChannel = TclpGetDefaultStdChannel(TCL_STDIN); + tsdPtr->stdinInitialized = 1; + + /* + * Artificially bump the refcount to ensure that the channel is + * only closed on exit. + * + * NOTE: Must only do this if stdinChannel is not NULL. It can be + * NULL in situations where Tcl is unable to connect to the + * standard input. + */ + + if (tsdPtr->stdinChannel != NULL) { + Tcl_RegisterChannel(NULL, tsdPtr->stdinChannel); + } + } + channel = tsdPtr->stdinChannel; + break; + case TCL_STDOUT: + if (!tsdPtr->stdoutInitialized) { + tsdPtr->stdoutChannel = TclpGetDefaultStdChannel(TCL_STDOUT); + tsdPtr->stdoutInitialized = 1; + if (tsdPtr->stdoutChannel != NULL) { + Tcl_RegisterChannel(NULL, tsdPtr->stdoutChannel); + } + } + channel = tsdPtr->stdoutChannel; + break; + case TCL_STDERR: + if (!tsdPtr->stderrInitialized) { + tsdPtr->stderrChannel = TclpGetDefaultStdChannel(TCL_STDERR); + tsdPtr->stderrInitialized = 1; + if (tsdPtr->stderrChannel != NULL) { + Tcl_RegisterChannel(NULL, tsdPtr->stderrChannel); + } + } + channel = tsdPtr->stderrChannel; + break; + } + return channel; +} + +/* + *---------------------------------------------------------------------- + * + * Tcl_CreateCloseHandler + * + * Creates a close callback which will be called when the channel is + * closed. + * + * Results: + * None. + * + * Side effects: + * Causes the callback to be called in the future when the channel will + * be closed. + * + *---------------------------------------------------------------------- + */ + +void +Tcl_CreateCloseHandler( + Tcl_Channel chan, /* The channel for which to create the close + * callback. */ + Tcl_CloseProc *proc, /* The callback routine to call when the + * channel will be closed. */ + ClientData clientData) /* Arbitrary data to pass to the close + * callback. */ +{ + ChannelState *statePtr = ((Channel *) chan)->state; + CloseCallback *cbPtr; + + cbPtr = ckalloc(sizeof(CloseCallback)); + cbPtr->proc = proc; + cbPtr->clientData = clientData; + + cbPtr->nextPtr = statePtr->closeCbPtr; + statePtr->closeCbPtr = cbPtr; +} + +/* + *---------------------------------------------------------------------- + * + * Tcl_DeleteCloseHandler -- + * + * Removes a callback that would have been called on closing the channel. + * If there is no matching callback then this function has no effect. + * + * Results: + * None. + * + * Side effects: + * The callback will not be called in the future when the channel is + * eventually closed. + * + *---------------------------------------------------------------------- + */ + +void +Tcl_DeleteCloseHandler( + Tcl_Channel chan, /* The channel for which to cancel the close + * callback. */ + Tcl_CloseProc *proc, /* The procedure for the callback to + * remove. */ + ClientData clientData) /* The callback data for the callback to + * remove. */ +{ + ChannelState *statePtr = ((Channel *) chan)->state; + CloseCallback *cbPtr, *cbPrevPtr; + + for (cbPtr = statePtr->closeCbPtr, cbPrevPtr = NULL; + cbPtr != NULL; cbPtr = cbPtr->nextPtr) { + if ((cbPtr->proc == proc) && (cbPtr->clientData == clientData)) { + if (cbPrevPtr == NULL) { + statePtr->closeCbPtr = cbPtr->nextPtr; + } else { + cbPrevPtr->nextPtr = cbPtr->nextPtr; + } + ckfree(cbPtr); + break; + } + cbPrevPtr = cbPtr; + } +} + +/* + *---------------------------------------------------------------------- + * + * GetChannelTable -- + * + * Gets and potentially initializes the channel table for an interpreter. + * If it is initializing the table it also inserts channels for stdin, + * stdout and stderr if the interpreter is trusted. + * + * Results: + * A pointer to the hash table created, for use by the caller. + * + * Side effects: + * Initializes the channel table for an interpreter. May create channels + * for stdin, stdout and stderr. + * + *---------------------------------------------------------------------- + */ + +static Tcl_HashTable * +GetChannelTable( + Tcl_Interp *interp) +{ + Tcl_HashTable *hTblPtr; /* Hash table of channels. */ + Tcl_Channel stdinChan, stdoutChan, stderrChan; + + hTblPtr = Tcl_GetAssocData(interp, "tclIO", NULL); + if (hTblPtr == NULL) { + hTblPtr = ckalloc(sizeof(Tcl_HashTable)); + Tcl_InitHashTable(hTblPtr, TCL_STRING_KEYS); + Tcl_SetAssocData(interp, "tclIO", + (Tcl_InterpDeleteProc *) DeleteChannelTable, hTblPtr); + + /* + * If the interpreter is trusted (not "safe"), insert channels for + * stdin, stdout and stderr (possibly creating them in the process). + */ + + if (Tcl_IsSafe(interp) == 0) { + stdinChan = Tcl_GetStdChannel(TCL_STDIN); + if (stdinChan != NULL) { + Tcl_RegisterChannel(interp, stdinChan); + } + stdoutChan = Tcl_GetStdChannel(TCL_STDOUT); + if (stdoutChan != NULL) { + Tcl_RegisterChannel(interp, stdoutChan); + } + stderrChan = Tcl_GetStdChannel(TCL_STDERR); + if (stderrChan != NULL) { + Tcl_RegisterChannel(interp, stderrChan); + } + } + } + return hTblPtr; +} + +/* + *---------------------------------------------------------------------- + * + * DeleteChannelTable -- + * + * Deletes the channel table for an interpreter, closing any open + * channels whose refcount reaches zero. This procedure is invoked when + * an interpreter is deleted, via the AssocData cleanup mechanism. + * + * Results: + * None. + * + * Side effects: + * Deletes the hash table of channels. May close channels. May flush + * output on closed channels. Removes any channeEvent handlers that were + * registered in this interpreter. + * + *---------------------------------------------------------------------- + */ + +static void +DeleteChannelTable( + ClientData clientData, /* The per-interpreter data structure. */ + Tcl_Interp *interp) /* The interpreter being deleted. */ +{ + Tcl_HashTable *hTblPtr; /* The hash table. */ + Tcl_HashSearch hSearch; /* Search variable. */ + Tcl_HashEntry *hPtr; /* Search variable. */ + Channel *chanPtr; /* Channel being deleted. */ + ChannelState *statePtr; /* State of Channel being deleted. */ + EventScriptRecord *sPtr, *prevPtr, *nextPtr; + /* Variables to loop over all channel events + * registered, to delete the ones that refer + * to the interpreter being deleted. */ + + /* + * Delete all the registered channels - this will close channels whose + * refcount reaches zero. + */ + + hTblPtr = clientData; + for (hPtr = Tcl_FirstHashEntry(hTblPtr, &hSearch); hPtr != NULL; + hPtr = Tcl_FirstHashEntry(hTblPtr, &hSearch)) { + chanPtr = Tcl_GetHashValue(hPtr); + statePtr = chanPtr->state; + + /* + * Remove any fileevents registered in this interpreter. + */ + + for (sPtr = statePtr->scriptRecordPtr, prevPtr = NULL; + sPtr != NULL; sPtr = nextPtr) { + nextPtr = sPtr->nextPtr; + if (sPtr->interp == interp) { + if (prevPtr == NULL) { + statePtr->scriptRecordPtr = nextPtr; + } else { + prevPtr->nextPtr = nextPtr; + } + + Tcl_DeleteChannelHandler((Tcl_Channel) chanPtr, + TclChannelEventScriptInvoker, sPtr); + + TclDecrRefCount(sPtr->scriptPtr); + ckfree(sPtr); + } else { + prevPtr = sPtr; + } + } + + /* + * Cannot call Tcl_UnregisterChannel because that procedure calls + * Tcl_GetAssocData to get the channel table, which might already be + * inaccessible from the interpreter structure. Instead, we emulate + * the behavior of Tcl_UnregisterChannel directly here. + */ + + Tcl_DeleteHashEntry(hPtr); + statePtr->epoch++; + if (statePtr->refCount-- <= 1) { + if (!GotFlag(statePtr, BG_FLUSH_SCHEDULED)) { + (void) Tcl_Close(interp, (Tcl_Channel) chanPtr); + } + } + + } + Tcl_DeleteHashTable(hTblPtr); + ckfree(hTblPtr); +} + +/* + *---------------------------------------------------------------------- + * + * CheckForStdChannelsBeingClosed -- + * + * Perform special handling for standard channels being closed. When + * given a standard channel, if the refcount is now 1, it means that the + * last reference to the standard channel is being explicitly closed. Now + * bump the refcount artificially down to 0, to ensure the normal + * handling of channels being closed will occur. Also reset the static + * pointer to the channel to NULL, to avoid dangling references. + * + * Results: + * None. + * + * Side effects: + * Manipulates the refcount on standard channels. May smash the global + * static pointer to a standard channel. + * + *---------------------------------------------------------------------- + */ + +static void +CheckForStdChannelsBeingClosed( + Tcl_Channel chan) +{ + ChannelState *statePtr = ((Channel *) chan)->state; + ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey); + + if (tsdPtr->stdinInitialized + && tsdPtr->stdinChannel != NULL + && statePtr == ((Channel *)tsdPtr->stdinChannel)->state) { + if (statePtr->refCount < 2) { + statePtr->refCount = 0; + tsdPtr->stdinChannel = NULL; + return; + } + } else if (tsdPtr->stdoutInitialized + && tsdPtr->stdoutChannel != NULL + && statePtr == ((Channel *)tsdPtr->stdoutChannel)->state) { + if (statePtr->refCount < 2) { + statePtr->refCount = 0; + tsdPtr->stdoutChannel = NULL; + return; + } + } else if (tsdPtr->stderrInitialized + && tsdPtr->stderrChannel != NULL + && statePtr == ((Channel *)tsdPtr->stderrChannel)->state) { + if (statePtr->refCount < 2) { + statePtr->refCount = 0; + tsdPtr->stderrChannel = NULL; + return; + } + } +} + +/* + *---------------------------------------------------------------------- + * + * Tcl_IsStandardChannel -- + * + * Test if the given channel is a standard channel. No attempt is made to + * check if the channel or the standard channels are initialized or + * otherwise valid. + * + * Results: + * Returns 1 if true, 0 if false. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +int +Tcl_IsStandardChannel( + Tcl_Channel chan) /* Channel to check. */ +{ + ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey); + + if ((chan == tsdPtr->stdinChannel) + || (chan == tsdPtr->stdoutChannel) + || (chan == tsdPtr->stderrChannel)) { + return 1; + } else { + return 0; + } +} + +/* + *---------------------------------------------------------------------- + * + * Tcl_RegisterChannel -- + * + * Adds an already-open channel to the channel table of an interpreter. + * If the interpreter passed as argument is NULL, it only increments the + * channel refCount. + * + * Results: + * None. + * + * Side effects: + * May increment the reference count of a channel. + * + *---------------------------------------------------------------------- + */ + +void +Tcl_RegisterChannel( + Tcl_Interp *interp, /* Interpreter in which to add the channel. */ + Tcl_Channel chan) /* The channel to add to this interpreter + * channel table. */ +{ + Tcl_HashTable *hTblPtr; /* Hash table of channels. */ + Tcl_HashEntry *hPtr; /* Search variable. */ + int isNew; /* Is the hash entry new or does it exist? */ + Channel *chanPtr; /* The actual channel. */ + ChannelState *statePtr; /* State of the actual channel. */ + + /* + * Always (un)register bottom-most channel in the stack. This makes + * management of the channel list easier because no manipulation is + * necessary during (un)stack operation. + */ + + chanPtr = ((Channel *) chan)->state->bottomChanPtr; + statePtr = chanPtr->state; + + if (statePtr->channelName == NULL) { + Tcl_Panic("Tcl_RegisterChannel: channel without name"); + } + if (interp != NULL) { + hTblPtr = GetChannelTable(interp); + hPtr = Tcl_CreateHashEntry(hTblPtr, statePtr->channelName, &isNew); + if (!isNew) { + if (chan == Tcl_GetHashValue(hPtr)) { + return; + } + + Tcl_Panic("Tcl_RegisterChannel: duplicate channel names"); + } + Tcl_SetHashValue(hPtr, chanPtr); + } + statePtr->refCount++; +} + +/* + *---------------------------------------------------------------------- + * + * Tcl_UnregisterChannel -- + * + * Deletes the hash entry for a channel associated with an interpreter. + * If the interpreter given as argument is NULL, it only decrements the + * reference count. (This all happens in the Tcl_DetachChannel helper + * function). + * + * Finally, if the reference count of the channel drops to zero, it is + * deleted. + * + * Results: + * A standard Tcl result. + * + * Side effects: + * Calls Tcl_DetachChannel which deletes the hash entry for a channel + * associated with an interpreter. + * + * May delete the channel, which can have a variety of consequences, + * especially if we are forced to close the channel. + * + *---------------------------------------------------------------------- + */ + +int +Tcl_UnregisterChannel( + Tcl_Interp *interp, /* Interpreter in which channel is defined. */ + Tcl_Channel chan) /* Channel to delete. */ +{ + ChannelState *statePtr; /* State of the real channel. */ + + statePtr = ((Channel *) chan)->state->bottomChanPtr->state; + + if (GotFlag(statePtr, CHANNEL_INCLOSE)) { + if (interp != NULL) { + Tcl_SetObjResult(interp, Tcl_NewStringObj( + "illegal recursive call to close through close-handler" + " of channel", -1)); + } + return TCL_ERROR; + } + + if (DetachChannel(interp, chan) != TCL_OK) { + return TCL_OK; + } + + statePtr = ((Channel *) chan)->state->bottomChanPtr->state; + + /* + * Perform special handling for standard channels being closed. If the + * refCount is now 1 it means that the last reference to the standard + * channel is being explicitly closed, so bump the refCount down + * artificially to 0. This will ensure that the channel is actually + * closed, below. Also set the static pointer to NULL for the channel. + */ + + CheckForStdChannelsBeingClosed(chan); + + /* + * If the refCount reached zero, close the actual channel. + */ + + if (statePtr->refCount <= 0) { + Tcl_Preserve(statePtr); + if (!GotFlag(statePtr, BG_FLUSH_SCHEDULED)) { + /* + * We don't want to re-enter Tcl_Close(). + */ + + if (!GotFlag(statePtr, CHANNEL_CLOSED)) { + if (Tcl_Close(interp, chan) != TCL_OK) { + SetFlag(statePtr, CHANNEL_CLOSED); + Tcl_Release(statePtr); + return TCL_ERROR; + } + } + } + SetFlag(statePtr, CHANNEL_CLOSED); + Tcl_Release(statePtr); + } + return TCL_OK; +} + +/* + *---------------------------------------------------------------------- + * + * Tcl_DetachChannel -- + * + * Deletes the hash entry for a channel associated with an interpreter. + * If the interpreter given as argument is NULL, it only decrements the + * reference count. Even if the ref count drops to zero, the channel is + * NOT closed or cleaned up. This allows a channel to be detached from an + * interpreter and left in the same state it was in when it was + * originally returned by 'Tcl_OpenFileChannel', for example. + * + * This function cannot be used on the standard channels, and will return + * TCL_ERROR if that is attempted. + * + * This function should only be necessary for special purposes in which + * you need to generate a pristine channel from one that has already been + * used. All ordinary purposes will almost always want to use + * Tcl_UnregisterChannel instead. + * + * Provided the channel is not attached to any other interpreter, it can + * then be closed with Tcl_Close, rather than with Tcl_UnregisterChannel. + * + * Results: + * A standard Tcl result. If the channel is not currently registered with + * the given interpreter, TCL_ERROR is returned, otherwise TCL_OK. + * However no error messages are left in the interp's result. + * + * Side effects: + * Deletes the hash entry for a channel associated with an interpreter. + * + *---------------------------------------------------------------------- + */ + +int +Tcl_DetachChannel( + Tcl_Interp *interp, /* Interpreter in which channel is defined. */ + Tcl_Channel chan) /* Channel to delete. */ +{ + if (Tcl_IsStandardChannel(chan)) { + return TCL_ERROR; + } + + return DetachChannel(interp, chan); +} + +/* + *---------------------------------------------------------------------- + * + * DetachChannel -- + * + * Deletes the hash entry for a channel associated with an interpreter. + * If the interpreter given as argument is NULL, it only decrements the + * reference count. Even if the ref count drops to zero, the channel is + * NOT closed or cleaned up. This allows a channel to be detached from an + * interpreter and left in the same state it was in when it was + * originally returned by 'Tcl_OpenFileChannel', for example. + * + * Results: + * A standard Tcl result. If the channel is not currently registered with + * the given interpreter, TCL_ERROR is returned, otherwise TCL_OK. + * However no error messages are left in the interp's result. + * + * Side effects: + * Deletes the hash entry for a channel associated with an interpreter. + * + *---------------------------------------------------------------------- + */ + +static int +DetachChannel( + Tcl_Interp *interp, /* Interpreter in which channel is defined. */ + Tcl_Channel chan) /* Channel to delete. */ +{ + Tcl_HashTable *hTblPtr; /* Hash table of channels. */ + Tcl_HashEntry *hPtr; /* Search variable. */ + Channel *chanPtr; /* The real IO channel. */ + ChannelState *statePtr; /* State of the real channel. */ + + /* + * Always (un)register bottom-most channel in the stack. This makes + * management of the channel list easier because no manipulation is + * necessary during (un)stack operation. + */ + + chanPtr = ((Channel *) chan)->state->bottomChanPtr; + statePtr = chanPtr->state; + + if (interp != NULL) { + hTblPtr = Tcl_GetAssocData(interp, "tclIO", NULL); + if (hTblPtr == NULL) { + return TCL_ERROR; + } + hPtr = Tcl_FindHashEntry(hTblPtr, statePtr->channelName); + if (hPtr == NULL) { + return TCL_ERROR; + } + if ((Channel *) Tcl_GetHashValue(hPtr) != chanPtr) { + return TCL_ERROR; + } + Tcl_DeleteHashEntry(hPtr); + statePtr->epoch++; + + /* + * Remove channel handlers that refer to this interpreter, so that + * they will not be present if the actual close is delayed and more + * events happen on the channel. This may occur if the channel is + * shared between several interpreters, or if the channel has async + * flushing active. + */ + + CleanupChannelHandlers(interp, chanPtr); + } + + statePtr->refCount--; + + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * Tcl_GetChannel -- + * + * Finds an existing Tcl_Channel structure by name in a given + * interpreter. This function is public because it is used by + * channel-type-specific functions. + * + * Results: + * A Tcl_Channel or NULL on failure. If failed, interp's result object + * contains an error message. *modePtr is filled with the modes in which + * the channel was opened. + * + * Side effects: + * None. + * + *--------------------------------------------------------------------------- + */ + +Tcl_Channel +Tcl_GetChannel( + Tcl_Interp *interp, /* Interpreter in which to find or create the + * channel. */ + const char *chanName, /* The name of the channel. */ + int *modePtr) /* Where to store the mode in which the + * channel was opened? Will contain an ORed + * combination of TCL_READABLE and + * TCL_WRITABLE, if non-NULL. */ +{ + Channel *chanPtr; /* The actual channel. */ + Tcl_HashTable *hTblPtr; /* Hash table of channels. */ + Tcl_HashEntry *hPtr; /* Search variable. */ + const char *name; /* Translated name. */ + + /* + * Substitute "stdin", etc. Note that even though we immediately find the + * channel using Tcl_GetStdChannel, we still need to look it up in the + * specified interpreter to ensure that it is present in the channel + * table. Otherwise, safe interpreters would always have access to the + * standard channels. + */ + + name = chanName; + if ((chanName[0] == 's') && (chanName[1] == 't')) { + chanPtr = NULL; + if (strcmp(chanName, "stdin") == 0) { + chanPtr = (Channel *) Tcl_GetStdChannel(TCL_STDIN); + } else if (strcmp(chanName, "stdout") == 0) { + chanPtr = (Channel *) Tcl_GetStdChannel(TCL_STDOUT); + } else if (strcmp(chanName, "stderr") == 0) { + chanPtr = (Channel *) Tcl_GetStdChannel(TCL_STDERR); + } + if (chanPtr != NULL) { + name = chanPtr->state->channelName; + } + } + + hTblPtr = GetChannelTable(interp); + hPtr = Tcl_FindHashEntry(hTblPtr, name); + if (hPtr == NULL) { + Tcl_SetObjResult(interp, Tcl_ObjPrintf( + "can not find channel named \"%s\"", chanName)); + Tcl_SetErrorCode(interp, "TCL", "LOOKUP", "CHANNEL", chanName, NULL); + return NULL; + } + + /* + * Always return bottom-most channel in the stack. This one lives the + * longest - other channels may go away unnoticed. The other APIs + * compensate where necessary to retrieve the topmost channel again. + */ + + chanPtr = Tcl_GetHashValue(hPtr); + chanPtr = chanPtr->state->bottomChanPtr; + if (modePtr != NULL) { + *modePtr = chanPtr->state->flags & (TCL_READABLE|TCL_WRITABLE); + } + + return (Tcl_Channel) chanPtr; +} + +/* + *--------------------------------------------------------------------------- + * + * TclGetChannelFromObj -- + * + * Finds an existing Tcl_Channel structure by name in a given + * interpreter. This function is public because it is used by + * channel-type-specific functions. + * + * Results: + * A Tcl_Channel or NULL on failure. If failed, interp's result object + * contains an error message. *modePtr is filled with the modes in which + * the channel was opened. + * + * Side effects: + * None. + * + *--------------------------------------------------------------------------- + */ + +int +TclGetChannelFromObj( + Tcl_Interp *interp, /* Interpreter in which to find or create the + * channel. */ + Tcl_Obj *objPtr, + Tcl_Channel *channelPtr, + int *modePtr, /* Where to store the mode in which the + * channel was opened? Will contain an ORed + * combination of TCL_READABLE and + * TCL_WRITABLE, if non-NULL. */ + int flags) +{ + ChannelState *statePtr; + ResolvedChanName *resPtr = NULL; + Tcl_Channel chan; + + if (interp == NULL) { + return TCL_ERROR; + } + + if (objPtr->typePtr == &chanObjType) { + /* + * Confirm validity of saved lookup results. + */ + + resPtr = (ResolvedChanName *) objPtr->internalRep.twoPtrValue.ptr1; + statePtr = resPtr->statePtr; + if ((resPtr->interp == interp) /* Same interp context */ + /* No epoch change in channel since lookup */ + && (resPtr->epoch == statePtr->epoch)) { + + /* Have a valid saved lookup. Jump to end to return it. */ + goto valid; + } + } + + chan = Tcl_GetChannel(interp, TclGetString(objPtr), NULL); + + if (chan == NULL) { + if (resPtr) { + FreeChannelIntRep(objPtr); + } + return TCL_ERROR; + } + + if (resPtr && resPtr->refCount == 1) { + /* Re-use the ResolvedCmdName struct */ + Tcl_Release((ClientData) resPtr->statePtr); + + } else { + TclFreeIntRep(objPtr); + + resPtr = (ResolvedChanName *) ckalloc(sizeof(ResolvedChanName)); + resPtr->refCount = 1; + objPtr->internalRep.twoPtrValue.ptr1 = (ClientData) resPtr; + objPtr->typePtr = &chanObjType; + } + statePtr = ((Channel *)chan)->state; + resPtr->statePtr = statePtr; + Tcl_Preserve((ClientData) statePtr); + resPtr->interp = interp; + resPtr->epoch = statePtr->epoch; + + valid: + *channelPtr = (Tcl_Channel) statePtr->bottomChanPtr; + + if (modePtr != NULL) { + *modePtr = statePtr->flags & (TCL_READABLE|TCL_WRITABLE); + } + + return TCL_OK; +} + +/* + *---------------------------------------------------------------------- + * + * Tcl_CreateChannel -- + * + * Creates a new entry in the hash table for a Tcl_Channel record. + * + * Results: + * Returns the new Tcl_Channel. + * + * Side effects: + * Creates a new Tcl_Channel instance and inserts it into the hash table. + * + *---------------------------------------------------------------------- + */ + +Tcl_Channel +Tcl_CreateChannel( + const Tcl_ChannelType *typePtr, /* The channel type record. */ + const char *chanName, /* Name of channel to record. */ + ClientData instanceData, /* Instance specific data. */ + int mask) /* TCL_READABLE & TCL_WRITABLE to indicate if + * the channel is readable, writable. */ +{ + Channel *chanPtr; /* The channel structure newly created. */ + ChannelState *statePtr; /* The stack-level independent state info for + * the channel. */ + const char *name; + char *tmp; + ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey); + + /* + * With the change of the Tcl_ChannelType structure to use a version in + * 8.3.2+, we have to make sure that our assumption that the structure + * remains a binary compatible size is true. + * + * If this assertion fails on some system, then it can be removed only if + * the user recompiles code with older channel drivers in the new system + * as well. + */ + + assert(sizeof(Tcl_ChannelTypeVersion) == sizeof(Tcl_DriverBlockModeProc *)); + assert(typePtr->typeName != NULL); + if (NULL == typePtr->closeProc) { + Tcl_Panic("channel type %s must define closeProc", typePtr->typeName); + } + if ((TCL_READABLE & mask) && (NULL == typePtr->inputProc)) { + Tcl_Panic("channel type %s must define inputProc when used for reader channel", typePtr->typeName); + } + if ((TCL_WRITABLE & mask) && (NULL == typePtr->outputProc)) { + Tcl_Panic("channel type %s must define outputProc when used for writer channel", typePtr->typeName); + } + if (NULL == typePtr->watchProc) { + Tcl_Panic("channel type %s must define watchProc", typePtr->typeName); + } + if ((NULL!=typePtr->wideSeekProc) && (NULL == typePtr->seekProc)) { + Tcl_Panic("channel type %s must define seekProc if defining wideSeekProc", typePtr->typeName); + } + + /* + * JH: We could subsequently memset these to 0 to avoid the numerous + * assignments to 0/NULL below. + */ + + chanPtr = ckalloc(sizeof(Channel)); + statePtr = ckalloc(sizeof(ChannelState)); + chanPtr->state = statePtr; + + chanPtr->instanceData = instanceData; + chanPtr->typePtr = typePtr; + + /* + * Set all the bits that are part of the stack-independent state + * information for the channel. + */ + + if (chanName != NULL) { + unsigned len = strlen(chanName) + 1; + + /* + * Make sure we allocate at least 7 bytes, so it fits for "stdout" + * later. + */ + + tmp = ckalloc((len < 7) ? 7 : len); + strcpy(tmp, chanName); + } else { + tmp = ckalloc(7); + tmp[0] = '\0'; + } + statePtr->channelName = tmp; + statePtr->flags = mask; + + /* + * Set the channel to system default encoding. + * + * Note the strange bit of protection taking place here. If the system + * encoding name is reported back as "binary", something weird is + * happening. Tcl provides no "binary" encoding, so someone else has + * provided one. We ignore it so as not to interfere with the "magic" + * interpretation that Tcl_Channels give to the "-encoding binary" option. + */ + + statePtr->encoding = NULL; + name = Tcl_GetEncodingName(NULL); + if (strcmp(name, "binary") != 0) { + statePtr->encoding = Tcl_GetEncoding(NULL, name); + } + statePtr->inputEncodingState = NULL; + statePtr->inputEncodingFlags = TCL_ENCODING_START; + statePtr->outputEncodingState = NULL; + statePtr->outputEncodingFlags = TCL_ENCODING_START; + + /* + * Set the channel up initially in AUTO input translation mode to accept + * "\n", "\r" and "\r\n". Output translation mode is set to a platform + * specific default value. The eofChar is set to 0 for both input and + * output, so that Tcl does not look for an in-file EOF indicator (e.g. + * ^Z) and does not append an EOF indicator to files. + */ + + statePtr->inputTranslation = TCL_TRANSLATE_AUTO; + statePtr->outputTranslation = TCL_PLATFORM_TRANSLATION; + statePtr->inEofChar = 0; + statePtr->outEofChar = 0; + + statePtr->unreportedError = 0; + statePtr->refCount = 0; + statePtr->closeCbPtr = NULL; + statePtr->curOutPtr = NULL; + statePtr->outQueueHead = NULL; + statePtr->outQueueTail = NULL; + statePtr->saveInBufPtr = NULL; + statePtr->inQueueHead = NULL; + statePtr->inQueueTail = NULL; + statePtr->chPtr = NULL; + statePtr->interestMask = 0; + statePtr->scriptRecordPtr = NULL; + statePtr->bufSize = CHANNELBUFFER_DEFAULT_SIZE; + statePtr->timer = NULL; + statePtr->csPtrR = NULL; + statePtr->csPtrW = NULL; + statePtr->outputStage = NULL; + + /* + * As we are creating the channel, it is obviously the top for now. + */ + + statePtr->topChanPtr = chanPtr; + statePtr->bottomChanPtr = chanPtr; + chanPtr->downChanPtr = NULL; + chanPtr->upChanPtr = NULL; + chanPtr->inQueueHead = NULL; + chanPtr->inQueueTail = NULL; + chanPtr->refCount = 0; + + /* + * TIP #219, Tcl Channel Reflection API + */ + + statePtr->chanMsg = NULL; + statePtr->unreportedMsg = NULL; + + statePtr->epoch = 0; + + /* + * Link the channel into the list of all channels; create an on-exit + * handler if there is not one already, to close off all the channels in + * the list on exit. + * + * JH: Could call Tcl_SpliceChannel, but need to avoid NULL check. + * + * TIP #218. + * AK: Just initialize the field to NULL before invoking Tcl_SpliceChannel + * We need Tcl_SpliceChannel, for the threadAction calls. There is no + * real reason to duplicate all of this. + * NOTE: All drivers using thread actions now have to perform their TSD + * manipulation only in their thread action proc. Doing it when + * creating their instance structures will collide with the thread + * action activity and lead to damaged lists. + */ + + statePtr->nextCSPtr = NULL; + SpliceChannel((Tcl_Channel) chanPtr); + + /* + * Install this channel in the first empty standard channel slot, if the + * channel was previously closed explicitly. + */ + + if ((tsdPtr->stdinChannel == NULL) && (tsdPtr->stdinInitialized == 1)) { + strcpy(tmp, "stdin"); + Tcl_SetStdChannel((Tcl_Channel) chanPtr, TCL_STDIN); + Tcl_RegisterChannel(NULL, (Tcl_Channel) chanPtr); + } else if ((tsdPtr->stdoutChannel == NULL) && + (tsdPtr->stdoutInitialized == 1)) { + strcpy(tmp, "stdout"); + Tcl_SetStdChannel((Tcl_Channel) chanPtr, TCL_STDOUT); + Tcl_RegisterChannel(NULL, (Tcl_Channel) chanPtr); + } else if ((tsdPtr->stderrChannel == NULL) && + (tsdPtr->stderrInitialized == 1)) { + strcpy(tmp, "stderr"); + Tcl_SetStdChannel((Tcl_Channel) chanPtr, TCL_STDERR); + Tcl_RegisterChannel(NULL, (Tcl_Channel) chanPtr); + } + return (Tcl_Channel) chanPtr; +} + +/* + *---------------------------------------------------------------------- + * + * Tcl_StackChannel -- + * + * Replaces an entry in the hash table for a Tcl_Channel record. The + * replacement is a new channel with same name, it supercedes the + * replaced channel. Input and output of the superceded channel is now + * going through the newly created channel and allows the arbitrary + * filtering/manipulation of the dataflow. + * + * Andreas Kupries <a.kupries@westend.com>, 12/13/1998 "Trf-Patch for + * filtering channels" + * + * Results: + * Returns the new Tcl_Channel, which actually contains the saved + * information about prevChan. + * + * Side effects: + * A new channel structure is allocated and linked below the existing + * channel. The channel operations and client data of the existing + * channel are copied down to the newly created channel, and the current + * channel has its operations replaced by the new typePtr. + * + *---------------------------------------------------------------------- + */ + +Tcl_Channel +Tcl_StackChannel( + Tcl_Interp *interp, /* The interpreter we are working in */ + const Tcl_ChannelType *typePtr, + /* The channel type record for the new + * channel. */ + ClientData instanceData, /* Instance specific data for the new + * channel. */ + int mask, /* TCL_READABLE & TCL_WRITABLE to indicate if + * the channel is readable, writable. */ + Tcl_Channel prevChan) /* The channel structure to replace */ +{ + ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey); + Channel *chanPtr, *prevChanPtr; + ChannelState *statePtr; + + /* + * Find the given channel (prevChan) in the list of all channels. If we do + * not find it, then it was never registered correctly. + * + * This operation should occur at the top of a channel stack. + */ + + statePtr = (ChannelState *) tsdPtr->firstCSPtr; + prevChanPtr = ((Channel *) prevChan)->state->topChanPtr; + + while ((statePtr != NULL) && (statePtr->topChanPtr != prevChanPtr)) { + statePtr = statePtr->nextCSPtr; + } + + if (statePtr == NULL) { + if (interp) { + Tcl_SetObjResult(interp, Tcl_ObjPrintf( + "couldn't find state for channel \"%s\"", + Tcl_GetChannelName(prevChan))); + } + return NULL; + } + + /* + * Here we check if the given "mask" matches the "flags" of the already + * existing channel. + * + * | - | R | W | RW | + * --+---+---+---+----+ <=> 0 != (chan->mask & prevChan->mask) + * - | | | | | + * R | | + | | + | The superceding channel is allowed to restrict + * W | | | + | + | the capabilities of the superceded one! + * RW| | + | + | + | + * --+---+---+---+----+ + */ + + if ((mask & (statePtr->flags & (TCL_READABLE | TCL_WRITABLE))) == 0) { + if (interp) { + Tcl_SetObjResult(interp, Tcl_ObjPrintf( + "reading and writing both disallowed for channel \"%s\"", + Tcl_GetChannelName(prevChan))); + } + return NULL; + } + + /* + * Flush the buffers. This ensures that any data still in them at this + * time is not handled by the new transformation. Restrict this to + * writable channels. Take care to hide a possible bg-copy in progress + * from Tcl_Flush and the CheckForChannelErrors inside. + */ + + if ((mask & TCL_WRITABLE) != 0) { + CopyState *csPtrR = statePtr->csPtrR; + CopyState *csPtrW = statePtr->csPtrW; + + statePtr->csPtrR = NULL; + statePtr->csPtrW = NULL; + + /* + * TODO: Examine what can go wrong if Tcl_Flush() call disturbs + * the stacking state of this channel during its operations. + */ + if (Tcl_Flush((Tcl_Channel) prevChanPtr) != TCL_OK) { + statePtr->csPtrR = csPtrR; + statePtr->csPtrW = csPtrW; + if (interp) { + Tcl_SetObjResult(interp, Tcl_ObjPrintf( + "could not flush channel \"%s\"", + Tcl_GetChannelName(prevChan))); + } + return NULL; + } + + statePtr->csPtrR = csPtrR; + statePtr->csPtrW = csPtrW; + } + + /* + * Discard any input in the buffers. They are not yet read by the user of + * the channel, so they have to go through the new transformation before + * reading. As the buffers contain the untransformed form their contents + * are not only useless but actually distorts our view of the system. + * + * To preserve the information without having to read them again and to + * avoid problems with the location in the channel (seeking might be + * impossible) we move the buffers from the common state structure into + * the channel itself. We use the buffers in the channel below the new + * transformation to hold the data. In the future this allows us to write + * transformations which pre-read data and push the unused part back when + * they are going away. + */ + + if (((mask & TCL_READABLE) != 0) && (statePtr->inQueueHead != NULL)) { + + /* + * When statePtr->inQueueHead is not NULL, we know + * prevChanPtr->inQueueHead must be NULL. + */ + + assert(prevChanPtr->inQueueHead == NULL); + assert(prevChanPtr->inQueueTail == NULL); + + prevChanPtr->inQueueHead = statePtr->inQueueHead; + prevChanPtr->inQueueTail = statePtr->inQueueTail; + + statePtr->inQueueHead = NULL; + statePtr->inQueueTail = NULL; + } + + chanPtr = ckalloc(sizeof(Channel)); + + /* + * Save some of the current state into the new structure, reinitialize the + * parts which will stay with the transformation. + * + * Remarks: + */ + + chanPtr->state = statePtr; + chanPtr->instanceData = instanceData; + chanPtr->typePtr = typePtr; + chanPtr->downChanPtr = prevChanPtr; + chanPtr->upChanPtr = NULL; + chanPtr->inQueueHead = NULL; + chanPtr->inQueueTail = NULL; + chanPtr->refCount = 0; + + /* + * Place new block at the head of a possibly existing list of previously + * stacked channels. + */ + + prevChanPtr->upChanPtr = chanPtr; + statePtr->topChanPtr = chanPtr; + + /* + * TIP #218, Channel Thread Actions. + * + * We call the thread actions for the new channel directly. We _cannot_ + * use SpliceChannel, because the (thread-)global list of all channels + * always contains the _ChannelState_ for a stack of channels, not the + * individual channels. And SpliceChannel would not only call the thread + * actions, but also add the shared ChannelState to this list a second + * time, mangling it. + */ + + ChanThreadAction(chanPtr, TCL_CHANNEL_THREAD_INSERT); + + return (Tcl_Channel) chanPtr; +} + +void +TclChannelPreserve( + Tcl_Channel chan) +{ + ((Channel *)chan)->refCount++; +} + +void +TclChannelRelease( + Tcl_Channel chan) +{ + Channel *chanPtr = (Channel *) chan; + + if (chanPtr->refCount == 0) { + Tcl_Panic("Channel released more than preserved"); + } + if (--chanPtr->refCount) { + return; + } + if (chanPtr->typePtr == NULL) { + ckfree(chanPtr); + } +} + +static void +ChannelFree( + Channel *chanPtr) +{ + if (chanPtr->refCount == 0) { + ckfree(chanPtr); + return; + } + chanPtr->typePtr = NULL; +} + +/* + *---------------------------------------------------------------------- + * + * Tcl_UnstackChannel -- + * + * Unstacks an entry in the hash table for a Tcl_Channel record. This is + * the reverse to 'Tcl_StackChannel'. + * + * Results: + * A standard Tcl result. + * + * Side effects: + * If TCL_ERROR is returned, the posix error code will be set with + * Tcl_SetErrno. May leave a message in interp result as well. + * + *---------------------------------------------------------------------- + */ + +int +Tcl_UnstackChannel( + Tcl_Interp *interp, /* The interpreter we are working in */ + Tcl_Channel chan) /* The channel to unstack */ +{ + Channel *chanPtr = (Channel *) chan; + ChannelState *statePtr = chanPtr->state; + int result = 0; + + /* + * This operation should occur at the top of a channel stack. + */ + + chanPtr = statePtr->topChanPtr; + + if (chanPtr->downChanPtr != NULL) { + /* + * Instead of manipulating the per-thread / per-interp list/hashtable + * of registered channels we wind down the state of the + * transformation, and then restore the state of underlying channel + * into the old structure. + */ + + /* + * TODO: Figure out how to handle the situation where the chan + * operations called below by this unstacking operation cause + * another unstacking recursively. In that case the downChanPtr + * value we're holding on to will not be the right thing. + */ + + Channel *downChanPtr = chanPtr->downChanPtr; + + /* + * Flush the buffers. This ensures that any data still in them at this + * time _is_ handled by the transformation we are unstacking right + * now. Restrict this to writable channels. Take care to hide a + * possible bg-copy in progress from Tcl_Flush and the + * CheckForChannelErrors inside. + */ + + if (GotFlag(statePtr, TCL_WRITABLE)) { + CopyState *csPtrR = statePtr->csPtrR; + CopyState *csPtrW = statePtr->csPtrW; + + statePtr->csPtrR = NULL; + statePtr->csPtrW = NULL; + + if (Tcl_Flush((Tcl_Channel) chanPtr) != TCL_OK) { + statePtr->csPtrR = csPtrR; + statePtr->csPtrW = csPtrW; + + /* + * TIP #219, Tcl Channel Reflection API. + * Move error messages put by the driver into the chan/ip + * bypass area into the regular interpreter result. Fall back + * to the regular message if nothing was found in the + * bypasses. + */ + + if (!TclChanCaughtErrorBypass(interp, chan) && interp) { + Tcl_SetObjResult(interp, Tcl_ObjPrintf( + "could not flush channel \"%s\"", + Tcl_GetChannelName((Tcl_Channel) chanPtr))); + } + return TCL_ERROR; + } + + statePtr->csPtrR = csPtrR; + statePtr->csPtrW = csPtrW; + } + + /* + * Anything in the input queue and the push-back buffers of the + * transformation going away is transformed data, but not yet read. As + * unstacking means that the caller does not want to see transformed + * data any more we have to discard these bytes. To avoid writing an + * analogue to 'DiscardInputQueued' we move the information in the + * push back buffers to the input queue and then call + * 'DiscardInputQueued' on that. + */ + + if (GotFlag(statePtr, TCL_READABLE) && + ((statePtr->inQueueHead != NULL) || + (chanPtr->inQueueHead != NULL))) { + if ((statePtr->inQueueHead != NULL) && + (chanPtr->inQueueHead != NULL)) { + statePtr->inQueueTail->nextPtr = chanPtr->inQueueHead; + statePtr->inQueueTail = chanPtr->inQueueTail; + statePtr->inQueueHead = statePtr->inQueueTail; + } else if (chanPtr->inQueueHead != NULL) { + statePtr->inQueueHead = chanPtr->inQueueHead; + statePtr->inQueueTail = chanPtr->inQueueTail; + } + + chanPtr->inQueueHead = NULL; + chanPtr->inQueueTail = NULL; + + DiscardInputQueued(statePtr, 0); + } + + /* + * TIP #218, Channel Thread Actions. + * + * We call the thread actions for the new channel directly. We + * _cannot_ use CutChannel, because the (thread-)global list of all + * channels always contains the _ChannelState_ for a stack of + * channels, not the individual channels. And SpliceChannel would not + * only call the thread actions, but also remove the shared + * ChannelState from this list despite there being more channels for + * the state which are still active. + */ + + ChanThreadAction(chanPtr, TCL_CHANNEL_THREAD_REMOVE); + + statePtr->topChanPtr = downChanPtr; + downChanPtr->upChanPtr = NULL; + + /* + * Leave this link intact for closeproc + * chanPtr->downChanPtr = NULL; + */ + + /* + * Close and free the channel driver state. + */ + + result = ChanClose(chanPtr, interp); + ChannelFree(chanPtr); + + UpdateInterest(statePtr->topChanPtr); + + if (result != 0) { + Tcl_SetErrno(result); + + /* + * TIP #219, Tcl Channel Reflection API. + * Move error messages put by the driver into the chan/ip bypass + * area into the regular interpreter result. + */ + + TclChanCaughtErrorBypass(interp, chan); + return TCL_ERROR; + } + } else { + /* + * This channel does not cover another one. Simply do a close, if + * necessary. + */ + + if (statePtr->refCount <= 0) { + if (Tcl_Close(interp, chan) != TCL_OK) { + /* + * TIP #219, Tcl Channel Reflection API. + * "TclChanCaughtErrorBypass" is not required here, it was + * done already by "Tcl_Close". + */ + + return TCL_ERROR; + } + } + + /* + * TIP #218, Channel Thread Actions. + * Not required in this branch, this is done by Tcl_Close. If + * Tcl_Close is not called then the ChannelState is still active in + * the thread and no action has to be taken either. + */ + } + + return TCL_OK; +} + +/* + *---------------------------------------------------------------------- + * + * Tcl_GetStackedChannel -- + * + * Determines whether the specified channel is stacked upon another. + * + * Results: + * NULL if the channel is not stacked upon another one, or a reference to + * the channel it is stacked upon. This reference can be used in queries, + * but modification is not allowed. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +Tcl_Channel +Tcl_GetStackedChannel( + Tcl_Channel chan) +{ + Channel *chanPtr = (Channel *) chan; + /* The actual channel. */ + + return (Tcl_Channel) chanPtr->downChanPtr; +} + +/* + *---------------------------------------------------------------------- + * + * Tcl_GetTopChannel -- + * + * Returns the top channel of a channel stack. + * + * Results: + * NULL if the channel is not stacked upon another one, or a reference to + * the channel it is stacked upon. This reference can be used in queries, + * but modification is not allowed. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +Tcl_Channel +Tcl_GetTopChannel( + Tcl_Channel chan) +{ + Channel *chanPtr = (Channel *) chan; + /* The actual channel. */ + + return (Tcl_Channel) chanPtr->state->topChanPtr; +} + +/* + *---------------------------------------------------------------------- + * + * Tcl_GetChannelInstanceData -- + * + * Returns the client data associated with a channel. + * + * Results: + * The client data. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +ClientData +Tcl_GetChannelInstanceData( + Tcl_Channel chan) /* Channel for which to return client data. */ +{ + Channel *chanPtr = (Channel *) chan; + /* The actual channel. */ + + return chanPtr->instanceData; +} + +/* + *---------------------------------------------------------------------- + * + * Tcl_GetChannelThread -- + * + * Given a channel structure, returns the thread managing it. TIP #10 + * + * Results: + * Returns the id of the thread managing the channel. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +Tcl_ThreadId +Tcl_GetChannelThread( + Tcl_Channel chan) /* The channel to return the managing thread + * for. */ +{ + Channel *chanPtr = (Channel *) chan; + /* The actual channel. */ + + return chanPtr->state->managingThread; +} + +/* + *---------------------------------------------------------------------- + * + * Tcl_GetChannelType -- + * + * Given a channel structure, returns the channel type structure. + * + * Results: + * Returns a pointer to the channel type structure. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +const Tcl_ChannelType * +Tcl_GetChannelType( + Tcl_Channel chan) /* The channel to return type for. */ +{ + Channel *chanPtr = (Channel *) chan; + /* The actual channel. */ + + return chanPtr->typePtr; +} + +/* + *---------------------------------------------------------------------- + * + * Tcl_GetChannelMode -- + * + * Computes a mask indicating whether the channel is open for reading and + * writing. + * + * Results: + * An OR-ed combination of TCL_READABLE and TCL_WRITABLE. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +int +Tcl_GetChannelMode( + Tcl_Channel chan) /* The channel for which the mode is being + * computed. */ +{ + ChannelState *statePtr = ((Channel *) chan)->state; + /* State of actual channel. */ + + return (statePtr->flags & (TCL_READABLE | TCL_WRITABLE)); +} + +/* + *---------------------------------------------------------------------- + * + * Tcl_GetChannelName -- + * + * Returns the string identifying the channel name. + * + * Results: + * The string containing the channel name. This memory is owned by the + * generic layer and should not be modified by the caller. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +const char * +Tcl_GetChannelName( + Tcl_Channel chan) /* The channel for which to return the name. */ +{ + ChannelState *statePtr = ((Channel *) chan)->state; + /* State of actual channel. */ + + return statePtr->channelName; +} + +/* + *---------------------------------------------------------------------- + * + * Tcl_GetChannelHandle -- + * + * Returns an OS handle associated with a channel. + * + * Results: + * Returns TCL_OK and places the handle in handlePtr, or returns + * TCL_ERROR on failure. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +int +Tcl_GetChannelHandle( + Tcl_Channel chan, /* The channel to get file from. */ + int direction, /* TCL_WRITABLE or TCL_READABLE. */ + ClientData *handlePtr) /* Where to store handle */ +{ + Channel *chanPtr; /* The actual channel. */ + ClientData handle; + int result; + + chanPtr = ((Channel *) chan)->state->bottomChanPtr; + if (!chanPtr->typePtr->getHandleProc) { + Tcl_SetChannelError(chan, Tcl_ObjPrintf( + "channel \"%s\" does not support OS handles", + Tcl_GetChannelName(chan))); + return TCL_ERROR; + } + result = chanPtr->typePtr->getHandleProc(chanPtr->instanceData, direction, + &handle); + if (handlePtr) { + *handlePtr = handle; + } + return result; +} + +/* + *--------------------------------------------------------------------------- + * + * AllocChannelBuffer -- + * + * A channel buffer has BUFFER_PADDING bytes extra at beginning to hold + * any bytes of a native-encoding character that got split by the end of + * the previous buffer and need to be moved to the beginning of the next + * buffer to make a contiguous string so it can be converted to UTF-8. + * + * A channel buffer has BUFFER_PADDING bytes extra at the end to hold any + * bytes of a native-encoding character (generated from a UTF-8 + * character) that overflow past the end of the buffer and need to be + * moved to the next buffer. + * + * Results: + * A newly allocated channel buffer. + * + * Side effects: + * None. + * + *--------------------------------------------------------------------------- + */ + +static ChannelBuffer * +AllocChannelBuffer( + int length) /* Desired length of channel buffer. */ +{ + ChannelBuffer *bufPtr; + int n; + + n = length + CHANNELBUFFER_HEADER_SIZE + BUFFER_PADDING + BUFFER_PADDING; + bufPtr = ckalloc(n); + bufPtr->nextAdded = BUFFER_PADDING; + bufPtr->nextRemoved = BUFFER_PADDING; + bufPtr->bufLength = length + BUFFER_PADDING; + bufPtr->nextPtr = NULL; + bufPtr->refCount = 1; + return bufPtr; +} + +static void +PreserveChannelBuffer( + ChannelBuffer *bufPtr) +{ + if (bufPtr->refCount == 0) { + Tcl_Panic("Reuse of ChannelBuffer! %p", bufPtr); + } + bufPtr->refCount++; +} + +static void +ReleaseChannelBuffer( + ChannelBuffer *bufPtr) +{ + if (--bufPtr->refCount) { + return; + } + ckfree(bufPtr); +} + +static int +IsShared( + ChannelBuffer *bufPtr) +{ + return bufPtr->refCount > 1; +} + +/* + *---------------------------------------------------------------------- + * + * RecycleBuffer -- + * + * Helper function to recycle input and output buffers. Ensures that two + * input buffers are saved (one in the input queue and another in the + * saveInBufPtr field) and that curOutPtr is set to a buffer. Only if + * these conditions are met is the buffer freed to the OS. + * + * Results: + * None. + * + * Side effects: + * May free a buffer to the OS. + * + *---------------------------------------------------------------------- + */ + +static void +RecycleBuffer( + ChannelState *statePtr, /* ChannelState in which to recycle buffers. */ + ChannelBuffer *bufPtr, /* The buffer to recycle. */ + int mustDiscard) /* If nonzero, free the buffer to the OS, + * always. */ +{ + /* + * Do we have to free the buffer to the OS? + */ + if (IsShared(bufPtr)) { + mustDiscard = 1; + } + + if (mustDiscard) { + ReleaseChannelBuffer(bufPtr); + return; + } + + /* + * Only save buffers which have the requested buffersize for the + * channel. This is to honor dynamic changes of the buffersize + * made by the user. + */ + + if ((bufPtr->bufLength - BUFFER_PADDING) != statePtr->bufSize) { + ReleaseChannelBuffer(bufPtr); + return; + } + + /* + * Only save buffers for the input queue if the channel is readable. + */ + + if (GotFlag(statePtr, TCL_READABLE)) { + if (statePtr->inQueueHead == NULL) { + statePtr->inQueueHead = bufPtr; + statePtr->inQueueTail = bufPtr; + goto keepBuffer; + } + if (statePtr->saveInBufPtr == NULL) { + statePtr->saveInBufPtr = bufPtr; + goto keepBuffer; + } + } + + /* + * Only save buffers for the output queue if the channel is writable. + */ + + if (GotFlag(statePtr, TCL_WRITABLE)) { + if (statePtr->curOutPtr == NULL) { + statePtr->curOutPtr = bufPtr; + goto keepBuffer; + } + } + + /* + * If we reached this code we return the buffer to the OS. + */ + + ReleaseChannelBuffer(bufPtr); + return; + + keepBuffer: + bufPtr->nextRemoved = BUFFER_PADDING; + bufPtr->nextAdded = BUFFER_PADDING; + bufPtr->nextPtr = NULL; +} + +/* + *---------------------------------------------------------------------- + * + * DiscardOutputQueued -- + * + * Discards all output queued in the output queue of a channel. + * + * Results: + * None. + * + * Side effects: + * Recycles buffers. + * + *---------------------------------------------------------------------- + */ + +static void +DiscardOutputQueued( + ChannelState *statePtr) /* ChannelState for which to discard output. */ +{ + ChannelBuffer *bufPtr; + + while (statePtr->outQueueHead != NULL) { + bufPtr = statePtr->outQueueHead; + statePtr->outQueueHead = bufPtr->nextPtr; + RecycleBuffer(statePtr, bufPtr, 0); + } + statePtr->outQueueHead = NULL; + statePtr->outQueueTail = NULL; + bufPtr = statePtr->curOutPtr; + if (bufPtr && BytesLeft(bufPtr)) { + statePtr->curOutPtr = NULL; + RecycleBuffer(statePtr, bufPtr, 0); + } +} + +/* + *---------------------------------------------------------------------- + * + * CheckForDeadChannel -- + * + * This function checks is a given channel is Dead (a channel that has + * been closed but not yet deallocated.) + * + * Results: + * True (1) if channel is Dead, False (0) if channel is Ok + * + * Side effects: + * None + * + *---------------------------------------------------------------------- + */ + +static int +CheckForDeadChannel( + Tcl_Interp *interp, /* For error reporting (can be NULL) */ + ChannelState *statePtr) /* The channel state to check. */ +{ + if (!GotFlag(statePtr, CHANNEL_DEAD)) { + return 0; + } + + Tcl_SetErrno(EINVAL); + if (interp) { + Tcl_SetObjResult(interp, Tcl_NewStringObj( + "unable to access channel: invalid channel", -1)); + } + return 1; +} + +/* + *---------------------------------------------------------------------- + * + * FlushChannel -- + * + * This function flushes as much of the queued output as is possible now. + * If calledFromAsyncFlush is nonzero, it is being called in an event + * handler to flush channel output asynchronously. + * + * Results: + * 0 if successful, else the error code that was returned by the channel + * type operation. May leave a message in the interp result. + * + * Side effects: + * May produce output on a channel. May block indefinitely if the channel + * is synchronous. May schedule an async flush on the channel. May + * recycle memory for buffers in the output queue. + * + *---------------------------------------------------------------------- + */ + +static int +FlushChannel( + Tcl_Interp *interp, /* For error reporting during close. */ + Channel *chanPtr, /* The channel to flush on. */ + int calledFromAsyncFlush) /* If nonzero then we are being called from an + * asynchronous flush callback. */ +{ + ChannelState *statePtr = chanPtr->state; + /* State of the channel stack. */ + ChannelBuffer *bufPtr; /* Iterates over buffered output queue. */ + int written; /* Amount of output data actually written in + * current round. */ + int errorCode = 0; /* Stores POSIX error codes from channel + * driver operations. */ + int wroteSome = 0; /* Set to one if any data was written to the + * driver. */ + + /* + * Prevent writing on a dead channel -- a channel that has been closed but + * not yet deallocated. This can occur if the exit handler for the channel + * deallocation runs before all channels are deregistered in all + * interpreters. + */ + + if (CheckForDeadChannel(interp, statePtr)) { + return -1; + } + + /* + * Should we shift the current output buffer over to the output queue? + * First check that there are bytes in it. If so then... + * If the output queue is empty, then yes, trusting the caller called + * us only when written bytes ought to be flushed. + * If the current output buffer is full, then yes, so we can meet + * the post-condition that on a successful return to caller we've + * left space in the current output buffer for more writing (the flush + * call was to make new room). + * If the channel is blocking, then yes, so we guarantee that + * blocking flushes actually flush all pending data. + * Otherwise, no. Keep the current output buffer where it is so more + * can be written to it, possibly filling it, to promote more efficient + * buffer usage. + */ + + bufPtr = statePtr->curOutPtr; + if (bufPtr && BytesLeft(bufPtr) && /* Keep empties off queue */ + (statePtr->outQueueHead == NULL || IsBufferFull(bufPtr) + || !GotFlag(statePtr, CHANNEL_NONBLOCKING))) { + if (statePtr->outQueueHead == NULL) { + statePtr->outQueueHead = bufPtr; + } else { + statePtr->outQueueTail->nextPtr = bufPtr; + } + statePtr->outQueueTail = bufPtr; + statePtr->curOutPtr = NULL; + } + + assert(!IsBufferFull(statePtr->curOutPtr)); + + /* + * If we are not being called from an async flush and an async flush + * is active, we just return without producing any output. + */ + + if (!calledFromAsyncFlush && GotFlag(statePtr, BG_FLUSH_SCHEDULED)) { + return 0; + } + + /* + * Loop over the queued buffers and attempt to flush as much as possible + * of the queued output to the channel. + */ + + TclChannelPreserve((Tcl_Channel)chanPtr); + while (statePtr->outQueueHead) { + bufPtr = statePtr->outQueueHead; + + /* + * Produce the output on the channel. + */ + + PreserveChannelBuffer(bufPtr); + written = ChanWrite(chanPtr, RemovePoint(bufPtr), BytesLeft(bufPtr), + &errorCode); + + /* + * If the write failed completely attempt to start the asynchronous + * flush mechanism and break out of this loop - do not attempt to + * write any more output at this time. + */ + + if (written < 0) { + /* + * If the last attempt to write was interrupted, simply retry. + */ + + if (errorCode == EINTR) { + errorCode = 0; + ReleaseChannelBuffer(bufPtr); + continue; + } + + /* + * If the channel is non-blocking and we would have blocked, start + * a background flushing handler and break out of the loop. + */ + + if ((errorCode == EWOULDBLOCK) || (errorCode == EAGAIN)) { + /* + * This used to check for CHANNEL_NONBLOCKING, and panic if + * the channel was blocking. However, it appears that setting + * stdin to -blocking 0 has some effect on the stdout when + * it's a tty channel (dup'ed underneath) + */ + + if (!GotFlag(statePtr, BG_FLUSH_SCHEDULED) && !TclInExit()) { + SetFlag(statePtr, BG_FLUSH_SCHEDULED); + UpdateInterest(chanPtr); + } + errorCode = 0; + ReleaseChannelBuffer(bufPtr); + break; + } + + /* + * Decide whether to report the error upwards or defer it. + */ + + if (calledFromAsyncFlush) { + /* + * TIP #219, Tcl Channel Reflection API. + * When defering the error copy a message from the bypass into + * the unreported area. Or discard it if the new error is to be + * ignored in favor of an earlier defered error. + */ + + Tcl_Obj *msg = statePtr->chanMsg; + + if (statePtr->unreportedError == 0) { + statePtr->unreportedError = errorCode; + statePtr->unreportedMsg = msg; + if (msg != NULL) { + Tcl_IncrRefCount(msg); + } + } else { + /* + * An old unreported error is kept, and this error thrown + * away. + */ + + statePtr->chanMsg = NULL; + if (msg != NULL) { + TclDecrRefCount(msg); + } + } + } else { + /* + * TIP #219, Tcl Channel Reflection API. + * Move error messages put by the driver into the chan bypass + * area into the regular interpreter result. Fall back to the + * regular message if nothing was found in the bypasses. + */ + + Tcl_SetErrno(errorCode); + if (interp != NULL && !TclChanCaughtErrorBypass(interp, + (Tcl_Channel) chanPtr)) { + Tcl_SetObjResult(interp, + Tcl_NewStringObj(Tcl_PosixError(interp), -1)); + } + + /* + * An unreportable bypassed message is kept, for the caller of + * Tcl_Seek, Tcl_Write, etc. + */ + } + + /* + * When we get an error we throw away all the output currently + * queued. + */ + + DiscardOutputQueued(statePtr); + ReleaseChannelBuffer(bufPtr); + break; + } else { + /* TODO: Consider detecting and reacting to short writes + * on blocking channels. Ought not happen. See iocmd-24.2. */ + wroteSome = 1; + } + + bufPtr->nextRemoved += written; + + /* + * If this buffer is now empty, recycle it. + */ + + if (IsBufferEmpty(bufPtr)) { + statePtr->outQueueHead = bufPtr->nextPtr; + if (statePtr->outQueueHead == NULL) { + statePtr->outQueueTail = NULL; + } + RecycleBuffer(statePtr, bufPtr, 0); + } + ReleaseChannelBuffer(bufPtr); + } /* Closes "while". */ + + /* + * If we wrote some data while flushing in the background, we are done. + * We can't finish the background flush until we run out of data and the + * channel becomes writable again. This ensures that all of the pending + * data has been flushed at the system level. + */ + + if (GotFlag(statePtr, BG_FLUSH_SCHEDULED)) { + if (wroteSome) { + goto done; + } else if (statePtr->outQueueHead == NULL) { + ResetFlag(statePtr, BG_FLUSH_SCHEDULED); + ChanWatch(chanPtr, statePtr->interestMask); + } else { + + /* + * When we are calledFromAsyncFlush, that means a writable + * state on the channel triggered the call, so we should be + * able to write something. Either we did write something + * and wroteSome should be set, or there was nothing left to + * write in this call, and we've completed the BG flush. + * These are the two cases above. If we get here, that means + * there is some kind failure in the writable event machinery. + * + * The tls extension indeed suffers from flaws in its channel + * event mgmt. See http://core.tcl.tk/tcl/info/c31ca233ca. + * Until that patch is broadly distributed, disable the + * assertion checking here, so that programs using Tcl and + * tls can be debugged. + + assert(!calledFromAsyncFlush); + */ + } + } + + /* + * If the channel is flagged as closed, delete it when the refCount drops + * to zero, the output queue is empty and there is no output in the + * current output buffer. + */ + + if (GotFlag(statePtr, CHANNEL_CLOSED) && (statePtr->refCount <= 0) && + (statePtr->outQueueHead == NULL) && + ((statePtr->curOutPtr == NULL) || + IsBufferEmpty(statePtr->curOutPtr))) { + errorCode = CloseChannel(interp, chanPtr, errorCode); + goto done; + } + + /* + * If the write-side of the channel is flagged as closed, delete it when + * the output queue is empty and there is no output in the current output + * buffer. + */ + + if (GotFlag(statePtr, CHANNEL_CLOSEDWRITE) && + (statePtr->outQueueHead == NULL) && + ((statePtr->curOutPtr == NULL) || + IsBufferEmpty(statePtr->curOutPtr))) { + errorCode = CloseChannelPart(interp, chanPtr, errorCode, TCL_CLOSE_WRITE); + goto done; + } + + done: + TclChannelRelease((Tcl_Channel)chanPtr); + return errorCode; +} + +/* + *---------------------------------------------------------------------- + * + * CloseChannel -- + * + * Utility procedure to close a channel and free associated resources. + * + * If the channel was stacked, then the it will copy the necessary + * elements of the NEXT channel into the TOP channel, in essence + * unstacking the channel. The NEXT channel will then be freed. + * + * If the channel was not stacked, then we will free all the bits for the + * TOP channel, including the data structure itself. + * + * Results: + * Error code from an unreported error or the driver close operation. + * + * Side effects: + * May close the actual channel, may free memory, may change the value of + * errno. + * + *---------------------------------------------------------------------- + */ + +static int +CloseChannel( + Tcl_Interp *interp, /* For error reporting. */ + Channel *chanPtr, /* The channel to close. */ + int errorCode) /* Status of operation so far. */ +{ + int result = 0; /* Of calling driver close operation. */ + ChannelState *statePtr; /* State of the channel stack. */ + ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey); + + if (chanPtr == NULL) { + return result; + } + statePtr = chanPtr->state; + + /* + * No more input can be consumed so discard any leftover input. + */ + + DiscardInputQueued(statePtr, 1); + + /* + * Discard a leftover buffer in the current output buffer field. + */ + + if (statePtr->curOutPtr != NULL) { + ReleaseChannelBuffer(statePtr->curOutPtr); + statePtr->curOutPtr = NULL; + } + + /* + * The caller guarantees that there are no more buffers queued for output. + */ + + if (statePtr->outQueueHead != NULL) { + Tcl_Panic("TclFlush, closed channel: queued output left"); + } + + /* + * If the EOF character is set in the channel, append that to the output + * device. + */ + + if ((statePtr->outEofChar != 0) && GotFlag(statePtr, TCL_WRITABLE)) { + int dummy; + char c = (char) statePtr->outEofChar; + + (void) ChanWrite(chanPtr, &c, 1, &dummy); + } + + /* + * TIP #219, Tcl Channel Reflection API. + * Move a leftover error message in the channel bypass into the + * interpreter bypass. Just clear it if there is no interpreter. + */ + + if (statePtr->chanMsg != NULL) { + if (interp != NULL) { + Tcl_SetChannelErrorInterp(interp, statePtr->chanMsg); + } + TclDecrRefCount(statePtr->chanMsg); + statePtr->chanMsg = NULL; + } + + /* + * Remove this channel from of the list of all channels. + */ + + CutChannel((Tcl_Channel) chanPtr); + + /* + * Close and free the channel driver state. + * This may leave a TIP #219 error message in the interp. + */ + + result = ChanClose(chanPtr, interp); + + /* + * Some resources can be cleared only if the bottom channel in a stack is + * closed. All the other channels in the stack are not allowed to remove. + */ + + if (chanPtr == statePtr->bottomChanPtr) { + if (statePtr->channelName != NULL) { + ckfree(statePtr->channelName); + statePtr->channelName = NULL; + } + + Tcl_FreeEncoding(statePtr->encoding); + } + + /* + * If we are being called synchronously, report either any latent error on + * the channel or the current error. + */ + + if (statePtr->unreportedError != 0) { + errorCode = statePtr->unreportedError; + + /* + * TIP #219, Tcl Channel Reflection API. + * Move an error message found in the unreported area into the regular + * bypass (interp). This kills any message in the channel bypass area. + */ + + if (statePtr->chanMsg != NULL) { + TclDecrRefCount(statePtr->chanMsg); + statePtr->chanMsg = NULL; + } + if (interp) { + Tcl_SetChannelErrorInterp(interp, statePtr->unreportedMsg); + } + } + if (errorCode == 0) { + errorCode = result; + if (errorCode != 0) { + Tcl_SetErrno(errorCode); + } + } + + /* + * Cancel any outstanding timer. + */ + + Tcl_DeleteTimerHandler(statePtr->timer); + + /* + * Mark the channel as deleted by clearing the type structure. + */ + + if (chanPtr->downChanPtr != NULL) { + Channel *downChanPtr = chanPtr->downChanPtr; + + statePtr->nextCSPtr = tsdPtr->firstCSPtr; + tsdPtr->firstCSPtr = statePtr; + + statePtr->topChanPtr = downChanPtr; + downChanPtr->upChanPtr = NULL; + + ChannelFree(chanPtr); + + return Tcl_Close(interp, (Tcl_Channel) downChanPtr); + } + + /* + * There is only the TOP Channel, so we free the remaining pointers we + * have and then ourselves. Since this is the last of the channels in the + * stack, make sure to free the ChannelState structure associated with it. + */ + + ChannelFree(chanPtr); + + Tcl_EventuallyFree(statePtr, TCL_DYNAMIC); + + return errorCode; +} + +/* + *---------------------------------------------------------------------- + * + * Tcl_CutChannel -- + * CutChannel -- + * + * Removes a channel from the (thread-)global list of all channels (in + * that thread). This is actually the statePtr for the stack of channel. + * + * Results: + * Nothing. + * + * Side effects: + * Resets the field 'nextCSPtr' of the specified channel state to NULL. + * + * NOTE: + * The channel to cut out of the list must not be referenced in any + * interpreter. This is something this procedure cannot check (despite + * the refcount) because the caller usually wants fiddle with the channel + * (like transfering it to a different thread) and thus keeps the + * refcount artifically high to prevent its destruction. + * + *---------------------------------------------------------------------- + */ + +static void +CutChannel( + Tcl_Channel chan) /* The channel being removed. Must not be + * referenced in any interpreter. */ +{ + ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey); + ChannelState *prevCSPtr; /* Preceding channel state in list of all + * states - used to splice a channel out of + * the list on close. */ + ChannelState *statePtr = ((Channel *) chan)->state; + /* State of the channel stack. */ + + /* + * Remove this channel from of the list of all channels (in the current + * thread). + */ + + if (tsdPtr->firstCSPtr && (statePtr == tsdPtr->firstCSPtr)) { + tsdPtr->firstCSPtr = statePtr->nextCSPtr; + } else { + for (prevCSPtr = tsdPtr->firstCSPtr; + prevCSPtr && (prevCSPtr->nextCSPtr != statePtr); + prevCSPtr = prevCSPtr->nextCSPtr) { + /* Empty loop body. */ + } + if (prevCSPtr == NULL) { + Tcl_Panic("FlushChannel: damaged channel list"); + } + prevCSPtr->nextCSPtr = statePtr->nextCSPtr; + } + + statePtr->nextCSPtr = NULL; + + /* + * TIP #218, Channel Thread Actions + */ + + ChanThreadAction((Channel *) chan, TCL_CHANNEL_THREAD_REMOVE); +} + +void +Tcl_CutChannel( + Tcl_Channel chan) /* The channel being added. Must not be + * referenced in any interpreter. */ +{ + Channel *chanPtr = ((Channel *) chan)->state->bottomChanPtr; + ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey); + ChannelState *prevCSPtr; /* Preceding channel state in list of all + * states - used to splice a channel out of + * the list on close. */ + ChannelState *statePtr = chanPtr->state; + /* State of the channel stack. */ + + /* + * Remove this channel from of the list of all channels (in the current + * thread). + */ + + if (tsdPtr->firstCSPtr && (statePtr == tsdPtr->firstCSPtr)) { + tsdPtr->firstCSPtr = statePtr->nextCSPtr; + } else { + for (prevCSPtr = tsdPtr->firstCSPtr; + prevCSPtr && (prevCSPtr->nextCSPtr != statePtr); + prevCSPtr = prevCSPtr->nextCSPtr) { + /* Empty loop body. */ + } + if (prevCSPtr == NULL) { + Tcl_Panic("FlushChannel: damaged channel list"); + } + prevCSPtr->nextCSPtr = statePtr->nextCSPtr; + } + + statePtr->nextCSPtr = NULL; + + /* + * TIP #218, Channel Thread Actions + * For all transformations and the base channel. + */ + + for (; chanPtr != NULL ; chanPtr = chanPtr->upChanPtr) { + ChanThreadAction(chanPtr, TCL_CHANNEL_THREAD_REMOVE); + } +} + +/* + *---------------------------------------------------------------------- + * + * Tcl_SpliceChannel -- + * SpliceChannel -- + * + * Adds a channel to the (thread-)global list of all channels (in that + * thread). Expects that the field 'nextChanPtr' in the channel is set to + * NULL. + * + * Results: + * Nothing. + * + * Side effects: + * Nothing. + * + * NOTE: + * The channel to splice into the list must not be referenced in any + * interpreter. This is something this procedure cannot check (despite + * the refcount) because the caller usually wants figgle with the channel + * (like transfering it to a different thread) and thus keeps the + * refcount artifically high to prevent its destruction. + * + *---------------------------------------------------------------------- + */ + +static void +SpliceChannel( + Tcl_Channel chan) /* The channel being added. Must not be + * referenced in any interpreter. */ +{ + ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey); + ChannelState *statePtr = ((Channel *) chan)->state; + + if (statePtr->nextCSPtr != NULL) { + Tcl_Panic("SpliceChannel: trying to add channel used in different list"); + } + + statePtr->nextCSPtr = tsdPtr->firstCSPtr; + tsdPtr->firstCSPtr = statePtr; + + /* + * TIP #10. Mark the current thread as the new one managing this channel. + * Note: 'Tcl_GetCurrentThread' returns sensible values even for + * a non-threaded core. + */ + + statePtr->managingThread = Tcl_GetCurrentThread(); + + /* + * TIP #218, Channel Thread Actions + */ + + ChanThreadAction((Channel *) chan, TCL_CHANNEL_THREAD_INSERT); +} + +void +Tcl_SpliceChannel( + Tcl_Channel chan) /* The channel being added. Must not be + * referenced in any interpreter. */ +{ + Channel *chanPtr = ((Channel *) chan)->state->bottomChanPtr; + ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey); + ChannelState *statePtr = chanPtr->state; + + if (statePtr->nextCSPtr != NULL) { + Tcl_Panic("SpliceChannel: trying to add channel used in different list"); + } + + statePtr->nextCSPtr = tsdPtr->firstCSPtr; + tsdPtr->firstCSPtr = statePtr; + + /* + * TIP #10. Mark the current thread as the new one managing this channel. + * Note: 'Tcl_GetCurrentThread' returns sensible values even for + * a non-threaded core. + */ + + statePtr->managingThread = Tcl_GetCurrentThread(); + + /* + * TIP #218, Channel Thread Actions + * For all transformations and the base channel. + */ + + for (; chanPtr != NULL ; chanPtr = chanPtr->upChanPtr) { + ChanThreadAction(chanPtr, TCL_CHANNEL_THREAD_INSERT); + } +} + +/* + *---------------------------------------------------------------------- + * + * Tcl_Close -- + * + * Closes a channel. + * + * Results: + * A standard Tcl result. + * + * Side effects: + * Closes the channel if this is the last reference. + * + * NOTE: + * Tcl_Close removes the channel as far as the user is concerned. + * However, it may continue to exist for a while longer if it has a + * background flush scheduled. The device itself is eventually closed and + * the channel record removed, in CloseChannel, above. + * + *---------------------------------------------------------------------- + */ + + /* ARGSUSED */ +int +Tcl_Close( + Tcl_Interp *interp, /* Interpreter for errors. */ + Tcl_Channel chan) /* The channel being closed. Must not be + * referenced in any interpreter. */ +{ + CloseCallback *cbPtr; /* Iterate over close callbacks for this + * channel. */ + Channel *chanPtr; /* The real IO channel. */ + ChannelState *statePtr; /* State of real IO channel. */ + int result; /* Of calling FlushChannel. */ + int flushcode; + int stickyError; + + if (chan == NULL) { + return TCL_OK; + } + + /* + * Perform special handling for standard channels being closed. If the + * refCount is now 1 it means that the last reference to the standard + * channel is being explicitly closed, so bump the refCount down + * artificially to 0. This will ensure that the channel is actually + * closed, below. Also set the static pointer to NULL for the channel. + */ + + CheckForStdChannelsBeingClosed(chan); + + /* + * This operation should occur at the top of a channel stack. + */ + + chanPtr = (Channel *) chan; + statePtr = chanPtr->state; + chanPtr = statePtr->topChanPtr; + + if (statePtr->refCount > 0) { + Tcl_Panic("called Tcl_Close on channel with refCount > 0"); + } + + if (GotFlag(statePtr, CHANNEL_INCLOSE)) { + if (interp) { + Tcl_SetObjResult(interp, Tcl_NewStringObj( + "illegal recursive call to close through close-handler" + " of channel", -1)); + } + return TCL_ERROR; + } + SetFlag(statePtr, CHANNEL_INCLOSE); + + /* + * When the channel has an escape sequence driven encoding such as + * iso2022, the terminated escape sequence must write to the buffer. + */ + + stickyError = 0; + + if (GotFlag(statePtr, TCL_WRITABLE) && (statePtr->encoding != NULL) + && !(statePtr->outputEncodingFlags & TCL_ENCODING_START)) { + + int code = CheckChannelErrors(statePtr, TCL_WRITABLE); + + if (code == 0) { + statePtr->outputEncodingFlags |= TCL_ENCODING_END; + code = WriteChars(chanPtr, "", 0); + statePtr->outputEncodingFlags &= ~TCL_ENCODING_END; + statePtr->outputEncodingFlags |= TCL_ENCODING_START; + } + if (code < 0) { + stickyError = Tcl_GetErrno(); + } + + /* + * TIP #219, Tcl Channel Reflection API. + * Move an error message found in the channel bypass into the + * interpreter bypass. Just clear it if there is no interpreter. + */ + + if (statePtr->chanMsg != NULL) { + if (interp != NULL) { + Tcl_SetChannelErrorInterp(interp, statePtr->chanMsg); + } + TclDecrRefCount(statePtr->chanMsg); + statePtr->chanMsg = NULL; + } + } + + Tcl_ClearChannelHandlers(chan); + + /* + * Invoke the registered close callbacks and delete their records. + */ + + while (statePtr->closeCbPtr != NULL) { + cbPtr = statePtr->closeCbPtr; + statePtr->closeCbPtr = cbPtr->nextPtr; + cbPtr->proc(cbPtr->clientData); + ckfree(cbPtr); + } + + ResetFlag(statePtr, CHANNEL_INCLOSE); + + /* + * If this channel supports it, close the read side, since we don't need + * it anymore and this will help avoid deadlocks on some channel types. + */ + + if (chanPtr->typePtr->closeProc == TCL_CLOSE2PROC) { + result = chanPtr->typePtr->close2Proc(chanPtr->instanceData, interp, + TCL_CLOSE_READ); + } else { + result = 0; + } + + /* + * The call to FlushChannel will flush any queued output and invoke the + * close function of the channel driver, or it will set up the channel to + * be flushed and closed asynchronously. + */ + + SetFlag(statePtr, CHANNEL_CLOSED); + + flushcode = FlushChannel(interp, chanPtr, 0); + + /* + * TIP #219. + * Capture error messages put by the driver into the bypass area and put + * them into the regular interpreter result. + * + * Notes: Due to the assertion of CHANNEL_CLOSED in the flags + * FlushChannel() has called CloseChannel() and thus freed all the channel + * structures. We must not try to access "chan" anymore, hence the NULL + * argument in the call below. The only place which may still contain a + * message is the interpreter itself, and "CloseChannel" made sure to lift + * any channel message it generated into it. + */ + + if (TclChanCaughtErrorBypass(interp, NULL)) { + result = EINVAL; + } + + if (stickyError != 0) { + Tcl_SetErrno(stickyError); + if (interp != NULL) { + Tcl_SetObjResult(interp, + Tcl_NewStringObj(Tcl_PosixError(interp), -1)); + } + return TCL_ERROR; + } + /* + * Bug 97069ea11a: set error message if a flush code is set and no error + * message set up to now. + */ + if (flushcode != 0 && interp != NULL + && 0 == Tcl_GetCharLength(Tcl_GetObjResult(interp)) ) { + Tcl_SetErrno(flushcode); + Tcl_SetObjResult(interp, + Tcl_NewStringObj(Tcl_PosixError(interp), -1)); + } + if ((flushcode != 0) || (result != 0)) { + return TCL_ERROR; + } + return TCL_OK; +} + +/* + *---------------------------------------------------------------------- + * + * Tcl_CloseEx -- + * + * Closes one side of a channel, read or write. + * + * Results: + * A standard Tcl result. + * + * Side effects: + * Closes one direction of the channel. + * + * NOTE: + * Tcl_CloseEx closes the specified direction of the channel as far as + * the user is concerned. The channel keeps existing however. You cannot + * calls this function to close the last possible direction of the + * channel. Use Tcl_Close for that. + * + *---------------------------------------------------------------------- + */ + + /* ARGSUSED */ +int +Tcl_CloseEx( + Tcl_Interp *interp, /* Interpreter for errors. */ + Tcl_Channel chan, /* The channel being closed. May still be used + * by some interpreter. */ + int flags) /* Flags telling us which side to close. */ +{ + Channel *chanPtr; /* The real IO channel. */ + ChannelState *statePtr; /* State of real IO channel. */ + + if (chan == NULL) { + return TCL_OK; + } + + /* TODO: assert flags validity ? */ + + chanPtr = (Channel *) chan; + statePtr = chanPtr->state; + + /* + * Does the channel support half-close anyway? Error if not. + */ + + if (!chanPtr->typePtr->close2Proc) { + Tcl_SetObjResult(interp, Tcl_ObjPrintf( + "half-close of channels not supported by %ss", + chanPtr->typePtr->typeName)); + return TCL_ERROR; + } + + /* + * Is the channel unstacked ? If not we fail. + */ + + if (chanPtr != statePtr->topChanPtr) { + Tcl_SetObjResult(interp, Tcl_NewStringObj( + "half-close not applicable to stack of transformations", -1)); + return TCL_ERROR; + } + + /* + * Check direction against channel mode. It is an error if we try to close + * a direction not supported by the channel (already closed, or never + * opened for that direction). + */ + + if (!(statePtr->flags & (TCL_READABLE | TCL_WRITABLE) & flags)) { + const char *msg; + + if (flags & TCL_CLOSE_READ) { + msg = "read"; + } else { + msg = "write"; + } + Tcl_SetObjResult(interp, Tcl_ObjPrintf( + "Half-close of %s-side not possible, side not opened or" + " already closed", msg)); + return TCL_ERROR; + } + + /* + * A user may try to call half-close from within a channel close + * handler. That won't do. + */ + + if (statePtr->flags & CHANNEL_INCLOSE) { + if (interp) { + Tcl_SetObjResult(interp, Tcl_NewStringObj( + "illegal recursive call to close through close-handler" + " of channel", -1)); + } + return TCL_ERROR; + } + + if (flags & TCL_CLOSE_READ) { + /* + * Call the finalization code directly. There are no events to handle, + * there cannot be for the read-side. + */ + + return CloseChannelPart(interp, chanPtr, 0, flags); + } else if (flags & TCL_CLOSE_WRITE) { + Tcl_Preserve(statePtr); + if (!GotFlag(statePtr, BG_FLUSH_SCHEDULED)) { + /* + * We don't want to re-enter CloseWrite(). + */ + + if (!GotFlag(statePtr, CHANNEL_CLOSEDWRITE)) { + if (CloseWrite(interp, chanPtr) != TCL_OK) { + SetFlag(statePtr, CHANNEL_CLOSEDWRITE); + Tcl_Release(statePtr); + return TCL_ERROR; + } + } + } + SetFlag(statePtr, CHANNEL_CLOSEDWRITE); + Tcl_Release(statePtr); + } + + return TCL_OK; +} + +/* + *---------------------------------------------------------------------- + * + * CloseWrite -- + * + * Closes the write side a channel. + * + * Results: + * A standard Tcl result. + * + * Side effects: + * Closes the write side of the channel. + * + * NOTE: + * CloseWrite removes the channel as far as the user is concerned. + * However, the ooutput data structures may continue to exist for a while + * longer if it has a background flush scheduled. The device itself is + * eventually closed and the channel structures modified, in + * CloseChannelPart, below. + * + *---------------------------------------------------------------------- + */ + +static int +CloseWrite( + Tcl_Interp *interp, /* Interpreter for errors. */ + Channel *chanPtr) /* The channel whose write side is being + * closed. May still be used by some + * interpreter */ +{ + /* Notes: clear-channel-handlers - write side only ? or keep around, just + * not called. */ + /* No close cllbacks are run - channel is still open (read side) */ + + ChannelState *statePtr = chanPtr->state; + /* State of real IO channel. */ + int flushcode; + int result = 0; + + /* + * The call to FlushChannel will flush any queued output and invoke the + * close function of the channel driver, or it will set up the channel to + * be flushed and closed asynchronously. + */ + + SetFlag(statePtr, CHANNEL_CLOSEDWRITE); + + flushcode = FlushChannel(interp, chanPtr, 0); + + /* + * TIP #219. + * Capture error messages put by the driver into the bypass area and put + * them into the regular interpreter result. + * + * Notes: Due to the assertion of CHANNEL_CLOSEDWRITE in the flags + * FlushChannel() has called CloseChannelPart(). While we can still access + * "chan" (no structures were freed), the only place which may still + * contain a message is the interpreter itself, and "CloseChannelPart" made + * sure to lift any channel message it generated into it. Hence the NULL + * argument in the call below. + */ + + if (TclChanCaughtErrorBypass(interp, NULL)) { + result = EINVAL; + } + + if ((flushcode != 0) || (result != 0)) { + return TCL_ERROR; + } + + return TCL_OK; +} + +/* + *---------------------------------------------------------------------- + * + * CloseChannelPart -- + * + * Utility procedure to close a channel partially and free associated + * resources. If the channel was stacked it will never be run (The higher + * level forbid this). If the channel was not stacked, then we will free + * all the bits of the chosen side (read, or write) for the TOP channel. + * + * Results: + * Error code from an unreported error or the driver close2 operation. + * + * Side effects: + * May free memory, may change the value of errno. + * + *---------------------------------------------------------------------- + */ + +static int +CloseChannelPart( + Tcl_Interp *interp, /* Interpreter for errors. */ + Channel *chanPtr, /* The channel being closed. May still be used + * by some interpreter. */ + int errorCode, /* Status of operation so far. */ + int flags) /* Flags telling us which side to close. */ +{ + ChannelState *statePtr; /* State of real IO channel. */ + int result; /* Of calling the close2proc. */ + + statePtr = chanPtr->state; + + if (flags & TCL_CLOSE_READ) { + /* + * No more input can be consumed so discard any leftover input. + */ + + DiscardInputQueued(statePtr, 1); + } else if (flags & TCL_CLOSE_WRITE) { + /* + * The caller guarantees that there are no more buffers queued for + * output. + */ + + if (statePtr->outQueueHead != NULL) { + Tcl_Panic("ClosechanHalf, closed write-side of channel: " + "queued output left"); + } + + /* + * If the EOF character is set in the channel, append that to the + * output device. + */ + + if ((statePtr->outEofChar != 0) && GotFlag(statePtr, TCL_WRITABLE)) { + int dummy; + char c = (char) statePtr->outEofChar; + + (void) ChanWrite(chanPtr, &c, 1, &dummy); + } + + /* + * TIP #219, Tcl Channel Reflection API. + * Move a leftover error message in the channel bypass into the + * interpreter bypass. Just clear it if there is no interpreter. + */ + + if (statePtr->chanMsg != NULL) { + if (interp != NULL) { + Tcl_SetChannelErrorInterp(interp, statePtr->chanMsg); + } + TclDecrRefCount(statePtr->chanMsg); + statePtr->chanMsg = NULL; + } + } + + /* + * Finally do what is asked of us. Close and free the channel driver state + * for the chosen side of the channel. This may leave a TIP #219 error + * message in the interp. + */ + + result = ChanCloseHalf(chanPtr, interp, flags); + + /* + * If we are being called synchronously, report either any latent error on + * the channel or the current error. + */ + + if (statePtr->unreportedError != 0) { + errorCode = statePtr->unreportedError; + + /* + * TIP #219, Tcl Channel Reflection API. + * Move an error message found in the unreported area into the regular + * bypass (interp). This kills any message in the channel bypass area. + */ + + if (statePtr->chanMsg != NULL) { + TclDecrRefCount(statePtr->chanMsg); + statePtr->chanMsg = NULL; + } + if (interp) { + Tcl_SetChannelErrorInterp(interp, statePtr->unreportedMsg); + } + } + if (errorCode == 0) { + errorCode = result; + if (errorCode != 0) { + Tcl_SetErrno(errorCode); + } + } + + /* + * TIP #219. + * Capture error messages put by the driver into the bypass area and put + * them into the regular interpreter result. See also the bottom of + * CloseWrite(). + */ + + if (TclChanCaughtErrorBypass(interp, (Tcl_Channel) chanPtr)) { + result = EINVAL; + } + + if (result != 0) { + return TCL_ERROR; + } + + /* + * Remove the closed side from the channel mode/flags. + */ + + ResetFlag(statePtr, flags & (TCL_READABLE | TCL_WRITABLE)); + return TCL_OK; +} + +/* + *---------------------------------------------------------------------- + * + * Tcl_ClearChannelHandlers -- + * + * Removes all channel handlers and event scripts from the channel, + * cancels all background copies involving the channel and any interest + * in events. + * + * Results: + * None. + * + * Side effects: + * See above. Deallocates memory. + * + *---------------------------------------------------------------------- + */ + +void +Tcl_ClearChannelHandlers( + Tcl_Channel channel) +{ + ChannelHandler *chPtr, *chNext; /* Iterate over channel handlers. */ + EventScriptRecord *ePtr, *eNextPtr; /* Iterate over eventscript records. */ + Channel *chanPtr; /* The real IO channel. */ + ChannelState *statePtr; /* State of real IO channel. */ + ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey); + NextChannelHandler *nhPtr; + + /* + * This operation should occur at the top of a channel stack. + */ + + chanPtr = (Channel *) channel; + statePtr = chanPtr->state; + chanPtr = statePtr->topChanPtr; + + /* + * Cancel any outstanding timer. + */ + + Tcl_DeleteTimerHandler(statePtr->timer); + + /* + * Remove any references to channel handlers for this channel that may be + * about to be invoked. + */ + + for (nhPtr = tsdPtr->nestedHandlerPtr; nhPtr != NULL; + nhPtr = nhPtr->nestedHandlerPtr) { + if (nhPtr->nextHandlerPtr && + (nhPtr->nextHandlerPtr->chanPtr == chanPtr)) { + nhPtr->nextHandlerPtr = NULL; + } + } + + /* + * Remove all the channel handler records attached to the channel itself. + */ + + for (chPtr = statePtr->chPtr; chPtr != NULL; chPtr = chNext) { + chNext = chPtr->nextPtr; + ckfree(chPtr); + } + statePtr->chPtr = NULL; + + /* + * Cancel any pending copy operation. + */ + + StopCopy(statePtr->csPtrR); + StopCopy(statePtr->csPtrW); + + /* + * Must set the interest mask now to 0, otherwise infinite loops + * will occur if Tcl_DoOneEvent is called before the channel is + * finally deleted in FlushChannel. This can happen if the channel + * has a background flush active. + */ + + statePtr->interestMask = 0; + + /* + * Remove any EventScript records for this channel. + */ + + for (ePtr = statePtr->scriptRecordPtr; ePtr != NULL; ePtr = eNextPtr) { + eNextPtr = ePtr->nextPtr; + TclDecrRefCount(ePtr->scriptPtr); + ckfree(ePtr); + } + statePtr->scriptRecordPtr = NULL; +} + +/* + *---------------------------------------------------------------------- + * + * Tcl_Write -- + * + * Puts a sequence of bytes into an output buffer, may queue the buffer + * for output if it gets full, and also remembers whether the current + * buffer is ready e.g. if it contains a newline and we are in line + * buffering mode. Compensates stacking, i.e. will redirect the data from + * the specified channel to the topmost channel in a stack. + * + * No encoding conversions are applied to the bytes being read. + * + * Results: + * The number of bytes written or -1 in case of error. If -1, + * Tcl_GetErrno will return the error code. + * + * Side effects: + * May buffer up output and may cause output to be produced on the + * channel. + * + *---------------------------------------------------------------------- + */ + +int +Tcl_Write( + Tcl_Channel chan, /* The channel to buffer output for. */ + const char *src, /* Data to queue in output buffer. */ + int srcLen) /* Length of data in bytes, or < 0 for + * strlen(). */ +{ + /* + * Always use the topmost channel of the stack + */ + + Channel *chanPtr; + ChannelState *statePtr; /* State info for channel */ + + statePtr = ((Channel *) chan)->state; + chanPtr = statePtr->topChanPtr; + + if (CheckChannelErrors(statePtr, TCL_WRITABLE) != 0) { + return -1; + } + + if (srcLen < 0) { + srcLen = strlen(src); + } + if (WriteBytes(chanPtr, src, srcLen) < 0) { + return -1; + } + return srcLen; +} + +/* + *---------------------------------------------------------------------- + * + * Tcl_WriteRaw -- + * + * Puts a sequence of bytes into an output buffer, may queue the buffer + * for output if it gets full, and also remembers whether the current + * buffer is ready e.g. if it contains a newline and we are in line + * buffering mode. Writes directly to the driver of the channel, does not + * compensate for stacking. + * + * No encoding conversions are applied to the bytes being read. + * + * Results: + * The number of bytes written or -1 in case of error. If -1, + * Tcl_GetErrno will return the error code. + * + * Side effects: + * May buffer up output and may cause output to be produced on the + * channel. + * + *---------------------------------------------------------------------- + */ + +int +Tcl_WriteRaw( + Tcl_Channel chan, /* The channel to buffer output for. */ + const char *src, /* Data to queue in output buffer. */ + int srcLen) /* Length of data in bytes, or < 0 for + * strlen(). */ +{ + Channel *chanPtr = ((Channel *) chan); + ChannelState *statePtr = chanPtr->state; + /* State info for channel */ + int errorCode, written; + + if (CheckChannelErrors(statePtr, TCL_WRITABLE | CHANNEL_RAW_MODE) != 0) { + return -1; + } + + if (srcLen < 0) { + srcLen = strlen(src); + } + + /* + * Go immediately to the driver, do all the error handling by ourselves. + * The code was stolen from 'FlushChannel'. + */ + + written = ChanWrite(chanPtr, src, srcLen, &errorCode); + if (written < 0) { + Tcl_SetErrno(errorCode); + } + + return written; +} + +/* + *--------------------------------------------------------------------------- + * + * Tcl_WriteChars -- + * + * Takes a sequence of UTF-8 characters and converts them for output + * using the channel's current encoding, may queue the buffer for output + * if it gets full, and also remembers whether the current buffer is + * ready e.g. if it contains a newline and we are in line buffering + * mode. Compensates stacking, i.e. will redirect the data from the + * specified channel to the topmost channel in a stack. + * + * Results: + * The number of bytes written or -1 in case of error. If -1, + * Tcl_GetErrno will return the error code. + * + * Side effects: + * May buffer up output and may cause output to be produced on the + * channel. + * + *---------------------------------------------------------------------- + */ + +int +Tcl_WriteChars( + Tcl_Channel chan, /* The channel to buffer output for. */ + const char *src, /* UTF-8 characters to queue in output + * buffer. */ + int len) /* Length of string in bytes, or < 0 for + * strlen(). */ +{ + Channel *chanPtr = (Channel *) chan; + ChannelState *statePtr = chanPtr->state; /* State info for channel */ + int result; + Tcl_Obj *objPtr; + + if (CheckChannelErrors(statePtr, TCL_WRITABLE) != 0) { + return -1; + } + + chanPtr = statePtr->topChanPtr; + + if (len < 0) { + len = strlen(src); + } + if (statePtr->encoding) { + return WriteChars(chanPtr, src, len); + } + + /* + * Inefficient way to convert UTF-8 to byte-array, but the code + * parallels the way it is done for objects. Special case for 1-byte + * (used by eg [puts] for the \n) could be extended to more efficient + * translation of the src string. + */ + + if ((len == 1) && (UCHAR(*src) < 0xC0)) { + return WriteBytes(chanPtr, src, len); + } + + objPtr = Tcl_NewStringObj(src, len); + src = (char *) Tcl_GetByteArrayFromObj(objPtr, &len); + result = WriteBytes(chanPtr, src, len); + TclDecrRefCount(objPtr); + return result; +} + +/* + *--------------------------------------------------------------------------- + * + * Tcl_WriteObj -- + * + * Takes the Tcl object and queues its contents for output. If the + * encoding of the channel is NULL, takes the byte-array representation + * of the object and queues those bytes for output. Otherwise, takes the + * characters in the UTF-8 (string) representation of the object and + * converts them for output using the channel's current encoding. May + * flush internal buffers to output if one becomes full or is ready for + * some other reason, e.g. if it contains a newline and the channel is in + * line buffering mode. + * + * Results: + * The number of bytes written or -1 in case of error. If -1, + * Tcl_GetErrno() will return the error code. + * + * Side effects: + * May buffer up output and may cause output to be produced on the + * channel. + * + *---------------------------------------------------------------------- + */ + +int +Tcl_WriteObj( + Tcl_Channel chan, /* The channel to buffer output for. */ + Tcl_Obj *objPtr) /* The object to write. */ +{ + /* + * Always use the topmost channel of the stack + */ + + Channel *chanPtr; + ChannelState *statePtr; /* State info for channel */ + const char *src; + int srcLen; + + statePtr = ((Channel *) chan)->state; + chanPtr = statePtr->topChanPtr; + + if (CheckChannelErrors(statePtr, TCL_WRITABLE) != 0) { + return -1; + } + if (statePtr->encoding == NULL) { + src = (char *) Tcl_GetByteArrayFromObj(objPtr, &srcLen); + return WriteBytes(chanPtr, src, srcLen); + } else { + src = TclGetStringFromObj(objPtr, &srcLen); + return WriteChars(chanPtr, src, srcLen); + } +} + +static void +WillWrite( + Channel *chanPtr) +{ + int inputBuffered; + + if ((chanPtr->typePtr->seekProc != NULL) && + ((inputBuffered = Tcl_InputBuffered((Tcl_Channel) chanPtr)) > 0)){ + int ignore; + + DiscardInputQueued(chanPtr->state, 0); + ChanSeek(chanPtr, -inputBuffered, SEEK_CUR, &ignore); + } +} + +static int +WillRead( + Channel *chanPtr) +{ + if (chanPtr->typePtr == NULL) { + /* Prevent read attempts on a closed channel */ + DiscardInputQueued(chanPtr->state, 0); + Tcl_SetErrno(EINVAL); + return -1; + } + if ((chanPtr->typePtr->seekProc != NULL) + && (Tcl_OutputBuffered((Tcl_Channel) chanPtr) > 0)) { + + /* + * CAVEAT - The assumption here is that FlushChannel() will + * push out the bytes of any writes that are in progress. + * Since this is a seekable channel, we assume it is not one + * that can block and force bg flushing. Channels we know that + * can do that -- sockets, pipes -- are not seekable. If the + * assumption is wrong, more drastic measures may be required here + * like temporarily setting the channel into blocking mode. + */ + + if (FlushChannel(NULL, chanPtr, 0) != 0) { + return -1; + } + } + return 0; +} + +/* + *---------------------------------------------------------------------- + * + * Write -- + * + * Convert srcLen bytes starting at src according to encoding and write + * produced bytes into an output buffer, may queue the buffer for output + * if it gets full, and also remembers whether the current buffer is + * ready e.g. if it contains a newline and we are in line buffering mode. + * + * Results: + * The number of bytes written or -1 in case of error. If -1, + * Tcl_GetErrno will return the error code. + * + * Side effects: + * May buffer up output and may cause output to be produced on the + * channel. + * + *---------------------------------------------------------------------- + */ + +static int +Write( + Channel *chanPtr, /* The channel to buffer output for. */ + const char *src, /* UTF-8 string to write. */ + int srcLen, /* Length of UTF-8 string in bytes. */ + Tcl_Encoding encoding) +{ + ChannelState *statePtr = chanPtr->state; + /* State info for channel */ + char *nextNewLine = NULL; + int endEncoding, saved = 0, total = 0, flushed = 0, needNlFlush = 0; + + if (srcLen) { + WillWrite(chanPtr); + } + + /* + * Write the terminated escape sequence even if srcLen is 0. + */ + + endEncoding = ((statePtr->outputEncodingFlags & TCL_ENCODING_END) != 0); + + if (GotFlag(statePtr, CHANNEL_LINEBUFFERED) + || (statePtr->outputTranslation != TCL_TRANSLATE_LF)) { + nextNewLine = memchr(src, '\n', srcLen); + } + + while (srcLen + saved + endEncoding > 0) { + ChannelBuffer *bufPtr; + char *dst, safe[BUFFER_PADDING]; + int result, srcRead, dstLen, dstWrote, srcLimit = srcLen; + + if (nextNewLine) { + srcLimit = nextNewLine - src; + } + + /* Get space to write into */ + bufPtr = statePtr->curOutPtr; + if (bufPtr == NULL) { + bufPtr = AllocChannelBuffer(statePtr->bufSize); + statePtr->curOutPtr = bufPtr; + } + if (saved) { + /* + * Here's some translated bytes left over from the last buffer + * that we need to stick at the beginning of this buffer. + */ + + memcpy(InsertPoint(bufPtr), safe, (size_t) saved); + bufPtr->nextAdded += saved; + saved = 0; + } + PreserveChannelBuffer(bufPtr); + dst = InsertPoint(bufPtr); + dstLen = SpaceLeft(bufPtr); + + result = Tcl_UtfToExternal(NULL, encoding, src, srcLimit, + statePtr->outputEncodingFlags, + &statePtr->outputEncodingState, dst, + dstLen + BUFFER_PADDING, &srcRead, &dstWrote, NULL); + + /* See chan-io-1.[89]. Tcl Bug 506297. */ + statePtr->outputEncodingFlags &= ~TCL_ENCODING_START; + + if ((result != TCL_OK) && (srcRead + dstWrote == 0)) { + /* We're reading from invalid/incomplete UTF-8 */ + ReleaseChannelBuffer(bufPtr); + if (total == 0) { + Tcl_SetErrno(EINVAL); + return -1; + } + break; + } + + bufPtr->nextAdded += dstWrote; + src += srcRead; + srcLen -= srcRead; + total += dstWrote; + dst += dstWrote; + dstLen -= dstWrote; + + if (src == nextNewLine && dstLen > 0) { + static char crln[3] = "\r\n"; + char *nl = NULL; + int nlLen = 0; + + switch (statePtr->outputTranslation) { + case TCL_TRANSLATE_LF: + nl = crln + 1; + nlLen = 1; + break; + case TCL_TRANSLATE_CR: + nl = crln; + nlLen = 1; + break; + case TCL_TRANSLATE_CRLF: + nl = crln; + nlLen = 2; + break; + default: + Tcl_Panic("unknown output translation requested"); + break; + } + + result |= Tcl_UtfToExternal(NULL, encoding, nl, nlLen, + statePtr->outputEncodingFlags, + &statePtr->outputEncodingState, dst, + dstLen + BUFFER_PADDING, &srcRead, &dstWrote, NULL); + + assert (srcRead == nlLen); + + bufPtr->nextAdded += dstWrote; + src++; + srcLen--; + total += dstWrote; + dst += dstWrote; + dstLen -= dstWrote; + nextNewLine = memchr(src, '\n', srcLen); + needNlFlush = 1; + } + + if (IsBufferOverflowing(bufPtr)) { + /* + * When translating from UTF-8 to external encoding, we + * allowed the translation to produce a character that crossed + * the end of the output buffer, so that we would get a + * completely full buffer before flushing it. The extra bytes + * will be moved to the beginning of the next buffer. + */ + + saved = -SpaceLeft(bufPtr); + memcpy(safe, dst + dstLen, (size_t) saved); + bufPtr->nextAdded = bufPtr->bufLength; + } + + if ((srcLen + saved == 0) && (result == TCL_OK)) { + endEncoding = 0; + } + + if (IsBufferFull(bufPtr)) { + if (FlushChannel(NULL, chanPtr, 0) != 0) { + ReleaseChannelBuffer(bufPtr); + return -1; + } + flushed += statePtr->bufSize; + + /* + * We just flushed. So if we have needNlFlush set to record + * that we need to flush because theres a (translated) newline + * in the buffer, that's likely not true any more. But there + * is a tricky exception. If we have saved bytes that did not + * really get flushed and those bytes came from a translation + * of a newline as the last thing taken from the src array, + * then needNlFlush needs to remain set to flag that the + * next buffer still needs a newline flush. + */ + if (needNlFlush && (saved == 0 || src[-1] != '\n')) { + needNlFlush = 0; + } + } + ReleaseChannelBuffer(bufPtr); + } + if ((flushed < total) && (GotFlag(statePtr, CHANNEL_UNBUFFERED) || + (needNlFlush && GotFlag(statePtr, CHANNEL_LINEBUFFERED)))) { + if (FlushChannel(NULL, chanPtr, 0) != 0) { + return -1; + } + } + + return total; +} + +/* + *--------------------------------------------------------------------------- + * + * Tcl_Gets -- + * + * Reads a complete line of input from the channel into a Tcl_DString. + * + * Results: + * Length of line read (in characters) or -1 if error, EOF, or blocked. + * If -1, use Tcl_GetErrno() to retrieve the POSIX error code for the + * error or condition that occurred. + * + * Side effects: + * May flush output on the channel. May cause input to be consumed from + * the channel. + * + *--------------------------------------------------------------------------- + */ + +int +Tcl_Gets( + Tcl_Channel chan, /* Channel from which to read. */ + Tcl_DString *lineRead) /* The line read will be appended to this + * DString as UTF-8 characters. The caller + * must have initialized it and is responsible + * for managing the storage. */ +{ + Tcl_Obj *objPtr; + int charsStored; + + TclNewObj(objPtr); + charsStored = Tcl_GetsObj(chan, objPtr); + if (charsStored > 0) { + TclDStringAppendObj(lineRead, objPtr); + } + TclDecrRefCount(objPtr); + return charsStored; +} + +/* + *--------------------------------------------------------------------------- + * + * Tcl_GetsObj -- + * + * Accumulate input from the input channel until end-of-line or + * end-of-file has been seen. Bytes read from the input channel are + * converted to UTF-8 using the encoding specified by the channel. + * + * Results: + * Number of characters accumulated in the object or -1 if error, + * blocked, or EOF. If -1, use Tcl_GetErrno() to retrieve the POSIX error + * code for the error or condition that occurred. + * + * Side effects: + * Consumes input from the channel. + * + * On reading EOF, leave channel pointing at EOF char. On reading EOL, + * leave channel pointing after EOL, but don't return EOL in dst buffer. + * + *--------------------------------------------------------------------------- + */ + +int +Tcl_GetsObj( + Tcl_Channel chan, /* Channel from which to read. */ + Tcl_Obj *objPtr) /* The line read will be appended to this + * object as UTF-8 characters. */ +{ + GetsState gs; + Channel *chanPtr = (Channel *) chan; + ChannelState *statePtr = chanPtr->state; + /* State info for channel */ + ChannelBuffer *bufPtr; + int inEofChar, skip, copiedTotal, oldLength, oldFlags, oldRemoved; + Tcl_Encoding encoding; + char *dst, *dstEnd, *eol, *eof; + Tcl_EncodingState oldState; + + if (CheckChannelErrors(statePtr, TCL_READABLE) != 0) { + return -1; + } + + /* + * If we're sitting ready to read the eofchar, there's no need to + * do it. + */ + + if (GotFlag(statePtr, CHANNEL_STICKY_EOF)) { + SetFlag(statePtr, CHANNEL_EOF); + assert( statePtr->inputEncodingFlags & TCL_ENCODING_END ); + assert( !GotFlag(statePtr, CHANNEL_BLOCKED|INPUT_SAW_CR) ); + + /* TODO: Do we need this? */ + UpdateInterest(chanPtr); + return -1; + } + + /* + * A binary version of Tcl_GetsObj. This could also handle encodings that + * are ascii-7 pure (iso8859, utf-8, ...) with a final encoding conversion + * done on objPtr. + */ + + if ((statePtr->encoding == NULL) + && ((statePtr->inputTranslation == TCL_TRANSLATE_LF) + || (statePtr->inputTranslation == TCL_TRANSLATE_CR))) { + return TclGetsObjBinary(chan, objPtr); + } + + /* + * This operation should occur at the top of a channel stack. + */ + + chanPtr = statePtr->topChanPtr; + TclChannelPreserve((Tcl_Channel)chanPtr); + + bufPtr = statePtr->inQueueHead; + encoding = statePtr->encoding; + + /* + * Preserved so we can restore the channel's state in case we don't find a + * newline in the available input. + */ + + TclGetStringFromObj(objPtr, &oldLength); + oldFlags = statePtr->inputEncodingFlags; + oldState = statePtr->inputEncodingState; + oldRemoved = BUFFER_PADDING; + if (bufPtr != NULL) { + oldRemoved = bufPtr->nextRemoved; + } + + /* + * If there is no encoding, use "iso8859-1" -- Tcl_GetsObj() doesn't + * produce ByteArray objects. + */ + + if (encoding == NULL) { + encoding = GetBinaryEncoding(); + } + + /* + * Object used by FilterInputBytes to keep track of how much data has been + * consumed from the channel buffers. + */ + + gs.objPtr = objPtr; + gs.dstPtr = &dst; + gs.encoding = encoding; + gs.bufPtr = bufPtr; + gs.state = oldState; + gs.rawRead = 0; + gs.bytesWrote = 0; + gs.charsWrote = 0; + gs.totalChars = 0; + + dst = objPtr->bytes + oldLength; + dstEnd = dst; + + skip = 0; + eof = NULL; + inEofChar = statePtr->inEofChar; + + ResetFlag(statePtr, CHANNEL_BLOCKED); + while (1) { + if (dst >= dstEnd) { + if (FilterInputBytes(chanPtr, &gs) != 0) { + goto restore; + } + dstEnd = dst + gs.bytesWrote; + } + + /* + * Remember if EOF char is seen, then look for EOL anyhow, because the + * EOL might be before the EOF char. + */ + + if (inEofChar != '\0') { + for (eol = dst; eol < dstEnd; eol++) { + if (*eol == inEofChar) { + dstEnd = eol; + eof = eol; + break; + } + } + } + + /* + * On EOL, leave current file position pointing after the EOL, but + * don't store the EOL in the output string. + */ + + switch (statePtr->inputTranslation) { + case TCL_TRANSLATE_LF: + for (eol = dst; eol < dstEnd; eol++) { + if (*eol == '\n') { + skip = 1; + goto gotEOL; + } + } + break; + case TCL_TRANSLATE_CR: + for (eol = dst; eol < dstEnd; eol++) { + if (*eol == '\r') { + skip = 1; + goto gotEOL; + } + } + break; + case TCL_TRANSLATE_CRLF: + for (eol = dst; eol < dstEnd; eol++) { + if (*eol == '\r') { + eol++; + + /* + * If a CR is at the end of the buffer, then check for a + * LF at the begining of the next buffer, unless EOF char + * was found already. + */ + + if (eol >= dstEnd) { + int offset; + + if (eol != eof) { + offset = eol - objPtr->bytes; + dst = dstEnd; + if (FilterInputBytes(chanPtr, &gs) != 0) { + goto restore; + } + dstEnd = dst + gs.bytesWrote; + eol = objPtr->bytes + offset; + } + if (eol >= dstEnd) { + skip = 0; + goto gotEOL; + } + } + if (*eol == '\n') { + eol--; + skip = 2; + goto gotEOL; + } + } + } + break; + case TCL_TRANSLATE_AUTO: + eol = dst; + skip = 1; + if (GotFlag(statePtr, INPUT_SAW_CR)) { + ResetFlag(statePtr, INPUT_SAW_CR); + if ((eol < dstEnd) && (*eol == '\n')) { + /* + * Skip the raw bytes that make up the '\n'. + */ + + char tmp[TCL_UTF_MAX]; + int rawRead; + + bufPtr = gs.bufPtr; + Tcl_ExternalToUtf(NULL, gs.encoding, RemovePoint(bufPtr), + gs.rawRead, statePtr->inputEncodingFlags + | TCL_ENCODING_NO_TERMINATE, &gs.state, tmp, + TCL_UTF_MAX, &rawRead, NULL, NULL); + bufPtr->nextRemoved += rawRead; + gs.rawRead -= rawRead; + gs.bytesWrote--; + gs.charsWrote--; + memmove(dst, dst + 1, (size_t) (dstEnd - dst)); + dstEnd--; + } + } + for (eol = dst; eol < dstEnd; eol++) { + if (*eol == '\r') { + eol++; + if (eol == dstEnd) { + /* + * If buffer ended on \r, peek ahead to see if a \n is + * available, unless EOF char was found already. + */ + + if (eol != eof) { + int offset; + + offset = eol - objPtr->bytes; + dst = dstEnd; + PeekAhead(chanPtr, &dstEnd, &gs); + eol = objPtr->bytes + offset; + } + + if (eol >= dstEnd) { + eol--; + SetFlag(statePtr, INPUT_SAW_CR); + goto gotEOL; + } + } + if (*eol == '\n') { + skip++; + } + eol--; + goto gotEOL; + } else if (*eol == '\n') { + goto gotEOL; + } + } + } + if (eof != NULL) { + /* + * EOF character was seen. On EOF, leave current file position + * pointing at the EOF character, but don't store the EOF + * character in the output string. + */ + + dstEnd = eof; + SetFlag(statePtr, CHANNEL_EOF | CHANNEL_STICKY_EOF); + statePtr->inputEncodingFlags |= TCL_ENCODING_END; + ResetFlag(statePtr, CHANNEL_BLOCKED|INPUT_SAW_CR); + } + if (GotFlag(statePtr, CHANNEL_EOF)) { + skip = 0; + eol = dstEnd; + if (eol == objPtr->bytes + oldLength) { + /* + * If we didn't append any bytes before encountering EOF, + * caller needs to see -1. + */ + + Tcl_SetObjLength(objPtr, oldLength); + CommonGetsCleanup(chanPtr); + copiedTotal = -1; + ResetFlag(statePtr, CHANNEL_BLOCKED); + goto done; + } + goto gotEOL; + } + dst = dstEnd; + } + + /* + * Found EOL or EOF, but the output buffer may now contain too many UTF-8 + * characters. We need to know how many raw bytes correspond to the number + * of UTF-8 characters we want, plus how many raw bytes correspond to the + * character(s) making up EOL (if any), so we can remove the correct + * number of bytes from the channel buffer. + */ + + gotEOL: + /* + * Regenerate the top channel, in case it was changed due to + * self-modifying reflected transforms. + */ + + if (chanPtr != statePtr->topChanPtr) { + TclChannelRelease((Tcl_Channel)chanPtr); + chanPtr = statePtr->topChanPtr; + TclChannelPreserve((Tcl_Channel)chanPtr); + } + + bufPtr = gs.bufPtr; + if (bufPtr == NULL) { + Tcl_Panic("Tcl_GetsObj: gotEOL reached with bufPtr==NULL"); + } + statePtr->inputEncodingState = gs.state; + Tcl_ExternalToUtf(NULL, gs.encoding, RemovePoint(bufPtr), gs.rawRead, + statePtr->inputEncodingFlags | TCL_ENCODING_NO_TERMINATE, + &statePtr->inputEncodingState, dst, + eol - dst + skip + TCL_UTF_MAX - 1, &gs.rawRead, NULL, + &gs.charsWrote); + bufPtr->nextRemoved += gs.rawRead; + + /* + * Recycle all the emptied buffers. + */ + + Tcl_SetObjLength(objPtr, eol - objPtr->bytes); + CommonGetsCleanup(chanPtr); + ResetFlag(statePtr, CHANNEL_BLOCKED); + copiedTotal = gs.totalChars + gs.charsWrote - skip; + goto done; + + /* + * Couldn't get a complete line. This only happens if we get a error + * reading from the channel or we are non-blocking and there wasn't an EOL + * or EOF in the data available. + */ + + restore: + /* + * Regenerate the top channel, in case it was changed due to + * self-modifying reflected transforms. + */ + if (chanPtr != statePtr->topChanPtr) { + TclChannelRelease((Tcl_Channel)chanPtr); + chanPtr = statePtr->topChanPtr; + TclChannelPreserve((Tcl_Channel)chanPtr); + } + bufPtr = statePtr->inQueueHead; + if (bufPtr != NULL) { + bufPtr->nextRemoved = oldRemoved; + bufPtr = bufPtr->nextPtr; + } + + for ( ; bufPtr != NULL; bufPtr = bufPtr->nextPtr) { + bufPtr->nextRemoved = BUFFER_PADDING; + } + CommonGetsCleanup(chanPtr); + + statePtr->inputEncodingState = oldState; + statePtr->inputEncodingFlags = oldFlags; + Tcl_SetObjLength(objPtr, oldLength); + + /* + * We didn't get a complete line so we need to indicate to UpdateInterest + * that the gets blocked. It will wait for more data instead of firing a + * timer, avoiding a busy wait. This is where we are assuming that the + * next operation is a gets. No more file events will be delivered on this + * channel until new data arrives or some operation is performed on the + * channel (e.g. gets, read, fconfigure) that changes the blocking state. + * Note that this means a file event will not be delivered even though a + * read would be able to consume the buffered data. + */ + + SetFlag(statePtr, CHANNEL_NEED_MORE_DATA); + copiedTotal = -1; + + /* + * Update the notifier state so we don't block while there is still data + * in the buffers. + */ + + done: + assert(!GotFlag(statePtr, CHANNEL_EOF) + || GotFlag(statePtr, CHANNEL_STICKY_EOF) + || Tcl_InputBuffered((Tcl_Channel)chanPtr) == 0); + + assert( !(GotFlag(statePtr, CHANNEL_EOF|CHANNEL_BLOCKED) + == (CHANNEL_EOF|CHANNEL_BLOCKED)) ); + + /* + * Regenerate the top channel, in case it was changed due to + * self-modifying reflected transforms. + */ + if (chanPtr != statePtr->topChanPtr) { + TclChannelRelease((Tcl_Channel)chanPtr); + chanPtr = statePtr->topChanPtr; + TclChannelPreserve((Tcl_Channel)chanPtr); + } + UpdateInterest(chanPtr); + TclChannelRelease((Tcl_Channel)chanPtr); + return copiedTotal; +} + +/* + *--------------------------------------------------------------------------- + * + * TclGetsObjBinary -- + * + * A variation of Tcl_GetsObj that works directly on the buffers until + * end-of-line or end-of-file has been seen. Bytes read from the input + * channel return as a ByteArray obj. + * + * WARNING! The notion of "binary" used here is different from + * notions of "binary" used in other places. In particular, this + * "binary" routine may be called when an -eofchar is set on the + * channel. + * + * Results: + * Number of characters accumulated in the object or -1 if error, + * blocked, or EOF. If -1, use Tcl_GetErrno() to retrieve the POSIX error + * code for the error or condition that occurred. + * + * Side effects: + * Consumes input from the channel. + * + * On reading EOF, leave channel pointing at EOF char. On reading EOL, + * leave channel pointing after EOL, but don't return EOL in dst buffer. + * + *--------------------------------------------------------------------------- + */ + +static int +TclGetsObjBinary( + Tcl_Channel chan, /* Channel from which to read. */ + Tcl_Obj *objPtr) /* The line read will be appended to this + * object as UTF-8 characters. */ +{ + Channel *chanPtr = (Channel *) chan; + ChannelState *statePtr = chanPtr->state; + /* State info for channel */ + ChannelBuffer *bufPtr; + int inEofChar, skip, copiedTotal, oldLength, oldFlags, oldRemoved; + int rawLen, byteLen, eolChar; + unsigned char *dst, *dstEnd, *eol, *eof, *byteArray; + + /* + * This operation should occur at the top of a channel stack. + */ + + chanPtr = statePtr->topChanPtr; + TclChannelPreserve((Tcl_Channel)chanPtr); + + bufPtr = statePtr->inQueueHead; + + /* + * Preserved so we can restore the channel's state in case we don't find a + * newline in the available input. + */ + + byteArray = Tcl_GetByteArrayFromObj(objPtr, &byteLen); + oldFlags = statePtr->inputEncodingFlags; + oldRemoved = BUFFER_PADDING; + oldLength = byteLen; + if (bufPtr != NULL) { + oldRemoved = bufPtr->nextRemoved; + } + + rawLen = 0; + skip = 0; + eof = NULL; + inEofChar = statePtr->inEofChar; + + /* + * Only handle TCL_TRANSLATE_LF and TCL_TRANSLATE_CR. + */ + + eolChar = (statePtr->inputTranslation == TCL_TRANSLATE_LF) ? '\n' : '\r'; + + ResetFlag(statePtr, CHANNEL_BLOCKED); + while (1) { + /* + * Subtract the number of bytes that were removed from channel + * buffer during last call. + */ + + if (bufPtr != NULL) { + bufPtr->nextRemoved += rawLen; + if (!IsBufferReady(bufPtr)) { + bufPtr = bufPtr->nextPtr; + } + } + + if ((bufPtr == NULL) || (bufPtr->nextAdded == BUFFER_PADDING)) { + /* + * All channel buffers were exhausted and the caller still + * hasn't seen EOL. Need to read more bytes from the channel + * device. Side effect is to allocate another channel buffer. + */ + if (GetInput(chanPtr) != 0) { + goto restore; + } + bufPtr = statePtr->inQueueTail; + if (bufPtr == NULL) { + goto restore; + } + } else { + /* + * Incoming CHANNEL_STICKY_EOF is filtered out on entry. + * A new CHANNEL_STICKY_EOF set in this routine leads to + * return before coming back here. When we are not dealing + * with CHANNEL_STICKY_EOF, a CHANNEL_EOF implies an + * empty buffer. Here the buffer is non-empty so we know + * we're a non-EOF */ + + assert ( !GotFlag(statePtr, CHANNEL_STICKY_EOF) ); + assert ( !GotFlag(statePtr, CHANNEL_EOF) ); + } + + dst = (unsigned char *) RemovePoint(bufPtr); + dstEnd = dst + BytesLeft(bufPtr); + + /* + * Remember if EOF char is seen, then look for EOL anyhow, because the + * EOL might be before the EOF char. + * XXX - in the binary case, consider coincident search for eol/eof. + */ + + if (inEofChar != '\0') { + for (eol = dst; eol < dstEnd; eol++) { + if (*eol == inEofChar) { + dstEnd = eol; + eof = eol; + break; + } + } + } + + /* + * On EOL, leave current file position pointing after the EOL, but + * don't store the EOL in the output string. + */ + + for (eol = dst; eol < dstEnd; eol++) { + if (*eol == eolChar) { + skip = 1; + goto gotEOL; + } + } + if (eof != NULL) { + /* + * EOF character was seen. On EOF, leave current file position + * pointing at the EOF character, but don't store the EOF + * character in the output string. + */ + + SetFlag(statePtr, CHANNEL_EOF | CHANNEL_STICKY_EOF); + statePtr->inputEncodingFlags |= TCL_ENCODING_END; + ResetFlag(statePtr, CHANNEL_BLOCKED|INPUT_SAW_CR); + } + if (GotFlag(statePtr, CHANNEL_EOF)) { + skip = 0; + eol = dstEnd; + if ((dst == dstEnd) && (byteLen == oldLength)) { + /* + * If we didn't append any bytes before encountering EOF, + * caller needs to see -1. + */ + + byteArray = Tcl_SetByteArrayLength(objPtr, oldLength); + CommonGetsCleanup(chanPtr); + copiedTotal = -1; + ResetFlag(statePtr, CHANNEL_BLOCKED); + goto done; + } + goto gotEOL; + } + if (GotFlag(statePtr, CHANNEL_BLOCKED|CHANNEL_NONBLOCKING) + == (CHANNEL_BLOCKED|CHANNEL_NONBLOCKING)) { + goto restore; + } + + /* + * Copy bytes from the channel buffer to the ByteArray. + * This may realloc space, so keep track of result. + */ + + rawLen = dstEnd - dst; + byteArray = Tcl_SetByteArrayLength(objPtr, byteLen + rawLen); + memcpy(byteArray + byteLen, dst, (size_t) rawLen); + byteLen += rawLen; + } + + /* + * Found EOL or EOF, but the output buffer may now contain too many bytes. + * We need to know how many bytes correspond to the number we want, so we + * can remove the correct number of bytes from the channel buffer. + */ + + gotEOL: + if (bufPtr == NULL) { + Tcl_Panic("TclGetsObjBinary: gotEOL reached with bufPtr==NULL"); + } + + rawLen = eol - dst; + byteArray = Tcl_SetByteArrayLength(objPtr, byteLen + rawLen); + memcpy(byteArray + byteLen, dst, (size_t) rawLen); + byteLen += rawLen; + bufPtr->nextRemoved += rawLen + skip; + + /* + * Convert the buffer if there was an encoding. + * XXX - unimplemented. + */ + + if (statePtr->encoding != NULL) { + } + + /* + * Recycle all the emptied buffers. + */ + + CommonGetsCleanup(chanPtr); + ResetFlag(statePtr, CHANNEL_BLOCKED); + copiedTotal = byteLen; + goto done; + + /* + * Couldn't get a complete line. This only happens if we get a error + * reading from the channel or we are non-blocking and there wasn't an EOL + * or EOF in the data available. + */ + + restore: + bufPtr = statePtr->inQueueHead; + if (bufPtr) { + bufPtr->nextRemoved = oldRemoved; + bufPtr = bufPtr->nextPtr; + } + + for ( ; bufPtr != NULL; bufPtr = bufPtr->nextPtr) { + bufPtr->nextRemoved = BUFFER_PADDING; + } + CommonGetsCleanup(chanPtr); + + statePtr->inputEncodingFlags = oldFlags; + byteArray = Tcl_SetByteArrayLength(objPtr, oldLength); + + /* + * We didn't get a complete line so we need to indicate to UpdateInterest + * that the gets blocked. It will wait for more data instead of firing a + * timer, avoiding a busy wait. This is where we are assuming that the + * next operation is a gets. No more file events will be delivered on this + * channel until new data arrives or some operation is performed on the + * channel (e.g. gets, read, fconfigure) that changes the blocking state. + * Note that this means a file event will not be delivered even though a + * read would be able to consume the buffered data. + */ + + SetFlag(statePtr, CHANNEL_NEED_MORE_DATA); + copiedTotal = -1; + + /* + * Update the notifier state so we don't block while there is still data + * in the buffers. + */ + + done: + assert(!GotFlag(statePtr, CHANNEL_EOF) + || GotFlag(statePtr, CHANNEL_STICKY_EOF) + || Tcl_InputBuffered((Tcl_Channel)chanPtr) == 0); + assert( !(GotFlag(statePtr, CHANNEL_EOF|CHANNEL_BLOCKED) + == (CHANNEL_EOF|CHANNEL_BLOCKED)) ); + UpdateInterest(chanPtr); + TclChannelRelease((Tcl_Channel)chanPtr); + return copiedTotal; +} + +/* + *--------------------------------------------------------------------------- + * + * FreeBinaryEncoding -- + * + * Frees any "iso8859-1" Tcl_Encoding created by [gets] on a binary + * channel in a thread as part of that thread's finalization. + * + * Results: + * None. + * + *--------------------------------------------------------------------------- + */ + +static void +FreeBinaryEncoding( + ClientData dummy) /* Not used */ +{ + ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey); + + if (tsdPtr->binaryEncoding != NULL) { + Tcl_FreeEncoding(tsdPtr->binaryEncoding); + tsdPtr->binaryEncoding = NULL; + } +} + +static Tcl_Encoding +GetBinaryEncoding() +{ + ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey); + + if (tsdPtr->binaryEncoding == NULL) { + tsdPtr->binaryEncoding = Tcl_GetEncoding(NULL, "iso8859-1"); + Tcl_CreateThreadExitHandler(FreeBinaryEncoding, NULL); + } + if (tsdPtr->binaryEncoding == NULL) { + Tcl_Panic("binary encoding is not available"); + } + return tsdPtr->binaryEncoding; +} + +/* + *--------------------------------------------------------------------------- + * + * FilterInputBytes -- + * + * Helper function for Tcl_GetsObj. Produces UTF-8 characters from raw + * bytes read from the channel. + * + * Consumes available bytes from channel buffers. When channel buffers + * are exhausted, reads more bytes from channel device into a new channel + * buffer. It is the caller's responsibility to free the channel buffers + * that have been exhausted. + * + * Results: + * The return value is -1 if there was an error reading from the channel, + * 0 otherwise. + * + * Side effects: + * Status object keeps track of how much data from channel buffers has + * been consumed and where UTF-8 bytes should be stored. + * + *--------------------------------------------------------------------------- + */ + +static int +FilterInputBytes( + Channel *chanPtr, /* Channel to read. */ + GetsState *gsPtr) /* Current state of gets operation. */ +{ + ChannelState *statePtr = chanPtr->state; + /* State info for channel */ + ChannelBuffer *bufPtr; + char *raw, *dst; + int offset, toRead, dstNeeded, spaceLeft, result, rawLen; + Tcl_Obj *objPtr; +#define ENCODING_LINESIZE 20 /* Lower bound on how many bytes to convert at + * a time. Since we don't know a priori how + * many bytes of storage this many source + * bytes will use, we actually need at least + * ENCODING_LINESIZE * TCL_MAX_UTF bytes of + * room. */ + + objPtr = gsPtr->objPtr; + + /* + * Subtract the number of bytes that were removed from channel buffer + * during last call. + */ + + bufPtr = gsPtr->bufPtr; + if (bufPtr != NULL) { + bufPtr->nextRemoved += gsPtr->rawRead; + if (!IsBufferReady(bufPtr)) { + bufPtr = bufPtr->nextPtr; + } + } + gsPtr->totalChars += gsPtr->charsWrote; + + if ((bufPtr == NULL) || (bufPtr->nextAdded == BUFFER_PADDING)) { + /* + * All channel buffers were exhausted and the caller still hasn't seen + * EOL. Need to read more bytes from the channel device. Side effect + * is to allocate another channel buffer. + */ + + read: + if (GotFlag(statePtr, CHANNEL_NONBLOCKING|CHANNEL_BLOCKED) + == (CHANNEL_NONBLOCKING|CHANNEL_BLOCKED)) { + gsPtr->charsWrote = 0; + gsPtr->rawRead = 0; + return -1; + } + if (GetInput(chanPtr) != 0) { + gsPtr->charsWrote = 0; + gsPtr->rawRead = 0; + return -1; + } + bufPtr = statePtr->inQueueTail; + gsPtr->bufPtr = bufPtr; + if (bufPtr == NULL) { + gsPtr->charsWrote = 0; + gsPtr->rawRead = 0; + return -1; + } + } else { + /* + * Incoming CHANNEL_STICKY_EOF is filtered out on entry. + * A new CHANNEL_STICKY_EOF set in this routine leads to + * return before coming back here. When we are not dealing + * with CHANNEL_STICKY_EOF, a CHANNEL_EOF implies an + * empty buffer. Here the buffer is non-empty so we know + * we're a non-EOF */ + + assert ( !GotFlag(statePtr, CHANNEL_STICKY_EOF) ); + assert ( !GotFlag(statePtr, CHANNEL_EOF) ); + } + + /* + * Convert some of the bytes from the channel buffer to UTF-8. Space in + * objPtr's string rep is used to hold the UTF-8 characters. Grow the + * string rep if we need more space. + */ + + raw = RemovePoint(bufPtr); + rawLen = BytesLeft(bufPtr); + + dst = *gsPtr->dstPtr; + offset = dst - objPtr->bytes; + toRead = ENCODING_LINESIZE; + if (toRead > rawLen) { + toRead = rawLen; + } + dstNeeded = toRead * TCL_UTF_MAX; + spaceLeft = objPtr->length - offset; + if (dstNeeded > spaceLeft) { + int length = offset + ((offset < dstNeeded) ? dstNeeded : offset); + + if (Tcl_AttemptSetObjLength(objPtr, length) == 0) { + length = offset + dstNeeded; + if (Tcl_AttemptSetObjLength(objPtr, length) == 0) { + dstNeeded = TCL_UTF_MAX - 1 + toRead; + length = offset + dstNeeded; + Tcl_SetObjLength(objPtr, length); + } + } + spaceLeft = length - offset; + dst = objPtr->bytes + offset; + *gsPtr->dstPtr = dst; + } + gsPtr->state = statePtr->inputEncodingState; + result = Tcl_ExternalToUtf(NULL, gsPtr->encoding, raw, rawLen, + statePtr->inputEncodingFlags | TCL_ENCODING_NO_TERMINATE, + &statePtr->inputEncodingState, dst, spaceLeft, &gsPtr->rawRead, + &gsPtr->bytesWrote, &gsPtr->charsWrote); + + /* + * Make sure that if we go through 'gets', that we reset the + * TCL_ENCODING_START flag still. [Bug #523988] + */ + + statePtr->inputEncodingFlags &= ~TCL_ENCODING_START; + + if (result == TCL_CONVERT_MULTIBYTE) { + /* + * The last few bytes in this channel buffer were the start of a + * multibyte sequence. If this buffer was full, then move them to the + * next buffer so the bytes will be contiguous. + */ + + ChannelBuffer *nextPtr; + int extra; + + nextPtr = bufPtr->nextPtr; + if (!IsBufferFull(bufPtr)) { + if (gsPtr->rawRead > 0) { + /* + * Some raw bytes were converted to UTF-8. Fall through, + * returning those UTF-8 characters because a EOL might be + * present in them. + */ + } else if (GotFlag(statePtr, CHANNEL_EOF)) { + /* + * There was a partial character followed by EOF on the + * device. Fall through, returning that nothing was found. + */ + + bufPtr->nextRemoved = bufPtr->nextAdded; + } else { + /* + * There are no more cached raw bytes left. See if we can get + * some more, but avoid blocking on a non-blocking channel. + */ + + goto read; + } + } else { + if (nextPtr == NULL) { + nextPtr = AllocChannelBuffer(statePtr->bufSize); + bufPtr->nextPtr = nextPtr; + statePtr->inQueueTail = nextPtr; + } + extra = rawLen - gsPtr->rawRead; + memcpy(nextPtr->buf + (BUFFER_PADDING - extra), + raw + gsPtr->rawRead, (size_t) extra); + nextPtr->nextRemoved -= extra; + bufPtr->nextAdded -= extra; + } + } + + gsPtr->bufPtr = bufPtr; + return 0; +} + +/* + *--------------------------------------------------------------------------- + * + * PeekAhead -- + * + * Helper function used by Tcl_GetsObj(). Called when we've seen a \r at + * the end of the UTF-8 string and want to look ahead one character to + * see if it is a \n. + * + * Results: + * *gsPtr->dstPtr is filled with a pointer to the start of the range of + * UTF-8 characters that were found by peeking and *dstEndPtr is filled + * with a pointer to the bytes just after the end of the range. + * + * Side effects: + * If no more raw bytes were available in one of the channel buffers, + * tries to perform a non-blocking read to get more bytes from the + * channel device. + * + *--------------------------------------------------------------------------- + */ + +static void +PeekAhead( + Channel *chanPtr, /* The channel to read. */ + char **dstEndPtr, /* Filled with pointer to end of new range of + * UTF-8 characters. */ + GetsState *gsPtr) /* Current state of gets operation. */ +{ + ChannelState *statePtr = chanPtr->state; + /* State info for channel */ + ChannelBuffer *bufPtr; + Tcl_DriverBlockModeProc *blockModeProc; + int bytesLeft; + + bufPtr = gsPtr->bufPtr; + + /* + * If there's any more raw input that's still buffered, we'll peek into + * that. Otherwise, only get more data from the channel driver if it looks + * like there might actually be more data. The assumption is that if the + * channel buffer is filled right up to the end, then there might be more + * data to read. + */ + + blockModeProc = NULL; + if (bufPtr->nextPtr == NULL) { + bytesLeft = BytesLeft(bufPtr) - gsPtr->rawRead; + if (bytesLeft == 0) { + if (!IsBufferFull(bufPtr)) { + /* + * Don't peek ahead if last read was short read. + */ + + goto cleanup; + } + if (!GotFlag(statePtr, CHANNEL_NONBLOCKING)) { + blockModeProc = Tcl_ChannelBlockModeProc(chanPtr->typePtr); + if (blockModeProc == NULL) { + /* + * Don't peek ahead if cannot set non-blocking mode. + */ + + goto cleanup; + } + StackSetBlockMode(chanPtr, TCL_MODE_NONBLOCKING); + } + } + } + if (FilterInputBytes(chanPtr, gsPtr) == 0) { + *dstEndPtr = *gsPtr->dstPtr + gsPtr->bytesWrote; + } + if (blockModeProc != NULL) { + StackSetBlockMode(chanPtr, TCL_MODE_BLOCKING); + } + return; + + cleanup: + bufPtr->nextRemoved += gsPtr->rawRead; + gsPtr->rawRead = 0; + gsPtr->totalChars += gsPtr->charsWrote; + gsPtr->bytesWrote = 0; + gsPtr->charsWrote = 0; +} + +/* + *--------------------------------------------------------------------------- + * + * CommonGetsCleanup -- + * + * Helper function for Tcl_GetsObj() to restore the channel after a + * "gets" operation. + * + * Results: + * None. + * + * Side effects: + * Encoding may be freed. + * + *--------------------------------------------------------------------------- + */ + +static void +CommonGetsCleanup( + Channel *chanPtr) +{ + ChannelState *statePtr = chanPtr->state; + /* State info for channel */ + ChannelBuffer *bufPtr, *nextPtr; + + bufPtr = statePtr->inQueueHead; + for ( ; bufPtr != NULL; bufPtr = nextPtr) { + nextPtr = bufPtr->nextPtr; + if (IsBufferReady(bufPtr)) { + break; + } + RecycleBuffer(statePtr, bufPtr, 0); + } + statePtr->inQueueHead = bufPtr; + if (bufPtr == NULL) { + statePtr->inQueueTail = NULL; + } else { + /* + * If any multi-byte characters were split across channel buffer + * boundaries, the split-up bytes were moved to the next channel + * buffer by FilterInputBytes(). Move the bytes back to their original + * buffer because the caller could change the channel's encoding which + * could change the interpretation of whether those bytes really made + * up multi-byte characters after all. + */ + + nextPtr = bufPtr->nextPtr; + for ( ; nextPtr != NULL; nextPtr = bufPtr->nextPtr) { + int extra; + + extra = SpaceLeft(bufPtr); + if (extra > 0) { + memcpy(InsertPoint(bufPtr), + nextPtr->buf + (BUFFER_PADDING - extra), + (size_t) extra); + bufPtr->nextAdded += extra; + nextPtr->nextRemoved = BUFFER_PADDING; + } + bufPtr = nextPtr; + } + } +} + +/* + *---------------------------------------------------------------------- + * + * Tcl_Read -- + * + * Reads a given number of bytes from a channel. EOL and EOF translation + * is done on the bytes being read, so the number of bytes consumed from + * the channel may not be equal to the number of bytes stored in the + * destination buffer. + * + * No encoding conversions are applied to the bytes being read. + * + * Results: + * The number of bytes read, or -1 on error. Use Tcl_GetErrno() to + * retrieve the error code for the error that occurred. + * + * Side effects: + * May cause input to be buffered. + * + *---------------------------------------------------------------------- + */ + +int +Tcl_Read( + Tcl_Channel chan, /* The channel from which to read. */ + char *dst, /* Where to store input read. */ + int bytesToRead) /* Maximum number of bytes to read. */ +{ + Channel *chanPtr = (Channel *) chan; + ChannelState *statePtr = chanPtr->state; + /* State info for channel */ + + /* + * This operation should occur at the top of a channel stack. + */ + + chanPtr = statePtr->topChanPtr; + + if (CheckChannelErrors(statePtr, TCL_READABLE) != 0) { + return -1; + } + + return DoRead(chanPtr, dst, bytesToRead, 0); +} + +/* + *---------------------------------------------------------------------- + * + * Tcl_ReadRaw -- + * + * Reads a given number of bytes from a channel. EOL and EOF translation + * is done on the bytes being read, so the number of bytes consumed from + * the channel may not be equal to the number of bytes stored in the + * destination buffer. + * + * No encoding conversions are applied to the bytes being read. + * + * Results: + * The number of bytes read, or -1 on error. Use Tcl_GetErrno() to + * retrieve the error code for the error that occurred. + * + * Side effects: + * May cause input to be buffered. + * + *---------------------------------------------------------------------- + */ + +int +Tcl_ReadRaw( + Tcl_Channel chan, /* The channel from which to read. */ + char *readBuf, /* Where to store input read. */ + int bytesToRead) /* Maximum number of bytes to read. */ +{ + Channel *chanPtr = (Channel *) chan; + ChannelState *statePtr = chanPtr->state; + /* State info for channel */ + int copied = 0; + + assert(bytesToRead > 0); + if (CheckChannelErrors(statePtr, TCL_READABLE | CHANNEL_RAW_MODE) != 0) { + return -1; + } + + /* First read bytes from the push-back buffers. */ + + while (chanPtr->inQueueHead && bytesToRead > 0) { + ChannelBuffer *bufPtr = chanPtr->inQueueHead; + int bytesInBuffer = BytesLeft(bufPtr); + int toCopy = (bytesInBuffer < bytesToRead) ? bytesInBuffer + : bytesToRead; + + /* Copy the current chunk into the read buffer. */ + + memcpy(readBuf, RemovePoint(bufPtr), (size_t) toCopy); + bufPtr->nextRemoved += toCopy; + copied += toCopy; + readBuf += toCopy; + bytesToRead -= toCopy; + + /* If the current buffer is empty recycle it. */ + + if (IsBufferEmpty(bufPtr)) { + chanPtr->inQueueHead = bufPtr->nextPtr; + if (chanPtr->inQueueHead == NULL) { + chanPtr->inQueueTail = NULL; + } + RecycleBuffer(chanPtr->state, bufPtr, 0); + } + } + + /* + * Go to the driver only if we got nothing from pushback. + * Have to do it this way to avoid EOF mis-timings when we + * consider the ability that EOF may not be a permanent + * condition in the driver, and in that case we have to + * synchronize. + */ + + if (copied) { + return copied; + } + + /* This test not needed. */ + if (bytesToRead > 0) { + + int nread = ChanRead(chanPtr, readBuf, bytesToRead); + + if (nread > 0) { + /* Successful read (short is OK) - add to bytes copied */ + copied += nread; + } else if (nread < 0) { + /* + * An error signaled. If CHANNEL_BLOCKED, then the error + * is not real, but an indication of blocked state. In + * that case, retain the flag and let caller receive the + * short read of copied bytes from the pushback. + * HOWEVER, if copied==0 bytes from pushback then repeat + * signalling the blocked state as an error to caller so + * there is no false report of an EOF. + * When !CHANNEL_BLOCKED, the error is real and passes on + * to caller. + */ + if (!GotFlag(statePtr, CHANNEL_BLOCKED) || copied == 0) { + copied = -1; + } + } else { + /* + * nread == 0. Driver is at EOF. Let that state filter up. + */ + } + } + return copied; +} + +/* + *--------------------------------------------------------------------------- + * + * Tcl_ReadChars -- + * + * Reads from the channel until the requested number of characters have + * been seen, EOF is seen, or the channel would block. EOL and EOF + * translation is done. If reading binary data, the raw bytes are wrapped + * in a Tcl byte array object. Otherwise, the raw bytes are converted to + * UTF-8 using the channel's current encoding and stored in a Tcl string + * object. + * + * Results: + * The number of characters read, or -1 on error. Use Tcl_GetErrno() to + * retrieve the error code for the error that occurred. + * + * Side effects: + * May cause input to be buffered. + * + *--------------------------------------------------------------------------- + */ + +int +Tcl_ReadChars( + Tcl_Channel chan, /* The channel to read. */ + Tcl_Obj *objPtr, /* Input data is stored in this object. */ + int toRead, /* Maximum number of characters to store, or + * -1 to read all available data (up to EOF or + * when channel blocks). */ + int appendFlag) /* If non-zero, data read from the channel + * will be appended to the object. Otherwise, + * the data will replace the existing contents + * of the object. */ +{ + Channel *chanPtr = (Channel *) chan; + ChannelState *statePtr = chanPtr->state; + /* State info for channel */ + + /* + * This operation should occur at the top of a channel stack. + */ + + chanPtr = statePtr->topChanPtr; + + if (CheckChannelErrors(statePtr, TCL_READABLE) != 0) { + /* + * Update the notifier state so we don't block while there is still + * data in the buffers. + */ + + UpdateInterest(chanPtr); + return -1; + } + + return DoReadChars(chanPtr, objPtr, toRead, appendFlag); +} +/* + *--------------------------------------------------------------------------- + * + * DoReadChars -- + * + * Reads from the channel until the requested number of characters have + * been seen, EOF is seen, or the channel would block. EOL and EOF + * translation is done. If reading binary data, the raw bytes are wrapped + * in a Tcl byte array object. Otherwise, the raw bytes are converted to + * UTF-8 using the channel's current encoding and stored in a Tcl string + * object. + * + * Results: + * The number of characters read, or -1 on error. Use Tcl_GetErrno() to + * retrieve the error code for the error that occurred. + * + * Side effects: + * May cause input to be buffered. + * + *--------------------------------------------------------------------------- + */ + +static int +DoReadChars( + Channel *chanPtr, /* The channel to read. */ + Tcl_Obj *objPtr, /* Input data is stored in this object. */ + int toRead, /* Maximum number of characters to store, or + * -1 to read all available data (up to EOF or + * when channel blocks). */ + int appendFlag) /* If non-zero, data read from the channel + * will be appended to the object. Otherwise, + * the data will replace the existing contents + * of the object. */ +{ + ChannelState *statePtr = chanPtr->state; + /* State info for channel */ + ChannelBuffer *bufPtr; + int copied, copiedNow, result; + Tcl_Encoding encoding = statePtr->encoding; + int binaryMode; +#define UTF_EXPANSION_FACTOR 1024 + int factor = UTF_EXPANSION_FACTOR; + + binaryMode = (encoding == NULL) + && (statePtr->inputTranslation == TCL_TRANSLATE_LF) + && (statePtr->inEofChar == '\0'); + + if (appendFlag == 0) { + if (binaryMode) { + Tcl_SetByteArrayLength(objPtr, 0); + } else { + Tcl_SetObjLength(objPtr, 0); + + /* + * We're going to access objPtr->bytes directly, so we must ensure + * that this is actually a string object (otherwise it might have + * been pure Unicode). + * + * Probably not needed anymore. + */ + + TclGetString(objPtr); + } + } + + /* + * Early out when next read will see eofchar. + * + * NOTE: See DoRead for argument that it's a bug (one we're keeping) + * to have this escape before the one for zero-char read request. + */ + + if (GotFlag(statePtr, CHANNEL_STICKY_EOF)) { + SetFlag(statePtr, CHANNEL_EOF); + assert( statePtr->inputEncodingFlags & TCL_ENCODING_END ); + assert( !GotFlag(statePtr, CHANNEL_BLOCKED|INPUT_SAW_CR) ); + + /* TODO: We don't need this call? */ + UpdateInterest(chanPtr); + return 0; + } + + /* Special handling for zero-char read request. */ + if (toRead == 0) { + if (GotFlag(statePtr, CHANNEL_EOF)) { + statePtr->inputEncodingFlags |= TCL_ENCODING_START; + } + ResetFlag(statePtr, CHANNEL_BLOCKED|CHANNEL_EOF); + statePtr->inputEncodingFlags &= ~TCL_ENCODING_END; + /* TODO: We don't need this call? */ + UpdateInterest(chanPtr); + return 0; + } + + /* + * This operation should occur at the top of a channel stack. + */ + + chanPtr = statePtr->topChanPtr; + TclChannelPreserve((Tcl_Channel)chanPtr); + + /* Must clear the BLOCKED|EOF flags here since we check before reading */ + if (GotFlag(statePtr, CHANNEL_EOF)) { + statePtr->inputEncodingFlags |= TCL_ENCODING_START; + } + ResetFlag(statePtr, CHANNEL_BLOCKED|CHANNEL_EOF); + statePtr->inputEncodingFlags &= ~TCL_ENCODING_END; + for (copied = 0; (unsigned) toRead > 0; ) { + copiedNow = -1; + if (statePtr->inQueueHead != NULL) { + if (binaryMode) { + copiedNow = ReadBytes(statePtr, objPtr, toRead); + } else { + copiedNow = ReadChars(statePtr, objPtr, toRead, &factor); + } + + /* + * If the current buffer is empty recycle it. + */ + + bufPtr = statePtr->inQueueHead; + if (IsBufferEmpty(bufPtr)) { + ChannelBuffer *nextPtr = bufPtr->nextPtr; + + RecycleBuffer(statePtr, bufPtr, 0); + statePtr->inQueueHead = nextPtr; + if (nextPtr == NULL) { + statePtr->inQueueTail = NULL; + } + } + } + + if (copiedNow < 0) { + if (GotFlag(statePtr, CHANNEL_EOF)) { + break; + } + if (GotFlag(statePtr, CHANNEL_NONBLOCKING|CHANNEL_BLOCKED) + == (CHANNEL_NONBLOCKING|CHANNEL_BLOCKED)) { + break; + } + result = GetInput(chanPtr); + if (chanPtr != statePtr->topChanPtr) { + TclChannelRelease((Tcl_Channel)chanPtr); + chanPtr = statePtr->topChanPtr; + TclChannelPreserve((Tcl_Channel)chanPtr); + } + if (result != 0) { + if (!GotFlag(statePtr, CHANNEL_BLOCKED)) { + copied = -1; + } + break; + } + } else { + copied += copiedNow; + toRead -= copiedNow; + } + } + + /* + * Failure to fill a channel buffer may have left channel reporting + * a "blocked" state, but so long as we fulfilled the request here, + * the caller does not consider us blocked. + */ + if (toRead == 0) { + ResetFlag(statePtr, CHANNEL_BLOCKED); + } + + /* + * Regenerate the top channel, in case it was changed due to + * self-modifying reflected transforms. + */ + if (chanPtr != statePtr->topChanPtr) { + TclChannelRelease((Tcl_Channel)chanPtr); + chanPtr = statePtr->topChanPtr; + TclChannelPreserve((Tcl_Channel)chanPtr); + } + + /* + * Update the notifier state so we don't block while there is still data + * in the buffers. + */ + assert(!GotFlag(statePtr, CHANNEL_EOF) + || GotFlag(statePtr, CHANNEL_STICKY_EOF) + || Tcl_InputBuffered((Tcl_Channel)chanPtr) == 0); + assert( !(GotFlag(statePtr, CHANNEL_EOF|CHANNEL_BLOCKED) + == (CHANNEL_EOF|CHANNEL_BLOCKED)) ); + UpdateInterest(chanPtr); + TclChannelRelease((Tcl_Channel)chanPtr); + return copied; +} + +/* + *--------------------------------------------------------------------------- + * + * ReadBytes -- + * + * Reads from the channel until the requested number of bytes have been + * seen, EOF is seen, or the channel would block. Bytes from the channel + * are stored in objPtr as a ByteArray object. EOL and EOF translation + * are done. + * + * 'bytesToRead' can safely be a very large number because space is only + * allocated to hold data read from the channel as needed. + * + * Results: + * The return value is the number of bytes appended to the object, or + * -1 to indicate that zero bytes were read due to an EOF. + * + * Side effects: + * The storage of bytes in objPtr can cause (re-)allocation of memory. + * + *--------------------------------------------------------------------------- + */ + +static int +ReadBytes( + ChannelState *statePtr, /* State of the channel to read. */ + Tcl_Obj *objPtr, /* Input data is appended to this ByteArray + * object. Its length is how much space has + * been allocated to hold data, not how many + * bytes of data have been stored in the + * object. */ + int bytesToRead) /* Maximum number of bytes to store, or < 0 to + * get all available bytes. Bytes are obtained + * from the first buffer in the queue - even + * if this number is larger than the number of + * bytes available in the first buffer, only + * the bytes from the first buffer are + * returned. */ +{ + ChannelBuffer *bufPtr = statePtr->inQueueHead; + int srcLen = BytesLeft(bufPtr); + int toRead = bytesToRead>srcLen || bytesToRead<0 ? srcLen : bytesToRead; + + TclAppendBytesToByteArray(objPtr, (unsigned char *) RemovePoint(bufPtr), + toRead); + bufPtr->nextRemoved += toRead; + return toRead; +} + +/* + *--------------------------------------------------------------------------- + * + * ReadChars -- + * + * Reads from the channel until the requested number of UTF-8 characters + * have been seen, EOF is seen, or the channel would block. Raw bytes + * from the channel are converted to UTF-8 and stored in objPtr. EOL and + * EOF translation is done. + * + * 'charsToRead' can safely be a very large number because space is only + * allocated to hold data read from the channel as needed. + * + * 'charsToRead' may *not* be 0. + * + * Results: + * The return value is the number of characters appended to the object, + * *offsetPtr is filled with the number of bytes that were appended, and + * *factorPtr is filled with the expansion factor used to guess how many + * bytes of UTF-8 to allocate to hold N source bytes. + * + * Side effects: + * None. + * + *--------------------------------------------------------------------------- + */ + +static int +ReadChars( + ChannelState *statePtr, /* State of channel to read. */ + Tcl_Obj *objPtr, /* Input data is appended to this object. + * objPtr->length is how much space has been + * allocated to hold data, not how many bytes + * of data have been stored in the object. */ + int charsToRead, /* Maximum number of characters to store, or + * -1 to get all available characters. + * Characters are obtained from the first + * buffer in the queue -- even if this number + * is larger than the number of characters + * available in the first buffer, only the + * characters from the first buffer are + * returned. The execption is when there is + * not any complete character in the first + * buffer. In that case, a recursive call + * effectively obtains chars from the + * second buffer. */ + int *factorPtr) /* On input, contains a guess of how many + * bytes need to be allocated to hold the + * result of converting N source bytes to + * UTF-8. On output, contains another guess + * based on the data seen so far. */ +{ + Tcl_Encoding encoding = statePtr->encoding? statePtr->encoding + : GetBinaryEncoding(); + Tcl_EncodingState savedState = statePtr->inputEncodingState; + ChannelBuffer *bufPtr = statePtr->inQueueHead; + int savedIEFlags = statePtr->inputEncodingFlags; + int savedFlags = statePtr->flags; + char *dst, *src = RemovePoint(bufPtr); + int numBytes, srcLen = BytesLeft(bufPtr); + + /* + * One src byte can yield at most one character. So when the + * number of src bytes we plan to read is less than the limit on + * character count to be read, clearly we will remain within that + * limit, and we can use the value of "srcLen" as a tighter limit + * for sizing receiving buffers. + */ + + int toRead = ((charsToRead<0)||(charsToRead > srcLen)) ? srcLen : charsToRead; + + /* + * 'factor' is how much we guess that the bytes in the source buffer will + * expand when converted to UTF-8 chars. This guess comes from analyzing + * how many characters were produced by the previous pass. + */ + + int factor = *factorPtr; + int dstLimit = TCL_UTF_MAX - 1 + toRead * factor / UTF_EXPANSION_FACTOR; + + (void) TclGetStringFromObj(objPtr, &numBytes); + Tcl_AppendToObj(objPtr, NULL, dstLimit); + if (toRead == srcLen) { + unsigned int size; + dst = TclGetStringStorage(objPtr, &size) + numBytes; + dstLimit = size - numBytes; + } else { + dst = TclGetString(objPtr) + numBytes; + } + + /* + * This routine is burdened with satisfying several constraints. + * It cannot append more than 'charsToRead` chars onto objPtr. + * This is measured after encoding and translation transformations + * are completed. There is no precise number of src bytes that can + * be associated with the limit. Yet, when we are done, we must know + * precisely the number of src bytes that were consumed to produce + * the appended chars, so that all subsequent bytes are left in + * the buffers for future read operations. + * + * The consequence is that we have no choice but to implement a + * "trial and error" approach, where in general we may need to + * perform transformations and copies multiple times to achieve + * a consistent set of results. This takes the shape of a loop. + */ + + while (1) { + int dstDecoded, dstRead, dstWrote, srcRead, numChars, code; + int flags = statePtr->inputEncodingFlags | TCL_ENCODING_NO_TERMINATE; + + if (charsToRead > 0) { + flags |= TCL_ENCODING_CHAR_LIMIT; + numChars = charsToRead; + } + + /* + * Perform the encoding transformation. Read no more than + * srcLen bytes, write no more than dstLimit bytes. + * + * Some trickiness with encoding flags here. We do not want + * the end of a buffer to be treated as the end of all input + * when the presence of bytes in a next buffer are already + * known to exist. This is checked with an assert() because + * so far no test case causing the assertion to be false has + * been created. The normal operations of channel reading + * appear to cause EOF and TCL_ENCODING_END setting to appear + * only in situations where there are no further bytes in + * any buffers. + */ + + assert(bufPtr->nextPtr == NULL || BytesLeft(bufPtr->nextPtr) == 0 + || (statePtr->inputEncodingFlags & TCL_ENCODING_END) == 0); + + code = Tcl_ExternalToUtf(NULL, encoding, src, srcLen, + flags, &statePtr->inputEncodingState, + dst, dstLimit, &srcRead, &dstDecoded, &numChars); + + /* + * Perform the translation transformation in place. Read no more + * than the dstDecoded bytes the encoding transformation actually + * produced. Capture the number of bytes written in dstWrote. + * Capture the number of bytes actually consumed in dstRead. + */ + + dstWrote = dstLimit; + dstRead = dstDecoded; + TranslateInputEOL(statePtr, dst, dst, &dstWrote, &dstRead); + + if (dstRead < dstDecoded) { + + /* + * The encoding transformation produced bytes that the + * translation transformation did not consume. Why did + * this happen? + */ + + if (statePtr->inEofChar && dst[dstRead] == statePtr->inEofChar) { + /* + * 1) There's an eof char set on the channel, and + * we saw it and stopped translating at that point. + * + * NOTE the bizarre spec of TranslateInputEOL in this case. + * Clearly the eof char had to be read in order to account + * for the stopping, but the value of dstRead does not + * include it. + * + * Also rather bizarre, our caller can only notice an + * EOF condition if we return the value -1 as the number + * of chars read. This forces us to perform a 2-call + * dance where the first call can read all the chars + * up to the eof char, and the second call is solely + * for consuming the encoded eof char then pointed at + * by src so that we can return that magic -1 value. + * This seems really wasteful, especially since + * the first decoding pass of each call is likely to + * decode many bytes beyond that eof char that's all we + * care about. + */ + + if (dstRead == 0) { + /* + * Curious choice in the eof char handling. We leave + * the eof char in the buffer. So, no need to compute + * a proper srcRead value. At this point, there + * are no chars before the eof char in the buffer. + */ + Tcl_SetObjLength(objPtr, numBytes); + return -1; + } + + { + /* + * There are chars leading the buffer before the eof + * char. Adjust the dstLimit so we go back and read + * only those and do not encounter the eof char this + * time. + */ + + dstLimit = dstRead - 1 + TCL_UTF_MAX; + statePtr->flags = savedFlags; + statePtr->inputEncodingFlags = savedIEFlags; + statePtr->inputEncodingState = savedState; + continue; + } + } + + /* + * 2) The other way to read fewer bytes than are decoded + * is when the final byte is \r and we're in a CRLF + * translation mode so we cannot decide whether to + * record \r or \n yet. + */ + + assert(dst[dstRead] == '\r'); + assert(statePtr->inputTranslation == TCL_TRANSLATE_CRLF); + + if (dstWrote > 0) { + /* + * There are chars we can read before we hit the bare cr. + * Go back with a smaller dstLimit so we get them in the + * next pass, compute a matching srcRead, and don't end + * up back here in this call. + */ + + dstLimit = dstRead - 1 + TCL_UTF_MAX; + statePtr->flags = savedFlags; + statePtr->inputEncodingFlags = savedIEFlags; + statePtr->inputEncodingState = savedState; + continue; + } + + assert(dstWrote == 0); + assert(dstRead == 0); + + /* + * We decoded only the bare cr, and we cannot read a + * translated char from that alone. We have to know what's + * next. So why do we only have the one decoded char? + */ + + if (code != TCL_OK) { + char buffer[TCL_UTF_MAX + 1]; + int read, decoded, count; + + /* + * Didn't get everything the buffer could offer + */ + + statePtr->flags = savedFlags; + statePtr->inputEncodingFlags = savedIEFlags; + statePtr->inputEncodingState = savedState; + + assert(bufPtr->nextPtr == NULL + || BytesLeft(bufPtr->nextPtr) == 0 || 0 == + (statePtr->inputEncodingFlags & TCL_ENCODING_END)); + + Tcl_ExternalToUtf(NULL, encoding, src, srcLen, + (statePtr->inputEncodingFlags | TCL_ENCODING_NO_TERMINATE), + &statePtr->inputEncodingState, buffer, TCL_UTF_MAX + 1, + &read, &decoded, &count); + + if (count == 2) { + if (buffer[1] == '\n') { + /* \r\n translate to \n */ + dst[0] = '\n'; + bufPtr->nextRemoved += read; + } else { + dst[0] = '\r'; + bufPtr->nextRemoved += srcRead; + } + + statePtr->inputEncodingFlags &= ~TCL_ENCODING_START; + + Tcl_SetObjLength(objPtr, numBytes + 1); + return 1; + } + + } else if (statePtr->flags & CHANNEL_EOF) { + + /* + * The bare \r is the only char and we will never read + * a subsequent char to make the determination. + */ + + dst[0] = '\r'; + bufPtr->nextRemoved = bufPtr->nextAdded; + Tcl_SetObjLength(objPtr, numBytes + 1); + return 1; + } + + /* + * Revise the dstRead value so that the numChars calc + * below correctly computes zero characters read. + */ + + dstRead = numChars; + + /* FALL THROUGH - get more data (dstWrote == 0) */ + } + + /* + * The translation transformation can only reduce the number + * of chars when it converts \r\n into \n. The reduction in + * the number of chars is the difference in bytes read and written. + */ + + numChars -= (dstRead - dstWrote); + + if (charsToRead > 0 && numChars > charsToRead) { + + /* + * TODO: This cannot happen anymore. + * + * We read more chars than allowed. Reset limits to + * prevent that and try again. Don't forget the extra + * padding of TCL_UTF_MAX bytes demanded by the + * Tcl_ExternalToUtf() call! + */ + + dstLimit = Tcl_UtfAtIndex(dst, charsToRead) - 1 + TCL_UTF_MAX - dst; + statePtr->flags = savedFlags; + statePtr->inputEncodingFlags = savedIEFlags; + statePtr->inputEncodingState = savedState; + continue; + } + + if (dstWrote == 0) { + ChannelBuffer *nextPtr; + + /* We were not able to read any chars. */ + + assert (numChars == 0); + + /* + * There is one situation where this is the correct final + * result. If the src buffer contains only a single \n + * byte, and we are in TCL_TRANSLATE_AUTO mode, and + * when the translation pass was made the INPUT_SAW_CR + * flag was set on the channel. In that case, the + * correct behavior is to consume that \n and produce the + * empty string. + */ + + if (dstRead == 1 && dst[0] == '\n') { + assert(statePtr->inputTranslation == TCL_TRANSLATE_AUTO); + + goto consume; + } + + /* Otherwise, reading zero characters indicates there's + * something incomplete at the end of the src buffer. + * Maybe there were not enough src bytes to decode into + * a char. Maybe a lone \r could not be translated (crlf + * mode). Need to combine any unused src bytes we have + * in the first buffer with subsequent bytes to try again. + */ + + nextPtr = bufPtr->nextPtr; + + if (nextPtr == NULL) { + if (srcLen > 0) { + SetFlag(statePtr, CHANNEL_NEED_MORE_DATA); + } + Tcl_SetObjLength(objPtr, numBytes); + return -1; + } + + /* + * Space is made at the beginning of the buffer to copy the + * previous unused bytes there. Check first if the buffer we + * are using actually has enough space at its beginning for + * the data we are copying. Because if not we will write over + * the buffer management information, especially the 'nextPtr'. + * + * Note that the BUFFER_PADDING (See AllocChannelBuffer) is + * used to prevent exactly this situation. I.e. it should never + * happen. Therefore it is ok to panic should it happen despite + * the precautions. + */ + + if (nextPtr->nextRemoved - srcLen < 0) { + Tcl_Panic("Buffer Underflow, BUFFER_PADDING not enough"); + } + + nextPtr->nextRemoved -= srcLen; + memcpy(RemovePoint(nextPtr), src, (size_t) srcLen); + RecycleBuffer(statePtr, bufPtr, 0); + statePtr->inQueueHead = nextPtr; + Tcl_SetObjLength(objPtr, numBytes); + return ReadChars(statePtr, objPtr, charsToRead, factorPtr); + } + + statePtr->inputEncodingFlags &= ~TCL_ENCODING_START; + + consume: + bufPtr->nextRemoved += srcRead; + /* + * If this read contained multibyte characters, revise factorPtr + * so the next read will allocate bigger buffers. + */ + if (numChars && numChars < srcRead) { + *factorPtr = srcRead * UTF_EXPANSION_FACTOR / numChars; + } + Tcl_SetObjLength(objPtr, numBytes + dstWrote); + return numChars; + } +} + +/* + *--------------------------------------------------------------------------- + * + * TranslateInputEOL -- + * + * Perform input EOL and EOF translation on the source buffer, leaving + * the translated result in the destination buffer. + * + * Results: + * The return value is 1 if the EOF character was found when copying + * bytes to the destination buffer, 0 otherwise. + * + * Side effects: + * None. + * + *--------------------------------------------------------------------------- + */ + +static void +TranslateInputEOL( + ChannelState *statePtr, /* Channel being read, for EOL translation and + * EOF character. */ + char *dstStart, /* Output buffer filled with chars by applying + * appropriate EOL translation to source + * characters. */ + const char *srcStart, /* Source characters. */ + int *dstLenPtr, /* On entry, the maximum length of output + * buffer in bytes. On exit, the number of + * bytes actually used in output buffer. */ + int *srcLenPtr) /* On entry, the length of source buffer. On + * exit, the number of bytes read from the + * source buffer. */ +{ + const char *eof = NULL; + int dstLen = *dstLenPtr; + int srcLen = *srcLenPtr; + int inEofChar = statePtr->inEofChar; + + /* + * Depending on the translation mode in use, there's no need + * to scan more srcLen bytes at srcStart than can possibly transform + * to dstLen bytes. This keeps the scan for eof char below from + * being pointlessly long. + */ + + switch (statePtr->inputTranslation) { + case TCL_TRANSLATE_LF: + case TCL_TRANSLATE_CR: + if (srcLen > dstLen) { + /* In these modes, each src byte become a dst byte. */ + srcLen = dstLen; + } + break; + default: + /* In other modes, at most 2 src bytes become a dst byte. */ + if (srcLen/2 > dstLen) { + srcLen = 2 * dstLen; + } + break; + } + + if (inEofChar != '\0') { + /* + * Make sure we do not read past any logical end of channel input + * created by the presence of the input eof char. + */ + + if ((eof = memchr(srcStart, inEofChar, srcLen))) { + srcLen = eof - srcStart; + } + } + + switch (statePtr->inputTranslation) { + case TCL_TRANSLATE_LF: + case TCL_TRANSLATE_CR: + if (dstStart != srcStart) { + memcpy(dstStart, srcStart, (size_t) srcLen); + } + if (statePtr->inputTranslation == TCL_TRANSLATE_CR) { + char *dst = dstStart; + char *dstEnd = dstStart + srcLen; + + while ((dst = memchr(dst, '\r', dstEnd - dst))) { + *dst++ = '\n'; + } + } + dstLen = srcLen; + break; + case TCL_TRANSLATE_CRLF: { + const char *crFound, *src = srcStart; + char *dst = dstStart; + int lesser = (dstLen < srcLen) ? dstLen : srcLen; + + while ((crFound = memchr(src, '\r', lesser))) { + int numBytes = crFound - src; + memmove(dst, src, numBytes); + + dst += numBytes; dstLen -= numBytes; + src += numBytes; srcLen -= numBytes; + if (srcLen == 1) { + /* valid src bytes end in \r */ + if (eof) { + *dst++ = '\r'; + src++; srcLen--; + } else { + lesser = 0; + break; + } + } else if (src[1] == '\n') { + *dst++ = '\n'; + src += 2; srcLen -= 2; + } else { + *dst++ = '\r'; + src++; srcLen--; + } + dstLen--; + lesser = (dstLen < srcLen) ? dstLen : srcLen; + } + memmove(dst, src, lesser); + srcLen = src + lesser - srcStart; + dstLen = dst + lesser - dstStart; + break; + } + case TCL_TRANSLATE_AUTO: { + const char *crFound, *src = srcStart; + char *dst = dstStart; + int lesser; + + if ((statePtr->flags & INPUT_SAW_CR) && srcLen) { + if (*src == '\n') { src++; srcLen--; } + ResetFlag(statePtr, INPUT_SAW_CR); + } + lesser = (dstLen < srcLen) ? dstLen : srcLen; + while ((crFound = memchr(src, '\r', lesser))) { + int numBytes = crFound - src; + memmove(dst, src, numBytes); + + dst[numBytes] = '\n'; + dst += numBytes + 1; dstLen -= numBytes + 1; + src += numBytes + 1; srcLen -= numBytes + 1; + if (srcLen == 0) { + SetFlag(statePtr, INPUT_SAW_CR); + } else if (*src == '\n') { + src++; srcLen--; + } + lesser = (dstLen < srcLen) ? dstLen : srcLen; + } + memmove(dst, src, lesser); + srcLen = src + lesser - srcStart; + dstLen = dst + lesser - dstStart; + break; + } + default: + Tcl_Panic("unknown input translation %d", statePtr->inputTranslation); + } + *dstLenPtr = dstLen; + *srcLenPtr = srcLen; + + if (srcStart + srcLen == eof) { + /* + * EOF character was seen in EOL translated range. Leave current file + * position pointing at the EOF character, but don't store the EOF + * character in the output string. + */ + + SetFlag(statePtr, CHANNEL_EOF | CHANNEL_STICKY_EOF); + statePtr->inputEncodingFlags |= TCL_ENCODING_END; + ResetFlag(statePtr, CHANNEL_BLOCKED|INPUT_SAW_CR); + } +} + +/* + *---------------------------------------------------------------------- + * + * Tcl_Ungets -- + * + * Causes the supplied string to be added to the input queue of the + * channel, at either the head or tail of the queue. + * + * Results: + * The number of bytes stored in the channel, or -1 on error. + * + * Side effects: + * Adds input to the input queue of a channel. + * + *---------------------------------------------------------------------- + */ + +int +Tcl_Ungets( + Tcl_Channel chan, /* The channel for which to add the input. */ + const char *str, /* The input itself. */ + int len, /* The length of the input. */ + int atEnd) /* If non-zero, add at end of queue; otherwise + * add at head of queue. */ +{ + Channel *chanPtr; /* The real IO channel. */ + ChannelState *statePtr; /* State of actual channel. */ + ChannelBuffer *bufPtr; /* Buffer to contain the data. */ + int flags; + + chanPtr = (Channel *) chan; + statePtr = chanPtr->state; + + /* + * This operation should occur at the top of a channel stack. + */ + + chanPtr = statePtr->topChanPtr; + + /* + * CheckChannelErrors clears too many flag bits in this one case. + */ + + flags = statePtr->flags; + if (CheckChannelErrors(statePtr, TCL_READABLE) != 0) { + len = -1; + goto done; + } + statePtr->flags = flags; + + /* + * Clear the EOF flags, and clear the BLOCKED bit. + */ + + if (GotFlag(statePtr, CHANNEL_EOF)) { + statePtr->inputEncodingFlags |= TCL_ENCODING_START; + } + ResetFlag(statePtr, + CHANNEL_BLOCKED | CHANNEL_STICKY_EOF | CHANNEL_EOF | INPUT_SAW_CR); + statePtr->inputEncodingFlags &= ~TCL_ENCODING_END; + + bufPtr = AllocChannelBuffer(len); + memcpy(InsertPoint(bufPtr), str, (size_t) len); + bufPtr->nextAdded += len; + + if (statePtr->inQueueHead == NULL) { + bufPtr->nextPtr = NULL; + statePtr->inQueueHead = bufPtr; + statePtr->inQueueTail = bufPtr; + } else if (atEnd) { + bufPtr->nextPtr = NULL; + statePtr->inQueueTail->nextPtr = bufPtr; + statePtr->inQueueTail = bufPtr; + } else { + bufPtr->nextPtr = statePtr->inQueueHead; + statePtr->inQueueHead = bufPtr; + } + + /* + * Update the notifier state so we don't block while there is still data + * in the buffers. + */ + + done: + UpdateInterest(chanPtr); + return len; +} + +/* + *---------------------------------------------------------------------- + * + * Tcl_Flush -- + * + * Flushes output data on a channel. + * + * Results: + * A standard Tcl result. + * + * Side effects: + * May flush output queued on this channel. + * + *---------------------------------------------------------------------- + */ + +int +Tcl_Flush( + Tcl_Channel chan) /* The Channel to flush. */ +{ + int result; /* Of calling FlushChannel. */ + Channel *chanPtr = (Channel *) chan; + /* The actual channel. */ + ChannelState *statePtr = chanPtr->state; + /* State of actual channel. */ + + /* + * This operation should occur at the top of a channel stack. + */ + + chanPtr = statePtr->topChanPtr; + + if (CheckChannelErrors(statePtr, TCL_WRITABLE) != 0) { + return -1; + } + + result = FlushChannel(NULL, chanPtr, 0); + if (result != 0) { + return TCL_ERROR; + } + + return TCL_OK; +} + +/* + *---------------------------------------------------------------------- + * + * DiscardInputQueued -- + * + * Discards any input read from the channel but not yet consumed by Tcl + * reading commands. + * + * Results: + * None. + * + * Side effects: + * May discard input from the channel. If discardLastBuffer is zero, + * leaves one buffer in place for back-filling. + * + *---------------------------------------------------------------------- + */ + +static void +DiscardInputQueued( + ChannelState *statePtr, /* Channel on which to discard the queued + * input. */ + int discardSavedBuffers) /* If non-zero, discard all buffers including + * last one. */ +{ + ChannelBuffer *bufPtr, *nxtPtr; + /* Loop variables. */ + + bufPtr = statePtr->inQueueHead; + statePtr->inQueueHead = NULL; + statePtr->inQueueTail = NULL; + for (; bufPtr != NULL; bufPtr = nxtPtr) { + nxtPtr = bufPtr->nextPtr; + RecycleBuffer(statePtr, bufPtr, discardSavedBuffers); + } + + /* + * If discardSavedBuffers is nonzero, must also discard any previously + * saved buffer in the saveInBufPtr field. + */ + + if (discardSavedBuffers && statePtr->saveInBufPtr != NULL) { + ReleaseChannelBuffer(statePtr->saveInBufPtr); + statePtr->saveInBufPtr = NULL; + } +} + +/* + *--------------------------------------------------------------------------- + * + * GetInput -- + * + * Reads input data from a device into a channel buffer. + * + * IMPORTANT! This routine is only called on a chanPtr argument + * that is the top channel of a stack! + * + * Results: + * The return value is the Posix error code if an error occurred while + * reading from the file, or 0 otherwise. + * + * Side effects: + * Reads from the underlying device. + * + *--------------------------------------------------------------------------- + */ + +static int +GetInput( + Channel *chanPtr) /* Channel to read input from. */ +{ + int toRead; /* How much to read? */ + int result; /* Of calling driver. */ + int nread; /* How much was read from channel? */ + ChannelBuffer *bufPtr; /* New buffer to add to input queue. */ + ChannelState *statePtr = chanPtr->state; + /* State info for channel */ + + /* + * Verify that all callers know better than to call us when + * it's recorded that the next char waiting to be read is the + * eofchar. + */ + + assert( !GotFlag(statePtr, CHANNEL_STICKY_EOF) ); + + /* + * Prevent reading from a dead channel -- a channel that has been closed + * but not yet deallocated, which can happen if the exit handler for + * channel cleanup has run but the channel is still registered in some + * interpreter. + */ + + if (CheckForDeadChannel(NULL, statePtr)) { + return EINVAL; + } + + /* + * WARNING: There was once a comment here claiming that it was + * a bad idea to make another call to the inputproc of a channel + * driver when EOF has already been detected on the channel. Through + * much of Tcl's history, this warning was then completely negated + * by having all (most?) read paths clear the EOF setting before + * reaching here. So we had a guard that was never triggered. + * + * Don't be tempted to restore the guard. Even if EOF is set on + * the channel, continue through and call the inputproc again. This + * is the way to enable the ability to [read] again beyond the EOF, + * which seems a strange thing to do, but for which use cases exist + * [Tcl Bug 5adc350683] and which may even be essential for channels + * representing things like ttys or other devices where the stream + * might take the logical form of a series of 'files' separated by + * an EOF condition. + */ + + /* + * First check for more buffers in the pushback area of the topmost + * channel in the stack and use them. They can be the result of a + * transformation which went away without reading all the information + * placed in the area when it was stacked. + */ + + if (chanPtr->inQueueHead != NULL) { + + /* TODO: Tests to cover this. */ + assert(statePtr->inQueueHead == NULL); + + statePtr->inQueueHead = chanPtr->inQueueHead; + statePtr->inQueueTail = chanPtr->inQueueTail; + chanPtr->inQueueHead = NULL; + chanPtr->inQueueTail = NULL; + return 0; + } + + /* + * Nothing in the pushback area, fall back to the usual handling (driver, + * etc.) + */ + + /* + * See if we can fill an existing buffer. If we can, read only as much as + * will fit in it. Otherwise allocate a new buffer, add it to the input + * queue and attempt to fill it to the max. + */ + + bufPtr = statePtr->inQueueTail; + + if ((bufPtr == NULL) || IsBufferFull(bufPtr)) { + bufPtr = statePtr->saveInBufPtr; + statePtr->saveInBufPtr = NULL; + + /* + * Check the actual buffersize against the requested buffersize. + * Saved buffers of the wrong size are squashed. This is done + * to honor dynamic changes of the buffersize made by the user. + * TODO: Tests to cover this. + */ + + if ((bufPtr != NULL) + && (bufPtr->bufLength - BUFFER_PADDING != statePtr->bufSize)) { + ReleaseChannelBuffer(bufPtr); + bufPtr = NULL; + } + + if (bufPtr == NULL) { + bufPtr = AllocChannelBuffer(statePtr->bufSize); + } + bufPtr->nextPtr = NULL; + + toRead = SpaceLeft(bufPtr); + assert(toRead == statePtr->bufSize); + + if (statePtr->inQueueTail == NULL) { + statePtr->inQueueHead = bufPtr; + } else { + statePtr->inQueueTail->nextPtr = bufPtr; + } + statePtr->inQueueTail = bufPtr; + } else { + toRead = SpaceLeft(bufPtr); + } + + PreserveChannelBuffer(bufPtr); + nread = ChanRead(chanPtr, InsertPoint(bufPtr), toRead); + + if (nread < 0) { + result = Tcl_GetErrno(); + } else { + result = 0; + bufPtr->nextAdded += nread; + } + + ReleaseChannelBuffer(bufPtr); + return result; +} + +/* + *---------------------------------------------------------------------- + * + * Tcl_Seek -- + * + * Implements seeking on Tcl Channels. This is a public function so that + * other C facilities may be implemented on top of it. + * + * Results: + * The new access point or -1 on error. If error, use Tcl_GetErrno() to + * retrieve the POSIX error code for the error that occurred. + * + * Side effects: + * May flush output on the channel. May discard queued input. + * + *---------------------------------------------------------------------- + */ + +Tcl_WideInt +Tcl_Seek( + Tcl_Channel chan, /* The channel on which to seek. */ + Tcl_WideInt offset, /* Offset to seek to. */ + int mode) /* Relative to which location to seek? */ +{ + Channel *chanPtr = (Channel *) chan; + /* The real IO channel. */ + ChannelState *statePtr = chanPtr->state; + /* State info for channel */ + int inputBuffered, outputBuffered; + /* # bytes held in buffers. */ + int result; /* Of device driver operations. */ + Tcl_WideInt curPos; /* Position on the device. */ + int wasAsync; /* Was the channel nonblocking before the seek + * operation? If so, must restore to + * non-blocking mode after the seek. */ + + if (CheckChannelErrors(statePtr, TCL_WRITABLE | TCL_READABLE) != 0) { + return Tcl_LongAsWide(-1); + } + + /* + * Disallow seek on dead channels - channels that have been closed but not + * yet been deallocated. Such channels can be found if the exit handler + * for channel cleanup has run but the channel is still registered in an + * interpreter. + */ + + if (CheckForDeadChannel(NULL, statePtr)) { + return Tcl_LongAsWide(-1); + } + + /* + * This operation should occur at the top of a channel stack. + */ + + chanPtr = statePtr->topChanPtr; + + /* + * Disallow seek on channels whose type does not have a seek procedure + * defined. This means that the channel does not support seeking. + */ + + if (chanPtr->typePtr->seekProc == NULL) { + Tcl_SetErrno(EINVAL); + return Tcl_LongAsWide(-1); + } + + /* + * Compute how much input and output is buffered. If both input and output + * is buffered, cannot compute the current position. + */ + + inputBuffered = Tcl_InputBuffered(chan); + outputBuffered = Tcl_OutputBuffered(chan); + + if ((inputBuffered != 0) && (outputBuffered != 0)) { + Tcl_SetErrno(EFAULT); + return Tcl_LongAsWide(-1); + } + + /* + * If we are seeking relative to the current position, compute the + * corrected offset taking into account the amount of unread input. + */ + + if (mode == SEEK_CUR) { + offset -= inputBuffered; + } + + /* + * Discard any queued input - this input should not be read after the + * seek. + */ + + DiscardInputQueued(statePtr, 0); + + /* + * Reset EOF and BLOCKED flags. We invalidate them by moving the access + * point. Also clear CR related flags. + */ + + if (GotFlag(statePtr, CHANNEL_EOF)) { + statePtr->inputEncodingFlags |= TCL_ENCODING_START; + } + ResetFlag(statePtr, CHANNEL_EOF | CHANNEL_STICKY_EOF | CHANNEL_BLOCKED | + INPUT_SAW_CR); + statePtr->inputEncodingFlags &= ~TCL_ENCODING_END; + + /* + * If the channel is in asynchronous output mode, switch it back to + * synchronous mode and cancel any async flush that may be scheduled. + * After the flush, the channel will be put back into asynchronous output + * mode. + */ + + wasAsync = 0; + if (GotFlag(statePtr, CHANNEL_NONBLOCKING)) { + wasAsync = 1; + result = StackSetBlockMode(chanPtr, TCL_MODE_BLOCKING); + if (result != 0) { + return Tcl_LongAsWide(-1); + } + ResetFlag(statePtr, CHANNEL_NONBLOCKING); + if (GotFlag(statePtr, BG_FLUSH_SCHEDULED)) { + ResetFlag(statePtr, BG_FLUSH_SCHEDULED); + } + } + + /* + * If the flush fails we cannot recover the original position. In that + * case the seek is not attempted because we do not know where the access + * position is - instead we return the error. FlushChannel has already + * called Tcl_SetErrno() to report the error upwards. If the flush + * succeeds we do the seek also. + */ + + if (FlushChannel(NULL, chanPtr, 0) != 0) { + curPos = -1; + } else { + /* + * Now seek to the new position in the channel as requested by the + * caller. + */ + + curPos = ChanSeek(chanPtr, offset, mode, &result); + if (curPos == Tcl_LongAsWide(-1)) { + Tcl_SetErrno(result); + } + } + + /* + * Restore to nonblocking mode if that was the previous behavior. + * + * NOTE: Even if there was an async flush active we do not restore it now + * because we already flushed all the queued output, above. + */ + + if (wasAsync) { + SetFlag(statePtr, CHANNEL_NONBLOCKING); + result = StackSetBlockMode(chanPtr, TCL_MODE_NONBLOCKING); + if (result != 0) { + return Tcl_LongAsWide(-1); + } + } + + return curPos; +} + +/* + *---------------------------------------------------------------------- + * + * Tcl_Tell -- + * + * Returns the position of the next character to be read/written on this + * channel. + * + * Results: + * A nonnegative integer on success, -1 on failure. If failed, use + * Tcl_GetErrno() to retrieve the POSIX error code for the error that + * occurred. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +Tcl_WideInt +Tcl_Tell( + Tcl_Channel chan) /* The channel to return pos for. */ +{ + Channel *chanPtr = (Channel *) chan; + /* The real IO channel. */ + ChannelState *statePtr = chanPtr->state; + /* State info for channel */ + int inputBuffered, outputBuffered; + /* # bytes held in buffers. */ + int result; /* Of calling device driver. */ + Tcl_WideInt curPos; /* Position on device. */ + + if (CheckChannelErrors(statePtr, TCL_WRITABLE | TCL_READABLE) != 0) { + return Tcl_LongAsWide(-1); + } + + /* + * Disallow tell on dead channels -- channels that have been closed but + * not yet been deallocated. Such channels can be found if the exit + * handler for channel cleanup has run but the channel is still registered + * in an interpreter. + */ + + if (CheckForDeadChannel(NULL, statePtr)) { + return Tcl_LongAsWide(-1); + } + + /* + * This operation should occur at the top of a channel stack. + */ + + chanPtr = statePtr->topChanPtr; + + /* + * Disallow tell on channels whose type does not have a seek procedure + * defined. This means that the channel does not support seeking. + */ + + if (chanPtr->typePtr->seekProc == NULL) { + Tcl_SetErrno(EINVAL); + return Tcl_LongAsWide(-1); + } + + /* + * Compute how much input and output is buffered. If both input and output + * is buffered, cannot compute the current position. + */ + + inputBuffered = Tcl_InputBuffered(chan); + outputBuffered = Tcl_OutputBuffered(chan); + + /* + * Get the current position in the device and compute the position where + * the next character will be read or written. Note that we prefer the + * wideSeekProc if that is available and non-NULL... + */ + + curPos = ChanSeek(chanPtr, Tcl_LongAsWide(0), SEEK_CUR, &result); + if (curPos == Tcl_LongAsWide(-1)) { + Tcl_SetErrno(result); + return Tcl_LongAsWide(-1); + } + + if (inputBuffered != 0) { + return curPos - inputBuffered; + } + return curPos + outputBuffered; +} + +/* + *--------------------------------------------------------------------------- + * + * Tcl_SeekOld, Tcl_TellOld -- + * + * Backward-compatibility versions of the seek/tell interface that do not + * support 64-bit offsets. This interface is not documented or expected + * to be supported indefinitely. + * + * Results: + * As for Tcl_Seek and Tcl_Tell respectively, except truncated to + * whatever value will fit in an 'int'. + * + * Side effects: + * As for Tcl_Seek and Tcl_Tell respectively. + * + *--------------------------------------------------------------------------- + */ + +int +Tcl_SeekOld( + Tcl_Channel chan, /* The channel on which to seek. */ + int offset, /* Offset to seek to. */ + int mode) /* Relative to which location to seek? */ +{ + Tcl_WideInt wOffset, wResult; + + wOffset = Tcl_LongAsWide((long) offset); + wResult = Tcl_Seek(chan, wOffset, mode); + return (int) Tcl_WideAsLong(wResult); +} + +int +Tcl_TellOld( + Tcl_Channel chan) /* The channel to return pos for. */ +{ + Tcl_WideInt wResult = Tcl_Tell(chan); + + return (int) Tcl_WideAsLong(wResult); +} + +/* + *--------------------------------------------------------------------------- + * + * Tcl_TruncateChannel -- + * + * Truncate a channel to the given length. + * + * Results: + * TCL_OK on success, TCL_ERROR if the operation failed (e.g. is not + * supported by the type of channel, or the underlying OS operation + * failed in some way). + * + * Side effects: + * Seeks the channel to the current location. Sets errno on OS error. + * + *--------------------------------------------------------------------------- + */ + +int +Tcl_TruncateChannel( + Tcl_Channel chan, /* Channel to truncate. */ + Tcl_WideInt length) /* Length to truncate it to. */ +{ + Channel *chanPtr = (Channel *) chan; + Tcl_DriverTruncateProc *truncateProc = + Tcl_ChannelTruncateProc(chanPtr->typePtr); + int result; + + if (truncateProc == NULL) { + /* + * Feature not supported and it's not emulatable. Pretend it's + * returned an EINVAL, a very generic error! + */ + + Tcl_SetErrno(EINVAL); + return TCL_ERROR; + } + + if (!GotFlag(chanPtr->state, TCL_WRITABLE)) { + /* + * We require that the file was opened of writing. Do that check now + * so that we only flush if we think we're going to succeed. + */ + + Tcl_SetErrno(EINVAL); + return TCL_ERROR; + } + + /* + * Seek first to force a total flush of all pending buffers and ditch any + * pre-read input data. + */ + + WillWrite(chanPtr); + + if (WillRead(chanPtr) < 0) { + return TCL_ERROR; + } + + /* + * We're all flushed to disk now and we also don't have any unfortunate + * input baggage around either; can truncate with impunity. + */ + + result = truncateProc(chanPtr->instanceData, length); + if (result != 0) { + Tcl_SetErrno(result); + return TCL_ERROR; + } + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * CheckChannelErrors -- + * + * See if the channel is in an ready state and can perform the desired + * operation. + * + * Results: + * The return value is 0 if the channel is OK, otherwise the return value + * is -1 and errno is set to indicate the error. + * + * Side effects: + * May clear the EOF and/or BLOCKED bits if reading from channel. + * + *--------------------------------------------------------------------------- + */ + +static int +CheckChannelErrors( + ChannelState *statePtr, /* Channel to check. */ + int flags) /* Test if channel supports desired operation: + * TCL_READABLE, TCL_WRITABLE. Also indicates + * Raw read or write for special close + * processing */ +{ + int direction = flags & (TCL_READABLE|TCL_WRITABLE); + + /* + * Check for unreported error. + */ + + if (statePtr->unreportedError != 0) { + Tcl_SetErrno(statePtr->unreportedError); + statePtr->unreportedError = 0; + + /* + * TIP #219, Tcl Channel Reflection API. + * Move a defered error message back into the channel bypass. + */ + + if (statePtr->chanMsg != NULL) { + TclDecrRefCount(statePtr->chanMsg); + } + statePtr->chanMsg = statePtr->unreportedMsg; + statePtr->unreportedMsg = NULL; + return -1; + } + + /* + * Only the raw read and write operations are allowed during close in + * order to drain data from stacked channels. + */ + + if (GotFlag(statePtr, CHANNEL_CLOSED) && !(flags & CHANNEL_RAW_MODE)) { + Tcl_SetErrno(EACCES); + return -1; + } + + /* + * Fail if the channel is not opened for desired operation. + */ + + if ((statePtr->flags & direction) == 0) { + Tcl_SetErrno(EACCES); + return -1; + } + + /* + * Fail if the channel is in the middle of a background copy. + * + * Don't do this tests for raw channels here or else the chaining in the + * transformation drivers will fail with 'file busy' error instead of + * retrieving and transforming the data to copy. + */ + + if (BUSY_STATE(statePtr, flags) && ((flags & CHANNEL_RAW_MODE) == 0)) { + Tcl_SetErrno(EBUSY); + return -1; + } + + if (direction == TCL_READABLE) { + ResetFlag(statePtr, CHANNEL_NEED_MORE_DATA); + } + + return 0; +} + +/* + *---------------------------------------------------------------------- + * + * Tcl_Eof -- + * + * Returns 1 if the channel is at EOF, 0 otherwise. + * + * Results: + * 1 or 0, always. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +int +Tcl_Eof( + Tcl_Channel chan) /* Does this channel have EOF? */ +{ + ChannelState *statePtr = ((Channel *) chan)->state; + /* State of real channel structure. */ + + return GotFlag(statePtr, CHANNEL_EOF) ? 1 : 0; +} + +/* + *---------------------------------------------------------------------- + * + * Tcl_InputBlocked -- + * + * Returns 1 if input is blocked on this channel, 0 otherwise. + * + * Results: + * 0 or 1, always. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +int +Tcl_InputBlocked( + Tcl_Channel chan) /* Is this channel blocked? */ +{ + ChannelState *statePtr = ((Channel *) chan)->state; + /* State of real channel structure. */ + + return GotFlag(statePtr, CHANNEL_BLOCKED) ? 1 : 0; +} + +/* + *---------------------------------------------------------------------- + * + * Tcl_InputBuffered -- + * + * Returns the number of bytes of input currently buffered in the common + * internal buffer of a channel. + * + * Results: + * The number of input bytes buffered, or zero if the channel is not open + * for reading. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +int +Tcl_InputBuffered( + Tcl_Channel chan) /* The channel to query. */ +{ + ChannelState *statePtr = ((Channel *) chan)->state; + /* State of real channel structure. */ + ChannelBuffer *bufPtr; + int bytesBuffered; + + for (bytesBuffered = 0, bufPtr = statePtr->inQueueHead; bufPtr != NULL; + bufPtr = bufPtr->nextPtr) { + bytesBuffered += BytesLeft(bufPtr); + } + + /* + * Don't forget the bytes in the topmost pushback area. + */ + + for (bufPtr = statePtr->topChanPtr->inQueueHead; bufPtr != NULL; + bufPtr = bufPtr->nextPtr) { + bytesBuffered += BytesLeft(bufPtr); + } + + return bytesBuffered; +} + +/* + *---------------------------------------------------------------------- + * + * Tcl_OutputBuffered -- + * + * Returns the number of bytes of output currently buffered in the common + * internal buffer of a channel. + * + * Results: + * The number of output bytes buffered, or zero if the channel is not open + * for writing. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +int +Tcl_OutputBuffered( + Tcl_Channel chan) /* The channel to query. */ +{ + ChannelState *statePtr = ((Channel *) chan)->state; + /* State of real channel structure. */ + ChannelBuffer *bufPtr; + int bytesBuffered; + + for (bytesBuffered = 0, bufPtr = statePtr->outQueueHead; bufPtr != NULL; + bufPtr = bufPtr->nextPtr) { + bytesBuffered += BytesLeft(bufPtr); + } + if (statePtr->curOutPtr != NULL) { + register ChannelBuffer *curOutPtr = statePtr->curOutPtr; + + if (IsBufferReady(curOutPtr)) { + bytesBuffered += BytesLeft(curOutPtr); + } + } + + return bytesBuffered; +} + +/* + *---------------------------------------------------------------------- + * + * Tcl_ChannelBuffered -- + * + * Returns the number of bytes of input currently buffered in the + * internal buffer (push back area) of a channel. + * + * Results: + * The number of input bytes buffered, or zero if the channel is not open + * for reading. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +int +Tcl_ChannelBuffered( + Tcl_Channel chan) /* The channel to query. */ +{ + Channel *chanPtr = (Channel *) chan; + /* Real channel structure. */ + ChannelBuffer *bufPtr; + int bytesBuffered = 0; + + for (bufPtr = chanPtr->inQueueHead; bufPtr != NULL; + bufPtr = bufPtr->nextPtr) { + bytesBuffered += BytesLeft(bufPtr); + } + + return bytesBuffered; +} + +/* + *---------------------------------------------------------------------- + * + * Tcl_SetChannelBufferSize -- + * + * Sets the size of buffers to allocate to store input or output in the + * channel. The size must be between 1 byte and 1 MByte. + * + * Results: + * None. + * + * Side effects: + * Sets the size of buffers subsequently allocated for this channel. + * + *---------------------------------------------------------------------- + */ + +void +Tcl_SetChannelBufferSize( + Tcl_Channel chan, /* The channel whose buffer size to set. */ + int sz) /* The size to set. */ +{ + ChannelState *statePtr; /* State of real channel structure. */ + + /* + * Clip the buffer size to force it into the [1,1M] range + */ + + if (sz < 1) { + sz = 1; + } else if (sz > MAX_CHANNEL_BUFFER_SIZE) { + sz = MAX_CHANNEL_BUFFER_SIZE; + } + + statePtr = ((Channel *) chan)->state; + + if (statePtr->bufSize == sz) { + return; + } + statePtr->bufSize = sz; + + /* + * If bufsize changes, need to get rid of old utility buffer. + */ + + if (statePtr->saveInBufPtr != NULL) { + RecycleBuffer(statePtr, statePtr->saveInBufPtr, 1); + statePtr->saveInBufPtr = NULL; + } + if ((statePtr->inQueueHead != NULL) + && (statePtr->inQueueHead->nextPtr == NULL) + && IsBufferEmpty(statePtr->inQueueHead)) { + RecycleBuffer(statePtr, statePtr->inQueueHead, 1); + statePtr->inQueueHead = NULL; + statePtr->inQueueTail = NULL; + } +} + +/* + *---------------------------------------------------------------------- + * + * Tcl_GetChannelBufferSize -- + * + * Retrieves the size of buffers to allocate for this channel. + * + * Results: + * The size. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +int +Tcl_GetChannelBufferSize( + Tcl_Channel chan) /* The channel for which to find the buffer + * size. */ +{ + ChannelState *statePtr = ((Channel *) chan)->state; + /* State of real channel structure. */ + + return statePtr->bufSize; +} + +/* + *---------------------------------------------------------------------- + * + * Tcl_BadChannelOption -- + * + * This procedure generates a "bad option" error message in an (optional) + * interpreter. It is used by channel drivers when a invalid Set/Get + * option is requested. Its purpose is to concatenate the generic options + * list to the specific ones and factorize the generic options error + * message string. + * + * Results: + * TCL_ERROR. + * + * Side effects: + + * An error message is generated in interp's result object to indicate + * that a command was invoked with the a bad option. The message has the + * form: + * bad option "blah": should be one of + * <...generic options...>+<...specific options...> + * "blah" is the optionName argument and "<specific options>" is a space + * separated list of specific option words. The function takes good care + * of inserting minus signs before each option, commas after, and an "or" + * before the last option. + * + *---------------------------------------------------------------------- + */ + +int +Tcl_BadChannelOption( + Tcl_Interp *interp, /* Current interpreter (can be NULL).*/ + const char *optionName, /* 'bad option' name */ + const char *optionList) /* Specific options list to append to the + * standard generic options. Can be NULL for + * generic options only. */ +{ + if (interp != NULL) { + const char *genericopt = + "blocking buffering buffersize encoding eofchar translation"; + const char **argv; + int argc, i; + Tcl_DString ds; + Tcl_Obj *errObj; + + Tcl_DStringInit(&ds); + Tcl_DStringAppend(&ds, genericopt, -1); + if (optionList && (*optionList)) { + TclDStringAppendLiteral(&ds, " "); + Tcl_DStringAppend(&ds, optionList, -1); + } + if (Tcl_SplitList(interp, Tcl_DStringValue(&ds), + &argc, &argv) != TCL_OK) { + Tcl_Panic("malformed option list in channel driver"); + } + Tcl_ResetResult(interp); + errObj = Tcl_ObjPrintf("bad option \"%s\": should be one of ", + optionName); + argc--; + for (i = 0; i < argc; i++) { + Tcl_AppendPrintfToObj(errObj, "-%s, ", argv[i]); + } + Tcl_AppendPrintfToObj(errObj, "or -%s", argv[i]); + Tcl_SetObjResult(interp, errObj); + Tcl_DStringFree(&ds); + ckfree(argv); + } + Tcl_SetErrno(EINVAL); + return TCL_ERROR; +} + +/* + *---------------------------------------------------------------------- + * + * Tcl_GetChannelOption -- + * + * Gets a mode associated with an IO channel. If the optionName arg is + * non NULL, retrieves the value of that option. If the optionName arg is + * NULL, retrieves a list of alternating option names and values for the + * given channel. + * + * Results: + * A standard Tcl result. Also sets the supplied DString to the string + * value of the option(s) returned. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +int +Tcl_GetChannelOption( + Tcl_Interp *interp, /* For error reporting - can be NULL. */ + Tcl_Channel chan, /* Channel on which to get option. */ + const char *optionName, /* Option to get. */ + Tcl_DString *dsPtr) /* Where to store value(s). */ +{ + size_t len; /* Length of optionName string. */ + char optionVal[128]; /* Buffer for sprintf. */ + Channel *chanPtr = (Channel *) chan; + ChannelState *statePtr = chanPtr->state; + /* State info for channel */ + int flags; + + /* + * Disallow options on dead channels -- channels that have been closed but + * not yet been deallocated. Such channels can be found if the exit + * handler for channel cleanup has run but the channel is still registered + * in an interpreter. + */ + + if (CheckForDeadChannel(interp, statePtr)) { + return TCL_ERROR; + } + + /* + * This operation should occur at the top of a channel stack. + */ + + chanPtr = statePtr->topChanPtr; + + /* + * If we are in the middle of a background copy, use the saved flags. + */ + + if (statePtr->csPtrR) { + flags = statePtr->csPtrR->readFlags; + } else if (statePtr->csPtrW) { + flags = statePtr->csPtrW->writeFlags; + } else { + flags = statePtr->flags; + } + + /* + * If the optionName is NULL it means that we want a list of all options + * and values. + */ + + if (optionName == NULL) { + len = 0; + } else { + len = strlen(optionName); + } + + if (len == 0 || HaveOpt(2, "-blocking")) { + if (len == 0) { + Tcl_DStringAppendElement(dsPtr, "-blocking"); + } + Tcl_DStringAppendElement(dsPtr, + (flags & CHANNEL_NONBLOCKING) ? "0" : "1"); + if (len > 0) { + return TCL_OK; + } + } + if (len == 0 || HaveOpt(7, "-buffering")) { + if (len == 0) { + Tcl_DStringAppendElement(dsPtr, "-buffering"); + } + if (flags & CHANNEL_LINEBUFFERED) { + Tcl_DStringAppendElement(dsPtr, "line"); + } else if (flags & CHANNEL_UNBUFFERED) { + Tcl_DStringAppendElement(dsPtr, "none"); + } else { + Tcl_DStringAppendElement(dsPtr, "full"); + } + if (len > 0) { + return TCL_OK; + } + } + if (len == 0 || HaveOpt(7, "-buffersize")) { + if (len == 0) { + Tcl_DStringAppendElement(dsPtr, "-buffersize"); + } + TclFormatInt(optionVal, statePtr->bufSize); + Tcl_DStringAppendElement(dsPtr, optionVal); + if (len > 0) { + return TCL_OK; + } + } + if (len == 0 || HaveOpt(2, "-encoding")) { + if (len == 0) { + Tcl_DStringAppendElement(dsPtr, "-encoding"); + } + if (statePtr->encoding == NULL) { + Tcl_DStringAppendElement(dsPtr, "binary"); + } else { + Tcl_DStringAppendElement(dsPtr, + Tcl_GetEncodingName(statePtr->encoding)); + } + if (len > 0) { + return TCL_OK; + } + } + if (len == 0 || HaveOpt(2, "-eofchar")) { + if (len == 0) { + Tcl_DStringAppendElement(dsPtr, "-eofchar"); + } + if (((flags & (TCL_READABLE|TCL_WRITABLE)) == + (TCL_READABLE|TCL_WRITABLE)) && (len == 0)) { + Tcl_DStringStartSublist(dsPtr); + } + if (flags & TCL_READABLE) { + if (statePtr->inEofChar == 0) { + Tcl_DStringAppendElement(dsPtr, ""); + } else { + char buf[4]; + + sprintf(buf, "%c", statePtr->inEofChar); + Tcl_DStringAppendElement(dsPtr, buf); + } + } + if (flags & TCL_WRITABLE) { + if (statePtr->outEofChar == 0) { + Tcl_DStringAppendElement(dsPtr, ""); + } else { + char buf[4]; + + sprintf(buf, "%c", statePtr->outEofChar); + Tcl_DStringAppendElement(dsPtr, buf); + } + } + if (!(flags & (TCL_READABLE|TCL_WRITABLE))) { + /* + * Not readable or writable (e.g. server socket) + */ + + Tcl_DStringAppendElement(dsPtr, ""); + } + if (((flags & (TCL_READABLE|TCL_WRITABLE)) == + (TCL_READABLE|TCL_WRITABLE)) && (len == 0)) { + Tcl_DStringEndSublist(dsPtr); + } + if (len > 0) { + return TCL_OK; + } + } + if (len == 0 || HaveOpt(1, "-translation")) { + if (len == 0) { + Tcl_DStringAppendElement(dsPtr, "-translation"); + } + if (((flags & (TCL_READABLE|TCL_WRITABLE)) == + (TCL_READABLE|TCL_WRITABLE)) && (len == 0)) { + Tcl_DStringStartSublist(dsPtr); + } + if (flags & TCL_READABLE) { + if (statePtr->inputTranslation == TCL_TRANSLATE_AUTO) { + Tcl_DStringAppendElement(dsPtr, "auto"); + } else if (statePtr->inputTranslation == TCL_TRANSLATE_CR) { + Tcl_DStringAppendElement(dsPtr, "cr"); + } else if (statePtr->inputTranslation == TCL_TRANSLATE_CRLF) { + Tcl_DStringAppendElement(dsPtr, "crlf"); + } else { + Tcl_DStringAppendElement(dsPtr, "lf"); + } + } + if (flags & TCL_WRITABLE) { + if (statePtr->outputTranslation == TCL_TRANSLATE_AUTO) { + Tcl_DStringAppendElement(dsPtr, "auto"); + } else if (statePtr->outputTranslation == TCL_TRANSLATE_CR) { + Tcl_DStringAppendElement(dsPtr, "cr"); + } else if (statePtr->outputTranslation == TCL_TRANSLATE_CRLF) { + Tcl_DStringAppendElement(dsPtr, "crlf"); + } else { + Tcl_DStringAppendElement(dsPtr, "lf"); + } + } + if (!(flags & (TCL_READABLE|TCL_WRITABLE))) { + /* + * Not readable or writable (e.g. server socket) + */ + + Tcl_DStringAppendElement(dsPtr, "auto"); + } + if (((flags & (TCL_READABLE|TCL_WRITABLE)) == + (TCL_READABLE|TCL_WRITABLE)) && (len == 0)) { + Tcl_DStringEndSublist(dsPtr); + } + if (len > 0) { + return TCL_OK; + } + } + + if (chanPtr->typePtr->getOptionProc != NULL) { + /* + * Let the driver specific handle additional options and result code + * and message. + */ + + return chanPtr->typePtr->getOptionProc(chanPtr->instanceData, interp, + optionName, dsPtr); + } else { + /* + * No driver specific options case. + */ + + if (len == 0) { + return TCL_OK; + } + return Tcl_BadChannelOption(interp, optionName, NULL); + } +} + +/* + *--------------------------------------------------------------------------- + * + * Tcl_SetChannelOption -- + * + * Sets an option on a channel. + * + * Results: + * A standard Tcl result. On error, sets interp's result object if + * interp is not NULL. + * + * Side effects: + * May modify an option on a device. + * + *--------------------------------------------------------------------------- + */ + +int +Tcl_SetChannelOption( + Tcl_Interp *interp, /* For error reporting - can be NULL. */ + Tcl_Channel chan, /* Channel on which to set mode. */ + const char *optionName, /* Which option to set? */ + const char *newValue) /* New value for option. */ +{ + Channel *chanPtr = (Channel *) chan; + /* The real IO channel. */ + ChannelState *statePtr = chanPtr->state; + /* State info for channel */ + size_t len; /* Length of optionName string. */ + int argc; + const char **argv; + + /* + * If the channel is in the middle of a background copy, fail. + */ + + if (statePtr->csPtrR || statePtr->csPtrW) { + if (interp) { + Tcl_SetObjResult(interp, Tcl_NewStringObj( + "unable to set channel options: background copy in" + " progress", -1)); + } + return TCL_ERROR; + } + + /* + * Disallow options on dead channels -- channels that have been closed but + * not yet been deallocated. Such channels can be found if the exit + * handler for channel cleanup has run but the channel is still registered + * in an interpreter. + */ + + if (CheckForDeadChannel(NULL, statePtr)) { + return TCL_ERROR; + } + + /* + * This operation should occur at the top of a channel stack. + */ + + chanPtr = statePtr->topChanPtr; + + len = strlen(optionName); + + if (HaveOpt(2, "-blocking")) { + int newMode; + + if (Tcl_GetBoolean(interp, newValue, &newMode) == TCL_ERROR) { + return TCL_ERROR; + } + if (newMode) { + newMode = TCL_MODE_BLOCKING; + } else { + newMode = TCL_MODE_NONBLOCKING; + } + return SetBlockMode(interp, chanPtr, newMode); + } else if (HaveOpt(7, "-buffering")) { + len = strlen(newValue); + if ((newValue[0] == 'f') && (strncmp(newValue, "full", len) == 0)) { + ResetFlag(statePtr, CHANNEL_UNBUFFERED | CHANNEL_LINEBUFFERED); + } else if ((newValue[0] == 'l') && + (strncmp(newValue, "line", len) == 0)) { + ResetFlag(statePtr, CHANNEL_UNBUFFERED); + SetFlag(statePtr, CHANNEL_LINEBUFFERED); + } else if ((newValue[0] == 'n') && + (strncmp(newValue, "none", len) == 0)) { + ResetFlag(statePtr, CHANNEL_LINEBUFFERED); + SetFlag(statePtr, CHANNEL_UNBUFFERED); + } else if (interp) { + Tcl_SetObjResult(interp, Tcl_NewStringObj( + "bad value for -buffering: must be one of" + " full, line, or none", -1)); + return TCL_ERROR; + } + return TCL_OK; + } else if (HaveOpt(7, "-buffersize")) { + int newBufferSize; + + if (Tcl_GetInt(interp, newValue, &newBufferSize) == TCL_ERROR) { + return TCL_ERROR; + } + Tcl_SetChannelBufferSize(chan, newBufferSize); + return TCL_OK; + } else if (HaveOpt(2, "-encoding")) { + Tcl_Encoding encoding; + + if ((newValue[0] == '\0') || (strcmp(newValue, "binary") == 0)) { + encoding = NULL; + } else { + encoding = Tcl_GetEncoding(interp, newValue); + if (encoding == NULL) { + return TCL_ERROR; + } + } + + /* + * When the channel has an escape sequence driven encoding such as + * iso2022, the terminated escape sequence must write to the buffer. + */ + + if ((statePtr->encoding != NULL) + && !(statePtr->outputEncodingFlags & TCL_ENCODING_START) + && (CheckChannelErrors(statePtr, TCL_WRITABLE) == 0)) { + statePtr->outputEncodingFlags |= TCL_ENCODING_END; + WriteChars(chanPtr, "", 0); + } + Tcl_FreeEncoding(statePtr->encoding); + statePtr->encoding = encoding; + statePtr->inputEncodingState = NULL; + statePtr->inputEncodingFlags = TCL_ENCODING_START; + statePtr->outputEncodingState = NULL; + statePtr->outputEncodingFlags = TCL_ENCODING_START; + ResetFlag(statePtr, CHANNEL_NEED_MORE_DATA); + UpdateInterest(chanPtr); + return TCL_OK; + } else if (HaveOpt(2, "-eofchar")) { + if (Tcl_SplitList(interp, newValue, &argc, &argv) == TCL_ERROR) { + return TCL_ERROR; + } + if (argc == 0) { + statePtr->inEofChar = 0; + statePtr->outEofChar = 0; + } else if (argc == 1 || argc == 2) { + int outIndex = (argc - 1); + int inValue = (int) argv[0][0]; + int outValue = (int) argv[outIndex][0]; + + if (inValue & 0x80 || outValue & 0x80) { + if (interp) { + Tcl_SetObjResult(interp, Tcl_NewStringObj( + "bad value for -eofchar: must be non-NUL ASCII" + " character", -1)); + } + ckfree(argv); + return TCL_ERROR; + } + if (GotFlag(statePtr, TCL_READABLE)) { + statePtr->inEofChar = inValue; + } + if (GotFlag(statePtr, TCL_WRITABLE)) { + statePtr->outEofChar = outValue; + } + } else { + if (interp) { + Tcl_SetObjResult(interp, Tcl_NewStringObj( + "bad value for -eofchar: should be a list of zero," + " one, or two elements", -1)); + } + ckfree(argv); + return TCL_ERROR; + } + if (argv != NULL) { + ckfree(argv); + } + + /* + * [Bug 930851] Reset EOF and BLOCKED flags. Changing the character + * which signals eof can transform a current eof condition into a 'go + * ahead'. Ditto for blocked. + */ + + if (GotFlag(statePtr, CHANNEL_EOF)) { + statePtr->inputEncodingFlags |= TCL_ENCODING_START; + } + ResetFlag(statePtr, CHANNEL_EOF|CHANNEL_STICKY_EOF|CHANNEL_BLOCKED); + statePtr->inputEncodingFlags &= ~TCL_ENCODING_END; + return TCL_OK; + } else if (HaveOpt(1, "-translation")) { + const char *readMode, *writeMode; + + if (Tcl_SplitList(interp, newValue, &argc, &argv) == TCL_ERROR) { + return TCL_ERROR; + } + + if (argc == 1) { + readMode = GotFlag(statePtr, TCL_READABLE) ? argv[0] : NULL; + writeMode = GotFlag(statePtr, TCL_WRITABLE) ? argv[0] : NULL; + } else if (argc == 2) { + readMode = GotFlag(statePtr, TCL_READABLE) ? argv[0] : NULL; + writeMode = GotFlag(statePtr, TCL_WRITABLE) ? argv[1] : NULL; + } else { + if (interp) { + Tcl_SetObjResult(interp, Tcl_NewStringObj( + "bad value for -translation: must be a one or two" + " element list", -1)); + } + ckfree(argv); + return TCL_ERROR; + } + + if (readMode) { + TclEolTranslation translation; + + if (*readMode == '\0') { + translation = statePtr->inputTranslation; + } else if (strcmp(readMode, "auto") == 0) { + translation = TCL_TRANSLATE_AUTO; + } else if (strcmp(readMode, "binary") == 0) { + translation = TCL_TRANSLATE_LF; + statePtr->inEofChar = 0; + Tcl_FreeEncoding(statePtr->encoding); + statePtr->encoding = NULL; + } else if (strcmp(readMode, "lf") == 0) { + translation = TCL_TRANSLATE_LF; + } else if (strcmp(readMode, "cr") == 0) { + translation = TCL_TRANSLATE_CR; + } else if (strcmp(readMode, "crlf") == 0) { + translation = TCL_TRANSLATE_CRLF; + } else if (strcmp(readMode, "platform") == 0) { + translation = TCL_PLATFORM_TRANSLATION; + } else { + if (interp) { + Tcl_SetObjResult(interp, Tcl_NewStringObj( + "bad value for -translation: must be one of " + "auto, binary, cr, lf, crlf, or platform", -1)); + } + ckfree(argv); + return TCL_ERROR; + } + + /* + * Reset the EOL flags since we need to look at any buffered data + * to see if the new translation mode allows us to complete the + * line. + */ + + if (translation != statePtr->inputTranslation) { + statePtr->inputTranslation = translation; + ResetFlag(statePtr, INPUT_SAW_CR | CHANNEL_NEED_MORE_DATA); + UpdateInterest(chanPtr); + } + } + if (writeMode) { + if (*writeMode == '\0') { + /* Do nothing. */ + } else if (strcmp(writeMode, "auto") == 0) { + /* + * This is a hack to get TCP sockets to produce output in CRLF + * mode if they are being set into AUTO mode. A better + * solution for achieving this effect will be coded later. + */ + + if (strcmp(Tcl_ChannelName(chanPtr->typePtr), "tcp") == 0) { + statePtr->outputTranslation = TCL_TRANSLATE_CRLF; + } else { + statePtr->outputTranslation = TCL_PLATFORM_TRANSLATION; + } + } else if (strcmp(writeMode, "binary") == 0) { + statePtr->outEofChar = 0; + statePtr->outputTranslation = TCL_TRANSLATE_LF; + Tcl_FreeEncoding(statePtr->encoding); + statePtr->encoding = NULL; + } else if (strcmp(writeMode, "lf") == 0) { + statePtr->outputTranslation = TCL_TRANSLATE_LF; + } else if (strcmp(writeMode, "cr") == 0) { + statePtr->outputTranslation = TCL_TRANSLATE_CR; + } else if (strcmp(writeMode, "crlf") == 0) { + statePtr->outputTranslation = TCL_TRANSLATE_CRLF; + } else if (strcmp(writeMode, "platform") == 0) { + statePtr->outputTranslation = TCL_PLATFORM_TRANSLATION; + } else { + if (interp) { + Tcl_SetObjResult(interp, Tcl_NewStringObj( + "bad value for -translation: must be one of " + "auto, binary, cr, lf, crlf, or platform", -1)); + } + ckfree(argv); + return TCL_ERROR; + } + } + ckfree(argv); + return TCL_OK; + } else if (chanPtr->typePtr->setOptionProc != NULL) { + return chanPtr->typePtr->setOptionProc(chanPtr->instanceData, interp, + optionName, newValue); + } else { + return Tcl_BadChannelOption(interp, optionName, NULL); + } + + return TCL_OK; +} + +/* + *---------------------------------------------------------------------- + * + * CleanupChannelHandlers -- + * + * Removes channel handlers that refer to the supplied interpreter, so + * that if the actual channel is not closed now, these handlers will not + * run on subsequent events on the channel. This would be erroneous, + * because the interpreter no longer has a reference to this channel. + * + * Results: + * None. + * + * Side effects: + * Removes channel handlers. + * + *---------------------------------------------------------------------- + */ + +static void +CleanupChannelHandlers( + Tcl_Interp *interp, + Channel *chanPtr) +{ + ChannelState *statePtr = chanPtr->state; + /* State info for channel */ + EventScriptRecord *sPtr, *prevPtr, *nextPtr; + + /* + * Remove fileevent records on this channel that refer to the given + * interpreter. + */ + + for (sPtr = statePtr->scriptRecordPtr, prevPtr = NULL; + sPtr != NULL; sPtr = nextPtr) { + nextPtr = sPtr->nextPtr; + if (sPtr->interp == interp) { + if (prevPtr == NULL) { + statePtr->scriptRecordPtr = nextPtr; + } else { + prevPtr->nextPtr = nextPtr; + } + + Tcl_DeleteChannelHandler((Tcl_Channel) chanPtr, + TclChannelEventScriptInvoker, sPtr); + + TclDecrRefCount(sPtr->scriptPtr); + ckfree(sPtr); + } else { + prevPtr = sPtr; + } + } +} + +/* + *---------------------------------------------------------------------- + * + * Tcl_NotifyChannel -- + * + * This procedure is called by a channel driver when a driver detects an + * event on a channel. This procedure is responsible for actually + * handling the event by invoking any channel handler callbacks. + * + * Results: + * None. + * + * Side effects: + * Whatever the channel handler callback procedure does. + * + *---------------------------------------------------------------------- + */ + +void +Tcl_NotifyChannel( + Tcl_Channel channel, /* Channel that detected an event. */ + int mask) /* OR'ed combination of TCL_READABLE, + * TCL_WRITABLE, or TCL_EXCEPTION: indicates + * which events were detected. */ +{ + Channel *chanPtr = (Channel *) channel; + ChannelState *statePtr = chanPtr->state; + /* State info for channel */ + ChannelHandler *chPtr; + ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey); + NextChannelHandler nh; + Channel *upChanPtr; + const Tcl_ChannelType *upTypePtr; + + /* + * In contrast to the other API functions this procedure walks towards the + * top of a stack and not down from it. + * + * The channel calling this procedure is the one who generated the event, + * and thus does not take part in handling it. IOW, its HandlerProc is not + * called, instead we begin with the channel above it. + * + * This behaviour also allows the transformation channels to generate + * their own events and pass them upward. + */ + + while (mask && (chanPtr->upChanPtr != NULL)) { + Tcl_DriverHandlerProc *upHandlerProc; + + upChanPtr = chanPtr->upChanPtr; + upTypePtr = upChanPtr->typePtr; + upHandlerProc = Tcl_ChannelHandlerProc(upTypePtr); + if (upHandlerProc != NULL) { + mask = upHandlerProc(upChanPtr->instanceData, mask); + } + + /* + * ELSE: Ignore transformations which are unable to handle the event + * coming from below. Assume that they don't change the mask and pass + * it on. + */ + + chanPtr = upChanPtr; + } + + channel = (Tcl_Channel) chanPtr; + + /* + * Here we have either reached the top of the stack or the mask is empty. + * We break out of the procedure if it is the latter. + */ + + if (!mask) { + return; + } + + /* + * We are now above the topmost channel in a stack and have events left. + * Now call the channel handlers as usual. + * + * Preserve the channel struct in case the script closes it. + */ + + TclChannelPreserve((Tcl_Channel)channel); + Tcl_Preserve(statePtr); + + /* + * If we are flushing in the background, be sure to call FlushChannel for + * writable events. Note that we have to discard the writable event so we + * don't call any write handlers before the flush is complete. + */ + + if (GotFlag(statePtr, BG_FLUSH_SCHEDULED) && (mask & TCL_WRITABLE)) { + if (0 == FlushChannel(NULL, chanPtr, 1)) { + mask &= ~TCL_WRITABLE; + } + } + + /* + * Add this invocation to the list of recursive invocations of + * Tcl_NotifyChannel. + */ + + nh.nextHandlerPtr = NULL; + nh.nestedHandlerPtr = tsdPtr->nestedHandlerPtr; + tsdPtr->nestedHandlerPtr = &nh; + + for (chPtr = statePtr->chPtr; chPtr != NULL; ) { + /* + * If this channel handler is interested in any of the events that + * have occurred on the channel, invoke its procedure. + */ + + if ((chPtr->mask & mask) != 0) { + nh.nextHandlerPtr = chPtr->nextPtr; + chPtr->proc(chPtr->clientData, chPtr->mask & mask); + chPtr = nh.nextHandlerPtr; + } else { + chPtr = chPtr->nextPtr; + } + } + + /* + * Update the notifier interest, since it may have changed after invoking + * event handlers. Skip that if the channel was deleted in the call to the + * channel handler. + */ + + if (chanPtr->typePtr != NULL) { + /* + * TODO: This call may not be needed. If a handler induced a + * change in interest, that handler should have made its own + * UpdateInterest() call, one would think. + */ + UpdateInterest(chanPtr); + } + + Tcl_Release(statePtr); + TclChannelRelease(channel); + + tsdPtr->nestedHandlerPtr = nh.nestedHandlerPtr; +} + +/* + *---------------------------------------------------------------------- + * + * UpdateInterest -- + * + * Arrange for the notifier to call us back at appropriate times based on + * the current state of the channel. + * + * Results: + * None. + * + * Side effects: + * May schedule a timer or driver handler. + * + *---------------------------------------------------------------------- + */ + +static void +UpdateInterest( + Channel *chanPtr) /* Channel to update. */ +{ + ChannelState *statePtr = chanPtr->state; + /* State info for channel */ + int mask = statePtr->interestMask; + + if (chanPtr->typePtr == NULL) { + /* Do not update interest on a closed channel */ + return; + } + + /* + * If there are flushed buffers waiting to be written, then we need to + * watch for the channel to become writable. + */ + + if (GotFlag(statePtr, BG_FLUSH_SCHEDULED)) { + mask |= TCL_WRITABLE; + } + + /* + * If there is data in the input queue, and we aren't waiting for more + * data, then we need to schedule a timer so we don't block in the + * notifier. Also, cancel the read interest so we don't get duplicate + * events. + */ + + if (mask & TCL_READABLE) { + if (!GotFlag(statePtr, CHANNEL_NEED_MORE_DATA) + && (statePtr->inQueueHead != NULL) + && IsBufferReady(statePtr->inQueueHead)) { + mask &= ~TCL_READABLE; + + /* + * Andreas Kupries, April 11, 2003 + * + * Some operating systems (Solaris 2.6 and higher (but not Solaris + * 2.5, go figure)) generate READABLE and EXCEPTION events when + * select()'ing [*] on a plain file, even if EOF was not yet + * reached. This is a problem in the following situation: + * + * - An extension asks to get both READABLE and EXCEPTION events. + * - It reads data into a buffer smaller than the buffer used by + * Tcl itself. + * - It does not process all events in the event queue, but only + * one, at least in some situations. + * + * In that case we can get into a situation where + * + * - Tcl drops READABLE here, because it has data in its own + * buffers waiting to be read by the extension. + * - A READABLE event is syntesized via timer. + * - The OS still reports the EXCEPTION condition on the file. + * - And the extension gets the EXCPTION event first, and handles + * this as EOF. + * + * End result ==> Premature end of reading from a file. + * + * The concrete example is 'Expect', and its [expect] command + * (and at the C-level, deep in the bowels of Expect, + * 'exp_get_next_event'. See marker 'SunOS' for commentary in + * that function too). + * + * [*] As the Tcl notifier does. See also for marker 'SunOS' in + * file 'exp_event.c' of Expect. + * + * Our solution here is to drop the interest in the EXCEPTION + * events too. This compiles on all platforms, and also passes the + * testsuite on all of them. + */ + + mask &= ~TCL_EXCEPTION; + + if (!statePtr->timer) { + statePtr->timer = Tcl_CreateTimerHandler(SYNTHETIC_EVENT_TIME, + ChannelTimerProc, chanPtr); + } + } + } + ChanWatch(chanPtr, mask); +} + +/* + *---------------------------------------------------------------------- + * + * ChannelTimerProc -- + * + * Timer handler scheduled by UpdateInterest to monitor the channel + * buffers until they are empty. + * + * Results: + * None. + * + * Side effects: + * May invoke channel handlers. + * + *---------------------------------------------------------------------- + */ + +static void +ChannelTimerProc( + ClientData clientData) +{ + Channel *chanPtr = clientData; + ChannelState *statePtr = chanPtr->state; + /* State info for channel */ + + if (!GotFlag(statePtr, CHANNEL_NEED_MORE_DATA) + && (statePtr->interestMask & TCL_READABLE) + && (statePtr->inQueueHead != NULL) + && IsBufferReady(statePtr->inQueueHead)) { + /* + * Restart the timer in case a channel handler reenters the event loop + * before UpdateInterest gets called by Tcl_NotifyChannel. + */ + + statePtr->timer = Tcl_CreateTimerHandler(SYNTHETIC_EVENT_TIME, + ChannelTimerProc,chanPtr); + Tcl_Preserve(statePtr); + Tcl_NotifyChannel((Tcl_Channel) chanPtr, TCL_READABLE); + Tcl_Release(statePtr); + } else { + statePtr->timer = NULL; + UpdateInterest(chanPtr); + } +} + +/* + *---------------------------------------------------------------------- + * + * Tcl_CreateChannelHandler -- + * + * Arrange for a given procedure to be invoked whenever the channel + * indicated by the chanPtr arg becomes readable or writable. + * + * Results: + * None. + * + * Side effects: + * From now on, whenever the I/O channel given by chanPtr becomes ready + * in the way indicated by mask, proc will be invoked. See the manual + * entry for details on the calling sequence to proc. If there is already + * an event handler for chan, proc and clientData, then the mask will be + * updated. + * + *---------------------------------------------------------------------- + */ + +void +Tcl_CreateChannelHandler( + Tcl_Channel chan, /* The channel to create the handler for. */ + int mask, /* OR'ed combination of TCL_READABLE, + * TCL_WRITABLE, and TCL_EXCEPTION: indicates + * conditions under which proc should be + * called. Use 0 to disable a registered + * handler. */ + Tcl_ChannelProc *proc, /* Procedure to call for each selected + * event. */ + ClientData clientData) /* Arbitrary data to pass to proc. */ +{ + ChannelHandler *chPtr; + Channel *chanPtr = (Channel *) chan; + ChannelState *statePtr = chanPtr->state; + /* State info for channel */ + + /* + * Check whether this channel handler is not already registered. If it is + * not, create a new record, else reuse existing record (smash current + * values). + */ + + for (chPtr = statePtr->chPtr; chPtr != NULL; chPtr = chPtr->nextPtr) { + if ((chPtr->chanPtr == chanPtr) && (chPtr->proc == proc) && + (chPtr->clientData == clientData)) { + break; + } + } + if (chPtr == NULL) { + chPtr = ckalloc(sizeof(ChannelHandler)); + chPtr->mask = 0; + chPtr->proc = proc; + chPtr->clientData = clientData; + chPtr->chanPtr = chanPtr; + chPtr->nextPtr = statePtr->chPtr; + statePtr->chPtr = chPtr; + } + + /* + * The remainder of the initialization below is done regardless of whether + * or not this is a new record or a modification of an old one. + */ + + chPtr->mask = mask; + + /* + * Recompute the interest mask for the channel - this call may actually be + * disabling an existing handler. + */ + + statePtr->interestMask = 0; + for (chPtr = statePtr->chPtr; chPtr != NULL; chPtr = chPtr->nextPtr) { + statePtr->interestMask |= chPtr->mask; + } + + UpdateInterest(statePtr->topChanPtr); +} + +/* + *---------------------------------------------------------------------- + * + * Tcl_DeleteChannelHandler -- + * + * Cancel a previously arranged callback arrangement for an IO channel. + * + * Results: + * None. + * + * Side effects: + * If a callback was previously registered for this chan, proc and + * clientData, it is removed and the callback will no longer be called + * when the channel becomes ready for IO. + * + *---------------------------------------------------------------------- + */ + +void +Tcl_DeleteChannelHandler( + Tcl_Channel chan, /* The channel for which to remove the + * callback. */ + Tcl_ChannelProc *proc, /* The procedure in the callback to delete. */ + ClientData clientData) /* The client data in the callback to + * delete. */ +{ + ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey); + ChannelHandler *chPtr, *prevChPtr; + Channel *chanPtr = (Channel *) chan; + ChannelState *statePtr = chanPtr->state; + /* State info for channel */ + NextChannelHandler *nhPtr; + + /* + * Find the entry and the previous one in the list. + */ + + for (prevChPtr = NULL, chPtr = statePtr->chPtr; chPtr != NULL; + chPtr = chPtr->nextPtr) { + if ((chPtr->chanPtr == chanPtr) && (chPtr->clientData == clientData) + && (chPtr->proc == proc)) { + break; + } + prevChPtr = chPtr; + } + + /* + * If not found, return without doing anything. + */ + + if (chPtr == NULL) { + return; + } + + /* + * If Tcl_NotifyChannel is about to process this handler, tell it to + * process the next one instead - we are going to delete *this* one. + */ + + for (nhPtr = tsdPtr->nestedHandlerPtr; nhPtr != NULL; + nhPtr = nhPtr->nestedHandlerPtr) { + if (nhPtr->nextHandlerPtr == chPtr) { + nhPtr->nextHandlerPtr = chPtr->nextPtr; + } + } + + /* + * Splice it out of the list of channel handlers. + */ + + if (prevChPtr == NULL) { + statePtr->chPtr = chPtr->nextPtr; + } else { + prevChPtr->nextPtr = chPtr->nextPtr; + } + ckfree(chPtr); + + /* + * Recompute the interest list for the channel, so that infinite loops + * will not result if Tcl_DeleteChannelHandler is called inside an event. + */ + + statePtr->interestMask = 0; + for (chPtr = statePtr->chPtr; chPtr != NULL; chPtr = chPtr->nextPtr) { + statePtr->interestMask |= chPtr->mask; + } + + UpdateInterest(statePtr->topChanPtr); +} + +/* + *---------------------------------------------------------------------- + * + * DeleteScriptRecord -- + * + * Delete a script record for this combination of channel, interp and + * mask. + * + * Results: + * None. + * + * Side effects: + * Deletes a script record and cancels a channel event handler. + * + *---------------------------------------------------------------------- + */ + +static void +DeleteScriptRecord( + Tcl_Interp *interp, /* Interpreter in which script was to be + * executed. */ + Channel *chanPtr, /* The channel for which to delete the script + * record (if any). */ + int mask) /* Events in mask must exactly match mask of + * script to delete. */ +{ + ChannelState *statePtr = chanPtr->state; + /* State info for channel */ + EventScriptRecord *esPtr, *prevEsPtr; + + for (esPtr = statePtr->scriptRecordPtr, prevEsPtr = NULL; esPtr != NULL; + prevEsPtr = esPtr, esPtr = esPtr->nextPtr) { + if ((esPtr->interp == interp) && (esPtr->mask == mask)) { + if (esPtr == statePtr->scriptRecordPtr) { + statePtr->scriptRecordPtr = esPtr->nextPtr; + } else { + CLANG_ASSERT(prevEsPtr); + prevEsPtr->nextPtr = esPtr->nextPtr; + } + + Tcl_DeleteChannelHandler((Tcl_Channel) chanPtr, + TclChannelEventScriptInvoker, esPtr); + + TclDecrRefCount(esPtr->scriptPtr); + ckfree(esPtr); + + break; + } + } +} + +/* + *---------------------------------------------------------------------- + * + * CreateScriptRecord -- + * + * Creates a record to store a script to be executed when a specific + * event fires on a specific channel. + * + * Results: + * None. + * + * Side effects: + * Causes the script to be stored for later execution. + * + *---------------------------------------------------------------------- + */ + +static void +CreateScriptRecord( + Tcl_Interp *interp, /* Interpreter in which to execute the stored + * script. */ + Channel *chanPtr, /* Channel for which script is to be stored */ + int mask, /* Set of events for which script will be + * invoked. */ + Tcl_Obj *scriptPtr) /* Pointer to script object. */ +{ + ChannelState *statePtr = chanPtr->state; + /* State info for channel */ + EventScriptRecord *esPtr; + int makeCH; + + for (esPtr=statePtr->scriptRecordPtr; esPtr!=NULL; esPtr=esPtr->nextPtr) { + if ((esPtr->interp == interp) && (esPtr->mask == mask)) { + TclDecrRefCount(esPtr->scriptPtr); + esPtr->scriptPtr = NULL; + break; + } + } + + makeCH = (esPtr == NULL); + + if (makeCH) { + esPtr = ckalloc(sizeof(EventScriptRecord)); + } + + /* + * Initialize the structure before calling Tcl_CreateChannelHandler, + * because a reflected channel calling 'chan postevent' aka + * 'Tcl_NotifyChannel' in its 'watch'Proc will invoke + * 'TclChannelEventScriptInvoker' immediately, and we do not wish it to + * see uninitialized memory and crash. See [Bug 2918110]. + */ + + esPtr->chanPtr = chanPtr; + esPtr->interp = interp; + esPtr->mask = mask; + Tcl_IncrRefCount(scriptPtr); + esPtr->scriptPtr = scriptPtr; + + if (makeCH) { + esPtr->nextPtr = statePtr->scriptRecordPtr; + statePtr->scriptRecordPtr = esPtr; + + Tcl_CreateChannelHandler((Tcl_Channel) chanPtr, mask, + TclChannelEventScriptInvoker, esPtr); + } +} + +/* + *---------------------------------------------------------------------- + * + * TclChannelEventScriptInvoker -- + * + * Invokes a script scheduled by "fileevent" for when the channel becomes + * ready for IO. This function is invoked by the channel handler which + * was created by the Tcl "fileevent" command. + * + * Results: + * None. + * + * Side effects: + * Whatever the script does. + * + *---------------------------------------------------------------------- + */ + +void +TclChannelEventScriptInvoker( + ClientData clientData, /* The script+interp record. */ + int mask) /* Not used. */ +{ + Tcl_Interp *interp; /* Interpreter in which to eval the script. */ + Channel *chanPtr; /* The channel for which this handler is + * registered. */ + EventScriptRecord *esPtr; /* The event script + interpreter to eval it + * in. */ + int result; /* Result of call to eval script. */ + + esPtr = clientData; + chanPtr = esPtr->chanPtr; + mask = esPtr->mask; + interp = esPtr->interp; + + /* + * We must preserve the interpreter so we can report errors on it later. + * Note that we do not need to preserve the channel because that is done + * by Tcl_NotifyChannel before calling channel handlers. + */ + + Tcl_Preserve(interp); + TclChannelPreserve((Tcl_Channel)chanPtr); + result = Tcl_EvalObjEx(interp, esPtr->scriptPtr, TCL_EVAL_GLOBAL); + + /* + * On error, cause a background error and remove the channel handler and + * the script record. + * + * NOTE: Must delete channel handler before causing the background error + * because the background error may want to reinstall the handler. + */ + + if (result != TCL_OK) { + if (chanPtr->typePtr != NULL) { + DeleteScriptRecord(interp, chanPtr, mask); + } + Tcl_BackgroundException(interp, result); + } + TclChannelRelease((Tcl_Channel)chanPtr); + Tcl_Release(interp); +} + +/* + *---------------------------------------------------------------------- + * + * Tcl_FileEventObjCmd -- + * + * This procedure implements the "fileevent" Tcl command. See the user + * documentation for details on what it does. This command is based on + * the Tk command "fileevent" which in turn is based on work contributed + * by Mark Diekhans. + * + * Results: + * A standard Tcl result. + * + * Side effects: + * May create a channel handler for the specified channel. + * + *---------------------------------------------------------------------- + */ + + /* ARGSUSED */ +int +Tcl_FileEventObjCmd( + ClientData clientData, /* Not used. */ + Tcl_Interp *interp, /* Interpreter in which the channel for which + * to create the handler is found. */ + int objc, /* Number of arguments. */ + Tcl_Obj *const objv[]) /* Argument objects. */ +{ + Channel *chanPtr; /* The channel to create the handler for. */ + ChannelState *statePtr; /* State info for channel */ + Tcl_Channel chan; /* The opaque type for the channel. */ + const char *chanName; + int modeIndex; /* Index of mode argument. */ + int mask; + static const char *const modeOptions[] = {"readable", "writable", NULL}; + static const int maskArray[] = {TCL_READABLE, TCL_WRITABLE}; + + if ((objc != 3) && (objc != 4)) { + Tcl_WrongNumArgs(interp, 1, objv, "channelId event ?script?"); + return TCL_ERROR; + } + if (Tcl_GetIndexFromObj(interp, objv[2], modeOptions, "event name", 0, + &modeIndex) != TCL_OK) { + return TCL_ERROR; + } + mask = maskArray[modeIndex]; + + chanName = TclGetString(objv[1]); + chan = Tcl_GetChannel(interp, chanName, NULL); + if (chan == NULL) { + return TCL_ERROR; + } + chanPtr = (Channel *) chan; + statePtr = chanPtr->state; + if ((statePtr->flags & mask) == 0) { + Tcl_SetObjResult(interp, Tcl_ObjPrintf("channel is not %s", + (mask == TCL_READABLE) ? "readable" : "writable")); + return TCL_ERROR; + } + + /* + * If we are supposed to return the script, do so. + */ + + if (objc == 3) { + EventScriptRecord *esPtr; + + for (esPtr = statePtr->scriptRecordPtr; esPtr != NULL; + esPtr = esPtr->nextPtr) { + if ((esPtr->interp == interp) && (esPtr->mask == mask)) { + Tcl_SetObjResult(interp, esPtr->scriptPtr); + break; + } + } + return TCL_OK; + } + + /* + * If we are supposed to delete a stored script, do so. + */ + + if (*(TclGetString(objv[3])) == '\0') { + DeleteScriptRecord(interp, chanPtr, mask); + return TCL_OK; + } + + /* + * Make the script record that will link between the event and the script + * to invoke. This also creates a channel event handler which will + * evaluate the script in the supplied interpreter. + */ + + CreateScriptRecord(interp, chanPtr, mask, objv[3]); + + return TCL_OK; +} + +/* + *---------------------------------------------------------------------- + * + * ZeroTransferTimerProc -- + * + * Timer handler scheduled by TclCopyChannel so that -command is + * called asynchronously even when -size is 0. + * + * Results: + * None. + * + * Side effects: + * Calls CopyData for -command invocation. + * + *---------------------------------------------------------------------- + */ + +static void +ZeroTransferTimerProc( + ClientData clientData) +{ + /* calling CopyData with mask==0 still implies immediate invocation of the + * -command callback, and completion of the fcopy. + */ + CopyData(clientData, 0); +} + +/* + *---------------------------------------------------------------------- + * + * TclCopyChannel -- + * + * This routine copies data from one channel to another, either + * synchronously or asynchronously. If a command script is supplied, the + * operation runs in the background. The script is invoked when the copy + * completes. Otherwise the function waits until the copy is completed + * before returning. + * + * Results: + * A standard Tcl result. + * + * Side effects: + * May schedule a background copy operation that causes both channels to + * be marked busy. + * + *---------------------------------------------------------------------- + */ + +int +TclCopyChannelOld( + Tcl_Interp *interp, /* Current interpreter. */ + Tcl_Channel inChan, /* Channel to read from. */ + Tcl_Channel outChan, /* Channel to write to. */ + int toRead, /* Amount of data to copy, or -1 for all. */ + Tcl_Obj *cmdPtr) /* Pointer to script to execute or NULL. */ +{ + return TclCopyChannel(interp, inChan, outChan, (Tcl_WideInt) toRead, + cmdPtr); +} + +int +TclCopyChannel( + Tcl_Interp *interp, /* Current interpreter. */ + Tcl_Channel inChan, /* Channel to read from. */ + Tcl_Channel outChan, /* Channel to write to. */ + Tcl_WideInt toRead, /* Amount of data to copy, or -1 for all. */ + Tcl_Obj *cmdPtr) /* Pointer to script to execute or NULL. */ +{ + Channel *inPtr = (Channel *) inChan; + Channel *outPtr = (Channel *) outChan; + ChannelState *inStatePtr, *outStatePtr; + int readFlags, writeFlags; + CopyState *csPtr; + int nonBlocking = (cmdPtr) ? CHANNEL_NONBLOCKING : 0; + int moveBytes; + + inStatePtr = inPtr->state; + outStatePtr = outPtr->state; + + if (BUSY_STATE(inStatePtr, TCL_READABLE)) { + if (interp) { + Tcl_SetObjResult(interp, Tcl_ObjPrintf( + "channel \"%s\" is busy", Tcl_GetChannelName(inChan))); + } + return TCL_ERROR; + } + if (BUSY_STATE(outStatePtr, TCL_WRITABLE)) { + if (interp) { + Tcl_SetObjResult(interp, Tcl_ObjPrintf( + "channel \"%s\" is busy", Tcl_GetChannelName(outChan))); + } + return TCL_ERROR; + } + + readFlags = inStatePtr->flags; + writeFlags = outStatePtr->flags; + + /* + * Set up the blocking mode appropriately. Background copies need + * non-blocking channels. Foreground copies need blocking channels. If + * there is an error, restore the old blocking mode. + */ + + if (nonBlocking != (readFlags & CHANNEL_NONBLOCKING)) { + if (SetBlockMode(interp, inPtr, nonBlocking ? + TCL_MODE_NONBLOCKING : TCL_MODE_BLOCKING) != TCL_OK) { + return TCL_ERROR; + } + } + if ((inPtr!=outPtr) && (nonBlocking!=(writeFlags&CHANNEL_NONBLOCKING)) && + (SetBlockMode(NULL, outPtr, nonBlocking ? + TCL_MODE_NONBLOCKING : TCL_MODE_BLOCKING) != TCL_OK) && + (nonBlocking != (readFlags & CHANNEL_NONBLOCKING))) { + SetBlockMode(NULL, inPtr, (readFlags & CHANNEL_NONBLOCKING) + ? TCL_MODE_NONBLOCKING : TCL_MODE_BLOCKING); + return TCL_ERROR; + } + + /* + * Make sure the output side is unbuffered. + */ + + outStatePtr->flags = (outStatePtr->flags & ~CHANNEL_LINEBUFFERED) + | CHANNEL_UNBUFFERED; + + /* + * Test for conditions where we know we can just move bytes from input + * channel to output channel with no transformation or even examination + * of the bytes themselves. + */ + + moveBytes = inStatePtr->inEofChar == '\0' /* No eofChar to stop input */ + && inStatePtr->inputTranslation == TCL_TRANSLATE_LF + && outStatePtr->outputTranslation == TCL_TRANSLATE_LF + && inStatePtr->encoding == outStatePtr->encoding; + + /* + * Allocate a new CopyState to maintain info about the current copy in + * progress. This structure will be deallocated when the copy is + * completed. + */ + + csPtr = ckalloc(sizeof(CopyState) + !moveBytes * inStatePtr->bufSize); + csPtr->bufSize = !moveBytes * inStatePtr->bufSize; + csPtr->readPtr = inPtr; + csPtr->writePtr = outPtr; + csPtr->readFlags = readFlags; + csPtr->writeFlags = writeFlags; + csPtr->toRead = toRead; + csPtr->total = (Tcl_WideInt) 0; + csPtr->interp = interp; + if (cmdPtr) { + Tcl_IncrRefCount(cmdPtr); + } + csPtr->cmdPtr = cmdPtr; + + inStatePtr->csPtrR = csPtr; + outStatePtr->csPtrW = csPtr; + + if (moveBytes) { + return MoveBytes(csPtr); + } + + /* + * Special handling of -size 0 async transfers, so that the -command is + * still called asynchronously. + */ + + if ((nonBlocking == CHANNEL_NONBLOCKING) && (toRead == 0)) { + Tcl_CreateTimerHandler(0, ZeroTransferTimerProc, csPtr); + return 0; + } + + /* + * Start copying data between the channels. + */ + + return CopyData(csPtr, 0); +} + +/* + *---------------------------------------------------------------------- + * + * CopyData -- + * + * This function implements the lowest level of the copying mechanism for + * TclCopyChannel. + * + * Results: + * Returns TCL_OK on success, else TCL_ERROR. + * + * Side effects: + * Moves data between channels, may create channel handlers. + * + *---------------------------------------------------------------------- + */ + +static void +MBCallback( + CopyState *csPtr, + Tcl_Obj *errObj) +{ + Tcl_Obj *cmdPtr = Tcl_DuplicateObj(csPtr->cmdPtr); + Tcl_WideInt total = csPtr->total; + Tcl_Interp *interp = csPtr->interp; + int code; + + Tcl_IncrRefCount(cmdPtr); + StopCopy(csPtr); + + /* TODO: What if cmdPtr is not a list?! */ + + Tcl_ListObjAppendElement(NULL, cmdPtr, Tcl_NewWideIntObj(total)); + if (errObj) { + Tcl_ListObjAppendElement(NULL, cmdPtr, errObj); + } + + Tcl_Preserve(interp); + code = Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL); + if (code != TCL_OK) { + Tcl_BackgroundException(interp, code); + } + Tcl_Release(interp); + TclDecrRefCount(cmdPtr); +} + +static void +MBError( + CopyState *csPtr, + int mask, + int errorCode) +{ + Tcl_Channel inChan = (Tcl_Channel) csPtr->readPtr; + Tcl_Channel outChan = (Tcl_Channel) csPtr->writePtr; + Tcl_Obj *errObj; + + Tcl_SetErrno(errorCode); + + errObj = Tcl_ObjPrintf( "error %sing \"%s\": %s", + (mask & TCL_READABLE) ? "read" : "writ", + Tcl_GetChannelName((mask & TCL_READABLE) ? inChan : outChan), + Tcl_PosixError(csPtr->interp)); + + if (csPtr->cmdPtr) { + MBCallback(csPtr, errObj); + } else { + Tcl_SetObjResult(csPtr->interp, errObj); + StopCopy(csPtr); + } +} + +static void +MBEvent( + ClientData clientData, + int mask) +{ + CopyState *csPtr = (CopyState *) clientData; + Tcl_Channel inChan = (Tcl_Channel) csPtr->readPtr; + Tcl_Channel outChan = (Tcl_Channel) csPtr->writePtr; + ChannelState *inStatePtr = csPtr->readPtr->state; + + if (mask & TCL_WRITABLE) { + Tcl_DeleteChannelHandler(inChan, MBEvent, csPtr); + Tcl_DeleteChannelHandler(outChan, MBEvent, csPtr); + switch (MBWrite(csPtr)) { + case TCL_OK: + MBCallback(csPtr, NULL); + break; + case TCL_CONTINUE: + Tcl_CreateChannelHandler(inChan, TCL_READABLE, MBEvent, csPtr); + break; + } + } else if (mask & TCL_READABLE) { + if (TCL_OK == MBRead(csPtr)) { + /* When at least one full buffer is present, stop reading. */ + if (IsBufferFull(inStatePtr->inQueueHead) + || !Tcl_InputBlocked(inChan)) { + Tcl_DeleteChannelHandler(inChan, MBEvent, csPtr); + } + + /* Successful read -- set up to write the bytes we read */ + Tcl_CreateChannelHandler(outChan, TCL_WRITABLE, MBEvent, csPtr); + } + } +} + +static int +MBRead( + CopyState *csPtr) +{ + ChannelState *inStatePtr = csPtr->readPtr->state; + ChannelBuffer *bufPtr = inStatePtr->inQueueHead; + int code; + + if (bufPtr && BytesLeft(bufPtr) > 0) { + return TCL_OK; + } + + code = GetInput(inStatePtr->topChanPtr); + if (code == 0 || GotFlag(inStatePtr, CHANNEL_BLOCKED)) { + return TCL_OK; + } else { + MBError(csPtr, TCL_READABLE, code); + return TCL_ERROR; + } +} + +static int +MBWrite( + CopyState *csPtr) +{ + ChannelState *inStatePtr = csPtr->readPtr->state; + ChannelState *outStatePtr = csPtr->writePtr->state; + ChannelBuffer *bufPtr = inStatePtr->inQueueHead; + ChannelBuffer *tail = NULL; + int code; + Tcl_WideInt inBytes = 0; + + /* Count up number of bytes waiting in the input queue */ + while (bufPtr) { + inBytes += BytesLeft(bufPtr); + tail = bufPtr; + if (csPtr->toRead != -1 && csPtr->toRead < inBytes) { + /* Queue has enough bytes to complete the copy */ + break; + } + bufPtr = bufPtr->nextPtr; + } + + if (bufPtr) { + /* Split the overflowing buffer in two */ + int extra = (int) (inBytes - csPtr->toRead); + /* Note that going with int for extra assumes that inBytes is not too + * much over toRead to require a wide itself. If that gets violated + * then the calculations involving extra must be made wide too. + * + * Noted with Win32/MSVC debug build treating the warning (possible of + * data in __int64 to int conversion) as error. + */ + + bufPtr = AllocChannelBuffer(extra); + + tail->nextAdded -= extra; + memcpy(InsertPoint(bufPtr), InsertPoint(tail), extra); + bufPtr->nextAdded += extra; + bufPtr->nextPtr = tail->nextPtr; + tail->nextPtr = NULL; + inBytes = csPtr->toRead; + } + + /* Update the byte counts */ + if (csPtr->toRead != -1) { + csPtr->toRead -= inBytes; + } + csPtr->total += inBytes; + + /* Move buffers from input to output channels */ + if (outStatePtr->outQueueTail) { + outStatePtr->outQueueTail->nextPtr = inStatePtr->inQueueHead; + } else { + outStatePtr->outQueueHead = inStatePtr->inQueueHead; + } + outStatePtr->outQueueTail = tail; + inStatePtr->inQueueHead = bufPtr; + if (inStatePtr->inQueueTail == tail) { + inStatePtr->inQueueTail = bufPtr; + } + if (bufPtr == NULL) { + inStatePtr->inQueueTail = NULL; + } + + code = FlushChannel(csPtr->interp, outStatePtr->topChanPtr, 0); + if (code) { + MBError(csPtr, TCL_WRITABLE, code); + return TCL_ERROR; + } + if (csPtr->toRead == 0 || GotFlag(inStatePtr, CHANNEL_EOF)) { + return TCL_OK; + } + return TCL_CONTINUE; +} + +static int +MoveBytes( + CopyState *csPtr) /* State of copy operation. */ +{ + ChannelState *outStatePtr = csPtr->writePtr->state; + ChannelBuffer *bufPtr = outStatePtr->curOutPtr; + int errorCode; + + if (bufPtr && BytesLeft(bufPtr)) { + /* If we start with unflushed bytes in the destination + * channel, flush them out of the way first. */ + + errorCode = FlushChannel(csPtr->interp, outStatePtr->topChanPtr, 0); + if (errorCode != 0) { + MBError(csPtr, TCL_WRITABLE, errorCode); + return TCL_ERROR; + } + } + + if (csPtr->cmdPtr) { + Tcl_Channel inChan = (Tcl_Channel) csPtr->readPtr; + Tcl_CreateChannelHandler(inChan, TCL_READABLE, MBEvent, csPtr); + return TCL_OK; + } + + while (1) { + int code; + + if (TCL_ERROR == MBRead(csPtr)) { + return TCL_ERROR; + } + code = MBWrite(csPtr); + if (code == TCL_OK) { + Tcl_SetObjResult(csPtr->interp, Tcl_NewWideIntObj(csPtr->total)); + StopCopy(csPtr); + return TCL_OK; + } + if (code == TCL_ERROR) { + return TCL_ERROR; + } + /* code == TCL_CONTINUE --> continue the loop */ + } + return TCL_OK; /* Silence compiler warnings */ +} + +static int +CopyData( + CopyState *csPtr, /* State of copy operation. */ + int mask) /* Current channel event flags. */ +{ + Tcl_Interp *interp; + Tcl_Obj *cmdPtr, *errObj = NULL, *bufObj = NULL, *msg = NULL; + Tcl_Channel inChan, outChan; + ChannelState *inStatePtr, *outStatePtr; + int result = TCL_OK, size, sizeb; + Tcl_WideInt total; + const char *buffer; + int inBinary, outBinary, sameEncoding; + /* Encoding control */ + int underflow; /* Input underflow */ + + inChan = (Tcl_Channel) csPtr->readPtr; + outChan = (Tcl_Channel) csPtr->writePtr; + inStatePtr = csPtr->readPtr->state; + outStatePtr = csPtr->writePtr->state; + interp = csPtr->interp; + cmdPtr = csPtr->cmdPtr; + + /* + * Copy the data the slow way, using the translation mechanism. + * + * Note: We have make sure that we use the topmost channel in a stack for + * the copying. The caller uses Tcl_GetChannel to access it, and thus gets + * the bottom of the stack. + */ + + inBinary = (inStatePtr->encoding == NULL); + outBinary = (outStatePtr->encoding == NULL); + sameEncoding = (inStatePtr->encoding == outStatePtr->encoding); + + if (!(inBinary || sameEncoding)) { + TclNewObj(bufObj); + Tcl_IncrRefCount(bufObj); + } + + while (csPtr->toRead != (Tcl_WideInt) 0) { + /* + * Check for unreported background errors. + */ + + Tcl_GetChannelError(inChan, &msg); + if ((inStatePtr->unreportedError != 0) || (msg != NULL)) { + Tcl_SetErrno(inStatePtr->unreportedError); + inStatePtr->unreportedError = 0; + goto readError; + } + Tcl_GetChannelError(outChan, &msg); + if ((outStatePtr->unreportedError != 0) || (msg != NULL)) { + Tcl_SetErrno(outStatePtr->unreportedError); + outStatePtr->unreportedError = 0; + goto writeError; + } + + if (cmdPtr && (mask == 0)) { + /* + * In async mode, we skip reading synchronously and fake an + * underflow instead to prime the readable fileevent. + */ + + size = 0; + underflow = 1; + } else { + /* + * Read up to bufSize bytes. + */ + + if ((csPtr->toRead == (Tcl_WideInt) -1) + || (csPtr->toRead > (Tcl_WideInt) csPtr->bufSize)) { + sizeb = csPtr->bufSize; + } else { + sizeb = (int) csPtr->toRead; + } + + if (inBinary || sameEncoding) { + size = DoRead(inStatePtr->topChanPtr, csPtr->buffer, sizeb, + !GotFlag(inStatePtr, CHANNEL_NONBLOCKING)); + } else { + size = DoReadChars(inStatePtr->topChanPtr, bufObj, sizeb, + 0 /* No append */); + } + underflow = (size >= 0) && (size < sizeb); /* Input underflow */ + } + + if (size < 0) { + readError: + if (interp) { + TclNewObj(errObj); + Tcl_AppendStringsToObj(errObj, "error reading \"", + Tcl_GetChannelName(inChan), "\": ", NULL); + if (msg != NULL) { + Tcl_AppendObjToObj(errObj, msg); + } else { + Tcl_AppendStringsToObj(errObj, Tcl_PosixError(interp), + NULL); + } + } + if (msg != NULL) { + Tcl_DecrRefCount(msg); + } + break; + } else if (underflow) { + /* + * We had an underflow on the read side. If we are at EOF, and not + * in the synchronous part of an asynchronous fcopy, then the + * copying is done, otherwise set up a channel handler to detect + * when the channel becomes readable again. + */ + + if ((size == 0) && Tcl_Eof(inChan) && !(cmdPtr && (mask == 0))) { + break; + } + if (cmdPtr && (!Tcl_Eof(inChan) || (mask == 0)) && + !(mask & TCL_READABLE)) { + if (mask & TCL_WRITABLE) { + Tcl_DeleteChannelHandler(outChan, CopyEventProc, csPtr); + } + Tcl_CreateChannelHandler(inChan, TCL_READABLE, CopyEventProc, + csPtr); + } + if (size == 0) { + if (!GotFlag(inStatePtr, CHANNEL_NONBLOCKING)) { + /* We allowed a short read. Keep trying. */ + continue; + } + if (bufObj != NULL) { + TclDecrRefCount(bufObj); + bufObj = NULL; + } + return TCL_OK; + } + } + + /* + * Now write the buffer out. + */ + + if (inBinary || sameEncoding) { + buffer = csPtr->buffer; + sizeb = size; + } else { + buffer = TclGetStringFromObj(bufObj, &sizeb); + } + + if (outBinary || sameEncoding) { + sizeb = WriteBytes(outStatePtr->topChanPtr, buffer, sizeb); + } else { + sizeb = WriteChars(outStatePtr->topChanPtr, buffer, sizeb); + } + + /* + * [Bug 2895565]. At this point 'size' still contains the number of + * bytes or characters which have been read. We keep this to later to + * update the totals and toRead information, see marker (UP) below. We + * must not overwrite it with 'sizeb', which is the number of written + * bytes or characters, and both EOL translation and encoding + * conversion may have changed this number unpredictably in relation + * to 'size' (It can be smaller or larger, in the latter case able to + * drive toRead below -1, causing infinite looping). Completely + * unsuitable for updating totals and toRead. + */ + + if (sizeb < 0) { + writeError: + if (interp) { + TclNewObj(errObj); + Tcl_AppendStringsToObj(errObj, "error writing \"", + Tcl_GetChannelName(outChan), "\": ", NULL); + if (msg != NULL) { + Tcl_AppendObjToObj(errObj, msg); + } else { + Tcl_AppendStringsToObj(errObj, Tcl_PosixError(interp), + NULL); + } + } + if (msg != NULL) { + Tcl_DecrRefCount(msg); + } + break; + } + + /* + * Update the current byte count. Do it now so the count is valid + * before a return or break takes us out of the loop. The invariant at + * the top of the loop should be that csPtr->toRead holds the number + * of bytes left to copy. + */ + + if (csPtr->toRead != -1) { + csPtr->toRead -= size; + } + csPtr->total += size; + + /* + * Break loop if EOF && (size>0) + */ + + if (Tcl_Eof(inChan)) { + break; + } + + /* + * Check to see if the write is happening in the background. If so, + * stop copying and wait for the channel to become writable again. + * After input underflow we already installed a readable handler + * therefore we don't need a writable handler. + */ + + if (!underflow && GotFlag(outStatePtr, BG_FLUSH_SCHEDULED)) { + if (!(mask & TCL_WRITABLE)) { + if (mask & TCL_READABLE) { + Tcl_DeleteChannelHandler(inChan, CopyEventProc, csPtr); + } + Tcl_CreateChannelHandler(outChan, TCL_WRITABLE, + CopyEventProc, csPtr); + } + if (bufObj != NULL) { + TclDecrRefCount(bufObj); + bufObj = NULL; + } + return TCL_OK; + } + + /* + * For background copies, we only do one buffer per invocation so we + * don't starve the rest of the system. + */ + + if (cmdPtr && (csPtr->toRead != 0)) { + /* + * The first time we enter this code, there won't be a channel + * handler established yet, so do it here. + */ + + if (mask == 0) { + Tcl_CreateChannelHandler(outChan, TCL_WRITABLE, CopyEventProc, + csPtr); + } + if (bufObj != NULL) { + TclDecrRefCount(bufObj); + bufObj = NULL; + } + return TCL_OK; + } + } /* while */ + + if (bufObj != NULL) { + TclDecrRefCount(bufObj); + bufObj = NULL; + } + + /* + * Make the callback or return the number of bytes transferred. The local + * total is used because StopCopy frees csPtr. + */ + + total = csPtr->total; + if (cmdPtr && interp) { + int code; + + /* + * Get a private copy of the command so we can mutate it by adding + * arguments. Note that StopCopy frees our saved reference to the + * original command obj. + */ + + cmdPtr = Tcl_DuplicateObj(cmdPtr); + Tcl_IncrRefCount(cmdPtr); + StopCopy(csPtr); + Tcl_Preserve(interp); + + Tcl_ListObjAppendElement(interp, cmdPtr, Tcl_NewWideIntObj(total)); + if (errObj) { + Tcl_ListObjAppendElement(interp, cmdPtr, errObj); + } + code = Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL); + if (code != TCL_OK) { + Tcl_BackgroundException(interp, code); + result = TCL_ERROR; + } + TclDecrRefCount(cmdPtr); + Tcl_Release(interp); + } else { + StopCopy(csPtr); + if (interp) { + if (errObj) { + Tcl_SetObjResult(interp, errObj); + result = TCL_ERROR; + } else { + Tcl_ResetResult(interp); + Tcl_SetObjResult(interp, Tcl_NewWideIntObj(total)); + } + } + } + return result; +} + +/* + *---------------------------------------------------------------------- + * + * DoRead -- + * + * Stores up to "bytesToRead" bytes in memory pointed to by "dst". + * These bytes come from reading the channel "chanPtr" and + * performing the configured translations. No encoding conversions + * are applied to the bytes being read. + * + * Results: + * The number of bytes actually stored (<= bytesToRead), + * or -1 if there is an error in reading the channel. Use + * Tcl_GetErrno() to retrieve the error code for the error + * that occurred. + * + * The number of bytes stored can be less than the number + * requested when + * - EOF is reached on the channel; or + * - the channel is non-blocking, and we've read all we can + * without blocking. + * - a channel reading error occurs (and we return -1) + * + * Side effects: + * May cause input to be buffered. + * + *---------------------------------------------------------------------- + */ + +static int +DoRead( + Channel *chanPtr, /* The channel from which to read. */ + char *dst, /* Where to store input read. */ + int bytesToRead, /* Maximum number of bytes to read. */ + int allowShortReads) /* Allow half-blocking (pipes,sockets) */ +{ + ChannelState *statePtr = chanPtr->state; + char *p = dst; + + assert (bytesToRead >= 0); + + /* + * Early out when we know a read will get the eofchar. + * + * NOTE: This seems to be a bug. The special handling for + * a zero-char read request ought to come first. As coded + * the EOF due to eofchar has distinguishing behavior from + * the EOF due to reported EOF on the underlying device, and + * that seems undesirable. However recent history indicates + * that new inconsistent behavior in a patchlevel has problems + * too. Keep on keeping on for now. + */ + + if (GotFlag(statePtr, CHANNEL_STICKY_EOF)) { + SetFlag(statePtr, CHANNEL_EOF); + assert( statePtr->inputEncodingFlags & TCL_ENCODING_END ); + assert( !GotFlag(statePtr, CHANNEL_BLOCKED|INPUT_SAW_CR) ); + + /* TODO: Don't need this call */ + UpdateInterest(chanPtr); + return 0; + } + + /* Special handling for zero-char read request. */ + if (bytesToRead == 0) { + if (GotFlag(statePtr, CHANNEL_EOF)) { + statePtr->inputEncodingFlags |= TCL_ENCODING_START; + } + ResetFlag(statePtr, CHANNEL_BLOCKED|CHANNEL_EOF); + statePtr->inputEncodingFlags &= ~TCL_ENCODING_END; + /* TODO: Don't need this call */ + UpdateInterest(chanPtr); + return 0; + } + + TclChannelPreserve((Tcl_Channel)chanPtr); + while (bytesToRead) { + /* + * Each pass through the loop is intended to process up to + * one channel buffer. + */ + + int bytesRead, bytesWritten; + ChannelBuffer *bufPtr = statePtr->inQueueHead; + + /* + * Don't read more data if we have what we need. + */ + + while (!bufPtr || /* We got no buffer! OR */ + (!IsBufferFull(bufPtr) && /* Our buffer has room AND */ + (BytesLeft(bufPtr) < bytesToRead) ) ) { + /* Not enough bytes in it + * yet to fill the dst */ + int code; + + moreData: + code = GetInput(chanPtr); + bufPtr = statePtr->inQueueHead; + + assert (bufPtr != NULL); + + if (GotFlag(statePtr, CHANNEL_EOF|CHANNEL_BLOCKED)) { + /* Further reads cannot do any more */ + break; + } + + if (code) { + /* Read error */ + UpdateInterest(chanPtr); + TclChannelRelease((Tcl_Channel)chanPtr); + return -1; + } + + assert (IsBufferFull(bufPtr)); + } + + assert (bufPtr != NULL); + + bytesRead = BytesLeft(bufPtr); + bytesWritten = bytesToRead; + + TranslateInputEOL(statePtr, p, RemovePoint(bufPtr), + &bytesWritten, &bytesRead); + bufPtr->nextRemoved += bytesRead; + p += bytesWritten; + bytesToRead -= bytesWritten; + + if (!IsBufferEmpty(bufPtr)) { + /* + * Buffer is not empty. How can that be? + * + * 0) We stopped early because we got all the bytes + * we were seeking. That's fine. + */ + + if (bytesToRead == 0) { + break; + } + + /* + * 1) We're @EOF because we saw eof char. + */ + + if (GotFlag(statePtr, CHANNEL_STICKY_EOF)) { + break; + } + + /* + * 2) The buffer holds a \r while in CRLF translation, + * followed by the end of the buffer. + */ + + assert(statePtr->inputTranslation == TCL_TRANSLATE_CRLF); + assert(RemovePoint(bufPtr)[0] == '\r'); + assert(BytesLeft(bufPtr) == 1); + + if (bufPtr->nextPtr == NULL) { + /* There's no more buffered data.... */ + + if (statePtr->flags & CHANNEL_EOF) { + /* ...and there never will be. */ + + *p++ = '\r'; + bytesToRead--; + bufPtr->nextRemoved++; + } else if (statePtr->flags & CHANNEL_BLOCKED) { + /* ...and we cannot get more now. */ + SetFlag(statePtr, CHANNEL_NEED_MORE_DATA); + break; + } else { + /* ... so we need to get some. */ + goto moreData; + } + } + + if (bufPtr->nextPtr) { + /* There's a next buffer. Shift orphan \r to it. */ + + ChannelBuffer *nextPtr = bufPtr->nextPtr; + + nextPtr->nextRemoved -= 1; + RemovePoint(nextPtr)[0] = '\r'; + bufPtr->nextRemoved++; + } + } + + if (IsBufferEmpty(bufPtr)) { + statePtr->inQueueHead = bufPtr->nextPtr; + if (statePtr->inQueueHead == NULL) { + statePtr->inQueueTail = NULL; + } + RecycleBuffer(statePtr, bufPtr, 0); + bufPtr = statePtr->inQueueHead; + } + + if ((GotFlag(statePtr, CHANNEL_NONBLOCKING) || allowShortReads) + && GotFlag(statePtr, CHANNEL_BLOCKED)) { + break; + } + + /* + * When there's no buffered data to read, and we're at EOF, + * escape to the caller. + */ + + if (GotFlag(statePtr, CHANNEL_EOF) + && (bufPtr == NULL || IsBufferEmpty(bufPtr))) { + break; + } + } + if (bytesToRead == 0) { + ResetFlag(statePtr, CHANNEL_BLOCKED); + } + + assert(!GotFlag(statePtr, CHANNEL_EOF) + || GotFlag(statePtr, CHANNEL_STICKY_EOF) + || Tcl_InputBuffered((Tcl_Channel)chanPtr) == 0); + assert( !(GotFlag(statePtr, CHANNEL_EOF|CHANNEL_BLOCKED) + == (CHANNEL_EOF|CHANNEL_BLOCKED)) ); + UpdateInterest(chanPtr); + TclChannelRelease((Tcl_Channel)chanPtr); + return (int)(p - dst); +} + +/* + *---------------------------------------------------------------------- + * + * CopyEventProc -- + * + * This routine is invoked as a channel event handler for the background + * copy operation. It is just a trivial wrapper around the CopyData + * routine. + * + * Results: + * None. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +static void +CopyEventProc( + ClientData clientData, + int mask) +{ + (void) CopyData(clientData, mask); +} + +/* + *---------------------------------------------------------------------- + * + * StopCopy -- + * + * This routine halts a copy that is in progress. + * + * Results: + * None. + * + * Side effects: + * Removes any pending channel handlers and restores the blocking and + * buffering modes of the channels. The CopyState is freed. + * + *---------------------------------------------------------------------- + */ + +static void +StopCopy( + CopyState *csPtr) /* State for bg copy to stop . */ +{ + ChannelState *inStatePtr, *outStatePtr; + Tcl_Channel inChan, outChan; + + int nonBlocking; + + if (!csPtr) { + return; + } + + inChan = (Tcl_Channel) csPtr->readPtr; + outChan = (Tcl_Channel) csPtr->writePtr; + inStatePtr = csPtr->readPtr->state; + outStatePtr = csPtr->writePtr->state; + + /* + * Restore the old blocking mode and output buffering mode. + */ + + nonBlocking = csPtr->readFlags & CHANNEL_NONBLOCKING; + if (nonBlocking != (inStatePtr->flags & CHANNEL_NONBLOCKING)) { + SetBlockMode(NULL, csPtr->readPtr, + nonBlocking ? TCL_MODE_NONBLOCKING : TCL_MODE_BLOCKING); + } + if (csPtr->readPtr != csPtr->writePtr) { + nonBlocking = csPtr->writeFlags & CHANNEL_NONBLOCKING; + if (nonBlocking != (outStatePtr->flags & CHANNEL_NONBLOCKING)) { + SetBlockMode(NULL, csPtr->writePtr, + nonBlocking ? TCL_MODE_NONBLOCKING : TCL_MODE_BLOCKING); + } + } + ResetFlag(outStatePtr, CHANNEL_LINEBUFFERED | CHANNEL_UNBUFFERED); + outStatePtr->flags |= + csPtr->writeFlags & (CHANNEL_LINEBUFFERED | CHANNEL_UNBUFFERED); + + if (csPtr->cmdPtr) { + Tcl_DeleteChannelHandler(inChan, CopyEventProc, csPtr); + if (inChan != outChan) { + Tcl_DeleteChannelHandler(outChan, CopyEventProc, csPtr); + } + Tcl_DeleteChannelHandler(inChan, MBEvent, csPtr); + Tcl_DeleteChannelHandler(outChan, MBEvent, csPtr); + TclDecrRefCount(csPtr->cmdPtr); + } + inStatePtr->csPtrR = NULL; + outStatePtr->csPtrW = NULL; + ckfree(csPtr); +} + +/* + *---------------------------------------------------------------------- + * + * StackSetBlockMode -- + * + * This function sets the blocking mode for a channel, iterating through + * each channel in a stack and updates the state flags. + * + * Results: + * 0 if OK, result code from failed blockModeProc otherwise. + * + * Side effects: + * Modifies the blocking mode of the channel and possibly generates an + * error. + * + *---------------------------------------------------------------------- + */ + +static int +StackSetBlockMode( + Channel *chanPtr, /* Channel to modify. */ + int mode) /* One of TCL_MODE_BLOCKING or + * TCL_MODE_NONBLOCKING. */ +{ + int result = 0; + Tcl_DriverBlockModeProc *blockModeProc; + ChannelState *statePtr = chanPtr->state; + + /* + * Start at the top of the channel stack + * TODO: Examine what can go wrong when blockModeProc calls + * disturb the stacking state of the channel. + */ + + chanPtr = statePtr->topChanPtr; + while (chanPtr != NULL) { + blockModeProc = Tcl_ChannelBlockModeProc(chanPtr->typePtr); + if (blockModeProc != NULL) { + result = blockModeProc(chanPtr->instanceData, mode); + if (result != 0) { + Tcl_SetErrno(result); + return result; + } + } + chanPtr = chanPtr->downChanPtr; + } + return 0; +} + +/* + *---------------------------------------------------------------------- + * + * SetBlockMode -- + * + * This function sets the blocking mode for a channel and updates the + * state flags. + * + * Results: + * A standard Tcl result. + * + * Side effects: + * Modifies the blocking mode of the channel and possibly generates an + * error. + * + *---------------------------------------------------------------------- + */ + +static int +SetBlockMode( + Tcl_Interp *interp, /* Interp for error reporting. */ + Channel *chanPtr, /* Channel to modify. */ + int mode) /* One of TCL_MODE_BLOCKING or + * TCL_MODE_NONBLOCKING. */ +{ + int result = 0; + ChannelState *statePtr = chanPtr->state; + /* State info for channel */ + + result = StackSetBlockMode(chanPtr, mode); + if (result != 0) { + if (interp != NULL) { + /* + * TIP #219. + * Move error messages put by the driver into the bypass area and + * put them into the regular interpreter result. Fall back to the + * regular message if nothing was found in the bypass. + * + * Note that we cannot have a message in the interpreter bypass + * area, StackSetBlockMode is restricted to the channel bypass. + * We still need the interp as the destination of the move. + */ + + if (!TclChanCaughtErrorBypass(interp, (Tcl_Channel) chanPtr)) { + Tcl_SetObjResult(interp, Tcl_ObjPrintf( + "error setting blocking mode: %s", + Tcl_PosixError(interp))); + } + } else { + /* + * TIP #219. + * If we have no interpreter to put a bypass message into we have + * to clear it, to prevent its propagation and use in other places + * unrelated to the actual occurence of the problem. + */ + + Tcl_SetChannelError((Tcl_Channel) chanPtr, NULL); + } + return TCL_ERROR; + } + if (mode == TCL_MODE_BLOCKING) { + ResetFlag(statePtr, CHANNEL_NONBLOCKING | BG_FLUSH_SCHEDULED); + } else { + SetFlag(statePtr, CHANNEL_NONBLOCKING); + } + return TCL_OK; +} + +/* + *---------------------------------------------------------------------- + * + * Tcl_GetChannelNames -- + * + * Return the names of all open channels in the interp. + * + * Results: + * TCL_OK or TCL_ERROR. + * + * Side effects: + * Interp result modified with list of channel names. + * + *---------------------------------------------------------------------- + */ + +int +Tcl_GetChannelNames( + Tcl_Interp *interp) /* Interp for error reporting. */ +{ + return Tcl_GetChannelNamesEx(interp, NULL); +} + +/* + *---------------------------------------------------------------------- + * + * Tcl_GetChannelNamesEx -- + * + * Return the names of open channels in the interp filtered filtered + * through a pattern. If pattern is NULL, it returns all the open + * channels. + * + * Results: + * TCL_OK or TCL_ERROR. + * + * Side effects: + * Interp result modified with list of channel names. + * + *---------------------------------------------------------------------- + */ + +int +Tcl_GetChannelNamesEx( + Tcl_Interp *interp, /* Interp for error reporting. */ + const char *pattern) /* Pattern to filter on. */ +{ + ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey); + ChannelState *statePtr; + const char *name; /* Name for channel */ + Tcl_Obj *resultPtr; /* Pointer to result object */ + Tcl_HashTable *hTblPtr; /* Hash table of channels. */ + Tcl_HashEntry *hPtr; /* Search variable. */ + Tcl_HashSearch hSearch; /* Search variable. */ + + if (interp == NULL) { + return TCL_OK; + } + + /* + * Get the channel table that stores the channels registered for this + * interpreter. + */ + + hTblPtr = GetChannelTable(interp); + TclNewObj(resultPtr); + if ((pattern != NULL) && TclMatchIsTrivial(pattern) + && !((pattern[0] == 's') && (pattern[1] == 't') + && (pattern[2] == 'd'))) { + if ((Tcl_FindHashEntry(hTblPtr, pattern) != NULL) + && (Tcl_ListObjAppendElement(interp, resultPtr, + Tcl_NewStringObj(pattern, -1)) != TCL_OK)) { + goto error; + } + goto done; + } + + for (hPtr = Tcl_FirstHashEntry(hTblPtr, &hSearch); hPtr != NULL; + hPtr = Tcl_NextHashEntry(&hSearch)) { + statePtr = ((Channel *) Tcl_GetHashValue(hPtr))->state; + + if (statePtr->topChanPtr == (Channel *) tsdPtr->stdinChannel) { + name = "stdin"; + } else if (statePtr->topChanPtr == (Channel *) tsdPtr->stdoutChannel) { + name = "stdout"; + } else if (statePtr->topChanPtr == (Channel *) tsdPtr->stderrChannel) { + name = "stderr"; + } else { + /* + * This is also stored in Tcl_GetHashKey(hTblPtr, hPtr), but it's + * simpler to just grab the name from the statePtr. + */ + + name = statePtr->channelName; + } + + if (((pattern == NULL) || Tcl_StringMatch(name, pattern)) && + (Tcl_ListObjAppendElement(interp, resultPtr, + Tcl_NewStringObj(name, -1)) != TCL_OK)) { + error: + TclDecrRefCount(resultPtr); + return TCL_ERROR; + } + } + + done: + Tcl_SetObjResult(interp, resultPtr); + return TCL_OK; +} + +/* + *---------------------------------------------------------------------- + * + * Tcl_IsChannelRegistered -- + * + * Checks whether the channel is associated with the interp. See also + * Tcl_RegisterChannel and Tcl_UnregisterChannel. + * + * Results: + * 0 if the channel is not registered in the interpreter, 1 else. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +int +Tcl_IsChannelRegistered( + Tcl_Interp *interp, /* The interp to query of the channel */ + Tcl_Channel chan) /* The channel to check */ +{ + Tcl_HashTable *hTblPtr; /* Hash table of channels. */ + Tcl_HashEntry *hPtr; /* Search variable. */ + Channel *chanPtr; /* The real IO channel. */ + ChannelState *statePtr; /* State of the real channel. */ + + /* + * Always check bottom-most channel in the stack. This is the one that + * gets registered. + */ + + chanPtr = ((Channel *) chan)->state->bottomChanPtr; + statePtr = chanPtr->state; + + hTblPtr = Tcl_GetAssocData(interp, "tclIO", NULL); + if (hTblPtr == NULL) { + return 0; + } + hPtr = Tcl_FindHashEntry(hTblPtr, statePtr->channelName); + if (hPtr == NULL) { + return 0; + } + if ((Channel *) Tcl_GetHashValue(hPtr) != chanPtr) { + return 0; + } + + return 1; +} + +/* + *---------------------------------------------------------------------- + * + * Tcl_IsChannelShared -- + * + * Checks whether the channel is shared by multiple interpreters. + * + * Results: + * A boolean value (0 = Not shared, 1 = Shared). + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +int +Tcl_IsChannelShared( + Tcl_Channel chan) /* The channel to query */ +{ + ChannelState *statePtr = ((Channel *) chan)->state; + /* State of real channel structure. */ + + return ((statePtr->refCount > 1) ? 1 : 0); +} + +/* + *---------------------------------------------------------------------- + * + * Tcl_IsChannelExisting -- + * + * Checks whether a channel of the given name exists in the + * (thread)-global list of all channels. See Tcl_GetChannelNamesEx for + * function exposed at the Tcl level. + * + * Results: + * A boolean value (0 = Does not exist, 1 = Does exist). + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +int +Tcl_IsChannelExisting( + const char *chanName) /* The name of the channel to look for. */ +{ + ChannelState *statePtr; + ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey); + const char *name; + int chanNameLen; + + chanNameLen = strlen(chanName); + for (statePtr = tsdPtr->firstCSPtr; statePtr != NULL; + statePtr = statePtr->nextCSPtr) { + if (statePtr->topChanPtr == (Channel *) tsdPtr->stdinChannel) { + name = "stdin"; + } else if (statePtr->topChanPtr == (Channel *) tsdPtr->stdoutChannel) { + name = "stdout"; + } else if (statePtr->topChanPtr == (Channel *) tsdPtr->stderrChannel) { + name = "stderr"; + } else { + name = statePtr->channelName; + } + + if ((*chanName == *name) && + (memcmp(name, chanName, (size_t) chanNameLen + 1) == 0)) { + return 1; + } + } + + return 0; +} + +/* + *---------------------------------------------------------------------- + * + * Tcl_ChannelName -- + * + * Return the name of the channel type. + * + * Results: + * A pointer the name of the channel type. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +const char * +Tcl_ChannelName( + const Tcl_ChannelType *chanTypePtr) /* Pointer to channel type. */ +{ + return chanTypePtr->typeName; +} + +/* + *---------------------------------------------------------------------- + * + * Tcl_ChannelVersion -- + * + * Return the of version of the channel type. + * + * Results: + * One of the TCL_CHANNEL_VERSION_* constants from tcl.h + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +Tcl_ChannelTypeVersion +Tcl_ChannelVersion( + const Tcl_ChannelType *chanTypePtr) + /* Pointer to channel type. */ +{ + if (chanTypePtr->version == TCL_CHANNEL_VERSION_2) { + return TCL_CHANNEL_VERSION_2; + } else if (chanTypePtr->version == TCL_CHANNEL_VERSION_3) { + return TCL_CHANNEL_VERSION_3; + } else if (chanTypePtr->version == TCL_CHANNEL_VERSION_4) { + return TCL_CHANNEL_VERSION_4; + } else if (chanTypePtr->version == TCL_CHANNEL_VERSION_5) { + return TCL_CHANNEL_VERSION_5; + } else { + /* + * In <v2 channel versions, the version field is occupied by the + * Tcl_DriverBlockModeProc + */ + + return TCL_CHANNEL_VERSION_1; + } +} + +/* + *---------------------------------------------------------------------- + * + * HaveVersion -- + * + * Return whether a channel type is (at least) of a given version. + * + * Results: + * True if the minimum version is exceeded by the version actually + * present. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +static int +HaveVersion( + const Tcl_ChannelType *chanTypePtr, + Tcl_ChannelTypeVersion minimumVersion) +{ + Tcl_ChannelTypeVersion actualVersion = Tcl_ChannelVersion(chanTypePtr); + + return (PTR2INT(actualVersion)) >= (PTR2INT(minimumVersion)); +} + +/* + *---------------------------------------------------------------------- + * + * Tcl_ChannelBlockModeProc -- + * + * Return the Tcl_DriverBlockModeProc of the channel type. + * + * Results: + * A pointer to the proc. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- */ + +Tcl_DriverBlockModeProc * +Tcl_ChannelBlockModeProc( + const Tcl_ChannelType *chanTypePtr) + /* Pointer to channel type. */ +{ + if (HaveVersion(chanTypePtr, TCL_CHANNEL_VERSION_2)) { + return chanTypePtr->blockModeProc; + } + + /* + * The v1 structure had the blockModeProc in a different place. + */ + + return (Tcl_DriverBlockModeProc *) chanTypePtr->version; +} + +/* + *---------------------------------------------------------------------- + * + * Tcl_ChannelCloseProc -- + * + * Return the Tcl_DriverCloseProc of the channel type. + * + * Results: + * A pointer to the proc. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +Tcl_DriverCloseProc * +Tcl_ChannelCloseProc( + const Tcl_ChannelType *chanTypePtr) + /* Pointer to channel type. */ +{ + return chanTypePtr->closeProc; +} + +/* + *---------------------------------------------------------------------- + * + * Tcl_ChannelClose2Proc -- + * + * Return the Tcl_DriverClose2Proc of the channel type. + * + * Results: + * A pointer to the proc. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +Tcl_DriverClose2Proc * +Tcl_ChannelClose2Proc( + const Tcl_ChannelType *chanTypePtr) + /* Pointer to channel type. */ +{ + return chanTypePtr->close2Proc; +} + +/* + *---------------------------------------------------------------------- + * + * Tcl_ChannelInputProc -- + * + * Return the Tcl_DriverInputProc of the channel type. + * + * Results: + * A pointer to the proc. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +Tcl_DriverInputProc * +Tcl_ChannelInputProc( + const Tcl_ChannelType *chanTypePtr) + /* Pointer to channel type. */ +{ + return chanTypePtr->inputProc; +} + +/* + *---------------------------------------------------------------------- + * + * Tcl_ChannelOutputProc -- + * + * Return the Tcl_DriverOutputProc of the channel type. + * + * Results: + * A pointer to the proc. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +Tcl_DriverOutputProc * +Tcl_ChannelOutputProc( + const Tcl_ChannelType *chanTypePtr) + /* Pointer to channel type. */ +{ + return chanTypePtr->outputProc; +} + +/* + *---------------------------------------------------------------------- + * + * Tcl_ChannelSeekProc -- + * + * Return the Tcl_DriverSeekProc of the channel type. + * + * Results: + * A pointer to the proc. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +Tcl_DriverSeekProc * +Tcl_ChannelSeekProc( + const Tcl_ChannelType *chanTypePtr) + /* Pointer to channel type. */ +{ + return chanTypePtr->seekProc; +} + +/* + *---------------------------------------------------------------------- + * + * Tcl_ChannelSetOptionProc -- + * + * Return the Tcl_DriverSetOptionProc of the channel type. + * + * Results: + * A pointer to the proc. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +Tcl_DriverSetOptionProc * +Tcl_ChannelSetOptionProc( + const Tcl_ChannelType *chanTypePtr) + /* Pointer to channel type. */ +{ + return chanTypePtr->setOptionProc; +} + +/* + *---------------------------------------------------------------------- + * + * Tcl_ChannelGetOptionProc -- + * + * Return the Tcl_DriverGetOptionProc of the channel type. + * + * Results: + * A pointer to the proc. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +Tcl_DriverGetOptionProc * +Tcl_ChannelGetOptionProc( + const Tcl_ChannelType *chanTypePtr) + /* Pointer to channel type. */ +{ + return chanTypePtr->getOptionProc; +} + +/* + *---------------------------------------------------------------------- + * + * Tcl_ChannelWatchProc -- + * + * Return the Tcl_DriverWatchProc of the channel type. + * + * Results: + * A pointer to the proc. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +Tcl_DriverWatchProc * +Tcl_ChannelWatchProc( + const Tcl_ChannelType *chanTypePtr) + /* Pointer to channel type. */ +{ + return chanTypePtr->watchProc; +} + +/* + *---------------------------------------------------------------------- + * + * Tcl_ChannelGetHandleProc -- + * + * Return the Tcl_DriverGetHandleProc of the channel type. + * + * Results: + * A pointer to the proc. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +Tcl_DriverGetHandleProc * +Tcl_ChannelGetHandleProc( + const Tcl_ChannelType *chanTypePtr) + /* Pointer to channel type. */ +{ + return chanTypePtr->getHandleProc; +} + +/* + *---------------------------------------------------------------------- + * + * Tcl_ChannelFlushProc -- + * + * Return the Tcl_DriverFlushProc of the channel type. + * + * Results: + * A pointer to the proc. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +Tcl_DriverFlushProc * +Tcl_ChannelFlushProc( + const Tcl_ChannelType *chanTypePtr) + /* Pointer to channel type. */ +{ + if (HaveVersion(chanTypePtr, TCL_CHANNEL_VERSION_2)) { + return chanTypePtr->flushProc; + } + return NULL; +} + +/* + *---------------------------------------------------------------------- + * + * Tcl_ChannelHandlerProc -- + * + * Return the Tcl_DriverHandlerProc of the channel type. + * + * Results: + * A pointer to the proc. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +Tcl_DriverHandlerProc * +Tcl_ChannelHandlerProc( + const Tcl_ChannelType *chanTypePtr) + /* Pointer to channel type. */ +{ + if (HaveVersion(chanTypePtr, TCL_CHANNEL_VERSION_2)) { + return chanTypePtr->handlerProc; + } + return NULL; +} + +/* + *---------------------------------------------------------------------- + * + * Tcl_ChannelWideSeekProc -- + * + * Return the Tcl_DriverWideSeekProc of the channel type. + * + * Results: + * A pointer to the proc. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +Tcl_DriverWideSeekProc * +Tcl_ChannelWideSeekProc( + const Tcl_ChannelType *chanTypePtr) + /* Pointer to channel type. */ +{ + if (HaveVersion(chanTypePtr, TCL_CHANNEL_VERSION_3)) { + return chanTypePtr->wideSeekProc; + } + return NULL; +} + +/* + *---------------------------------------------------------------------- + * + * Tcl_ChannelThreadActionProc -- + * + * TIP #218, Channel Thread Actions. Return the + * Tcl_DriverThreadActionProc of the channel type. + * + * Results: + * A pointer to the proc. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +Tcl_DriverThreadActionProc * +Tcl_ChannelThreadActionProc( + const Tcl_ChannelType *chanTypePtr) + /* Pointer to channel type. */ +{ + if (HaveVersion(chanTypePtr, TCL_CHANNEL_VERSION_4)) { + return chanTypePtr->threadActionProc; + } + return NULL; +} + +/* + *---------------------------------------------------------------------- + * + * Tcl_SetChannelErrorInterp -- + * + * TIP #219, Tcl Channel Reflection API. + * Store an error message for the I/O system. + * + * Results: + * None. + * + * Side effects: + * Discards a previously stored message. + * + *---------------------------------------------------------------------- + */ + +void +Tcl_SetChannelErrorInterp( + Tcl_Interp *interp, /* Interp to store the data into. */ + Tcl_Obj *msg) /* Error message to store. */ +{ + Interp *iPtr = (Interp *) interp; + + if (iPtr->chanMsg != NULL) { + TclDecrRefCount(iPtr->chanMsg); + iPtr->chanMsg = NULL; + } + + if (msg != NULL) { + iPtr->chanMsg = FixLevelCode(msg); + Tcl_IncrRefCount(iPtr->chanMsg); + } + return; +} + +/* + *---------------------------------------------------------------------- + * + * Tcl_SetChannelError -- + * + * TIP #219, Tcl Channel Reflection API. + * Store an error message for the I/O system. + * + * Results: + * None. + * + * Side effects: + * Discards a previously stored message. + * + *---------------------------------------------------------------------- + */ + +void +Tcl_SetChannelError( + Tcl_Channel chan, /* Channel to store the data into. */ + Tcl_Obj *msg) /* Error message to store. */ +{ + ChannelState *statePtr = ((Channel *) chan)->state; + + if (statePtr->chanMsg != NULL) { + TclDecrRefCount(statePtr->chanMsg); + statePtr->chanMsg = NULL; + } + + if (msg != NULL) { + statePtr->chanMsg = FixLevelCode(msg); + Tcl_IncrRefCount(statePtr->chanMsg); + } + return; +} + +/* + *---------------------------------------------------------------------- + * + * FixLevelCode -- + * + * TIP #219, Tcl Channel Reflection API. + * Scans an error message for bad -code / -level directives. Returns a + * modified copy with such directives corrected, and the input if it had + * no problems. + * + * Results: + * A Tcl_Obj* + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +static Tcl_Obj * +FixLevelCode( + Tcl_Obj *msg) +{ + int explicitResult, numOptions, lc, lcn; + Tcl_Obj **lv, **lvn; + int res, i, j, val, lignore, cignore; + int newlevel = -1, newcode = -1; + + /* ASSERT msg != NULL */ + + /* + * Process the caught message. + * + * Syntax = (option value)... ?message? + * + * Bad message syntax causes a panic, because the other side uses + * Tcl_GetReturnOptions and list construction functions to marshall the + * information. Hence an error means that we've got serious breakage. + */ + + res = Tcl_ListObjGetElements(NULL, msg, &lc, &lv); + if (res != TCL_OK) { + Tcl_Panic("Tcl_SetChannelError: bad syntax of message"); + } + + explicitResult = (1 == (lc % 2)); + numOptions = lc - explicitResult; + + /* + * No options, nothing to do. + */ + + if (numOptions == 0) { + return msg; + } + + /* + * Check for -code x, x != 1|error, and -level x, x != 0 + */ + + for (i = 0; i < numOptions; i += 2) { + if (0 == strcmp(TclGetString(lv[i]), "-code")) { + /* + * !"error", !integer, integer != 1 (numeric code for error) + */ + + res = TclGetIntFromObj(NULL, lv[i+1], &val); + if (((res == TCL_OK) && (val != 1)) || ((res != TCL_OK) && + (0 != strcmp(TclGetString(lv[i+1]), "error")))) { + newcode = 1; + } + } else if (0 == strcmp(TclGetString(lv[i]), "-level")) { + /* + * !integer, integer != 0 + */ + + res = TclGetIntFromObj(NULL, lv [i+1], &val); + if ((res != TCL_OK) || (val != 0)) { + newlevel = 0; + } + } + } + + /* + * -code, -level are either not present or ok. Nothing to do. + */ + + if ((newlevel < 0) && (newcode < 0)) { + return msg; + } + + lcn = numOptions; + if (explicitResult) { + lcn ++; + } + if (newlevel >= 0) { + lcn += 2; + } + if (newcode >= 0) { + lcn += 2; + } + + lvn = ckalloc(lcn * sizeof(Tcl_Obj *)); + + /* + * New level/code information is spliced into the first occurence of + * -level, -code, further occurences are ignored. The options cannot be + * not present, we would not come here. Options which are ok are simply + * copied over. + */ + + lignore = cignore = 0; + for (i=0, j=0; i<numOptions; i+=2) { + if (0 == strcmp(TclGetString(lv[i]), "-level")) { + if (newlevel >= 0) { + lvn[j++] = lv[i]; + lvn[j++] = Tcl_NewIntObj(newlevel); + newlevel = -1; + lignore = 1; + continue; + } else if (lignore) { + continue; + } + } else if (0 == strcmp(TclGetString(lv[i]), "-code")) { + if (newcode >= 0) { + lvn[j++] = lv[i]; + lvn[j++] = Tcl_NewIntObj(newcode); + newcode = -1; + cignore = 1; + continue; + } else if (cignore) { + continue; + } + } + + /* + * Keep everything else, possibly copied down. + */ + + lvn[j++] = lv[i]; + lvn[j++] = lv[i+1]; + } + if (newlevel >= 0) { + Tcl_Panic("Defined newlevel not used in rewrite"); + } + if (newcode >= 0) { + Tcl_Panic("Defined newcode not used in rewrite"); + } + + if (explicitResult) { + lvn[j++] = lv[i]; + } + + msg = Tcl_NewListObj(j, lvn); + + ckfree(lvn); + return msg; +} + +/* + *---------------------------------------------------------------------- + * + * Tcl_GetChannelErrorInterp -- + * + * TIP #219, Tcl Channel Reflection API. + * Return the message stored by the channel driver. + * + * Results: + * Tcl error message object. + * + * Side effects: + * Resets the stored data to NULL. + * + *---------------------------------------------------------------------- + */ + +void +Tcl_GetChannelErrorInterp( + Tcl_Interp *interp, /* Interp to query. */ + Tcl_Obj **msg) /* Place for error message. */ +{ + Interp *iPtr = (Interp *) interp; + + *msg = iPtr->chanMsg; + iPtr->chanMsg = NULL; +} + +/* + *---------------------------------------------------------------------- + * + * Tcl_GetChannelError -- + * + * TIP #219, Tcl Channel Reflection API. + * Return the message stored by the channel driver. + * + * Results: + * Tcl error message object. + * + * Side effects: + * Resets the stored data to NULL. + * + *---------------------------------------------------------------------- + */ + +void +Tcl_GetChannelError( + Tcl_Channel chan, /* Channel to query. */ + Tcl_Obj **msg) /* Place for error message. */ +{ + ChannelState *statePtr = ((Channel *) chan)->state; + + *msg = statePtr->chanMsg; + statePtr->chanMsg = NULL; +} + +/* + *---------------------------------------------------------------------- + * + * Tcl_ChannelTruncateProc -- + * + * TIP #208 (subsection relating to truncation, based on TIP #206). + * Return the Tcl_DriverTruncateProc of the channel type. + * + * Results: + * A pointer to the proc. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +Tcl_DriverTruncateProc * +Tcl_ChannelTruncateProc( + const Tcl_ChannelType *chanTypePtr) + /* Pointer to channel type. */ +{ + if (HaveVersion(chanTypePtr, TCL_CHANNEL_VERSION_5)) { + return chanTypePtr->truncateProc; + } + return NULL; +} + +/* + *---------------------------------------------------------------------- + * + * DupChannelIntRep -- + * + * Initialize the internal representation of a new Tcl_Obj to a copy of + * the internal representation of an existing string object. + * + * Results: + * None. + * + * Side effects: + * copyPtr's internal rep is set to a copy of srcPtr's internal + * representation. + * + *---------------------------------------------------------------------- + */ + +static void +DupChannelIntRep( + register Tcl_Obj *srcPtr, /* Object with internal rep to copy. Must have + * an internal rep of type "Channel". */ + register Tcl_Obj *copyPtr) /* Object with internal rep to set. Must not + * currently have an internal rep.*/ +{ + ResolvedChanName *resPtr = srcPtr->internalRep.twoPtrValue.ptr1; + + resPtr->refCount++; + copyPtr->internalRep.twoPtrValue.ptr1 = resPtr; + copyPtr->typePtr = srcPtr->typePtr; +} + +/* + *---------------------------------------------------------------------- + * + * FreeChannelIntRep -- + * + * Release statePtr storage. + * + * Results: + * None. + * + * Side effects: + * May cause state to be freed. + * + *---------------------------------------------------------------------- + */ + +static void +FreeChannelIntRep( + Tcl_Obj *objPtr) /* Object with internal rep to free. */ +{ + ResolvedChanName *resPtr = objPtr->internalRep.twoPtrValue.ptr1; + + objPtr->typePtr = NULL; + if (--resPtr->refCount) { + return; + } + Tcl_Release(resPtr->statePtr); + ckfree(resPtr); +} + +#if 0 +/* + * For future debugging work, a simple function to print the flags of a + * channel in semi-readable form. + */ + +static int +DumpFlags( + char *str, + int flags) +{ + char buf[20]; + int i = 0; + +#define ChanFlag(chr, bit) (buf[i++] = ((flags & (bit)) ? (chr) : '_')) + + ChanFlag('r', TCL_READABLE); + ChanFlag('w', TCL_WRITABLE); + ChanFlag('n', CHANNEL_NONBLOCKING); + ChanFlag('l', CHANNEL_LINEBUFFERED); + ChanFlag('u', CHANNEL_UNBUFFERED); + ChanFlag('F', BG_FLUSH_SCHEDULED); + ChanFlag('c', CHANNEL_CLOSED); + ChanFlag('E', CHANNEL_EOF); + ChanFlag('S', CHANNEL_STICKY_EOF); + ChanFlag('B', CHANNEL_BLOCKED); + ChanFlag('/', INPUT_SAW_CR); + ChanFlag('D', CHANNEL_DEAD); + ChanFlag('R', CHANNEL_RAW_MODE); + ChanFlag('x', CHANNEL_INCLOSE); + + buf[i] ='\0'; + + fprintf(stderr, "%s: %s\n", str, buf); + return 0; +} +#endif + +/* + * Local Variables: + * mode: c + * c-basic-offset: 4 + * fill-column: 78 + * tab-width: 8 + * indent-tabs-mode: nil + * End: + */ |