"

 COPYRIGHT (c) 1989 by Claus Gittinger

	      All Rights Reserved

 This software is furnished under a license and may be used

 only in accordance with the terms of that license and with the

 inclusion of the above copyright notice.   This software may not

 be provided or otherwise made available to, or used by, any

 other person.  No title to or ownership of the software is

 hereby transferred.

"

NonPositionableExternalStream subclass:#PipeStream

	classVariableNames:'BrokenPipeSignal'

	poolDictionaries:''

	category:'Streams-External'

!

!PipeStream primitiveDefinitions!

%{

#if defined(NT) || defined(WIN32) || defined(MSDOS)

# undef UNIX_LIKE

# define MSDOS_LIKE

#endif

#if defined(__openVMS__)

# undef __new

#endif

#include <stdio.h>

#define _STDIO_H_INCLUDED_

#include <errno.h>

#define _ERRNO_H_INCLUDED_

#ifndef transputer

# include <sys/types.h>

# include <sys/stat.h>

#endif

/*

 * on some systems errno is a macro ... check for it here

 */

#ifndef errno

 extern errno;

#endif

#ifdef LINUX

# define BUGGY_STDIO_LIB

#endif

%}

! !

!PipeStream primitiveFunctions!

%{

/*

 * no longer needed - popen is useless ...

 */

#undef NEED_POPEN_WITH_VFORK

/*

 * some systems (i.e. ultrix) use fork;

 * were better off with a popen based on vfork ...

 */

#ifdef NEED_POPEN_WITH_VFORK

static int popen_pid = 0;

FILE *

popen(command, type)

/* const */ char *command;

/* const */ char *type;

{

    int pipes[2];

    int itype = (strcmp(type, "w") == 0 ? 1 : 0);

    if (pipe(pipes) == -1)

	return NULL;

    switch (popen_pid = vfork()) {

    case -1:

	(void)close(pipes[0]);

	(void)close(pipes[1]);

	return NULL;

    case 0:

	if (itype) {

	    dup2(pipes[0], fileno(stdin));

	    close(pipes[1]);

	} else {

	    dup2(pipes[1], fileno(stdout));

	    close(pipes[0]);

	}

	execl("/bin/sh", "/bin/sh", "-c", command, 0);

	fprintf(stderr, "XRN Error: failed the execlp\n");

	_exit(-1);

	/* NOTREACHED */

    default:

	    if (itype) {

		close(pipes[0]);

		return fdopen(pipes[1], "w");

	    } else {

		close(pipes[1]);

		return fdopen(pipes[0], "r");

	    }

    }

}

int

pclose(str)

FILE *str;

{

    int pd = 0;

    int status;

    int err;

    err = fclose(str);

    do {

	if ((pd = wait(&status)) == -1)

	{

		err = EOF;

		break;

	}

    } while (pd !=  popen_pid);

    if (err == EOF)

	return  -1;

    if (status)

	status >>= 8;   /* exit status in high byte */

    return status;

}

#endif /* NEED_POPEN_WITH_VFORK */

%}

! !

!PipeStream class methodsFor:'documentation'!

copyright

"

 COPYRIGHT (c) 1989 by Claus Gittinger

	      All Rights Reserved

 This software is furnished under a license and may be used

 only in accordance with the terms of that license and with the

 inclusion of the above copyright notice.   This software may not

 be provided or otherwise made available to, or used by, any

 other person.  No title to or ownership of the software is

 hereby transferred.

"

!

documentation

"

    Pipestreams allow reading or writing from/to a unix command.

    For example, to get a stream reading the output of an 'ls -l'

    command, a PipeStream can be created with:

    the characters of the commands output can be read using the

    standard stream messages as next, nextLine etc.

    If a writing pipeStream is written to, after the command has finished,

    UNIX will generate an error-signal (SIGPIPE), which will raise the BrokenPipeSignal. 

    Thus, to handle this condition correctly, the following code is suggested:

    Notice, that iff the Stream is buffered, the Signal may occur some time after

    the write - or even at close time; to avoid a recursive signal in the exception

    handler, a #shutDown is useful there; if you use close in the handler, this would

    try to send any buffered output to the pipe, leading to another brokenPipe exception.

    Buffered pipes do not work with Linux - the stdio library seems to be

    buggy (trying to restart the read ...)

    Currently, no filtering pipeStreams (i.e. both reading AND writing) are provided.

    However, if you look at how things are setup, this can be implemented using the

    low level primitives #mapePipe and #executeCommand from the OS class protocol.

    [author:]

    [see also:]

	ExternalStream FileStream Socket

	OperatingSystem

"

! !

!PipeStream class methodsFor:'initialization'!

initialize

    "setup the signal"

    BrokenPipeSignal isNil ifTrue:[

	BrokenPipeSignal := WriteErrorSignal newSignalMayProceed:true.

	BrokenPipeSignal nameClass:self message:#brokenPipeSignal.

	BrokenPipeSignal notifierString:'write on a pipe with no one to read'.

    ]

! !

!PipeStream class methodsFor:'instance creation'!

readingFrom:commandString

    "create and return a new pipeStream which can read from the unix command

     given by command."

    ^ (self basicNew) readingFrom:commandString

    "unix:

    "

    "

	Transcript showCR:p nextLine.

	p close

    "

    "

    "

    "vms:

	PipeStream readingFrom:'dir'.

    "

    "

	p := PipeStream readingFrom:'dir'.

	Transcript showCR:p nextLine.

	p close

    "

    "msdos:

	PipeStream readingFrom:'dir'.

    "

    "

	p := PipeStream readingFrom:'dir'.

	Transcript showCR:p nextLine.

	p close

    "

    "Modified: 24.4.1996 / 09:09:25 / stefan"

!

writingTo:commandString

    "create and return a new pipeStream which can write to the unix command

     given by command."

    ^ (self basicNew) writingTo:commandString

    "unix:

    "

! !

!PipeStream class methodsFor:'Signal constants'!

brokenPipeSignal

    "return the signal used to handle SIGPIPE unix-signals"

    ^ BrokenPipeSignal

! !

!PipeStream methodsFor:'accessing'!

commandString

    "return the command string"

    ^ commandString

!

exitStatus

    "return exitStatus"

    ^ exitStatus

    "Created: 28.12.1995 / 14:54:41 / stefan"

!

pid

    "return pid"

    ^ pid

    "Created: 28.12.1995 / 14:54:30 / stefan"

! !

!PipeStream methodsFor:'instance release'!

closeFile

    "low level close

     This waits for the command to finish. 

     Use shutDown for a fast (nonBlocking) close."

    filePointer notNil ifTrue:[

	    [

		]

	    ] valueUninterruptably

    ].

!

closeFileDescriptor

    "alternative very low level close 

     This closes the underlying OS-fileDescriptor 

     - and will NOT write any buffered data to the stream.

     You have been warned."

#if !defined(transputer) && !defined(MSDOS_LIKE)

    OBJ fp;

    FILE *f;

    if ((fp = __INST(filePointer)) != nil) {

	__INST(filePointer) = nil;

	f = __FILEVal(fp);

	__BEGIN_INTERRUPTABLE__

	close(fileno(f));

	__END_INTERRUPTABLE__

    }

#endif /* not transputer && not MSDOS_LIKE */

!

disposed

    "redefined to avoid blocking in close."

    self shutDown

!

shutDown

    "close the Stream, ignoring any broken-pipe errors.

     Terminate the command"

    BrokenPipeSignal catch:[

    ]

    "Modified: 23.5.1996 / 09:15:41 / stefan"

! !

!PipeStream methodsFor:'private'!

openPipeFor:aCommandString withMode:mode

    "open a pipe to the unix command in commandString; 

     mode may be 'r' or 'w'"