Вызов внешних программ

#include <unistd.h>
int execl(char *name, char *arg0, ... /*NULL*/);
int execv(char *name, char *argv[]);
int execle(char *name, char *arg0, ... /*,NULL,
           char *envp[]*/);
int execve(char *name, char *arv[], char *envp[]);
int execlp(char *name, char *arg0, ... /*NULL*/);
int execvp(char *name, char *argv[]);

#include <sys/types>
#include <unistd.h>
pid_t fork(void);

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
main()
{
  pid_t pid;
  int rv;
  switch(pid=fork()) {
  case -1:
          perror("fork"); /* произошла ошибка */
          exit(1); /*выход из родительского процесса*/
  case 0:
          printf(" CHILD: Это процесс-потомок!\n");
          printf(" CHILD: Мой PID -- %d\n", getpid());
          printf(" CHILD: PID моего родителя -- %d\n",
              getppid());
          printf(" CHILD: Введите мой код возврата
                         (как можно меньше):");
          scanf(" %d");
          printf(" CHILD: Выход!\n");
          exit(rv);
  default:
          printf("PARENT: Это процесс-родитель!\n");
          printf("PARENT: Мой PID -- %d\n", getpid());
          printf("PARENT: PID моего потомка %d\n",pid);
          printf("PARENT: Я жду, пока потомок
                          не вызовет exit()...\n");
          wait();
          printf("PARENT: Код возврата потомка:%d\n",
                   WEXITSTATUS(rv));
          printf("PARENT: Выход!\n");
  }
}

#include <sys/types.h>
#include <stdio.h>
#include <unistd.h>
int main()
{
   char pid{[}255{]};
   fork();
   fork();
   fork();
   sprintf(pid, "PID : %d\n",getpid());
   write(STDOUT_FILENO, pid, strlen(pid));
   exit(0);
}

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <signal.h>
#include <fcntl.h>
#include <errno.h>
#include <string.h>

//-------------------------Global Variables--------------------------------
    extern int errno;
    bool signal_flag = false;
//-------------------------------------------------------------------------

//------------------------Auxilary functions-------------------------------
   
    void onSignal( int )
    {
    signal_flag = true;
    }
   
    void echo( const char* const message, pid_t pid )
    {
    fprintf( stderr, "(debug message) Process %d sent message: %s\n", pid, message );
    }
   
//-------------------------------------------------------------------------
    int main( int argc, char** argv )
    {
        //Declare Variables
        short int status, execute_status;
        pid_t process_ls, process_grep, process_wc, process_common;
        int pipeOne[ 2 ], pipeTwo [ 2 ], fp;
        char *grepArgument;
       
        //Declare Auxilary Variables
        unsigned short int i;
        int errCode;

        //Initialize Variables
        status = execute_status = 0;
        char fileName[] = "a.txt";
        errCode = 0;
       
        //If any argument exists set it as grep parameter
        if( argc > 1 )
            grepArgument = argv[1];
        else
        {
            grepArgument = (char*)malloc( strlen( "April" ) + 1 );
            strcpy( grepArgument, "April" );
        }

        //Set signal catcher
        signal( SIGUSR1, onSignal );

        //Creating pipes (one per pipeline)
        pipe( pipeOne );
        pipe( pipeTwo );

        //Creating childs. Let's each child get start after signal of preversion process (logical sequence)
        //-------------------------------------------------------------------------------------------------
       
        process_ls = fork();
        if( process_ls == (pid_t)0 )
        {
            //-----------------------Body of child process---------------------------
           
            //Print stats
            echo( "Started...", getpid() );
           
            //Set process output to pipeOne and close unusefull
            close( pipeOne[ 0 ] );
                close( pipeTwo[ 0 ] );
            close( pipeTwo[ 1 ] );         

            close( STDOUT_FILENO );
            dup( pipeOne[ 1 ] );
           
            //Call to external program. Result will be redirected to pipeOne
            errCode = execl( "/bin/ls", "ls", "-a", "-l", NULL );
            if( errCode == -1 )
            {
                echo( strerror( errno ), getpid() );
                kill( getppid(), SIGUSR1 );
                execute_status = -1;
            }
           
            exit( execute_status );    

            //-----------------------------------------------------------------------
        }  

        process_grep = fork();
        if( process_grep == (pid_t)0 )
        {
            //-----------------------Body of child process---------------------------
           
            //Print stats
            echo( "Started...", getpid() );
           
            //Set process input to pipeOne and process output to pipeTwo
            close( pipeOne[ 1 ] );
            close( pipeTwo[ 0 ] );
           
            close( STDIN_FILENO );
            dup( pipeOne[ 0 ] );
            close( STDOUT_FILENO );
            dup( pipeTwo[ 1 ] );

            //Call to external program. Result will be redirected to pipeTwo
            errCode = execl( "/bin/grep", "grep", grepArgument, NULL );
            if( errCode == -1 )
            {
                echo( strerror( errno ), getpid() );
                kill( getppid(), SIGUSR1 );
                execute_status = -1;
            }
           
            exit( execute_status );

            //-----------------------------------------------------------------------
        }
       
        process_wc = fork();
        if( process_wc == (pid_t)0 )
        {
            //-----------------------Body of child process--------------------------
           
            //Print stats
            echo( "Started...", getpid() );

            //Set process input to pipeTwo and output to file
            close( pipeOne[ 0 ] );
            close( pipeOne[ 1 ] );
                close( pipeTwo[ 1 ] );
           
            fp = open( fileName, O_WRONLY|O_CREAT );
           
            close( STDIN_FILENO );
            dup( pipeTwo[ 0 ] );
            close( STDOUT_FILENO );
            fcntl( fp, F_DUPFD, STDOUT_FILENO );

            //Call to external program. Result will be redirected to pipeTwo
            errCode = execl( "/usr/bin/wc", "wc", "-l", NULL );
            if( errCode == -1 )
            {
                echo( strerror( errno ), getpid() );
                kill( getppid(), SIGUSR1 );
                execute_status = -1;
            }
           
            exit( execute_status );

            //-----------------------------------------------------------------------
        }

        //-------------------------------------------------------------------------------------------------

        //Close all relations with pipes
        close( pipeOne[ 0 ] );
        close( pipeOne[ 1 ] );
        close( pipeTwo[ 0 ] );
        close( pipeTwo[ 1 ] );

        //Waiting for childs
        while( ( process_common = wait(&status) ) > 0 )
        {
            //If error occured atleast in one child - terminate all application
            if( signal_flag )
            {
                kill( -getpgrp(), SIGKILL );
                execute_status = -1;
            }
            else
                echo( "Finished...", process_common );
        }
       
        return( execute_status );
    }