开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 通讯编程 > 查看源码
tclUnixPipe.c
资源名称：ns-allinone-2.33.tar.gz　[点击查看]
上传用户：rrhhcc
上传日期：2015-12-11
资源大小：54129k
文件大小：33k
源码类别：

通讯编程

开发平台：

Visual C++

tclUnixPipe.c：源码内容
  1. /* 
  2.  * tclUnixPipe.c --
  3.  *
  4.  * This file implements the UNIX-specific exec pipeline functions,
  5.  * the "pipe" channel driver, and the "pid" Tcl command.
  6.  *
  7.  * Copyright (c) 1991-1994 The Regents of the University of California.
  8.  * Copyright (c) 1994-1997 Sun Microsystems, Inc.
  9.  *
  10.  * See the file "license.terms" for information on usage and redistribution
  11.  * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
  12.  *
  13.  * RCS: @(#) $Id: tclUnixPipe.c,v 1.23.2.7 2006/08/02 20:04:40 das Exp $
  14.  */
  16. #include "tclInt.h"
  17. #include "tclPort.h"
  19. #ifdef USE_VFORK
  20. #define fork vfork
  21. #endif
  23. /*
  24.  * The following macros convert between TclFile's and fd's.  The conversion
  25.  * simple involves shifting fd's up by one to ensure that no valid fd is ever
  26.  * the same as NULL.
  27.  */
  29. #define MakeFile(fd) ((TclFile)(((int)fd)+1))
  30. #define GetFd(file) (((int)file)-1)
  32. /*
  33.  * This structure describes per-instance state of a pipe based channel.
  34.  */
  36. typedef struct PipeState {
  37.     Tcl_Channel channel;/* Channel associated with this file. */
  38.     TclFile inFile; /* Output from pipe. */
  39.     TclFile outFile; /* Input to pipe. */
  40.     TclFile errorFile; /* Error output from pipe. */
  41.     int numPids; /* How many processes are attached to this pipe? */
  42.     Tcl_Pid *pidPtr; /* The process IDs themselves. Allocated by
  43.                          * the creator of the pipe. */
  44.     int isNonBlocking; /* Nonzero when the pipe is in nonblocking mode.
  45.                          * Used to decide whether to wait for the children
  46.                          * at close time. */
  47. } PipeState;
  49. /*
  50.  * Declarations for local procedures defined in this file:
  51.  */
  53. static int PipeBlockModeProc _ANSI_ARGS_((ClientData instanceData,
  54.     int mode));
  55. static int PipeCloseProc _ANSI_ARGS_((ClientData instanceData,
  56.     Tcl_Interp *interp));
  57. static int PipeGetHandleProc _ANSI_ARGS_((ClientData instanceData,
  58.     int direction, ClientData *handlePtr));
  59. static int PipeInputProc _ANSI_ARGS_((ClientData instanceData,
  60.     char *buf, int toRead, int *errorCode));
  61. static int PipeOutputProc _ANSI_ARGS_((
  62.     ClientData instanceData, CONST char *buf, int toWrite,
  63.     int *errorCode));
  64. static void PipeWatchProc _ANSI_ARGS_((ClientData instanceData, int mask));
  65. static void RestoreSignals _ANSI_ARGS_((void));
  66. static int SetupStdFile _ANSI_ARGS_((TclFile file, int type));
  68. /*
  69.  * This structure describes the channel type structure for command pipe
  70.  * based IO:
  71.  */
  73. static Tcl_ChannelType pipeChannelType = {
  74.     "pipe", /* Type name. */
  75.     TCL_CHANNEL_VERSION_4, /* v4 channel */
  76.     PipeCloseProc, /* Close proc. */
  77.     PipeInputProc, /* Input proc. */
  78.     PipeOutputProc, /* Output proc. */
  79.     NULL, /* Seek proc. */
  80.     NULL, /* Set option proc. */
  81.     NULL, /* Get option proc. */
  82.     PipeWatchProc, /* Initialize notifier. */
  83.     PipeGetHandleProc, /* Get OS handles out of channel. */
  84.     NULL, /* close2proc. */
  85.     PipeBlockModeProc, /* Set blocking or non-blocking mode.*/
  86.     NULL, /* flush proc. */
  87.     NULL, /* handler proc. */
  88.     NULL,                       /* wide seek proc */
  89.     NULL,                       /* thread action proc */
  90. };
  92. /*
  93.  *----------------------------------------------------------------------
  94.  *
  95.  * TclpMakeFile --
  96.  *
  97.  * Make a TclFile from a channel.
  98.  *
  99.  * Results:
  100.  * Returns a new TclFile or NULL on failure.
  101.  *
  102.  * Side effects:
  103.  * None.
  104.  *
  105.  *----------------------------------------------------------------------
  106.  */
  108. TclFile
  109. TclpMakeFile(channel, direction)
  110.     Tcl_Channel channel; /* Channel to get file from. */
  111.     int direction; /* Either TCL_READABLE or TCL_WRITABLE. */
  112. {
  113.     ClientData data;
  115.     if (Tcl_GetChannelHandle(channel, direction, (ClientData *) &data)
  116.     == TCL_OK) {
  117. return MakeFile((int)data);
  118.     } else {
  119. return (TclFile) NULL;
  120.     }
  121. }
  123. /*
  124.  *----------------------------------------------------------------------
  125.  *
  126.  * TclpOpenFile --
  127.  *
  128.  * Open a file for use in a pipeline.  
  129.  *
  130.  * Results:
  131.  * Returns a new TclFile handle or NULL on failure.
  132.  *
  133.  * Side effects:
  134.  * May cause a file to be created on the file system.
  135.  *
  136.  *----------------------------------------------------------------------
  137.  */
  139. TclFile
  140. TclpOpenFile(fname, mode)
  141.     CONST char *fname; /* The name of the file to open. */
  142.     int mode; /* In what mode to open the file? */
  143. {
  144.     int fd;
  145.     CONST char *native;
  146.     Tcl_DString ds;
  148.     native = Tcl_UtfToExternalDString(NULL, fname, -1, &ds);
  149.     fd = TclOSopen(native, mode, 0666); /* INTL: Native. */
  150.     Tcl_DStringFree(&ds);
  151.     if (fd != -1) {
  152.         fcntl(fd, F_SETFD, FD_CLOEXEC);
  154. /*
  155.  * If the file is being opened for writing, seek to the end
  156.  * so we can append to any data already in the file.
  157.  */
  159. if ((mode & O_WRONLY) && !(mode & O_APPEND)) {
  160.     TclOSseek(fd, (Tcl_SeekOffset) 0, SEEK_END);
  161. }
  163. /*
  164.  * Increment the fd so it can't be 0, which would conflict with
  165.  * the NULL return for errors.
  166.  */
  168. return MakeFile(fd);
  169.     }
  170.     return NULL;
  171. }
  173. /*
  174.  *----------------------------------------------------------------------
  175.  *
  176.  * TclpCreateTempFile --
  177.  *
  178.  * This function creates a temporary file initialized with an
  179.  * optional string, and returns a file handle with the file pointer
  180.  * at the beginning of the file.
  181.  *
  182.  * Results:
  183.  * A handle to a file.
  184.  *
  185.  * Side effects:
  186.  * None.
  187.  *
  188.  *----------------------------------------------------------------------
  189.  */
  191. TclFile
  192. TclpCreateTempFile(contents)
  193.     CONST char *contents; /* String to write into temp file, or NULL. */
  194. {
  195.     char fileName[L_tmpnam + 9];
  196.     CONST char *native;
  197.     Tcl_DString dstring;
  198.     int fd;
  200.     /*
  201.      * We should also check against making more then TMP_MAX of these.
  202.      */
  204.     strcpy(fileName, P_tmpdir); /* INTL: Native. */
  205.     if (fileName[strlen(fileName) - 1] != '/') {
  206. strcat(fileName, "/"); /* INTL: Native. */
  207.     }
  208.     strcat(fileName, "tclXXXXXX");
  209.     fd = mkstemp(fileName); /* INTL: Native. */
  210.     if (fd == -1) {
  211. return NULL;
  212.     }
  213.     fcntl(fd, F_SETFD, FD_CLOEXEC);
  214.     unlink(fileName); /* INTL: Native. */
  216.     if (contents != NULL) {
  217. native = Tcl_UtfToExternalDString(NULL, contents, -1, &dstring);
  218. if (write(fd, native, strlen(native)) == -1) {
  219.     close(fd);
  220.     Tcl_DStringFree(&dstring);
  221.     return NULL;
  222. }
  223. Tcl_DStringFree(&dstring);
  224. TclOSseek(fd, (Tcl_SeekOffset) 0, SEEK_SET);
  225.     }
  226.     return MakeFile(fd);
  227. }
  229. /*
  230.  *----------------------------------------------------------------------
  231.  *
  232.  * TclpTempFileName --
  233.  *
  234.  * This function returns unique filename.
  235.  *
  236.  * Results:
  237.  * Returns a valid Tcl_Obj* with refCount 0, or NULL on failure.
  238.  *
  239.  * Side effects:
  240.  * None.
  241.  *
  242.  *----------------------------------------------------------------------
  243.  */
  245. Tcl_Obj* 
  246. TclpTempFileName()
  247. {
  248.     char fileName[L_tmpnam + 9];
  249.     Tcl_Obj *result = NULL;
  250.     int fd;
  252.     /*
  253.      * We should also check against making more then TMP_MAX of these.
  254.      */
  256.     strcpy(fileName, P_tmpdir); /* INTL: Native. */
  257.     if (fileName[strlen(fileName) - 1] != '/') {
  258. strcat(fileName, "/"); /* INTL: Native. */
  259.     }
  260.     strcat(fileName, "tclXXXXXX");
  261.     fd = mkstemp(fileName); /* INTL: Native. */
  262.     if (fd == -1) {
  263. return NULL;
  264.     }
  265.     fcntl(fd, F_SETFD, FD_CLOEXEC);
  266.     unlink(fileName); /* INTL: Native. */
  268.     result = TclpNativeToNormalized((ClientData) fileName);
  269.     close (fd);
  270.     return result;
  271. }
  273. /*
  274.  *----------------------------------------------------------------------
  275.  *
  276.  * TclpCreatePipe --
  277.  *
  278.  *      Creates a pipe - simply calls the pipe() function.
  279.  *
  280.  * Results:
  281.  *      Returns 1 on success, 0 on failure. 
  282.  *
  283.  * Side effects:
  284.  *      Creates a pipe.
  285.  *
  286.  *----------------------------------------------------------------------
  287.  */
  289. int
  290. TclpCreatePipe(readPipe, writePipe)
  291.     TclFile *readPipe; /* Location to store file handle for
  292.  * read side of pipe. */
  293.     TclFile *writePipe; /* Location to store file handle for
  294.  * write side of pipe. */
  295. {
  296.     int pipeIds[2];
  298.     if (pipe(pipeIds) != 0) {
  299. return 0;
  300.     }
  302.     fcntl(pipeIds[0], F_SETFD, FD_CLOEXEC);
  303.     fcntl(pipeIds[1], F_SETFD, FD_CLOEXEC);
  305.     *readPipe = MakeFile(pipeIds[0]);
  306.     *writePipe = MakeFile(pipeIds[1]);
  307.     return 1;
  308. }
  310. /*
  311.  *----------------------------------------------------------------------
  312.  *
  313.  * TclpCloseFile --
  314.  *
  315.  * Implements a mechanism to close a UNIX file.
  316.  *
  317.  * Results:
  318.  * Returns 0 on success, or -1 on error, setting errno.
  319.  *
  320.  * Side effects:
  321.  * The file is closed.
  322.  *
  323.  *----------------------------------------------------------------------
  324.  */
  326. int
  327. TclpCloseFile(file)
  328.     TclFile file; /* The file to close. */
  329. {
  330.     int fd = GetFd(file);
  332.     /*
  333.      * Refuse to close the fds for stdin, stdout and stderr.
  334.      */
  335.     
  336.     if ((fd == 0) || (fd == 1) || (fd == 2)) {
  337.         return 0;
  338.     }
  339.     
  340.     Tcl_DeleteFileHandler(fd);
  341.     return close(fd);
  342. }
  344. /*
  345.  *---------------------------------------------------------------------------
  346.  *
  347.  * TclpCreateProcess --
  348.  *
  349.  * Create a child process that has the specified files as its 
  350.  * standard input, output, and error.  The child process runs
  351.  * asynchronously and runs with the same environment variables
  352.  * as the creating process.
  353.  *
  354.  * The path is searched to find the specified executable.  
  355.  *
  356.  * Results:
  357.  * The return value is TCL_ERROR and an error message is left in
  358.  * the interp's result if there was a problem creating the child 
  359.  * process.  Otherwise, the return value is TCL_OK and *pidPtr is
  360.  * filled with the process id of the child process.
  361.  * 
  362.  * Side effects:
  363.  * A process is created.
  364.  *
  365.  *---------------------------------------------------------------------------
  366.  */
  368.     /* ARGSUSED */
  369. int
  370. TclpCreateProcess(interp, argc, argv, inputFile, outputFile, errorFile, 
  371. pidPtr)
  372.     Tcl_Interp *interp; /* Interpreter in which to leave errors that
  373.  * occurred when creating the child process.
  374.  * Error messages from the child process
  375.  * itself are sent to errorFile. */
  376.     int argc; /* Number of arguments in following array. */
  377.     CONST char **argv; /* Array of argument strings in UTF-8.
  378.  * argv[0] contains the name of the executable
  379.  * translated using Tcl_TranslateFileName
  380.  * call).  Additional arguments have not been
  381.  * converted. */
  382.     TclFile inputFile; /* If non-NULL, gives the file to use as
  383.  * input for the child process.  If inputFile
  384.  * file is not readable or is NULL, the child
  385.  * will receive no standard input. */
  386.     TclFile outputFile; /* If non-NULL, gives the file that
  387.  * receives output from the child process.  If
  388.  * outputFile file is not writeable or is
  389.  * NULL, output from the child will be
  390.  * discarded. */
  391.     TclFile errorFile; /* If non-NULL, gives the file that
  392.  * receives errors from the child process.  If
  393.  * errorFile file is not writeable or is NULL,
  394.  * errors from the child will be discarded.
  395.  * errorFile may be the same as outputFile. */
  396.     Tcl_Pid *pidPtr; /* If this procedure is successful, pidPtr
  397.  * is filled with the process id of the child
  398.  * process. */
  399. {
  400.     TclFile errPipeIn, errPipeOut;
  401.     int count, status, fd;
  402.     char errSpace[200 + TCL_INTEGER_SPACE];
  403.     Tcl_DString *dsArray;
  404.     char **newArgv;
  405.     int pid, i;
  406.     
  407.     errPipeIn = NULL;
  408.     errPipeOut = NULL;
  409.     pid = -1;
  411.     /*
  412.      * Create a pipe that the child can use to return error
  413.      * information if anything goes wrong.
  414.      */
  416.     if (TclpCreatePipe(&errPipeIn, &errPipeOut) == 0) {
  417. Tcl_AppendResult(interp, "couldn't create pipe: ",
  418. Tcl_PosixError(interp), (char *) NULL);
  419. goto error;
  420.     }
  422.     /*
  423.      * We need to allocate and convert this before the fork
  424.      * so it is properly deallocated later
  425.      */
  426.     dsArray = (Tcl_DString *) ckalloc(argc * sizeof(Tcl_DString));
  427.     newArgv = (char **) ckalloc((argc+1) * sizeof(char *));
  428.     newArgv[argc] = NULL;
  429.     for (i = 0; i < argc; i++) {
  430. newArgv[i] = Tcl_UtfToExternalDString(NULL, argv[i], -1, &dsArray[i]);
  431.     }
  433. #ifdef USE_VFORK
  434.     /*
  435.      * After vfork(), do not call code in the child that changes global state,
  436.      * because it is using the parent's memory space at that point and writes
  437.      * might corrupt the parent: so ensure standard channels are initialized in
  438.      * the parent, otherwise SetupStdFile() might initialize them in the child.
  439.      */
  440.     if (!inputFile) {
  441. Tcl_GetStdChannel(TCL_STDIN);
  442.     }
  443.     if (!outputFile) {
  444.         Tcl_GetStdChannel(TCL_STDOUT);
  445.     }
  446.     if (!errorFile) {
  447.         Tcl_GetStdChannel(TCL_STDERR);
  448.     }
  449. #endif
  450.     pid = fork();
  451.     if (pid == 0) {
  452. int joinThisError = errorFile && (errorFile == outputFile);
  454. fd = GetFd(errPipeOut);
  456. /*
  457.  * Set up stdio file handles for the child process.
  458.  */
  460. if (!SetupStdFile(inputFile, TCL_STDIN)
  461. || !SetupStdFile(outputFile, TCL_STDOUT)
  462. || (!joinThisError && !SetupStdFile(errorFile, TCL_STDERR))
  463. || (joinThisError &&
  464. ((dup2(1,2) == -1) ||
  465.  (fcntl(2, F_SETFD, 0) != 0)))) {
  466.     sprintf(errSpace,
  467.     "%dforked process couldn't set up input/output: ", errno);
  468.     write(fd, errSpace, (size_t) strlen(errSpace));
  469.     _exit(1);
  470. }
  472. /*
  473.  * Close the input side of the error pipe.
  474.  */
  476. RestoreSignals();
  477. execvp(newArgv[0], newArgv); /* INTL: Native. */
  478. sprintf(errSpace, "%dcouldn't execute "%.150s": ", errno, argv[0]);
  479. write(fd, errSpace, (size_t) strlen(errSpace));
  480. _exit(1);
  481.     }
  482.     
  483.     /*
  484.      * Free the mem we used for the fork
  485.      */
  486.     for (i = 0; i < argc; i++) {
  487. Tcl_DStringFree(&dsArray[i]);
  488.     }
  489.     ckfree((char *) dsArray);
  490.     ckfree((char *) newArgv);
  492.     if (pid == -1) {
  493. Tcl_AppendResult(interp, "couldn't fork child process: ",
  494. Tcl_PosixError(interp), (char *) NULL);
  495. goto error;
  496.     }
  498.     /*
  499.      * Read back from the error pipe to see if the child started
  500.      * up OK.  The info in the pipe (if any) consists of a decimal
  501.      * errno value followed by an error message.
  502.      */
  504.     TclpCloseFile(errPipeOut);
  505.     errPipeOut = NULL;
  507.     fd = GetFd(errPipeIn);
  508.     count = read(fd, errSpace, (size_t) (sizeof(errSpace) - 1));
  509.     if (count > 0) {
  510. char *end;
  511. errSpace[count] = 0;
  512. errno = strtol(errSpace, &end, 10);
  513. Tcl_AppendResult(interp, end, Tcl_PosixError(interp),
  514. (char *) NULL);
  515. goto error;
  516.     }
  517.     
  518.     TclpCloseFile(errPipeIn);
  519.     *pidPtr = (Tcl_Pid) pid;
  520.     return TCL_OK;
  522.     error:
  523.     if (pid != -1) {
  524. /*
  525.  * Reap the child process now if an error occurred during its
  526.  * startup.  We don't call this with WNOHANG because that can lead to
  527.  * defunct processes on an MP system.   We shouldn't have to worry
  528.  * about hanging here, since this is the error case.  [Bug: 6148]
  529.  */
  531. Tcl_WaitPid((Tcl_Pid) pid, &status, 0);
  532.     }
  533.     
  534.     if (errPipeIn) {
  535. TclpCloseFile(errPipeIn);
  536.     }
  537.     if (errPipeOut) {
  538. TclpCloseFile(errPipeOut);
  539.     }
  540.     return TCL_ERROR;
  541. }
  543. /*
  544.  *----------------------------------------------------------------------
  545.  *
  546.  * RestoreSignals --
  547.  *
  548.  *      This procedure is invoked in a forked child process just before
  549.  *      exec-ing a new program to restore all signals to their default
  550.  *      settings.
  551.  *
  552.  * Results:
  553.  *      None.
  554.  *
  555.  * Side effects:
  556.  *      Signal settings get changed.
  557.  *
  558.  *----------------------------------------------------------------------
  559.  */
  560.  
  561. static void
  562. RestoreSignals()
  563. {
  564. #ifdef SIGABRT
  565.     signal(SIGABRT, SIG_DFL);
  566. #endif
  567. #ifdef SIGALRM
  568.     signal(SIGALRM, SIG_DFL);
  569. #endif
  570. #ifdef SIGFPE
  571.     signal(SIGFPE, SIG_DFL);
  572. #endif
  573. #ifdef SIGHUP
  574.     signal(SIGHUP, SIG_DFL);
  575. #endif
  576. #ifdef SIGILL
  577.     signal(SIGILL, SIG_DFL);
  578. #endif
  579. #ifdef SIGINT
  580.     signal(SIGINT, SIG_DFL);
  581. #endif
  582. #ifdef SIGPIPE
  583.     signal(SIGPIPE, SIG_DFL);
  584. #endif
  585. #ifdef SIGQUIT
  586.     signal(SIGQUIT, SIG_DFL);
  587. #endif
  588. #ifdef SIGSEGV
  589.     signal(SIGSEGV, SIG_DFL);
  590. #endif
  591. #ifdef SIGTERM
  592.     signal(SIGTERM, SIG_DFL);
  593. #endif
  594. #ifdef SIGUSR1
  595.     signal(SIGUSR1, SIG_DFL);
  596. #endif
  597. #ifdef SIGUSR2
  598.     signal(SIGUSR2, SIG_DFL);
  599. #endif
  600. #ifdef SIGCHLD
  601.     signal(SIGCHLD, SIG_DFL);
  602. #endif
  603. #ifdef SIGCONT
  604.     signal(SIGCONT, SIG_DFL);
  605. #endif
  606. #ifdef SIGTSTP
  607.     signal(SIGTSTP, SIG_DFL);
  608. #endif
  609. #ifdef SIGTTIN
  610.     signal(SIGTTIN, SIG_DFL);
  611. #endif
  612. #ifdef SIGTTOU
  613.     signal(SIGTTOU, SIG_DFL);
  614. #endif
  615. }
  617. /*
  618.  *----------------------------------------------------------------------
  619.  *
  620.  * SetupStdFile --
  621.  *
  622.  * Set up stdio file handles for the child process, using the
  623.  * current standard channels if no other files are specified.
  624.  * If no standard channel is defined, or if no file is associated
  625.  * with the channel, then the corresponding standard fd is closed.
  626.  *
  627.  * Results:
  628.  * Returns 1 on success, or 0 on failure.
  629.  *
  630.  * Side effects:
  631.  * Replaces stdio fds.
  632.  *
  633.  *----------------------------------------------------------------------
  634.  */
  636. static int
  637. SetupStdFile(file, type)
  638.     TclFile file; /* File to dup, or NULL. */
  639.     int type; /* One of TCL_STDIN, TCL_STDOUT, TCL_STDERR */
  640. {
  641.     Tcl_Channel channel;
  642.     int fd;
  643.     int targetFd = 0; /* Initializations here needed only to */
  644.     int direction = 0; /* prevent warnings about using uninitialized
  645.  * variables. */
  647.     switch (type) {
  648. case TCL_STDIN:
  649.     targetFd = 0;
  650.     direction = TCL_READABLE;
  651.     break;
  652. case TCL_STDOUT:
  653.     targetFd = 1;
  654.     direction = TCL_WRITABLE;
  655.     break;
  656. case TCL_STDERR:
  657.     targetFd = 2;
  658.     direction = TCL_WRITABLE;
  659.     break;
  660.     }
  662.     if (!file) {
  663. channel = Tcl_GetStdChannel(type);
  664. if (channel) {
  665.     file = TclpMakeFile(channel, direction);
  666. }
  667.     }
  668.     if (file) {
  669. fd = GetFd(file);
  670. if (fd != targetFd) {
  671.     if (dup2(fd, targetFd) == -1) {
  672. return 0;
  673.     }
  675.             /*
  676.              * Must clear the close-on-exec flag for the target FD, since
  677.              * some systems (e.g. Ultrix) do not clear the CLOEXEC flag on
  678.              * the target FD.
  679.              */
  680.             
  681.             fcntl(targetFd, F_SETFD, 0);
  682. } else {
  683.     /*
  684.      * Since we aren't dup'ing the file, we need to explicitly clear
  685.      * the close-on-exec flag.
  686.      */
  688.    fcntl(fd, F_SETFD, 0);
  689. }
  690.     } else {
  691. close(targetFd);
  692.     }
  693.     return 1;
  694. }
  696. /*
  697.  *----------------------------------------------------------------------
  698.  *
  699.  * TclpCreateCommandChannel --
  700.  *
  701.  * This function is called by the generic IO level to perform
  702.  * the platform specific channel initialization for a command
  703.  * channel.
  704.  *
  705.  * Results:
  706.  * Returns a new channel or NULL on failure.
  707.  *
  708.  * Side effects:
  709.  * Allocates a new channel.
  710.  *
  711.  *----------------------------------------------------------------------
  712.  */
  714. Tcl_Channel
  715. TclpCreateCommandChannel(readFile, writeFile, errorFile, numPids, pidPtr)
  716.     TclFile readFile; /* If non-null, gives the file for reading. */
  717.     TclFile writeFile; /* If non-null, gives the file for writing. */
  718.     TclFile errorFile; /* If non-null, gives the file where errors
  719.  * can be read. */
  720.     int numPids; /* The number of pids in the pid array. */
  721.     Tcl_Pid *pidPtr; /* An array of process identifiers.
  722.                                  * Allocated by the caller, freed when
  723.                                  * the channel is closed or the processes
  724.                                  * are detached (in a background exec). */
  725. {
  726.     char channelName[16 + TCL_INTEGER_SPACE];
  727.     int channelId;
  728.     PipeState *statePtr = (PipeState *) ckalloc((unsigned) sizeof(PipeState));
  729.     int mode;
  731.     statePtr->inFile = readFile;
  732.     statePtr->outFile = writeFile;
  733.     statePtr->errorFile = errorFile;
  734.     statePtr->numPids = numPids;
  735.     statePtr->pidPtr = pidPtr;
  736.     statePtr->isNonBlocking = 0;
  738.     mode = 0;
  739.     if (readFile) {
  740.         mode |= TCL_READABLE;
  741.     }
  742.     if (writeFile) {
  743.         mode |= TCL_WRITABLE;
  744.     }
  745.     
  746.     /*
  747.      * Use one of the fds associated with the channel as the
  748.      * channel id.
  749.      */
  751.     if (readFile) {
  752. channelId = GetFd(readFile);
  753.     } else if (writeFile) {
  754. channelId = GetFd(writeFile);
  755.     } else if (errorFile) {
  756. channelId = GetFd(errorFile);
  757.     } else {
  758. channelId = 0;
  759.     }
  761.     /*
  762.      * For backward compatibility with previous versions of Tcl, we
  763.      * use "file%d" as the base name for pipes even though it would
  764.      * be more natural to use "pipe%d".
  765.      */
  767.     sprintf(channelName, "file%d", channelId);
  768.     statePtr->channel = Tcl_CreateChannel(&pipeChannelType, channelName,
  769.             (ClientData) statePtr, mode);
  770.     return statePtr->channel;
  771. }
  773. /*
  774.  *----------------------------------------------------------------------
  775.  *
  776.  * TclGetAndDetachPids --
  777.  *
  778.  * This procedure is invoked in the generic implementation of a
  779.  * background "exec" (An exec when invoked with a terminating "&")
  780.  * to store a list of the PIDs for processes in a command pipeline
  781.  * in the interp's result and to detach the processes.
  782.  *
  783.  * Results:
  784.  * None.
  785.  *
  786.  * Side effects:
  787.  * Modifies the interp's result. Detaches processes.
  788.  *
  789.  *----------------------------------------------------------------------
  790.  */
  792. void
  793. TclGetAndDetachPids(interp, chan)
  794.     Tcl_Interp *interp;
  795.     Tcl_Channel chan;
  796. {
  797.     PipeState *pipePtr;
  798.     Tcl_ChannelType *chanTypePtr;
  799.     int i;
  800.     char buf[TCL_INTEGER_SPACE];
  802.     /*
  803.      * Punt if the channel is not a command channel.
  804.      */
  806.     chanTypePtr = Tcl_GetChannelType(chan);
  807.     if (chanTypePtr != &pipeChannelType) {
  808.         return;
  809.     }
  811.     pipePtr = (PipeState *) Tcl_GetChannelInstanceData(chan);
  812.     for (i = 0; i < pipePtr->numPids; i++) {
  813.         TclFormatInt(buf, (long) TclpGetPid(pipePtr->pidPtr[i]));
  814.         Tcl_AppendElement(interp, buf);
  815.         Tcl_DetachPids(1, &(pipePtr->pidPtr[i]));
  816.     }
  817.     if (pipePtr->numPids > 0) {
  818.         ckfree((char *) pipePtr->pidPtr);
  819.         pipePtr->numPids = 0;
  820.     }
  821. }
  823. /*
  824.  *----------------------------------------------------------------------
  825.  *
  826.  * PipeBlockModeProc --
  827.  *
  828.  * Helper procedure to set blocking and nonblocking modes on a
  829.  * pipe based channel. Invoked by generic IO level code.
  830.  *
  831.  * Results:
  832.  * 0 if successful, errno when failed.
  833.  *
  834.  * Side effects:
  835.  * Sets the device into blocking or non-blocking mode.
  836.  *
  837.  *----------------------------------------------------------------------
  838.  */
  840. /* ARGSUSED */
  841. static int
  842. PipeBlockModeProc(instanceData, mode)
  843.     ClientData instanceData; /* Pipe state. */
  844.     int mode; /* The mode to set. Can be one of
  845.                                          * TCL_MODE_BLOCKING or
  846.                                          * TCL_MODE_NONBLOCKING. */
  847. {
  848.     PipeState *psPtr = (PipeState *) instanceData;
  849.     int curStatus;
  850.     int fd;
  852. #ifndef USE_FIONBIO    
  853.     if (psPtr->inFile) {
  854.         fd = GetFd(psPtr->inFile);
  855.         curStatus = fcntl(fd, F_GETFL);
  856.         if (mode == TCL_MODE_BLOCKING) {
  857.             curStatus &= (~(O_NONBLOCK));
  858.         } else {
  859.             curStatus |= O_NONBLOCK;
  860.         }
  861.         if (fcntl(fd, F_SETFL, curStatus) < 0) {
  862.             return errno;
  863.         }
  864.     }
  865.     if (psPtr->outFile) {
  866.         fd = GetFd(psPtr->outFile);
  867.         curStatus = fcntl(fd, F_GETFL);
  868.         if (mode == TCL_MODE_BLOCKING) {
  869.             curStatus &= (~(O_NONBLOCK));
  870.         } else {
  871.             curStatus |= O_NONBLOCK;
  872.         }
  873.         if (fcntl(fd, F_SETFL, curStatus) < 0) {
  874.             return errno;
  875.         }
  876.     }
  877. #endif /* !FIONBIO */
  879. #ifdef USE_FIONBIO
  880.     if (psPtr->inFile) {
  881.         fd = GetFd(psPtr->inFile);
  882.         if (mode == TCL_MODE_BLOCKING) {
  883.             curStatus = 0;
  884.         } else {
  885.             curStatus = 1;
  886.         }
  887.         if (ioctl(fd, (int) FIONBIO, &curStatus) < 0) {
  888.             return errno;
  889.         }
  890.     }
  891.     if (psPtr->outFile != NULL) {
  892.         fd = GetFd(psPtr->outFile);
  893.         if (mode == TCL_MODE_BLOCKING) {
  894.             curStatus = 0;
  895.         } else {
  896.             curStatus = 1;
  897.         }
  898.         if (ioctl(fd, (int) FIONBIO,  &curStatus) < 0) {
  899.             return errno;
  900.         }
  901.     }
  902. #endif /* USE_FIONBIO */
  904.     psPtr->isNonBlocking = (mode == TCL_MODE_NONBLOCKING);
  906.     return 0;
  907. }
  909. /*
  910.  *----------------------------------------------------------------------
  911.  *
  912.  * PipeCloseProc --
  913.  *
  914.  * This procedure is invoked by the generic IO level to perform
  915.  * channel-type-specific cleanup when a command pipeline channel
  916.  * is closed.
  917.  *
  918.  * Results:
  919.  * 0 on success, errno otherwise.
  920.  *
  921.  * Side effects:
  922.  * Closes the command pipeline channel.
  923.  *
  924.  *----------------------------------------------------------------------
  925.  */
  927. /* ARGSUSED */
  928. static int
  929. PipeCloseProc(instanceData, interp)
  930.     ClientData instanceData; /* The pipe to close. */
  931.     Tcl_Interp *interp; /* For error reporting. */
  932. {
  933.     PipeState *pipePtr;
  934.     Tcl_Channel errChan;
  935.     int errorCode, result;
  937.     errorCode = 0;
  938.     result = 0;
  939.     pipePtr = (PipeState *) instanceData;
  940.     if (pipePtr->inFile) {
  941. if (TclpCloseFile(pipePtr->inFile) < 0) {
  942.     errorCode = errno;
  943. }
  944.     }
  945.     if (pipePtr->outFile) {
  946. if ((TclpCloseFile(pipePtr->outFile) < 0) && (errorCode == 0)) {
  947.     errorCode = errno;
  948. }
  949.     }
  951.     if (pipePtr->isNonBlocking || TclInExit()) {
  952.     
  953. /*
  954.          * If the channel is non-blocking or Tcl is being cleaned up, just
  955.          * detach the children PIDs, reap them (important if we are in a
  956.          * dynamic load module), and discard the errorFile.
  957.          */
  958.         
  959.         Tcl_DetachPids(pipePtr->numPids, pipePtr->pidPtr);
  960.         Tcl_ReapDetachedProcs();
  962.         if (pipePtr->errorFile) {
  963.     TclpCloseFile(pipePtr->errorFile);
  964.         }
  965.     } else {
  966.         
  967. /*
  968.          * Wrap the error file into a channel and give it to the cleanup
  969.          * routine.
  970.          */
  972.         if (pipePtr->errorFile) {
  973.     errChan = Tcl_MakeFileChannel(
  974. (ClientData) GetFd(pipePtr->errorFile), TCL_READABLE);
  975.         } else {
  976.             errChan = NULL;
  977.         }
  978.         result = TclCleanupChildren(interp, pipePtr->numPids, pipePtr->pidPtr,
  979.                 errChan);
  980.     }
  982.     if (pipePtr->numPids != 0) {
  983.         ckfree((char *) pipePtr->pidPtr);
  984.     }
  985.     ckfree((char *) pipePtr);
  986.     if (errorCode == 0) {
  987.         return result;
  988.     }
  989.     return errorCode;
  990. }
  992. /*
  993.  *----------------------------------------------------------------------
  994.  *
  995.  * PipeInputProc --
  996.  *
  997.  * This procedure is invoked from the generic IO level to read
  998.  * input from a command pipeline based channel.
  999.  *
  1000.  * Results:
  1001.  * The number of bytes read is returned or -1 on error. An output
  1002.  * argument contains a POSIX error code if an error occurs, or zero.
  1003.  *
  1004.  * Side effects:
  1005.  * Reads input from the input device of the channel.
  1006.  *
  1007.  *----------------------------------------------------------------------
  1008.  */
  1010. static int
  1011. PipeInputProc(instanceData, buf, toRead, errorCodePtr)
  1012.     ClientData instanceData; /* Pipe state. */
  1013.     char *buf; /* Where to store data read. */
  1014.     int toRead; /* How much space is available
  1015.                                          * in the buffer? */
  1016.     int *errorCodePtr; /* Where to store error code. */
  1017. {
  1018.     PipeState *psPtr = (PipeState *) instanceData;
  1019.     int bytesRead; /* How many bytes were actually
  1020.                                          * read from the input device? */
  1022.     *errorCodePtr = 0;
  1023.     
  1024.     /*
  1025.      * Assume there is always enough input available. This will block
  1026.      * appropriately, and read will unblock as soon as a short read is
  1027.      * possible, if the channel is in blocking mode. If the channel is
  1028.      * nonblocking, the read will never block.
  1029.      * Some OSes can throw an interrupt error, for which we should
  1030.      * immediately retry. [Bug #415131]
  1031.      */
  1033.     do {
  1034. bytesRead = read (GetFd(psPtr->inFile), buf, (size_t) toRead);
  1035.     } while ((bytesRead < 0) && (errno == EINTR));
  1037.     if (bytesRead < 0) {
  1038. *errorCodePtr = errno;
  1039. return -1;
  1040.     } else {
  1041. return bytesRead;
  1042.     }
  1043. }
  1045. /*
  1046.  *----------------------------------------------------------------------
  1047.  *
  1048.  * PipeOutputProc--
  1049.  *
  1050.  * This procedure is invoked from the generic IO level to write
  1051.  * output to a command pipeline based channel.
  1052.  *
  1053.  * Results:
  1054.  * The number of bytes written is returned or -1 on error. An
  1055.  * output argument contains a POSIX error code if an error occurred,
  1056.  * or zero.
  1057.  *
  1058.  * Side effects:
  1059.  * Writes output on the output device of the channel.
  1060.  *
  1061.  *----------------------------------------------------------------------
  1062.  */
  1064. static int
  1065. PipeOutputProc(instanceData, buf, toWrite, errorCodePtr)
  1066.     ClientData instanceData; /* Pipe state. */
  1067.     CONST char *buf; /* The data buffer. */
  1068.     int toWrite; /* How many bytes to write? */
  1069.     int *errorCodePtr; /* Where to store error code. */
  1070. {
  1071.     PipeState *psPtr = (PipeState *) instanceData;
  1072.     int written;
  1074.     *errorCodePtr = 0;
  1076.     /*
  1077.      * Some OSes can throw an interrupt error, for which we should
  1078.      * immediately retry. [Bug #415131]
  1079.      */
  1081.     do {
  1082. written = write(GetFd(psPtr->outFile), buf, (size_t) toWrite);
  1083.     } while ((written < 0) && (errno == EINTR));
  1085.     if (written < 0) {
  1086. *errorCodePtr = errno;
  1087. return -1;
  1088.     } else {
  1089. return written;
  1090.     }
  1091. }
  1093. /*
  1094.  *----------------------------------------------------------------------
  1095.  *
  1096.  * PipeWatchProc --
  1097.  *
  1098.  * Initialize the notifier to watch the fds from this channel.
  1099.  *
  1100.  * Results:
  1101.  * None.
  1102.  *
  1103.  * Side effects:
  1104.  * Sets up the notifier so that a future event on the channel will
  1105.  * be seen by Tcl.
  1106.  *
  1107.  *----------------------------------------------------------------------
  1108.  */
  1110. static void
  1111. PipeWatchProc(instanceData, mask)
  1112.     ClientData instanceData; /* The pipe state. */
  1113.     int mask; /* Events of interest; an OR-ed
  1114.                                          * combination of TCL_READABLE,
  1115.                                          * TCL_WRITABEL and TCL_EXCEPTION. */
  1116. {
  1117.     PipeState *psPtr = (PipeState *) instanceData;
  1118.     int newmask;
  1120.     if (psPtr->inFile) {
  1121. newmask = mask & (TCL_READABLE | TCL_EXCEPTION);
  1122. if (newmask) {
  1123.     Tcl_CreateFileHandler(GetFd(psPtr->inFile), mask,
  1124.     (Tcl_FileProc *) Tcl_NotifyChannel,
  1125.     (ClientData) psPtr->channel);
  1126. } else {
  1127.     Tcl_DeleteFileHandler(GetFd(psPtr->inFile));
  1128. }
  1129.     }
  1130.     if (psPtr->outFile) {
  1131. newmask = mask & (TCL_WRITABLE | TCL_EXCEPTION);
  1132. if (newmask) {
  1133.     Tcl_CreateFileHandler(GetFd(psPtr->outFile), mask,
  1134.     (Tcl_FileProc *) Tcl_NotifyChannel,
  1135.     (ClientData) psPtr->channel);
  1136. } else {
  1137.     Tcl_DeleteFileHandler(GetFd(psPtr->outFile));
  1138. }
  1139.     }
  1140. }
  1142. /*
  1143.  *----------------------------------------------------------------------
  1144.  *
  1145.  * PipeGetHandleProc --
  1146.  *
  1147.  * Called from Tcl_GetChannelHandle to retrieve OS handles from
  1148.  * inside a command pipeline based channel.
  1149.  *
  1150.  * Results:
  1151.  * Returns TCL_OK with the fd in handlePtr, or TCL_ERROR if
  1152.  * there is no handle for the specified direction. 
  1153.  *
  1154.  * Side effects:
  1155.  * None.
  1156.  *
  1157.  *----------------------------------------------------------------------
  1158.  */
  1160. static int
  1161. PipeGetHandleProc(instanceData, direction, handlePtr)
  1162.     ClientData instanceData; /* The pipe state. */
  1163.     int direction; /* TCL_READABLE or TCL_WRITABLE */
  1164.     ClientData *handlePtr; /* Where to store the handle.  */
  1165. {
  1166.     PipeState *psPtr = (PipeState *) instanceData;
  1168.     if (direction == TCL_READABLE && psPtr->inFile) {
  1169. *handlePtr = (ClientData) GetFd(psPtr->inFile);
  1170. return TCL_OK;
  1171.     }
  1172.     if (direction == TCL_WRITABLE && psPtr->outFile) {
  1173. *handlePtr = (ClientData) GetFd(psPtr->outFile);
  1174. return TCL_OK;
  1175.     }
  1176.     return TCL_ERROR;
  1177. }
  1179. /*
  1180.  *----------------------------------------------------------------------
  1181.  *
  1182.  * Tcl_WaitPid --
  1183.  *
  1184.  * Implements the waitpid system call on Unix systems.
  1185.  *
  1186.  * Results:
  1187.  * Result of calling waitpid.
  1188.  *
  1189.  * Side effects:
  1190.  * Waits for a process to terminate.
  1191.  *
  1192.  *----------------------------------------------------------------------
  1193.  */
  1195. Tcl_Pid
  1196. Tcl_WaitPid(pid, statPtr, options)
  1197.     Tcl_Pid pid;
  1198.     int *statPtr;
  1199.     int options;
  1200. {
  1201.     int result;
  1202.     pid_t real_pid;
  1204.     real_pid = (pid_t) pid;
  1205.     while (1) {
  1206. result = (int) waitpid(real_pid, statPtr, options);
  1207. if ((result != -1) || (errno != EINTR)) {
  1208.     return (Tcl_Pid) result;
  1209. }
  1210.     }
  1211. }
  1213. /*
  1214.  *----------------------------------------------------------------------
  1215.  *
  1216.  * Tcl_PidObjCmd --
  1217.  *
  1218.  * This procedure is invoked to process the "pid" Tcl command.
  1219.  * See the user documentation for details on what it does.
  1220.  *
  1221.  * Results:
  1222.  * A standard Tcl result.
  1223.  *
  1224.  * Side effects:
  1225.  * See the user documentation.
  1226.  *
  1227.  *----------------------------------------------------------------------
  1228.  */
  1230. /* ARGSUSED */
  1231. int
  1232. Tcl_PidObjCmd(dummy, interp, objc, objv)
  1233.     ClientData dummy; /* Not used. */
  1234.     Tcl_Interp *interp; /* Current interpreter. */
  1235.     int objc; /* Number of arguments. */
  1236.     Tcl_Obj *CONST *objv; /* Argument strings. */
  1237. {
  1238.     Tcl_Channel chan;
  1239.     Tcl_ChannelType *chanTypePtr;
  1240.     PipeState *pipePtr;
  1241.     int i;
  1242.     Tcl_Obj *resultPtr, *longObjPtr;
  1244.     if (objc > 2) {
  1245. Tcl_WrongNumArgs(interp, 1, objv, "?channelId?");
  1246. return TCL_ERROR;
  1247.     }
  1248.     if (objc == 1) {
  1249. Tcl_SetLongObj(Tcl_GetObjResult(interp), (long) getpid());
  1250.     } else {
  1251.         chan = Tcl_GetChannel(interp, Tcl_GetString(objv[1]), NULL);
  1252.         if (chan == (Tcl_Channel) NULL) {
  1253.     return TCL_ERROR;
  1254. }
  1255. chanTypePtr = Tcl_GetChannelType(chan);
  1256. if (chanTypePtr != &pipeChannelType) {
  1257.     return TCL_OK;
  1258. }
  1259.         pipePtr = (PipeState *) Tcl_GetChannelInstanceData(chan);
  1260. resultPtr = Tcl_GetObjResult(interp);
  1261.         for (i = 0; i < pipePtr->numPids; i++) {
  1262.     longObjPtr = Tcl_NewLongObj((long) TclpGetPid(pipePtr->pidPtr[i]));
  1263.     Tcl_ListObjAppendElement(NULL, resultPtr, longObjPtr);
  1264. }
  1265.     }
  1266.     return TCL_OK;
  1267. }
  1269. /*
  1270.  *----------------------------------------------------------------------
  1271.  *
  1272.  * TclpFinalizePipes --
  1273.  *
  1274.  * Cleans up the pipe subsystem from Tcl_FinalizeThread
  1275.  *
  1276.  * Results:
  1277.  * None.
  1278.  *
  1279.  * This procedure carries out no operation on Unix.
  1280.  *
  1281.  *----------------------------------------------------------------------
  1282.  */
  1284. void
  1285. TclpFinalizePipes()
  1286. {
  1287. }