inc/pipeline.h File Reference

#include <stdio.h>

Include dependency graph for pipeline.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Enumerations
enum	pipelineOpts { pipelineRead = 0x01, pipelineWrite = 0x02, pipelineNoAbort = 0x04, pipelineMemInput = 0x08 }
Functions
pipeline *	pipelineOpenFd (char ***cmds, unsigned opts, int otherEndFd, int stderrFd)
pipeline *	pipelineOpen (char ***cmds, unsigned opts, char *otherEndFile, char *stderrFile)
void	pipelineDumpCmds (char ***cmds)
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)
int	pipelineWait (struct pipeline *pl)
void	pipelineFree (struct pipeline **plPtr)

---

Enumeration Type Documentation

enum pipelineOpts

Enumerator:

pipelineRead
pipelineWrite
pipelineNoAbort
pipelineMemInput

Definition at line 68 of file pipeline.h.

    {
    pipelineRead       = 0x01, /* read from pipeline */
    pipelineWrite      = 0x02, /* write to pipeline */
    pipelineNoAbort    = 0x04, /* don't abort if a process exits non-zero,
                                * wait will return exit code instead.
                                * Still aborts if process signals. */
    /* these are internal options */
    pipelineMemInput   = 0x08  /* pipeline takes input from memory */
    };

---

Function Documentation

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");
}

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:

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:

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:

---