lib/pipeline.c File Reference

#include "pipeline.h"
#include "common.h"
#include "sqlNum.h"
#include "dystring.h"
#include "errabort.h"
#include "portable.h"
#include "linefile.h"
#include <sys/types.h>
#include <unistd.h>
#include <sys/wait.h>
#include <signal.h>

Include dependency graph for pipeline.c:

Go to the source code of this file.

Data Structures
struct	plProc
struct	pipeline
Defines
#define	FILE_BUF_SIZE   64*1024
Functions
static int	pipeCreate (int *writeFd)
static void	safeClose (int *fdPtr)
static char *	joinCmd (char **cmd)
static char *	joinCmds (char ***cmds)
static struct plProc *	plProcNew (char **cmd, struct pipeline *pl)
static void	plProcFree (struct plProc *proc)
static void	childAbortHandler ()
static void	plProcSetup (struct plProc *proc, int stdinFd, int stdoutFd, int stderrFd)
static void	plProcExecChild (struct plProc *proc, int stdinFd, int stdoutFd, int stderrFd)
static void	plProcMemWrite (struct plProc *proc, int stdoutFd, int stderrFd, void *otherEndBuf, size_t otherEndBufSize)
static void	plProcWait (struct plProc *proc)
static struct pipeline *	pipelineNew (char ***cmds, unsigned options)
void	pipelineFree (struct pipeline **plPtr)
static int	pipelineExecProc (struct pipeline *pl, struct plProc *proc, int prevStdoutFd, int stdinFd, int stdoutFd, int stderrFd, void *otherEndBuf, size_t otherEndBufSize)
static void	pipelineExec (struct pipeline *pl, int stdinFd, int stdoutFd, int stderrFd, void *otherEndBuf, size_t otherEndBufSize)
static int	openRead (char *fname)
static int	openWrite (char *fname)
static void	pipelineStartRead (struct pipeline *pl, int stdinFd, int stderrFd, void *otherEndBuf, size_t otherEndBufSize)
static void	pipelineStartWrite (struct pipeline *pl, int stdoutFd, int stderrFd)
static void	checkOpts (unsigned opts)
pipeline *	pipelineOpenFd (char ***cmds, unsigned opts, int otherEndFd, int stderrFd)
pipeline *	pipelineOpen (char ***cmds, unsigned opts, char *otherEndFile, char *stderrFile)
pipeline *	pipelineOpenMem (char ***cmds, unsigned opts, void *otherEndBuf, size_t otherEndBufSize, int stderrFd)
pipeline *	pipelineOpenFd1 (char **cmd, unsigned opts, int otherEndFd, int stderrFd)
pipeline *	pipelineOpen1 (char **cmd, unsigned opts, char *otherEndFile, char *stderrFile)
pipeline *	pipelineOpenMem1 (char **cmd, unsigned opts, void *otherEndBuf, size_t otherEndBufSize, int stderrFd)
char *	pipelineDesc (struct pipeline *pl)
int	pipelineFd (struct pipeline *pl)
FILE *	pipelineFile (struct pipeline *pl)
lineFile *	pipelineLineFile (struct pipeline *pl)
static void	closePipelineFile (struct pipeline *pl)
static void	closePipeline (struct pipeline *pl)
int	pipelineWait (struct pipeline *pl)
void	pipelineDumpCmds (char ***cmds)

---

Define Documentation

#define FILE_BUF_SIZE   64*1024

Definition at line 41 of file pipeline.c.

Referenced by pipelineFile().

---

Function Documentation

static void checkOpts

(

unsigned

opts

)

[static]

Definition at line 351 of file pipeline.c.

References errAbort(), pipelineRead, and pipelineWrite.

Referenced by pipelineOpen(), pipelineOpenFd(), and pipelineOpenMem().

{
if (((opts & (pipelineRead|pipelineWrite)) == 0)
    || ((opts & (pipelineRead|pipelineWrite)) == (pipelineRead|pipelineWrite)))
    errAbort("must specify one of pipelineRead or pipelineWrite to pipelineOpen");
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void childAbortHandler

(

)

[static]

Definition at line 126 of file pipeline.c.

Referenced by plProcSetup().

{
exit(100);
}

Here is the caller graph for this function:

static void closePipeline

(

struct pipeline *

pl

)

[static]

Definition at line 510 of file pipeline.c.

References closePipelineFile(), errAbort(), lineFileClose(), pipeline::pipeFh, and lineFile::pl.

Referenced by pipelineWait().

{
if (pl->pipeFh != NULL)
    closePipelineFile(pl);
else if (pl->pipeLf != NULL)
    lineFileClose(&pl->pipeLf);
else
    {
    if (close(pl->pipeFd) < 0)
        errAbort("close failed on pipeline: %s ", pl->procName);
    }
pl->pipeFd = -1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void closePipelineFile

(

struct pipeline *

pl

)

[static]

Definition at line 493 of file pipeline.c.

References errAbort(), pipeline::options, pipeline::pipeFh, pipelineWrite, lineFile::pl, and pipeline::procName.

Referenced by closePipeline().

{
if (pl->options & pipelineWrite)
    {
    fflush(pl->pipeFh);
    if (ferror(pl->pipeFh))
        errAbort("write failed to pipeline: %s ", pl->procName);
    }
else if (ferror(pl->pipeFh))
    errAbort("read failed from pipeline: %s ", pl->procName);

if (fclose(pl->pipeFh) == EOF)
    errAbort("close failed on pipeline: %s ", pl->procName);
pl->pipeFh = NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static char* joinCmd

(

char **

cmd

)

[static]

Definition at line 65 of file pipeline.c.

References dyStringAppend(), dyStringCannibalize(), and dyStringNew.

Referenced by plProcWait().

{
struct dyString *str = dyStringNew(512);
int i;
for (i = 0; cmd[i] != NULL; i++)
    {
    if (i > 0)
        dyStringAppend(str, " ");
    dyStringAppend(str, cmd[i]);
    }
return dyStringCannibalize(&str);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static char* joinCmds

(

char ***

cmds

)

[static]

Definition at line 79 of file pipeline.c.

References dyStringAppend(), dyStringCannibalize(), and dyStringNew.

Referenced by pipelineNew().

{
struct dyString *str = dyStringNew(512);
int i, j;
for (i = 0; cmds[i] != NULL; i++)
    {
    if (i > 0)
        dyStringAppend(str, " | ");
    for (j = 0; cmds[i][j] != NULL; j++)
        {
        if (j > 0)
            dyStringAppend(str, " ");
        dyStringAppend(str, cmds[i][j]);
        }
    }
return dyStringCannibalize(&str);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int openRead

(

char *

fname

)

[static]

Definition at line 315 of file pipeline.c.

References errnoAbort().

Referenced by pipelineOpen().

{
int fd = open(fname, O_RDONLY);
if (fd < 0)
    errnoAbort("can't open for read access: %s", fname);
return fd;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int openWrite

(

char *

fname

)

[static]

Definition at line 324 of file pipeline.c.

References errnoAbort().

Referenced by pipelineOpen().

{
int fd = open(fname, O_WRONLY|O_CREAT|O_TRUNC, 0666);
if (fd < 0)
    errnoAbort("can't open for write access: %s", fname);
return fd;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int pipeCreate

(

int *

writeFd

)

[static]

Definition at line 43 of file pipeline.c.

References errnoAbort().

Referenced by pipelineExecProc(), pipelineStartRead(), and pipelineStartWrite().

{
int pipeFds[2];
if (pipe(pipeFds) < 0)
    errnoAbort("can't create pipe");
*writeFd = pipeFds[1];
return pipeFds[0];
}

Here is the call graph for this function:

Here is the caller graph for this function:

char* pipelineDesc

(

struct pipeline *

pl

)

Definition at line 444 of file pipeline.c.

References pipeline::procName.

Referenced by pipelineLineFile().

{
return pl->procName;
}

Here is the caller graph for this function:

void pipelineDumpCmds

(

char ***

cmds

)

Definition at line 552 of file pipeline.c.

References plProc::cmd, FALSE, and TRUE.

{
char **cmd;
boolean first = TRUE;
while ((cmd = *cmds++) != NULL)
   {
   char *word;
   if (first)
      first = FALSE;
   else
      printf("| ");
   while ((word = *cmd++) != NULL)
       printf("%s ", word);
   }
printf("<BR>\n");
}

static void pipelineExec	(	struct pipeline *	pl,
		int	stdinFd,
		int	stdoutFd,
		int	stderrFd,
		void *	otherEndBuf,
		size_t	otherEndBufSize
	)			[static]

Definition at line 298 of file pipeline.c.

References plProc::next, pipelineExecProc(), plProc::pl, and pipeline::procs.

Referenced by pipelineStartRead(), and pipelineStartWrite().

{
struct plProc *proc;
int prevStdoutFd = -1;
for (proc = pl->procs; proc != NULL; proc = proc->next)
    {
    prevStdoutFd = pipelineExecProc(pl, proc, prevStdoutFd,
                                    stdinFd, stdoutFd, stderrFd,
                                    otherEndBuf, otherEndBufSize);
    otherEndBuf = NULL;  /* only for first process (read pipes) */
    otherEndBufSize = 0;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int pipelineExecProc	(	struct pipeline *	pl,
		struct plProc *	proc,
		int	prevStdoutFd,
		int	stdinFd,
		int	stdoutFd,
		int	stderrFd,
		void *	otherEndBuf,
		size_t	otherEndBufSize
	)			[static]

Definition at line 263 of file pipeline.c.

References errnoAbort(), plProc::next, plProc::pid, pipeCreate(), plProc::pl, plProcExecChild(), plProcMemWrite(), pipeline::procs, and safeClose().

Referenced by pipelineExec().

{
/* determine stdin/stdout to use */
int procStdinFd, procStdoutFd;
if (proc == pl->procs)
    procStdinFd = stdinFd; /* first process in pipeline */
else
    procStdinFd = prevStdoutFd;
if (proc->next == NULL)
    procStdoutFd = stdoutFd; /* last process in pipeline */
else
    prevStdoutFd = pipeCreate(&procStdoutFd);

/* start process */
if ((proc->pid = fork()) < 0)
    errnoAbort("can't fork");
if (proc->pid == 0)
    {
    if (otherEndBuf != NULL)
        plProcMemWrite(proc, procStdoutFd, stderrFd, otherEndBuf, otherEndBufSize);
    else
        plProcExecChild(proc, procStdinFd, procStdoutFd, stderrFd);
    }

/* don't leave intermediate pipes open in parent */
if (proc != pl->procs)
    safeClose(&procStdinFd);
if (proc->next != NULL)
    safeClose(&procStdoutFd);
return prevStdoutFd;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int pipelineFd

(

struct pipeline *

pl

)

Definition at line 450 of file pipeline.c.

References pipeline::pipeFd.

Referenced by lineFileDecompress(), lineFileDecompressFd(), lineFileDecompressMem(), and textOutInit().

{
return pl->pipeFd;
}

Here is the caller graph for this function:

FILE* pipelineFile

(

struct pipeline *

pl

)

Definition at line 456 of file pipeline.c.

References errAbort(), errnoAbort(), FILE_BUF_SIZE, needLargeMem(), pipeline::options, pipeline::pipeFd, pipeline::pipeFh, pipeline::pipeLf, pipelineRead, pipeline::procName, and pipeline::stdioBuf.

{
if (pl->pipeFh == NULL)
    {
    /* create FILE* on first access */
    char *mode = (pl->options & pipelineRead) ? "r" : "w";
    if (pl->pipeLf != NULL)
        errAbort("can't call pipelineFile after having associated a lineFile with a pipeline");
    pl->pipeFh = fdopen(pl->pipeFd, mode);
    if (pl->pipeFh == NULL)
        errnoAbort("fdopen failed for: %s", pl->procName);
    pl->stdioBuf = needLargeMem(FILE_BUF_SIZE);
    setvbuf(pl->pipeFh, pl->stdioBuf,  _IOFBF, FILE_BUF_SIZE);
    }
return pl->pipeFh;
}

Here is the call graph for this function:

void pipelineFree

(

struct pipeline **

plPtr

)

Definition at line 244 of file pipeline.c.

References freez(), plProc::next, plProc::pl, plProcFree(), pipeline::procName, pipeline::procs, and pipeline::stdioBuf.

Referenced by lineFileClose(), and textOutClose().

{
struct pipeline *pl = *plPtr;
if (pl != NULL)
    {
    struct plProc *proc = pl->procs;
    while (proc != NULL)
        {
        struct plProc *delProc = proc;
        proc = proc->next;
        plProcFree(delProc);
        }
    freez(&pl->procName);
    freez(&pl->stdioBuf);
    freez(plPtr);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

struct lineFile* pipelineLineFile

(

struct pipeline *

pl

)

[read]

Definition at line 476 of file pipeline.c.

References errAbort(), lineFileAttach(), pipeline::options, pipeline::pipeFd, pipeline::pipeFh, pipeline::pipeLf, pipelineDesc(), pipelineWrite, lineFile::pl, and TRUE.

{
if (pl->pipeLf == NULL)
    {
    /* create line on first acess */
    if (pl->pipeFh != NULL)
        errAbort("can't call pipelineLineFile after having associated a FILE with a pipeline");
    if (pl->options & pipelineWrite)
        errAbort("can't associated a lineFile with a write pipeline");
    pl->pipeLf = lineFileAttach(pipelineDesc(pl), TRUE, pl->pipeFd);
    }
return pl->pipeLf;
}

Here is the call graph for this function:

static struct pipeline* pipelineNew	(	char ***	cmds,
		unsigned	options
	)			[static, read]

Definition at line 217 of file pipeline.c.

References AllocVar, errAbort(), joinCmds(), pipeline::options, pipeline::pipeFd, pipelineMemInput, plProcNew(), pipeline::procName, pipeline::procs, and slAddTail().

Referenced by pipelineOpenFd(), and pipelineOpenMem().

{
static char *memPseudoCmd[] = {"[mem]", NULL};
struct pipeline *pl;
int iCmd;

AllocVar(pl);
pl->pipeFd = -1;
pl->options = options;
pl->procName = joinCmds(cmds);

if (cmds[0] == NULL)
    errAbort("no commands in pipeline");

if (options & pipelineMemInput)
    {
    /* add proc for forked process to write memory to pipeline */
    slAddTail(&pl->procs, plProcNew(memPseudoCmd, pl));
    }

for(iCmd = 0; cmds[iCmd] != NULL; iCmd++)
    slAddTail(&pl->procs, plProcNew(cmds[iCmd], pl));

return pl;
}

Here is the call graph for this function:

Here is the caller graph for this function:

struct pipeline* pipelineOpen	(	char ***	cmds,
		unsigned	opts,
		char *	otherEndFile,
		char *	stderrFile
	)			[read]

Definition at line 375 of file pipeline.c.

References checkOpts(), openRead(), openWrite(), pipelineOpenFd(), pipelineRead, and safeClose().

Referenced by pipelineOpen1().

{
int otherEndFd;
int stderrFd = (stderrFile == NULL) ? STDERR_FILENO : openWrite(stderrFile);

checkOpts(opts);
if (opts & pipelineRead)
    otherEndFd = (otherEndFile == NULL) ? STDIN_FILENO : openRead(otherEndFile);
else
    otherEndFd = (otherEndFile == NULL) ? STDOUT_FILENO : openWrite(otherEndFile);
struct pipeline *pl = pipelineOpenFd(cmds, opts, otherEndFd, stderrFd);
safeClose(&otherEndFd);
if (stderrFile != NULL)
    safeClose(&stderrFd);
return pl;
}

Here is the call graph for this function:

Here is the caller graph for this function:

struct pipeline* pipelineOpen1	(	char **	cmd,
		unsigned	opts,
		char *	otherEndFile,
		char *	stderrFile
	)			[read]

Definition at line 423 of file pipeline.c.

References pipelineOpen().

Referenced by lineFileDecompress(), and textOutInit().

{
char **cmds[2];
cmds[0] = cmd;
cmds[1] = NULL;
return pipelineOpen(cmds, opts, otherEndFile, stderrFile);
}

Here is the call graph for this function:

Here is the caller graph for this function:

struct pipeline* pipelineOpenFd	(	char ***	cmds,
		unsigned	opts,
		int	otherEndFd,
		int	stderrFd
	)			[read]

Definition at line 359 of file pipeline.c.

References checkOpts(), pipelineNew(), pipelineRead, pipelineStartRead(), and pipelineStartWrite().

Referenced by pipelineOpen(), and pipelineOpenFd1().

{
struct pipeline *pl;

checkOpts(opts);
pl = pipelineNew(cmds, opts);
if (opts & pipelineRead)
    pipelineStartRead(pl, otherEndFd, stderrFd, NULL, 0);
else
    pipelineStartWrite(pl, otherEndFd, stderrFd);
return pl;
}

Here is the call graph for this function:

Here is the caller graph for this function:

struct pipeline* pipelineOpenFd1	(	char **	cmd,
		unsigned	opts,
		int	otherEndFd,
		int	stderrFd
	)			[read]

Definition at line 413 of file pipeline.c.

References pipelineOpenFd().

Referenced by lineFileDecompressFd().

{
char **cmds[2];
cmds[0] = cmd;
cmds[1] = NULL;
return pipelineOpenFd(cmds, opts, otherEndFd, stderrFd);
}

Here is the call graph for this function:

Here is the caller graph for this function:

struct pipeline* pipelineOpenMem	(	char ***	cmds,
		unsigned	opts,
		void *	otherEndBuf,
		size_t	otherEndBufSize,
		int	stderrFd
	)			[read]

Definition at line 395 of file pipeline.c.

References checkOpts(), errAbort(), pipelineMemInput, pipelineNew(), pipelineStartRead(), and pipelineWrite.

Referenced by pipelineOpenMem1().

{
struct pipeline *pl;
checkOpts(opts);
if (opts & pipelineWrite)
    errAbort("pipelineOpenMem only supports read pipelines at this time");
opts |= pipelineMemInput;

pl = pipelineNew(cmds, opts);
pipelineStartRead(pl, STDIN_FILENO, stderrFd, otherEndBuf, otherEndBufSize);
return pl;
}

Here is the call graph for this function:

Here is the caller graph for this function:

struct pipeline* pipelineOpenMem1	(	char **	cmd,
		unsigned	opts,
		void *	otherEndBuf,
		size_t	otherEndBufSize,
		int	stderrFd
	)			[read]

Definition at line 433 of file pipeline.c.

References pipelineOpenMem().

Referenced by lineFileDecompressMem().

{
char **cmds[2];
cmds[0] = cmd;
cmds[1] = NULL;
return pipelineOpenMem(cmds, opts, otherEndBuf, otherEndBufSize, stderrFd);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void pipelineStartRead	(	struct pipeline *	pl,
		int	stdinFd,
		int	stderrFd,
		void *	otherEndBuf,
		size_t	otherEndBufSize
	)			[static]

Definition at line 333 of file pipeline.c.

References pipeCreate(), pipeline::pipeFd, pipelineExec(), plProc::pl, and safeClose().

Referenced by pipelineOpenFd(), and pipelineOpenMem().

{
int pipeWrFd;
pl->pipeFd = pipeCreate(&pipeWrFd);
pipelineExec(pl, stdinFd, pipeWrFd, stderrFd, otherEndBuf, otherEndBufSize);
safeClose(&pipeWrFd);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void pipelineStartWrite	(	struct pipeline *	pl,
		int	stdoutFd,
		int	stderrFd
	)			[static]

Definition at line 343 of file pipeline.c.

References pipeCreate(), pipeline::pipeFd, pipelineExec(), plProc::pl, and safeClose().

Referenced by pipelineOpenFd().

{
int pipeRdFd = pipeCreate(&pl->pipeFd);
pipelineExec(pl, pipeRdFd, stdoutFd, stderrFd, NULL, 0);
safeClose(&pipeRdFd);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int pipelineWait

(

struct pipeline *

pl

)

Definition at line 525 of file pipeline.c.

References closePipeline(), plProc::next, pipeline::options, pipelineRead, pipelineWrite, plProc::pl, plProcWait(), plProc::status, and WEXITSTATUS.

Referenced by lineFileClose(), and textOutClose().

{
struct plProc *proc;
int exitCode = 0;

/* must close before waits for output pipeline */
if (pl->options & pipelineWrite)
    closePipeline(pl);

/* wait on each process in order */
for (proc = pl->procs; proc != NULL; proc = proc->next)
    {
    plProcWait(proc);
    if ((WEXITSTATUS(proc->status) != 0) && (exitCode == 0))
        exitCode = WEXITSTATUS(proc->status);
    }

/* must close after waits for input pipeline */
if (pl->options & pipelineRead)
    closePipeline(pl);

return exitCode;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void plProcExecChild	(	struct plProc *	proc,
		int	stdinFd,
		int	stdoutFd,
		int	stderrFd
	)			[static]

Definition at line 172 of file pipeline.c.

References plProc::cmd, errnoAbort(), and plProcSetup().

Referenced by pipelineExecProc().

{
plProcSetup(proc, stdinFd, stdoutFd, stderrFd);
/* FIXME: add close-on-exec startup error reporting here */
execvp(proc->cmd[0], proc->cmd);
errnoAbort("exec failed: %s", proc->cmd[0]);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void plProcFree

(

struct plProc *

proc

)

[static]

Definition at line 116 of file pipeline.c.

References plProc::cmd, and freeMem().

Referenced by pipelineFree().

{
int i;
for (i = 0; proc->cmd[i] != NULL; i++)
    freeMem(proc->cmd[i]);
freeMem(proc->cmd);
freeMem(proc);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void plProcMemWrite	(	struct plProc *	proc,
		int	stdoutFd,
		int	stderrFd,
		void *	otherEndBuf,
		size_t	otherEndBufSize
	)			[static]

Definition at line 181 of file pipeline.c.

References errAbort(), errnoAbort(), and plProcSetup().

Referenced by pipelineExecProc().

{
ssize_t wrCnt;
plProcSetup(proc, STDIN_FILENO, stdoutFd, stderrFd);
wrCnt = write(STDOUT_FILENO, otherEndBuf, otherEndBufSize);
if (wrCnt < 0)
    errnoAbort("pipeline input buffer write failed");
else if (wrCnt != otherEndBufSize)
    errAbort("pipeline input buffer short write %lld, expected %lld",
             (long long)wrCnt, (long long)otherEndBufSize);
else
    {
    close(STDOUT_FILENO);
    exit(0);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static struct plProc* plProcNew	(	char **	cmd,
		struct pipeline *	pl
	)			[static, read]

Definition at line 98 of file pipeline.c.

References AllocVar, cloneString(), plProc::cmd, needMem(), and plProc::pl.

Referenced by pipelineNew().

{
int i, cmdLen = 0;
struct plProc* proc;
AllocVar(proc);
proc->pl = pl;

for (i = 0; cmd[i] != NULL; i++)
    cmdLen++;
proc->cmd = needMem((cmdLen+1)*sizeof(char*));

for (i = 0; i < cmdLen; i++)
    proc->cmd[i] = cloneString(cmd[i]);
proc->cmd[cmdLen] = NULL;
return proc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void plProcSetup	(	struct plProc *	proc,
		int	stdinFd,
		int	stdoutFd,
		int	stderrFd
	)			[static]

Definition at line 132 of file pipeline.c.

References childAbortHandler(), errnoAbort(), pushAbortHandler(), pushWarnAbort(), and ZeroVar.

Referenced by plProcExecChild(), and plProcMemWrite().

{
int fd;
struct sigaction sigAct;

/* make sure abort handler exits */
pushWarnAbort();
pushAbortHandler(childAbortHandler);

/* treat a closed pipe as an EOF rather than getting SIGPIPE */
ZeroVar(&sigAct);
sigAct.sa_handler = SIG_IGN;
if (sigaction(SIGPIPE, &sigAct, NULL) != 0)
    errnoAbort("failed to set SIGPIPE to SIG_IGN");

/* child, first setup stdio files */
if (stdinFd != STDIN_FILENO)
    {
    if (dup2(stdinFd, STDIN_FILENO) < 0)
        errnoAbort("can't dup2 to stdin");
    }
    
if (stdoutFd != STDOUT_FILENO)
    {
    if (dup2(stdoutFd, STDOUT_FILENO) < 0)
        errnoAbort("can't dup2 to stdout");
    }
    
if (stderrFd != STDERR_FILENO)
    {
    if (dup2(stderrFd, STDERR_FILENO) < 0)
        errnoAbort("can't dup2 to stderr");
    }

/* close other file descriptors */
for (fd = STDERR_FILENO+1; fd < 64; fd++)
    close(fd);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void plProcWait

(

struct plProc *

proc

)

[static]

Definition at line 200 of file pipeline.c.

References plProc::cmd, errAbort(), errnoAbort(), joinCmd(), pipeline::options, plProc::pid, pipelineNoAbort, plProc::pl, pipeline::procName, plProc::status, WEXITSTATUS, WIFEXITED, WIFSIGNALED, and WTERMSIG.

Referenced by pipelineWait().

{
if (waitpid(proc->pid, &proc->status, 0) < 0)
    errnoAbort("process lost for: \"%s\" in pipeline \"%s\"", joinCmd(proc->cmd),
               proc->pl->procName);
if (WIFSIGNALED(proc->status))
    errAbort("process terminated on signal %d: \"%s\" in pipeline \"%s\"",
             WTERMSIG(proc->status), joinCmd(proc->cmd), proc->pl->procName);
assert(WIFEXITED(proc->status));

if ((WEXITSTATUS(proc->status) != 0) && !(proc->pl->options & pipelineNoAbort))
    errAbort("process exited with %d: \"%s\" in pipeline \"%s\"",
             WEXITSTATUS(proc->status), joinCmd(proc->cmd), proc->pl->procName);
proc->pid = -1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void safeClose

(

int *

fdPtr

)

[static]

Definition at line 53 of file pipeline.c.

References errnoAbort(), and lineFile::fd.

Referenced by pipelineExecProc(), pipelineOpen(), pipelineStartRead(), and pipelineStartWrite().

{
int fd = *fdPtr;
if (fd != -1)
    {
    if (close(fd) < 0)
        errnoAbort("close failed on fd %d", fd);
    *fdPtr = -1;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

---