497 lines
12 KiB
C
497 lines
12 KiB
C
|
/*
|
|||
|
|
* tclUnixPipe.c -- This file implements the UNIX-specific exec pipeline
|
|||
|
|
* functions.
|
|||
|
|
*
|
|||
|
|
* Copyright (c) 1991-1994 The Regents of the University of California.
|
|||
|
|
* Copyright (c) 1994-1996 Sun Microsystems, Inc.
|
|||
|
|
*
|
|||
|
|
* See the file "license.terms" for information on usage and redistribution
|
|||
|
|
* of this file, and for a DISCLAIMER OF ALL WARRANTIES.
|
|||
|
|
*
|
|||
|
|
* SCCS: @(#) tclUnixPipe.c 1.29 96/04/18 15:56:26
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
#include "tclInt.h"
|
|||
|
|
#include "tclPort.h"
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
* Declarations for local procedures defined in this file:
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
static void RestoreSignals _ANSI_ARGS_((void));
|
|||
|
|
static int SetupStdFile _ANSI_ARGS_((Tcl_File file, int type));
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
*----------------------------------------------------------------------
|
|||
|
|
*
|
|||
|
|
* RestoreSignals --
|
|||
|
|
*
|
|||
|
|
* This procedure is invoked in a forked child process just before
|
|||
|
|
* exec-ing a new program to restore all signals to their default
|
|||
|
|
* settings.
|
|||
|
|
*
|
|||
|
|
* Results:
|
|||
|
|
* None.
|
|||
|
|
*
|
|||
|
|
* Side effects:
|
|||
|
|
* Signal settings get changed.
|
|||
|
|
*
|
|||
|
|
*----------------------------------------------------------------------
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
static void
|
|||
|
|
RestoreSignals()
|
|||
|
|
{
|
|||
|
|
#ifdef SIGABRT
|
|||
|
|
signal(SIGABRT, SIG_DFL);
|
|||
|
|
#endif
|
|||
|
|
#ifdef SIGALRM
|
|||
|
|
signal(SIGALRM, SIG_DFL);
|
|||
|
|
#endif
|
|||
|
|
#ifdef SIGFPE
|
|||
|
|
signal(SIGFPE, SIG_DFL);
|
|||
|
|
#endif
|
|||
|
|
#ifdef SIGHUP
|
|||
|
|
signal(SIGHUP, SIG_DFL);
|
|||
|
|
#endif
|
|||
|
|
#ifdef SIGILL
|
|||
|
|
signal(SIGILL, SIG_DFL);
|
|||
|
|
#endif
|
|||
|
|
#ifdef SIGINT
|
|||
|
|
signal(SIGINT, SIG_DFL);
|
|||
|
|
#endif
|
|||
|
|
#ifdef SIGPIPE
|
|||
|
|
signal(SIGPIPE, SIG_DFL);
|
|||
|
|
#endif
|
|||
|
|
#ifdef SIGQUIT
|
|||
|
|
signal(SIGQUIT, SIG_DFL);
|
|||
|
|
#endif
|
|||
|
|
#ifdef SIGSEGV
|
|||
|
|
signal(SIGSEGV, SIG_DFL);
|
|||
|
|
#endif
|
|||
|
|
#ifdef SIGTERM
|
|||
|
|
signal(SIGTERM, SIG_DFL);
|
|||
|
|
#endif
|
|||
|
|
#ifdef SIGUSR1
|
|||
|
|
signal(SIGUSR1, SIG_DFL);
|
|||
|
|
#endif
|
|||
|
|
#ifdef SIGUSR2
|
|||
|
|
signal(SIGUSR2, SIG_DFL);
|
|||
|
|
#endif
|
|||
|
|
#ifdef SIGCHLD
|
|||
|
|
signal(SIGCHLD, SIG_DFL);
|
|||
|
|
#endif
|
|||
|
|
#ifdef SIGCONT
|
|||
|
|
signal(SIGCONT, SIG_DFL);
|
|||
|
|
#endif
|
|||
|
|
#ifdef SIGTSTP
|
|||
|
|
signal(SIGTSTP, SIG_DFL);
|
|||
|
|
#endif
|
|||
|
|
#ifdef SIGTTIN
|
|||
|
|
signal(SIGTTIN, SIG_DFL);
|
|||
|
|
#endif
|
|||
|
|
#ifdef SIGTTOU
|
|||
|
|
signal(SIGTTOU, SIG_DFL);
|
|||
|
|
#endif
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
*----------------------------------------------------------------------
|
|||
|
|
*
|
|||
|
|
* SetupStdFile --
|
|||
|
|
*
|
|||
|
|
* Set up stdio file handles for the child process, using the
|
|||
|
|
* current standard channels if no other files are specified.
|
|||
|
|
* If no standard channel is defined, or if no file is associated
|
|||
|
|
* with the channel, then the corresponding standard fd is closed.
|
|||
|
|
*
|
|||
|
|
* Results:
|
|||
|
|
* Returns 1 on success, or 0 on failure.
|
|||
|
|
*
|
|||
|
|
* Side effects:
|
|||
|
|
* Replaces stdio fds.
|
|||
|
|
*
|
|||
|
|
*----------------------------------------------------------------------
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
static int
|
|||
|
|
SetupStdFile(file, type)
|
|||
|
|
Tcl_File file; /* File to dup, or NULL. */
|
|||
|
|
int type; /* One of TCL_STDIN, TCL_STDOUT, TCL_STDERR */
|
|||
|
|
{
|
|||
|
|
Tcl_Channel channel;
|
|||
|
|
int fd;
|
|||
|
|
int targetFd = 0; /* Initializations here needed only to */
|
|||
|
|
int direction = 0; /* prevent warnings about using uninitialized
|
|||
|
|
* variables. */
|
|||
|
|
|
|||
|
|
switch (type) {
|
|||
|
|
case TCL_STDIN:
|
|||
|
|
targetFd = 0;
|
|||
|
|
direction = TCL_READABLE;
|
|||
|
|
break;
|
|||
|
|
case TCL_STDOUT:
|
|||
|
|
targetFd = 1;
|
|||
|
|
direction = TCL_WRITABLE;
|
|||
|
|
break;
|
|||
|
|
case TCL_STDERR:
|
|||
|
|
targetFd = 2;
|
|||
|
|
direction = TCL_WRITABLE;
|
|||
|
|
break;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (!file) {
|
|||
|
|
channel = Tcl_GetStdChannel(type);
|
|||
|
|
if (channel) {
|
|||
|
|
file = Tcl_GetChannelFile(channel, direction);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
if (file) {
|
|||
|
|
fd = (int)Tcl_GetFileInfo(file, NULL);
|
|||
|
|
if (fd != targetFd) {
|
|||
|
|
if (dup2(fd, targetFd) == -1) {
|
|||
|
|
return 0;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
* Must clear the close-on-exec flag for the target FD, since
|
|||
|
|
* some systems (e.g. Ultrix) do not clear the CLOEXEC flag on
|
|||
|
|
* the target FD.
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
fcntl(targetFd, F_SETFD, 0);
|
|||
|
|
} else {
|
|||
|
|
int result;
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
* Since we aren't dup'ing the file, we need to explicitly clear
|
|||
|
|
* the close-on-exec flag.
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
result = fcntl(fd, F_SETFD, 0);
|
|||
|
|
}
|
|||
|
|
} else {
|
|||
|
|
close(targetFd);
|
|||
|
|
}
|
|||
|
|
return 1;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
*----------------------------------------------------------------------
|
|||
|
|
*
|
|||
|
|
* TclSpawnPipeline --
|
|||
|
|
*
|
|||
|
|
* Given an argc/argv array, instantiate a pipeline of processes
|
|||
|
|
* as described by the argv.
|
|||
|
|
*
|
|||
|
|
* Results:
|
|||
|
|
* The return value is 1 on success, 0 on error
|
|||
|
|
*
|
|||
|
|
* Side effects:
|
|||
|
|
* Processes and pipes are created.
|
|||
|
|
*
|
|||
|
|
*----------------------------------------------------------------------
|
|||
|
|
*/
|
|||
|
|
int
|
|||
|
|
TclSpawnPipeline(interp, pidPtr, numPids, argc, argv, inputFile,
|
|||
|
|
outputFile, errorFile, intIn, finalOut)
|
|||
|
|
Tcl_Interp *interp; /* Interpreter in which to process pipeline. */
|
|||
|
|
int *pidPtr; /* Array of pids which are created. */
|
|||
|
|
int *numPids; /* Number of pids created. */
|
|||
|
|
int argc; /* Number of entries in argv. */
|
|||
|
|
char **argv; /* Array of strings describing commands in
|
|||
|
|
* pipeline plus I/O redirection with <,
|
|||
|
|
* <<, >, etc. argv[argc] must be NULL. */
|
|||
|
|
Tcl_File inputFile; /* If >=0, gives file id to use as input for
|
|||
|
|
* first process in pipeline (specified via <
|
|||
|
|
* or <@). */
|
|||
|
|
Tcl_File outputFile; /* Writable file id for output from last
|
|||
|
|
* command in pipeline (could be file or
|
|||
|
|
* pipe). NULL means use stdout. */
|
|||
|
|
Tcl_File errorFile; /* Writable file id for error output from all
|
|||
|
|
* commands in the pipeline. NULL means use
|
|||
|
|
* stderr */
|
|||
|
|
char *intIn; /* File name for initial input (for Win32s). */
|
|||
|
|
char *finalOut; /* File name for final output (for Win32s). */
|
|||
|
|
{
|
|||
|
|
int firstArg, lastArg;
|
|||
|
|
int pid, count;
|
|||
|
|
Tcl_DString buffer;
|
|||
|
|
char *execName;
|
|||
|
|
char errSpace[200];
|
|||
|
|
Tcl_File pipeIn, errPipeIn, errPipeOut;
|
|||
|
|
int joinThisError;
|
|||
|
|
Tcl_File curOutFile = NULL, curInFile;
|
|||
|
|
|
|||
|
|
Tcl_DStringInit(&buffer);
|
|||
|
|
pipeIn = errPipeIn = errPipeOut = NULL;
|
|||
|
|
|
|||
|
|
curInFile = inputFile;
|
|||
|
|
|
|||
|
|
for (firstArg = 0; firstArg < argc; firstArg = lastArg+1) {
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
* Convert the program name into native form.
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
Tcl_DStringFree(&buffer);
|
|||
|
|
execName = Tcl_TranslateFileName(interp, argv[firstArg], &buffer);
|
|||
|
|
if (execName == NULL) {
|
|||
|
|
goto error;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
* Find the end of the current segment of the pipeline.
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
joinThisError = 0;
|
|||
|
|
for (lastArg = firstArg; lastArg < argc; lastArg++) {
|
|||
|
|
if (argv[lastArg][0] == '|') {
|
|||
|
|
if (argv[lastArg][1] == 0) {
|
|||
|
|
break;
|
|||
|
|
}
|
|||
|
|
if ((argv[lastArg][1] == '&') && (argv[lastArg][2] == 0)) {
|
|||
|
|
joinThisError = 1;
|
|||
|
|
break;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
argv[lastArg] = NULL;
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
* If this is the last segment, use the specified outputFile.
|
|||
|
|
* Otherwise create an intermediate pipe.
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
if (lastArg == argc) {
|
|||
|
|
curOutFile = outputFile;
|
|||
|
|
} else {
|
|||
|
|
if (TclCreatePipe(&pipeIn, &curOutFile) == 0) {
|
|||
|
|
Tcl_AppendResult(interp, "couldn't create pipe: ",
|
|||
|
|
Tcl_PosixError(interp), (char *) NULL);
|
|||
|
|
goto error;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
* Create a pipe that the child can use to return error
|
|||
|
|
* information if anything goes wrong.
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
if (TclCreatePipe(&errPipeIn, &errPipeOut) == 0) {
|
|||
|
|
Tcl_AppendResult(interp, "couldn't create pipe: ",
|
|||
|
|
Tcl_PosixError(interp), (char *) NULL);
|
|||
|
|
goto error;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
pid = vfork();
|
|||
|
|
if (pid == 0) {
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
* Set up stdio file handles for the child process.
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
if (!SetupStdFile(curInFile, TCL_STDIN)
|
|||
|
|
|| !SetupStdFile(curOutFile, TCL_STDOUT)
|
|||
|
|
|| (!joinThisError && !SetupStdFile(errorFile, TCL_STDERR))
|
|||
|
|
|| (joinThisError &&
|
|||
|
|
((dup2(1,2) == -1) ||
|
|||
|
|
(fcntl(2, F_SETFD, 0) != 0)))) {
|
|||
|
|
sprintf(errSpace,
|
|||
|
|
"%dforked process couldn't set up input/output: ",
|
|||
|
|
errno);
|
|||
|
|
TclWriteFile(errPipeOut, 1, errSpace, (int) strlen(errSpace));
|
|||
|
|
_exit(1);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
* Close the input side of the error pipe.
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
RestoreSignals();
|
|||
|
|
execvp(execName, &argv[firstArg]);
|
|||
|
|
sprintf(errSpace, "%dcouldn't execute \"%.150s\": ", errno,
|
|||
|
|
argv[firstArg]);
|
|||
|
|
TclWriteFile(errPipeOut, 1, errSpace, (int) strlen(errSpace));
|
|||
|
|
_exit(1);
|
|||
|
|
}
|
|||
|
|
Tcl_DStringFree(&buffer);
|
|||
|
|
if (pid == -1) {
|
|||
|
|
Tcl_AppendResult(interp, "couldn't fork child process: ",
|
|||
|
|
Tcl_PosixError(interp), (char *) NULL);
|
|||
|
|
goto error;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
* Add the child process to the list of those to be reaped.
|
|||
|
|
* Note: must do it now, so that the process will be reaped even if
|
|||
|
|
* an error occurs during its startup.
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
pidPtr[*numPids] = pid;
|
|||
|
|
(*numPids)++;
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
* Read back from the error pipe to see if the child startup
|
|||
|
|
* up OK. The info in the pipe (if any) consists of a decimal
|
|||
|
|
* errno value followed by an error message.
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
TclCloseFile(errPipeOut);
|
|||
|
|
errPipeOut = NULL;
|
|||
|
|
|
|||
|
|
count = TclReadFile(errPipeIn, 1, errSpace,
|
|||
|
|
(size_t) (sizeof(errSpace) - 1));
|
|||
|
|
if (count > 0) {
|
|||
|
|
char *end;
|
|||
|
|
errSpace[count] = 0;
|
|||
|
|
errno = strtol(errSpace, &end, 10);
|
|||
|
|
Tcl_AppendResult(interp, end, Tcl_PosixError(interp),
|
|||
|
|
(char *) NULL);
|
|||
|
|
goto error;
|
|||
|
|
}
|
|||
|
|
TclCloseFile(errPipeIn);
|
|||
|
|
errPipeIn = NULL;
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
* Close off our copies of file descriptors that were set up for
|
|||
|
|
* this child, then set up the input for the next child.
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
if (curInFile && (curInFile != inputFile)) {
|
|||
|
|
TclCloseFile(curInFile);
|
|||
|
|
}
|
|||
|
|
curInFile = pipeIn;
|
|||
|
|
pipeIn = NULL;
|
|||
|
|
|
|||
|
|
if (curOutFile && (curOutFile != outputFile)) {
|
|||
|
|
TclCloseFile(curOutFile);
|
|||
|
|
}
|
|||
|
|
curOutFile = NULL;
|
|||
|
|
}
|
|||
|
|
return 1;
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
* An error occured, so we need to clean up any open pipes.
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
error:
|
|||
|
|
Tcl_DStringFree(&buffer);
|
|||
|
|
if (errPipeIn) {
|
|||
|
|
TclCloseFile(errPipeIn);
|
|||
|
|
}
|
|||
|
|
if (errPipeOut) {
|
|||
|
|
TclCloseFile(errPipeOut);
|
|||
|
|
}
|
|||
|
|
if (pipeIn) {
|
|||
|
|
TclCloseFile(pipeIn);
|
|||
|
|
}
|
|||
|
|
if (curOutFile && (curOutFile != outputFile)) {
|
|||
|
|
TclCloseFile(curOutFile);
|
|||
|
|
}
|
|||
|
|
if (curInFile && (curInFile != inputFile)) {
|
|||
|
|
TclCloseFile(curInFile);
|
|||
|
|
}
|
|||
|
|
return 0;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
*----------------------------------------------------------------------
|
|||
|
|
*
|
|||
|
|
* TclCreatePipe --
|
|||
|
|
*
|
|||
|
|
* Creates a pipe - simply calls the pipe() function.
|
|||
|
|
*
|
|||
|
|
* Results:
|
|||
|
|
* Returns 1 on success, 0 on failure.
|
|||
|
|
*
|
|||
|
|
* Side effects:
|
|||
|
|
* Creates a pipe.
|
|||
|
|
*
|
|||
|
|
*----------------------------------------------------------------------
|
|||
|
|
*/
|
|||
|
|
int
|
|||
|
|
TclCreatePipe(readPipe, writePipe)
|
|||
|
|
Tcl_File *readPipe; /* Location to store file handle for
|
|||
|
|
* read side of pipe. */
|
|||
|
|
Tcl_File *writePipe; /* Location to store file handle for
|
|||
|
|
* write side of pipe. */
|
|||
|
|
{
|
|||
|
|
int pipeIds[2];
|
|||
|
|
|
|||
|
|
if (pipe(pipeIds) != 0) {
|
|||
|
|
return 0;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
fcntl(pipeIds[0], F_SETFD, FD_CLOEXEC);
|
|||
|
|
fcntl(pipeIds[1], F_SETFD, FD_CLOEXEC);
|
|||
|
|
|
|||
|
|
*readPipe = Tcl_GetFile((ClientData)pipeIds[0], TCL_UNIX_FD);
|
|||
|
|
*writePipe = Tcl_GetFile((ClientData)pipeIds[1], TCL_UNIX_FD);
|
|||
|
|
return 1;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
*----------------------------------------------------------------------
|
|||
|
|
*
|
|||
|
|
* Tcl_CreatePipeline --
|
|||
|
|
*
|
|||
|
|
* This function is a compatibility wrapper for TclCreatePipeline.
|
|||
|
|
* It is only available under Unix, and may be removed from later
|
|||
|
|
* versions.
|
|||
|
|
*
|
|||
|
|
* Results:
|
|||
|
|
* Same as TclCreatePipeline.
|
|||
|
|
*
|
|||
|
|
* Side effects:
|
|||
|
|
* Same as TclCreatePipeline.
|
|||
|
|
*
|
|||
|
|
*----------------------------------------------------------------------
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
int
|
|||
|
|
Tcl_CreatePipeline(interp, argc, argv, pidArrayPtr, inPipePtr,
|
|||
|
|
outPipePtr, errFilePtr)
|
|||
|
|
Tcl_Interp *interp;
|
|||
|
|
int argc;
|
|||
|
|
char **argv;
|
|||
|
|
int **pidArrayPtr;
|
|||
|
|
int *inPipePtr;
|
|||
|
|
int *outPipePtr;
|
|||
|
|
int *errFilePtr;
|
|||
|
|
{
|
|||
|
|
Tcl_File inFile, outFile, errFile;
|
|||
|
|
int result;
|
|||
|
|
|
|||
|
|
result = TclCreatePipeline(interp, argc, argv, pidArrayPtr,
|
|||
|
|
(inPipePtr ? &inFile : NULL),
|
|||
|
|
(outPipePtr ? &outFile : NULL),
|
|||
|
|
(errFilePtr ? &errFile : NULL));
|
|||
|
|
|
|||
|
|
if (inPipePtr) {
|
|||
|
|
if (inFile) {
|
|||
|
|
*inPipePtr = (int) Tcl_GetFileInfo(inFile, NULL);
|
|||
|
|
Tcl_FreeFile(inFile);
|
|||
|
|
} else {
|
|||
|
|
*inPipePtr = -1;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
if (outPipePtr) {
|
|||
|
|
if (outFile) {
|
|||
|
|
*outPipePtr = (int) Tcl_GetFileInfo(outFile, NULL);
|
|||
|
|
Tcl_FreeFile(outFile);
|
|||
|
|
} else {
|
|||
|
|
*outPipePtr = -1;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
if (errFilePtr) {
|
|||
|
|
if (errFile) {
|
|||
|
|
*errFilePtr = (int) Tcl_GetFileInfo(errFile, NULL);
|
|||
|
|
Tcl_FreeFile(errFile);
|
|||
|
|
} else {
|
|||
|
|
*errFilePtr = -1;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
return result;
|
|||
|
|
}
|