Programming

pid_t pid;
int	commpipe[2];
char buf[BUFSIZE];

pipe(commpipe)
 
pid=fork();

 if(pid){
    dup2(commpipe[0],0);
    close(commpipe[0]);
    while ( fgets ( buf, BUFSIZE, stdin ) )
    { processBuffer ( buf );
 } else{
    dup2(commpipe[1],1); 
   close(commpipe[0]);
    setvbuf(stdout,(char*)NULL,_IONBF,0); 
   execl("child","child",NULL) 	
}

#include <unistd.h>
#include <stdio.h>
#include <errno.h>

int main( int argc, char **argv )
{
    FILE* pipe1;
    FILE* pipe2;
    char    buf[4096];

    pipe1 = popen( "df -h", "r" );   /* execute commands in parallel */
    pipe2 = popen( "ls -al", "r" );

    printf( "output from command 2:\n" );     /* read and print all data from one command */
    while( fgets( buf, sizeof( buf ), pipe2 ) )
        printf( "%s", buf );

    pclose( pipe2 );

    printf( "output from command 1:\n" );      /* read and print from other command */
    while( fgets( buf, sizeof( buf ), pipe1 ) )
        printf( "%s", buf );

     pclose( pipe1 );


    return 0; 
 }

#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <pthread.h>
#include <string.h>



/*
    started as a thread. creates a child process via popen() and reads
    the child's output counting the number of target characters (global)
    that were in the output. When done, the count is printed on stdout.
    A delay of 2s is imposed to demonstrate that the main has started
    all threads in parallel, otherwise it is unnecessary.
*/
void *reader( void *data )
{
    char    target = 'e';       /* count these from the command's output */
    char    *cmd;               /* command to execute */
    FILE    *rpipe;
    char    buf[4096];          /* read bufffer */
    int     tcount = 0;         /* count of target */
    char    *cp;                /* pointer as we walk the buffer looking for target */

    cmd = (char *) data;

    sleep( 2);
    fprintf( stderr, "starting the command: %s\n", cmd );

    rpipe = popen( cmd, "r" );                      /* start the child */
    while( fgets( buf, sizeof( buf ), rpipe ) )     /* read all of the child's stdout */
    {
        cp = buf;
        while( (cp = strchr( cp, target )) )        /* count number of target characters in this buffer */
        {
            tcount++;
            cp++;
        }
    }

    pclose( rpipe );

    printf( "output from `%s` contained %d '%c' characters\n", cmd, tcount, target );

    free( data );
    pthread_exit( 0 );

    return NULL;            /* shouldn't matter, but keeps compilers happy */
}

int main( int argc, char **argv )
{
    pthread_t tids[10];
    char    cbuf[1024];
    int     i;

    if( argc < 2 || argc > 11 )
    {
        fprintf( stderr, "usage: %s filename1 [filename2... filename10]\n", argv[0] );
        exit( 1 );
    }


    for( i = 1; i < argc; i++ )         /* start all threads to process all files in parallel */
    {
        snprintf( cbuf, sizeof( cbuf ), "cat %s", argv[i] );
        fprintf( stderr, "starting thread: %s\n", cbuf );
        pthread_create( &tids[i-1], NULL, reader, (void *) strdup( cbuf ) );        
                                                  /* thread must free dup to avoid leak */
    }

    fprintf( stderr, "all threads started, main thread waits....\n" );

    for( i = 0; i < argc-1; i++ )                       /* wait for all threads to finish */
        pthread_join( tids[i], NULL );

    fprintf( stderr, "all threads finished\n" );

    return 0;
 }