redirecting standard i/o from and exec'ed programme

George Bogatko bogatko at lzga.ATT.COM
Wed Aug 15 22:45:19 AEST 1990


HI:
	This posting is in response to:
"michael at fe2o3.UUCP (Michael Katzmann @ Rusty's BSD machine at home)"
found in comp.unix.questions

I have a task that requires the ability to fork off another programme but
to supply it's standard input and output. 
		.
		.
		.
However there doesn't seem to be any way to use popen() to do both
similtaneously.

What is the usual way to to this?

**********

Here is how I did it.

********** CUT HERE ********** CUT HERE ********** CUT HERE ********** CUT HERE

#! /bin/sh
# This is a shell archive, meaning:
# 1. Remove everything above the #! /bin/sh line.
# 2. Save the resulting text in a file.
# 3. Execute the file with /bin/sh (not csh) to create:
#	makefile
#	fcopy.c
#	fpipe.c
#	fpipe.h
#	main.c
#	tst.c
# This archive created: Tue Feb 27 13:44:14 1990
export PATH; PATH=/bin:/usr/bin:$PATH
if test -f 'makefile'
then
       echo shar: "will not over-write existing file 'makefile'"
else
cat << \SHAR_EOF > 'makefile'
CFLAGS=-I.

LIBS=

OBJS=\
main.o \
fpipe.o \
fcopy.o

OUTPUT=\
main

$(OUTPUT):	$(OBJS)
	cc -o $(OUTPUT) $(OBJS) $(LIBS)
SHAR_EOF
fi
if test -f 'fcopy.c'
then
       echo shar: "will not over-write existing file 'fcopy.c'"
else
cat << \SHAR_EOF > 'fcopy.c'
/******************************************************************************
*                                                                             *
*                                  fcopy.c                                    *
*                                                                             *
******************************************************************************/

/*--------------------------  INITIAL CODING DATE -----------------------------
Thu Nov 10 10:56:37 EST 1988 by George M. Bogatko

--------------------------------  HEADER FILES  -----------------------------*/
#include <stdio.h>
#include <fpipe.h>
#include <fcntl.h>

/*------------------  TYPEDEF'S, DEFINES, STRUCTURE DEF'S  ------------------*/

/*----------------  IMPORTED GLOBAL VARIABLE/FUNCTION DEF'S  ----------------*/
extern char *fgets();

/*----------------  EXPORTED GLOBAL VARIABLE/FUNCTION DEF'S  ----------------*/

/*----------------  INTERNAL GLOBAL VARIABLE/FUNCTION DEF'S  ----------------*/
#ident "%W% %G% - George M. Bogatko -"

/*-----------------------------------------------------------------------------

SYNOPSIS:
	fcopy(in_fd, out_fname, flag)

DESCRIPTION:
	FCOPY copies lines from an IN_FD (maybe a pipe) to a standard
	file.  The arguments are:

	in_fd - a 'FILE *' type file descriptor

	out_fname - The file you want to write to

	flag - Whether your want the READ to be BLOCK or NON_BLOCK

		with BLOCK, the fgets will block (in the case of pipes,
			a block occurs if there is nothing in the pipe
			to read.

		with NON_BLOCK, the first READ is BLOCKED, (to allow
			pipe synchronization) and subsequent reads are
			NON_BLOCK.

RETURN:
	0 on success
	-1 on error  (use perror())

=============================================================================*/

int fcopy(in_fp, outname, blockflag)
FILE *in_fp;
char *outname;
int blockflag;
{
FILE *out_fp;
char buf[BUFSIZ];
enum {first, next} time = first;

	if( (out_fp = fopen(outname, "w")) == (FILE *)NULL )
		return -1;

	while( fgets(buf, BUFSIZ, in_fp) != (char *)NULL )
	{
		if( time == first )
		{
			if( blockflag == NO_BLOCK )
			{
				if(fcntl( fileno(in_fp), F_SETFL, O_NDELAY ) == -1 )
				{
					perror("");
					fclose(out_fp);
					return -1;
				}
			}
			time = next;
		}
		fputs(buf, out_fp);
	}
	fclose(out_fp);
	return 0;
}
SHAR_EOF
fi
if test -f 'fpipe.c'
then
       echo shar: "will not over-write existing file 'fpipe.c'"
else
cat << \SHAR_EOF > 'fpipe.c'
/******************************************************************************
*                                                                             *
*                                  fpipe.c                                    *
*                                                                             *
******************************************************************************/

/*--------------------------  INITIAL CODING DATE -----------------------------
Thu Nov 10 10:30:22 EST 1988 by George M. Bogatko

--------------------------------  HEADER FILES  -----------------------------*/
#include <stdio.h>
#include <fpipe.h>
#include <fcntl.h>
#include <varargs.h>

/*------------------  TYPEDEF'S, DEFINES, STRUCTURE DEF'S  ------------------*/

/*----------------  IMPORTED GLOBAL VARIABLE/FUNCTION DEF'S  ----------------*/

/*----------------  EXPORTED GLOBAL VARIABLE/FUNCTION DEF'S  ----------------*/

/*----------------  INTERNAL GLOBAL VARIABLE/FUNCTION DEF'S  ----------------*/
#ident "%W% %G% - George M. Bogatko -"

/*-----------------------------------------------------------------------------

SYNOPSIS:
	int fpipe(flag, arg_array, program, arg1, arg2, ... argn, 0 );

DESCRIPTION:
	FPIPE creates a two way pipe between a calling process and
	a child process.  
	That child process should expect to read from STANDARD IN
	and write to STANDARD OUT.

	The arguments are:

		flag - one of STD_ERR_SCR or STD_ERR_NUL.  STD_ERR_SCR will
			put STANDARD ERR to the screen,  STD_ERR_NUL will
			put STANDARD ERR to "/dev/null"

		arg_array - an array of 2 'FILE *' type pointers
			EX:  FILE *arg_array[2];
			When the function returns,
				
				arg_array[0] will contain the READING end of the
					pipe connected to the process's
					standard output, and

				arg_array[1] will contain the WRITING end of the
					pipe connected to the process's
					standard input.

		program - the full path of the program you want to invoke.

		arg1 ... argN - all the arguments to your program

		0 - the termination point of the arg1 ... argN sequence.

RETURN:
	the PROCESS ID of the created child on success,
	-1 on any error (use "perror()" to find out what happened).

CAVEATS:
	The LAST argument MUST be 0

=============================================================================*/

int fpipe(flag, arg_array, va_alist)
int flag;
FILE *arg_array[];
va_dcl
{
	char **args;
	int in_pfd[2];
	int out_pfd[2];
	FILE *read_fp, *write_fp;
	char *file;
	int i;
	int proc_id = 0;

	if( pipe(in_pfd) == (-1) )
		return(-1);
	if( pipe(out_pfd) == (-1) )
		return(-1);

	args = (char **)&va_alist; /* won't work on Pyramid */

	switch( proc_id = fork() )
	{
	case -1:
		return(-1);

	case 0:
		close(0);
		dup(out_pfd[0]);
		close(1);
		dup(in_pfd[1]);
		if( flag == STD_ERR_NUL )
		{
			close(2);
			if(open("/dev/null", O_WRONLY) == -1)
				return(-1);
		}
		close(in_pfd[0]);
		close(in_pfd[1]);
		close(out_pfd[0]);
		close(out_pfd[1]);
		execv(args[0], args);
		return(-1);

	default:
		close(in_pfd[1]);
		close(out_pfd[0]);

		if( (read_fp = fdopen( in_pfd[0], "r" )) == (FILE *)NULL )
			return(-1);
		if( (write_fp = fdopen( out_pfd[1], "w" )) == (FILE *)NULL )
			return(-1);

		arg_array[0] = read_fp;
		arg_array[1] = write_fp;

		return(proc_id);
	}
}
SHAR_EOF
fi
if test -f 'fpipe.h'
then
       echo shar: "will not over-write existing file 'fpipe.h'"
else
cat << \SHAR_EOF > 'fpipe.h'
/******************************************************************************
*                                                                             *
*                                  fpipe.h                                    *
*                                                                             *
******************************************************************************/

/*--------------------------  INITIAL CODING DATE -----------------------------
Thu Nov 10 11:01:32 EST 1988 by George M. Bogatko

--------------------------------  HEADER FILES  -----------------------------*/

/*------------------  TYPEDEF'S, DEFINES, STRUCTURE DEF'S  ------------------*/
#define STD_ERR_SCR 0
#define STD_ERR_NUL 1
#define NO_BLOCK 0
#define BLOCK 1

#ident "%W% %G% - George M. Bogatko -"

/*-----------------------------------------------------------------------------

SYNOPSIS:
	#include <fpipe.h>

DESCRIPTION:
	This includes #define's used by

		FCOPY and FPIPE

CAVEATS:

=============================================================================*/
SHAR_EOF
fi
if test -f 'main.c'
then
       echo shar: "will not over-write existing file 'main.c'"
else
cat << \SHAR_EOF > 'main.c'
#include <stdio.h>
#include <fcntl.h>
#include <fpipe.h>
#include <signal.h>

#define READ_END 0
#define WRITE_END 1
extern int fpipe();
extern char *fgets();

char buf[BUFSIZ];

main()
{
FILE *args[2];
enum {first, next} time = first;
int pid;

/*	if( (pid = fpipe(STD_ERR_SCR, args, "./tst",0)) == -1 )  */

	if( (pid = fpipe(STD_ERR_NUL, args, "/usr/bin/mailx", "-u", "gb", "-f","$HOME/mbox",0)) == -1 ) 

	{
		puts("AARRRRRGGGG!!!!");
		exit(-1);
	}

	for(;;)
	{
		fcopy(args[READ_END], "/dev/tty", NO_BLOCK);
		printf("enter command\n");
		gets(buf);
		if( *buf == 27 )
			break;
		fprintf(args[WRITE_END], "%s\n", buf);
		fflush(args[WRITE_END]);
	}
/*
 * closing the file pointers also sends 'CTRL-D' (EOF) to the child
 * process.   In the case of 'mailx' this will kill it.
 */
	fcopy(args[READ_END], "/dev/tty", NO_BLOCK);
	fclose(args[READ_END]);
	fclose(args[WRITE_END]);
	return 0;
}
SHAR_EOF
fi
if test -f 'tst.c'
then
       echo shar: "will not over-write existing file 'tst.c'"
else
cat << \SHAR_EOF > 'tst.c'
#include <stdio.h>
main()
{
	fprintf(stdout, "THIS TO STANDARD OUT\n");
	fprintf(stderr, "THIS TO STANDARD ERR\n");
}
SHAR_EOF
fi
exit 0
#	End of shell archive



More information about the Alt.sources mailing list